/*
- * vim:ts=8:expandtab
+ * vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- *
- * © 2009-2010 Michael Stapelberg and contributors
- *
- * See file LICENSE for license information.
+ * © 2009-2010 Michael Stapelberg and contributors (see also: LICENSE)
*
*/
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-#include <stdlib.h>
#include <time.h>
-#include <xcb/xcb.h>
#include <xcb/xcb_atom.h>
-#include <xcb/xcb_icccm.h>
#include <xcb/randr.h>
#include <X11/XKBlib.h>
-#include "i3.h"
-#include "debug.h"
-#include "table.h"
-#include "layout.h"
-#include "commands.h"
-#include "data.h"
-#include "xcb.h"
-#include "util.h"
-#include "randr.h"
-#include "config.h"
-#include "queue.h"
-#include "resize.h"
-#include "client.h"
-#include "manage.h"
-#include "floating.h"
-#include "workspace.h"
-#include "log.h"
-#include "container.h"
+#include "all.h"
/* After mapping/unmapping windows, a notify event is generated. However, we don’t want it,
since it’d trigger an infinite loop of switching between the different windows when
return false;
}
-/*
- * Due to bindings like Mode_switch + <a>, we need to bind some keys in XCB_GRAB_MODE_SYNC.
- * Therefore, we just replay all key presses.
- *
- */
-int handle_key_release(void *ignored, xcb_connection_t *conn, xcb_key_release_event_t *event) {
- xcb_allow_events(conn, XCB_ALLOW_REPLAY_KEYBOARD, event->time);
- xcb_flush(conn);
- return 1;
-}
-
/*
* There was a key press. We compare this key code with our bindings table and pass
* the bound action to parse_command().
*
*/
int handle_key_press(void *ignored, xcb_connection_t *conn, xcb_key_press_event_t *event) {
- DLOG("Keypress %d, state raw = %d\n", event->detail, event->state);
-
- /* Remove the numlock bit, all other bits are modifiers we can bind to */
- uint16_t state_filtered = event->state & ~(xcb_numlock_mask | XCB_MOD_MASK_LOCK);
- DLOG("(removed numlock, state = %d)\n", state_filtered);
- /* Only use the lower 8 bits of the state (modifier masks) so that mouse
- * button masks are filtered out */
- state_filtered &= 0xFF;
- DLOG("(removed upper 8 bits, state = %d)\n", state_filtered);
-
- if (xkb_supported) {
- /* We need to get the keysym group (There are group 1 to group 4, each holding
- two keysyms (without shift and with shift) using Xkb because X fails to
- provide them reliably (it works in Xephyr, it does not in real X) */
- XkbStateRec state;
- if (XkbGetState(xkbdpy, XkbUseCoreKbd, &state) == Success && (state.group+1) == 2)
- state_filtered |= BIND_MODE_SWITCH;
- }
-
- DLOG("(checked mode_switch, state %d)\n", state_filtered);
-
- /* Find the binding */
- Binding *bind;
- TAILQ_FOREACH(bind, bindings, bindings) {
- /* First compare the modifiers */
- if (bind->mods != state_filtered)
- continue;
-
- /* If a symbol was specified by the user, we need to look in
- * the array of translated keycodes for the event’s keycode */
- if (bind->symbol != NULL) {
- if (memmem(bind->translated_to,
- bind->number_keycodes * sizeof(xcb_keycode_t),
- &(event->detail), sizeof(xcb_keycode_t)) != NULL)
- break;
- } else {
- /* This case is easier: The user specified a keycode */
- if (bind->keycode == event->detail)
- break;
- }
- }
-
- /* No match? Then it was an actively grabbed key, that is with Mode_switch, and
- the user did not press Mode_switch, so just pass it… */
- if (bind == TAILQ_END(bindings)) {
- xcb_allow_events(conn, ReplayKeyboard, event->time);
- xcb_flush(conn);
- return 1;
- }
-
- parse_command(conn, bind->command);
- if (state_filtered & BIND_MODE_SWITCH) {
- DLOG("Mode_switch -> allow_events(SyncKeyboard)\n");
- xcb_allow_events(conn, SyncKeyboard, event->time);
- xcb_flush(conn);
- }
- return 1;
+ DLOG("Keypress %d, state raw = %d\n", event->detail, event->state);
+
+ /* Remove the numlock bit, all other bits are modifiers we can bind to */
+ uint16_t state_filtered = event->state & ~(xcb_numlock_mask | XCB_MOD_MASK_LOCK);
+ DLOG("(removed numlock, state = %d)\n", state_filtered);
+ /* Only use the lower 8 bits of the state (modifier masks) so that mouse
+ * button masks are filtered out */
+ state_filtered &= 0xFF;
+ DLOG("(removed upper 8 bits, state = %d)\n", state_filtered);
+
+ if (xkb_current_group == XkbGroup2Index)
+ state_filtered |= BIND_MODE_SWITCH;
+
+ DLOG("(checked mode_switch, state %d)\n", state_filtered);
+
+ /* Find the binding */
+ Binding *bind = get_binding(state_filtered, event->detail);
+
+ /* No match? Then the user has Mode_switch enabled but does not have a
+ * specific keybinding. Fall back to the default keybindings (without
+ * Mode_switch). Makes it much more convenient for users of a hybrid
+ * layout (like us, ru). */
+ if (bind == NULL) {
+ state_filtered &= ~(BIND_MODE_SWITCH);
+ DLOG("no match, new state_filtered = %d\n", state_filtered);
+ if ((bind = get_binding(state_filtered, event->detail)) == NULL) {
+ ELOG("Could not lookup key binding (modifiers %d, keycode %d)\n",
+ state_filtered, event->detail);
+ return 1;
+ }
+ }
+
+ parse_command(bind->command);
+ return 1;
}
+#if 0
+
/*
* Called with coordinates of an enter_notify event or motion_notify event
* to check if the user crossed virtual screen boundaries and adjust the
static void check_crossing_screen_boundary(uint32_t x, uint32_t y) {
Output *output;
- if ((output = get_screen_containing(x, y)) == NULL) {
+ if ((output = get_output_containing(x, y)) == NULL) {
ELOG("ERROR: No such screen\n");
return;
}
xcb_get_numlock_mask(conn);
ungrab_all_keys(conn);
- grab_all_keys(conn);
+ translate_keysyms();
+ grab_all_keys(conn, false);
return 0;
}
if (client_is_floating(client)) {
i3Font *font = load_font(conn, config.font);
int mode = (client->container != NULL ? client->container->mode : MODE_DEFAULT);
+ /* TODO: refactor this code. we need a function to translate
+ * coordinates of child_rect/rect. */
- if (event->value_mask & XCB_CONFIG_WINDOW_X)
- client->rect.x = event->x;
- if (event->value_mask & XCB_CONFIG_WINDOW_Y)
- client->rect.y = event->y;
+ if (event->value_mask & XCB_CONFIG_WINDOW_X) {
+ if (mode == MODE_STACK || mode == MODE_TABBED) {
+ client->rect.x = event->x - 2;
+ } else {
+ if (client->titlebar_position == TITLEBAR_OFF && client->borderless)
+ client->rect.x = event->x;
+ else if (client->titlebar_position == TITLEBAR_OFF && !client->borderless)
+ client->rect.x = event->x - 1;
+ else client->rect.x = event->x - 2;
+ }
+ }
+ if (event->value_mask & XCB_CONFIG_WINDOW_Y) {
+ if (mode == MODE_STACK || mode == MODE_TABBED) {
+ client->rect.y = event->y - 2;
+ } else {
+ if (client->titlebar_position == TITLEBAR_OFF && client->borderless)
+ client->rect.y = event->y;
+ else if (client->titlebar_position == TITLEBAR_OFF && !client->borderless)
+ client->rect.y = event->y - 1;
+ else client->rect.y = event->y - font->height - 2 - 2;
+ }
+ }
if (event->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
if (mode == MODE_STACK || mode == MODE_TABBED) {
client->rect.width = event->width + 2 + 2;
xcb_generic_event_t *e) {
DLOG("RandR screen change\n");
- randr_query_screens(conn);
+ randr_query_outputs(conn);
+
+ ipc_send_event("output", I3_IPC_EVENT_OUTPUT, "{\"change\":\"unspecified\"}");
return 1;
}
/* Let’s see how many clients there are left on the workspace to delete it if it’s empty */
bool workspace_empty = SLIST_EMPTY(&(client->workspace->focus_stack));
- bool workspace_active = false;
+ bool workspace_focused = (c_ws == client->workspace);
Client *to_focus = (!workspace_empty ? SLIST_FIRST(&(client->workspace->focus_stack)) : NULL);
- /* If this workspace is currently active, we don’t delete it */
- Output *screen;
- TAILQ_FOREACH(screen, &outputs, outputs)
- if (screen->current_workspace == client->workspace) {
- workspace_active = true;
- workspace_empty = false;
- break;
- }
+ /* If this workspace is currently visible, we don’t delete it */
+ if (workspace_is_visible(client->workspace))
+ workspace_empty = false;
- if (workspace_empty)
+ if (workspace_empty) {
client->workspace->output = NULL;
+ ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"empty\"}");
+ }
/* Remove the urgency flag if set */
client->urgent = false;
* the screen itself (if we do not focus the screen, it can happen that
* the focus is "nowhere" and thus keypress events will not be received
* by i3, thus the user cannot use any hotkeys). */
- if (workspace_active) {
+ if (workspace_focused) {
if (to_focus != NULL)
set_focus(conn, to_focus, true);
else {
return 1;
}
+/*
+ * A destroy notify event is sent when the window is not unmapped, but
+ * immediately destroyed (for example when starting a window and immediately
+ * killing the program which started it).
+ *
+ * We just pass on the event to the unmap notify handler (by copying the
+ * important fields in the event data structure).
+ *
+ */
+int handle_destroy_notify_event(void *data, xcb_connection_t *conn, xcb_destroy_notify_event_t *event) {
+ DLOG("destroy notify for 0x%08x, 0x%08x\n", event->event, event->window);
+
+ xcb_unmap_notify_event_t unmap;
+ unmap.sequence = event->sequence;
+ unmap.event = event->event;
+ unmap.window = event->window;
+
+ return handle_unmap_notify_event(NULL, conn, &unmap);
+}
+#endif
/*
* Called when a window changes its title
*
*/
int handle_windowname_change(void *data, xcb_connection_t *conn, uint8_t state,
xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop) {
- if (prop == NULL || xcb_get_property_value_length(prop) == 0) {
- DLOG("_NET_WM_NAME not specified, not changing\n");
- return 1;
- }
- Client *client = table_get(&by_child, window);
- if (client == NULL)
- return 1;
-
- /* Save the old pointer to make the update atomic */
- char *new_name;
- int new_len;
- asprintf(&new_name, "%.*s", xcb_get_property_value_length(prop), (char*)xcb_get_property_value(prop));
- /* Convert it to UCS-2 here for not having to convert it later every time we want to pass it to X */
- char *ucs2_name = convert_utf8_to_ucs2(new_name, &new_len);
- LOG("_NET_WM_NAME changed to \"%s\"\n", new_name);
- free(new_name);
-
- /* Check if they are the same and don’t update if so.
- Note the use of new_len * 2 to check all bytes as each glyph takes 2 bytes.
- Also note the use of memcmp() instead of strncmp() because the latter stops on nullbytes,
- but UCS-2 uses nullbytes to fill up glyphs which only use one byte. */
- if ((new_len == client->name_len) &&
- (client->name != NULL) &&
- (memcmp(client->name, ucs2_name, new_len * 2) == 0)) {
- free(ucs2_name);
- return 1;
- }
-
- char *old_name = client->name;
- client->name = ucs2_name;
- client->name_len = new_len;
- client->uses_net_wm_name = true;
-
- FREE(old_name);
+ Con *con;
+ if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
+ return 1;
- /* If the client is a dock window, we don’t need to render anything */
- if (client->dock)
- return 1;
+ window_update_name(con->window, prop);
- int mode = container_mode(client->container, true);
- if (mode == MODE_STACK || mode == MODE_TABBED)
- render_container(conn, client->container);
- else decorate_window(conn, client, client->frame, client->titlegc, 0, 0);
- xcb_flush(conn);
+ x_push_changes(croot);
- return 1;
+ return 1;
}
-
+#if 0
/*
* We handle legacy window names (titles) which are in COMPOUND_TEXT encoding. However, we
* just pass them along, so when containing non-ASCII characters, those will be rendering
return 1;
}
+#endif
/*
* Updates the client’s WM_CLASS property
*/
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) {
- if (prop == NULL || xcb_get_property_value_length(prop) == 0) {
- DLOG("prop == NULL\n");
- return 1;
- }
- Client *client = table_get(&by_child, window);
- if (client == NULL)
- return 1;
-
- /* We cannot use asprintf here since this property contains two
- * null-terminated strings (for compatibility reasons). Instead, we
- * use strdup() on both strings */
- char *new_class = xcb_get_property_value(prop);
-
- FREE(client->window_class_instance);
- FREE(client->window_class_class);
+ Con *con;
+ if ((con = con_by_window_id(window)) == NULL || con->window == NULL)
+ return 1;
- client->window_class_instance = strdup(new_class);
- if ((strlen(new_class) + 1) < xcb_get_property_value_length(prop))
- client->window_class_class = strdup(new_class + strlen(new_class) + 1);
- else client->window_class_class = NULL;
- LOG("WM_CLASS changed to %s (instance), %s (class)\n",
- client->window_class_instance, client->window_class_class);
+ window_update_class(con->window, prop);
- return 0;
+ return 0;
}
+#if 0
/*
* Expose event means we should redraw our windows (= title bar)
*
return 1;
xcb_window_t *leader = xcb_get_property_value(prop);
- if (leader == NULL || *leader == 0)
+ if (leader == NULL)
return 1;
DLOG("Client leader changed to %08x\n", *leader);
return 1;
}
+#endif
projects / i3 / i3 / blobdiff