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