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 #include <X11/extensions/Xinerama.h>
  28
  29 #include "screen.h"
  30 #include "event.h"
  31 #include "tag.h"
  32 #include "statusbar.h"
  33 #include "window.h"
  34 #include "mouse.h"
  35 #include "ewmh.h"
  36 #include "client.h"
  37 #include "widget.h"
  38 #include "xutil.h"
  39 #include "rules.h"
  40 #include "layouts/tile.h"
  41 #include "layouts/floating.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.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                   case Off:
 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         client_focus(c, c->screen, True);
 131         if(CLEANMASK(ev->state) == NoSymbol
 132            && ev->button == Button1)
 133         {
 134             XAllowEvents(globalconf.display, ReplayPointer, CurrentTime);
 135             window_grabbuttons(get_phys_screen(c->screen), c->win);
 136         }
 137         else
 138             event_handle_mouse_button_press(c->screen, ev->button, ev->state, globalconf.buttons.client, NULL);
 139     }
 140     else
 141         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 142             if(RootWindow(e->xany.display, screen) == ev->window
 143                && XQueryPointer(e->xany.display,
 144                                 ev->window, &wdummy,
 145                                 &wdummy, &x, &y, &i,
 146                                 &i, &udummy))
 147             {
 148                 screen = screen_get_bycoord(screen, x, y);
 149                 event_handle_mouse_button_press(screen, ev->button, ev->state,
 150                                           globalconf.buttons.root, NULL);
 151                 return;
 152             }
 153 }
 154
 155 /** Handle XConfigureRequest events
 156  * \param e XEvent
 157  */
 158 void
 159 event_handle_configurerequest(XEvent * e)
 160 {
 161     Client *c;
 162     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 163     XWindowChanges wc;
 164     int old_screen;
 165     Area geometry;
 166
 167     if((c = client_get_bywin(globalconf.clients, ev->window)))
 168     {
 169         geometry = c->geometry;
 170
 171         if(ev->value_mask & CWX)
 172             geometry.x = ev->x;
 173         if(ev->value_mask & CWY)
 174             geometry.y = ev->y;
 175         if(ev->value_mask & CWWidth)
 176             geometry.width = ev->width;
 177         if(ev->value_mask & CWHeight)
 178             geometry.height = ev->height;
 179
 180         if(geometry.x != c->geometry.x || geometry.y != c->geometry.y
 181            || geometry.width != c->geometry.width || geometry.height != c->geometry.height)
 182         {
 183             old_screen = c->screen;
 184
 185             client_resize(c, geometry, False);
 186
 187             tag_client_with_rule(c, rule_matching_client(c));
 188
 189             if(!c->isfloating)
 190                 globalconf.screens[c->screen].need_arrange = True;
 191         }
 192         else
 193             window_configure(c->win, geometry, c->border);
 194     }
 195     else
 196     {
 197         wc.x = ev->x;
 198         wc.y = ev->y;
 199         wc.width = ev->width;
 200         wc.height = ev->height;
 201         wc.border_width = ev->border_width;
 202         wc.sibling = ev->above;
 203         wc.stack_mode = ev->detail;
 204         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 205     }
 206 }
 207
 208 /** Handle XConfigure events
 209  * \param e XEvent
 210  */
 211 void
 212 event_handle_configurenotify(XEvent * e)
 213 {
 214     XConfigureEvent *ev = &e->xconfigure;
 215     int screen;
 216
 217     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 218         if(ev->window == RootWindow(e->xany.display, screen)
 219            && (ev->width != DisplayWidth(e->xany.display, screen)
 220                || ev->height != DisplayHeight(e->xany.display, screen)))
 221             /* it's not that we panic, but restart */
 222             uicb_exec(0, globalconf.argv);
 223 }
 224
 225 /** Handle XDestroyWindow events
 226  * \param e XEvent
 227  */
 228 void
 229 event_handle_destroynotify(XEvent *e)
 230 {
 231     Client *c;
 232     XDestroyWindowEvent *ev = &e->xdestroywindow;
 233
 234     if((c = client_get_bywin(globalconf.clients, ev->window)))
 235         client_unmanage(c);
 236 }
 237
 238 /** Handle XCrossing events on enter
 239  * \param e XEvent
 240  */
 241 void
 242 event_handle_enternotify(XEvent *e)
 243 {
 244     Client *c;
 245     XCrossingEvent *ev = &e->xcrossing;
 246     int screen;
 247
 248     if(ev->mode != NotifyNormal
 249        || (ev->x_root == globalconf.pointer_x
 250            && ev->y_root == globalconf.pointer_y))
 251         return;
 252
 253     /* the idea behing saving pointer_x and pointer_y is Bob Marley powered */
 254     globalconf.pointer_x = ev->x_root;
 255     globalconf.pointer_y = ev->y_root;
 256
 257     if((c = client_get_bywin(globalconf.clients, ev->window)))
 258     {
 259         window_grabbuttons(get_phys_screen(c->screen), c->win);
 260         if(globalconf.screens[c->screen].sloppy_focus)
 261             client_focus(c, c->screen,
 262                          (globalconf.screens[c->screen].sloppy_focus
 263                           && globalconf.screens[c->screen].sloppy_focus_raise));
 264     }
 265     else
 266         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 267             if(ev->window == RootWindow(e->xany.display, screen))
 268                 window_root_grabbuttons(screen);
 269
 270 }
 271
 272 /** Handle XMotion events
 273  * \param e XEvent
 274  */
 275 void
 276 event_handle_motionnotify(XEvent *e)
 277 {
 278     XMotionEvent *ev = &e->xmotion;
 279
 280     globalconf.pointer_x = ev->x_root;
 281     globalconf.pointer_y = ev->y_root;
 282 }
 283
 284 /** Handle XExpose events
 285  * \param e XEvent
 286  */
 287 void
 288 event_handle_expose(XEvent *e)
 289 {
 290     XExposeEvent *ev = &e->xexpose;
 291     int screen;
 292     Statusbar *statusbar;
 293
 294     if(!ev->count)
 295         for(screen = 0; screen < globalconf.nscreen; screen++)
 296             for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
 297                 if(statusbar->sw->window == ev->window)
 298                 {
 299                     statusbar_display(statusbar);
 300                     return;
 301                 }
 302 }
 303
 304 /** Handle XKey events
 305  * \param e XEvent
 306  */
 307 void
 308 event_handle_keypress(XEvent *e)
 309 {
 310     int screen, x, y, d;
 311     unsigned int m;
 312     XKeyEvent *ev = &e->xkey;
 313     Window dummy;
 314     Key *k;
 315
 316     /* find the right screen for this event */
 317     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 318         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 319         {
 320             /* if screen is 0, we are on first Zaphod screen or on the
 321              * only screen in Xinerama, so we can ask for a better screen
 322              * number with screen_get_bycoord: we'll get 0 in Zaphod mode
 323              * so it's the same, or maybe the real Xinerama screen */
 324             screen = screen_get_bycoord(screen, x, y);
 325             break;
 326         }
 327
 328     for(k = globalconf.keys; k; k = k->next)
 329         if(ev->keycode == k->keycode &&
 330           k->func && CLEANMASK(k->mod) == CLEANMASK(ev->state))
 331         {
 332             k->func(screen, k->arg);
 333             break;
 334         }
 335 }
 336
 337 /** Handle XCrossing events on leave
 338  * \param e XEvent
 339  */
 340 void
 341 event_handle_leavenotify(XEvent * e)
 342 {
 343     XCrossingEvent *ev = &e->xcrossing;
 344     int screen;
 345
 346     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 347         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 348             client_focus(NULL, screen, True);
 349 }
 350
 351 /** Handle XMapping events
 352  * \param e XEvent
 353  */
 354 void
 355 event_handle_mappingnotify(XEvent *e)
 356 {
 357     XMappingEvent *ev = &e->xmapping;
 358     int screen;
 359
 360     XRefreshKeyboardMapping(ev);
 361     if(ev->request == MappingKeyboard)
 362         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 363             window_root_grabkeys(screen);
 364 }
 365
 366 /** Handle XMapRequest events
 367  * \param e XEvent
 368  */
 369 void
 370 event_handle_maprequest(XEvent *e)
 371 {
 372     static XWindowAttributes wa;
 373     XMapRequestEvent *ev = &e->xmaprequest;
 374     int screen = 0, x, y, d;
 375     unsigned int m;
 376     Window dummy;
 377
 378     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 379         return;
 380     if(wa.override_redirect)
 381         return;
 382     if(!client_get_bywin(globalconf.clients, ev->window))
 383     {
 384         if(XineramaIsActive(globalconf.display)
 385            && XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 386                             &dummy, &dummy, &x, &y, &d, &d, &m))
 387             screen = screen_get_bycoord(screen, x, y);
 388         else
 389              for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 390
 391         client_manage(ev->window, &wa, screen);
 392     }
 393 }
 394
 395 /** Handle XProperty events
 396  * \param e XEvent
 397  */
 398 void
 399 event_handle_propertynotify(XEvent * e)
 400 {
 401     Client *c;
 402     Window trans;
 403     XPropertyEvent *ev = &e->xproperty;
 404
 405     if(ev->state == PropertyDelete)
 406         return;                 /* ignore */
 407     if((c = client_get_bywin(globalconf.clients, ev->window)))
 408     {
 409         switch (ev->atom)
 410         {
 411           case XA_WM_TRANSIENT_FOR:
 412             XGetTransientForHint(e->xany.display, c->win, &trans);
 413             if(!c->isfloating
 414                && (c->isfloating = (client_get_bywin(globalconf.clients, trans) != NULL)))
 415                 globalconf.screens[c->screen].need_arrange = True;
 416             break;
 417           case XA_WM_NORMAL_HINTS:
 418             client_updatesizehints(c);
 419             break;
 420           case XA_WM_HINTS:
 421             client_updatewmhints(c);
 422             break;
 423         }
 424         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(globalconf.display, "_NET_WM_NAME", False))
 425             client_updatetitle(c);
 426     }
 427 }
 428
 429 /** Handle XUnmap events
 430  * \param e XEvent
 431  */
 432 void
 433 event_handle_unmapnotify(XEvent * e)
 434 {
 435     Client *c;
 436     XUnmapEvent *ev = &e->xunmap;
 437
 438     if((c = client_get_bywin(globalconf.clients, ev->window))
 439        && ev->event == RootWindow(e->xany.display, get_phys_screen(c->screen))
 440        && ev->send_event && window_getstate(c->win) == NormalState)
 441         client_unmanage(c);
 442 }
 443
 444 /** Handle XShape events
 445  * \param e XEvent
 446  */
 447 void
 448 event_handle_shape(XEvent * e)
 449 {
 450     XShapeEvent *ev = (XShapeEvent *) e;
 451     Client *c = client_get_bywin(globalconf.clients, ev->window);
 452
 453     if(c)
 454         window_setshape(get_phys_screen(c->screen), c->win);
 455 }
 456
 457 /** Handle XRandR events
 458  * \param e XEvent
 459  */
 460 void
 461 event_handle_randr_screen_change_notify(XEvent *e)
 462 {
 463     XRRUpdateConfiguration(e);
 464     uicb_exec(0, globalconf.argv);
 465 }
 466
 467 /** Handle XClientMessage events
 468  * \param e XEvent
 469  */
 470 void
 471 event_handle_clientmessage(XEvent *e)
 472 {
 473     ewmh_process_client_message(&e->xclient);
 474 }
 475
 476 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80