xorg-server-1.4/hw/darwin/darwinXinput.c

   1
   2 /*
   3  * X server support of the XINPUT extension for Darwin
   4  *
   5  * This is currently a copy of mi/stubs.c, but eventually this
   6  * should include more complete XINPUT support.
   7  */
   8
   9 /************************************************************
  10
  11 Copyright 1989, 1998  The Open Group
  12
  13 Permission to use, copy, modify, distribute, and sell this software and its
  14 documentation for any purpose is hereby granted without fee, provided that
  15 the above copyright notice appear in all copies and that both that
  16 copyright notice and this permission notice appear in supporting
  17 documentation.
  18
  19 The above copyright notice and this permission notice shall be included in
  20 all copies or substantial portions of the Software.
  21
  22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  23 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  25 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  26 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  27 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28
  29 Except as contained in this notice, the name of The Open Group shall not be
  30 used in advertising or otherwise to promote the sale, use or other dealings
  31 in this Software without prior written authorization from The Open Group.
  32
  33 Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
  34
  35                         All Rights Reserved
  36
  37 Permission to use, copy, modify, and distribute this software and its
  38 documentation for any purpose and without fee is hereby granted,
  39 provided that the above copyright notice appear in all copies and that
  40 both that copyright notice and this permission notice appear in
  41 supporting documentation, and that the name of Hewlett-Packard not be
  42 used in advertising or publicity pertaining to distribution of the
  43 software without specific, written prior permission.
  44
  45 HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  46 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  47 HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  48 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  49 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  50 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  51 SOFTWARE.
  52
  53 ********************************************************/
  54
  55 #define  NEED_EVENTS
  56 #include <X11/X.h>
  57 #include <X11/Xproto.h>
  58 #include "inputstr.h"
  59 #include <X11/extensions/XI.h>
  60 #include <X11/extensions/XIproto.h>
  61 #include "XIstubs.h"
  62
  63 /***********************************************************************
  64  *
  65  * Caller:      ProcXChangeKeyboardDevice
  66  *
  67  * This procedure does the implementation-dependent portion of the work
  68  * needed to change the keyboard device.
  69  *
  70  * The X keyboard device has a FocusRec.  If the device that has been
  71  * made into the new X keyboard did not have a FocusRec,
  72  * ProcXChangeKeyboardDevice will allocate one for it.
  73  *
  74  * If you do not want clients to be able to focus the old X keyboard
  75  * device, call DeleteFocusClassDeviceStruct to free the FocusRec.
  76  *
  77  * If you support input devices with keys that you do not want to be
  78  * used as the X keyboard, you need to check for them here and return
  79  * a BadDevice error.
  80  *
  81  * The default implementation is to do nothing (assume you do want
  82  * clients to be able to focus the old X keyboard).  The commented-out
  83  * sample code shows what you might do if you don't want the default.
  84  *
  85  */
  86
  87 int
  88 ChangeKeyboardDevice (old_dev, new_dev)
  89     DeviceIntPtr        old_dev;
  90     DeviceIntPtr        new_dev;
  91     {
  92     /***********************************************************************
  93      DeleteFocusClassDeviceStruct(old_dev);      * defined in xchgptr.c *
  94     **********************************************************************/
  95     return BadMatch;
  96     }
  97
  98
  99 /***********************************************************************
 100  *
 101  * Caller:      ProcXChangePointerDevice
 102  *
 103  * This procedure does the implementation-dependent portion of the work
 104  * needed to change the pointer device.
 105  *
 106  * The X pointer device does not have a FocusRec.  If the device that
 107  * has been made into the new X pointer had a FocusRec,
 108  * ProcXChangePointerDevice will free it.
 109  *
 110  * If you want clients to be able to focus the old pointer device that
 111  * has now become accessible through the input extension, you need to
 112  * add a FocusRec to it here.
 113  *
 114  * The XChangePointerDevice protocol request also allows the client
 115  * to choose which axes of the new pointer device are used to move
 116  * the X cursor in the X- and Y- directions.  If the axes are different
 117  * than the default ones, you need to keep track of that here.
 118  *
 119  * If you support input devices with valuators that you do not want to be
 120  * used as the X pointer, you need to check for them here and return a
 121  * BadDevice error.
 122  *
 123  * The default implementation is to do nothing (assume you don't want
 124  * clients to be able to focus the old X pointer).  The commented-out
 125  * sample code shows what you might do if you don't want the default.
 126  *
 127  */
 128
 129 int
 130 ChangePointerDevice (
 131     DeviceIntPtr        old_dev,
 132     DeviceIntPtr        new_dev,
 133     unsigned char       x,
 134     unsigned char       y)
 135     {
 136     /***********************************************************************
 137     InitFocusClassDeviceStruct(old_dev);        * allow focusing old ptr*
 138
 139     x_axis = x;                                 * keep track of new x-axis*
 140     y_axis = y;                                 * keep track of new y-axis*
 141     if (x_axis != 0 || y_axis != 1)
 142         axes_changed = TRUE;                    * remember axes have changed*
 143     else
 144         axes_changed = FALSE;
 145     *************************************************************************/
 146     return BadMatch;
 147     }
 148
 149 /***********************************************************************
 150  *
 151  * Caller:      ProcXCloseDevice
 152  *
 153  * Take care of implementation-dependent details of closing a device.
 154  * Some implementations may actually close the device, others may just
 155  * remove this clients interest in that device.
 156  *
 157  * The default implementation is to do nothing (assume all input devices
 158  * are initialized during X server initialization and kept open).
 159  *
 160  */
 161
 162 void
 163 CloseInputDevice (d, client)
 164     DeviceIntPtr d;
 165     ClientPtr client;
 166     {
 167     }
 168
 169 /***********************************************************************
 170  *
 171  * Caller:      ProcXListInputDevices
 172  *
 173  * This is the implementation-dependent routine to initialize an input
 174  * device to the point that information about it can be listed.
 175  * Some implementations open all input devices when the server is first
 176  * initialized, and never close them.  Other implementations open only
 177  * the X pointer and keyboard devices during server initialization,
 178  * and only open other input devices when some client makes an
 179  * XOpenDevice request.  If some other process has the device open, the
 180  * server may not be able to get information about the device to list it.
 181  *
 182  * This procedure should be used by implementations that do not initialize
 183  * all input devices at server startup.  It should do device-dependent
 184  * initialization for any devices not previously initialized, and call
 185  * AddInputDevice for each of those devices so that a DeviceIntRec will be
 186  * created for them.
 187  *
 188  * The default implementation is to do nothing (assume all input devices
 189  * are initialized during X server initialization and kept open).
 190  * The commented-out sample code shows what you might do if you don't want
 191  * the default.
 192  *
 193  */
 194
 195 void
 196 AddOtherInputDevices ()
 197     {
 198     /**********************************************************************
 199      for each uninitialized device, do something like:
 200
 201     DeviceIntPtr dev;
 202     DeviceProc deviceProc;
 203     pointer private;
 204
 205     dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE);
 206     dev->public.devicePrivate = private;
 207     RegisterOtherDevice(dev);
 208     dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
 209     ************************************************************************/
 210
 211     }
 212
 213 /***********************************************************************
 214  *
 215  * Caller:      ProcXOpenDevice
 216  *
 217  * This is the implementation-dependent routine to open an input device.
 218  * Some implementations open all input devices when the server is first
 219  * initialized, and never close them.  Other implementations open only
 220  * the X pointer and keyboard devices during server initialization,
 221  * and only open other input devices when some client makes an
 222  * XOpenDevice request.  This entry point is for the latter type of
 223  * implementation.
 224  *
 225  * If the physical device is not already open, do it here.  In this case,
 226  * you need to keep track of the fact that one or more clients has the
 227  * device open, and physically close it when the last client that has
 228  * it open does an XCloseDevice.
 229  *
 230  * The default implementation is to do nothing (assume all input devices
 231  * are opened during X server initialization and kept open).
 232  *
 233  */
 234
 235 void
 236 OpenInputDevice (dev, client, status)
 237     DeviceIntPtr dev;
 238     ClientPtr client;
 239     int *status;
 240     {
 241     }
 242
 243 /****************************************************************************
 244  *
 245  * Caller:      ProcXSetDeviceMode
 246  *
 247  * Change the mode of an extension device.
 248  * This function is used to change the mode of a device from reporting
 249  * relative motion to reporting absolute positional information, and
 250  * vice versa.
 251  * The default implementation below is that no such devices are supported.
 252  *
 253  */
 254
 255 int
 256 SetDeviceMode (client, dev, mode)
 257     register    ClientPtr       client;
 258     DeviceIntPtr dev;
 259     int         mode;
 260     {
 261     return BadMatch;
 262     }
 263
 264 /****************************************************************************
 265  *
 266  * Caller:      ProcXSetDeviceValuators
 267  *
 268  * Set the value of valuators on an extension input device.
 269  * This function is used to set the initial value of valuators on
 270  * those input devices that are capable of reporting either relative
 271  * motion or an absolute position, and allow an initial position to be set.
 272  * The default implementation below is that no such devices are supported.
 273  *
 274  */
 275
 276 int
 277 SetDeviceValuators (client, dev, valuators, first_valuator, num_valuators)
 278     register    ClientPtr       client;
 279     DeviceIntPtr dev;
 280     int         *valuators;
 281     int         first_valuator;
 282     int         num_valuators;
 283     {
 284     return BadMatch;
 285     }
 286
 287 /****************************************************************************
 288  *
 289  * Caller:      ProcXChangeDeviceControl
 290  *
 291  * Change the specified device controls on an extension input device.
 292  *
 293  */
 294
 295 int
 296 ChangeDeviceControl (client, dev, control)
 297     register    ClientPtr       client;
 298     DeviceIntPtr dev;
 299     xDeviceCtl  *control;
 300     {
 301     switch (control->control)
 302         {
 303         case DEVICE_RESOLUTION:
 304             return (BadMatch);
 305         default:
 306             return (BadMatch);
 307         }
 308     }