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