-#include <stdio.h>
+/* Copyright (c) 2012, Bastien Dejean
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
#include <stdlib.h>
-#include <string.h>
-#include <xcb/xcb.h>
-#include <xcb/randr.h>
-#include <xcb/xcb_event.h>
-#include <xcb/xcb_icccm.h>
-#include "types.h"
+#include <stdbool.h>
#include "bspwm.h"
+#include "ewmh.h"
+#include "monitor.h"
+#include "query.h"
#include "settings.h"
-#include "helpers.h"
+#include "subscribe.h"
+#include "tree.h"
#include "window.h"
+#include "pointer.h"
#include "events.h"
-#include "tree.h"
-#include "rules.h"
-#include "ewmh.h"
void handle_event(xcb_generic_event_t *evt)
{
- uint8_t resp_type = XCB_EVENT_RESPONSE_TYPE(evt);
- switch (resp_type) {
- case XCB_MAP_REQUEST:
- map_request(evt);
- break;
- case XCB_DESTROY_NOTIFY:
- destroy_notify(evt);
- break;
- case XCB_UNMAP_NOTIFY:
- unmap_notify(evt);
- break;
- case XCB_CLIENT_MESSAGE:
- client_message(evt);
- break;
- case XCB_CONFIGURE_REQUEST:
- configure_request(evt);
- break;
- case XCB_PROPERTY_NOTIFY:
- property_notify(evt);
- break;
- case XCB_ENTER_NOTIFY:
- enter_notify(evt);
- break;
- case XCB_MOTION_NOTIFY:
- motion_notify();
- break;
- default:
- if (resp_type == randr_base + XCB_RANDR_SCREEN_CHANGE_NOTIFY)
- import_monitors();
- break;
- }
+ uint8_t resp_type = XCB_EVENT_RESPONSE_TYPE(evt);
+ switch (resp_type) {
+ case XCB_MAP_REQUEST:
+ map_request(evt);
+ break;
+ case XCB_DESTROY_NOTIFY:
+ destroy_notify(evt);
+ break;
+ case XCB_UNMAP_NOTIFY:
+ unmap_notify(evt);
+ break;
+ case XCB_CLIENT_MESSAGE:
+ client_message(evt);
+ break;
+ case XCB_CONFIGURE_REQUEST:
+ configure_request(evt);
+ break;
+ case XCB_PROPERTY_NOTIFY:
+ property_notify(evt);
+ break;
+ case XCB_ENTER_NOTIFY:
+ enter_notify(evt);
+ break;
+ case XCB_BUTTON_PRESS:
+ button_press(evt);
+ break;
+ case XCB_MOTION_NOTIFY:
+ motion_notify(evt);
+ break;
+ case XCB_FOCUS_IN:
+ focus_in(evt);
+ break;
+ case 0:
+ process_error(evt);
+ break;
+ default:
+ if (randr && resp_type == randr_base + XCB_RANDR_SCREEN_CHANGE_NOTIFY) {
+ update_monitors();
+ }
+ break;
+ }
}
void map_request(xcb_generic_event_t *evt)
{
- xcb_map_request_event_t *e = (xcb_map_request_event_t *) evt;
+ xcb_map_request_event_t *e = (xcb_map_request_event_t *) evt;
- PRINTF("map request %X\n", e->window);
-
- manage_window(mon, mon->desk, e->window);
+ schedule_window(e->window);
}
void configure_request(xcb_generic_event_t *evt)
{
- xcb_configure_request_event_t *e = (xcb_configure_request_event_t *) evt;
-
- PRINTF("configure request %X\n", e->window);
-
- window_location_t loc;
- bool is_managed = locate_window(e->window, &loc);
-
- if (!is_managed || is_floating(loc.node->client)) {
- uint16_t mask = 0;
- uint32_t values[7];
- unsigned short i = 0;
-
- if (e->value_mask & XCB_CONFIG_WINDOW_X) {
- mask |= XCB_CONFIG_WINDOW_X;
- values[i++] = e->x;
- if (is_managed)
- loc.node->client->floating_rectangle.x = e->x;
- }
-
- if (e->value_mask & XCB_CONFIG_WINDOW_Y) {
- mask |= XCB_CONFIG_WINDOW_Y;
- values[i++] = e->y;
- if (is_managed)
- loc.node->client->floating_rectangle.y = e->y;
- }
-
- if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
- mask |= XCB_CONFIG_WINDOW_WIDTH;
- values[i++] = e->width;
- if (is_managed)
- loc.node->client->floating_rectangle.width = e->width;
- }
-
- if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
- mask |= XCB_CONFIG_WINDOW_HEIGHT;
- values[i++] = e->height;
- if (is_managed)
- loc.node->client->floating_rectangle.height = e->height;
- }
-
- if (!is_managed && e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
- mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
- values[i++] = e->border_width;
- }
-
- if (e->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
- mask |= XCB_CONFIG_WINDOW_SIBLING;
- values[i++] = e->sibling;
- }
-
- if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
- mask |= XCB_CONFIG_WINDOW_STACK_MODE;
- values[i++] = e->stack_mode;
- }
-
- xcb_configure_window(dpy, e->window, mask, values);
- if (is_managed)
- window_draw_border(loc.node, loc.node == loc.desktop->focus, loc.monitor == mon);
- } else {
- xcb_configure_notify_event_t evt;
- xcb_rectangle_t rect;
- unsigned int bw;
- xcb_window_t win = loc.node->client->window;
-
- if (is_tiled(loc.node->client)) {
- rect = loc.node->client->tiled_rectangle;
- bw = border_width;
- } else {
- rect = loc.monitor->rectangle;
- bw = 0;
- }
-
- evt.response_type = XCB_CONFIGURE_NOTIFY;
- evt.event = win;
- evt.window = win;
- evt.above_sibling = XCB_NONE;
- evt.x = rect.x;
- evt.y = rect.y;
- evt.width = rect.width;
- evt.height = rect.height;
- evt.border_width = bw;
- evt.override_redirect = false;
-
- xcb_send_event(dpy, false, win, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (const char *) &evt);
- }
+ xcb_configure_request_event_t *e = (xcb_configure_request_event_t *) evt;
+
+ coordinates_t loc;
+ bool is_managed = locate_window(e->window, &loc);
+ client_t *c = (is_managed ? loc.node->client : NULL);
+ uint16_t width, height;
+
+ if (!is_managed) {
+ uint16_t mask = 0;
+ uint32_t values[7];
+ unsigned short i = 0;
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_X) {
+ mask |= XCB_CONFIG_WINDOW_X;
+ values[i++] = e->x;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_Y) {
+ mask |= XCB_CONFIG_WINDOW_Y;
+ values[i++] = e->y;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
+ mask |= XCB_CONFIG_WINDOW_WIDTH;
+ values[i++] = e->width;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
+ mask |= XCB_CONFIG_WINDOW_HEIGHT;
+ values[i++] = e->height;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
+ mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
+ values[i++] = e->border_width;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
+ mask |= XCB_CONFIG_WINDOW_SIBLING;
+ values[i++] = e->sibling;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
+ mask |= XCB_CONFIG_WINDOW_STACK_MODE;
+ values[i++] = e->stack_mode;
+ }
+
+ xcb_configure_window(dpy, e->window, mask, values);
+
+ } else if (IS_FLOATING(c)) {
+ width = c->floating_rectangle.width;
+ height = c->floating_rectangle.height;
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_X) {
+ c->floating_rectangle.x = e->x;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_Y) {
+ c->floating_rectangle.y = e->y;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
+ width = e->width;
+ }
+
+ if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
+ height = e->height;
+ }
+
+ apply_size_hints(c, &width, &height);
+ c->floating_rectangle.width = width;
+ c->floating_rectangle.height = height;
+ xcb_rectangle_t r = c->floating_rectangle;
+
+ window_move_resize(e->window, r.x, r.y, r.width, r.height);
+
+ put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc.monitor->id, loc.desktop->id, e->window, r.width, r.height, r.x, r.y);
+
+ monitor_t *m = monitor_from_client(c);
+ if (m != loc.monitor) {
+ transfer_node(loc.monitor, loc.desktop, loc.node, m, m->desk, m->desk->focus);
+ }
+ } else {
+ if (c->state == STATE_PSEUDO_TILED) {
+ width = c->floating_rectangle.width;
+ height = c->floating_rectangle.height;
+ if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
+ width = e->width;
+ }
+ if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
+ height = e->height;
+ }
+ apply_size_hints(c, &width, &height);
+ if (width != c->floating_rectangle.width || height != c->floating_rectangle.height) {
+ c->floating_rectangle.width = width;
+ c->floating_rectangle.height = height;
+ arrange(loc.monitor, loc.desktop);
+ }
+ }
+
+
+ xcb_configure_notify_event_t evt;
+ unsigned int bw = c->border_width;
+
+ xcb_rectangle_t r = IS_FULLSCREEN(c) ? loc.monitor->rectangle : c->tiled_rectangle;
+
+ evt.response_type = XCB_CONFIGURE_NOTIFY;
+ evt.event = e->window;
+ evt.window = e->window;
+ evt.above_sibling = XCB_NONE;
+ evt.x = r.x;
+ evt.y = r.y;
+ evt.width = r.width;
+ evt.height = r.height;
+ evt.border_width = bw;
+ evt.override_redirect = false;
+
+ xcb_send_event(dpy, false, e->window, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (const char *) &evt);
+ }
}
void destroy_notify(xcb_generic_event_t *evt)
{
- xcb_destroy_notify_event_t *e = (xcb_destroy_notify_event_t *) evt;
-
- PRINTF("destroy notify %X\n", e->window);
+ xcb_destroy_notify_event_t *e = (xcb_destroy_notify_event_t *) evt;
- window_location_t loc;
- if (locate_window(e->window, &loc)) {
- remove_node(loc.desktop, loc.node);
- arrange(loc.monitor, loc.desktop);
- }
+ unmanage_window(e->window);
}
void unmap_notify(xcb_generic_event_t *evt)
{
- xcb_unmap_notify_event_t *e = (xcb_unmap_notify_event_t *) evt;
-
- PRINTF("unmap notify %X\n", e->window);
+ xcb_unmap_notify_event_t *e = (xcb_unmap_notify_event_t *) evt;
- window_location_t loc;
- if (locate_window(e->window, &loc)) {
- remove_node(loc.desktop, loc.node);
- arrange(loc.monitor, loc.desktop);
- }
+ unmanage_window(e->window);
}
void property_notify(xcb_generic_event_t *evt)
{
- xcb_property_notify_event_t *e = (xcb_property_notify_event_t *) evt;
- xcb_icccm_wm_hints_t hints;
-
- /* PRINTF("property notify %X\n", e->window); */
-
- if (e->atom != XCB_ATOM_WM_HINTS)
- return;
-
- window_location_t loc;
- if (locate_window(e->window, &loc)
- && xcb_icccm_get_wm_hints_reply(dpy, xcb_icccm_get_wm_hints(dpy, e->window), &hints, NULL) == 1)
- set_urgency(loc.monitor, loc.desktop, loc.node, xcb_icccm_wm_hints_get_urgency(&hints));
+ xcb_property_notify_event_t *e = (xcb_property_notify_event_t *) evt;
+
+ if (e->atom != XCB_ATOM_WM_HINTS && e->atom != XCB_ATOM_WM_NORMAL_HINTS) {
+ return;
+ }
+
+ coordinates_t loc;
+ if (!locate_window(e->window, &loc)) {
+ return;
+ }
+
+ if (e->atom == XCB_ATOM_WM_HINTS) {
+ xcb_icccm_wm_hints_t hints;
+ if (xcb_icccm_get_wm_hints_reply(dpy, xcb_icccm_get_wm_hints(dpy, e->window), &hints, NULL) == 1 &&
+ (hints.flags & XCB_ICCCM_WM_HINT_X_URGENCY))
+ set_urgent(loc.monitor, loc.desktop, loc.node, xcb_icccm_wm_hints_get_urgency(&hints));
+ } else if (e->atom == XCB_ATOM_WM_NORMAL_HINTS) {
+ client_t *c = loc.node->client;
+ if (xcb_icccm_get_wm_normal_hints_reply(dpy, xcb_icccm_get_wm_normal_hints(dpy, e->window), &c->size_hints, NULL) == 1) {
+ arrange(loc.monitor, loc.desktop);
+ }
+ }
}
void client_message(xcb_generic_event_t *evt)
{
- xcb_client_message_event_t *e = (xcb_client_message_event_t *) evt;
-
- PRINTF("client message %X %u\n", e->window, e->type);
-
- if (e->type == ewmh->_NET_CURRENT_DESKTOP) {
- desktop_location_t loc;
- if (ewmh_locate_desktop(e->data.data32[0], &loc))
- focus_node(loc.monitor, loc.desktop, loc.desktop->focus);
- return;
- }
-
- window_location_t loc;
- if (!locate_window(e->window, &loc))
- return;
-
- if (e->type == ewmh->_NET_WM_STATE) {
- handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[1], e->data.data32[0]);
- handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[2], e->data.data32[0]);
- } else if (e->type == ewmh->_NET_ACTIVE_WINDOW) {
- if (loc.desktop->focus->client->fullscreen && loc.desktop->focus != loc.node) {
- toggle_fullscreen(loc.desktop, loc.desktop->focus);
- arrange(loc.monitor, loc.desktop);
- }
- focus_node(loc.monitor, loc.desktop, loc.node);
- }
+ xcb_client_message_event_t *e = (xcb_client_message_event_t *) evt;
+
+ if (e->type == ewmh->_NET_CURRENT_DESKTOP) {
+ coordinates_t loc;
+ if (ewmh_locate_desktop(e->data.data32[0], &loc)) {
+ focus_node(loc.monitor, loc.desktop, loc.desktop->focus);
+ }
+ return;
+ }
+
+ coordinates_t loc;
+ if (!locate_window(e->window, &loc)) {
+ return;
+ }
+
+ if (e->type == ewmh->_NET_WM_STATE) {
+ handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[1], e->data.data32[0]);
+ handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[2], e->data.data32[0]);
+ } else if (e->type == ewmh->_NET_ACTIVE_WINDOW) {
+ if ((ignore_ewmh_focus && e->data.data32[0] == XCB_EWMH_CLIENT_SOURCE_TYPE_NORMAL) ||
+ loc.node == mon->desk->focus) {
+ return;
+ }
+ focus_node(loc.monitor, loc.desktop, loc.node);
+ } else if (e->type == ewmh->_NET_WM_DESKTOP) {
+ coordinates_t dloc;
+ if (ewmh_locate_desktop(e->data.data32[0], &dloc)) {
+ transfer_node(loc.monitor, loc.desktop, loc.node, dloc.monitor, dloc.desktop, dloc.desktop->focus);
+ }
+ } else if (e->type == ewmh->_NET_CLOSE_WINDOW) {
+ close_node(loc.node);
+ }
}
-void enter_notify(xcb_generic_event_t *evt)
+void focus_in(xcb_generic_event_t *evt)
{
- xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *) evt;
- xcb_window_t win = e->event;
-
- PRINTF("enter notify %X %d %d\n", win, e->mode, e->detail);
-
- if (e->mode != XCB_NOTIFY_MODE_NORMAL
- || (mon->desk->focus != NULL && mon->desk->focus->client->window == win))
- return;
-
- enable_motion_recorder();
+ xcb_focus_in_event_t *e = (xcb_focus_in_event_t *) evt;
+
+ if (e->mode == XCB_NOTIFY_MODE_GRAB || e->mode == XCB_NOTIFY_MODE_UNGRAB
+ || e->detail == XCB_NOTIFY_DETAIL_POINTER || e->detail == XCB_NOTIFY_DETAIL_POINTER_ROOT
+ || e->detail == XCB_NOTIFY_DETAIL_NONE) {
+ return;
+ }
+
+ if (mon->desk->focus != NULL && e->event == mon->desk->focus->id) {
+ return;
+ }
+
+ coordinates_t loc;
+ if (locate_window(e->event, &loc)) {
+ // prevent input focus stealing
+ update_input_focus();
+ }
}
-void motion_notify(void)
+void button_press(xcb_generic_event_t *evt)
{
- PUTS("motion notify");
-
- disable_motion_recorder();
-
- xcb_window_t win = XCB_NONE;
- query_pointer(&win, NULL);
- if (win != XCB_NONE) {
- bool backup = pointer_follows_monitor;
- pointer_follows_monitor = false;
- window_focus(win);
- pointer_follows_monitor = backup;
- }
+ xcb_button_press_event_t *e = (xcb_button_press_event_t *) evt;
+ switch (e->detail) {
+ case XCB_BUTTON_INDEX_1:
+ if (click_to_focus && cleaned_mask(e->state) == XCB_NONE) {
+ xcb_allow_events(dpy, XCB_ALLOW_REPLAY_POINTER, e->time);
+ xcb_flush(dpy);
+ grab_pointer(ACTION_FOCUS);
+ } else {
+ grab_pointer(ACTION_MOVE);
+ }
+ break;
+ case XCB_BUTTON_INDEX_2:
+ grab_pointer(ACTION_RESIZE_SIDE);
+ break;
+ case XCB_BUTTON_INDEX_3:
+ grab_pointer(ACTION_RESIZE_CORNER);
+ break;
+ }
}
-void handle_state(monitor_t *m, desktop_t *d, node_t *n, xcb_atom_t state, unsigned int action)
+void enter_notify(xcb_generic_event_t *evt)
{
- if (state == ewmh->_NET_WM_STATE_FULLSCREEN) {
- bool fs = n->client->fullscreen;
- if (action == XCB_EWMH_WM_STATE_TOGGLE
- || (fs && action == XCB_EWMH_WM_STATE_REMOVE)
- || (!fs && action == XCB_EWMH_WM_STATE_ADD)) {
- toggle_fullscreen(d, n);
- arrange(m, d);
- }
- } else if (state == ewmh->_NET_WM_STATE_DEMANDS_ATTENTION) {
- if (action == XCB_EWMH_WM_STATE_ADD)
- set_urgency(m, d, n, true);
- else if (action == XCB_EWMH_WM_STATE_REMOVE)
- set_urgency(m, d, n, false);
- else if (action == XCB_EWMH_WM_STATE_TOGGLE)
- set_urgency(m, d, n, !n->client->urgent);
- }
+ xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *) evt;
+ xcb_window_t win = e->event;
+
+ if (e->mode != XCB_NOTIFY_MODE_NORMAL ||
+ (mon->desk->focus != NULL &&
+ mon->desk->focus->id == win)) {
+ return;
+ }
+
+ xcb_get_window_attributes_reply_t *wa = xcb_get_window_attributes_reply(dpy, xcb_get_window_attributes(dpy, motion_recorder), NULL);
+
+ if (wa == NULL) {
+ return;
+ }
+
+ if (wa->map_state == XCB_MAP_STATE_UNMAPPED) {
+ enable_motion_recorder();
+ } else {
+ disable_motion_recorder();
+ }
}
-void grab_pointer(pointer_action_t pac)
+void motion_notify(xcb_generic_event_t *evt)
{
- PRINTF("grab pointer %u\n", pac);
-
- xcb_window_t win = XCB_NONE;
- xcb_point_t pos;
-
- query_pointer(&win, &pos);
-
- if (win == XCB_NONE)
- return;
-
- window_location_t loc;
- if (locate_window(win, &loc)) {
- client_t *c = NULL;
- frozen_pointer->position = pos;
- frozen_pointer->action = pac;
- c = loc.node->client;
- frozen_pointer->monitor = loc.monitor;
- frozen_pointer->desktop = loc.desktop;
- frozen_pointer->node = loc.node;
- frozen_pointer->client = c;
- frozen_pointer->window = c->window;
- frozen_pointer->horizontal_fence = NULL;
- frozen_pointer->vertical_fence = NULL;
-
- switch (pac) {
- case ACTION_FOCUS:
- if (loc.node != mon->desk->focus) {
- bool backup = pointer_follows_monitor;
- pointer_follows_monitor = false;
- focus_node(loc.monitor, loc.desktop, loc.node);
- pointer_follows_monitor = backup;
- }
- break;
- case ACTION_MOVE:
- case ACTION_RESIZE_SIDE:
- case ACTION_RESIZE_CORNER:
- if (is_tiled(c)) {
- frozen_pointer->rectangle = c->tiled_rectangle;
- frozen_pointer->is_tiled = true;
- } else if (is_floating(c)) {
- frozen_pointer->rectangle = c->floating_rectangle;
- frozen_pointer->is_tiled = false;
- } else {
- frozen_pointer->action = ACTION_NONE;
- return;
- }
- if (pac == ACTION_RESIZE_SIDE) {
- float W = frozen_pointer->rectangle.width;
- float H = frozen_pointer->rectangle.height;
- float ratio = W / H;
- float x = pos.x - frozen_pointer->rectangle.x;
- float y = pos.y - frozen_pointer->rectangle.y;
- float diag_a = ratio * y;
- float diag_b = W - diag_a;
- if (x < diag_a) {
- if (x < diag_b)
- frozen_pointer->side = SIDE_LEFT;
- else
- frozen_pointer->side = SIDE_BOTTOM;
- } else {
- if (x < diag_b)
- frozen_pointer->side = SIDE_TOP;
- else
- frozen_pointer->side = SIDE_RIGHT;
- }
- } else if (pac == ACTION_RESIZE_CORNER) {
- int16_t mid_x = frozen_pointer->rectangle.x + (frozen_pointer->rectangle.width / 2);
- int16_t mid_y = frozen_pointer->rectangle.y + (frozen_pointer->rectangle.height / 2);
- if (pos.x > mid_x) {
- if (pos.y > mid_y)
- frozen_pointer->corner = CORNER_BOTTOM_RIGHT;
- else
- frozen_pointer->corner = CORNER_TOP_RIGHT;
- } else {
- if (pos.y > mid_y)
- frozen_pointer->corner = CORNER_BOTTOM_LEFT;
- else
- frozen_pointer->corner = CORNER_TOP_LEFT;
- }
- }
- if (frozen_pointer->is_tiled) {
- if (pac == ACTION_RESIZE_SIDE) {
- switch (frozen_pointer->side) {
- case SIDE_TOP:
- frozen_pointer->horizontal_fence = find_fence(loc.node, DIR_UP);
- break;
- case SIDE_RIGHT:
- frozen_pointer->vertical_fence = find_fence(loc.node, DIR_RIGHT);
- break;
- case SIDE_BOTTOM:
- frozen_pointer->horizontal_fence = find_fence(loc.node, DIR_DOWN);
- break;
- case SIDE_LEFT:
- frozen_pointer->vertical_fence = find_fence(loc.node, DIR_LEFT);
- break;
- }
- } else if (pac == ACTION_RESIZE_CORNER) {
- switch (frozen_pointer->corner) {
- case CORNER_TOP_LEFT:
- frozen_pointer->horizontal_fence = find_fence(loc.node, DIR_UP);
- frozen_pointer->vertical_fence = find_fence(loc.node, DIR_LEFT);
- break;
- case CORNER_TOP_RIGHT:
- frozen_pointer->horizontal_fence = find_fence(loc.node, DIR_UP);
- frozen_pointer->vertical_fence = find_fence(loc.node, DIR_RIGHT);
- break;
- case CORNER_BOTTOM_RIGHT:
- frozen_pointer->horizontal_fence = find_fence(loc.node, DIR_DOWN);
- frozen_pointer->vertical_fence = find_fence(loc.node, DIR_RIGHT);
- break;
- case CORNER_BOTTOM_LEFT:
- frozen_pointer->horizontal_fence = find_fence(loc.node, DIR_DOWN);
- frozen_pointer->vertical_fence = find_fence(loc.node, DIR_LEFT);
- break;
- }
- }
- if (frozen_pointer->horizontal_fence != NULL)
- frozen_pointer->horizontal_ratio = frozen_pointer->horizontal_fence->split_ratio;
- if (frozen_pointer->vertical_fence != NULL)
- frozen_pointer->vertical_ratio = frozen_pointer->vertical_fence->split_ratio;
- }
- break;
- case ACTION_NONE:
- break;
- }
- } else {
- frozen_pointer->action = ACTION_NONE;
- }
+ xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t *) evt;
+
+ static uint16_t last_motion_x = 0, last_motion_y = 0;
+ static xcb_timestamp_t last_motion_time = 0;
+
+ int64_t dtime = e->time - last_motion_time;
+
+ if (dtime > 1000) {
+ last_motion_time = e->time;
+ last_motion_x = e->event_x;
+ last_motion_y = e->event_y;
+ return;
+ }
+
+ int mdist = abs(e->event_x - last_motion_x) + abs(e->event_y - last_motion_y);
+ if (mdist < 10) {
+ return;
+ }
+
+ xcb_window_t win = XCB_NONE;
+ xcb_point_t pt = {e->root_x, e->root_y};
+ query_pointer(&win, NULL);
+
+ bool pfm_backup = pointer_follows_monitor;
+ bool pff_backup = pointer_follows_focus;
+ auto_raise = false;
+ pointer_follows_monitor = false;
+ pointer_follows_focus = false;
+ coordinates_t loc;
+ if (locate_window(win, &loc)) {
+ if (loc.node != mon->desk->focus) {
+ focus_node(loc.monitor, loc.desktop, loc.node);
+ }
+ } else {
+ monitor_t *m = monitor_from_point(pt);
+ if (m != NULL && m != mon) {
+ focus_node(m, m->desk, m->desk->focus);
+ }
+ }
+ pointer_follows_monitor = pfm_backup;
+ pointer_follows_focus = pff_backup;
+ auto_raise = true;
+
+ disable_motion_recorder();
}
-void track_pointer(int root_x, int root_y)
+void handle_state(monitor_t *m, desktop_t *d, node_t *n, xcb_atom_t state, unsigned int action)
{
- if (frozen_pointer->action == ACTION_NONE)
- return;
-
- int16_t delta_x, delta_y, x, y, w, h;
- uint16_t width, height;
-
- pointer_action_t pac = frozen_pointer->action;
- monitor_t *m = frozen_pointer->monitor;
- desktop_t *d = frozen_pointer->desktop;
- node_t *n = frozen_pointer->node;
- client_t *c = frozen_pointer->client;
- xcb_window_t win = frozen_pointer->window;
- xcb_rectangle_t rect = frozen_pointer->rectangle;
- node_t *vertical_fence = frozen_pointer->vertical_fence;
- node_t *horizontal_fence = frozen_pointer->horizontal_fence;
-
- x = y = 0;
- w = h = 1;
-
- delta_x = root_x - frozen_pointer->position.x;
- delta_y = root_y - frozen_pointer->position.y;
-
- switch (pac) {
- case ACTION_MOVE:
- if (frozen_pointer->is_tiled) {
- xcb_window_t pwin = XCB_NONE;
- query_pointer(&pwin, NULL);
- if (pwin == win)
- return;
- window_location_t loc;
- bool is_managed = (pwin == XCB_NONE ? false : locate_window(pwin, &loc));
- if (is_managed && is_tiled(loc.node->client) && loc.monitor == m) {
- swap_nodes(n, loc.node);
- arrange(m, d);
- } else {
- if (is_managed && loc.monitor == m) {
- return;
- } else if (!is_managed) {
- xcb_point_t pt = (xcb_point_t) {root_x, root_y};
- monitor_t *pmon = monitor_from_point(pt);
- if (pmon == NULL || pmon == m) {
- return;
- } else {
- loc.monitor = pmon;
- loc.desktop = pmon->desk;
- }
- }
- transfer_node(m, d, loc.monitor, loc.desktop, n);
- frozen_pointer->monitor = loc.monitor;
- frozen_pointer->desktop = loc.desktop;
- }
- } else {
- x = rect.x + delta_x;
- y = rect.y + delta_y;
- window_move(win, x, y);
- }
- break;
- case ACTION_RESIZE_SIDE:
- case ACTION_RESIZE_CORNER:
- if (frozen_pointer->is_tiled) {
- if (vertical_fence != NULL) {
- double sr = frozen_pointer->vertical_ratio + (double) delta_x / vertical_fence->rectangle.width;
- sr = MAX(0, sr);
- sr = MIN(1, sr);
- vertical_fence->split_ratio = sr;
- }
- if (horizontal_fence != NULL) {
- double sr = frozen_pointer->horizontal_ratio + (double) delta_y / horizontal_fence->rectangle.height;
- sr = MAX(0, sr);
- sr = MIN(1, sr);
- horizontal_fence->split_ratio = sr;
- }
- arrange(mon, mon->desk);
- } else {
- if (pac == ACTION_RESIZE_SIDE) {
- switch (frozen_pointer->side) {
- case SIDE_TOP:
- x = rect.x;
- y = rect.y + delta_y;
- w = rect.width;
- h = rect.height - delta_y;
- break;
- case SIDE_RIGHT:
- x = rect.x;
- y = rect.y;
- w = rect.width + delta_x;
- h = rect.height;
- break;
- case SIDE_BOTTOM:
- x = rect.x;
- y = rect.y;
- w = rect.width;
- h = rect.height + delta_y;
- break;
- case SIDE_LEFT:
- x = rect.x + delta_x;
- y = rect.y;
- w = rect.width - delta_x;
- h = rect.height;
- break;
- }
- width = MAX(1, w);
- height = MAX(1, h);
- window_move_resize(win, x, y, width, height);
- c->floating_rectangle = (xcb_rectangle_t) {x, y, width, height};
- window_draw_border(n, d->focus == n, mon == m);
- } else if (pac == ACTION_RESIZE_CORNER) {
- switch (frozen_pointer->corner) {
- case CORNER_TOP_LEFT:
- x = rect.x + delta_x;
- y = rect.y + delta_y;
- w = rect.width - delta_x;
- h = rect.height - delta_y;
- break;
- case CORNER_TOP_RIGHT:
- x = rect.x;
- y = rect.y + delta_y;
- w = rect.width + delta_x;
- h = rect.height - delta_y;
- break;
- case CORNER_BOTTOM_LEFT:
- x = rect.x + delta_x;
- y = rect.y;
- w = rect.width - delta_x;
- h = rect.height + delta_y;
- break;
- case CORNER_BOTTOM_RIGHT:
- x = rect.x;
- y = rect.y;
- w = rect.width + delta_x;
- h = rect.height + delta_y;
- break;
- }
- width = MAX(1, w);
- height = MAX(1, h);
- window_move_resize(win, x, y, width, height);
- c->floating_rectangle = (xcb_rectangle_t) {x, y, width, height};
- window_draw_border(n, d->focus == n, mon == m);
- }
- }
- break;
- case ACTION_FOCUS:
- case ACTION_NONE:
- break;
- }
+ if (state == ewmh->_NET_WM_STATE_FULLSCREEN) {
+ if (action == XCB_EWMH_WM_STATE_ADD) {
+ set_state(m, d, n, STATE_FULLSCREEN);
+ } else if (action == XCB_EWMH_WM_STATE_REMOVE) {
+ if (n->client->state == STATE_FULLSCREEN) {
+ set_state(m, d, n, n->client->last_state);
+ }
+ } else if (action == XCB_EWMH_WM_STATE_TOGGLE) {
+ set_state(m, d, n, IS_FULLSCREEN(n->client) ? n->client->last_state : STATE_FULLSCREEN);
+ }
+ arrange(m, d);
+ } else if (state == ewmh->_NET_WM_STATE_BELOW) {
+ if (action == XCB_EWMH_WM_STATE_ADD) {
+ set_layer(m, d, n, LAYER_BELOW);
+ } else if (action == XCB_EWMH_WM_STATE_REMOVE) {
+ if (n->client->layer == LAYER_BELOW) {
+ set_layer(m, d, n, n->client->last_layer);
+ }
+ } else if (action == XCB_EWMH_WM_STATE_TOGGLE) {
+ set_layer(m, d, n, n->client->layer == LAYER_BELOW ? n->client->last_layer : LAYER_BELOW);
+ }
+ } else if (state == ewmh->_NET_WM_STATE_ABOVE) {
+ if (action == XCB_EWMH_WM_STATE_ADD) {
+ set_layer(m, d, n, LAYER_ABOVE);
+ } else if (action == XCB_EWMH_WM_STATE_REMOVE) {
+ if (n->client->layer == LAYER_ABOVE) {
+ set_layer(m, d, n, n->client->last_layer);
+ }
+ } else if (action == XCB_EWMH_WM_STATE_TOGGLE) {
+ set_layer(m, d, n, n->client->layer == LAYER_ABOVE ? n->client->last_layer : LAYER_ABOVE);
+ }
+ } else if (state == ewmh->_NET_WM_STATE_STICKY) {
+ if (action == XCB_EWMH_WM_STATE_ADD) {
+ set_sticky(m, d, n, true);
+ } else if (action == XCB_EWMH_WM_STATE_REMOVE) {
+ set_sticky(m, d, n, false);
+ } else if (action == XCB_EWMH_WM_STATE_TOGGLE) {
+ set_sticky(m, d, n, !n->sticky);
+ }
+ } else if (state == ewmh->_NET_WM_STATE_DEMANDS_ATTENTION) {
+ if (action == XCB_EWMH_WM_STATE_ADD) {
+ set_urgent(m, d, n, true);
+ } else if (action == XCB_EWMH_WM_STATE_REMOVE) {
+ set_urgent(m, d, n, false);
+ } else if (action == XCB_EWMH_WM_STATE_TOGGLE) {
+ set_urgent(m, d, n, !n->client->urgent);
+ }
+#define HANDLE_WM_STATE(s) \
+ } else if (state == ewmh->_NET_WM_STATE_##s) { \
+ if (action == XCB_EWMH_WM_STATE_ADD) { \
+ n->client->wm_flags |= WM_FLAG_##s; \
+ } else if (action == XCB_EWMH_WM_STATE_REMOVE) { \
+ n->client->wm_flags &= ~WM_FLAG_##s; \
+ } else if (action == XCB_EWMH_WM_STATE_TOGGLE) { \
+ n->client->wm_flags ^= WM_FLAG_##s; \
+ } \
+ ewmh_wm_state_update(n);
+ HANDLE_WM_STATE(MODAL)
+ HANDLE_WM_STATE(MAXIMIZED_VERT)
+ HANDLE_WM_STATE(MAXIMIZED_HORZ)
+ HANDLE_WM_STATE(SHADED)
+ HANDLE_WM_STATE(SKIP_TASKBAR)
+ HANDLE_WM_STATE(SKIP_PAGER)
+ HANDLE_WM_STATE(HIDDEN)
+ }
+#undef HANDLE_WM_STATE
}
-void ungrab_pointer(void)
+void process_error(xcb_generic_event_t *evt)
{
- PUTS("ungrab pointer");
-
- if (frozen_pointer->action == ACTION_NONE || frozen_pointer->is_tiled)
- return;
-
- update_floating_rectangle(frozen_pointer->client);
- monitor_t *m = underlying_monitor(frozen_pointer->client);
- if (m != NULL && m != frozen_pointer->monitor)
- transfer_node(frozen_pointer->monitor, frozen_pointer->desktop, m, m->desk, frozen_pointer->node);
+ xcb_request_error_t *e = (xcb_request_error_t *) evt;
+ warn("Failed request: %s, %s: 0x%08X.\n", xcb_event_get_request_label(e->major_opcode), xcb_event_get_error_label(e->error_code), e->bad_value);
}
projects / bspwm.git / blobdiff