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 _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)
} 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_MODESWITCH             = (WACOM_BUTTON_RING_MODESWITCH | WACOM_BUTTON_RING2_MODESWITCH | WACOM_BUTTON_TOUCHSTRIP_MODESWITCH | WACOM_BUTTON_TOUCHSTRIP2_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),
} 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
} WacomStatusLEDs;
 
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_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);
 
const int *libwacom_get_supported_styli(const WacomDevice *device, int *num_styli);
 
int libwacom_has_ring(const WacomDevice *device);
 
int libwacom_has_ring2(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);
 
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);
 
const WacomStylus *libwacom_stylus_get_for_id (const WacomDeviceDatabase *db, int id);
 
int         libwacom_stylus_get_id (const WacomStylus *stylus);
 
const char *libwacom_stylus_get_name (const WacomStylus *stylus);
 
const int *libwacom_stylus_get_paired_ids(const WacomStylus *stylus, int *num_paired_ids);
 
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);
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);
 
#endif /* _LIBWACOM_H_ */
 
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */