FAQ – CTH470, CTH670 Bamboo

9/23/11 – version 0

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’s that enables any software application to connect to and receive finger touch data from a Wacom CTH470 or CTH670 tablet.  As the end-user touches the tablet, data from each finger touch is streamed through the Feel™ Multi-Touch API.  Use this touch data stream to create unique features and gestures for your desktop or web application.

The Feel™ Multi-Touch SDK is available for free from Wacom and works with Wacom multi-finger touch tablets CTH470 and CTH670.

Sample Application

Included are sample applications to demonstrate how to collect and use the Feel™ Multi-Touch data.  These apps will be improved over time and made available to early-look developers.

There are Mac desktop, Win desktop and WebPlugin browser sample apps.


CTH470, CTH670 Features

1.     What are the Pen features for these products?

The pens have 1024 levels of pressure, eraser, 2 programmable pen buttons.

2.     How many Express Keys does the product have?

4 Programmable keys.

3.     What are the Feel™ Multi-Touch features?

The resolution for touch input is 0.1mm.  The touch data will report at 100 times per second. It will support up to 16 different finger touch points at once.  Information for each finger touch point is streamed to the application via the Feel™ Multi-Touch API.

If the application chooses to pass the touch data through to the driver then the following gestures are enabled via the driver gesture engine for all environments:

2 finger pinch in Zoom in               

2 finger pinch out Zoom out        

2 finger Rotate CW                            

2 finger Rotate CCW                         

2 finger V scroll                                    

2 finger H scroll                                   

3 finger Swipe to right                     

3 finger Swipe to left                        

4 finger Swipe to left/right           

4 finger swipe up                                

4 finger swipe down


4.     Does CTH470/CTH670 reject palm touches when the pen is in use (also known as palm, hand or wrist detection)?

The CTH470/CTH670 operates 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.

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

CTH470/CTH670 does not report touch data (gestures or finger touch points) if the pen tip or eraser tip is in proximity (near or on) the tablet writing surface.

6.     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 SDK

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

You’ll need a Feel™ Multi-Touch enabled product –the CTH470/CTH670 product.  Also you will need to download the Feel™ Multi-Touch SDK which includes the drivers, documentation and sample code to use the Feel™ Multi-Touch API.

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

The Feel™ Multi-Touch API support is a part of the driver itself, and the necessary dll’s get installed with it.  After installing the driver, you need to just include the header files.  No SDK/lib is required.

9.     Does the 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.

Using Touch

1.     What kind of touch data can I get from the tablet via the Feel™ Multi-Touch API? For the CTH470 and CTH670?

The CTH470/CTH670 products will report at least the following for each finger:

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

Š       finger touch location (x,y)

Š       finger touch sensitivity (the strength of the contact, this is not finger pressure.  It is device and user specific indication of the capacitive strength of the contact point.)

Š       See the Feel™ Multi-Touch API documentation for a full review of capabilities.


2.     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 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.

3.     What is the “touch confidence bit”?

This is a flag that is set based on an algorithm that determines the likelihood that the touch was meant to happen, and not accidental by the user.  This bit is not used in CTH470/CTH670.

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

The developer can use the 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.

5.     Do we have sample code for the Feel™ Multi-Touch API?

Yes, when the developer downloads the SDK documentation they receive some sample code for the Mac, Win and Browser-based environments.

6.     Why do the keystrokes sent for indirect track pad rotate gestures only report every 5 degrees?

The rotation gesture is based on two criteria – initial threshold (how much rotation needs to occur before it can be correctly recognized as a start of the ‘rotation’ gesture) and incremental threshold (issued every 5 degrees of rotation). Some apps rotate smoothly, while some apps support less granular rotation (45 degrees or 90 degrees). So a 5 degree resolution was selected for efficiency (to avoid sending unnecessary keystrokes to an app).

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

No, there is no palm rejection for “touch”.  When using the Feel™ Multi-Touch API, all touches are interpreted as valid and are reported.  When using the driver gesture engine, the palm touch will be included in determining the gesture.

Mac Environment – CTH470/CTH670

8.     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’s 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.

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

Use the 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.)

10.  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 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.

11.  Which gestures are supported for Mac OS?

2 finger pinch in Zoom in                opt+f16

2 finger pinch out Zoom out         opt+f15

2 finger Rotate CW                             opt+f13 (5 degree increments)

2 finger Rotate CCW                          opt+f14 (5 degree increments)

2 finger V scroll                                     scroll messages - vertical

2 finger H scroll                                    scroll messages - horizontal

3 finger Swipe to right                      command+] (forward)

3 finger Swipe to left                         command+[ (back)

4 finger Swipe to left/right            command+tab (app switcher)

4 finger swipe up                                 F4 (show desktop)

4 finger swipe down                          F9 (show/hide expose)


12.  Does the CTH470/CTH670 product support Mac OS X Lion?

Yes.  However, the new Lion gestures are not yet supported (pending driver update).

Windows Environment – CTH470/CTH670

13.  Does CTH470/CTH670 support Windows 7 native Multi-touch via WM_GESTURE events (the standard Win7 OS level event to be handled by applications)?

The CTH470/CTH670 tablet uses a “relative touch track pad” model for touch gesture interaction.   While the Win 7 native gesture API was designed for screen displays and supports a “absolute on-screen touch” model via displays.  Therefore the standard Microsoft API is not available to use with a relative touch tablet like CTH470/CTH670.  Instead, there are two options for the application to use touch gestures with the CTH470/CTH670:

Š       Using the “Observer mode” will allow the touch data to “pass through” to the Wacom driver and the gesture engine which will interpret the touch data.  This gesture engine converts the touch data to appropriate keystrokes and sends these to the app to drive gesture actions.

The Wacom tablet driver gesture engine provides the following keystrokes to the app:

Zoom in                           ctrl+wheel up

Zoom out                       ctrl+wheel down

Rotate CW                    alt+f13

Rotate CCW                 alt+f14

V scroll                            wheel

H scroll                            WM_HCROLL

Swipe to right             5TH click (forward)

Swipe to left                4th click (back)


Š       Alternatively, the App can be in “Consumer mode” and directly access the raw touch data through the Feel™ Multi-Touch API for its own gesture processing.  In this mode, the app should configure the touch API to prevent the tablet driver from interpreting the data.  This allows your app to implement high-performance actions in response to typical gestures (or even create custom gestures.)


14.  Is CTH470/CTH670 Windows 7 WHQL certificated?

Our latest drivers have passed WHQL for Windows7 and legacy Windows WinXP and Vista.

15.  Windows 8 WHQL certification

Microsoft has not yet opened testing for Windows 8 for peripherals.

Web App Plugin - CTH470/CTH670

16.  Which Web Browsers are supported

Supported Browsers

Support on 32-bit and 64-bit Windows 7, Vista and XP:

The following browsers are supported.


Minimum  supported version

Internet Explorer











Support on Mac OSX 10.4 and above:

The following browsers are supported.


Minimum  supported version






Application Design Considerations

17.  The 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 Bamboo CTH470/CTH670.  It is also designed to anticipate possible new feature capabilities in the future.  When designing software applications to using the Feel™ Multi-Touch API you can be comfortable that your features should be consistent and compatible with possible future products from Wacom.

18.  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. 

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

20.  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.

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


Common Problems


22.  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.

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

The CTH470/CTH670 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 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.