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 "window.h"
  33 #include "mouse.h"
  34 #include "ewmh.h"
  35 #include "client.h"
  36 #include "widget.h"
  37 #include "rules.h"
  38 #include "layouts/tile.h"
  39 #include "layouts/floating.h"
  40 #include "common/xscreen.h"
  41
  42 extern AwesomeConf globalconf;
  43
  44 /** Handle mouse button click
  45  * \param screen screen number
  46  * \param button button number
  47  * \param state modkeys state
  48  * \param buttons buttons list to check for
  49  * \param arg optional arg passed to uicb, otherwise buttons' arg are used
  50  */
  51 static void
  52 event_handle_mouse_button_press(int screen, unsigned int button, unsigned int state,
  53                           Button *buttons, char *arg)
  54 {
  55     Button *b;
  56
  57     for(b = buttons; b; b = b->next)
  58         if(button == b->button && CLEANMASK(state) == b->mod && b->func)
  59         {
  60             if(arg)
  61                 b->func(screen, arg);
  62             else
  63                 b->func(screen, b->arg);
  64             return;
  65         }
  66 }
  67
  68 /** Handle XButtonPressed events
  69  * \param e XEvent
  70  */
  71 void
  72 event_handle_buttonpress(XEvent *e)
  73 {
  74     int i, screen, x = 0, y = 0;
  75     unsigned int udummy;
  76     Client *c;
  77     Window wdummy;
  78     Widget *widget;
  79     Statusbar *statusbar;
  80     XButtonPressedEvent *ev = &e->xbutton;
  81
  82     for(screen = 0; screen < globalconf.screens_info->nscreen; screen++)
  83         for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
  84             if(statusbar->sw->window == ev->window || statusbar->sw->window == ev->subwindow)
  85             {
  86                 switch(statusbar->position)
  87                 {
  88                   case Top:
  89                   case Bottom:
  90                     for(widget = statusbar->widgets; widget; widget = widget->next)
  91                         if(ev->x >= widget->area.x && ev->x < widget->area.x + widget->area.width
  92                            && ev->y >= widget->area.y && ev->y < widget->area.y + widget->area.height)
  93                         {
  94                             widget->button_press(widget, ev);
  95                             return;
  96                         }
  97                     break;
  98                   case Right:
  99                     for(widget = statusbar->widgets; widget; widget = widget->next)
 100                         if(ev->y >= widget->area.x && ev->y < widget->area.x + widget->area.width
 101                            && statusbar->sw->geometry.width - ev->x >= widget->area.y
 102                            && statusbar->sw->geometry.width - ev->x
 103                               < widget->area.y + widget->area.height)
 104                         {
 105                             widget->button_press(widget, ev);
 106                             return;
 107                         }
 108                     break;
 109                   case Left:
 110                     for(widget = statusbar->widgets; widget; widget = widget->next)
 111                         if(statusbar->sw->geometry.height - ev->y >= widget->area.x
 112                            && statusbar->sw->geometry.height - ev->y
 113                               < widget->area.x + widget->area.width
 114                            && ev->x >= widget->area.y && ev->x < widget->area.y + widget->area.height)
 115                         {
 116                             widget->button_press(widget, ev);
 117                             return;
 118                         }
 119                     break;
 120                   default:
 121                     break;
 122                 }
 123                 /* return if no widget match */
 124                 return;
 125             }
 126
 127     if((c = client_get_bywin(globalconf.clients, ev->window)))
 128     {
 129         client_focus(c, c->screen, True);
 130         if(CLEANMASK(ev->state) == NoSymbol
 131            && ev->button == Button1)
 132         {
 133             XAllowEvents(globalconf.display, ReplayPointer, CurrentTime);
 134             window_grabbuttons(get_phys_screen(c->screen), c->win);
 135         }
 136         else
 137             event_handle_mouse_button_press(c->screen, ev->button, ev->state, globalconf.buttons.client, NULL);
 138     }
 139     else
 140         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 141             if(RootWindow(e->xany.display, screen) == ev->window
 142                && XQueryPointer(e->xany.display,
 143                                 ev->window, &wdummy,
 144                                 &wdummy, &x, &y, &i,
 145                                 &i, &udummy))
 146             {
 147                 screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 148                 event_handle_mouse_button_press(screen, ev->button, ev->state,
 149                                           globalconf.buttons.root, NULL);
 150                 return;
 151             }
 152 }
 153
 154 /** Handle XConfigureRequest events
 155  * \param e XEvent
 156  */
 157 void
 158 event_handle_configurerequest(XEvent * e)
 159 {
 160     Client *c;
 161     XConfigureRequestEvent *ev = &e->xconfigurerequest;
 162     XWindowChanges wc;
 163     int old_screen;
 164     area_t geometry;
 165
 166     if((c = client_get_bywin(globalconf.clients, ev->window)))
 167     {
 168         geometry = c->geometry;
 169
 170         if(ev->value_mask & CWX)
 171             geometry.x = ev->x;
 172         if(ev->value_mask & CWY)
 173             geometry.y = ev->y;
 174         if(ev->value_mask & CWWidth)
 175             geometry.width = ev->width;
 176         if(ev->value_mask & CWHeight)
 177             geometry.height = ev->height;
 178
 179         if(geometry.x != c->geometry.x || geometry.y != c->geometry.y
 180            || geometry.width != c->geometry.width || geometry.height != c->geometry.height)
 181         {
 182             old_screen = c->screen;
 183
 184             client_resize(c, geometry);
 185
 186             tag_client_with_rule(c, rule_matching_client(c));
 187
 188             if(!c->isfloating)
 189                 globalconf.screens[c->screen].need_arrange = True;
 190         }
 191         else
 192             window_configure(c->win, geometry, c->border);
 193     }
 194     else
 195     {
 196         wc.x = ev->x;
 197         wc.y = ev->y;
 198         wc.width = ev->width;
 199         wc.height = ev->height;
 200         wc.border_width = ev->border_width;
 201         wc.sibling = ev->above;
 202         wc.stack_mode = ev->detail;
 203         XConfigureWindow(e->xany.display, ev->window, ev->value_mask, &wc);
 204     }
 205 }
 206
 207 /** Handle XConfigure events
 208  * \param e XEvent
 209  */
 210 void
 211 event_handle_configurenotify(XEvent * e)
 212 {
 213     XConfigureEvent *ev = &e->xconfigure;
 214     int screen;
 215
 216     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 217         if(ev->window == RootWindow(e->xany.display, screen)
 218            && (ev->width != DisplayWidth(e->xany.display, screen)
 219                || ev->height != DisplayHeight(e->xany.display, screen)))
 220             /* it's not that we panic, but restart */
 221             uicb_exec(0, globalconf.argv);
 222 }
 223
 224 /** Handle XDestroyWindow events
 225  * \param e XEvent
 226  */
 227 void
 228 event_handle_destroynotify(XEvent *e)
 229 {
 230     Client *c;
 231     XDestroyWindowEvent *ev = &e->xdestroywindow;
 232
 233     if((c = client_get_bywin(globalconf.clients, ev->window)))
 234         client_unmanage(c);
 235 }
 236
 237 /** Handle XCrossing events on enter
 238  * \param e XEvent
 239  */
 240 void
 241 event_handle_enternotify(XEvent *e)
 242 {
 243     Client *c;
 244     XCrossingEvent *ev = &e->xcrossing;
 245     int screen;
 246
 247     if(ev->mode != NotifyNormal
 248        || (ev->x_root == globalconf.pointer_x
 249            && ev->y_root == globalconf.pointer_y))
 250         return;
 251
 252     /* the idea behing saving pointer_x and pointer_y is Bob Marley powered */
 253     globalconf.pointer_x = ev->x_root;
 254     globalconf.pointer_y = ev->y_root;
 255
 256     for(c = globalconf.clients; c; c = c->next)
 257         if(c->titlebar.sw && c->titlebar.sw->window == ev->window)
 258             break;
 259
 260     if(c || (c = client_get_bywin(globalconf.clients, ev->window)))
 261     {
 262         window_grabbuttons(get_phys_screen(c->screen), c->win);
 263         if(globalconf.screens[c->screen].sloppy_focus)
 264             client_focus(c, c->screen,
 265                          (globalconf.screens[c->screen].sloppy_focus
 266                           && globalconf.screens[c->screen].sloppy_focus_raise));
 267     }
 268     else
 269         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 270             if(ev->window == RootWindow(e->xany.display, screen))
 271             {
 272                 window_root_grabbuttons(screen);
 273                 return;
 274             }
 275 }
 276
 277 /** Handle XMotion events
 278  * \param e XEvent
 279  */
 280 void
 281 event_handle_motionnotify(XEvent *e)
 282 {
 283     XMotionEvent *ev = &e->xmotion;
 284
 285     globalconf.pointer_x = ev->x_root;
 286     globalconf.pointer_y = ev->y_root;
 287 }
 288
 289 /** Handle XExpose events
 290  * \param e XEvent
 291  */
 292 void
 293 event_handle_expose(XEvent *e)
 294 {
 295     XExposeEvent *ev = &e->xexpose;
 296     int screen;
 297     Statusbar *statusbar;
 298     Client *c;
 299
 300     if(!ev->count)
 301     {
 302         for(screen = 0; screen < globalconf.screens_info->nscreen; screen++)
 303             for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
 304                 if(statusbar->sw->window == ev->window)
 305                 {
 306                     statusbar_display(statusbar);
 307                     return;
 308                 }
 309
 310         for(c = globalconf.clients; c; c = c->next)
 311             if(c->titlebar.sw && c->titlebar.sw->window == ev->window)
 312             {
 313                 simplewindow_refresh_drawable(c->titlebar.sw, get_phys_screen(c->screen));
 314                 return;
 315             }
 316     }
 317 }
 318
 319 /** Handle XKey events
 320  * \param e XEvent
 321  */
 322 void
 323 event_handle_keypress(XEvent *e)
 324 {
 325     int screen, x, y, d;
 326     unsigned int m;
 327     XKeyEvent *ev = &e->xkey;
 328     Window dummy;
 329     Key *k;
 330
 331     /* find the right screen for this event */
 332     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 333         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 334         {
 335             /* if screen is 0, we are on first Zaphod screen or on the
 336              * only screen in Xinerama, so we can ask for a better screen
 337              * number with screen_get_bycoord: we'll get 0 in Zaphod mode
 338              * so it's the same, or maybe the real Xinerama screen */
 339             screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 340             break;
 341         }
 342
 343     for(k = globalconf.keys; k; k = k->next)
 344         if(ev->keycode == k->keycode &&
 345           k->func && CLEANMASK(k->mod) == CLEANMASK(ev->state))
 346             k->func(screen, k->arg);
 347 }
 348
 349 /** Handle XCrossing events on leave
 350  * \param e XEvent
 351  */
 352 void
 353 event_handle_leavenotify(XEvent * e)
 354 {
 355     XCrossingEvent *ev = &e->xcrossing;
 356     int screen;
 357
 358     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 359         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 360             client_focus(NULL, screen, True);
 361 }
 362
 363 /** Handle XMapping events
 364  * \param e XEvent
 365  */
 366 void
 367 event_handle_mappingnotify(XEvent *e)
 368 {
 369     XMappingEvent *ev = &e->xmapping;
 370     int screen;
 371
 372     XRefreshKeyboardMapping(ev);
 373     if(ev->request == MappingKeyboard)
 374         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 375             window_root_grabkeys(screen);
 376 }
 377
 378 /** Handle XMapRequest events
 379  * \param e XEvent
 380  */
 381 void
 382 event_handle_maprequest(XEvent *e)
 383 {
 384     static XWindowAttributes wa;
 385     XMapRequestEvent *ev = &e->xmaprequest;
 386     int screen = 0, x, y, d;
 387     unsigned int m;
 388     Window dummy;
 389
 390     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 391         return;
 392     if(wa.override_redirect)
 393         return;
 394     if(!client_get_bywin(globalconf.clients, ev->window))
 395     {
 396         if(globalconf.screens_info->xinerama_is_active
 397            && XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 398                             &dummy, &dummy, &x, &y, &d, &d, &m))
 399             screen = screen_get_bycoord(globalconf.screens_info, screen, x, y);
 400         else
 401              for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 402
 403         client_manage(ev->window, &wa, screen);
 404     }
 405 }
 406
 407 /** Handle XProperty events
 408  * \param e XEvent
 409  */
 410 void
 411 event_handle_propertynotify(XEvent * e)
 412 {
 413     Client *c;
 414     Window trans;
 415     XPropertyEvent *ev = &e->xproperty;
 416
 417     if(ev->state == PropertyDelete)
 418         return;                 /* ignore */
 419     if((c = client_get_bywin(globalconf.clients, ev->window)))
 420     {
 421         switch (ev->atom)
 422         {
 423           case XA_WM_TRANSIENT_FOR:
 424             XGetTransientForHint(e->xany.display, c->win, &trans);
 425             if(!c->isfloating
 426                && (c->isfloating = (client_get_bywin(globalconf.clients, trans) != NULL)))
 427                 globalconf.screens[c->screen].need_arrange = True;
 428             break;
 429           case XA_WM_NORMAL_HINTS:
 430             client_updatesizehints(c);
 431             break;
 432           case XA_WM_HINTS:
 433             client_updatewmhints(c);
 434             break;
 435         }
 436         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(globalconf.display, "_NET_WM_NAME", False))
 437             client_updatetitle(c);
 438     }
 439 }
 440
 441 /** Handle XUnmap events
 442  * \param e XEvent
 443  */
 444 void
 445 event_handle_unmapnotify(XEvent * e)
 446 {
 447     Client *c;
 448     XUnmapEvent *ev = &e->xunmap;
 449
 450     if((c = client_get_bywin(globalconf.clients, ev->window))
 451        && ev->event == RootWindow(e->xany.display, get_phys_screen(c->screen))
 452        && ev->send_event && window_getstate(c->win) == NormalState)
 453         client_unmanage(c);
 454 }
 455
 456 /** Handle XShape events
 457  * \param e XEvent
 458  */
 459 void
 460 event_handle_shape(XEvent * e)
 461 {
 462     XShapeEvent *ev = (XShapeEvent *) e;
 463     Client *c = client_get_bywin(globalconf.clients, ev->window);
 464
 465     if(c)
 466         window_setshape(get_phys_screen(c->screen), c->win);
 467 }
 468
 469 /** Handle XRandR events
 470  * \param e XEvent
 471  */
 472 void
 473 event_handle_randr_screen_change_notify(XEvent *e)
 474 {
 475     XRRUpdateConfiguration(e);
 476     uicb_exec(0, globalconf.argv);
 477 }
 478
 479 /** Handle XClientMessage events
 480  * \param e XEvent
 481  */
 482 void
 483 event_handle_clientmessage(XEvent *e)
 484 {
 485     ewmh_process_client_message(&e->xclient);
 486 }
 487
 488 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80