Attachment #227934 for bug #409366

View | Details | Raw Unified | Return to bug 409366
Collapse All | Expand All




#include <stdio.h> /* debugging only, we've got no business output text */
#include <ctype.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <string.h>
#include <memory.h>
#include <assert.h>

#include "xf86Parser.h"

WACOMDEVICETYPE checkIfWacomDevice (XF86ConfigPtr, const char* );
WACOMDEVICETYPE mapStringToType (const char*);
XF86ConfigPtr readConfig (char *);
void VErrorF(const char*, va_list);
void ErrorF (const char*, ...);

/*****************************************************************************
** Internal structures
*****************************************************************************/

	unsigned char* pReq;
	WACOMDEVICEINFO* pInfo;
	XDeviceInfo* info;
	XF86ConfigPtr conf;
	char devName[64];

	if (!hConfig || !ppInfo || !puCount)

	if (!hConfig->pDevs && CfgGetDevs(hConfig))
		return -1;

	/* read the config in for wacom devices which don'T use the commnon identifier */
	conf = readConfig ("/etc/X11/xorg.conf");

	/* estimate size of memory needed to hold structures */
	nSize = nCount = 0;
	for (i=0; i<hConfig->nDevCnt; ++i)
	{
		info = hConfig->pDevs + i;
		if (info->use != IsXExtensionDevice && info->use != IsXExtensionPointer) continue;
		if (!info->num_classes) continue;
		nSize += sizeof(WACOMDEVICEINFO);
		nSize += strlen(info->name) + 1;


	/* allocate memory and zero */
	pReq = (unsigned char*)malloc(nSize);

	if (!pReq) 
		return CfgError(hConfig,errno, "WacomConfigListDevices: failed to allocate memory");

	memset(pReq,0,nSize);

	/* populate data */

	{
		info = hConfig->pDevs + i;
		/* ignore non-extension devices */
		if (info->use != IsXExtensionDevice && info->use != IsXExtensionPointer) continue;
		/* ignore uninitialized tools  */
		if (!info->num_classes) continue;
		/* copy name */

		for (j=0; j<strlen(pInfo->pszName); j++)
			devName[j] = tolower(pInfo->pszName[j]);
		devName[j] = '\0';

		pInfo->type = mapStringToType (devName);

		if ( pInfo->type == WACOMDEVICETYPE_UNKNOWN ) {
			pInfo->type = checkIfWacomDevice (conf, pInfo->pszName);
		}
		else if (strstr(devName,"pad") != NULL)
			pInfo->type = WACOMDEVICETYPE_PAD;
		else
			pInfo->type = WACOMDEVICETYPE_UNKNOWN;

		if ( pInfo->type != WACOMDEVICETYPE_UNKNOWN )
		{

	return 0;
}

WACOMDEVICETYPE checkIfWacomDevice (XF86ConfigPtr conf, const char* pszDeviceName) {
	XF86ConfInputPtr ip;

	if (!conf || !pszDeviceName) {
		return WACOMDEVICETYPE_UNKNOWN;
	}

	ip = (XF86ConfInputPtr) conf->conf_input_lst;
	if (! ip) {
		return WACOMDEVICETYPE_UNKNOWN;
	}

	for (;ip;ip=ip->list.next) {
		XF86OptionPtr op = (XF86OptionPtr) ip->inp_option_lst;
		char* type = 0;

		if (! op) {
			return WACOMDEVICETYPE_UNKNOWN;
		}

		if (strcasecmp(ip->inp_identifier, pszDeviceName) != 0) {
			continue;
		}

		if (strcasecmp(ip->inp_driver,"wacom") != 0) {
			continue;
		}

		for (;op;op=op->list.next) {
			if (strcasecmp(op->opt_name,"Type") == 0) {
				type = op->opt_val;
				return mapStringToType(type);
			}
		}
	}
	
	return WACOMDEVICETYPE_UNKNOWN;
}

WACOMDEVICETYPE mapStringToType (const char* name) {
	if (!name)
		return WACOMDEVICETYPE_UNKNOWN;

	if (strstr(name,"cursor") != NULL)
		return WACOMDEVICETYPE_CURSOR;
	else if (strstr(name,"stylus") != NULL)
		return WACOMDEVICETYPE_STYLUS;
	else if (strstr(name,"eraser") != NULL)
		return WACOMDEVICETYPE_ERASER;
	else if (strstr(name,"pad") != NULL)
		return WACOMDEVICETYPE_PAD;
	else
		return WACOMDEVICETYPE_UNKNOWN;
	
}

WACOMDEVICE * WacomConfigOpenDevice(WACOMCONFIG * hConfig,
	const char* pszDeviceName)
{


	free(pvData);
}

XF86ConfigPtr readConfig (char *filename) {
	XF86ConfigPtr conf = 0;
	const char *file   = 0;
	char CONFPATH[]= "%A,%R,/etc/%R,%P/etc/X11/%R,%E,%F,/etc/X11/%F," \
			 "%P/etc/X11/%F,%D/%X,/etc/X11/%X,/etc/%X,%P/etc/X11/%X.%H," \
			 "%P/etc/X11/%X,%P/lib/X11/%X.%H,%P/lib/X11/%X";

	if (!(file = (char*)xf86openConfigFile (CONFPATH, filename, 0))) {
		fprintf (stderr, "Unable to open config file\n");
		return 0;
	}

	if ((conf = (XF86ConfigPtr)xf86readConfigFile ()) == 0) {
		fprintf (stderr, "Problem when parsing config file\n");
		xf86closeConfigFile ();
		return 0;
	}

	xf86closeConfigFile ();
	return conf;
}

void VErrorF(const char *f, va_list args) {
	vfprintf(stderr, f, args);
}

void ErrorF(const char *f, ...) {
	va_list args;
	va_start(args, f);
	vfprintf(stderr, f, args);
	va_end(args);
}

Lines 4-10 Link Here

(-)src/util/Makefile.am (-2 / +5 lines)
4	wacomcfgdir = $(includedir)/wacomcfg	4	wacomcfgdir = $(includedir)/wacomcfg
5	wacomcfg_HEADERS = wacomcfg.h	5	wacomcfg_HEADERS = wacomcfg.h
6		6
7	AM_CFLAGS = -Wall -pedantic	7	if WCM_ENV_XORGSDK
		8	WACOMCFG_INCLUDES = -I/usr/include/xorg $(X_CFLAGS)
		9	endif
		10	AM_CFLAGS = -Wall -pedantic $(WACOMCFG_INCLUDES)
8	DEPFLAGS = @WCM_DEPFLAGS@	11	DEPFLAGS = @WCM_DEPFLAGS@
9		12
10	# These identify which programs, libraries, and headers could	13	# These identify which programs, libraries, and headers could
Lines 27-33 Link Here
27		35
28	libwacomcfg_la_SOURCES = wacomcfg.c wacomcfg.h ../include/Xwacom.h	36	libwacomcfg_la_SOURCES = wacomcfg.c wacomcfg.h ../include/Xwacom.h
29	libwacomcfg_la_LDFLAGS = -no-undefined -version-info @WCM_LIBWACOMCFG_VER@	37	libwacomcfg_la_LDFLAGS = -no-undefined -version-info @WCM_LIBWACOMCFG_VER@
30	libwacomcfg_la_LIBADD = @WCM_LIBWACOMCFG_LIBS@	38	libwacomcfg_la_LIBADD = @WCM_LIBWACOMCFG_LIBS@ -lxf86config -lm
31		39
32	xsetwacom_SOURCES = xsetwacom.c wacomcfg.h wcmAction.c wcmAction.h ../include/Xwacom.h	40	xsetwacom_SOURCES = xsetwacom.c wacomcfg.h wcmAction.c wcmAction.h ../include/Xwacom.h
33	xsetwacom_LDADD = libwacomcfg.la	41	xsetwacom_LDADD = libwacomcfg.la

Return to bug 409366

Lines 41-51 Link Here

(-)src/util/wacomcfg.c (-14 / +114 lines)
41	#include <stdio.h> /* debugging only, we've got no business output text */	41	#include <stdio.h> /* debugging only, we've got no business output text */
42	#include <ctype.h>	42	#include <ctype.h>
43	#include <stdlib.h>	43	#include <stdlib.h>
		44	#include <stdarg.h>
44	#include <errno.h>	45	#include <errno.h>
45	#include <string.h>	46	#include <string.h>
46	#include <memory.h>	47	#include <memory.h>
47	#include <assert.h>	48	#include <assert.h>
48		49
		50	#include "xf86Parser.h"
		51
		52	WACOMDEVICETYPE checkIfWacomDevice (XF86ConfigPtr, const char* );
		53	WACOMDEVICETYPE mapStringToType (const char*);
		54	XF86ConfigPtr readConfig (char *);
		55	void VErrorF(const char*, va_list);
		56	void ErrorF (const char*, ...);
		57
49	/*****************************************************************************	58	/*****************************************************************************
50	** Internal structures	59	** Internal structures
51	*****************************************************************************/	60	*****************************************************************************/
Lines 123-128 Link Here
123	unsigned char* pReq;	132	unsigned char* pReq;
124	WACOMDEVICEINFO* pInfo;	133	WACOMDEVICEINFO* pInfo;
125	XDeviceInfo* info;	134	XDeviceInfo* info;
		135	XF86ConfigPtr conf;
126	char devName[64];	136	char devName[64];
127		137
128	if (!hConfig \|\| !ppInfo \|\| !puCount)	138	if (!hConfig \|\| !ppInfo \|\| !puCount)
Lines 132-143 Link Here
132	if (!hConfig->pDevs && CfgGetDevs(hConfig))	142	if (!hConfig->pDevs && CfgGetDevs(hConfig))
133	return -1;	143	return -1;
134		144
		145	/* read the config in for wacom devices which don'T use the commnon identifier */
		146	conf = readConfig ("/etc/X11/xorg.conf");
		147
135	/* estimate size of memory needed to hold structures */	148	/* estimate size of memory needed to hold structures */
136	nSize = nCount = 0;	149	nSize = nCount = 0;
137	for (i=0; i<hConfig->nDevCnt; ++i)	150	for (i=0; i<hConfig->nDevCnt; ++i)
138	{	151	{
139	info = hConfig->pDevs + i;	152	info = hConfig->pDevs + i;
140	if (info->use != IsXExtensionDevice) continue;	153	if (info->use != IsXExtensionDevice && info->use != IsXExtensionPointer) continue;
141	if (!info->num_classes) continue;	154	if (!info->num_classes) continue;
142	nSize += sizeof(WACOMDEVICEINFO);	155	nSize += sizeof(WACOMDEVICEINFO);
143	nSize += strlen(info->name) + 1;	156	nSize += strlen(info->name) + 1;
Lines 146-153 Link Here
146		159
147	/* allocate memory and zero */	160	/* allocate memory and zero */
148	pReq = (unsigned char*)malloc(nSize);	161	pReq = (unsigned char*)malloc(nSize);
149	if (!pReq) return CfgError(hConfig,errno,	162
150	"WacomConfigListDevices: failed to allocate memory");	163	if (!pReq)
		164	return CfgError(hConfig,errno, "WacomConfigListDevices: failed to allocate memory");
		165
151	memset(pReq,0,nSize);	166	memset(pReq,0,nSize);
152		167
153	/* populate data */	168	/* populate data */
Lines 158-164 Link Here
158	{	173	{
159	info = hConfig->pDevs + i;	174	info = hConfig->pDevs + i;
160	/* ignore non-extension devices */	175	/* ignore non-extension devices */
161	if (info->use != IsXExtensionDevice) continue;	176	if (info->use != IsXExtensionDevice && info->use != IsXExtensionPointer) continue;
162	/* ignore uninitialized tools */	177	/* ignore uninitialized tools */
163	if (!info->num_classes) continue;	178	if (!info->num_classes) continue;
164	/* copy name */	179	/* copy name */
Lines 170-185 Link Here
170	for (j=0; j<strlen(pInfo->pszName); j++)	185	for (j=0; j<strlen(pInfo->pszName); j++)
171	devName[j] = tolower(pInfo->pszName[j]);	186	devName[j] = tolower(pInfo->pszName[j]);
172	devName[j] = '\0';	187	devName[j] = '\0';
173	if (strstr(devName,"cursor") != NULL)	188
174	pInfo->type = WACOMDEVICETYPE_CURSOR;	189	pInfo->type = mapStringToType (devName);
175	else if (strstr(devName,"stylus") != NULL)	190
176	pInfo->type = WACOMDEVICETYPE_STYLUS;	191	if ( pInfo->type == WACOMDEVICETYPE_UNKNOWN ) {
177	else if (strstr(devName,"eraser") != NULL)	192	pInfo->type = checkIfWacomDevice (conf, pInfo->pszName);
178	pInfo->type = WACOMDEVICETYPE_ERASER;	193	}
179	else if (strstr(devName,"pad") != NULL)
180	pInfo->type = WACOMDEVICETYPE_PAD;
181	else
182	pInfo->type = WACOMDEVICETYPE_UNKNOWN;
183		194
184	if ( pInfo->type != WACOMDEVICETYPE_UNKNOWN )	195	if ( pInfo->type != WACOMDEVICETYPE_UNKNOWN )
185	{	196	{
Lines 196-201 Link Here
196	return 0;	207	return 0;
197	}	208	}
198		209
		210	WACOMDEVICETYPE checkIfWacomDevice (XF86ConfigPtr conf, const char* pszDeviceName) {
		211	XF86ConfInputPtr ip;
		212
		213	if (!conf \|\| !pszDeviceName) {
		214	return WACOMDEVICETYPE_UNKNOWN;
		215	}
		216
		217	ip = (XF86ConfInputPtr) conf->conf_input_lst;
		218	if (! ip) {
		219	return WACOMDEVICETYPE_UNKNOWN;
		220	}
		221
		222	for (;ip;ip=ip->list.next) {
		223	XF86OptionPtr op = (XF86OptionPtr) ip->inp_option_lst;
		224	char* type = 0;
		225
		226	if (! op) {
		227	return WACOMDEVICETYPE_UNKNOWN;
		228	}
		229
		230	if (strcasecmp(ip->inp_identifier, pszDeviceName) != 0) {
		231	continue;
		232	}
		233
		234	if (strcasecmp(ip->inp_driver,"wacom") != 0) {
		235	continue;
		236	}
		237
		238	for (;op;op=op->list.next) {
		239	if (strcasecmp(op->opt_name,"Type") == 0) {
		240	type = op->opt_val;
		241	return mapStringToType(type);
		242	}
		243	}
		244	}
		245
		246	return WACOMDEVICETYPE_UNKNOWN;
		247	}
		248
		249	WACOMDEVICETYPE mapStringToType (const char* name) {
		250	if (!name)
		251	return WACOMDEVICETYPE_UNKNOWN;
		252
		253	if (strstr(name,"cursor") != NULL)
		254	return WACOMDEVICETYPE_CURSOR;
		255	else if (strstr(name,"stylus") != NULL)
		256	return WACOMDEVICETYPE_STYLUS;
		257	else if (strstr(name,"eraser") != NULL)
		258	return WACOMDEVICETYPE_ERASER;
		259	else if (strstr(name,"pad") != NULL)
		260	return WACOMDEVICETYPE_PAD;
		261	else
		262	return WACOMDEVICETYPE_UNKNOWN;
		263
		264	}
		265
199	WACOMDEVICE * WacomConfigOpenDevice(WACOMCONFIG * hConfig,	266	WACOMDEVICE * WacomConfigOpenDevice(WACOMCONFIG * hConfig,
200	const char* pszDeviceName)	267	const char* pszDeviceName)
201	{	268	{
Lines 381-383 Link Here
381		448
382	free(pvData);	449	free(pvData);
383	}	450	}
		451
		452	XF86ConfigPtr readConfig (char *filename) {
		453	XF86ConfigPtr conf = 0;
		454	const char *file = 0;
		455	char CONFPATH[]= "%A,%R,/etc/%R,%P/etc/X11/%R,%E,%F,/etc/X11/%F," \
		456	"%P/etc/X11/%F,%D/%X,/etc/X11/%X,/etc/%X,%P/etc/X11/%X.%H," \
		457	"%P/etc/X11/%X,%P/lib/X11/%X.%H,%P/lib/X11/%X";
		458
		459	if (!(file = (char*)xf86openConfigFile (CONFPATH, filename, 0))) {
		460	fprintf (stderr, "Unable to open config file\n");
		461	return 0;
		462	}
		463
		464	if ((conf = (XF86ConfigPtr)xf86readConfigFile ()) == 0) {
		465	fprintf (stderr, "Problem when parsing config file\n");
		466	xf86closeConfigFile ();
		467	return 0;
		468	}
		469
		470	xf86closeConfigFile ();
		471	return conf;
		472	}
		473
		474	void VErrorF(const char *f, va_list args) {
		475	vfprintf(stderr, f, args);
		476	}
		477
		478	void ErrorF(const char *f, ...) {
		479	va_list args;
		480	va_start(args, f);
		481	vfprintf(stderr, f, args);
		482	va_end(args);
		483	}