*.gcno
testcases/testsuite-*
testcases/latest
+testcases/Makefile
*.output
*.tab.*
*.yy.c
UNUSED:=$(shell $(MAKE) loglevels.h)
endif
-SUBDIRS:=i3-msg i3-input i3-nagbar i3-config-wizard i3bar
+SUBDIRS:=i3-msg i3-input i3-nagbar i3-config-wizard i3bar i3-dump-log
# Depend on the specific file (.c for each .o) and on all headers
src/%.o: src/%.c ${HEADERS}
src/cfgparse.yy.o: src/cfgparse.l src/cfgparse.y.o ${HEADERS}
echo "[i3] LEX $<"
- flex -i -o$(@:.o=.c) $<
+ $(FLEX) -i -o$(@:.o=.c) $<
$(CC) $(CPPFLAGS) $(CFLAGS) -DLOGLEVEL="(1 << $(shell awk '/cfgparse.l/ { print NR }' loglevels.tmp))" -c -o $@ $(@:.o=.c)
src/cmdparse.yy.o: src/cmdparse.l src/cmdparse.y.o ${HEADERS}
echo "[i3] LEX $<"
- flex -Pcmdyy -i -o$(@:.o=.c) $<
+ $(FLEX) -Pcmdyy -i -o$(@:.o=.c) $<
$(CC) $(CPPFLAGS) $(CFLAGS) -DLOGLEVEL="(1 << $(shell awk '/cmdparse.l/ { print NR }' loglevels.tmp))" -c -o $@ $(@:.o=.c)
src/cfgparse.y.o: src/cfgparse.y ${HEADERS}
echo "[i3] YACC $<"
- bison --debug --verbose -b $(basename $< .y) -d $<
+ $(BISON) --debug --verbose -b $(basename $< .y) -d $<
$(CC) $(CPPFLAGS) $(CFLAGS) -DLOGLEVEL="(1 << $(shell awk '/cfgparse.y/ { print NR }' loglevels.tmp))" -c -o $@ $(<:.y=.tab.c)
src/cmdparse.y.o: src/cmdparse.y ${HEADERS}
echo "[i3] YACC $<"
- bison -p cmdyy --debug --verbose -b $(basename $< .y) -d $<
+ $(BISON) -p cmdyy --debug --verbose -b $(basename $< .y) -d $<
$(CC) $(CPPFLAGS) $(CFLAGS) -DLOGLEVEL="(1 << $(shell awk '/cmdparse.y/ { print NR }' loglevels.tmp))" -c -o $@ $(<:.y=.tab.c)
[ ! -e i3-${VERSION}.tar.bz2 ] || rm i3-${VERSION}.tar.bz2
mkdir i3-${VERSION}
cp i3-migrate-config-to-v4 i3-sensible-* i3.config.keycodes DEPENDS GOALS LICENSE PACKAGE-MAINTAINER RELEASE-NOTES-${VERSION} i3.config i3.desktop i3.welcome pseudo-doc.doxygen i3-wsbar Makefile i3-${VERSION}
- cp -r src libi3 i3-msg i3-nagbar i3-config-wizard i3bar yajl-fallback include man i3-${VERSION}
+ cp -r src libi3 i3-msg i3-nagbar i3-config-wizard i3bar i3-dump-log yajl-fallback include man i3-${VERSION}
# Only copy toplevel documentation (important stuff)
mkdir i3-${VERSION}/docs
# Pre-generate documentation
DEBUG=1
COVERAGE=0
INSTALL=install
+FLEX=flex
+BISON=bison
ifndef PREFIX
PREFIX=/usr
endif
endif
LIBS += -lm
+LIBS += -lrt
LIBS += -L $(TOPDIR)/libi3 -li3
LIBS += $(call ldflags_for_lib, xcb-event,xcb-event)
LIBS += $(call ldflags_for_lib, xcb-keysyms,xcb-keysyms)
Package: i3
Architecture: any
Section: x11
-Depends: i3-wm, ${misc:Depends}
-Recommends: i3lock, suckless-tools, i3status
+Depends: i3-wm (=${binary:Version}), ${misc:Depends}
+Recommends: i3lock (>= 2.2), suckless-tools, i3status (>= 2.3)
Description: metapackage (i3 window manager, screen locker, menu, statusbar)
This metapackage installs the i3 window manager (i3-wm), the i3lock screen
locker, i3status (for system information) and suckless-tools (for dmenu).
docs/testsuite.html
docs/i3-sync-working.png
docs/i3-sync.png
+docs/tree-layout1.png
+docs/tree-layout2.png
+docs/tree-shot1.png
+docs/tree-shot2.png
+docs/tree-shot3.png
+docs/tree-shot4.png
-# distribution-specific mechanism to find the preferred terminal emulator. On
-# Debian, there is the x-terminal-emulator symlink for example.
-# Please don't touch the first line, though:
- which $TERMINAL >/dev/null && exec $TERMINAL "$@"
+ [ -n "$TERMINAL" ] && which $TERMINAL >/dev/null && exec $TERMINAL "$@"
+# Debian-specific: use x-terminal-emulator
+which x-terminal-emulator >/dev/null && exec x-terminal-emulator "$@"
layout (like dwm, awesome, …) but provide mechanisms for you to easily create
the layout you need at the moment.
-=== The layout table
+=== The layout tree
-*********************************************************************************
-This section has not been updated for v4.0 yet, sorry! We wanted to release on
-time, but we will update this soon. Please talk to us on IRC if you need to
-know stuff *NOW* :).
-*********************************************************************************
-
-/////////////////////////////////////////////////////////////////////////////////
-To accomplish flexible layouts, we decided to simply use a table. The table
-grows and shrinks as you need it. Each cell holds a container which then holds
-windows (see picture below). You can use different layouts for each container
-(default layout and stacking layout).
+The data structure which i3 uses to keep track of your windows is a tree. Every
+node in the tree is a container (type +Con+). Some containers represent actual
+windows (every container with a +window != NULL+), some represent split
+containers and a few have special purposes: they represent workspaces, outputs
+(like VGA1, LVDS1, …) or the X11 root window.
So, when you open a terminal and immediately open another one, they reside in
-the same container, in default layout. The layout table has exactly one column,
-one row and therefore one cell. When you move one of the terminals to the
-right, the table needs to grow. It will be expanded to two columns and one row.
-This enables you to have different layouts for each container. The table then
-looks like this:
-
-[width="15%",cols="^,^"]
-|========
-| T1 | T2
-|========
-
-When moving terminal 2 to the bottom, the table will be expanded again.
-
-[width="15%",cols="^,^"]
-|========
-| T1 |
-| | T2
-|========
+the same split container, which uses the default layout. In case of an empty
+workspace, the split container we are talking about is the workspace.
-You can really think of the layout table like a traditional HTML table, if
-you’ve ever designed one. Especially col- and rowspan work similarly. Below,
-you see an example of colspan=2 for the first container (which has T1 as
-window).
-
-[width="15%",cols="^asciidoc"]
-|========
-| T1
-|
-[cols="^,^",frame="none"]
-!========
-! T2 ! T3
-!========
-|========
-
-Furthermore, you can freely resize table cells.
-/////////////////////////////////////////////////////////////////////////////////
+To get an impression of how different layouts are represented, just play around
+and look at the data structures -- they are exposed as a JSON hash. See
+http://i3wm.org/docs/ipc.html#_get_tree_reply for documentation on that and an
+example.
== Files
Contains debugging functions to print unhandled X events.
src/ewmh.c::
-iFunctions to get/set certain EWMH properties easily.
+Functions to get/set certain EWMH properties easily.
src/floating.c::
Contains functions for floating mode (mostly resizing/dragging).
== Data structures
-*********************************************************************************
-This section has not been updated for v4.0 yet, sorry! We wanted to release on
-time, but we will update this soon. Please talk to us on IRC if you need to
-know stuff *NOW* :).
-*********************************************************************************
-
-/////////////////////////////////////////////////////////////////////////////////
See include/data.h for documented data structures. The most important ones are
explained right here.
+/////////////////////////////////////////////////////////////////////////////////
+// TODO: update image
+
image:bigpicture.png[The Big Picture]
/////////////////////////////////////////////////////////////////////////////////
So, the hierarchy is:
. *X11 root window*, the root container
-. *Virtual screens* (Screen 0 in this example)
+. *Output container* (LVDS1 in this example)
. *Content container* (there are also containers for dock windows)
. *Workspaces* (Workspace 1 in this example, with horizontal orientation)
. *Split container* (vertically split)
The data type is +Con+, in all cases.
-=== Virtual screens
+=== X11 root window
-A virtual screen (type `i3Screen`) is generated from the connected outputs
-obtained through RandR. The difference to the raw RandR outputs as seen
-when using +xrandr(1)+ is that it falls back to the lowest common resolution of
-the actual enabled outputs.
+The X11 root window is a single window per X11 display (a display is identified
+by +:0+ or +:1+ etc.). The root window is what you draw your background image
+on. It spans all the available outputs, e.g. +VGA1+ is a specific part of the
+root window and +LVDS1+ is a specific part of the root window.
+
+=== Output container
+
+Every active output obtained through RandR is represented by one output
+container. Outputs are considered active when a mode is configured (meaning
+something is actually displayed on the output) and the output is not a clone.
For example, if your notebook has a screen resolution of 1280x800 px and you
connect a video projector with a resolution of 1024x768 px, set it up in clone
-mode (+xrandr \--output VGA1 \--mode 1024x768 \--same-as LVDS1+), i3 will have
-one virtual screen.
+mode (+xrandr \--output VGA1 \--mode 1024x768 \--same-as LVDS1+), i3 will
+reduce the resolution to the lowest common resolution and disable one of the
+cloned outputs afterwards.
However, if you configure it using +xrandr \--output VGA1 \--mode 1024x768
-\--right-of LVDS1+, i3 will generate two virtual screens. For each virtual
-screen, a new workspace will be assigned. New workspaces are created on the
-screen you are currently on.
+\--right-of LVDS1+, i3 will set both outputs active. For each output, a new
+workspace will be assigned. New workspaces are created on the output you are
+currently on.
+
+=== Content container
+
+Each output has multiple children. Two of them are dock containers which hold
+dock clients. The other one is the content container, which holds the actual
+content (workspaces) of this output.
=== Workspace
A workspace is identified by its name. Basically, you could think of
workspaces as different desks in your office, if you like the desktop
-methaphor. They just contain different sets of windows and are completely
+metaphor. They just contain different sets of windows and are completely
separate of each other. Other window managers also call this ``Virtual
desktops''.
-=== The layout table
+=== Split container
-*********************************************************************************
-This section has not been updated for v4.0 yet, sorry! We wanted to release on
-time, but we will update this soon. Please talk to us on IRC if you need to
-know stuff *NOW* :).
-*********************************************************************************
+A split container is a container which holds an arbitrary amount of split
+containers or X11 window containers. It has an orientation (horizontal or
+vertical) and a layout.
-/////////////////////////////////////////////////////////////////////////////////
-
-Each workspace has a table, which is just a two-dimensional dynamic array
-containing Containers (see below). This table grows and shrinks as you need it
-(by moving windows to the right you can create a new column in the table, by
-moving them to the bottom you create a new row).
+Split containers (and X11 window containers, which are a subtype of split
+containers) can have different border styles.
-/////////////////////////////////////////////////////////////////////////////////
+=== X11 window container
-=== Container
-
-*********************************************************************************
-This section has not been updated for v4.0 yet, sorry! We wanted to release on
-time, but we will update this soon. Please talk to us on IRC if you need to
-know stuff *NOW* :).
-*********************************************************************************
-
-/////////////////////////////////////////////////////////////////////////////////
-
-A container is the content of a table’s cell. It holds an arbitrary amount of
-windows and has a specific layout (default layout, stack layout or tabbed
-layout). Containers can consume multiple table cells by modifying their
-colspan/rowspan attribute.
-
-/////////////////////////////////////////////////////////////////////////////////
-
-=== Client
-
-A client is x11-speak for a window.
+An X11 window container holds exactly one X11 window. These are the leaf nodes
+of the layout tree, they cannot have any children.
== List/queue macros
whether this window is a dock (`_NET_WM_WINDOW_TYPE_DOCK`), like dzen2 for
example. Docks are handled differently, they don’t have decorations and are not
assigned to a specific container. Instead, they are positioned at the bottom
-of the screen. To get the height which needs to be reserved for the window,
-the `_NET_WM_STRUT_PARTIAL` property is used.
+or top of the screen (in the appropriate dock area containers). To get the
+height which needs to be reserved for the window, the `_NET_WM_STRUT_PARTIAL`
+property is used.
Furthermore, the list of assignments (to other workspaces, which may be on
other screens) is checked. If the window matches one of the user’s criteria,
== Rendering (src/layout.c, render_layout() and render_container())
-*********************************************************************************
-This section has not been updated for v4.0 yet, sorry! We wanted to release on
-time, but we will update this soon. Please talk to us on IRC if you need to
-know stuff *NOW* :).
-*********************************************************************************
-
-/////////////////////////////////////////////////////////////////////////////////
-
-
-There are several entry points to rendering: `render_layout()`,
-`render_workspace()` and `render_container()`. The former one calls
-`render_workspace()` for every screen, which in turn will call
-`render_container()` for every container inside its layout table. Therefore, if
-you need to render only a single container, for example because a window was
-removed, added or changed its title, you should directly call
-render_container().
-
-Rendering consists of two steps: In the first one, in `render_workspace()`, each
-container gets its position (screen offset + offset in the table) and size
-(container's width times colspan/rowspan). Then, `render_container()` is called,
-which takes different approaches, depending on the mode the container is in:
-
-=== Common parts
-
-On the frame (the window which was created around the client’s window for the
-decorations), a black rectangle is drawn as a background for windows like
-MPlayer, which do not completely fit into the frame.
-
-=== Default mode
-
-Each clients gets the container’s width and an equal amount of height.
-
-=== Stack mode
-
-In stack mode, a window containing the decorations of all windows inside the
-container is placed at the top. The currently focused window is then given the
-whole remaining space.
-
-=== Tabbed mode
-
-Tabbed mode is like stack mode, except that the window decorations are drawn
-in one single line at the top of the container.
-
-=== Window decorations
+Rendering in i3 version 4 is the step which assigns the correct sizes for
+borders, decoration windows, child windows and the stacking order of all
+windows. In a separate step (+x_push_changes()+), these changes are pushed to
+X11.
+
+Keep in mind that all these properties (+rect+, +window_rect+ and +deco_rect+)
+are temporary, meaning they will be overwritten by calling +render_con+.
+Persistent position/size information is kept in +geometry+.
+
+The entry point for every rendering operation (except for the case of moving
+floating windows around) currently is +tree_render()+ which will re-render
+everything that’s necessary (for every output, only the currently displayed
+workspace is rendered). This behavior is expected to change in the future,
+since for a lot of updates, re-rendering everything is not actually necessary.
+Focus was on getting it working correct, not getting it work very fast.
+
+What +tree_render()+ actually does is calling +render_con()+ on the root
+container and then pushing the changes to X11. The following sections talk
+about the different rendering steps, in the order of "top of the tree" (root
+container) to the bottom.
+
+=== Rendering the root container
+
+The i3 root container (`con->type == CT_ROOT`) represents the X11 root window.
+It contains one child container for every output (like LVDS1, VGA1, …), which
+is available on your computer.
+
+Rendering the root will first render all tiling windows and then all floating
+windows. This is necessary because a floating window can be positioned in such
+a way that it is visible on two different outputs. Therefore, by first
+rendering all the tiling windows (of all outputs), we make sure that floating
+windows can never be obscured by tiling windows.
+
+Essentially, though, this code path will just call +render_con()+ for every
+output and +x_raise_con(); render_con()+ for every floating window.
+
+In the special case of having a "global fullscreen" window (fullscreen mode
+spanning all outputs), a shortcut is taken and +x_raise_con(); render_con()+ is
+only called for the global fullscreen window.
+
+=== Rendering an output
+
+Output containers (`con->layout == L_OUTPUT`) represent a hardware output like
+LVDS1, VGA1, etc. An output container has three children (at the moment): One
+content container (having workspaces as children) and the top/bottom dock area
+containers.
+
+The rendering happens in the function +render_l_output()+ in the following
+steps:
+
+1. Find the content container (`con->type == CT_CON`)
+2. Get the currently visible workspace (+con_get_fullscreen_con(content,
+ CF_OUTPUT)+).
+3. If there is a fullscreened window on that workspace, directly render it and
+ return, thus ignoring the dock areas.
+4. Sum up the space used by all the dock windows (they have a variable height
+ only).
+5. Set the workspace rects (x/y/width/height) based on the position of the
+ output (stored in `con->rect`) and the usable space
+ (`con->rect.{width,height}` without the space used for dock windows).
+6. Recursively raise and render the output’s child containers (meaning dock
+ area containers and the content container).
+
+=== Rendering a workspace or split container
+
+From here on, there really is no difference anymore. All containers are of
+`con->type == CT_CON` (whether workspace or split container) and some of them
+have a `con->window`, meaning they represent an actual window instead of a
+split container.
+
+==== Default layout
+
+In default layout, containers are placed horizontally or vertically next to
+each other (depending on the `con->orientation`). If a child is a leaf node (as
+opposed to a split container) and has border style "normal", appropriate space
+will be reserved for its window decoration.
+
+==== Stacked layout
+
+In stacked layout, only the focused window is actually shown (this is achieved
+by calling +x_raise_con()+ in reverse focus order at the end of +render_con()+).
+
+The available space for the focused window is the size of the container minus
+the height of the window decoration for all windows inside this stacked
+container.
-The window decorations consist of a rectangle in the appropriate color (depends
-on whether this window is the currently focused one, the last focused one in a
-not focused container or not focused at all) forming the background.
-Afterwards, two lighter lines are drawn and the last step is drawing the
-window’s title (see WM_NAME) onto it.
+If border style is "1pixel" or "none", no window decoration height will be
+reserved (or displayed later on), unless there is more than one window inside
+the stacked container.
+
+==== Tabbed layout
+
+Tabbed layout works precisely like stacked layout, but the window decoration
+position/size is different: They are placed next to each other on a single line
+(fixed height).
+
+==== Dock area layout
+
+This is a special case. Users cannot chose the dock area layout, but it will be
+set for the dock area containers. In the dockarea layout (at the moment!),
+windows will be placed above each other.
+
+=== Rendering a window
+
+A window’s size and position will be determined in the following way:
+
+1. Subtract the border if border style is not "none" (but "normal" or "1pixel").
+2. Subtract the X11 border, if the window has an X11 border > 0.
+3. Obey the aspect ratio of the window (think MPlayer).
+4. Obey the height- and width-increments of the window (think terminal emulator
+ which can only be resized in one-line or one-character steps).
+
+== Pushing updates to X11 / Drawing
+
+A big problem with i3 before version 4 was that we just sent requests to X11
+anywhere in the source code. This was bad because nobody could understand the
+entirety of our interaction with X11, it lead to subtle bugs and a lot of edge
+cases which we had to consider all over again.
+
+Therefore, since version 4, we have a single file, +src/x.c+, which is
+responsible for repeatedly transferring parts of our tree datastructure to X11.
+
++src/x.c+ consists of multiple parts:
+
+1. The state pushing: +x_push_changes()+, which calls +x_push_node()+.
+2. State modification functions: +x_con_init+, +x_reinit+,
+ +x_reparent_child+, +x_move_win+, +x_con_kill+, +x_raise_con+, +x_set_name+
+ and +x_set_warp_to+.
+3. Expose event handling (drawing decorations): +x_deco_recurse()+ and
+ +x_draw_decoration()+.
+
+=== Pushing state to X11
+
+In general, the function +x_push_changes+ should be called to push state
+changes. Only when the scope of the state change is clearly defined (for
+example only the title of a window) and its impact is known beforehand, one can
+optimize this and call +x_push_node+ on the appropriate con directly.
+
++x_push_changes+ works in the following steps:
+
+1. Clear the eventmask for all mapped windows. This leads to not getting
+ useless ConfigureNotify or EnterNotify events which are caused by our
+ requests. In general, we only want to handle user input.
+2. Stack windows above each other, in reverse stack order (starting with the
+ most obscured/bottom window). This is relevant for floating windows which
+ can overlap each other, but also for tiling windows in stacked or tabbed
+ containers. We also update the +_NET_CLIENT_LIST_STACKING+ hint which is
+ necessary for tab drag and drop in Chromium.
+3. +x_push_node+ will be called for the root container, recursively calling
+ itself for the container’s children. This function actually pushes the
+ state, see the next paragraph.
+4. If the pointer needs to be warped to a different position (for example when
+ changing focus to a differnt output), it will be warped now.
+5. The eventmask is restored for all mapped windows.
+6. Window decorations will be rendered by calling +x_deco_recurse+ on the root
+ container, which then recursively calls itself for the children.
+7. If the input focus needs to be changed (because the user focused a different
+ window), it will be updated now.
+8. +x_push_node_unmaps+ will be called for the root container. This function
+ only pushes UnmapWindow requests. Separating the state pushing is necessary
+ to handle fullscreen windows (and workspace switches) in a smooth fashion:
+ The newly visible windows should be visible before the old windows are
+ unmapped.
+
++x_push_node+ works in the following steps:
+
+1. Update the window’s +WM_NAME+, if changed (the +WM_NAME+ is set on i3
+ containers mainly for debugging purposes).
+2. Reparents a child window into the i3 container if the container was created
+ for a specific managed window.
+3. If the size/position of the i3 container changed (due to opening a new
+ window or switching layouts for example), the window will be reconfigured.
+ Also, the pixmap which is used to draw the window decoration/border on is
+ reconfigured (pixmaps are size-dependent).
+4. Size/position for the child window is adjusted.
+5. The i3 container is mapped if it should be visible and was not yet mapped.
+ When mapping, +WM_STATE+ is set to +WM_STATE_NORMAL+. Also, the eventmask of
+ the child window is updated and the i3 container’s contents are copied from
+ the pixmap.
+6. +x_push_node+ is called recursively for all children of the current
+ container.
+
++x_push_node_unmaps+ handles the remaining case of an i3 container being
+unmapped if it should not be visible anymore. +WM_STATE+ will be set to
++WM_STATE_WITHDRAWN+.
+
+
+=== Drawing window decorations/borders/backgrounds
+
++x_draw_decoration+ draws window decorations. It is run for every leaf
+container (representing an actual X11 window) and for every non-leaf container
+which is in a stacked/tabbed container (because stacked/tabbed containers
+display a window decoration for split containers, which at the moment just says
+"another container").
+
+Then, parameters are collected to be able to determine whether this decoration
+drawing is actually necessary or was already done. This saves a substantial
+number of redraws (depending on your workload, but far over 50%).
+
+Assuming that we need to draw this decoration, we start by filling the empty
+space around the child window (think of MPlayer with a specific aspect ratio)
+in the user-configured client background color.
+
+Afterwards, we draw the appropriate border (in case of border styles "normal"
+and "1pixel") and the top bar (in case of border style "normal").
+
+The last step is drawing the window title on the top bar.
-=== Fullscreen windows
-For fullscreen windows, the `rect` (x, y, width, height) is not changed to
-allow the client to easily go back to its previous position. Instead,
-fullscreen windows are skipped when rendering.
+/////////////////////////////////////////////////////////////////////////////////
-=== Resizing containers
+== Resizing containers
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
-----------------------
Just send us the generated file via email.
+
+== Thought experiments
+
+In this section, we collect thought experiments, so that we don’t forget our
+thoughts about specific topics. They are not necessary to get into hacking i3,
+but if you are interested in one of the topics they cover, you should read them
+before asking us why things are the way they are or why we don’t implement
+things.
+
+=== Using cgroups per workspace
+
+cgroups (control groups) are a linux-only feature which provides the ability to
+group multiple processes. For each group, you can individually set resource
+limits, like allowed memory usage. Furthermore, and more importantly for our
+purposes, they serve as a namespace, a label which you can attach to processes
+and their children.
+
+One interesting use for cgroups is having one cgroup per workspace (or
+container, doesn’t really matter). That way, you could set different priorities
+and have a workspace for important stuff (say, writing a LaTeX document or
+programming) and a workspace for unimportant background stuff (say,
+JDownloader). Both tasks can obviously consume a lot of I/O resources, but in
+this example it doesn’t really matter if JDownloader unpacks the download a
+minute earlier or not. However, your compiler should work as fast as possible.
+Having one cgroup per workspace, you would assign more resources to the
+programming workspace.
+
+Another interesting feature is that an inherent problem of the workspace
+concept could be solved by using cgroups: When starting an application on
+workspace 1, then switching to workspace 2, you will get the application’s
+window(s) on workspace 2 instead of the one you started it on. This is because
+the window manager does not have any mapping between the process it starts (or
+gets started in any way) and the window(s) which appear.
+
+Imagine for example using dmenu: The user starts dmenu by pressing Mod+d, dmenu
+gets started with PID 3390. The user then decides to launch Firefox, which
+takes a long time. So he enters firefox into dmenu and presses enter. Firefox
+gets started with PID 4001. When it finally finishes loading, it creates an X11
+window and uses MapWindow to make it visible. This is the first time i3
+actually gets in touch with Firefox. It decides to map the window, but it has
+no way of knowing that this window (even though it has the _NET_WM_PID property
+set to 4001) belongs to the dmenu the user started before.
+
+How do cgroups help with this? Well, when pressing Mod+d to launch dmenu, i3
+would create a new cgroup, let’s call it i3-3390-1. It launches dmenu in that
+cgroup, which gets PID 3390. As before, the user enters firefox and Firefox
+gets launched with PID 4001. This time, though, the Firefox process with PID
+4001 is *also* member of the cgroup i3-3390-1 (because fork()ing in a cgroup
+retains the cgroup property). Therefore, when mapping the window, i3 can look
+up in which cgroup the process is and can establish a mapping between the
+workspace and the window.
+
+There are multiple problems with this approach:
+
+. Every application has to properly set +_NET_WM_PID+. This is acceptable and
+ patches can be written for the few applications which don’t set the hint yet.
+. It does only work on Linux, since cgroups are a Linux-only feature. Again,
+ this is acceptable.
+. The main problem is that some applications create X11 windows completely
+ independent of UNIX processes. An example for this is Chromium (or
+ gnome-terminal), which, when being started a second time, communicates with
+ the first process and lets the first process open a new window. Therefore, if
+ you have a Chromium window on workspace 2 and you are currently working on
+ workspace 3, starting +chromium+ does not lead to the desired result (the
+ window will open on workspace 2).
+
+Therefore, my conclusion is that the only proper way of fixing the "window gets
+opened on the wrong workspace" problem is in the application itself. Most
+modern applications support freedesktop startup-notifications which can be
+used for this.
IPC interface (interprocess communication)
==========================================
Michael Stapelberg <michael+i3@stapelberg.de>
-October 2011
+December 2011
This document describes how to interface with i3 from a separate process. This
is useful for example to remote-control i3 (to write test cases for example) or
COMMAND (0)::
The payload of the message is a command for i3 (like the commands you
can bind to keys in the configuration file) and will be executed
- directly after receiving it. There is no reply to this message.
+ directly after receiving it.
GET_WORKSPACES (1)::
Gets the current workspaces. The reply will be a JSON-encoded list of
workspaces (see the reply section).
Gets the configuration (as JSON map) of the workspace bar with the
given ID. If no ID is provided, an array with all configured bar IDs is
returned instead.
+GET_LOG_MARKERS (7)::
+ Gets the SHM log markers for the current position, the last wrap, the
+ SHM segment name and segment size. This is necessary for tools like
+ i3-dump-log which want to display the SHM log.
So, a typical message could look like this:
--------------------------------------------------
COMMAND (0)::
Confirmation/Error code for the COMMAND message.
-GET_WORKSPACES (1)::
+WORKSPACES (1)::
Reply to the GET_WORKSPACES message.
SUBSCRIBE (2)::
Confirmation/Error code for the SUBSCRIBE message.
-GET_OUTPUTS (3)::
+OUTPUTS (3)::
Reply to the GET_OUTPUTS message.
-GET_TREE (4)::
+TREE (4)::
Reply to the GET_TREE message.
-GET_MARKS (5)::
+MARKS (5)::
Reply to the GET_MARKS message.
-GET_BAR_CONFIG (6)::
+BAR_CONFIG (6)::
Reply to the GET_BAR_CONFIG message.
+LOG_MARKERS (7)::
+ Reply to the GET_LOG_MARKERS message.
=== COMMAND reply
{ "success": true }
-------------------
-=== GET_WORKSPACES reply
+=== WORKSPACES reply
The reply consists of a serialized list of workspaces. Each workspace has the
following properties:
]
-------------------
-=== GET_TREE reply
+=== TREE reply
The reply consists of a serialized tree. Each node in the tree (representing
one container) has at least the properties listed below. While the nodes might
}
------------------------
-=== GET_MARKS reply
+=== MARKS reply
The reply consists of a single array of strings for each container that has a
mark. The order of that array is undefined. If more than one container has the
If no window has a mark the response will be the empty array [].
-=== GET_BAR_CONFIG reply
+=== BAR_CONFIG reply
This can be used by third-party workspace bars (especially i3bar, but others
are free to implement compatible alternatives) to get the +bar+ block
}
--------------
+=== LOG_MARKERS reply
+
+Gets the SHM log markers for the current position, the last wrap, the
+SHM segment name and segment size. This is necessary for tools like
+i3-dump-log which want to display the SHM log.
+
+The reply is a JSON map with the following entries:
+
+shmname (string)::
+ The name of the SHM segment, will be of the format +/i3-log-<pid>+.
+size (integer)::
+ The size (in bytes) of the SHM segment. If this is 0, SHM logging is
+ disabled.
+offset_next_write (integer)::
+ The offset in the SHM segment at which the next write will happen.
+ Tools should start printing lines from here, since the bytes following
+ this offset are the oldest log lines. However, the first line might be
+ garbled, so it makes sense to skip all bytes until the first \0.
+offset_last_wrap (integer)::
+ The offset in the SHM segment at which the last wrap occured. i3 only
+ stores entire messages in the SHM log, so it might waste a few bytes at
+ the end to be more efficient. Tools should not print content after the
+ offset_last_wrap.
+
+*Example*:
+-----------------------------
+{
+ "offset_next_write":132839,
+ "offset_last_wrap":26214400,
+ "shmname":"/i3-log-3392",
+ "size":26214400
+}
+-----------------------------
+
== Events
[[events]]
i3 stores all information about the X11 outputs, workspaces and layout of the
windows on them in a tree. The root node is the X11 root window, followed by
the X11 outputs, then dock areas and a content container, then workspaces and
-finally the windows themselve. In previous versions of i3 we had multiple lists
+finally the windows themselves. In previous versions of i3 we had multiple lists
(of outputs, workspaces) and a table for each workspace. That approach turned
out to be complicated to use (snapping), understand and implement.
}
---------------------------
+=== i3bar command
+
+By default i3 will just pass +i3bar+ and let your shell handle the execution,
+searching your +$PATH+ for a correct version.
+If you have a different +i3bar+ somewhere or the binary is not in your +$PATH+ you can
+tell i3 what to execute.
+
+The specified command will be passed to +sh -c+, so you can use globbing and
+have to have correct quoting etc.
+
+*Syntax*:
+----------------------
+i3bar_command command
+----------------------
+
+*Example*:
+-------------------------------------------------
+bar {
+ i3bar_command /home/user/bin/i3bar
+}
+-------------------------------------------------
+
=== Statusline command
i3bar can run a program and display every line of its +stdout+ output on the
*Example*:
-------------------------------------------------
-status_command i3status --config ~/.i3status.conf
+bar {
+ status_command i3status --config ~/.i3status.conf
+}
-------------------------------------------------
=== Display mode
*Example*:
----------------
-mode hide
+bar {
+ mode hide
+}
----------------
=== Position
*Example*:
---------------------
-position top
+bar {
+ position top
+}
---------------------
=== Output(s)
handle all outputs. Restricting the outputs is useful for using different
options for different outputs by using multiple 'bar' blocks.
+To make a particular i3bar instance handle multiple outputs, specify the output
+directive multiple times.
+
*Syntax*:
---------------
output <output>
-------------------------------
# big monitor: everything
bar {
- output HDMI2
- status_command i3status
+ # The display is connected either via HDMI or via DisplayPort
+ output HDMI2
+ output DP2
+ status_command i3status
}
# laptop monitor: bright colors and i3status with less modules.
bar {
- output LVDS1
- status_command i3status --config ~/.i3status-small.conf
- colors {
- background #000000
- statusline #ffffff
- }
+ output LVDS1
+ status_command i3status --config ~/.i3status-small.conf
+ colors {
+ background #000000
+ statusline #ffffff
+ }
}
-------------------------------
*Example*:
-------------------------
# disable system tray
-tray_output none
+bar {
+ tray_output none
+}
# show tray icons on the big monitor
-tray_output HDMI2
+bar {
+ tray_output HDMI2
+}
-------------------------
=== Font
*Example*:
--------------------------------------------------------------
-font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+bar {
+ font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+}
--------------------------------------------------------------
=== Workspace buttons
*Example*:
--------------------
-workspace_buttons no
+bar {
+ workspace_buttons no
+}
--------------------
=== Colors
*Example*:
--------------------------------------
-colors {
- background #000000
- statusline #ffffff
-
- focused_workspace #ffffff #285577
- active_workspace #ffffff #333333
- inactive_workspace #888888 #222222
- urgent_workspace #ffffff #900000
+bar {
+ colors {
+ background #000000
+ statusline #ffffff
+
+ focused_workspace #ffffff #285577
+ active_workspace #ffffff #333333
+ inactive_workspace #888888 #222222
+ urgent_workspace #ffffff #900000
+ }
}
--------------------------------------
bindsym mod+g exec gimp
# Start the terminal emulator urxvt which is not yet startup-notification-aware
-bindsym mod+enter exec --no-startup-id urxvt
+bindsym mod+Return exec --no-startup-id urxvt
------------------------------
The +--no-startup-id+ parameter disables startup-notification support for this
cfgparse.yy.o: cfgparse.l cfgparse.y.o ${HEADERS}
echo "[i3-config-wizard] LEX $<"
- flex -i -o$(@:.o=.c) $<
+ $(FLEX) -i -o$(@:.o=.c) $<
$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $(@:.o=.c)
cfgparse.y.o: cfgparse.y ${HEADERS}
echo "[i3-config-wizard] YACC $<"
- bison --debug --verbose -b $(basename $< .y) -d $<
+ $(BISON) --debug --verbose -b $(basename $< .y) -d $<
$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $(<:.y=.tab.c)
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#000000") });
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &border);
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
+ set_font(&font);
-#define txt(x, row, text) xcb_image_text_8(conn, strlen(text), pixmap, pixmap_gc, x, (row * font.height) + 2, text)
+#define txt(x, row, text) \
+ draw_text(text, strlen(text), false, pixmap, pixmap_gc,\
+ x, (row - 1) * font.height + 4, 300 - x * 2)
if (current_step == STEP_WELCOME) {
/* restore font color */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
+ set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
txt(10, 2, "You have not configured i3 yet.");
txt(10, 3, "Do you want me to generate ~/.i3/config?");
txt(85, 7, "No, I will use the defaults");
/* green */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#00FF00") });
+ set_font_colors(pixmap_gc, get_colorpixel("#00FF00"), get_colorpixel("#000000"));
txt(25, 5, "<Enter>");
/* red */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FF0000") });
+ set_font_colors(pixmap_gc, get_colorpixel("#FF0000"), get_colorpixel("#000000"));
txt(31, 7, "<ESC>");
}
if (current_step == STEP_GENERATE) {
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
+ set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
txt(10, 2, "Please choose either:");
txt(85, 4, "Win as default modifier");
else txt(31, 4, "<Win>");
/* the selected modifier */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ bold_font.id });
+ set_font(&bold_font);
+ set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
if (modifier == MOD_Mod4)
txt(31, 4, "<Win>");
else txt(31, 5, "<Alt>");
/* green */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_FONT,
- (uint32_t[]) { get_colorpixel("#00FF00"), font.id });
-
+ set_font(&font);
+ set_font_colors(pixmap_gc, get_colorpixel("#00FF00"), get_colorpixel("#000000"));
txt(25, 9, "<Enter>");
/* red */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FF0000") });
+ set_font_colors(pixmap_gc, get_colorpixel("#FF0000"), get_colorpixel("#000000"));
txt(31, 10, "<ESC>");
}
--- /dev/null
+# Default value so one can compile i3-dump-log standalone
+TOPDIR=..
+
+include $(TOPDIR)/common.mk
+
+CFLAGS += -I$(TOPDIR)/include
+
+# Depend on the object files of all source-files in src/*.c and on all header files
+FILES=$(patsubst %.c,%.o,$(wildcard *.c))
+HEADERS=$(wildcard *.h)
+
+# Depend on the specific file (.c for each .o) and on all headers
+%.o: %.c ${HEADERS}
+ echo "[i3-dump-log] CC $<"
+ $(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<
+
+all: i3-dump-log
+
+i3-dump-log: ${FILES}
+ echo "[i3-dump-log] LINK i3-dump-log"
+ $(CC) $(LDFLAGS) -o i3-dump-log ${FILES} $(LIBS)
+
+install: all
+ echo "[i3-dump-log] INSTALL"
+ $(INSTALL) -d -m 0755 $(DESTDIR)$(PREFIX)/bin
+ $(INSTALL) -m 0755 i3-dump-log $(DESTDIR)$(PREFIX)/bin/
+
+clean:
+ rm -f *.o
+
+distclean: clean
+ rm -f i3-dump-log
--- /dev/null
+/*
+ * vim:ts=4:sw=4:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ *
+ * i3-dump-log/main.c: Dumps the i3 SHM log to stdout.
+ *
+ */
+#include <stdio.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <err.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+#include "libi3.h"
+#include <i3/ipc.h>
+
+int main(int argc, char *argv[]) {
+ char *socket_path = getenv("I3SOCK");
+ int o, option_index = 0;
+ int message_type = I3_IPC_MESSAGE_TYPE_GET_LOG_MARKERS;
+ bool verbose = false;
+
+ static struct option long_options[] = {
+ {"socket", required_argument, 0, 's'},
+ {"version", no_argument, 0, 'v'},
+ {"verbose", no_argument, 0, 'V'},
+ {"help", no_argument, 0, 'h'},
+ {0, 0, 0, 0}
+ };
+
+ char *options_string = "s:vVh";
+
+ while ((o = getopt_long(argc, argv, options_string, long_options, &option_index)) != -1) {
+ if (o == 's') {
+ if (socket_path != NULL)
+ free(socket_path);
+ socket_path = sstrdup(optarg);
+ } else if (o == 'v') {
+ printf("i3-dump-log " I3_VERSION "\n");
+ return 0;
+ } else if (o == 'V') {
+ verbose = true;
+ } else if (o == 'h') {
+ printf("i3-dump-log " I3_VERSION "\n");
+ printf("i3-dump-log [-s <socket>]\n");
+ return 0;
+ }
+ }
+
+ if (socket_path == NULL)
+ socket_path = socket_path_from_x11();
+
+ /* Fall back to the default socket path */
+ if (socket_path == NULL)
+ socket_path = sstrdup("/tmp/i3-ipc.sock");
+
+ int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
+ if (sockfd == -1)
+ err(EXIT_FAILURE, "Could not create socket");
+
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(struct sockaddr_un));
+ addr.sun_family = AF_LOCAL;
+ strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
+ if (connect(sockfd, (const struct sockaddr*)&addr, sizeof(struct sockaddr_un)) < 0)
+ err(EXIT_FAILURE, "Could not connect to i3");
+
+ if (ipc_send_message(sockfd, 0, message_type, NULL) == -1)
+ err(EXIT_FAILURE, "IPC: write()");
+
+ uint32_t reply_length;
+ uint8_t *reply;
+ int ret;
+ if ((ret = ipc_recv_message(sockfd, message_type, &reply_length, &reply)) != 0) {
+ if (ret == -1)
+ err(EXIT_FAILURE, "IPC: read()");
+ exit(1);
+ }
+ char *buffer = NULL;
+ sasprintf(&buffer, "%.*s", reply_length, reply);
+ /* The reply will look like this:
+ * {"offset_next_write":1729,"offset_last_wrap":1996,"size":2048,"shmname":"/i3-log-399"}
+ * IMO, it’s not worth linking a JSON parser in just for this. If the
+ * structure changes in the future, this decision needs to be re-evaluated
+ * :). */
+ int offset_next_write, offset_last_wrap, logbuffer_size;
+ char *next_write_str = strstr(buffer, "offset_next_write"),
+ *last_wrap_str = strstr(buffer, "offset_last_wrap"),
+ *size_str = strstr(buffer, "size"),
+ *shmname = strstr(buffer, "shmname");
+ if (!next_write_str ||
+ !last_wrap_str ||
+ !size_str ||
+ !shmname ||
+ sscanf(next_write_str, "offset_next_write\":%d", &offset_next_write) != 1 ||
+ sscanf(last_wrap_str, "offset_last_wrap\":%d", &offset_last_wrap) != 1 ||
+ sscanf(size_str, "size\":%d", &logbuffer_size) != 1)
+ errx(EXIT_FAILURE, "invalid IPC reply: %s\n", buffer);
+
+ shmname += strlen("shmname\":\"");
+ char *quote = strchr(shmname, '"');
+ if (!quote)
+ errx(EXIT_FAILURE, "invalid IPC reply: %s\n", buffer);
+ *quote = '\0';
+
+ if (verbose)
+ printf("next_write = %d, last_wrap = %d, logbuffer_size = %d, shmname = %s\n",
+ offset_next_write, offset_last_wrap, logbuffer_size, shmname);
+
+ if (*shmname == '\0')
+ errx(EXIT_FAILURE, "Cannot dump log: SHM logging is disabled in i3.");
+
+ int logbuffer_shm = shm_open(shmname, O_RDONLY, 0);
+ if (logbuffer_shm == -1)
+ err(EXIT_FAILURE, "Could not shm_open SHM segment for the i3 log (%s)", shmname);
+
+ char *logbuffer = mmap(NULL, logbuffer_size, PROT_READ, MAP_SHARED, logbuffer_shm, 0);
+ if (logbuffer == MAP_FAILED)
+ err(EXIT_FAILURE, "Could not mmap SHM segment for the i3 log");
+
+ int chars;
+ char *walk = logbuffer + offset_next_write;
+ /* Skip the first line, it very likely is mangled. Not a problem, though,
+ * the log is chatty enough to have plenty lines left. */
+ while (*walk != '\0')
+ walk++;
+
+ /* Print the oldest log lines. We use printf("%s") to stop on \0. */
+ while (walk < (logbuffer + offset_last_wrap)) {
+ chars = printf("%s", walk);
+ /* Shortcut: If there are two consecutive \0 bytes, this part of the
+ * buffer was never touched. To not call printf() for every byte of the
+ * buffer, we directly exit the loop. */
+ if (*walk == '\0' && *(walk+1) == '\0')
+ break;
+ walk += (chars > 0 ? chars : 1);
+ }
+
+ /* Then start from the beginning and print the newer lines */
+ walk = logbuffer;
+ while (walk < (logbuffer + offset_next_write)) {
+ chars = printf("%s", walk);
+ walk += (chars > 0 ? chars : 1);
+ }
+
+ return 0;
+}
extern xcb_window_t root;
-char *convert_ucs_to_utf8(char *input);
-char *convert_utf8_to_ucs2(char *input, int *real_strlen);
-
#endif
static int input_position;
static i3Font font;
static char *prompt;
-static int prompt_len;
+static size_t prompt_len;
static int limit;
xcb_window_t root;
xcb_connection_t *conn;
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &inner);
/* restore font color */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
+ set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
+
+ /* draw the text */
uint8_t *con = concat_strings(glyphs_ucs, input_position);
char *full_text = (char*)con;
if (prompt != NULL) {
memcpy(full_text, prompt, prompt_len * 2);
memcpy(full_text + (prompt_len * 2), con, input_position * 2);
}
- xcb_image_text_16(conn, input_position + prompt_len, pixmap, pixmap_gc, 4 /* X */,
- font.height + 2 /* Y = baseline of font */, (xcb_char2b_t*)full_text);
+ if (input_position + prompt_len != 0)
+ draw_text(full_text, input_position + prompt_len, true, pixmap, pixmap_gc, 4, 4, 492);
/* Copy the contents of the pixmap to the real window */
xcb_copy_area(conn, pixmap, win, pixmap_gc, 0, 0, 0, 0, /* */ 500, font.height + 8);
printf("inp[0] = %02x, inp[1] = %02x, inp[2] = %02x\n", inp[0], inp[1], inp[2]);
/* convert it to UTF-8 */
- char *out = convert_ucs_to_utf8((char*)inp);
+ char *out = convert_ucs2_to_utf8((xcb_char2b_t*)inp, 1);
printf("converted to %s\n", out);
glyphs_ucs[input_position] = malloc(3 * sizeof(uint8_t));
if (glyphs_ucs[input_position] == NULL)
err(EXIT_FAILURE, "malloc() failed\n");
memcpy(glyphs_ucs[input_position], inp, 3);
- glyphs_utf8[input_position] = strdup(out);
+ glyphs_utf8[input_position] = out;
input_position++;
if (input_position == limit)
sockfd = ipc_connect(socket_path);
if (prompt != NULL)
- prompt = convert_utf8_to_ucs2(prompt, &prompt_len);
+ prompt = (char*)convert_utf8_to_ucs2(prompt, &prompt_len);
int screens;
conn = xcb_connect(NULL, &screens);
symbols = xcb_key_symbols_alloc(conn);
font = load_font(pattern, true);
+ set_font(&font);
/* Open an input window */
win = xcb_generate_id(conn);
* this for us) */
xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, win, XCB_CURRENT_TIME);
- /* Create graphics context */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
-
/* Grab the keyboard to get all input */
xcb_flush(conn);
+++ /dev/null
-/*
- * vim:ts=4:sw=4:expandtab
- *
- * i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
- *
- * ucs2_to_utf8.c: Converts between UCS-2 and UTF-8, both of which are used in
- * different contexts in X11.
- *
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <err.h>
-#include <iconv.h>
-
-#include "libi3.h"
-
-static iconv_t conversion_descriptor = 0;
-static iconv_t conversion_descriptor2 = 0;
-
-/*
- * Returns the input string, but converted from UCS-2 to UTF-8. Memory will be
- * allocated, thus the caller has to free the output.
- *
- */
-char *convert_ucs_to_utf8(char *input) {
- size_t input_size = 2;
- /* UTF-8 may consume up to 4 byte */
- int buffer_size = 8;
-
- char *buffer = scalloc(buffer_size);
- size_t output_size = buffer_size;
- /* We need to use an additional pointer, because iconv() modifies it */
- char *output = buffer;
-
- /* We convert the input into UCS-2 big endian */
- if (conversion_descriptor == 0) {
- conversion_descriptor = iconv_open("UTF-8", "UCS-2BE");
- if (conversion_descriptor == 0)
- errx(EXIT_FAILURE, "Error opening the conversion context");
- }
-
- /* Get the conversion descriptor back to original state */
- iconv(conversion_descriptor, NULL, NULL, NULL, NULL);
-
- /* Convert our text */
- int rc = iconv(conversion_descriptor, (void*)&input, &input_size, &output, &output_size);
- if (rc == (size_t)-1) {
- free(buffer);
- perror("Converting to UCS-2 failed");
- return NULL;
- }
-
- return buffer;
-}
-
-/*
- * Converts the given string to UCS-2 big endian for use with
- * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen,
- * a buffer containing the UCS-2 encoded string (16 bit per glyph) is
- * returned. It has to be freed when done.
- *
- */
-char *convert_utf8_to_ucs2(char *input, int *real_strlen) {
- size_t input_size = strlen(input) + 1;
- /* UCS-2 consumes exactly two bytes for each glyph */
- int buffer_size = input_size * 2;
-
- char *buffer = smalloc(buffer_size);
- size_t output_size = buffer_size;
- /* We need to use an additional pointer, because iconv() modifies it */
- char *output = buffer;
-
- /* We convert the input into UCS-2 big endian */
- if (conversion_descriptor2 == 0) {
- conversion_descriptor2 = iconv_open("UCS-2BE", "UTF-8");
- if (conversion_descriptor2 == 0)
- errx(EXIT_FAILURE, "Error opening the conversion context");
- }
-
- /* Get the conversion descriptor back to original state */
- iconv(conversion_descriptor2, NULL, NULL, NULL, NULL);
-
- /* Convert our text */
- int rc = iconv(conversion_descriptor2, (void*)&input, &input_size, &output, &output_size);
- if (rc == (size_t)-1) {
- perror("Converting to UCS-2 failed");
- free(buffer);
- if (real_strlen != NULL)
- *real_strlen = 0;
- return NULL;
- }
-
- if (real_strlen != NULL)
- *real_strlen = ((buffer_size - output_size) / 2) - 1;
-
- return buffer;
-}
-
message_type = I3_IPC_MESSAGE_TYPE_GET_MARKS;
else if (strcasecmp(optarg, "get_bar_config") == 0)
message_type = I3_IPC_MESSAGE_TYPE_GET_BAR_CONFIG;
+ else if (strcasecmp(optarg, "get_log_markers") == 0)
+ message_type = I3_IPC_MESSAGE_TYPE_GET_LOG_MARKERS;
else {
printf("Unknown message type\n");
- printf("Known types: command, get_workspaces, get_outputs, get_tree, get_marks, get_bar_config\n");
+ printf("Known types: command, get_workspaces, get_outputs, get_tree, get_marks, get_bar_config, get_log_markers\n");
exit(EXIT_FAILURE);
}
} else if (o == 'q') {
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &rect);
/* restore font color */
- uint32_t values[3];
- values[0] = color_text;
- values[1] = color_background;
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND, values);
- xcb_image_text_8(conn, strlen(prompt), pixmap, pixmap_gc, 4 + 4/* X */,
- font.height + 2 + 4 /* Y = baseline of font */, prompt);
+ set_font_colors(pixmap_gc, color_text, color_background);
+ draw_text(prompt, strlen(prompt), false, pixmap, pixmap_gc,
+ 4 + 4, 4 + 4, rect.width - 4 - 4);
/* render close button */
int line_width = 4;
int w = 20;
int y = rect.width;
+ uint32_t values[3];
values[0] = color_button_background;
values[1] = line_width;
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_LINE_WIDTH, values);
};
xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, pixmap, pixmap_gc, 5, points);
- values[0] = color_text;
- values[1] = color_button_background;
- values[2] = 1;
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_LINE_WIDTH, values);
- xcb_image_text_8(conn, strlen("x"), pixmap, pixmap_gc, y - w - line_width + (w / 2) - 4/* X */,
- font.height + 2 + 4 - 1/* Y = baseline of font */, "X");
+ values[0] = 1;
+ set_font_colors(pixmap_gc, color_text, color_button_background);
+ draw_text("X", 1, false, pixmap, pixmap_gc, y - w - line_width + w / 2 - 4,
+ 4 + 4 - 1, rect.width - y + w + line_width - w / 2 + 4);
y -= w;
y -= 20;
values[0] = color_text;
values[1] = color_button_background;
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND, values);
- xcb_image_text_8(conn, strlen(buttons[c].label), pixmap, pixmap_gc, y - w - line_width + 6/* X */,
- font.height + 2 + 3/* Y = baseline of font */, buttons[c].label);
+ set_font_colors(pixmap_gc, color_text, color_button_background);
+ draw_text(buttons[c].label, strlen(buttons[c].label), false, pixmap, pixmap_gc,
+ y - w - line_width + 6, 4 + 3, rect.width - y + w + line_width - 6);
y -= w;
}
break;
case 'h':
printf("i3-nagbar " I3_VERSION "\n");
- printf("i3-nagbar [-m <message>] [-b <button> <action>] [-f <font>] [-v]\n");
+ printf("i3-nagbar [-m <message>] [-b <button> <action>] [-t warning|error] [-f <font>] [-v]\n");
return 0;
case 'b':
buttons = realloc(buttons, sizeof(button_t) * (buttoncnt + 1));
}
font = load_font(pattern, true);
+ set_font(&font);
/* Open an input window */
win = xcb_generate_id(conn);
xcb_create_pixmap(conn, root_screen->root_depth, pixmap, win, 500, font.height + 8);
xcb_create_gc(conn, pixmap_gc, pixmap, 0, 0);
- /* Create graphics context */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
-
/* Grab the keyboard to get all input */
xcb_flush(conn);
xcb_create_pixmap(conn, root_screen->root_depth, pixmap, win, rect.width, rect.height);
xcb_create_gc(conn, pixmap_gc, pixmap, 0, 0);
-
- /* Create graphics context */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
break;
}
}
#
# Distributions/packagers can enhance this script with a
# distribution-specific mechanism to find the preferred pager.
-which $VISUAL >/dev/null && exec $VISUAL "$@"
-which $EDITOR >/dev/null && exec $EDITOR "$@"
+[ -n "$VISUAL" ] && which $VISUAL >/dev/null && exec $VISUAL "$@"
+[ -n "$EDITOR" ] && which $EDITOR >/dev/null && exec $EDITOR "$@"
# Hopefully one of these is installed (no flamewars about preference please!):
which nano >/dev/null && exec nano "$@"
#
# Distributions/packagers can enhance this script with a
# distribution-specific mechanism to find the preferred pager.
-which $PAGER >/dev/null && exec $PAGER "$@"
+[ -n "$PAGER" ] && which $PAGER >/dev/null && exec $PAGER "$@"
# Hopefully one of these is installed:
which most >/dev/null && exec most "$@"
# distribution-specific mechanism to find the preferred terminal emulator. On
# Debian, there is the x-terminal-emulator symlink for example.
# Please don't touch the first line, though:
-which $TERMINAL >/dev/null && exec $TERMINAL "$@"
+[ -n "$TERMINAL" ] && which $TERMINAL >/dev/null && exec $TERMINAL "$@"
# Hopefully one of these is installed:
which xterm >/dev/null && exec xterm "$@"
#include "workspaces.h"
#include "trayclients.h"
#include "xcb.h"
-#include "ucs2_to_utf8.h"
#include "config.h"
#include "libi3.h"
+++ /dev/null
-/*
- * vim:ts=4:sw=4:expandtab
- *
- * i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
- *
- * ucs2_to_utf8.c: Converts between UCS-2 and UTF-8, both of which are used in
- * different contexts in X11.
- */
-#ifndef _UCS2_TO_UTF8
-#define _UCS2_TO_UTF8
-
-char *convert_utf8_to_ucs2(char *input, int *real_strlen);
-
-#endif
*/
void redraw_bars();
-/*
- * Predicts the length of text based on cached data.
- * The string has to be encoded in ucs2 and glyph_len has to be the length
- * of the string (in glyphs).
- *
- */
-uint32_t predict_text_extents(xcb_char2b_t *text, uint32_t length);
-
#endif
+++ /dev/null
-/*
- * vim:ts=4:sw=4:expandtab
- *
- * i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
- *
- * ucs2_to_utf8.c: Converts between UCS-2 and UTF-8, both of which are used in
- * different contexts in X11.
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <err.h>
-#include <iconv.h>
-
-#include "libi3.h"
-
-static iconv_t conversion_descriptor = 0;
-static iconv_t conversion_descriptor2 = 0;
-
-/*
- * Returns the input string, but converted from UCS-2 to UTF-8. Memory will be
- * allocated, thus the caller has to free the output.
- *
- */
-char *convert_ucs_to_utf8(char *input) {
- size_t input_size = 2;
- /* UTF-8 may consume up to 4 byte */
- int buffer_size = 8;
-
- char *buffer = scalloc(buffer_size);
- size_t output_size = buffer_size;
- /* We need to use an additional pointer, because iconv() modifies it */
- char *output = buffer;
-
- /* We convert the input into UCS-2 big endian */
- if (conversion_descriptor == 0) {
- conversion_descriptor = iconv_open("UTF-8", "UCS-2BE");
- if (conversion_descriptor == 0) {
- fprintf(stderr, "error opening the conversion context\n");
- exit(1);
- }
- }
-
- /* Get the conversion descriptor back to original state */
- iconv(conversion_descriptor, NULL, NULL, NULL, NULL);
-
- /* Convert our text */
- int rc = iconv(conversion_descriptor, (void*)&input, &input_size, &output, &output_size);
- if (rc == (size_t)-1) {
- perror("Converting to UCS-2 failed");
- free(buffer);
- return NULL;
- }
-
- return buffer;
-}
-
-/*
- * Converts the given string to UCS-2 big endian for use with
- * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen,
- * a buffer containing the UCS-2 encoded string (16 bit per glyph) is
- * returned. It has to be freed when done.
- *
- */
-char *convert_utf8_to_ucs2(char *input, int *real_strlen) {
- size_t input_size = strlen(input) + 1;
- /* UCS-2 consumes exactly two bytes for each glyph */
- int buffer_size = input_size * 2;
-
- char *buffer = smalloc(buffer_size);
- size_t output_size = buffer_size;
- /* We need to use an additional pointer, because iconv() modifies it */
- char *output = buffer;
-
- /* We convert the input into UCS-2 big endian */
- if (conversion_descriptor2 == 0) {
- conversion_descriptor2 = iconv_open("UCS-2BE", "UTF-8");
- if (conversion_descriptor2 == 0) {
- fprintf(stderr, "error opening the conversion context\n");
- exit(1);
- }
- }
-
- /* Get the conversion descriptor back to original state */
- iconv(conversion_descriptor2, NULL, NULL, NULL, NULL);
-
- /* Convert our text */
- int rc = iconv(conversion_descriptor2, (void*)&input, &input_size, &output, &output_size);
- if (rc == (size_t)-1) {
- perror("Converting to UCS-2 failed");
- free(buffer);
- if (real_strlen != NULL)
- *real_strlen = 0;
- return NULL;
- }
-
- if (real_strlen != NULL)
- *real_strlen = ((buffer_size - output_size) / 2) - 1;
-
- return buffer;
-}
params->workspaces_walk->name[len] = '\0';
/* Convert the name to ucs2, save its length in glyphs and calculate its rendered width */
- int ucs2_len;
+ size_t ucs2_len;
xcb_char2b_t *ucs2_name = (xcb_char2b_t*) convert_utf8_to_ucs2(params->workspaces_walk->name, &ucs2_len);
params->workspaces_walk->ucs2_name = ucs2_name;
params->workspaces_walk->name_glyphs = ucs2_len;
params->workspaces_walk->name_width =
- predict_text_extents(params->workspaces_walk->ucs2_name,
- params->workspaces_walk->name_glyphs);
+ predict_text_width((char *)params->workspaces_walk->ucs2_name,
+ params->workspaces_walk->name_glyphs, true);
DLOG("Got Workspace %s, name_width: %d, glyphs: %d\n",
params->workspaces_walk->name,
int screen;
xcb_screen_t *xcb_screen;
xcb_window_t xcb_root;
-xcb_font_t xcb_font;
-/* We need to cache some data to speed up text-width-prediction */
-xcb_query_font_reply_t *font_info;
-int font_height;
-xcb_charinfo_t *font_table;
+/* This is needed for integration with libi3 */
+xcb_connection_t *conn;
+
+/* The font we'll use */
+static i3Font font;
/* These are only relevant for XKB, which we only need for grabbing modifiers */
Display *xkb_dpy;
return 0;
}
-/*
- * Predicts the length of text based on cached data.
- * The string has to be encoded in ucs2 and glyph_len has to be the length
- * of the string (in glyphs).
- *
- */
-uint32_t predict_text_extents(xcb_char2b_t *text, uint32_t length) {
- /* If we don't have per-character data, return the maximum width */
- if (font_table == NULL) {
- return (font_info->max_bounds.character_width * length);
- }
-
- uint32_t width = 0;
- uint32_t i;
-
- for (i = 0; i < length; i++) {
- xcb_charinfo_t *info;
- int row = text[i].byte1;
- int col = text[i].byte2;
-
- if (row < font_info->min_byte1 || row > font_info->max_byte1 ||
- col < font_info->min_char_or_byte2 || col > font_info->max_char_or_byte2) {
- continue;
- }
-
- /* Don't you ask me, how this one works… */
- info = &font_table[((row - font_info->min_byte1) *
- (font_info->max_char_or_byte2 - font_info->min_char_or_byte2 + 1)) +
- (col - font_info->min_char_or_byte2)];
-
- if (info->character_width != 0 ||
- (info->right_side_bearing |
- info->left_side_bearing |
- info->ascent |
- info->descent) != 0) {
- width += info->character_width;
- }
- }
-
- return width;
-}
-
-/*
- * Draws text given in UCS-2-encoding to a given drawable and position
- *
- */
-void draw_text(xcb_drawable_t drawable, xcb_gcontext_t ctx, int16_t x, int16_t y,
- xcb_char2b_t *text, uint32_t glyph_count) {
- int offset = 0;
- int16_t pos_x = x;
- int16_t font_ascent = font_info->font_ascent;
-
- while (glyph_count > 0) {
- uint8_t chunk_size = MIN(255, glyph_count);
- uint32_t chunk_width = predict_text_extents(text + offset, chunk_size);
-
- xcb_image_text_16(xcb_connection,
- chunk_size,
- drawable,
- ctx,
- pos_x, y + font_ascent,
- text + offset);
-
- offset += chunk_size;
- pos_x += chunk_width;
- glyph_count -= chunk_size;
- }
-}
-
/*
* Redraws the statusline to the buffer
*
*/
void refresh_statusline() {
- int glyph_count;
+ size_t glyph_count;
if (statusline == NULL) {
return;
}
- xcb_char2b_t *text = (xcb_char2b_t*) convert_utf8_to_ucs2(statusline, &glyph_count);
+ xcb_char2b_t *text = (xcb_char2b_t*)convert_utf8_to_ucs2(statusline, &glyph_count);
uint32_t old_statusline_width = statusline_width;
- statusline_width = predict_text_extents(text, glyph_count);
+ statusline_width = predict_text_width((char*)text, glyph_count, true);
/* If the statusline is bigger than our screen we need to make sure that
* the pixmap provides enough space, so re-allocate if the width grew */
if (statusline_width > xcb_screen->width_in_pixels &&
statusline_width > old_statusline_width)
realloc_sl_buffer();
- xcb_rectangle_t rect = { 0, 0, xcb_screen->width_in_pixels, font_height };
+ xcb_rectangle_t rect = { 0, 0, xcb_screen->width_in_pixels, font.height };
xcb_poly_fill_rectangle(xcb_connection, statusline_pm, statusline_clear, 1, &rect);
- draw_text(statusline_pm, statusline_ctx, 0, 0, text, glyph_count);
+ set_font_colors(statusline_ctx, colors.bar_fg, colors.bar_bg);
+ draw_text((char*)text, glyph_count, true, statusline_pm, statusline_ctx,
+ 0, 0, xcb_screen->width_in_pixels);
FREE(text);
}
values[0] = walk->rect.x;
if (config.position == POS_TOP)
values[1] = walk->rect.y;
- else values[1] = walk->rect.y + walk->rect.h - font_height - 6;
+ else values[1] = walk->rect.y + walk->rect.h - font.height - 6;
values[2] = walk->rect.w;
- values[3] = font_height + 6;
+ values[3] = font.height + 6;
values[4] = XCB_STACK_MODE_ABOVE;
DLOG("Reconfiguring Window for output %s to %d,%d\n", walk->name, values[0], values[1]);
cookie = xcb_configure_window_checked(xcb_connection,
clients++;
DLOG("Configuring tray window %08x to x=%d\n",
- trayclient->win, output->rect.w - (clients * (font_height + 2)));
- uint32_t x = output->rect.w - (clients * (font_height + 2));
+ trayclient->win, output->rect.w - (clients * (font.height + 2)));
+ uint32_t x = output->rect.w - (clients * (font.height + 2));
xcb_configure_window(xcb_connection,
trayclient->win,
XCB_CONFIG_WINDOW_X,
xcb_reparent_window(xcb_connection,
client,
output->bar,
- output->rect.w - font_height - 2,
+ output->rect.w - font.height - 2,
2);
/* We reconfigure the window to use a reasonable size. The systray
* specification explicitly says:
* should do their best to cope with any size effectively
*/
mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
- values[0] = font_height;
- values[1] = font_height;
+ values[0] = font.height;
+ values[1] = font.height;
xcb_configure_window(xcb_connection,
client,
mask,
continue;
xcb_rectangle_t rect;
- rect.x = output->rect.w - (clients * (font_height + 2));
+ rect.x = output->rect.w - (clients * (font.height + 2));
rect.y = 2;
- rect.width = font_height;
- rect.height = font_height;
+ rect.width = font.height;
+ rect.height = font.height;
DLOG("This is a tray window. x = %d\n", rect.x);
fake_configure_notify(xcb_connection, rect, event->window, 0);
ELOG("Cannot open display\n");
exit(EXIT_FAILURE);
}
+ conn = xcb_connection;
DLOG("Connected to xcb\n");
/* We have to request the atoms we need */
mask,
vals);
- mask |= XCB_GC_BACKGROUND;
- vals[0] = colors.bar_fg;
statusline_ctx = xcb_generate_id(xcb_connection);
xcb_void_cookie_t sl_ctx_cookie = xcb_create_gc_checked(xcb_connection,
statusline_ctx,
xcb_root,
- mask,
- vals);
+ 0,
+ NULL);
statusline_pm = xcb_generate_id(xcb_connection);
xcb_void_cookie_t sl_pm_cookie = xcb_create_pixmap_checked(xcb_connection,
*
*/
void init_xcb_late(char *fontname) {
- if (fontname == NULL) {
- /* XXX: font fallback to 'misc' like i3 does it would be good. */
+ if (fontname == NULL)
fontname = "-misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1";
- }
- /* We load and allocate the font */
- xcb_font = xcb_generate_id(xcb_connection);
- xcb_void_cookie_t open_font_cookie;
- open_font_cookie = xcb_open_font_checked(xcb_connection,
- xcb_font,
- strlen(fontname),
- fontname);
-
- /* We need to save info about the font, because we need the font's height and
- * information about the width of characters */
- xcb_query_font_cookie_t query_font_cookie;
- query_font_cookie = xcb_query_font(xcb_connection,
- xcb_font);
-
- xcb_change_gc(xcb_connection,
- statusline_ctx,
- XCB_GC_FONT,
- (uint32_t[]){ xcb_font });
+ /* Load the font */
+ font = load_font(fontname, true);
+ set_font(&font);
+ DLOG("Calculated Font-height: %d\n", font.height);
xcb_flush(xcb_connection);
ev_io_start(main_loop, xkb_io);
XFlush(xkb_dpy);
}
-
- /* Now we save the font-infos */
- font_info = xcb_query_font_reply(xcb_connection,
- query_font_cookie,
- NULL);
-
- if (xcb_request_failed(open_font_cookie, "Could not open font")) {
- exit(EXIT_FAILURE);
- }
-
- font_height = font_info->font_ascent + font_info->font_descent;
-
- if (xcb_query_font_char_infos_length(font_info) == 0) {
- font_table = NULL;
- } else {
- font_table = xcb_query_font_char_infos(font_info);
- }
-
- DLOG("Calculated Font-height: %d\n", font_height);
}
/*
FREE(xcb_chk);
FREE(xcb_prep);
FREE(xcb_io);
- FREE(font_info);
}
/*
xcb_screen->height_in_pixels);
uint32_t mask = XCB_GC_FOREGROUND;
- uint32_t vals[3] = { colors.bar_bg, colors.bar_bg, xcb_font };
+ uint32_t vals[2] = { colors.bar_bg, colors.bar_bg };
xcb_free_gc(xcb_connection, statusline_clear);
statusline_clear = xcb_generate_id(xcb_connection);
xcb_void_cookie_t clear_ctx_cookie = xcb_create_gc_checked(xcb_connection,
mask,
vals);
- mask |= XCB_GC_BACKGROUND | XCB_GC_FONT;
+ mask |= XCB_GC_BACKGROUND;
vals[0] = colors.bar_fg;
statusline_ctx = xcb_generate_id(xcb_connection);
xcb_free_gc(xcb_connection, statusline_ctx);
xcb_screen->root_depth,
walk->bar,
xcb_root,
- walk->rect.x, walk->rect.y + walk->rect.h - font_height - 6,
- walk->rect.w, font_height + 6,
+ walk->rect.x, walk->rect.y + walk->rect.h - font.height - 6,
+ walk->rect.w, font.height + 6,
1,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
xcb_screen->root_visual,
case POS_NONE:
break;
case POS_TOP:
- strut_partial.top = font_height + 6;
+ strut_partial.top = font.height + 6;
strut_partial.top_start_x = walk->rect.x;
strut_partial.top_end_x = walk->rect.x + walk->rect.w;
break;
case POS_BOT:
- strut_partial.bottom = font_height + 6;
+ strut_partial.bottom = font.height + 6;
strut_partial.bottom_start_x = walk->rect.x;
strut_partial.bottom_end_x = walk->rect.x + walk->rect.w;
break;
/* We also want a graphics-context for the bars (it defines the properties
* with which we draw to them) */
walk->bargc = xcb_generate_id(xcb_connection);
- mask = XCB_GC_FONT;
- values[0] = xcb_font;
xcb_void_cookie_t gc_cookie = xcb_create_gc_checked(xcb_connection,
walk->bargc,
walk->bar,
- mask,
- values);
+ 0,
+ NULL);
/* We finally map the bar (display it on screen), unless the modifier-switch is on */
xcb_void_cookie_t map_cookie;
XCB_CONFIG_WINDOW_HEIGHT |
XCB_CONFIG_WINDOW_STACK_MODE;
values[0] = walk->rect.x;
- values[1] = walk->rect.y + walk->rect.h - font_height - 6;
+ values[1] = walk->rect.y + walk->rect.h - font.height - 6;
values[2] = walk->rect.w;
- values[3] = font_height + 6;
+ values[3] = font.height + 6;
values[4] = XCB_STACK_MODE_ABOVE;
DLOG("Destroying buffer for output %s", walk->name);
outputs_walk->bargc,
XCB_GC_FOREGROUND,
&color);
- xcb_rectangle_t rect = { 0, 0, outputs_walk->rect.w, font_height + 6 };
+ xcb_rectangle_t rect = { 0, 0, outputs_walk->rect.w, font.height + 6 };
xcb_poly_fill_rectangle(xcb_connection,
outputs_walk->buffer,
outputs_walk->bargc,
/* We assume the tray icons are quadratic (we use the font
* *height* as *width* of the icons) because we configured them
* like this. */
- traypx += font_height + 2;
+ traypx += font.height + 2;
}
/* Add 2px of padding if there are any tray icons */
if (traypx > 0)
outputs_walk->bargc,
MAX(0, (int16_t)(statusline_width - outputs_walk->rect.w + 4)), 0,
MAX(0, (int16_t)(outputs_walk->rect.w - statusline_width - traypx - 4)), 3,
- MIN(outputs_walk->rect.w - traypx - 4, statusline_width), font_height);
+ MIN(outputs_walk->rect.w - traypx - 4, statusline_width), font.height);
}
if (config.disable_ws) {
outputs_walk->bargc,
mask,
vals);
- xcb_rectangle_t rect = { i + 1, 1, ws_walk->name_width + 8, font_height + 4 };
+ xcb_rectangle_t rect = { i + 1, 1, ws_walk->name_width + 8, font.height + 4 };
xcb_poly_fill_rectangle(xcb_connection,
outputs_walk->buffer,
outputs_walk->bargc,
1,
&rect);
- xcb_change_gc(xcb_connection,
- outputs_walk->bargc,
- XCB_GC_FOREGROUND,
- &fg_color);
- xcb_image_text_16(xcb_connection,
- ws_walk->name_glyphs,
- outputs_walk->buffer,
- outputs_walk->bargc,
- i + 5, font_info->font_ascent + 2,
- ws_walk->ucs2_name);
+ set_font_colors(outputs_walk->bargc, fg_color, bg_color);
+ draw_text((char*)ws_walk->ucs2_name, ws_walk->name_glyphs, true,
+ outputs_walk->buffer, outputs_walk->bargc, i + 5, 2, ws_walk->name_width);
i += 10 + ws_walk->name_width;
}
/** Bar position (bottom by default). */
enum { P_BOTTOM = 0, P_TOP = 1 } position;
+ /** Command that should be run to execute i3bar, give a full path if i3bar is not
+ * in your $PATH.
+ * By default just 'i3bar' is executed. */
+ char *i3bar_command;
+
/** Command that should be run to get a statusline, for example 'i3status'.
* Will be passed to the shell. */
char *status_command;
Rect con_deco_rect;
uint32_t background;
bool con_is_leaf;
- xcb_font_t font;
};
/**
char *name_json;
/** The length of the name in glyphs (not bytes) */
- int name_len;
+ size_t name_len;
/** Whether the application used _NET_WM_NAME */
bool uses_net_wm_name;
* this before starting any other process, since we set RLIMIT_CORE to
* RLIM_INFINITY for i3 debugging versions. */
extern struct rlimit original_rlimit_core;
+/** Whether this version of i3 is a debug build or a release build. */
+extern bool debug_build;
extern xcb_connection_t *conn;
extern int conn_screen;
/** The last timestamp we got from X11 (timestamps are included in some events
/** Request the configuration for a specific 'bar' */
#define I3_IPC_MESSAGE_TYPE_GET_BAR_CONFIG 6
+/** Request the SHM debug log start/wrap markers */
+#define I3_IPC_MESSAGE_TYPE_GET_LOG_MARKERS 7
+
/*
* Messages from i3 to clients
*
/** Bar config reply type */
#define I3_IPC_REPLY_TYPE_BAR_CONFIG 6
+/** Request the SHM debug log start/wrap markers */
+#define I3_IPC_REPLY_TYPE_LOG_MARKERS 7
+
/*
* Events from i3 to clients. Events have the first bit set high.
*
*
*/
struct Font {
- /** The height of the font, built from font_ascent + font_descent */
- int height;
/** The xcb-id for the font */
xcb_font_t id;
+
+ /** Font information gathered from the server */
+ xcb_query_font_reply_t *info;
+
+ /** Font table for this font (may be NULL) */
+ xcb_charinfo_t *table;
+
+ /** The height of the font, built from font_ascent + font_descent */
+ int height;
};
/* Since this file also gets included by utilities which don’t use the i3 log
* the fonts 'fixed' or '-misc-*' will be loaded instead of exiting.
*
*/
-i3Font load_font(const char *pattern, bool fallback);
+i3Font load_font(const char *pattern, const bool fallback);
+
+/**
+ * Defines the font to be used for the forthcoming calls.
+ *
+ */
+void set_font(i3Font *font);
+
+/**
+ * Frees the resources taken by the current font.
+ *
+ */
+void free_font();
+
+/**
+ * Converts the given string to UTF-8 from UCS-2 big endian. The return value
+ * must be freed after use.
+ *
+ */
+char *convert_ucs2_to_utf8(xcb_char2b_t *text, size_t num_glyphs);
+
+/**
+ * Converts the given string to UCS-2 big endian for use with
+ * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen,
+ * a buffer containing the UCS-2 encoded string (16 bit per glyph) is
+ * returned. It has to be freed when done.
+ *
+ */
+xcb_char2b_t *convert_utf8_to_ucs2(char *input, size_t *real_strlen);
+
+/**
+ * Defines the colors to be used for the forthcoming draw_text calls.
+ *
+ */
+void set_font_colors(xcb_gcontext_t gc, uint32_t foreground, uint32_t background);
+
+/**
+ * Draws text onto the specified X drawable (normally a pixmap) at the
+ * specified coordinates (from the top left corner of the leftmost, uppermost
+ * glyph) and using the provided gc. Text can be specified as UCS-2 or UTF-8.
+ *
+ */
+void draw_text(char *text, size_t text_len, bool is_ucs2, xcb_drawable_t drawable,
+ xcb_gcontext_t gc, int x, int y, int max_width);
+
+/**
+ * Predict the text width in pixels for the given text. Text can be specified
+ * as UCS-2 or UTF-8.
+ *
+ */
+int predict_text_width(char *text, size_t text_len, bool is_ucs2);
#endif
extern char *loglevels[];
extern char *errorfilename;
+extern char *shmlogname;
+extern int shmlog_size;
/**
* Initializes logging by creating an error logfile in /tmp (or
*/
void add_loglevel(const char *level);
+/**
+ * Returns the offsets for the next write and for the last wrap.
+ * Necessary to print the i3 SHM log in the correct order.
+ *
+ */
+void get_log_markers(int *offset_next_write, int *offset_last_wrap, int *size);
+
/**
* Set verbosity of i3. If verbose is set to true, informative messages will
* be printed to stdout. If verbose is set to false, only errors will be
void check_error(xcb_connection_t *conn, xcb_void_cookie_t cookie,
char *err_message);
-/**
- * Converts the given string to UCS-2 big endian for use with
- * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen, a
- * buffer containing the UCS-2 encoded string (16 bit per glyph) is
- * returned. It has to be freed when done.
- *
- */
-char *convert_utf8_to_ucs2(char *input, int *real_strlen);
-
/**
* This function resolves ~ in pathnames.
* It may resolve wildcards in the first part of the path, but if no match
*/
void xcb_raise_window(xcb_connection_t *conn, xcb_window_t window);
-/**
- * Calculate the width of the given text (16-bit characters, UCS) with given
- * real length (amount of glyphs) using the given font.
- *
- */
-int predict_text_width(char *text, int length);
-
/**
* Configures the given window to have the size/position specified by given rect
*
--- /dev/null
+/*
+ * vim:ts=4:sw=4:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ *
+ */
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <err.h>
+
+#include "libi3.h"
+
+extern xcb_connection_t *conn;
+static const i3Font *savedFont = NULL;
+
+/*
+ * Loads a font for usage, also getting its metrics. If fallback is true,
+ * the fonts 'fixed' or '-misc-*' will be loaded instead of exiting.
+ *
+ */
+i3Font load_font(const char *pattern, const bool fallback) {
+ i3Font font;
+
+ /* Send all our requests first */
+ font.id = xcb_generate_id(conn);
+ xcb_void_cookie_t font_cookie = xcb_open_font_checked(conn, font.id,
+ strlen(pattern), pattern);
+ xcb_query_font_cookie_t info_cookie = xcb_query_font(conn, font.id);
+
+ /* Check for errors. If errors, fall back to default font. */
+ xcb_generic_error_t *error;
+ error = xcb_request_check(conn, font_cookie);
+
+ /* If we fail to open font, fall back to 'fixed' */
+ if (fallback && error != NULL) {
+ ELOG("Could not open font %s (X error %d). Trying fallback to 'fixed'.\n",
+ pattern, error->error_code);
+ pattern = "fixed";
+ font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
+ info_cookie = xcb_query_font(conn, font.id);
+
+ /* Check if we managed to open 'fixed' */
+ error = xcb_request_check(conn, font_cookie);
+
+ /* Fall back to '-misc-*' if opening 'fixed' fails. */
+ if (error != NULL) {
+ ELOG("Could not open fallback font 'fixed', trying with '-misc-*'.\n");
+ pattern = "-misc-*";
+ font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
+ info_cookie = xcb_query_font(conn, font.id);
+
+ if ((error = xcb_request_check(conn, font_cookie)) != NULL)
+ errx(EXIT_FAILURE, "Could open neither requested font nor fallbacks "
+ "(fixed or -misc-*): X11 error %d", error->error_code);
+ }
+ }
+
+ /* Get information (height/name) for this font */
+ if (!(font.info = xcb_query_font_reply(conn, info_cookie, NULL)))
+ errx(EXIT_FAILURE, "Could not load font \"%s\"", pattern);
+
+ /* Get the font table, if possible */
+ if (xcb_query_font_char_infos_length(font.info) == 0)
+ font.table = NULL;
+ else
+ font.table = xcb_query_font_char_infos(font.info);
+
+ /* Calculate the font height */
+ font.height = font.info->font_ascent + font.info->font_descent;
+
+ return font;
+}
+
+/*
+ * Defines the font to be used for the forthcoming calls.
+ *
+ */
+void set_font(i3Font *font) {
+ savedFont = font;
+}
+
+/*
+ * Frees the resources taken by the current font.
+ *
+ */
+void free_font() {
+ /* Close the font and free the info */
+ xcb_close_font(conn, savedFont->id);
+ if (savedFont->info)
+ free(savedFont->info);
+}
+
+/*
+ * Defines the colors to be used for the forthcoming draw_text calls.
+ *
+ */
+void set_font_colors(xcb_gcontext_t gc, uint32_t foreground, uint32_t background) {
+ assert(savedFont != NULL);
+ uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
+ uint32_t values[] = { foreground, background, savedFont->id };
+ xcb_change_gc(conn, gc, mask, values);
+}
+
+/*
+ * Draws text onto the specified X drawable (normally a pixmap) at the
+ * specified coordinates (from the top left corner of the leftmost, uppermost
+ * glyph) and using the provided gc. Text can be specified as UCS-2 or UTF-8.
+ *
+ */
+void draw_text(char *text, size_t text_len, bool is_ucs2, xcb_drawable_t drawable,
+ xcb_gcontext_t gc, int x, int y, int max_width) {
+ assert(savedFont != NULL);
+ assert(text_len != 0);
+
+ /* X11 coordinates for fonts start at the baseline */
+ int pos_y = y + savedFont->info->font_ascent;
+
+ /* As an optimization, check if we can bypass conversion */
+ if (!is_ucs2 && text_len <= 255) {
+ xcb_image_text_8(conn, text_len, drawable, gc, x, pos_y, text);
+ return;
+ }
+
+ /* Convert the text into UCS-2 so we can do basic pointer math */
+ char *input = (is_ucs2 ? text : (char*)convert_utf8_to_ucs2(text, &text_len));
+
+ /* The X11 protocol limits text drawing to 255 chars, so we may need
+ * multiple calls */
+ int pos_x = x;
+ int offset = 0;
+ for (;;) {
+ /* Calculate the size of this chunk */
+ int chunk_size = (text_len > 255 ? 255 : text_len);
+ xcb_char2b_t *chunk = (xcb_char2b_t*)input + offset;
+
+ /* Draw it */
+ xcb_image_text_16(conn, chunk_size, drawable, gc, pos_x, pos_y, chunk);
+
+ /* Advance the offset and length of the text to draw */
+ offset += chunk_size;
+ text_len -= chunk_size;
+
+ /* Check if we're done */
+ if (text_len == 0)
+ break;
+
+ /* Advance pos_x based on the predicted text width */
+ pos_x += predict_text_width((char*)chunk, chunk_size, true);
+ }
+
+ /* If we had to convert, free the converted string */
+ if (!is_ucs2)
+ free(input);
+}
+
+static int xcb_query_text_width(xcb_char2b_t *text, size_t text_len) {
+ /* Make the user know we’re using the slow path, but only once. */
+ static bool first_invocation = true;
+ if (first_invocation) {
+ fprintf(stderr, "Using slow code path for text extents\n");
+ first_invocation = false;
+ }
+
+ /* Query the text width */
+ xcb_generic_error_t *error;
+ xcb_query_text_extents_cookie_t cookie = xcb_query_text_extents(conn,
+ savedFont->id, text_len, (xcb_char2b_t*)text);
+ xcb_query_text_extents_reply_t *reply = xcb_query_text_extents_reply(conn,
+ cookie, &error);
+ if (reply == NULL) {
+ /* We return a safe estimate because a rendering error is better than
+ * a crash. Plus, the user will see the error in his log. */
+ fprintf(stderr, "Could not get text extents (X error code %d)\n",
+ error->error_code);
+ return savedFont->info->max_bounds.character_width * text_len;
+ }
+
+ int width = reply->overall_width;
+ free(reply);
+ return width;
+}
+
+/*
+ * Predict the text width in pixels for the given text. Text can be specified
+ * as UCS-2 or UTF-8.
+ *
+ */
+int predict_text_width(char *text, size_t text_len, bool is_ucs2) {
+ /* Convert the text into UTF-16 so we can do basic pointer math */
+ xcb_char2b_t *input;
+ if (is_ucs2)
+ input = (xcb_char2b_t*)text;
+ else
+ input = convert_utf8_to_ucs2(text, &text_len);
+
+ int width;
+ if (savedFont->table == NULL) {
+ /* If we don't have a font table, fall back to querying the server */
+ width = xcb_query_text_width(input, text_len);
+ } else {
+ /* Save some pointers for convenience */
+ xcb_query_font_reply_t *font_info = savedFont->info;
+ xcb_charinfo_t *font_table = savedFont->table;
+
+ /* Calculate the width using the font table */
+ width = 0;
+ for (size_t i = 0; i < text_len; i++) {
+ xcb_charinfo_t *info;
+ int row = input[i].byte1;
+ int col = input[i].byte2;
+
+ if (row < font_info->min_byte1 ||
+ row > font_info->max_byte1 ||
+ col < font_info->min_char_or_byte2 ||
+ col > font_info->max_char_or_byte2)
+ continue;
+
+ /* Don't you ask me, how this one works… (Merovius) */
+ info = &font_table[((row - font_info->min_byte1) *
+ (font_info->max_char_or_byte2 - font_info->min_char_or_byte2 + 1)) +
+ (col - font_info->min_char_or_byte2)];
+
+ if (info->character_width != 0 ||
+ (info->right_side_bearing |
+ info->left_side_bearing |
+ info->ascent |
+ info->descent) != 0) {
+ width += info->character_width;
+ }
+ }
+ }
+
+ /* If we had to convert, free the converted string */
+ if (!is_ucs2)
+ free(input);
+
+ return width;
+}
+++ /dev/null
-/*
- * vim:ts=4:sw=4:expandtab
- *
- * i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
- *
- */
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
-#include <err.h>
-
-#include "libi3.h"
-
-extern xcb_connection_t *conn;
-
-/*
- * Loads a font for usage, also getting its height. If fallback is true,
- * the fonts 'fixed' or '-misc-*' will be loaded instead of exiting.
- *
- */
-i3Font load_font(const char *pattern, bool fallback) {
- i3Font font;
- xcb_void_cookie_t font_cookie;
- xcb_list_fonts_with_info_cookie_t info_cookie;
- xcb_list_fonts_with_info_reply_t *info_reply;
- xcb_generic_error_t *error;
-
- /* Send all our requests first */
- font.id = xcb_generate_id(conn);
- font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
- info_cookie = xcb_list_fonts_with_info(conn, 1, strlen(pattern), pattern);
-
- /* Check for errors. If errors, fall back to default font. */
- error = xcb_request_check(conn, font_cookie);
-
- /* If we fail to open font, fall back to 'fixed' */
- if (fallback && error != NULL) {
- ELOG("Could not open font %s (X error %d). Trying fallback to 'fixed'.\n",
- pattern, error->error_code);
- pattern = "fixed";
- font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
- info_cookie = xcb_list_fonts_with_info(conn, 1, strlen(pattern), pattern);
-
- /* Check if we managed to open 'fixed' */
- error = xcb_request_check(conn, font_cookie);
-
- /* Fall back to '-misc-*' if opening 'fixed' fails. */
- if (error != NULL) {
- ELOG("Could not open fallback font 'fixed', trying with '-misc-*'.\n");
- pattern = "-misc-*";
- font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
- info_cookie = xcb_list_fonts_with_info(conn, 1, strlen(pattern), pattern);
-
- if ((error = xcb_request_check(conn, font_cookie)) != NULL)
- errx(EXIT_FAILURE, "Could open neither requested font nor fallbacks "
- "(fixed or -misc-*): X11 error %d", error->error_code);
- }
- }
-
- /* Get information (height/name) for this font */
- if (!(info_reply = xcb_list_fonts_with_info_reply(conn, info_cookie, NULL)))
- errx(EXIT_FAILURE, "Could not load font \"%s\"", pattern);
-
- font.height = info_reply->font_ascent + info_reply->font_descent;
-
- free(info_reply);
-
- return font;
-}
--- /dev/null
+/*
+ * vim:ts=4:sw=4:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ *
+ */
+#include <err.h>
+#include <errno.h>
+#include <iconv.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libi3.h"
+
+static iconv_t utf8_conversion_descriptor = (iconv_t)-1;
+static iconv_t ucs2_conversion_descriptor = (iconv_t)-1;
+
+/*
+ * Converts the given string to UTF-8 from UCS-2 big endian. The return value
+ * must be freed after use.
+ *
+ */
+char *convert_ucs2_to_utf8(xcb_char2b_t *text, size_t num_glyphs) {
+ /* Allocate the output buffer (UTF-8 is at most 4 bytes per glyph) */
+ size_t buffer_size = num_glyphs * 4 * sizeof(char) + 1;
+ char *buffer = scalloc(buffer_size * sizeof(char));
+
+ /* We need to use an additional pointer, because iconv() modifies it */
+ char *output = buffer;
+ size_t output_size = buffer_size - 1;
+
+ if (utf8_conversion_descriptor == (iconv_t)-1) {
+ /* Get a new conversion descriptor */
+ utf8_conversion_descriptor = iconv_open("UTF-8", "UCS-2BE");
+ if (utf8_conversion_descriptor == (iconv_t)-1)
+ err(EXIT_FAILURE, "Error opening the conversion context");
+ } else {
+ /* Reset the existing conversion descriptor */
+ iconv(utf8_conversion_descriptor, NULL, NULL, NULL, NULL);
+ }
+
+ /* Do the conversion */
+ size_t input_len = num_glyphs * sizeof(xcb_char2b_t);
+ size_t rc = iconv(utf8_conversion_descriptor, (char**)&text,
+ &input_len, &output, &output_size);
+ if (rc == (size_t)-1) {
+ perror("Converting to UTF-8 failed");
+ free(buffer);
+ return NULL;
+ }
+
+ return buffer;
+}
+
+/*
+ * Converts the given string to UCS-2 big endian for use with
+ * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen,
+ * a buffer containing the UCS-2 encoded string (16 bit per glyph) is
+ * returned. It has to be freed when done.
+ *
+ */
+xcb_char2b_t *convert_utf8_to_ucs2(char *input, size_t *real_strlen) {
+ /* Calculate the input buffer size (UTF-8 is strlen-safe) */
+ size_t input_size = strlen(input);
+
+ /* Calculate the output buffer size and allocate the buffer */
+ size_t buffer_size = input_size * sizeof(xcb_char2b_t);
+ xcb_char2b_t *buffer = smalloc(buffer_size);
+
+ /* We need to use an additional pointer, because iconv() modifies it */
+ size_t output_size = buffer_size;
+ xcb_char2b_t *output = buffer;
+
+ if (ucs2_conversion_descriptor == (iconv_t)-1) {
+ /* Get a new conversion descriptor */
+ ucs2_conversion_descriptor = iconv_open("UCS-2BE", "UTF-8");
+ if (ucs2_conversion_descriptor == (iconv_t)-1)
+ err(EXIT_FAILURE, "Error opening the conversion context");
+ } else {
+ /* Reset the existing conversion descriptor */
+ iconv(ucs2_conversion_descriptor, NULL, NULL, NULL, NULL);
+ }
+
+ /* Do the conversion */
+ size_t rc = iconv(ucs2_conversion_descriptor, (char**)&input,
+ &input_size, (char**)&output, &output_size);
+ if (rc == (size_t)-1) {
+ perror("Converting to UCS-2 failed");
+ free(buffer);
+ if (real_strlen != NULL)
+ *real_strlen = 0;
+ return NULL;
+ }
+
+ /* Return the resulting string's length */
+ if (real_strlen != NULL)
+ *real_strlen = (buffer_size - output_size) / sizeof(xcb_char2b_t);
+
+ return buffer;
+}
A2M:=a2x -f manpage --asciidoc-opts="-f asciidoc.conf"
-all: i3.1 i3-msg.1 i3-input.1 i3-nagbar.1 i3-wsbar.1 i3-config-wizard.1 i3-migrate-config-to-v4.1 i3-sensible-editor.1 i3-sensible-pager.1 i3-sensible-terminal.1
+all: i3.1 i3-msg.1 i3-input.1 i3-nagbar.1 i3-wsbar.1 i3-config-wizard.1 i3-migrate-config-to-v4.1 i3-sensible-editor.1 i3-sensible-pager.1 i3-sensible-terminal.1 i3-dump-log.1
%.1: %.man asciidoc.conf
${A2M} $<
pod2man $^ > $@
clean:
- for file in $$(echo i3 i3-msg i3-input i3-nagbar i3-wsbar i3-config-wizard i3-migrate-config-to-v4 i3-sensible-editor i3-sensible-pager i3-sensible-terminal); \
+ for file in $$(echo i3 i3-msg i3-input i3-nagbar i3-wsbar i3-config-wizard i3-migrate-config-to-v4 i3-sensible-editor i3-sensible-pager i3-sensible-terminal i3-dump-log); \
do \
rm -f $${file}.1 $${file}.html $${file}.xml; \
done
--- /dev/null
+i3-dump-log(1)
+==============
+Michael Stapelberg <michael+i3@stapelberg.de>
+v4.1, December 2011
+
+== NAME
+
+i3-dump-log - dumps the i3 SHM log
+
+== SYNOPSIS
+
+i3-dump-log [-s <socketpath>]
+
+== DESCRIPTION
+
+Debug versions of i3 automatically use 1% of your RAM (but 25 MiB max) to store
+full debug loglevel log output. This is extremely helpful for bugreports and
+figuring out what is going on, without permanently logging to a file.
+
+With i3-dump-log, you can dump the SHM log to stdout.
+
+== EXAMPLE
+
+i3-dump-log | gzip -9 > /tmp/i3-log.gz
+
+== SEE ALSO
+
+i3(1)
+
+== AUTHOR
+
+Michael Stapelberg and contributors
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/
+You can also access these documents online at http://i3wm.org/
i3-input(1), i3-msg(1), i3-wsbar(1), i3-nagbar(1), i3-config-wizard(1),
i3-migrate-config-to-v4(1)
<BAR_POSITION>bottom { yy_pop_state(); return TOK_BAR_BOTTOM; }
<BAR_POSITION>top { yy_pop_state(); return TOK_BAR_TOP; }
<BAR>status_command { WS_STRING; return TOK_BAR_STATUS_COMMAND; }
+<BAR>i3bar_command { WS_STRING; return TOK_BAR_I3BAR_COMMAND; }
<BAR>font { WS_STRING; return TOK_BAR_FONT; }
<BAR>workspace_buttons { return TOK_BAR_WORKSPACE_BUTTONS; }
<BAR>verbose { return TOK_BAR_VERBOSE; }
%token TOK_BAR_BOTTOM "bottom"
%token TOK_BAR_TOP "top"
%token TOK_BAR_STATUS_COMMAND "status_command"
+%token TOK_BAR_I3BAR_COMMAND "i3bar_command"
%token TOK_BAR_FONT "font (bar)"
%token TOK_BAR_WORKSPACE_BUTTONS "workspace_buttons"
%token TOK_BAR_VERBOSE "verbose"
barline:
comment
| bar_status_command
+ | bar_i3bar_command
| bar_output
| bar_tray_output
| bar_position
}
;
+bar_i3bar_command:
+ TOK_BAR_I3BAR_COMMAND STR
+ {
+ DLOG("should add i3bar_command %s\n", $2);
+ FREE(current_bar.i3bar_command);
+ current_bar.i3bar_command = $2;
+ }
+ ;
+
bar_output:
TOK_BAR_OUTPUT STR
{
TOKFONT STR
{
config.font = load_font($2, true);
+ set_font(&config.font);
printf("font %s\n", $2);
FREE(font_pattern);
font_pattern = $2;
FREE(barconfig->tray_output);
FREE(barconfig->socket_path);
FREE(barconfig->status_command);
+ FREE(barconfig->i3bar_command);
FREE(barconfig->font);
FREE(barconfig->colors.background);
FREE(barconfig->colors.statusline);
TAILQ_FOREACH(ws, workspaces, workspaces)
workspace_set_name(ws, NULL);
#endif
+
+ /* Invalidate pixmap caches in case font or colors changed */
+ Con *con;
+ TAILQ_FOREACH(con, &all_cons, all_cons)
+ FREE(con->deco_render_params);
+
+ /* Get rid of the current font */
+ free_font();
}
SLIST_INIT(&modes);
if (config.font.id == 0) {
ELOG("You did not specify required configuration option \"font\"\n");
config.font = load_font("fixed", true);
+ set_font(&config.font);
+ }
+
+ /* Redraw the currently visible decorations on reload, so that
+ * the possibly new drawing parameters changed. */
+ if (reload) {
+ x_deco_recurse(croot);
+ xcb_flush(conn);
}
#if 0
static int handle_expose_event(xcb_expose_event_t *event) {
Con *parent;
- /* event->count is the number of minimum remaining expose events for this
- * window, so we skip all events but the last one */
- if (event->count != 0)
- return 1;
-
DLOG("window = %08x\n", event->window);
if ((parent = con_by_frame_id(event->window)) == NULL) {
return 1;
}
- /* re-render the parent (recursively, if it’s a split con) */
- x_deco_recurse(parent);
+ /* Since we render to our pixmap on every change anyways, expose events
+ * only tell us that the X server lost (parts of) the window contents. We
+ * can handle that by copying the appropriate part from our pixmap to the
+ * window. */
+ xcb_copy_area(conn, parent->pixmap, parent->frame, parent->pm_gc,
+ event->x, event->y, event->x, event->y,
+ event->width, event->height);
xcb_flush(conn);
return 1;
y(free);
}
+/*
+ * Formats the reply message for a GET_LOG_MARKERS request and sends it to the
+ * client.
+ *
+ */
+IPC_HANDLER(get_log_markers) {
+#if YAJL_MAJOR >= 2
+ yajl_gen gen = yajl_gen_alloc(NULL);
+#else
+ yajl_gen gen = yajl_gen_alloc(NULL, NULL);
+#endif
+
+ int offset_next_write, offset_last_wrap, logsize;
+ get_log_markers(&offset_next_write, &offset_last_wrap, &logsize);
+
+ y(map_open);
+ ystr("offset_next_write");
+ y(integer, offset_next_write);
+
+ ystr("offset_last_wrap");
+ y(integer, offset_last_wrap);
+
+ ystr("shmname");
+ ystr(shmlogname);
+
+ ystr("size");
+ y(integer, logsize);
+
+ y(map_close);
+
+ const unsigned char *payload;
+#if YAJL_MAJOR >= 2
+ size_t length;
+#else
+ unsigned int length;
+#endif
+ y(get_buf, &payload, &length);
+
+ ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_LOG_MARKERS, payload);
+ y(free);
+}
+
/*
* Callback for the YAJL parser (will be called when a string is parsed).
*
/* The index of each callback function corresponds to the numeric
* value of the message type (see include/i3/ipc.h) */
-handler_t handlers[7] = {
+handler_t handlers[8] = {
handle_command,
handle_get_workspaces,
handle_subscribe,
handle_get_outputs,
handle_tree,
handle_get_marks,
- handle_get_bar_config
+ handle_get_bar_config,
+ handle_get_log_markers
};
/*
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <errno.h>
#include "util.h"
#include "log.h"
+#include "i3.h"
+#include "libi3.h"
/* loglevels.h is autogenerated at make time */
#include "loglevels.h"
static FILE *errorfile;
char *errorfilename;
+/* SHM logging variables */
+
+/* The name for the SHM (/i3-log-%pid). Will end up on /dev/shm on most
+ * systems. Global so that we can clean up at exit. */
+char *shmlogname = "";
+/* Size limit for the SHM log, by default 25 MiB. Can be overwritten using the
+ * flag --shmlog-size. */
+int shmlog_size = 0;
+/* If enabled, logbuffer will point to a memory mapping of the i3 SHM log. */
+static char *logbuffer;
+/* A pointer (within logbuffer) where data will be written to next. */
+static char *logwalk;
+/* A pointer to the byte where we last wrapped. Necessary to not print the
+ * left-overs at the end of the ringbuffer. */
+static char *loglastwrap;
+/* Size (in bytes) of the i3 SHM log. */
+static int logbuffer_size;
+/* File descriptor for shm_open. */
+static int logbuffer_shm;
+
/*
* Initializes logging by creating an error logfile in /tmp (or
* XDG_RUNTIME_DIR, see get_process_filename()).
*
+ * Will be called twice if --shmlog-size is specified.
+ *
*/
void init_logging() {
- errorfilename = get_process_filename("errorlog");
- if (errorfilename == NULL) {
- ELOG("Could not initialize errorlog\n");
- return;
+ if (!errorfilename) {
+ if (!(errorfilename = get_process_filename("errorlog")))
+ ELOG("Could not initialize errorlog\n");
+ else {
+ errorfile = fopen(errorfilename, "w");
+ if (fcntl(fileno(errorfile), F_SETFD, FD_CLOEXEC)) {
+ ELOG("Could not set close-on-exec flag\n");
+ }
+ }
}
- errorfile = fopen(errorfilename, "w");
- if (fcntl(fileno(errorfile), F_SETFD, FD_CLOEXEC)) {
- ELOG("Could not set close-on-exec flag\n");
+ /* If this is a debug build (not a release version), we will enable SHM
+ * logging by default, unless the user turned it off explicitly. */
+ if (logbuffer == NULL && shmlog_size > 0) {
+ /* Reserve 1% of the RAM for the logfile, but at max 25 MiB.
+ * For 512 MiB of RAM this will lead to a 5 MiB log buffer.
+ * At the moment (2011-12-10), no testcase leads to an i3 log
+ * of more than ~ 600 KiB. */
+ long long physical_mem_bytes = (long long)sysconf(_SC_PHYS_PAGES) *
+ sysconf(_SC_PAGESIZE);
+ logbuffer_size = min(physical_mem_bytes * 0.01, shmlog_size);
+ sasprintf(&shmlogname, "/i3-log-%d", getpid());
+ logbuffer_shm = shm_open(shmlogname, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
+ if (logbuffer_shm == -1) {
+ ELOG("Could not shm_open SHM segment for the i3 log: %s\n", strerror(errno));
+ return;
+ }
+
+ if (ftruncate(logbuffer_shm, logbuffer_size) == -1) {
+ close(logbuffer_shm);
+ shm_unlink("/i3-log-");
+ ELOG("Could not ftruncate SHM segment for the i3 log: %s\n", strerror(errno));
+ return;
+ }
+
+ logbuffer = mmap(NULL, logbuffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, logbuffer_shm, 0);
+ if (logbuffer == MAP_FAILED) {
+ close(logbuffer_shm);
+ shm_unlink("/i3-log-");
+ ELOG("Could not mmap SHM segment for the i3 log: %s\n", strerror(errno));
+ logbuffer = NULL;
+ return;
+ }
+ logwalk = logbuffer;
+ loglastwrap = logbuffer + logbuffer_size;
}
}
}
/*
- * Logs the given message to stdout while prefixing the current time to it.
+ * Returns the offsets for the next write and for the last wrap.
+ * Necessary to print the i3 SHM log in the correct order.
+ *
+ */
+void get_log_markers(int *offset_next_write, int *offset_last_wrap, int *size) {
+ *offset_next_write = (logwalk - logbuffer);
+ *offset_last_wrap = (loglastwrap - logbuffer);
+ *size = logbuffer_size;
+}
+
+/*
+ * Logs the given message to stdout (if print is true) while prefixing the
+ * current time to it. Additionally, the message will be saved in the i3 SHM
+ * log if enabled.
* This is to be called by *LOG() which includes filename/linenumber/function.
*
*/
-void vlog(char *fmt, va_list args) {
- static char timebuf[64];
+static void vlog(const bool print, const char *fmt, va_list args) {
+ /* Precisely one page to not consume too much memory but to hold enough
+ * data to be useful. */
+ static char message[4096];
static struct tm result;
+ static time_t t;
+ static struct tm *tmp;
+ static size_t len;
/* Get current time */
- time_t t = time(NULL);
+ t = time(NULL);
/* Convert time to local time (determined by the locale) */
- struct tm *tmp = localtime_r(&t, &result);
+ tmp = localtime_r(&t, &result);
/* Generate time prefix */
- strftime(timebuf, sizeof(timebuf), "%x %X - ", tmp);
+ len = strftime(message, sizeof(message), "%x %X - ", tmp);
+
+ /*
+ * logbuffer print
+ * ----------------
+ * true true format message, save, print
+ * true false format message, save
+ * false true print message only
+ * false false INVALID, never called
+ */
+ if (!logbuffer) {
#ifdef DEBUG_TIMING
- struct timeval tv;
- gettimeofday(&tv, NULL);
- printf("%s%d.%d - ", timebuf, tv.tv_sec, tv.tv_usec);
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ printf("%s%d.%d - ", message, tv.tv_sec, tv.tv_usec);
#else
- printf("%s", timebuf);
+ printf("%s", message);
#endif
- vprintf(fmt, args);
+ vprintf(fmt, args);
+ } else {
+ len += vsnprintf(message + len, sizeof(message) - len, fmt, args);
+ if (len == sizeof(message)) {
+ fprintf(stderr, "BUG: single log message > 4k\n");
+ }
+ /* If there is no space for the current message (plus trailing
+ * nullbyte) in the ringbuffer, we need to wrap and write to the
+ * beginning again. */
+ if ((len+1) >= (logbuffer_size - (logwalk - logbuffer))) {
+ loglastwrap = logwalk;
+ logwalk = logbuffer;
+ }
+
+ /* Copy the buffer, terminate it, move the write pointer to the byte after
+ * our current message. */
+ strncpy(logwalk, message, len);
+ logwalk[len] = '\0';
+ logwalk += len + 1;
+
+ if (print)
+ fwrite(message, len, 1, stdout);
+ }
}
/*
void verboselog(char *fmt, ...) {
va_list args;
- if (!verbose)
+ if (!logbuffer && !verbose)
return;
va_start(args, fmt);
- vlog(fmt, args);
+ vlog(verbose, fmt, args);
va_end(args);
}
va_list args;
va_start(args, fmt);
- vlog(fmt, args);
+ vlog(true, fmt, args);
va_end(args);
/* also log to the error logfile, if opened */
void debuglog(uint64_t lev, char *fmt, ...) {
va_list args;
- if ((loglevel & lev) == 0)
+ if (!logbuffer && !(loglevel & lev))
return;
va_start(args, fmt);
- vlog(fmt, args);
+ vlog((loglevel & lev), fmt, args);
va_end(args);
}
#include <sys/un.h>
#include <sys/time.h>
#include <sys/resource.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
#include "all.h"
#include "sd-daemon.h"
* RLIM_INFINITY for i3 debugging versions. */
struct rlimit original_rlimit_core;
+/* Whether this version of i3 is a debug build or a release build. */
+bool debug_build = false;
+
static int xkb_event_base;
int xkb_current_group;
#if EV_VERSION_MAJOR >= 4
ev_loop_destroy(main_loop);
#endif
+
+ if (*shmlogname != '\0') {
+ fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
+ fflush(stderr);
+ shm_unlink(shmlogname);
+ }
+}
+
+/*
+ * (One-shot) Handler for all signals with default action "Term", see signal(7)
+ *
+ * Unlinks the SHM log and re-raises the signal.
+ *
+ */
+static void handle_signal(int sig, siginfo_t *info, void *data) {
+ fprintf(stderr, "Received signal %d, terminating\n", sig);
+ if (*shmlogname != '\0') {
+ fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
+ shm_unlink(shmlogname);
+ }
+ fflush(stderr);
+ raise(sig);
}
int main(int argc, char *argv[]) {
{"force-xinerama", no_argument, 0, 0},
{"force_xinerama", no_argument, 0, 0},
{"disable-signalhandler", no_argument, 0, 0},
+ {"shmlog-size", required_argument, 0, 0},
+ {"shmlog_size", required_argument, 0, 0},
{"get-socketpath", no_argument, 0, 0},
{"get_socketpath", no_argument, 0, 0},
{0, 0, 0, 0}
srand(time(NULL));
+ /* Init logging *before* initializing debug_build to guarantee early
+ * (file) logging. */
init_logging();
+ /* I3_VERSION contains either something like this:
+ * "4.0.2 (2011-11-11, branch "release")".
+ * or: "4.0.2-123-gCOFFEEBABE (2011-11-11, branch "next")".
+ *
+ * So we check for the offset of the first opening round bracket to
+ * determine whether this is a git version or a release version. */
+ debug_build = ((strchr(I3_VERSION, '(') - I3_VERSION) > 10);
+
+ /* On non-release builds, disable SHM logging by default. */
+ shmlog_size = (debug_build ? 25 * 1024 * 1024 : 0);
+
start_argv = argv;
while ((opt = getopt_long(argc, argv, "c:CvaL:hld:V", long_options, &option_index)) != -1) {
}
return 1;
+ } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
+ strcmp(long_options[option_index].name, "shmlog_size") == 0) {
+ shmlog_size = atoi(optarg);
+ /* Re-initialize logging immediately to get as many
+ * logmessages as possible into the SHM log. */
+ init_logging();
+ LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
+ break;
} else if (strcmp(long_options[option_index].name, "restart") == 0) {
FREE(layout_path);
layout_path = sstrdup(optarg);
fprintf(stderr, "\t--get-socketpath\n"
"\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
fprintf(stderr, "\n");
+ fprintf(stderr, "\t--shmlog-size <limit>\n"
+ "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
+ "\tto 0 disables SHM logging entirely.\n"
+ "\tThe default is %d bytes.\n", shmlog_size);
+ fprintf(stderr, "\n");
fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
"to send to a currently running i3 (like i3-msg). This allows you to\n"
"use nice and logical commands, such as:\n"
return 0;
}
- /* I3_VERSION contains either something like this:
- * "4.0.2 (2011-11-11, branch "release")".
- * or: "4.0.2-123-gCOFFEEBABE (2011-11-11, branch "next")".
- *
- * So we check for the offset of the first opening round bracket to
- * determine whether this is a git version or a release version. */
- if ((strchr(I3_VERSION, '(') - I3_VERSION) > 10) {
+ /* Enable logging to handle the case when the user did not specify --shmlog-size */
+ init_logging();
+
+ /* Try to enable core dumps by default when running a debug build */
+ if (debug_build) {
struct rlimit limit = { RLIM_INFINITY, RLIM_INFINITY };
setrlimit(RLIMIT_CORE, &limit);
ev_io_start(main_loop, ipc_io);
}
- /* Also handle the UNIX domain sockets passed via socket activation */
+ /* Also handle the UNIX domain sockets passed via socket activation. The
+ * parameter 1 means "remove the environment variables", we don’t want to
+ * pass these to child processes. */
int fds = sd_listen_fds(1);
if (fds < 0)
ELOG("socket activation: Error in sd_listen_fds\n");
manage_existing_windows(root);
+ struct sigaction action;
+
+ action.sa_sigaction = handle_signal;
+ action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
+ sigemptyset(&action.sa_mask);
+
if (!disable_signalhandler)
setup_signal_handler();
+ else {
+ /* Catch all signals with default action "Core", see signal(7) */
+ if (sigaction(SIGQUIT, &action, NULL) == -1 ||
+ sigaction(SIGILL, &action, NULL) == -1 ||
+ sigaction(SIGABRT, &action, NULL) == -1 ||
+ sigaction(SIGFPE, &action, NULL) == -1 ||
+ sigaction(SIGSEGV, &action, NULL) == -1)
+ ELOG("Could not setup signal handler");
+ }
+
+ /* Catch all signals with default action "Term", see signal(7) */
+ if (sigaction(SIGHUP, &action, NULL) == -1 ||
+ sigaction(SIGINT, &action, NULL) == -1 ||
+ sigaction(SIGALRM, &action, NULL) == -1 ||
+ sigaction(SIGUSR1, &action, NULL) == -1 ||
+ sigaction(SIGUSR2, &action, NULL) == -1)
+ ELOG("Could not setup signal handler");
/* Ignore SIGPIPE to survive errors when an IPC client disconnects
* while we are sending him a message */
Barconfig *barconfig;
TAILQ_FOREACH(barconfig, &barconfigs, configs) {
char *command = NULL;
- sasprintf(&command, "i3bar --bar_id=%s --socket=\"%s\"",
- barconfig->id, current_socketpath);
+ sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
+ barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
+ barconfig->id, current_socketpath);
LOG("Starting bar process: %s\n", command);
start_application(command, true);
free(command);
}
/* find the height for the decorations */
- int deco_height = config.font.height + 5;
+ int deco_height = config.font.height + 4;
+ if (config.font.height & 0x01)
+ ++deco_height;
/* precalculate the sizes to be able to correct rounding errors */
int sizes[children];
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &inner);
/* restore font color */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
+ set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
for (int i = 0; i < sizeof(crash_text) / sizeof(char*); i++) {
- int text_len = strlen(crash_text[i]);
- char *full_text = convert_utf8_to_ucs2(crash_text[i], &text_len);
- xcb_image_text_16(conn, text_len, pixmap, pixmap_gc, 8 /* X */,
- 3 + (i + 1) * font_height /* Y = baseline of font */,
- (xcb_char2b_t*)full_text);
- free(full_text);
+ draw_text(crash_text[i], strlen(crash_text[i]), false, pixmap, pixmap_gc,
+ 8, 5 + i * font_height, width - 16);
}
/* Copy the contents of the pixmap to the real window */
int height = 13 + (crash_text_num * config.font.height);
/* calculate width for longest text */
- int text_len = strlen(crash_text[crash_text_longest]);
- char *longest_text = convert_utf8_to_ucs2(crash_text[crash_text_longest], &text_len);
- int font_width = predict_text_width(longest_text, text_len);
+ size_t text_len = strlen(crash_text[crash_text_longest]);
+ xcb_char2b_t *longest_text = convert_utf8_to_ucs2(crash_text[crash_text_longest], &text_len);
+ int font_width = predict_text_width((char *)longest_text, text_len, true);
int width = font_width + 20;
/* Open a popup window on each virtual screen */
xcb_create_pixmap(conn, root_depth, pixmap, win, width, height);
xcb_create_gc(conn, pixmap_gc, pixmap, 0, 0);
- /* Create graphics context */
- xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ config.font.id });
-
/* Grab the keyboard to get all input */
xcb_grab_keyboard(conn, false, win, XCB_CURRENT_TIME, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
sigemptyset(&action.sa_mask);
- if (sigaction(SIGSEGV, &action, NULL) == -1 ||
+ /* Catch all signals with default action "Core", see signal(7) */
+ if (sigaction(SIGQUIT, &action, NULL) == -1 ||
+ sigaction(SIGILL, &action, NULL) == -1 ||
sigaction(SIGABRT, &action, NULL) == -1 ||
- sigaction(SIGFPE, &action, NULL) == -1)
+ sigaction(SIGFPE, &action, NULL) == -1 ||
+ sigaction(SIGSEGV, &action, NULL) == -1)
ELOG("Could not setup signal handler");
}
#include <sys/wait.h>
#include <stdarg.h>
-#include <iconv.h>
#if defined(__OpenBSD__)
#include <sys/cdefs.h>
#endif
#define SN_API_NOT_YET_FROZEN 1
#include <libsn/sn-launcher.h>
-static iconv_t conversion_descriptor = 0;
-
int min(int a, int b) {
return (a < b ? a : b);
}
}
}
-/*
- * Converts the given string to UCS-2 big endian for use with
- * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen,
- * a buffer containing the UCS-2 encoded string (16 bit per glyph) is
- * returned. It has to be freed when done.
- *
- */
-char *convert_utf8_to_ucs2(char *input, int *real_strlen) {
- size_t input_size = strlen(input) + 1;
- /* UCS-2 consumes exactly two bytes for each glyph */
- int buffer_size = input_size * 2;
-
- char *buffer = smalloc(buffer_size);
- size_t output_size = buffer_size;
- /* We need to use an additional pointer, because iconv() modifies it */
- char *output = buffer;
-
- /* We convert the input into UCS-2 big endian */
- if (conversion_descriptor == 0) {
- conversion_descriptor = iconv_open("UCS-2BE", "UTF-8");
- if (conversion_descriptor == 0) {
- fprintf(stderr, "error opening the conversion context\n");
- exit(1);
- }
- }
-
- /* Get the conversion descriptor back to original state */
- iconv(conversion_descriptor, NULL, NULL, NULL, NULL);
-
- /* Convert our text */
- int rc = iconv(conversion_descriptor, (void*)&input, &input_size, &output, &output_size);
- if (rc == (size_t)-1) {
- perror("Converting to UCS-2 failed");
- FREE(buffer);
- if (real_strlen != NULL)
- *real_strlen = 0;
- return NULL;
- }
-
- if (real_strlen != NULL)
- *real_strlen = ((buffer_size - output_size) / 2) - 1;
-
- return buffer;
-}
-
/*
* This function resolves ~ in pathnames.
* It may resolve wildcards in the first part of the path, but if no match
return;
}
/* Convert it to UCS-2 here for not having to convert it later every time we want to pass it to X */
- int len;
- char *ucs2_name = convert_utf8_to_ucs2(new_name, &len);
+ size_t len;
+ xcb_char2b_t *ucs2_name = convert_utf8_to_ucs2(new_name, &len);
if (ucs2_name == NULL) {
LOG("Could not convert _NET_WM_NAME to UCS-2, ignoring new hint\n");
FREE(new_name);
FREE(win->name_x);
FREE(win->name_json);
win->name_json = new_name;
- win->name_x = ucs2_name;
+ win->name_x = (char*)ucs2_name;
win->name_len = len;
win->name_x_changed = true;
LOG("_NET_WM_NAME changed to \"%s\"\n", win->name_json);
p->con_deco_rect = con->deco_rect;
p->background = config.client.background;
p->con_is_leaf = con_is_leaf(con);
- p->font = config.font.id;
if (con->deco_render_params != NULL &&
(con->window == NULL || !con->window->name_x_changed) &&
xcb_poly_segment(conn, parent->pixmap, parent->pm_gc, 2, segments);
/* 6: draw the title */
- uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
- uint32_t values[] = { p->color->text, p->color->background, config.font.id };
- xcb_change_gc(conn, parent->pm_gc, mask, values);
- int text_offset_y = config.font.height + (con->deco_rect.height - config.font.height) / 2 - 1;
+ set_font_colors(parent->pm_gc, p->color->text, p->color->background);
+ int text_offset_y = (con->deco_rect.height - config.font.height) / 2;
struct Window *win = con->window;
if (win == NULL || win->name_x == NULL) {
/* this is a non-leaf container, we need to make up a good description */
// TODO: use a good description instead of just "another container"
- xcb_image_text_8(
- conn,
- strlen("another container"),
- parent->pixmap,
- parent->pm_gc,
- con->deco_rect.x + 2,
- con->deco_rect.y + text_offset_y,
- "another container"
- );
-
+ draw_text("another container", strlen("another container"), false,
+ parent->pixmap, parent->pm_gc,
+ con->deco_rect.x + 2, con->deco_rect.y + text_offset_y,
+ con->deco_rect.width - 2);
goto copy_pixmaps;
}
//DLOG("indent_level = %d, indent_mult = %d\n", indent_level, indent_mult);
int indent_px = (indent_level * 5) * indent_mult;
- if (win->uses_net_wm_name)
- xcb_image_text_16(
- conn,
- win->name_len,
- parent->pixmap,
- parent->pm_gc,
- con->deco_rect.x + 2 + indent_px,
- con->deco_rect.y + text_offset_y,
- (xcb_char2b_t*)win->name_x
- );
- else
- xcb_image_text_8(
- conn,
- win->name_len,
- parent->pixmap,
- parent->pm_gc,
- con->deco_rect.x + 2 + indent_px,
- con->deco_rect.y + text_offset_y,
- win->name_x
- );
+ draw_text(win->name_x, win->name_len, win->uses_net_wm_name,
+ parent->pixmap, parent->pm_gc,
+ con->deco_rect.x + 2 + indent_px, con->deco_rect.y + text_offset_y,
+ con->deco_rect.width - 2 - indent_px);
copy_pixmaps:
xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height);
xcb_configure_window(conn, window, XCB_CONFIG_WINDOW_STACK_MODE, values);
}
-/*
- * Query the width of the given text (16-bit characters, UCS) with given real
- * length (amount of glyphs) using the given font.
- *
- */
-int predict_text_width(char *text, int length) {
- xcb_query_text_extents_cookie_t cookie;
- xcb_query_text_extents_reply_t *reply;
- xcb_generic_error_t *error;
- int width;
-
- cookie = xcb_query_text_extents(conn, config.font.id, length, (xcb_char2b_t*)text);
- if ((reply = xcb_query_text_extents_reply(conn, cookie, &error)) == NULL) {
- ELOG("Could not get text extents (X error code %d)\n",
- error->error_code);
- /* We return the rather safe guess of 7 pixels, because a
- * rendering error is better than a crash. Plus, the user will
- * see the error in his log. */
- return 7;
- }
-
- width = reply->overall_width;
- free(reply);
- return width;
-}
-
/*
* Configures the given window to have the size/position specified by given rect
*
use ExtUtils::MakeMaker;
WriteMakefile(
- NAME => 'i3 testsuite',
+ NAME => 'i3-testsuite',
MIN_PERL_VERSION => '5.010000', # 5.10.0
PREREQ_PM => {
'AnyEvent' => 0,
'AnyEvent::I3' => '0.09',
'X11::XCB' => '0.03',
- 'Test::Most' => 0,
- 'Test::Deep' => 0,
- 'EV' => 0,
- 'Inline' => 0,
+ 'Inline' => 0,
},
- # don't install any files from this directory
- PM => {},
+ PM => {}, # do not install any files from this directory
clean => {
- FILES => 'testsuite-* latest'
+ FILES => 'testsuite-* latest i3-cfg-for-*',
}
);
-# and don't run the tests while installing
-sub MY::test { }
+
+package MY;
+sub test { } # do not run the tests while installing
+
+# do not rename the Makefile
+sub clean {
+ my $section = shift->SUPER::clean(@_);
+ $section =~ s/^\t\Q$_\E\n$//m for
+ '- $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL)';
+ $section;
+}
#!/usr/bin/env perl
# vim:ts=4:sw=4:expandtab
# © 2010-2011 Michael Stapelberg and contributors
-
+package complete_run;
use strict;
use warnings;
use v5.10;
# the following are modules which ship with Perl (>= 5.10):
use Pod::Usage;
use Cwd qw(abs_path);
-use File::Basename qw(basename);
use File::Temp qw(tempfile tempdir);
use Getopt::Long;
-use IO::Socket::UNIX;
-use POSIX;
-use Time::HiRes qw(sleep gettimeofday tv_interval);
+use POSIX ();
use TAP::Harness;
use TAP::Parser;
use TAP::Parser::Aggregator;
+use Time::HiRes qw(time);
# these are shipped with the testsuite
use lib qw(lib);
-use SocketActivation;
use StartXDummy;
use StatusLine;
+use TestWorker;
# the following modules are not shipped with Perl
use AnyEvent;
+use AnyEvent::Util;
use AnyEvent::Handle;
use AnyEvent::I3 qw(:all);
-use X11::XCB;
-
-# We actually use AnyEvent to make sure it loads an event loop implementation.
-# Afterwards, we overwrite SIGCHLD:
-my $cv = AnyEvent->condvar;
-
-# Install a dummy CHLD handler to overwrite the CHLD handler of AnyEvent.
-# AnyEvent’s handler wait()s for every child which conflicts with TAP (TAP
-# needs to get the exit status to determine if a test is successful).
-$SIG{CHLD} = sub {
-};
-
-# reads in a whole file
-sub slurp {
- open(my $fh, '<', shift);
- local $/;
- <$fh>;
-}
+use X11::XCB::Connection;
+use JSON::XS; # AnyEvent::I3 depends on it, too.
+
+# Close superfluous file descriptors which were passed by running in a VIM
+# subshell or situations like that.
+AnyEvent::Util::close_all_fds_except(0, 1, 2);
# convinience wrapper to write to the log file
my $log;
sub Log { say $log "@_" }
+my %timings;
my $coverage_testing = 0;
my $valgrind = 0;
+my $strace = 0;
my $help = 0;
# Number of tests to run in parallel. Important to know how many Xdummy
# instances we need to start (unless @displays are given). Defaults to
# num_cores * 2.
my $parallel = undef;
my @displays = ();
-my @childpids = ();
my $result = GetOptions(
"coverage-testing" => \$coverage_testing,
"valgrind" => \$valgrind,
+ "strace" => \$strace,
"display=s" => \@displays,
"parallel=i" => \$parallel,
"help|?" => \$help,
@displays = split(/,/, join(',', @displays));
@displays = map { s/ //g; $_ } @displays;
+# 2: get a list of all testcases
+my @testfiles = @ARGV;
+
+# if no files were passed on command line, run all tests from t/
+@testfiles = <t/*.t> if @testfiles == 0;
+
+my $numtests = scalar @testfiles;
+
# No displays specified, let’s start some Xdummy instances.
-if (@displays == 0) {
- my ($displays, $pids) = start_xdummy($parallel);
- @displays = @$displays;
- @childpids = @$pids;
-}
+@displays = start_xdummy($parallel, $numtests) if @displays == 0;
+
+# 1: create an output directory for this test-run
+my $outdir = "testsuite-";
+$outdir .= POSIX::strftime("%Y-%m-%d-%H-%M-%S-", localtime());
+$outdir .= `git describe --tags`;
+chomp($outdir);
+mkdir($outdir) or die "Could not create $outdir";
+unlink("latest") if -e "latest";
+symlink("$outdir", "latest") or die "Could not symlink latest to $outdir";
+
# connect to all displays for two reasons:
# 1: check if the display actually works
# 2: keep the connection open so that i3 is not the only client. this prevents
# the X server from exiting (Xdummy will restart it, but not quick enough
# sometimes)
-my @conns;
-my @wdisplays;
+my @worker;
for my $display (@displays) {
my $screen;
- my $x = X11::XCB->new($display, $screen);
+ my $x = X11::XCB::Connection->new(display => $display);
if ($x->has_error) {
- Log "WARNING: Not using X11 display $display, could not connect";
+ die "Could not connect to display $display\n";
} else {
- push @conns, $x;
- push @wdisplays, $display;
+ # start a TestWorker for each display
+ push @worker, worker($display, $x, $outdir);
}
}
-die "No usable displays found" if @wdisplays == 0;
+# Read previous timing information, if available. We will be able to roughly
+# predict the test duration and schedule a good order for the tests.
+my $timingsjson = StartXDummy::slurp('.last_run_timings.json');
+%timings = %{decode_json($timingsjson)} if length($timingsjson) > 0;
-my $config = slurp('i3-test.config');
+# Re-order the files so that those which took the longest time in the previous
+# run will be started at the beginning to not delay the whole run longer than
+# necessary.
+@testfiles = map { $_->[0] }
+ sort { $b->[1] <=> $a->[1] }
+ map { [$_, $timings{$_} // 999] } @testfiles;
-# 1: get a list of all testcases
-my @testfiles = @ARGV;
-
-# if no files were passed on command line, run all tests from t/
-@testfiles = <t/*.t> if @testfiles == 0;
+printf("\nRough time estimate for this run: %.2f seconds\n\n", $timings{GLOBAL})
+ if exists($timings{GLOBAL});
-# 2: create an output directory for this test-run
-my $outdir = "testsuite-";
-$outdir .= POSIX::strftime("%Y-%m-%d-%H-%M-%S-", localtime());
-$outdir .= `git describe --tags`;
-chomp($outdir);
-mkdir($outdir) or die "Could not create $outdir";
-unlink("latest") if -e "latest";
-symlink("$outdir", "latest") or die "Could not symlink latest to $outdir";
+# Forget the old timings, we don’t necessarily run the same set of tests as
+# before. Otherwise we would end up with left-overs.
+%timings = (GLOBAL => time());
my $logfile = "$outdir/complete-run.log";
open $log, '>', $logfile or die "Could not create '$logfile': $!";
my $aggregator = TAP::Parser::Aggregator->new();
$aggregator->start();
-status_init(displays => \@wdisplays, tests => $num);
+status_init(displays => \@displays, tests => $num);
+
+my $cv = AE::cv;
# We start tests concurrently: For each display, one test gets started. Every
# test starts another test after completing.
-take_job($_) for @wdisplays;
+for (@worker) { $cv->begin; take_job($_) }
+
+$cv->recv;
+
+$aggregator->stop();
+
+# print empty lines to seperate failed tests from statuslines
+print "\n\n";
+
+for (@done) {
+ my ($test, $output) = @$_;
+ say "no output for $test" unless $output;
+ Log "output for $test:";
+ Log $output;
+ # print error messages of failed tests
+ say for $output =~ /^not ok.+\n+((?:^#.+\n)+)/mg
+}
+
+# 4: print summary
+$harness->summary($aggregator);
+
+close $log;
+
+# 5: Save the timings for better scheduling/prediction next run.
+$timings{GLOBAL} = time() - $timings{GLOBAL};
+open(my $fh, '>', '.last_run_timings.json');
+print $fh encode_json(\%timings);
+close($fh);
+
+# 6: Print the slowest test files.
+my @slowest = map { $_->[0] }
+ sort { $b->[1] <=> $a->[1] }
+ map { [$_, $timings{$_}] }
+ grep { !/^GLOBAL$/ } keys %timings;
+say '';
+say 'The slowest tests are:';
+printf("\t%s with %.2f seconds\n", $_, $timings{$_})
+ for @slowest[0..($#slowest > 4 ? 4 : $#slowest)];
+
+# When we are running precisely one test, print the output. Makes developing
+# with a single testcase easier.
+if ($numtests == 1) {
+ say '';
+ say 'Test output:';
+ say StartXDummy::slurp($logfile);
+}
+
+END { cleanup() }
+
+exit 0;
#
# Takes a test from the beginning of @testfiles and runs it.
# triggered to finish testing.
#
sub take_job {
- my ($display) = @_;
+ my ($worker) = @_;
- my $test = shift @testfiles;
- return unless $test;
+ my $test = shift @testfiles
+ or return $cv->end;
- my $dont_start = (slurp($test) =~ /# !NO_I3_INSTANCE!/);
- my $basename = basename($test);
- my $logpath = "$outdir/i3-log-for-$basename";
+ my $display = $worker->{display};
- my ($fh, $tmpfile) = tempfile("i3-cfg-for-$basename.XXXXXX", UNLINK => 1);
- say $fh $config;
- say $fh "ipc-socket /tmp/nested-$display";
- close($fh);
+ Log status($display, "$test: starting");
+ $timings{$test} = time();
+ worker_next($worker, $test);
- my $activate_cv = AnyEvent->condvar;
- my $time_before_start = [gettimeofday];
-
- my $pid;
- if ($dont_start) {
- $activate_cv->send(1);
- } else {
- $pid = activate_i3(
- unix_socket_path => "/tmp/nested-$display-activation",
- display => $display,
- configfile => $tmpfile,
- outdir => $outdir,
- logpath => $logpath,
- valgrind => $valgrind,
- cv => $activate_cv
- );
-
- my $child_watcher;
- $child_watcher = AnyEvent->child(pid => $pid, cb => sub {
- Log status($display, "child died. pid = $pid");
- undef $child_watcher;
- });
- }
-
- my $kill_i3 = sub {
- my $kill_cv = AnyEvent->condvar;
-
- # Don’t bother killing i3 when we haven’t started it
- if ($dont_start) {
- $kill_cv->send();
- return $kill_cv;
- }
+ # create a TAP::Parser with an in-memory fh
+ my $output;
+ my $parser = TAP::Parser->new({
+ source => do { open(my $fh, '<', \$output); $fh },
+ });
- # When measuring code coverage, try to exit i3 cleanly (otherwise, .gcda
- # files are not written) and fallback to killing it
- if ($coverage_testing || $valgrind) {
- my $exited = 0;
- Log status($display, 'Exiting i3 cleanly...');
- my $i3 = i3("/tmp/nested-$display");
- $i3->connect->cb(sub {
- if (!$_[0]->recv) {
- # Could not connect to i3, just kill -9 it
- kill(9, $pid) or die "Could not kill i3 using kill($pid)";
- $kill_cv->send();
- } else {
- # Connected. Now send exit and continue once that’s acked.
- $i3->command('exit')->cb(sub {
- $kill_cv->send();
- });
+ my $ipc = $worker->{ipc};
+
+ my $w;
+ $w = AnyEvent->io(
+ fh => $ipc,
+ poll => 'r',
+ cb => sub {
+ state $tests_completed = 0;
+ state $partial = '';
+
+ sysread($ipc, my $buf, 4096) or die "sysread: $!";
+
+ if ($partial) {
+ $buf = $partial . $buf;
+ $partial = '';
+ }
+
+ # make sure we feed TAP::Parser complete lines so it doesn't blow up
+ if (substr($buf, -1, 1) ne "\n") {
+ my $nl = rindex($buf, "\n");
+ if ($nl == -1) {
+ $partial = $buf;
+ return;
}
- });
- } else {
- Log status($display, 'killing i3');
- # No coverage testing or valgrind? Just kill -9 i3.
- kill(9, $pid) or die "Could not kill i3 using kill($pid)";
- $kill_cv->send();
- }
+ # strip partial from buffer
+ $partial = substr($buf, $nl + 1, '');
+ }
- return $kill_cv;
- };
-
- # This will be called as soon as i3 is running and answered to our
- # IPC request
- $activate_cv->cb(sub {
- my $time_activating = [gettimeofday];
- my $start_duration = tv_interval($time_before_start, $time_activating);
- my ($status) = $activate_cv->recv;
- if ($dont_start) {
- Log status($display, 'Not starting i3, testcase does that');
- } else {
- my $duration = sprintf("%.2f", $start_duration);
- Log status($display, "i3 startup: took $duration sec, status = $status");
- }
+ # count lines before stripping eof-marker otherwise we might
+ # end up with for (1 .. 0) { } which would effectivly skip the loop
+ my $lines = $buf =~ tr/\n//;
+ my $t_eof = $buf =~ s/^$TestWorker::EOF$//m;
- Log status($display, "Starting $test");
-
- my $output;
- open(my $spool, '>', \$output);
- my $parser = TAP::Parser->new({
- exec => [ 'sh', '-c', qq|DISPLAY=$display LOGPATH="$logpath" OUTDIR="$outdir" VALGRIND=$valgrind /usr/bin/perl -Ilib $test| ],
- spool => $spool,
- merge => 1,
- });
-
- my $tests_completed;
-
- my @watchers;
- my ($stdout, $stderr) = $parser->get_select_handles;
- for my $handle ($parser->get_select_handles) {
- my $w;
- $w = AnyEvent->io(
- fh => $handle,
- poll => 'r',
- cb => sub {
- # Ignore activity on stderr (unnecessary with merge => 1,
- # but let’s keep it in here if we want to use merge => 0
- # for some reason in the future).
- return if defined($stderr) and $handle == $stderr;
-
- my $result = $parser->next;
- if (defined($result)) {
- $tests_completed++;
- status($display, "Running $test: [$tests_completed/??]");
- # TODO: check if we should bail out
- return;
- }
-
- # $result is not defined, we are done parsing
- Log status($display, "$test finished");
- close($parser->delete_spool);
- $aggregator->add($test, $parser);
- push @done, [ $test, $output ];
-
- status_completed(scalar @done);
-
- my $exitcv = $kill_i3->();
- $exitcv->cb(sub {
-
- undef $_ for @watchers;
- if (@done == $num) {
- $cv->send;
- } else {
- take_job($display);
- }
- });
+ $output .= $buf;
+
+ for (1 .. $lines) {
+ my $result = $parser->next;
+ if (defined($result) and $result->is_test) {
+ $tests_completed++;
+ status($display, "$test: [$tests_completed/??] ");
}
- );
- push @watchers, $w;
- }
- });
-}
+ }
-$cv->recv;
+ return unless $t_eof;
-$aggregator->stop();
+ Log status($display, "$test: finished");
+ $timings{$test} = time() - $timings{$test};
+ status_completed(scalar @done);
-# print empty lines to seperate failed tests from statuslines
-print "\n\n";
+ $aggregator->add($test, $parser);
+ push @done, [ $test, $output ];
-for (@done) {
- my ($test, $output) = @$_;
- Log "output for $test:";
- Log $output;
- # print error messages of failed tests
- say for $output =~ /^not ok.+\n+((?:^#.+\n)+)/mg
+ undef $w;
+ take_job($worker);
+ }
+ );
}
-# 4: print summary
-$harness->summary($aggregator);
-
-close $log;
+sub cleanup {
+ $_->() for our @CLEANUP;
+ exit;
+}
-kill(15, $_) for @childpids;
+# must be in a begin block because we C<exit 0> above
+BEGIN {
+ $SIG{$_} = sub {
+ require Carp; Carp::cluck("Caught SIG$_[0]\n");
+ cleanup();
+ } for qw(INT TERM QUIT KILL PIPE)
+}
__END__
=item B<--valgrind>
Runs i3 under valgrind to find memory problems. The output will be available in
-C<latest/valgrind.log>.
+C<latest/valgrind-for-$test.log>.
+
+=item B<--strace>
+
+Runs i3 under strace to trace system calls. The output will be available in
+C<latest/strace-for-$test.log>.
=item B<--coverage-testing>
use warnings;
use IO::Socket::UNIX; # core
use Cwd qw(abs_path); # core
-use POSIX (); # core
+use POSIX qw(:fcntl_h); # core
use AnyEvent::Handle; # not core
+use AnyEvent::Util; # not core
use Exporter 'import';
use v5.10;
# remove the old unix socket
unlink($args{unix_socket_path});
- # pass all file descriptors up to three to the children.
- # we need to set this flag before opening the socket.
- open(my $fdtest, '<', '/dev/null');
- $^F = fileno($fdtest);
- close($fdtest);
my $socket = IO::Socket::UNIX->new(
Listen => 1,
Local => $args{unix_socket_path},
'..',
$ENV{PATH}
);
- # Only pass file descriptors 0 (stdin), 1 (stdout), 2 (stderr) and
- # 3 (socket) to the child.
- $^F = 3;
+
+ # We are about to exec, but we did not modify $^F to include $socket
+ # when creating the socket (because the file descriptor could have a
+ # number != 3 which would lead to i3 leaking a file descriptor). This
+ # caused Perl to set the FD_CLOEXEC flag, which would close $socket on
+ # exec(), effectively *NOT* passing $socket to the new process.
+ # Therefore, we explicitly clear FD_CLOEXEC (the only flag right now)
+ # by setting the flags to 0.
+ POSIX::fcntl($socket, F_SETFD, 0) or die "Could not clear fd flags: $!";
# If the socket does not use file descriptor 3 by chance already, we
# close fd 3 and dup2() the socket to 3.
if (fileno($socket) != 3) {
POSIX::close(3);
POSIX::dup2(fileno($socket), 3);
+ POSIX::close(fileno($socket));
}
+ # Make sure no file descriptors are open. Strangely, I got an open file
+ # descriptor pointing to AnyEvent/Impl/EV.pm when testing.
+ AnyEvent::Util::close_all_fds_except(0, 1, 2, 3);
+
# Construct the command to launch i3. Use maximum debug level, disable
# the interactive signalhandler to make it crash immediately instead.
- my $i3cmd = abs_path("../i3") . " -V -d all --disable-signalhandler";
+ # Also disable logging to SHM since we want to redirect the logs anyways.
+ my $i3cmd = abs_path("../i3") . " -V -d all --disable-signalhandler --shmlog-size=0";
+
+ # For convenience:
+ my $outdir = $args{outdir};
+ my $test = $args{testname};
if ($args{valgrind}) {
$i3cmd =
- qq|valgrind -v --log-file="$args{outdir}/valgrind.log" | .
+ qq|valgrind -v --log-file="$outdir/valgrind-for-$test.log" | .
qq|--leak-check=full --track-origins=yes --num-callers=20 | .
qq|--tool=memcheck -- $i3cmd|;
}
- # Append to $args{logpath} instead of overwriting because i3 might be
+ my $logfile = "$outdir/i3-log-for-$test";
+ # Append to $logfile instead of overwriting because i3 might be
# run multiple times in one testcase.
- my $cmd = "exec $i3cmd -c $args{configfile} >>$args{logpath} 2>&1";
+ my $cmd = "exec $i3cmd -c $args{configfile} >>$logfile 2>&1";
+
+ if ($args{strace}) {
+ my $out = "$outdir/strace-for-$test.log";
+
+ # We overwrite LISTEN_PID with the correct process ID to make
+ # socket activation work (LISTEN_PID has to match getpid(),
+ # otherwise the LISTEN_FDS will be treated as a left-over).
+ $cmd = qq|strace -fF -s2048 -v -o "$out" -- | .
+ 'sh -c "export LISTEN_PID=\$\$; ' . $cmd . '"';
+ }
# We need to use the shell due to using output redirections.
exec '/bin/sh', '-c', $cmd;
the Xdummy processes and a list of PIDs of the processes.
=cut
+
+my $x_socketpath = '/tmp/.X11-unix/X';
+
sub start_xdummy {
- my ($parallel) = @_;
+ my ($parallel, $numtests) = @_;
my @displays = ();
my @childpids = ();
$parallel ||= $num_cores * 2;
+ # If we are running a small number of tests, don’t over-parallelize.
+ $parallel = $numtests if $numtests < $parallel;
+
# First get the last used display number, then increment it by one.
# Effectively falls back to 1 if no X server is running.
- my ($displaynum) = reverse ('0', sort </tmp/.X11-unix/X*>);
- $displaynum =~ s/.*(\d)$/$1/;
+ my ($displaynum) = map { /(\d+)$/ } reverse sort glob($x_socketpath . '*');
$displaynum++;
say "Starting $parallel Xdummy instances, starting at :$displaynum...";
+ my @sockets_waiting;
for my $idx (0 .. ($parallel-1)) {
my $pid = fork();
die "Could not fork: $!" unless defined($pid);
# Child, close stdout/stderr, then start Xdummy.
close STDOUT;
close STDERR;
+ # make sure this display isn’t in use yet
+ $displaynum++ while -e ($x_socketpath . $displaynum);
+
# We use -config /dev/null to prevent Xdummy from using the system
# Xorg configuration. The tests should be independant from the
# actual system X configuration.
exec './Xdummy', ":$displaynum", '-config', '/dev/null';
exit 1;
}
- push(@childpids, $pid);
+ push(@complete_run::CLEANUP, sub { kill(15, $pid) });
push(@displays, ":$displaynum");
+ push(@sockets_waiting, $x_socketpath . $displaynum);
$displaynum++;
}
# Wait until the X11 sockets actually appear. Pretty ugly solution, but as
# long as we can’t socket-activate X11…
- my $sockets_ready;
- do {
- $sockets_ready = 1;
- for (@displays) {
- my $path = "/tmp/.X11-unix/X" . substr($_, 1);
- $sockets_ready = 0 unless -S $path;
- }
+ while (1) {
+ @sockets_waiting = grep { ! -S $_ } @sockets_waiting;
+ last unless @sockets_waiting;
sleep 0.1;
- } until $sockets_ready;
+ }
- return \@displays, \@childpids;
+ return @displays;
}
1
--- /dev/null
+# vim:ts=4:sw=4:sts=4:expandtab
+package TestWorker;
+use strict; use warnings;
+use v5.10;
+
+use Socket qw(AF_UNIX SOCK_DGRAM PF_UNSPEC);
+use IO::Handle; # for ->autoflush
+
+use POSIX ();
+
+use Exporter 'import';
+our @EXPORT = qw(worker worker_next);
+
+use File::Basename qw(basename);
+my @x;
+
+sub worker {
+ my ($display, $x, $outdir) = @_;
+
+ # make sure $x hangs around
+ push @x, $x;
+
+ socketpair(my $ipc_child, my $ipc, AF_UNIX, SOCK_DGRAM, PF_UNSPEC)
+ or die "socketpair: $!";
+
+ $ipc->autoflush(1);
+ $ipc_child->autoflush(1);
+
+ my $worker = {
+ display => $display,
+ ipc => $ipc,
+ };
+
+ my $pid = fork // die "could not fork: $!";
+
+ if ($pid == 0) {
+ close $ipc;
+ undef @complete_run::CLEANUP;
+ # reap dead test children
+ $SIG{CHLD} = sub { waitpid -1, POSIX::WNOHANG };
+
+ $worker->{ipc} = $ipc_child;
+
+ require i3test;
+ # TODO: recycle $x
+ # unfortunately this fails currently with:
+ # Could not get reply for: xcb_intern_atom_reply at X11/XCB/Atom.pm line 22.
+
+ # $i3test::x = bless $x, 'i3test::X11';
+ worker_wait($worker, $outdir);
+ exit 23;
+
+ }
+
+ close $ipc_child;
+ push @complete_run::CLEANUP, sub {
+ # signal via empty line to exit itself
+ syswrite($ipc, "\n") or kill('TERM', $pid);
+ waitpid $pid, 0;
+ };
+
+ return $worker;
+
+}
+
+our $EOF = "# end of file\n";
+sub worker_wait {
+ my ($self, $outdir) = @_;
+
+ my $ipc = $self->{ipc};
+ my $ipc_fd = fileno($ipc);
+
+ while (defined(my $file = $ipc->getline)) {
+ chomp $file;
+
+ exit unless $file;
+
+ die "tried to launch nonexistend testfile $file: $!\n"
+ unless -e $file;
+
+ # start a new and self contained process:
+ # whatever happens in the testfile should *NOT* effect us.
+
+ my $pid = fork // die "could not fork: $!";
+ if ($pid == 0) {
+ undef @complete_run::CLEANUP;
+ local $SIG{CHLD};
+
+ $0 = $file;
+
+ POSIX::dup2($ipc_fd, 0);
+ POSIX::dup2($ipc_fd, 1);
+ POSIX::dup2(1, 2);
+
+ # get Test::Builder singleton
+ my $test = Test::Builder->new;
+
+ # Test::Builder dups stdout/stderr while loading.
+ # we need to reset them here to point to $ipc
+ $test->output(\*STDOUT);
+ $test->failure_output(\*STDERR);
+ $test->todo_output(\*STDOUT);
+
+ @ENV{qw(DISPLAY TESTNAME OUTDIR VALGRIND STRACE COVERAGE)}
+ = ($self->{display}, basename($file), $outdir, 0, 0, 0);
+
+ package main;
+ local $@;
+ do "./$file";
+ $test->ok(undef, "$@") if $@;
+
+ # XXX hack, we need to trigger the read watcher once more
+ # to signal eof to TAP::Parser
+ print $EOF;
+
+ exit 0;
+ }
+ }
+}
+
+sub worker_next {
+ my ($self, $file) = @_;
+
+ my $ipc = $self->{ipc};
+ syswrite $ipc, "$file\n" or die "syswrite: $!";
+}
+
+__PACKAGE__ __END__
use X11::XCB::Window;
use X11::XCB qw(:all);
use AnyEvent::I3;
-use EV;
use List::Util qw(first);
use Time::HiRes qw(sleep);
use Cwd qw(abs_path);
+use Scalar::Util qw(blessed);
use SocketActivation;
use v5.10;
+# preload
+use Test::More ();
+use Data::Dumper ();
+
use Exporter ();
our @EXPORT = qw(
get_workspace_names
wait_for_event
wait_for_map
wait_for_unmap
+ $x
);
my $tester = Test::Builder->new();
my $_sync_window = undef;
my $tmp_socket_path = undef;
+our $x;
+
BEGIN {
my $window_count = 0;
sub counter_window {
}
}
+my $i3_pid;
+my $i3_autostart;
+
+END {
+
+ # testcases which start i3 manually should always call exit_gracefully
+ # on their own. Let’s see, whether they really did.
+ if (! $i3_autostart) {
+ return unless $i3_pid;
+
+ $tester->ok(undef, 'testcase called exit_gracefully()');
+ }
+
+ # don't trigger SIGCHLD handler
+ local $SIG{CHLD};
+
+ # From perldoc -v '$?':
+ # Inside an "END" subroutine $? contains the value
+ # that is going to be given to "exit()".
+ #
+ # Since waitpid sets $?, we need to localize it,
+ # otherwise TAP would be misinterpreted our return status
+ local $?;
+
+ # When measuring code coverage, try to exit i3 cleanly (otherwise, .gcda
+ # files are not written)
+ if ($ENV{COVERAGE} || $ENV{VALGRIND}) {
+ exit_gracefully($i3_pid, "/tmp/nested-$ENV{DISPLAY}");
+
+ } else {
+ kill(9, $i3_pid)
+ or $tester->BAIL_OUT("could not kill i3");
+
+ waitpid $i3_pid, 0;
+ }
+}
+
sub import {
- my $class = shift;
+ my ($class, %args) = @_;
my $pkg = caller;
- eval "package $pkg;
-use Test::Most" . (@_ > 0 ? " qw(@_)" : "") . ";
+
+ $i3_autostart = delete($args{i3_autostart}) // 1;
+
+ my $cv = launch_with_config('-default', dont_block => 1)
+ if $i3_autostart;
+
+ my $test_more_args = '';
+ $test_more_args = join(' ', 'qw(', %args, ')') if keys %args;
+ local $@;
+ eval << "__";
+package $pkg;
+use Test::More $test_more_args;
use Data::Dumper;
use AnyEvent::I3;
use Time::HiRes qw(sleep);
-use Test::Deep qw(eq_deeply cmp_deeply cmp_set cmp_bag cmp_methods useclass noclass set bag subbagof superbagof subsetof supersetof superhashof subhashof bool str arraylength Isa ignore methods regexprefonly regexpmatches num regexponly scalref reftype hashkeysonly blessed array re hash regexpref hash_each shallow array_each code arrayelementsonly arraylengthonly scalarrefonly listmethods any hashkeys isa);
-use v5.10;
-use strict;
-use warnings;
-";
+__
+ $tester->BAIL_OUT("$@") if $@;
+ feature->import(":5.10");
+ strict->import;
+ warnings->import;
+
+ $x ||= i3test::X11->new;
+ $cv->recv if $i3_autostart;
+
@_ = ($class);
goto \&Exporter::import;
}
# wait_for_event $x, 0.25, sub { $_[0]->{response_type} == MAP_NOTIFY };
#
sub wait_for_event {
- my ($x, $timeout, $cb) = @_;
+ my ($timeout, $cb) = @_;
my $cv = AE::cv;
- my $prep = EV::prepare sub {
- $x->flush;
- };
+ $x->flush;
- my $check = EV::check sub {
+ # unfortunately, there is no constant for this
+ my $ae_read = 0;
+
+ my $guard = AE::io $x->get_file_descriptor, $ae_read, sub {
while (defined(my $event = $x->poll_for_event)) {
if ($cb->($event)) {
$cv->send(1);
}
};
- my $watcher = EV::io $x->get_file_descriptor, EV::READ, sub {
- # do nothing, we only need this watcher so that EV picks up the events
- };
-
# Trigger timeout after $timeout seconds (can be fractional)
my $t = AE::timer $timeout, 0, sub { warn "timeout ($timeout secs)"; $cv->send(0) };
my $result = $cv->recv;
undef $t;
+ undef $guard;
return $result;
}
# thin wrapper around wait_for_event which waits for MAP_NOTIFY
# make sure to include 'structure_notify' in the window’s event_mask attribute
sub wait_for_map {
- my ($x) = @_;
- wait_for_event $x, 2, sub { $_[0]->{response_type} == MAP_NOTIFY };
+ my ($win) = @_;
+ my $id = (blessed($win) && $win->isa('X11::XCB::Window')) ? $win->id : $win;
+ wait_for_event 2, sub {
+ $_[0]->{response_type} == MAP_NOTIFY and $_[0]->{window} == $id
+ };
}
# Wrapper around wait_for_event which waits for UNMAP_NOTIFY. Also calls
# sync_with_i3 to make sure i3 also picked up and processed the UnmapNotify
# event.
sub wait_for_unmap {
- my ($x) = @_;
- wait_for_event $x, 2, sub { $_[0]->{response_type} == UNMAP_NOTIFY };
- sync_with_i3($x);
+ my ($win) = @_;
+ # my $id = (blessed($win) && $win->isa('X11::XCB::Window')) ? $win->id : $win;
+ wait_for_event 2, sub {
+ $_[0]->{response_type} == UNMAP_NOTIFY # and $_[0]->{window} == $id
+ };
+ sync_with_i3();
}
#
#
# set dont_map to a true value to avoid mapping
#
+# if you want to change aspects of your window before it would be mapped,
+# set before_map to a coderef. $window gets passed as $_ and as first argument.
+#
+# if you set both dont_map and before_map, the coderef will be called nevertheless
+#
+#
# default values:
# class => WINDOW_CLASS_INPUT_OUTPUT
# rect => [ 0, 0, 30, 30 ]
# name => 'Window <n>'
#
sub open_window {
- my ($x, $args) = @_;
- my %args = ($args ? %$args : ());
+ my %args = @_ == 1 ? %{$_[0]} : @_;
my $dont_map = delete $args{dont_map};
+ my $before_map = delete $args{before_map};
$args{class} //= WINDOW_CLASS_INPUT_OUTPUT;
$args{rect} //= [ 0, 0, 30, 30 ];
my $window = $x->root->create_child(%args);
+ if ($before_map) {
+ # TODO: investigate why _create is not needed
+ $window->_create;
+ $before_map->($window) for $window;
+ }
+
return $window if $dont_map;
$window->map;
- wait_for_map($x);
- # We sync with i3 here to make sure $x->input_focus is updated.
- sync_with_i3($x);
+ wait_for_map($window);
return $window;
}
# Thin wrapper around open_window which sets window_type to
# _NET_WM_WINDOW_TYPE_UTILITY to make the window floating.
sub open_floating_window {
- my ($x, $args) = @_;
- my %args = ($args ? %$args : ());
+ my %args = @_ == 1 ? %{$_[0]} : @_;
$args{window_type} = $x->atom(name => '_NET_WM_WINDOW_TYPE_UTILITY');
- return open_window($x, \%args);
+ return open_window(\%args);
}
sub open_empty_con {
# See also docs/testsuite for a long explanation
#
sub sync_with_i3 {
- my ($x) = @_;
-
# Since we need a (mapped) window for receiving a ClientMessage, we create
# one on the first call of sync_with_i3. It will be re-used in all
# subsequent calls.
if (!defined($_sync_window)) {
- $_sync_window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => X11::XCB::Rect->new(x => -15, y => -15, width => 10, height => 10 ),
+ $_sync_window = open_window(
+ rect => [ -15, -15, 10, 10 ],
override_redirect => 1,
- background_color => '#ff0000',
- event_mask => [ 'structure_notify' ],
);
-
- $_sync_window->map;
-
- wait_for_event $x, 2, sub { $_[0]->{response_type} == MAP_NOTIFY };
}
my $root = $x->get_root_window();
$x->send_event(0, $root, EVENT_MASK_SUBSTRUCTURE_REDIRECT, $msg);
# now wait until the reply is here
- return wait_for_event $x, 2, sub {
+ return wait_for_event 2, sub {
my ($event) = @_;
# TODO: const
return 0 unless $event->{response_type} == 161;
};
if (!$exited) {
- kill(9, $pid) or die "could not kill i3";
+ kill(9, $pid)
+ or $tester->BAIL_OUT("could not kill i3");
}
if ($socketpath =~ m,^/tmp/i3-test-socket-,) {
unlink($socketpath);
}
+
+ waitpid $pid, 0;
+ undef $i3_pid;
}
# Gets the socket path from the I3_SOCKET_PATH atom stored on the X11 root window
return $_cached_socket_path;
}
- my $x = X11::XCB::Connection->new;
my $atom = $x->atom(name => 'I3_SOCKET_PATH');
my $cookie = $x->get_property(0, $x->get_root_window(), $atom->id, GET_PROPERTY_TYPE_ANY, 0, 256);
my $reply = $x->get_property_reply($cookie->{sequence});
#
# launches a new i3 process with the given string as configuration file.
# useful for tests which test specific config file directives.
-#
-# be sure to use !NO_I3_INSTANCE! somewhere in the file to signal
-# complete-run.pl that it should not create an instance of i3
-#
sub launch_with_config {
- my ($config, $dont_add_socket_path) = @_;
+ my ($config, %args) = @_;
+
+ $tmp_socket_path = "/tmp/nested-$ENV{DISPLAY}";
- $dont_add_socket_path //= 0;
+ my ($fh, $tmpfile) = tempfile("i3-cfg-for-$ENV{TESTNAME}-XXXXX", UNLINK => 1);
- if (!defined($tmp_socket_path)) {
- $tmp_socket_path = File::Temp::tempnam('/tmp', 'i3-test-socket-');
+ if ($config ne '-default') {
+ say $fh $config;
+ } else {
+ open(my $conf_fh, '<', './i3-test.config')
+ or $tester->BAIL_OUT("could not open default config: $!");
+ local $/;
+ say $fh scalar <$conf_fh>;
}
- my ($fh, $tmpfile) = tempfile('i3-test-config-XXXXX', UNLINK => 1);
- say $fh $config;
- say $fh "ipc-socket $tmp_socket_path" unless $dont_add_socket_path;
+ say $fh "ipc-socket $tmp_socket_path"
+ unless $args{dont_add_socket_path};
+
close($fh);
my $cv = AnyEvent->condvar;
- my $pid = activate_i3(
+ $i3_pid = activate_i3(
unix_socket_path => "$tmp_socket_path-activation",
display => $ENV{DISPLAY},
configfile => $tmpfile,
outdir => $ENV{OUTDIR},
- logpath => $ENV{LOGPATH},
+ testname => $ENV{TESTNAME},
valgrind => $ENV{VALGRIND},
+ strace => $ENV{STRACE},
cv => $cv,
);
+ # force update of the cached socket path in lib/i3test
+ # as soon as i3 has started
+ $cv->cb(sub { get_socket_path(0) });
+
+ return $cv if $args{dont_block};
+
# blockingly wait until i3 is ready
$cv->recv;
- # force update of the cached socket path in lib/i3test
- get_socket_path(0);
+ return $i3_pid;
+}
+
+package i3test::X11;
+use parent 'X11::XCB::Connection';
+
+sub input_focus {
+ my $self = shift;
+ i3test::sync_with_i3();
- return $pid;
+ return $self->SUPER::input_focus(@_);
}
1
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
my $original_rect = X11::XCB::Rect->new(x => 0, y => 0, width => 30, height => 30);
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => $original_rect,
- background_color => '#C0C0C0',
-);
-
+my $window = open_window(rect => $original_rect, dont_map => 1);
isa_ok($window, 'X11::XCB::Window');
is_deeply($window->rect, $original_rect, "rect unmodified before mapping");
$window->map;
-
-sleep(0.25);
+wait_for_map $window;
my $new_rect = $window->rect;
-ok(!eq_deeply($new_rect, $original_rect), "Window got repositioned");
+ok(!eq_hash($new_rect, $original_rect), "Window got repositioned");
done_testing;
#
# checks if i3 supports I3_SYNC
#
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
use i3test;
-my $x = X11::XCB::Connection->new;
-
-my $result = sync_with_i3($x);
+my $result = sync_with_i3;
ok($result, 'syncing was successful');
done_testing;
use i3test;
-my $x = X11::XCB::Connection->new;
-
fresh_workspace;
#####################################################################
#####################################################################
# Create a window so we can get a focus different from NULL
-my $window = open_window($x);
+my $window = open_window;
my $focus = $x->input_focus;
# Switch to another workspace
fresh_workspace;
-sync_with_i3($x);
+sync_with_i3;
my $new_focus = $x->input_focus;
isnt($focus, $new_focus, "Focus changed");
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
my $original_rect = X11::XCB::Rect->new(x => 0, y => 0, width => 30, height => 30);
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
+my $window = open_window(
rect => $original_rect,
override_redirect => 1,
- background_color => '#C0C0C0',
+ dont_map => 1,
);
isa_ok($window, 'X11::XCB::Window');
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
# Create a floating window which is smaller than the minimum enforced size of i3
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30],
- background_color => '#C0C0C0',
- # replace the type with 'utility' as soon as the coercion works again in X11::XCB
- window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_UTILITY'),
- event_mask => [ 'structure_notify' ],
-);
+my $window = open_floating_window;
isa_ok($window, 'X11::XCB::Window');
-$window->map;
-
-wait_for_map $x;
-
my ($absolute, $top) = $window->rect;
ok($window->mapped, 'Window is mapped');
$window->unmap;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 1, 1, 80, 90],
- background_color => '#C0C0C0',
- window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_UTILITY'),
- event_mask => [ 'structure_notify' ],
-);
+$window = open_floating_window(rect => [ 1, 1, 80, 90 ]);
isa_ok($window, 'X11::XCB::Window');
-$window->map;
-
-wait_for_map $x;
-
($absolute, $top) = $window->rect;
cmp_ok($absolute->{width}, '==', 80, "i3 let the width at 80");
# at least the size of its initial geometry
#####################################################################
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 1, 1, 80, 90],
- background_color => '#C0C0C0',
- #window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_UTILITY'),
- event_mask => [ 'structure_notify' ],
-);
+$window = open_window(rect => [ 1, 1, 80, 90 ]);
isa_ok($window, 'X11::XCB::Window');
-$window->map;
-
-wait_for_map $x;
-
cmd 'floating enable';
+sync_with_i3;
($absolute, $top) = $window->rect;
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
use List::Util qw(first);
my $i3 = i3(get_socket_path());
}
}
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
-
##################################
# map a window, then fullscreen it
##################################
my $original_rect = X11::XCB::Rect->new(x => 0, y => 0, width => 30, height => 30);
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
+my $window = open_window(
rect => $original_rect,
- background_color => '#C0C0C0',
- event_mask => [ 'structure_notify' ],
+ dont_map => 1,
);
isa_ok($window, 'X11::XCB::Window');
$window->map;
-wait_for_map $x;
+wait_for_map $window;
# open another container to make the window get only half of the screen
cmd 'open';
my $new_rect = $window->rect;
-ok(!eq_deeply($new_rect, $original_rect), "Window got repositioned");
+ok(!eq_hash($new_rect, $original_rect), "Window got repositioned");
$original_rect = $new_rect;
$window->fullscreen(1);
-sync_with_i3($x);
+sync_with_i3;
$new_rect = $window->rect;
-ok(!eq_deeply($new_rect, $original_rect), "Window got repositioned after fullscreen");
+ok(!eq_hash($new_rect, $original_rect), "Window got repositioned after fullscreen");
my $orect = $output->{rect};
my $wrect = $new_rect;
cmd 'open';
$original_rect = X11::XCB::Rect->new(x => 0, y => 0, width => 30, height => 30);
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
+$window = open_window(
rect => $original_rect,
- background_color => 61440,
- event_mask => [ 'structure_notify' ],
+ dont_map => 1,
);
is_deeply($window->rect, $original_rect, "rect unmodified before mapping");
$window->fullscreen(1);
$window->map;
-wait_for_map $x;
+wait_for_map $window;
$new_rect = $window->rect;
-ok(!eq_deeply($new_rect, $original_rect), "Window got repositioned after fullscreen");
+ok(!eq_hash($new_rect, $original_rect), "Window got repositioned after fullscreen");
ok($window->mapped, "Window is mapped after opening it in fullscreen mode");
$wrect = $new_rect;
###############################################################################
$original_rect = X11::XCB::Rect->new(x => 0, y => 0, width => 30, height => 30);
-my $swindow = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
+my $swindow = open_window(
rect => $original_rect,
- background_color => '#C0C0C0',
- event_mask => [ 'structure_notify' ],
+ dont_map => 1,
);
$swindow->map;
-sync_with_i3($x);
+sync_with_i3;
ok(!$swindow->mapped, 'window not mapped while fullscreen window active');
$new_rect = $swindow->rect;
-ok(!eq_deeply($new_rect, $original_rect), "Window got repositioned");
+ok(!eq_hash($new_rect, $original_rect), "Window got repositioned");
$swindow->fullscreen(1);
-sync_with_i3($x);
+sync_with_i3;
is(fullscreen_windows(), 1, 'amount of fullscreen windows');
$window->fullscreen(0);
-sync_with_i3($x);
+sync_with_i3;
is(fullscreen_windows(), 0, 'amount of fullscreen windows');
ok($swindow->mapped, 'window mapped after other fullscreen ended');
###########################################################################
$swindow->fullscreen(0);
-sync_with_i3($x);
+sync_with_i3;
is(fullscreen_windows(), 0, 'amount of fullscreen windows after disabling');
use i3test;
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
#####################################################################
cmd 'layout default';
cmd 'split v';
-my $top = open_window($x);
-my $mid = open_window($x);
-my $bottom = open_window($x);
+my $top = open_window;
+my $mid = open_window;
+my $bottom = open_window;
#
# Returns the input focus after sending the given command to i3 via IPC
my $msg = shift;
cmd $msg;
- sync_with_i3 $x;
return $x->input_focus;
}
-$focus = $x->input_focus;
+my $focus = $x->input_focus;
is($focus, $bottom->id, "Latest window focused");
$focus = focus_after('focus up');
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
+use X11::XCB 'PROP_MODE_REPLACE';
use List::Util qw(first);
-BEGIN {
- use_ok('X11::XCB::Connection') or BAIL_OUT('Cannot load X11::XCB::Connection');
-}
-
-my $x = X11::XCB::Connection->new;
-
#####################################################################
# verify that there is no dock window yet
#####################################################################
my $primary = first { $_->primary } @{$screens};
# TODO: focus the primary screen before
-my $window = open_window($x, {
+my $window = open_window({
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
});
$window->rect(X11::XCB::Rect->new(x => 0, y => 0, width => 50, height => 40));
-sync_with_i3 $x;
+sync_with_i3;
@docked = get_dock_clients('top');
is(@docked, 1, 'one dock client found');
$window->destroy;
-wait_for_unmap $x;
+wait_for_unmap $window;
@docked = get_dock_clients();
is(@docked, 0, 'no more dock clients');
# check if it gets placed on bottom (by coordinates)
#####################################################################
-$window = open_window($x, {
+$window = open_window({
rect => [ 0, 1000, 30, 30 ],
background_color => '#FF0000',
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
});
-my $rect = $window->rect;
+$rect = $window->rect;
is($rect->width, $primary->rect->width, 'dock client is as wide as the screen');
is($rect->height, 30, 'height is unchanged');
$window->destroy;
-wait_for_unmap $x;
+wait_for_unmap $window;
@docked = get_dock_clients();
is(@docked, 0, 'no more dock clients');
# check if it gets placed on bottom (by hint)
#####################################################################
-$window = open_window($x, {
+$window = open_window({
dont_map => 1,
rect => [ 0, 1000, 30, 30 ],
background_color => '#FF0000',
$window->map;
-wait_for_map $x;
+wait_for_map $window;
@docked = get_dock_clients('top');
is(@docked, 1, 'dock client on top');
$window->destroy;
-wait_for_unmap $x;
+wait_for_unmap $window;
@docked = get_dock_clients();
is(@docked, 0, 'no more dock clients');
-$window = open_window($x, {
+$window = open_window({
dont_map => 1,
rect => [ 0, 1000, 30, 30 ],
background_color => '#FF0000',
$window->_create();
# Add a _NET_WM_STRUT_PARTIAL hint
-my $atomname = $x->atom(name => '_NET_WM_STRUT_PARTIAL');
-my $atomtype = $x->atom(name => 'CARDINAL');
+$atomname = $x->atom(name => '_NET_WM_STRUT_PARTIAL');
+$atomtype = $x->atom(name => 'CARDINAL');
$x->change_property(
PROP_MODE_REPLACE,
$window->map;
-wait_for_map $x;
+wait_for_map $window;
@docked = get_dock_clients('bottom');
is(@docked, 1, 'dock client on bottom');
# regression test: transient dock client
#####################################################################
-$fwindow = open_window($x, {
+my $fwindow = open_window({
dont_map => 1,
background_color => '#FF0000',
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
$fwindow->transient_for($window);
$fwindow->map;
-wait_for_map $x;
+wait_for_map $fwindow;
does_i3_live;
return $x->input_focus;
}
-$focus = $x->input_focus;
+my $focus = $x->input_focus;
is($focus, $bottom->id, "Latest window focused");
$focus = focus_after("ml");
use i3test;
-my $x = X11::XCB::Connection->new;
-
fresh_workspace;
cmd 'split h';
-my $tiled_left = open_window($x);
-my $tiled_right = open_window($x);
+my $tiled_left = open_window;
+my $tiled_right = open_window;
# Get input focus before creating the floating window
my $focus = $x->input_focus;
# Create a floating window which is smaller than the minimum enforced size of i3
-my $window = open_floating_window($x);
+my $window = open_floating_window;
is($x->input_focus, $window->id, 'floating window focused');
$window->unmap;
-wait_for_unmap($x);
+wait_for_unmap $window;
is($x->input_focus, $focus, 'Focus correctly restored');
return $x->input_focus;
}
-$focus = $x->input_focus;
+my $focus = $x->input_focus;
is($focus, $bottom->id, "Latest window focused");
$focus = focus_after("s");
use i3test;
use File::Temp;
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
cmd 'split h';
# Create two windows and make sure focus switching works
#####################################################################
-my $top = open_window($x);
-my $mid = open_window($x);
-my $bottom = open_window($x);
+my $top = open_window;
+my $mid = open_window;
+my $bottom = open_window;
#
# Returns the input focus after sending the given command to i3 via IPC
my $msg = shift;
cmd $msg;
- sync_with_i3($x);
return $x->input_focus;
}
-$focus = $x->input_focus;
+my $focus = $x->input_focus;
is($focus, $bottom->id, "Latest window focused");
$focus = focus_after('focus left');
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Connection') or BAIL_OUT('Cannot load X11::XCB::Connection');
-}
-
-my $x = X11::XCB::Connection->new;
fresh_workspace;
# Create a floating window and see if resizing works
#####################################################################
-my $window = open_floating_window($x);
+my $window = open_floating_window;
# See if configurerequests cause window movements (they should not)
my ($a, $t) = $window->rect;
$window->rect(X11::XCB::Rect->new(x => $a->x, y => $a->y, width => $a->width, height => $a->height));
-sync_with_i3($x);
+sync_with_i3;
my ($na, $nt) = $window->rect;
is_deeply($na, $a, 'Rects are equal after configurerequest');
sub test_resize {
$window->rect(X11::XCB::Rect->new(x => 0, y => 0, width => 100, height => 100));
- sync_with_i3($x);
+ sync_with_i3;
my ($absolute, $top) = $window->rect;
$window->rect(X11::XCB::Rect->new(x => 0, y => 0, width => 300, height => 500));
- sync_with_i3($x);
+ sync_with_i3;
($absolute, $top) = $window->rect;
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
use List::Util qw(first);
-BEGIN {
- use_ok('X11::XCB::Connection') or BAIL_OUT('Cannot load X11::XCB::Connection');
-}
-
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
#####################################################################
cmd 'split v';
-my $top = open_window($x);
-my $bottom = open_window($x);
+my $top = open_window;
+my $bottom = open_window;
my @urgent = grep { $_->{urgent} } @{get_ws_content($tmp)};
is(@urgent, 0, 'no window got the urgent flag');
# Add the urgency hint, switch to a different workspace and back again
#####################################################################
$top->add_hint('urgency');
-sync_with_i3($x);
+sync_with_i3;
-@content = @{get_ws_content($tmp)};
+my @content = @{get_ws_content($tmp)};
@urgent = grep { $_->{urgent} } @content;
-$top_info = first { $_->{window} == $top->id } @content;
-$bottom_info = first { $_->{window} == $bottom->id } @content;
+my $top_info = first { $_->{window} == $top->id } @content;
+my $bottom_info = first { $_->{window} == $bottom->id } @content;
ok($top_info->{urgent}, 'top window is marked urgent');
ok(!$bottom_info->{urgent}, 'bottom window is not marked urgent');
is(@urgent, 0, 'no window got the urgent flag after focusing');
$top->add_hint('urgency');
-sync_with_i3($x);
+sync_with_i3;
@urgent = grep { $_->{urgent} } @{get_ws_content($tmp)};
is(@urgent, 0, 'no window got the urgent flag after re-setting urgency hint');
my $otmp = fresh_workspace;
$top->add_hint('urgency');
-sync_with_i3($x);
+sync_with_i3;
$ws = get_ws($tmp);
ok($ws->{urgent}, 'urgent flag set on workspace');
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Connection') or BAIL_OUT('Cannot load X11::XCB::Connection');
-}
-
-my $x = X11::XCB::Connection->new;
my $tmp = fresh_workspace;
# one of both (depending on your screen resolution) will be positioned wrong.
####################################################################################
-my $left = open_window($x, { name => 'Left' });
-my $right = open_window($x, { name => 'Right' });
+my $left = open_window({ name => 'Left' });
+my $right = open_window({ name => 'Right' });
my ($abs, $rgeom) = $right->rect;
-my $child = open_floating_window($x, {
+my $child = open_floating_window({
dont_map => 1,
name => 'Child window',
});
$child->client_leader($right);
$child->map;
-ok(wait_for_map($x), 'child window mapped');
+ok(wait_for_map($child), 'child window mapped');
my $cgeom;
($abs, $cgeom) = $child->rect;
cmp_ok($cgeom->x, '>=', $rgeom->x, 'Child X >= right container X');
-my $child2 = open_floating_window($x, {
+my $child2 = open_floating_window({
dont_map => 1,
name => 'Child window 2',
});
$child2->client_leader($left);
$child2->map;
-ok(wait_for_map($x), 'second child window mapped');
+ok(wait_for_map($child2), 'second child window mapped');
($abs, $cgeom) = $child2->rect;
cmp_ok(($cgeom->x + $cgeom->width), '<', $rgeom->x, 'child above left window');
# check wm_transient_for
-my $fwindow = open_window($x, { dont_map => 1 });
+my $fwindow = open_window({ dont_map => 1 });
$fwindow->transient_for($right);
$fwindow->map;
-ok(wait_for_map($x), 'transient window mapped');
+ok(wait_for_map($fwindow), 'transient window mapped');
my ($absolute, $top) = $fwindow->rect;
ok($absolute->{x} != 0 && $absolute->{y} != 0, 'i3 did not map it to (0x0)');
# Create a parent window
#####################################################################
-my $window = open_window($x, { dont_map => 1, name => 'Parent window' });
+my $window = open_window({ dont_map => 1, name => 'Parent window' });
$window->map;
-ok(wait_for_map($x), 'parent window mapped');
+ok(wait_for_map($window), 'parent window mapped');
#########################################################################
# Switch to a different workspace and open a child window. It should be opened
#########################################################################
fresh_workspace;
-my $child = open_window($x, { dont_map => 1, name => 'Child window' });
+my $child = open_window({ dont_map => 1, name => 'Child window' });
$child->client_leader($window);
$child->map;
-ok(wait_for_map($x), 'child window mapped');
+ok(wait_for_map($child), 'child window mapped');
isnt($x->input_focus, $child->id, "Child window focused");
my $tree = $i3->get_tree->recv;
+# a unique value
+my $ignore = \"";
+
my $expected = {
fullscreen_mode => 0,
- nodes => ignore(),
+ nodes => $ignore,
window => undef,
name => 'root',
- orientation => ignore(),
+ orientation => $ignore,
type => 0,
- id => ignore(),
- rect => ignore(),
- window_rect => ignore(),
- geometry => ignore(),
- swallows => ignore(),
+ id => $ignore,
+ rect => $ignore,
+ window_rect => $ignore,
+ geometry => $ignore,
+ swallows => $ignore,
percent => undef,
layout => 'default',
- focus => ignore(),
+ focus => $ignore,
focused => JSON::XS::false,
urgent => JSON::XS::false,
border => 'normal',
- 'floating_nodes' => ignore(),
+ 'floating_nodes' => $ignore,
};
-cmp_deeply($tree, $expected, 'root node OK');
+# a shallow copy is sufficient, since we only ignore values at the root
+my $tree_copy = { %$tree };
+
+for (keys %$expected) {
+ my $val = $expected->{$_};
+
+ # delete unwanted keys, so we can use is_deeply()
+ if (ref($val) eq 'SCALAR' and $val == $ignore) {
+ delete $tree_copy->{$_};
+ delete $expected->{$_};
+ }
+}
+
+is_deeply($tree_copy, $expected, 'root node OK');
my @nodes = @{$tree->{nodes}};
is($ws->{num}, 3, 'workspace number is 3');
cmd "workspace 0: $tmp";
-my $ws = get_ws("0: $tmp");
+$ws = get_ws("0: $tmp");
ok(defined($ws), "workspace 0: $tmp was created");
is($ws->{num}, 0, 'workspace number is 0');
cmd "workspace aa: $tmp";
-my $ws = get_ws("aa: $tmp");
+$ws = get_ws("aa: $tmp");
ok(defined($ws), "workspace aa: $tmp was created");
is($ws->{num}, -1, 'workspace number is -1');
# Tests all kinds of matching methods
#
use i3test;
-use X11::XCB qw(:all);
+use X11::XCB qw(PROP_MODE_REPLACE);
my $tmp = fresh_workspace;
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
# Open a new window
-my $x = X11::XCB::Connection->new;
-my $window = open_window($x);
+my $window = open_window;
my $content = get_ws_content($tmp);
ok(@{$content} == 1, 'window mapped');
my $win = $content->[0];
my $id = $win->{id};
cmd qq|[con_id="$id"] kill|;
-wait_for_unmap $x;
+wait_for_unmap $window;
cmd 'nop checking if its gone';
$content = get_ws_content($tmp);
);
}
-my $left = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$left->_create;
-set_wm_class($left->id, 'special', 'special');
-$left->name('left');
-$left->map;
-ok(wait_for_map($x), 'left window mapped');
-
-my $right = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$right->_create;
-set_wm_class($right->id, 'special', 'special');
-$right->name('right');
-$right->map;
-ok(wait_for_map($x), 'right window mapped');
+sub open_special {
+ my %args = @_;
+ my $wm_class = delete($args{wm_class}) || 'special';
+
+ return open_window(
+ %args,
+ before_map => sub { set_wm_class($_->id, $wm_class, $wm_class) },
+ );
+}
+
+my $left = open_special(name => 'left');
+ok($left->mapped, 'left window mapped');
+
+my $right = open_special(name => 'right');
+ok($right->mapped, 'right window mapped');
# two windows should be here
$content = get_ws_content($tmp);
cmd '[class="special" title="left"] kill';
-sync_with_i3($x);
+sync_with_i3;
$content = get_ws_content($tmp);
is(@{$content}, 1, 'one window still there');
$tmp = fresh_workspace;
-$left = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$left->_create;
-set_wm_class($left->id, 'special7', 'special7');
-$left->name('left');
-$left->map;
-ok(wait_for_map($x), 'left window mapped');
+$left = open_special(name => 'left', wm_class => 'special7');
+ok($left->mapped, 'left window mapped');
# two windows should be here
$content = get_ws_content($tmp);
cmd '[class="^special[0-9]$"] kill';
-wait_for_unmap $x;
+wait_for_unmap $left;
$content = get_ws_content($tmp);
is(@{$content}, 0, 'window killed');
$tmp = fresh_workspace;
-$left = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$left->_create;
-set_wm_class($left->id, 'special7', 'special7');
-$left->name('ä 3');
-$left->map;
-ok(wait_for_map($x), 'left window mapped');
+$left = open_special(name => 'ä 3', wm_class => 'special7');
+ok($left->mapped, 'left window mapped');
# two windows should be here
$content = get_ws_content($tmp);
cmd '[title="^\w [3]$"] kill';
-wait_for_unmap $x;
+wait_for_unmap $left;
$content = get_ws_content($tmp);
is(@{$content}, 0, 'window killed');
# Tests splitting
#
use i3test;
-use X11::XCB qw(:all);
my $tmp = fresh_workspace;
# 4) move a container in a different direction so that we need to go up in tree
#
use i3test;
-use X11::XCB::Connection;
-my $x = X11::XCB::Connection->new;
my $i3 = i3(get_socket_path());
my $tmp = fresh_workspace;
######################################################################
$tmp = fresh_workspace;
-my $floatwin = open_floating_window($x);
+my $floatwin = open_floating_window;
my ($absolute_before, $top_before) = $floatwin->rect;
cmd 'move left';
my $floating = get_focused($tmp);
diag("focused floating: " . get_focused($tmp));
cmd 'mode toggle';
-# TODO: eliminate this race conditition
-sleep 1;
+sync_with_i3;
# kill old container
cmd qq|[con_id="$old"] focus|;
cmd qq|[con_id="$floating"] focus|;
is(get_focused($tmp), $floating, 'floating window focused');
-sleep 1;
+sync_with_i3;
cmd 'mode toggle';
does_i3_live;
cmd qq|[con_id="$first"] focus|;
cmd 'open';
-$content = get_ws_content($tmp);
+my $content = get_ws_content($tmp);
ok(@{$content} == 3, 'three containers opened');
is($content->[0]->{id}, $first, 'first container unmodified');
# Check if the focus is correctly restored after closing windows.
#
use i3test;
-use X11::XCB qw(:all);
use List::Util qw(first);
-my $x = X11::XCB::Connection->new;
-
my $i3 = i3(get_socket_path());
my $tmp = fresh_workspace;
##############################################################
cmd 'kill';
-# TODO: this testcase sometimes has different outcomes when the
-# sleep is missing. why?
-sleep 0.25;
+sync_with_i3;
+
($nodes, $focus) = get_ws_content($tmp);
is($nodes->[1]->{nodes}->[0]->{id}, $second, 'second container found');
ok($nodes->[1]->{nodes}->[0]->{focused}, 'second container focused');
$middle = open_empty_con($i3);
# XXX: the $right empty con will be filled with the x11 window we are creating afterwards
$right = open_empty_con($i3);
-my $win = open_window($x, { background_color => '#00ff00' });
+my $win = open_window({ background_color => '#00ff00' });
cmd qq|[con_id="$middle"] focus|;
$win->destroy;
-
-sleep 0.25;
+sync_with_i3;
is(get_focused($tmp), $middle, 'middle container focused');
cmd 'split v';
-($nodes, $focus) = get_ws_content($tmp);
+my ($nodes, $focus) = get_ws_content($tmp);
is($nodes->[0]->{focused}, 0, 'split container not focused');
my $split = $focus->[0];
cmd 'level down';
-my $second = open_empty_con($i3);
+$second = open_empty_con($i3);
isnt($first, $second, 'different container focused');
# focus the split container
cmd 'level up';
($nodes, $focus) = get_ws_content($tmp);
-my $split = $focus->[0];
+$split = $focus->[0];
cmd 'level down';
-my $second = open_empty_con($i3);
+$second = open_empty_con($i3);
isnt($first, $second, 'different container focused');
# We move the pointer out of our way to avoid a bug where the focus will
# be set to the window under the cursor
-my $x = X11::XCB::Connection->new;
$x->root->warp_pointer(0, 0);
my $tmp = get_unused_workspace();
#
use i3test;
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-my $win = open_window($x, { dont_map => 1 });
+my $win = open_window({ dont_map => 1 });
# XXX: we should check screen size. in screens with an AR of 2.0,
# this is not a good idea.
my $aspect = X11::XCB::Sizehints::Aspect->new;
$aspect->max_den(300);
$win->_create;
$win->map;
-wait_for_map $x;
+wait_for_map $win;
$win->hints->aspect($aspect);
$x->flush;
-sync_with_i3($x);
+sync_with_i3;
my $rect = $win->rect;
my $ar = $rect->width / $rect->height;
# vim:ts=4:sw=4:expandtab
use i3test;
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-
-my $x = X11::XCB::Connection->new;
my $tmp = fresh_workspace;
# 1: see if focus stays the same when toggling tiling/floating mode
#############################################################################
-my $first = open_window($x);
-my $second = open_window($x);
+my $first = open_window;
+my $second = open_window;
is($x->input_focus, $second->id, 'second window focused');
$tmp = fresh_workspace;
-$first = open_window($x); # window 2
-$second = open_window($x); # window 3
-my $third = open_window($x); # window 4
+$first = open_window; # window 2
+$second = open_window; # window 3
+my $third = open_window; # window 4
is($x->input_focus, $third->id, 'last container focused');
cmd '[id="' . $second->id . '"] focus';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'second con focused');
cmd 'floating enable';
# now kill the third one (it's floating). focus should stay unchanged
cmd '[id="' . $third->id . '"] kill';
-# TODO: wait for unmapnotify
-sync_with_i3($x);
+wait_for_unmap($third);
is($x->input_focus, $second->id, 'second con still focused after killing third');
$tmp = fresh_workspace;
-$first = open_window($x, { background_color => '#ff0000' }); # window 5
-$second = open_window($x, { background_color => '#00ff00' }); # window 6
-my $third = open_window($x, { background_color => '#0000ff' }); # window 7
+$first = open_window({ background_color => '#ff0000' }); # window 5
+$second = open_window({ background_color => '#00ff00' }); # window 6
+$third = open_window({ background_color => '#0000ff' }); # window 7
is($x->input_focus, $third->id, 'last container focused');
cmd '[id="' . $second->id . '"] focus';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'second con focused');
cmd 'floating enable';
# now kill the second one. focus should fall back to the third one, which is
# also floating
cmd 'kill';
-
-# TODO: wait for unmapnotify
-sync_with_i3($x);
+wait_for_unmap($second);
is($x->input_focus, $third->id, 'third con focused');
cmd 'kill';
-# TODO: wait for unmapnotify
-sync_with_i3($x);
+wait_for_unmap($third);
is($x->input_focus, $first->id, 'first con focused after killing all floating cons');
$tmp = fresh_workspace;
-$first = open_window($x, { background_color => '#ff0000' }); # window 5
+$first = open_window({ background_color => '#ff0000' }); # window 5
cmd 'split v';
cmd 'layout stacked';
-$second = open_window($x, { background_color => '#00ff00' }); # window 6
-$third = open_window($x, { background_color => '#0000ff' }); # window 7
+$second = open_window({ background_color => '#00ff00' }); # window 6
+$third = open_window({ background_color => '#0000ff' }); # window 7
is($x->input_focus, $third->id, 'last container focused');
cmd '[id="' . $second->id . '"] focus';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'second con focused');
cmd 'floating enable';
-sync_with_i3($x);
+sync_with_i3;
# now kill the second one. focus should fall back to the third one, which is
# also floating
cmd 'kill';
-
-# TODO: wait for unmapnotify
-sync_with_i3($x);
+wait_for_unmap($second);
is($x->input_focus, $third->id, 'third con focused');
cmd 'kill';
-# TODO: wait for unmapnotify
-sync_with_i3($x);
+wait_for_unmap($third);
is($x->input_focus, $first->id, 'first con focused after killing all floating cons');
$tmp = fresh_workspace;
-$first = open_window($x, { background_color => '#ff0000' }); # window 8
-$second = open_window($x, { background_color => '#00ff00' }); # window 9
-
-sync_with_i3($x);
+$first = open_window({ background_color => '#ff0000' }); # window 8
+$second = open_window({ background_color => '#00ff00' }); # window 9
is($x->input_focus, $second->id, 'second container focused');
cmd 'focus tiling';
-sync_with_i3($x);
-
is($x->input_focus, $first->id, 'first (tiling) container focused');
cmd 'focus floating';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'second (floating) container focused');
cmd 'focus floating';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'second (floating) container still focused');
cmd 'focus mode_toggle';
-sync_with_i3($x);
-
is($x->input_focus, $first->id, 'first (tiling) container focused');
cmd 'focus mode_toggle';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'second (floating) container focused');
#############################################################################
$tmp = fresh_workspace;
-$first = open_floating_window($x, { background_color => '#ff0000' });# window 10
-$second = open_floating_window($x, { background_color => '#00ff00' }); # window 11
-$third = open_floating_window($x, { background_color => '#0000ff' }); # window 12
-
-sync_with_i3($x);
+$first = open_floating_window({ background_color => '#ff0000' });# window 10
+$second = open_floating_window({ background_color => '#00ff00' }); # window 11
+$third = open_floating_window({ background_color => '#0000ff' }); # window 12
is($x->input_focus, $third->id, 'third container focused');
cmd 'focus left';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'second container focused');
cmd 'focus left';
-sync_with_i3($x);
-
is($x->input_focus, $first->id, 'first container focused');
cmd 'focus left';
-sync_with_i3($x);
-
is($x->input_focus, $third->id, 'focus wrapped to third container');
cmd 'focus right';
-sync_with_i3($x);
-
is($x->input_focus, $first->id, 'focus wrapped to first container');
cmd 'focus right';
-sync_with_i3($x);
-
is($x->input_focus, $second->id, 'focus on second container');
done_testing;
# Regression test: when only having a floating window on a workspace, it should not be deleted.
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
my $i3 = i3(get_socket_path());
ok(workspace_exists($tmp), "workspace $tmp exists");
-my $x = X11::XCB::Connection->new;
-
# Create a floating window which is smaller than the minimum enforced size of i3
-my $window = open_floating_window($x);
+my $window = open_floating_window;
ok($window->mapped, 'Window is mapped');
# switch to a different workspace, see if the window is still mapped?
# to a different workspace.
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
my $i3 = i3(get_socket_path());
# 1: open a floating window, get it mapped
#############################################################################
-my $x = X11::XCB::Connection->new;
-
# Create a floating window which is smaller than the minimum enforced size of i3
-my $window = open_floating_window($x);
+my $window = open_floating_window;
ok($window->mapped, 'Window is mapped');
# switch to a different workspace, see if the window is still mapped?
my $otmp = fresh_workspace;
-sync_with_i3($x);
+sync_with_i3;
ok(!$window->mapped, 'Window is not mapped after switching ws');
# if only a floating window is present on the workspace.
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
my $i3 = i3(get_socket_path());
# 1: open a floating window, get it mapped
#############################################################################
-my $x = X11::XCB::Connection->new;
-
# Create a floating window
-my $window = open_floating_window($x);
+my $window = open_floating_window;
ok($window->mapped, 'Window is mapped');
my $ws = get_ws($tmp);
is(@{$nodes}, 0, 'no tiling nodes');
# Create a tiling window
-my $twindow = open_window($x);
+my $twindow = open_window;
($nodes, $focus) = get_ws_content($tmp);
$tmp = fresh_workspace;
-my $first = open_window($x);
-my $second = open_window($x);
+my $first = open_window;
+my $second = open_window;
cmd 'layout stacked';
is(@{$ws->{nodes}}, 1, 'one tiling node (stacked con)');
# Create a floating window
-my $window = open_floating_window($x);
+$window = open_floating_window;
ok($window->mapped, 'Window is mapped');
$ws = get_ws($tmp);
is(@{$ws->{floating_nodes}}, 1, 'one floating nodes');
is(@{$ws->{nodes}}, 1, 'one tiling node (stacked con)');
-my $third = open_window($x);
+my $third = open_window;
$ws = get_ws($tmp);
# Check if numbered workspaces and named workspaces are sorted in the right way
# in get_workspaces IPC output (necessary for i3bar etc.).
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
my $i3 = i3(get_socket_path());
-my $x = X11::XCB::Connection->new;
sub check_order {
my ($msg) = @_;
my @nums = map { $_->{num} } grep { defined($_->{num}) } @ws;
my @sorted = sort @nums;
- cmp_deeply(\@nums, \@sorted, $msg);
+ is_deeply(\@nums, \@sorted, $msg);
}
check_order('workspace order alright before testing');
cmd "workspace 93";
-open_window($x);
+open_window;
my @ws = @{$i3->get_workspaces->recv};
my @f = grep { defined($_->{num}) && $_->{num} == 93 } @ws;
check_order('workspace order alright after opening 93');
cmd "workspace 92";
-open_window($x);
+open_window;
check_order('workspace order alright after opening 92');
cmd "workspace 94";
-open_window($x);
+open_window;
check_order('workspace order alright after opening 94');
cmd "workspace 96";
-open_window($x);
+open_window;
check_order('workspace order alright after opening 96');
cmd "workspace foo";
-open_window($x);
+open_window;
check_order('workspace order alright after opening foo');
cmd "workspace 91";
-open_window($x);
+open_window;
check_order('workspace order alright after opening 91');
done_testing;
# Regression: Check if the focus stays the same when switching the layout
# bug introduced by 77d0d42ed2d7ac8cafe267c92b35a81c1b9491eb
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
my $i3 = i3(get_socket_path());
-my $x = X11::XCB::Connection->new;
sub check_order {
my ($msg) = @_;
my @nums = map { $_->{num} } grep { defined($_->{num}) } @ws;
my @sorted = sort @nums;
- cmp_deeply(\@nums, \@sorted, $msg);
+ is_deeply(\@nums, \@sorted, $msg);
}
my $tmp = fresh_workspace;
-my $left = open_window($x);
-my $mid = open_window($x);
-my $right = open_window($x);
-
-sync_with_i3($x);
+my $left = open_window;
+my $mid = open_window;
+my $right = open_window;
diag("left = " . $left->id . ", mid = " . $mid->id . ", right = " . $right->id);
# vim:ts=4:sw=4:expandtab
# Tests resizing tiling containers
use i3test;
-use X11::XCB qw(:all);
-
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
my $tmp = fresh_workspace;
cmd 'split v';
-my $top = open_window($x);
-my $bottom = open_window($x);
-
-sync_with_i3($x);
+my $top = open_window;
+my $bottom = open_window;
diag("top = " . $top->id . ", bottom = " . $bottom->id);
cmd 'split v';
-$top = open_window($x);
-$bottom = open_window($x);
+$top = open_window;
+$bottom = open_window;
cmd 'split h';
cmd 'layout stacked';
$tmp = fresh_workspace;
-$top = open_window($x);
+$top = open_window;
cmd 'floating enable';
my $tmp = fresh_workspace;
-cmd 'exec /usr/bin/urxvt';
-sleep 0.5;
-cmd 'exec /usr/bin/urxvt';
-sleep 0.5;
+my $first = open_window;
+my $second = open_window;
+
my ($nodes, $focus) = get_ws_content($tmp);
my $old_sum = sum map { $_->{rect}->{width} } @{$nodes};
-#cmd 'open';
+
cmd 'resize grow left 10 px or 25 ppt';
cmd 'split v';
-#cmd 'open';
-cmd 'exec /usr/bin/urxvt';
-sleep 0.5;
+
+sync_with_i3;
+
+my $third = open_window;
+
cmd 'mode toggle';
-sleep 0.5;
-cmd 'kill';
+sync_with_i3;
-sleep 0.5;
+cmd 'kill';
+sync_with_i3;
($nodes, $focus) = get_ws_content($tmp);
my $new_sum = sum map { $_->{rect}->{width} } @{$nodes};
#
# This testcase checks that the tree is properly flattened after moving.
#
-use X11::XCB qw(:all);
use i3test;
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
-my $left = open_window($x);
-my $mid = open_window($x);
-my $right = open_window($x);
+my $left = open_window;
+my $mid = open_window;
+my $right = open_window;
-cmd 'move before v';
-cmd 'move after h';
+cmd 'move up';
+cmd 'move right';
my $ws = get_ws($tmp);
is($ws->{orientation}, 'horizontal', 'workspace orientation is horizontal');
#!perl
# vim:ts=4:sw=4:expandtab
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
-my $left = open_window($x);
-my $mid = open_window($x);
+my $left = open_window;
+my $mid = open_window;
cmd 'split v';
-my $bottom = open_window($x);
+my $bottom = open_window;
my ($nodes, $focus) = get_ws_content($tmp);
#############################################################################
# Create a floating window
-my $window = open_floating_window($x);
+my $window = open_floating_window;
ok($window->mapped, 'Window is mapped');
($nodes, $focus) = get_ws_content($tmp);
cmd 'floating toggle';
-my ($nodes, $focus) = get_ws_content($tmp);
+($nodes, $focus) = get_ws_content($tmp);
is(@{$nodes->[1]->{nodes}}, 3, 'three windows in split con after floating toggle');
# Regression test for moving a con outside of a floating con when there are no
# tiling cons on a workspace
#
-use X11::XCB qw(:all);
-use Time::HiRes qw(sleep);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
+sub sync_cmd {
+ cmd @_;
+ sync_with_i3;
}
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
-my $left = open_window($x);
-my $mid = open_window($x);
-my $right = open_window($x);
+my $left = open_window;
+my $mid = open_window;
+my $right = open_window;
# go to workspace level
-cmd 'level up';
-sleep 0.25;
+sync_cmd 'level up';
# make it floating
-cmd 'mode toggle';
-sleep 0.25;
+sync_cmd 'mode toggle';
# move the con outside the floating con
-cmd 'move before v';
-sleep 0.25;
+sync_cmd 'move up';
does_i3_live;
# move another con outside
-cmd '[id="' . $mid->id . '"] focus';
-cmd 'move before v';
-sleep 0.25;
+sync_cmd '[id="' . $mid->id . '"] focus';
+sync_cmd 'move up';
does_i3_live;
# Regression test for correct focus behaviour when moving a floating con to
# another workspace.
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
# open a tiling window on the first workspace
-open_window($x);
-#sleep 0.25;
+open_window;
my $first = get_focused($tmp);
# on a different ws, open a floating window
my $otmp = fresh_workspace;
-open_window($x);
-#sleep 0.25;
+open_window;
my $float = get_focused($otmp);
cmd 'mode toggle';
-#sleep 0.25;
+sync_with_i3;
# move the floating con to first workspace
cmd "move workspace $tmp";
-#sleep 0.25;
+sync_with_i3;
# switch to the first ws and check focus
is(get_focused($tmp), $float, 'floating client correctly focused');
#
# Regression test for inplace restarting with dock clients
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
#####################################################################
# open a dock client
-my $window = open_window($x, {
+my $window = open_window({
background_color => '#FF0000',
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
});
$window->destroy;
-wait_for_unmap $x;
+wait_for_unmap $window;
@docked = get_dock_clients;
is(@docked, 0, 'no dock clients found');
# create a dock client with a 1px border
#####################################################################
-$window = open_window($x, {
+$window = open_window({
border => 1,
rect => [ 0, 0, 30, 20 ],
background_color => '#00FF00',
#
# Test if the requested width/height is set after making the window floating.
#
-use X11::XCB qw(:all);
use i3test;
my $tmp = fresh_workspace;
-my $x = X11::XCB::Connection->new;
-
# Create a floating window which is smaller than the minimum enforced size of i3
-my $window = open_window($x, { rect => [ 0, 0, 400, 150 ] });
+my $window = open_window({ rect => [ 0, 0, 400, 150 ] });
my ($absolute, $top) = $window->rect;
cmp_ok($absolute->{height}, '>', 150, 'i3 raised the height');
cmd 'floating toggle';
-sync_with_i3($x);
+sync_with_i3;
($absolute, $top) = $window->rect;
#
# Regression test for closing one of multiple dock clients
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
#####################################################################
# open a dock client
#####################################################################
-my $first = open_window($x, {
+my $first = open_window({
background_color => '#FF0000',
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
});
# Open a second dock client
#####################################################################
-my $second = open_window($x, {
+my $second = open_window({
background_color => '#FF0000',
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
});
# Test to see if i3 combines the geometry of all children in a split container
# when setting the split container to floating
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
#####################################################################
# open a window with 200x80
#####################################################################
-my $first = open_window($x, {
+my $first = open_window({
rect => [ 0, 0, 200, 80],
background_color => '#FF0000',
});
# Open a second window with 300x90
#####################################################################
-my $second = open_window($x, {
+my $second = open_window({
rect => [ 0, 0, 300, 90],
background_color => '#00FF00',
});
# Test if new containers get focused when there is a fullscreen container at
# the time of launching the new one.
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
my $i3 = i3(get_socket_path());
my $tmp = fresh_workspace;
# open the left window
#####################################################################
-my $left = open_window($x, { background_color => '#ff0000' });
+my $left = open_window({ background_color => '#ff0000' });
is($x->input_focus, $left->id, 'left window focused');
# Open the right window
#####################################################################
-my $right = open_window($x, { background_color => '#00ff00' });
+my $right = open_window({ background_color => '#00ff00' });
diag("right = " . $right->id);
# Open a third window
#####################################################################
-my $third = open_window($x, {
+my $third = open_window({
background_color => '#0000ff',
name => 'Third window',
dont_map => 1,
$third->map;
-sync_with_i3 $x;
+sync_with_i3;
diag("third = " . $third->id);
cmd "move workspace $tmp2";
# verify that the third window has the focus
-
-sync_with_i3($x);
-
is($x->input_focus, $third->id, 'third window focused');
done_testing;
#
# Regression test: level up should be a noop during fullscreen mode
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
-
my $tmp = fresh_workspace;
#####################################################################
# open a window, verify it’s not in fullscreen mode
#####################################################################
-my $win = open_window($x);
+my $win = open_window;
my $nodes = get_ws_content $tmp;
is(@$nodes, 1, 'exactly one client');
cmd 'nop making fullscreen';
cmd 'fullscreen';
-my $nodes = get_ws_content $tmp;
+$nodes = get_ws_content $tmp;
is($nodes->[0]->{fullscreen_mode}, 1, 'client fullscreen now');
#####################################################################
cmd 'level up';
cmd 'fullscreen';
-my $nodes = get_ws_content $tmp;
+$nodes = get_ws_content $tmp;
is($nodes->[0]->{fullscreen_mode}, 0, 'client not fullscreen any longer');
does_i3_live;
#
# Tests if the WM_TAKE_FOCUS protocol is correctly handled by i3
#
-use X11::XCB qw(:all);
use i3test;
-use v5.10;
-
-my $x = X11::XCB::Connection->new;
subtest 'Window without WM_TAKE_FOCUS', sub {
fresh_workspace;
- my $window = open_window($x);
+ my $window = open_window;
- ok(!wait_for_event($x, 1, sub { $_[0]->{response_type} == 161 }), 'did not receive ClientMessage');
+ ok(!wait_for_event(1, sub { $_[0]->{response_type} == 161 }), 'did not receive ClientMessage');
done_testing;
};
my $take_focus = $x->atom(name => 'WM_TAKE_FOCUS');
- my $window = open_window($x, {
+ my $window = open_window({
dont_map => 1,
protocols => [ $take_focus ],
});
$window->map;
- ok(wait_for_event($x, 1, sub {
+ ok(wait_for_event(1, sub {
return 0 unless $_[0]->{response_type} == 161;
my ($data, $time) = unpack("L2", $_[0]->{data});
return ($data == $take_focus->id);
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Tests if the various ipc_socket_path options are correctly handled
#
-use i3test;
+use i3test i3_autostart => 0;
use File::Temp qw(tempfile tempdir);
use POSIX qw(getuid);
use v5.10;
# See which files exist in /tmp before to not mistakenly check an already
# existing tmpdir of another i3 instance.
my @files_before = </tmp/i3-*>;
-my $pid = launch_with_config($config, 1);
+my $pid = launch_with_config($config, dont_add_socket_path => 1);
my @files_after = </tmp/i3-*>;
@files_after = grep { !($_ ~~ @files_before) } @files_after;
$ENV{XDG_RUNTIME_DIR} = $rtdir;
-$pid = launch_with_config($config, 1);
+$pid = launch_with_config($config, dont_add_socket_path => 1);
ok(-d "$rtdir/i3", "$rtdir/i3 exists and is a directory");
$socketpath = "$rtdir/i3/ipc-socket." . $pid;
ipc-socket $socketpath
EOT
-$pid = launch_with_config($config, 1);
+$pid = launch_with_config($config, dont_add_socket_path => 1);
ok(-S $socketpath, "file $socketpath exists and is a socket");
# restart.
# found in eb8ad348b28e243cba1972e802ca8ee636472fc9
#
-use X11::XCB qw(:all);
use List::Util qw(first);
use i3test;
-my $x = X11::XCB::Connection->new;
my $i3 = i3(get_socket_path());
my $tmp = fresh_workspace;
-my $window = open_window($x);
+my $window = open_window;
sub get_border_style {
my @content = @{get_ws_content($tmp)};
# Regression test for setting the urgent hint on dock clients.
# found in 4be3178d4d360c2996217d811e61161c84d25898
#
-use X11::XCB qw(:all);
use i3test;
-BEGIN {
- use_ok('X11::XCB::Window');
-}
-
-my $x = X11::XCB::Connection->new;
my $i3 = i3(get_socket_path());
my $tmp = fresh_workspace;
# open a dock client
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30],
- background_color => '#FF0000',
+my $window = open_window(
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
);
-$window->map;
-
-sleep 0.25;
-
#####################################################################
# check that we can find it in the layout tree at the expected position
#####################################################################
$window->add_hint('urgency');
-sync_with_i3($x);
+sync_with_i3;
does_i3_live;
# Tests if WM_STATE is WM_STATE_NORMAL when mapped and WM_STATE_WITHDRAWN when
# unmapped.
#
-use X11::XCB qw(:all);
use i3test;
+use X11::XCB qw(ICCCM_WM_STATE_NORMAL ICCCM_WM_STATE_WITHDRAWN);
-my $x = X11::XCB::Connection->new;
-
-my $window = open_window($x);
-
-sync_with_i3($x);
+my $window = open_window;
is($window->state, ICCCM_WM_STATE_NORMAL, 'WM_STATE normal');
$window->unmap;
-wait_for_unmap $x;
+wait_for_unmap $window;
is($window->state, ICCCM_WM_STATE_WITHDRAWN, 'WM_STATE withdrawn');
#
use i3test;
-my $x = X11::XCB::Connection->new;
-
sub two_windows {
my $tmp = fresh_workspace;
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
- my $first = open_window($x);
- my $second = open_window($x);
-
- sync_with_i3 $x;
+ my $first = open_window;
+ my $second = open_window;
is($x->input_focus, $second->id, 'second window focused');
ok(@{get_ws_content($tmp)} == 2, 'two containers opened');
# 'kill window'
##############################################################
-my $tmp = two_windows;
+$tmp = two_windows;
cmd 'kill window';
# and check if both are gone
##############################################################
-my $tmp = two_windows;
+$tmp = two_windows;
cmd 'kill client';
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
-#
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-use i3test;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
+use X11::XCB qw(PROP_MODE_REPLACE);
##############################################################
# 1: test the following directive:
my $tmp = fresh_workspace;
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->name('Border window');
-$window->map;
-wait_for_map $x;
+my $window = open_window(name => 'Border window');
my @content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'normal', 'normal border');
$window->unmap;
-wait_for_unmap $x;
+wait_for_unmap $window;
-my @content = @{get_ws_content($tmp)};
+@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 0, 'no more nodes');
diag('content = '. Dumper(\@content));
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->_create;
# TODO: move this to X11::XCB::Window
sub set_wm_class {
);
}
-set_wm_class($window->id, 'borderless', 'borderless');
-$window->name('Borderless window');
-$window->map;
-wait_for_map $x;
+$window = open_window(
+ name => 'Borderless window',
+ before_map => sub { set_wm_class($_->id, 'borderless', 'borderless') },
+);
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'none', 'no border');
$window->unmap;
-wait_for_unmap $x;
+wait_for_unmap $window;
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 0, 'no more nodes');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->name('special title');
-$window->map;
-wait_for_map $x;
+$window = open_window(name => 'special title');
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'normal', 'normal border');
$window->name('special borderless title');
-sync_with_i3 $x;
+sync_with_i3;
@content = @{get_ws_content($tmp)};
is($content[0]->{border}, 'none', 'no border');
$window->name('special title');
-sync_with_i3 $x;
+sync_with_i3;
cmd 'border normal';
is($content[0]->{border}, 'normal', 'border reset to normal');
$window->name('special borderless title');
-sync_with_i3 $x;
+sync_with_i3;
@content = @{get_ws_content($tmp)};
is($content[0]->{border}, 'normal', 'still normal border');
$window->unmap;
-wait_for_unmap $x;
+wait_for_unmap $window;
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 0, 'no more nodes');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->name('special mark title');
-$window->map;
-wait_for_map $x;
+$window = open_window(name => 'special mark title');
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'none', 'no border');
-my $other = open_window($x);
+my $other = open_window;
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 2, 'two nodes');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
+$window = open_window(
+ name => 'usethis',
+ before_map => sub { set_wm_class($_->id, 'borderless', 'borderless') },
);
-$window->_create;
-
-set_wm_class($window->id, 'borderless', 'borderless');
-$window->name('usethis');
-$window->map;
-wait_for_map $x;
-
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'none', 'no border');
cmd 'kill';
-wait_for_unmap $x;
+wait_for_unmap $window;
$window->destroy;
+# give i3 a chance to delete the window from its tree
+sync_with_i3;
+
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 0, 'no nodes on this workspace now');
set_wm_class($window->id, 'borderless', 'borderless');
$window->name('notthis');
$window->map;
-wait_for_map $x;
+wait_for_map $window;
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
-);
-$window->_create;
-
-set_wm_class($window->id, 'bar', 'foo');
-$window->name('usethis');
-$window->map;
-wait_for_map $x;
+$window = open_window(
+ name => 'usethis',
+ before_map => sub { set_wm_class($_->id, 'bar', 'foo') },
+);
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
+$window = open_window(
+ name => 'usethis',
+ before_map => sub { set_wm_class($_->id, 'bar', 'foo') },
);
-$window->_create;
-
-set_wm_class($window->id, 'bar', 'foo');
-$window->name('usethis');
-$window->map;
-wait_for_map $x;
-
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'none', 'no border');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
+$window = open_window(
+ name => 'usethis',
+ before_map => sub { set_wm_class($_->id, 'bar', 'foo') },
);
-$window->_create;
-
-set_wm_class($window->id, 'bar', 'foo');
-$window->name('usethis');
-$window->map;
-wait_for_map $x;
-
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'normal', 'normal border');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
+$window = open_window(
+ name => 'usethis',
+ before_map => sub {
+ my ($window) = @_;
+ my $atomname = $x->atom(name => 'WM_WINDOW_ROLE');
+ my $atomtype = $x->atom(name => 'STRING');
+ $x->change_property(
+ PROP_MODE_REPLACE,
+ $window->id,
+ $atomname->id,
+ $atomtype->id,
+ 8,
+ length("i3test") + 1,
+ "i3test\x00"
+ );
+ },
);
-$window->_create;
-
-my $atomname = $x->atom(name => 'WM_WINDOW_ROLE');
-my $atomtype = $x->atom(name => 'STRING');
-$x->change_property(
- PROP_MODE_REPLACE,
- $window->id,
- $atomname->id,
- $atomtype->id,
- 8,
- length("i3test") + 1,
- "i3test\x00"
-);
-
-$window->name('usethis');
-$window->map;
-wait_for_map $x;
-
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'none', 'no border (window_role)');
$tmp = fresh_workspace;
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#00ff00',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->_create;
-
-$window->name('usethis');
-$window->map;
-wait_for_map $x;
+$window = open_window(name => 'usethis');
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
is($content[0]->{border}, 'normal', 'normal border (window_role 2)');
-$atomname = $x->atom(name => 'WM_WINDOW_ROLE');
-$atomtype = $x->atom(name => 'STRING');
+my $atomname = $x->atom(name => 'WM_WINDOW_ROLE');
+my $atomtype = $x->atom(name => 'STRING');
$x->change_property(
PROP_MODE_REPLACE,
$window->id,
$x->flush;
-sync_with_i3 $x;
+sync_with_i3;
@content = @{get_ws_content($tmp)};
cmp_ok(@content, '==', 1, 'one node on this workspace now');
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Tests if assignments work
#
-use i3test;
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-use v5.10;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
+use X11::XCB qw(PROP_MODE_REPLACE);
# TODO: move to X11::XCB
sub set_wm_class {
);
}
+sub open_special {
+ my %args = @_;
+ my $wm_class = delete($args{wm_class}) || 'special';
+ $args{name} //= 'special window';
+
+ return open_window(
+ %args,
+ before_map => sub { set_wm_class($_->id, $wm_class, $wm_class) },
+ );
+}
#####################################################################
# start a window and see that it does not get assigned with an empty config
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->_create;
-set_wm_class($window->id, 'special', 'special');
-$window->name('special window');
-$window->map;
-wait_for_map $x;
+my $window = open_special;
ok(@{get_ws_content($tmp)} == 1, 'special window got managed to current (random) workspace');
my $workspaces = get_workspace_names;
ok(!("targetws" ~~ @{$workspaces}), 'targetws does not exist yet');
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->_create;
-set_wm_class($window->id, 'special', 'special');
-$window->name('special window');
-$window->map;
-wait_for_map $x;
+$window = open_special;
ok(@{get_ws_content($tmp)} == 0, 'still no containers');
ok("targetws" ~~ @{get_workspace_names()}, 'targetws exists');
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
ok("targetws" ~~ @{get_workspace_names()}, 'targetws does not exist yet');
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->_create;
-set_wm_class($window->id, 'special', 'special');
-$window->name('special window');
-$window->map;
# We use sync_with_i3 instead of wait_for_map here because i3 will not actually
# map the window -- it will be assigned to a different workspace and will only
# be mapped once you switch to that workspace
-sync_with_i3 $x;
+$window = open_special(dont_map => 1);
+$window->map;
+sync_with_i3;
ok(@{get_ws_content($tmp)} == 0, 'still no containers');
ok(@{get_ws_content('targetws')} == 2, 'two containers on targetws');
$tmp = fresh_workspace;
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-my $workspaces = get_workspace_names;
+$workspaces = get_workspace_names;
ok(!("targetws" ~~ @{$workspaces}), 'targetws does not exist yet');
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->_create;
-set_wm_class($window->id, 'special', 'special');
-$window->name('special window');
-$window->map;
-wait_for_map $x;
+$window = open_special;
my $content = get_ws($tmp);
ok(@{$content->{nodes}} == 0, 'no tiling cons');
$tmp = fresh_workspace;
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-my $workspaces = get_workspace_names;
+$workspaces = get_workspace_names;
ok(!("targetws" ~~ @{$workspaces}), 'targetws does not exist yet');
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
- event_mask => [ 'structure_notify' ],
-);
-
-$window->_create;
-set_wm_class($window->id, 'SPEcial', 'SPEcial');
-$window->name('special window');
-$window->map;
-wait_for_map $x;
+$window = open_special(wm_class => 'SPEcial');
-my $content = get_ws($tmp);
+$content = get_ws($tmp);
ok(@{$content->{nodes}} == 0, 'no tiling cons');
ok(@{$content->{floating_nodes}} == 1, 'one floating con');
# syntax
is(@docked, 1, 'one dock client yet');
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
+$window = open_special(
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_DOCK'),
- event_mask => [ 'structure_notify' ],
);
-$window->_create;
-set_wm_class($window->id, 'special', 'special');
-$window->name('special window');
-$window->map;
-wait_for_map $x;
-
-my $content = get_ws($tmp);
+$content = get_ws($tmp);
ok(@{$content->{nodes}} == 0, 'no tiling cons');
ok(@{$content->{floating_nodes}} == 0, 'one floating con');
@docked = get_dock_clients;
exit_gracefully($pid);
-sleep 0.25;
-
done_testing;
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Tests the workspace_layout config option.
#
-use i3test;
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
#####################################################################
# 1: check that with an empty config, cons are place next to each
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-my $first = open_window($x);
-my $second = open_window($x);
-
-sync_with_i3($x);
+my $first = open_window;
+my $second = open_window;
is($x->input_focus, $second->id, 'second window focused');
-ok(@{get_ws_content($tmp)} == 2, 'two containers opened');
+my @content = @{get_ws_content($tmp)};
+ok(@content == 2, 'two containers opened');
isnt($content[0]->{layout}, 'stacked', 'layout not stacked');
isnt($content[1]->{layout}, 'stacked', 'layout not stacked');
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-$first = open_window($x);
-$second = open_window($x);
-
-sync_with_i3($x);
+$first = open_window;
+$second = open_window;
is($x->input_focus, $second->id, 'second window focused');
-my @content = @{get_ws_content($tmp)};
+@content = @{get_ws_content($tmp)};
ok(@content == 1, 'one con at workspace level');
is($content[0]->{layout}, 'stacked', 'layout stacked');
#####################################################################
cmd 'focus parent';
-my $right_top = open_window($x);
-my $right_bot = open_window($x);
+my $right_top = open_window;
+my $right_bot = open_window;
@content = @{get_ws_content($tmp)};
is(@content, 2, 'two cons at workspace level after focus parent');
# Verifies that i3 survives inplace restarts with fullscreen containers
#
use i3test;
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-
-my $x = X11::XCB::Connection->new;
fresh_workspace;
-open_window($x);
-open_window($x);
+open_window;
+open_window;
cmd 'layout stacking';
-sleep 1;
+sync_with_i3;
cmd 'fullscreen';
-sleep 1;
+sync_with_i3;
cmd 'restart';
sleep 1;
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Tests if the 'force_focus_wrapping' config directive works correctly.
#
-use i3test;
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
#####################################################################
# 1: test the wrapping behaviour without force_focus_wrapping
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-my $first = open_window($x);
-my $second = open_window($x);
+my $first = open_window;
+my $second = open_window;
cmd 'layout tabbed';
cmd 'focus parent';
-my $third = open_window($x);
+my $third = open_window;
is($x->input_focus, $third->id, 'third window focused');
cmd 'focus left';
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-$first = open_window($x);
-$second = open_window($x);
+$first = open_window;
+$second = open_window;
cmd 'layout tabbed';
cmd 'focus parent';
-$third = open_window($x);
-
-sync_with_i3($x);
+$third = open_window;
is($x->input_focus, $third->id, 'third window focused');
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Tests if i3-migrate-config-to-v4 correctly migrates all config file
# directives and commands
#
-use i3test;
+use i3test i3_autostart => 0;
use Cwd qw(abs_path);
use File::Temp qw(tempfile tempdir);
use v5.10;
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
-#
# checks if i3 starts up on workspace '1' or the first configured named workspace
#
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-use i3test;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
##############################################################
# 1: i3 should start with workspace '1'
my $pid = launch_with_config($config);
my @names = @{get_workspace_names()};
-cmp_deeply(\@names, [ '1' ], 'i3 starts on workspace 1 without any configuration');
+is_deeply(\@names, [ '1' ], 'i3 starts on workspace 1 without any configuration');
exit_gracefully($pid);
$pid = launch_with_config($config);
-my @names = @{get_workspace_names()};
-cmp_deeply(\@names, [ 'foobar' ], 'i3 starts on named workspace foobar');
+@names = @{get_workspace_names()};
+is_deeply(\@names, [ 'foobar' ], 'i3 starts on named workspace foobar');
exit_gracefully($pid);
$pid = launch_with_config($config);
-my @names = @{get_workspace_names()};
-cmp_deeply(\@names, [ 'foobar' ], 'i3 starts on named workspace foobar');
+@names = @{get_workspace_names()};
+is_deeply(\@names, [ 'foobar' ], 'i3 starts on named workspace foobar');
exit_gracefully($pid);
my $tmp = fresh_workspace;
my $marks = get_marks();
-cmp_deeply($marks, [], 'no marks set so far');
+is_deeply($marks, [], 'no marks set so far');
##############################################################
# 2: check that setting a mark is reflected in the get_marks reply
cmd 'open';
cmd 'mark foo';
-cmp_deeply(get_marks(), [ 'foo' ], 'mark foo set');
+is_deeply(get_marks(), [ 'foo' ], 'mark foo set');
##############################################################
# 3: check that the mark is gone after killing the container
cmd 'kill';
-cmp_deeply(get_marks(), [ ], 'mark gone');
+is_deeply(get_marks(), [ ], 'mark gone');
done_testing;
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Regression: Checks if focus is stolen when a window is managed which is
# assigned to an invisible workspace
#
-use i3test;
-use X11::XCB qw(:all);
-use X11::XCB::Connection;
-use v5.10;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
+use X11::XCB qw(PROP_MODE_REPLACE);
# TODO: move to X11::XCB
sub set_wm_class {
);
}
+sub open_special {
+ my %args = @_;
+ my $wm_class = delete($args{wm_class}) || 'special';
+ $args{name} //= 'special window';
+
+ return open_window(
+ %args,
+ before_map => sub { set_wm_class($_->id, $wm_class, $wm_class) },
+ );
+}
#####################################################################
# start a window and see that it does not get assigned with an empty config
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
ok(get_ws($tmp)->{focused}, 'current workspace focused');
-my $window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
-);
-
-$window->_create;
-set_wm_class($window->id, 'special', 'special');
-$window->name('special window');
-$window->map;
-sleep 0.25;
-
+my $window = open_special;
ok(@{get_ws_content($tmp)} == 0, 'special window not on current workspace');
ok(@{get_ws_content('targetws')} == 1, 'special window on targetws');
# the same test, but with a floating window
#####################################################################
-$window = $x->root->create_child(
- class => WINDOW_CLASS_INPUT_OUTPUT,
- rect => [ 0, 0, 30, 30 ],
- background_color => '#0000ff',
+$window = open_special(
window_type => $x->atom(name => '_NET_WM_WINDOW_TYPE_UTILITY'),
);
-$window->_create;
-set_wm_class($window->id, 'special', 'special');
-$window->name('special window');
-$window->map;
-sleep 0.25;
-
-
ok(@{get_ws_content($tmp)} == 0, 'special window not on current workspace');
ok(@{get_ws_content('targetws')} == 1, 'special window on targetws');
ok(get_ws($tmp)->{focused}, 'current workspace still focused');
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Tests the new_window and new_float config option.
#
-use i3test;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
#####################################################################
# 1: check that new windows start with 'normal' border unless configured
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-my $first = open_window($x);
+my $first = open_window;
my @content = @{get_ws_content($tmp)};
ok(@content == 1, 'one container opened');
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-$first = open_window($x);
+$first = open_window;
@content = @{get_ws_content($tmp)};
ok(@content == 1, 'one container opened');
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-$first = open_floating_window($x);
+$first = open_floating_window;
my $wscontent = get_ws($tmp);
my @floating = @{$wscontent->{floating_nodes}};
ok(@{get_ws_content($tmp)} == 0, 'no containers yet');
-$first = open_floating_window($x);
+$first = open_floating_window;
$wscontent = get_ws($tmp);
@floating = @{$wscontent->{floating_nodes}};
use POSIX qw(mkfifo);
use File::Temp qw(:POSIX);
-my $x = X11::XCB::Connection->new;
use ExtUtils::PkgConfig;
# setup dependency on libstartup-notification using pkg-config
is(@{get_ws_content($second_ws)}, 0, 'no containers on the second workspace yet');
-my $win = open_window($x, { dont_map => 1 });
+my $win = open_window({ dont_map => 1 });
mark_window($win->id);
$win->map;
# We don’t use wait_for_map because the window will not get mapped -- it is on
# a different workspace.
# We sync with i3 here to make sure $x->input_focus is updated.
-sync_with_i3($x);
+sync_with_i3;
is(@{get_ws_content($second_ws)}, 0, 'still no containers on the second workspace');
is(@{get_ws_content($first_ws)}, 1, 'one container on the first workspace');
# same thing, but with _NET_STARTUP_ID set on the leader
######################################################################
-my $leader = open_window($x, { dont_map => 1 });
+my $leader = open_window({ dont_map => 1 });
mark_window($leader->id);
-$win = open_window($x, { dont_map => 1, client_leader => $leader });
+$win = open_window({ dont_map => 1, client_leader => $leader });
$win->map;
-sync_with_i3($x);
+sync_with_i3;
is(@{get_ws_content($second_ws)}, 0, 'still no containers on the second workspace');
is(@{get_ws_content($first_ws)}, 2, 'two containers on the first workspace');
######################################################################
complete_startup();
-sync_with_i3($x);
+sync_with_i3;
-my $otherwin = open_window($x);
+my $otherwin = open_window;
is(@{get_ws_content($second_ws)}, 1, 'one container on the second workspace');
######################################################################
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
-#
# Checks if the 'workspace back_and_forth' command and the
# 'workspace_auto_back_and_forth' config directive work correctly.
#
-use i3test;
-use X11::XCB::Connection;
-
-my $x = X11::XCB::Connection->new;
+use i3test i3_autostart => 0;
my $config = <<EOT;
# i3 config file (v4)
#!perl
# vim:ts=4:sw=4:expandtab
-# !NO_I3_INSTANCE! will prevent complete-run.pl from starting i3
#
# Checks that the bar config is parsed correctly.
#
-use i3test;
+use i3test i3_autostart => 0;
#####################################################################
# test a config without any bars
--- /dev/null
+#!perl
+# vim:ts=4:sw=4:expandtab
+#
+# Verifies that i3 does not leak any file descriptors in 'exec'.
+#
+use i3test;
+use POSIX qw(mkfifo);
+use File::Temp qw(:POSIX tempfile);
+
+my $i3 = i3(get_socket_path());
+
+my $tmp = tmpnam();
+mkfifo($tmp, 0600) or die "Could not create FIFO in $tmp";
+my ($outfh, $outname) = tempfile('/tmp/i3-ls-output.XXXXXX', UNLINK => 1);
+
+cmd qq|exec ls -l /proc/self/fd >$outname && echo done >$tmp|;
+
+open(my $fh, '<', $tmp);
+# Block on the FIFO, this will return exactly when the command is done.
+<$fh>;
+close($fh);
+unlink($tmp);
+
+# Get the ls /proc/self/fd output
+my $output;
+{
+ local $/;
+ $output = <$outfh>;
+}
+close($outfh);
+
+# Split lines, keep only those which are symlinks.
+my @lines = grep { /->/ } split("\n", $output);
+
+my %fds = map { /([0-9]+) -> (.+)$/; ($1, $2) } @lines;
+
+# Filter out 0, 1, 2 (stdin, stdout, stderr).
+delete $fds{0};
+delete $fds{1};
+delete $fds{2};
+
+# Filter out the fd which is caused by ls calling readdir().
+for my $fd (keys %fds) {
+ delete $fds{$fd} if $fds{$fd} =~ m,^/proc/\d+/fd$,;
+}
+
+is(scalar keys %fds, 0, 'No file descriptors leaked');
+
+done_testing;
--- /dev/null
+#!perl
+# vim:ts=4:sw=4:expandtab
+#
+# Regression test: Changing border style should not have an impact on the size
+# (geometry) of the child window. See ticket http://bugs.i3wm.org/561
+# Wrong behaviour manifested itself up to (including) commit
+# d805d1bbeaf89e11f67c981f94c9f55bbb4b89d9
+#
+use i3test;
+use Data::Dumper;
+
+fresh_workspace;
+
+my $win = open_floating_window(rect => [10, 10, 200, 100]);
+
+my $geometry = $win->rect;
+is($geometry->{width}, 200, 'width correct');
+is($geometry->{height}, 100, 'height correct');
+
+cmd 'border 1pixel';
+
+$geometry = $win->rect;
+is($geometry->{width}, 200, 'width correct');
+is($geometry->{height}, 100, 'height correct');
+
+done_testing;
--- /dev/null
+#!perl
+# vim:ts=4:sw=4:expandtab
+#
+# Checks that variables are parsed correctly by using for_window rules with
+# variables in it.
+#
+
+use i3test i3_autostart => 0;
+
+# starts i3 with the given config, opens a window, returns its border style
+sub launch_get_border {
+ my ($config) = @_;
+
+ my $pid = launch_with_config($config);
+
+ my $i3 = i3(get_socket_path(0));
+ my $tmp = fresh_workspace;
+
+ my $window = open_window(name => 'special title');
+
+ my @content = @{get_ws_content($tmp)};
+ cmp_ok(@content, '==', 1, 'one node on this workspace now');
+ my $border = $content[0]->{border};
+
+ exit_gracefully($pid);
+
+ return $border;
+}
+
+#####################################################################
+# test thet windows get the default border
+#####################################################################
+
+my $config = <<EOT;
+# i3 config file (v4)
+font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+EOT
+
+is(launch_get_border($config), 'normal', 'normal border');
+
+#####################################################################
+# now use a variable and for_window
+#####################################################################
+
+$config = <<'EOT';
+# i3 config file (v4)
+font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+
+set $vartest special title
+for_window [title="$vartest"] border none
+EOT
+
+is(launch_get_border($config), 'none', 'no border');
+
+#####################################################################
+# check that whitespaces and tabs are ignored
+#####################################################################
+
+$config = <<'EOT';
+# i3 config file (v4)
+font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+
+set $vartest special title
+for_window [title="$vartest"] border none
+EOT
+
+is(launch_get_border($config), 'none', 'no border');
+
+
+
+done_testing;
+
projects / i3 / i3 / commitdiff