2003-11-25 20:29:01 +01:00
|
|
|
/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Xinput.c,v 3.70 2003/11/03 05:11:02 tsi Exp $ */
|
2003-11-14 16:54:54 +01:00
|
|
|
/*
|
2003-11-14 17:49:22 +01:00
|
|
|
* Copyright 1995-1999 by Frederic Lepied, France. <Lepied@XFree86.org>
|
2003-11-14 16:54:54 +01:00
|
|
|
*
|
|
|
|
* 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 Frederic Lepied not be used in
|
|
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
|
|
* specific, written prior permission. Frederic Lepied makes no
|
|
|
|
* representations about the suitability of this software for any purpose. It
|
|
|
|
* is provided "as is" without express or implied warranty.
|
|
|
|
*
|
|
|
|
* FREDERIC LEPIED DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
|
* EVENT SHALL FREDERIC LEPIED 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.
|
|
|
|
*
|
|
|
|
*/
|
2003-11-25 20:29:01 +01:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2000-2002 by The XFree86 Project, Inc.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Except as contained in this notice, the name of the copyright holder(s)
|
|
|
|
* and author(s) shall not be used in advertising or otherwise to promote
|
|
|
|
* the sale, use or other dealings in this Software without prior written
|
|
|
|
* authorization from the copyright holder(s) and author(s).
|
|
|
|
*/
|
|
|
|
/* $XConsortium: xf86Xinput.c /main/14 1996/10/27 11:05:25 kaleb $ */
|
2005-01-19 23:23:20 +01:00
|
|
|
/* $XdotOrg: $ */
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#include "Xfuncproto.h"
|
2003-11-14 16:54:54 +01:00
|
|
|
#include "Xmd.h"
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef XINPUT
|
2003-11-14 16:54:54 +01:00
|
|
|
#include "XI.h"
|
|
|
|
#include "XIproto.h"
|
2003-11-14 17:49:22 +01:00
|
|
|
#endif
|
2003-11-14 16:54:54 +01:00
|
|
|
#include "xf86.h"
|
|
|
|
#include "xf86Priv.h"
|
|
|
|
#include "xf86Xinput.h"
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef XINPUT
|
|
|
|
#include "XIstubs.h"
|
|
|
|
#endif
|
2003-11-14 16:54:54 +01:00
|
|
|
#include "mipointer.h"
|
2003-11-14 17:49:22 +01:00
|
|
|
#include "xf86InPriv.h"
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
#ifdef DPMSExtension
|
2003-11-14 17:49:22 +01:00
|
|
|
#define DPMS_SERVER
|
2003-11-14 16:54:54 +01:00
|
|
|
#include "extensions/dpms.h"
|
2003-11-14 17:49:22 +01:00
|
|
|
#include "dpmsproc.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef XFreeXDGA
|
|
|
|
#include "dgaproc.h"
|
2003-11-14 16:54:54 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "exevents.h" /* AddInputDevice */
|
2003-11-14 17:49:22 +01:00
|
|
|
#include "exglobals.h"
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#define EXTENSION_PROC_ARGS void *
|
2003-11-14 16:54:54 +01:00
|
|
|
#include "extnsionst.h"
|
|
|
|
#include "extinit.h" /* LookupDeviceIntRec */
|
|
|
|
|
|
|
|
#include "windowstr.h" /* screenIsSaved */
|
|
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#include "osdep.h" /* EnabledDevices */
|
|
|
|
#include "Xpoll.h"
|
|
|
|
#include "xf86_OSproc.h" /* sigio stuff */
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
/******************************************************************************
|
|
|
|
* debugging macro
|
|
|
|
*****************************************************************************/
|
|
|
|
#ifdef DBG
|
|
|
|
#undef DBG
|
2003-11-14 16:54:54 +01:00
|
|
|
#endif
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef DEBUG
|
|
|
|
#undef DEBUG
|
2003-11-14 16:54:54 +01:00
|
|
|
#endif
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#define DEBUG 0
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#if DEBUG
|
|
|
|
static int debug_level = 0;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#define DBG(lvl, f) {if ((lvl) <= debug_level) f;}
|
|
|
|
#else
|
|
|
|
#define DBG(lvl, f)
|
|
|
|
#endif
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
/******************************************************************************
|
|
|
|
* macros
|
|
|
|
*****************************************************************************/
|
|
|
|
#define ENQUEUE(e) xf86eqEnqueue((e))
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* xf86AlwaysCoreControl --
|
|
|
|
*
|
|
|
|
* Control proc for the integer feedback that controls the always
|
|
|
|
* core feature.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xf86AlwaysCoreControl(DeviceIntPtr device,
|
|
|
|
IntegerCtrl *control)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Core devices functions --
|
|
|
|
*
|
|
|
|
* Test if device is the core device by checking the
|
|
|
|
* value of always core feedback and the inputInfo struct.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xf86IsCorePointer(DeviceIntPtr device)
|
2003-11-14 17:49:22 +01:00
|
|
|
{
|
|
|
|
return(device == inputInfo.pointer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xf86ShareCorePointer(DeviceIntPtr device)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
LocalDevicePtr local = (LocalDevicePtr) device->public.devicePrivate;
|
|
|
|
|
|
|
|
return((local->always_core_feedback &&
|
2003-11-14 17:49:22 +01:00
|
|
|
local->always_core_feedback->ctrl.integer_displayed));
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
static Bool
|
|
|
|
xf86SendDragEvents(DeviceIntPtr device)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2003-11-14 17:49:22 +01:00
|
|
|
LocalDevicePtr local = (LocalDevicePtr) device->public.devicePrivate;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (inputInfo.pointer->button->buttonsDown > 0)
|
|
|
|
return (local->flags & XI86_SEND_DRAG_EVENTS);
|
|
|
|
else
|
|
|
|
return (TRUE);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xf86IsCoreKeyboard(DeviceIntPtr device)
|
|
|
|
{
|
|
|
|
LocalDevicePtr local = (LocalDevicePtr) device->public.devicePrivate;
|
|
|
|
|
|
|
|
return((local->flags & XI86_ALWAYS_CORE) ||
|
|
|
|
(device == inputInfo.keyboard));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2003-11-14 17:49:22 +01:00
|
|
|
xf86XInputSetSendCoreEvents(LocalDevicePtr local, Bool always)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
if (always) {
|
|
|
|
local->flags |= XI86_ALWAYS_CORE;
|
|
|
|
} else {
|
|
|
|
local->flags &= ~XI86_ALWAYS_CORE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
static int xf86CoreButtonState;
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* xf86CheckButton --
|
|
|
|
*
|
|
|
|
* Test if the core pointer button state is coherent with
|
|
|
|
* the button event to send.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
Bool
|
|
|
|
xf86CheckButton(int button,
|
|
|
|
int down)
|
|
|
|
{
|
2003-11-14 17:49:22 +01:00
|
|
|
int check;
|
|
|
|
int bit = (1 << (button - 1));
|
|
|
|
|
|
|
|
check = xf86CoreButtonState & bit;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
DBG(5, ErrorF("xf86CheckButton "
|
|
|
|
"button=%d down=%d state=%d check=%d returns ",
|
2005-01-19 23:23:20 +01:00
|
|
|
button, down, xf86CoreButtonState, check));
|
2003-11-14 17:49:22 +01:00
|
|
|
if ((check && down) || (!check && !down)) {
|
|
|
|
DBG(5, ErrorF("FALSE\n"));
|
2003-11-14 16:54:54 +01:00
|
|
|
return FALSE;
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
xf86CoreButtonState ^= bit;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
DBG(5, ErrorF("TRUE\n"));
|
2003-11-14 16:54:54 +01:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
2003-11-14 17:49:22 +01:00
|
|
|
* xf86ProcessCommonOptions --
|
|
|
|
*
|
|
|
|
* Process global options.
|
2003-11-14 16:54:54 +01:00
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
2003-11-14 17:49:22 +01:00
|
|
|
void
|
|
|
|
xf86ProcessCommonOptions(LocalDevicePtr local,
|
|
|
|
pointer list)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2003-11-14 17:49:22 +01:00
|
|
|
if (xf86SetBoolOption(list, "AlwaysCore", 0) ||
|
|
|
|
xf86SetBoolOption(list, "SendCoreEvents", 0)) {
|
|
|
|
local->flags |= XI86_ALWAYS_CORE;
|
|
|
|
xf86Msg(X_CONFIG, "%s: always reports core events\n", local->name);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (xf86SetBoolOption(list, "CorePointer", 0)) {
|
|
|
|
local->flags |= XI86_CORE_POINTER;
|
|
|
|
xf86Msg(X_CONFIG, "%s: Core Pointer\n", local->name);
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (xf86SetBoolOption(list, "CoreKeyboard", 0)) {
|
|
|
|
local->flags |= XI86_CORE_KEYBOARD;
|
|
|
|
xf86Msg(X_CONFIG, "%s: Core Keyboard\n", local->name);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (xf86SetBoolOption(list, "SendDragEvents", 1)) {
|
|
|
|
local->flags |= XI86_SEND_DRAG_EVENTS;
|
2003-11-14 16:54:54 +01:00
|
|
|
} else {
|
2003-11-14 17:49:22 +01:00
|
|
|
xf86Msg(X_CONFIG, "%s: doesn't report drag events\n", local->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
local->history_size = xf86SetIntOption(list, "HistorySize", 0);
|
|
|
|
|
|
|
|
if (local->history_size > 0) {
|
|
|
|
xf86Msg(X_CONFIG, "%s: has a history of %d motions\n", local->name,
|
|
|
|
local->history_size);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* xf86XinputFinalizeInit --
|
|
|
|
*
|
|
|
|
* Create and initialize an integer feedback to control the always
|
|
|
|
* core feature.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xf86XinputFinalizeInit(DeviceIntPtr dev)
|
|
|
|
{
|
|
|
|
LocalDevicePtr local = (LocalDevicePtr)dev->public.devicePrivate;
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
local->dxremaind = 0.0;
|
|
|
|
local->dyremaind = 0.0;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
if (InitIntegerFeedbackClassDeviceStruct(dev, xf86AlwaysCoreControl) == FALSE) {
|
|
|
|
ErrorF("Unable to init integer feedback for always core feature\n");
|
|
|
|
} else {
|
|
|
|
local->always_core_feedback = dev->intfeed;
|
|
|
|
dev->intfeed->ctrl.integer_displayed = (local->flags & XI86_ALWAYS_CORE) ? 1 : 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
2003-11-14 17:49:22 +01:00
|
|
|
* xf86ActivateDevice --
|
2003-11-14 16:54:54 +01:00
|
|
|
*
|
2003-11-14 17:49:22 +01:00
|
|
|
* Initialize an input device.
|
2003-11-14 16:54:54 +01:00
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
void
|
2003-11-14 17:49:22 +01:00
|
|
|
xf86ActivateDevice(LocalDevicePtr local)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
DeviceIntPtr dev;
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (local->flags & XI86_CONFIGURED) {
|
|
|
|
int open_on_init;
|
|
|
|
|
|
|
|
open_on_init = local->flags &
|
|
|
|
(XI86_OPEN_ON_INIT |
|
|
|
|
XI86_ALWAYS_CORE | XI86_CORE_POINTER | XI86_CORE_KEYBOARD);
|
|
|
|
|
|
|
|
dev = AddInputDevice(local->device_control,
|
|
|
|
open_on_init);
|
|
|
|
if (dev == NULL)
|
|
|
|
FatalError("Too many input devices");
|
|
|
|
|
|
|
|
local->atom = MakeAtom(local->name,
|
|
|
|
strlen(local->name),
|
|
|
|
TRUE);
|
|
|
|
AssignTypeAndName (dev, local->atom, local->name);
|
|
|
|
dev->public.devicePrivate = (pointer) local;
|
|
|
|
local->dev = dev;
|
|
|
|
|
|
|
|
xf86XinputFinalizeInit(dev);
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
/*
|
|
|
|
* XXX Can a single device instance be both core keyboard and
|
|
|
|
* core pointer? If so, this should be changed.
|
|
|
|
*/
|
|
|
|
if (local->flags & XI86_CORE_POINTER)
|
|
|
|
RegisterPointerDevice(dev);
|
|
|
|
else if (local->flags & XI86_CORE_KEYBOARD)
|
|
|
|
RegisterKeyboardDevice(dev);
|
|
|
|
#ifdef XINPUT
|
|
|
|
else
|
2003-11-14 16:54:54 +01:00
|
|
|
RegisterOtherDevice(dev);
|
2003-11-14 17:49:22 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (serverGeneration == 1)
|
|
|
|
xf86Msg(X_INFO, "XINPUT: Adding extended input device \"%s\" (type: %s)\n",
|
|
|
|
local->name, local->type_name);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef XINPUT
|
2003-11-14 16:54:54 +01:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXOpenDevice
|
|
|
|
*
|
|
|
|
* This is the implementation-dependent routine to open an input device.
|
|
|
|
* Some implementations open all input devices when the server is first
|
|
|
|
* initialized, and never close them. Other implementations open only
|
|
|
|
* the X pointer and keyboard devices during server initialization,
|
|
|
|
* and only open other input devices when some client makes an
|
|
|
|
* XOpenDevice request. This entry point is for the latter type of
|
|
|
|
* implementation.
|
|
|
|
*
|
|
|
|
* If the physical device is not already open, do it here. In this case,
|
|
|
|
* you need to keep track of the fact that one or more clients has the
|
|
|
|
* device open, and physically close it when the last client that has
|
|
|
|
* it open does an XCloseDevice.
|
|
|
|
*
|
|
|
|
* The default implementation is to do nothing (assume all input devices
|
|
|
|
* are opened during X server initialization and kept open).
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
2003-11-14 17:49:22 +01:00
|
|
|
OpenInputDevice(DeviceIntPtr dev,
|
|
|
|
ClientPtr client,
|
|
|
|
int *status)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
if (!dev->inited) {
|
|
|
|
*status = BadDevice;
|
|
|
|
} else {
|
|
|
|
if (!dev->public.on) {
|
|
|
|
if (!EnableDevice(dev)) {
|
|
|
|
*status = BadDevice;
|
|
|
|
} else {
|
|
|
|
/* to prevent ProcXOpenDevice to call EnableDevice again */
|
|
|
|
dev->startup = FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXChangeKeyboardDevice
|
|
|
|
*
|
|
|
|
* This procedure does the implementation-dependent portion of the work
|
|
|
|
* needed to change the keyboard device.
|
|
|
|
*
|
|
|
|
* The X keyboard device has a FocusRec. If the device that has been
|
|
|
|
* made into the new X keyboard did not have a FocusRec,
|
|
|
|
* ProcXChangeKeyboardDevice will allocate one for it.
|
|
|
|
*
|
|
|
|
* If you do not want clients to be able to focus the old X keyboard
|
|
|
|
* device, call DeleteFocusClassDeviceStruct to free the FocusRec.
|
|
|
|
*
|
|
|
|
* If you support input devices with keys that you do not want to be
|
|
|
|
* used as the X keyboard, you need to check for them here and return
|
|
|
|
* a BadDevice error.
|
|
|
|
*
|
|
|
|
* The default implementation is to do nothing (assume you do want
|
|
|
|
* clients to be able to focus the old X keyboard). The commented-out
|
|
|
|
* sample code shows what you might do if you don't want the default.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2003-11-14 17:49:22 +01:00
|
|
|
ChangeKeyboardDevice (DeviceIntPtr old_dev, DeviceIntPtr new_dev)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
/**********************************************************************
|
|
|
|
* DeleteFocusClassDeviceStruct(old_dev); * defined in xchgptr.c *
|
|
|
|
**********************************************************************/
|
|
|
|
return !Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXChangePointerDevice
|
|
|
|
*
|
|
|
|
* This procedure does the implementation-dependent portion of the work
|
|
|
|
* needed to change the pointer device.
|
|
|
|
*
|
|
|
|
* The X pointer device does not have a FocusRec. If the device that
|
|
|
|
* has been made into the new X pointer had a FocusRec,
|
|
|
|
* ProcXChangePointerDevice will free it.
|
|
|
|
*
|
|
|
|
* If you want clients to be able to focus the old pointer device that
|
|
|
|
* has now become accessible through the input extension, you need to
|
|
|
|
* add a FocusRec to it here.
|
|
|
|
*
|
|
|
|
* The XChangePointerDevice protocol request also allows the client
|
|
|
|
* to choose which axes of the new pointer device are used to move
|
|
|
|
* the X cursor in the X- and Y- directions. If the axes are different
|
|
|
|
* than the default ones, you need to keep track of that here.
|
|
|
|
*
|
|
|
|
* If you support input devices with valuators that you do not want to be
|
|
|
|
* used as the X pointer, you need to check for them here and return a
|
|
|
|
* BadDevice error.
|
|
|
|
*
|
|
|
|
* The default implementation is to do nothing (assume you don't want
|
|
|
|
* clients to be able to focus the old X pointer). The commented-out
|
|
|
|
* sample code shows what you might do if you don't want the default.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
ChangePointerDevice (
|
|
|
|
DeviceIntPtr old_dev,
|
|
|
|
DeviceIntPtr new_dev,
|
|
|
|
unsigned char x,
|
|
|
|
unsigned char y)
|
|
|
|
{
|
|
|
|
/************************************************************************
|
|
|
|
InitFocusClassDeviceStruct(old_dev); * allow focusing old ptr*
|
|
|
|
|
|
|
|
x_axis = x; * keep track of new x-axis*
|
|
|
|
y_axis = y; * keep track of new y-axis*
|
|
|
|
if (x_axis != 0 || y_axis != 1)
|
|
|
|
axes_changed = TRUE; * remember axes have changed*
|
|
|
|
else
|
|
|
|
axes_changed = FALSE;
|
|
|
|
*************************************************************************/
|
2003-11-14 17:49:22 +01:00
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
/*
|
|
|
|
* We don't allow axis swap or other exotic features.
|
|
|
|
*/
|
|
|
|
if (x == 0 && y == 1) {
|
|
|
|
LocalDevicePtr old_local = (LocalDevicePtr)old_dev->public.devicePrivate;
|
|
|
|
LocalDevicePtr new_local = (LocalDevicePtr)new_dev->public.devicePrivate;
|
|
|
|
|
|
|
|
InitFocusClassDeviceStruct(old_dev);
|
|
|
|
|
|
|
|
/* Restore Extended motion history information */
|
|
|
|
old_dev->valuator->GetMotionProc = old_local->motion_history_proc;
|
|
|
|
old_dev->valuator->numMotionEvents = old_local->history_size;
|
|
|
|
|
|
|
|
/* Save Extended motion history information */
|
|
|
|
new_local->motion_history_proc = new_dev->valuator->GetMotionProc;
|
|
|
|
new_local->history_size = new_dev->valuator->numMotionEvents;
|
|
|
|
|
|
|
|
/* Set Core motion history information */
|
|
|
|
new_dev->valuator->GetMotionProc = miPointerGetMotionEvents;
|
|
|
|
new_dev->valuator->numMotionEvents = miPointerGetMotionBufferSize();
|
|
|
|
|
|
|
|
return Success;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return !Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXCloseDevice
|
|
|
|
*
|
|
|
|
* Take care of implementation-dependent details of closing a device.
|
|
|
|
* Some implementations may actually close the device, others may just
|
|
|
|
* remove this clients interest in that device.
|
|
|
|
*
|
|
|
|
* The default implementation is to do nothing (assume all input devices
|
|
|
|
* are initialized during X server initialization and kept open).
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
2003-11-14 17:49:22 +01:00
|
|
|
CloseInputDevice (DeviceIntPtr d, ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
ErrorF("ProcXCloseDevice to close or not ?\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXListInputDevices
|
|
|
|
*
|
|
|
|
* This is the implementation-dependent routine to initialize an input
|
|
|
|
* device to the point that information about it can be listed.
|
|
|
|
* Some implementations open all input devices when the server is first
|
|
|
|
* initialized, and never close them. Other implementations open only
|
|
|
|
* the X pointer and keyboard devices during server initialization,
|
|
|
|
* and only open other input devices when some client makes an
|
|
|
|
* XOpenDevice request. If some other process has the device open, the
|
|
|
|
* server may not be able to get information about the device to list it.
|
|
|
|
*
|
|
|
|
* This procedure should be used by implementations that do not initialize
|
|
|
|
* all input devices at server startup. It should do device-dependent
|
|
|
|
* initialization for any devices not previously initialized, and call
|
|
|
|
* AddInputDevice for each of those devices so that a DeviceIntRec will be
|
|
|
|
* created for them.
|
|
|
|
*
|
|
|
|
* The default implementation is to do nothing (assume all input devices
|
|
|
|
* are initialized during X server initialization and kept open).
|
|
|
|
* The commented-out sample code shows what you might do if you don't want
|
|
|
|
* the default.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
AddOtherInputDevices ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXSetDeviceMode
|
|
|
|
*
|
|
|
|
* Change the mode of an extension device.
|
|
|
|
* This function is used to change the mode of a device from reporting
|
|
|
|
* relative motion to reporting absolute positional information, and
|
|
|
|
* vice versa.
|
|
|
|
* The default implementation below is that no such devices are supported.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2003-11-14 17:49:22 +01:00
|
|
|
SetDeviceMode (ClientPtr client, DeviceIntPtr dev, int mode)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
LocalDevicePtr local = (LocalDevicePtr)dev->public.devicePrivate;
|
|
|
|
|
|
|
|
if (local->switch_mode) {
|
|
|
|
return (*local->switch_mode)(client, dev, mode);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return BadMatch;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXSetDeviceValuators
|
|
|
|
*
|
|
|
|
* Set the value of valuators on an extension input device.
|
|
|
|
* This function is used to set the initial value of valuators on
|
|
|
|
* those input devices that are capable of reporting either relative
|
|
|
|
* motion or an absolute position, and allow an initial position to be set.
|
|
|
|
* The default implementation below is that no such devices are supported.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2003-11-14 17:49:22 +01:00
|
|
|
SetDeviceValuators (ClientPtr client, DeviceIntPtr dev, int *valuators,
|
|
|
|
int first_valuator, int num_valuators)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
return BadMatch;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Caller: ProcXChangeDeviceControl
|
|
|
|
*
|
|
|
|
* Change the specified device controls on an extension input device.
|
|
|
|
*
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2003-11-14 17:49:22 +01:00
|
|
|
ChangeDeviceControl (ClientPtr client, DeviceIntPtr dev, xDeviceCtl *control)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
LocalDevicePtr local = (LocalDevicePtr)dev->public.devicePrivate;
|
|
|
|
|
|
|
|
if (!local->control_proc) {
|
|
|
|
return (BadMatch);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return (*local->control_proc)(local, control);
|
|
|
|
}
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
#endif
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* adapted from mieq.c to support extended events
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#define QUEUE_SIZE 256
|
|
|
|
|
|
|
|
typedef struct _Event {
|
|
|
|
xEvent event;
|
|
|
|
#ifdef XINPUT
|
|
|
|
deviceValuator val;
|
|
|
|
#endif
|
|
|
|
ScreenPtr pScreen;
|
|
|
|
} EventRec, *EventPtr;
|
|
|
|
|
|
|
|
typedef struct _EventQueue {
|
|
|
|
HWEventQueueType head, tail;
|
|
|
|
CARD32 lastEventTime; /* to avoid time running backwards */
|
|
|
|
Bool lastMotion;
|
|
|
|
EventRec events[QUEUE_SIZE]; /* static allocation for signals */
|
|
|
|
DevicePtr pKbd, pPtr; /* device pointer, to get funcs */
|
|
|
|
ScreenPtr pEnqueueScreen; /* screen events are being delivered to */
|
|
|
|
ScreenPtr pDequeueScreen; /* screen events are being dispatched to */
|
|
|
|
} EventQueueRec, *EventQueuePtr;
|
|
|
|
|
|
|
|
static EventQueueRec xf86EventQueue;
|
|
|
|
|
|
|
|
Bool
|
2003-11-14 17:49:22 +01:00
|
|
|
xf86eqInit (DevicePtr pKbd, DevicePtr pPtr)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
xf86EventQueue.head = xf86EventQueue.tail = 0;
|
|
|
|
xf86EventQueue.lastEventTime = GetTimeInMillis ();
|
|
|
|
xf86EventQueue.pKbd = pKbd;
|
|
|
|
xf86EventQueue.pPtr = pPtr;
|
|
|
|
xf86EventQueue.lastMotion = FALSE;
|
|
|
|
xf86EventQueue.pEnqueueScreen = screenInfo.screens[0];
|
|
|
|
xf86EventQueue.pDequeueScreen = xf86EventQueue.pEnqueueScreen;
|
|
|
|
SetInputCheck (&xf86EventQueue.head, &xf86EventQueue.tail);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must be reentrant with ProcessInputEvents. Assumption: xf86eqEnqueue
|
|
|
|
* will never be interrupted. If this is called from both signal
|
|
|
|
* handlers and regular code, make sure the signal is suspended when
|
|
|
|
* called from regular code.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
2003-11-14 17:49:22 +01:00
|
|
|
xf86eqEnqueue (xEvent *e)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2003-11-14 17:49:22 +01:00
|
|
|
int oldtail, newtail;
|
|
|
|
Bool isMotion;
|
2003-11-14 16:54:54 +01:00
|
|
|
#ifdef XINPUT
|
2003-11-14 17:49:22 +01:00
|
|
|
int count;
|
|
|
|
|
|
|
|
xf86AssertBlockedSIGIO ("xf86eqEnqueue");
|
|
|
|
switch (e->u.u.type) {
|
|
|
|
case KeyPress:
|
|
|
|
case KeyRelease:
|
|
|
|
#ifdef XFreeXDGA
|
|
|
|
/* we do this here, because nobody seems to be calling
|
|
|
|
xf86PostKeyEvent(). We can't steal MotionNotify events here
|
|
|
|
because the motion-relative information has been lost already. */
|
|
|
|
if(DGAStealKeyEvent(xf86EventQueue.pEnqueueScreen->myNum, e))
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
/* fall through */
|
|
|
|
case ButtonPress:
|
|
|
|
case ButtonRelease:
|
|
|
|
case MotionNotify:
|
2003-11-14 16:54:54 +01:00
|
|
|
count = 1;
|
|
|
|
break;
|
2003-11-14 17:49:22 +01:00
|
|
|
default:
|
|
|
|
#ifdef XFreeXDGA
|
|
|
|
if (DGAIsDgaEvent (e))
|
|
|
|
{
|
|
|
|
count = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (!((deviceKeyButtonPointer *) e)->deviceid & MORE_EVENTS) {
|
2003-11-14 16:54:54 +01:00
|
|
|
count = 1;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
count = 2;
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
break;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
oldtail = xf86EventQueue.tail;
|
|
|
|
isMotion = e->u.u.type == MotionNotify;
|
2003-11-14 17:49:22 +01:00
|
|
|
if (isMotion && xf86EventQueue.lastMotion && oldtail != xf86EventQueue.head) {
|
2003-11-14 16:54:54 +01:00
|
|
|
if (oldtail == 0)
|
|
|
|
oldtail = QUEUE_SIZE;
|
|
|
|
oldtail = oldtail - 1;
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
else {
|
2003-11-14 16:54:54 +01:00
|
|
|
newtail = oldtail + 1;
|
|
|
|
if (newtail == QUEUE_SIZE)
|
|
|
|
newtail = 0;
|
|
|
|
/* Toss events which come in late */
|
|
|
|
if (newtail == xf86EventQueue.head)
|
|
|
|
return;
|
|
|
|
xf86EventQueue.tail = newtail;
|
|
|
|
}
|
|
|
|
|
|
|
|
xf86EventQueue.lastMotion = isMotion;
|
|
|
|
xf86EventQueue.events[oldtail].event = *e;
|
|
|
|
#ifdef XINPUT
|
2003-11-14 17:49:22 +01:00
|
|
|
if (count == 2) {
|
|
|
|
xf86EventQueue.events[oldtail].val = *((deviceValuator *) (((deviceKeyButtonPointer *) e)+1));
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Make sure that event times don't go backwards - this
|
|
|
|
* is "unnecessary", but very useful
|
|
|
|
*/
|
|
|
|
if (e->u.keyButtonPointer.time < xf86EventQueue.lastEventTime &&
|
2003-11-14 17:49:22 +01:00
|
|
|
xf86EventQueue.lastEventTime - e->u.keyButtonPointer.time < 10000) {
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
xf86EventQueue.events[oldtail].event.u.keyButtonPointer.time =
|
|
|
|
xf86EventQueue.lastEventTime;
|
|
|
|
}
|
|
|
|
xf86EventQueue.events[oldtail].pScreen = xf86EventQueue.pEnqueueScreen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call this from ProcessInputEvents()
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xf86eqProcessInputEvents ()
|
|
|
|
{
|
|
|
|
EventRec *e;
|
|
|
|
int x, y;
|
2003-11-14 17:49:22 +01:00
|
|
|
struct {
|
|
|
|
xEvent event;
|
|
|
|
#ifdef XINPUT
|
|
|
|
deviceValuator val;
|
|
|
|
#endif
|
|
|
|
} xe;
|
2003-11-14 16:54:54 +01:00
|
|
|
#ifdef XINPUT
|
|
|
|
DeviceIntPtr dev;
|
|
|
|
int id, count;
|
|
|
|
deviceKeyButtonPointer *dev_xe;
|
|
|
|
#endif
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
while (xf86EventQueue.head != xf86EventQueue.tail) {
|
2003-11-14 16:54:54 +01:00
|
|
|
if (screenIsSaved == SCREEN_SAVER_ON)
|
|
|
|
SaveScreens (SCREEN_SAVER_OFF, ScreenSaverReset);
|
|
|
|
#ifdef DPMSExtension
|
2003-11-14 17:49:22 +01:00
|
|
|
if (DPMSPowerLevel != DPMSModeOn)
|
|
|
|
DPMSSet(DPMSModeOn);
|
2003-11-14 16:54:54 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
e = &xf86EventQueue.events[xf86EventQueue.head];
|
|
|
|
/*
|
|
|
|
* Assumption - screen switching can only occur on motion events
|
|
|
|
*/
|
2003-11-14 17:49:22 +01:00
|
|
|
if (e->pScreen != xf86EventQueue.pDequeueScreen) {
|
2003-11-14 16:54:54 +01:00
|
|
|
xf86EventQueue.pDequeueScreen = e->pScreen;
|
|
|
|
x = e->event.u.keyButtonPointer.rootX;
|
|
|
|
y = e->event.u.keyButtonPointer.rootY;
|
|
|
|
if (xf86EventQueue.head == QUEUE_SIZE - 1)
|
|
|
|
xf86EventQueue.head = 0;
|
|
|
|
else
|
|
|
|
++xf86EventQueue.head;
|
|
|
|
NewCurrentScreen (xf86EventQueue.pDequeueScreen, x, y);
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
else {
|
|
|
|
xe.event = e->event;
|
|
|
|
xe.val = e->val;
|
2003-11-14 16:54:54 +01:00
|
|
|
if (xf86EventQueue.head == QUEUE_SIZE - 1)
|
|
|
|
xf86EventQueue.head = 0;
|
|
|
|
else
|
|
|
|
++xf86EventQueue.head;
|
2003-11-14 17:49:22 +01:00
|
|
|
switch (xe.event.u.u.type) {
|
2003-11-14 16:54:54 +01:00
|
|
|
case KeyPress:
|
|
|
|
case KeyRelease:
|
|
|
|
(*xf86EventQueue.pKbd->processInputProc)
|
2003-11-14 17:49:22 +01:00
|
|
|
(&xe.event, (DeviceIntPtr)xf86EventQueue.pKbd, 1);
|
2003-11-14 16:54:54 +01:00
|
|
|
break;
|
|
|
|
#ifdef XINPUT
|
|
|
|
case ButtonPress:
|
|
|
|
case ButtonRelease:
|
|
|
|
case MotionNotify:
|
|
|
|
(*(inputInfo.pointer->public.processInputProc))
|
2003-11-14 17:49:22 +01:00
|
|
|
(&xe.event, (DeviceIntPtr)inputInfo.pointer, 1);
|
|
|
|
break;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
default:
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef XFreeXDGA
|
|
|
|
if (DGADeliverEvent (xf86EventQueue.pDequeueScreen, &xe.event))
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
dev_xe = (deviceKeyButtonPointer *) &xe.event;
|
|
|
|
id = dev_xe->deviceid & DEVICE_BITS;
|
|
|
|
if (!(dev_xe->deviceid & MORE_EVENTS)) {
|
|
|
|
count = 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
count = 2;
|
|
|
|
}
|
|
|
|
dev = LookupDeviceIntRec(id);
|
|
|
|
if (dev == NULL) {
|
|
|
|
ErrorF("LookupDeviceIntRec id=0x%x not found\n", id);
|
2003-11-14 16:54:54 +01:00
|
|
|
/* FatalError("xf86eqProcessInputEvents : device not found.\n");
|
|
|
|
*/
|
2003-11-14 17:49:22 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!dev->public.processInputProc) {
|
|
|
|
FatalError("xf86eqProcessInputEvents : device has no input proc.\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
(*dev->public.processInputProc)(&xe.event, dev, count);
|
2003-11-14 16:54:54 +01:00
|
|
|
#else
|
|
|
|
default:
|
|
|
|
(*xf86EventQueue.pPtr->processInputProc)
|
2003-11-14 17:49:22 +01:00
|
|
|
(&xe.event, (DeviceIntPtr)xf86EventQueue.pPtr, 1);
|
2003-11-14 16:54:54 +01:00
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
void
|
|
|
|
xf86eqSwitchScreen(ScreenPtr pScreen,
|
|
|
|
Bool fromDIX)
|
|
|
|
{
|
|
|
|
xf86EventQueue.pEnqueueScreen = pScreen;
|
|
|
|
|
|
|
|
if (fromDIX)
|
|
|
|
xf86EventQueue.pDequeueScreen = pScreen;
|
|
|
|
}
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
/*
|
|
|
|
* convenient functions to post events
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
xf86PostMotionEvent(DeviceIntPtr device,
|
|
|
|
int is_absolute,
|
|
|
|
int first_valuator,
|
|
|
|
int num_valuators,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list var;
|
|
|
|
int loop;
|
|
|
|
xEvent xE[2];
|
|
|
|
deviceKeyButtonPointer *xev = (deviceKeyButtonPointer*) xE;
|
|
|
|
deviceValuator *xv = (deviceValuator*) xev+1;
|
2003-11-14 17:49:22 +01:00
|
|
|
LocalDevicePtr local = (LocalDevicePtr) device->public.devicePrivate;
|
|
|
|
char *buff = 0;
|
|
|
|
Time current;
|
|
|
|
Bool is_core = xf86IsCorePointer(device);
|
|
|
|
Bool is_shared = xf86ShareCorePointer(device);
|
|
|
|
Bool drag = xf86SendDragEvents(device);
|
|
|
|
ValuatorClassPtr val = device->valuator;
|
|
|
|
int valuator[6];
|
|
|
|
int oldaxis[6];
|
|
|
|
int *axisvals;
|
|
|
|
int dx = 0, dy = 0;
|
|
|
|
float mult;
|
|
|
|
int x, y;
|
|
|
|
int loop_start;
|
|
|
|
int i;
|
|
|
|
int num;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
DBG(5, ErrorF("xf86PostMotionEvent BEGIN 0x%x(%s) is_core=%s is_shared=%s is_absolute=%s\n",
|
|
|
|
device, device->name,
|
|
|
|
is_core ? "True" : "False",
|
|
|
|
is_shared ? "True" : "False",
|
|
|
|
is_absolute ? "True" : "False"));
|
|
|
|
|
|
|
|
xf86Info.lastEventTime = xev->time = current = GetTimeInMillis();
|
|
|
|
|
|
|
|
if (!is_core) {
|
|
|
|
if (HAS_MOTION_HISTORY(local)) {
|
2003-11-14 16:54:54 +01:00
|
|
|
buff = ((char *)local->motion_history +
|
|
|
|
(sizeof(INT32) * local->dev->valuator->numAxes + sizeof(Time)) * local->last);
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_valuators && (!val || (first_valuator + num_valuators > val->numAxes))) {
|
|
|
|
ErrorF("Bad valuators reported for device \"%s\"\n", device->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
axisvals = val->axisVal;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
va_start(var, num_valuators);
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
loop_start = first_valuator;
|
2003-11-14 16:54:54 +01:00
|
|
|
for(loop=0; loop<num_valuators; loop++) {
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
valuator[loop%6] = va_arg(var,int);
|
|
|
|
|
|
|
|
if (loop % 6 == 5 || loop == num_valuators - 1) {
|
|
|
|
num = loop % 6 + 1;
|
|
|
|
/*
|
|
|
|
* Adjust first two relative valuators
|
|
|
|
*/
|
|
|
|
if (!is_absolute && num_valuators >= 2 && loop_start == 0) {
|
|
|
|
|
|
|
|
dx = valuator[0];
|
|
|
|
dy = valuator[1];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Accelerate
|
|
|
|
*/
|
|
|
|
if (device->ptrfeed && device->ptrfeed->ctrl.num) {
|
|
|
|
/* modeled from xf86Events.c */
|
|
|
|
if (device->ptrfeed->ctrl.threshold) {
|
|
|
|
if ((abs(dx) + abs(dy)) >= device->ptrfeed->ctrl.threshold) {
|
2004-12-13 03:13:32 +01:00
|
|
|
local->dxremaind = ((float)dx * (float)(device->ptrfeed->ctrl.num)) /
|
|
|
|
(float)(device->ptrfeed->ctrl.den) + local->dxremaind;
|
|
|
|
valuator[0] = (int)local->dxremaind;
|
|
|
|
local->dxremaind = local->dxremaind - (float)valuator[0];
|
|
|
|
|
|
|
|
local->dyremaind = ((float)dy * (float)(device->ptrfeed->ctrl.num)) /
|
|
|
|
(float)(device->ptrfeed->ctrl.den) + local->dyremaind;
|
|
|
|
valuator[1] = (int)local->dyremaind;
|
|
|
|
local->dyremaind = local->dyremaind - (float)valuator[1];
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (dx || dy) {
|
|
|
|
mult = pow((float)(dx*dx+dy*dy),
|
|
|
|
((float)(device->ptrfeed->ctrl.num) /
|
|
|
|
(float)(device->ptrfeed->ctrl.den) - 1.0) /
|
|
|
|
2.0) / 2.0;
|
|
|
|
if (dx) {
|
|
|
|
local->dxremaind = mult * (float)dx + local->dxremaind;
|
|
|
|
valuator[0] = (int)local->dxremaind;
|
|
|
|
local->dxremaind = local->dxremaind - (float)valuator[0];
|
|
|
|
}
|
|
|
|
if (dy) {
|
|
|
|
local->dyremaind = mult * (float)dy + local->dyremaind;
|
|
|
|
valuator[1] = (int)local->dyremaind;
|
|
|
|
local->dyremaind = local->dyremaind - (float)valuator[1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DBG(6, ErrorF("xf86PostMotionEvent acceleration v0=%d v1=%d\n",
|
|
|
|
valuator[0], valuator[1]));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map current position back to device space in case
|
|
|
|
* the cursor was warped
|
|
|
|
*/
|
|
|
|
if (is_core || is_shared)
|
|
|
|
{
|
|
|
|
miPointerPosition (&x, &y);
|
|
|
|
if (local->reverse_conversion_proc)
|
|
|
|
(*local->reverse_conversion_proc)(local, x, y, axisvals);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
axisvals[0] = x;
|
|
|
|
axisvals[1] = y;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update axes
|
|
|
|
*/
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
{
|
|
|
|
oldaxis[i] = axisvals[loop_start + i];
|
|
|
|
if (is_absolute)
|
|
|
|
axisvals[loop_start + i] = valuator[i];
|
|
|
|
else
|
|
|
|
axisvals[loop_start + i] += valuator[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deliver extension event
|
|
|
|
*/
|
|
|
|
if (!is_core) {
|
2003-11-14 16:54:54 +01:00
|
|
|
xev->type = DeviceMotionNotify;
|
|
|
|
xev->detail = 0;
|
|
|
|
xev->deviceid = device->id | MORE_EVENTS;
|
|
|
|
|
|
|
|
xv->type = DeviceValuator;
|
|
|
|
xv->deviceid = device->id;
|
|
|
|
|
|
|
|
xv->device_state = 0;
|
2003-11-14 17:49:22 +01:00
|
|
|
xv->num_valuators = num;
|
|
|
|
xv->first_valuator = loop_start;
|
|
|
|
memcpy (&xv->valuator0, &axisvals[loop_start],
|
|
|
|
sizeof(INT32)*xv->num_valuators);
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
if (HAS_MOTION_HISTORY(local)) {
|
|
|
|
*(Time*)buff = current;
|
2003-11-14 17:49:22 +01:00
|
|
|
memcpy(buff+sizeof(Time)+sizeof(INT32)*xv->first_valuator,
|
|
|
|
&axisvals[loop_start],
|
2003-11-14 16:54:54 +01:00
|
|
|
sizeof(INT32)*xv->num_valuators);
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
ENQUEUE(xE);
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
/*
|
|
|
|
* Deliver core event
|
|
|
|
*/
|
|
|
|
if (is_core ||
|
|
|
|
(is_shared && num_valuators >= 2 && loop_start == 0)) {
|
|
|
|
#ifdef XFreeXDGA
|
|
|
|
/*
|
|
|
|
* Let DGA peek at the event and steal it
|
|
|
|
*/
|
|
|
|
xev->type = MotionNotify;
|
|
|
|
xev->detail = 0;
|
|
|
|
if (is_absolute)
|
|
|
|
{
|
|
|
|
dx = axisvals[0] - oldaxis[0];
|
|
|
|
dy = axisvals[1] - oldaxis[1];
|
|
|
|
}
|
|
|
|
if (DGAStealMouseEvent(xf86EventQueue.pEnqueueScreen->myNum,
|
|
|
|
xE, dx, dy))
|
|
|
|
continue;
|
|
|
|
#endif
|
|
|
|
if (!(*local->conversion_proc)(local, loop_start, num,
|
|
|
|
axisvals[0], axisvals[1],
|
|
|
|
axisvals[2], axisvals[3],
|
|
|
|
axisvals[4], axisvals[5],
|
|
|
|
&x, &y))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (drag)
|
|
|
|
miPointerAbsoluteCursor (x, y, current);
|
|
|
|
/*
|
|
|
|
* Retrieve the position
|
|
|
|
*/
|
|
|
|
miPointerPosition (&x, &y);
|
|
|
|
if (local->reverse_conversion_proc)
|
|
|
|
(*local->reverse_conversion_proc)(local, x, y, axisvals);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
axisvals[0] = x;
|
|
|
|
axisvals[1] = y;
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
loop_start += 6;
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
va_end(var);
|
2003-11-14 16:54:54 +01:00
|
|
|
if (HAS_MOTION_HISTORY(local)) {
|
|
|
|
local->last = (local->last + 1) % device->valuator->numMotionEvents;
|
|
|
|
if (local->last == local->first)
|
|
|
|
local->first = (local->first + 1) % device->valuator->numMotionEvents;
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
DBG(5, ErrorF("xf86PostMotionEvent END 0x%x(%s) is_core=%s is_shared=%s\n",
|
|
|
|
device, device->name,
|
|
|
|
is_core ? "True" : "False",
|
|
|
|
is_shared ? "True" : "False"));
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xf86PostProximityEvent(DeviceIntPtr device,
|
|
|
|
int is_in,
|
|
|
|
int first_valuator,
|
|
|
|
int num_valuators,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list var;
|
|
|
|
int loop;
|
|
|
|
xEvent xE[2];
|
|
|
|
deviceKeyButtonPointer *xev = (deviceKeyButtonPointer*) xE;
|
|
|
|
deviceValuator *xv = (deviceValuator*) xev+1;
|
2003-11-14 17:49:22 +01:00
|
|
|
ValuatorClassPtr val = device->valuator;
|
|
|
|
Bool is_core = xf86IsCorePointer(device);
|
|
|
|
Bool is_absolute = val && ((val->mode & 1) == Relative);
|
|
|
|
|
|
|
|
DBG(5, ErrorF("xf86PostProximityEvent BEGIN 0x%x(%s) prox=%s is_core=%s is_absolute=%s\n",
|
|
|
|
device, device->name, is_in ? "true" : "false",
|
|
|
|
is_core ? "True" : "False",
|
|
|
|
is_absolute ? "True" : "False"));
|
|
|
|
|
|
|
|
if (is_core) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_valuators && (!val || (first_valuator + num_valuators > val->numAxes))) {
|
|
|
|
ErrorF("Bad valuators reported for device \"%s\"\n", device->name);
|
|
|
|
return;
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
xev->type = is_in ? ProximityIn : ProximityOut;
|
|
|
|
xev->detail = 0;
|
|
|
|
xev->deviceid = device->id | MORE_EVENTS;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
xv->type = DeviceValuator;
|
|
|
|
xv->deviceid = device->id;
|
|
|
|
xv->device_state = 0;
|
|
|
|
|
|
|
|
if ((device->valuator->mode & 1) == Relative) {
|
|
|
|
num_valuators = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_valuators != 0) {
|
|
|
|
int *axisvals = val->axisVal;
|
|
|
|
|
|
|
|
va_start(var, num_valuators);
|
|
|
|
|
|
|
|
for(loop=0; loop<num_valuators; loop++) {
|
|
|
|
switch (loop % 6) {
|
|
|
|
case 0:
|
|
|
|
xv->valuator0 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
xv->valuator1 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
xv->valuator2 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
xv->valuator3 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
xv->valuator4 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
xv->valuator5 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((loop % 6 == 5) || (loop == num_valuators - 1)) {
|
|
|
|
xf86Info.lastEventTime = xev->time = GetTimeInMillis();
|
|
|
|
|
|
|
|
xv->num_valuators = (loop % 6) + 1;
|
|
|
|
xv->first_valuator = first_valuator + (loop / 6) * 6;
|
|
|
|
ENQUEUE(xE);
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
va_end(var);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
else {
|
|
|
|
/* no valuator */
|
|
|
|
xf86Info.lastEventTime = xev->time = GetTimeInMillis();
|
|
|
|
|
|
|
|
xv->num_valuators = 0;
|
|
|
|
xv->first_valuator = 0;
|
|
|
|
ENQUEUE(xE);
|
|
|
|
}
|
|
|
|
DBG(5, ErrorF("xf86PostProximityEvent END 0x%x(%s) prox=%s is_core=%s is_absolute=%s\n",
|
|
|
|
device, device->name, is_in ? "true" : "false",
|
|
|
|
is_core ? "True" : "False",
|
|
|
|
is_absolute ? "True" : "False"));
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xf86PostButtonEvent(DeviceIntPtr device,
|
|
|
|
int is_absolute,
|
|
|
|
int button,
|
|
|
|
int is_down,
|
|
|
|
int first_valuator,
|
|
|
|
int num_valuators,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list var;
|
|
|
|
int loop;
|
|
|
|
xEvent xE[2];
|
|
|
|
deviceKeyButtonPointer *xev = (deviceKeyButtonPointer*) xE;
|
|
|
|
deviceValuator *xv = (deviceValuator*) xev+1;
|
2003-11-14 17:49:22 +01:00
|
|
|
ValuatorClassPtr val = device->valuator;
|
|
|
|
Bool is_core = xf86IsCorePointer(device);
|
|
|
|
Bool is_shared = xf86ShareCorePointer(device);
|
|
|
|
|
|
|
|
DBG(5, ErrorF("xf86PostButtonEvent BEGIN 0x%x(%s) button=%d down=%s is_core=%s is_shared=%s is_absolute=%s\n",
|
|
|
|
device, device->name, button,
|
|
|
|
is_down ? "True" : "False",
|
|
|
|
is_core ? "True" : "False",
|
|
|
|
is_shared ? "True" : "False",
|
|
|
|
is_absolute ? "True" : "False"));
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
/* Check the core pointer button state not to send an inconsistent
|
|
|
|
* event. This can happen with the AlwaysCore feature.
|
|
|
|
*/
|
2003-11-14 17:49:22 +01:00
|
|
|
if ((is_core || is_shared) &&
|
|
|
|
!xf86CheckButton(device->button->map[button], is_down))
|
|
|
|
{
|
2003-11-14 16:54:54 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (num_valuators && (!val || (first_valuator + num_valuators > val->numAxes))) {
|
|
|
|
ErrorF("Bad valuators reported for device \"%s\"\n", device->name);
|
|
|
|
return;
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (!is_core) {
|
|
|
|
xev->type = is_down ? DeviceButtonPress : DeviceButtonRelease;
|
|
|
|
xev->detail = button;
|
|
|
|
xev->deviceid = device->id | MORE_EVENTS;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
xv->type = DeviceValuator;
|
|
|
|
xv->deviceid = device->id;
|
|
|
|
xv->device_state = 0;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (num_valuators != 0) {
|
|
|
|
int *axisvals = val->axisVal;
|
|
|
|
|
|
|
|
va_start(var, num_valuators);
|
|
|
|
|
|
|
|
for(loop=0; loop<num_valuators; loop++) {
|
|
|
|
switch (loop % 6) {
|
|
|
|
case 0:
|
|
|
|
xv->valuator0 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
xv->valuator1 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
xv->valuator2 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
xv->valuator3 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
xv->valuator4 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
xv->valuator5 = is_absolute ? va_arg(var, int) : axisvals[loop];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((loop % 6 == 5) || (loop == num_valuators - 1)) {
|
|
|
|
xf86Info.lastEventTime = xev->time = GetTimeInMillis();
|
|
|
|
xv->num_valuators = (loop % 6) + 1;
|
|
|
|
xv->first_valuator = first_valuator + (loop / 6) * 6;
|
|
|
|
ENQUEUE(xE);
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
va_end(var);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* no valuator */
|
|
|
|
xf86Info.lastEventTime = xev->time = GetTimeInMillis();
|
|
|
|
xv->num_valuators = 0;
|
|
|
|
xv->first_valuator = 0;
|
|
|
|
ENQUEUE(xE);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
/* removed rootX/rootY as DIX sets these fields */
|
|
|
|
if (is_core || is_shared) {
|
|
|
|
xE->u.u.type = is_down ? ButtonPress : ButtonRelease;
|
|
|
|
xE->u.u.detail = device->button->map[button];
|
|
|
|
xf86Info.lastEventTime = xE->u.keyButtonPointer.time = GetTimeInMillis();
|
|
|
|
|
|
|
|
#ifdef XFreeXDGA
|
|
|
|
if (!DGAStealMouseEvent(xf86EventQueue.pEnqueueScreen->myNum, xE, 0, 0))
|
|
|
|
#endif
|
|
|
|
ENQUEUE(xE);
|
|
|
|
}
|
|
|
|
DBG(5, ErrorF("xf86PostButtonEvent END\n"));
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xf86PostKeyEvent(DeviceIntPtr device,
|
|
|
|
unsigned int key_code,
|
|
|
|
int is_down,
|
|
|
|
int is_absolute,
|
|
|
|
int first_valuator,
|
|
|
|
int num_valuators,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list var;
|
|
|
|
int loop;
|
|
|
|
xEvent xE[2];
|
|
|
|
deviceKeyButtonPointer *xev = (deviceKeyButtonPointer*) xE;
|
|
|
|
deviceValuator *xv = (deviceValuator*) xev+1;
|
|
|
|
|
|
|
|
va_start(var, num_valuators);
|
|
|
|
|
|
|
|
for(loop=0; loop<num_valuators; loop++) {
|
|
|
|
switch (loop % 6) {
|
|
|
|
case 0:
|
|
|
|
xv->valuator0 = va_arg(var, int);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
xv->valuator1 = va_arg(var, int);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
xv->valuator2 = va_arg(var, int);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
xv->valuator3 = va_arg(var, int);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
xv->valuator4 = va_arg(var, int);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
xv->valuator5 = va_arg(var, int);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (((loop % 6 == 5) || (loop == num_valuators - 1))) {
|
|
|
|
xev->type = is_down ? DeviceKeyPress : DeviceKeyRelease;
|
|
|
|
xev->detail = key_code;
|
|
|
|
|
|
|
|
xf86Info.lastEventTime = xev->time = GetTimeInMillis();
|
|
|
|
xev->deviceid = device->id | MORE_EVENTS;
|
|
|
|
|
|
|
|
xv->type = DeviceValuator;
|
|
|
|
xv->deviceid = device->id;
|
|
|
|
xv->device_state = 0;
|
|
|
|
/* if the device is in the relative mode we don't have to send valuators */
|
|
|
|
xv->num_valuators = is_absolute ? (loop % 6) + 1 : 0;
|
|
|
|
xv->first_valuator = first_valuator + (loop / 6) * 6;
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
ENQUEUE(xE);
|
2003-11-14 16:54:54 +01:00
|
|
|
/* if the device is in the relative mode only one event is needed */
|
|
|
|
if (!is_absolute) break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
va_end(var);
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
void
|
|
|
|
xf86PostKeyboardEvent(DeviceIntPtr device,
|
|
|
|
unsigned int key_code,
|
|
|
|
int is_down)
|
|
|
|
{
|
|
|
|
xEvent xE[2];
|
|
|
|
deviceKeyButtonPointer *xev = (deviceKeyButtonPointer*) xE;
|
|
|
|
|
|
|
|
if (xf86IsCoreKeyboard(device)) {
|
|
|
|
xev->type = is_down ? KeyPress : KeyRelease;
|
|
|
|
} else {
|
|
|
|
xev->type = is_down ? DeviceKeyPress : DeviceKeyRelease;
|
|
|
|
}
|
|
|
|
xev->detail = key_code;
|
|
|
|
xf86Info.lastEventTime = xev->time = GetTimeInMillis();
|
|
|
|
|
|
|
|
#ifdef XFreeXDGA
|
|
|
|
/* if(!DGAStealKeyEvent(xf86EventQueue.pEnqueueScreen->myNum, xE)) */
|
|
|
|
#endif
|
|
|
|
ENQUEUE(xE);
|
|
|
|
}
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
/*
|
|
|
|
* Motion history management.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
xf86MotionHistoryAllocate(LocalDevicePtr local)
|
|
|
|
{
|
|
|
|
ValuatorClassPtr valuator = local->dev->valuator;
|
|
|
|
|
|
|
|
if (!HAS_MOTION_HISTORY(local))
|
|
|
|
return;
|
2003-11-14 17:49:22 +01:00
|
|
|
if (local->motion_history) xfree(local->motion_history);
|
2003-11-14 16:54:54 +01:00
|
|
|
local->motion_history = xalloc((sizeof(INT32) * valuator->numAxes + sizeof(Time))
|
|
|
|
* valuator->numMotionEvents);
|
|
|
|
local->first = 0;
|
|
|
|
local->last = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xf86GetMotionEvents(DeviceIntPtr dev,
|
|
|
|
xTimecoord *buff,
|
|
|
|
unsigned long start,
|
|
|
|
unsigned long stop,
|
|
|
|
ScreenPtr pScreen)
|
|
|
|
{
|
|
|
|
LocalDevicePtr local = (LocalDevicePtr)dev->public.devicePrivate;
|
|
|
|
ValuatorClassPtr valuator = dev->valuator;
|
|
|
|
int num = 0;
|
|
|
|
int loop = local->first;
|
|
|
|
int size;
|
|
|
|
Time current;
|
|
|
|
|
|
|
|
if (!HAS_MOTION_HISTORY(local))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
size = (sizeof(INT32) * valuator->numAxes + sizeof(Time));
|
|
|
|
|
|
|
|
while (loop != local->last) {
|
|
|
|
current = *(Time*)(((char *)local->motion_history)+loop*size);
|
|
|
|
if (current > stop)
|
|
|
|
return num;
|
|
|
|
if (current >= start) {
|
|
|
|
memcpy(((char *)buff)+size*num,
|
|
|
|
((char *)local->motion_history)+loop*size, size);
|
|
|
|
num++;
|
|
|
|
}
|
|
|
|
loop = (loop + 1) % valuator->numMotionEvents;
|
|
|
|
}
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
LocalDevicePtr
|
|
|
|
xf86FirstLocalDevice()
|
|
|
|
{
|
|
|
|
return xf86InputDevs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cx - raw data from touch screen
|
|
|
|
* Sxhigh - scaled highest dimension
|
|
|
|
* (remember, this is of rows - 1 because of 0 origin)
|
|
|
|
* Sxlow - scaled lowest dimension
|
|
|
|
* Rxhigh - highest raw value from touch screen calibration
|
|
|
|
* Rxlow - lowest raw value from touch screen calibration
|
|
|
|
*
|
|
|
|
* This function is the same for X or Y coordinates.
|
|
|
|
* You may have to reverse the high and low values to compensate for
|
|
|
|
* different orgins on the touch screen vs X.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
xf86ScaleAxis(int Cx,
|
|
|
|
int Sxhigh,
|
|
|
|
int Sxlow,
|
|
|
|
int Rxhigh,
|
|
|
|
int Rxlow )
|
|
|
|
{
|
|
|
|
int X;
|
|
|
|
int dSx = Sxhigh - Sxlow;
|
|
|
|
int dRx = Rxhigh - Rxlow;
|
|
|
|
|
|
|
|
dSx = Sxhigh - Sxlow;
|
|
|
|
if (dRx) {
|
|
|
|
X = ((dSx * (Cx - Rxlow)) / dRx) + Sxlow;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
X = 0;
|
|
|
|
ErrorF ("Divide by Zero in xf86ScaleAxis");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (X > Sxlow)
|
|
|
|
X = Sxlow;
|
|
|
|
if (X < Sxhigh)
|
|
|
|
X = Sxhigh;
|
|
|
|
|
|
|
|
return (X);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function checks the given screen against the current screen and
|
|
|
|
* makes changes if appropriate. It should be called from an XInput driver's
|
|
|
|
* ReadInput function before any events are posted, if the device is screen
|
|
|
|
* specific like a touch screen.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xf86XInputSetScreen(LocalDevicePtr local,
|
|
|
|
int screen_number,
|
|
|
|
int x,
|
|
|
|
int y)
|
|
|
|
{
|
|
|
|
if ((xf86IsCorePointer(local->dev) || xf86ShareCorePointer(local->dev)) &&
|
|
|
|
(miPointerCurrentScreen() != screenInfo.screens[screen_number])) {
|
|
|
|
miPointerSetNewScreen (screen_number, x, y);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
|
|
|
|
int resolution, int min_res, int max_res)
|
|
|
|
{
|
|
|
|
#ifdef XINPUT
|
|
|
|
if (maxval == -1) {
|
|
|
|
if (axnum == 0)
|
|
|
|
maxval = screenInfo.screens[0]->width - 1;
|
|
|
|
else if (axnum == 1)
|
|
|
|
maxval = screenInfo.screens[0]->height - 1;
|
|
|
|
/* else? */
|
|
|
|
}
|
|
|
|
InitValuatorAxisStruct(dev, axnum, minval, maxval, resolution, min_res,
|
|
|
|
max_res);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the valuator values to be in synch with dix/event.c
|
|
|
|
* DefineInitialRootWindow().
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xf86InitValuatorDefaults(DeviceIntPtr dev, int axnum)
|
|
|
|
{
|
|
|
|
#ifdef XINPUT
|
|
|
|
if (axnum == 0)
|
|
|
|
dev->valuator->axisVal[0] = screenInfo.screens[0]->width / 2;
|
|
|
|
else if (axnum == 1)
|
|
|
|
dev->valuator->axisVal[1] = screenInfo.screens[0]->height / 2;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
/* end of xf86Xinput.c */
|