/**
* Allocate a device pair that is initialised as a slave
* device with properties that identify the devices as belonging
* to XTest subsystem.
* This only creates the pair, Activate/Enable Device
* still need to be called.
*/
int AllocXTestDevice (ClientPtr client, char* name,
DeviceIntPtr* ptr, DeviceIntPtr* keybd,
DeviceIntPtr master_ptr, DeviceIntPtr master_keybd)
{
int retval;
int len = strlen(name);
char *xtestname = calloc(len + 7, 1 );
char dummy = 1;
strncpy( xtestname, name, len);
strncat( xtestname, " XTEST", 6 );
retval = AllocDevicePair( client, xtestname, ptr, keybd, CorePointerProc, CoreKeyboardProc, FALSE);
if ( retval == Success ){
(*ptr)->xtest_master_id = master_ptr->id;
(*keybd)->xtest_master_id = master_keybd->id;
XIChangeDeviceProperty(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
XA_INTEGER, 8, PropModeReplace, 1, &dummy,
FALSE);
XISetDevicePropertyDeletable(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), FALSE);
XIRegisterPropertyHandler(*ptr, DeviceSetXTestProperty, NULL, NULL);
XIChangeDeviceProperty(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
XA_INTEGER, 8, PropModeReplace, 1, &dummy,
FALSE);
XISetDevicePropertyDeletable(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), FALSE);
XIRegisterPropertyHandler(*keybd, DeviceSetXTestProperty, NULL, NULL);
}
free( xtestname );
return retval;
}
BOOL
DeletePredictableAccelerationProperties(DeviceIntPtr dev,
PredictableAccelSchemePtr scheme)
{
DeviceVelocityPtr vel;
Atom prop;
int i;
prop = XIGetKnownProperty(ACCEL_PROP_VELOCITY_SCALING);
XIDeleteDeviceProperty(dev, prop, FALSE);
prop = XIGetKnownProperty(ACCEL_PROP_ADAPTIVE_DECELERATION);
XIDeleteDeviceProperty(dev, prop, FALSE);
prop = XIGetKnownProperty(ACCEL_PROP_CONSTANT_DECELERATION);
XIDeleteDeviceProperty(dev, prop, FALSE);
prop = XIGetKnownProperty(ACCEL_PROP_PROFILE_NUMBER);
XIDeleteDeviceProperty(dev, prop, FALSE);
vel = GetDevicePredictableAccelData(dev);
if (vel) {
for (i = 0; i < scheme->num_prop_handlers; i++)
if (scheme->prop_handlers[i])
XIUnregisterPropertyHandler(dev, scheme->prop_handlers[i]);
}
free(scheme->prop_handlers);
scheme->prop_handlers = NULL;
scheme->num_prop_handlers = 0;
return TRUE;
}
static long
AccelInitAdaptDecelProperty(DeviceIntPtr dev, DeviceVelocityPtr vel)
{
float fval = 1.0/vel->min_acceleration;
Atom prop_adapt_decel = XIGetKnownProperty(ACCEL_PROP_ADAPTIVE_DECELERATION);
XIChangeDeviceProperty(dev, prop_adapt_decel, XIGetKnownProperty(XATOM_FLOAT), 32,
PropModeReplace, 1, &fval, FALSE);
XISetDevicePropertyDeletable(dev, prop_adapt_decel, FALSE);
return XIRegisterPropertyHandler(dev, AccelSetAdaptDecelProperty, NULL, NULL);
}
static long
AccelInitScaleProperty(DeviceIntPtr dev, DeviceVelocityPtr vel)
{
float fval = vel->corr_mul;
Atom prop_velo_scale = XIGetKnownProperty(ACCEL_PROP_VELOCITY_SCALING);
XIChangeDeviceProperty(dev, prop_velo_scale, XIGetKnownProperty(XATOM_FLOAT), 32,
PropModeReplace, 1, &fval, FALSE);
XISetDevicePropertyDeletable(dev, prop_velo_scale, FALSE);
return XIRegisterPropertyHandler(dev, AccelSetScaleProperty, NULL, NULL);
}
static void
AccelInitDecelProperty(DeviceIntPtr dev, DeviceVelocityPtr vel)
{
float fval = 1.0/vel->const_acceleration;
Atom prop_const_decel = XIGetKnownProperty(ACCEL_PROP_CONSTANT_DECELERATION);
XIChangeDeviceProperty(dev, prop_const_decel,
XIGetKnownProperty(XATOM_FLOAT), 32,
PropModeReplace, 1, &fval, FALSE);
XISetDevicePropertyDeletable(dev, prop_const_decel, FALSE);
XIRegisterPropertyHandler(dev, AccelSetDecelProperty, NULL, NULL);
}
/**
* adaptive deceleration
*/
static int
AccelSetAdaptDecelProperty(DeviceIntPtr dev, Atom atom,
XIPropertyValuePtr val, BOOL checkOnly)
{
DeviceVelocityPtr veloc;
float v, *ptr = &v;
int rc;
int nelem = 1;
if (atom != XIGetKnownProperty(ACCEL_PROP_ADAPTIVE_DECELERATION))
return Success;
veloc = GetDevicePredictableAccelData(dev);
if (!veloc)
return BadValue;
rc = XIPropToFloat(val, &nelem, &ptr);
if (checkOnly) {
if (rc)
return rc;
return (v >= 1.0f) ? Success : BadValue;
}
if (v >= 1.0f)
veloc->min_acceleration = 1 / v;
return Success;
}
/**
* constant deceleration
*/
static int
AccelSetDecelProperty(DeviceIntPtr dev, Atom atom,
XIPropertyValuePtr val, BOOL checkOnly)
{
DeviceVelocityPtr vel;
float v, *ptr = &v;
int rc;
int nelem = 1;
if (atom != XIGetKnownProperty(ACCEL_PROP_CONSTANT_DECELERATION))
return Success;
vel = GetDevicePredictableAccelData(dev);
if (!vel)
return BadValue;
rc = XIPropToFloat(val, &nelem, &ptr);
if (checkOnly) {
if (rc)
return rc;
return (v > 0) ? Success : BadValue;
}
vel->const_acceleration = 1 / v;
return Success;
}
/**
* choose profile
*/
static int
AccelSetProfileProperty(DeviceIntPtr dev, Atom atom,
XIPropertyValuePtr val, BOOL checkOnly)
{
DeviceVelocityPtr vel;
int profile, *ptr = &profile;
int rc;
int nelem = 1;
if (atom != XIGetKnownProperty(ACCEL_PROP_PROFILE_NUMBER))
return Success;
vel = GetDevicePredictableAccelData(dev);
if (!vel)
return BadValue;
rc = XIPropToInt(val, &nelem, &ptr);
if (checkOnly) {
if (rc)
return rc;
if (GetAccelerationProfile(vel, profile) == NULL)
return BadValue;
}
else
SetAccelerationProfile(vel, profile);
return Success;
}
/**
* velocity scaling
*/
static int
AccelSetScaleProperty(DeviceIntPtr dev, Atom atom,
XIPropertyValuePtr val, BOOL checkOnly)
{
DeviceVelocityPtr vel;
float v, *ptr = &v;
int rc;
int nelem = 1;
if (atom != XIGetKnownProperty(ACCEL_PROP_VELOCITY_SCALING))
return Success;
vel = GetDevicePredictableAccelData(dev);
if (!vel)
return BadValue;
rc = XIPropToFloat(val, &nelem, &ptr);
if (checkOnly) {
if (rc)
return rc;
return (v > 0) ? Success : BadValue;
}
if (v > 0)
vel->corr_mul = v;
return Success;
}
static int
vfbMouseProc(DeviceIntPtr pDevice, int onoff)
{
#define NBUTTONS 3
#define NAXES 2
BYTE map[NBUTTONS + 1];
DevicePtr pDev = (DevicePtr) pDevice;
Atom btn_labels[NBUTTONS] = { 0 };
Atom axes_labels[NAXES] = { 0 };
switch (onoff) {
case DEVICE_INIT:
map[1] = 1;
map[2] = 2;
map[3] = 3;
btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
InitPointerDeviceStruct(pDev, map, NBUTTONS, btn_labels,
(PtrCtrlProcPtr) NoopDDA,
GetMotionHistorySize(), NAXES, axes_labels);
break;
case DEVICE_ON:
pDev->on = TRUE;
break;
case DEVICE_OFF:
pDev->on = FALSE;
break;
case DEVICE_CLOSE:
break;
}
return Success;
#undef NBUTTONS
#undef NAXES
}
/**
* Don't allow changing the XTest property.
*/
static int
DeviceSetXTestProperty(DeviceIntPtr dev, Atom property,
XIPropertyValuePtr prop, BOOL checkonly)
{
if (property == XIGetKnownProperty(XI_PROP_XTEST_DEVICE))
return BadAccess;
return Success;
}
static long
AccelInitProfileProperty(DeviceIntPtr dev, DeviceVelocityPtr vel)
{
int profile = vel->statistics.profile_number;
Atom prop_profile_number = XIGetKnownProperty(ACCEL_PROP_PROFILE_NUMBER);
XIChangeDeviceProperty(dev, prop_profile_number, XA_INTEGER, 32,
PropModeReplace, 1, &profile, FALSE);
XISetDevicePropertyDeletable(dev, prop_profile_number, FALSE);
return XIRegisterPropertyHandler(dev, AccelSetProfileProperty, NULL, NULL);
}
/**
* Allocate a device pair that is initialised as a slave
* device with properties that identify the devices as belonging
* to XTest subsystem.
* This only creates the pair, Activate/Enable Device
* still need to be called.
*/
int
AllocXTestDevice(ClientPtr client, const char *name,
DeviceIntPtr *ptr, DeviceIntPtr *keybd,
DeviceIntPtr master_ptr, DeviceIntPtr master_keybd)
{
int retval;
char *xtestname;
char dummy = 1;
if (asprintf(&xtestname, "%s XTEST", name) == -1)
return BadAlloc;
retval =
AllocDevicePair(client, xtestname, ptr, keybd, CorePointerProc,
CoreKeyboardProc, FALSE);
if (retval == Success) {
(*ptr)->xtest_master_id = master_ptr->id;
(*keybd)->xtest_master_id = master_keybd->id;
XIChangeDeviceProperty(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
XA_INTEGER, 8, PropModeReplace, 1, &dummy,
FALSE);
XISetDevicePropertyDeletable(*ptr,
XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
FALSE);
XIRegisterPropertyHandler(*ptr, DeviceSetXTestProperty, NULL, NULL);
XIChangeDeviceProperty(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
XA_INTEGER, 8, PropModeReplace, 1, &dummy,
FALSE);
XISetDevicePropertyDeletable(*keybd,
XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
FALSE);
XIRegisterPropertyHandler(*keybd, DeviceSetXTestProperty, NULL, NULL);
}
free(xtestname);
return retval;
}
/**
* Each xtest devices has a property attached marking it. This property
* cannot be changed.
*/
static void xtest_properties(void)
{
int rc;
char value = 1;
XIPropertyValuePtr prop;
Atom xtest_prop = XIGetKnownProperty(XI_PROP_XTEST_DEVICE);
rc = XIGetDeviceProperty(xtestpointer, xtest_prop, &prop);
g_assert(rc == Success);
g_assert(prop);
rc = XIGetDeviceProperty(xtestkeyboard, xtest_prop, &prop);
g_assert(rc == Success);
g_assert(prop != NULL);
rc = XIChangeDeviceProperty(xtestpointer, xtest_prop,
XA_INTEGER, 8, PropModeReplace, 1, &value, FALSE);
g_assert(rc == BadAccess);
rc = XIChangeDeviceProperty(xtestkeyboard, xtest_prop,
XA_INTEGER, 8, PropModeReplace, 1, &value, FALSE);
g_assert(rc == BadAccess);
}
/* This is essentially CorePointerProc with ScrollAxes added */
static int
TestPointerProc(DeviceIntPtr pDev, int what)
{
#define NBUTTONS 10
#define NAXES 4
BYTE map[NBUTTONS + 1];
int i = 0;
Atom btn_labels[NBUTTONS] = { 0 };
Atom axes_labels[NAXES] = { 0 };
switch (what) {
case DEVICE_INIT:
for (i = 1; i <= NBUTTONS; i++)
map[i] = i;
btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
/* don't know about the rest */
axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_VSCROLL);
axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_HSCROLL);
if (!InitPointerDeviceStruct
((DevicePtr) pDev, map, NBUTTONS, btn_labels,
(PtrCtrlProcPtr) NoopDDA, GetMotionHistorySize(), NAXES,
axes_labels)) {
ErrorF("Could not initialize device '%s'. Out of memory.\n",
pDev->name);
return BadAlloc;
}
pDev->valuator->axisVal[0] = screenInfo.screens[0]->width / 2;
pDev->last.valuators[0] = pDev->valuator->axisVal[0];
pDev->valuator->axisVal[1] = screenInfo.screens[0]->height / 2;
pDev->last.valuators[1] = pDev->valuator->axisVal[1];
/* protocol-xiquerydevice.c relies on these increment */
SetScrollValuator(pDev, 2, SCROLL_TYPE_VERTICAL, 2.4, SCROLL_FLAG_NONE);
SetScrollValuator(pDev, 3, SCROLL_TYPE_HORIZONTAL, 3.5,
SCROLL_FLAG_PREFERRED);
break;
case DEVICE_CLOSE:
break;
default:
break;
}
return Success;
#undef NBUTTONS
#undef NAXES
}
void mprops_init(struct MConfig* cfg, InputInfoPtr local) {
int ivals[MAX_INT_VALUES];
float fvals[MAX_FLOAT_VALUES];
mprops.float_type = XIGetKnownProperty(XATOM_FLOAT);
if (!mprops.float_type) {
mprops.float_type = MakeAtom(XATOM_FLOAT, strlen(XATOM_FLOAT), TRUE);
if (!mprops.float_type) {
xf86Msg(X_ERROR, "mtrack: %s: Failed to init float atom. Property support is disabled.\n", local->name);
return;
}
}
ivals[0] = cfg->trackpad_disable;
mprops.trackpad_disable = atom_init_integer(local->dev, MTRACK_PROP_TRACKPAD_DISABLE, 1, ivals, 8);
fvals[0] = (float)cfg->sensitivity;
mprops.sensitivity = atom_init_float(local->dev, MTRACK_PROP_SENSITIVITY, 1, fvals, mprops.float_type);
ivals[0] = cfg->touch_down;
ivals[1] = cfg->touch_up;
mprops.pressure = atom_init_integer(local->dev, MTRACK_PROP_PRESSURE, 2, ivals, 8);
ivals[0] = cfg->button_enable;
ivals[1] = cfg->button_integrated;
mprops.button_settings = atom_init_integer(local->dev, MTRACK_PROP_BUTTON_SETTINGS, 2, ivals, 8);
ivals[0] = cfg->button_zones;
ivals[1] = cfg->button_move;
ivals[2] = cfg->button_expire;
mprops.button_emulate_settings = atom_init_integer(local->dev, MTRACK_PROP_BUTTON_EMULATE_SETTINGS, 3, ivals, 16);
ivals[0] = cfg->button_1touch;
ivals[1] = cfg->button_2touch;
ivals[2] = cfg->button_3touch;
mprops.button_emulate_values = atom_init_integer(local->dev, MTRACK_PROP_BUTTON_EMULATE_VALUES, 3, ivals, 8);
ivals[0] = cfg->tap_hold;
ivals[1] = cfg->tap_timeout;
ivals[2] = cfg->tap_dist;
mprops.tap_settings = atom_init_integer(local->dev, MTRACK_PROP_TAP_SETTINGS, 3, ivals, 32);
ivals[0] = cfg->tap_1touch;
ivals[1] = cfg->tap_2touch;
ivals[2] = cfg->tap_3touch;
ivals[3] = cfg->tap_4touch;
mprops.tap_emulate = atom_init_integer(local->dev, MTRACK_PROP_TAP_EMULATE, 4, ivals, 8);
ivals[0] = cfg->single_finger;
mprops.single_finger = atom_init_integer(local->dev, MTRACK_PROP_SINGLE_FINGER, 1, ivals, 8);
ivals[0] = cfg->ignore_thumb;
ivals[1] = cfg->disable_on_thumb;
mprops.thumb_detect = atom_init_integer(local->dev, MTRACK_PROP_THUMB_DETECT, 2, ivals, 8);
ivals[0] = cfg->thumb_size;
ivals[1] = cfg->thumb_ratio;
mprops.thumb_size = atom_init_integer(local->dev, MTRACK_PROP_THUMB_SIZE, 2, ivals, 32);
ivals[0] = cfg->ignore_palm;
ivals[1] = cfg->disable_on_palm;
mprops.palm_detect = atom_init_integer(local->dev, MTRACK_PROP_PALM_DETECT, 2, ivals, 8);
ivals[0] = cfg->palm_size;
mprops.palm_size = atom_init_integer(local->dev, MTRACK_PROP_PALM_SIZE, 1, ivals, 32);
ivals[0] = cfg->gesture_hold;
ivals[1] = cfg->gesture_wait;
mprops.gesture_settings = atom_init_integer(local->dev, MTRACK_PROP_GESTURE_SETTINGS, 2, ivals, 16);
ivals[0] = cfg->scroll_dist;
mprops.scroll_dist = atom_init_integer(local->dev, MTRACK_PROP_SCROLL_DIST, 1, ivals, 32);
ivals[0] = cfg->scroll_up_btn;
ivals[1] = cfg->scroll_dn_btn;
ivals[2] = cfg->scroll_lt_btn;
ivals[3] = cfg->scroll_rt_btn;
mprops.scroll_buttons = atom_init_integer(local->dev, MTRACK_PROP_SCROLL_BUTTONS, 4, ivals, 8);
ivals[0] = cfg->swipe_dist;
mprops.swipe_dist = atom_init_integer(local->dev, MTRACK_PROP_SWIPE_DIST, 1, ivals, 32);
ivals[0] = cfg->swipe_up_btn;
ivals[1] = cfg->swipe_dn_btn;
ivals[2] = cfg->swipe_lt_btn;
ivals[3] = cfg->swipe_rt_btn;
mprops.swipe_buttons = atom_init_integer(local->dev, MTRACK_PROP_SWIPE_BUTTONS, 4, ivals, 8);
ivals[0] = cfg->swipe4_dist;
mprops.swipe4_dist = atom_init_integer(local->dev, MTRACK_PROP_SWIPE4_DIST, 1, ivals, 32);
ivals[0] = cfg->swipe4_up_btn;
ivals[1] = cfg->swipe4_dn_btn;
ivals[2] = cfg->swipe4_lt_btn;
ivals[3] = cfg->swipe4_rt_btn;
mprops.swipe4_buttons = atom_init_integer(local->dev, MTRACK_PROP_SWIPE4_BUTTONS, 4, ivals, 8);
ivals[0] = cfg->scale_dist;
mprops.scale_dist = atom_init_integer(local->dev, MTRACK_PROP_SCALE_DIST, 1, ivals, 32);
ivals[0] = cfg->scale_up_btn;
ivals[1] = cfg->scale_dn_btn;
mprops.scale_buttons = atom_init_integer(local->dev, MTRACK_PROP_SCALE_BUTTONS, 2, ivals, 8);
ivals[0] = cfg->rotate_dist;
mprops.rotate_dist = atom_init_integer(local->dev, MTRACK_PROP_ROTATE_DIST, 1, ivals, 32);
ivals[0] = cfg->rotate_lt_btn;
ivals[1] = cfg->rotate_rt_btn;
mprops.rotate_buttons = atom_init_integer(local->dev, MTRACK_PROP_ROTATE_BUTTONS, 2, ivals, 8);
ivals[0] = cfg->drag_enable;
ivals[1] = cfg->drag_timeout;
ivals[2] = cfg->drag_wait;
ivals[3] = cfg->drag_dist;
mprops.drag_settings = atom_init_integer(local->dev, MTRACK_PROP_DRAG_SETTINGS, 4, ivals, 32);
ivals[0] = cfg->axis_x_invert;
ivals[1] = cfg->axis_y_invert;
mprops.axis_invert = atom_init_integer(local->dev, MTRACK_PROP_AXIS_INVERT, 2, ivals, 8);
}
static int device_init(DeviceIntPtr dev, InputInfoPtr local)
{
struct mtev_mtouch *mt = local->private;
Atom atom;
int i;
int j;
unsigned char map[MT_NUM_BUTTONS + 1];
Atom btn_labels[MT_NUM_BUTTONS] = { 0 };
Atom axes_labels[MT_NUM_VALUATORS] = { 0, };
int r;
if (MT_NUM_VALUATORS > MAX_VALUATORS) {
xf86Msg(X_ERROR, "MT_NUM_VALUATORS(%d) > MAX_VALUATORS(%d)\n",
MT_NUM_VALUATORS, MAX_VALUATORS);
return BadValue;
}
for (i = 0; i < MT_NUM_BUTTONS; i++)
btn_labels[i] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_UNKNOWN);
atom = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
btn_labels[0] = atom;
init_axes_labels(axes_labels, MT_NUM_VALUATORS);
r = init_properties(dev);
if (r != Success)
return r;
local->fd = xf86OpenSerial(local->options);
if (local->fd < 0) {
xf86Msg(X_ERROR, "mtev: cannot open device\n");
return !Success;
}
if (mtouch_configure(mt, local->fd)) {
xf86Msg(X_ERROR, "mtev: cannot configure device\n");
return !Success;
}
xf86CloseSerial(local->fd);
for (i = 0; i < MT_NUM_BUTTONS+1; i++)
map[i] = i;
InitPointerDeviceStruct((DevicePtr)dev,
map,
MT_NUM_BUTTONS,
btn_labels,
pointer_control,
GetMotionHistorySize(),
MT_NUM_VALUATORS,
axes_labels);
for (i = 0; i < MT_NUM_FINGERS; i++) {
for (j = 0; j < MT_AXIS_PER_FINGER; j++) {
const int val = (i * MT_AXIS_PER_FINGER) + j;
int min;
int max;
switch (j) {
case 0:
min = mt->caps.abs_position_x.minimum;
max = mt->caps.abs_position_x.maximum;
if (mt->swap_xy) {
mt->min_y = min;
mt->max_y = max;
} else {
mt->min_x = min;
mt->max_x = max;
}
break;
case 1:
min = mt->caps.abs_position_y.minimum;
max = mt->caps.abs_position_y.maximum;
if (mt->swap_xy) {
mt->min_x = min;
mt->max_x = max;
} else {
mt->min_y = min;
mt->max_y = max;
}
break;
case 2:
min = mt->caps.abs_touch_major.minimum;
max = mt->caps.abs_touch_major.maximum;
break;
case 3:
if (mt->caps.has_touch_minor) {
min = mt->caps.abs_touch_minor.minimum;
max = mt->caps.abs_touch_minor.maximum;
} else {
min = mt->caps.abs_touch_major.minimum;
max = mt->caps.abs_touch_major.maximum;
}
break;
case 4: // Tracking id
min = mt->caps.abs_tracking_id.minimum;
max = mt->caps.abs_tracking_id.maximum >
(MT_NUM_FINGERS-1) ?
(MT_NUM_FINGERS-1) :
mt->caps.abs_tracking_id.maximum;
break;
default:
return BadValue;
}
xf86InitValuatorAxisStruct(dev, val, axes_labels[val],
min,
max,
1, 0, 1, Absolute);
xf86InitValuatorDefaults(dev, val);
}
}
XIRegisterPropertyHandler(dev, pointer_property, NULL, NULL);
return Success;
}
atom = MakeAtom(name, strlen(name), TRUE);
XIChangeDeviceProperty(dev, atom, float_type, 32, PropModeReplace,
nvalues, values, FALSE);
XISetDevicePropertyDeletable(dev, atom, FALSE);
return atom;
}
void
InitDeviceProperties(InputInfoPtr pInfo)
{
SynapticsPrivate *priv = (SynapticsPrivate *) pInfo->private;
SynapticsParameters *para = &priv->synpara;
int values[9]; /* we never have more than 9 values in an atom */
float fvalues[4]; /* never have more than 4 float values */
float_type = XIGetKnownProperty(XATOM_FLOAT);
if (!float_type)
{
float_type = MakeAtom(XATOM_FLOAT, strlen(XATOM_FLOAT), TRUE);
if (!float_type)
{
xf86IDrvMsg(pInfo, X_ERROR, "Failed to init float atom. "
"Disabling property support.\n");
return;
}
}
values[0] = para->left_edge;
values[1] = para->right_edge;
values[2] = para->top_edge;
values[3] = para->bottom_edge;
int
winMouseProc (DeviceIntPtr pDeviceInt, int iState)
{
int lngMouseButtons, i;
int lngWheelEvents = 2;
CARD8 *map;
DevicePtr pDevice = (DevicePtr) pDeviceInt;
Atom *btn_labels;
Atom axes_labels[2];
switch (iState)
{
case DEVICE_INIT:
/* Get number of mouse buttons */
lngMouseButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
/* Mapping of windows events to X events:
* LEFT:1 MIDDLE:2 RIGHT:3
* SCROLL_UP:4 SCROLL_DOWN:5
* XBUTTON 1:6 XBUTTON 2:7 ...
*
* To map scroll wheel correctly we need at least the 3 normal buttons
*/
if (lngMouseButtons < 3)
lngMouseButtons = 3;
winMsg(X_PROBED, "%d mouse buttons found\n", lngMouseButtons);
/* allocate memory:
* number of buttons + 2x mouse wheel event + 1 extra (offset for map)
*/
map = malloc(sizeof(CARD8) * (lngMouseButtons + lngWheelEvents + 1));
/* initalize button map */
map[0] = 0;
for (i=1; i <= lngMouseButtons + lngWheelEvents; i++)
map[i] = i;
btn_labels = calloc((lngMouseButtons + lngWheelEvents), sizeof(Atom));
btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
InitPointerDeviceStruct (pDevice,
map,
lngMouseButtons + lngWheelEvents,
btn_labels,
winMouseCtrl,
GetMotionHistorySize(),
2,
axes_labels);
free(map);
free(btn_labels);
#if defined(XFree86Server)
g_winMouseButtonMap = pDeviceInt->button->map;
#endif
break;
case DEVICE_ON:
pDevice->on = TRUE;
break;
case DEVICE_CLOSE:
#if defined(XFree86Server)
g_winMouseButtonMap = NULL;
#endif
case DEVICE_OFF:
pDevice->on = FALSE;
break;
}
return Success;
}
