libs/FEvent.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /* ---------------------------- included header files ---------------------- */
  18
  19 #define FEVENT_C
  20 #define FEVENT_PRIVILEGED_ACCESS
  21 #include "config.h"
  22 #include "libs/fvwmlib.h"
  23 #include <X11/Xlib.h>
  24 #include "FEvent.h"
  25 #undef FEVENT_C
  26 #undef FEVENT_PRIVILEGED_ACCESS
  27
  28 #include <stdio.h>
  29
  30 #include "libs/ftime.h"
  31
  32 /* ---------------------------- local definitions -------------------------- */
  33
  34 /* ---------------------------- local macros ------------------------------- */
  35
  36 /* ---------------------------- imports ------------------------------------ */
  37
  38 /* ---------------------------- included code files ------------------------ */
  39
  40 /* ---------------------------- local types -------------------------------- */
  41
  42 typedef struct
  43 {
  44         Bool (*predicate) (Display *display, XEvent *event, XPointer arg);
  45         XPointer arg;
  46         XEvent event;
  47         Bool found;
  48 } fev_check_peek_args;
  49
  50 /* ---------------------------- forward declarations ----------------------- */
  51
  52 /* ---------------------------- local variables ---------------------------- */
  53
  54 static XEvent fev_event;
  55 static XEvent fev_event_old;
  56 /* until Xlib does this for us */
  57 Time fev_last_timestamp = CurrentTime;
  58
  59 /* ---------------------------- exported variables (globals) --------------- */
  60
  61 /* ---------------------------- local functions ---------------------------- */
  62
  63 /* Records the time of the last processed event. */
  64 static void fev_update_last_timestamp(const XEvent *ev)
  65 {
  66         Time new_timestamp = CurrentTime;
  67
  68         switch (ev->type)
  69         {
  70         case KeyPress:
  71         case KeyRelease:
  72                 new_timestamp = ev->xkey.time;
  73                 break;
  74         case ButtonPress:
  75         case ButtonRelease:
  76                 new_timestamp = ev->xbutton.time;
  77                 break;
  78         case MotionNotify:
  79                 new_timestamp = ev->xmotion.time;
  80                 break;
  81         case EnterNotify:
  82         case LeaveNotify:
  83                 new_timestamp = ev->xcrossing.time;
  84                 break;
  85         case PropertyNotify:
  86                 new_timestamp = ev->xproperty.time;
  87                 break;
  88         case SelectionClear:
  89                 new_timestamp = ev->xselectionclear.time;
  90                 break;
  91         case SelectionRequest:
  92                 new_timestamp = ev->xselectionrequest.time;
  93                 break;
  94         case SelectionNotify:
  95                 new_timestamp = ev->xselection.time;
  96                 break;
  97         default:
  98                 return;
  99         }
 100         /* Only update if the new timestamp is later than the old one, or
 101          * if the new one is from a time at least 30 seconds earlier than the
 102          * old one (in which case the system clock may have changed) */
 103         if (new_timestamp > fev_last_timestamp ||
 104             fev_last_timestamp - new_timestamp > CLOCK_SKEW_MS)
 105         {
 106                 fev_last_timestamp = new_timestamp;
 107         }
 108
 109         return;
 110 }
 111
 112 static Bool fev_check_peek_pred(
 113         Display *display, XEvent *event, XPointer arg)
 114 {
 115         fev_check_peek_args *cpa = (fev_check_peek_args *)arg;
 116
 117         if (cpa->found == True)
 118         {
 119                 return False;
 120         }
 121         cpa->found = cpa->predicate(display, event, cpa->arg);
 122         if (cpa->found == True)
 123         {
 124                 cpa->event = *event;
 125         }
 126
 127         return False;
 128 }
 129
 130 /* ---------------------------- interface functions (privileged access) ----- */
 131
 132 void fev_copy_last_event(XEvent *dest)
 133 {
 134         *dest = fev_event;
 135
 136         return;
 137 }
 138
 139 XEvent *fev_get_last_event_address(void)
 140 {
 141         return &fev_event;
 142 }
 143
 144 /* ---------------------------- interface functions (normal_access) -------- */
 145
 146 Time fev_get_evtime(void)
 147 {
 148         return fev_last_timestamp;
 149 }
 150
 151 Bool fev_get_evpos_or_query(
 152         Display *dpy, Window w, const XEvent *e, int *ret_x, int *ret_y)
 153 {
 154         Window JunkW;
 155         int JunkC;
 156         unsigned int JunkM;
 157         Bool rc;
 158         int type;
 159
 160         type = (e != NULL) ? e->type : -1;
 161         switch (type)
 162         {
 163         case ButtonPress:
 164         case ButtonRelease:
 165                 *ret_x = e->xbutton.x_root;
 166                 *ret_y = e->xbutton.y_root;
 167                 return True;
 168         case KeyPress:
 169         case KeyRelease:
 170                 *ret_x = e->xkey.x_root;
 171                 *ret_y = e->xkey.y_root;
 172                 return True;
 173         case EnterNotify:
 174         case LeaveNotify:
 175                 *ret_x = e->xcrossing.x_root;
 176                 *ret_y = e->xcrossing.y_root;
 177                 return True;
 178         case MotionNotify:
 179                 if (e->xmotion.same_screen == True)
 180                 {
 181                         *ret_x = e->xmotion.x_root;
 182                         *ret_y = e->xmotion.y_root;
 183                 }
 184                 else
 185                 {
 186                         /* pointer is on different screen */
 187                         *ret_x = 0;
 188                         *ret_y = 0;
 189                 }
 190                 return True;
 191         default:
 192                 rc = FQueryPointer(
 193                         dpy, w, &JunkW, &JunkW, ret_x, ret_y, &JunkC, &JunkC,
 194                         &JunkM);
 195                 if (rc == False)
 196                 {
 197                         /* pointer is on a different screen */
 198                         *ret_x = 0;
 199                         *ret_y = 0;
 200                 }
 201                 return rc;
 202         }
 203 }
 204
 205 Bool fev_set_evpos(XEvent *e, int x, int y)
 206 {
 207         switch (e->type)
 208         {
 209         case ButtonPress:
 210         case ButtonRelease:
 211                 e->xbutton.x_root = x;
 212                 e->xbutton.y_root = y;
 213                 return True;
 214         case KeyPress:
 215         case KeyRelease:
 216                 e->xkey.x_root = x;
 217                 e->xkey.y_root = y;
 218                 return True;
 219         case MotionNotify:
 220                 if (e->xmotion.same_screen == True)
 221                 {
 222                         e->xmotion.x_root = x;
 223                         e->xmotion.y_root = y;
 224                         return True;
 225                 }
 226                 break;
 227         default:
 228                 break;
 229         } /* switch */
 230
 231         return False;
 232 }
 233
 234 void fev_fake_event(XEvent *ev)
 235 {
 236         fev_event_old = fev_event;
 237         fev_event = *ev;
 238         /* don't update the last timestamp here; the triggering event has
 239          * already done this */
 240
 241         return;
 242 }
 243
 244 void *fev_save_event(void)
 245 {
 246         XEvent *ev;
 247
 248         ev = (XEvent *)safemalloc(sizeof(XEvent));
 249         *ev = fev_event;
 250
 251         return ev;
 252 }
 253
 254 void fev_restore_event(void *ev)
 255 {
 256         fev_event = *(XEvent *)ev;
 257         free(ev);
 258
 259         return;
 260 }
 261
 262 void fev_make_null_event(XEvent *ev, Display *dpy)
 263 {
 264         memset(ev, 0, sizeof(*ev));
 265         ev->xany.serial = fev_event.xany.serial;
 266         ev->xany.display = dpy;
 267
 268         return;
 269 }
 270
 271 void fev_get_last_event(XEvent *ev)
 272 {
 273         *ev = fev_event;
 274
 275         return;
 276 }
 277
 278 /* ---------------------------- X event replacements ----------------------- */
 279
 280 XTimeCoord *FGetMotionEvents(
 281         Display *display, Window w, Time start, Time stop, int *nevents_return)
 282 {
 283         XTimeCoord *rc;
 284
 285         rc = XGetMotionEvents(display, w, start, stop, nevents_return);
 286
 287         return rc;
 288 }
 289
 290 int FAllowEvents(
 291         Display *display, int event_mode, Time time)
 292 {
 293         int rc;
 294
 295         rc = XAllowEvents(display, event_mode, time);
 296
 297         return rc;
 298 }
 299
 300 Bool FCheckIfEvent(
 301         Display *display, XEvent *event_return,
 302         Bool (*predicate) (Display *display, XEvent *event, XPointer arg),
 303         XPointer arg)
 304 {
 305         Bool rc;
 306         XEvent new_ev;
 307
 308         rc = XCheckIfEvent(display, &new_ev, predicate, arg);
 309         if (rc == True)
 310         {
 311                 fev_event_old = fev_event;
 312                 fev_event = new_ev;
 313                 *event_return = fev_event;
 314                 fev_update_last_timestamp(event_return);
 315         }
 316
 317         return rc;
 318 }
 319
 320 Bool FCheckMaskEvent(
 321         Display *display, long event_mask, XEvent *event_return)
 322 {
 323         Bool rc;
 324         XEvent new_ev;
 325
 326         rc = XCheckMaskEvent(display, event_mask, &new_ev);
 327         if (rc == True)
 328         {
 329                 fev_event_old = fev_event;
 330                 fev_event = new_ev;
 331                 *event_return = fev_event;
 332                 fev_update_last_timestamp(event_return);
 333         }
 334
 335         return rc;
 336 }
 337
 338 Bool FCheckPeekIfEvent(
 339         Display *display, XEvent *event_return,
 340         Bool (*predicate) (Display *display, XEvent *event, XPointer arg),
 341         XPointer arg)
 342 {
 343         XEvent dummy;
 344         fev_check_peek_args cpa;
 345
 346         cpa.predicate = predicate;
 347         cpa.arg = arg;
 348         cpa.found = False;
 349         XCheckIfEvent(display, &dummy, fev_check_peek_pred, (char *)&cpa);
 350         if (cpa.found == True)
 351         {
 352                 *event_return = cpa.event;
 353                 fev_update_last_timestamp(event_return);
 354         }
 355
 356         return cpa.found;
 357 }
 358
 359 Bool FCheckTypedEvent(
 360         Display *display, int event_type, XEvent *event_return)
 361 {
 362         Bool rc;
 363         XEvent new_ev;
 364
 365         rc = XCheckTypedEvent(display, event_type, &new_ev);
 366         if (rc == True)
 367         {
 368                 fev_event_old = fev_event;
 369                 fev_event = new_ev;
 370                 *event_return = fev_event;
 371                 fev_update_last_timestamp(event_return);
 372         }
 373
 374         return rc;
 375 }
 376
 377 Bool FCheckTypedWindowEvent(
 378         Display *display, Window w, int event_type, XEvent *event_return)
 379 {
 380         Bool rc;
 381         XEvent new_ev;
 382
 383         rc = XCheckTypedWindowEvent(display, w, event_type, &new_ev);
 384         if (rc == True)
 385         {
 386                 fev_event_old = fev_event;
 387                 fev_event = new_ev;
 388                 *event_return = fev_event;
 389                 fev_update_last_timestamp(event_return);
 390         }
 391
 392         return rc;
 393 }
 394
 395 Bool FCheckWindowEvent(
 396         Display *display, Window w, long event_mask, XEvent *event_return)
 397 {
 398         Bool rc;
 399         XEvent new_ev;
 400
 401         rc = XCheckWindowEvent(display, w, event_mask, &new_ev);
 402         if (rc == True)
 403         {
 404                 fev_event_old = fev_event;
 405                 fev_event = new_ev;
 406                 *event_return = fev_event;
 407                 fev_update_last_timestamp(event_return);
 408         }
 409
 410         return rc;
 411 }
 412
 413 int FEventsQueued(
 414         Display *display, int mode)
 415 {
 416         int rc;
 417
 418         rc = XEventsQueued(display, mode);
 419
 420         return rc;
 421 }
 422
 423 int FIfEvent(
 424         Display *display, XEvent *event_return,
 425         Bool (*predicate) (Display *display, XEvent *event, XPointer arg),
 426         XPointer arg)
 427 {
 428         int rc;
 429
 430         fev_event_old = fev_event;
 431         rc = XIfEvent(display, &fev_event, predicate, arg);
 432         *event_return = fev_event;
 433         fev_update_last_timestamp(event_return);
 434
 435         return rc;
 436 }
 437
 438 int FMaskEvent(
 439         Display *display, long event_mask, XEvent *event_return)
 440 {
 441         int rc;
 442
 443         fev_event_old = fev_event;
 444         rc = XMaskEvent(display, event_mask, &fev_event);
 445         *event_return = fev_event;
 446         fev_update_last_timestamp(event_return);
 447
 448         return rc;
 449 }
 450
 451 int FNextEvent(
 452         Display *display, XEvent *event_return)
 453 {
 454         int rc;
 455
 456         fev_event_old = fev_event;
 457         rc = XNextEvent(display, &fev_event);
 458         *event_return = fev_event;
 459         fev_update_last_timestamp(event_return);
 460
 461         return rc;
 462 }
 463
 464 int FPeekEvent(
 465         Display *display, XEvent *event_return)
 466 {
 467         int rc;
 468
 469         rc = XPeekEvent(display, event_return);
 470         if (rc == True)
 471         {
 472                 fev_update_last_timestamp(event_return);
 473         }
 474
 475         return rc;
 476 }
 477
 478 int FPeekIfEvent(
 479         Display *display, XEvent *event_return,
 480         Bool (*predicate) (Display *display, XEvent *event, XPointer arg),
 481         XPointer arg)
 482 {
 483         int rc;
 484
 485         rc = XPeekIfEvent(display, event_return, predicate, arg);
 486         if (rc == True)
 487         {
 488                 fev_update_last_timestamp(event_return);
 489         }
 490
 491         return rc;
 492 }
 493
 494 int FPending(
 495         Display *display)
 496 {
 497         int rc;
 498
 499         rc = XPending(display);
 500
 501         return rc;
 502 }
 503
 504 int FPutBackEvent(
 505         Display *display, XEvent *event)
 506 {
 507         int rc;
 508
 509         rc = XPutBackEvent(display, event);
 510         fev_event = fev_event_old;
 511
 512         return rc;
 513 }
 514
 515 int FQLength(
 516         Display *display)
 517 {
 518         int rc;
 519
 520         rc = XQLength(display);
 521
 522         return rc;
 523 }
 524
 525 Bool FQueryPointer(
 526         Display *display, Window w, Window *root_return, Window *child_return,
 527         int *root_x_return, int *root_y_return, int *win_x_return,
 528         int *win_y_return, unsigned int *mask_return)
 529 {
 530         Bool rc;
 531
 532         rc = XQueryPointer(
 533                 display, w, root_return, child_return, root_x_return,
 534                 root_y_return, win_x_return, win_y_return, mask_return);
 535
 536         return rc;
 537 }
 538
 539 Status FSendEvent(
 540         Display *display, Window w, Bool propagate, long event_mask,
 541         XEvent *event_send)
 542 {
 543         Status rc;
 544
 545         rc = XSendEvent(display, w, propagate, event_mask, event_send);
 546
 547         return rc;
 548 }
 549
 550 int FWarpPointer(
 551         Display *display, Window src_w, Window dest_w, int src_x, int src_y,
 552         unsigned int src_width, unsigned int src_height, int dest_x, int dest_y)
 553 {
 554         int rc;
 555
 556         rc = XWarpPointer(
 557                 display, src_w, dest_w, src_x, src_y, src_width, src_height,
 558                 dest_x, dest_y);
 559
 560         return rc;
 561 }
 562
 563 int FWarpPointerUpdateEvpos(
 564         XEvent *ev, Display *display, Window src_w, Window dest_w, int src_x,
 565         int src_y, unsigned int src_width, unsigned int src_height,
 566         int dest_x, int dest_y)
 567 {
 568         int rc;
 569
 570         rc = XWarpPointer(
 571                 display, src_w, dest_w, src_x, src_y, src_width, src_height,
 572                 dest_x, dest_y);
 573         if (ev != NULL && dest_w == DefaultRootWindow(display))
 574         {
 575                 fev_set_evpos(ev, dest_x, dest_y);
 576         }
 577
 578         return rc;
 579 }
 580
 581 int FWindowEvent(
 582         Display *display, Window w, long event_mask, XEvent *event_return)
 583 {
 584         int rc;
 585
 586         fev_event_old = fev_event;
 587         rc = XWindowEvent(display, w, event_mask, &fev_event);
 588         *event_return = fev_event;
 589         fev_update_last_timestamp(event_return);
 590
 591         return rc;
 592 }