events.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <xcb/xcb.h>
   5 #include <xcb/xcb_event.h>
   6 #include <xcb/xcb_icccm.h>
   7 #include "types.h"
   8 #include "bspwm.h"
   9 #include "settings.h"
  10 #include "helpers.h"
  11 #include "window.h"
  12 #include "events.h"
  13 #include "tree.h"
  14 #include "rules.h"
  15 #include "ewmh.h"
  16
  17 void handle_event(xcb_generic_event_t *evt)
  18 {
  19     switch (XCB_EVENT_RESPONSE_TYPE(evt)) {
  20         case XCB_MAP_REQUEST:
  21             map_request(evt);
  22             break;
  23         case XCB_DESTROY_NOTIFY:
  24             destroy_notify(evt);
  25             break;
  26         case XCB_UNMAP_NOTIFY:
  27             unmap_notify(evt);
  28             break;
  29         case XCB_CLIENT_MESSAGE:
  30             client_message(evt);
  31             break;
  32         case XCB_CONFIGURE_REQUEST:
  33             configure_request(evt);
  34             break;
  35         case XCB_PROPERTY_NOTIFY:
  36             property_notify(evt);
  37             break;
  38         case XCB_ENTER_NOTIFY:
  39             enter_notify(evt);
  40             break;
  41         case XCB_MOTION_NOTIFY:
  42             motion_notify(evt);
  43             break;
  44         default:
  45             break;
  46     }
  47 }
  48
  49 void map_request(xcb_generic_event_t *evt)
  50 {
  51     xcb_map_request_event_t *e = (xcb_map_request_event_t *) evt;
  52
  53     PRINTF("map request %X\n", e->window);
  54
  55     manage_window(mon, mon->desk, e->window);
  56 }
  57
  58 void configure_request(xcb_generic_event_t *evt)
  59 {
  60     xcb_configure_request_event_t *e = (xcb_configure_request_event_t *) evt;
  61
  62     PRINTF("configure request %X\n", e->window);
  63
  64     window_location_t loc;
  65     bool is_managed = locate_window(e->window, &loc);
  66
  67     if (!is_managed || is_floating(loc.node->client)) {
  68         uint16_t mask = 0;
  69         uint32_t values[7];
  70         unsigned short i = 0;
  71
  72         if (e->value_mask & XCB_CONFIG_WINDOW_X) {
  73             mask |= XCB_CONFIG_WINDOW_X;
  74             values[i++] = e->x;
  75             if (is_managed)
  76                 loc.node->client->floating_rectangle.x = e->x;
  77         }
  78
  79         if (e->value_mask & XCB_CONFIG_WINDOW_Y) {
  80             mask |= XCB_CONFIG_WINDOW_Y;
  81             values[i++] = e->y;
  82             if (is_managed)
  83                 loc.node->client->floating_rectangle.y = e->y;
  84         }
  85
  86         if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
  87             mask |= XCB_CONFIG_WINDOW_WIDTH;
  88             values[i++] = e->width;
  89             if (is_managed)
  90                 loc.node->client->floating_rectangle.width = e->width;
  91         }
  92
  93         if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
  94             mask |= XCB_CONFIG_WINDOW_HEIGHT;
  95             values[i++] = e->height;
  96             if (is_managed)
  97                 loc.node->client->floating_rectangle.height = e->height;
  98         }
  99
 100         if (!is_managed && e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
 101             mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
 102             values[i++] = e->border_width;
 103         }
 104
 105         if (e->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
 106             mask |= XCB_CONFIG_WINDOW_SIBLING;
 107             values[i++] = e->sibling;
 108         }
 109
 110         if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
 111             mask |= XCB_CONFIG_WINDOW_STACK_MODE;
 112             values[i++] = e->stack_mode;
 113         }
 114
 115         xcb_configure_window(dpy, e->window, mask, values);
 116         if (is_managed)
 117             window_draw_border(loc.node, loc.node == loc.desktop->focus, loc.monitor == mon);
 118     } else {
 119         xcb_configure_notify_event_t evt;
 120         xcb_rectangle_t rect;
 121         unsigned int bw;
 122         xcb_window_t win = loc.node->client->window;
 123
 124         if (is_tiled(loc.node->client)) {
 125             rect = loc.node->client->tiled_rectangle;
 126             bw = border_width;
 127         } else {
 128             rect = loc.monitor->rectangle;
 129             bw = 0;
 130         }
 131
 132         evt.response_type = XCB_CONFIGURE_NOTIFY;
 133         evt.event = win;
 134         evt.window = win;
 135         evt.above_sibling = XCB_NONE;
 136         evt.x = rect.x;
 137         evt.y = rect.y;
 138         evt.width = rect.width;
 139         evt.height = rect.height;
 140         evt.border_width = bw;
 141         evt.override_redirect = false;
 142
 143         xcb_send_event(dpy, false, win, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (const char *) &evt);
 144     }
 145 }
 146
 147 void destroy_notify(xcb_generic_event_t *evt)
 148 {
 149     xcb_destroy_notify_event_t *e = (xcb_destroy_notify_event_t *) evt;
 150
 151     PRINTF("destroy notify %X\n", e->window);
 152
 153     window_location_t loc;
 154     if (locate_window(e->window, &loc)) {
 155         remove_node(loc.desktop, loc.node);
 156         arrange(loc.monitor, loc.desktop);
 157     }
 158 }
 159
 160 void unmap_notify(xcb_generic_event_t *evt)
 161 {
 162     xcb_unmap_notify_event_t *e = (xcb_unmap_notify_event_t *) evt;
 163
 164     PRINTF("unmap notify %X\n", e->window);
 165
 166     window_location_t loc;
 167     if (locate_window(e->window, &loc)) {
 168         remove_node(loc.desktop, loc.node);
 169         arrange(loc.monitor, loc.desktop);
 170     }
 171 }
 172
 173 void property_notify(xcb_generic_event_t *evt)
 174 {
 175     xcb_property_notify_event_t *e = (xcb_property_notify_event_t *) evt;
 176     xcb_icccm_wm_hints_t hints;
 177
 178     /* PRINTF("property notify %X\n", e->window); */
 179
 180     if (e->atom != XCB_ATOM_WM_HINTS)
 181         return;
 182
 183     window_location_t loc;
 184     if (locate_window(e->window, &loc)) {
 185         if (xcb_icccm_get_wm_hints_reply(dpy, xcb_icccm_get_wm_hints(dpy, e->window), &hints, NULL) == 1) {
 186             uint32_t urgent = xcb_icccm_wm_hints_get_urgency(&hints);
 187             if (urgent != 0 && loc.node != mon->desk->focus) {
 188                 loc.node->client->urgent = urgent;
 189                 put_status();
 190                 if (loc.monitor->desk == loc.desktop)
 191                     arrange(loc.monitor, loc.desktop);
 192             }
 193         }
 194     }
 195 }
 196
 197 void client_message(xcb_generic_event_t *evt)
 198 {
 199     xcb_client_message_event_t *e = (xcb_client_message_event_t *) evt;
 200
 201     PRINTF("client message %X %u\n", e->window, e->type);
 202
 203     if (e->type == ewmh->_NET_CURRENT_DESKTOP) {
 204         desktop_location_t loc;
 205         if (ewmh_locate_desktop(e->data.data32[0], &loc)) {
 206             select_monitor(loc.monitor);
 207             select_desktop(loc.desktop);
 208         }
 209         return;
 210     }
 211
 212     window_location_t loc;
 213     if (!locate_window(e->window, &loc))
 214         return;
 215
 216     if (e->type == ewmh->_NET_WM_STATE) {
 217         handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[1], e->data.data32[0]);
 218         handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[2], e->data.data32[0]);
 219     } else if (e->type == ewmh->_NET_ACTIVE_WINDOW) {
 220         if (loc.desktop->focus->client->fullscreen && loc.desktop->focus != loc.node)
 221             toggle_fullscreen(loc.monitor, loc.desktop->focus->client);
 222         select_monitor(loc.monitor);
 223         select_desktop(loc.desktop);
 224         focus_node(loc.monitor, loc.desktop, loc.node, true);
 225         arrange(loc.monitor, loc.desktop);
 226     }
 227 }
 228
 229 void enter_notify(xcb_generic_event_t *evt)
 230 {
 231     xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *) evt;
 232     xcb_window_t win = e->event;
 233
 234     PRINTF("enter notify %X %d %d\n", win, e->mode, e->detail);
 235
 236     if (e->mode != XCB_NOTIFY_MODE_NORMAL
 237             || (last_pointer_position.x = e->root_x && last_pointer_position.y == e->root_y))
 238         return;
 239
 240     window_focus(win);
 241 }
 242
 243 void motion_notify(xcb_generic_event_t *evt)
 244 {
 245     xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t *) evt;
 246     xcb_window_t win = e->event;
 247
 248     PRINTF("motion notify %X\n", win);
 249
 250     window_focus(win);
 251 }
 252
 253 void handle_state(monitor_t *m, desktop_t *d, node_t *n, xcb_atom_t state, unsigned int action)
 254 {
 255     if (state == ewmh->_NET_WM_STATE_FULLSCREEN) {
 256         bool fs = n->client->fullscreen;
 257         if (action == XCB_EWMH_WM_STATE_TOGGLE
 258                 || (fs && action == XCB_EWMH_WM_STATE_REMOVE)
 259                 || (!fs && action == XCB_EWMH_WM_STATE_ADD)) {
 260             toggle_fullscreen(m, n->client);
 261             arrange(m, d);
 262         }
 263     }
 264 }
 265
 266 void grab_pointer(pointer_action_t pac)
 267 {
 268     PRINTF("grab pointer %u\n", pac);
 269
 270     xcb_window_t win;
 271     xcb_point_t pos;
 272
 273     xcb_query_pointer_reply_t *qpr = xcb_query_pointer_reply(dpy, xcb_query_pointer(dpy, root), NULL);
 274     if (qpr != NULL) {
 275         pos = (xcb_point_t) {qpr->root_x, qpr->root_y};
 276         win = qpr->child;
 277         free(qpr);
 278     } else {
 279         return;
 280     }
 281
 282     window_location_t loc;
 283     if (locate_window(win, &loc)) {
 284         client_t *c = loc.node->client;
 285         switch (pac)  {
 286             case ACTION_FOCUS:
 287                 focus_node(loc.monitor, loc.desktop, loc.node, true);
 288                 break;
 289             case ACTION_MOVE:
 290             case ACTION_RESIZE:
 291                 if (is_tiled(loc.node->client)) {
 292                     loc.node->client->floating_rectangle = loc.node->client->tiled_rectangle;
 293                     toggle_floating(loc.node);
 294                     arrange(loc.monitor, loc.desktop);
 295                 } else if (loc.node->client->fullscreen) {
 296                     frozen_pointer->action = ACTION_NONE;
 297                     return;
 298                 }
 299                 frozen_pointer->monitor = loc.monitor;
 300                 frozen_pointer->desktop = loc.desktop;
 301                 frozen_pointer->node = loc.node;
 302                 frozen_pointer->rectangle = c->floating_rectangle;
 303                 frozen_pointer->position = pos;
 304                 frozen_pointer->action = pac;
 305                 if (pac == ACTION_RESIZE) {
 306                     int16_t mid_x, mid_y;
 307                     mid_x = c->floating_rectangle.x + (c->floating_rectangle.width / 2);
 308                     mid_y = c->floating_rectangle.y + (c->floating_rectangle.height / 2);
 309                     if (pos.x > mid_x) {
 310                         if (pos.y > mid_y)
 311                             frozen_pointer->corner = BOTTOM_RIGHT;
 312                         else
 313                             frozen_pointer->corner = TOP_RIGHT;
 314                     } else {
 315                         if (pos.y > mid_y)
 316                             frozen_pointer->corner = BOTTOM_LEFT;
 317                         else
 318                             frozen_pointer->corner = TOP_LEFT;
 319                     }
 320                 }
 321                 break;
 322             case ACTION_NONE:
 323                 break;
 324         }
 325     } else {
 326         frozen_pointer->action = ACTION_NONE;
 327     }
 328 }
 329
 330 void track_pointer(int root_x, int root_y)
 331 {
 332     if (frozen_pointer->action == ACTION_NONE)
 333         return;
 334
 335     int16_t delta_x, delta_y, x, y, w, h;
 336     uint16_t width, height;
 337
 338     monitor_t *m = frozen_pointer->monitor;
 339     desktop_t *d = frozen_pointer->desktop;
 340     node_t *n = frozen_pointer->node;
 341     client_t *c = n->client;
 342     xcb_rectangle_t rect = frozen_pointer->rectangle;
 343     xcb_window_t win = c->window;
 344
 345     x = y = 0;
 346     w = h = 1;
 347
 348     delta_x = root_x - frozen_pointer->position.x;
 349     delta_y = root_y - frozen_pointer->position.y;
 350
 351     switch (frozen_pointer->action) {
 352         case ACTION_MOVE:
 353             x = rect.x + delta_x;
 354             y = rect.y + delta_y;
 355             window_move(win, x, y);
 356             break;
 357         case ACTION_RESIZE:
 358             switch (frozen_pointer->corner) {
 359                 case TOP_LEFT:
 360                     x = rect.x + delta_x;
 361                     y = rect.y + delta_y;
 362                     w = rect.width - delta_x;
 363                     h = rect.height - delta_y;
 364                     break;
 365                 case TOP_RIGHT:
 366                     x = rect.x;
 367                     y = rect.y + delta_y;
 368                     w = rect.width + delta_x;
 369                     h = rect.height - delta_y;
 370                     break;
 371                 case BOTTOM_LEFT:
 372                     x = rect.x + delta_x;
 373                     y = rect.y;
 374                     w = rect.width - delta_x;
 375                     h = rect.height + delta_y;
 376                     break;
 377                 case BOTTOM_RIGHT:
 378                     x = rect.x;
 379                     y = rect.y;
 380                     w = rect.width + delta_x;
 381                     h = rect.height + delta_y;
 382                     break;
 383             }
 384             width = MAX(1, w);
 385             height = MAX(1, h);
 386             window_move_resize(win, x, y, width, height);
 387             c->floating_rectangle = (xcb_rectangle_t) {x, y, width, height};
 388             window_draw_border(n, d->focus == n, mon == m);
 389             break;
 390         case ACTION_FOCUS:
 391         case ACTION_NONE:
 392             break;
 393     }
 394 }
 395
 396 void ungrab_pointer(void)
 397 {
 398     PUTS("ungrab pointer");
 399
 400     if (frozen_pointer->action == ACTION_NONE)
 401         return;
 402
 403     update_floating_rectangle(frozen_pointer->node->client);
 404     monitor_t *m = underlying_monitor(frozen_pointer->node->client);
 405     if (m != NULL && m != frozen_pointer->monitor) {
 406         transfer_node(frozen_pointer->monitor, frozen_pointer->desktop, m, m->desk, frozen_pointer->node);
 407         select_monitor(m);
 408     }
 409 }