FAQ – Wacom Feel™ Multi-Touch API

API Version

Update date (author)

Reasons for update

2.0

5/7/2012 (RCC)

First version for public release

3.0

Various (various)

Added FrameNumber support, update supported tablet list

4.0

4/10/2014 (RCC)

Added info on passthrough mode

 

 

 

Contents

Supported Tablets. 3

Feel™ Multi- Touch SDK. 4

Intended Audience. 4

Who is the intended audience for this FAQ?. 4

Wacom Feel™ Multi-Touch Tablet Features. 4

What are the primary Wacom Feel™ Multi-Touch API features?. 4

Do the multi-touch tablets reject palm touches when the pen is in use (also known as palm, hand or wrist detection)?  5

Can the pen data be used at the same time (simultaneously) as the touch data?. 5

When the wireless accessory is being used is the performance or feature set reduced?. 5

Using the Wacom Feel™ Multi-Touch API 5

Which build environments are supported?. 5

What do I need to start developing software for the Wacom Feel™ Multi-Touch API?. 6

What do I need to use Wacom Feel™ Multi-Touch APIs?  Do I need to include any SDK or library with my own project?  6

Does the Wacom Feel™ Multi-Touch API also work with the first generation Bamboo Pen and Touch products?  6

Where can I find Wacom Feel™ Multi-Touch API sample applications?. 6

How can I download the SDK for the Feel™ Multi-touch API?. 6

What kind of touch data can I get from the tablet via the Wacom Feel™ Multi-Touch API?. 6

What can I do with this touch data?. 7

What are the primary operating modes supported by the Wacom Feel™ Multi-Touch API?. 7

What is the difference between Consumer and Observer modes?. 8

How does palm rejection work?  What is the “touch confidence bit”?. 8

How can I create extended and customizable gestures? Does Wacom provide a tool to create them?. 8

How does the Wacom gesture engine work in relation to the API?. 9

How can my application support the system-wide “user configurable gestures” from Wacom, and also my custom application-specific touch features?. 9

When resting my palm on the tablet and touching with fingers for gestures or finger data input, can the Wacom Feel™ Multi-Touch API identify and reject the palm?. 9

Why can’t I get the model # to use when designing features for Wacom tablets?. 9

As the API changes and improves, will my application still work with older versions of the API?. 9

What is frame count and how do I use it?. 9

Application Design Considerations. 10

What are some key design considerations when using the Wacom Feel™ Multi-Touch API?. 10

What are some tips to create a fast and fluid touch experience?. 10

What are some recommendations for designing gestures from finger data?. 10

What are some recommendations about using pen simultaneous with touch?. 11

What is the difference in designing touch features for a Cintiq (touch display tablet) or Intuos (touch opaque tablet)?  11

Mac Specific Environment API Usage. 11

What Wacom data will I get from Apple's touch APIs (NSEvent, NSTouch)?. 11

How can I write a multi-touch, finger-position-aware app for Wacom's hardware?. 12

On the Apple trackpad hardware a single finger gesture will move the cursor. If I enable the finger-callback in the Wacom driver then a single finger gesture on the Wacom hardware does not drive the mouse, but is fed to my finger callback. 12

Which gestures are supported for Mac OS?. 12

Windows Specific Environment API Usage. 13

Does the Wacom Feel™ Multi-Touch API support Windows 7 native Multi-touch via WM_GESTURE events (the standard Win7 OS level event to be handled by applications)?. 13

Can I use the Wacom Feel™ Multi-touch API to design touch functionality or gestures for my Windows 8 Metro application?. 13

What is the difference between Win8 touch API and Wacom Feel(tm) Multi-touch API?. 13

Common Issues and Problems. 14

Here are some common build issues for Windows: 14

Here are some common build issues for Mac: 14

When using the pen hand to complete gestures, the gesture touches do not register or are intermittent. 14

My app is getting overwhelmed with too many touch callbacks, the callback is lagging and becoming unresponsive.  How can I fix this?. 14

Web App Plugin. 15

What is the Wacom Web App Plugin?. 15

Which Web Browsers are supported by the Wacom Web App Plugin?. 15

 

Supported Tablets

The following table shows which Wacom touch-enabled tablets are supported by the Wacom Feel™ Multi-Touch API, and which touch data types are supported.

Data type descriptions:

·         Simultaneous pen/touch – both pen and touch data can be detected at the same time.  This allows applications to respond to user pen input with one hand while doing touch functions with the other hand (for example rotating a drawing canvas).

·         Confidence bits – a true/false flag within a finger touch point data packet that indicates whether the tablet driver software has algorithmically determined the finger data to be "good" or not.  For example, touches due to the palm resting on the tablet while the user is drawing with the pen would be determined to be false (ie, not confident). This allows apps to perform palm rejection on such touches.

·         Touch point data – finger touch data, showing each finger position, size and confidence

·         Blob data – finger touch data, showing each finger outline

·         Raw data – tablet touch sensor data, showing all tablet points, whether touched or not.

See the Wacom Feel™ Multi-Touch API document for details.

 

Tablet model

Tablet name

Simultaneous pen/touch

Supports confidence bits in API

Touch point data

Blob data

Raw data

Approximate number of touch points per second per finger
(5 fingers or fewer)

First driver version

for touch data support

Windows / Mac

CTH-460

Bamboo Pen & Touch

no

no

no

no

no

50

n/a

CTH-461

Bamboo Craft Pen & Touch

no

no

no

no

no

50

n/a

CTH-661

Bamboo Fun Medium Pen & Touch

no

no

no

no

no

50

n/a

CTH-470

Bamboo Capture

no

no

yes

no

no

50

5.2.5 / 5.2.6

CTH-670

Bamboo Create

no

no

yes

no

no

50

5.2.5 / 5.2.6

PTH-450

Intuos5 Small

yes

yes

yes

no

no

100

6.3.2 / 6.3.2

PTH-650

Intuos5 Medium

yes

yes

yes

no

no

100

6.3.2 / 6.3.2

PTH-850

Intuos5 Large

yes

yes

yes

no

no

100

6.3.2 / 6.3.2

DTH-2400

Cintiq 24HDT Pen and Touch Display

yes

yes

yes

yes

yes

100

6.3.3 / 6.3.3

DTH-2200

Cintiq 22HD touch

yes

yes

yes

yes

yes

100

6.3.5 / 6.3.5

DTH-2242

DTH-2242

yes

yes

yes

yes

yes

100

6.3.5 / 6.3.5

DTH-A1300

Cintiq Companion Hybrid

yes

yes

yes

yes

yes

100

6.3.6 / 6.3.6

CTH-480

Intuos PT S

no

yes

yes

no

no

100

6.3.6 / 6.3.6

CTH-680

Intuos PT M

no

yes

yes

no

no

100

6.3.6 / 6.3.6

PTH-451

Intuos pro S

yes

yes

yes

no

no

100

6.3.6 / 6.3.6

PTH-651

Intuos pro M

yes

yes

yes

no

no

100

6.3.6 / 6.3.6

PTH-851

Intuos pro L

yes

yes

yes

no

no

100

6.3.6 / 6.3.6

DTH-W1300

Cintiq Companion

yes

yes

yes

yes

yes

100

6.3.7 / 6.3.7

Table 1 - Wacom Multi-Touch API supported tablets

Feel™ Multi- Touch SDK

Wacom’s Feel™ Multi-Touch Application Programming Interface (API) enables you to build applications that use the powerful finger detection and location capabilities of the Wacom touch tablets.  Use this stream of finger information to create unique features for your application, including custom gestures or direct on screen manipulation of objects.

Wacom’s Feel™ Multi-Touch SDK is an API that enables any software application to connect to and receive finger touch data from Wacom Feel™ Multi-Touch supported tablets.  As the end-user touches the tablet, data from each finger touch is streamed through the Wacom Feel™ Multi-Touch API.  Use this touch data stream to create unique features and gestures for your desktop or web application.

The Wacom Feel™ Multi-Touch SDK is available for free from Wacom and currently works with the tablets listed in Table 1 .

Intended Audience

Who is the intended audience for this FAQ?

This FAQ is intended to help software developers use the Wacom Feel™ Multi-Touch API to integrate touch support into their applications.

Wacom Feel™ Multi-Touch Tablet Features

What are the primary Wacom Feel™ Multi-Touch API features?

The API supports:

·       Per finger contact data.  Information for each finger touch point is streamed to the Wacom Feel™ Multi-Touch API application

·       Palm rejection for non-finger contacts

·       Per finger confidence data

·       Touch blob data on supported tablets

·       Raw touch data on supported tablets

·       Applications can be designed to use both touch data and pen data for optimal user interaction

·       A "consumer mode" to allow a single app to process all touch data

·       An "observer mode" to allow multiple apps to process all touch data, as well as passing the data to the system for processing (such as for gesture recognition)

·       A “passthrough mode” to allow designated hitrects within a consumer or observer mode application to pass data to the system for processing (such as for button pushes in a dialog)

                See the information below for descriptions of these supported capabilities. 

                Also, see the API documentation for a complete description of all supported features: http://www.wacomeng.com/touch/WacomFeelMulti-TouchAPI.htm

Do the multi-touch tablets reject palm touches when the pen is in use (also known as palm, hand or wrist detection)?

Some tablets (see Table 1) operate exclusively in one of the two modes - pen or  touch. When the pen tip or eraser tip is in proximity to the tablet (near or on it), any touches from palm or fingers will be ignored.  Other tablets support simultaneous pen and touch.  For these tablets, the API provides palm rejection properties.

Can the pen data be used at the same time (simultaneously) as the touch data?

See Table 1 for tablets that support simultaneous pen and touch.

When the wireless accessory is being used is the performance or feature set reduced?

Using wireless does not reduce the capabilities of the product.

Using the Wacom Feel™ Multi-Touch API

Which build environments are supported?

The following build environment is supported for Windows:

·         Microsoft Visual Studio 2010, 2012

The following build environments are supported for Mac:

·         Xcode  4 & 5

 

What do I need to start developing software for the Wacom Feel™ Multi-Touch API?

You’ll need a Wacom Feel™ Multi-Touch enabled product (see Table 1).  Also you will need to download the Wacom Feel™ Multi-Touch SDK which includes documentation, project files, and sample code to enable use of the Wacom Feel™ Multi-Touch API.

What do I need to use Wacom Feel™ Multi-Touch APIs?  Do I need to include any SDK or library with my own project?

The Wacom Feel™ Multi-Touch API support is a part of the tablet driver software itself.  Driver installation supplies all necessary system components to communicate with the tablets via the API.    When you build your app using SDK-supplied headers, you can dynamically link to the installed API system components.  No .LIB files are required.  See code samples at http://www.wacomeng.com/touch/index.html.

Does the Wacom Feel™ Multi-Touch API also work with the first generation Bamboo Pen and Touch products?

No, there is no touch API for the first generation Bamboo Pen and Touch products (see Table 1 for product model information).

Where can I find Wacom Feel™ Multi-Touch API sample applications?

Included in the multi-touch API support are sample applications to demonstrate how to collect and use the Wacom Feel™ Multi-Touch data.  When the developer downloads the SDK documentation they receive some sample code for the Mac, Win and browser-based environments.   Go to http://www.wacomeng.com/touch/index.html.

How can I download the SDK for the Feel™ Multi-touch API?

 The Feel™ Multi-touch API is provided via the software driver.  The drivers are specific to OS and tablet type and installed when the end-user installs their tablet on their computer.  The SDK download from the Wacom Developer webpage (http://www.wacomeng.com/touch/index.html) provides documentation and sample code to use this API.

What kind of touch data can I get from the tablet via the Wacom Feel™ Multi-Touch API?

The API-supported multi-touch tablets will report at least the following for each finger:

·       Finger state (none, up, down, hold)

·       Finger touch location (x,y)

·       Finger size (width and height)


        For supported tablets (see Table 1), additional data types are supported:

·       Blob data – irregular shaped regions where one or more touch contacts were detected

·       Raw data – all data for the sensor, which includes areas of non-contact along with contact areas

See the Wacom Feel™ Multi-Touch API documentation (http://www.wacomeng.com/touch/WacomFeelMulti-TouchAPI.htm ) for a full review of capabilities.

What can I do with this touch data?

You can use the data to create features that enable direct interaction between the user and content on-screen – touching the screen objects and causing some action on them.  Or to create gestures that drive the application.  Create an immersive experience with fingers, without a mouse or keyboard.  The Wacom Feel™ Multi-Touch screen responds to many points of contact simultaneously, not just from one or two fingers, but from multiple contact points at once.

What are the primary operating modes supported by the Wacom Feel™ Multi-Touch API?

·       Consumer mode – In Consumer mode, the  forefront Wacom Feel™ Multi-Touch API enabled application is the only process to receive touch data.  The data is not passed on for gesture processing, to the system or other multi-touch applications.

·       Observer mode – In Observer mode, the multi-touch application is configured to receive touch data, which it can parse as needed.  The touch data is also sent to the tablet driver gesture recognition algorithms as well as on to the system itself (for cursor navigation, for example).  All running Wacom Feel™ Multi-Touch API enabled applications will receive the touch data.  If the application chooses to pass the touch data through to the driver in Observer mode, then the tablet driver will interpret touch data and recognize gestures as appropriate for the tablet and operating system.  See the user manual for your tablet for a description of supported gestures.

·       Passthrough mode – In Passthrough mode, touch data is sent to the system if it falls within a specified hitrect.  This is useful for consumer applications that want to preserve exclusive use of the touch data for drawing or object manipulation, while still maintaining the ability for users to interact with application controls (eg: buttons, menus, etc.).   Passthrough mode regions (hitrects) can be used in conjunction with the other two modes.

What is the difference between Consumer,  Observer and Passthrough modes?

Consumer mode is useful if you are using the touch data to define your own gestures or other interactions and do not want any interference from the OS. It may require more work in your application because the OS does not move the cursor or provide the ability to interact with menus or other dialogs.

Observer mode provides the application the ability to interact with the touch data.  The data is then passed on to the OS to do the work of moving the cursor and interacting with items outside the scope of your window.

Passthrough mode is useful for setting up click regions or button box areas in your application.

How does palm rejection work?  What is the “touch confidence bit”?

Palm rejection is the ability for an application to ignore touch data at such times where it would cause interference (such as leaving smudges or streaks) in the application with which the user is interacting.  The API supports the ability for an application to build in palm rejection through the use of "confidence bits".   A confidence bit is a flag for a single finger's touch data that indicates whether the tablet driver thinks the touch is intentional (valid) or accidental (invalid).

A common use of the confidence bit is for applications that incorporate both pen and touch input.  Touches that are in the vicinity of the pen location would be deemed non-confident (for right-handed users, if the touch occurs primarily to the right of the pen location).  Another use of confidence bits is to flag when a touch contact is too large, where "too large" is approximately anything over the size of a normal finger contact.  Although confidence bits come with all finger touch data, the application is free to ignore them and build in its own criteria for deciding when touches are valid or not.

If your application needs to match the Down and Up events it will be important to inspect the non-confident data; most down events happen in a non-confident state. 

The use of palm rejection will add some delay it can take several frames for a contact to be accepted.

See Table 1 for tablets that support the touch confidence bit. 

How can I create extended and customizable gestures? Does Wacom provide a tool to create them?

The developer can use the Wacom Feel™ Multi-Touch data to create their own gestures in place of the standard OS gestures, or to extend them in a unique way.  Wacom does not provide a tool for this.

How does the Wacom gesture engine work in relation to the API?

The Wacom Feel™ Multi-Touch API does not provide any gesture events. The gesture events generated by the driver are sent in the form of keystroke and mouse wheel events.  The output of some gestures can be modified by the user via the Wacom Tablet Preference Pane.  If the application registers for Consumer mode touch data then these events are not generated.  If an application wishes to receive tablet driver gesture support as well as handle touch data input, it should register for Observer mode touch data.

How can my application support the system-wide “user configurable gestures” from Wacom, and also my custom application-specific touch features?

                 To do this you would need to use Observer mode and respond to the events from the OS as needed by your application.

When resting my palm on the tablet and touching with fingers for gestures or finger data input, can the Wacom Feel™ Multi-Touch API identify and reject the palm?

Some tablets can use confidence bits to indicate a false (reject) condition when a palm is resting on the tablet (see Table 1 for tablets that support this bit).  For tablets that do not support confidence bits, using the Wacom Feel™ Multi-Touch API, all touches are interpreted as valid and are reported. 

Note that if the multi-touch app is set up as an “observer”, then touch data is also passed to the tablet driver gesture recognizers which may or may not use the touch confidence bits in their gesture recognizer algorithms in determining gestures.

Why can’t I get the model # to use when designing features for Wacom tablets?

Designing touch interactions based on features provided by the touch capabilities structure is the best way to insure future compatibility. We will make sure that the same features in future tablets work with the API. Design decisions based on model numbers may break when future tablet models are released.

As the API changes and improves, will my application still work with older versions of the API?

Most likely, yes. Maintaining backward compatibility is a high priority. We will strive to maintain support for previous versions of the API as new versions come out. Please check the return value from the WacomMTInitialize function for version compatibility issues. 

What is frame count and how do I use it?

The frame count value is incremented every time a new packet of contacts is detected. Since the rate of packet delivery is fixed the frame count value can be used to measure the rate a contact moves without needing to rely on an internal timer value.  This can also be used to identify when a frame is dropped.   The property returns zero for unsupported tablets.

Application Design Considerations

What are some key design considerations when using the Wacom Feel™ Multi-Touch API?

The Wacom Feel™ Multi-Touch API is a cross-OS platform data format that works with Mac, Win and web apps.  It is designed to work with compatible tablets listed in  Table 1.  It is also designed to anticipate possible new feature capabilities in the future.  When designing software applications to using the Wacom Feel™ Multi-Touch API you can be comfortable that your features should be consistent and compatible with possible future products from Wacom.  Here are some design considerations:

·         Help your user keep their creative focus on their work.  Seek to maximize fluidity of gestures for pan, rotate, zoom in-out, etc. within the user workspace. 

·         Maximize the touchability of the user workspace. Use larger and well-spaced menus, controls and sliders, etc. 

·         Enable non-dominant hand to control menus while using pen with the dominant hand.  Allow menus to float or be near the non-dominant hand for simple two handed operations.

·         Bring controls to the pen and touch location, rather than menu strips.

What are some tips to create a fast and fluid touch experience?

For interactions that use both pen and touch it is important to allow touch to still work when the pen is in range. If arbitrating between pen and touch it works best if you use pen pressure rather than the in range status of the pen.  For example, continue handling touch input while pen pressure is zero.   Once the pen touches the tablet, pressure is greater than zero.  As long as the pen is hovering (zero pressure), the app can continue processing touch input.

What are some recommendations for designing gestures from finger data?

One of the key benefits of using the Feel™ Multi-Touch API is to get fluid interaction with both pen and touch. Our recommendation is that touch gestures you implement should not be interrupted when the pen is in range of the tablet. This allows for a more natural workflow as the user does not have to consciously raise the pen out of range before manipulating the application. So instead of testing the in range bit it is best to use the tip bit to determine when to stop a gesture.

The Windows sample code demo at http://www.wacomeng.com/touch/index.html - although not implementing gesture support - gives an example of integrating both the Wacom Feel™ Multi-Touch API and the tablet pen API into the same application.

What are some recommendations about using pen simultaneous with touch?

                 When using simultaneous pen and touch it is best to pay attention to the confidence bit.  This is particularly useful for ignoring data that comes from the hand holding the pen.

What is the difference in designing touch features for a Cintiq (touch display tablet) or Intuos (touch opaque tablet)?

The most important thing to consider when designing touch interactions for display tablets (Cintiq, etc) and opaque tablets (Intuos, etc) is that display tablets are direct touch and opaque tablets  are indirect touch.

Indirect touch devices operate like track pads. Touching an indirect device may move the cursor but does not automatically generate a click at that location. As you move your finger the cursor moves relative to its last location.  You can reach  any part of the desktop area when multiple monitors are attached.  In this model, a gesture effects the object that is selected or the object that has focus.  Because the tablet is relative and not mapped to any specific monitor the finger data is output in a unit natural percentage of the tablet.

Direct touch device, on the other hand, moves the cursor on a single monitor. This is a one to one relationship with where the user touches.  As soon as the user touches the surface a click is generated at that location.  Here a gesture effects the object under the fingers.  Finger data from a direct touch device will be output in the monitor space for which the tablet is mapped to.

The Feel™ Multi-Touch API provides information about the tablet that provided the touch data.  An application should always check for and handle data from both direct tablets and indirect tablets.  Using the information provided in with the device capabilities, an application can translate the finger position data into the best units for the individual application.

Mac Specific Environment API Usage

What Wacom data will I get from Apple's touch APIs (NSEvent, NSTouch)?

Apple’s touch API provides mouse-cursor location, mouse clicks, and swipe, zoom, rotate, and scroll gestures.

Swipe, Zoom, and Rotate are provided by Wacom tablet driver special handling of Apple's events.

Wacom does not provide touch coordinates for these gestures. (Unlike the Magic Trackpad, which publishes its finger locations through NSTouch.) It isn't possible for Wacom to access that structure, since the device dimensions provided by NSTouch cannot be accessed.

How can I write a multi-touch, finger-position-aware app for Wacom's hardware?

Use the Wacom Feel™ Multi-Touch API to receive information about the finger touch points and use these within your app.

You would need finger coordinates to implement, for example, a photo app which could zoom and rotate a photo directly under your fingertips. You would need finger coordinates to implement iPhone-style scrolling (where the content moves directly under your fingers.)

On the Apple trackpad hardware a single finger gesture will move the cursor. If I enable the finger-callback in the Wacom driver then a single finger gesture on the Wacom hardware does not drive the mouse, but is fed to my finger callback.

This is correct behavior.  The Wacom Feel™ Multi-Touch API will return information about the touch to the application, but will not execute any logic for mouse, gestures, etc.  This gives the app the flexibility to decide what to do with this data.  For example a single finger may be smudging color on a canvas.  However, if the app is in a mode where a gesture is expected, then allow the data to pass through to the Apple gesture engine, or interpret the data within the app as a gesture and execute accordingly.

Which gestures are supported for Mac OS?

                See the user manual for your tablet for a description of tablet-supported gestures. Note again, that gesture recognition is not supported in the Wacom Feel™ Multi-Touch API.

Windows Specific Environment API Usage

Does the Wacom Feel™ Multi-Touch API support Windows 7 / Windows 8 native Multi-touch via WM_GESTURE events?

No, the API itself does not support Windows WM_GESTURE events.  However, you can write a multi-touch app that is configured as an “Observer”, and provide hooks for these events, which are passed from Windows.  As an observer, the app also allows the data to be passed to the system. If Windows detects a gesture (such as a two-finger scroll), it will send out a WM_GESTURE event to interested apps.  If the multi-touch app is configured as a “Consumer”, then Windows does not see the touch data and does not issue WM_GESTURE events.

See the user manual for your tablet for a description of tablet-supported gestures (gestures that recognized by the tablet driver software, not the Wacom Feel™ Multi-Touch API).

Can I use the Wacom Feel™ Multi-touch API to design touch functionality or gestures for my Windows 8 Metro application?

No, Metro applications have restricted access and cannot link to our library.  For Metro applications, use Windows Pointer Events (see: http://msdn.microsoft.com/en-us/library/ie/dn433244(v=vs.85).aspx).

What is the difference between Win8 touch API and Wacom Feel(tm) Multi-touch API?

The Wacom Feel™ Multi-touch API adds support for other OS’s such as Win 7, Mac OS X, etc.  Also it allows the application to design touch features that work at the same time as the pen (simultaneously).  It provides a standardized interface for cross-platform development.

Common Issues and Problems

Here are some common build issues for Windows:

·       For building a C++ application, you will need to add WacomMultiTouch.cpp to your Visual Studio 2010 project and modify the include path for WacomMultiTouch.h to point to the correct location (both files are included in the Wacom_Feel_SDK.zip as well as in the WacomMT_Scribble.zip demo).

·       Although not required for building, the execution of an app built with the SDK relies on finding WacomMT.dll in a Windows system folder.  This DLL is not included in the SDK itself; rather it is installed with the tablet driver software.

 

Here are some common build issues for Mac:

·       Need to add WacomMultitouch.framework to the project.

When using the pen hand to complete gestures, the gesture touches do not register or are intermittent.

Be sure that the pen tip and eraser tip are not in proximity (on or near) the writing surface.

My app is getting overwhelmed with too many touch callbacks, the callback is lagging and becoming unresponsive.  How can I fix this?

The tablet touch data is high resolution and reports at 100 times per second for optimal user experience.  This data stream includes the finger location and whether the finger is in the “down”, “up” or “hold” position.  The Wacom Feel™ Multi-Touch API cannot anticipate the performance requirements of the application and will report at full speed. For the smoothest control and best quality experience it is not recommended to skip data points.  For optimal performance, the app is advised to use a separate thread to manage, thereby alleviating load on the main app. 

On Windows, there are two methods for reading data.  The developer can either register a read callback or register a window handle to receive a message when data is ready.

If performance is an issue it may be better to use the callback method to queue the data and process it on a different thread.  The processing thread could then peek at the data and determine if further processing is needed and maybe not process all of the data.  If you want to skip frames for performance reasons one possibility may be to look at the contact state of each finger in the frame and process every other one (for example) unless there is a change in finger state (up or new finger down).  This way you don’t miss any ups or downs but also don’t need to process every packet in between if you don’t want to.  It is important not to take very much time in the callback function and you also can’t rely on the data persisting after you exit.  So it’s best to maintain your own internal queue of contacts and process them on a separate thread.

Web App Plugin

What is the Wacom Web App Plugin?

This is a browser plugin that is used to support a subset of the Wacom Feel™ Multi-Touch API for web applications.  See http://www.wacomeng.com/web/index.html for details.

Which Web Browsers are supported by the Wacom Web App Plugin?

See the Release notes at http://www.wacomeng.com/web/index.html.