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