Building Tablet PC Applications

Building Tablet PC Applications

Released September 2002
Publisher(s): Microsoft Press
ISBN: 9780735617230

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

The authoritative guide to creating applications for the Tablet PC—direct from the Microsoft Tablet PC software development team!

The introduction of faster chips and hardware has recently enabled the first workable, tablet-sized, pen-based PCs. Building Tablet PC Applications distills the best usability research on pen-based computing to present an authoritative discussion of how to design pen-based applications and user interfaces. It also gives you an in-depth description of the Tablet PC Platform SDK, complete with tips and tricks on how to produce "ink-aware" applications for the Microsoft® Windows® XP Table PC Edition operating system. By the time you finish this book, you'll understand how to create natural, pen-based applications for this exciting new platform, where portability, digital ink, and pen-driven input are the new PC paradigm.

Table of contents

  1. Building Tablet PC Applications
    1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
    2. A Note Regarding Supplemental Files
    3. Dedication
    4. Foreword
    5. Acknowledgments
      1. Rob and Philip Thank…
      2. Rob Thanks…
      3. Philip Thanks…
    6. Introduction
      1. A Beautiful Day
        1. Target Audience
        2. Sample Code
        3. The Companion CD-ROM
        4. Using the Companion CD-ROM Samples
        5. System Requirements
          1. Software
          2. Hardware
      2. Chapter Overviews
        1. Chapter 1—The Tablet PC and Its Applications
        2. Chapter 2—Designing Tablet PC Applications
        3. Chapter 3—The Tablet PC Platform SDK
        4. Chapter 4—Tablet PC Platform SDK: Tablet Input
        5. Chapters 5 and 6—Tablet PC Platform SDK: Ink Data Management
        6. Chapter 7—Tablet PC Platform SDK: Ink Recognition
        7. Chapter 8—Ink Controls
        8. Chapter 9—Updating Existing Applications
      3. Some Final Thoughts
        1. Support
    7. I. The Tablet PC and Its Applications
      1. 1. Tablet Computing Comes of Age
        1. What Makes a Tablet Computer
          1. Form Factor
          2. Pen Input
          3. Stand-Alone and General-Purpose
          4. What Isn’t a Tablet Computer
          5. The Role of Tablet Computers
        2. A Brief History of Tablet Computing
          1. GRiD GRiDPad
          2. GO PenPoint
          3. Microsoft Windows for Pen Computing
          4. Apple Newton
          5. Palm Computing PalmPilot
          6. Microsoft Pocket PC
          7. In a Little While
        3. The Microsoft Tablet PC
          1. The Birth of Microsoft Tablet PC
          2. Microsoft Tablet PC Hardware Guidelines
          3. Microsoft Tablet PC Software
          4. Could This Be the One?
        4. Summary
      2. 2. Designing Tablet PC Applications
        1. User Research
          1. Tablet Usability
          2. Application Usability
            1. It’s Unconventional but Boy Is It Optimized
            2. Ink as Ink
            3. Visual Distinction of Inkable Regions
            4. High Screen DPI
            5. Input Modality
          3. Pen Usability
            1. Targeting
            2. Selection
        2. Of Mice and Pen
          1. Tablet Displays
        3. Digitizer Technology
          1. Resistive Digitizers
          2. Electrostatic Digitizers
          3. Electromagnetic Digitizers
          4. Digitizer Distortion
          5. Parallax
          6. Still Motion
          7. Handedness
        4. Thinking in Ink
          1. Ink Modeling
            1. What’s Ink Got to Do with It?
            2. Mysterious Ways
            3. Free-Form Ink
            4. Annotation Ink
            5. Inline Ink
          2. Ink Interaction
            1. Common Pen Actions
            2. Selecting Ink
            3. Other Ink Interactions
            4. Moving and Resizing
            5. Formatting
            6. Gestures
          3. Ink Realism
            1. Right Here, Right Now
            2. Curves Ahead
            3. Bézier Curve Fitting
            4. Antialiasing
            5. Pen Tip Shape
            6. Pressure Sensitivity
            7. Subtractive Color Rendering
        5. Summary
    8. II. The Tablet PC Platform SDK
      1. 3. Introduction to the Tablet PC Platform SDK
        1. A Sort of Homecoming
          1. Finding the Right Operating System for the Job
          2. Managed APIs
          3. Ink Controls
          4. COM Automation APIs
          5. Sample Applications
        2. Installing the Tablet PC Platform SDK
          1. System Requirements
          2. Getting the SDK
          3. Setting Up Your Environment
            1. Setting Up Your Visual Studio .NET Environment
          4. Anatomy of the Tablet PC Platform SDK
        3. Overview of the Managed API
          1. All That You Can’t Leave Behind
          2. Design Goals of the API
            1. The Prime Directive
            2. What’s Covered by the Managed API
            3. What’s Not Covered by the Managed API
          3. Managed API Object Survey
            1. Tablet Input API
          4. Ink Data Management API
          5. Ink Recognition API
        4. Ink Control Comparison with Managed API
        5. Welcome to the Great Adventure
      2. 4. Tablet PC Platform SDK: Tablet Input
        1. Sample Applications
        2. Capturing Input from the Pen
          1. Requirement #1—Mouse Emulation
          2. Requirement #2—Digital Ink
          3. Requirement #3—Pen-Based Actions
          4. Summing Up the Requirements
        3. Anatomy of the Tablet PC’s Tablet Input Subsystem
          1. Tablet Hardware
          2. Chock-full of HID-y Goodness
          3. The Center of the TIS Universe: Wisptis.exe
            1. Getting Input from the Driver
            2. Performing Mouse Emulation
            3. Detecting Pen-Based Actions
            4. Dispatching Events
            5. Making Sense of It All
          4. Winlogon Desktop Support
          5. What About Ink?
        4. Platform SDK Support for Tablet Input
          1. Getting Ink from a Tablet
            1. Say Hello to the InkCollector
            2. Sample Application: "HelloInkCollector"
          2. When Ink Is Not Enough
            1. Sample Application: HelloInkOverlay
            2. Changing the Eraser Mode
            3. The InkControl Class in the BuildingTabletApps Library
            4. InkOverlay’s Attach Mode
          3. InkCollector Events
            1. Ink Stroke Events
            2. Pen Movement Events
            3. Mouse Trigger Events
            4. Tablet Hardware Events
            5. Rendering Events (InkOverlay Only)
            6. Ink Editing Events (InkOverlay Only)
            7. Sample Application: InputWatcher
            8. Analyzing the Events
          4. InkOverlay Events
          5. Specifying the Tablet Data to Capture—Packet Properties
            1. Sample Application: PacketPropertyWatcher
            2. Ink Coordinates
          6. Extending InkOverlay Behaviors
          7. Sample Application: TopOfPenErase
          8. Sample Application: ModelessSwitch
        5. Getting Introspective
          1. Tablets Collection
          2. Tablet Class
            1. Sample Application: DeviceWalker
          3. Common Properties on InkCollector and InkOverlay
        6. Best Practices for InkCollector and InkOverlay
          1. NewPackets and NewInAirPackets Events
          2. Choosing Desired Packet Properties
          3. Gesture Recognition
          4. Mouse Events
        7. Summary
      3. 5. Tablet PC Platform SDK: Ink Data Management, Part I
        1. Ink and Stroke Objects
          1. Introduction to the Ink, Stroke, and Strokes Classes
            1. The Ink Class
            2. The Stroke Class
            3. The Strokes Class
            4. Sample Application—StrokeIdViewer
            5. Analysis of Stroke ID Behavior
          2. Using Strokes Collections
            1. Collection Functionality
            2. Receiving Notification of Stroke Addition or Removal
            3. Sample Application—InkSelector
          3. Creation, Deletion, and Ownership of Stroke Objects
            1. Adding Ink
            2. Deleting Ink
            3. Receiving Notification of Ink Addition and Deletion
            4. Sample Application—InkCopy
            5. Sample Application—InkFactory
        2. Rendering Digital Ink
          1. Renderer Class
            1. Creating and Maintaining Renderer Objects
            2. Drawing Ink
            3. Sample Application—InkLayers
            4. Converting Between Ink Space and Pixels
            5. Renderer Transforms—Scrolling and Zooming
            6. Sample Application—InkMagnify
          2. Adding Style—The DrawingAttributes Class
            1. Antialiased
            2. FitToCurve Property
            3. IgnorePressure Property
            4. PenTip Attribute
            5. RasterOperation Property
            6. Using the DrawingAttributes Property
            7. Sample Application—InkFormatter
          3. Special Rendering Effects
            1. Rendering Selection State
            2. Glowing Ink
            3. Truly Transparent Ink
            4. Performance Implications of These Methods
        3. Summary
      4. 6. Tablet PC Platform SDK: Ink Data Management, Part II
        1. Stroke Geometry
          1. Computing the Bounding Box of a Stroke
            1. The GetBoundingBox Method
            2. The Renderer Class’s Measure Method
            3. Code Snippet—DrawBoundingBoxes
          2. Retrieving the Points of a Stroke
            1. Polyline Points
            2. Bézier Control Points
            3. Code Snippet—DrawPoints (Draws Bézier or Polyline Points of Ink)
          3. Computing Intersections of a Stroke
            1. Code Snippet—DrawIntersections
          4. Retrieving and Setting the Packet Data of a Stroke
            1. Code Snippet—PressureAdjust
          5. Retrieving the Cusps of a Stroke
            1. Code Snippet—DrawCusps
          6. Putting It Together—the StrokeDataViewer Example
            1. Sample Application—StrokeDataViewer
          7. Transforming Strokes
            1. Sample Application—StrokeWarper
        2. Targeting and Hit-Testing Ink Strokes
          1. Different Types of Hit-Testing
            1. Point-Based
            2. Rectangle-Based
            3. Lasso-Based
            4. Percentage-Based Enclosure
          2. Hit-Testing Functions
            1. Computing the Nearest Point
            2. Sample Application—InsertRemoveSpace
            3. Sample Application—RealtimeLasso
        3. Splitting and Trimming Ink
          1. Splitting Strokes
          2. Clipping/Trimming Strokes
            1. Sample Application—StrokeChopper
        4. Serialization, the Clipboard, and Drag and Drop
          1. Serialization
            1. Persisting Strokes Collections
            2. Extended Property Data
            3. Sample Application—InkPersist
          2. Using the Clipboard
            1. Sample Application—InkClippy
          3. Implementing Drag and Drop
            1. Sample Application—InkDragDrop
        5. Summary
      5. 7. Tablet PC Platform SDK: Ink Recognition
        1. Recognizer Architecture
          1. Text vs. Object Recognition
          2. Synchronous vs. Asynchronous Recognition
            1. Partial Recognition
            2. When to Use Foreground and Background Recognition
          3. Recognition Results
        2. Performing Simple Recognition
          1. Recognizing Text
            1. Sample Application—BasicReco
          2. Recognizing Application Gestures
            1. Specifying Application Gestures to Recognize
            2. Receiving Application Gesture Events
            3. Sample Application—GesturePad
        3. Using the Recognition Classes
          1. Obtaining a Recognizer to Use
          2. Initiating a Recognition Session
            1. The Recognition Mode
            2. Prefix and Suffix Strings
            3. The Character Auto-Complete Mode
          3. Supplying Strokes to the Recognizer
          4. Getting Results I: Easy Synchronous Recognition
            1. Sample Application—IntermediateReco
          5. Getting Results II: Electric Boogaloo (a.k.a. Harder Synchronous Recognition)
            1. Sample Application—AdvancedReco
          6. Getting Results III: The Final Chapter (a.k.a. Asynchronous Recognition)
            1. Sample Application—AsyncReco
          7. Working with Recognition Results
            1. The RecognitionAlternate Class
            2. Sample Application—WordSelect
            3. Sample Application—CorrectionUI
          8. Storing Recognition Results
          9. Recognition Properties
          10. Improving Recognition Results
            1. Factoids—Content Hint
            2. Word Lists—Content Hint
            3. Determining if a Word Is Supported
            4. Guides—Spatial Hint
        4. Summary
      6. 8. Ink Controls
        1. Achtung Baby
        2. InkEdit
          1. InkEdit Basics
            1. Basic Properties
            2. Mouse-Related Properties
            3. Basic Properties Example
          2. Working with Ink
            1. Accessing Ink with SelInks
            2. Toggling Ink Display with SelInksDisplayMode
          3. Recognizing Ink and Gestures
            1. Changing Recognition
            2. Recognition Timing
            3. Gestures in InkEdit
          4. InkEdit Parting Thoughts
        3. InkPicture
        4. Summary
    9. III. Advanced Tablet PC Topics
      1. 9. Updating Existing Applications
        1. Even Better than the Real Thing
          1. User Benefits of Integration
            1. Pen-Friendly User Interfaces
            2. Digital Ink Features
          2. Business Benefits of Integration
        2. Technical Considerations
          1. Application Design
            1. InkCollector and InkOverlay
            2. Storage
            3. Clipboard
            4. Undo
            5. Ink Architecture
            6. Accessibility
          2. Performance
            1. Speed of Common Operations
            2. Memory and Storage of Ink
        3. InkPadJunior
        4. Summary
    10. IV. Appendixes
      1. A. BuildingTabletApps Library Reference
        1. The InkInputPanel Class
          1. InkInputPanel
        2. The InkControl and InkControl2 Classes
          1. InkControl
          2. InkControl2
          3. InkOverlay
          4. InkInputPanel
        3. The FormatInkDlg Class
          1. FormatInkDlg
          2. DrawingAttributes
        4. The InkEx Class
          1. AddStrokesAtRectangle
        5. The RendererEx Class
          1. InkSpaceToPixel
          2. PixelToInkSpace
          3. DrawSelected
          4. DrawStrokeIds
          5. DrawBoundingBoxes
          6. DrawPoints
          7. DrawIntersections
          8. DrawCusps
        6. The LassoUI Class
          1. LassoUI
          2. Start
          3. Continue
          4. Render
          5. Points
          6. BoundingRect
          7. DotSpacing
          8. DotSize
          9. DotBrush
        7. The CopyAsTextDlg Class
          1. CopyAsTextDlg
          2. RecognitionResult
      2. B. Tablet PC Hardware Guidelines
        1. Windows XP Tablet PC Edition Hardware Requirements
          1. Digitizer:
          2. Power States:
          3. Viewing Mode:
          4. Removal from Dock:
          5. Legacy-Free:
          6. CTRL+ALT+DEL or Equivalent Functionality:
    11. C. About the Author
    12. SPECIAL OFFER: Upgrade this ebook with O’Reilly

Product information

  • Title: Building Tablet PC Applications
  • Author(s):
  • Release date: September 2002
  • Publisher(s): Microsoft Press
  • ISBN: 9780735617230