Merge branch 'next' (3.β is stable now)

CMDMODE

@@ -1,36 +1,44 @@
-left := <h> | <cursor-left>
+---------------------
+- Command mode
+---------------------
+
+This is the grammar for the command mode (your configuration file uses these commands, too).
+
+left  := <h> | <cursor-left>
 right := <l> | <cursor-right>
-up := <j> | <cursor-up>
+up    := <j> | <cursor-up>
-down := <k> | <cursor-down>
+down  := <k> | <cursor-down>
 
 where := <left|right|up|down> | <tag>
-move := <m>
+move  := <m>
-snap := <s>
+snap  := <s>
-
-Eingabe ist entweder
-
-cmd := [ <times> ] [ <move> | <snap> ] <where>
-
-oder
-
-with := <w> { [ <times> ] <where> }+ <space> <cmd>
-
-oder
 
+cmd     := [ <times> ] [ <move> | <snap> ] <where>
+with    := <w> { [ <times> ] <where> }+ <space> <cmd>
+jump    := [ "<window class>[/<window title>]" | <workspace> [ <column> <row> ] ]
+focus   := focus [ <times> | floating | tiling | ft ]
+(travels the focus stack backwards the given amount of times (by default 1), so
+ it selects the window which had the focus before you focused the current one when
+ specifying "focus 1".
+ The special values 'floating' (select the next floating window), 'tiling'
+ (select the next tiling window), 'ft' (if the current window is floating,
+ select the next tiling window and vice-versa) are also valid)
 special := [ exec <path> | kill | exit | restart ]
 
-an jeder Stelle kann mit escape abgebrochen werden
+input := [ <cmd> | <with> | <jump> | <focus> | <special> ]
 
-Beispiele:
+you can cancel command mode by pressing escape anytime.
 
-Fenster links neben dem aktuellen auswählen:
+Some examples:
+
+Select the window on the left:
 h
 
-Fenster zwei links neben dem aktuellen auswählen:
+Select the window two places on the left:
 2h
 
-Fenster nach rechts verschieben:
+Move window to the right:
 ml
 
-Fenster und Fenster untendrunter nach rechts verschieben:
+Move window and window on the bottom to the right:
 wk ml

DEPENDS

@@ -5,6 +5,7 @@ In that case, please try using the versions mentioned below until a fix is provi
  * xcb-proto-1.3 (2008-12-10)
  * libxcb-1.1.93 (2008-12-11)
  * xcb-util-0.3.3 (2009-01-31)
+ * libev
  * asciidoc >= 8.3.0 for docs/hacking-howto
  * asciidoc, xmlto, docbook-xml for man/i3.man
  * Xlib, the one that comes with your X-Server
@@ -14,9 +15,10 @@ Recommendations:
  * dmenu for launching applications
 
 Get the libraries from:
-http://xcb.freedesktop.org/dist/xcb-proto-1.3.tar.bz2
+http://xcb.freedesktop.org/dist/xcb-proto-1.5.tar.bz2
 http://xcb.freedesktop.org/dist/libxcb-1.1.93.tar.bz2
-http://xcb.freedesktop.org/dist/xcb-util-0.3.3.tar.bz2
+http://xcb.freedesktop.org/dist/xcb-util-0.3.5.tar.bz2
+http://libev.schmorp.de/
 
 http://i3.zekjur.net/i3lock/
 http://tools.suckless.org/dmenu

Makefile

@@ -37,6 +37,7 @@ LDFLAGS += -lxcb-aux
 LDFLAGS += -lxcb-icccm
 LDFLAGS += -lxcb-xinerama
 LDFLAGS += -lX11
+LDFLAGS += -lev
 LDFLAGS += -L/usr/local/lib -L/usr/pkg/lib
 
 ifeq ($(UNAME),NetBSD)

RELEASE-NOTES-3.b

@@ -0,0 +1,51 @@
+Release notes for i3 v3.β
+-----------------------------
+
+This is the second version (3.β, transcribed 3.b) of i3. It is considered stable.
+
+The most important change probably is the implementation of floating clients,
+primarily useful for dialog/toolbar/popup/splash windows. When using i3 for
+managing floating windows other than the ones mentioned beforehand, please
+keep in mind that i3 is a tiling window manager in the first place and thus
+you might better use a "traditional" window manager when having to deal a
+lot with floating windows.
+
+Now that you’re warned, let’s have a quick glance at the other new features:
+  * jumping to other windows by specifying their position or window class/title
+  * assigning clients to specific workspaces by window class/title
+  * automatically starting programs (such as i3status + dzen2)
+  * configurable colors
+  * variables in configfile
+
+Furthermore, we now have a user’s guide which should be the first document
+you read when new to i3 (apart from the manpage).
+
+Thanks for this release go out to mist, Atsutane, ch3ka, urs, Moredread,
+badboy and all other people who reported bugs/made suggestions.
+
+A list of changes follows:
+
+  * Bugfix: Correctly handle col-/rowspanned containers when setting focus.
+  * Bugfix: Correctly handle col-/rowspanned containers when snapping.
+  * Bugfix: Force reconfiguration of all windows on workspaces which are
+    re-assigned because a screen was detached.
+  * Bugfix: Several bugs in resizing table columns fixed.
+  * Bugfix: Resizing should now work correctly in all cases.
+  * Bugfix: Correctly re-assign dock windows when workspace is destroyed.
+  * Bugfix: Correctly handle Mode_switch modifier.
+  * Bugfix: Don't raise clients in fullscreen mode.
+  * Bugfix: Re-assign dock windows to different workspaces when a workspace
+    is detached.
+  * Bugfix: Fix crash because of workspace-pointer which did not get updated
+  * Bugfix: Correctly initialize screen when Xinerama is disabled.
+  * Bugfix: Fullscreen window movement and focus problems fixed
+  * Implement jumping to other windows by specifying their position or
+    window class/title.
+  * Implement jumping back by using the focus stack.
+  * Implement autostart (exec-command in configuration file).
+  * Implement floating.
+  * Implement automatically assigning clients on specific workspaces.
+  * Implement variables in configfile.
+  * Colors are now configurable.
+
+-- Michael Stapelberg, 2009-06-21

debian/changelog

@@ -1,3 +1,30 @@
+i3-wm (3.b-1) unstable; urgency=low
+
+  * Bugfix: Correctly handle col-/rowspanned containers when setting focus.
+  * Bugfix: Correctly handle col-/rowspanned containers when snapping.
+  * Bugfix: Force reconfiguration of all windows on workspaces which are
+    re-assigned because a screen was detached.
+  * Bugfix: Several bugs in resizing table columns fixed.
+  * Bugfix: Resizing should now work correctly in all cases.
+  * Bugfix: Correctly re-assign dock windows when workspace is destroyed.
+  * Bugfix: Correctly handle Mode_switch modifier.
+  * Bugfix: Don't raise clients in fullscreen mode.
+  * Bugfix: Re-assign dock windows to different workspaces when a workspace
+    is detached.
+  * Bugfix: Fix crash because of workspace-pointer which did not get updated
+  * Bugfix: Correctly initialize screen when Xinerama is disabled.
+  * Bugfix: Fullscreen window movement and focus problems fixed
+  * Implement jumping to other windows by specifying their position or
+    window class/title.
+  * Implement jumping back by using the focus stack.
+  * Implement autostart (exec-command in configuration file).
+  * Implement floating.
+  * Implement automatically assigning clients on specific workspaces.
+  * Implement variables in configfile.
+  * Colors are now configurable.
+
+ -- Michael Stapelberg <michael@stapelberg.de>  Fri, 26 Jun 2009 04:42:23 +0200
+
 i3-wm (3.a-bf2-1) unstable; urgency=low
 
   * Bugfix: Don't crash when setting focus

debian/control

@@ -1,26 +1,28 @@
 Source: i3-wm
 Section: utils
-Priority: optional
+Priority: extra
 Maintainer: Michael Stapelberg <michael@stapelberg.de>
 DM-Upload-Allowed: yes
-Build-Depends: debhelper (>= 5), libx11-dev, libxcb-aux0-dev (>= 0.3.3), libxcb-keysyms1-dev, libxcb-xinerama0-dev (>= 1.1), libxcb-event1-dev (>= 0.3.3), libxcb-property1-dev (>= 0.3.3), libxcb-atom1-dev (>= 0.3.3), libxcb-icccm1-dev (>= 0.3.3), asciidoc (>= 8.4.4-1), xmlto, docbook-xml, pkg-config
+Build-Depends: debhelper (>= 5), libx11-dev, libxcb-aux0-dev (>= 0.3.3), libxcb-keysyms1-dev, libxcb-xinerama0-dev (>= 1.1), libxcb-event1-dev (>= 0.3.3), libxcb-property1-dev (>= 0.3.3), libxcb-atom1-dev (>= 0.3.3), libxcb-icccm1-dev (>= 0.3.3), asciidoc (>= 8.4.4-1), xmlto, docbook-xml, pkg-config, libev-dev
-Standards-Version: 3.8.0
+Standards-Version: 3.8.2
 Homepage: http://i3.zekjur.net/
 
 Package: i3
 Architecture: any
-Priority: optional
+Priority: extra
 Section: x11
 Depends: i3-wm, ${misc:Depends}
-Recommends: i3lock, dwm-tools
+Recommends: i3lock, dwm-tools, i3status
-Description: metapackage (i3 window manager, i3lock (screen locker), dwm-tools)
+Description: metapackage (i3 window manager, screen locker, menu, statusbar)
  This metapackage installs the i3 window manager (i3-wm), the i3lock screen
- locker (slightly improved version of slock) and dwm-tools which contains dmenu.
+ locker (slightly improved version of slock), dwm-tools which contains dmenu
- These are all the tools you need to use the i3 window manager efficiently.
+ and i3status, which displays useful information about your system in
+ combination with dzen2. These are all the tools you need to use the i3 window
+ manager efficiently.
 
 Package: i3-wm
 Architecture: any
-Priority: optional
+Priority: extra
 Section: x11
 Depends: ${shlibs:Depends}, ${misc:Depends}
 Provides: x-window-manager

debian/i3-wm.docs

@@ -0,0 +1,8 @@
+docs/debugging.html
+docs/hacking-howto.html
+docs/userguide.html
+docs/bigpicture.png
+docs/single_terminal.png
+docs/snapping.png
+docs/two_columns.png
+docs/two_terminals.png

debian/rules

@@ -19,6 +19,7 @@ build:
 	# Add here commands to compile the package.
 	$(MAKE)
 	$(MAKE) -C man
+	$(MAKE) -C docs
 
 	touch $@
 

docs/Makefile

@@ -1,5 +1,5 @@
 
-all: hacking-howto.html debugging.html
+all: hacking-howto.html debugging.html userguide.html
 
 hacking-howto.html: hacking-howto
 	asciidoc -a toc -n $<
@@ -7,6 +7,8 @@ hacking-howto.html: hacking-howto
 debugging.html: debugging
 	asciidoc -n $<
 
+userguide.html: userguide
+	asciidoc -a toc -n $<
 
 clean:
 	rm -f */*.{aux,log,toc,bm,pdf,dvi}

docs/debugging

@@ -84,35 +84,9 @@ gdb $(which i3) core.i3.3849
 
 Then, generate a backtrace using:
 
----------
+--------------
-backtrace
+backtrace full
----------
+--------------
-
-Also, getting an overview of the local variables might help:
------------
-info locals
------------
-
-If your backtrace looks like this:
----------------------------------------------------------------------------------------------------
-(gdb) backtrace
-#0  0x041b1a01 in vfprintf () from /lib/libc.so.6
-#1  0x041b2f80 in vprintf () from /lib/libc.so.6
-#2  0x080555de in slog (fmt=0x8059ba0 "%s:%s:%d - Name should change to \"%s\"\n") at src/util.c:60
-#3  0x0804fa73 in handle_windowname_change_legacy (data=0x0, conn=0x42da908,
-                  state=0 '\0', window=8389918, atom=39, prop=0x4303f90) at src/handlers.c:752
-#4  0x0406cace in ?? () from /usr/lib/libxcb-property.so.1
-#5  0x00000000 in ?? ()
----------------------------------------------------------------------------------------------------
-
-you need to find the first frame which actually belongs to i3 code. You can easily spot them, as
-their filename starts with src/ and has a line number. In this case, frame 2 would be the correct
-frame, so before getting the local variables, switch to frame 2:
-
------------
-frame 2
-info locals
------------
 
 == Sending bugreports/debugging on IRC
 

docs/hacking-howto

@@ -107,23 +107,38 @@ Contains forward definitions for all public functions, aswell as doxygen-compati
 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/client.c::
+Contains all functions which are specific to a certain client (make it
+fullscreen, see if its class/name matches a pattern, kill it, …).
+
 src/commands.c::
-Parsing commands
+Parsing commands and actually execute them (focussing, moving, …).
 
 src/config.c::
-Parses the configuration file
+Parses the configuration file.
 
 src/debug.c::
-Contains debugging functions to print unhandled X events
+Contains debugging functions to print unhandled X events.
+
+src/floating.c::
+Contains functions for floating mode (mostly resizing/dragging).
 
 src/handlers.c::
-Contains all handlers for all kind of X events
+Contains all handlers for all kind of X events (new window title, new hints,
+unmapping, key presses, button presses, …).
 
 src/layout.c::
-Renders your layout (screens, workspaces, containers)
+Renders your layout (screens, workspaces, containers).
 
 src/mainx.c::
-Initializes the window manager
+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/resize.c::
+Contains the functions to resize columns/rows in the table.
 
 src/resize.c::
 Contains the functions to resize columns/rows in the table.
@@ -213,7 +228,7 @@ chosen for those:
  * ``conn'' is the xcb_connection_t
  * ``event'' is the event of the particular type
  * ``container'' names a container
- * ``client'' names a client, for example when using a `CIRCLEQ_FOREACH`
+ * ``client'' names a client, for example when using a +CIRCLEQ_FOREACH+
 
 == Startup (src/mainx.c, main())
 
@@ -361,9 +376,26 @@ when rendering.
 
 === Resizing containers
 
-By clicking and dragging the border of a container, you can resize it freely.
+By clicking and dragging the border of a container, you can resize the whole column
+(respectively row) which this container is in. This is necessary to keep the table
+layout working and consistent.
 
-TODO
+Currently, only vertical resizing is implemented.
+
+The resizing works similarly to the resizing of floating windows or movement of floating
+windows:
+
+* A new, invisible window with the size of the root window is created (+grabwin+)
+* Another window, 2px width and as high as your screen (or vice versa for horizontal
+  resizing) is created. Its background color is the border color and it is only
+  there to signalize the user how big the container will be (it creates the impression
+  of dragging the border out of the container).
+* The +drag_pointer+ function of +src/floating.c+ is called to grab the pointer and
+  enter an own event loop which will pass all events (expose events) but motion notify
+  events. This function then calls the specified callback (+resize_callback+) which
+  does some boundary checking and moves the helper window. As soon as the mouse
+  button is released, this loop will be terminated.
+* The new width_factor for each involved column (respectively row) will be calculated.
 
 == User commands / commandmode (src/commands.c)
 
@@ -396,7 +428,8 @@ direction to move a window respectively or snap.
 
 == Using git / sending patches
 
-For a short introduction into using git, see TODO.
+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

docs/userguide

@@ -0,0 +1,371 @@
+i3 User’s Guide
+===============
+Michael Stapelberg <michael+i3@stapelberg.de>
+June 2009
+
+This document contains all information you need to configuring and using the i3
+window manager. If it does not, please contact me on IRC, Jabber or E-Mail and
+I’ll help you out.
+
+For a complete listing of the default keybindings, please see the manpage.
+
+== Using i3
+
+=== Creating terminals and moving around
+
+A very basic operation is to create a new terminal. By default, the keybinding
+for that is Mod1+Enter, that is Alt+Enter in the default configuration. By
+pressing Mod1+Enter, a new terminal will be created and it will fill the whole
+space which is available on your screen.
+
+image:single_terminal.png[Single terminal]
+
+It is important to keep in mind that i3 uses a table to manage your windows. At
+the moment, you have exactly one column and one row which leaves you with one
+cell. In this cell, there is a container in which your newly opened terminal is.
+
+If you now open another terminal, you still have only one cell. However, the
+container has both of your terminals. So, a container is just a group of clients
+with a specific layout. You can resize containers as they directly resemble
+columns/rows of the layout table.
+
+image:two_terminals.png[Two terminals]
+
+To move the focus between the two terminals, you use the direction keys which
+you may know from the editor +vi+. However, in i3, your homerow is used for
+these keys (in +vi+, the keys are shifted to the left by one for compatibility
+with most keyboard layouts). Therefore, +Mod1+J+ is left, +Mod1+K+ is down, +Mod1+L+
+is up and `Mod1+;` is right. So, to switch between the terminals, use +Mod1+K+ or
++Mod1+L+.
+
+To create a new row/column, you can simply move a terminal (or any other window)
+to the direction you want to expand your table. So, let’s expand the table to
+the right by pressing `Mod1+Shift+;`.
+
+image:two_columns.png[Two columns]
+
+=== Changing mode of containers
+
+A container can be in two modes at the moment (more to be implemented later):
++default+ or +stacking+. In default mode, clients are sized so that every client
+gets an equal amount of space of the container. In stacking mode, only one
+focused client of the container is displayed and you get a list of windows
+at the top of the container.
+
+To switch the mode, press +Mod1+h+ for stacking and +Mod1+e+ for default.
+
+=== Toggling fullscreen mode for a window
+
+To display a window fullscreen or to go out of fullscreen mode again, press
++Mod1+f+.
+
+=== Opening other applications
+
+Aside from opening applicatios from a terminal, you can also use the handy
++dmenu+ which is opened by pressing +Mod1+v+ by default. Just type the name
+(or a part of it) of the application which you want to open. It has to be in
+your +$PATH+ for that to work.
+
+Furthermore, if you have applications you open very frequently, you can also
+create a keybinding for it. See the section "Configuring i3" for details.
+
+=== Closing windows
+
+If an application does not provide a mechanism to close (most applications
+provide a menu, the escape key or a shortcut like +Control+W+ to close), you
+can press +Mod1+Shift+q+ to kill a window. For applications which support
+the WM_DELETE protocol, this will correctly close the application (saving
+any modifications or doing other cleanup). If the application doesn’t support
+it, your X server will kill the window and the behaviour depends on the
+application.
+
+=== Using workspaces
+
+Workspaces are an easy way to group a set of windows. By default, you are on
+the first workspace, as the bar on the bottom left indicates. To switch to
+another workspace, press +Mod1+num+ where +num+ is the number of the workspace
+you want to use. If the workspace does not exist yet, it will be created.
+
+A common paradigm is to put the web browser on one workspace, communication
+applications (+mutt+, +irssi+, ...) on another one and the ones with which you
+work on the third one. Of course, there is no need to follow this approach.
+
+If you have multiple screens, a workspace will be created on each screen. If
+you open a new workspace, it will be bound to the screen you created it on.
+When you switch to a workspace on another screen, i3 will set focus to this
+screen.
+
+=== Moving windows to workspaces
+
+To move a window to another workspace, simply press +Mod1+Shift+num+ where
++num+ is (like when switching workspaces) the number of the target workspace.
+Similarly to switching workspaces, the target workspace will be created if
+it does not yet exist.
+
+=== Resizing columns
+
+To resize columns just grab the border between the two columns and move it to
+the wanted size.
+
+A command for doing this via keyboard will be implemented soon.
+
+=== Restarting i3 inplace
+
+To restart i3 inplace (and thus get it into a clean state if it has a bug, to
+reload your configuration or even to upgrade to a newer version of i3) you
+can use +Mod1+Shift+r+. Be aware, though, that this kills your current layout
+and all the windows you have opened will be put in a default container in only
+one cell. Saving the layout will be implemented in a later version.
+
+=== Exiting i3
+
+To cleanly exit i3 without killing your X server, you can use +Mod1+Shift+e+.
+
+=== Snapping
+
+Snapping is a mechanism to increase/decrease the colspan/rowspan of a container.
+Colspan/rowspan is the amount of columns/rows a specific cell of the table
+consumes. This is easier explained by giving an example, so take the following
+layout:
+
+image:snapping.png[Snapping example]
+
+To use the full size of your screen, you can now snap container 3 downwards
+by pressing +Mod1+Control+k+ (or snap container 2 rightwards).
+
+=== Floating
+
+Floating is the opposite of tiling mode. The position and size of a window
+are then not managed by i3, but by you. Using this mode violates the tiling
+paradigm but can be useful for some corner cases like "Save as" dialog
+windows or toolbar windows (GIMP or similar).
+
+You can enable floating for a window by pressing +Mod1+Shift+Space+. By
+dragging the window’s titlebar with your mouse, you can move the window
+around. By grabbing the borders and moving them you can resize the window.
+
+Bindings for doing this with your keyboard will follow.
+
+Floating clients are always on top of tiling clients.
+
+== Configuring i3
+
+This is where the real fun begins ;-). Most things are very dependant on your
+ideal working environment, so we can’t make reasonable defaults for them.
+
+While not using a programming language for the configuration, i3 stays
+quite flexible regarding to the things you usually want your window manager
+to do.
+
+For example, you can configure bindings to jump to specific windows,
+you can set specific applications to start on a specific workspace, you can
+automatically start applications, you can change the colors of i3 or bind
+your keys to do useful stuff.
+
+terminal::
+	Specifies the terminal emulator program you prefer. It will be started
+	by default when you press Mod1+Enter, but you can overwrite this. Refer
+	to it as +$terminal+ to keep things modular.
+font::
+	Specifies the default font you want i3 to use. Use an X core font
+	descriptor here, like
+	+-misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1+. You can
+	use +xfontsel(1)+ to pick one.
+
+=== Keyboard bindings
+
+You can use each command (see below) using keyboard bindings. At the moment,
+keyboard bindings require you to specify the keycode (38) of the key, not its key
+symbol ("a"). This has some advantages (keybindings make sense regardless of
+the layout you type) and some disadvantages (hard to remember, you have to look
+them up every time).
+
+*Syntax*:
+--------------------------------
+bind [Modifiers+]keycode command
+--------------------------------
+
+*Examples*:
+--------------------------------
+# Fullscreen
+bind Mod1+41 f
+
+# Restart
+bind Mod1+Shift+27 restart
+--------------------------------
+
+Available Modifiers:
+
+Mod1-Mod5, Shift, Control::
+Standard modifiers, see +xmodmap(1)+
+
+Mode_switch::
+Unlike other window managers, i3 can use Mode_switch as a modifier. This allows
+you to remap capslock (for example) to Mode_switch and use it for both: typing
+umlauts or special characters 'and' having some comfortably reachable key
+bindings. For example, when typing, capslock+1 or capslock+2 for switching
+workspaces is totally convenient. Try it :-).
+
+=== The floating modifier
+
+To move floating windows with your mouse, you can either grab their titlebar
+or configure the so called floating modifier which you can then press and
+click anywhere in the window itself. The most common setup is to configure
+it as the same one you use for managing windows (Mod1 for example). Afterwards,
+you can press Mod1, click into a window using your left mouse button and drag
+it to the position you want it at.
+
+*Syntax*:
+--------------------------------
+floating_modifier <Modifiers>
+--------------------------------
+
+*Examples*:
+--------------------------------
+floating_modifier Mod1
+--------------------------------
+
+
+=== Variables
+
+As you learned in the previous section about keyboard bindings, you will have
+to configure lots of bindings containing modifier keys. If you want to save
+yourself some typing and have the possibility to change the modifier you want
+to use later, variables can be handy.
+
+*Syntax*:
+--------------
+set name value
+--------------
+
+*Examples*:
+------------------------
+set $m Mod1
+bind $m+Shift+27 restart
+------------------------
+
+Variables are directly replaced in the file when parsing, there is no fancy
+handling and there are absolutely no plans to change this. If you need a more
+dynamic configuration, you should create a little script, like when configuring
+wmii.
+
+=== Automatically putting clients on specific workspaces
+
+It is recommended that you match on window classes whereever possible because
+some applications first create their window and then care about setting the
+correct title. Firefox with Vimperator comes to mind, as the window starts up
+being named Firefox and only when Vimperator is loaded, the title changes. As
+i3 will get the title as soon as the application maps the window (mapping means
+actually displaying it on the screen), you’d need to have to match on Firefox
+in this case.
+
+You can use the special workspace +~+ to specify that matching clients should
+be put into floating mode.
+
+*Syntax*:
+----------------------------------------------------
+assign ["]window class[/window title]["] [→] workspace
+----------------------------------------------------
+
+*Examples*:
+----------------------
+assign urxvt 2
+assign urxvt → 2
+assign "urxvt" → 2
+assign "urxvt/VIM" → 3
+assign "gecko" → ~
+----------------------
+
+=== Automatically starting applications on startup
+
+By using the +exec+ keyword outside a keybinding, you can configure which
+commands will be performed by i3 on the first start (not when reloading inplace
+however). The commands will be run in order.
+
+*Syntax*:
+------------
+exec command
+------------
+
+*Examples*:
+--------------------------------
+exec sudo i3status | dzen2 -dock
+--------------------------------
+
+=== Jumping to specific windows
+
+Especially when in a multi-monitor environment, you want to quickly jump to a specific
+window, for example while currently working on workspace 3 you may want to jump to
+your mailclient to mail your boss that you’ve achieved some important goal. Instead
+of figuring out how to navigate to your mailclient, it would be more convenient to
+have a shortcut.
+
+*Syntax*:
+----------------------------------------------------
+jump ["]window class[/window title]["]
+jump workspace [ column row ]
+----------------------------------------------------
+
+You can either use the same matching algorithm as in the +assign+ command (see above)
+or you can specify the position of the client if you always use the same layout.
+
+*Examples*:
+--------------------------------------
+# Get me to the next open VIM instance
+bind Mod1+38 jump "urxvt/VIM"
+--------------------------------------
+
+=== Traveling the focus stack
+
+This mechanism can be thought of as the opposite of the +jump+ command. It travels
+the focus stack and jumps to the window you focused before.
+
+*Syntax*:
+--------------
+focus [number] | floating | tilling | ft
+--------------
+
+Where +number+ by default is 1 meaning that the next client in the focus stack will
+be selected.
+
+The special values have the following meaning:
+
+floating::
+	The next floating window is selected.
+tiling::
+	The next tiling window is selected.
+ft::
+	If the current window is floating, the next tiling window will be selected
+	and vice-versa.
+
+=== Changing colors
+
+You can change all colors which i3 uses to draw the window decorations and the
+bottom bar.
+
+*Syntax*:
+--------------------------------------------
+colorclass border background text
+--------------------------------------------
+
+Where colorclass can be one of:
+
+client.focused::
+	A client which currently has the focus.
+client.focused_inactive::
+	A client which is the focused one of its container, but it does not have
+	the focus at the moment.
+client.unfocused::
+	A client which is not the focused one of its container.
+bar.focused::
+	The current workspace in the bottom bar.
+bar.unfocused::
+	All other workspaces in the bottom bar.
+
+Colors are in HTML hex format, see below.
+
+*Examples*:
+--------------------------------------
+# class        border  backgr. text
+client.focused #2F343A #900000 #FFFFFF
+--------------------------------------

i3.config

@@ -1,11 +1,17 @@
 # This configuration uses Mod1 and Mod3. Make sure they are mapped properly using xev(1)
 # and xmodmap(1). Usually, Mod1 is Alt (Alt_L) and Mod3 is Windows (Super_L)
 
+# Tell i3 about your preferred terminal. You can refer to this as $terminal
+# later. It is recommended to set this option to allow i3 to open a terminal
+# containing the introduction on first start.
 terminal /usr/bin/urxvt
 
 # ISO 10646 = Unicode
 font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
 
+# Use Mouse+Mod1 to drag floating windows to their wanted position
+floating_modifier Mod1
+
 # Fullscreen (Mod1+f)
 bind Mod1+41 f
 
@@ -15,6 +21,13 @@ bind Mod1+43 s
 # Default (Mod1+e)
 bind Mod1+26 d
 
+# Toggle tiling/floating of the current window (Mod1+Shift+Space)
+bind Mod1+Shift+65 t
+
+# Go into the tiling layer / floating layer, depending on whether
+# the current window is tiling / floating (Mod1+t)
+bind Mod1+28 focus ft
+
 # Focus (Mod1+j/k/l/;)
 bind Mod1+44 h
 bind Mod1+45 j

include/client.h

@@ -0,0 +1,78 @@
+/*
+ * vim:ts=8:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ *
+ * (c) 2009 Michael Stapelberg and contributors
+ *
+ * See file LICENSE for license information.
+ *
+ */
+#include <xcb/xcb.h>
+
+#include "data.h"
+
+#ifndef _CLIENT_H
+#define _CLIENT_H
+
+/**
+ * Removes the given client from the container, either because it will be inserted into another
+ * one or because it was unmapped
+ *
+ */
+void client_remove_from_container(xcb_connection_t *conn, Client *client, Container *container, bool remove_from_focusstack);
+
+/**
+ * Warps the pointer into the given client (in the middle of it, to be specific), therefore
+ * selecting it
+ *
+ */
+void client_warp_pointer_into(xcb_connection_t *conn, Client *client);
+
+/**
+ * Kills the given window using WM_DELETE_WINDOW or xcb_kill_window
+ *
+ */
+void client_kill(xcb_connection_t *conn, Client *window);
+
+/**
+ * Checks if the given window class and title match the given client
+ * Window title is passed as "normal" string and as UCS-2 converted string for
+ * matching _NET_WM_NAME capable clients as well as those using legacy hints.
+ *
+ */
+bool client_matches_class_name(Client *client, char *to_class, char *to_title,
+                               char *to_title_ucs, int to_title_ucs_len);
+
+/**
+ * Enters fullscreen mode for the given client. This is called by toggle_fullscreen
+ * and when moving a fullscreen client to another screen.
+ *
+ */
+void client_enter_fullscreen(xcb_connection_t *conn, Client *client);
+
+/**
+ * Toggles fullscreen mode for the given client. It updates the data structures and
+ * reconfigures (= resizes/moves) the client and its frame to the full size of the
+ * screen. When leaving fullscreen, re-rendering the layout is forced.
+ *
+ */
+void client_toggle_fullscreen(xcb_connection_t *conn, Client *client);
+
+/**
+ * Sets the position of the given client in the X stack to the highest (tiling layer is always
+ * on the same position, so this doesn’t matter) below the first floating client, so that
+ * floating windows are always on top.
+ *
+ */
+void client_set_below_floating(xcb_connection_t *conn, Client *client);
+
+/**
+ * Returns true if the client is floating. Makes the code more beatiful, as floating
+ * is not simply a boolean, but also saves whether the user selected the current state
+ * or whether it was automatically set.
+ *
+ */
+bool client_is_floating(Client *client);
+
+#endif

include/config.h

@@ -1,12 +1,56 @@
+/*
+ * vim:ts=8:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ *
+ * © 2009 Michael Stapelberg and contributors
+ *
+ * See file LICENSE for license information.
+ *
+ * include/config.h: Contains all structs/variables for
+ * the configurable part of i3
+ *
+ */
+
 #ifndef _CONFIG_H
 #define _CONFIG_H
 
+#include "queue.h"
+
 typedef struct Config Config;
 extern Config config;
 
+struct Colortriple {
+        uint32_t border;
+        uint32_t background;
+        uint32_t text;
+};
+
+struct Variable {
+        char *key;
+        char *value;
+
+        SLIST_ENTRY(Variable) variables;
+};
+
 struct Config {
-	const char *terminal;
+        const char *terminal;
-	const char *font;
+        const char *font;
+
+        /** The modifier which needs to be pressed in combination with your mouse
+         * buttons to do things with floating windows (move, resize) */
+        uint32_t floating_modifier;
+
+        /* Color codes are stored here */
+        struct config_client {
+                struct Colortriple focused;
+                struct Colortriple focused_inactive;
+                struct Colortriple unfocused;
+        } client;
+        struct config_bar {
+                struct Colortriple focused;
+                struct Colortriple unfocused;
+        } bar;
 };
 
 /**
@@ -16,6 +60,6 @@ struct Config {
  * configuration file.
  *
  */
-void load_configuration(const char *override_configfile);
+void load_configuration(xcb_connection_t *conn, const char *override_configfile);
 
 #endif

include/data.h

@@ -3,7 +3,7 @@
  *
  * i3 - an improved dynamic tiling window manager
  *
- * (c) 2009 Michael Stapelberg and contributors
+ * © 2009 Michael Stapelberg and contributors
  *
  * See file LICENSE for license information.
  *
@@ -161,12 +161,21 @@ struct Workspace {
         int current_row;
         int current_col;
 
+        /* Should clients on this workspace be automatically floating? */
+        bool auto_float;
+        /* Are the floating clients on this workspace currently hidden? */
+        bool floating_hidden;
+
         Client *fullscreen_client;
 
         /* The focus stack contains the clients in the correct order of focus so that
            the focus can be reverted correctly when a client is closed */
         SLIST_HEAD(focus_stack_head, Client) focus_stack;
 
+        /* This tail queue contains the floating clients in order of when they were first
+         * set to floating (new floating clients are just appended) */
+        TAILQ_HEAD(floating_clients_head, Client) floating_clients;
+
         /* Backpointer to the screen this workspace is on */
         i3Screen *screen;
 
@@ -197,6 +206,30 @@ struct Binding {
         TAILQ_ENTRY(Binding) bindings;
 };
 
+/*
+ * Holds a command specified by an exec-line in the config (see src/config.c)
+ *
+ */
+struct Autostart {
+        /* Command, like in command mode */
+        char *command;
+        TAILQ_ENTRY(Autostart) autostarts;
+};
+
+/*
+ * Holds an assignment for a given window class/title to a specific workspace
+ * (see src/config.c)
+ *
+ */
+struct Assignment {
+        char *windowclass_title;
+        /* floating is true if this was an assignment to the special workspace "~".
+         * Matching clients will be put into floating mode automatically. */
+        bool floating;
+        int workspace;
+        TAILQ_ENTRY(Assignment) assignments;
+};
+
 /*
  * Data structure for cached font information:
  * - font id in X11 (load it once)
@@ -221,6 +254,10 @@ struct Font {
  *
  */
 struct Client {
+        /* initialized will be set to true if the client was fully initialized by
+         * manage_window() and all functions can be used normally */
+        bool initialized;
+
         /* if you set a client to floating and set it back to managed, it does remember its old
            position and *tries* to get back there */
         Cell old_position;
@@ -232,6 +269,8 @@ struct Client {
 
         /* x, y, width, height of the frame */
         Rect rect;
+        /* Position in floating mode and in tiling mode are saved separately */
+        Rect floating_rect;
         /* x, y, width, height of the child (relative to its frame) */
         Rect child_rect;
 
@@ -255,9 +294,18 @@ struct Client {
            legacy window names are ignored. */
         bool uses_net_wm_name;
 
+        /* Holds the WM_CLASS, useful for matching the client in commands */
+        char *window_class;
+
         /* fullscreen is pretty obvious */
         bool fullscreen;
 
+        /* floating? (= not in tiling layout) This cannot be simply a bool because we want to keep track
+         * of whether the status was set by the application (by setting WM_CLASS to tools for example) or
+         * by the user. The user’s choice overwrites automatic mode, of course. The order of the values
+         * is important because we check with >= FLOATING_AUTO_ON if a client is floating. */
+        enum { FLOATING_AUTO_OFF = 0, FLOATING_USER_OFF = 1, FLOATING_AUTO_ON = 2, FLOATING_USER_ON = 3 } floating;
+
         /* Ensure TITLEBAR_TOP maps to 0 because we use calloc for initialization later */
         enum { TITLEBAR_TOP = 0, TITLEBAR_LEFT, TITLEBAR_RIGHT, TITLEBAR_BOTTOM, TITLEBAR_OFF } titlebar_position;
 
@@ -283,6 +331,7 @@ struct Client {
         CIRCLEQ_ENTRY(Client) clients;
         SLIST_ENTRY(Client) dock_clients;
         SLIST_ENTRY(Client) focus_clients;
+        TAILQ_ENTRY(Client) floating_clients;
 };
 
 /*

include/floating.h

@@ -0,0 +1,87 @@
+/*
+ * vim:ts=8:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ *
+ * © 2009 Michael Stapelberg and contributors
+ *
+ * See file LICENSE for license information.
+ *
+ */
+#ifndef _FLOATING_H
+#define _FLOATING_H
+
+/** Callback for dragging */
+typedef void(*callback_t)(Rect*, uint32_t, uint32_t);
+
+/** On which border was the dragging initiated? */
+typedef enum { BORDER_LEFT, BORDER_RIGHT, BORDER_TOP, BORDER_BOTTOM} border_t;
+
+/**
+ * Enters floating mode for the given client.
+ * Correctly takes care of the position/size (separately stored for tiling/floating mode)
+ * and repositions/resizes/redecorates the client.
+ *
+ * If the automatic flag is set to true, this was an automatic update by a change of the
+ * window class from the application which can be overwritten by the user.
+ *
+ */
+void toggle_floating_mode(xcb_connection_t *conn, Client *client, bool automatic);
+
+/**
+ * Removes the floating client from its workspace and attaches it to the new workspace.
+ * This is centralized here because it may happen if you move it via keyboard and
+ * if you move it using your mouse.
+ *
+ */
+void floating_assign_to_workspace(Client *client, Workspace *new_workspace);
+
+/**
+ * Called whenever the user clicks on a border (not the titlebar!) of a floating window.
+ * Determines on which border the user clicked and launches the drag_pointer function
+ * with the resize_callback.
+ *
+ */
+int floating_border_click(xcb_connection_t *conn, Client *client, xcb_button_press_event_t *event);
+
+/**
+ * Called when the user clicked on the titlebar of a floating window.
+ * Calls the drag_pointer function with the drag_window callback
+ *
+ */
+void floating_drag_window(xcb_connection_t *conn, Client *client, xcb_button_press_event_t *event);
+
+/**
+ * Changes focus in the given direction for floating clients.
+ *
+ * Changing to the left/right means going to the previous/next floating client,
+ * changing to top/bottom means cycling through the Z-index.
+ *
+ */
+void floating_focus_direction(xcb_connection_t *conn, Client *currently_focused, direction_t direction);
+
+/**
+ * Moves the client 10px to the specified direction.
+ *
+ */
+void floating_move(xcb_connection_t *conn, Client *currently_focused, direction_t direction);
+
+/**
+ * Hides all floating clients (or show them if they are currently hidden) on
+ * the specified workspace.
+ *
+ */
+void floating_toggle_hide(xcb_connection_t *conn, Workspace *workspace);
+
+/**
+ * This function grabs your pointer and lets you drag stuff around (borders).
+ * Every time you move your mouse, an XCB_MOTION_NOTIFY event will be received
+ * and the given callback will be called with the parameters specified (client,
+ * border on which the click originally was), the original rect of the client,
+ * the event and the new coordinates (x, y).
+ *
+ */
+void drag_pointer(xcb_connection_t *conn, Client *client, xcb_button_press_event_t *event,
+                  xcb_window_t confine_to, border_t border, callback_t callback);
+
+#endif

include/handlers.h

@@ -85,7 +85,15 @@ int handle_windowname_change(void *data, xcb_connection_t *conn, uint8_t state,
  *
  */
 int handle_windowname_change_legacy(void *data, xcb_connection_t *conn, uint8_t state,
-                                xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop);
+                                    xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *prop);
+
+/**
+ * Store the window classes for jumping to them later.
+ *
+ */
+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);
+
 
 /**
  * Expose event means we should redraw our windows (= title bar)
@@ -116,4 +124,14 @@ int handle_window_type(void *data, xcb_connection_t *conn, uint8_t state, xcb_wi
 int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
                         xcb_atom_t name, xcb_get_property_reply_t *reply);
 
+/**
+ * Handles the transient for hints set by a window, signalizing that this window is a popup window
+ * for some other window.
+ *
+ * See ICCCM 4.1.2.6 for more details
+ *
+ */
+int handle_transient_for(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
+                         xcb_atom_t name, xcb_get_property_reply_t *reply);
+
 #endif

include/i3.h

@@ -3,7 +3,7 @@
  *
  * i3 - an improved dynamic tiling window manager
  *
- * (c) 2009 Michael Stapelberg and contributors
+ * © 2009 Michael Stapelberg and contributors
  *
  * See file LICENSE for license information.
  *
@@ -20,19 +20,16 @@
 #ifndef _I3_H
 #define _I3_H
 
-#define NUM_ATOMS 13
+#define NUM_ATOMS 17
 
 extern char **start_argv;
 extern Display *xkbdpy;
 extern TAILQ_HEAD(bindings_head, Binding) bindings;
+extern TAILQ_HEAD(autostarts_head, Autostart) autostarts;
+extern TAILQ_HEAD(assignments_head, Assignment) assignments;
 extern SLIST_HEAD(stack_wins_head, Stack_Window) stack_wins;
 extern xcb_event_handlers_t evenths;
 extern int num_screens;
 extern xcb_atom_t atoms[NUM_ATOMS];
 
-void manage_window(xcb_property_handlers_t *prophs, xcb_connection_t *conn, xcb_window_t window, window_attributes_t wa);
-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);
-
 #endif

include/layout.h

@@ -36,6 +36,18 @@ void decorate_window(xcb_connection_t *conn, Client *client, xcb_drawable_t draw
  */
 void redecorate_window(xcb_connection_t *conn, Client *client);
 
+/**
+ * Pushes the client’s x and y coordinates to X11
+ *
+ */
+void reposition_client(xcb_connection_t *conn, Client *client);
+
+/**
+ * Pushes the client’s width/height to X11 and resizes the child window
+ *
+ */
+void resize_client(xcb_connection_t *conn, Client *client);
+
 /**
  * Renders the given container. Is called by render_layout() or individually (for example
  * when focus changes in a stacking container)

include/manage.h

@@ -0,0 +1,42 @@
+/*
+ * vim:ts=8:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ *
+ * (c) 2009 Michael Stapelberg and contributors
+ *
+ * See file LICENSE for license information.
+ *
+ */
+#include <xcb/xcb.h>
+
+#include "data.h"
+
+#ifndef _MANAGE_H
+#define _MANAGE_H
+
+/**
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * 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);
+
+#endif

include/util.h

@@ -25,7 +25,7 @@
                         for (int cols = 0; cols < (workspace)->cols; cols++) \
                                 for (int rows = 0; rows < (workspace)->rows; rows++)
 #define FREE(pointer) do { \
-        if (pointer == NULL) { \
+        if (pointer != NULL) { \
                 free(pointer); \
                 pointer = NULL; \
         } \
@@ -54,7 +54,7 @@ void slog(char *fmt, ...);
  * Prints the message (see printf()) to stderr, then exits the program.
  *
  */
-void die(char *fmt, ...);
+void die(char *fmt, ...) __attribute__((__noreturn__));
 
 /**
  * Safe-wrapper around malloc which exits if malloc returns NULL (meaning that there
@@ -123,13 +123,6 @@ void check_error(xcb_connection_t *conn, xcb_void_cookie_t cookie, char *err_mes
  */
 char *convert_utf8_to_ucs2(char *input, int *real_strlen);
 
-/**
- * Removes the given client from the container, either because it will be inserted into another
- * one or because it was unmapped
- *
- */
-void remove_client_from_container(xcb_connection_t *conn, Client *client, Container *container);
-
 /**
  * Returns the client which comes next in focus stack (= was selected before) for
  * the given container, optionally excluding the given client.
@@ -148,6 +141,17 @@ Client *get_last_focused_client(xcb_connection_t *conn, Container *container, Cl
  */
 void unmap_workspace(xcb_connection_t *conn, Workspace *u_ws);
 
+/**
+ * Unmaps all clients (and stack windows) of the given workspace.
+ *
+ * This needs to be called separately when temporarily rendering
+ * a workspace which is not the active workspace to force
+ * reconfiguration of all clients, like in src/xinerama.c when
+ * re-assigning a workspace to another screen.
+ *
+ */
+void unmap_workspace(xcb_connection_t *conn, Workspace *u_ws);
+
 /**
  * Sets the given client as focused by updating the data structures correctly,
  * updating the X input focus and finally re-decorating both windows (to signalize
@@ -170,24 +174,12 @@ void leave_stack_mode(xcb_connection_t *conn, Container *container);
 void switch_layout_mode(xcb_connection_t *conn, Container *container, int mode);
 
 /**
- * Warps the pointer into the given client (in the middle of it, to be specific), therefore
+ * Gets the first matching client for the given window class/window title.
- * selecting it
+ * If the paramater specific is set to a specific client, only this one
+ * will be checked.
  *
  */
-void warp_pointer_into(xcb_connection_t *conn, Client *client);
+Client *get_matching_client(xcb_connection_t *conn, const char *window_classtitle,
-
+                            Client *specific);
-/**
- * Toggles fullscreen mode for the given client. It updates the data structures and
- * reconfigures (= resizes/moves) the client and its frame to the full size of the
- * screen. When leaving fullscreen, re-rendering the layout is forced.
- *
- */
-void toggle_fullscreen(xcb_connection_t *conn, Client *client);
-
-/**
- * Kills the given window using WM_DELETE_WINDOW or xcb_kill_window
- *
- */
-void kill_window(xcb_connection_t *conn, Client *window);
 
 #endif

include/xcb.h

@@ -49,6 +49,10 @@ enum { _NET_SUPPORTED = 0,
         _NET_WM_STATE,
         _NET_WM_WINDOW_TYPE,
         _NET_WM_WINDOW_TYPE_DOCK,
+        _NET_WM_WINDOW_TYPE_DIALOG,
+        _NET_WM_WINDOW_TYPE_UTILITY,
+        _NET_WM_WINDOW_TYPE_TOOLBAR,
+        _NET_WM_WINDOW_TYPE_SPLASH,
         _NET_WM_DESKTOP,
         _NET_WM_STRUT_PARTIAL,
         WM_PROTOCOLS,
@@ -126,4 +130,10 @@ void fake_absolute_configure_notify(xcb_connection_t *conn, Client *client);
  */
 void xcb_get_numlock_mask(xcb_connection_t *conn);
 
+/**
+ * Raises the given window (typically client->frame) above all other windows
+ *
+ */
+void xcb_raise_window(xcb_connection_t *conn, xcb_window_t window);
+
 #endif

man/asciidoc.conf

@@ -7,7 +7,7 @@ template::[header-declarations]
 <refentrytitle>{mantitle}</refentrytitle>
 <manvolnum>{manvolnum}</manvolnum>
 <refmiscinfo class="source">i3</refmiscinfo>
-<refmiscinfo class="version">alpha</refmiscinfo>
+<refmiscinfo class="version">beta</refmiscinfo>
 <refmiscinfo class="manual">i3 Manual</refmiscinfo>
 </refmeta>
 <refnamediv>

man/i3.man

@@ -1,7 +1,7 @@
 i3(1)
 =====
 Michael Stapelberg <michael+i3@stapelberg.de>
-v3.alpha-bf1, May 2009
+v3.beta, May 2009
 
 == NAME
 
@@ -9,7 +9,15 @@ i3 - an improved dynamic, tiling window manager
 
 == SYNOPSIS
 
-i3 [-c configfile]
+i3 [-c configfile] [-a]
+
+== OPTIONS
+
+-c::
+Specifies an alternate configuration file path
+
+-a::
+Disables autostart.
 
 == DESCRIPTION
 
@@ -98,8 +106,17 @@ Enable stacking layout for the current container.
 Mod1+e::
 Enable default layout for the current container.
 
+Mod1+Shift+Space::
+Toggle tiling/floating for the current window.
+
+Mod1+t::
+Select the first tiling window if the current window is floating and vice-versa.
+
 Mod1+Shift+q::
-Kills the current client.
+Kills the current window. This is equivalent to "clicking on the close button", meaning a polite
+request to the application to close this window. For example, Firefox will save its session
+upon such a request. If the application does not support that, the window will be killed and
+it depends on the application what happens.
 
 Mod1+Shift+r::
 Restarts i3 in place (without losing any windows, but the layout).
@@ -157,6 +174,13 @@ bind Mod1+43 s
 # Default (Mod1+e)
 bind Mod1+26 d
 
+# Toggle tiling/floating of the current window (Mod1+Shift+Space)
+bind Mod1+Shift+65 t
+
+# Go into the tiling layer / floating layer, depending on whether
+# the current window is tiling / floating (Mod1+t)
+bind Mod1+28 focus ft
+
 # Focus (Mod1+j/k/l/;)
 bind Mod1+44 h
 bind Mod1+45 j
@@ -225,6 +249,9 @@ export LC_TELEPHONE=de_DE.UTF-8
 export LC_MEASUREMENT=de_DE.UTF-8
 export LC_IDENTIFICATION=de_DE.UTF-8
 
+# Set background color
+xsetroot -solid "#333333"
+
 # Enable core dumps in case something goes wrong
 ulimit -c unlimited
 
@@ -238,6 +265,14 @@ exec /usr/bin/i3 >> ~/.i3/logfile
 There is still lot of work to do. Please check our bugtracker for up-to-date information
 about tasks which are still not finished.
 
+== SEE ALSO
+
+You should have a copy of the userguide (featuring nice screenshots/graphics which is why this
+is not integrated into this manpage), the debugging guide and the "how to hack" guide. If you
+are building from source, run +make -C docs+.
+
+You can also access these documents online at http://i3.zekjur.net/
+
 == AUTHOR
 
 Michael Stapelberg and contributors

src/client.c

@@ -0,0 +1,250 @@
+/*
+ * vim:ts=8:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ *
+ * © 2009 Michael Stapelberg and contributors
+ *
+ * See file LICENSE for license information.
+ *
+ * client.c: holds all client-specific functions
+ *
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <xcb/xcb.h>
+#include <xcb/xcb_icccm.h>
+
+#include "data.h"
+#include "i3.h"
+#include "xcb.h"
+#include "util.h"
+#include "queue.h"
+#include "layout.h"
+#include "client.h"
+
+/*
+ * Removes the given client from the container, either because it will be inserted into another
+ * one or because it was unmapped
+ *
+ */
+void client_remove_from_container(xcb_connection_t *conn, Client *client, Container *container, bool remove_from_focusstack) {
+        CIRCLEQ_REMOVE(&(container->clients), client, clients);
+
+        if (remove_from_focusstack)
+                SLIST_REMOVE(&(container->workspace->focus_stack), client, Client, focus_clients);
+
+        /* If the container will be empty now and is in stacking mode, we need to
+           unmap the stack_win */
+        if (CIRCLEQ_EMPTY(&(container->clients)) && container->mode == MODE_STACK) {
+                struct Stack_Window *stack_win = &(container->stack_win);
+                stack_win->rect.height = 0;
+                xcb_unmap_window(conn, stack_win->window);
+        }
+}
+
+/*
+ * Warps the pointer into the given client (in the middle of it, to be specific), therefore
+ * selecting it
+ *
+ */
+void client_warp_pointer_into(xcb_connection_t *conn, Client *client) {
+        int mid_x = client->rect.width / 2,
+            mid_y = client->rect.height / 2;
+        xcb_warp_pointer(conn, XCB_NONE, client->child, 0, 0, 0, 0, mid_x, mid_y);
+}
+
+/*
+ * Returns true if the client supports the given protocol atom (like WM_DELETE_WINDOW)
+ *
+ */
+static bool client_supports_protocol(xcb_connection_t *conn, Client *client, xcb_atom_t atom) {
+        xcb_get_property_cookie_t cookie;
+        xcb_get_wm_protocols_reply_t protocols;
+        bool result = false;
+
+        cookie = xcb_get_wm_protocols_unchecked(conn, client->child, atoms[WM_PROTOCOLS]);
+        if (xcb_get_wm_protocols_reply(conn, cookie, &protocols, NULL) != 1)
+                return false;
+
+        /* Check if the client’s protocols have the requested atom set */
+        for (uint32_t i = 0; i < protocols.atoms_len; i++)
+                if (protocols.atoms[i] == atom)
+                        result = true;
+
+        xcb_get_wm_protocols_reply_wipe(&protocols);
+
+        return result;
+}
+
+/*
+ * Kills the given window using WM_DELETE_WINDOW or xcb_kill_window
+ *
+ */
+void client_kill(xcb_connection_t *conn, Client *window) {
+        /* If the client does not support WM_DELETE_WINDOW, we kill it the hard way */
+        if (!client_supports_protocol(conn, window, atoms[WM_DELETE_WINDOW])) {
+                LOG("Killing window the hard way\n");
+                xcb_kill_client(conn, window->child);
+                return;
+        }
+
+        xcb_client_message_event_t ev;
+
+        memset(&ev, 0, sizeof(xcb_client_message_event_t));
+
+        ev.response_type = XCB_CLIENT_MESSAGE;
+        ev.window = window->child;
+        ev.type = atoms[WM_PROTOCOLS];
+        ev.format = 32;
+        ev.data.data32[0] = atoms[WM_DELETE_WINDOW];
+        ev.data.data32[1] = XCB_CURRENT_TIME;
+
+        LOG("Sending WM_DELETE to the client\n");
+        xcb_send_event(conn, false, window->child, XCB_EVENT_MASK_NO_EVENT, (char*)&ev);
+        xcb_flush(conn);
+}
+
+/*
+ * Checks if the given window class and title match the given client
+ * Window title is passed as "normal" string and as UCS-2 converted string for
+ * matching _NET_WM_NAME capable clients as well as those using legacy hints.
+ *
+ */
+bool client_matches_class_name(Client *client, char *to_class, char *to_title,
+                               char *to_title_ucs, int to_title_ucs_len) {
+        /* Check if the given class is part of the window class */
+        if (client->window_class == NULL || strcasestr(client->window_class, to_class) == NULL)
+                return false;
+
+        /* If no title was given, we’re done */
+        if (to_title == NULL)
+                return true;
+
+        if (client->name_len > -1) {
+                /* UCS-2 converted window titles */
+                if (client->name == NULL || memmem(client->name, (client->name_len * 2), to_title_ucs, (to_title_ucs_len * 2)) == NULL)
+                        return false;
+        } else {
+                /* Legacy hints */
+                if (client->name == NULL || strcasestr(client->name, to_title) == NULL)
+                        return false;
+        }
+
+        return true;
+}
+
+/*
+ * Enters fullscreen mode for the given client. This is called by toggle_fullscreen
+ * and when moving a fullscreen client to another screen.
+ *
+ */
+void client_enter_fullscreen(xcb_connection_t *conn, Client *client) {
+        Workspace *workspace = client->workspace;
+
+        if (workspace->fullscreen_client != NULL) {
+                LOG("Not entering fullscreen mode, there already is a fullscreen client.\n");
+                return;
+        }
+
+        client->fullscreen = true;
+        workspace->fullscreen_client = client;
+        LOG("Entering fullscreen mode...\n");
+        /* We just entered fullscreen mode, let’s configure the window */
+        uint32_t mask = XCB_CONFIG_WINDOW_X |
+                        XCB_CONFIG_WINDOW_Y |
+                        XCB_CONFIG_WINDOW_WIDTH |
+                        XCB_CONFIG_WINDOW_HEIGHT;
+        uint32_t values[4] = {workspace->rect.x,
+                              workspace->rect.y,
+                              workspace->rect.width,
+                              workspace->rect.height};
+
+        LOG("child itself will be at %dx%d with size %dx%d\n",
+                        values[0], values[1], values[2], values[3]);
+
+        xcb_configure_window(conn, client->frame, mask, values);
+
+        /* Child’s coordinates are relative to the parent (=frame) */
+        values[0] = 0;
+        values[1] = 0;
+        xcb_configure_window(conn, client->child, mask, values);
+
+        /* Raise the window */
+        values[0] = XCB_STACK_MODE_ABOVE;
+        xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_STACK_MODE, values);
+
+        Rect child_rect = workspace->rect;
+        child_rect.x = child_rect.y = 0;
+        fake_configure_notify(conn, child_rect, client->child);
+
+        xcb_flush(conn);
+}
+
+/*
+ * Toggles fullscreen mode for the given client. It updates the data structures and
+ * reconfigures (= resizes/moves) the client and its frame to the full size of the
+ * screen. When leaving fullscreen, re-rendering the layout is forced.
+ *
+ */
+void client_toggle_fullscreen(xcb_connection_t *conn, Client *client) {
+        /* dock clients cannot enter fullscreen mode */
+        assert(!client->dock);
+
+        Workspace *workspace = client->workspace;
+
+        if (!client->fullscreen) {
+                client_enter_fullscreen(conn, client);
+                return;
+        }
+
+        LOG("leaving fullscreen mode\n");
+        client->fullscreen = false;
+        workspace->fullscreen_client = NULL;
+        if (client_is_floating(client)) {
+                /* For floating clients it’s enough if we just reconfigure that window (in fact,
+                 * re-rendering the layout will not update the client.) */
+                reposition_client(conn, client);
+                resize_client(conn, client);
+                /* redecorate_window flushes */
+                redecorate_window(conn, client);
+        } else {
+                client_set_below_floating(conn, client);
+
+                /* Because the coordinates of the window haven’t changed, it would not be
+                   re-configured if we don’t set the following flag */
+                client->force_reconfigure = true;
+                /* We left fullscreen mode, redraw the whole layout to ensure enternotify events are disabled */
+                render_layout(conn);
+        }
+
+        xcb_flush(conn);
+}
+
+/*
+ * Sets the position of the given client in the X stack to the highest (tiling layer is always
+ * on the same position, so this doesn’t matter) below the first floating client, so that
+ * floating windows are always on top.
+ *
+ */
+void client_set_below_floating(xcb_connection_t *conn, Client *client) {
+        /* Ensure that it is below all floating clients */
+        Client *first_floating = TAILQ_FIRST(&(client->workspace->floating_clients));
+        if (first_floating != TAILQ_END(&(client->workspace->floating_clients))) {
+                LOG("Setting below floating\n");
+                uint32_t values[] = { first_floating->frame, XCB_STACK_MODE_BELOW };
+                xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
+        }
+}
+
+/*
+ * Returns true if the client is floating. Makes the code more beatiful, as floating
+ * is not simply a boolean, but also saves whether the user selected the current state
+ * or whether it was automatically set.
+ *
+ */
+bool client_is_floating(Client *client) {
+        return (client->floating >= FLOATING_AUTO_ON);
+}

src/commands.c

@@ -23,6 +23,9 @@
 #include "layout.h"
 #include "i3.h"
 #include "xinerama.h"
+#include "client.h"
+#include "floating.h"
+#include "xcb.h"
 
 bool focus_window_in_container(xcb_connection_t *conn, Container *container, direction_t direction) {
         /* If this container is empty, we’re done */
@@ -57,10 +60,17 @@ static void focus_thing(xcb_connection_t *conn, direction_t direction, thing_t t
 
         int new_row = current_row,
             new_col = current_col;
-
         Container *container = CUR_CELL;
         Workspace *t_ws = c_ws;
 
+        /* Makes sure new_col and new_row are within bounds of the new workspace */
+        void check_colrow_boundaries() {
+                if (new_col >= t_ws->cols)
+                        new_col = (t_ws->cols - 1);
+                if (new_row >= t_ws->rows)
+                        new_row = (t_ws->rows - 1);
+        }
+
         /* There always is a container. If not, current_col or current_row is wrong */
         assert(container != NULL);
 
@@ -103,6 +113,21 @@ static void focus_thing(xcb_connection_t *conn, direction_t direction, thing_t t
                         t_ws = &(workspaces[screen->current_workspace]);
                         new_row = (direction == D_UP ? (t_ws->rows - 1) : 0);
                 }
+
+                check_colrow_boundaries();
+
+                LOG("new_col = %d, new_row = %d\n", new_col, new_row);
+                if (t_ws->table[new_col][new_row]->currently_focused == NULL) {
+                        LOG("Cell empty, checking for colspanned client above...\n");
+                        for (int cols = 0; cols < new_col; cols += t_ws->table[cols][new_row]->colspan) {
+                                if (new_col > (cols + (t_ws->table[cols][new_row]->colspan - 1)))
+                                        continue;
+
+                                new_col = cols;
+                                break;
+                        }
+                        LOG("Fixed it to new col %d\n", new_col);
+                }
         } else if (direction == D_LEFT || direction == D_RIGHT) {
                 if (direction == D_RIGHT && cell_exists(current_col+1, current_row))
                         new_col = current_col + t_ws->table[current_col][current_row]->colspan;
@@ -130,16 +155,27 @@ static void focus_thing(xcb_connection_t *conn, direction_t direction, thing_t t
                         t_ws = &(workspaces[screen->current_workspace]);
                         new_col = (direction == D_LEFT ? (t_ws->cols - 1) : 0);
                 }
+
+                check_colrow_boundaries();
+
+                LOG("new_col = %d, new_row = %d\n", new_col, new_row);
+                if (t_ws->table[new_col][new_row]->currently_focused == NULL) {
+                        LOG("Cell empty, checking for rowspanned client above...\n");
+                        for (int rows = 0; rows < new_row; rows += t_ws->table[new_col][rows]->rowspan) {
+                                if (new_row > (rows + (t_ws->table[new_col][rows]->rowspan - 1)))
+                                        continue;
+
+                                new_row = rows;
+                                break;
+                        }
+                        LOG("Fixed it to new row %d\n", new_row);
+                }
         } else {
                 LOG("direction unhandled\n");
                 return;
         }
 
-        /* Bounds checking */
+        check_colrow_boundaries();
-        if (new_col >= t_ws->cols)
-                new_col = (t_ws->cols - 1);
-        if (new_row >= t_ws->rows)
-                new_row = (t_ws->rows - 1);
 
         if (t_ws->table[new_col][new_row]->currently_focused != NULL)
                 set_focus(conn, t_ws->table[new_col][new_row]->currently_focused, true);
@@ -237,10 +273,13 @@ static void move_current_window(xcb_connection_t *conn, direction_t direction) {
 
                         new = CUR_TABLE[current_col][++current_row];
                         break;
+                /* To make static analyzers happy: */
+                default:
+                        return;
         }
 
         /* Remove it from the old container and put it into the new one */
-        remove_client_from_container(conn, current_client, container);
+        client_remove_from_container(conn, current_client, container, true);
 
         if (new->currently_focused != NULL)
                 CIRCLEQ_INSERT_AFTER(&(new->clients), new->currently_focused, current_client, clients);
@@ -261,7 +300,8 @@ static void move_current_window(xcb_connection_t *conn, direction_t direction) {
         /* Fix colspan/rowspan if it’d overlap */
         fix_colrowspan(conn, workspace);
 
-        render_layout(conn);
+        render_workspace(conn, workspace->screen, workspace);
+        xcb_flush(conn);
 
         set_focus(conn, current_client, true);
 }
@@ -309,6 +349,9 @@ static void move_current_container(xcb_connection_t *conn, direction_t direction
 
                         new = CUR_TABLE[current_col][++current_row];
                         break;
+                /* To make static analyzers happy: */
+                default:
+                        return;
         }
 
         LOG("old = %d,%d and new = %d,%d\n", container->col, container->row, new->col, new->row);
@@ -415,11 +458,66 @@ static void snap_current_container(xcb_connection_t *conn, direction_t direction
                         container->rowspan++;
                         break;
                 }
+                /* To make static analyzers happy: */
+                default:
+                        return;
         }
 
         render_layout(conn);
 }
 
+static void move_floating_window_to_workspace(xcb_connection_t *conn, Client *client, int workspace) {
+        /* t_ws (to workspace) is just a container pointer to the workspace we’re switching to */
+        Workspace *t_ws = &(workspaces[workspace-1]),
+                  *old_ws = client->workspace;
+
+        LOG("moving floating\n");
+
+        if (t_ws->screen == NULL) {
+                LOG("initializing new workspace, setting num to %d\n", workspace-1);
+                t_ws->screen = c_ws->screen;
+                /* Copy the dimensions from the virtual screen */
+		memcpy(&(t_ws->rect), &(t_ws->screen->rect), sizeof(Rect));
+        } else {
+                /* Check if there is already a fullscreen client on the destination workspace and
+                 * stop moving if so. */
+                if (client->fullscreen && (t_ws->fullscreen_client != NULL)) {
+                        LOG("Not moving: Fullscreen client already existing on destination workspace.\n");
+                        return;
+                }
+        }
+
+        floating_assign_to_workspace(client, t_ws);
+
+        bool target_invisible = t_ws->screen->current_workspace != t_ws->num;
+
+        /* If we’re moving it to an invisible screen, we need to unmap it */
+        if (target_invisible) {
+                LOG("This workspace is not visible, unmapping\n");
+                xcb_unmap_window(conn, client->frame);
+        } else {
+                /* If this is not the case, we move the window to a workspace
+                 * which is on another screen, so we also need to adjust its
+                 * coordinates. */
+                LOG("before x = %d, y = %d\n", client->rect.x, client->rect.y);
+                uint32_t relative_x = client->rect.x - old_ws->rect.x,
+                         relative_y = client->rect.y - old_ws->rect.y;
+                LOG("rel_x = %d, rel_y = %d\n", relative_x, relative_y);
+                client->rect.x = t_ws->rect.x + relative_x;
+                client->rect.y = t_ws->rect.y + relative_y;
+                LOG("after x = %d, y = %d\n", client->rect.x, client->rect.y);
+                reposition_client(conn, client);
+                xcb_flush(conn);
+        }
+
+        LOG("done\n");
+
+        render_layout(conn);
+
+        if (!target_invisible)
+                set_focus(conn, client, true);
+}
+
 /*
  * Moves the currently selected window to the given workspace
  *
@@ -461,14 +559,14 @@ static void move_current_window_to_workspace(xcb_connection_t *conn, int workspa
 
         assert(to_container != NULL);
 
-        remove_client_from_container(conn, current_client, container);
+        client_remove_from_container(conn, current_client, container, true);
         if (container->workspace->fullscreen_client == current_client)
                 container->workspace->fullscreen_client = NULL;
 
+        /* TODO: insert it to the correct position */
         CIRCLEQ_INSERT_TAIL(&(to_container->clients), current_client, clients);
+
         SLIST_INSERT_HEAD(&(to_container->workspace->focus_stack), current_client, focus_clients);
-        if (current_client->fullscreen)
-                t_ws->fullscreen_client = current_client;
         LOG("Moved.\n");
 
         current_client->container = to_container;
@@ -476,16 +574,26 @@ static void move_current_window_to_workspace(xcb_connection_t *conn, int workspa
         container->currently_focused = to_focus;
         to_container->currently_focused = current_client;
 
+        bool target_invisible = (to_container->workspace->screen->current_workspace != to_container->workspace->num);
+
         /* If we’re moving it to an invisible screen, we need to unmap it */
-        if (to_container->workspace->screen->current_workspace != to_container->workspace->num) {
+        if (target_invisible) {
                 LOG("This workspace is not visible, unmapping\n");
                 xcb_unmap_window(conn, current_client->frame);
+        } else {
+                if (current_client->fullscreen) {
+                        LOG("Calling client_enter_fullscreen again\n");
+                        client_enter_fullscreen(conn, current_client);
+                }
         }
 
         /* delete all empty columns/rows */
         cleanup_table(conn, container->workspace);
 
         render_layout(conn);
+
+        if (!target_invisible)
+                set_focus(conn, current_client, true);
 }
 
 /*
@@ -539,22 +647,25 @@ void show_workspace(xcb_connection_t *conn, int workspace) {
 
         /* Check if we need to change something or if we’re already there */
         if (c_ws->screen->current_workspace == (workspace-1)) {
-                if (CUR_CELL->currently_focused != NULL) {
+                Client *last_focused = SLIST_FIRST(&(c_ws->focus_stack));
-                        set_focus(conn, CUR_CELL->currently_focused, true);
+                if (last_focused != SLIST_END(&(c_ws->focus_stack))) {
+                        set_focus(conn, last_focused, true);
                         if (need_warp) {
-                                warp_pointer_into(conn, CUR_CELL->currently_focused);
+                                client_warp_pointer_into(conn, last_focused);
                                 xcb_flush(conn);
                         }
                 }
+
                 return;
         }
 
         t_ws->screen->current_workspace = workspace-1;
-
+        Workspace *old_workspace = c_ws;
-        /* Unmap all clients of the current workspace */
-        unmap_workspace(conn, c_ws);
-
         c_ws = &workspaces[workspace-1];
+
+        /* Unmap all clients of the old workspace */
+        unmap_workspace(conn, old_workspace);
+
         current_row = c_ws->current_row;
         current_col = c_ws->current_col;
         LOG("new current row = %d, current col = %d\n", current_row, current_col);
@@ -566,6 +677,11 @@ void show_workspace(xcb_connection_t *conn, int workspace) {
                 CIRCLEQ_FOREACH(client, &(c_ws->table[cols][rows]->clients), clients)
                         xcb_map_window(conn, client->frame);
 
+        /* Map all floating clients */
+        if (!c_ws->floating_hidden)
+                TAILQ_FOREACH(client, &(c_ws->floating_clients), floating_clients)
+                        xcb_map_window(conn, client->frame);
+
         /* Map all stack windows, if any */
         struct Stack_Window *stack_win;
         SLIST_FOREACH(stack_win, &stack_wins, stack_windows)
@@ -575,10 +691,11 @@ void show_workspace(xcb_connection_t *conn, int workspace) {
         ignore_enter_notify_forall(conn, c_ws, false);
 
         /* Restore focus on the new workspace */
-        if (CUR_CELL->currently_focused != NULL) {
+        Client *last_focused = SLIST_FIRST(&(c_ws->focus_stack));
-                set_focus(conn, CUR_CELL->currently_focused, true);
+        if (last_focused != SLIST_END(&(c_ws->focus_stack))) {
+                set_focus(conn, last_focused, true);
                 if (need_warp) {
-                        warp_pointer_into(conn, CUR_CELL->currently_focused);
+                        client_warp_pointer_into(conn, last_focused);
                         xcb_flush(conn);
                 }
         } else xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, root, XCB_CURRENT_TIME);
@@ -586,12 +703,161 @@ void show_workspace(xcb_connection_t *conn, int workspace) {
         render_layout(conn);
 }
 
+/*
+ * Jumps to the given window class / title.
+ * Title is matched using strstr, that is, matches if it appears anywhere
+ * in the string. Regular expressions seem to be a bit overkill here. However,
+ * if we need them for something else somewhen, we may introduce them here, too.
+ *
+ */
+static void jump_to_window(xcb_connection_t *conn, const char *arguments) {
+        char *classtitle;
+        Client *client;
+
+        /* The first character is a quote, this was checked before */
+        classtitle = sstrdup(arguments+1);
+        /* The last character is a quote, we just set it to NULL */
+        classtitle[strlen(classtitle)-1] = '\0';
+
+        if ((client = get_matching_client(conn, classtitle, NULL)) == NULL) {
+                free(classtitle);
+                LOG("No matching client found.\n");
+                return;
+        }
+
+        free(classtitle);
+        set_focus(conn, client, true);
+}
+
+/*
+ * Jump directly to the specified workspace, row and col.
+ * Great for reaching windows that you always keep in the same spot (hello irssi, I'm looking at you)
+ *
+ */
+static void jump_to_container(xcb_connection_t *conn, const char *arguments) {
+        int ws, row, col;
+        int result;
+
+        result = sscanf(arguments, "%d %d %d", &ws, &col, &row);
+        LOG("Jump called with %d parameters (\"%s\")\n", result, arguments);
+
+        /* No match? Either no arguments were specified, or no numbers */
+        if (result < 1) {
+                LOG("At least one valid argument required\n");
+                return;
+        }
+
+        /* Move to the target workspace */
+        show_workspace(conn, ws);
+
+        if (result < 3)
+                return;
+
+        LOG("Boundary-checking col %d, row %d... (max cols %d, max rows %d)\n", col, row, c_ws->cols, c_ws->rows);
+
+        /* Move to row/col */
+        if (row >= c_ws->rows)
+                row = c_ws->rows - 1;
+        if (col >= c_ws->cols)
+                col = c_ws->cols - 1;
+
+        LOG("Jumping to col %d, row %d\n", col, row);
+        if (c_ws->table[col][row]->currently_focused != NULL)
+                set_focus(conn, c_ws->table[col][row]->currently_focused, true);
+}
+
+/*
+ * Travels the focus stack by the given number of times (or once, if no argument
+ * was specified). That is, selects the window you were in before you focused
+ * the current window.
+ *
+ * The special values 'floating' (select the next floating window), 'tiling'
+ * (select the next tiling window), 'ft' (if the current window is floating,
+ * select the next tiling window and vice-versa) are also valid
+ *
+ */
+static void travel_focus_stack(xcb_connection_t *conn, const char *arguments) {
+        /* Start count at -1 to always skip the first element */
+        int times, count = -1;
+        Client *current;
+        bool floating_criteria;
+
+        /* Either it’s one of the special values… */
+        if (strcasecmp(arguments, "floating") == 0) {
+                floating_criteria = true;
+        } else if (strcasecmp(arguments, "tiling") == 0) {
+                floating_criteria = false;
+        } else if (strcasecmp(arguments, "ft") == 0) {
+                Client *last_focused = SLIST_FIRST(&(c_ws->focus_stack));
+                if (last_focused == SLIST_END(&(c_ws->focus_stack))) {
+                        LOG("Cannot select the next floating/tiling client because there is no client at all\n");
+                        return;
+                }
+
+                floating_criteria = !client_is_floating(last_focused);
+        } else {
+                /* …or a number was specified */
+                if (sscanf(arguments, "%u", &times) != 1) {
+                        LOG("No or invalid argument given (\"%s\"), using default of 1 times\n", arguments);
+                        times = 1;
+                }
+
+                SLIST_FOREACH(current, &(CUR_CELL->workspace->focus_stack), focus_clients) {
+                        if (++count < times) {
+                                LOG("Skipping\n");
+                                continue;
+                        }
+
+                        LOG("Focussing\n");
+                        set_focus(conn, current, true);
+                        break;
+                }
+                return;
+        }
+
+        /* Select the next client matching the criteria parsed above */
+        SLIST_FOREACH(current, &(CUR_CELL->workspace->focus_stack), focus_clients)
+                if (client_is_floating(current) == floating_criteria) {
+                        set_focus(conn, current, true);
+                        break;
+                }
+}
+
+/*
+ * Goes through the list of arguments (for exec()) and checks if the given argument
+ * is present. If not, it copies the arguments (because we cannot realloc it) and
+ * appends the given argument.
+ *
+ */
+static char **append_argument(char **original, char *argument) {
+        int num_args;
+        for (num_args = 0; original[num_args] != NULL; num_args++) {
+                LOG("original argument: \"%s\"\n", original[num_args]);
+                /* If the argument is already present we return the original pointer */
+                if (strcmp(original[num_args], argument) == 0)
+                        return original;
+        }
+        /* Copy the original array */
+        char **result = smalloc((num_args+2) * sizeof(char*));
+        memcpy(result, original, num_args * sizeof(char*));
+        result[num_args] = argument;
+        result[num_args+1] = NULL;
+
+        return result;
+}
+
 /*
  * Parses a command, see file CMDMODE for more information
  *
  */
 void parse_command(xcb_connection_t *conn, const char *command) {
         LOG("--- parsing command \"%s\" ---\n", command);
+        /* Get the first client from focus stack because floating clients are not
+         * in any container, therefore CUR_CELL is not appropriate. */
+        Client *last_focused = SLIST_FIRST(&(c_ws->focus_stack));
+        if (last_focused == SLIST_END(&(c_ws->focus_stack)))
+                last_focused = NULL;
+
         /* Hmm, just to be sure */
         if (command[0] == '\0')
                 return;
@@ -612,37 +878,66 @@ void parse_command(xcb_connection_t *conn, const char *command) {
         /* Is it <restart>? Then restart in place. */
         if (STARTS_WITH(command, "restart")) {
                 LOG("restarting \"%s\"...\n", start_argv[0]);
+                /* make sure -a is in the argument list or append it */
+                start_argv = append_argument(start_argv, "-a");
+
                 execvp(start_argv[0], start_argv);
                 /* not reached */
         }
 
         if (STARTS_WITH(command, "kill")) {
-                if (CUR_CELL->currently_focused == NULL) {
+                if (last_focused == NULL) {
                         LOG("There is no window to kill\n");
                         return;
                 }
 
                 LOG("Killing current window\n");
-                kill_window(conn, CUR_CELL->currently_focused);
+                client_kill(conn, last_focused);
+                return;
+        }
+
+        /* Is it a jump to a specified workspace, row, col? */
+        if (STARTS_WITH(command, "jump ")) {
+                const char *arguments = command + strlen("jump ");
+                if (arguments[0] == '"')
+                        jump_to_window(conn, arguments);
+                else jump_to_container(conn, arguments);
+                return;
+        }
+
+        /* Should we travel the focus stack? */
+        if (STARTS_WITH(command, "focus")) {
+                const char *arguments = command + strlen("focus ");
+                travel_focus_stack(conn, arguments);
                 return;
         }
 
         /* Is it 'f' for fullscreen? */
         if (command[0] == 'f') {
-                if (CUR_CELL->currently_focused == NULL)
+                if (last_focused == NULL)
                         return;
-                toggle_fullscreen(conn, CUR_CELL->currently_focused);
+                client_toggle_fullscreen(conn, last_focused);
                 return;
         }
 
         /* Is it just 's' for stacking or 'd' for default? */
         if ((command[0] == 's' || command[0] == 'd') && (command[1] == '\0')) {
+                if (last_focused == NULL || client_is_floating(last_focused)) {
+                        LOG("not switching, this is a floating client\n");
+                        return;
+                }
                 LOG("Switching mode for current container\n");
                 switch_layout_mode(conn, CUR_CELL, (command[0] == 's' ? MODE_STACK : MODE_DEFAULT));
                 return;
         }
 
-        enum { WITH_WINDOW, WITH_CONTAINER } with = WITH_WINDOW;
+        if (command[0] == 'H') {
+                LOG("Hiding all floating windows\n");
+                floating_toggle_hide(conn, c_ws);
+                return;
+        }
+
+        enum { WITH_WINDOW, WITH_CONTAINER, WITH_WORKSPACE } with = WITH_WINDOW;
 
         /* Is it a <with>? */
         if (command[0] == 'w') {
@@ -651,13 +946,44 @@ void parse_command(xcb_connection_t *conn, const char *command) {
                 if (command[0] == 'c') {
                         with = WITH_CONTAINER;
                         command++;
+                } else if (command[0] == 'w') {
+                        with = WITH_WORKSPACE;
+                        command++;
                 } else {
                         LOG("not yet implemented.\n");
                         return;
                 }
         }
 
-        /* It's a normal <cmd> */
+        /* Is it 't' for toggle tiling/floating? */
+        if (command[0] == 't') {
+                if (with == WITH_WORKSPACE) {
+                        c_ws->auto_float = !c_ws->auto_float;
+                        LOG("autofloat is now %d\n", c_ws->auto_float);
+                        return;
+                }
+                if (last_focused == NULL) {
+                        LOG("Cannot toggle tiling/floating: workspace empty\n");
+                        return;
+                }
+
+                toggle_floating_mode(conn, last_focused, false);
+                /* delete all empty columns/rows */
+                cleanup_table(conn, last_focused->workspace);
+
+                /* Fix colspan/rowspan if it’d overlap */
+                fix_colrowspan(conn, last_focused->workspace);
+
+                render_workspace(conn, last_focused->workspace->screen, last_focused->workspace);
+
+                /* Re-focus the client because cleanup_table sets the focus to the last
+                 * focused client inside a container only. */
+                set_focus(conn, last_focused, true);
+
+                return;
+        }
+
+        /* It’s a normal <cmd> */
         char *rest = NULL;
         enum { ACTION_FOCUS, ACTION_MOVE, ACTION_SNAP } action = ACTION_FOCUS;
         direction_t direction;
@@ -668,7 +994,7 @@ void parse_command(xcb_connection_t *conn, const char *command) {
         }
 
         if (*rest == '\0') {
-                /* No rest? This was a tag number, not a times specification */
+                /* No rest? This was a workspace number, not a times specification */
                 show_workspace(conn, times);
                 return;
         }
@@ -686,7 +1012,20 @@ void parse_command(xcb_connection_t *conn, const char *command) {
         }
 
         if (*rest == '\0') {
-                move_current_window_to_workspace(conn, workspace);
+                if (last_focused != NULL && client_is_floating(last_focused))
+                        move_floating_window_to_workspace(conn, last_focused, workspace);
+                else move_current_window_to_workspace(conn, workspace);
+                return;
+        }
+
+        if (last_focused == NULL) {
+                LOG("Not performing (no window found)\n");
+                return;
+        }
+
+        if (client_is_floating(last_focused) &&
+            (action != ACTION_FOCUS && action != ACTION_MOVE)) {
+                LOG("Not performing (floating)\n");
                 return;
         }
 
@@ -704,18 +1043,32 @@ void parse_command(xcb_connection_t *conn, const char *command) {
                         LOG("unknown direction: %c\n", *rest);
                         return;
                 }
+                rest++;
 
-                if (action == ACTION_FOCUS)
+                if (action == ACTION_FOCUS) {
+                        if (client_is_floating(last_focused)) {
+                                floating_focus_direction(conn, last_focused, direction);
+                                continue;
+                        }
                         focus_thing(conn, direction, (with == WITH_WINDOW ? THING_WINDOW : THING_CONTAINER));
-                else if (action == ACTION_MOVE) {
+                        continue;
+                }
+
+                if (action == ACTION_MOVE) {
+                        if (client_is_floating(last_focused)) {
+                                floating_move(conn, last_focused, direction);
+                                continue;
+                        }
                         if (with == WITH_WINDOW)
                                 move_current_window(conn, direction);
                         else move_current_container(conn, direction);
+                        continue;
                 }
-                else if (action == ACTION_SNAP)
-                        snap_current_container(conn, direction);
 
-                rest++;
+                if (action == ACTION_SNAP) {
+                        snap_current_container(conn, direction);
+                        continue;
+                }
         }
 
         LOG("--- done ---\n");

src/config.c

@@ -17,6 +17,7 @@
 #include "i3.h"
 #include "util.h"
 #include "config.h"
+#include "xcb.h"
 
 Config config;
 
@@ -25,14 +26,36 @@ Config config;
  *
  */
 static char *glob_path(const char *path) {
-	static glob_t globbuf;
+        static glob_t globbuf;
-	if (glob(path, GLOB_NOCHECK | GLOB_TILDE, NULL, &globbuf) < 0)
+        if (glob(path, GLOB_NOCHECK | GLOB_TILDE, NULL, &globbuf) < 0)
-		die("glob() failed");
+                die("glob() failed");
-	char *result = sstrdup(globbuf.gl_pathc > 0 ? globbuf.gl_pathv[0] : path);
+        char *result = sstrdup(globbuf.gl_pathc > 0 ? globbuf.gl_pathv[0] : path);
-	globfree(&globbuf);
+        globfree(&globbuf);
-	return result;
+        return result;
 }
 
+/*
+ * This function does a very simple replacement of each instance of key with value.
+ *
+ */
+static void replace_variable(char *buffer, const char *key, const char *value) {
+        char *pos;
+        /* To prevent endless recursions when the user makes an error configuring,
+         * we stop after 100 replacements. That should be vastly more than enough. */
+        int c = 0;
+        LOG("Replacing %s with %s\n", key, value);
+        while ((pos = strcasestr(buffer, key)) != NULL && c++ < 100) {
+                LOG("replacing variable %s in \"%s\" with \"%s\"\n", key, buffer, value);
+                char *rest = pos + strlen(key);
+                *pos = '\0';
+                char *replaced;
+                asprintf(&replaced, "%s%s%s", buffer, value, rest);
+                /* Hm, this is a bit ugly, but sizeof(buffer) = 4, as it’s just a pointer.
+                 * So we need to hard-code the dimensions here. */
+                strncpy(buffer, replaced, 1026);
+                free(replaced);
+        }
+}
 
 /*
  * Reads the configuration from ~/.i3/config or /etc/i3/config if not found.
@@ -41,7 +64,9 @@ static char *glob_path(const char *path) {
  * configuration file.
  *
  */
-void load_configuration(const char *override_configpath) {
+void load_configuration(xcb_connection_t *conn, const char *override_configpath) {
+        SLIST_HEAD(variables_head, Variable) variables;
+
 #define OPTION_STRING(name) \
         if (strcasecmp(key, #name) == 0) { \
                 config.name = sstrdup(value); \
@@ -52,9 +77,51 @@ void load_configuration(const char *override_configpath) {
         if (config.name == NULL) \
                 die("You did not specify required configuration option " #name "\n");
 
+#define OPTION_COLORTRIPLE(opt, name) \
+        if (strcasecmp(key, opt) == 0) { \
+                char border[8], background[8], text[8]; \
+                memset(border, 0, sizeof(border)); \
+                memset(background, 0, sizeof(background)); \
+                memset(text, 0, sizeof(text)); \
+                border[0] = background[0] = text[0] = '#'; \
+                if (sscanf(value, "#%06[0-9a-fA-F] #%06[0-9a-fA-F] #%06[0-9a-fA-F]", \
+                    border + 1, background + 1, text + 1) != 3 || \
+                    strlen(border) != 7 || \
+                    strlen(background) != 7 || \
+                    strlen(text) != 7) \
+                        die("invalid color code line: %s\n", value); \
+                config.name.border = get_colorpixel(conn, border); \
+                config.name.background = get_colorpixel(conn, background); \
+                config.name.text = get_colorpixel(conn, text); \
+                continue; \
+        }
+
         /* Clear the old config or initialize the data structure */
         memset(&config, 0, sizeof(config));
 
+        SLIST_INIT(&variables);
+
+        /* Initialize default colors */
+        config.client.focused.border = get_colorpixel(conn, "#4c7899");
+        config.client.focused.background = get_colorpixel(conn, "#285577");
+        config.client.focused.text = get_colorpixel(conn, "#ffffff");
+
+        config.client.focused_inactive.border = get_colorpixel(conn, "#4c7899");
+        config.client.focused_inactive.background = get_colorpixel(conn, "#555555");
+        config.client.focused_inactive.text = get_colorpixel(conn, "#ffffff");
+
+        config.client.unfocused.border = get_colorpixel(conn, "#333333");
+        config.client.unfocused.background = get_colorpixel(conn, "#222222");
+        config.client.unfocused.text = get_colorpixel(conn, "#888888");
+
+        config.bar.focused.border = get_colorpixel(conn, "#4c7899");
+        config.bar.focused.background = get_colorpixel(conn, "#285577");
+        config.bar.focused.text = get_colorpixel(conn, "#ffffff");
+
+        config.bar.unfocused.border = get_colorpixel(conn, "#333333");
+        config.bar.unfocused.background = get_colorpixel(conn, "#222222");
+        config.bar.unfocused.text = get_colorpixel(conn, "#888888");
+
         FILE *handle;
         if (override_configpath != NULL) {
                 if ((handle = fopen(override_configpath, "r")) == NULL)
@@ -77,6 +144,14 @@ void load_configuration(const char *override_configpath) {
                         die("Could not read configuration file\n");
                 }
 
+                if (config.terminal != NULL)
+                        replace_variable(buffer, "$terminal", config.terminal);
+
+                /* Replace all custom variables */
+                struct Variable *current;
+                SLIST_FOREACH(current, &variables, variables)
+                        replace_variable(buffer, current->key, current->value);
+
                 /* sscanf implicitly strips whitespace. Also, we skip comments and empty lines. */
                 if (sscanf(buffer, "%s %[^\n]", key, value) < 1 ||
                     key[0] == '#' || strlen(key) < 3)
@@ -85,6 +160,22 @@ void load_configuration(const char *override_configpath) {
                 OPTION_STRING(terminal);
                 OPTION_STRING(font);
 
+                /* Colors */
+                OPTION_COLORTRIPLE("client.focused", client.focused);
+                OPTION_COLORTRIPLE("client.focused_inactive", client.focused_inactive);
+                OPTION_COLORTRIPLE("client.unfocused", client.unfocused);
+                OPTION_COLORTRIPLE("bar.focused", bar.focused);
+                OPTION_COLORTRIPLE("bar.unfocused", bar.unfocused);
+
+                /* exec-lines (autostart) */
+                if (strcasecmp(key, "exec") == 0) {
+                        struct Autostart *new = smalloc(sizeof(struct Autostart));
+                        new->command = sstrdup(value);
+                        TAILQ_INSERT_TAIL(&autostarts, new, autostarts);
+                        continue;
+                }
+
+                /* key bindings */
                 if (strcasecmp(key, "bind") == 0) {
                         #define CHECK_MODIFIER(name) \
                                 if (strncasecmp(walk, #name, strlen(#name)) == 0) { \
@@ -124,13 +215,105 @@ void load_configuration(const char *override_configpath) {
                         continue;
                 }
 
-                fprintf(stderr, "Unknown configfile option: %s\n", key);
+                if (strcasecmp(key, "floating_modifier") == 0) {
-                exit(1);
+                        char *walk = value;
+                        uint32_t modifiers = 0;
+
+                        while (*walk != '\0') {
+                                /* Need to check for Mod1-5, Ctrl, Shift, Mode_switch */
+                                CHECK_MODIFIER(SHIFT);
+                                CHECK_MODIFIER(CONTROL);
+                                CHECK_MODIFIER(MODE_SWITCH);
+                                CHECK_MODIFIER(MOD1);
+                                CHECK_MODIFIER(MOD2);
+                                CHECK_MODIFIER(MOD3);
+                                CHECK_MODIFIER(MOD4);
+                                CHECK_MODIFIER(MOD5);
+
+                                /* No modifier found? Then we’re done with this step */
+                                break;
+                        }
+
+                        LOG("Floating modifiers = %d\n", modifiers);
+                        config.floating_modifier = modifiers;
+                        continue;
+                }
+
+                /* assign window class[/window title] → workspace */
+                if (strcasecmp(key, "assign") == 0) {
+                        LOG("assign: \"%s\"\n", value);
+                        char *class_title = sstrdup(value);
+                        char *target;
+
+                        /* If the window class/title is quoted we skip quotes */
+                        if (class_title[0] == '"') {
+                                class_title++;
+                                char *end = strchr(class_title, '"');
+                                if (end == NULL)
+                                        die("Malformed assignment, couldn't find terminating quote\n");
+                                *end = '\0';
+                        } else {
+                                /* If it is not quoted, we terminate it at the first space */
+                                char *end = strchr(class_title, ' ');
+                                if (end == NULL)
+                                        die("Malformed assignment, couldn't find terminating space\n");
+                                *end = '\0';
+                        }
+
+                        /* The target is the last argument separated by a space */
+                        if ((target = strrchr(value, ' ')) == NULL)
+                                die("Malformed assignment, couldn't find target\n");
+                        target++;
+
+                        if (*target != '~' && (atoi(target) < 1 || atoi(target) > 10))
+                                die("Malformed assignment, invalid workspace number\n");
+
+                        LOG("assignment parsed: \"%s\" to \"%s\"\n", class_title, target);
+
+                        struct Assignment *new = scalloc(sizeof(struct Assignment));
+                        new->windowclass_title = class_title;
+                        if (*target == '~')
+                                new->floating = true;
+                        else new->workspace = atoi(target);
+                        TAILQ_INSERT_TAIL(&assignments, new, assignments);
+                        continue;
+                }
+
+                /* set a custom variable */
+                if (strcasecmp(key, "set") == 0) {
+                        if (value[0] != '$')
+                                die("Malformed variable assignment, name has to start with $\n");
+
+                        /* get key/value for this variable */
+                        char *v_key = value, *v_value;
+                        if ((v_value = strstr(value, " ")) == NULL)
+                                die("Malformed variable assignment, need a value\n");
+
+                        *(v_value++) = '\0';
+
+                        struct Variable *new = scalloc(sizeof(struct Variable));
+                        new->key = sstrdup(v_key);
+                        new->value = sstrdup(v_value);
+                        SLIST_INSERT_HEAD(&variables, new, variables);
+                        LOG("Got new variable %s = %s\n", v_key, v_value);
+                        continue;
+                }
+
+                die("Unknown configfile option: %s\n", key);
         }
         fclose(handle);
 
         REQUIRED_OPTION(terminal);
         REQUIRED_OPTION(font);
 
+
+        while (!SLIST_EMPTY(&variables)) {
+                struct Variable *v = SLIST_FIRST(&variables);
+                SLIST_REMOVE_HEAD(&variables, variables);
+                free(v->key);
+                free(v->value);
+                free(v);
+        }
+ 
         return;
 }

src/floating.c

@@ -0,0 +1,433 @@
+/*
+ * vim:ts=8:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ *
+ * © 2009 Michael Stapelberg and contributors
+ *
+ * See file LICENSE for license information.
+ *
+ * src/floating.c: contains all functions for handling floating clients
+ *
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <xcb/xcb.h>
+#include <xcb/xcb_event.h>
+
+#include "i3.h"
+#include "config.h"
+#include "data.h"
+#include "util.h"
+#include "xcb.h"
+#include "debug.h"
+#include "layout.h"
+#include "client.h"
+#include "floating.h"
+
+/*
+ * Toggles floating mode for the given client.
+ * Correctly takes care of the position/size (separately stored for tiling/floating mode)
+ * and repositions/resizes/redecorates the client.
+ *
+ * If the automatic flag is set to true, this was an automatic update by a change of the
+ * window class from the application which can be overwritten by the user.
+ *
+ */
+void toggle_floating_mode(xcb_connection_t *conn, Client *client, bool automatic) {
+        Container *con = client->container;
+        i3Font *font = load_font(conn, config.font);
+
+        if (con == NULL) {
+                LOG("This client is already in floating (container == NULL), re-inserting\n");
+                Client *next_tiling;
+                SLIST_FOREACH(next_tiling, &(client->workspace->focus_stack), focus_clients)
+                        if (!client_is_floating(next_tiling))
+                                break;
+                /* If there are no tiling clients on this workspace, there can only be one
+                 * container: the first one */
+                if (next_tiling == TAILQ_END(&(client->workspace->focus_stack)))
+                        con = client->workspace->table[0][0];
+                else con = next_tiling->container;
+
+                /* Remove the client from the list of floating clients */
+                TAILQ_REMOVE(&(client->workspace->floating_clients), client, floating_clients);
+
+                LOG("destination container = %p\n", con);
+                Client *old_focused = con->currently_focused;
+                /* Preserve position/size */
+                memcpy(&(client->floating_rect), &(client->rect), sizeof(Rect));
+
+                client->floating = FLOATING_USER_OFF;
+                client->container = con;
+
+                if (old_focused != NULL && !old_focused->dock)
+                        CIRCLEQ_INSERT_AFTER(&(con->clients), old_focused, client, clients);
+                else CIRCLEQ_INSERT_TAIL(&(con->clients), client, clients);
+
+                LOG("Re-inserted the client into the matrix.\n");
+                con->currently_focused = client;
+
+                client_set_below_floating(conn, client);
+
+                render_container(conn, con);
+                xcb_flush(conn);
+
+                return;
+        }
+
+        LOG("Entering floating for client %08x\n", client->child);
+
+        /* Remove the client of its container */
+        client_remove_from_container(conn, client, con, false);
+        client->container = NULL;
+
+        /* Add the client to the list of floating clients for its workspace */
+        TAILQ_INSERT_TAIL(&(client->workspace->floating_clients), client, floating_clients);
+
+        if (con->currently_focused == client) {
+                LOG("Need to re-adjust currently_focused\n");
+                /* Get the next client in the focus stack for this particular container */
+                con->currently_focused = get_last_focused_client(conn, con, NULL);
+        }
+
+        if (automatic)
+                client->floating = FLOATING_AUTO_ON;
+        else client->floating = FLOATING_USER_ON;
+
+        /* Initialize the floating position from the position in tiling mode, if this
+         * client never was floating (x == -1) */
+        if (client->floating_rect.x == -1) {
+                /* Copy over the position */
+                client->floating_rect.x = client->rect.x;
+                client->floating_rect.y = client->rect.y;
+
+                /* Copy size the other direction */
+                client->child_rect.width = client->floating_rect.width;
+                client->child_rect.height = client->floating_rect.height;
+
+                client->rect.width = client->child_rect.width + 2 + 2;
+                client->rect.height = client->child_rect.height + (font->height + 2 + 2) + 2;
+
+                LOG("copying size from tiling (%d, %d) size (%d, %d)\n", client->floating_rect.x, client->floating_rect.y,
+                                client->floating_rect.width, client->floating_rect.height);
+        } else {
+                /* If the client was already in floating before we restore the old position / size */
+                LOG("using: (%d, %d) size (%d, %d)\n", client->floating_rect.x, client->floating_rect.y,
+                        client->floating_rect.width, client->floating_rect.height);
+                memcpy(&(client->rect), &(client->floating_rect), sizeof(Rect));
+        }
+
+        /* Raise the client */
+        xcb_raise_window(conn, client->frame);
+        reposition_client(conn, client);
+        resize_client(conn, client);
+        /* redecorate_window flushes */
+        redecorate_window(conn, client);
+
+        /* Re-render the tiling layout of this container */
+        render_container(conn, con);
+        xcb_flush(conn);
+}
+
+/*
+ * Removes the floating client from its workspace and attaches it to the new workspace.
+ * This is centralized here because it may happen if you move it via keyboard and
+ * if you move it using your mouse.
+ *
+ */
+void floating_assign_to_workspace(Client *client, Workspace *new_workspace) {
+        /* Remove from focus stack and list of floating clients */
+        SLIST_REMOVE(&(client->workspace->focus_stack), client, Client, focus_clients);
+        TAILQ_REMOVE(&(client->workspace->floating_clients), client, floating_clients);
+
+        if (client->workspace->fullscreen_client == client)
+                client->workspace->fullscreen_client = NULL;
+
+        /* Insert into destination focus stack and list of floating clients */
+        client->workspace = new_workspace;
+        SLIST_INSERT_HEAD(&(client->workspace->focus_stack), client, focus_clients);
+        TAILQ_INSERT_TAIL(&(client->workspace->floating_clients), client, floating_clients);
+        if (client->fullscreen)
+                client->workspace->fullscreen_client = client;
+
+}
+
+/*
+ * Called whenever the user clicks on a border (not the titlebar!) of a floating window.
+ * Determines on which border the user clicked and launches the drag_pointer function
+ * with the resize_callback.
+ *
+ */
+int floating_border_click(xcb_connection_t *conn, Client *client, xcb_button_press_event_t *event) {
+
+        LOG("floating border click\n");
+
+        border_t border;
+
+        void resize_callback(Rect *old_rect, uint32_t new_x, uint32_t new_y) {
+                switch (border) {
+                        case BORDER_RIGHT: {
+                                int new_width = old_rect->width + (new_x - event->root_x);
+                                if ((new_width < 0) ||
+                                    (new_width < 50 && client->rect.width >= new_width))
+                                        return;
+                                client->rect.width = new_width;
+                                break;
+                        }
+
+                        case BORDER_BOTTOM: {
+                                int new_height = old_rect->height + (new_y - event->root_y);
+                                if ((new_height < 0) ||
+                                    (new_height < 20 && client->rect.height >= new_height))
+                                        return;
+                                client->rect.height = old_rect->height + (new_y - event->root_y);
+                                break;
+                        }
+
+                        case BORDER_TOP: {
+                                int new_height = old_rect->height + (event->root_y - new_y);
+                                if ((new_height < 0) ||
+                                    (new_height < 20 && client->rect.height >= new_height))
+                                        return;
+
+                                client->rect.y = old_rect->y + (new_y - event->root_y);
+                                client->rect.height = new_height;
+                                break;
+                        }
+
+                        case BORDER_LEFT: {
+                                int new_width = old_rect->width + (event->root_x - new_x);
+                                if ((new_width < 0) ||
+                                    (new_width < 50 && client->rect.width >= new_width))
+                                        return;
+                                client->rect.x = old_rect->x + (new_x - event->root_x);
+                                client->rect.width = new_width;
+                                break;
+                        }
+                }
+
+                /* Push the new position/size to X11 */
+                reposition_client(conn, client);
+                resize_client(conn, client);
+                xcb_flush(conn);
+        }
+
+        if (event->event_y < 2)
+                border = BORDER_TOP;
+        else if (event->event_y >= (client->rect.height - 2))
+                border = BORDER_BOTTOM;
+        else if (event->event_x <= 2)
+                border = BORDER_LEFT;
+        else if (event->event_x >= (client->rect.width - 2))
+                border = BORDER_RIGHT;
+        else {
+                LOG("Not on any border, not doing anything.\n");
+                return 1;
+        }
+
+        LOG("border = %d\n", border);
+
+        drag_pointer(conn, client, event, XCB_NONE, border, resize_callback);
+
+        return 1;
+}
+
+
+/*
+ * Called when the user clicked on the titlebar of a floating window.
+ * Calls the drag_pointer function with the drag_window callback
+ *
+ */
+void floating_drag_window(xcb_connection_t *conn, Client *client, xcb_button_press_event_t *event) {
+        LOG("floating_drag_window\n");
+
+        void drag_window_callback(Rect *old_rect, uint32_t new_x, uint32_t new_y) {
+                /* Reposition the client correctly while moving */
+                client->rect.x = old_rect->x + (new_x - event->root_x);
+                client->rect.y = old_rect->y + (new_y - event->root_y);
+                reposition_client(conn, client);
+                /* Because reposition_client does not send a faked configure event (only resize does),
+                 * we need to initiate that on our own */
+                fake_absolute_configure_notify(conn, client);
+                /* fake_absolute_configure_notify flushes */
+        }
+
+
+        drag_pointer(conn, client, event, XCB_NONE, BORDER_TOP /* irrelevant */, drag_window_callback);
+}
+
+/*
+ * This function grabs your pointer and lets you drag stuff around (borders).
+ * Every time you move your mouse, an XCB_MOTION_NOTIFY event will be received
+ * and the given callback will be called with the parameters specified (client,
+ * border on which the click originally was), the original rect of the client,
+ * the event and the new coordinates (x, y).
+ *
+ */
+void drag_pointer(xcb_connection_t *conn, Client *client, xcb_button_press_event_t *event,
+                  xcb_window_t confine_to, border_t border, callback_t callback) {
+        xcb_window_t root = xcb_setup_roots_iterator(xcb_get_setup(conn)).data->root;
+        uint32_t new_x, new_y;
+        Rect old_rect;
+        if (client != NULL)
+                memcpy(&old_rect, &(client->rect), sizeof(Rect));
+
+        /* Grab the pointer */
+        /* TODO: returncode */
+        xcb_grab_pointer(conn, 
+                        false,               /* get all pointer events specified by the following mask */
+                        root,                /* grab the root window */
+                        XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION, /* which events to let through */
+                        XCB_GRAB_MODE_ASYNC, /* pointer events should continue as normal */
+                        XCB_GRAB_MODE_ASYNC, /* keyboard mode */
+                        confine_to,          /* confine_to = in which window should the cursor stay */
+                        XCB_NONE,            /* don’t display a special cursor */
+                        XCB_CURRENT_TIME);
+
+        /* Go into our own event loop */
+        xcb_flush(conn);
+
+        xcb_generic_event_t *inside_event, *last_motion_notify = NULL;
+        /* I’ve always wanted to have my own eventhandler… */
+        while ((inside_event = xcb_wait_for_event(conn))) {
+                /* We now handle all events we can get using xcb_poll_for_event */
+                do {
+                        /* Same as get_event_handler in xcb */
+                        int nr = inside_event->response_type;
+                        if (nr == 0) {
+                                /* An error occured */
+                                handle_event(NULL, conn, inside_event);
+                                free(inside_event);
+                                continue;
+                        }
+                        assert(nr < 256);
+                        nr &= XCB_EVENT_RESPONSE_TYPE_MASK;
+                        assert(nr >= 2);
+
+                        switch (nr) {
+                                case XCB_BUTTON_RELEASE:
+                                        goto done;
+
+                                case XCB_MOTION_NOTIFY:
+                                        /* motion_notify events are saved for later */
+                                        FREE(last_motion_notify);
+                                        last_motion_notify = inside_event;
+
+                                        break;
+                                default:
+                                        LOG("Passing to original handler\n");
+                                        /* Use original handler */
+                                        xcb_event_handle(&evenths, inside_event);
+                                        break;
+                        }
+                        if (last_motion_notify != inside_event)
+                                free(inside_event);
+                } while ((inside_event = xcb_poll_for_event(conn)) != NULL);
+
+                if (last_motion_notify == NULL)
+                        continue;
+
+                new_x = ((xcb_motion_notify_event_t*)last_motion_notify)->root_x;
+                new_y = ((xcb_motion_notify_event_t*)last_motion_notify)->root_y;
+
+                callback(&old_rect, new_x, new_y);
+                FREE(last_motion_notify);
+        }
+done:
+        xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
+        xcb_flush(conn);
+}
+
+/*
+ * Changes focus in the given direction for floating clients.
+ *
+ * Changing to the left/right means going to the previous/next floating client,
+ * changing to top/bottom means cycling through the Z-index.
+ *
+ */
+void floating_focus_direction(xcb_connection_t *conn, Client *currently_focused, direction_t direction) {
+        LOG("floating focus\n");
+
+        if (direction == D_LEFT || direction == D_RIGHT) {
+                /* Go to the next/previous floating client */
+                Client *client;
+
+                while ((client = (direction == D_LEFT ? TAILQ_PREV(currently_focused, floating_clients_head, floating_clients) :
+                                                        TAILQ_NEXT(currently_focused, floating_clients))) !=
+                       TAILQ_END(&(currently_focused->workspace->floating_clients))) {
+                        if (!client->floating)
+                                continue;
+                        set_focus(conn, client, true);
+                        return;
+                }
+        }
+}
+
+/*
+ * Moves the client 10px to the specified direction.
+ *
+ */
+void floating_move(xcb_connection_t *conn, Client *currently_focused, direction_t direction) {
+        LOG("floating move\n");
+
+        switch (direction) {
+                case D_LEFT:
+                        if (currently_focused->rect.x < 10)
+                                return;
+                        currently_focused->rect.x -= 10;
+                        break;
+                case D_RIGHT:
+                        currently_focused->rect.x += 10;
+                        break;
+                case D_UP:
+                        if (currently_focused->rect.y < 10)
+                                return;
+                        currently_focused->rect.y -= 10;
+                        break;
+                case D_DOWN:
+                        currently_focused->rect.y += 10;
+                        break;
+                /* to make static analyzers happy */
+                default:
+                        break;
+        }
+
+        reposition_client(conn, currently_focused);
+
+        /* Because reposition_client does not send a faked configure event (only resize does),
+         * we need to initiate that on our own */
+        fake_absolute_configure_notify(conn, currently_focused);
+        /* fake_absolute_configure_notify flushes */
+}
+
+/*
+ * Hides all floating clients (or show them if they are currently hidden) on
+ * the specified workspace.
+ *
+ */
+void floating_toggle_hide(xcb_connection_t *conn, Workspace *workspace) {
+        Client *client;
+
+        workspace->floating_hidden = !workspace->floating_hidden;
+        LOG("floating_hidden is now: %d\n", workspace->floating_hidden);
+        TAILQ_FOREACH(client, &(workspace->floating_clients), floating_clients) {
+                if (workspace->floating_hidden)
+                        xcb_unmap_window(conn, client->frame);
+                else xcb_map_window(conn, client->frame);
+        }
+
+        /* If we just unmapped all floating windows we should ensure that the focus
+         * is set correctly, that ist, to the first non-floating client in stack */
+        if (workspace->floating_hidden)
+                SLIST_FOREACH(client, &(workspace->focus_stack), focus_clients) {
+                        if (client_is_floating(client))
+                                continue;
+                        set_focus(conn, client, true);
+                        return;
+                }
+
+        xcb_flush(conn);
+}

src/handlers.c

@@ -32,6 +32,9 @@
 #include "config.h"
 #include "queue.h"
 #include "resize.h"
+#include "client.h"
+#include "manage.h"
+#include "floating.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
@@ -149,7 +152,7 @@ int handle_enter_notify(void *ignored, xcb_connection_t *conn, xcb_enter_notify_
                 return 1;
         }
         /* Some events are not interesting, because they were not generated actively by the
-           user, but be reconfiguration of windows */
+           user, but by reconfiguration of windows */
         if (event_is_ignored(event->sequence))
                 return 1;
 
@@ -196,6 +199,14 @@ int handle_enter_notify(void *ignored, xcb_connection_t *conn, xcb_enter_notify_
                 return 1;
         }
 
+        if (client->workspace != c_ws && client->workspace->screen == c_ws->screen) {
+                /* 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. */
+                LOG("enter_notify for a client on a different workspace but the same screen, ignoring\n");
+                return 1;
+        }
+
         set_focus(conn, client, false);
 
         return 1;
@@ -283,6 +294,7 @@ static bool button_press_bar(xcb_connection_t *conn, xcb_button_press_event_t *e
 
 int handle_button_press(void *ignored, xcb_connection_t *conn, xcb_button_press_event_t *event) {
         LOG("button press!\n");
+        LOG("state = %d\n", event->state);
         /* This was either a focus for a client’s parent (= titlebar)… */
         Client *client = table_get(&by_child, event->event);
         bool border_click = false;
@@ -290,6 +302,21 @@ int handle_button_press(void *ignored, xcb_connection_t *conn, xcb_button_press_
                 client = table_get(&by_parent, event->event);
                 border_click = true;
         }
+        /* See if this was a click with the configured modifier. If so, we need
+         * to move around the client if it was floating. if not, we just process
+         * as usual. */
+        if (config.floating_modifier != 0 &&
+            (event->state & config.floating_modifier) != 0) {
+                if (client == NULL) {
+                        LOG("Not handling, Mod1 was pressed and no client found\n");
+                        return 1;
+                }
+                if (client_is_floating(client)) {
+                        floating_drag_window(conn, client, event);
+                        return 1;
+                }
+        }
+
         if (client == NULL) {
                 /* The client was neither on a client’s titlebar nor on a client itself, maybe on a stack_window? */
                 if (button_press_stackwin(conn, event))
@@ -312,7 +339,7 @@ int handle_button_press(void *ignored, xcb_connection_t *conn, xcb_button_press_
         Container *con = client->container;
         int first, second;
 
-        if (con == NULL) {
+        if (client->dock) {
                 LOG("dock. done.\n");
                 xcb_allow_events(conn, XCB_ALLOW_REPLAY_POINTER, event->time);
                 xcb_flush(conn);
@@ -324,6 +351,9 @@ int handle_button_press(void *ignored, xcb_connection_t *conn, xcb_button_press_
         if (!border_click) {
                 LOG("client. done.\n");
                 xcb_allow_events(conn, XCB_ALLOW_REPLAY_POINTER, event->time);
+                /* Floating clients should be raised on click */
+                if (client_is_floating(client))
+                        xcb_raise_window(conn, client->frame);
                 xcb_flush(conn);
                 return 1;
         }
@@ -332,9 +362,21 @@ int handle_button_press(void *ignored, xcb_connection_t *conn, xcb_button_press_
         i3Font *font = load_font(conn, config.font);
         if (event->event_y >= 2 && event->event_y <= (font->height + 2 + 2)) {
                 LOG("click on titlebar\n");
+
+                /* Floating clients can be dragged by grabbing their titlebar */
+                if (client_is_floating(client)) {
+                        /* Firstly, we raise it. Maybe the user just wanted to raise it without grabbing */
+                        xcb_raise_window(conn, client->frame);
+                        xcb_flush(conn);
+
+                        floating_drag_window(conn, client, event);
+                }
                 return 1;
         }
 
+        if (client_is_floating(client))
+                return floating_border_click(conn, client, event);
+
         if (event->event_y < 2) {
                 /* This was a press on the top border */
                 if (con->row == 0)
@@ -412,8 +454,61 @@ int handle_configure_request(void *prophs, xcb_connection_t *conn, xcb_configure
         Client *client = table_get(&by_child, event->window);
         if (client == NULL) {
                 LOG("This client is not mapped, so we don't care and just tell the client that he will get its size\n");
-                Rect rect = {event->x, event->y, event->width, event->height};
+                uint32_t mask = 0;
-                fake_configure_notify(conn, rect, event->window);
+                uint32_t values[7];
+                int c = 0;
+#define COPY_MASK_MEMBER(mask_member, event_member) do { \
+                if (event->value_mask & mask_member) { \
+                        mask |= mask_member; \
+                        values[c++] = event->event_member; \
+                } \
+} while (0)
+
+                COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_X, x);
+                COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_Y, y);
+                COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_WIDTH, width);
+                COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_HEIGHT, height);
+                COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_BORDER_WIDTH, border_width);
+                COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_SIBLING, sibling);
+                COPY_MASK_MEMBER(XCB_CONFIG_WINDOW_STACK_MODE, stack_mode);
+
+                xcb_configure_window(conn, event->window, mask, values);
+                xcb_flush(conn);
+
+                return 1;
+        }
+
+        /* Floating clients can be reconfigured */
+        if (client_is_floating(client)) {
+                i3Font *font = load_font(conn, config.font);
+
+                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_WIDTH)
+                        client->rect.width = event->width + 2 + 2;
+                if (event->value_mask & XCB_CONFIG_WINDOW_HEIGHT)
+                        client->rect.height = event->height + (font->height + 2 + 2) + 2;
+
+                LOG("Accepted new position/size for floating client: (%d, %d) size %d x %d\n",
+                    client->rect.x, client->rect.y, client->rect.width, client->rect.height);
+
+                /* Push the new position/size to X11 */
+                reposition_client(conn, client);
+                resize_client(conn, client);
+                xcb_flush(conn);
+
+                return 1;
+        }
+
+        if (client->fullscreen) {
+                LOG("Client is in fullscreen mode\n");
+
+                Rect child_rect = client->container->workspace->rect;
+                child_rect.x = child_rect.y = 0;
+                fake_configure_notify(conn, child_rect, client->child);
+
                 return 1;
         }
 
@@ -495,18 +590,16 @@ int handle_unmap_notify_event(void *data, xcb_connection_t *conn, xcb_unmap_noti
 
         client = table_remove(&by_child, event->window);
 
-        if (client->name != NULL)
+        /* If this was the fullscreen client, we need to unset it */
-                free(client->name);
+        if (client->fullscreen)
+                client->workspace->fullscreen_client = NULL;
 
+        /* Clients without a container are either floating or dock windows */
         if (client->container != NULL) {
                 Container *con = client->container;
 
-                /* If this was the fullscreen client, we need to unset it */
-                if (client->fullscreen)
-                        con->workspace->fullscreen_client = NULL;
-
                 /* Remove the client from the list of clients */
-                remove_client_from_container(conn, client, con);
+                client_remove_from_container(conn, client, con, true);
 
                 /* Set focus to the last focused client in this container */
                 con->currently_focused = get_last_focused_client(conn, con, NULL);
@@ -514,6 +607,10 @@ int handle_unmap_notify_event(void *data, xcb_connection_t *conn, xcb_unmap_noti
                 /* Only if this is the active container, we need to really change focus */
                 if ((con->currently_focused != NULL) && ((con == CUR_CELL) || client->fullscreen))
                         set_focus(conn, con->currently_focused, true);
+        } else if (client_is_floating(client)) {
+                LOG("Removing from floating clients\n");
+                TAILQ_REMOVE(&(client->workspace->floating_clients), client, floating_clients);
+                SLIST_REMOVE(&(client->workspace->focus_stack), client, Client, focus_clients);
         }
 
         if (client->dock) {
@@ -528,32 +625,41 @@ int handle_unmap_notify_event(void *data, xcb_connection_t *conn, xcb_unmap_noti
         table_remove(&by_parent, client->frame);
 
         if (client->container != NULL) {
-                cleanup_table(conn, client->container->workspace);
+                Workspace *workspace = client->container->workspace;
-                fix_colrowspan(conn, client->container->workspace);
+                cleanup_table(conn, workspace);
+                fix_colrowspan(conn, workspace);
         }
 
         /* Let’s see how many clients there are left on the workspace to delete it if it’s empty */
-        bool workspace_empty = true;
+        bool workspace_empty = SLIST_EMPTY(&(client->workspace->focus_stack));
-        FOR_TABLE(client->workspace)
+        bool workspace_active = false;
-                if (!CIRCLEQ_EMPTY(&(client->workspace->table[cols][rows]->clients))) {
+        Client *to_focus = (!workspace_empty ? SLIST_FIRST(&(client->workspace->focus_stack)) : NULL);
-                        workspace_empty = false;
-                        break;
-                }
 
+        /* If this workspace is currently active, we don’t delete it */
         i3Screen *screen;
         TAILQ_FOREACH(screen, virtual_screens, screens)
                 if (screen->current_workspace == client->workspace->num) {
+                        workspace_active = true;
                         workspace_empty = false;
                         break;
                 }
 
-        if (workspace_empty)
+        if (workspace_empty) {
+                LOG("setting ws to NULL for workspace %d (%p)\n", client->workspace->num,
+                                client->workspace);
                 client->workspace->screen = NULL;
+        }
 
+        FREE(client->window_class);
+        FREE(client->name);
         free(client);
 
         render_layout(conn);
 
+        /* Ensure the focus is set to the next client in the focus stack */
+        if (workspace_active && to_focus != NULL)
+                set_focus(conn, to_focus, true);
+
         return 1;
 }
 
@@ -598,14 +704,13 @@ int handle_windowname_change(void *data, xcb_connection_t *conn, uint8_t state,
         client->name_len = new_len;
         client->uses_net_wm_name = true;
 
-        if (old_name != NULL)
+        FREE(old_name);
-                free(old_name);
 
         /* If the client is a dock window, we don’t need to render anything */
         if (client->dock)
                 return 1;
 
-        if (client->container->mode == MODE_STACK)
+        if (client->container != NULL && client->container->mode == MODE_STACK)
                 render_container(conn, client->container);
         else decorate_window(conn, client, client->frame, client->titlegc, 0);
         xcb_flush(conn);
@@ -673,7 +778,7 @@ int handle_windowname_change_legacy(void *data, xcb_connection_t *conn, uint8_t
         if (client->dock)
                 return 1;
 
-        if (client->container->mode == MODE_STACK)
+        if (client->container != NULL && client->container->mode == MODE_STACK)
                 render_container(conn, client->container);
         else decorate_window(conn, client, client->frame, client->titlegc, 0);
         xcb_flush(conn);
@@ -681,6 +786,46 @@ int handle_windowname_change_legacy(void *data, xcb_connection_t *conn, uint8_t
         return 1;
 }
 
+/*
+ * 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) {
+        LOG("window class changed\n");
+        if (prop == NULL || xcb_get_property_value_length(prop) == 0) {
+                LOG("prop == NULL\n");
+                return 1;
+        }
+        Client *client = table_get(&by_child, window);
+        if (client == NULL)
+                return 1;
+        char *new_class;
+        if (asprintf(&new_class, "%.*s", xcb_get_property_value_length(prop), (char*)xcb_get_property_value(prop)) == -1) {
+                perror("Could not get window class");
+                LOG("Could not get window class\n");
+                return 1;
+        }
+
+        LOG("changed to %s\n", new_class);
+        char *old_class = client->window_class;
+        client->window_class = new_class;
+        FREE(old_class);
+
+        if (!client->initialized) {
+                LOG("Client is not yet initialized, not putting it to floating\n");
+                return 1;
+        }
+
+        if (strcmp(new_class, "tools") == 0 || strcmp(new_class, "Dialog") == 0) {
+                LOG("tool/dialog window, should we put it floating?\n");
+                if (client->floating == FLOATING_AUTO_OFF)
+                        toggle_floating_mode(conn, client, true);
+        }
+
+        return 1;
+}
+
 /*
  * Expose event means we should redraw our windows (= title bar)
  *
@@ -717,15 +862,15 @@ int handle_expose_event(void *data, xcb_connection_t *conn, xcb_expose_event_t *
                 return 1;
         }
 
-        if (client->container->mode != MODE_STACK)
+        if (client->container == NULL || client->container->mode != MODE_STACK)
                 decorate_window(conn, client, client->frame, client->titlegc, 0);
         else {
                 uint32_t background_color;
                 /* Distinguish if the window is currently focused… */
                 if (CUR_CELL->currently_focused == client)
-                        background_color = get_colorpixel(conn, "#285577");
+                        background_color = config.client.focused.background;
                 /* …or if it is the focused window in a not focused container */
-                else background_color = get_colorpixel(conn, "#555555");
+                else background_color = config.client.focused_inactive.background;
 
                 /* Set foreground color to current focused color, line width to 2 */
                 uint32_t values[] = {background_color, 2};
@@ -771,7 +916,7 @@ int handle_client_message(void *data, xcb_connection_t *conn, xcb_client_message
                     (!client->fullscreen &&
                      (event->data.data32[0] == _NET_WM_STATE_ADD ||
                       event->data.data32[0] == _NET_WM_STATE_TOGGLE)))
-                        toggle_fullscreen(conn, client);
+                        client_toggle_fullscreen(conn, client);
         } else {
                 LOG("unhandled clientmessage\n");
                 return 0;
@@ -804,6 +949,7 @@ int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_w
                 return 1;
         }
         xcb_size_hints_t size_hints;
+        LOG("client is %08x / child %08x\n", client->frame, client->child);
 
         /* If the hints were already in this event, use them, if not, request them */
         if (reply != NULL)
@@ -811,6 +957,11 @@ int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_w
         else
                 xcb_get_wm_normal_hints_reply(conn, xcb_get_wm_normal_hints_unchecked(conn, client->child), &size_hints, NULL);
 
+        if ((size_hints.flags & XCB_SIZE_HINT_P_MIN_SIZE)) {
+                LOG("min size set\n");
+                LOG("gots min_width = %d, min_height = %d\n", size_hints.min_width, size_hints.min_height);
+        }
+
         /* If no aspect ratio was set or if it was invalid, we ignore the hints */
         if (!(size_hints.flags & XCB_SIZE_HINT_P_ASPECT) ||
             (size_hints.min_aspect_num <= 0) ||
@@ -821,8 +972,7 @@ int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_w
 
         LOG("window is %08x / %s\n", client->child, client->name);
 
-        int base_width = 0, base_height = 0,
+        int base_width = 0, base_height = 0;
-            min_width = 0, min_height = 0;
 
         /* base_width/height are the desired size of the window.
            We check if either the program-specified size or the program-specified
@@ -835,14 +985,6 @@ int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_w
                 base_height = size_hints.min_height;
         }
 
-        if (size_hints.flags & XCB_SIZE_HINT_P_MIN_SIZE) {
-                min_width = size_hints.min_width;
-                min_height = size_hints.min_height;
-        } else if (size_hints.flags & XCB_SIZE_HINT_P_SIZE) {
-                min_width = size_hints.base_width;
-                min_height = size_hints.base_height;
-        }
-
         double width = client->rect.width - base_width;
         double height = client->rect.height - base_height;
         /* Convert numerator/denominator to a double */
@@ -874,3 +1016,42 @@ int handle_normal_hints(void *data, xcb_connection_t *conn, uint8_t state, xcb_w
 
         return 1;
 }
+
+/*
+ * Handles the transient for hints set by a window, signalizing that this window is a popup window
+ * for some other window.
+ *
+ * See ICCCM 4.1.2.6 for more details
+ *
+ */
+int handle_transient_for(void *data, xcb_connection_t *conn, uint8_t state, xcb_window_t window,
+                         xcb_atom_t name, xcb_get_property_reply_t *reply) {
+        LOG("Transient hint!\n");
+        Client *client = table_get(&by_child, window);
+        if (client == NULL) {
+                LOG("No such client\n");
+                return 1;
+        }
+
+        xcb_window_t transient_for;
+
+        if (reply != NULL) {
+                if (!xcb_get_wm_transient_for_from_reply(&transient_for, reply)) {
+                        LOG("Not transient for any window\n");
+                        return 1;
+                }
+        } else {
+                if (!xcb_get_wm_transient_for_reply(conn, xcb_get_wm_transient_for_unchecked(conn, window),
+                                                    &transient_for, NULL)) {
+                        LOG("Not transient for any window\n");
+                        return 1;
+                }
+        }
+
+        if (client->floating == FLOATING_AUTO_OFF) {
+                LOG("This is a popup window, putting into floating\n");
+                toggle_floating_mode(conn, client, true);
+        }
+
+        return 1;
+}

src/layout.c

@@ -24,6 +24,8 @@
 #include "util.h"
 #include "xinerama.h"
 #include "layout.h"
+#include "client.h"
+#include "floating.h"
 
 /*
  * Updates *destination with new_value and returns true if it was changed or false
@@ -83,7 +85,7 @@ int get_unoccupied_y(Workspace *workspace, int col) {
  *
  */
 void redecorate_window(xcb_connection_t *conn, Client *client) {
-        if (client->container->mode == MODE_STACK) {
+        if (client->container != NULL && client->container->mode == MODE_STACK) {
                 render_container(conn, client->container);
                 /* We clear the frame to generate exposure events, because the color used
                    in drawing may be different */
@@ -100,47 +102,39 @@ void redecorate_window(xcb_connection_t *conn, Client *client) {
 void decorate_window(xcb_connection_t *conn, Client *client, xcb_drawable_t drawable, xcb_gcontext_t gc, int offset) {
         i3Font *font = load_font(conn, config.font);
         int decoration_height = font->height + 2 + 2;
-        uint32_t background_color,
+        struct Colortriple *color;
-                 text_color,
-                 border_color;
 
         /* Clients without a container (docks) won’t get decorated */
-        if (client->container == NULL)
+        if (client->dock)
                 return;
 
-        if (client->container->currently_focused == client) {
+        LOG("redecorating child %08x\n", client->child);
+        if (client_is_floating(client) || client->container->currently_focused == client) {
                 /* Distinguish if the window is currently focused… */
-                if (CUR_CELL->currently_focused == client)
+                if (client_is_floating(client) || CUR_CELL->currently_focused == client)
-                        background_color = get_colorpixel(conn, "#285577");
+                        color = &(config.client.focused);
                 /* …or if it is the focused window in a not focused container */
-                else background_color = get_colorpixel(conn, "#555555");
+                else color = &(config.client.focused_inactive);
-
+        } else color = &(config.client.unfocused);
-                text_color = get_colorpixel(conn, "#ffffff");
-                border_color = get_colorpixel(conn, "#4c7899");
-        } else {
-                background_color = get_colorpixel(conn, "#222222");
-                text_color = get_colorpixel(conn, "#888888");
-                border_color = get_colorpixel(conn, "#333333");
-        }
 
         /* Our plan is the following:
-           - Draw a rect around the whole client in background_color
+           - Draw a rect around the whole client in color->background
            - Draw two lines in a lighter color
            - Draw the window’s title
          */
 
         /* Draw a rectangle in background color around the window */
-        xcb_change_gc_single(conn, gc, XCB_GC_FOREGROUND, background_color);
+        xcb_change_gc_single(conn, gc, XCB_GC_FOREGROUND, color->background);
 
         /* In stacking mode, we only render the rect for this specific decoration */
-        if (client->container->mode == MODE_STACK) {
+        if (client->container != NULL && client->container->mode == MODE_STACK) {
-                xcb_rectangle_t rect = {0, offset, client->container->width, offset + decoration_height };
-                xcb_poly_fill_rectangle(conn, drawable, gc, 1, &rect);
-        } else {
                 /* We need to use the container’s width because it is the more recent value - when
                    in stacking mode, clients get reconfigured only on demand (the not active client
                    is not reconfigured), so the client’s rect.width would be wrong */
-                xcb_rectangle_t rect = {0, 0, client->container->width, client->rect.height};
+                xcb_rectangle_t rect = {0, offset, client->container->width, offset + decoration_height };
+                xcb_poly_fill_rectangle(conn, drawable, gc, 1, &rect);
+        } else {
+                xcb_rectangle_t rect = {0, 0, client->rect.width, client->rect.height};
                 xcb_poly_fill_rectangle(conn, drawable, gc, 1, &rect);
 
                 /* Draw the inner background to have a black frame around clients (such as mplayer)
@@ -152,15 +146,15 @@ void decorate_window(xcb_connection_t *conn, Client *client, xcb_drawable_t draw
         }
 
         /* Draw the lines */
-        xcb_draw_line(conn, drawable, gc, border_color, 2, offset, client->rect.width, offset);
+        xcb_draw_line(conn, drawable, gc, color->border, 0, offset, client->rect.width, offset);
-        xcb_draw_line(conn, drawable, gc, border_color, 2, offset + font->height + 3,
+        xcb_draw_line(conn, drawable, gc, color->border, 2, offset + font->height + 3,
-                      2 + client->rect.width, offset + font->height + 3);
+                      client->rect.width - 3, offset + font->height + 3);
 
         /* If the client has a title, we draw it */
         if (client->name != NULL) {
                 /* Draw the font */
                 uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
-                uint32_t values[] = { text_color, background_color, font->id };
+                uint32_t values[] = { color->text, color->background, font->id };
                 xcb_change_gc(conn, gc, mask, values);
 
                 /* name_len == -1 means this is a legacy application which does not specify _NET_WM_NAME,
@@ -179,18 +173,37 @@ void decorate_window(xcb_connection_t *conn, Client *client, xcb_drawable_t draw
  * Pushes the client’s x and y coordinates to X11
  *
  */
-static void reposition_client(xcb_connection_t *conn, Client *client) {
+void reposition_client(xcb_connection_t *conn, Client *client) {
+        i3Screen *screen;
+
         LOG("frame 0x%08x needs to be pushed to %dx%d\n", client->frame, client->rect.x, client->rect.y);
         /* Note: We can use a pointer to client->x like an array of uint32_ts
            because it is followed by client->y by definition */
         xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, &(client->rect.x));
+
+        if (!client_is_floating(client))
+                return;
+
+        /* If the client is floating, we need to check if we moved it to a different workspace */
+        if (client->workspace->screen == (screen = get_screen_containing(client->rect.x, client->rect.y)))
+                return;
+
+        if (screen == NULL) {
+                LOG("Boundary checking disabled, no screen found for (%d, %d)\n", client->rect.x, client->rect.y);
+                return;
+        }
+
+        LOG("Client is on workspace %p with screen %p\n", client->workspace, client->workspace->screen);
+        LOG("but screen at %d, %d is %p\n", client->rect.x, client->rect.y, screen);
+        floating_assign_to_workspace(client, &workspaces[screen->current_workspace]);
+        LOG("fixed that\n");
 }
 
 /*
  * Pushes the client’s width/height to X11 and resizes the child window
  *
  */
-static void resize_client(xcb_connection_t *conn, Client *client) {
+void resize_client(xcb_connection_t *conn, Client *client) {
         i3Font *font = load_font(conn, config.font);
 
         LOG("resizing client 0x%08x to %d x %d\n", client->frame, client->rect.width, client->rect.height);
@@ -335,8 +348,13 @@ void render_container(xcb_connection_t *conn, Container *container) {
                                         XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                                         XCB_CONFIG_WINDOW_STACK_MODE;
 
-                        /* If there is no fullscreen client, we raise the stack window */
+                        /* Raise the stack window, but keep it below the first floating client
-                        if (container->workspace->fullscreen_client != NULL) {
+                         * and below the fullscreen client (if any) */
+                        Client *first_floating = TAILQ_FIRST(&(container->workspace->floating_clients));
+                        if (first_floating != TAILQ_END(&(container->workspace->floating_clients))) {
+                                mask |= XCB_CONFIG_WINDOW_SIBLING;
+                                values[4] = first_floating->frame;
+                        } else if (container->workspace->fullscreen_client != NULL) {
                                 mask |= XCB_CONFIG_WINDOW_SIBLING;
                                 values[4] = container->workspace->fullscreen_client->frame;
                         }
@@ -344,9 +362,6 @@ void render_container(xcb_connection_t *conn, Container *container) {
                         xcb_configure_window(conn, stack_win->window, mask, values);
                 }
 
-                /* Reconfigure the currently focused client, if necessary. It is the only visible one */
-                client = container->currently_focused;
-
                 /* Render the decorations of all clients */
                 CIRCLEQ_FOREACH(client, &(container->clients), clients) {
                         /* If the client is in fullscreen mode, it does not get reconfigured */
@@ -400,24 +415,10 @@ static void render_internal_bar(xcb_connection_t *conn, Workspace *r_ws, int wid
         i3Font *font = load_font(conn, config.font);
         i3Screen *screen = r_ws->screen;
         enum { SET_NORMAL = 0, SET_FOCUSED = 1 };
-        uint32_t background_color[2],
-                 text_color[2],
-                 border_color[2],
-                 black;
         char label[3];
 
-        black = get_colorpixel(conn, "#000000");
-
-        background_color[SET_NORMAL] = get_colorpixel(conn, "#222222");
-        text_color[SET_NORMAL] = get_colorpixel(conn, "#888888");
-        border_color[SET_NORMAL] = get_colorpixel(conn, "#333333");
-
-        background_color[SET_FOCUSED] = get_colorpixel(conn, "#285577");
-        text_color[SET_FOCUSED] = get_colorpixel(conn, "#ffffff");
-        border_color[SET_FOCUSED] = get_colorpixel(conn, "#4c7899");
-
         /* Fill the whole bar in black */
-        xcb_change_gc_single(conn, screen->bargc, XCB_GC_FOREGROUND, black);
+        xcb_change_gc_single(conn, screen->bargc, XCB_GC_FOREGROUND, get_colorpixel(conn, "#000000"));
         xcb_rectangle_t rect = {0, 0, width, height};
         xcb_poly_fill_rectangle(conn, screen->bar, screen->bargc, 1, &rect);
 
@@ -429,16 +430,17 @@ static void render_internal_bar(xcb_connection_t *conn, Workspace *r_ws, int wid
                 if (workspaces[c].screen != screen)
                         continue;
 
-                int set = (screen->current_workspace == c ? SET_FOCUSED : SET_NORMAL);
+                struct Colortriple *color = (screen->current_workspace == c ? &(config.bar.focused) :
+                                             &(config.bar.unfocused));
 
-                xcb_draw_rect(conn, screen->bar, screen->bargc, border_color[set],
+                xcb_draw_rect(conn, screen->bar, screen->bargc, color->border,
                               drawn * height, 1, height - 2, height - 2);
-                xcb_draw_rect(conn, screen->bar, screen->bargc, background_color[set],
+                xcb_draw_rect(conn, screen->bar, screen->bargc, color->background,
                               drawn * height + 1, 2, height - 4, height - 4);
 
                 snprintf(label, sizeof(label), "%d", c+1);
-                xcb_change_gc_single(conn, screen->bargc, XCB_GC_FOREGROUND, text_color[set]);
+                xcb_change_gc_single(conn, screen->bargc, XCB_GC_FOREGROUND, color->text);
-                xcb_change_gc_single(conn, screen->bargc, XCB_GC_BACKGROUND, background_color[set]);
+                xcb_change_gc_single(conn, screen->bargc, XCB_GC_BACKGROUND, color->background);
                 xcb_image_text_8(conn, strlen(label), screen->bar, screen->bargc, drawn * height + 5 /* X */,
                                                 font->height + 1 /* Y = baseline of font */, label);
                 drawn++;

src/mainx.c

@@ -31,6 +31,8 @@
 #include <xcb/xcb_icccm.h>
 #include <xcb/xinerama.h>
 
+#include <ev.h>
+
 #include "config.h"
 #include "data.h"
 #include "debug.h"
@@ -42,6 +44,7 @@
 #include "util.h"
 #include "xcb.h"
 #include "xinerama.h"
+#include "manage.h"
 
 /* This is the path to i3, copied from argv[0] when starting up */
 char **start_argv;
@@ -52,6 +55,12 @@ Display *xkbdpy;
 /* The list of key bindings */
 struct bindings_head bindings = TAILQ_HEAD_INITIALIZER(bindings);
 
+/* The list of exec-lines */
+struct autostarts_head autostarts = TAILQ_HEAD_INITIALIZER(autostarts);
+
+/* The list of assignments */
+struct assignments_head assignments = TAILQ_HEAD_INITIALIZER(assignments);
+
 /* 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);
 
@@ -63,273 +72,40 @@ xcb_atom_t atoms[NUM_ATOMS];
 int num_screens = 0;
 
 /*
- * Do some sanity checks and then reparent the window.
+ * This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
+ * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
  *
  */
-void manage_window(xcb_property_handlers_t *prophs, xcb_connection_t *conn, xcb_window_t window, window_attributes_t wa) {
+static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
-        LOG("managing window.\n");
+        /* empty, because xcb_prepare_cb and xcb_check_cb are used */
-        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(&by_child, 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);
-                xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, WM_NORMAL_HINTS);
-                xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, atoms[_NET_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
+ * Flush before blocking (and waiting for new events)
- * 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,
+static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
-                     xcb_visualid_t visual, xcb_window_t root, uint8_t depth,
+        xcb_flush(evenths.c);
-                     int16_t x, int16_t y, uint16_t width, uint16_t height) {
-
-        xcb_get_property_cookie_t wm_type_cookie, strut_cookie, state_cookie;
-        uint32_t mask = 0;
-        uint32_t values[3];
-
-        /* We are interested in property changes */
-        mask = XCB_CW_EVENT_MASK;
-        values[0] = CHILD_EVENT_MASK;
-        xcb_change_window_attributes(conn, child, mask, values);
-
-        /* Map the window first to avoid flickering */
-        xcb_map_window(conn, child);
-
-        /* 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);
-        state_cookie = xcb_get_any_property_unchecked(conn, false, child, atoms[_NET_WM_STATE], UINT32_MAX);
-
-        Client *new = table_get(&by_child, child);
-
-        /* Events for already managed windows should already be filtered in manage_window() */
-        assert(new == NULL);
-
-        LOG("reparenting new client\n");
-        new = calloc(sizeof(Client), 1);
-        new->force_reconfigure = true;
-
-        /* Update the data structures */
-        Client *old_focused = CUR_CELL->currently_focused;
-
-        new->container = CUR_CELL;
-        new->workspace = new->container->workspace;
-
-        new->frame = xcb_generate_id(conn);
-        new->child = child;
-        new->rect.width = width;
-        new->rect.height = height;
-
-        mask = 0;
-
-        /* 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] = FRAME_EVENT_MASK;
-
-        LOG("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);
-
-        long data[] = { XCB_WM_STATE_NORMAL, XCB_NONE };
-        xcb_change_property(conn, XCB_PROP_MODE_REPLACE, new->child, atoms[WM_STATE], atoms[WM_STATE], 32, 2, data);
-
-        /* 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);
-
-        /* 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);
-        if (xcb_request_check(conn, cookie) != NULL) {
-                LOG("Could not reparent the window, aborting\n");
-                xcb_destroy_window(conn, new->frame);
-                free(new);
-                return;
-        }
-
-        /* Put our data structure (Client) into the table */
-        table_put(&by_parent, new->frame, new);
-        table_put(&by_child, child, new);
-
-        /* 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 */);
-
-        /* 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]) {
-                                LOG("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->screen->dock_clients), new, dock_clients);
-                        }
-        }
-
-        if (new->dock) {
-                /* 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];
-                        if (new->desired_height == 0) {
-                                LOG("Client wanted to be 0 pixels high, using the window's height (%d)\n", height);
-                                new->desired_height = height;
-                        }
-                        LOG("the client wants to be %d pixels high\n", new->desired_height);
-                } else {
-                        LOG("The client didn't specify space to reserve at the screen edge, using its height (%d)\n", height);
-                        new->desired_height = height;
-                }
-        }
-
-        /* Focus the new window if we’re not in fullscreen mode and if it is not a dock window */
-        if (CUR_CELL->workspace->fullscreen_client == NULL) {
-                if (!new->dock) {
-                        CUR_CELL->currently_focused = new;
-                        xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, new->child, XCB_CURRENT_TIME);
-                }
-        } else {
-                /* If we are in fullscreen, we should lower the window to not be annoying */
-                uint32_t values[] = { XCB_STACK_MODE_BELOW };
-                xcb_configure_window(conn, new->frame, XCB_CONFIG_WINDOW_STACK_MODE, values);
-        }
-
-        /* 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 && !old_focused->dock)
-                        CIRCLEQ_INSERT_AFTER(&(CUR_CELL->clients), old_focused, new, clients);
-                else CIRCLEQ_INSERT_TAIL(&(CUR_CELL->clients), new, clients);
-
-                SLIST_INSERT_HEAD(&(new->container->workspace->focus_stack), new, focus_clients);
-        }
-
-        /* Check if the window already got the fullscreen hint set */
-        xcb_atom_t *state;
-        if ((preply = xcb_get_property_reply(conn, state_cookie, NULL)) != NULL &&
-            (state = xcb_get_property_value(preply)) != NULL)
-                /* Check all set _NET_WM_STATEs */
-                for (int i = 0; i < xcb_get_property_value_length(preply); i++)
-                        if (state[i] == atoms[_NET_WM_STATE_FULLSCREEN]) {
-                                /* If the window got the fullscreen state, we just toggle fullscreen
-                                   and don’t event bother to redraw the layout – that would not change
-                                   anything anyways */
-                                toggle_fullscreen(conn, new);
-                                return;
-                        }
-
-        render_layout(conn);
 }
 
 /*
- * Go through all existing windows (if the window manager is restarted) and manage them
+ * Instead of polling the X connection socket we leave this to
+ * xcb_poll_for_event() which knows better than we can ever know.
  *
  */
-void manage_existing_windows(xcb_connection_t *conn, xcb_property_handlers_t *prophs, xcb_window_t root) {
+static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
-        xcb_query_tree_reply_t *reply;
+        xcb_generic_event_t *event;
-        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) */
+        while ((event = xcb_poll_for_event(evenths.c)) != NULL) {
-        if ((reply = xcb_query_tree_reply(conn, xcb_query_tree(conn, root), 0)) == NULL)
+                xcb_event_handle(&evenths, event);
-                return;
+                free(event);
-
-        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);
-        free(cookies);
 }
 
 int main(int argc, char *argv[], char *env[]) {
         int i, screens, opt;
         char *override_configpath = NULL;
+        bool autostart = true;
         xcb_connection_t *conn;
         xcb_property_handlers_t prophs;
         xcb_window_t root;
@@ -343,8 +119,12 @@ int main(int argc, char *argv[], char *env[]) {
 
         start_argv = argv;
 
-        while ((opt = getopt(argc, argv, "c:v")) != -1) {
+        while ((opt = getopt(argc, argv, "c:va")) != -1) {
                 switch (opt) {
+                        case 'a':
+                                LOG("Autostart disabled using -a\n");
+                                autostart = false;
+                                break;
                         case 'c':
                                 override_configpath = sstrdup(optarg);
                                 break;
@@ -365,10 +145,13 @@ int main(int argc, char *argv[], char *env[]) {
         memset(&evenths, 0, sizeof(xcb_event_handlers_t));
         memset(&prophs, 0, sizeof(xcb_property_handlers_t));
 
-        load_configuration(override_configpath);
-
         conn = xcb_connect(NULL, &screens);
 
+        if (xcb_connection_has_error(conn))
+                die("Cannot open display\n");
+
+        load_configuration(conn, override_configpath);
+
         /* 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);
 
@@ -380,6 +163,10 @@ int main(int argc, char *argv[], char *env[]) {
         REQUEST_ATOM(_NET_WM_WINDOW_TYPE);
         REQUEST_ATOM(_NET_WM_DESKTOP);
         REQUEST_ATOM(_NET_WM_WINDOW_TYPE_DOCK);
+        REQUEST_ATOM(_NET_WM_WINDOW_TYPE_DIALOG);
+        REQUEST_ATOM(_NET_WM_WINDOW_TYPE_UTILITY);
+        REQUEST_ATOM(_NET_WM_WINDOW_TYPE_TOOLBAR);
+        REQUEST_ATOM(_NET_WM_WINDOW_TYPE_SPLASH);
         REQUEST_ATOM(_NET_WM_STRUT_PARTIAL);
         REQUEST_ATOM(WM_PROTOCOLS);
         REQUEST_ATOM(WM_DELETE_WINDOW);
@@ -406,6 +193,27 @@ int main(int argc, char *argv[], char *env[]) {
         }
         /* end of ugliness */
 
+        /* Initialize event loop using libev */
+        struct ev_loop *loop = ev_default_loop(0);
+        if (loop == NULL)
+                die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
+
+        struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
+        struct ev_check *xcb_check = scalloc(sizeof(struct ev_check));
+        struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare));
+
+        ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
+        ev_io_start(loop, xcb_watcher);
+
+        ev_check_init(xcb_check, xcb_check_cb);
+        ev_check_start(loop, xcb_check);
+
+        ev_prepare_init(xcb_prepare, xcb_prepare_cb);
+        ev_prepare_start(loop, xcb_prepare);
+
+        /* Grab the server to delay any events until we enter the eventloop */
+        xcb_grab_server(conn);
+
         xcb_event_handlers_init(conn, &evenths);
 
         /* DEBUG: Trap all events and print them */
@@ -483,6 +291,10 @@ int main(int argc, char *argv[], char *env[]) {
         GET_ATOM(_NET_WM_WINDOW_TYPE);
         GET_ATOM(_NET_WM_DESKTOP);
         GET_ATOM(_NET_WM_WINDOW_TYPE_DOCK);
+        GET_ATOM(_NET_WM_WINDOW_TYPE_DIALOG);
+        GET_ATOM(_NET_WM_WINDOW_TYPE_UTILITY);
+        GET_ATOM(_NET_WM_WINDOW_TYPE_TOOLBAR);
+        GET_ATOM(_NET_WM_WINDOW_TYPE_SPLASH);
         GET_ATOM(_NET_WM_STRUT_PARTIAL);
         GET_ATOM(WM_PROTOCOLS);
         GET_ATOM(WM_DELETE_WINDOW);
@@ -495,9 +307,15 @@ int main(int argc, char *argv[], char *env[]) {
         /* Watch _NET_WM_NAME (= title of the window in UTF-8) property */
         xcb_property_set_handler(&prophs, atoms[_NET_WM_NAME], 128, handle_windowname_change, NULL);
 
+        /* Watch WM_TRANSIENT_FOR property (to which client this popup window belongs) */
+        xcb_property_set_handler(&prophs, WM_TRANSIENT_FOR, UINT_MAX, handle_transient_for, NULL);
+
         /* Watch WM_NAME (= title of the window in compound text) property for legacy applications */
         xcb_watch_wm_name(&prophs, 128, handle_windowname_change_legacy, NULL);
 
+        /* Watch WM_CLASS (= class of the window) */
+        xcb_property_set_handler(&prophs, WM_CLASS, 128, handle_windowclass_change, NULL);
+
         /* 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");
@@ -523,6 +341,15 @@ int main(int argc, char *argv[], char *env[]) {
                 }
         }
 
+        /* Autostarting exec-lines */
+        struct Autostart *exec;
+        if (autostart) {
+                TAILQ_FOREACH(exec, &autostarts, autostarts) {
+                        LOG("auto-starting %s\n", exec->command);
+                        start_application(exec->command);
+                }
+        }
+
         /* check for Xinerama */
         LOG("Checking for Xinerama...\n");
         initialize_xinerama(conn);
@@ -548,8 +375,12 @@ int main(int argc, char *argv[], char *env[]) {
                 c_ws = &workspaces[screen->current_workspace];
         }
 
-        /* Enter xcb’s event handler */
+        /* Handle the events which arrived until now */
-        xcb_event_wait_for_event_loop(&evenths);
+        xcb_check_cb(NULL, NULL, 0);
+
+        /* Ungrab the server to receive events and enter libev’s eventloop */
+        xcb_ungrab_server(conn);
+        ev_loop(loop, 0);
 
         /* not reached */
         return 0;

src/manage.c

@@ -0,0 +1,425 @@
+/*
+ * vim:ts=8:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ *
+ * © 2009 Michael Stapelberg and contributors
+ *
+ * See file LICENSE for license information.
+ *
+ * src/manage.c: Contains all functions for initially managing new windows
+ *               (or existing ones on restart).
+ *
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <xcb/xcb.h>
+#include <xcb/xcb_icccm.h>
+
+#include "xcb.h"
+#include "data.h"
+#include "util.h"
+#include "i3.h"
+#include "table.h"
+#include "config.h"
+#include "handlers.h"
+#include "layout.h"
+#include "manage.h"
+#include "floating.h"
+#include "client.h"
+
+/*
+ * 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);
+        free(cookies);
+}
+
+/*
+ * 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) {
+        LOG("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(&by_child, 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);
+                if ((attr = xcb_get_window_attributes_reply(conn, wa.u.cookie, 0)) == NULL)
+                        return;
+        }
+        if ((geom = xcb_get_geometry_reply(conn, geomc, 0)) == NULL)
+                goto out;
+
+        /* Reparent the window and add it to our list of managed windows */
+        reparent_window(conn, window, attr->visual, geom->root, geom->depth,
+                        geom->x, geom->y, geom->width, geom->height);
+
+        /* Generate callback events for every property we watch */
+        xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, WM_CLASS);
+        xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, WM_NAME);
+        xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, WM_NORMAL_HINTS);
+        xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, WM_TRANSIENT_FOR);
+        xcb_property_changed(prophs, XCB_PROPERTY_NEW_VALUE, window, atoms[_NET_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, state_cookie,
+                                  utf8_title_cookie, title_cookie, class_cookie;
+        uint32_t mask = 0;
+        uint32_t values[3];
+        uint16_t original_height = height;
+
+        /* We are interested in property changes */
+        mask = XCB_CW_EVENT_MASK;
+        values[0] = CHILD_EVENT_MASK;
+        xcb_change_window_attributes(conn, child, mask, values);
+
+        /* Map the window first to avoid flickering */
+        xcb_map_window(conn, child);
+
+        /* 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);
+        state_cookie = xcb_get_any_property_unchecked(conn, false, child, atoms[_NET_WM_STATE], UINT32_MAX);
+        utf8_title_cookie = xcb_get_any_property_unchecked(conn, false, child, atoms[_NET_WM_NAME], 128);
+        title_cookie = xcb_get_any_property_unchecked(conn, false, child, WM_NAME, 128);
+        class_cookie  = xcb_get_any_property_unchecked(conn, false, child, WM_CLASS, 128);
+
+        Client *new = table_get(&by_child, child);
+
+        /* Events for already managed windows should already be filtered in manage_window() */
+        assert(new == NULL);
+
+        LOG("reparenting new client\n");
+        LOG("x = %d, y = %d, width = %d, height = %d\n", x, y, width, height);
+        new = calloc(sizeof(Client), 1);
+        new->force_reconfigure = true;
+
+        /* Update the data structures */
+        Client *old_focused = CUR_CELL->currently_focused;
+
+        new->container = CUR_CELL;
+        new->workspace = new->container->workspace;
+
+        /* Minimum useful size for managed windows is 75x50 (primarily affects floating) */
+        width = max(width, 75);
+        height = max(height, 50);
+
+        new->frame = xcb_generate_id(conn);
+        new->child = child;
+        new->rect.width = width;
+        new->rect.height = height;
+        /* Pre-initialize the values for floating */
+        new->floating_rect.x = -1;
+        new->floating_rect.width = width;
+        new->floating_rect.height = height;
+
+        mask = 0;
+
+        /* 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] = FRAME_EVENT_MASK;
+
+        LOG("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);
+
+        /* Set WM_STATE_NORMAL because GTK applications don’t want to drag & drop if we don’t.
+         * Also, xprop(1) needs that to work. */
+        long data[] = { XCB_WM_STATE_NORMAL, XCB_NONE };
+        xcb_change_property(conn, XCB_PROP_MODE_REPLACE, new->child, atoms[WM_STATE], atoms[WM_STATE], 32, 2, data);
+
+        /* 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);
+
+        /* 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);
+        if (xcb_request_check(conn, cookie) != NULL) {
+                LOG("Could not reparent the window, aborting\n");
+                xcb_destroy_window(conn, new->frame);
+                free(new);
+                return;
+        }
+
+        /* Put our data structure (Client) into the table */
+        table_put(&by_parent, new->frame, new);
+        table_put(&by_child, child, new);
+
+        /* 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 */);
+
+        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_MOD_MASK_1);
+
+        /* 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]) {
+                                LOG("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->screen->dock_clients), new, dock_clients);
+                                /* If it’s a dock we can’t make it float, so we break */
+                                break;
+                        } else if (atom[i] == atoms[_NET_WM_WINDOW_TYPE_DIALOG] ||
+                                   atom[i] == atoms[_NET_WM_WINDOW_TYPE_UTILITY] ||
+                                   atom[i] == atoms[_NET_WM_WINDOW_TYPE_TOOLBAR] ||
+                                   atom[i] == atoms[_NET_WM_WINDOW_TYPE_SPLASH]) {
+                                /* Set the dialog window to automatically floating, will be used below */
+                                new->floating = FLOATING_AUTO_ON;
+                                LOG("dialog/utility/toolbar/splash window, automatically floating\n");
+                        }
+        }
+
+        if (new->workspace->auto_float) {
+                new->floating = FLOATING_AUTO_ON;
+                LOG("workspace is in autofloat mode, setting floating\n");
+        }
+
+        if (new->dock) {
+                /* 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];
+                        if (new->desired_height == 0) {
+                                LOG("Client wanted to be 0 pixels high, using the window's height (%d)\n", original_height);
+                                new->desired_height = original_height;
+                        }
+                        LOG("the client wants to be %d pixels high\n", new->desired_height);
+                } else {
+                        LOG("The client didn't specify space to reserve at the screen edge, using its height (%d)\n", original_height);
+                        new->desired_height = original_height;
+                }
+        } else {
+                /* If it’s not a dock, we can check on which workspace we should put it. */
+
+                /* Firstly, we need to get the window’s class / title. We asked for the properties at the
+                 * top of this function, get them now and pass them to our callback function for window class / title
+                 * changes. It is important that the client was already inserted into the by_child table,
+                 * because the callbacks won’t work otherwise. */
+                preply = xcb_get_property_reply(conn, utf8_title_cookie, NULL);
+                handle_windowname_change(NULL, conn, 0, new->child, atoms[_NET_WM_NAME], preply);
+
+                preply = xcb_get_property_reply(conn, title_cookie, NULL);
+                handle_windowname_change_legacy(NULL, conn, 0, new->child, WM_NAME, preply);
+
+                preply = xcb_get_property_reply(conn, class_cookie, NULL);
+                handle_windowclass_change(NULL, conn, 0, new->child, WM_CLASS, preply);
+
+                LOG("DEBUG: should have all infos now\n");
+                struct Assignment *assign;
+                TAILQ_FOREACH(assign, &assignments, assignments) {
+                        if (get_matching_client(conn, assign->windowclass_title, new) == NULL)
+                                continue;
+
+                        if (assign->floating) {
+                                new->floating = FLOATING_AUTO_ON;
+                                LOG("Assignment matches, putting client into floating mode\n");
+                                break;
+                        }
+
+                        LOG("Assignment \"%s\" matches, so putting it on workspace %d\n",
+                            assign->windowclass_title, assign->workspace);
+
+                        if (c_ws->screen->current_workspace == (assign->workspace-1)) {
+                                LOG("We are already there, no need to do anything\n");
+                                break;
+                        }
+
+                        LOG("Changin container/workspace and unmapping the client\n");
+                        Workspace *t_ws = &(workspaces[assign->workspace-1]);
+                        if (t_ws->screen == NULL) {
+                                LOG("initializing new workspace, setting num to %d\n", assign->workspace);
+                                t_ws->screen = c_ws->screen;
+                                /* Copy the dimensions from the virtual screen */
+                                memcpy(&(t_ws->rect), &(t_ws->screen->rect), sizeof(Rect));
+                        }
+
+                        new->container = t_ws->table[t_ws->current_col][t_ws->current_row];
+                        new->workspace = t_ws;
+                        old_focused = new->container->currently_focused;
+
+                        xcb_unmap_window(conn, new->frame);
+                        break;
+                }
+        }
+
+        if (CUR_CELL->workspace->fullscreen_client != NULL) {
+                if (new->container == CUR_CELL) {
+                        /* If we are in fullscreen, we should lower the window to not be annoying */
+                        uint32_t values[] = { XCB_STACK_MODE_BELOW };
+                        xcb_configure_window(conn, new->frame, XCB_CONFIG_WINDOW_STACK_MODE, values);
+                }
+        } else if (!new->dock) {
+                /* Focus the new window if we’re not in fullscreen mode and if it is not a dock window */
+                if (new->container->workspace->fullscreen_client == NULL) {
+                        if (!client_is_floating(new))
+                                new->container->currently_focused = new;
+                        if (new->container == CUR_CELL)
+                                xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, new->child, XCB_CURRENT_TIME);
+                }
+        }
+
+        /* Insert into the currently active container, if it’s not a dock window */
+        if (!new->dock && !client_is_floating(new)) {
+                /* 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 && !old_focused->dock)
+                        CIRCLEQ_INSERT_AFTER(&(new->container->clients), old_focused, new, clients);
+                else CIRCLEQ_INSERT_TAIL(&(new->container->clients), new, clients);
+
+                if (new->container->workspace->fullscreen_client != NULL)
+                        SLIST_INSERT_AFTER(new->container->workspace->fullscreen_client, new, focus_clients);
+                else SLIST_INSERT_HEAD(&(new->container->workspace->focus_stack), new, focus_clients);
+
+                client_set_below_floating(conn, new);
+        }
+
+        if (client_is_floating(new)) {
+                SLIST_INSERT_HEAD(&(new->workspace->focus_stack), new, focus_clients);
+
+                /* Add the client to the list of floating clients for its workspace */
+                TAILQ_INSERT_TAIL(&(new->workspace->floating_clients), new, floating_clients);
+
+                new->container = NULL;
+
+                new->floating_rect.x = new->rect.x = x;
+                new->floating_rect.y = new->rect.y = y;
+                new->rect.width = new->floating_rect.width + 2 + 2;
+                new->rect.height = new->floating_rect.height + (font->height + 2 + 2) + 2;
+                LOG("copying floating_rect from tiling (%d, %d) size (%d, %d)\n",
+                                new->floating_rect.x, new->floating_rect.y,
+                                new->floating_rect.width, new->floating_rect.height);
+                LOG("outer rect (%d, %d) size (%d, %d)\n",
+                                new->rect.x, new->rect.y, new->rect.width, new->rect.height);
+
+                /* Make sure it is on top of the other windows */
+                xcb_raise_window(conn, new->frame);
+                reposition_client(conn, new);
+                resize_client(conn, new);
+                /* redecorate_window flushes */
+                redecorate_window(conn, new);
+        }
+
+        new->initialized = true;
+
+        /* Check if the window already got the fullscreen hint set */
+        xcb_atom_t *state;
+        if ((preply = xcb_get_property_reply(conn, state_cookie, NULL)) != NULL &&
+            (state = xcb_get_property_value(preply)) != NULL)
+                /* Check all set _NET_WM_STATEs */
+                for (int i = 0; i < xcb_get_property_value_length(preply); i++) {
+                        if (state[i] != atoms[_NET_WM_STATE_FULLSCREEN])
+                                continue;
+                        /* If the window got the fullscreen state, we just toggle fullscreen
+                           and don’t event bother to redraw the layout – that would not change
+                           anything anyways */
+                        client_toggle_fullscreen(conn, new);
+                        return;
+                }
+
+        render_layout(conn);
+}

src/resize.c

@@ -24,6 +24,9 @@
 #include "xcb.h"
 #include "debug.h"
 #include "layout.h"
+#include "xinerama.h"
+#include "config.h"
+#include "floating.h"
 
 /*
  * Renders the resize window between the first/second container and resizes
@@ -33,8 +36,14 @@
 int resize_graphical_handler(xcb_connection_t *conn, Workspace *ws, int first, int second,
                              resize_orientation_t orientation, xcb_button_press_event_t *event) {
         int new_position;
-        xcb_window_t root = xcb_setup_roots_iterator(xcb_get_setup(conn)).data->root;
         xcb_screen_t *root_screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
+        i3Screen *screen = get_screen_containing(event->root_x, event->root_y);
+        if (screen == NULL) {
+                LOG("BUG: No screen found at this position (%d, %d)\n", event->root_x, event->root_y);
+                return 1;
+        }
+
+        LOG("Screen dimensions: (%d, %d) %d x %d\n", screen->rect.x, screen->rect.y, screen->rect.width, screen->rect.height);
 
         /* FIXME: horizontal resizing causes empty spaces to exist */
         if (orientation == O_HORIZONTAL) {
@@ -57,9 +66,9 @@ int resize_graphical_handler(xcb_connection_t *conn, Workspace *ws, int first, i
         Rect helprect;
         if (orientation == O_VERTICAL) {
                 helprect.x = event->root_x;
-                helprect.y = 0;
+                helprect.y = screen->rect.y;
                 helprect.width = 2;
-                helprect.height = root_screen->height_in_pixels;
+                helprect.height = screen->rect.height;
                 new_position = event->root_x;
         } else {
                 helprect.x = 0;
@@ -70,7 +79,7 @@ int resize_graphical_handler(xcb_connection_t *conn, Workspace *ws, int first, i
         }
 
         mask = XCB_CW_BACK_PIXEL;
-        values[0] = get_colorpixel(conn, "#4c7899");
+        values[0] = config.client.focused.border;
 
         mask |= XCB_CW_OVERRIDE_REDIRECT;
         values[1] = 1;
@@ -82,52 +91,32 @@ int resize_graphical_handler(xcb_connection_t *conn, Workspace *ws, int first, i
 
         xcb_circulate_window(conn, XCB_CIRCULATE_RAISE_LOWEST, helpwin);
 
-        xcb_grab_pointer(conn, false, root, XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION,
-                        XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, grabwin, XCB_NONE, XCB_CURRENT_TIME);
-
         xcb_flush(conn);
 
-        xcb_generic_event_t *inside_event;
+        void resize_callback(Rect *old_rect, uint32_t new_x, uint32_t new_y) {
-        /* I’ve always wanted to have my own eventhandler… */
+                LOG("new x = %d, y = %d\n", new_x, new_y);
-        while ((inside_event = xcb_wait_for_event(conn))) {
+                if (orientation == O_VERTICAL) {
-                /* Same as get_event_handler in xcb */
+                        /* Check if the new coordinates are within screen boundaries */
-                int nr = inside_event->response_type;
+                        if (new_x > (screen->rect.x + screen->rect.width - 25) ||
-                if (nr == 0) {
+                            new_x < (screen->rect.x + 25))
-                        /* An error occured */
+                                return;
-                        handle_event(NULL, conn, inside_event);
+
-                        free(inside_event);
+                        values[0] = new_position = new_x;
-                        continue;
+                        xcb_configure_window(conn, helpwin, XCB_CONFIG_WINDOW_X, values);
+                } else {
+                        if (new_y > (screen->rect.y + screen->rect.height - 25) ||
+                            new_y < (screen->rect.y + 25))
+                                return;
+
+                        values[0] = new_position = new_y;
+                        xcb_configure_window(conn, helpwin, XCB_CONFIG_WINDOW_Y, values);
                 }
-                assert(nr < 256);
-                nr &= XCB_EVENT_RESPONSE_TYPE_MASK;
-                assert(nr >= 2);
 
-                /* Check if we need to escape this loop */
+                xcb_flush(conn);
-                if (nr == XCB_BUTTON_RELEASE)
-                        break;
-
-                switch (nr) {
-                        case XCB_MOTION_NOTIFY:
-                                if (orientation == O_VERTICAL) {
-                                        values[0] = new_position = ((xcb_motion_notify_event_t*)inside_event)->root_x;
-                                        xcb_configure_window(conn, helpwin, XCB_CONFIG_WINDOW_X, values);
-                                } else {
-                                        values[0] = new_position = ((xcb_motion_notify_event_t*)inside_event)->root_y;
-                                        xcb_configure_window(conn, helpwin, XCB_CONFIG_WINDOW_Y, values);
-                                }
-
-                                xcb_flush(conn);
-                                break;
-                        default:
-                                LOG("Passing to original handler\n");
-                                /* Use original handler */
-                                xcb_event_handle(&evenths, inside_event);
-                                break;
-                }
-                free(inside_event);
         }
 
-        xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
+        drag_pointer(conn, NULL, event, grabwin, BORDER_TOP, resize_callback);
+
         xcb_destroy_window(conn, helpwin);
         xcb_destroy_window(conn, grabwin);
         xcb_flush(conn);

src/table.c

@@ -43,6 +43,7 @@ void init_table() {
         for (int i = 0; i < 10; i++) {
                 workspaces[i].screen = NULL;
                 workspaces[i].num = i;
+                TAILQ_INIT(&(workspaces[i].floating_clients));
                 expand_table_cols(&(workspaces[i]));
                 expand_table_rows(&(workspaces[i]));
         }

src/util.c

@@ -27,6 +27,7 @@
 #include "layout.h"
 #include "util.h"
 #include "xcb.h"
+#include "client.h"
 
 static iconv_t conversion_descriptor = 0;
 struct keyvalue_table_head by_parent = TAILQ_HEAD_INITIALIZER(by_parent);
@@ -213,34 +214,17 @@ char *convert_utf8_to_ucs2(char *input, int *real_strlen) {
 	int rc = iconv(conversion_descriptor, (void*)&input, &input_size, &output, &output_size);
         if (rc == (size_t)-1) {
                 perror("Converting to UCS-2 failed");
-		*real_strlen = 0;
+                if (real_strlen != NULL)
+		        *real_strlen = 0;
                 return NULL;
 	}
 
-	*real_strlen = ((buffer_size - output_size) / 2) - 1;
+        if (real_strlen != NULL)
+	        *real_strlen = ((buffer_size - output_size) / 2) - 1;
 
 	return buffer;
 }
 
-/*
- * Removes the given client from the container, either because it will be inserted into another
- * one or because it was unmapped
- *
- */
-void remove_client_from_container(xcb_connection_t *conn, Client *client, Container *container) {
-        CIRCLEQ_REMOVE(&(container->clients), client, clients);
-
-        SLIST_REMOVE(&(container->workspace->focus_stack), client, Client, focus_clients);
-
-        /* If the container will be empty now and is in stacking mode, we need to
-           unmap the stack_win */
-        if (CIRCLEQ_EMPTY(&(container->clients)) && container->mode == MODE_STACK) {
-                struct Stack_Window *stack_win = &(container->stack_win);
-                stack_win->rect.height = 0;
-                xcb_unmap_window(conn, stack_win->window);
-        }
-}
-
 /*
  * Returns the client which comes next in focus stack (= was selected before) for
  * the given container, optionally excluding the given client.
@@ -270,19 +254,43 @@ void unmap_workspace(xcb_connection_t *conn, Workspace *u_ws) {
         /* Ignore notify events because they would cause focus to be changed */
         ignore_enter_notify_forall(conn, u_ws, true);
 
-        /* Unmap all clients of the current workspace */
+        /* Unmap all clients of the given workspace */
         int unmapped_clients = 0;
         FOR_TABLE(u_ws)
                 CIRCLEQ_FOREACH(client, &(u_ws->table[cols][rows]->clients), clients) {
+                        LOG("unmapping normal client %p / %p / %p\n", client, client->frame, client->child);
                         xcb_unmap_window(conn, client->frame);
                         unmapped_clients++;
                 }
 
-        /* If we did not unmap any clients, the workspace is empty and we can destroy it */
+        /* To find floating clients, we traverse the focus stack */
-        if (unmapped_clients == 0)
+        SLIST_FOREACH(client, &(u_ws->focus_stack), focus_clients) {
-                u_ws->screen = NULL;
+                if (!client_is_floating(client))
+                        continue;
 
-        /* Unmap the stack windows on the current workspace, if any */
+                LOG("unmapping floating client %p / %p / %p\n", client, client->frame, client->child);
+
+                xcb_unmap_window(conn, client->frame);
+                unmapped_clients++;
+        }
+
+        /* If we did not unmap any clients, the workspace is empty and we can destroy it, at least
+         * if it is not the current workspace. */
+        if (unmapped_clients == 0 && u_ws != c_ws) {
+                /* Re-assign the workspace of all dock clients which use this workspace */
+                Client *dock;
+                LOG("workspace %p is empty\n", u_ws);
+                SLIST_FOREACH(dock, &(u_ws->screen->dock_clients), dock_clients) {
+                        if (dock->workspace != u_ws)
+                                continue;
+
+                        LOG("Re-assigning dock client to c_ws (%p)\n", c_ws);
+                        dock->workspace = c_ws;
+                }
+                u_ws->screen = NULL;
+        }
+
+        /* Unmap the stack windows on the given workspace, if any */
         SLIST_FOREACH(stack_win, &stack_wins, stack_windows)
                 if (stack_win->container->workspace == u_ws)
                         xcb_unmap_window(conn, stack_win->window);
@@ -302,7 +310,7 @@ void set_focus(xcb_connection_t *conn, Client *client, bool set_anyways) {
                 return;
 
         /* Store the old client */
-        Client *old_client = CUR_CELL->currently_focused;
+        Client *old_client = SLIST_FIRST(&(c_ws->focus_stack));
 
         /* Check if the focus needs to be changed at all */
         if (!set_anyways && (old_client == client)) {
@@ -313,47 +321,54 @@ void set_focus(xcb_connection_t *conn, Client *client, bool set_anyways) {
         /* Store current_row/current_col */
         c_ws->current_row = current_row;
         c_ws->current_col = current_col;
-        c_ws = client->container->workspace;
+        c_ws = client->workspace;
+        /* Load current_col/current_row if we switch to a client without a container */
+        current_col = c_ws->current_col;
+        current_row = c_ws->current_row;
 
         /* Update container */
-        client->container->currently_focused = client;
+        if (client->container != NULL) {
+                client->container->currently_focused = client;
 
-        current_col = client->container->col;
+                current_col = client->container->col;
-        current_row = client->container->row;
+                current_row = client->container->row;
+        }
 
         LOG("set_focus(frame %08x, child %08x, name %s)\n", client->frame, client->child, client->name);
         /* Set focus to the entered window, and flush xcb buffer immediately */
         xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, client->child, XCB_CURRENT_TIME);
         //xcb_warp_pointer(conn, XCB_NONE, client->child, 0, 0, 0, 0, 10, 10);
 
-        /* Get the client which was last focused in this particular container, it may be a different
+        if (client->container != NULL) {
-           one than old_client */
+                /* Get the client which was last focused in this particular container, it may be a different
-        Client *last_focused = get_last_focused_client(conn, client->container, NULL);
+                   one than old_client */
+                Client *last_focused = get_last_focused_client(conn, client->container, NULL);
 
-        /* In stacking containers, raise the client in respect to the one which was focused before */
+                /* In stacking containers, raise the client in respect to the one which was focused before */
-        if (client->container->mode == MODE_STACK && client->container->workspace->fullscreen_client == NULL) {
+                if (client->container->mode == MODE_STACK && client->container->workspace->fullscreen_client == NULL) {
-                /* We need to get the client again, this time excluding the current client, because
+                        /* We need to get the client again, this time excluding the current client, because
-                 * we might have just gone into stacking mode and need to raise */
+                         * we might have just gone into stacking mode and need to raise */
-                Client *last_focused = get_last_focused_client(conn, client->container, client);
+                        Client *last_focused = get_last_focused_client(conn, client->container, client);
 
-                if (last_focused != NULL) {
+                        if (last_focused != NULL) {
-                        LOG("raising above frame %p / child %p\n", last_focused->frame, last_focused->child);
+                                LOG("raising above frame %p / child %p\n", last_focused->frame, last_focused->child);
-                        uint32_t values[] = { last_focused->frame, XCB_STACK_MODE_ABOVE };
+                                uint32_t values[] = { last_focused->frame, XCB_STACK_MODE_ABOVE };
-                        xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
+                                xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
+                        }
                 }
-        }
 
-        /* If it is the same one as old_client, we save us the unnecessary redecorate */
+                /* If it is the same one as old_client, we save us the unnecessary redecorate */
-        if ((last_focused != NULL) && (last_focused != old_client))
+                if ((last_focused != NULL) && (last_focused != old_client))
-                redecorate_window(conn, last_focused);
+                        redecorate_window(conn, last_focused);
+        }
 
         /* If we’re in stacking mode, this renders the container to update changes in the title
            bars and to raise the focused client */
         if ((old_client != NULL) && (old_client != client) && !old_client->dock)
                 redecorate_window(conn, old_client);
 
-        SLIST_REMOVE(&(client->container->workspace->focus_stack), client, Client, focus_clients);
+        SLIST_REMOVE(&(client->workspace->focus_stack), client, Client, focus_clients);
-        SLIST_INSERT_HEAD(&(client->container->workspace->focus_stack), client, focus_clients);
+        SLIST_INSERT_HEAD(&(client->workspace->focus_stack), client, focus_clients);
 
         /* redecorate_window flushes, so we don’t need to */
         redecorate_window(conn, client);
@@ -390,7 +405,7 @@ void switch_layout_mode(xcb_connection_t *conn, Container *container, int mode)
                 /* When entering stacking mode, we need to open a window on which we can draw the
                    title bars of the clients, it has height 1 because we don’t bother here with
                    calculating the correct height - it will be adjusted when rendering anyways. */
-                Rect rect = {container->x, container->y, container->width, 1 };
+                Rect rect = {container->x, container->y, container->width, 1};
 
                 uint32_t mask = 0;
                 uint32_t values[2];
@@ -429,129 +444,79 @@ void switch_layout_mode(xcb_connection_t *conn, Container *container, int mode)
 
         render_layout(conn);
 
-        if (container->currently_focused != NULL)
+        if (container->currently_focused != NULL) {
-                set_focus(conn, container->currently_focused, true);
+                /* We need to make sure that this client is above *each* of the
-}
+                 * other clients in this container */
+                Client *last_focused = get_last_focused_client(conn, container, container->currently_focused);
 
-/*
+                CIRCLEQ_FOREACH(client, &(container->clients), clients) {
- * Warps the pointer into the given client (in the middle of it, to be specific), therefore
+                        if (client == container->currently_focused || client == last_focused)
- * selecting it
+                                continue;
- *
- */
-void warp_pointer_into(xcb_connection_t *conn, Client *client) {
-        int mid_x = client->rect.width / 2,
-            mid_y = client->rect.height / 2;
-        xcb_warp_pointer(conn, XCB_NONE, client->child, 0, 0, 0, 0, mid_x, mid_y);
-}
 
-/*
+                        LOG("setting %08x below %08x / %08x\n", client->frame, container->currently_focused->frame);
- * Toggles fullscreen mode for the given client. It updates the data structures and
+                        uint32_t values[] = { container->currently_focused->frame, XCB_STACK_MODE_BELOW };
- * reconfigures (= resizes/moves) the client and its frame to the full size of the
+                        xcb_configure_window(conn, client->frame,
- * screen. When leaving fullscreen, re-rendering the layout is forced.
+                                             XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
- *
- */
-void toggle_fullscreen(xcb_connection_t *conn, Client *client) {
-        /* clients without a container (docks) cannot be focused */
-        assert(client->container != NULL);
-
-        Workspace *workspace = client->container->workspace;
-
-        if (!client->fullscreen) {
-                if (workspace->fullscreen_client != NULL) {
-                        LOG("Not entering fullscreen mode, there already is a fullscreen client.\n");
-                        return;
                 }
-                client->fullscreen = true;
-                workspace->fullscreen_client = client;
-                LOG("Entering fullscreen mode...\n");
-                /* We just entered fullscreen mode, let’s configure the window */
-                 uint32_t mask = XCB_CONFIG_WINDOW_X |
-                                 XCB_CONFIG_WINDOW_Y |
-                                 XCB_CONFIG_WINDOW_WIDTH |
-                                 XCB_CONFIG_WINDOW_HEIGHT;
-                uint32_t values[4] = {workspace->rect.x,
-                                      workspace->rect.y,
-                                      workspace->rect.width,
-                                      workspace->rect.height};
 
-                LOG("child itself will be at %dx%d with size %dx%d\n",
+                if (last_focused != NULL) {
-                                values[0], values[1], values[2], values[3]);
+                        LOG("Putting last_focused directly underneath the currently focused\n");
+                        uint32_t values[] = { container->currently_focused->frame, XCB_STACK_MODE_BELOW };
+                        xcb_configure_window(conn, last_focused->frame,
+                                             XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
+                }
 
-                xcb_configure_window(conn, client->frame, mask, values);
 
-                /* Child’s coordinates are relative to the parent (=frame) */
+                set_focus(conn, container->currently_focused, true);
-                values[0] = 0;
-                values[1] = 0;
-                xcb_configure_window(conn, client->child, mask, values);
-
-                /* Raise the window */
-                values[0] = XCB_STACK_MODE_ABOVE;
-                xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_STACK_MODE, values);
-
-                Rect child_rect = workspace->rect;
-                child_rect.x = child_rect.y = 0;
-                fake_configure_notify(conn, child_rect, client->child);
-        } else {
-                LOG("leaving fullscreen mode\n");
-                client->fullscreen = false;
-                workspace->fullscreen_client = NULL;
-                /* Because the coordinates of the window haven’t changed, it would not be
-                   re-configured if we don’t set the following flag */
-                client->force_reconfigure = true;
-                /* We left fullscreen mode, redraw the whole layout to ensure enternotify events are disabled */
-                render_layout(conn);
         }
-
-        xcb_flush(conn);
 }
 
 /*
- * Returns true if the client supports the given protocol atom (like WM_DELETE_WINDOW)
+ * Gets the first matching client for the given window class/window title.
+ * If the paramater specific is set to a specific client, only this one
+ * will be checked.
  *
  */
-static bool client_supports_protocol(xcb_connection_t *conn, Client *client, xcb_atom_t atom) {
+Client *get_matching_client(xcb_connection_t *conn, const char *window_classtitle,
-        xcb_get_property_cookie_t cookie;
+                            Client *specific) {
-        xcb_get_wm_protocols_reply_t protocols;
+        char *to_class, *to_title, *to_title_ucs = NULL;
-        bool result = false;
+        int to_title_ucs_len = 0;
+        Client *matching = NULL;
 
-        cookie = xcb_get_wm_protocols_unchecked(conn, client->child, atoms[WM_PROTOCOLS]);
+        to_class = sstrdup(window_classtitle);
-        if (xcb_get_wm_protocols_reply(conn, cookie, &protocols, NULL) != 1)
-                return false;
 
-        /* Check if the client’s protocols have the requested atom set */
+        /* If a title was specified, split both strings at the slash */
-        for (uint32_t i = 0; i < protocols.atoms_len; i++)
+        if ((to_title = strstr(to_class, "/")) != NULL) {
-                if (protocols.atoms[i] == atom)
+                *(to_title++) = '\0';
-                        result = true;
+                /* Convert to UCS-2 */
-
+                to_title_ucs = convert_utf8_to_ucs2(to_title, &to_title_ucs_len);
-        xcb_get_wm_protocols_reply_wipe(&protocols);
-
-        return result;
-}
-
-/*
- * Kills the given window using WM_DELETE_WINDOW or xcb_kill_window
- *
- */
-void kill_window(xcb_connection_t *conn, Client *window) {
-        /* If the client does not support WM_DELETE_WINDOW, we kill it the hard way */
-        if (!client_supports_protocol(conn, window, atoms[WM_DELETE_WINDOW])) {
-                LOG("Killing window the hard way\n");
-                xcb_kill_client(conn, window->child);
-                return;
         }
 
-        xcb_client_message_event_t ev;
+        /* If we were given a specific client we only check if that one matches */
+        if (specific != NULL) {
+                if (client_matches_class_name(specific, to_class, to_title, to_title_ucs, to_title_ucs_len))
+                        matching = specific;
+                goto done;
+        }
 
-        memset(&ev, 0, sizeof(xcb_client_message_event_t));
+        LOG("Getting clients for class \"%s\" / title \"%s\"\n", to_class, to_title);
+        for (int workspace = 0; workspace < 10; workspace++) {
+                if (workspaces[workspace].screen == NULL)
+                        continue;
 
-        ev.response_type = XCB_CLIENT_MESSAGE;
+                Client *client;
-        ev.window = window->child;
+                SLIST_FOREACH(client, &(workspaces[workspace].focus_stack), focus_clients) {
-        ev.type = atoms[WM_PROTOCOLS];
+                        LOG("Checking client with class=%s, name=%s\n", client->window_class, client->name);
-        ev.format = 32;
+                        if (!client_matches_class_name(client, to_class, to_title, to_title_ucs, to_title_ucs_len))
-        ev.data.data32[0] = atoms[WM_DELETE_WINDOW];
+                                continue;
-        ev.data.data32[1] = XCB_CURRENT_TIME;
 
-        LOG("Sending WM_DELETE to the client\n");
+                        matching = client;
-        xcb_send_event(conn, false, window->child, XCB_EVENT_MASK_NO_EVENT, (char*)&ev);
+                        goto done;
-        xcb_flush(conn);
+                }
+        }
+
+done:
+        free(to_class);
+        FREE(to_title_ucs);
+        return matching;
 }

src/xcb.c

@@ -22,7 +22,6 @@
 #include "xcb.h"
 
 TAILQ_HEAD(cached_fonts_head, Font) cached_fonts = TAILQ_HEAD_INITIALIZER(cached_fonts);
-SLIST_HEAD(colorpixel_head, Colorpixel) colorpixels;
 unsigned int xcb_numlock_mask;
 
 /*
@@ -74,42 +73,14 @@ i3Font *load_font(xcb_connection_t *conn, const char *pattern) {
  *
  */
 uint32_t get_colorpixel(xcb_connection_t *conn, char *hex) {
-        /* Lookup this colorpixel in the cache */
-        struct Colorpixel *colorpixel;
-        SLIST_FOREACH(colorpixel, &(colorpixels), colorpixels)
-                if (strcmp(colorpixel->hex, hex) == 0)
-                        return colorpixel->pixel;
-
-        #define RGB_8_TO_16(i) (65535 * ((i) & 0xFF) / 255)
         char strgroups[3][3] = {{hex[1], hex[2], '\0'},
                                 {hex[3], hex[4], '\0'},
                                 {hex[5], hex[6], '\0'}};
-        int rgb16[3] = {RGB_8_TO_16(strtol(strgroups[0], NULL, 16)),
+        uint32_t rgb16[3] = {(strtol(strgroups[0], NULL, 16)),
-                        RGB_8_TO_16(strtol(strgroups[1], NULL, 16)),
+                             (strtol(strgroups[1], NULL, 16)),
-                        RGB_8_TO_16(strtol(strgroups[2], NULL, 16))};
+                             (strtol(strgroups[2], NULL, 16))};
 
-        xcb_screen_t *root_screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
+        return (rgb16[0] << 16) + (rgb16[1] << 8) + rgb16[2];
-        xcb_alloc_color_reply_t *reply;
-        
-        reply = xcb_alloc_color_reply(conn, xcb_alloc_color(conn, root_screen->default_colormap,
-                                                            rgb16[0], rgb16[1], rgb16[2]), NULL);
-
-        if (!reply) {
-                LOG("Could not allocate color\n");
-                exit(1);
-        }
-
-        uint32_t pixel = reply->pixel;
-        free(reply);
-
-        /* Store the result in the cache */
-        struct Colorpixel *cache_pixel = scalloc(sizeof(struct Colorpixel));
-        cache_pixel->hex = sstrdup(hex);
-        cache_pixel->pixel = pixel;
-
-        SLIST_INSERT_HEAD(&(colorpixels), cache_pixel, colorpixels);
-
-        return pixel;
 }
 
 /*
@@ -267,10 +238,11 @@ void xcb_get_numlock_mask(xcb_connection_t *conn) {
         /* For now, we only use the first keysymbol. */
         xcb_keycode_t *numlock_syms = xcb_key_symbols_get_keycode(keysyms, XCB_NUM_LOCK);
         xcb_keycode_t numlock = *numlock_syms;
+        free(numlock_syms);
 #endif
 
         /* Check all modifiers (Mod1-Mod5, Shift, Control, Lock) */
-        for (mask = 0; mask < sizeof(masks); mask++)
+        for (mask = 0; mask < 8; mask++)
                 for (i = 0; i < reply->keycodes_per_modifier; i++)
                         if (modmap[(mask * reply->keycodes_per_modifier) + i] == numlock)
                                 xcb_numlock_mask = masks[mask];
@@ -278,3 +250,12 @@ void xcb_get_numlock_mask(xcb_connection_t *conn) {
         xcb_key_symbols_free(keysyms);
         free(reply);
 }
+
+/*
+ * Raises the given window (typically client->frame) above all other windows
+ *
+ */
+void xcb_raise_window(xcb_connection_t *conn, xcb_window_t window) {
+        uint32_t values[] = { XCB_STACK_MODE_ABOVE };
+        xcb_configure_window(conn, window, XCB_CONFIG_WINDOW_STACK_MODE, values);
+}

src/xinerama.c

@@ -100,6 +100,31 @@ i3Screen *get_screen_most(direction_t direction) {
         return candidate;
 }
 
+static void initialize_screen(xcb_connection_t *conn, i3Screen *screen, Workspace *workspace) {
+        i3Font *font = load_font(conn, config.font);
+
+        workspace->screen = screen;
+        screen->current_workspace = workspace->num;
+
+        /* Create a bar for each screen */
+        Rect bar_rect = {screen->rect.x,
+                         screen->rect.height - (font->height + 6),
+                         screen->rect.x + screen->rect.width,
+                         font->height + 6};
+        uint32_t mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
+        uint32_t values[] = {1, XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS};
+        screen->bar = create_window(conn, bar_rect, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_CURSOR_LEFT_PTR, mask, values);
+        screen->bargc = xcb_generate_id(conn);
+        xcb_create_gc(conn, screen->bargc, screen->bar, 0, 0);
+
+        SLIST_INIT(&(screen->dock_clients));
+
+        /* Copy dimensions */
+        memcpy(&(workspace->rect), &(screen->rect), sizeof(Rect));
+        LOG("that is virtual screen at %d x %d with %d x %d\n",
+                        screen->rect.x, screen->rect.y, screen->rect.width, screen->rect.height);
+}
+
 /*
  * Fills virtual_screens with exactly one screen with width/height of the whole X server.
  *
@@ -114,6 +139,10 @@ static void disable_xinerama(xcb_connection_t *conn) {
         s->rect.width = root_screen->width_in_pixels;
         s->rect.height = root_screen->height_in_pixels;
 
+        num_screens = 1;
+        s->num = 0;
+        initialize_screen(conn, s, &(workspaces[0]));
+
         TAILQ_INSERT_TAIL(virtual_screens, s, screens);
 
         xinerama_enabled = false;
@@ -170,31 +199,6 @@ static void query_screens(xcb_connection_t *conn, struct screens_head *screenlis
         }
 }
 
-static void initialize_screen(xcb_connection_t *conn, i3Screen *screen, Workspace *workspace) {
-        i3Font *font = load_font(conn, config.font);
-
-        workspace->screen = screen;
-        screen->current_workspace = workspace->num;
-
-        /* Create a bar for each screen */
-        Rect bar_rect = {screen->rect.x,
-                         screen->rect.height - (font->height + 6),
-                         screen->rect.x + screen->rect.width,
-                         font->height + 6};
-        uint32_t mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
-        uint32_t values[] = {1, XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS};
-        screen->bar = create_window(conn, bar_rect, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_CURSOR_LEFT_PTR, mask, values);
-        screen->bargc = xcb_generate_id(conn);
-        xcb_create_gc(conn, screen->bargc, screen->bar, 0, 0);
-
-        SLIST_INIT(&(screen->dock_clients));
-
-        /* Copy dimensions */
-        memcpy(&(workspace->rect), &(screen->rect), sizeof(Rect));
-        LOG("that is virtual screen at %d x %d with %d x %d\n",
-                        screen->rect.x, screen->rect.y, screen->rect.width, screen->rect.height);
-}
-
 /*
  * We have just established a connection to the X server and need the initial Xinerama
  * information to setup workspaces for each screen.

website/screenshots/index.html

@@ -78,7 +78,6 @@ li {
   <li>
     <a href="/screenshots/i3-5.png">i3 v3.α-bf2</a>, mc, vim, xosview, mplayer, irssi, gajim, i3status
   </li>
-
 </ul>
 
 <h2>Screencasts</h2>