#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 301)
#define LIBWACOM_DEPRECATED __attribute__((deprecated))
#else
#define LIBWACOM_DEPRECATED
#endif /* __GNUC__ */
/**
@mainpage
@section Introduction
libwacom is a library to identify wacom tablets and their model-specific
features. It provides easy access to information such as "is this a
built-in on-screen tablet", "what is the size of this model", etc.
@section Usage
The usage of libwacom in an application could look like this:
WacomDeviceDatabase *db;
WacomDevice *device;
WacomError *error;
db = libwacom_database_new();
error = libwacom_error_new();
device = libwacom_new_from_path(db, "/dev/input/event0", WFALLBACK_NONE, error);
if (!device)
return; // should check for error here
if (libwacom_device_is_builtin(device))
printf("This is a built-in device\n");
libwacom_destroy(device);
libwacom_database_destroy(db);
For a full API reference to see libwacom.h.
@section Database
libwacom comes with a database of models and their features in key-value
format. If you cannot use libwacom, the files may be parsed directly. Note
that the file format may change over time, especially in the beginning.
*/
/**
@file libwacom.h
*/
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
/**
* Possible error codes.
*/
enum WacomErrorCode {
WERROR_NONE, /**< No error has occured */
WERROR_BAD_ALLOC, /**< Allocation error */
WERROR_INVALID_PATH, /**< A path specified is invalid */
WERROR_INVALID_DB, /**< The passed DB is invalid */
WERROR_BAD_ACCESS, /**< Invalid permissions to access the path */
WERROR_UNKNOWN_MODEL, /**< Unsupported/unknown device */
WERROR_BUG_CALLER, /**< A bug in the caller */
};
/**
* Bus types for tablets.
*/
typedef enum {
WBUSTYPE_UNKNOWN, /**< Unknown/unsupported bus type */
WBUSTYPE_USB, /**< USB tablet */
WBUSTYPE_SERIAL, /**< Serial tablet */
WBUSTYPE_BLUETOOTH, /**< Bluetooth tablet */
WBUSTYPE_I2C, /**< I2C tablet */
} WacomBusType;
/**
* Tablet integration.
*/
typedef enum {
WACOM_DEVICE_INTEGRATED_NONE = 0,
WACOM_DEVICE_INTEGRATED_DISPLAY = (1 << 0),
WACOM_DEVICE_INTEGRATED_SYSTEM = (1 << 1)
} WacomIntegrationFlags;
/**
* Classes of devices.
*/
typedef enum {
WCLASS_UNKNOWN, /**< Unknown/unsupported device class */
WCLASS_INTUOS3, /**< Any Intuos3 series */
WCLASS_INTUOS4, /**< Any Intuos4 series */
WCLASS_INTUOS5, /**< Any Intuos5 series */
WCLASS_CINTIQ, /**< Any Cintiq device */
WCLASS_BAMBOO, /**< Any Bamboo device */
WCLASS_GRAPHIRE, /**< Any Graphire device */
WCLASS_ISDV4, /**< Any serial ISDV4 device */
WCLASS_INTUOS, /**< Any Intuos series */
WCLASS_INTUOS2, /**< Any Intuos2 series */
WCLASS_PEN_DISPLAYS, /**< Any "interactive pen display" */
WCLASS_REMOTE, /**< Any Wacom Remote */
} WacomClass;
/**
* Class of stylus
*/
typedef enum {
WSTYLUS_UNKNOWN,
WSTYLUS_GENERAL,
WSTYLUS_INKING,
WSTYLUS_AIRBRUSH,
WSTYLUS_CLASSIC,
WSTYLUS_MARKER,
WSTYLUS_STROKE,
WSTYLUS_PUCK,
WSTYLUS_3D,
} WacomStylusType;
/**
* Capabilities of the various tablet buttons
*/
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;
/**
* Axis type for a stylus. Note that x/y is implied.
*/
typedef enum {
WACOM_AXIS_TYPE_NONE = 0,
/** Tilt in x and y direction */
WACOM_AXIS_TYPE_TILT = (1 << 1),
/** Rotation in the z-axis */
WACOM_AXIS_TYPE_ROTATION_Z = (1 << 2),
/** Distance to surface */
WACOM_AXIS_TYPE_DISTANCE = (1 << 3),
/** Tip pressure */
WACOM_AXIS_TYPE_PRESSURE = (1 << 4),
/** A absolute-position slider like the wheel on the airbrush */
WACOM_AXIS_TYPE_SLIDER = (1 << 5),
} WacomAxisTypeFlags;
typedef enum {
WFALLBACK_NONE = 0,
WFALLBACK_GENERIC = 1
} WacomFallbackFlags;
typedef enum {
WCOMPARE_NORMAL = 0, /**< compare the device only */
WCOMPARE_MATCHES = (1 << 1), /**< compare all possible matches too */
} 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;
/**
* Allocate a new structure for error reporting.
*
* @return A newly allocated error structure or NULL if the allocation
* failed.
*/
WacomError* libwacom_error_new(void);
/**
* Free the error and associated memory.
* Resets error to NULL.
*
* @param error A reference to a error struct.
* @see libwacom_error_new
*/
void libwacom_error_free(WacomError **error);
/**
* @return The code for this error.
*/
enum WacomErrorCode libwacom_error_get_code(WacomError *error);
/**
* @return A human-readable message for this error
*/
const char* libwacom_error_get_message(WacomError *error);
/**
* Loads the Tablet and Stylus databases, to be used
* in libwacom_new_*() functions.
*
* @return A new database or NULL on error.
*/
WacomDeviceDatabase* libwacom_database_new(void);
/**
* Loads the Tablet and Stylus databases, to be used
* in libwacom_new_*() functions, from the prefix
* path passes. This is only useful for diagnostics
* applications.
*
* @return A new database or NULL on error.
*/
WacomDeviceDatabase* libwacom_database_new_for_path(const char *datadir);
/**
* Free all memory used by the database.
*
* @param db A Tablet and Stylus database.
*/
void libwacom_database_destroy(WacomDeviceDatabase *db);
/**
* Create a new device reference from the given device path.
* In case of error, NULL is returned and the error is set to the
* appropriate value.
*
* @param db A device database
* @param path A device path in the form of e.g. /dev/input/event0
* @param fallback Whether we should create a generic if model is unknown
* @param error If not NULL, set to the error if any occurs
*
* @return A new reference to this device or NULL on errror.
*/
WacomDevice* libwacom_new_from_path(const WacomDeviceDatabase *db, const char *path, WacomFallbackFlags fallback, WacomError *error);
/**
* Create a new device reference from the given vendor/product IDs.
* In case of error, NULL is returned and the error is set to the
* appropriate value.
*
* @param db A device database
* @param vendor_id The vendor ID of the device
* @param product_id The product ID of the device
* @param error If not NULL, set to the error if any occurs
*
* @return A new reference to this device or NULL on errror.
*/
WacomDevice* libwacom_new_from_usbid(const WacomDeviceDatabase *db, int vendor_id, int product_id, WacomError *error);
/**
* Create a new device reference from the given name.
* In case of error, NULL is returned and the error is set to the
* appropriate value.
*
* @param db A device database
* @param name The name identifying the device
* @param error If not NULL, set to the error if any occurs
*
* @return A new reference to this device or NULL on error.
*/
WacomDevice* libwacom_new_from_name(const WacomDeviceDatabase *db, const char *name, WacomError *error);
/**
* Returns the list of devices in the given database.
*
* @param db A device database
* @param error If not NULL, set to the error if any occurs
*
* @return A NULL terminated list of pointers to all the devices inside the
* database.
* The content of the list is owned by the database and should not be
* modified or freed. Use free() to free the list.
*/
WacomDevice** libwacom_list_devices_from_database(const WacomDeviceDatabase *db, WacomError *error);
/**
* Print the description of this device to the given file.
*
* @param fd The file descriptor to print to
* @param device The device to print the description for.
*/
void libwacom_print_device_description (int fd, const WacomDevice *device);
/**
* Remove the device and free all memory and references to it.
*
* @param device The device to delete
*/
void libwacom_destroy(WacomDevice *device);
/**
* Compare the two devices for equal-ness.
*
* @param a The first device
* @param b The second device
* @param flags Flags to dictate what constitutes a match
*
* @return 0 if the devices are identical, nonzero otherwise
*/
int libwacom_compare(const WacomDevice *a, const WacomDevice *b, WacomCompareFlags flags);
/**
* @param device The tablet to query
* @return The class of the device
*/
WacomClass libwacom_get_class(const WacomDevice *device);
/**
* @param device The tablet to query
* @return The human-readable name for this device
*/
const char* libwacom_get_name(const WacomDevice *device);
/**
* @param device The tablet to query
* @return The vendor-specific model name (e.g. CTE-650 for a Bamboo Fun), or NULL if none is set
*/
const char* libwacom_get_model_name(const WacomDevice *device);
/**
* @param device The tablet to query
* @return The full filename including path to the SVG layout of the device
* if available, or NULL otherwise
*/
const char* libwacom_get_layout_filename(const WacomDevice *device);
/**
* @param device The tablet to query
* @return The numeric vendor ID for this device
*
* @bug The return value is a signed int but libwacom_match_get_vendor_id()
* returns an unsigned int. This may cause compiler warnings, but the
* effective range for vendor IDs is 16-bit only anyway.
*/
int libwacom_get_vendor_id(const WacomDevice *device);
/**
* @param device The tablet to query
* @return The current match string used for this device (if set) or the first
* match string in the tablet definition.
*/
const char* libwacom_get_match(const WacomDevice *device);
/**
* @param device The tablet to query
* @return A pointer to the null-terminated list of possible matches for this device. Do not
* modify this pointer or any content!
*/
const WacomMatch** libwacom_get_matches(const WacomDevice *device);
/**
* Return the match string of the paired device for this device. A paired
* device is a device with a different match string but that shares the
* physical device with this device.
*
* If the return value is NULL, no device is paired with this device or all
* paired devices have the same WacomMatch as this device.
*
* The returned device may not be a libwacom device itself.
*
* @param device The tablet to query
* @return A pointer to paired device for this device. Do not
* modify this pointer or any content!
*/
const WacomMatch* libwacom_get_paired_device(const WacomDevice *device);
/**
* @param device The tablet to query
* @return The numeric product ID for this device
*
* @bug The return value is a signed int but libwacom_match_get_product_id()
* returns an unsigned int. This may cause compiler warning, but the
* effective range for product IDs is 16-bit only anyway.
*/
int libwacom_get_product_id(const WacomDevice *device);
/**
* Retrieve the width of the device. This is the width of the usable area as
* advertised, not the total size of the physical tablet. For e.g. an
* Intuos4 6x9 this will return 9.
*
* @param device The tablet to query
* @return The width of this device in inches
*/
int libwacom_get_width(const WacomDevice *device);
/**
* Retrieve the height of the device. This is the height of the usable area as
* advertised, not the total size of the physical tablet. For e.g. an
* Intuos4 6x9 this will return 6.
*
* @param device The tablet to query
* @return The width of this device in inches
*/
int libwacom_get_height(const WacomDevice *device);
/**
* @param device The tablet to query
* @return non-zero if the device supports styli or zero otherwise
*/
int libwacom_has_stylus(const WacomDevice *device);
/**
* @param device The tablet to query
* @return non-zero if the device supports touch or zero otherwise
*/
int libwacom_has_touch(const WacomDevice *device);
/**
* Tablet buttons are numbered 'A' through to 'A' + number of buttons.
*
* @param device The tablet to query
* @return The number of buttons on the tablet
*/
int libwacom_get_num_buttons(const WacomDevice *device);
/**
* @param device The tablet to query
* @param num_styli Return location for the number of listed styli
* @return an array of Styli IDs supported by the device
*/
const int *libwacom_get_supported_styli(const WacomDevice *device, int *num_styli);
/**
* @param device The tablet to query
* @return non-zero if the device has a touch ring or zero otherwise
*/
int libwacom_has_ring(const WacomDevice *device);
/**
* @param device The tablet to query
* @return non-zero if the device has a second touch ring or zero otherwise
*/
int libwacom_has_ring2(const WacomDevice *device);
/**
* @param device The tablet to query
* @return non-zero if the device has a touch switch or zero otherwise
*/
int libwacom_has_touchswitch(const WacomDevice *device);
/**
* @param device The tablet to query
* @return the number of modes for the touchring if it has a mode switch
*/
int libwacom_get_ring_num_modes(const WacomDevice *device);
/**
* @param device The tablet to query
* @return the number of modes for the second touchring if it has a mode switch
*/
int libwacom_get_ring2_num_modes(const WacomDevice *device);
/**
* @param device The tablet to query
* @return the number of touch strips on the tablet
* otherwise
*/
int libwacom_get_num_strips(const WacomDevice *device);
/**
* @param device The tablet to query
* @return the number of modes for each of the touchstrips if any
*/
int libwacom_get_strips_num_modes(const WacomDevice *device);
/**
* @param device The tablet to query
* @param num_leds Return location for the number of supported status LEDs
* @return an array of status LEDs supported by the device
*/
const WacomStatusLEDs *libwacom_get_status_leds(const WacomDevice *device, int *num_leds);
/**
* @param device The tablet to query
* @param button The ID of the button to check for, between 'A' and 'Z'
* @return the status LED group id to use
* or -1 if no LED is available for the given tablet / button
*/
int libwacom_get_button_led_group (const WacomDevice *device,
char button);
/**
* @param device The tablet to query
* @return non-zero if the device is built into the screen (ie a screen tablet)
* or zero if the device is an external tablet
* @deprecated 0.7 Use libwacom_get_integration_flags() instead.
*/
int libwacom_is_builtin(const WacomDevice *device) LIBWACOM_DEPRECATED;
/**
* @param device The tablet to query
* @return non-zero if the device can be used left-handed
* (rotated 180 degrees)
*/
int libwacom_is_reversible(const WacomDevice *device);
/**
* @param device The tablet to query
* @return the integration flags for the device
*/
WacomIntegrationFlags libwacom_get_integration_flags (const WacomDevice *device);
/**
* @param device The tablet to query
* @return The bustype of this device.
*/
WacomBusType libwacom_get_bustype(const WacomDevice *device);
/**
* @param device The tablet to query
* @param button The ID of the button to check for, between 'A' and 'Z'
* @return a WacomButtonFlags with information about the button
*/
WacomButtonFlags libwacom_get_button_flag(const WacomDevice *device,
char button);
/**
* @param device The tablet to query
* @param button The ID of the button to check for, between 'A' and 'Z'
* @return The evdev event code sent when the button is pressed or 0 if
* unknown.
*/
int libwacom_get_button_evdev_code(const WacomDevice *device,
char button);
/**
* Get the WacomStylus for the given tool ID.
*
* @param db A Tablet and Stylus database.
* @param id The Tool ID for this stylus
* @return A WacomStylus representing the stylus. Do not free.
*/
const WacomStylus *libwacom_stylus_get_for_id (const WacomDeviceDatabase *db, int id);
/**
* @param stylus The stylus to query
* @return the ID of the tool
*/
int libwacom_stylus_get_id (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return The name of the stylus
*/
const char *libwacom_stylus_get_name (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return The number of buttons on the stylus
*/
int libwacom_stylus_get_num_buttons (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return Whether the stylus has an eraser
*/
int libwacom_stylus_has_eraser (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return Whether the stylus is actually an eraser
*/
int libwacom_stylus_is_eraser (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return Whether the stylus has a lens
*/
int libwacom_stylus_has_lens (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return Whether the stylus has a relative mouse wheel
*/
int libwacom_stylus_has_wheel (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return The flags specifying the list of absolute axes
*/
WacomAxisTypeFlags libwacom_stylus_get_axes (const WacomStylus *stylus);
/**
* @param stylus The stylus to query
* @return The type of stylus
*/
WacomStylusType libwacom_stylus_get_type (const WacomStylus *stylus);
/**
* Print the description of this stylus to the given file.
*
* @param fd The file descriptor
* @param stylus The stylus to print the description for.
*/
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);
/** @cond hide_from_doxygen */
#endif /* _LIBWACOM_H_ */
/** @endcond */
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/libwacom/libwacom.sym 0000664 0000000 0000000 00000003723 13636474017 0021111 0 ustar 00root root 0000000 0000000 /* in alphabetical order! */
LIBWACOM_0.33 {
global:
libwacom_compare;
libwacom_database_destroy;
libwacom_database_new;
libwacom_database_new_for_path;
libwacom_destroy;
libwacom_error_free;
libwacom_error_get_code;
libwacom_error_get_message;
libwacom_error_new;
libwacom_error_set;
libwacom_get_bustype;
libwacom_get_button_evdev_code;
libwacom_get_button_flag;
libwacom_get_button_led_group;
libwacom_get_class;
libwacom_get_height;
libwacom_get_integration_flags;
libwacom_get_layout_filename;
libwacom_get_match;
libwacom_get_matches;
libwacom_get_model_name;
libwacom_get_name;
libwacom_get_num_buttons;
libwacom_get_num_strips;
libwacom_get_paired_device;
libwacom_get_product_id;
libwacom_get_ring2_num_modes;
libwacom_get_ring_num_modes;
libwacom_get_status_leds;
libwacom_get_strips_num_modes;
libwacom_get_supported_styli;
libwacom_get_vendor_id;
libwacom_get_width;
libwacom_has_ring;
libwacom_has_ring2;
libwacom_has_stylus;
libwacom_has_touch;
libwacom_has_touchswitch;
libwacom_is_builtin;
libwacom_is_reversible;
libwacom_list_devices_from_database;
libwacom_match_destroy;
libwacom_match_get_bustype;
libwacom_match_get_match_string;
libwacom_match_get_name;
libwacom_match_get_product_id;
libwacom_match_get_vendor_id;
libwacom_match_new;
libwacom_new_from_name;
libwacom_new_from_path;
libwacom_new_from_usbid;
libwacom_print_device_description;
libwacom_print_stylus_description;
libwacom_stylus_destroy;
libwacom_stylus_get_axes;
libwacom_stylus_get_for_id;
libwacom_stylus_get_id;
libwacom_stylus_get_name;
libwacom_stylus_get_num_buttons;
libwacom_stylus_get_type;
libwacom_stylus_has_eraser;
libwacom_stylus_has_lens;
libwacom_stylus_has_wheel;
libwacom_stylus_is_eraser;
libwacom_update_match;
local:
*;
};
libwacom-libwacom-1.3/libwacom/libwacomint.h 0000664 0000000 0000000 00000010156 13636474017 0021241 0 ustar 00root root 0000000 0000000 /*
* 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)
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifndef _LIBWACOMINT_H_
#define _LIBWACOMINT_H_
#include "libwacom.h"
#include
#include
#define LIBWACOM_EXPORT __attribute__ ((visibility("default")))
#define DBG(...) \
printf(__VA_ARGS__)
#define GENERIC_DEVICE_MATCH "generic"
#define WACOM_DEVICE_INTEGRATED_UNSET (WACOM_DEVICE_INTEGRATED_NONE - 1U)
enum WacomFeature {
FEATURE_STYLUS = (1 << 0),
FEATURE_TOUCH = (1 << 1),
FEATURE_RING = (1 << 2),
FEATURE_RING2 = (1 << 3),
FEATURE_REVERSIBLE = (1 << 4),
FEATURE_TOUCHSWITCH = (1 << 5)
};
/* WARNING: When adding new members to this struct
* make sure to update libwacom_copy_match() ! */
struct _WacomMatch {
gint refcnt;
char *match;
char *name;
WacomBusType bus;
uint32_t vendor_id;
uint32_t product_id;
};
/* WARNING: When adding new members to this struct
* make sure to update libwacom_copy() and
* libwacom_print_device_description() ! */
struct _WacomDevice {
char *name;
char *model_name;
int width;
int height;
int match; /* used match or first match by default */
WacomMatch **matches; /* NULL-terminated */
int nmatches; /* not counting NULL-terminated element */
WacomMatch *paired;
WacomClass cls;
int num_strips;
uint32_t features;
uint32_t integration_flags;
int strips_num_modes;
int ring_num_modes;
int ring2_num_modes;
gsize num_styli;
int *supported_styli;
int num_buttons;
WacomButtonFlags *buttons;
int *button_codes;
int num_leds;
WacomStatusLEDs *status_leds;
char *layout;
gint refcnt; /* for the db hashtable */
};
struct _WacomStylus {
gint refcnt;
int id;
char *name;
char *group;
int num_buttons;
gboolean has_eraser;
gboolean is_eraser;
gboolean has_lens;
gboolean has_wheel;
WacomStylusType type;
WacomAxisTypeFlags axes;
};
struct _WacomDeviceDatabase {
GHashTable *device_ht; /* key = DeviceMatch (str), value = WacomDeviceData * */
GHashTable *stylus_ht; /* key = ID (int), value = WacomStylus * */
};
struct _WacomError {
enum WacomErrorCode code;
char *msg;
};
WacomDevice* libwacom_ref(WacomDevice *device);
WacomDevice* libwacom_unref(WacomDevice *device);
WacomStylus* libwacom_stylus_ref(WacomStylus *stylus);
WacomStylus* libwacom_stylus_unref(WacomStylus *stylus);
WacomMatch* libwacom_match_ref(WacomMatch *match);
WacomMatch* libwacom_match_unref(WacomMatch *match);
void libwacom_error_set(WacomError *error, enum WacomErrorCode code, const char *msg, ...);
void libwacom_add_match(WacomDevice *device, WacomMatch *newmatch);
WacomMatch* libwacom_match_new(const char *name, WacomBusType bus,
int vendor_id, int product_id);
WacomBusType bus_from_str (const char *str);
const char *bus_to_str (WacomBusType bus);
char *make_match_string(const char *name, WacomBusType bus, int vendor_id, int product_id);
#define streq(s1, s2) (strcmp((s1), (s2)) == 0)
#define strneq(s1, s2, n) (strncmp((s1), (s2), (n)) == 0)
#endif /* _LIBWACOMINT_H_ */
/* vim: set noexpandtab shiftwidth=8: */
libwacom-libwacom-1.3/meson.build 0000664 0000000 0000000 00000044651 13636474017 0017134 0 ustar 00root root 0000000 0000000 project('libwacom', 'c',
version: '1.3', # change configure.ac as well
license: 'MIT/Expat',
default_options: [ 'c_std=gnu99', 'warning_level=2' ],
meson_version: '>= 0.47.0')
dir_data = join_paths(get_option('prefix'), get_option('datadir'), 'libwacom')
dir_layouts = join_paths(dir_data, 'layouts')
dir_man1 = join_paths(get_option('prefix'), get_option('mandir'), 'man1')
dir_src = join_paths(meson.source_root(), 'libwacom')
dir_test = join_paths(meson.source_root(), 'test')
dir_sys_udev= join_paths(get_option('prefix'), 'lib', 'udev')
dir_udev = get_option('udev-dir')
if dir_udev == ''
dir_udev = dir_sys_udev
endif
# Do not modify this, use symbol versioning instead.
libwacom_lt_c=8
libwacom_lt_r=1
libwacom_lt_a=6
# convert ltversion to soname
libwacom_so_version = '@0@.@1@.@2@'.format((libwacom_lt_c - libwacom_lt_a),
libwacom_lt_a, libwacom_lt_r)
# Compiler setup
cc = meson.get_compiler('c')
cflags= ['-Wno-unused-parameter',
'-fvisibility=hidden',
'-Wmissing-prototypes',
'-Wstrict-prototypes']
add_project_arguments(cflags, language: 'c')
# Dependencies
pkgconfig = import('pkgconfig')
dep_gudev = dependency('gudev-1.0')
dep_glib = dependency('glib-2.0')
dep_librsvg = dependency('librsvg-2.0', required: false)
dep_gtk2 = dependency('gtk+-2.0', required: false)
includes_include = include_directories('include')
includes_src = include_directories('libwacom')
#################### libwacom.so ########################
src_libwacom = [
'include/linux/input-event-codes.h',
'libwacom/libwacom.h',
'libwacom/libwacomint.h',
'libwacom/libwacom.c',
'libwacom/libwacom-error.c',
'libwacom/libwacom-database.c',
'libwacom/libwacom-deprecated.c',
]
deps_libwacom = [
dep_gudev,
dep_glib
]
inc_libwacom = [
includes_include,
includes_src,
]
mapfile = join_paths(dir_src, 'libwacom.sym')
version_flag = '-Wl,--version-script,@0@'.format(mapfile)
lib_libwacom = shared_library('wacom',
src_libwacom,
include_directories: inc_libwacom,
dependencies: deps_libwacom,
version: libwacom_so_version,
link_args: version_flag,
link_depends: mapfile,
c_args: [
'-DG_LOG_DOMAIN="@0@"'.format(meson.project_name()),
'-DDATADIR="@0@"'.format(dir_data),
],
install: true)
dep_libwacom = declare_dependency(link_with: lib_libwacom)
install_headers('libwacom/libwacom.h', subdir: 'libwacom-1.0/libwacom')
pkgconfig.generate(filebase: 'libwacom',
name: 'libwacom',
description: 'Wacom model feature query library',
version: meson.project_version(),
subdirs: 'libwacom-1.0',
requires_private: deps_libwacom,
libraries: lib_libwacom)
#################### data files ########################
data_files = [
# stylus data files
'data/libwacom.stylus',
# tablet data files
'data/bamboo-0fg-m-p-alt.tablet',
'data/bamboo-0fg-s-p.tablet',
'data/bamboo-0fg-s-p-alt.tablet',
'data/bamboo-2fg-fun-m-pt.tablet',
'data/bamboo-2fg-fun-s-pt.tablet',
'data/bamboo-2fg-m-p.tablet',
'data/bamboo-2fg-s-p.tablet',
'data/bamboo-2fg-s-pt.tablet',
'data/bamboo-2fg-s-t.tablet',
'data/bamboo-4fg-fun-m.tablet',
'data/bamboo-4fg-fun-s.tablet',
'data/bamboo-4fg-se-m-pt.tablet',
'data/bamboo-4fg-se-s-pt.tablet',
'data/bamboo-4fg-s-pt.tablet',
'data/bamboo-4fg-s-t.tablet',
'data/bamboo-16fg-m-pt.tablet',
'data/bamboo-16fg-s-p.tablet',
'data/bamboo-16fg-s-pt.tablet',
'data/bamboo-16fg-s-t.tablet',
'data/bamboo-one.tablet',
'data/bamboo-one-m-p.tablet',
'data/bamboo-pad.tablet',
'data/bamboo-pad-wireless.tablet',
'data/cintiq-12wx.tablet',
'data/cintiq-13hd.tablet',
'data/cintiq-13hdt.tablet',
'data/cintiq-16.tablet',
'data/cintiq-20wsx.tablet',
'data/cintiq-21ux.tablet',
'data/cintiq-21ux2.tablet',
'data/cintiq-22.tablet',
'data/cintiq-22hd.tablet',
'data/cintiq-22hdt.tablet',
'data/cintiq-24hd.tablet',
'data/cintiq-24hd-touch.tablet',
'data/cintiq-27hd.tablet',
'data/cintiq-27hdt.tablet',
'data/cintiq-companion.tablet',
'data/cintiq-companion-2.tablet',
'data/cintiq-companion-hybrid.tablet',
'data/cintiq-pro-13.tablet',
'data/cintiq-pro-16.tablet',
'data/cintiq-pro-24-p.tablet',
'data/cintiq-pro-24-pt.tablet',
'data/cintiq-pro-32.tablet',
'data/dell-canvas-27.tablet',
'data/dtf-720.tablet',
'data/dth-1152.tablet',
'data/dth-2242.tablet',
'data/dth-2452.tablet',
'data/dti-520.tablet',
'data/dtk-1651.tablet',
'data/dtk-1660e.tablet',
'data/dtk-2241.tablet',
'data/dtk-2451.tablet',
'data/dtu-1031.tablet',
'data/dtu-1031x.tablet',
'data/dtu-1141.tablet',
'data/dtu-1141b.tablet',
'data/dtu-1631.tablet',
'data/dtu-1931.tablet',
'data/dtu-2231.tablet',
'data/ek-remote.tablet',
'data/elan-22e2.tablet',
'data/elan-24db.tablet',
'data/elan-29a1.tablet',
'data/elan-29b6.tablet',
'data/elan-262b.tablet',
'data/elan-264c.tablet',
'data/elan-2072.tablet',
'data/elan-2537.tablet',
'data/elan-2627.tablet',
'data/elan-2628.tablet',
'data/elan-5515.tablet',
'data/generic.tablet',
'data/graphire2-4x5.tablet',
'data/graphire2-5x7.tablet',
'data/graphire3-4x5.tablet',
'data/graphire3-6x8.tablet',
'data/graphire4-4x5.tablet',
'data/graphire4-6x8.tablet',
'data/graphire-usb.tablet',
'data/graphire-wireless-8x6.tablet',
'data/huion-h420.tablet',
'data/huion-h610-pro.tablet',
'data/intuos2-4x5.tablet',
'data/intuos2-6x8.tablet',
'data/intuos2-9x12.tablet',
'data/intuos2-12x12.tablet',
'data/intuos2-12x18.tablet',
'data/intuos3-4x5.tablet',
'data/intuos3-4x6.tablet',
'data/intuos3-6x8.tablet',
'data/intuos3-6x11.tablet',
'data/intuos3-9x12.tablet',
'data/intuos3-12x12.tablet',
'data/intuos3-12x19.tablet',
'data/intuos4-4x6.tablet',
'data/intuos4-6x9.tablet',
'data/intuos4-6x9-wl.tablet',
'data/intuos4-8x13.tablet',
'data/intuos4-12x19.tablet',
'data/intuos5-m.tablet',
'data/intuos5-s.tablet',
'data/intuos5-touch-l.tablet',
'data/intuos5-touch-m.tablet',
'data/intuos5-touch-s.tablet',
'data/intuos-4x5.tablet',
'data/intuos-6x8.tablet',
'data/intuos-9x12.tablet',
'data/intuos-12x12.tablet',
'data/intuos-12x18.tablet',
'data/intuos-m-p.tablet',
'data/intuos-m-p2.tablet',
'data/intuos-m-p3.tablet',
'data/intuos-m-p3-android.tablet',
'data/intuos-m-p3-wl.tablet',
'data/intuos-m-p3-wl-android.tablet',
'data/intuos-m-pt.tablet',
'data/intuos-m-pt2.tablet',
'data/intuos-pro-2-l.tablet',
'data/intuos-pro-2-m.tablet',
'data/intuos-pro-2-s.tablet',
'data/intuos-pro-l.tablet',
'data/intuos-pro-m.tablet',
'data/intuos-pro-s.tablet',
'data/intuos-s-p.tablet',
'data/intuos-s-p2.tablet',
'data/intuos-s-p3.tablet',
'data/intuos-s-p3-android.tablet',
'data/intuos-s-p3-wl.tablet',
'data/intuos-s-p3-wl-android.tablet',
'data/intuos-s-pt.tablet',
'data/intuos-s-pt2.tablet',
'data/isdv4-2d1f-001e.tablet',
'data/isdv4-2d1f-002e.tablet',
'data/isdv4-10d.tablet',
'data/isdv4-10e.tablet',
'data/isdv4-10f.tablet',
'data/isdv4-12c.tablet',
'data/isdv4-48c9.tablet',
'data/isdv4-48ec.tablet',
'data/isdv4-48ed.tablet',
'data/isdv4-48ee.tablet',
'data/isdv4-50b4.tablet',
'data/isdv4-50b6.tablet',
'data/isdv4-50b8.tablet',
'data/isdv4-50db.tablet',
'data/isdv4-50e9.tablet',
'data/isdv4-50ef.tablet',
'data/isdv4-50f1.tablet',
'data/isdv4-50f8.tablet',
'data/isdv4-50fd.tablet',
'data/isdv4-51a0.tablet',
'data/isdv4-51af.tablet',
'data/isdv4-51b0.tablet',
'data/isdv4-51b1.tablet',
'data/isdv4-51b2.tablet',
'data/isdv4-51b3.tablet',
'data/isdv4-51b6.tablet',
'data/isdv4-51b7.tablet',
'data/isdv4-51b8.tablet',
'data/isdv4-51b9.tablet',
'data/isdv4-51ba.tablet',
'data/isdv4-51bb.tablet',
'data/isdv4-51bc.tablet',
'data/isdv4-51bd.tablet',
'data/isdv4-51be.tablet',
'data/isdv4-51bf.tablet',
'data/isdv4-51c4.tablet',
'data/isdv4-51e2.tablet',
'data/isdv4-51f5.tablet',
'data/isdv4-51f6.tablet',
'data/isdv4-90.tablet',
'data/isdv4-93.tablet',
'data/isdv4-100.tablet',
'data/isdv4-101.tablet',
'data/isdv4-104.tablet',
'data/isdv4-114.tablet',
'data/isdv4-116.tablet',
'data/isdv4-117.tablet',
'data/isdv4-124.tablet',
'data/isdv4-149.tablet',
'data/isdv4-481a.tablet',
'data/isdv4-484c.tablet',
'data/isdv4-485e.tablet',
'data/isdv4-486a.tablet',
'data/isdv4-488f.tablet',
'data/isdv4-502a.tablet',
'data/isdv4-503e.tablet',
'data/isdv4-503f.tablet',
'data/isdv4-504a.tablet',
'data/isdv4-509d.tablet',
'data/isdv4-509f.tablet',
'data/isdv4-513b.tablet',
'data/isdv4-515a.tablet',
'data/isdv4-516b.tablet',
'data/isdv4-517d.tablet',
'data/isdv4-521f.tablet',
'data/isdv4-4004.tablet',
'data/isdv4-4800.tablet',
'data/isdv4-4806.tablet',
'data/isdv4-4807.tablet',
'data/isdv4-4809.tablet',
'data/isdv4-4814.tablet',
'data/isdv4-4822.tablet',
'data/isdv4-4824.tablet',
'data/isdv4-4831.tablet',
'data/isdv4-4841.tablet',
'data/isdv4-4865.tablet',
'data/isdv4-4870.tablet',
'data/isdv4-4875.tablet',
'data/isdv4-5000.tablet',
'data/isdv4-5002.tablet',
'data/isdv4-5010.tablet',
'data/isdv4-5013.tablet',
'data/isdv4-5014.tablet',
'data/isdv4-5040.tablet',
'data/isdv4-5044.tablet',
'data/isdv4-5048.tablet',
'data/isdv4-5090.tablet',
'data/isdv4-5099.tablet',
'data/isdv4-5110.tablet',
'data/isdv4-5115.tablet',
'data/isdv4-5122.tablet',
'data/isdv4-5128.tablet',
'data/isdv4-5146.tablet',
'data/isdv4-5147.tablet',
'data/isdv4-5150.tablet',
'data/isdv4-5157.tablet',
'data/isdv4-5158.tablet',
'data/isdv4-5169.tablet',
'data/isdv4-5196.tablet',
'data/isdv4-5221.tablet',
'data/isdv4-5222.tablet',
'data/isdv4-e2.tablet',
'data/isdv4-e3.tablet',
'data/isdv4-e5.tablet',
'data/isdv4-e6.tablet',
'data/isdv4-ec.tablet',
'data/isdv4-ed.tablet',
'data/isdv4-ef.tablet',
'data/mobilestudio-pro-13.tablet',
'data/mobilestudio-pro-13-2.tablet',
'data/mobilestudio-pro-16.tablet',
'data/mobilestudio-pro-16-2.tablet',
'data/mobilestudio-pro-16-3.tablet',
'data/n-trig-pen.tablet',
'data/one-by-wacom-m-p.tablet',
'data/one-by-wacom-m-p2.tablet',
'data/one-by-wacom-s-p.tablet',
'data/one-by-wacom-s-p2.tablet',
'data/serial-wacf004.tablet',
'data/wacom-one.tablet',
'data/xp-pen-star03.tablet',
]
svg_files = [
'data/layouts/bamboo-0fg-s-p.svg',
'data/layouts/bamboo-0fg-s-p-alt.svg',
'data/layouts/bamboo-2fg-fun-m-pt.svg',
'data/layouts/bamboo-2fg-fun-s-pt.svg',
'data/layouts/bamboo-2fg-s-pt.svg',
'data/layouts/bamboo-2fg-s-t.svg',
'data/layouts/bamboo-4fg-fun-m-pt.svg',
'data/layouts/bamboo-4fg-fun-s-pt.svg',
'data/layouts/bamboo-4fg-se-m-pt.svg',
'data/layouts/bamboo-4fg-se-s-pt.svg',
'data/layouts/bamboo-4fg-s-pt.svg',
'data/layouts/bamboo-4fg-s-t.svg',
'data/layouts/bamboo-16fg-m-pt.svg',
'data/layouts/bamboo-16fg-s-pt.svg',
'data/layouts/bamboo-16fg-s-t.svg',
'data/layouts/bamboo-pad.svg',
'data/layouts/cintiq-12wx.svg',
'data/layouts/cintiq-13hd.svg',
'data/layouts/cintiq-20wsx.svg',
'data/layouts/cintiq-21ux.svg',
'data/layouts/cintiq-21ux2.svg',
'data/layouts/cintiq-22hd.svg',
'data/layouts/cintiq-24hd.svg',
'data/layouts/cintiq-companion.svg',
'data/layouts/cintiq-companion-2.svg',
'data/layouts/cintiq-companion-hybrid.svg',
'data/layouts/dth-2242.svg',
'data/layouts/dth-2452.svg',
'data/layouts/dti-520.svg',
'data/layouts/dtk-1651.svg',
'data/layouts/dtk-2451.svg',
'data/layouts/dtu-1031.svg',
'data/layouts/dtu-1141.svg',
'data/layouts/dtu-1141b.svg',
'data/layouts/ek-remote.svg',
'data/layouts/graphire4-4x5.svg',
'data/layouts/graphire4-6x8.svg',
'data/layouts/graphire-wireless-8x6.svg',
'data/layouts/huion-h420.svg',
'data/layouts/huion-h610-pro.svg',
'data/layouts/intuos3-4x5.svg',
'data/layouts/intuos3-4x6.svg',
'data/layouts/intuos3-6x8.svg',
'data/layouts/intuos3-6x11.svg',
'data/layouts/intuos3-9x12.svg',
'data/layouts/intuos3-12x12.svg',
'data/layouts/intuos3-12x19.svg',
'data/layouts/intuos4-4x6.svg',
'data/layouts/intuos4-6x9.svg',
'data/layouts/intuos4-6x9-wl.svg',
'data/layouts/intuos4-8x13.svg',
'data/layouts/intuos4-12x19.svg',
'data/layouts/intuos5-l.svg',
'data/layouts/intuos5-m.svg',
'data/layouts/intuos5-s.svg',
'data/layouts/intuos-m-p.svg',
'data/layouts/intuos-m-p2.svg',
'data/layouts/intuos-m-p3.svg',
'data/layouts/intuos-m-pt.svg',
'data/layouts/intuos-m-pt2.svg',
'data/layouts/intuos-pro-2-l.svg',
'data/layouts/intuos-pro-2-m.svg',
'data/layouts/intuos-pro-2-s.svg',
'data/layouts/intuos-pro-l.svg',
'data/layouts/intuos-pro-m.svg',
'data/layouts/intuos-pro-s.svg',
'data/layouts/intuos-s-p.svg',
'data/layouts/intuos-s-p2.svg',
'data/layouts/intuos-s-p3.svg',
'data/layouts/intuos-s-pt.svg',
'data/layouts/intuos-s-pt2.svg',
'data/layouts/mobilestudio-pro-13.svg',
'data/layouts/mobilestudio-pro-16.svg',
'data/layouts/xp-pen-star03.svg',
]
install_data(data_files, install_dir: dir_data)
install_data(svg_files, install_dir: dir_layouts)
test('files-in-git',
find_program('data/check-files-in-git.sh'),
args: [meson.source_root()],
suite: ['all'])
test('svg-layout-exists',
find_program('data/check-svg-exists.sh'),
args: [meson.source_root()],
suite: ['all'])
# meson requires that we specify all files one-by-one, so let's add a test
# that we can't forget about that.
test('data-files-in-meson.build',
find_program('data/check-data-in-meson.build.sh'),
args: [meson.source_root()],
suite: ['all'])
############### tools ###########################
executable('libwacom-list-local-devices',
'tools/list-local-devices.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_src],
install: true)
tools_cflags = ['-DTOPSRCDIR="@0@"'.format(meson.source_root())]
gen_udev_rules = executable('generate-udev-rules',
'tools/generate-udev-rules.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_src],
c_args: tools_cflags,
install: false)
custom_target('udev-rules',
command: gen_udev_rules,
capture: true,
output: '65-libwacom.rules',
install: true,
install_dir: join_paths(dir_udev, 'rules.d'))
executable('list-devices',
'tools/list-devices.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_src],
c_args: tools_cflags,
install: false)
executable('list-compatible-styli',
'tools/list-compatible-styli.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_src],
c_args: tools_cflags,
install: false)
if dep_gtk2.found() and dep_librsvg.found()
executable('show-svg-image',
'tools/show-svg-image.c',
dependencies: [dep_libwacom, dep_gtk2, dep_librsvg],
include_directories: [includes_src],
c_args: tools_cflags,
install: false)
endif
install_man(configure_file(input: 'tools/libwacom-list-local-devices.man',
output: '@BASENAME@.1',
copy: true))
############### docs ###########################
docs_feature = get_option('documentation')
doxygen = find_program('doxygen', required: docs_feature)
if doxygen.found()
src_doxygen = [
join_paths(dir_src, 'libwacom.h'),
]
doc_config = configuration_data()
doc_config.set('PACKAGE_NAME', meson.project_name())
doc_config.set('PACKAGE_VERSION', meson.project_version())
doc_config.set('TOPSRCDIR', meson.source_root())
doxyfile = configure_file(input: 'doc/doxygen.conf.in',
output: 'doxygen.conf',
configuration: doc_config)
custom_target('doxygen',
input: [doxyfile] + src_doxygen,
output: ['html'],
command: [doxygen, doxyfile],
install: false,
build_by_default: true)
endif
############# tests ############################
if get_option('tests').enabled()
dep_libxml = dependency('libxml-2.0', required : false)
dep_dl = meson.get_compiler('c').find_library('dl')
tests_cflags = ['-DTOPSRCDIR="@0@"'.format(meson.source_root())]
test_load = executable('test-load',
'test/test-load.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_include, includes_src],
c_args: tests_cflags,
install: false)
test('test-load', test_load, suite: ['all', 'valgrind'])
test_dbverify = executable('test-dbverify',
'test/test-dbverify.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_src],
c_args: tests_cflags,
install: false)
test('test-dbverify', test_dbverify, suite: ['all', 'valgrind'])
test_tablet_validity = executable('test-tablet-validity',
'test/test-tablet-validity.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_src],
c_args: tests_cflags,
install: false)
test('test-tablet-validity', test_tablet_validity, suite: ['all', 'valgrind'])
test_stylus_validity= executable('test-stylus-validity',
'test/test-stylus-validity.c',
dependencies: [dep_libwacom, dep_glib],
include_directories: [includes_src],
c_args: tests_cflags,
install: false)
test('test-stylus-validity', test_stylus_validity, suite: ['all', 'valgrind'])
if dep_libxml.found()
test_svg_validity = executable('test-svg-validity',
'test/test-tablet-svg-validity.c',
dependencies: [dep_libwacom, dep_libxml, dep_glib],
include_directories: [includes_src],
c_args: tests_cflags,
install: false)
test('test-svg-validity', test_svg_validity, suite: ['all', 'valgrind'])
endif
valgrind = find_program('valgrind', required : false)
if valgrind.found()
valgrind_suppressions_file = join_paths(dir_test, 'valgrind.suppressions')
add_test_setup('valgrind',
exe_wrapper: [valgrind,
'--leak-check=full',
'--gen-suppressions=all',
'--error-exitcode=3',
'--suppressions=' + valgrind_suppressions_file ],
timeout_multiplier : 100)
else
message('valgrind not found, disabling valgrind test suite')
endif
# because of the tricks we use in calling the function and exposing
# it to begin with, LTO gets confused and this fails to link.
# Let's just disable it here.
if not get_option('b_lto')
test_deprecated = executable('test-deprecated',
'test/test-deprecated.c',
dependencies: [dep_libwacom, dep_dl],
include_directories: [includes_src],
c_args: tests_cflags,
install: false)
test('test-deprecated', test_deprecated, suite: ['all'])
endif
endif
# This is a non-optional test
lt_version = '@0@:@1@:@2@'.format( libwacom_lt_c, libwacom_lt_r, libwacom_lt_a)
test_ltversion = executable('test-ltversion',
'test/test-ltversion.c',
c_args: ['-DLIBWACOM_LT_VERSION="@0@"'.format(lt_version)],
install: false)
test('test-ltversion', test_ltversion, suite: ['all'])
# vim: set noexpandtab tabstop=8 shiftwidth=8:
libwacom-libwacom-1.3/meson_options.txt 0000664 0000000 0000000 00000000605 13636474017 0020416 0 ustar 00root root 0000000 0000000 option('documentation',
type: 'feature',
value: 'auto',
description: 'Build doxygen documentation [default=auto]')
option('udev-dir',
type: 'string',
value: '',
description: 'udev base directory [default=$prefix/lib/udev]')
option('tests',
type: 'feature',
value: 'enabled',
description: 'Build the tests [default=enabled]')
libwacom-libwacom-1.3/run-full-test.sh 0000775 0000000 0000000 00000003407 13636474017 0020044 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
set -e
date=`date +"%Y-%m-%d-%H.%M.%S"`
builddir="build.$date"
echo "####################################### running test suite"
meson $builddir
ninja -C $builddir test
echo "####################################### running valgrind"
pushd $builddir > /dev/null
meson test --setup=valgrind --suite=valgrind
popd > /dev/null
echo "####################################### running ubsan"
meson configure $builddir -Db_sanitize=undefined
ninja -C $builddir test
echo "####################################### running asan"
meson configure $builddir -Db_sanitize=address
ninja -C $builddir test
echo "####################################### running scan-build"
meson configure $builddir -Db_sanitize=none
ninja -C $builddir scan-build
echo "####################################### running make distcheck"
# we can't configure with a custom sourcetree if we have run configure
# previously. So let's only do this where we have a clean tree that we can
# clone.
if git diff --exit-code -s; then
unset GIT_WORK_TREE
mkdir -p "$builddir/autotools/build"
mkdir -p "$builddir/autotools/inst"
pushd "$builddir/autotools" > /dev/null
git clone ../.. "src"
pushd src > /dev/null
autoreconf -ivf
popd
pushd build > /dev/null
../src/configure --prefix=$PWD/../inst/
make && make check
make install
make distcheck
echo "############### running meson off tarball"
mkdir -p _tarball_dir
tar xf libwacom-*.tar.bz2 -C _tarball_dir
pushd _tarball_dir/libwacom-*/ > /dev/null
meson $builddir && ninja -C $builddir test
popd > /dev/null
popd > /dev/null
popd > /dev/null
else
echo "local changes present, skipping make distcheck"
fi
echo "######## Success. Removing builddir #########"
rm -rf "$buildir"
libwacom-libwacom-1.3/test/ 0000775 0000000 0000000 00000000000 13636474017 0015737 5 ustar 00root root 0000000 0000000 libwacom-libwacom-1.3/test/Makefile.am 0000664 0000000 0000000 00000003453 13636474017 0020000 0 ustar 00root root 0000000 0000000 noinst_PROGRAMS= \
test-load \
test-dbverify \
test-tablet-validity \
test-stylus-validity \
test-ltversion \
test-deprecated \
$(NULL)
TESTS=$(noinst_PROGRAMS)
AM_CPPFLAGS= \
-I$(top_srcdir)/libwacom \
-I$(top_srcdir)/include \
-DTOPSRCDIR="\"$(abs_top_srcdir)\""
test_load_SOURCES = test-load.c
test_load_LDADD=$(top_builddir)/libwacom/libwacom.la $(GLIB_LIBS)
test_load_LDFLAGS = -no-install
test_load_CFLAGS=$(AM_CFLAGS) $(GLIB_CFLAGS)
test_dbverify_SOURCES = test-dbverify.c
test_dbverify_LDADD=$(top_builddir)/libwacom/libwacom.la $(GLIB_LIBS)
test_dbverify_LDFLAGS = -no-install
test_dbverify_CFLAGS=$(AM_CFLAGS) $(GLIB_CFLAGS)
test_tablet_validity_SOURCES = test-tablet-validity.c
test_tablet_validity_LDADD=$(top_builddir)/libwacom/libwacom.la $(GLIB_LIBS)
test_tablet_validity_LDFLAGS = -no-install
test_tablet_validity_CFLAGS = $(AM_CFLAGS) $(GLIB_CFLAGS)
test_stylus_validity_SOURCES = test-stylus-validity.c
test_stylus_validity_LDADD=$(top_builddir)/libwacom/libwacom.la $(GLIB_LIBS)
test_stylus_validity_LDFLAGS = -no-install
test_stylus_validity_CFLAGS = $(AM_CFLAGS) $(GLIB_CFLAGS)
test_ltversion_SOURCES = test-ltversion.c
test_ltversion_CFLAGS = $(AM_CFLAGS) -DLIBWACOM_LT_VERSION="\"$(LIBWACOM_LT_VERSION)\""
test_deprecated_SOURCES = test-deprecated.c
test_deprecated_LDADD=$(top_builddir)/libwacom/libwacom.la $(DL_LIBS)
test_deprecated_LDFLAGS = -no-install
if HAVE_LIBXML
noinst_PROGRAMS += test-tablet-svg-validity
test_tablet_svg_validity_SOURCES = test-tablet-svg-validity.c
test_tablet_svg_validity_LDADD = $(top_builddir)/libwacom/libwacom.la $(LIBXML_LIBS)
test_tablet_svg_validity_LDFLAGS = -no-install
test_tablet_svg_validity_CFLAGS = $(LIBXML_CFLAGS)
endif
clean-local: clean-local-check
.PHONY: clean-local-check
clean-local-check:
rm -rf tmp.dbverify.*
libwacom-libwacom-1.3/test/test-dbverify.c 0000664 0000000 0000000 00000014221 13636474017 0020672 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2012 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)
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include "libwacom.h"
#include
static WacomDeviceDatabase *db_old;
static WacomDeviceDatabase *db_new;
static int
scandir_filter(const struct dirent *entry)
{
return strncmp(entry->d_name, ".", 1);
}
static void
rmtmpdir(const char *dir)
{
int nfiles;
struct dirent **files;
char *path = NULL;
nfiles = scandir(dir, &files, scandir_filter, alphasort);
while(nfiles--)
{
g_assert(asprintf(&path, "%s/%s", dir, files[nfiles]->d_name) != -1);
g_assert(path);
g_assert(remove(path) != -1);
free(files[nfiles]);
free(path);
path = NULL;
}
free(files);
g_assert(remove(dir) != -1);
}
static void
find_matching(gconstpointer data)
{
WacomDevice **devs_old, **devs_new;
WacomDevice **devices, **d;
WacomDevice *other;
gboolean found = FALSE;
int index = GPOINTER_TO_INT(data);
devs_old = libwacom_list_devices_from_database(db_old, NULL);
devs_new = libwacom_list_devices_from_database(db_new, NULL);
/* Make sure each device in old has a device in new */
devices = devs_old;
other = devs_new[index];
for (d = devices; *d; d++) {
if (libwacom_compare(other, *d, WCOMPARE_MATCHES) == 0) {
found = TRUE;
break;
}
}
g_assert_true(found);
/* Make sure each device in new has a device in old */
devices = devs_new;
other = devs_old[index];
found = FALSE;
for (d = devices; *d; d++) {
/* devices with multiple matches will have multiple
* devices in the list */
if (libwacom_compare(other, *d, WCOMPARE_MATCHES) == 0) {
found = TRUE;
break;
}
}
g_assert_true(found);
free(devs_old);
free(devs_new);
}
static void
test_database_size(void)
{
int sz1, sz2;
WacomDevice **d1, **d2;
d1 = libwacom_list_devices_from_database(db_old, NULL);
d2 = libwacom_list_devices_from_database(db_new, NULL);
g_assert_nonnull(d1);
g_assert_nonnull(d2);
sz1 = 0;
for (WacomDevice **d = d1; *d; d++)
sz1++;
sz2 = 0;
for (WacomDevice **d = d2; *d; d++)
sz2++;
g_assert_cmpint(sz1, ==, sz2);
free(d1);
free(d2);
}
static int
compare_databases(WacomDeviceDatabase *orig, WacomDeviceDatabase *new)
{
int i, rc;
WacomDevice **devs_new, **n;
g_test_add_func("/dbverify/database-sizes", test_database_size);
devs_new = libwacom_list_devices_from_database(new, NULL);
for (n = devs_new, i = 0 ; *n; n++, i++)
{
char buf[1024];
/* We need to add the test index to avoid duplicate
test names */
snprintf(buf, sizeof(buf), "/dbverify/%03d/%04x:%04x-%s",
i,
libwacom_get_vendor_id(*n),
libwacom_get_product_id(*n),
libwacom_get_name(*n));
g_test_add_data_func(buf, GINT_TO_POINTER(i), find_matching);
}
rc = g_test_run();
free(devs_new);
return rc;
}
/* write out the current db, read it back in, compare */
static void
duplicate_database(WacomDeviceDatabase *db, const char *dirname)
{
WacomDevice **device, **devices;
int i;
devices = libwacom_list_devices_from_database(db, NULL);
g_assert(devices);
g_assert(*devices);
for (device = devices, i = 0; *device; device++, i++) {
int i;
int fd;
char *path = NULL;
int nstyli;
const int *styli;
g_assert(asprintf(&path, "%s/%s.tablet", dirname,
libwacom_get_match(*device)) != -1);
g_assert(path);
fd = open(path, O_WRONLY|O_CREAT, S_IRWXU);
g_assert(fd >= 0);
libwacom_print_device_description(fd, *device);
close(fd);
free(path);
if (!libwacom_has_stylus(*device))
continue;
styli = libwacom_get_supported_styli(*device, &nstyli);
for (i = 0; i < nstyli; i++) {
int fd_stylus;
const WacomStylus *stylus;
g_assert(asprintf(&path, "%s/%#x.stylus", dirname, styli[i]) != -1);
stylus = libwacom_stylus_get_for_id(db, styli[i]);
g_assert(stylus);
fd_stylus = open(path, O_WRONLY|O_CREAT, S_IRWXU);
g_assert(fd_stylus >= 0);
libwacom_print_stylus_description(fd_stylus, stylus);
close(fd_stylus);
free(path);
}
}
free(devices);
}
static WacomDeviceDatabase *
load_database(void)
{
WacomDeviceDatabase *db;
const char *datadir;
datadir = getenv("LIBWACOM_DATA_DIR");
if (!datadir)
datadir = TOPSRCDIR"/data";
db = libwacom_database_new_for_path(datadir);
if (!db)
printf("Failed to load data from %s", datadir);
g_assert(db);
return db;
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
char *dirname;
int rc;
g_test_init(&argc, &argv, NULL);
g_test_set_nonfatal_assertions();
db = load_database();
dirname = strdup("tmp.dbverify.XXXXXX");
g_assert(mkdtemp(dirname)); /* just check for non-null to avoid
Coverity complaints */
duplicate_database(db, dirname);
db_new = libwacom_database_new_for_path(dirname);
g_assert(db_new);
db_old = db;
rc = compare_databases(db_old, db_new);
libwacom_database_destroy(db_new);
libwacom_database_destroy(db_old);
rmtmpdir(dirname);
free(dirname);
return rc;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/test/test-deprecated.c 0000664 0000000 0000000 00000005656 13636474017 0021174 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2019 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.
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include
#include
#include "libwacom.h"
/**
* The normal symbols are hidden now when linking against a new library.
* We know which version they're in though so we can remap them for this
* test - if we get an unresolved symbol something has gone wrong.
*/
asm(".symver libwacom_match_destroy,libwacom_match_destroy@LIBWACOM_0.33");
asm(".symver libwacom_match_new,libwacom_match_new@LIBWACOM_0.33");
asm(".symver libwacom_error_set,libwacom_error_set@LIBWACOM_0.33");
asm(".symver libwacom_update_match,libwacom_update_match@LIBWACOM_0.33");
asm(".symver libwacom_stylus_destroy,libwacom_stylus_destroy@LIBWACOM_0.33");
/* Only generally matches the real functions, but since they're all noops
* anyway it doesn't matter that we only have generic pointers. The basic
* signatures are the same.
*/
extern void libwacom_match_destroy(void*);
void* libwacom_match_new(void *, int, int, int);
void libwacom_error_set(void *error, int, char *, ...);
void libwacom_stylus_destroy(void *);
void libwacom_update_match(void *, const void *);
int main(void) {
const char *syms[] = {
"libwacom_match_destroy",
"libwacom_match_new",
"libwacom_error_set",
"libwacom_update_match",
"libwacom_stylus_destroy",
NULL,
};
void *lib, *sym;
lib = dlopen("libwacom.so", RTLD_LAZY);
assert(lib != NULL);
for (const char **s = syms; *s; s++) {
sym = dlsym(lib, *s);
assert(sym == NULL);
}
/* These are all noops, so all we're looking for is not getting a linker
* error */
libwacom_match_destroy(NULL);
libwacom_match_new(NULL, 0, 0, 0);
libwacom_error_set(NULL, 0, NULL);
libwacom_stylus_destroy(NULL);
libwacom_update_match(NULL, NULL);
return 0;
}
libwacom-libwacom-1.3/test/test-load.c 0000664 0000000 0000000 00000021722 13636474017 0020003 0 ustar 00root root 0000000 0000000 /*
* 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)
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include
#include
#include
#include "libwacom.h"
struct fixture {
WacomDeviceDatabase *db;
};
static WacomDeviceDatabase *
load_database(void)
{
WacomDeviceDatabase *db;
const char *datadir;
datadir = getenv("LIBWACOM_DATA_DIR");
if (!datadir)
datadir = TOPSRCDIR"/data";
db = libwacom_database_new_for_path(datadir);
if (!db)
printf("Failed to load data from %s", datadir);
g_assert(db);
return db;
}
static void
fixture_setup(struct fixture *f, gconstpointer user_data)
{
f->db = load_database();
}
static void
fixture_teardown(struct fixture *f, gconstpointer user_data)
{
libwacom_database_destroy(f->db);
}
static void check_multiple_match(WacomDevice *device)
{
const WacomMatch **match;
int nmatches = 0;
int found_bus = 0,
found_vendor_id = 0,
found_product_id = 0;
for (match = libwacom_get_matches(device); *match; match++)
{
nmatches++;
if (libwacom_match_get_bustype(*match) == libwacom_get_bustype(device))
found_bus = 1;
if ((int)libwacom_match_get_vendor_id(*match) == libwacom_get_vendor_id(device))
found_vendor_id = 1;
if ((int)libwacom_match_get_product_id(*match) == libwacom_get_product_id(device))
found_product_id = 1;
}
g_assert_cmpint(nmatches, ==, 2);
g_assert_true(found_bus);
g_assert_true(found_vendor_id);
g_assert_true(found_product_id);
}
static void
test_invalid_device(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_usbid(f->db, 0, 0, NULL);
g_assert_null(device);
}
static void
test_intuos4(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_usbid(f->db, 0x56a, 0x00bc, NULL);
g_assert_nonnull(device);
g_assert_cmpstr(libwacom_get_name(device), ==, "Wacom Intuos4 WL");
g_assert_cmpint(libwacom_get_class(device), ==, WCLASS_INTUOS4);
g_assert_cmpint(libwacom_get_vendor_id(device), ==, 0x56a);
g_assert_cmpint(libwacom_get_product_id(device), ==, 0xbc);
g_assert_cmpint(libwacom_get_bustype(device), ==, WBUSTYPE_USB);
g_assert_cmpint(libwacom_get_num_buttons(device), ==, 9);
g_assert_true(libwacom_has_stylus(device));
g_assert_true(libwacom_is_reversible(device));
g_assert_false(libwacom_has_touch(device));
g_assert_true(libwacom_has_ring(device));
g_assert_false(libwacom_has_ring2(device));
g_assert_false(libwacom_has_touchswitch(device));
g_assert_cmpint(libwacom_get_num_strips(device), ==, 0);
g_assert_cmpint(libwacom_get_integration_flags (device), ==, WACOM_DEVICE_INTEGRATED_NONE);
g_assert_cmpint(libwacom_get_width(device), ==, 8);
g_assert_cmpint(libwacom_get_height(device), ==, 5);
check_multiple_match(device);
libwacom_destroy(device);
}
static void
test_intuos4_wl(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_usbid(f->db, 0x56a, 0x00b9, NULL);
g_assert_nonnull(device);
g_assert_true(libwacom_get_button_flag(device, 'A') & WACOM_BUTTON_RING_MODESWITCH);
g_assert_true(libwacom_get_button_flag(device, 'I') & WACOM_BUTTON_OLED);
#if 0
/* disabled - needs subprocesses testing but invalid data handling
is better handled in a separate test suite */
/*
* I4 WL has only 9 buttons, asking for a 10th button will raise a warning
* in libwacom_get_button_flag() which is expected.
*/
printf("Following critical warning in libwacom_get_button_flag() is expected\n");
g_assert_cmpint(libwacom_get_button_flag(device, 'J'), ==, WACOM_BUTTON_NONE);
#endif
g_assert_cmpint(libwacom_get_ring_num_modes(device), ==, 4);
libwacom_destroy(device);
}
static void
test_cintiq24hd(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_usbid(f->db, 0x56a, 0x00f4, NULL);
g_assert_nonnull(device);
g_assert_cmpint(libwacom_get_ring_num_modes(device), ==, 3);
g_assert_cmpint(libwacom_get_ring2_num_modes(device), ==, 3);
libwacom_destroy(device);
}
static void
test_cintiq21ux(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_usbid(f->db, 0x56a, 0x00cc, NULL);
g_assert_nonnull(device);
g_assert_cmpint(libwacom_get_num_strips(device), ==, 2);
libwacom_destroy(device);
}
static void
test_wacf004(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_name(f->db, "Wacom Serial Tablet WACf004", NULL);
g_assert_nonnull(device);
g_assert_true(libwacom_get_integration_flags(device) & WACOM_DEVICE_INTEGRATED_DISPLAY);
g_assert_true(libwacom_get_integration_flags(device) & WACOM_DEVICE_INTEGRATED_SYSTEM);
g_assert_null(libwacom_get_model_name(device));
libwacom_destroy(device);
}
static void
test_cintiq24hdt(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_usbid(f->db, 0x56a, 0x00f8, NULL);
const WacomMatch *match;
g_assert_nonnull(device);
/* 24HDT has one paired device */
match = libwacom_get_paired_device(device);
g_assert_nonnull(match);
g_assert_cmpint(libwacom_match_get_vendor_id(match), ==, 0x56a);
g_assert_cmpint(libwacom_match_get_product_id(match), ==, 0xf6);
g_assert_cmpint(libwacom_match_get_bustype(match), ==, WBUSTYPE_USB);
libwacom_destroy(device);
}
static void
test_cintiq13hd(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_name(f->db, "Wacom Cintiq 13HD", NULL);
g_assert_nonnull(device);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'A'), ==, BTN_0);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'B'), ==, BTN_1);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'C'), ==, BTN_2);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'D'), ==, BTN_3);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'E'), ==, BTN_4);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'F'), ==, BTN_5);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'G'), ==, BTN_6);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'H'), ==, BTN_7);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'I'), ==, BTN_8);
g_assert_cmpstr(libwacom_get_model_name(device), ==, "DTK-1300");
libwacom_destroy(device);
}
static void
test_bamboopen(struct fixture *f, gconstpointer user_data)
{
WacomDevice *device = libwacom_new_from_name(f->db, "Wacom Bamboo Pen", NULL);
g_assert_nonnull(device);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'A'), ==, BTN_BACK);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'B'), ==, BTN_FORWARD);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'C'), ==, BTN_LEFT);
g_assert_cmpint(libwacom_get_button_evdev_code(device, 'D'), ==, BTN_RIGHT);
g_assert_cmpstr(libwacom_get_model_name(device), ==, "MTE-450");
libwacom_destroy(device);
}
int main(int argc, char **argv)
{
g_test_init(&argc, &argv, NULL);
g_test_set_nonfatal_assertions();
g_test_add("/load/0000:0000", struct fixture, NULL,
fixture_setup, test_invalid_device,
fixture_teardown);
g_test_add("/load/056a:00bc", struct fixture, NULL,
fixture_setup, test_intuos4,
fixture_teardown);
g_test_add("/load/056a:00b8", struct fixture, NULL,
fixture_setup, test_intuos4_wl,
fixture_teardown);
g_test_add("/load/056a:00f4", struct fixture, NULL,
fixture_setup, test_cintiq24hd,
fixture_teardown);
g_test_add("/load/056a:00cc", struct fixture, NULL,
fixture_setup, test_cintiq21ux,
fixture_teardown);
g_test_add("/load/056a:00f8", struct fixture, NULL,
fixture_setup, test_cintiq24hdt,
fixture_teardown);
g_test_add("/load/056a:0304", struct fixture, NULL,
fixture_setup, test_cintiq13hd,
fixture_teardown);
g_test_add("/load/056a:0065", struct fixture, NULL,
fixture_setup, test_bamboopen,
fixture_teardown);
g_test_add("/load/056a:WACf004", struct fixture, NULL,
fixture_setup, test_wacf004,
fixture_teardown);
return g_test_run();
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/test/test-ltversion.c 0000664 0000000 0000000 00000000662 13636474017 0021111 0 ustar 00root root 0000000 0000000 #include
#include
int main(void) {
const char *version = LIBWACOM_LT_VERSION;
int C, R, A;
int rc;
rc = sscanf(version, "%d:%d:%d", &C, &R, &A);
assert(rc == 3);
/* we don't change the soname anymore, we use symbol maps instead.
So these can stay fixed until we properly break the ABI and bump
the soname. */
assert(C == 8);
assert(R == 1);
assert(A == 6);
return 0;
}
libwacom-libwacom-1.3/test/test-stylus-validity.c 0000664 0000000 0000000 00000021371 13636474017 0022252 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2019 Red Hat, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software
udo y 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include "libwacom.h"
#include
static const WacomStylus **all_styli;
static void
test_type(gconstpointer data)
{
const WacomStylus *stylus = data;
switch (libwacom_stylus_get_type(stylus)) {
case WSTYLUS_GENERAL:
case WSTYLUS_INKING:
case WSTYLUS_AIRBRUSH:
case WSTYLUS_CLASSIC:
case WSTYLUS_MARKER:
case WSTYLUS_STROKE:
case WSTYLUS_PUCK:
case WSTYLUS_3D:
break;
case WSTYLUS_UNKNOWN:
default:
g_test_fail();
}
}
static void
test_eraser(gconstpointer data)
{
const WacomStylus *stylus = data;
WacomStylusType type;
gboolean matching_eraser_found = FALSE;
/* A stylus cannot be an eraser and have an eraser at the same time */
g_assert_true(libwacom_stylus_has_eraser(stylus));
g_assert_false(libwacom_stylus_is_eraser(stylus));
/* Search for another stylus with the same type as ours that is an
eraser.
FIXME: This is imprecise. Multiple pens share the same type but
we are happy with the first eraser of that type we find. So once
we have an eraser for each type, this will always be true, even if
we forget to add the right eraser for a new pen.
*/
type = libwacom_stylus_get_type (stylus);
for (const WacomStylus **s = all_styli; *s; s++) {
if (libwacom_stylus_is_eraser(*s) &&
libwacom_stylus_get_type(*s) == type) {
matching_eraser_found = TRUE;
break;
}
}
g_assert_true(matching_eraser_found);
}
static void
test_puck(gconstpointer data)
{
const WacomStylus *stylus = data;
int has_wheel = libwacom_stylus_has_wheel(stylus);
int has_lens = libwacom_stylus_has_lens(stylus);
/* 4D mouse is the only one with neither, everything
* else has either wheel or lens */
if (libwacom_stylus_get_id(stylus) == 0x94) {
g_assert_false(has_wheel);
g_assert_false(has_lens);
} else {
g_assert_true(has_wheel != has_lens);
}
}
static void
test_tilt(gconstpointer data)
{
const WacomStylus *stylus = data;
gboolean has_tilt = libwacom_stylus_get_axes(stylus) & WACOM_AXIS_TYPE_TILT;
g_assert_true(has_tilt);
}
static void
test_no_tilt(gconstpointer data)
{
const WacomStylus *stylus = data;
gboolean has_tilt = libwacom_stylus_get_axes(stylus) & WACOM_AXIS_TYPE_TILT;
g_assert_false(has_tilt);
}
static void
test_pressure(gconstpointer data)
{
const WacomStylus *stylus = data;
gboolean has_pressure = libwacom_stylus_get_axes(stylus) & WACOM_AXIS_TYPE_PRESSURE;
g_assert_true(has_pressure);
}
static void
test_no_pressure(gconstpointer data)
{
const WacomStylus *stylus = data;
gboolean has_pressure = libwacom_stylus_get_axes(stylus) & WACOM_AXIS_TYPE_PRESSURE;
g_assert_false(has_pressure);
}
static void
test_distance(gconstpointer data)
{
const WacomStylus *stylus = data;
gboolean has_distance = libwacom_stylus_get_axes(stylus) & WACOM_AXIS_TYPE_DISTANCE;
g_assert_true(has_distance);
}
static void
test_no_distance(gconstpointer data)
{
const WacomStylus *stylus = data;
gboolean has_distance = libwacom_stylus_get_axes(stylus) & WACOM_AXIS_TYPE_DISTANCE;
g_assert_false(has_distance);
}
static void
test_name(gconstpointer data)
{
const WacomStylus *stylus = data;
g_assert_nonnull(libwacom_stylus_get_name(stylus));
}
static void
test_buttons(gconstpointer data)
{
const WacomStylus *stylus = data;
g_assert_cmpint(libwacom_stylus_get_num_buttons(stylus), >, 0);
}
static void
test_no_buttons(gconstpointer data)
{
const WacomStylus *stylus = data;
g_assert_cmpint(libwacom_stylus_get_num_buttons(stylus), ==, 0);
}
/* Wrapper function to make adding tests simpler. g_test requires
* a unique test case name so we assemble that from the test function and
* the stylus data.
*/
static inline void
_add_test(const WacomStylus *stylus, GTestDataFunc func, const char *funcname)
{
char buf[128];
const char *prefix;
/* tests must be test_foobar */
g_assert(strncmp(funcname, "test_", 5) == 0);
prefix = &funcname[5];
snprintf(buf, 128, "/stylus/%s/%03x-%s",
prefix,
libwacom_stylus_get_id(stylus),
libwacom_stylus_get_name(stylus));
g_test_add_data_func(buf, stylus, func);
}
#define add_test(stylus, func_) \
_add_test(stylus, func_, #func_)
static void
setup_tests(const WacomStylus *stylus)
{
add_test(stylus, test_name);
add_test(stylus, test_type);
/* Button checks */
switch (libwacom_stylus_get_type(stylus)) {
case WSTYLUS_PUCK:
add_test(stylus, test_puck);
add_test(stylus, test_buttons);
break;
case WSTYLUS_INKING:
case WSTYLUS_STROKE:
add_test(stylus, test_no_buttons);
break;
default:
switch (libwacom_stylus_get_id(stylus)) {
case 0x885:
add_test(stylus, test_no_buttons);
break;
default:
add_test(stylus, test_buttons);
}
}
/* Axes checks */
switch (libwacom_stylus_get_id(stylus)) {
case 0xffffd:
add_test(stylus, test_pressure);
add_test(stylus, test_no_distance);
add_test(stylus, test_no_tilt);
break;
case 0x006:
case 0x096:
case 0x097:
add_test(stylus, test_no_pressure);
add_test(stylus, test_distance);
add_test(stylus, test_no_tilt);
break;
case 0x007:
case 0x017:
case 0x094:
case 0x806:
add_test(stylus, test_no_pressure);
add_test(stylus, test_distance);
add_test(stylus, test_tilt);
break;
case 0x021:
case 0x8e2:
case 0x862:
add_test(stylus, test_pressure);
add_test(stylus, test_distance);
add_test(stylus, test_no_tilt);
break;
default:
add_test(stylus, test_pressure);
add_test(stylus, test_tilt);
add_test(stylus, test_distance);
break;
}
if (libwacom_stylus_has_eraser(stylus))
add_test(stylus, test_eraser);
}
/**
* Return a NULL-terminated list of all styli.
*
* libwacom only gives us the styli per-device so this is a bit more
* complicated than it should be.
*/
static const WacomStylus **
assemble_styli(WacomDeviceDatabase *db)
{
WacomDevice **devices = libwacom_list_devices_from_database(db, NULL);
const WacomStylus **styli;
int *ids = NULL;
int nids = 0;
int sz = 0;
g_assert(devices);
for (WacomDevice **d = devices; *d; d++) {
const int *styli;
int nstyli;
styli = libwacom_get_supported_styli(*d, &nstyli);
/* Make sure our array is large enough to accommodate for
all new styli. Simpler than reallocing after every entry */
if (nstyli > sz - nids) {
sz = nids + nstyli;
ids = realloc(ids, sz * sizeof(*ids));
g_assert(ids);
}
/* For each stylus in the current device, add it to ids[] if
it's not already in there */
for (int i = 0; i < nstyli; i++) {
gboolean found = FALSE;
for (int j = 0; j < nids && !found; j++) {
if (ids[j] == styli[i])
found = TRUE;
}
if (!found)
ids[nids++] = styli[i];
}
}
styli = calloc(nids + 1, sizeof(*styli));
for (int i = 0; i < nids; i++) {
styli[i] = libwacom_stylus_get_for_id (db, ids[i]);
g_assert(styli[i]);
}
free(devices);
free(ids);
return styli;
}
static WacomDeviceDatabase *
load_database(void)
{
WacomDeviceDatabase *db;
const char *datadir;
datadir = getenv("LIBWACOM_DATA_DIR");
if (!datadir)
datadir = TOPSRCDIR"/data";
db = libwacom_database_new_for_path(datadir);
if (!db)
printf("Failed to load data from %s", datadir);
g_assert(db);
return db;
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
int rc;
g_test_init(&argc, &argv, NULL);
g_test_set_nonfatal_assertions();
db = load_database();
all_styli = assemble_styli(db);
for (const WacomStylus **s = all_styli; *s; s++)
setup_tests(*s);
rc = g_test_run();
free(all_styli);
libwacom_database_destroy (db);
return rc;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/test/test-tablet-svg-validity.c 0000664 0000000 0000000 00000023774 13636474017 0022770 0 ustar 00root root 0000000 0000000 /*
* Copyright ?? 2012 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:
* Olivier Fourdan
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include
#include
#include
#include
#include
#include
#include
#include "libwacom.h"
static xmlNodePtr
verify_has_sub (xmlNodePtr cur, char *sub)
{
cur = cur->xmlChildrenNode;
while (cur != NULL) {
xmlChar *prop;
/* Descend the tree if dealing with a group */
if (xmlStrcmp(cur->name, (const xmlChar *) "g") == 0) {
xmlNodePtr sub_node;
sub_node = verify_has_sub (cur, sub);
if (sub_node != NULL)
return sub_node;
}
prop = xmlGetProp(cur, (xmlChar *) "id");
if (prop) {
int status = xmlStrcmp(prop, (const xmlChar *) sub);
xmlFree(prop);
if (status == 0)
return cur;
}
cur = cur->next;
}
return NULL;
}
static gboolean
class_found (gchar **classes, gchar *value)
{
gchar **ptr = classes;
while (*ptr) {
if (strcmp (*ptr++, value) == 0)
return TRUE;
}
return FALSE;
}
static void
verify_has_class (xmlNodePtr cur, const gchar *expected)
{
xmlChar *prop;
gchar **classes_present;
gchar **classes_expected;
gchar **ptr;
prop = xmlGetProp (cur, (xmlChar *) "class");
g_assert (prop != NULL);
g_assert (strlen((const char *) prop) > 0);
classes_present = g_strsplit ((const gchar *) prop, " ", -1);
classes_expected = g_strsplit (expected, " ", -1);
ptr = classes_expected;
while (*ptr)
g_assert (class_found (classes_present, *ptr++));
g_strfreev (classes_present);
g_strfreev (classes_expected);
xmlFree (prop);
}
static void
check_button (xmlNodePtr cur, const WacomDevice *device, char button, gchar *type)
{
char *sub;
char *class;
xmlNodePtr node;
WacomButtonFlags flags;
/* Check ID */
sub = g_strdup_printf ("%s%c", type, button);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
/* Check class */
flags = libwacom_get_button_flag(device, button);
if (flags & WACOM_BUTTON_MODESWITCH)
class = g_strdup_printf ("%c ModeSwitch %s", button, type);
else
class = g_strdup_printf ("%c %s", button, type);
verify_has_class (node, class);
g_free (class);
}
static void
check_touchstrip (xmlNodePtr cur, gchar *id)
{
char *sub;
char *class;
xmlNodePtr node;
node = verify_has_sub (cur, id);
g_assert (node != NULL);
class = g_strdup_printf ("%s %s", id, "TouchStrip");
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Label%sUp", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sUp %s Label", id, id);
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Label%sDown", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sDown %s Label", id, id);
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Leader%sUp", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sUp %s Leader", id, id);
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Leader%sDown", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sDown %s Leader", id, id);
verify_has_class (node, class);
g_free (class);
}
static void
check_touchring (xmlNodePtr cur, gchar *id)
{
char *sub;
char *class;
xmlNodePtr node;
node = verify_has_sub (cur, id);
g_assert (node != NULL);
class = g_strdup_printf ("%s %s", id, "TouchRing");
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Label%sCCW", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sCCW %s Label", id, id);
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Label%sCW", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sCW %s Label", id, id);
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Leader%sCCW", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sCCW %s Leader", id, id);
verify_has_class (node, class);
g_free (class);
sub = g_strdup_printf ("Leader%sCW", id);
node = verify_has_sub (cur, sub);
g_assert (node != NULL);
g_free (sub);
class = g_strdup_printf ("%sCW %s Leader", id, id);
verify_has_class (node, class);
g_free (class);
}
struct fixture {
xmlDocPtr doc;
xmlNodePtr root;
};
static void
test_filename(struct fixture *f, gconstpointer data)
{
const WacomDevice *device = data;
const char *filename;
filename = libwacom_get_layout_filename(device);
if (libwacom_get_num_buttons(device) > 0) {
g_assert_nonnull(filename);
g_assert_cmpstr(filename, !=, "");
}
}
static void
test_svg(struct fixture *f, gconstpointer data)
{
g_assert_nonnull(f->doc);
g_assert_nonnull(f->root);
g_assert_cmpint(xmlStrcmp(f->root->name, (const xmlChar*) "svg"), ==, 0);
}
static void
test_dimensions(struct fixture *f, gconstpointer data)
{
xmlChar *prop;
/* width is provided */
prop = xmlGetProp(f->root, (xmlChar *) "width") ;
g_assert_nonnull(prop);
xmlFree(prop);
/* height is provided */
prop = xmlGetProp(f->root, (xmlChar *) "height") ;
g_assert_nonnull(prop);
xmlFree(prop);
}
static void
test_rings(struct fixture *f, gconstpointer data)
{
const WacomDevice *device = data;
if (libwacom_has_ring(device))
check_touchring(f->root, "Ring");
if (libwacom_has_ring2(device))
check_touchring(f->root, "Ring2");
}
static void
test_strips(struct fixture *f, gconstpointer data)
{
const WacomDevice *device = data;
if (libwacom_get_num_strips(device) > 0)
check_touchstrip(f->root, "Strip");
if (libwacom_get_num_strips(device) > 1)
check_touchstrip(f->root, "Strip2");
}
static void
test_buttons(struct fixture *f, gconstpointer data)
{
const WacomDevice *device = data;
int num_buttons = libwacom_get_num_buttons (device);
for (char button = 'A'; button < 'A' + num_buttons; button++) {
check_button(f->root, device, button, "Button");
check_button(f->root, device, button, "Label");
check_button(f->root, device, button, "Leader");
}
}
static void
setup_svg(struct fixture *f, gconstpointer data)
{
const WacomDevice *device = data;
const char *filename = libwacom_get_layout_filename(device);
xmlDocPtr doc;
if (!filename)
return;
doc = xmlParseFile(filename);
f->doc = doc;
f->root = doc ? xmlDocGetRootElement(doc) : NULL;
}
static void
teardown_svg(struct fixture *f, gconstpointer data)
{
if (f->doc)
xmlFreeDoc(f->doc);
}
typedef void (*testfunc)(struct fixture *f, gconstpointer d);
/* Wrapper function to make adding tests simpler. g_test requires
* a unique test case name so we assemble that from the test function and
* the tablet data.
*/
static inline void
_add_test(WacomDevice *device, testfunc func, const char *funcname)
{
char buf[128];
static int count; /* guarantee unique test case names */
const char *prefix;
/* tests must be test_foobar */
g_assert(strncmp(funcname, "test_", 5) == 0);
prefix = &funcname[5];
snprintf(buf, 128, "/svg/%s/%03d/%04x:%04x-%s",
prefix,
++count,
libwacom_get_vendor_id(device),
libwacom_get_product_id(device),
libwacom_get_name(device));
g_test_add(buf, struct fixture, device,
setup_svg, func, teardown_svg);
}
#define add_test(device_, func_) \
_add_test(device_, func_, #func_)
#define add_test(device_, func_) \
_add_test(device_, func_, #func_)
static void setup_tests(WacomDevice *device)
{
const char *name;
name = libwacom_get_name(device);
if (strcmp(name, "Generic") == 0)
return;
add_test(device, test_filename);
if (!libwacom_get_layout_filename(device))
return;
add_test(device, test_svg);
add_test(device, test_dimensions);
if (libwacom_get_num_buttons(device) > 0)
add_test(device, test_buttons);
if (libwacom_has_ring(device) || libwacom_has_ring2(device))
add_test(device, test_rings);
if (libwacom_get_num_strips(device) > 0)
add_test(device, test_strips);
}
static WacomDeviceDatabase *
load_database(void)
{
WacomDeviceDatabase *db;
const char *datadir;
datadir = getenv("LIBWACOM_DATA_DIR");
if (!datadir)
datadir = TOPSRCDIR"/data";
db = libwacom_database_new_for_path(datadir);
if (!db)
printf("Failed to load data from %s", datadir);
g_assert(db);
return db;
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
WacomDevice **devices;
int rc;
g_test_init(&argc, &argv, NULL);
db = load_database();
devices = libwacom_list_devices_from_database(db, NULL);
g_assert(devices);
g_assert(*devices);
for (WacomDevice **device = devices; *device; device++)
setup_tests(*device);
rc = g_test_run();
free(devices);
libwacom_database_destroy (db);
return rc;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/test/test-tablet-validity.c 0000664 0000000 0000000 00000023151 13636474017 0022160 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2012 Red Hat, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software
udo y 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)
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include "libwacom.h"
#include
typedef int (*NumModesFn) (const WacomDevice *device);
static gboolean
buttons_have_direction(WacomDevice *device)
{
char button;
int num_buttons;
num_buttons = libwacom_get_num_buttons (device);
if (num_buttons == 0)
return TRUE;
for (button = 'A'; button < 'A' + num_buttons; button++) {
WacomButtonFlags flags;
flags = libwacom_get_button_flag(device, button);
if (!(flags & WACOM_BUTTON_DIRECTION))
return FALSE;
}
return TRUE;
}
static gboolean
match_mode_switch(WacomDevice *device,
NumModesFn get_num_modes,
WacomButtonFlags flag)
{
char button;
int num_buttons;
int num_switches;
int num_modes;
num_buttons = libwacom_get_num_buttons (device);
num_modes = get_num_modes (device);
num_switches = 0;
for (button = 'A'; button < 'A' + num_buttons; button++) {
WacomButtonFlags flags;
flags = libwacom_get_button_flag(device, button);
if (flags & flag)
num_switches++;
}
/*
* If we have more than one mode-switch button, then the
* number of modes must match the number of mode-switch buttons.
*/
if (num_switches > 1 && num_modes != num_switches)
return FALSE;
/*
* If we have more than one mode, then we should find at least
* one mode-switch button.
*/
if (num_modes > 1 && num_switches == 0)
return FALSE;
return TRUE;
}
static gboolean
tablet_has_lr_buttons(WacomDevice *device)
{
int nleft = 0;
int nright = 0;
int num_buttons;
char button;
num_buttons = libwacom_get_num_buttons (device);
for (button = 'A'; button < 'A' + num_buttons; button++) {
WacomButtonFlags f = libwacom_get_button_flag(device, button);
if (f & WACOM_BUTTON_POSITION_LEFT)
nleft++;
if (f & WACOM_BUTTON_POSITION_RIGHT)
nright++;
}
if (nleft > 0 || nright > 0)
return TRUE;
return FALSE;
}
static void
test_class(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
switch (libwacom_get_class(device)) {
case WCLASS_BAMBOO:
case WCLASS_ISDV4:
case WCLASS_PEN_DISPLAYS:
case WCLASS_GRAPHIRE:
case WCLASS_REMOTE:
case WCLASS_INTUOS:
case WCLASS_INTUOS2:
case WCLASS_INTUOS3:
case WCLASS_INTUOS4:
case WCLASS_INTUOS5:
case WCLASS_CINTIQ:
break;
default:
g_test_fail();
break;
}
}
static void
test_name(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
g_assert_nonnull(libwacom_get_name(device));
g_assert_cmpstr(libwacom_get_name(device), !=, "");
}
static void
assert_vidpid(WacomBusType bus, int vid, int pid)
{
switch (bus) {
case WBUSTYPE_SERIAL:
g_assert_cmpint(vid, >=, 0);
g_assert_cmpint(pid, >=, 0);
break;
case WBUSTYPE_USB:
if (vid == 0x056A)
g_assert_cmpint(pid, !=, 0x84); /* wireless dongle */
/* fall through */
case WBUSTYPE_BLUETOOTH:
case WBUSTYPE_I2C:
g_assert_cmpint(vid, >, 0);
g_assert_cmpint(pid, >, 0);
break;
case WBUSTYPE_UNKNOWN:
default:
g_test_fail();
break;
}
}
static void
test_vidpid(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
WacomBusType bus = libwacom_get_bustype(device);
assert_vidpid(bus, libwacom_get_vendor_id(device), libwacom_get_product_id(device));
}
static void
test_matches(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
g_assert_nonnull(libwacom_get_match(device));
g_assert_nonnull(libwacom_get_matches(device));
}
static void
test_matches_vidpid(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
const WacomMatch **match = libwacom_get_matches(device);
while (*match) {
WacomBusType bus = libwacom_match_get_bustype(*match);
assert_vidpid(bus, libwacom_match_get_vendor_id(*match), libwacom_match_get_product_id(*match));
match++;
}
}
static void
test_dimensions(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
g_assert_cmpint(libwacom_get_width(device), >, 0);
g_assert_cmpint(libwacom_get_height(device), >, 0);
}
static void
test_buttons(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
g_assert_cmpint(libwacom_get_num_buttons(device), >=, 0);
g_assert_true(buttons_have_direction(device));
if (libwacom_is_reversible(device) && libwacom_get_num_buttons(device) > 0)
g_assert_true(tablet_has_lr_buttons(device));
}
static void
test_styli(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
int nstyli;
const int *styli = libwacom_get_supported_styli(device, &nstyli);
g_assert_cmpint(nstyli, >, 0);
g_assert_nonnull(styli);
}
static void
test_realstylus(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
int nstyli;
const int *styli = libwacom_get_supported_styli(device, &nstyli);
for (int i = 0; i < nstyli; i++) {
g_assert_cmpint(styli[i], !=, WACOM_STYLUS_FALLBACK_ID);
g_assert_cmpint(styli[i], !=, WACOM_ERASER_FALLBACK_ID);
}
}
static void
test_rings(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
g_assert_cmpint(libwacom_get_ring_num_modes(device), >=, 0);
g_assert_cmpint(libwacom_get_ring2_num_modes(device), >=, 0);
if (libwacom_has_ring(device))
g_assert_true(match_mode_switch(device,
libwacom_get_ring_num_modes,
WACOM_BUTTON_RING_MODESWITCH));
if (libwacom_has_ring2(device))
g_assert_true(match_mode_switch(device,
libwacom_get_ring2_num_modes,
WACOM_BUTTON_RING2_MODESWITCH));
}
static void
test_strips(gconstpointer data)
{
WacomDevice *device = (WacomDevice*)data;
g_assert_cmpint(libwacom_get_num_strips(device), >=, 0);
g_assert_cmpint(libwacom_get_strips_num_modes(device), >=, 0);
if (libwacom_get_num_strips(device) > 0)
g_assert_true(match_mode_switch(device,
libwacom_get_strips_num_modes,
WACOM_BUTTON_TOUCHSTRIP_MODESWITCH));
}
/* Wrapper function to make adding tests simpler. g_test requires
* a unique test case name so we assemble that from the test function and
* the tablet data.
*/
static inline void
_add_test(WacomDevice *device, GTestDataFunc func, const char *funcname)
{
char buf[128];
static int count; /* guarantee unique test case names */
const char *prefix;
/* tests must be test_foobar */
g_assert(strncmp(funcname, "test_", 5) == 0);
prefix = &funcname[5];
snprintf(buf, 128, "/tablet/%s/%03d/%04x:%04x-%s",
prefix,
++count,
libwacom_get_vendor_id(device),
libwacom_get_product_id(device),
libwacom_get_name(device));
g_test_add_data_func(buf, device, func);
}
#define add_test(device_, func_) \
_add_test(device_, func_, #func_)
static void setup_tests(WacomDevice *device)
{
const char *name;
name = libwacom_get_name(device);
if (strcmp(name, "Generic") == 0)
return;
add_test(device, test_class);
add_test(device, test_name);
add_test(device, test_vidpid);
add_test(device, test_matches);
add_test(device, test_matches_vidpid);
add_test(device, test_buttons);
add_test(device, test_styli);
add_test(device, test_rings);
add_test(device, test_strips);
/* ISDv4 are built-in, they may be of varying size */
if (libwacom_get_class(device) != WCLASS_ISDV4 &&
libwacom_get_class(device) != WCLASS_REMOTE)
add_test(device, test_dimensions);
/* FIXME: we force the generic pen for these, should add a test */
if (libwacom_has_stylus(device))
add_test(device, test_styli);
switch (libwacom_get_class(device)) {
case WCLASS_INTUOS:
case WCLASS_INTUOS2:
case WCLASS_INTUOS3:
case WCLASS_INTUOS4:
case WCLASS_INTUOS5:
case WCLASS_CINTIQ:
add_test(device, test_realstylus);
break;
default:
break;
}
}
static WacomDeviceDatabase *
load_database(void)
{
WacomDeviceDatabase *db;
const char *datadir;
datadir = getenv("LIBWACOM_DATA_DIR");
if (!datadir)
datadir = TOPSRCDIR"/data";
db = libwacom_database_new_for_path(datadir);
if (!db)
printf("Failed to load data from %s", datadir);
g_assert(db);
return db;
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
WacomDevice **devices;
int rc;
g_test_init(&argc, &argv, NULL);
g_test_set_nonfatal_assertions();
db = load_database();
devices = libwacom_list_devices_from_database(db, NULL);
g_assert(devices);
g_assert(*devices);
for (WacomDevice **device = devices; *device; device++)
setup_tests(*device);
rc = g_test_run();
libwacom_database_destroy(db);
free(devices);
return rc;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/test/valgrind.suppressions 0000664 0000000 0000000 00000000557 13636474017 0022253 0 ustar 00root root 0000000 0000000 {
Memcheck:Leak
...
fun:g_type_register_static
}
{
Memcheck:Leak
...
fun:g_type_register_fundamental
}
{
Memcheck:Leak
...
fun:g_malloc0
}
{
Memcheck:Leak
fun:malloc
...
fun:g_get_language_names_with_category
}
libwacom-libwacom-1.3/tools/ 0000775 0000000 0000000 00000000000 13636474017 0016120 5 ustar 00root root 0000000 0000000 libwacom-libwacom-1.3/tools/Makefile.am 0000664 0000000 0000000 00000002304 13636474017 0020153 0 ustar 00root root 0000000 0000000 AM_CPPFLAGS=-I$(top_srcdir)/libwacom -DTOPSRCDIR="\"$(abs_top_srcdir)\""
noinst_PROGRAMS = generate-udev-rules list-devices list-compatible-styli
generate_udev_rules_SOURCES = generate-udev-rules.c
generate_udev_rules_LDADD=$(top_builddir)/libwacom/libwacom.la $(GLIB_LIBS)
generate_udev_rules_CFLAGS=$(GLIB_CFLAGS)
list_devices_SOURCES = list-devices.c
list_devices_LDADD=$(top_builddir)/libwacom/libwacom.la
list_compatible_styli_SOURCES = list-compatible-styli.c
list_compatible_styli_LDADD=$(top_builddir)/libwacom/libwacom.la
bin_PROGRAMS = libwacom-list-local-devices
libwacom_list_local_devices_SOURCES = list-local-devices.c
libwacom_list_local_devices_LDADD=$(top_builddir)/libwacom/libwacom.la $(GLIB_LIBS)
libwacom_list_local_devices_CFLAGS=$(GLIB_CFLAGS)
if HAVE_GTK2
noinst_PROGRAMS += show-svg-image
show_svg_image_SOURCES = show-svg-image.c
show_svg_image_LDADD = $(top_builddir)/libwacom/libwacom.la $(GTK2_LIBS)
show_svg_image_CFLAGS = $(GTK2_CFLAGS)
endif
dist_man1_MANS = libwacom-list-local-devices.man
rules = 65-libwacom.rules
udev_rulesdir=$(UDEV_DIR)/rules.d
dist_udev_rules_DATA = $(rules)
$(rules): generate-udev-rules
$(builddir)/$< > $@
CLEANFILES = $(rules)
EXTRA_DIST = $(rules)
libwacom-libwacom-1.3/tools/clean_svg.py 0000775 0000000 0000000 00000022157 13636474017 0020445 0 ustar 00root root 0000000 0000000 #! /usr/bin/env python
#
# Copyright (c) 2013 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# Author: Joaquim Rocha
#
import sys
from argparse import ArgumentParser
from xml.etree import ElementTree as ET
NAMESPACE = "http://www.w3.org/2000/svg"
BRACKETS_NAMESPACE = '{' + NAMESPACE + '}'
def human_round(number):
'''
Round to closest .5
'''
return round(number * 2) / 2.0
def traverse_and_clean(node):
'''
Clean the tree recursively
'''
# Remove any non-SVG namespace attributes
for key in node.attrib.keys():
if key.startswith('{'):
del node.attrib[key]
if node.tag == 'g' and node.attrib.has_key('id'):
apply_id_and_class_from_group(node)
del node.attrib['id']
if node.attrib.has_key('style'):
if node.tag == 'text':
node.attrib['style'] = 'text-anchor:start;'
elif node.tag != 'svg':
del node.attrib['style']
remove_transform_if_exists(node)
round_attrib(node, 'd', 'x', 'y', 'rx', 'ry', 'width', 'height', 'cx', 'cy', 'r')
for child in node.getchildren():
traverse_and_clean(child)
def round_attrib(node, *attrs):
for attr_name in attrs:
attr_value = node.attrib.get(attr_name)
if attr_value is None:
continue
if attr_name == 'd':
d = attr_value.replace(',', ' ')
values = [round_if_number(value) for value in d.split()]
node.attrib[attr_name] = ' '.join(values)
else:
node.attrib[attr_name] = round_if_number(attr_value)
def round_if_number(value):
try:
value = human_round(float(value.strip()))
except ValueError:
pass
return str(value)
def remove_non_svg_nodes_and_strip_namespace(root):
if root.tag.startswith(BRACKETS_NAMESPACE):
root.tag = root.tag[len(BRACKETS_NAMESPACE):]
for elem in root.getchildren():
if not elem.tag.startswith(BRACKETS_NAMESPACE) or \
elem.tag == BRACKETS_NAMESPACE + 'metadata':
root.remove(elem)
else:
remove_non_svg_nodes_and_strip_namespace(elem)
def remove_transform_if_exists(node):
TRANSLATE = 'translate'
MATRIX = 'matrix'
transform = node.attrib.get('transform')
if transform is None:
return
transform = transform.strip()
if transform.startswith(TRANSLATE):
values = transform[len(TRANSLATE) + 1:-1].split(',')
try:
x, y = float(values[0]), float(values[1])
except:
return
apply_translation(node, 1, 0, 0, 1, x, y)
elif transform.startswith(MATRIX):
values = transform[len(MATRIX) + 1:-1].split(',')
try:
a, b, c, d, e, f = [float(value.strip()) for value in values]
except:
return
apply_translation(node, a, b, c, d, e, f)
apply_scaling(node, a, d)
del node.attrib['transform']
def apply_translation(node, a, b, c, d, e, f):
x_attr, y_attr = 'x', 'y'
if node.tag == 'circle':
x_attr, y_attr = 'cx', 'cy'
elif node.tag == 'path':
apply_translation_to_path(node, e, f)
return
try:
x, y = float(node.attrib[x_attr]), float(node.attrib[y_attr])
new_x = x * a + y * c + 1 * e
new_y = x * b + y * d + 1 * f
node.attrib[x_attr] = str(new_x)
node.attrib[y_attr] = str(new_y)
except:
pass
def apply_translation_to_path(node, x, y):
d = node.attrib.get('d')
if d is None:
return
d = d.replace(',', ' ').split()
m_init_index = 0
length = len(d)
m_end_index = length
operation = 'M'
i = 0
while i < length:
value = d[i]
if value.lower() == 'm':
operation = value
m_init_index = i + 1
elif len(value) == 1 and value.isalpha():
m_end_index = i
break
i += 1
for i in range(m_init_index, m_end_index, 2):
d[i] = str(float(d[i]) + x)
d[i + 1] = str(float(d[i + 1]) + y)
if operation == 'm':
break
node.attrib['d'] = ' '.join(d[:m_init_index]) + ' ' + ' '.join(d[m_init_index:m_end_index]) + ' '.join(d[m_end_index:])
def apply_scaling(node, x, y):
w_attr, h_attr = 'width', 'height'
if node.tag == 'circle':
r = float(node.attrib.get('r', 1.0))
node.attrib['r'] = str(r * x)
try:
w = float(node.attrib[w_attr])
h = float(node.attrib[h_attr])
node.attrib[w_attr] = str(w * x)
node.attrib[h_attr] = str(h * y)
except:
pass
def to_string_rec(node, level=0):
indent = '\n' + level * ' '
tag_name = node.tag
# Remove 'defs' element. This cannot be done in the traverse_and_clean
# because somehow it is never found
if tag_name == 'defs':
return ''
# use a list to put id and class as the first arguments
attribs = []
for attr in get_node_attrs_sorted(node):
attr_value = node.attrib.get(attr)
if attr_value is not None:
attribs.append(indent + ' %s="%s"' % (attr, attr_value))
string = indent + '<' + tag_name + ''.join(attribs)
if len(node) or node.text:
string += '>'
if not node.text or not node.text.strip():
node.text = indent + ' '
else:
string += node.text
if list(node):
for child in get_node_children_sorted(node):
string += to_string_rec(child, level+1)
string += indent
string += '' % tag_name
else:
string += ' />'
return string
def custom_tag_sort(arg):
'''
Use as key functon in sorted().
Pre-fix arg tag name by a number in the sort order we want. Anything
unspecified defaults to 9. i.e. circle -> 1circle, thus sorts lower
than
other tags.
'''
tag_order = {'title': 0,
'rect': 1,
'circle': 2,
'path': 3 }
return str(tag_order.get(arg.tag, 9)) + arg.tag
def get_node_children_sorted(node):
children = node.getchildren()
return sorted(children, key=custom_tag_sort)
def custom_attr_sort(arg):
'''
Same as custom_tag_sort but for a node's attributes
'''
attr_order = {'id': 0, 'class': 1,
'x': 2, 'y': 3, 'cx': 4, 'cy': 5,
'width': 6, 'height': 7}
return str(attr_order.get(arg, 9)) + arg
def get_node_attrs_sorted(node):
attrs = node.attrib.keys()
return sorted(attrs, key=custom_attr_sort)
def apply_id_and_class_from_group(group_node):
button_assigned = label_assigned = path_assigned = False
_id = group_node.attrib.get('id')
if _id is None:
return
for child in group_node.getchildren():
if child.tag == 'rect' or child.tag == 'circle':
if button_assigned:
continue
child.attrib['id'] = 'Button%s' % _id
child.attrib['class'] = '%s Button' % _id
button_assigned = True
elif child.tag == 'path':
if path_assigned:
continue
child.attrib['id'] = 'Leader%s' % _id
child.attrib['class'] = '%s Leader' % _id
path_assigned = True
elif child.tag == 'text':
if label_assigned:
continue
child.attrib['id'] = 'Label%s' % _id
child.attrib['class'] = '%s Label' % _id
child.text = _id
label_assigned = True
def to_string(root):
header = '''
'''
return header + to_string_rec(root)
def clean_svg(root, tabletname):
remove_non_svg_nodes_and_strip_namespace(root)
title = root.find('title')
if title is not None:
title.text = tabletname
root.attrib['xmlns'] = 'http://www.w3.org/2000/svg'
traverse_and_clean(root)
if __name__ == '__main__':
parser = ArgumentParser(description='Clean SVG files for libwacom')
parser.add_argument('filename', nargs=1, type=str,
help='SVG file to clean', metavar='FILE')
parser.add_argument('tabletname', nargs=1, type=str,
help='The name of the tablet', metavar='TABLET_NAME')
args = parser.parse_args()
ET.register_namespace('', NAMESPACE)
try:
tree = ET.parse(args.filename[0])
except Exception, e:
sys.stderr.write(str(e) + '\n')
exit(1)
root = tree.getroot()
clean_svg(root, args.tabletname[0])
print to_string(root)
libwacom-libwacom-1.3/tools/generate-udev-rules.c 0000664 0000000 0000000 00000017717 13636474017 0022164 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2012 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:
* Olivier Fourdan (ofourdan@redhat.com)
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include
#include
#include
#include "libwacom.h"
#include
#include
static gboolean need_uinput_rules = FALSE;
static GOptionEntry opts[] = {
{"with-uinput-rules", 0, 0, G_OPTION_ARG_NONE, &need_uinput_rules, N_("Print udev rules for uinput devices"), NULL },
{NULL}
};
static void print_udev_header (void)
{
printf ("# udev rules for libwacom supported devices\n");
printf ("# This file is generated by libwacom, do not edit\n");
printf ("\n");
printf ("ACTION!=\"add|change\", GOTO=\"libwacom_end\"\n");
printf ("KERNEL!=\"event[0-9]*\", GOTO=\"libwacom_end\"\n");
printf ("\n");
}
static void print_huion_quirk (void)
{
/* Huion tablets have a "consumer control" device with the same
* VID/PID as the tablet but only a few buttons and no axes.
*
*/
printf("# HUION consumer control devices are not tablets.\n");
printf("ATTRS{name}==\"HUION * Consumer Control\", GOTO=\"libwacom_end\"\n");
printf ("\n");
}
static void print_wireless_kit_quirk (void)
{
/* Bamboo and Intuos devices connected to the system via Wacom's
* Wireless Accessory Kit appear to udev as having the PID of the
* dongle rather than the actual tablet. Make sure we properly tag
* such devices.
*/
char *match = "ENV{ID_BUS}==\"usb\", ENV{ID_VENDOR_ID}==\"056a\", ENV{ID_MODEL_ID}==\"0084\"";
printf("# Wacom Wireless Accessory Kit\n");
printf("%s, ENV{ID_INPUT}=\"1\", ENV{ID_INPUT_JOYSTICK}=\"\", ENV{ID_INPUT_TABLET}=\"1\"\n", match);
printf("ATTRS{name}==\"* Finger\", %s, ENV{ID_INPUT_TOUCHPAD}=\"1\"\n", match);
printf("ATTRS{name}==\"* Pad\", %s, ENV{ID_INPUT_TABLET_PAD}=\"1\"\n", match);
printf("\n");
}
static char * generate_device_match(const WacomMatch *match)
{
WacomBusType type = libwacom_match_get_bustype (match);
int vendor = libwacom_match_get_vendor_id (match);
int product = libwacom_match_get_product_id (match);
char *matchstr = NULL;
switch (type) {
case WBUSTYPE_USB:
matchstr = g_strdup_printf ("ENV{ID_BUS}==\"usb\", ENV{ID_VENDOR_ID}==\"%04x\", ENV{ID_MODEL_ID}==\"%04x\", ", vendor, product);
g_assert(matchstr != NULL);
break;
case WBUSTYPE_BLUETOOTH:
/* Bluetooth tablets do not have ID_VENDOR_ID/ID_MODEL_ID etc set correctly. They
* do have the PRODUCT set though. */
matchstr = g_strdup_printf ("ENV{PRODUCT}==\"5/%x/%x/*\", ", vendor, product);
g_assert(matchstr != NULL);
break;
default:
/* Not sure how to deal with serials */
return NULL;
}
return matchstr;
}
static void print_udev_entry_matchstr(WacomDevice *device, const char *matchstr)
{
printf ("# %s\n", libwacom_get_name (device));
/* unset joystick, set tablet */
printf ("%s ENV{ID_INPUT}=\"1\", ENV{ID_INPUT_JOYSTICK}=\"\", ENV{ID_INPUT_TABLET}=\"1\"\n", matchstr);
if (libwacom_has_touch (device)) {
const char *touchtype = "ID_INPUT_TOUCHPAD";
if (libwacom_get_integration_flags (device) != WACOM_DEVICE_INTEGRATED_NONE)
touchtype = "ID_INPUT_TOUCHSCREEN";
printf( "ATTRS{name}==\"* Finger\", %s ENV{%s}=\"1\"\n", matchstr, touchtype);
}
/* set ID_INPUT_TABLET_PAD for pads */
if (libwacom_get_num_buttons (device) > 0)
printf ("ATTRS{name}==\"* Pad\", %s ENV{ID_INPUT_TABLET_PAD}=\"1\"\n", matchstr);
}
static char * generate_uinput_match (const WacomMatch *match)
{
WacomBusType type = libwacom_match_get_bustype (match);
int vendor = libwacom_match_get_vendor_id (match);
int product = libwacom_match_get_product_id (match);
const char *subsystem;
char *matchstr;
switch(type) {
case WBUSTYPE_USB: subsystem = "usb"; break;
case WBUSTYPE_BLUETOOTH: subsystem = "bluetooth"; break;
case WBUSTYPE_SERIAL: subsystem = "tty"; break;
default:
return NULL;
}
matchstr = g_strdup_printf("ENV{DEVPATH}==\"/devices/virtual/*\", "
"ATTRS{id/vendor}==\"%04x\", "
"ATTRS{id/product}==\"%04x\", "
"ENV{UINPUT_DEVICE}=\"1\", "
"ENV{UINPUT_SUBSYSTEM}=\"%s\", "
"ENV{ID_VENDOR_ID}=\"%04x\", "
"ENV{ID_MODEL_ID}=\"%04x\", ",
vendor, product,
subsystem, vendor, product);
return matchstr;
}
static void print_uinput_entry (WacomDevice *device, WacomBusType bus_type_filter)
{
const WacomMatch **matches, **match;
matches = libwacom_get_matches(device);
for (match = matches; *match; match++) {
WacomBusType type = libwacom_match_get_bustype (*match);
char *matchstr;
if (bus_type_filter != type)
continue;
matchstr = generate_uinput_match (*match);
if (matchstr == NULL)
continue;
print_udev_entry_matchstr (device, matchstr);
g_free (matchstr);
}
}
static void print_udev_entry (WacomDevice *device, WacomBusType bus_type_filter)
{
const WacomMatch **matches, **match;
matches = libwacom_get_matches(device);
for (match = matches; *match; match++) {
WacomBusType type = libwacom_match_get_bustype (*match);
char *matchstr;
if (bus_type_filter != type)
continue;
matchstr = generate_device_match (*match);
if (matchstr == NULL)
continue;
print_udev_entry_matchstr (device, matchstr);
g_free (matchstr);
}
}
static void print_udev_trailer (void)
{
printf ("\n");
printf ("# Match all serial wacom tablets with a serial ID starting with WACf\n");
printf ("ENV{ID_BUS}==\"tty|pnp\", ATTRS{id}==\"WACf*\", ENV{ID_INPUT}=\"1\", ENV{ID_INPUT_TABLET}=\"1\"\n");
printf ("ENV{ID_BUS}==\"tty|pnp\", ATTRS{id}==\"FUJ*\", ENV{ID_INPUT}=\"1\", ENV{ID_INPUT_TABLET}=\"1\"\n");
printf ("\n");
printf ("LABEL=\"libwacom_end\"\n");
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
WacomDevice **list, **p;
GOptionContext *context;
GError *error;
gboolean rc;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, opts, NULL);
error = NULL;
rc = g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (!rc) {
if (error != NULL) {
fprintf (stderr, "%s\n", error->message);
g_error_free (error);
}
return EXIT_FAILURE;
}
db = libwacom_database_new_for_path(TOPSRCDIR"/data");
list = libwacom_list_devices_from_database(db, NULL);
if (!list) {
fprintf(stderr, "Failed to load device database.\n");
return 1;
}
print_udev_header ();
print_huion_quirk ();
print_wireless_kit_quirk ();
for (p = list; *p; p++)
print_udev_entry ((WacomDevice *) *p, WBUSTYPE_USB);
print_udev_trailer ();
for (p = list; *p; p++)
print_udev_entry ((WacomDevice *) *p, WBUSTYPE_BLUETOOTH);
if (need_uinput_rules) {
printf("\n# Start of uinput rules\n");
for (p = list; *p; p++)
print_uinput_entry ((WacomDevice *) *p, WBUSTYPE_USB);
for (p = list; *p; p++)
print_uinput_entry ((WacomDevice *) *p, WBUSTYPE_BLUETOOTH);
}
g_free(list);
libwacom_database_destroy (db);
return 0;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/tools/libwacom-list-local-devices.man 0000664 0000000 0000000 00000001573 13636474017 0024101 0 ustar 00root root 0000000 0000000 .TH libwacom-list-local-devices 1
.SH NAME
libwacom-list-local-devices - utility to list tablet devices
.SH SYNOPSIS
.B libwacom-list-local-devices [--database /path/to/datadir]
.SH DESCRIPTION
libwacom-list-local-devices is a debug utility to list connected tablet
devices identified by libwacom. It is usually used to check whether a
libwacom data file is correct, present and/or applies to a specific device.
.SH OPTIONS
.TP 8
.B --database /path/do/datadir
Sets the data directory path to be used. This is only useful when testing
against a modified data path. Only libwacom developers need this option.
.SH NOTES
The Linux kernel provides separate \fI/dev/input/event*\fR nodes for the
stylus, the pad and the touch part of the tablet. This usually results in a
connected tablet being listed multiple times with this tool. This behavior
is expected and should not be seen as a bug.
libwacom-libwacom-1.3/tools/list-compatible-styli.c 0000664 0000000 0000000 00000005234 13636474017 0022522 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2019 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
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _GNU_SOURCE
#include
#include
#include
#include
#include "libwacom.h"
static void
print_device_info(const WacomDeviceDatabase *db, const WacomDevice *device)
{
const int *styli;
int nstyli;
printf("%s", libwacom_get_name(device));
if (libwacom_get_model_name(device)) {
printf(" (%s)", libwacom_get_model_name(device));
}
printf(":\n");
if (!libwacom_has_stylus(device)) {
printf("\tno styli defined\n");
return;
}
styli = libwacom_get_supported_styli(device, &nstyli);
for (int i = 0; i < nstyli; i++) {
const WacomStylus *s;
s = libwacom_stylus_get_for_id(db, styli[i]);
printf("\t%#8x:\t%s\n",
libwacom_stylus_get_id(s),
libwacom_stylus_get_name(s));
}
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
WacomDevice **list, **p;
if (argc > 1) {
printf("Usage: %s [--help] - list all supported devices\n",
basename(argv[0]));
return !!(strcmp(argv[1], "--help"));
}
db = libwacom_database_new_for_path(TOPSRCDIR"/data");
list = libwacom_list_devices_from_database(db, NULL);
if (!list) {
fprintf(stderr, "Failed to load device database.\n");
return 1;
}
for (p = list; *p; p++)
print_device_info(db, (WacomDevice *)*p);
libwacom_database_destroy(db);
return 0;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/tools/list-devices.c 0000664 0000000 0000000 00000005216 13636474017 0020663 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2012 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
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _GNU_SOURCE
#include
#include
#include
#include
#include "libwacom.h"
static void print_device_info (WacomDevice *device, WacomBusType bus_type_filter)
{
const WacomMatch **match;
for (match = libwacom_get_matches(device); *match; match++) {
WacomBusType type = libwacom_match_get_bustype(*match);
if (type == bus_type_filter) {
libwacom_print_device_description(STDOUT_FILENO, device);
dprintf(STDOUT_FILENO, "---------------------------------------------------------------\n");
}
}
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
WacomDevice **list, **p;
if (argc > 1) {
printf("Usage: %s [--help] - list all supported devices\n",
basename(argv[0]));
return !!(strcmp(argv[1], "--help"));
}
db = libwacom_database_new_for_path(TOPSRCDIR"/data");
list = libwacom_list_devices_from_database(db, NULL);
if (!list) {
fprintf(stderr, "Failed to load device database.\n");
return 1;
}
for (p = list; *p; p++)
print_device_info ((WacomDevice *) *p, WBUSTYPE_USB);
for (p = list; *p; p++)
print_device_info ((WacomDevice *) *p, WBUSTYPE_BLUETOOTH);
for (p = list; *p; p++)
print_device_info ((WacomDevice *) *p, WBUSTYPE_SERIAL);
for (p = list; *p; p++)
print_device_info ((WacomDevice *) *p, WBUSTYPE_UNKNOWN);
libwacom_database_destroy (db);
return 0;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/tools/list-local-devices.c 0000664 0000000 0000000 00000006216 13636474017 0021754 0 ustar 00root root 0000000 0000000 /*
* Copyright © 2012 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
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include "libwacom.h"
static char *database_path;
static GOptionEntry opts[] = {
{"database", 0, 0, G_OPTION_ARG_FILENAME, &database_path, N_("Path to device database"), NULL },
{NULL}
};
static int event_devices_only(const struct dirent *dir) {
return strncmp("event", dir->d_name, 5) == 0;
}
int main(int argc, char **argv)
{
WacomDeviceDatabase *db;
WacomDevice *dev;
int i;
struct dirent **namelist = NULL;
GOptionContext *context;
GError *error;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, opts, NULL);
error = NULL;
if (!g_option_context_parse (context, &argc, &argv, &error)) {
if (error != NULL) {
fprintf (stderr, "%s\n", error->message);
g_error_free (error);
}
return EXIT_FAILURE;
}
g_option_context_free (context);
if (database_path) {
db = libwacom_database_new_for_path(database_path);
g_free (database_path);
} else {
db = libwacom_database_new();
}
if (!db) {
fprintf(stderr, "Failed to initialize device database\n");
return 1;
}
i = scandir("/dev/input", &namelist, event_devices_only, alphasort);
if (i < 0 || i == 0) {
fprintf(stderr, "Failed to find any devices.\n");
goto out;
}
while (i--) {
char fname[PATH_MAX];
snprintf(fname, sizeof(fname), "/dev/input/%s", namelist[i]->d_name);
dev = libwacom_new_from_path(db, fname, WFALLBACK_NONE, NULL);
if (!dev)
continue;
dprintf(STDOUT_FILENO, "# Device node: %s\n", fname);
libwacom_print_device_description(STDOUT_FILENO, dev);
libwacom_destroy(dev);
dprintf(STDOUT_FILENO, "---------------------------------------------------------------\n");
}
out:
if (namelist)
free(namelist);
libwacom_database_destroy (db);
return 0;
}
/* vim: set noexpandtab tabstop=8 shiftwidth=8: */
libwacom-libwacom-1.3/tools/show-svg-image.c 0000664 0000000 0000000 00000034421 13636474017 0021125 0 ustar 00root root 0000000 0000000 /*
* Copyright ?? 2012 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:
* Olivier Fourdan
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include "libwacom.h"
#ifndef LIBRSVG_CHECK_VERSION
#include
#endif
#if !LIBRSVG_CHECK_VERSION(2,36,2)
#include
#endif
#define INACTIVE_COLOR "#ededed"
#define ACTIVE_COLOR "#729fcf"
#define STROKE_COLOR "#000000"
#define DARK_COLOR "#535353"
#define BACK_COLOR "#000000"
/* Convenient struct to store our stuff around */
typedef struct
{
RsvgHandle *handle;
GtkWidget *widget;
guint timeout;
WacomDevice *device;
GdkRectangle area;
char active_button;
int num_buttons;
} Tablet;
static gboolean
get_sub_location (cairo_t *cairo_context, RsvgHandle *handle, const char *sub, double *x, double *y, double *width, double *height)
{
if (x || y) {
RsvgPositionData position;
double tx, ty;
if (!rsvg_handle_get_position_sub (handle, &position, sub)) {
g_warning ("Failed to retrieve '%s' position", sub);
return FALSE;
}
tx = (double) position.x;
ty = (double) position.y;
cairo_user_to_device (cairo_context, &tx, &ty);
if (x)
*x = tx;
if (y)
*y = ty;
}
if (width || height) {
RsvgDimensionData dimensions;
double twidth, theight;
if (!rsvg_handle_get_dimensions_sub (handle, &dimensions, sub)) {
g_warning ("Failed to retrieve '%s' dimension", sub);
return FALSE;
}
twidth = (double) dimensions.width;
theight = (double) dimensions.height;
cairo_user_to_device_distance (cairo_context, &twidth, &theight);
if (width)
*width = twidth;
if (height)
*height = theight;
}
return TRUE;
}
static void
print_label (cairo_t *cairo_context, Tablet *tablet, const char *sub, const char *markup, WacomButtonFlags flags)
{
GtkWidget *widget;
GtkAllocation allocation;
GtkStyle *style;
PangoContext *pango_context;
PangoLayout *pango_layout;
PangoRectangle pango_rect;
double label_x, label_y;
int x, y;
if (!get_sub_location (cairo_context, tablet->handle, sub, &label_x, &label_y, NULL, NULL))
return;
widget = GTK_WIDGET(tablet->widget);
gtk_widget_get_allocation(widget, &allocation);
style = gtk_widget_get_style (widget);
pango_context = gtk_widget_get_pango_context (widget);
pango_layout = pango_layout_new (pango_context);
pango_layout_set_markup (pango_layout, markup, -1);
pango_layout_get_pixel_extents (pango_layout, NULL, &pango_rect);
if (flags & WACOM_BUTTON_POSITION_LEFT) {
pango_layout_set_alignment (pango_layout, PANGO_ALIGN_LEFT);
x = (int) label_x + pango_rect.x;
y = (int) label_y + pango_rect.y - pango_rect.height / 2;
} else if (flags & WACOM_BUTTON_POSITION_RIGHT) {
pango_layout_set_alignment (pango_layout, PANGO_ALIGN_RIGHT);
x = (int) label_x + pango_rect.x - pango_rect.width;
y = (int) label_y + pango_rect.y - pango_rect.height / 2;
} else {
pango_layout_set_alignment (pango_layout, PANGO_ALIGN_CENTER);
x = (int) label_x + pango_rect.x - pango_rect.width / 2;
y = (int) label_y + pango_rect.y;
}
gtk_paint_layout (style,
gtk_widget_get_window (widget),
0,
TRUE,
&allocation,
widget,
NULL,
x,
y,
pango_layout);
g_object_unref (pango_layout);
}
static void
print_button_labels (cairo_t *cairo_context, Tablet *tablet)
{
char button;
for (button = 'A'; button < 'A' + tablet->num_buttons; button++) {
WacomButtonFlags flags;
gchar *sub;
gchar *label;
flags = libwacom_get_button_flag(tablet->device, button);
sub = g_strdup_printf ("#Label%c", button);
label = g_strdup_printf ("Button %c ",
(button == tablet->active_button) ? ACTIVE_COLOR : INACTIVE_COLOR,
button);
print_label (cairo_context, tablet, sub, label, flags);
g_free (label);
g_free (sub);
}
/* Touch rings */
if (libwacom_has_ring(tablet->device)) {
print_label (cairo_context, tablet, "#LabelRingCCW", "Ring Counter Clockwise ", WACOM_BUTTON_POSITION_LEFT);
print_label (cairo_context, tablet, "#LabelRingCW", "Ring Clockwise ", WACOM_BUTTON_POSITION_LEFT);
}
if (libwacom_has_ring2(tablet->device)) {
print_label (cairo_context, tablet, "#LabelRing2CCW", "2nd Ring Counter Clockwise ", WACOM_BUTTON_POSITION_RIGHT);
print_label (cairo_context, tablet, "#LabelRing2CW", "2nd Ring Clockwise ", WACOM_BUTTON_POSITION_RIGHT);
}
/* Touch strips */
if (libwacom_get_num_strips(tablet->device) > 0) {
print_label (cairo_context, tablet, "#LabelStripUp", "Strip Up ", WACOM_BUTTON_POSITION_LEFT);
print_label (cairo_context, tablet, "#LabelStripDown", "Strip Down ", WACOM_BUTTON_POSITION_LEFT);
}
if (libwacom_get_num_strips(tablet->device) > 1) {
print_label (cairo_context, tablet, "#LabelStrip2Up", "2nd Strip Up ", WACOM_BUTTON_POSITION_RIGHT);
print_label (cairo_context, tablet, "#LabelStrip2Down", "2nd Strip Down ", WACOM_BUTTON_POSITION_RIGHT);
}
}
static void
update_tablet (Tablet *tablet)
{
char *width, *height;
char button;
GError *error;
gchar *file_data, *escaped_file_data, *data;
gsize file_len;
error = NULL;
if (tablet->handle)
g_object_unref (tablet->handle);
if (!g_file_get_contents (libwacom_get_layout_filename (tablet->device), &file_data, &file_len, NULL))
return;
escaped_file_data = g_base64_encode ((guchar*) file_data, file_len);
width = g_strdup_printf ("%d", tablet->area.width);
height = g_strdup_printf ("%d", tablet->area.height);
data = g_strconcat ("\n"
"\n"
" \n"
" ",
NULL);
tablet->handle = rsvg_handle_new_from_data ((guint8 *) data, strlen(data), &error);
g_free (data);
g_free (escaped_file_data);
g_free (file_data);
}
static void
on_expose_cb (GtkWidget *widget, GdkEvent *event, Tablet *tablet)
{
GtkAllocation allocation;
cairo_t *cairo_context;
float scale;
double twidth, theight;
if (tablet->handle == NULL)
update_tablet (tablet);
/* Create a Cairo for the widget */
cairo_context = gdk_cairo_create (gtk_widget_get_window (widget));
cairo_set_operator (cairo_context, CAIRO_OPERATOR_CLEAR);
cairo_paint (cairo_context);
cairo_set_operator (cairo_context, CAIRO_OPERATOR_OVER);
/* Scale to fit in window */
gtk_widget_get_allocation(widget, &allocation);
scale = MIN ((float) allocation.width / tablet->area.width,
(float) allocation.height / tablet->area.height);
cairo_scale (cairo_context, scale, scale);
/* Center the result in window */
twidth = (double) tablet->area.width;
theight = (double) tablet->area.height;
cairo_user_to_device_distance (cairo_context, &twidth, &theight);
twidth = ((double) allocation.width - twidth) / 2.0;
theight = ((double) allocation.height - theight) / 2.0;
cairo_device_to_user_distance (cairo_context, &twidth, &theight);
cairo_translate (cairo_context, twidth, theight);
/* And render the tablet layout */
rsvg_handle_render_cairo (tablet->handle, cairo_context);
print_button_labels (cairo_context, tablet);
cairo_destroy (cairo_context);
}
static gboolean
on_timer_cb (Tablet *tablet)
{
GtkAllocation allocation;
int num_buttons;
tablet->active_button++;
num_buttons = libwacom_get_num_buttons (tablet->device);
if (tablet->active_button >= 'A' + num_buttons)
tablet->active_button = 'A';
update_tablet (tablet);
gtk_widget_get_allocation (GTK_WIDGET(tablet->widget), &allocation);
gdk_window_invalidate_rect(gtk_widget_get_window (tablet->widget), &allocation, FALSE);
return TRUE;
}
static gboolean
on_delete_cb (GtkWidget *widget, GdkEvent *event, Tablet *tablet)
{
gtk_main_quit ();
return TRUE;
}
int
main (int argc, char **argv)
{
GOptionContext *context;
RsvgHandle *handle;
RsvgDimensionData dimensions;
GError *error;
WacomDeviceDatabase *db;
WacomDevice *device;
Tablet *tablet;
GdkWindow *gdk_win;
GdkColor black;
char *tabletname;
const char *filename;
GOptionEntry
options[] = {
{"tablet", 't', 0, G_OPTION_ARG_STRING, &tabletname, "Name of the tablet to show", ""},
{NULL}
};
handle = NULL;
error = NULL;
tabletname = NULL;
context = g_option_context_new ("- libwacom tablet viewer");
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_set_help_enabled (context, TRUE);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
gtk_init (&argc, &argv);
if (tabletname == NULL) {
g_warning ("No tablet name provided, exiting");
return 1;
}
db = libwacom_database_new_for_path(TOPSRCDIR"/data");
if (!db) {
g_warning ("Failed to load libwacom database, exiting");
return 1;
}
device = libwacom_new_from_name(db, tabletname, NULL);
if (!device) {
g_warning ("Device '%s' not found in libwacom database, exiting", tabletname);
return 1;
}
filename = libwacom_get_layout_filename(device);
if (filename == NULL) {
g_warning ("Device '%s' has no layout available, exiting", tabletname);
return 1;
}
handle = rsvg_handle_new_from_file (filename, &error);
if (error || handle == NULL)
return 1;
rsvg_handle_get_dimensions (handle, &dimensions);
g_object_unref (handle);
tablet = g_new0 (Tablet, 1);
tablet->device = device;
tablet->area.width = dimensions.width;
tablet->area.height = dimensions.height;
tablet->handle = NULL;
tablet->active_button = 'A';
tablet->num_buttons = libwacom_get_num_buttons (device);
tablet->widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable (tablet->widget, TRUE);
gtk_widget_realize (tablet->widget);
gdk_win = gtk_widget_get_window (tablet->widget);
gdk_color_parse (BACK_COLOR, &black);
gdk_window_set_background (gdk_win, &black);
gtk_window_set_default_size (GTK_WINDOW (tablet->widget), 800, 600);
gtk_window_set_title (GTK_WINDOW (tablet->widget), libwacom_get_name (device));
g_signal_connect (tablet->widget, "expose-event", G_CALLBACK(on_expose_cb), tablet);
g_signal_connect (tablet->widget, "delete-event", G_CALLBACK(on_delete_cb), tablet);
tablet->timeout = g_timeout_add(750 /* ms */, (GSourceFunc) on_timer_cb, tablet);
gtk_widget_show (tablet->widget);
gtk_main();
libwacom_destroy(device);
libwacom_database_destroy(db);
return 0;
}