libwacom.h

Go to the documentation of this file.

/*
 * Copyright © 2011 Red Hat, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without
 * fee, provided that the above copyright notice appear in all copies
 * and that both that copyright notice and this permission notice
 * appear in supporting documentation, and that the name of Red Hat
 * not be used in advertising or publicity pertaining to distribution
 * of the software without specific, written prior permission.  Red
 * Hat makes no representations about the suitability of this software
 * for any purpose.  It is provided "as is" without express or implied
 * warranty.
 *
 * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
 * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Authors:
 *      Peter Hutterer (peter.hutterer@redhat.com)
 */
 
#ifndef _LIBWACOM_H_
#define _LIBWACOM_H_
#include <stdint.h>
#include <stdio.h>
 
#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 301)
#define LIBWACOM_DEPRECATED  __attribute__((deprecated))
#else
#define LIBWACOM_DEPRECATED
#endif /* __GNUC__ */
 
typedef struct _WacomDevice WacomDevice;
 
typedef struct _WacomBuilder WacomBuilder;
 
typedef struct _WacomMatch WacomMatch;
 
typedef struct _WacomStylus WacomStylus;
 
typedef struct _WacomError WacomError;
 
typedef struct _WacomDeviceDatabase WacomDeviceDatabase;
 
#define WACOM_STYLUS_FALLBACK_ID 0xfffff
#define WACOM_ERASER_FALLBACK_ID 0xffffe
 
enum WacomErrorCode {
        WERROR_NONE,          
        WERROR_BAD_ALLOC,     
        WERROR_INVALID_PATH,  
        WERROR_INVALID_DB,    
        WERROR_BAD_ACCESS,    
        WERROR_UNKNOWN_MODEL, 
        WERROR_BUG_CALLER,    
};
 
typedef enum {
        WBUSTYPE_UNKNOWN,   
        WBUSTYPE_USB,       
        WBUSTYPE_SERIAL,    
        WBUSTYPE_BLUETOOTH, 
        WBUSTYPE_I2C,       
} WacomBusType;
 
typedef enum {
        WACOM_DEVICE_INTEGRATED_NONE = 0,
        WACOM_DEVICE_INTEGRATED_DISPLAY = (1 << 0),
        WACOM_DEVICE_INTEGRATED_SYSTEM = (1 << 1),
        WACOM_DEVICE_INTEGRATED_REMOTE = (1 << 2),
} WacomIntegrationFlags;
 
typedef enum {
        WCLASS_UNKNOWN,      
        WCLASS_INTUOS3,      
        WCLASS_INTUOS4,      
        WCLASS_INTUOS5,      
        WCLASS_CINTIQ,       
        WCLASS_BAMBOO,       
        WCLASS_GRAPHIRE,     
        WCLASS_ISDV4,        
        WCLASS_INTUOS,       
        WCLASS_INTUOS2,      
        WCLASS_PEN_DISPLAYS, 
        WCLASS_REMOTE,       
} WacomClass;
 
typedef enum {
        WSTYLUS_UNKNOWN,
        WSTYLUS_GENERAL,
        WSTYLUS_INKING,
        WSTYLUS_AIRBRUSH,
        WSTYLUS_CLASSIC,
        WSTYLUS_MARKER,
        WSTYLUS_STROKE,
        WSTYLUS_PUCK,
        WSTYLUS_3D,
        WSTYLUS_MOBILE,
} WacomStylusType;
 
typedef enum {
        WACOM_ERASER_UNKNOWN,
        WACOM_ERASER_NONE,   
        WACOM_ERASER_INVERT, 
        WACOM_ERASER_BUTTON, 
} WacomEraserType;
 
typedef enum {
        WACOM_BUTTON_NONE = 0,
        WACOM_BUTTON_POSITION_LEFT = (1 << 1),
        WACOM_BUTTON_POSITION_RIGHT = (1 << 2),
        WACOM_BUTTON_POSITION_TOP = (1 << 3),
        WACOM_BUTTON_POSITION_BOTTOM = (1 << 4),
        WACOM_BUTTON_RING_MODESWITCH = (1 << 5),
        WACOM_BUTTON_RING2_MODESWITCH = (1 << 6),
        WACOM_BUTTON_TOUCHSTRIP_MODESWITCH = (1 << 7),
        WACOM_BUTTON_TOUCHSTRIP2_MODESWITCH = (1 << 8),
        WACOM_BUTTON_OLED = (1 << 9),
        WACOM_BUTTON_DIAL_MODESWITCH = (1 << 10),
        WACOM_BUTTON_DIAL2_MODESWITCH = (1 << 11),
        WACOM_BUTTON_MODESWITCH =
                (WACOM_BUTTON_RING_MODESWITCH | WACOM_BUTTON_RING2_MODESWITCH |
                 WACOM_BUTTON_TOUCHSTRIP_MODESWITCH |
                 WACOM_BUTTON_TOUCHSTRIP2_MODESWITCH | WACOM_BUTTON_DIAL_MODESWITCH |
                 WACOM_BUTTON_DIAL2_MODESWITCH),
        WACOM_BUTTON_DIRECTION =
                (WACOM_BUTTON_POSITION_LEFT | WACOM_BUTTON_POSITION_RIGHT |
                 WACOM_BUTTON_POSITION_TOP | WACOM_BUTTON_POSITION_BOTTOM),
        WACOM_BUTTON_RINGS_MODESWITCH =
                (WACOM_BUTTON_RING_MODESWITCH | WACOM_BUTTON_RING2_MODESWITCH),
        WACOM_BUTTON_TOUCHSTRIPS_MODESWITCH = (WACOM_BUTTON_TOUCHSTRIP_MODESWITCH |
                                               WACOM_BUTTON_TOUCHSTRIP2_MODESWITCH),
        WACOM_BUTTON_DIALS_MODESWITCH =
                (WACOM_BUTTON_DIAL_MODESWITCH | WACOM_BUTTON_DIAL2_MODESWITCH),
} WacomButtonFlags;
 
typedef enum {
        WACOM_AXIS_TYPE_NONE = 0,
        WACOM_AXIS_TYPE_TILT = (1 << 1),
        WACOM_AXIS_TYPE_ROTATION_Z = (1 << 2),
        WACOM_AXIS_TYPE_DISTANCE = (1 << 3),
        WACOM_AXIS_TYPE_PRESSURE = (1 << 4),
        WACOM_AXIS_TYPE_SLIDER = (1 << 5),
} WacomAxisTypeFlags;
 
typedef enum { WFALLBACK_NONE = 0, WFALLBACK_GENERIC = 1 } WacomFallbackFlags;
 
typedef enum {
        WCOMPARE_NORMAL = 0,         
        WCOMPARE_MATCHES = (1 << 1), 
} WacomCompareFlags;
 
typedef enum {
        WACOM_STATUS_LED_UNAVAILABLE = -1,
        WACOM_STATUS_LED_RING = 0,
        WACOM_STATUS_LED_RING2 = 1,
        WACOM_STATUS_LED_TOUCHSTRIP = 2,
        WACOM_STATUS_LED_TOUCHSTRIP2 = 3,
        WACOM_STATUS_LED_DIAL = 4,
        WACOM_STATUS_LED_DIAL2 = 5,
} WacomStatusLEDs;
 
typedef enum {
        IGNORE_ALIASES = 0,
        ONLY_ALIASES = 1,
} AliasStatus;
typedef enum {
        WACOM_MODE_SWITCH_NEXT = -1,
        WACOM_MODE_SWITCH_0 = 0,
        WACOM_MODE_SWITCH_1 = 1,
        WACOM_MODE_SWITCH_2 = 2,
        WACOM_MODE_SWITCH_3 = 3,
        /* further modes are numerical only */
} WacomModeSwitch;
 
WacomError *
libwacom_error_new(void);
 
void
libwacom_error_free(WacomError **error);
 
enum WacomErrorCode
libwacom_error_get_code(WacomError *error);
 
const char *
libwacom_error_get_message(WacomError *error);
 
WacomDeviceDatabase *
libwacom_database_new(void);
 
WacomDeviceDatabase *
libwacom_database_new_for_path(const char *datadir);
 
void
libwacom_database_destroy(WacomDeviceDatabase *db);
 
WacomDevice *
libwacom_new_from_builder(const WacomDeviceDatabase *db,
                          const WacomBuilder *builder,
                          WacomFallbackFlags fallback,
                          WacomError *error);
 
WacomDevice *
libwacom_new_from_path(const WacomDeviceDatabase *db,
                       const char *path,
                       WacomFallbackFlags fallback,
                       WacomError *error);
 
WacomDevice *
libwacom_new_from_usbid(const WacomDeviceDatabase *db,
                        int vendor_id,
                        int product_id,
                        WacomError *error);
 
WacomDevice *
libwacom_new_from_name(const WacomDeviceDatabase *db,
                       const char *name,
                       WacomError *error);
 
WacomDevice **
libwacom_list_devices_from_database(const WacomDeviceDatabase *db,
                                    WacomError *error);
 
void
libwacom_print_device_description(int fd,
                                  const WacomDevice *device);
 
void
libwacom_destroy(WacomDevice *device);
 
int
libwacom_compare(const WacomDevice *a,
                 const WacomDevice *b,
                 WacomCompareFlags flags);
 
LIBWACOM_DEPRECATED
WacomClass
libwacom_get_class(const WacomDevice *device);
 
const char *
libwacom_get_name(const WacomDevice *device);
 
const char *
libwacom_get_model_name(const WacomDevice *device);
 
const char *
libwacom_get_layout_filename(const WacomDevice *device);
 
int
libwacom_get_vendor_id(const WacomDevice *device);
 
const char *
libwacom_get_match(const WacomDevice *device);
 
const WacomMatch **
libwacom_get_matches(const WacomDevice *device);
 
const WacomMatch *
libwacom_get_paired_device(const WacomDevice *device);
 
int
libwacom_get_product_id(const WacomDevice *device);
 
int
libwacom_get_width(const WacomDevice *device);
 
int
libwacom_get_height(const WacomDevice *device);
 
int
libwacom_has_stylus(const WacomDevice *device);
 
int
libwacom_has_touch(const WacomDevice *device);
 
int
libwacom_get_num_buttons(const WacomDevice *device);
 
int
libwacom_get_num_keys(const WacomDevice *device);
 
LIBWACOM_DEPRECATED
const int *
libwacom_get_supported_styli(const WacomDevice *device,
                             int *num_styli);
 
const WacomStylus **
libwacom_get_styli(const WacomDevice *device,
                   int *num_styli);
 
int
libwacom_has_ring(const WacomDevice *device) LIBWACOM_DEPRECATED;
 
int
libwacom_has_ring2(const WacomDevice *device) LIBWACOM_DEPRECATED;
 
int
libwacom_get_num_rings(const WacomDevice *device);
 
int
libwacom_has_touchswitch(const WacomDevice *device);
 
int
libwacom_get_ring_num_modes(const WacomDevice *device);
 
int
libwacom_get_ring2_num_modes(const WacomDevice *device);
 
int
libwacom_get_num_strips(const WacomDevice *device);
 
int
libwacom_get_strips_num_modes(const WacomDevice *device);
 
int
libwacom_get_num_dials(const WacomDevice *device);
 
int
libwacom_get_dial_num_modes(const WacomDevice *device);
 
int
libwacom_get_dial2_num_modes(const WacomDevice *device);
 
const WacomStatusLEDs *
libwacom_get_status_leds(const WacomDevice *device,
                         int *num_leds);
 
int
libwacom_get_button_led_group(const WacomDevice *device,
                              char button);
 
int
libwacom_is_builtin(const WacomDevice *device) LIBWACOM_DEPRECATED;
 
int
libwacom_is_reversible(const WacomDevice *device);
 
WacomIntegrationFlags
libwacom_get_integration_flags(const WacomDevice *device);
 
WacomBusType
libwacom_get_bustype(const WacomDevice *device);
 
WacomButtonFlags
libwacom_get_button_flag(const WacomDevice *device,
                         char button);
 
int
libwacom_get_button_evdev_code(const WacomDevice *device,
                               char button);
 
WacomModeSwitch
libwacom_get_button_modeswitch_mode(const WacomDevice *device,
                                    char button);
 
LIBWACOM_DEPRECATED
const WacomStylus *
libwacom_stylus_get_for_id(const WacomDeviceDatabase *db,
                           int id);
 
int
libwacom_stylus_get_id(const WacomStylus *stylus);
 
int
libwacom_stylus_get_vendor_id(const WacomStylus *stylus);
 
const char *
libwacom_stylus_get_name(const WacomStylus *stylus);
 
LIBWACOM_DEPRECATED
const int *
libwacom_stylus_get_paired_ids(const WacomStylus *stylus,
                               int *num_paired_ids);
 
const WacomStylus **
libwacom_stylus_get_paired_styli(const WacomStylus *stylus,
                                 int *num_paired);
 
int
libwacom_stylus_get_num_buttons(const WacomStylus *stylus);
 
int
libwacom_stylus_has_eraser(const WacomStylus *stylus);
 
int
libwacom_stylus_is_eraser(const WacomStylus *stylus);
 
int
libwacom_stylus_has_lens(const WacomStylus *stylus);
 
int
libwacom_stylus_has_wheel(const WacomStylus *stylus);
 
WacomAxisTypeFlags
libwacom_stylus_get_axes(const WacomStylus *stylus);
 
WacomStylusType
libwacom_stylus_get_type(const WacomStylus *stylus);
 
WacomEraserType
libwacom_stylus_get_eraser_type(const WacomStylus *stylus);
 
void
libwacom_print_stylus_description(int fd,
                                  const WacomStylus *stylus);
 
const char *
libwacom_match_get_name(const WacomMatch *match);
const char *
libwacom_match_get_uniq(const WacomMatch *match);
WacomBusType
libwacom_match_get_bustype(const WacomMatch *match);
uint32_t
libwacom_match_get_product_id(const WacomMatch *match);
uint32_t
libwacom_match_get_vendor_id(const WacomMatch *match);
const char *
libwacom_match_get_match_string(const WacomMatch *match);
WacomBuilder *
libwacom_builder_new(void);
void
libwacom_builder_destroy(WacomBuilder *builder);
 
void
libwacom_builder_set_bustype(WacomBuilder *builder,
                             WacomBusType bustype);
 
void
libwacom_builder_set_usbid(WacomBuilder *builder,
                           int vendor_id,
                           int product_id);
 
void
libwacom_builder_set_device_name(WacomBuilder *builder,
                                 const char *name);
 
void
libwacom_builder_set_match_name(WacomBuilder *builder,
                                const char *name);
 
void
libwacom_builder_set_uniq(WacomBuilder *builder,
                          const char *uniq);
 
#endif /* _LIBWACOM_H_ */
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */