486 lines
19 KiB
C
486 lines
19 KiB
C
/*
|
||
* vim:ts=8:expandtab
|
||
*
|
||
* i3 - an improved dynamic tiling window manager
|
||
*
|
||
* © 2009 Michael Stapelberg and contributors
|
||
*
|
||
* See file LICENSE for license information.
|
||
*
|
||
*/
|
||
#include <stdio.h>
|
||
#include <assert.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/types.h>
|
||
#include <unistd.h>
|
||
#include <stdbool.h>
|
||
#include <assert.h>
|
||
#include <limits.h>
|
||
|
||
#include <X11/XKBlib.h>
|
||
#include <X11/extensions/XKB.h>
|
||
|
||
#include <xcb/xcb.h>
|
||
#include <xcb/xcb_wm.h>
|
||
#include <xcb/xcb_aux.h>
|
||
#include <xcb/xcb_event.h>
|
||
#include <xcb/xcb_property.h>
|
||
#include <xcb/xcb_keysyms.h>
|
||
#include <xcb/xcb_icccm.h>
|
||
#include <xcb/xinerama.h>
|
||
|
||
#include "config.h"
|
||
#include "data.h"
|
||
#include "debug.h"
|
||
#include "handlers.h"
|
||
#include "i3.h"
|
||
#include "layout.h"
|
||
#include "queue.h"
|
||
#include "table.h"
|
||
#include "util.h"
|
||
#include "xcb.h"
|
||
#include "xinerama.h"
|
||
|
||
/* This is the path to i3, copied from argv[0] when starting up */
|
||
char *application_path;
|
||
|
||
/* This is our connection to X11 for use with XKB */
|
||
Display *xkbdpy;
|
||
|
||
/* The list of key bindings */
|
||
struct bindings_head bindings = TAILQ_HEAD_INITIALIZER(bindings);
|
||
|
||
/* This is a list of Stack_Windows, global, for easier/faster access on expose events */
|
||
struct stack_wins_head stack_wins = SLIST_HEAD_INITIALIZER(stack_wins);
|
||
|
||
/* The event handlers need to be global because they are accessed by our custom event handler
|
||
in handle_button_press(), needed for graphical resizing */
|
||
xcb_event_handlers_t evenths;
|
||
xcb_atom_t atoms[NUM_ATOMS];
|
||
|
||
int num_screens = 0;
|
||
|
||
/*
|
||
* Do some sanity checks and then reparent the window.
|
||
*
|
||
*/
|
||
void manage_window(xcb_property_handlers_t *prophs, xcb_connection_t *conn, xcb_window_t window, window_attributes_t wa) {
|
||
printf("managing window.\n");
|
||
xcb_drawable_t d = { window };
|
||
xcb_get_geometry_cookie_t geomc;
|
||
xcb_get_geometry_reply_t *geom;
|
||
xcb_get_window_attributes_reply_t *attr = 0;
|
||
|
||
if (wa.tag == TAG_COOKIE) {
|
||
/* Check if the window is mapped (it could be not mapped when intializing and
|
||
calling manage_window() for every window) */
|
||
if ((attr = xcb_get_window_attributes_reply(conn, wa.u.cookie, 0)) == NULL)
|
||
return;
|
||
|
||
if (attr->map_state != XCB_MAP_STATE_VIEWABLE)
|
||
goto out;
|
||
|
||
wa.tag = TAG_VALUE;
|
||
wa.u.override_redirect = attr->override_redirect;
|
||
}
|
||
|
||
/* Don’t manage clients with the override_redirect flag */
|
||
if (wa.u.override_redirect)
|
||
goto out;
|
||
|
||
/* Check if the window is already managed */
|
||
if (table_get(byChild, window))
|
||
goto out;
|
||
|
||
/* Get the initial geometry (position, size, …) */
|
||
geomc = xcb_get_geometry(conn, d);
|
||
if (!attr) {
|
||
wa.tag = TAG_COOKIE;
|
||
wa.u.cookie = xcb_get_window_attributes(conn, window);
|
||
attr = xcb_get_window_attributes_reply(conn, wa.u.cookie, 0);
|
||
}
|
||
geom = xcb_get_geometry_reply(conn, geomc, 0);
|
||
if (attr && geom) {
|
||
reparent_window(conn, window, attr->visual, geom->root, geom->depth,
|
||
geom->x, geom->y, geom->width, geom->height);
|
||
xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, WM_NAME);
|
||
}
|
||
|
||
free(geom);
|
||
out:
|
||
free(attr);
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* reparent_window() gets called when a new window was opened and becomes a child of the root
|
||
* window, or it gets called by us when we manage the already existing windows at startup.
|
||
*
|
||
* Essentially, this is the point where we take over control.
|
||
*
|
||
*/
|
||
void reparent_window(xcb_connection_t *conn, xcb_window_t child,
|
||
xcb_visualid_t visual, xcb_window_t root, uint8_t depth,
|
||
int16_t x, int16_t y, uint16_t width, uint16_t height) {
|
||
|
||
xcb_get_property_cookie_t wm_type_cookie, strut_cookie;
|
||
|
||
/* Place requests for properties ASAP */
|
||
wm_type_cookie = xcb_get_any_property_unchecked(conn, false, child, atoms[_NET_WM_WINDOW_TYPE], UINT32_MAX);
|
||
strut_cookie = xcb_get_any_property_unchecked(conn, false, child, atoms[_NET_WM_STRUT_PARTIAL], UINT32_MAX);
|
||
|
||
Client *new = table_get(byChild, child);
|
||
|
||
/* Events for already managed windows should already be filtered in manage_window() */
|
||
assert(new == NULL);
|
||
|
||
printf("reparenting new client\n");
|
||
new = calloc(sizeof(Client), 1);
|
||
new->force_reconfigure = true;
|
||
uint32_t mask = 0;
|
||
uint32_t values[3];
|
||
|
||
/* Update the data structures */
|
||
Client *old_focused = CUR_CELL->currently_focused;
|
||
CUR_CELL->currently_focused = new;
|
||
new->container = CUR_CELL;
|
||
|
||
new->frame = xcb_generate_id(conn);
|
||
new->child = child;
|
||
new->rect.width = width;
|
||
new->rect.height = height;
|
||
|
||
/* Don’t generate events for our new window, it should *not* be managed */
|
||
mask |= XCB_CW_OVERRIDE_REDIRECT;
|
||
values[0] = 1;
|
||
|
||
/* We want to know when… */
|
||
mask |= XCB_CW_EVENT_MASK;
|
||
values[1] = XCB_EVENT_MASK_BUTTON_PRESS | /* …mouse is pressed/released */
|
||
XCB_EVENT_MASK_BUTTON_RELEASE |
|
||
XCB_EVENT_MASK_EXPOSURE | /* …our window needs to be redrawn */
|
||
XCB_EVENT_MASK_ENTER_WINDOW; /* …user moves cursor inside our window */
|
||
|
||
printf("Reparenting 0x%08x under 0x%08x.\n", child, new->frame);
|
||
|
||
i3Font *font = load_font(conn, config.font);
|
||
width = min(width, c_ws->rect.x + c_ws->rect.width);
|
||
height = min(height, c_ws->rect.y + c_ws->rect.height);
|
||
|
||
Rect framerect = {x, y,
|
||
width + 2 + 2, /* 2 px border at each side */
|
||
height + 2 + 2 + font->height}; /* 2 px border plus font’s height */
|
||
|
||
/* Yo dawg, I heard you like windows, so I create a window around your window… */
|
||
new->frame = create_window(conn, framerect, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_CURSOR_LEFT_PTR, mask, values);
|
||
|
||
/* Put the client inside the save set. Upon termination (whether killed or normal exit
|
||
does not matter) of the window manager, these clients will be correctly reparented
|
||
to their most closest living ancestor (= cleanup) */
|
||
xcb_change_save_set(conn, XCB_SET_MODE_INSERT, child);
|
||
|
||
/* Generate a graphics context for the titlebar */
|
||
new->titlegc = xcb_generate_id(conn);
|
||
xcb_create_gc(conn, new->titlegc, new->frame, 0, 0);
|
||
|
||
/* Put our data structure (Client) into the table */
|
||
table_put(byParent, new->frame, new);
|
||
table_put(byChild, child, new);
|
||
|
||
/* Moves the original window into the new frame we've created for it */
|
||
new->awaiting_useless_unmap = true;
|
||
xcb_void_cookie_t cookie = xcb_reparent_window_checked(conn, child, new->frame, 0, font->height);
|
||
check_error(conn, cookie, "Could not reparent window");
|
||
|
||
/* We are interested in property changes */
|
||
mask = XCB_CW_EVENT_MASK;
|
||
values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE |
|
||
XCB_EVENT_MASK_STRUCTURE_NOTIFY |
|
||
XCB_EVENT_MASK_ENTER_WINDOW;
|
||
cookie = xcb_change_window_attributes_checked(conn, child, mask, values);
|
||
check_error(conn, cookie, "Could not change window attributes");
|
||
|
||
/* We need to grab the mouse buttons for click to focus */
|
||
xcb_grab_button(conn, false, child, XCB_EVENT_MASK_BUTTON_PRESS,
|
||
XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, root, XCB_NONE,
|
||
1 /* left mouse button */,
|
||
XCB_BUTTON_MASK_ANY /* don’t filter for any modifiers */);
|
||
|
||
/* Focus the new window */
|
||
xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, new->child, XCB_CURRENT_TIME);
|
||
|
||
/* Get _NET_WM_WINDOW_TYPE (to see if it’s a dock) */
|
||
xcb_atom_t *atom;
|
||
xcb_get_property_reply_t *preply = xcb_get_property_reply(conn, wm_type_cookie, NULL);
|
||
if (preply != NULL && preply->value_len > 0 && (atom = xcb_get_property_value(preply))) {
|
||
for (int i = 0; i < xcb_get_property_value_length(preply); i++)
|
||
if (atom[i] == atoms[_NET_WM_WINDOW_TYPE_DOCK]) {
|
||
printf("Window is a dock.\n");
|
||
new->dock = true;
|
||
new->titlebar_position = TITLEBAR_OFF;
|
||
new->force_reconfigure = true;
|
||
new->container = NULL;
|
||
SLIST_INSERT_HEAD(&(c_ws->dock_clients), new, dock_clients);
|
||
}
|
||
}
|
||
|
||
/* Get _NET_WM_STRUT_PARTIAL to determine the client’s requested height */
|
||
uint32_t *strut;
|
||
preply = xcb_get_property_reply(conn, strut_cookie, NULL);
|
||
if (preply != NULL && preply->value_len > 0 && (strut = xcb_get_property_value(preply))) {
|
||
/* We only use a subset of the provided values, namely the reserved space at the top/bottom
|
||
of the screen. This is because the only possibility for bars is at to be at the top/bottom
|
||
with maximum horizontal size.
|
||
TODO: bars at the top */
|
||
new->desired_height = strut[3];
|
||
printf("the client wants to be %d pixels height\n", new->desired_height);
|
||
}
|
||
|
||
/* Insert into the currently active container, if it’s not a dock window */
|
||
if (!new->dock) {
|
||
/* Insert after the old active client, if existing. If it does not exist, the
|
||
container is empty and it does not matter, where we insert it */
|
||
if (old_focused != NULL)
|
||
CIRCLEQ_INSERT_AFTER(&(CUR_CELL->clients), old_focused, new, clients);
|
||
else CIRCLEQ_INSERT_TAIL(&(CUR_CELL->clients), new, clients);
|
||
}
|
||
|
||
render_layout(conn);
|
||
}
|
||
|
||
/*
|
||
* Go through all existing windows (if the window manager is restarted) and manage them
|
||
*
|
||
*/
|
||
void manage_existing_windows(xcb_connection_t *conn, xcb_property_handlers_t *prophs, xcb_window_t root) {
|
||
xcb_query_tree_reply_t *reply;
|
||
int i, len;
|
||
xcb_window_t *children;
|
||
xcb_get_window_attributes_cookie_t *cookies;
|
||
|
||
/* Get the tree of windows whose parent is the root window (= all) */
|
||
if ((reply = xcb_query_tree_reply(conn, xcb_query_tree(conn, root), 0)) == NULL)
|
||
return;
|
||
|
||
len = xcb_query_tree_children_length(reply);
|
||
cookies = smalloc(len * sizeof(*cookies));
|
||
|
||
/* Request the window attributes for every window */
|
||
children = xcb_query_tree_children(reply);
|
||
for(i = 0; i < len; ++i)
|
||
cookies[i] = xcb_get_window_attributes(conn, children[i]);
|
||
|
||
/* Call manage_window with the attributes for every window */
|
||
for(i = 0; i < len; ++i) {
|
||
window_attributes_t wa = { TAG_COOKIE, { cookies[i] } };
|
||
manage_window(prophs, conn, children[i], wa);
|
||
}
|
||
|
||
free(reply);
|
||
}
|
||
|
||
int main(int argc, char *argv[], char *env[]) {
|
||
int i, screens, opt;
|
||
char *override_configpath = NULL;
|
||
xcb_connection_t *conn;
|
||
xcb_property_handlers_t prophs;
|
||
xcb_window_t root;
|
||
xcb_intern_atom_cookie_t atom_cookies[NUM_ATOMS];
|
||
|
||
/* Disable output buffering to make redirects in .xsession actually useful for debugging */
|
||
if (!isatty(fileno(stdout)))
|
||
setbuf(stdout, NULL);
|
||
|
||
application_path = sstrdup(argv[0]);
|
||
|
||
while ((opt = getopt(argc, argv, "c:")) != -1) {
|
||
switch (opt) {
|
||
case 'c':
|
||
override_configpath = sstrdup(optarg);
|
||
break;
|
||
default:
|
||
fprintf(stderr, "Usage: %s [-c configfile]\n", argv[0]);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
/* Initialize the table data structures for each workspace */
|
||
init_table();
|
||
|
||
memset(&evenths, 0, sizeof(xcb_event_handlers_t));
|
||
memset(&prophs, 0, sizeof(xcb_property_handlers_t));
|
||
|
||
byChild = alloc_table();
|
||
byParent = alloc_table();
|
||
|
||
load_configuration(override_configpath);
|
||
|
||
conn = xcb_connect(NULL, &screens);
|
||
|
||
/* Place requests for the atoms we need as soon as possible */
|
||
#define REQUEST_ATOM(name) atom_cookies[name] = xcb_intern_atom(conn, 0, strlen(#name), #name);
|
||
|
||
REQUEST_ATOM(_NET_SUPPORTED);
|
||
REQUEST_ATOM(_NET_WM_STATE_FULLSCREEN);
|
||
REQUEST_ATOM(_NET_SUPPORTING_WM_CHECK);
|
||
REQUEST_ATOM(_NET_WM_NAME);
|
||
REQUEST_ATOM(_NET_WM_STATE);
|
||
REQUEST_ATOM(_NET_WM_WINDOW_TYPE);
|
||
REQUEST_ATOM(_NET_WM_DESKTOP);
|
||
REQUEST_ATOM(_NET_WM_WINDOW_TYPE_DOCK);
|
||
REQUEST_ATOM(_NET_WM_STRUT_PARTIAL);
|
||
REQUEST_ATOM(UTF8_STRING);
|
||
|
||
/* TODO: this has to be more beautiful somewhen */
|
||
int major, minor, error;
|
||
|
||
major = XkbMajorVersion;
|
||
minor = XkbMinorVersion;
|
||
|
||
int evBase, errBase;
|
||
|
||
if ((xkbdpy = XkbOpenDisplay(getenv("DISPLAY"), &evBase, &errBase, &major, &minor, &error)) == NULL) {
|
||
fprintf(stderr, "XkbOpenDisplay() failed\n");
|
||
return 1;
|
||
}
|
||
|
||
int i1;
|
||
if (!XkbQueryExtension(xkbdpy,&i1,&evBase,&errBase,&major,&minor)) {
|
||
fprintf(stderr, "XKB not supported by X-server\n");
|
||
return 1;
|
||
}
|
||
/* end of ugliness */
|
||
|
||
xcb_event_handlers_init(conn, &evenths);
|
||
|
||
/* DEBUG: Trap all events and print them */
|
||
for (i = 2; i < 128; ++i)
|
||
xcb_event_set_handler(&evenths, i, handle_event, 0);
|
||
|
||
for (i = 0; i < 256; ++i)
|
||
xcb_event_set_error_handler(&evenths, i, (xcb_generic_error_handler_t)handle_event, 0);
|
||
|
||
/* Expose = an Application should redraw itself, in this case it’s our titlebars. */
|
||
xcb_event_set_expose_handler(&evenths, handle_expose_event, 0);
|
||
|
||
/* Key presses/releases are pretty obvious, I think */
|
||
xcb_event_set_key_press_handler(&evenths, handle_key_press, 0);
|
||
xcb_event_set_key_release_handler(&evenths, handle_key_release, 0);
|
||
|
||
/* Enter window = user moved his mouse over the window */
|
||
xcb_event_set_enter_notify_handler(&evenths, handle_enter_notify, 0);
|
||
|
||
/* Button press = user pushed a mouse button over one of our windows */
|
||
xcb_event_set_button_press_handler(&evenths, handle_button_press, 0);
|
||
|
||
/* Map notify = there is a new window */
|
||
xcb_event_set_map_notify_handler(&evenths, handle_map_notify_event, &prophs);
|
||
|
||
/* Unmap notify = window disappeared. When sent from a client, we don’t manage
|
||
it any longer. Usually, the client destroys the window shortly afterwards. */
|
||
xcb_event_set_unmap_notify_handler(&evenths, handle_unmap_notify_event, 0);
|
||
|
||
/* Configure notify = window’s configuration (geometry, stacking, …). We only need
|
||
it to set up ignore the following enter_notify events */
|
||
xcb_event_set_configure_notify_handler(&evenths, handle_configure_event, 0);
|
||
|
||
/* Client message = client changed its properties (EWMH) */
|
||
/* TODO: can’t we do this via property handlers? */
|
||
xcb_event_set_client_message_handler(&evenths, handle_client_message, 0);
|
||
|
||
/* Initialize the property handlers */
|
||
xcb_property_handlers_init(&prophs, &evenths);
|
||
|
||
/* Watch the WM_NAME (= title of the window) property */
|
||
xcb_watch_wm_name(&prophs, 128, handle_windowname_change, 0);
|
||
|
||
/* Get the root window and set the event mask */
|
||
root = xcb_aux_get_screen(conn, screens)->root;
|
||
|
||
uint32_t mask = XCB_CW_EVENT_MASK;
|
||
uint32_t values[] = { XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
|
||
XCB_EVENT_MASK_STRUCTURE_NOTIFY | /* when the user adds a screen (e.g. video
|
||
projector), the root window gets a
|
||
ConfigureNotify */
|
||
XCB_EVENT_MASK_PROPERTY_CHANGE |
|
||
XCB_EVENT_MASK_ENTER_WINDOW };
|
||
xcb_change_window_attributes(conn, root, mask, values);
|
||
|
||
/* Setup NetWM atoms */
|
||
#define GET_ATOM(name) { \
|
||
xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, atom_cookies[name], NULL); \
|
||
if (!reply) { \
|
||
printf("Could not get atom " #name "\n"); \
|
||
exit(-1); \
|
||
} \
|
||
atoms[name] = reply->atom; \
|
||
free(reply); \
|
||
}
|
||
|
||
GET_ATOM(_NET_SUPPORTED);
|
||
GET_ATOM(_NET_WM_STATE_FULLSCREEN);
|
||
GET_ATOM(_NET_SUPPORTING_WM_CHECK);
|
||
GET_ATOM(_NET_WM_NAME);
|
||
GET_ATOM(_NET_WM_STATE);
|
||
GET_ATOM(_NET_WM_WINDOW_TYPE);
|
||
GET_ATOM(_NET_WM_DESKTOP);
|
||
GET_ATOM(_NET_WM_WINDOW_TYPE_DOCK);
|
||
GET_ATOM(_NET_WM_STRUT_PARTIAL);
|
||
GET_ATOM(UTF8_STRING);
|
||
|
||
xcb_property_set_handler(&prophs, atoms[_NET_WM_WINDOW_TYPE], UINT_MAX, window_type_handler, NULL);
|
||
/* TODO: In order to comply with EWMH, we have to watch _NET_WM_STRUT_PARTIAL */
|
||
|
||
/* Set up the atoms we support */
|
||
check_error(conn, xcb_change_property_checked(conn, XCB_PROP_MODE_REPLACE, root, atoms[_NET_SUPPORTED],
|
||
ATOM, 32, 7, atoms), "Could not set _NET_SUPPORTED");
|
||
|
||
/* Set up the window manager’s name */
|
||
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, atoms[_NET_SUPPORTING_WM_CHECK], WINDOW, 32, 1, &root);
|
||
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, atoms[_NET_WM_NAME], atoms[UTF8_STRING], 8, strlen("i3"), "i3");
|
||
|
||
/* Grab the bound keys */
|
||
Binding *bind;
|
||
TAILQ_FOREACH(bind, &bindings, bindings) {
|
||
printf("Grabbing %d\n", bind->keycode);
|
||
if (bind->mods & BIND_MODE_SWITCH)
|
||
xcb_grab_key(conn, 0, root, 0, bind->keycode, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_SYNC);
|
||
else xcb_grab_key(conn, 0, root, bind->mods, bind->keycode, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC);
|
||
}
|
||
|
||
/* check for Xinerama */
|
||
printf("Checking for Xinerama...\n");
|
||
initialize_xinerama(conn);
|
||
|
||
/* DEBUG: Start a terminal */
|
||
start_application(config.terminal);
|
||
|
||
xcb_flush(conn);
|
||
|
||
manage_existing_windows(conn, &prophs, root);
|
||
|
||
/* Get pointer position to see on which screen we’re starting */
|
||
xcb_query_pointer_reply_t *reply;
|
||
if ((reply = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, root), NULL)) == NULL) {
|
||
printf("Could not get pointer position\n");
|
||
return 1;
|
||
}
|
||
|
||
i3Screen *screen = get_screen_containing(reply->root_x, reply->root_y);
|
||
if (screen == NULL) {
|
||
printf("ERROR: No screen at %d x %d\n", reply->root_x, reply->root_y);
|
||
return 0;
|
||
}
|
||
if (screen->current_workspace != 0) {
|
||
printf("Ok, I need to go to the other workspace\n");
|
||
c_ws = &workspaces[screen->current_workspace];
|
||
}
|
||
|
||
/* Enter xcb’s event handler */
|
||
xcb_event_wait_for_event_loop(&evenths);
|
||
|
||
/* not reached */
|
||
return 0;
|
||
}
|