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 #include <X11/extensions/Xinerama.h>
  28
  29 #include "screen.h"
  30 #include "event.h"
  31 #include "tag.h"
  32 #include "statusbar.h"
  33 #include "window.h"
  34 #include "mouse.h"
  35 #include "ewmh.h"
  36 #include "client.h"
  37 #include "widget.h"
  38 #include "rules.h"
  39 #include "layouts/tile.h"
  40 #include "layouts/floating.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.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                   case Off:
 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(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 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, False);
 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     if((c = client_get_bywin(globalconf.clients, ev->window)))
 257     {
 258         window_grabbuttons(get_phys_screen(c->screen), c->win);
 259         if(globalconf.screens[c->screen].sloppy_focus)
 260             client_focus(c, c->screen,
 261                          (globalconf.screens[c->screen].sloppy_focus
 262                           && globalconf.screens[c->screen].sloppy_focus_raise));
 263     }
 264     else
 265         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 266             if(ev->window == RootWindow(e->xany.display, screen))
 267                 window_root_grabbuttons(screen);
 268
 269 }
 270
 271 /** Handle XMotion events
 272  * \param e XEvent
 273  */
 274 void
 275 event_handle_motionnotify(XEvent *e)
 276 {
 277     XMotionEvent *ev = &e->xmotion;
 278
 279     globalconf.pointer_x = ev->x_root;
 280     globalconf.pointer_y = ev->y_root;
 281 }
 282
 283 /** Handle XExpose events
 284  * \param e XEvent
 285  */
 286 void
 287 event_handle_expose(XEvent *e)
 288 {
 289     XExposeEvent *ev = &e->xexpose;
 290     int screen;
 291     Statusbar *statusbar;
 292
 293     if(!ev->count)
 294         for(screen = 0; screen < globalconf.nscreen; screen++)
 295             for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
 296                 if(statusbar->sw->window == ev->window)
 297                 {
 298                     statusbar_display(statusbar);
 299                     return;
 300                 }
 301 }
 302
 303 /** Handle XKey events
 304  * \param e XEvent
 305  */
 306 void
 307 event_handle_keypress(XEvent *e)
 308 {
 309     int screen, x, y, d;
 310     unsigned int m;
 311     XKeyEvent *ev = &e->xkey;
 312     Window dummy;
 313     Key *k;
 314
 315     /* find the right screen for this event */
 316     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 317         if(XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen), &dummy, &dummy, &x, &y, &d, &d, &m))
 318         {
 319             /* if screen is 0, we are on first Zaphod screen or on the
 320              * only screen in Xinerama, so we can ask for a better screen
 321              * number with screen_get_bycoord: we'll get 0 in Zaphod mode
 322              * so it's the same, or maybe the real Xinerama screen */
 323             screen = screen_get_bycoord(screen, x, y);
 324             break;
 325         }
 326
 327     for(k = globalconf.keys; k; k = k->next)
 328         if(ev->keycode == k->keycode &&
 329           k->func && CLEANMASK(k->mod) == CLEANMASK(ev->state))
 330         {
 331             k->func(screen, k->arg);
 332             break;
 333         }
 334 }
 335
 336 /** Handle XCrossing events on leave
 337  * \param e XEvent
 338  */
 339 void
 340 event_handle_leavenotify(XEvent * e)
 341 {
 342     XCrossingEvent *ev = &e->xcrossing;
 343     int screen;
 344
 345     for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 346         if((ev->window == RootWindow(e->xany.display, screen)) && !ev->same_screen)
 347             client_focus(NULL, screen, True);
 348 }
 349
 350 /** Handle XMapping events
 351  * \param e XEvent
 352  */
 353 void
 354 event_handle_mappingnotify(XEvent *e)
 355 {
 356     XMappingEvent *ev = &e->xmapping;
 357     int screen;
 358
 359     XRefreshKeyboardMapping(ev);
 360     if(ev->request == MappingKeyboard)
 361         for(screen = 0; screen < ScreenCount(e->xany.display); screen++)
 362             window_root_grabkeys(screen);
 363 }
 364
 365 /** Handle XMapRequest events
 366  * \param e XEvent
 367  */
 368 void
 369 event_handle_maprequest(XEvent *e)
 370 {
 371     static XWindowAttributes wa;
 372     XMapRequestEvent *ev = &e->xmaprequest;
 373     int screen = 0, x, y, d;
 374     unsigned int m;
 375     Window dummy;
 376
 377     if(!XGetWindowAttributes(e->xany.display, ev->window, &wa))
 378         return;
 379     if(wa.override_redirect)
 380         return;
 381     if(!client_get_bywin(globalconf.clients, ev->window))
 382     {
 383         if(XineramaIsActive(globalconf.display)
 384            && XQueryPointer(e->xany.display, RootWindow(e->xany.display, screen),
 385                             &dummy, &dummy, &x, &y, &d, &d, &m))
 386             screen = screen_get_bycoord(screen, x, y);
 387         else
 388              for(screen = 0; wa.screen != ScreenOfDisplay(e->xany.display, screen); screen++);
 389
 390         client_manage(ev->window, &wa, screen);
 391     }
 392 }
 393
 394 /** Handle XProperty events
 395  * \param e XEvent
 396  */
 397 void
 398 event_handle_propertynotify(XEvent * e)
 399 {
 400     Client *c;
 401     Window trans;
 402     XPropertyEvent *ev = &e->xproperty;
 403
 404     if(ev->state == PropertyDelete)
 405         return;                 /* ignore */
 406     if((c = client_get_bywin(globalconf.clients, ev->window)))
 407     {
 408         switch (ev->atom)
 409         {
 410           case XA_WM_TRANSIENT_FOR:
 411             XGetTransientForHint(e->xany.display, c->win, &trans);
 412             if(!c->isfloating
 413                && (c->isfloating = (client_get_bywin(globalconf.clients, trans) != NULL)))
 414                 globalconf.screens[c->screen].need_arrange = True;
 415             break;
 416           case XA_WM_NORMAL_HINTS:
 417             client_updatesizehints(c);
 418             break;
 419           case XA_WM_HINTS:
 420             client_updatewmhints(c);
 421             break;
 422         }
 423         if(ev->atom == XA_WM_NAME || ev->atom == XInternAtom(globalconf.display, "_NET_WM_NAME", False))
 424             client_updatetitle(c);
 425     }
 426 }
 427
 428 /** Handle XUnmap events
 429  * \param e XEvent
 430  */
 431 void
 432 event_handle_unmapnotify(XEvent * e)
 433 {
 434     Client *c;
 435     XUnmapEvent *ev = &e->xunmap;
 436
 437     if((c = client_get_bywin(globalconf.clients, ev->window))
 438        && ev->event == RootWindow(e->xany.display, get_phys_screen(c->screen))
 439        && ev->send_event && window_getstate(c->win) == NormalState)
 440         client_unmanage(c);
 441 }
 442
 443 /** Handle XShape events
 444  * \param e XEvent
 445  */
 446 void
 447 event_handle_shape(XEvent * e)
 448 {
 449     XShapeEvent *ev = (XShapeEvent *) e;
 450     Client *c = client_get_bywin(globalconf.clients, ev->window);
 451
 452     if(c)
 453         window_setshape(get_phys_screen(c->screen), c->win);
 454 }
 455
 456 /** Handle XRandR events
 457  * \param e XEvent
 458  */
 459 void
 460 event_handle_randr_screen_change_notify(XEvent *e)
 461 {
 462     XRRUpdateConfiguration(e);
 463     uicb_exec(0, globalconf.argv);
 464 }
 465
 466 /** Handle XClientMessage events
 467  * \param e XEvent
 468  */
 469 void
 470 event_handle_clientmessage(XEvent *e)
 471 {
 472     ewmh_process_client_message(&e->xclient);
 473 }
 474
 475 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80