ioncore/eventh.c

   1 /*
   2  * ion/ioncore/eventh.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <sys/time.h>
  12
  13 #include <libtu/objp.h>
  14 #include "common.h"
  15 #include "global.h"
  16 #include "rootwin.h"
  17 #include "property.h"
  18 #include "pointer.h"
  19 #include "key.h"
  20 #include "focus.h"
  21 #include "selection.h"
  22 #include "event.h"
  23 #include "eventh.h"
  24 #include "clientwin.h"
  25 #include "colormap.h"
  26 #include "grab.h"
  27 #include "bindmaps.h"
  28 #include "activity.h"
  29 #include "netwm.h"
  30 #include "xwindow.h"
  31 #include "log.h"
  32
  33
  34 /*{{{ ioncore_handle_event */
  35
  36
  37 #define CASE_EVENT(EV) case EV:  /*\
  38     fprintf(stderr, "[%#lx] %s\n", ev->xany.window, #EV);*/
  39
  40
  41 bool ioncore_handle_event(XEvent *ev)
  42 {
  43
  44     switch(ev->type){
  45     CASE_EVENT(MapRequest)
  46         ioncore_handle_map_request(&(ev->xmaprequest));
  47         break;
  48     CASE_EVENT(ConfigureRequest)
  49         ioncore_handle_configure_request(&(ev->xconfigurerequest));
  50         break;
  51     CASE_EVENT(UnmapNotify)
  52         ioncore_handle_unmap_notify(&(ev->xunmap));
  53         break;
  54     CASE_EVENT(DestroyNotify)
  55         ioncore_handle_destroy_notify(&(ev->xdestroywindow));
  56         break;
  57     CASE_EVENT(ClientMessage)
  58         ioncore_handle_client_message(&(ev->xclient));
  59         break;
  60     CASE_EVENT(PropertyNotify)
  61         ioncore_handle_property(&(ev->xproperty));
  62         break;
  63     CASE_EVENT(FocusIn)
  64         ioncore_handle_focus_in(&(ev->xfocus));
  65         break;
  66     CASE_EVENT(FocusOut)
  67         ioncore_handle_focus_out(&(ev->xfocus));
  68         break;
  69     CASE_EVENT(EnterNotify)
  70         ioncore_handle_enter_window(ev);
  71         break;
  72     CASE_EVENT(Expose)
  73         ioncore_handle_expose(&(ev->xexpose));
  74         break;
  75     CASE_EVENT(KeyPress)
  76         ioncore_handle_keyboard(ev);
  77         break;
  78     CASE_EVENT(KeyRelease)
  79         ioncore_handle_keyboard(ev);
  80         break;
  81     CASE_EVENT(ButtonPress)
  82         ioncore_handle_buttonpress(ev);
  83         break;
  84     CASE_EVENT(ColormapNotify)
  85         ioncore_handle_colormap_notify(&(ev->xcolormap));
  86         break;
  87     CASE_EVENT(MappingNotify)
  88         ioncore_handle_mapping_notify(ev);
  89         break;
  90     CASE_EVENT(SelectionClear)
  91         ioncore_clear_selection();
  92         break;
  93     CASE_EVENT(SelectionNotify)
  94         ioncore_handle_selection(&(ev->xselection));
  95         break;
  96     CASE_EVENT(SelectionRequest)
  97         ioncore_handle_selection_request(&(ev->xselectionrequest));
  98         break;
  99     default:
 100         return FALSE;
 101     }
 102
 103     return TRUE;
 104 }
 105
 106
 107 /*}}}*/
 108
 109
 110 /*{{{ Map, unmap, destroy */
 111
 112
 113 void ioncore_handle_map_request(const XMapRequestEvent *ev)
 114 {
 115     WRegion *reg;
 116
 117     reg=XWINDOW_REGION_OF(ev->window);
 118
 119     if(reg!=NULL)
 120         return;
 121
 122     ioncore_manage_clientwin(ev->window, TRUE);
 123 }
 124
 125
 126 void ioncore_handle_unmap_notify(const XUnmapEvent *ev)
 127 {
 128     WClientWin *cwin;
 129
 130     /* We are not interested in SubstructureNotify -unmaps. */
 131     if(ev->event!=ev->window && ev->send_event!=True)
 132         return;
 133
 134     cwin=XWINDOW_REGION_OF_T(ev->window, WClientWin);
 135
 136     if(cwin!=NULL)
 137         clientwin_unmapped(cwin);
 138 }
 139
 140
 141 void ioncore_handle_destroy_notify(const XDestroyWindowEvent *ev)
 142 {
 143     WClientWin *cwin;
 144
 145     cwin=XWINDOW_REGION_OF_T(ev->window, WClientWin);
 146
 147     if(cwin!=NULL)
 148         clientwin_destroyed(cwin);
 149 }
 150
 151
 152 /*}}}*/
 153
 154
 155 /*{{{ Client configure/property/message */
 156
 157 void ioncore_handle_configure_request(XConfigureRequestEvent *ev)
 158 {
 159     WClientWin *cwin;
 160     XWindowChanges wc;
 161
 162     cwin=XWINDOW_REGION_OF_T(ev->window, WClientWin);
 163
 164     if(cwin==NULL){
 165         wc.border_width=ev->border_width;
 166         wc.sibling=ev->above;
 167         wc.stack_mode=ev->detail;
 168         wc.x=ev->x;
 169         wc.y=ev->y;
 170         wc.width=ev->width;
 171         wc.height=ev->height;
 172         XConfigureWindow(ioncore_g.dpy, ev->window, ev->value_mask, &wc);
 173         return;
 174     }
 175
 176     clientwin_handle_configure_request(cwin, ev);
 177 }
 178
 179
 180 void ioncore_handle_client_message(const XClientMessageEvent *ev)
 181 {
 182     netwm_handle_client_message(ev);
 183
 184 #if 0
 185     WClientWin *cwin;
 186
 187     if(ev->message_type!=ioncore_g.atom_wm_change_state)
 188         return;
 189
 190     cwin=XWINDOW_REGION_OF_T(ev->window, WClientWin);
 191
 192     if(cwin==NULL)
 193         return;
 194
 195     if(ev->format==32 && ev->data.l[0]==IconicState){
 196         if(cwin->state==NormalState)
 197             iconify_clientwin(cwin);
 198     }
 199 #endif
 200 }
 201
 202
 203 static bool pchg_mrsh_extl(ExtlFn fn, void **p)
 204 {
 205     extl_call(fn, "oi", NULL, p[0], ((XPropertyEvent*)p[1])->atom);
 206     return TRUE;
 207 }
 208
 209 static bool pchg_mrsh(void (*fn)(void *p1, void *p2), void **p)
 210 {
 211     fn(p[0], p[1]);
 212     return TRUE;
 213 }
 214
 215
 216 void ioncore_handle_property(const XPropertyEvent *ev)
 217 {
 218     WClientWin *cwin;
 219
 220     cwin=XWINDOW_REGION_OF_T(ev->window, WClientWin);
 221
 222     if(cwin==NULL)
 223         return;
 224
 225     if(ev->atom==XA_WM_HINTS){
 226         XWMHints *hints;
 227         hints=XGetWMHints(ioncore_g.dpy, ev->window);
 228         /* region_notify/clear_activity take care of checking current state */
 229         if(hints!=NULL){
 230             if(hints->flags&XUrgencyHint){
 231                 if(!region_skip_focus((WRegion*)cwin))
 232                     region_set_activity((WRegion*)cwin, SETPARAM_SET);
 233             }else{
 234                 region_set_activity((WRegion*)cwin, SETPARAM_UNSET);
 235             }
 236         }
 237         XFree(hints);
 238     }else if(ev->atom==XA_WM_NORMAL_HINTS){
 239         if(ev->state==PropertyNewValue){
 240             if(clientwin_get_size_hints(cwin)<0)
 241                 LOG(WARN, GENERAL, "Retrieving sizehints failed for cwin '%s'", cwin->region.ni.name);
 242         }else if(ev->state==PropertyDelete)
 243             clientwin_reset_size_hints(cwin);
 244     }else if(ev->atom==XA_WM_NAME){
 245         if(!(cwin->flags&CLIENTWIN_USE_NET_WM_NAME))
 246             clientwin_get_set_name(cwin);
 247     }else if(ev->atom==XA_WM_TRANSIENT_FOR){
 248         clientwin_tfor_changed(cwin);
 249     }else if(ev->atom==ioncore_g.atom_wm_protocols){
 250         clientwin_get_protocols(cwin);
 251     }else{
 252         netwm_handle_property(cwin, ev);
 253     }
 254
 255     /* Call property hook */
 256     {
 257         void *p[2];
 258         p[0]=(void*)cwin;
 259         p[1]=(void*)ev;
 260         hook_call(clientwin_property_change_hook, p,
 261                   (WHookMarshall*)pchg_mrsh,
 262                   (WHookMarshallExtl*)pchg_mrsh_extl);
 263     }
 264 }
 265
 266
 267 /*}}}*/
 268
 269
 270 /*{{{ Misc. notifies */
 271
 272
 273 void ioncore_handle_mapping_notify(XEvent *ev)
 274 {
 275     do{
 276         XRefreshKeyboardMapping(&(ev->xmapping));
 277     }while(XCheckTypedEvent(ioncore_g.dpy, MappingNotify, ev));
 278
 279     ioncore_refresh_bindmaps();
 280 }
 281
 282
 283 /*}}}*/
 284
 285
 286 /*{{{ Expose */
 287
 288
 289 void ioncore_handle_expose(const XExposeEvent *ev)
 290 {
 291     WWindow *wwin;
 292     XEvent tmp;
 293
 294     while(XCheckWindowEvent(ioncore_g.dpy, ev->window, ExposureMask, &tmp))
 295         /* nothing */;
 296
 297     wwin=XWINDOW_REGION_OF_T(ev->window, WWindow);
 298
 299     if(wwin!=NULL)
 300         window_draw(wwin, FALSE);
 301 }
 302
 303
 304 /*}}}*/
 305
 306
 307 /*{{{ Enter window, focus */
 308
 309
 310 void ioncore_handle_enter_window(XEvent *ev)
 311 {
 312     XEnterWindowEvent *eev=&(ev->xcrossing);
 313     WRegion *reg=NULL;
 314
 315     if(ioncore_g.input_mode!=IONCORE_INPUTMODE_NORMAL ||
 316        ioncore_g.no_mousefocus){
 317         return;
 318     }
 319
 320     if(eev->mode!=NotifyNormal && !ioncore_g.warp_enabled)
 321         return;
 322
 323     reg=XWINDOW_REGION_OF_T(eev->window, WRegion);
 324
 325     if(reg==NULL)
 326         return;
 327
 328     if(REGION_IS_ACTIVE(reg))
 329         return;
 330
 331     if(region_skip_focus(reg))
 332         return;
 333
 334     if(ioncore_g.focus_next!=NULL &&
 335        ioncore_g.focus_next_source<IONCORE_FOCUSNEXT_ENTERWINDOW){
 336         return;
 337     }
 338
 339     /* If a child of 'reg' is to be focused, do not process this
 340      * event. (ioncore_g.focus_next should only be set here by
 341      * another call to use from ioncore_handle_enter_window below.)
 342      */
 343     if(ioncore_g.focus_next!=NULL){
 344         WRegion *r2=ioncore_g.focus_next;
 345         while(r2!=NULL){
 346             if(r2==reg)
 347                 return;
 348             r2=REGION_PARENT_REG(r2);
 349         }
 350     }
 351
 352     if(region_goto_flags(reg, (REGION_GOTO_FOCUS|
 353                                REGION_GOTO_NOWARP|
 354                                REGION_GOTO_ENTERWINDOW))){
 355         ioncore_g.focus_next_source=IONCORE_FOCUSNEXT_ENTERWINDOW;
 356     }
 357 }
 358
 359
 360 static bool pointer_in_root(Window root1)
 361 {
 362     Window root2=None, win;
 363     int x, y, wx, wy;
 364     uint mask;
 365
 366     XQueryPointer(ioncore_g.dpy, root1, &root2, &win,
 367                   &x, &y, &wx, &wy, &mask);
 368
 369     return (root1==root2);
 370 }
 371
 372
 373 void ioncore_handle_focus_in(const XFocusChangeEvent *ev)
 374 {
 375     WRegion *reg;
 376     WWindow *wwin;
 377
 378     reg=XWINDOW_REGION_OF_T(ev->window, WRegion);
 379
 380     if(reg==NULL)
 381         return;
 382
 383     D(fprintf(stderr, "FI: %s %p %d %d\n", OBJ_TYPESTR(reg), reg, ev->mode, ev->detail);)
 384
 385     if(ev->mode==NotifyGrab)
 386         return;
 387
 388     if(ev->detail==NotifyPointer)
 389         return;
 390
 391     /* Input contexts */
 392     if(OBJ_IS(reg, WWindow)){
 393         wwin=(WWindow*)reg;
 394         if(wwin->xic!=NULL)
 395             XSetICFocus(wwin->xic);
 396     }
 397
 398     if(ev->detail!=NotifyInferior)
 399         netwm_set_active(reg);
 400
 401     region_got_focus(reg);
 402
 403     if(ioncore_g.focus_next!=NULL &&
 404        ioncore_g.focus_next_source<IONCORE_FOCUSNEXT_FALLBACK){
 405         return;
 406     }
 407
 408     if((ev->detail==NotifyPointerRoot || ev->detail==NotifyDetailNone)
 409        && ev->window==region_root_of(reg) /* OBJ_IS(reg, WRootWin) */){
 410         /* Restore focus if it was returned to a root window and we don't
 411          * know of a pending focus change.
 412          */
 413         if(pointer_in_root(ev->window)){
 414             region_set_focus(reg);
 415             ioncore_g.focus_next_source=IONCORE_FOCUSNEXT_FALLBACK;
 416         }
 417     }else{
 418         /* Something got the focus, don't use fallback. */
 419         ioncore_g.focus_next=NULL;
 420     }
 421 }
 422
 423
 424 void ioncore_handle_focus_out(const XFocusChangeEvent *ev)
 425 {
 426     WRegion *reg;
 427     WWindow *wwin;
 428
 429     reg=XWINDOW_REGION_OF_T(ev->window, WRegion);
 430
 431     if(reg==NULL)
 432         return;
 433
 434     D(fprintf(stderr, "FO: %s %p %d %d\n", OBJ_TYPESTR(reg), reg, ev->mode, ev->detail);)
 435
 436     if(ev->mode==NotifyGrab)
 437         return;
 438
 439     if(ev->detail==NotifyPointer)
 440         return;
 441
 442     D(if(OBJ_IS(reg, WRootWin))
 443       fprintf(stderr, "scr-out %d %d %d\n", ((WRootWin*)reg)->xscr, ev->mode, ev->detail));
 444
 445     if(OBJ_IS(reg, WWindow)){
 446         wwin=(WWindow*)reg;
 447         if(wwin->xic!=NULL)
 448             XUnsetICFocus(wwin->xic);
 449     }
 450
 451     if(ev->detail!=NotifyInferior)
 452         region_lost_focus(reg);
 453     else
 454         region_got_focus(reg);
 455 }
 456
 457
 458 /*}}}*/
 459
 460
 461 /*{{{ Pointer, keyboard */
 462
 463
 464 void ioncore_handle_buttonpress(XEvent *ev)
 465 {
 466     XEvent tmp;
 467     bool finished=FALSE;
 468
 469     if(ioncore_grab_held())
 470         return;
 471
 472     if(!ioncore_do_handle_buttonpress(&(ev->xbutton)))
 473         return;
 474
 475     while(!finished && ioncore_grab_held()){
 476         XFlush(ioncore_g.dpy);
 477         ioncore_get_event(ev, IONCORE_EVENTMASK_PTRLOOP);
 478
 479         if(ev->type==MotionNotify){
 480             /* Handle sequences of MotionNotify (possibly followed by button
 481              * release) as one.
 482              */
 483             if(XPeekEvent(ioncore_g.dpy, &tmp)){
 484                 if(tmp.type==MotionNotify || tmp.type==ButtonRelease)
 485                     XNextEvent(ioncore_g.dpy, ev);
 486             }
 487         }
 488
 489         switch(ev->type){
 490         CASE_EVENT(ButtonRelease)
 491             if(ioncore_do_handle_buttonrelease(&ev->xbutton))
 492                 finished=TRUE;
 493             break;
 494         CASE_EVENT(MotionNotify)
 495             ioncore_do_handle_motionnotify(&ev->xmotion);
 496             break;
 497         CASE_EVENT(Expose)
 498             ioncore_handle_expose(&(ev->xexpose));
 499             break;
 500         CASE_EVENT(KeyPress)
 501         CASE_EVENT(KeyRelease)
 502             ioncore_handle_grabs(ev);
 503             break;
 504         CASE_EVENT(FocusIn)
 505             ioncore_handle_focus_in(&(ev->xfocus));
 506             break;
 507         CASE_EVENT(FocusOut)
 508             ioncore_handle_focus_out(&(ev->xfocus));
 509             break;
 510         }
 511     }
 512 }
 513
 514
 515 void ioncore_handle_keyboard(XEvent *ev)
 516 {
 517     if(ioncore_handle_grabs(ev))
 518         return;
 519
 520     if(ev->type==KeyPress)
 521         ioncore_do_handle_keypress(&(ev->xkey));
 522 }
 523
 524
 525 /*}}}*/
 526
 527