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 static void
  46 handle_mouse_button_press(int screen, unsigned int button, unsigned int state,
  47                           Button *buttons, char *arg)
  48 {
  49     Button *b;
  50
  51     for(b = buttons; b; b = b->next)
  52         if(button == b->button && CLEANMASK(state) == b->mod && b->func)
  53         {
  54             if(arg)
  55                 b->func(screen, arg);
  56             else
  57                 b->func(screen, b->arg);
  58             return;
  59         }
  60 }
  61
  62 void
  63 handle_event_buttonpress(XEvent *e)
  64 {
  65     int i, screen, x = 0, y = 0;
  66     unsigned int udummy;
  67     Client *c;
  68     Window wdummy;
  69     Widget *widget;
  70     Statusbar *statusbar;
  71     XButtonPressedEvent *ev = &e->xbutton;
  72
  73     for(screen = 0; screen < globalconf.nscreen; screen++)
  74         for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
  75             if(statusbar->sw->window == ev->window || statusbar->sw->window == ev->subwindow)
  76             {
  77                 switch(statusbar->position)
  78                 {
  79                   case Top:
  80                   case Bottom:
  81                     for(widget = statusbar->widgets; widget; widget = widget->next)
  82                         if(ev->x >= widget->area.x && ev->x < widget->area.x + widget->area.width
  83                            && ev->y >= widget->area.y && ev->y < widget->area.y + widget->area.height)
  84                         {
  85                             widget->button_press(widget, ev);
  86                             return;
  87                         }
  88                     break;
  89                   case Right:
  90                     for(widget = statusbar->widgets; widget; widget = widget->next)
  91                         if(ev->y >= widget->area.x && ev->y < widget->area.x + widget->area.width
  92                            && statusbar->sw->geometry.width - ev->x >= widget->area.y
  93                            && statusbar->sw->geometry.width - ev->x
  94                               < widget->area.y + widget->area.height)
  95                         {
  96                             widget->button_press(widget, ev);
  97                             return;
  98                         }
  99                     break;
 100                   case Left:
 101                     for(widget = statusbar->widgets; widget; widget = widget->next)
 102                         if(statusbar->sw->geometry.height - ev->y >= widget->area.x
 103                            && statusbar->sw->geometry.height - ev->y
 104                               < widget->area.x + widget->area.width
 105                            && ev->x >= widget->area.y && ev->x < widget->area.y + widget->area.height)
 106                         {
 107                             widget->button_press(widget, ev);
 108                             return;
 109                         }
 110                     break;
 111                   case Off:
 112                     break;
 113                 }
 114                 /* return if no widget match */
 115                 return;
 116             }
 117
 118     if((c = client_get_bywin(globalconf.clients, ev->window)))
 119     {
 120         client_focus(c, c->screen, True);
 121         if(CLEANMASK(ev->state) == NoSymbol
 122            && ev->button == Button1)
 123         {
 124             XAllowEvents(globalconf.display, ReplayPointer, CurrentTime);
 125             window_grabbuttons(get_phys_screen(c->screen), c->win);
 126         }
 127         else
 128             handle_mouse_button_press(c->screen, ev->button, ev->state, globalconf.buttons.client, NULL);
 129     }
 130     else
 131         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 132             if(RootWindow(e->xany.display, screen) == ev->window
 133                && XQueryPointer(e->xany.display,
 134                                 ev->window, &wdummy,
 135                                 &wdummy, &x, &y, &i,
 136                                 &i, &udummy))
 137             {
 138                 screen = screen_get_bycoord(screen, x, y);
 139                 handle_mouse_button_press(screen, ev->button, ev->state,
 140                                           globalconf.buttons.root, NULL);
 141                 return;
 142             }
 143 }
 144
 145 void
 146 handle_event_configurerequest(XEvent * e)
 147 {
 148     Client *c;
 149     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 150     XWindowChanges wc;
 151     int old_screen;
 152     Area geometry;
 153
 154     if((c = client_get_bywin(globalconf.clients, ev->window)))
 155     {
 156         geometry = c->geometry;
 157
 158         if(ev->value_mask & CWX)
 159             geometry.x = ev->x;
 160         if(ev->value_mask & CWY)
 161             geometry.y = ev->y;
 162         if(ev->value_mask & CWWidth)
 163             geometry.width = ev->width;
 164         if(ev->value_mask & CWHeight)
 165             geometry.height = ev->height;
 166
 167         if(geometry.x != c->geometry.x || geometry.y != c->geometry.y
 168            || geometry.width != c->geometry.width || geometry.height != c->geometry.height)
 169         {
 170             old_screen = c->screen;
 171
 172             client_resize(c, geometry, False);
 173
 174             tag_client_with_rule(c, rule_matching_client(c));
 175
 176             if(!c->isfloating)
 177                 globalconf.screens[c->screen].need_arrange = True;
 178         }
 179         else
 180             window_configure(c->win, geometry, c->border);
 181     }
 182     else
 183     {
 184         wc.x = ev->x;
 185         wc.y = ev->y;
 186         wc.width = ev->width;
 187         wc.height = ev->height;
 188         wc.border_width = ev->border_width;
 189         wc.sibling = ev->above;
 190         wc.stack_mode = ev->detail;
 191         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 192     }
 193 }
 194
 195 void
 196 handle_event_configurenotify(XEvent * e)
 197 {
 198     XConfigureEvent *ev = &e->xconfigure;
 199     int screen;
 200
 201     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 202         if(ev->window == RootWindow(e->xany.display, screen)
 203            && (ev->width != DisplayWidth(e->xany.display, screen)
 204                || ev->height != DisplayHeight(e->xany.display, screen)))
 205             /* it's not that we panic, but restart */
 206             uicb_exec(0, globalconf.argv);
 207 }
 208
 209 void
 210 handle_event_destroynotify(XEvent *e)
 211 {
 212     Client *c;
 213     XDestroyWindowEvent *ev = &e->xdestroywindow;
 214
 215     if((c = client_get_bywin(globalconf.clients, ev->window)))
 216         client_unmanage(c);
 217 }
 218
 219 /** Handle event enternotify
 220  * \param e XEvent
 221  */
 222 void
 223 handle_event_enternotify(XEvent *e)
 224 {
 225     Client *c;
 226     XCrossingEvent *ev = &e->xcrossing;
 227     int screen;
 228
 229     if(ev->mode != NotifyNormal
 230        || (ev->x_root == globalconf.pointer_x
 231            && ev->y_root == globalconf.pointer_y))
 232         return;
 233
 234     /* the idea behing saving pointer_x and pointer_y is Bob Marley powered */
 235     globalconf.pointer_x = ev->x_root;
 236     globalconf.pointer_y = ev->y_root;
 237
 238     if((c = client_get_bywin(globalconf.clients, ev->window)))
 239     {
 240         window_grabbuttons(get_phys_screen(c->screen), c->win);
 241         if(globalconf.screens[c->screen].sloppy_focus)
 242             client_focus(c, c->screen,
 243                          (globalconf.screens[c->screen].sloppy_focus
 244                           && globalconf.screens[c->screen].sloppy_focus_raise));
 245     }
 246     else
 247         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 248             if(ev->window == RootWindow(e->xany.display, screen))
 249                 window_root_grabbuttons(screen);
 250
 251 }
 252
 253 void
 254 handle_event_motionnotify(XEvent *e)
 255 {
 256     XMotionEvent *ev = &e->xmotion;
 257
 258     globalconf.pointer_x = ev->x_root;
 259     globalconf.pointer_y = ev->y_root;
 260 }
 261
 262 void
 263 handle_event_expose(XEvent *e)
 264 {
 265     XExposeEvent *ev = &e->xexpose;
 266     int screen;
 267     Statusbar *statusbar;
 268
 269     if(!ev->count)
 270         for(screen = 0; screen < globalconf.nscreen; screen++)
 271             for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
 272                 if(statusbar->sw->window == ev->window)
 273                 {
 274                     statusbar_display(statusbar);
 275                     return;
 276                 }
 277 }
 278
 279 void
 280 handle_event_keypress(XEvent *e)
 281 {
 282     int screen, x, y, d;
 283     unsigned int m;
 284     XKeyEvent *ev = &e->xkey;
 285     Window dummy;
 286     Key *k;
 287
 288     /* find the right screen for this event */
 289     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 290         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 291         {
 292             /* if screen is 0, we are on first Zaphod screen or on the
 293              * only screen in Xinerama, so we can ask for a better screen
 294              * number with screen_get_bycoord: we'll get 0 in Zaphod mode
 295              * so it's the same, or maybe the real Xinerama screen */
 296             screen = screen_get_bycoord(screen, x, y);
 297             break;
 298         }
 299
 300     for(k = globalconf.keys; k; k = k->next)
 301         if(ev->keycode == k->keycode &&
 302           k->func && CLEANMASK(k->mod) == CLEANMASK(ev->state))
 303         {
 304             k->func(screen, k->arg);
 305             break;
 306         }
 307 }
 308
 309 void
 310 handle_event_leavenotify(XEvent * e)
 311 {
 312     XCrossingEvent *ev = &e->xcrossing;
 313     int screen;
 314
 315     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 316         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 317             client_focus(NULL, screen, True);
 318 }
 319
 320 void
 321 handle_event_mappingnotify(XEvent *e)
 322 {
 323     XMappingEvent *ev = &e->xmapping;
 324     int screen;
 325
 326     XRefreshKeyboardMapping(ev);
 327     if(ev->request == MappingKeyboard)
 328         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 329             grabkeys(get_phys_screen(screen));
 330 }
 331
 332 void
 333 handle_event_maprequest(XEvent *e)
 334 {
 335     static XWindowAttributes wa;
 336     XMapRequestEvent *ev = &e->xmaprequest;
 337     int screen = 0, x, y, d;
 338     unsigned int m;
 339     Window dummy;
 340
 341     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 342         return;
 343     if(wa.override_redirect)
 344         return;
 345     if(!client_get_bywin(globalconf.clients, ev->window))
 346     {
 347         if(XineramaIsActive(globalconf.display)
 348            && XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 349                             &dummy, &dummy, &x, &y, &d, &d, &m))
 350             screen = screen_get_bycoord(screen, x, y);
 351         else
 352              for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 353
 354         client_manage(ev->window, &wa, screen);
 355     }
 356 }
 357
 358 void
 359 handle_event_propertynotify(XEvent * e)
 360 {
 361     Client *c;
 362     Window trans;
 363     XPropertyEvent *ev = &e->xproperty;
 364
 365     if(ev->state == PropertyDelete)
 366         return;                 /* ignore */
 367     if((c = client_get_bywin(globalconf.clients, ev->window)))
 368     {
 369         switch (ev->atom)
 370         {
 371           case XA_WM_TRANSIENT_FOR:
 372             XGetTransientForHint(e->xany.display, c->win, &trans);
 373             if(!c->isfloating
 374                && (c->isfloating = (client_get_bywin(globalconf.clients, trans) != NULL)))
 375                 globalconf.screens[c->screen].need_arrange = True;
 376             break;
 377           case XA_WM_NORMAL_HINTS:
 378             client_updatesizehints(c);
 379             break;
 380           case XA_WM_HINTS:
 381             client_updatewmhints(c);
 382             break;
 383         }
 384         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(globalconf.display, "_NET_WM_NAME", False))
 385             client_updatetitle(c);
 386     }
 387 }
 388
 389 void
 390 handle_event_unmapnotify(XEvent * e)
 391 {
 392     Client *c;
 393     XUnmapEvent *ev = &e->xunmap;
 394
 395     if((c = client_get_bywin(globalconf.clients, ev->window))
 396        && ev->event == RootWindow(e->xany.display, get_phys_screen(c->screen))
 397        && ev->send_event && window_getstate(c->win) == NormalState)
 398         client_unmanage(c);
 399 }
 400
 401 void
 402 handle_event_shape(XEvent * e)
 403 {
 404     XShapeEvent *ev = (XShapeEvent *) e;
 405     Client *c = client_get_bywin(globalconf.clients, ev->window);
 406
 407     if(c)
 408         window_setshape(get_phys_screen(c->screen), c->win);
 409 }
 410
 411 void
 412 handle_event_randr_screen_change_notify(XEvent *e)
 413 {
 414     XRRUpdateConfiguration(e);
 415     uicb_exec(0, globalconf.argv);
 416 }
 417
 418 void
 419 handle_event_clientmessage(XEvent *e)
 420 {
 421     ewmh_process_client_message(&e->xclient);
 422 }
 423
 424 void
 425 grabkeys(int phys_screen)
 426 {
 427     Key *k;
 428     KeyCode code;
 429
 430     XUngrabKey(globalconf.display, AnyKey, AnyModifier, RootWindow(globalconf.display, phys_screen));
 431     for(k = globalconf.keys; k; k = k->next)
 432     {
 433         if((code = k->keycode) == 0)
 434             continue;
 435         XGrabKey(globalconf.display, code, k->mod, RootWindow(globalconf.display, phys_screen), True, GrabModeAsync, GrabModeAsync);
 436         XGrabKey(globalconf.display, code, k->mod | LockMask, RootWindow(globalconf.display, phys_screen), True, GrabModeAsync, GrabModeAsync);
 437         XGrabKey(globalconf.display, code, k->mod | globalconf.numlockmask, RootWindow(globalconf.display, phys_screen), True, GrabModeAsync, GrabModeAsync);
 438         XGrabKey(globalconf.display, code, k->mod | globalconf.numlockmask | LockMask, RootWindow(globalconf.display, phys_screen), True, GrabModeAsync, GrabModeAsync);
 439     }
 440 }
 441 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80