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         }
  66 }
  67
  68 /** Handle XButtonPressed events
  69  * \param e XEvent
  70  */
  71 void
  72 event_handle_buttonpress(XEvent *e)
  73 {
  74     int i, screen, x = 0, y = 0;
  75     unsigned int udummy;
  76     Client *c;
  77     Window wdummy;
  78     Widget *widget;
  79     Statusbar *statusbar;
  80     XButtonPressedEvent *ev = &e->xbutton;
  81
  82     for(screen = 0; screen < globalconf.screens_info->nscreen; screen++)
  83         for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
  84             if(statusbar->sw->window == ev->window || statusbar->sw->window == ev->subwindow)
  85             {
  86                 switch(statusbar->position)
  87                 {
  88                   case Top:
  89                   case Bottom:
  90                     for(widget = statusbar->widgets; widget; widget = widget->next)
  91                         if(ev->x >= widget->area.x && ev->x < widget->area.x + widget->area.width
  92                            && ev->y >= widget->area.y && ev->y < widget->area.y + widget->area.height)
  93                         {
  94                             widget->button_press(widget, ev);
  95                             return;
  96                         }
  97                     break;
  98                   case Right:
  99                     for(widget = statusbar->widgets; widget; widget = widget->next)
 100                         if(ev->y >= widget->area.x && ev->y < widget->area.x + widget->area.width
 101                            && statusbar->sw->geometry.width - ev->x >= widget->area.y
 102                            && statusbar->sw->geometry.width - ev->x
 103                               < widget->area.y + widget->area.height)
 104                         {
 105                             widget->button_press(widget, ev);
 106                             return;
 107                         }
 108                     break;
 109                   case Left:
 110                     for(widget = statusbar->widgets; widget; widget = widget->next)
 111                         if(statusbar->sw->geometry.height - ev->y >= widget->area.x
 112                            && statusbar->sw->geometry.height - ev->y
 113                               < widget->area.x + widget->area.width
 114                            && ev->x >= widget->area.y && ev->x < widget->area.y + widget->area.height)
 115                         {
 116                             widget->button_press(widget, ev);
 117                             return;
 118                         }
 119                     break;
 120                   default:
 121                     break;
 122                 }
 123                 /* return if no widget match */
 124                 return;
 125             }
 126
 127     for(c = globalconf.clients; c; c = c->next)
 128         if(c->titlebar.sw && c->titlebar.sw->window == 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                 window_grabbuttons(c->win, c->phys_screen);
 135             event_handle_mouse_button_press(c->screen, ev->button, ev->state,
 136                                             globalconf.buttons.titlebar, NULL);
 137             return;
 138         }
 139
 140     if((c = client_get_bywin(globalconf.clients, ev->window)))
 141     {
 142         if(!client_focus(c, c->screen, True))
 143             client_stack(c);
 144         if(CLEANMASK(ev->state) == NoSymbol
 145            && ev->button == Button1)
 146         {
 147             XAllowEvents(globalconf.display, ReplayPointer, CurrentTime);
 148             window_grabbuttons(c->win, c->phys_screen);
 149         }
 150         else
 151             event_handle_mouse_button_press(c->screen, ev->button, ev->state, globalconf.buttons.client, NULL);
 152     }
 153     else
 154     {
 155         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 156             if(RootWindow(e->xany.display, screen) == ev->window
 157                && XQueryPointer(e->xany.display,
 158                                 ev->window, &wdummy,
 159                                 &wdummy, &x, &y, &i,
 160                                 &i, &udummy))
 161             {
 162                 screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 163                 event_handle_mouse_button_press(screen, ev->button, ev->state,
 164                                           globalconf.buttons.root, NULL);
 165                 return;
 166             }
 167     }
 168 }
 169
 170 /** Handle XConfigureRequest events
 171  * \param e XEvent
 172  */
 173 void
 174 event_handle_configurerequest(XEvent * e)
 175 {
 176     Client *c;
 177     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 178     XWindowChanges wc;
 179     area_t geometry;
 180
 181     if((c = client_get_bywin(globalconf.clients, ev->window)))
 182     {
 183         geometry = c->geometry;
 184
 185         if(ev->value_mask & CWX)
 186             geometry.x = ev->x;
 187         if(ev->value_mask & CWY)
 188             geometry.y = ev->y;
 189         if(ev->value_mask & CWWidth)
 190             geometry.width = ev->width;
 191         if(ev->value_mask & CWHeight)
 192             geometry.height = ev->height;
 193
 194         if(geometry.x != c->geometry.x || geometry.y != c->geometry.y
 195            || geometry.width != c->geometry.width || geometry.height != c->geometry.height)
 196         {
 197             if(c->isfloating || layout_get_current(c->screen)->arrange == layout_floating)
 198                 client_resize(c, geometry, False);
 199             else
 200             {
 201                 globalconf.screens[c->screen].need_arrange = True;
 202                 /* If we do not resize the client, at least tell it that it
 203                  * has its new configuration. That fixes at least
 204                  * gnome-terminal */
 205                 window_configure(c->win, c->geometry, c->border);
 206             }
 207         }
 208         else
 209         {
 210             titlebar_update_geometry_floating(c);
 211             window_configure(c->win, geometry, c->border);
 212         }
 213     }
 214     else
 215     {
 216         wc.x = ev->x;
 217         wc.y = ev->y;
 218         wc.width = ev->width;
 219         wc.height = ev->height;
 220         wc.border_width = ev->border_width;
 221         wc.sibling = ev->above;
 222         wc.stack_mode = ev->detail;
 223         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 224     }
 225 }
 226
 227 /** Handle XConfigure events
 228  * \param e XEvent
 229  */
 230 void
 231 event_handle_configurenotify(XEvent * e)
 232 {
 233     XConfigureEvent *ev = &e->xconfigure;
 234     int screen;
 235
 236     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 237         if(ev->window == RootWindow(e->xany.display, screen)
 238            && (ev->width != DisplayWidth(e->xany.display, screen)
 239                || ev->height != DisplayHeight(e->xany.display, screen)))
 240             /* it's not that we panic, but restart */
 241             uicb_restart(0, NULL);
 242 }
 243
 244 /** Handle XDestroyWindow events
 245  * \param e XEvent
 246  */
 247 void
 248 event_handle_destroynotify(XEvent *e)
 249 {
 250     Client *c;
 251     XDestroyWindowEvent *ev = &e->xdestroywindow;
 252
 253     if((c = client_get_bywin(globalconf.clients, ev->window)))
 254         client_unmanage(c);
 255 }
 256
 257 /** Handle XCrossing events on enter
 258  * \param e XEvent
 259  */
 260 void
 261 event_handle_enternotify(XEvent *e)
 262 {
 263     Client *c;
 264     XCrossingEvent *ev = &e->xcrossing;
 265     int screen;
 266
 267     if(ev->mode != NotifyNormal
 268        || (ev->x_root == globalconf.pointer_x
 269            && ev->y_root == globalconf.pointer_y))
 270         return;
 271
 272     for(c = globalconf.clients; c; c = c->next)
 273         if(c->titlebar.sw && c->titlebar.sw->window == ev->window)
 274             break;
 275
 276     if(c || (c = client_get_bywin(globalconf.clients, ev->window)))
 277     {
 278         window_grabbuttons(c->win, c->phys_screen);
 279         /* the idea behind saving pointer_x and pointer_y is Bob Marley powered
 280          * this will allow us top drop some EnterNotify events and thus not giving
 281          * focus to windows appering under the cursor without a cursor move */
 282         globalconf.pointer_x = ev->x_root;
 283         globalconf.pointer_y = ev->y_root;
 284
 285         if(globalconf.screens[c->screen].sloppy_focus)
 286             client_focus(c, c->screen,
 287                          globalconf.screens[c->screen].sloppy_focus_raise);
 288     }
 289     else
 290         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 291             if(ev->window == RootWindow(e->xany.display, screen))
 292             {
 293                 window_root_grabbuttons(screen);
 294                 return;
 295             }
 296 }
 297
 298 /** Handle XExpose events
 299  * \param e XEvent
 300  */
 301 void
 302 event_handle_expose(XEvent *e)
 303 {
 304     XExposeEvent *ev = &e->xexpose;
 305     int screen;
 306     Statusbar *statusbar;
 307     Client *c;
 308
 309     if(!ev->count)
 310     {
 311         for(screen = 0; screen < globalconf.screens_info->nscreen; screen++)
 312             for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
 313                 if(statusbar->sw->window == ev->window)
 314                 {
 315                     statusbar_display(statusbar);
 316                     return;
 317                 }
 318
 319         for(c = globalconf.clients; c; c = c->next)
 320             if(c->titlebar.sw && c->titlebar.sw->window == ev->window)
 321             {
 322                 simplewindow_refresh_drawable(c->titlebar.sw, c->phys_screen);
 323                 return;
 324             }
 325     }
 326 }
 327
 328 /** Handle XKey events
 329  * \param e XEvent
 330  */
 331 void
 332 event_handle_keypress(XEvent *e)
 333 {
 334     int screen, x, y, d;
 335     unsigned int m;
 336     XKeyEvent *ev = &e->xkey;
 337     KeySym keysym;
 338     Window dummy;
 339     Key *k;
 340
 341     /* find the right screen for this event */
 342     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 343         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 344         {
 345             /* if screen is 0, we are on first Zaphod screen or on the
 346              * only screen in Xinerama, so we can ask for a better screen
 347              * number with screen_get_bycoord: we'll get 0 in Zaphod mode
 348              * so it's the same, or maybe the real Xinerama screen */
 349             screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 350             break;
 351         }
 352
 353     keysym = XKeycodeToKeysym(globalconf.display, (KeyCode) ev->keycode, 0);
 354
 355     for(k = globalconf.keys; k; k = k->next)
 356         if(keysym == k->keysym &&
 357           k->func && CLEANMASK(k->mod) == CLEANMASK(ev->state))
 358             k->func(screen, k->arg);
 359 }
 360
 361 /** Handle XMapping events
 362  * \param e XEvent
 363  */
 364 void
 365 event_handle_mappingnotify(XEvent *e)
 366 {
 367     XMappingEvent *ev = &e->xmapping;
 368     int screen;
 369
 370     XRefreshKeyboardMapping(ev);
 371     if(ev->request == MappingKeyboard)
 372         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 373             window_root_grabkeys(screen);
 374 }
 375
 376 /** Handle XMapRequest events
 377  * \param e XEvent
 378  */
 379 void
 380 event_handle_maprequest(XEvent *e)
 381 {
 382     static XWindowAttributes wa;
 383     XMapRequestEvent *ev = &e->xmaprequest;
 384     int screen = 0, x, y, d;
 385     unsigned int m;
 386     Window dummy;
 387
 388     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 389         return;
 390     if(wa.override_redirect)
 391         return;
 392     if(!client_get_bywin(globalconf.clients, ev->window))
 393     {
 394         if(globalconf.screens_info->xinerama_is_active
 395            && XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 396                             &dummy, &dummy, &x, &y, &d, &d, &m))
 397             screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 398         else
 399              for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 400
 401         client_manage(ev->window, &wa, screen);
 402     }
 403 }
 404
 405 /** Handle XProperty events
 406  * \param e XEvent
 407  */
 408 void
 409 event_handle_propertynotify(XEvent * e)
 410 {
 411     Client *c;
 412     Window trans;
 413     XPropertyEvent *ev = &e->xproperty;
 414
 415     if(ev->state == PropertyDelete)
 416         return;                 /* ignore */
 417     if((c = client_get_bywin(globalconf.clients, ev->window)))
 418     {
 419         switch (ev->atom)
 420         {
 421           case XA_WM_TRANSIENT_FOR:
 422             XGetTransientForHint(e->xany.display, c->win, &trans);
 423             if(!c->isfloating
 424                && (c->isfloating = (client_get_bywin(globalconf.clients, trans) != NULL)))
 425                 globalconf.screens[c->screen].need_arrange = True;
 426             break;
 427           case XA_WM_NORMAL_HINTS:
 428             client_updatesizehints(c);
 429             break;
 430           case XA_WM_HINTS:
 431             client_updatewmhints(c);
 432             break;
 433         }
 434         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(globalconf.display, "_NET_WM_NAME", False))
 435             client_updatetitle(c);
 436     }
 437 }
 438
 439 /** Handle XUnmap events
 440  * \param e XEvent
 441  */
 442 void
 443 event_handle_unmapnotify(XEvent * e)
 444 {
 445     Client *c;
 446     XUnmapEvent *ev = &e->xunmap;
 447
 448     if((c = client_get_bywin(globalconf.clients, ev->window))
 449        && ev->event == RootWindow(e->xany.display, c->phys_screen)
 450        && ev->send_event && window_getstate(c->win) == NormalState)
 451         client_unmanage(c);
 452 }
 453
 454 /** Handle XShape events
 455  * \param e XEvent
 456  */
 457 void
 458 event_handle_shape(XEvent * e)
 459 {
 460     XShapeEvent *ev = (XShapeEvent *) e;
 461     Client *c = client_get_bywin(globalconf.clients, ev->window);
 462
 463     if(c)
 464         window_setshape(c->win, c->phys_screen);
 465 }
 466
 467 /** Handle XRandR events
 468  * \param e XEvent
 469  */
 470 void
 471 event_handle_randr_screen_change_notify(XEvent *e)
 472 {
 473     XRRUpdateConfiguration(e);
 474     uicb_restart(0, NULL);
 475 }
 476
 477 /** Handle XClientMessage events
 478  * \param e XEvent
 479  */
 480 void
 481 event_handle_clientmessage(XEvent *e)
 482 {
 483     ewmh_process_client_message(&e->xclient);
 484 }
 485
 486 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80