src/XF86Misc.c

   1 /* $XFree86: xc/lib/Xxf86misc/XF86Misc.c,v 3.12 2002/11/20 04:04:57 dawes Exp $ */
   2
   3 /*
   4  * Copyright (c) 1995, 1996  The XFree86 Project, Inc
   5  */
   6
   7 /* THIS IS NOT AN X CONSORTIUM STANDARD */
   8
   9 #define NEED_EVENTS
  10 #define NEED_REPLIES
  11 #include <X11/Xlibint.h>
  12 #include <X11/extensions/xf86mscstr.h>
  13 #include <X11/extensions/Xext.h>
  14 #include <X11/extensions/extutil.h>
  15
  16 static XExtensionInfo _xf86misc_info_data;
  17 static XExtensionInfo *xf86misc_info = &_xf86misc_info_data;
  18 static char *xf86misc_extension_name = XF86MISCNAME;
  19
  20 #define XF86MiscCheckExtension(dpy,i,val) \
  21   XextCheckExtension (dpy, i, xf86misc_extension_name, val)
  22
  23 /*****************************************************************************
  24  *                                                                           *
  25  *                         private utility routines                          *
  26  *                                                                           *
  27  *****************************************************************************/
  28
  29 static int close_display(Display *dpy, XExtCodes *codes);
  30
  31 static /* const */ XExtensionHooks xf86misc_extension_hooks = {
  32     NULL,                               /* create_gc */
  33     NULL,                               /* copy_gc */
  34     NULL,                               /* flush_gc */
  35     NULL,                               /* free_gc */
  36     NULL,                               /* create_font */
  37     NULL,                               /* free_font */
  38     close_display,                      /* close_display */
  39     NULL,                               /* wire_to_event */
  40     NULL,                               /* event_to_wire */
  41     NULL,                               /* error */
  42     NULL,                               /* error_string */
  43 };
  44
  45 static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86misc_info,
  46                                    xf86misc_extension_name,
  47                                    &xf86misc_extension_hooks,
  48                                    0, NULL)
  49
  50 static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86misc_info)
  51
  52
  53 /*****************************************************************************
  54  *                                                                           *
  55  *                  public XFree86-Misc Extension routines                *
  56  *                                                                           *
  57  *****************************************************************************/
  58
  59 Bool XF86MiscQueryExtension (Display *dpy, int *event_basep, int *error_basep)
  60 {
  61     XExtDisplayInfo *info = find_display (dpy);
  62
  63     if (XextHasExtension(info)) {
  64         *event_basep = info->codes->first_event;
  65         *error_basep = info->codes->first_error;
  66         return True;
  67     } else {
  68         return False;
  69     }
  70 }
  71
  72 Bool XF86MiscQueryVersion(Display* dpy, int* majorVersion, int* minorVersion)
  73 {
  74     XExtDisplayInfo *info = find_display (dpy);
  75     xXF86MiscQueryVersionReply rep;
  76     xXF86MiscQueryVersionReq *req;
  77
  78     XF86MiscCheckExtension (dpy, info, False);
  79     LockDisplay(dpy);
  80     GetReq(XF86MiscQueryVersion, req);
  81     req->reqType = info->codes->major_opcode;
  82     req->xf86miscReqType = X_XF86MiscQueryVersion;
  83     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  84         UnlockDisplay(dpy);
  85         SyncHandle();
  86         return False;
  87     }
  88     *majorVersion = rep.majorVersion;
  89     *minorVersion = rep.minorVersion;
  90     UnlockDisplay(dpy);
  91     SyncHandle();
  92     if (*majorVersion > 0 || *minorVersion > 5)
  93         XF86MiscSetClientVersion(dpy);
  94
  95     return True;
  96 }
  97
  98 Bool
  99 XF86MiscSetClientVersion(Display *dpy)
 100 {
 101     XExtDisplayInfo *info = find_display(dpy);
 102     xXF86MiscSetClientVersionReq *req;
 103
 104     XF86MiscCheckExtension(dpy, info, False);
 105
 106     LockDisplay(dpy);
 107     GetReq(XF86MiscSetClientVersion, req);
 108     req->reqType = info->codes->major_opcode;
 109     req->xf86miscReqType = X_XF86MiscSetClientVersion;
 110     req->major = XF86MISC_MAJOR_VERSION;
 111     req->minor = XF86MISC_MINOR_VERSION;
 112     UnlockDisplay(dpy);
 113     SyncHandle();
 114     return True;
 115 }
 116
 117 Bool XF86MiscGetMouseSettings(Display* dpy, XF86MiscMouseSettings *mouseinfo)
 118 {
 119     XExtDisplayInfo *info = find_display (dpy);
 120     xXF86MiscGetMouseSettingsReply rep;
 121     xXF86MiscGetMouseSettingsReq *req;
 122
 123     XF86MiscCheckExtension (dpy, info, False);
 124
 125     LockDisplay(dpy);
 126     GetReq(XF86MiscGetMouseSettings, req);
 127     req->reqType = info->codes->major_opcode;
 128     req->xf86miscReqType = X_XF86MiscGetMouseSettings;
 129     if (!_XReply(dpy, (xReply *)&rep,
 130                 (SIZEOF(xXF86MiscGetMouseSettingsReply) - SIZEOF(xReply))>>2,
 131                 xFalse)) {
 132         UnlockDisplay(dpy);
 133         SyncHandle();
 134         return False;
 135     }
 136
 137     mouseinfo->type = rep.mousetype;
 138     mouseinfo->baudrate = rep.baudrate;
 139     mouseinfo->samplerate = rep.samplerate;
 140     mouseinfo->resolution = rep.resolution;
 141     mouseinfo->buttons = rep.buttons;
 142     mouseinfo->emulate3buttons = rep.emulate3buttons;
 143     mouseinfo->emulate3timeout = rep.emulate3timeout;
 144     mouseinfo->chordmiddle = rep.chordmiddle;
 145     mouseinfo->flags = rep.flags;
 146     if (rep.devnamelen > 0) {
 147         if (!(mouseinfo->device = Xcalloc(rep.devnamelen + 1, 1))) {
 148             _XEatData(dpy, (rep.devnamelen+3) & ~3);
 149             Xfree(mouseinfo->device);
 150             return False;
 151         }
 152         _XReadPad(dpy, mouseinfo->device, rep.devnamelen);
 153     } else
 154         mouseinfo->device = NULL;
 155
 156     UnlockDisplay(dpy);
 157     SyncHandle();
 158     return True;
 159 }
 160
 161 Bool XF86MiscGetKbdSettings(Display* dpy, XF86MiscKbdSettings *kbdinfo)
 162 {
 163     XExtDisplayInfo *info = find_display (dpy);
 164     xXF86MiscGetKbdSettingsReply rep;
 165     xXF86MiscGetKbdSettingsReq *req;
 166
 167     XF86MiscCheckExtension (dpy, info, False);
 168
 169     LockDisplay(dpy);
 170     GetReq(XF86MiscGetKbdSettings, req);
 171     req->reqType = info->codes->major_opcode;
 172     req->xf86miscReqType = X_XF86MiscGetKbdSettings;
 173     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 174         UnlockDisplay(dpy);
 175         SyncHandle();
 176         return False;
 177     }
 178
 179     kbdinfo->type = rep.kbdtype;
 180     kbdinfo->rate = rep.rate;
 181     kbdinfo->delay = rep.delay;
 182     kbdinfo->servnumlock = rep.servnumlock;
 183
 184     UnlockDisplay(dpy);
 185     SyncHandle();
 186     return True;
 187 }
 188
 189 Bool XF86MiscSetMouseSettings(Display* dpy, XF86MiscMouseSettings *mouseinfo)
 190 {
 191     XExtDisplayInfo *info = find_display (dpy);
 192     xXF86MiscSetMouseSettingsReq *req;
 193     int majorVersion, minorVersion;
 194
 195     XF86MiscCheckExtension (dpy, info, False);
 196     XF86MiscQueryVersion(dpy, &majorVersion, &minorVersion);
 197
 198     LockDisplay(dpy);
 199     GetReq(XF86MiscSetMouseSettings, req);
 200
 201     req->reqType = info->codes->major_opcode;
 202     req->xf86miscReqType = X_XF86MiscSetMouseSettings;
 203     req->mousetype = mouseinfo->type;
 204     req->baudrate = mouseinfo->baudrate;
 205     req->samplerate = mouseinfo->samplerate;
 206     req->resolution = mouseinfo->resolution;
 207     req->buttons = mouseinfo->buttons;
 208     req->emulate3buttons = mouseinfo->emulate3buttons;
 209     req->emulate3timeout = mouseinfo->emulate3timeout;
 210     req->chordmiddle = mouseinfo->chordmiddle;
 211     req->flags = mouseinfo->flags;
 212     if (majorVersion > 0 || minorVersion > 5) {
 213         int len;
 214         if ((len = strlen(mouseinfo->device))) {
 215         req->devnamelen =  len + 1;
 216         len = (req->devnamelen + 3) >> 2;
 217         SetReqLen(req,len,len);
 218         Data(dpy, mouseinfo->device, req->devnamelen);
 219         }
 220     }
 221
 222     UnlockDisplay(dpy);
 223     SyncHandle();
 224     return True;
 225 }
 226
 227 Bool XF86MiscSetKbdSettings(Display* dpy, XF86MiscKbdSettings *kbdinfo)
 228 {
 229     XExtDisplayInfo *info = find_display (dpy);
 230     xXF86MiscSetKbdSettingsReq *req;
 231
 232     XF86MiscCheckExtension (dpy, info, False);
 233
 234     LockDisplay(dpy);
 235     GetReq(XF86MiscSetKbdSettings, req);
 236     req->reqType = info->codes->major_opcode;
 237     req->xf86miscReqType = X_XF86MiscSetKbdSettings;
 238     req->kbdtype = kbdinfo->type;
 239     req->rate = kbdinfo->rate;
 240     req->delay = kbdinfo->delay;
 241     req->servnumlock = kbdinfo->servnumlock;
 242
 243     UnlockDisplay(dpy);
 244     SyncHandle();
 245     return True;
 246 }
 247
 248 int XF86MiscSetGrabKeysState(Display* dpy, Bool enable)
 249 {
 250     XExtDisplayInfo *info = find_display (dpy);
 251     xXF86MiscSetGrabKeysStateReply rep;
 252     xXF86MiscSetGrabKeysStateReq *req;
 253
 254     XF86MiscCheckExtension (dpy, info, False);
 255
 256     LockDisplay(dpy);
 257     GetReq(XF86MiscSetGrabKeysState, req);
 258     req->reqType = info->codes->major_opcode;
 259     req->xf86miscReqType = X_XF86MiscSetGrabKeysState;
 260     req->enable = enable;
 261     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 262         UnlockDisplay(dpy);
 263         SyncHandle();
 264         return 0;
 265     }
 266
 267     UnlockDisplay(dpy);
 268     SyncHandle();
 269     return rep.status;
 270 }
 271
 272 Bool XF86MiscGetFilePaths(Display* dpy, XF86MiscFilePaths *filpaths)
 273 {
 274     XExtDisplayInfo *info = find_display (dpy);
 275     xXF86MiscGetFilePathsReply rep;
 276     xXF86MiscGetFilePathsReq *req;
 277
 278     XF86MiscCheckExtension (dpy, info, False);
 279
 280     LockDisplay(dpy);
 281     GetReq(XF86MiscGetFilePaths, req);
 282     req->reqType = info->codes->major_opcode;
 283     req->xf86miscReqType = X_XF86MiscGetFilePaths;
 284     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 285         UnlockDisplay(dpy);
 286         SyncHandle();
 287         return False;
 288     }
 289
 290     if (rep.configlen) {
 291         if (!(filpaths->configfile = Xcalloc(rep.configlen + 1, 1))) {
 292             _XEatData(dpy, ((rep.configlen+3) & ~3) + ((rep.modulelen+3) & ~3)
 293                             + ((rep.loglen+3) & ~3));
 294             return False;
 295         }
 296     }
 297
 298     if (rep.modulelen) {
 299         if (!(filpaths->modulepath = Xcalloc(rep.modulelen + 1, 1))) {
 300             _XEatData(dpy, ((rep.configlen+3) & ~3) + ((rep.modulelen+3) & ~3)
 301                             + ((rep.loglen+3) & ~3));
 302             if (filpaths->configfile)
 303                     Xfree(filpaths->configfile);
 304             return False;
 305         }
 306     }
 307
 308     if (rep.loglen) {
 309         if (!(filpaths->logfile = Xcalloc(rep.loglen + 1, 1))) {
 310             _XEatData(dpy, ((rep.configlen+3) & ~3) + ((rep.modulelen+3) & ~3)
 311                             + ((rep.loglen+3) & ~3));
 312             if (filpaths->configfile)
 313                     Xfree(filpaths->configfile);
 314             if (filpaths->modulepath)
 315                     Xfree(filpaths->modulepath);
 316             return False;
 317         }
 318     }
 319
 320     if (rep.configlen)
 321         _XReadPad(dpy, filpaths->configfile, rep.configlen);
 322     else
 323         filpaths->configfile = "";
 324
 325     if (rep.modulelen)
 326         _XReadPad(dpy, filpaths->modulepath, rep.modulelen);
 327     else
 328         filpaths->modulepath = "";
 329
 330     if (rep.loglen)
 331         _XReadPad(dpy, filpaths->logfile, rep.loglen);
 332     else
 333         filpaths->logfile = "";
 334
 335     UnlockDisplay(dpy);
 336     SyncHandle();
 337     return True;
 338 }
 339
 340 Status XF86MiscPassMessage(Display* dpy, int screen,
 341                            const char* msgtype, const char* msgval,
 342                            char** retmsg)
 343 {
 344     XExtDisplayInfo *info = find_display (dpy);
 345     xXF86MiscPassMessageReply rep;
 346     xXF86MiscPassMessageReq *req;
 347     int len;
 348
 349     XF86MiscCheckExtension (dpy, info, False);
 350
 351     LockDisplay(dpy);
 352     GetReq(XF86MiscPassMessage, req);
 353     req->reqType = info->codes->major_opcode;
 354     req->xf86miscReqType = X_XF86MiscPassMessage;
 355     req->screen = screen;
 356     if ((len = strlen(msgtype))) {
 357         req->typelen =  len + 1;
 358         len = (req->typelen + 3) >> 2;
 359         SetReqLen(req,len,len);
 360         Data(dpy, msgtype, req->typelen);
 361     }
 362     if ((len = strlen(msgval))) {
 363         req->vallen =  len + 1;
 364         len = (req->vallen + 3) >> 2;
 365         SetReqLen(req,len,len);
 366         Data(dpy, msgval, req->vallen);
 367     }
 368     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 369         UnlockDisplay(dpy);
 370         SyncHandle();
 371         return BadImplementation;
 372     }
 373
 374     if (rep.mesglen) {
 375         if (!(*retmsg = Xcalloc(rep.mesglen + 1, 1))) {
 376             _XEatData(dpy, ((rep.mesglen+3) & ~3));
 377             return BadAlloc;
 378         }
 379         _XReadPad(dpy, *retmsg, rep.mesglen);
 380     }
 381
 382     UnlockDisplay(dpy);
 383     SyncHandle();
 384     return rep.status;
 385 }
 386