event.c

   1 /*
   2  * event.c - event handlers
   3  *
   4  * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <X11/keysym.h>
  23 #include <X11/Xatom.h>
  24 #include <X11/Xutil.h>
  25 #include <X11/extensions/shape.h>
  26 #include <X11/extensions/Xrandr.h>
  27
  28 #include "screen.h"
  29 #include "event.h"
  30 #include "tag.h"
  31 #include "statusbar.h"
  32 #include "window.h"
  33 #include "mouse.h"
  34 #include "ewmh.h"
  35 #include "client.h"
  36 #include "widget.h"
  37 #include "rules.h"
  38 #include "titlebar.h"
  39 #include "layouts/tile.h"
  40 #include "layouts/floating.h"
  41 #include "common/xscreen.h"
  42
  43 extern AwesomeConf globalconf;
  44
  45 /** Handle mouse button click
  46  * \param screen screen number
  47  * \param button button number
  48  * \param state modkeys state
  49  * \param buttons buttons list to check for
  50  * \param arg optional arg passed to uicb, otherwise buttons' arg are used
  51  */
  52 static void
  53 event_handle_mouse_button_press(int screen, unsigned int button, unsigned int state,
  54                           Button *buttons, char *arg)
  55 {
  56     Button *b;
  57
  58     for(b = buttons; b; b = b->next)
  59         if(button == b->button && CLEANMASK(state) == b->mod && b->func)
  60         {
  61             if(arg)
  62                 b->func(screen, arg);
  63             else
  64                 b->func(screen, b->arg);
  65             return;
  66         }
  67 }
  68
  69 /** Handle XButtonPressed events
  70  * \param e XEvent
  71  */
  72 void
  73 event_handle_buttonpress(XEvent *e)
  74 {
  75     int i, screen, x = 0, y = 0;
  76     unsigned int udummy;
  77     Client *c;
  78     Window wdummy;
  79     Widget *widget;
  80     Statusbar *statusbar;
  81     XButtonPressedEvent *ev = &e->xbutton;
  82
  83     for(screen = 0; screen < globalconf.screens_info->nscreen; screen++)
  84         for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
  85             if(statusbar->sw->window == ev->window || statusbar->sw->window == ev->subwindow)
  86             {
  87                 switch(statusbar->position)
  88                 {
  89                   case Top:
  90                   case Bottom:
  91                     for(widget = statusbar->widgets; widget; widget = widget->next)
  92                         if(ev->x >= widget->area.x && ev->x < widget->area.x + widget->area.width
  93                            && ev->y >= widget->area.y && ev->y < widget->area.y + widget->area.height)
  94                         {
  95                             widget->button_press(widget, ev);
  96                             return;
  97                         }
  98                     break;
  99                   case Right:
 100                     for(widget = statusbar->widgets; widget; widget = widget->next)
 101                         if(ev->y >= widget->area.x && ev->y < widget->area.x + widget->area.width
 102                            && statusbar->sw->geometry.width - ev->x >= widget->area.y
 103                            && statusbar->sw->geometry.width - ev->x
 104                               < widget->area.y + widget->area.height)
 105                         {
 106                             widget->button_press(widget, ev);
 107                             return;
 108                         }
 109                     break;
 110                   case Left:
 111                     for(widget = statusbar->widgets; widget; widget = widget->next)
 112                         if(statusbar->sw->geometry.height - ev->y >= widget->area.x
 113                            && statusbar->sw->geometry.height - ev->y
 114                               < widget->area.x + widget->area.width
 115                            && ev->x >= widget->area.y && ev->x < widget->area.y + widget->area.height)
 116                         {
 117                             widget->button_press(widget, ev);
 118                             return;
 119                         }
 120                     break;
 121                   default:
 122                     break;
 123                 }
 124                 /* return if no widget match */
 125                 return;
 126             }
 127
 128     if((c = client_get_bywin(globalconf.clients, ev->window)))
 129     {
 130         if(!client_focus(c, c->screen, True))
 131             client_stack(c);
 132         if(CLEANMASK(ev->state) == NoSymbol
 133            && ev->button == Button1)
 134         {
 135             XAllowEvents(globalconf.display, ReplayPointer, CurrentTime);
 136             window_grabbuttons(c->win, c->phys_screen);
 137         }
 138         else
 139             event_handle_mouse_button_press(c->screen, ev->button, ev->state, globalconf.buttons.client, NULL);
 140     }
 141     else
 142     {
 143         for(c = globalconf.clients; c; c = c->next)
 144             if(c->titlebar.sw && c->titlebar.sw->window == ev->window)
 145                 event_handle_mouse_button_press(c->screen, ev->button, ev->state, globalconf.buttons.titlebar, NULL);
 146         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 147             if(RootWindow(e->xany.display, screen) == ev->window
 148                && XQueryPointer(e->xany.display,
 149                                 ev->window, &wdummy,
 150                                 &wdummy, &x, &y, &i,
 151                                 &i, &udummy))
 152             {
 153                 screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 154                 event_handle_mouse_button_press(screen, ev->button, ev->state,
 155                                           globalconf.buttons.root, NULL);
 156                 return;
 157             }
 158     }
 159 }
 160
 161 /** Handle XConfigureRequest events
 162  * \param e XEvent
 163  */
 164 void
 165 event_handle_configurerequest(XEvent * e)
 166 {
 167     Client *c;
 168     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 169     XWindowChanges wc;
 170     area_t geometry;
 171
 172     if((c = client_get_bywin(globalconf.clients, ev->window)))
 173     {
 174         geometry = c->geometry;
 175
 176         if(ev->value_mask & CWX)
 177             geometry.x = ev->x;
 178         if(ev->value_mask & CWY)
 179             geometry.y = ev->y;
 180         if(ev->value_mask & CWWidth)
 181             geometry.width = ev->width;
 182         if(ev->value_mask & CWHeight)
 183             geometry.height = ev->height;
 184
 185         if(geometry.x != c->geometry.x || geometry.y != c->geometry.y
 186            || geometry.width != c->geometry.width || geometry.height != c->geometry.height)
 187         {
 188             if(c->isfloating || layout_get_current(c->screen)->arrange == layout_floating)
 189                 client_resize(c, geometry, False);
 190             else
 191             {
 192                 globalconf.screens[c->screen].need_arrange = True;
 193                 /* If we do not resize the client, at least tell it that it
 194                  * has its new configuration. That fixes at least
 195                  * gnome-terminal */
 196                 window_configure(c->win, c->geometry, c->border);
 197             }
 198         }
 199         else
 200         {
 201             titlebar_update_geometry_floating(c);
 202             window_configure(c->win, geometry, c->border);
 203         }
 204     }
 205     else
 206     {
 207         wc.x = ev->x;
 208         wc.y = ev->y;
 209         wc.width = ev->width;
 210         wc.height = ev->height;
 211         wc.border_width = ev->border_width;
 212         wc.sibling = ev->above;
 213         wc.stack_mode = ev->detail;
 214         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 215     }
 216 }
 217
 218 /** Handle XConfigure events
 219  * \param e XEvent
 220  */
 221 void
 222 event_handle_configurenotify(XEvent * e)
 223 {
 224     XConfigureEvent *ev = &e->xconfigure;
 225     int screen;
 226
 227     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 228         if(ev->window == RootWindow(e->xany.display, screen)
 229            && (ev->width != DisplayWidth(e->xany.display, screen)
 230                || ev->height != DisplayHeight(e->xany.display, screen)))
 231             /* it's not that we panic, but restart */
 232             uicb_restart(0, NULL);
 233 }
 234
 235 /** Handle XDestroyWindow events
 236  * \param e XEvent
 237  */
 238 void
 239 event_handle_destroynotify(XEvent *e)
 240 {
 241     Client *c;
 242     XDestroyWindowEvent *ev = &e->xdestroywindow;
 243
 244     if((c = client_get_bywin(globalconf.clients, ev->window)))
 245         client_unmanage(c);
 246 }
 247
 248 /** Handle XCrossing events on enter
 249  * \param e XEvent
 250  */
 251 void
 252 event_handle_enternotify(XEvent *e)
 253 {
 254     Client *c;
 255     XCrossingEvent *ev = &e->xcrossing;
 256     int screen;
 257
 258     if(ev->mode != NotifyNormal
 259        || (ev->x_root == globalconf.pointer_x
 260            && ev->y_root == globalconf.pointer_y))
 261         return;
 262
 263     /* the idea behind saving pointer_x and pointer_y is Bob Marley powered
 264      * this will allow us top drop some EnterNotify events and thus not giving
 265      * focus to windows appering under the cursor without a cursor move */
 266     globalconf.pointer_x = ev->x_root;
 267     globalconf.pointer_y = ev->y_root;
 268
 269     for(c = globalconf.clients; c; c = c->next)
 270         if(c->titlebar.sw && c->titlebar.sw->window == ev->window)
 271             break;
 272
 273     if(c || (c = client_get_bywin(globalconf.clients, ev->window)))
 274     {
 275         window_grabbuttons(c->win, c->phys_screen);
 276         if(globalconf.screens[c->screen].sloppy_focus)
 277             client_focus(c, c->screen,
 278                          globalconf.screens[c->screen].sloppy_focus_raise);
 279     }
 280     else
 281         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 282             if(ev->window == RootWindow(e->xany.display, screen))
 283             {
 284                 window_root_grabbuttons(screen);
 285                 return;
 286             }
 287 }
 288
 289 /** Handle XMotion events
 290  * \param e XEvent
 291  */
 292 void
 293 event_handle_motionnotify(XEvent *e)
 294 {
 295     XMotionEvent *ev = &e->xmotion;
 296
 297     globalconf.pointer_x = ev->x_root;
 298     globalconf.pointer_y = ev->y_root;
 299 }
 300
 301 /** Handle XExpose events
 302  * \param e XEvent
 303  */
 304 void
 305 event_handle_expose(XEvent *e)
 306 {
 307     XExposeEvent *ev = &e->xexpose;
 308     int screen;
 309     Statusbar *statusbar;
 310     Client *c;
 311
 312     if(!ev->count)
 313     {
 314         for(screen = 0; screen < globalconf.screens_info->nscreen; screen++)
 315             for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
 316                 if(statusbar->sw->window == ev->window)
 317                 {
 318                     statusbar_display(statusbar);
 319                     return;
 320                 }
 321
 322         for(c = globalconf.clients; c; c = c->next)
 323             if(c->titlebar.sw && c->titlebar.sw->window == ev->window)
 324             {
 325                 simplewindow_refresh_drawable(c->titlebar.sw, c->phys_screen);
 326                 return;
 327             }
 328     }
 329 }
 330
 331 /** Handle XKey events
 332  * \param e XEvent
 333  */
 334 void
 335 event_handle_keypress(XEvent *e)
 336 {
 337     int screen, x, y, d;
 338     unsigned int m;
 339     XKeyEvent *ev = &e->xkey;
 340     Window dummy;
 341     Key *k;
 342
 343     /* find the right screen for this event */
 344     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 345         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 346         {
 347             /* if screen is 0, we are on first Zaphod screen or on the
 348              * only screen in Xinerama, so we can ask for a better screen
 349              * number with screen_get_bycoord: we'll get 0 in Zaphod mode
 350              * so it's the same, or maybe the real Xinerama screen */
 351             screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 352             break;
 353         }
 354
 355     for(k = globalconf.keys; k; k = k->next)
 356         if(ev->keycode == k->keycode &&
 357           k->func && CLEANMASK(k->mod) == CLEANMASK(ev->state))
 358             k->func(screen, k->arg);
 359 }
 360
 361 /** Handle XCrossing events on leave
 362  * \param e XEvent
 363  */
 364 void
 365 event_handle_leavenotify(XEvent * e)
 366 {
 367     XCrossingEvent *ev = &e->xcrossing;
 368     int screen;
 369
 370     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 371         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 372             client_focus(NULL, screen, True);
 373 }
 374
 375 /** Handle XMapping events
 376  * \param e XEvent
 377  */
 378 void
 379 event_handle_mappingnotify(XEvent *e)
 380 {
 381     XMappingEvent *ev = &e->xmapping;
 382     int screen;
 383
 384     XRefreshKeyboardMapping(ev);
 385     if(ev->request == MappingKeyboard)
 386         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 387             window_root_grabkeys(screen);
 388 }
 389
 390 /** Handle XMapRequest events
 391  * \param e XEvent
 392  */
 393 void
 394 event_handle_maprequest(XEvent *e)
 395 {
 396     static XWindowAttributes wa;
 397     XMapRequestEvent *ev = &e->xmaprequest;
 398     int screen = 0, x, y, d;
 399     unsigned int m;
 400     Window dummy;
 401
 402     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 403         return;
 404     if(wa.override_redirect)
 405         return;
 406     if(!client_get_bywin(globalconf.clients, ev->window))
 407     {
 408         if(globalconf.screens_info->xinerama_is_active
 409            && XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 410                             &dummy, &dummy, &x, &y, &d, &d, &m))
 411             screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 412         else
 413              for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 414
 415         client_manage(ev->window, &wa, screen);
 416     }
 417 }
 418
 419 /** Handle XProperty events
 420  * \param e XEvent
 421  */
 422 void
 423 event_handle_propertynotify(XEvent * e)
 424 {
 425     Client *c;
 426     Window trans;
 427     XPropertyEvent *ev = &e->xproperty;
 428
 429     if(ev->state == PropertyDelete)
 430         return;                 /* ignore */
 431     if((c = client_get_bywin(globalconf.clients, ev->window)))
 432     {
 433         switch (ev->atom)
 434         {
 435           case XA_WM_TRANSIENT_FOR:
 436             XGetTransientForHint(e->xany.display, c->win, &trans);
 437             if(!c->isfloating
 438                && (c->isfloating = (client_get_bywin(globalconf.clients, trans) != NULL)))
 439                 globalconf.screens[c->screen].need_arrange = True;
 440             break;
 441           case XA_WM_NORMAL_HINTS:
 442             client_updatesizehints(c);
 443             break;
 444           case XA_WM_HINTS:
 445             client_updatewmhints(c);
 446             break;
 447         }
 448         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(globalconf.display, "_NET_WM_NAME", False))
 449             client_updatetitle(c);
 450     }
 451 }
 452
 453 /** Handle XUnmap events
 454  * \param e XEvent
 455  */
 456 void
 457 event_handle_unmapnotify(XEvent * e)
 458 {
 459     Client *c;
 460     XUnmapEvent *ev = &e->xunmap;
 461
 462     if((c = client_get_bywin(globalconf.clients, ev->window))
 463        && ev->event == RootWindow(e->xany.display, c->phys_screen)
 464        && ev->send_event && window_getstate(c->win) == NormalState)
 465         client_unmanage(c);
 466 }
 467
 468 /** Handle XShape events
 469  * \param e XEvent
 470  */
 471 void
 472 event_handle_shape(XEvent * e)
 473 {
 474     XShapeEvent *ev = (XShapeEvent *) e;
 475     Client *c = client_get_bywin(globalconf.clients, ev->window);
 476
 477     if(c)
 478         window_setshape(c->win, c->phys_screen);
 479 }
 480
 481 /** Handle XRandR events
 482  * \param e XEvent
 483  */
 484 void
 485 event_handle_randr_screen_change_notify(XEvent *e)
 486 {
 487     XRRUpdateConfiguration(e);
 488     uicb_restart(0, NULL);
 489 }
 490
 491 /** Handle XClientMessage events
 492  * \param e XEvent
 493  */
 494 void
 495 event_handle_clientmessage(XEvent *e)
 496 {
 497     ewmh_process_client_message(&e->xclient);
 498 }
 499
 500 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80