i3 - improved tiling WM

This document is intended to be the first thing you read before looking and/or touching i3’s source code. It should contain all important information to help you understand why things are like they are. If it does not mention something you find necessary, please do not hesitate to contact me.

1. Window Managers

A window manager is not necessarily needed to run X, but it is usually used in combination with X to facilitate some things. The window manager’s job is to take care of the placement of windows, to provide the user with some mechanisms to change the position/size of windows and to communicate with clients to a certain extent (for example handle fullscreen requests of clients such as MPlayer).

There are no different contexts in which X11 clients run, so a window manager is just another client, like all other X11 applications. However, it handles some events which normal clients usually don’t handle.

In the case of i3, the tasks (and order of them) are the following:

  1. Grab the key bindings (events will be sent upon keypress/keyrelease)

  2. Iterate through all existing windows (if the window manager is not started as the first client of X) and manage them (reparent them, create window decorations, etc.)

  3. When new windows are created, manage them

  4. Handle the client’s _WM_STATE property, but only the _WM_STATE_FULLSCREEN

  5. Handle the client’s WM_NAME property

  6. Handle the client’s size hints to display them proportionally

  7. Handle the client’s urgency hint

  8. Handle enter notifications (focus follows mouse)

  9. Handle button (as in mouse buttons) presses for focus/raise on click

  10. Handle expose events to re-draw own windows such as decorations

  11. React to the user’s commands: Change focus, Move windows, Switch workspaces, Change the layout mode of a container (default/stacking/tabbed), start a new application, restart the window manager

In the following chapters, each of these tasks and their implementation details will be discussed.

1.1. Tiling window managers

Traditionally, there are two approaches to managing windows: The most common one nowadays is floating, which means the user can freely move/resize the windows. The other approach is called tiling, which means that your window manager distributes windows to use as much space as possible while not overlapping each other.

The idea behind tiling is that you should not need to waste your time moving/resizing windows while you usually want to get some work done. After all, most users sooner or later tend to lay out their windows in a way which corresponds to tiling or stacking mode in i3. Therefore, why not let i3 do this for you? Certainly, it’s faster than you could ever do it.

The problem with most tiling window managers is that they are too unflexible. In my opinion, a window manager is just another tool, and similar to vim which can edit all kinds of text files (like source code, HTML, …) and is not limited to a specific file type, a window manager should not limit itself to a certain layout (like dwm, awesome, …) but provide mechanisms for you to easily create the layout you need at the moment.

1.2. The layout table

This section has not been updated for v4.0 yet, sorry! We wanted to release on time, but we will update this soon. Please talk to us on IRC if you need to know stuff NOW :).

2. Files

include/atoms.xmacro

A file containing all X11 atoms which i3 uses. This file will be included various times (for defining, requesting and receiving the atoms), each time with a different definition of xmacro().

include/data.h

Contains data definitions used by nearly all files. You really need to read this first.

include/*.h

Contains forward definitions for all public functions, as well as doxygen-compatible comments (so if you want to get a bit more of the big picture, either browse all header files or use doxygen if you prefer that).

src/cfgparse.l

Contains the lexer for i3’s configuration file, written for flex(1).

src/cfgparse.y

Contains the parser for i3’s configuration file, written for bison(1).

src/click.c

Contains all functions which handle mouse button clicks (right mouse button clicks initiate resizing and thus are relatively complex).

src/cmdparse.l

Contains the lexer for i3 commands, written for flex(1).

src/cmdparse.y

Contains the parser for i3 commands, written for bison(1).

src/con.c

Contains all functions which deal with containers directly (creating containers, searching containers, getting specific properties from containers, …).

src/config.c

Contains all functions handling the configuration file (calling the parser (src/cfgparse.y) with the correct path, switching key bindings mode).

src/debug.c

Contains debugging functions to print unhandled X events.

src/ewmh.c

iFunctions to get/set certain EWMH properties easily.

src/floating.c

Contains functions for floating mode (mostly resizing/dragging).

src/handlers.c

Contains all handlers for all kinds of X events (new window title, new hints, unmapping, key presses, button presses, …).

src/ipc.c

Contains code for the IPC interface.

src/load_layout.c

Contains code for loading layouts from JSON files.

src/log.c

Handles the setting of loglevels, contains the logging functions.

src/main.c

Initializes the window manager.

src/manage.c

Looks at existing or new windows and decides whether to manage them. If so, it reparents the window and inserts it into our data structures.

src/match.c

A "match" is a data structure which acts like a mask or expression to match certain windows or not. For example, when using commands, you can specify a command like this: [title="Firefox"] kill. The title member of the match data structure will then be filled and i3 will check each window using match_matches_window() to find the windows affected by this command.

src/move.c

Contains code to move a container in a specific direction.

src/output.c

Functions to handle CT_OUTPUT cons.

src/randr.c

The RandR API is used to get (and re-query) the configured outputs (monitors, …).

src/render.c

Renders the tree data structure by assigning coordinates to every node. These values will later be pushed to X11 in src/x.c.

src/resize.c

Contains the functions to resize containers.

src/sighandler.c

Handles SIGSEGV, SIGABRT and SIGFPE by showing a dialog that i3 crashed. You can chose to let it dump core, to restart it in-place or to restart it in-place but forget about the layout.

src/tree.c

Contains functions which open or close containers in the tree, change focus or cleanup ("flatten") the tree. See also src/move.c for another similar function, which was moved into its own file because it is so long.

src/util.c

Contains useful functions which are not really dependant on anything.

src/window.c

Handlers to update X11 window properties like WM_CLASS, _NET_WM_NAME, CLIENT_LEADER, etc.

src/workspace.c

Contains all functions related to workspaces (displaying, hiding, renaming…)

src/x.c

Transfers our in-memory tree (see src/render.c) to X11.

src/xcb.c

Contains wrappers to use xcb more easily.

src/xcursor.c

XCursor functions (for cursor themes).

src/xinerama.c

Legacy support for Xinerama. See src/randr.c for the preferred API.

3. Data structures

This section has not been updated for v4.0 yet, sorry! We wanted to release on time, but we will update this soon. Please talk to us on IRC if you need to know stuff NOW :).

So, the hierarchy is:

  1. X11 root window, the root container

  2. Virtual screens (Screen 0 in this example)

  3. Content container (there are also containers for dock windows)

  4. Workspaces (Workspace 1 in this example, with horizontal orientation)

  5. Split container (vertically split)

  6. X11 window containers

The data type is Con, in all cases.

3.1. Virtual screens

A virtual screen (type i3Screen) is generated from the connected outputs obtained through RandR. The difference to the raw RandR outputs as seen when using xrandr(1) is that it falls back to the lowest common resolution of the actual enabled outputs.

For example, if your notebook has a screen resolution of 1280x800 px and you connect a video projector with a resolution of 1024x768 px, set it up in clone mode (xrandr --output VGA1 --mode 1024x768 --same-as LVDS1), i3 will have one virtual screen.

However, if you configure it using xrandr --output VGA1 --mode 1024x768 --right-of LVDS1, i3 will generate two virtual screens. For each virtual screen, a new workspace will be assigned. New workspaces are created on the screen you are currently on.

3.2. Workspace

A workspace is identified by its name. Basically, you could think of workspaces as different desks in your office, if you like the desktop methaphor. They just contain different sets of windows and are completely separate of each other. Other window managers also call this “Virtual desktops”.

3.3. The layout table

This section has not been updated for v4.0 yet, sorry! We wanted to release on time, but we will update this soon. Please talk to us on IRC if you need to know stuff NOW :).

3.4. Container

This section has not been updated for v4.0 yet, sorry! We wanted to release on time, but we will update this soon. Please talk to us on IRC if you need to know stuff NOW :).

3.5. Client

A client is x11-speak for a window.

4. List/queue macros

i3 makes heavy use of the list macros defined in BSD operating systems. To ensure that the operating system on which i3 is compiled has all the expected features, i3 comes with include/queue.h. On BSD systems, you can use man queue(3). On Linux, you have to use google (or read the source).

The lists used are SLIST (single linked lists), CIRCLEQ (circular queues) and TAILQ (tail queues). Usually, only forward traversal is necessary, so an SLIST works fine. If inserting elements at arbitrary positions or at the end of a list is necessary, a TAILQ is used instead. However, for the windows inside a container, a CIRCLEQ is necessary to go from the currently selected window to the window above/below.

5. Naming conventions

There is a row of standard variables used in many events. The following names should be chosen for those:

  • “conn” is the xcb_connection_t

  • “event” is the event of the particular type

  • “con” names a container

  • “current” is a loop variable when using TAILQ_FOREACH etc.

6. Startup (src/mainx.c, main())

  • Establish the xcb connection

  • Check for XKB extension on the separate X connection, load Xcursor

  • Check for RandR screens (with a fall-back to Xinerama)

  • Grab the keycodes for which bindings exist

  • Manage all existing windows

  • Enter the event loop

7. Keybindings

7.1. Grabbing the bindings

Grabbing the bindings is quite straight-forward. You pass X your combination of modifiers and the keycode you want to grab and whether you want to grab them actively or passively. Most bindings (everything except for bindings using Mode_switch) are grabbed passively, that is, just the window manager gets the event and cannot replay it.

We need to grab bindings that use Mode_switch actively because of a bug in X. When the window manager receives the keypress/keyrelease event for an actively grabbed keycode, it has to decide what to do with this event: It can either replay it so that other applications get it or it can prevent other applications from receiving it.

So, why do we need to grab keycodes actively? Because X does not set the state-property of keypress/keyrelease events properly. The Mode_switch bit is not set and we need to get it using XkbGetState. This means we cannot pass X our combination of modifiers containing Mode_switch when grabbing the key and therefore need to grab the keycode itself without any modifiers. This means, if you bind Mode_switch + keycode 38 ("a"), i3 will grab keycode 38 ("a") and check on each press of "a" if the Mode_switch bit is set using XKB. If yes, it will handle the event, if not, it will replay the event.

7.2. Handling a keypress

As mentioned in "Grabbing the bindings", upon a keypress event, i3 first gets the correct state.

Then, it looks through all bindings and gets the one which matches the received event.

The bound command is parsed by the cmdparse lexer/parser, see parse_cmd in src/cmdparse.y.

8. Manage windows (src/main.c, manage_window() and reparent_window())

manage_window() does some checks to decide whether the window should be managed at all:

  • Windows have to be mapped, that is, visible on screen

  • The override_redirect must not be set. Windows with override_redirect shall not be managed by a window manager

Afterwards, i3 gets the intial geometry and reparents the window (see reparent_window()) if it wasn’t already managed.

Reparenting means that for each window which is reparented, a new window, slightly larger than the original one, is created. The original window is then reparented to the bigger one (called "frame").

After reparenting, the window type (_NET_WM_WINDOW_TYPE) is checked to see whether this window is a dock (_NET_WM_WINDOW_TYPE_DOCK), like dzen2 for example. Docks are handled differently, they don’t have decorations and are not assigned to a specific container. Instead, they are positioned at the bottom of the screen. To get the height which needs to be reserved for the window, the _NET_WM_STRUT_PARTIAL property is used.

Furthermore, the list of assignments (to other workspaces, which may be on other screens) is checked. If the window matches one of the user’s criteria, it may either be put in floating mode or moved to a different workspace. If the target workspace is not visible, the window will not be mapped.

9. What happens when an application is started?

i3 does not care for applications. All it notices is when new windows are mapped (see src/handlers.c, handle_map_request()). The window is then reparented (see section "Manage windows").

After reparenting the window, render_tree() is called which renders the internal layout table. The new window has been placed in the currently focused container and therefore the new window and the old windows (if any) need to be moved/resized so that the currently active layout (default/stacking/tabbed mode) is rendered correctly. To move/resize windows, a window is “configured” in X11-speak.

Some applications, such as MPlayer obviously assume the window manager is stupid and try to configure their windows by themselves. This generates an event called configurerequest. i3 handles these events and tells the window the size it had before the configurerequest (with the exception of not yet mapped windows, which get configured like they want to, and floating windows, which can reconfigure themselves).

10. _NET_WM_STATE

Only the _NET_WM_STATE_FULLSCREEN atom is handled. It calls “toggle_fullscreen()” for the specific client which just configures the client to use the whole screen on which it currently is. Also, it is set as fullscreen_client for the i3Screen.

11. WM_NAME

When the WM_NAME property of a window changes, its decoration (containing the title) is re-rendered. Note that WM_NAME is in COMPOUND_TEXT encoding which is totally uncommon and cumbersome. Therefore, the _NET_WM_NAME atom will be used if present.

12. _NET_WM_NAME

Like WM_NAME, this atom contains the title of a window. However, _NET_WM_NAME is encoded in UTF-8. i3 will recode it to UCS-2 in order to be able to pass it to X. Using an appropriate font (ISO-10646), you can see most special characters (every special character contained in your font).

13. Size hints

Size hints specify the minimum/maximum size for a given window as well as its aspect ratio. This is important for clients like mplayer, who only set the aspect ratio and resize their window to be as small as possible (but only with some video outputs, for example in Xv, while when using x11, mplayer does the necessary centering for itself).

So, when an aspect ratio was specified, i3 adjusts the height of the window until the size maintains the correct aspect ratio. For the code to do this, see src/layout.c, function resize_client().

14. Rendering (src/layout.c, render_layout() and render_container())

This section has not been updated for v4.0 yet, sorry! We wanted to release on time, but we will update this soon. Please talk to us on IRC if you need to know stuff NOW :).

15. User commands / commandmode (src/cmdparse.{l,y})

This section has not been updated for v4.0 yet, sorry! We wanted to release on time, but we will update this soon. Please talk to us on IRC if you need to know stuff NOW :).

16. Moving containers

The movement code is pretty delicate. You need to consider all cases before making any changes or before being able to fully understand how it works.

16.1. Case 1: Moving inside the same container

The reference layout for this case is a single workspace in horizontal orientation with two containers on it. Focus is on the left container (1).

1

2

When moving the left window to the right (command move right), tree_move will look for a container with horizontal orientation and finds the parent of the left container, that is, the workspace. Afterwards, it runs the code branch commented with "the easy case": it calls TAILQ_NEXT to get the container right of the current one and swaps both containers.

16.2. Case 2: Move a container into a split container

The reference layout for this case is a horizontal workspace with two containers. The right container is a v-split with two containers. Focus is on the left container (1).

1

2

3

When moving to the right (command move right), i3 will work like in case 1 ("the easy case"). However, as the right container is not a leaf container, but a v-split, the left container (1) will be inserted at the right position (below 2, assuming that 2 is focused inside the v-split) by calling insert_con_into.

insert_con_into detaches the container from its parent and inserts it before/after the given target container. Afterwards, the on_remove_child callback is called on the old parent container which will then be closed, if empty.

Afterwards, con_focus will be called to fix the focus stack and the tree will be flattened.

16.3. Case 3: Moving to non-existant top/bottom

Like in case 1, the reference layout for this case is a single workspace in horizontal orientation with two containers on it. Focus is on the left container:

1

2

This time however, the command is move up or move down. tree_move will look for a container with vertical orientation. As it will not find any, same_orientation is NULL and therefore i3 will perform a forced orientation change on the workspace by creating a new h-split container, moving the workspace contents into it and then changing the workspace orientation to vertical. Now it will again search for parent containers with vertical orientation and it will find the workspace.

This time, the easy case code path will not be run as we are not moving inside the same container. Instead, insert_con_into will be called with the focused container and the container above/below the current one (on the level of same_orientation).

Now, con_focus will be called to fix the focus stack and the tree will be flattened.

16.4. Case 4: Moving to existant top/bottom

The reference layout for this case is a vertical workspace with two containers. The bottom one is a h-split containing two containers (1 and 2). Focus is on the bottom left container (1).

3

1

2

This case is very much like case 3, only this time the forced workspace orientation change does not need to be performed because the workspace already is in vertical orientation.

16.5. Case 5: Moving in one-child h-split

The reference layout for this case is a horizontal workspace with two containers having a v-split on the left side with a one-child h-split on the bottom. Focus is on the bottom left container (2(h)):

1

3

2(h)

In this case, same_orientation will be set to the h-split container around the focused container. However, when trying the easy case, the next/previous container swap will be NULL. Therefore, i3 will search again for a same_orientation container, this time starting from the parent of the h-split container.

After determining a new same_orientation container (if it is NULL, the orientation will be force-changed), this case is equivalent to case 2 or case 4.

16.6. Case 6: Floating containers

The reference layout for this case is a horizontal workspace with two containers plus one floating h-split container. Focus is on the floating container.

TODO: nice illustration. table not possible?

When moving up/down, the container needs to leave the floating container and it needs to be placed on the workspace (at workspace level). This is accomplished by calling the function attach_to_workspace.

17. Click handling

Without much ado, here is the list of cases which need to be considered:

  • click to focus (tiling + floating) and raise (floating)

  • click to focus/raise when in stacked/tabbed mode

  • floating_modifier + left mouse button to drag a floating con

  • floating_modifier + right mouse button to resize a floating con

  • click on decoration in a floating con to either initiate a resize (if there is more than one child in the floating con) or to drag the floating con (if it’s the one at the top).

  • click on border in a floating con to resize the floating con

  • floating_modifier + right mouse button to resize a tiling con

  • click on border/decoration to resize a tiling con

18. Gotchas

  • Forgetting to call xcb_flush(conn); after sending a request. This usually leads to code which looks like it works fine but which does not work under certain conditions.

19. Using git / sending patches

For a short introduction into using git, see http://www.spheredev.org/wiki/Git_for_the_lazy or, for more documentation, see http://git-scm.com/documentation

When you want to send a patch because you fixed a bug or implemented a cool feature (please talk to us before working on features to see whether they are maybe already implemented, not possible for some some reason, or don’t fit into the concept), please use git to create a patchfile.

First of all, update your working copy to the latest version of the master branch:

git pull

Afterwards, make the necessary changes for your bugfix/feature. Then, review the changes using git diff (you might want to enable colors in the diff using git config diff.color auto). When you are definitely done, use git commit -a to commit all changes you’ve made.

Then, use the following command to generate a patchfile which we can directly apply to the branch, preserving your commit message and name:

git format-patch origin

Just send us the generated file via email.