-#undef I3__FILE__
-#define I3__FILE__ "handlers.c"
/*
* vim:ts=4:sw=4:expandtab
*
enter_child = true;
}
- /* If not, then the user moved their cursor to the root window. In that case, we adjust c_ws */
- if (con == NULL) {
+ /* If we cannot find the container, the user moved their cursor to the root
+ * window. In this case and if they used it to a dock, we need to focus the
+ * workspace on the correct output. */
+ if (con == NULL || con->parent->type == CT_DOCKAREA) {
DLOG("Getting screen at %d x %d\n", event->root_x, event->root_y);
check_crossing_screen_boundary(event->root_x, event->root_y);
return;
}
- if (con->parent->type == CT_DOCKAREA) {
- DLOG("Ignoring, this is a dock client\n");
- return;
- }
-
/* see if the user entered the window on a certain window decoration */
layout_t layout = (enter_child ? con->parent->layout : con->layout);
if (layout == L_DEFAULT) {
}
}
-#if 0
- if (client->workspace != c_ws && client->workspace->output == c_ws->output) {
- /* This can happen when a client gets assigned to a different workspace than
- * the current one (see src/mainx.c:reparent_window). Shortly after it was created,
- * an enter_notify will follow. */
- DLOG("enter_notify for a client on a different workspace but the same screen, ignoring\n");
- return 1;
- }
-#endif
-
if (config.disable_focus_follows_mouse)
return;
return;
}
-#if 0
-
-/*
- * Configuration notifies are only handled because we need to set up ignore for
- * the following enter notify events.
- *
- */
-int handle_configure_event(void *prophs, xcb_connection_t *conn, xcb_configure_notify_event_t *event) {
- DLOG("configure_event, sequence %d\n", event->sequence);
- /* We ignore this sequence twice because events for child and frame should be ignored */
- add_ignore_event(event->sequence);
- add_ignore_event(event->sequence);
-
- return 1;
-}
-#endif
/*
* Gets triggered upon a RandR screen change event, that is when the user
return true;
}
-#if 0
-/*
- * Updates the client’s WM_CLASS property
- *
- */
-static int handle_windowclass_change(void *data, xcb_connection_t *conn, uint8_t state,
- xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
- Con *con;
- if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
- return 1;
-
- window_update_class(con->window, prop, false);
-
- return 0;
-}
-#endif
-
/*
* Expose event means we should redraw our windows (= title bar)
*
* only tell us that the X server lost (parts of) the window contents. We
* can handle that by copying the appropriate part from our surface to the
* window. */
- draw_util_copy_surface(conn, &(parent->frame_buffer), &(parent->frame),
+ draw_util_copy_surface(&(parent->frame_buffer), &(parent->frame),
event->x, event->y, event->x, event->y,
event->width, event->height);
xcb_flush(conn);
#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10 /* move via keyboard */
#define _NET_WM_MOVERESIZE_CANCEL 11 /* cancel operation */
+#define _NET_MOVERESIZE_WINDOW_X (1 << 8)
+#define _NET_MOVERESIZE_WINDOW_Y (1 << 9)
+#define _NET_MOVERESIZE_WINDOW_WIDTH (1 << 10)
+#define _NET_MOVERESIZE_WINDOW_HEIGHT (1 << 11)
+
/*
* Handle client messages (EWMH)
*
}
Con *ws = con_get_workspace(con);
-
if (ws == NULL) {
DLOG("Window is not being managed, ignoring _NET_ACTIVE_WINDOW\n");
return;
}
- if (con_is_internal(ws)) {
- DLOG("Workspace is internal, ignoring _NET_ACTIVE_WINDOW\n");
+ if (con_is_internal(ws) && ws != workspace_get("__i3_scratch", NULL)) {
+ DLOG("Workspace is internal but not scratchpad, ignoring _NET_ACTIVE_WINDOW\n");
return;
}
/* Always focus the con if it is from a pager, because this is most
* likely from some user action */
DLOG("This request came from a pager. Focusing con = %p\n", con);
- workspace_show(ws);
- con_focus(con);
+
+ if (con_is_internal(ws)) {
+ scratchpad_show(con);
+ } else {
+ workspace_show(ws);
+ con_focus(con);
+ }
} else {
/* Request is from an application. */
+ if (con_is_internal(ws)) {
+ DLOG("Ignoring request to make con = %p active because it's on an internal workspace.\n", con);
+ return;
+ }
if (config.focus_on_window_activation == FOWA_FOCUS || (config.focus_on_window_activation == FOWA_SMART && workspace_is_visible(ws))) {
DLOG("Focusing con = %p\n", con);
DLOG("_NET_WM_MOVERESIZE direction %d not implemented\n", direction);
break;
}
+ } else if (event->type == A__NET_MOVERESIZE_WINDOW) {
+ DLOG("Received _NET_MOVE_RESIZE_WINDOW. Handling by faking a configure request.\n");
+
+ void *_generated_event = scalloc(32, 1);
+ xcb_configure_request_event_t *generated_event = _generated_event;
+
+ generated_event->window = event->window;
+ generated_event->response_type = XCB_CONFIGURE_REQUEST;
+
+ generated_event->value_mask = 0;
+ if (event->data.data32[0] & _NET_MOVERESIZE_WINDOW_X) {
+ generated_event->value_mask |= XCB_CONFIG_WINDOW_X;
+ generated_event->x = event->data.data32[1];
+ }
+ if (event->data.data32[0] & _NET_MOVERESIZE_WINDOW_Y) {
+ generated_event->value_mask |= XCB_CONFIG_WINDOW_Y;
+ generated_event->y = event->data.data32[2];
+ }
+ if (event->data.data32[0] & _NET_MOVERESIZE_WINDOW_WIDTH) {
+ generated_event->value_mask |= XCB_CONFIG_WINDOW_WIDTH;
+ generated_event->width = event->data.data32[3];
+ }
+ if (event->data.data32[0] & _NET_MOVERESIZE_WINDOW_HEIGHT) {
+ generated_event->value_mask |= XCB_CONFIG_WINDOW_HEIGHT;
+ generated_event->height = event->data.data32[4];
+ }
+
+ handle_configure_request(generated_event);
+ FREE(generated_event);
} else {
DLOG("Skipping client message for unhandled type %d\n", event->type);
}
xcb_size_hints_t size_hints;
- //CLIENT_LOG(client);
-
/* If the hints were already in this event, use them, if not, request them */
- if (reply != NULL)
+ if (reply != NULL) {
xcb_icccm_get_wm_size_hints_from_reply(&size_hints, reply);
- else
+ } else {
xcb_icccm_get_wm_normal_hints_reply(conn, xcb_icccm_get_wm_normal_hints_unchecked(conn, con->window->id), &size_hints, NULL);
+ }
+
+ int win_width = con->window_rect.width;
+ int win_height = con->window_rect.height;
if ((size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)) {
- // TODO: Minimum size is not yet implemented
DLOG("Minimum size: %d (width) x %d (height)\n", size_hints.min_width, size_hints.min_height);
+
+ con->window->min_width = size_hints.min_width;
+ con->window->min_height = size_hints.min_height;
+ }
+
+ if (con_is_floating(con)) {
+ win_width = MAX(win_width, con->window->min_width);
+ win_height = MAX(win_height, con->window->min_height);
}
bool changed = false;
if ((size_hints.flags & XCB_ICCCM_SIZE_HINT_P_RESIZE_INC)) {
- if (size_hints.width_inc > 0 && size_hints.width_inc < 0xFFFF)
+ if (size_hints.width_inc > 0 && size_hints.width_inc < 0xFFFF) {
if (con->window->width_increment != size_hints.width_inc) {
con->window->width_increment = size_hints.width_inc;
changed = true;
}
- if (size_hints.height_inc > 0 && size_hints.height_inc < 0xFFFF)
+ }
+
+ if (size_hints.height_inc > 0 && size_hints.height_inc < 0xFFFF) {
if (con->window->height_increment != size_hints.height_inc) {
con->window->height_increment = size_hints.height_inc;
changed = true;
}
+ }
- if (changed)
+ if (changed) {
DLOG("resize increments changed\n");
+ }
}
- int base_width = 0, base_height = 0;
+ bool has_base_size = false;
+ int base_width = 0;
+ int base_height = 0;
- /* base_width/height are the desired size of the window.
- We check if either the program-specified size or the program-specified
- min-size is available */
+ /* The base width / height is the desired size of the window. */
if (size_hints.flags & XCB_ICCCM_SIZE_HINT_BASE_SIZE) {
base_width = size_hints.base_width;
base_height = size_hints.base_height;
- } else if (size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE) {
- /* TODO: is this right? icccm says not */
+ has_base_size = true;
+ }
+
+ /* If the window didn't specify a base size, the ICCCM tells us to fall
+ * back to the minimum size instead, if available. */
+ if (!has_base_size && size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE) {
base_width = size_hints.min_width;
base_height = size_hints.min_height;
}
- if (base_width != con->window->base_width ||
- base_height != con->window->base_height) {
+ // TODO XXX Should we only do this is the base size is > 0?
+ if (base_width != con->window->base_width || base_height != con->window->base_height) {
con->window->base_width = base_width;
con->window->base_height = base_height;
+
DLOG("client's base_height changed to %d\n", base_height);
DLOG("client's base_width changed to %d\n", base_width);
changed = true;
goto render_and_return;
}
- /* XXX: do we really use rect here, not window_rect? */
- double width = con->rect.width - base_width;
- double height = con->rect.height - base_height;
+ /* The ICCCM says to subtract the base size from the window size for aspect
+ * ratio calculations. However, unlike determining the base size itself we
+ * must not fall back to using the minimum size in this case according to
+ * the ICCCM. */
+ double width = win_width - base_width * has_base_size;
+ double height = win_height - base_height * has_base_size;
+
/* Convert numerator/denominator to a double */
double min_aspect = (double)size_hints.min_aspect_num / size_hints.min_aspect_den;
double max_aspect = (double)size_hints.max_aspect_num / size_hints.min_aspect_den;
DLOG("width = %f, height = %f\n", width, height);
/* Sanity checks, this is user-input, in a way */
- if (max_aspect <= 0 || min_aspect <= 0 || height == 0 || (width / height) <= 0)
+ if (max_aspect <= 0 || min_aspect <= 0 || height == 0 || (width / height) <= 0) {
goto render_and_return;
+ }
/* Check if we need to set proportional_* variables using the correct ratio */
double aspect_ratio = 0.0;
aspect_ratio = min_aspect;
} else if ((width / height) > max_aspect) {
aspect_ratio = max_aspect;
- } else
+ } else {
goto render_and_return;
+ }
if (fabs(con->window->aspect_ratio - aspect_ratio) > DBL_EPSILON) {
con->window->aspect_ratio = aspect_ratio;
}
render_and_return:
- if (changed)
+ if (changed) {
tree_render();
+ }
+
FREE(reply);
return true;
}
return;
}
+/*
+ * Handles ConfigureNotify events for the root window, which are generated when
+ * the monitor configuration changed.
+ *
+ */
+static void handle_configure_notify(xcb_configure_notify_event_t *event) {
+ if (event->event != root) {
+ DLOG("ConfigureNotify for non-root window 0x%08x, ignoring\n", event->event);
+ return;
+ }
+ DLOG("ConfigureNotify for root window 0x%08x\n", event->event);
+
+ randr_query_outputs();
+}
+
/*
* Handles the WM_CLASS property for assignments and criteria selection.
*
return true;
}
+/*
+ * Handles the _MOTIF_WM_HINTS property of specifing window deocration settings.
+ *
+ */
+static bool handle_motif_hints_change(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
+ xcb_atom_t name, xcb_get_property_reply_t *prop) {
+ Con *con;
+ if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
+ return false;
+
+ if (prop == NULL) {
+ prop = xcb_get_property_reply(conn, xcb_get_property_unchecked(conn,
+ false, window, A__MOTIF_WM_HINTS, XCB_GET_PROPERTY_TYPE_ANY, 0, 5 * sizeof(uint64_t)),
+ NULL);
+
+ if (prop == NULL)
+ return false;
+ }
+
+ border_style_t motif_border_style;
+ window_update_motif_hints(con->window, prop, &motif_border_style);
+
+ if (motif_border_style != con->border_style && motif_border_style != BS_NORMAL) {
+ DLOG("Update border style of con %p to %d\n", con, motif_border_style);
+ con_set_border_style(con, motif_border_style, con->current_border_width);
+
+ x_push_changes(croot);
+ }
+
+ return true;
+}
+
/*
* Handles the _NET_WM_STRUT_PARTIAL property for allocating space for dock clients.
*
{0, 128, handle_windowrole_change},
{0, 128, handle_class_change},
{0, UINT_MAX, handle_strut_partial_change},
- {0, UINT_MAX, handle_window_type}};
+ {0, UINT_MAX, handle_window_type},
+ {0, 5 * sizeof(uint64_t), handle_motif_hints_change}};
#define NUM_HANDLERS (sizeof(property_handlers) / sizeof(struct property_handler_t))
/*
property_handlers[7].atom = XCB_ATOM_WM_CLASS;
property_handlers[8].atom = A__NET_WM_STRUT_PARTIAL;
property_handlers[9].atom = A__NET_WM_WINDOW_TYPE;
+ property_handlers[10].atom = A__MOTIF_WM_HINTS;
}
static void property_notify(uint8_t state, xcb_window_t window, xcb_atom_t atom) {
break;
case XCB_EXPOSE:
- handle_expose_event((xcb_expose_event_t *)event);
+ if (((xcb_expose_event_t *)event)->count == 0) {
+ handle_expose_event((xcb_expose_event_t *)event);
+ }
+
break;
case XCB_MOTION_NOTIFY:
break;
}
+ case XCB_CONFIGURE_NOTIFY:
+ handle_configure_notify((xcb_configure_notify_event_t *)event);
+ break;
+
default:
//DLOG("Unhandled event of type %d\n", type);
break;
projects / i3 / i3 / blobdiff