event.c

   1 /*
   2  * event.c - event handlers
   3  *
   4  * Copyright © 2007 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 "layout.h"
  31 #include "tag.h"
  32 #include "draw.h"
  33 #include "statusbar.h"
  34 #include "util.h"
  35 #include "layouts/tile.h"
  36 #include "layouts/floating.h"
  37
  38 /* extern */
  39 extern DC *dc;                   /* global draw context */
  40 extern Client *clients, *sel;   /* global client list */
  41
  42 #define CLEANMASK(mask, screen)         (mask & ~(awesomeconf[screen].numlockmask | LockMask))
  43 #define MOUSEMASK                       (BUTTONMASK | PointerMotionMask)
  44
  45 static Client *
  46 getclient(Window w)
  47 {
  48     Client *c;
  49
  50     for(c = clients; c && c->win != w; c = c->next);
  51     return c;
  52 }
  53
  54 static void
  55 movemouse(Client * c, awesome_config *awesomeconf)
  56 {
  57     int x1, y1, ocx, ocy, di, nx, ny, real_screen;
  58     unsigned int dui;
  59     Window dummy;
  60     XEvent ev;
  61     ScreenInfo *si;
  62
  63     real_screen = get_real_screen(c->display, awesomeconf->screen);
  64
  65     si = get_display_info(c->display, real_screen, NULL);
  66
  67     ocx = nx = c->x;
  68     ocy = ny = c->y;
  69     if(XGrabPointer(c->display, RootWindow(c->display, real_screen), False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
  70                     None, dc[c->screen].cursor[CurMove], CurrentTime) != GrabSuccess)
  71         return;
  72     XQueryPointer(c->display, RootWindow(c->display, real_screen), &dummy, &dummy, &x1, &y1, &di, &di, &dui);
  73     for(;;)
  74     {
  75         XMaskEvent(c->display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev);
  76         switch (ev.type)
  77         {
  78         case ButtonRelease:
  79             XUngrabPointer(c->display, CurrentTime);
  80             return;
  81         case ConfigureRequest:
  82         case Expose:
  83         case MapRequest:
  84             handle_event_maprequest(&ev, awesomeconf);
  85             break;
  86         case MotionNotify:
  87             XSync(c->display, False);
  88             nx = ocx + (ev.xmotion.x - x1);
  89             ny = ocy + (ev.xmotion.y - y1);
  90             if(abs(si->x_org + nx) < awesomeconf->snap)
  91                 nx = si->x_org;
  92             else if(abs((si->x_org + si->width) - (nx + c->w + 2 * c->border)) < awesomeconf->snap)
  93                 nx = si->x_org + si->width - c->w - 2 * c->border;
  94             if(abs(si->y_org - ny) < awesomeconf->snap)
  95                 ny = si->y_org;
  96             else if(abs((si->y_org + si->height) - (ny + c->h + 2 * c->border)) < awesomeconf->snap)
  97                 ny = si->y_org + si->height - c->h - 2 * c->border;
  98             resize(c, nx, ny, c->w, c->h, awesomeconf, False);
  99             break;
 100         }
 101     }
 102     XFree(si);
 103 }
 104
 105 static void
 106 resizemouse(Client * c, awesome_config *awesomeconf)
 107 {
 108     int ocx, ocy, nw, nh;
 109     XEvent ev;
 110
 111     ocx = c->x;
 112     ocy = c->y;
 113     if(XGrabPointer(c->display, RootWindow(c->display, get_real_screen(c->display, awesomeconf->screen)),
 114                     False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
 115                     None, dc[c->screen].cursor[CurResize], CurrentTime) != GrabSuccess)
 116         return;
 117     c->ismax = False;
 118     XWarpPointer(c->display, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1);
 119     for(;;)
 120     {
 121         XMaskEvent(c->display, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev);
 122         switch (ev.type)
 123         {
 124         case ButtonRelease:
 125             XWarpPointer(c->display, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1);
 126             XUngrabPointer(c->display, CurrentTime);
 127             while(XCheckMaskEvent(c->display, EnterWindowMask, &ev));
 128             return;
 129         case ConfigureRequest:
 130         case Expose:
 131         case MapRequest:
 132             handle_event_maprequest(&ev, awesomeconf);
 133             break;
 134         case MotionNotify:
 135             XSync(c->display, False);
 136             if((nw = ev.xmotion.x - ocx - 2 * c->border + 1) <= 0)
 137                 nw = 1;
 138             if((nh = ev.xmotion.y - ocy - 2 * c->border + 1) <= 0)
 139                 nh = 1;
 140             resize(c, c->x, c->y, nw, nh, awesomeconf, True);
 141             break;
 142         }
 143     }
 144 }
 145
 146 void
 147 handle_event_buttonpress(XEvent * e, awesome_config *awesomeconf)
 148 {
 149     int i, screen;
 150     Client *c;
 151     XButtonPressedEvent *ev = &e->xbutton;
 152
 153     for(screen = 0; screen < get_screen_count(e->xany.display); screen++)
 154         if(awesomeconf[screen].statusbar.window == ev->window)
 155         {
 156             int x = 0;
 157             for(i = 0; i < awesomeconf[screen].ntags; i++)
 158             {
 159                 x += textw(dc[screen].font.set, dc[screen].font.xfont, awesomeconf[screen].tags[i].name, dc[screen].font.height);
 160                 if(ev->x < x)
 161                 {
 162                     if(ev->button == Button1)
 163                     {
 164                         if(ev->state & awesomeconf[screen].modkey)
 165                             uicb_tag(e->xany.display, &dc[screen], &awesomeconf[screen], awesomeconf[screen].tags[i].name);
 166                         else
 167                             uicb_view(e->xany.display, &dc[screen], &awesomeconf[screen], awesomeconf[screen].tags[i].name);
 168                     }
 169                     else if(ev->button == Button3)
 170                     {
 171                         if(ev->state & awesomeconf[screen].modkey)
 172                             uicb_toggletag(e->xany.display, &dc[screen], &awesomeconf[screen], awesomeconf[screen].tags[i].name);
 173                         else
 174                             uicb_toggleview(e->xany.display, &dc[screen], &awesomeconf[screen], awesomeconf[screen].tags[i].name);
 175                     }
 176                     return;
 177                 }
 178             }
 179             if((ev->x < x + awesomeconf[screen].statusbar.width) && ev->button == Button1)
 180                 uicb_setlayout(e->xany.display, &dc[screen], &awesomeconf[screen], NULL);
 181             return;
 182         }
 183
 184     if((c = getclient(ev->window)))
 185     {
 186         focus(c->display, &dc[c->screen], c, ev->same_screen, &awesomeconf[c->screen]);
 187         if(CLEANMASK(ev->state, c->screen) != awesomeconf[c->screen].modkey)
 188             return;
 189         if(ev->button == Button1)
 190         {
 191             if(!IS_ARRANGE(layout_floating) && !c->isfloating)
 192                 uicb_togglefloating(e->xany.display, &dc[c->screen], &awesomeconf[c->screen], NULL);
 193             else
 194                 restack(e->xany.display, &dc[c->screen], &awesomeconf[c->screen]);
 195             movemouse(c, &awesomeconf[c->screen]);
 196         }
 197         else if(ev->button == Button2)
 198         {
 199             if(!IS_ARRANGE(layout_floating) && !c->isfixed && c->isfloating)
 200                 uicb_togglefloating(e->xany.display, &dc[c->screen], &awesomeconf[c->screen], NULL);
 201             else
 202                 uicb_zoom(e->xany.display, &dc[c->screen], &awesomeconf[c->screen], NULL);
 203         }
 204         else if(ev->button == Button3)
 205         {
 206             if(!IS_ARRANGE(layout_floating) && !c->isfloating)
 207                 uicb_togglefloating(e->xany.display, &dc[c->screen], &awesomeconf[c->screen], NULL);
 208             else
 209                 restack(e->xany.display, &dc[c->screen], &awesomeconf[c->screen]);
 210             resizemouse(c, &awesomeconf[c->screen]);
 211         }
 212     }
 213     else if(!sel)
 214         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 215             if(RootWindow(e->xany.display, screen) == ev->window)
 216             {
 217                 if(ev->button == Button4)
 218                     uicb_tag_viewnext(e->xany.display, &dc[screen], &awesomeconf[screen], NULL);
 219                 else if(ev->button == Button5)
 220                     uicb_tag_viewprev(e->xany.display, &dc[screen], &awesomeconf[screen], NULL);
 221             }
 222 }
 223
 224 void
 225 handle_event_configurerequest(XEvent * e, awesome_config *awesomeconf)
 226 {
 227     Client *c;
 228     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 229     XWindowChanges wc;
 230     int real_screen;
 231
 232     if((c = getclient(ev->window)))
 233     {
 234         c->ismax = False;
 235         if(ev->value_mask & CWBorderWidth)
 236             c->border = ev->border_width;
 237         if(c->isfixed || c->isfloating || IS_ARRANGE(layout_floating))
 238         {
 239             real_screen = get_real_screen(c->display, c->screen);
 240             if(ev->value_mask & CWX)
 241                 c->x = ev->x;
 242             if(ev->value_mask & CWY)
 243                 c->y = ev->y;
 244             if(ev->value_mask & CWWidth)
 245                 c->w = ev->width;
 246             if(ev->value_mask & CWHeight)
 247                 c->h = ev->height;
 248             if((c->x + c->w) > DisplayWidth(c->display, real_screen) && c->isfloating)
 249                 c->x = DisplayWidth(c->display, real_screen) / 2 - c->w / 2;       /* center in x direction */
 250             if((c->y + c->h) > DisplayHeight(c->display, real_screen) && c->isfloating)
 251                 c->y = DisplayHeight(c->display, real_screen) / 2 - c->h / 2;       /* center in y direction */
 252             if((ev->value_mask & (CWX | CWY)) && !(ev->value_mask & (CWWidth | CWHeight)))
 253                 configure(c);
 254             if(isvisible(c, c->screen, awesomeconf[c->screen].tags, awesomeconf[c->screen].ntags))
 255                 XMoveResizeWindow(e->xany.display, c->win, c->x, c->y, c->w, c->h);
 256         }
 257         else
 258             configure(c);
 259     }
 260     else
 261     {
 262         wc.x = ev->x;
 263         wc.y = ev->y;
 264         wc.width = ev->width;
 265         wc.height = ev->height;
 266         wc.border_width = ev->border_width;
 267         wc.sibling = ev->above;
 268         wc.stack_mode = ev->detail;
 269         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 270     }
 271     XSync(e->xany.display, False);
 272 }
 273
 274 void
 275 handle_event_configurenotify(XEvent * e, awesome_config *awesomeconf)
 276 {
 277     XConfigureEvent *ev = &e->xconfigure;
 278     int screen, dummy;
 279     ScreenInfo *si;
 280
 281     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 282         if(ev->window == RootWindow(e->xany.display, screen)
 283            && (ev->width != DisplayWidth(e->xany.display, screen)
 284                || ev->height != DisplayHeight(e->xany.display, screen)))
 285         {
 286             DisplayWidth(e->xany.display, screen) = ev->width;
 287             DisplayHeight(e->xany.display, screen) = ev->height;
 288
 289             si = get_screen_info(e->xany.display, screen, NULL, &dummy);
 290             XFreePixmap(e->xany.display, awesomeconf[screen].statusbar.drawable);
 291             awesomeconf[screen].statusbar.drawable = XCreatePixmap(e->xany.display, RootWindow(e->xany.display, screen),
 292                                                                    si[screen].width,
 293                                                                    awesomeconf[screen].statusbar.height,
 294                                                                    DefaultDepth(e->xany.display, screen));
 295             XResizeWindow(e->xany.display, awesomeconf[screen].statusbar.window,
 296                           si[screen].width, awesomeconf[screen].statusbar.height);
 297             XFree(si);
 298             updatebarpos(e->xany.display, awesomeconf[screen].statusbar);
 299             arrange(e->xany.display, &dc[screen], &awesomeconf[screen]);
 300         }
 301 }
 302
 303 void
 304 handle_event_destroynotify(XEvent * e, awesome_config *awesomeconf)
 305 {
 306     Client *c;
 307     XDestroyWindowEvent *ev = &e->xdestroywindow;
 308
 309     if((c = getclient(ev->window)))
 310         unmanage(c, &dc[c->screen], WithdrawnState, &awesomeconf[c->screen]);
 311 }
 312
 313 void
 314 handle_event_enternotify(XEvent * e, awesome_config *awesomeconf)
 315 {
 316     Client *c;
 317     XCrossingEvent *ev = &e->xcrossing;
 318     int screen;
 319
 320     if(ev->mode != NotifyNormal || ev->detail == NotifyInferior)
 321         return;
 322     if((c = getclient(ev->window)))
 323         focus(c->display, &dc[c->screen], c, ev->same_screen, &awesomeconf[c->screen]);
 324     else
 325         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 326             if(ev->window == RootWindow(e->xany.display, screen))
 327                 focus(e->xany.display, &dc[screen], NULL, True, &awesomeconf[screen]);
 328 }
 329
 330 void
 331 handle_event_expose(XEvent * e, awesome_config *awesomeconf)
 332 {
 333     XExposeEvent *ev = &e->xexpose;
 334     int screen;
 335
 336     if(!ev->count)
 337         for(screen = 0; screen < get_screen_count(e->xany.display); screen++)
 338             if(awesomeconf[screen].statusbar.window == ev->window)
 339                 drawstatusbar(e->xany.display, &dc[screen], &awesomeconf[screen]);
 340 }
 341
 342 void
 343 handle_event_keypress(XEvent * e, awesome_config *awesomeconf)
 344 {
 345     int i, screen, x, y, d;
 346     unsigned int m;
 347     KeySym keysym;
 348     XKeyEvent *ev = &e->xkey;
 349     Window dummy;
 350
 351     keysym = XKeycodeToKeysym(e->xany.display, (KeyCode) ev->keycode, 0);
 352
 353     /* find the right screen for this event */
 354     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 355         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 356         {
 357             /* if screen is 0, we are on first Zaphod screen or on the
 358              * only screen in Xinerama, so we can ask for a better screen
 359              * number with get_screen_bycoord: we'll get 0 in Zaphod mode
 360              * so it's the same, or maybe the real Xinerama screen */
 361            if(screen == 0)
 362                screen = get_screen_bycoord(e->xany.display, x, y);
 363            break;
 364         }
 365
 366     for(i = 0; i < awesomeconf[screen].nkeys; i++)
 367         if(keysym == awesomeconf[screen].keys[i].keysym
 368            && CLEANMASK(awesomeconf[screen].keys[i].mod, screen) == CLEANMASK(ev->state, screen) && awesomeconf[screen].keys[i].func)
 369             awesomeconf[screen].keys[i].func(e->xany.display, &dc[screen], &awesomeconf[screen], awesomeconf[screen].keys[i].arg);
 370 }
 371
 372 void
 373 handle_event_leavenotify(XEvent * e, awesome_config *awesomeconf)
 374 {
 375     XCrossingEvent *ev = &e->xcrossing;
 376     int screen;
 377
 378     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 379         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 380             focus(e->xany.display, &dc[screen], NULL, ev->same_screen, &awesomeconf[screen]);
 381 }
 382
 383 void
 384 handle_event_mappingnotify(XEvent * e, awesome_config *awesomeconf)
 385 {
 386     XMappingEvent *ev = &e->xmapping;
 387     int screen;
 388
 389     XRefreshKeyboardMapping(ev);
 390     if(ev->request == MappingKeyboard)
 391         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 392             grabkeys(e->xany.display, screen, &awesomeconf[screen]);
 393 }
 394
 395 void
 396 handle_event_maprequest(XEvent * e, awesome_config *awesomeconf)
 397 {
 398     static XWindowAttributes wa;
 399     XMapRequestEvent *ev = &e->xmaprequest;
 400     int screen;
 401
 402     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 403         return;
 404     if(wa.override_redirect)
 405         return;
 406     if(!getclient(ev->window))
 407     {
 408         for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 409         if(screen == 0)
 410             screen = get_screen_bycoord(e->xany.display, wa.x, wa.y);
 411         manage(e->xany.display, &dc[screen], ev->window, &wa, &awesomeconf[screen]);
 412     }
 413 }
 414
 415 void
 416 handle_event_propertynotify(XEvent * e, awesome_config *awesomeconf)
 417 {
 418     Client *c;
 419     Window trans;
 420     XPropertyEvent *ev = &e->xproperty;
 421
 422     if(ev->state == PropertyDelete)
 423         return;                 /* ignore */
 424     if((c = getclient(ev->window)))
 425     {
 426         switch (ev->atom)
 427         {
 428         case XA_WM_TRANSIENT_FOR:
 429             XGetTransientForHint(e->xany.display, c->win, &trans);
 430             if(!c->isfloating && (c->isfloating = (getclient(trans) != NULL)))
 431                 arrange(e->xany.display, &dc[c->screen], &awesomeconf[c->screen]);
 432             break;
 433         case XA_WM_NORMAL_HINTS:
 434             updatesizehints(c);
 435             break;
 436         }
 437         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(c->display, "_NET_WM_NAME", False))
 438         {
 439             updatetitle(c);
 440             if(c == sel)
 441                 drawstatusbar(e->xany.display, &dc[c->screen], &awesomeconf[c->screen]);
 442         }
 443     }
 444 }
 445
 446 void
 447 handle_event_unmapnotify(XEvent * e, awesome_config *awesomeconf)
 448 {
 449     Client *c;
 450     XUnmapEvent *ev = &e->xunmap;
 451
 452     if((c = getclient(ev->window))
 453        && ev->event == RootWindow(e->xany.display, c->screen) && (ev->send_event || !c->unmapped))
 454         unmanage(c, &dc[c->screen], WithdrawnState, &awesomeconf[c->screen]);
 455 }
 456
 457 void
 458 handle_event_shape(XEvent * e,
 459                    awesome_config *awesomeconf __attribute__ ((unused)))
 460 {
 461     XShapeEvent *ev = (XShapeEvent *) e;
 462     Client *c = getclient(ev->window);
 463
 464     if(c)
 465         set_shape(c);
 466 }
 467
 468 void
 469 handle_event_randr_screen_change_notify(XEvent *e,
 470                                         awesome_config *awesomeconf __attribute__ ((unused)))
 471 {
 472     XRRUpdateConfiguration(e);
 473 }
 474
 475 void
 476 grabkeys(Display *disp, int screen, awesome_config *awesomeconf)
 477 {
 478     int i;
 479     KeyCode code;
 480
 481     XUngrabKey(disp, AnyKey, AnyModifier, RootWindow(disp, screen));
 482     for(i = 0; i < awesomeconf->nkeys; i++)
 483     {
 484         if((code = XKeysymToKeycode(disp, awesomeconf->keys[i].keysym)) == NoSymbol)
 485             continue;
 486         XGrabKey(disp, code, awesomeconf->keys[i].mod, RootWindow(disp, screen), True, GrabModeAsync, GrabModeAsync);
 487         XGrabKey(disp, code, awesomeconf->keys[i].mod | LockMask, RootWindow(disp, screen), True, GrabModeAsync, GrabModeAsync);
 488         XGrabKey(disp, code, awesomeconf->keys[i].mod | awesomeconf->numlockmask, RootWindow(disp, screen), True, GrabModeAsync, GrabModeAsync);
 489         XGrabKey(disp, code, awesomeconf->keys[i].mod | awesomeconf->numlockmask | LockMask, RootWindow(disp, screen), True,
 490                  GrabModeAsync, GrabModeAsync);
 491     }
 492 }