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