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