2009-02-13 20:33:31 -05:00
|
|
|
|
/*
|
2010-04-13 11:52:23 -04:00
|
|
|
|
* vim:ts=4:sw=4:expandtab
|
2009-02-13 20:33:31 -05:00
|
|
|
|
*
|
|
|
|
|
* i3 - an improved dynamic tiling window manager
|
2012-01-18 14:16:57 -05:00
|
|
|
|
* © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
|
2009-02-13 20:33:31 -05:00
|
|
|
|
*
|
2009-02-24 08:18:08 -05:00
|
|
|
|
* include/data.h: This file defines all data structures used by i3
|
|
|
|
|
*
|
2009-02-13 20:33:31 -05:00
|
|
|
|
*/
|
2012-09-21 09:36:25 -04:00
|
|
|
|
#ifndef I3_DATA_H
|
|
|
|
|
#define I3_DATA_H
|
2011-10-10 10:21:08 -04:00
|
|
|
|
|
2011-10-10 10:30:07 -04:00
|
|
|
|
#define SN_API_NOT_YET_FROZEN 1
|
|
|
|
|
#include <libsn/sn-launcher.h>
|
|
|
|
|
|
2010-03-02 06:47:21 -05:00
|
|
|
|
#include <xcb/randr.h>
|
2009-02-14 02:38:07 -05:00
|
|
|
|
#include <stdbool.h>
|
2011-09-10 18:53:11 -04:00
|
|
|
|
#include <pcre.h>
|
2012-02-21 07:38:49 -05:00
|
|
|
|
#include <sys/time.h>
|
2009-02-07 22:04:35 -05:00
|
|
|
|
|
2012-08-07 15:23:06 -04:00
|
|
|
|
#include "libi3.h"
|
2009-02-24 08:18:08 -05:00
|
|
|
|
#include "queue.h"
|
|
|
|
|
|
2009-02-06 11:49:45 -05:00
|
|
|
|
/*
|
2011-12-30 05:23:15 -05:00
|
|
|
|
* To get the big concept: There are helper structures like struct
|
|
|
|
|
* Workspace_Assignment. Every struct which is also defined as type (see
|
2009-06-29 15:54:51 -04:00
|
|
|
|
* forward definitions) is considered to be a major structure, thus important.
|
2009-02-24 08:18:08 -05:00
|
|
|
|
*
|
2011-12-30 05:23:15 -05:00
|
|
|
|
* The following things are all stored in a 'Con', from very high level (the
|
|
|
|
|
* biggest Cons) to very small (a single window):
|
2009-02-24 08:18:08 -05:00
|
|
|
|
*
|
2011-12-30 05:23:15 -05:00
|
|
|
|
* 1) X11 root window (as big as all your outputs combined)
|
|
|
|
|
* 2) output (like LVDS1)
|
|
|
|
|
* 3) content container, dockarea containers
|
|
|
|
|
* 4) workspaces
|
|
|
|
|
* 5) split containers
|
|
|
|
|
* ... (you can arbitrarily nest split containers)
|
|
|
|
|
* 6) X11 window containers
|
2009-02-06 11:49:45 -05:00
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2009-02-07 20:39:56 -05:00
|
|
|
|
/* Forward definitions */
|
2009-02-10 14:49:47 -05:00
|
|
|
|
typedef struct Binding Binding;
|
2009-02-14 19:58:09 -05:00
|
|
|
|
typedef struct Rect Rect;
|
2010-03-02 06:47:21 -05:00
|
|
|
|
typedef struct xoutput Output;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
typedef struct Con Con;
|
|
|
|
|
typedef struct Match Match;
|
2011-05-15 14:10:25 -04:00
|
|
|
|
typedef struct Assignment Assignment;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
typedef struct Window i3Window;
|
|
|
|
|
|
2009-02-07 20:39:56 -05:00
|
|
|
|
|
2009-02-24 08:18:08 -05:00
|
|
|
|
/******************************************************************************
|
|
|
|
|
* Helper types
|
|
|
|
|
*****************************************************************************/
|
2009-02-07 20:39:56 -05:00
|
|
|
|
typedef enum { D_LEFT, D_RIGHT, D_UP, D_DOWN } direction_t;
|
2010-06-01 16:45:18 -04:00
|
|
|
|
typedef enum { NO_ORIENTATION = 0, HORIZ, VERT } orientation_t;
|
2012-09-23 19:14:00 -04:00
|
|
|
|
typedef enum { BS_NORMAL = 0, BS_NONE = 1, BS_PIXEL = 2 } border_style_t;
|
2009-02-10 14:49:47 -05:00
|
|
|
|
|
2011-05-13 14:41:03 -04:00
|
|
|
|
/** parameter to specify whether tree_close() and x_window_kill() should kill
|
|
|
|
|
* only this specific window or the whole X11 client */
|
|
|
|
|
typedef enum { DONT_KILL_WINDOW = 0, KILL_WINDOW = 1, KILL_CLIENT = 2 } kill_window_t;
|
|
|
|
|
|
2012-07-22 05:57:07 -04:00
|
|
|
|
/** describes if the window is adjacent to the output (physical screen) edges. */
|
|
|
|
|
typedef enum { ADJ_NONE = 0,
|
2012-08-05 15:41:36 -04:00
|
|
|
|
ADJ_LEFT_SCREEN_EDGE = (1 << 0),
|
|
|
|
|
ADJ_RIGHT_SCREEN_EDGE = (1 << 1),
|
|
|
|
|
ADJ_UPPER_SCREEN_EDGE = (1 << 2),
|
|
|
|
|
ADJ_LOWER_SCREEN_EDGE = (1 << 4)} adjacent_t;
|
2012-07-22 05:57:07 -04:00
|
|
|
|
|
2009-02-10 14:49:47 -05:00
|
|
|
|
enum {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
BIND_NONE = 0,
|
|
|
|
|
BIND_SHIFT = XCB_MOD_MASK_SHIFT, /* (1 << 0) */
|
|
|
|
|
BIND_CONTROL = XCB_MOD_MASK_CONTROL, /* (1 << 2) */
|
|
|
|
|
BIND_MOD1 = XCB_MOD_MASK_1, /* (1 << 3) */
|
|
|
|
|
BIND_MOD2 = XCB_MOD_MASK_2, /* (1 << 4) */
|
|
|
|
|
BIND_MOD3 = XCB_MOD_MASK_3, /* (1 << 5) */
|
|
|
|
|
BIND_MOD4 = XCB_MOD_MASK_4, /* (1 << 6) */
|
|
|
|
|
BIND_MOD5 = XCB_MOD_MASK_5, /* (1 << 7) */
|
|
|
|
|
BIND_MODE_SWITCH = (1 << 8)
|
2009-02-10 14:49:47 -05:00
|
|
|
|
};
|
|
|
|
|
|
2013-05-22 00:28:13 -04:00
|
|
|
|
/**
|
|
|
|
|
* Container layouts. See Con::layout.
|
|
|
|
|
*/
|
|
|
|
|
typedef enum {
|
|
|
|
|
L_DEFAULT = 0,
|
|
|
|
|
L_STACKED = 1,
|
|
|
|
|
L_TABBED = 2,
|
|
|
|
|
L_DOCKAREA = 3,
|
|
|
|
|
L_OUTPUT = 4,
|
|
|
|
|
L_SPLITV = 5,
|
|
|
|
|
L_SPLITH = 6
|
|
|
|
|
} layout_t;
|
|
|
|
|
|
2009-06-29 15:54:51 -04:00
|
|
|
|
/**
|
2009-06-29 16:15:37 -04:00
|
|
|
|
* Stores a rectangle, for example the size of a window, the child window etc.
|
2009-12-31 11:48:41 -05:00
|
|
|
|
* It needs to be packed so that the compiler will not add any padding bytes.
|
|
|
|
|
* (it is used in src/ewmh.c for example)
|
2009-06-29 15:54:51 -04:00
|
|
|
|
*
|
2010-02-12 07:06:59 -05:00
|
|
|
|
* Note that x and y can contain signed values in some cases (for example when
|
|
|
|
|
* used for the coordinates of a window, which can be set outside of the
|
|
|
|
|
* visible area, but not when specifying the position of a workspace for the
|
|
|
|
|
* _NET_WM_WORKAREA hint). Not declaring x/y as int32_t saves us a lot of
|
|
|
|
|
* typecasts.
|
|
|
|
|
*
|
2009-06-29 15:54:51 -04:00
|
|
|
|
*/
|
2009-02-14 19:58:09 -05:00
|
|
|
|
struct Rect {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
uint32_t x;
|
|
|
|
|
uint32_t y;
|
|
|
|
|
uint32_t width;
|
|
|
|
|
uint32_t height;
|
2009-12-31 11:48:41 -05:00
|
|
|
|
} __attribute__((packed));
|
2009-02-14 19:58:09 -05:00
|
|
|
|
|
2011-02-21 08:27:32 -05:00
|
|
|
|
/**
|
|
|
|
|
* Stores the reserved pixels on each screen edge read from a
|
|
|
|
|
* _NET_WM_STRUT_PARTIAL.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct reservedpx {
|
|
|
|
|
uint32_t left;
|
|
|
|
|
uint32_t right;
|
|
|
|
|
uint32_t top;
|
|
|
|
|
uint32_t bottom;
|
|
|
|
|
};
|
|
|
|
|
|
2011-03-20 09:07:16 -04:00
|
|
|
|
/**
|
|
|
|
|
* Stores a width/height pair, used as part of deco_render_params to check
|
|
|
|
|
* whether the rects width/height have changed.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct width_height {
|
|
|
|
|
uint32_t w;
|
|
|
|
|
uint32_t h;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Stores the parameters for rendering a window decoration. This structure is
|
|
|
|
|
* cached in every Con and no re-rendering will be done if the parameters have
|
|
|
|
|
* not changed (only the pixmaps will be copied).
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct deco_render_params {
|
|
|
|
|
struct Colortriple *color;
|
|
|
|
|
int border_style;
|
|
|
|
|
struct width_height con_rect;
|
|
|
|
|
struct width_height con_window_rect;
|
2011-03-20 13:07:07 -04:00
|
|
|
|
Rect con_deco_rect;
|
2011-03-20 09:07:16 -04:00
|
|
|
|
uint32_t background;
|
2013-04-29 04:14:11 -04:00
|
|
|
|
layout_t parent_layout;
|
2013-06-08 09:37:41 -04:00
|
|
|
|
bool con_is_leaf;
|
2011-03-20 09:07:16 -04:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-14 16:13:29 -04:00
|
|
|
|
/**
|
|
|
|
|
* Stores which workspace (by name) goes to which output.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct Workspace_Assignment {
|
|
|
|
|
char *name;
|
|
|
|
|
char *output;
|
|
|
|
|
|
|
|
|
|
TAILQ_ENTRY(Workspace_Assignment) ws_assignments;
|
|
|
|
|
};
|
|
|
|
|
|
2009-03-09 19:51:15 -04:00
|
|
|
|
struct Ignore_Event {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
int sequence;
|
Bugfix: Ignore EnterNotifies generated by UnmapNotifies
Actually, commit 1c5adc6c35cffaedc08c7d1dd1b03a3269d1367c commented out code
without ever fixing it. I think this was responsible for the 'workspace
switching sometimes does not work' bug. My observations:
Had it again today and analyzed a log of it. Looks like after unmapping the
windows on one workspace (in my case: chromium, eclipse, urxvt, focus on
eclipse) we get UnmapNotify events for chromium and eclipse, but then we get an
EnterNotify for the terminal (due to unmapping the other windows and therefore
mapping the terminal under the cursor), only afterwards the UnmapNotify
follows.
So, there are two things wrong with that:
• We handle EnterNotifys for unmapped windows
• Unmapping windows sometimes works in a sequence, sometimes the sequence gets
split. Not sure why (if unmapping can take longer for some windows or if our
syncing is wrong -- but i checked the latter briefly and it looks correct).
Maybe GrabServer helps?
• We don’t ignore EnterNotify events caused by UnmapNotifies. We used to, but
then there was a different problem and we decided to solve the EnterNotify
problem in another way, which actually never happened (commit
1c5adc6c35cffaedc08c7d1dd1b03a3269d1367c).
2011-04-19 15:50:56 -04:00
|
|
|
|
int response_type;
|
2010-04-13 11:52:23 -04:00
|
|
|
|
time_t added;
|
2009-02-24 08:18:08 -05:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
SLIST_ENTRY(Ignore_Event) ignore_events;
|
2009-04-19 14:44:34 -04:00
|
|
|
|
};
|
|
|
|
|
|
2011-10-10 07:47:56 -04:00
|
|
|
|
/**
|
|
|
|
|
* Stores internal information about a startup sequence, like the workspace it
|
|
|
|
|
* was initiated on.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct Startup_Sequence {
|
|
|
|
|
/** startup ID for this sequence, generated by libstartup-notification */
|
|
|
|
|
char *id;
|
|
|
|
|
/** workspace on which this startup was initiated */
|
|
|
|
|
char *workspace;
|
2011-10-10 10:30:07 -04:00
|
|
|
|
/** libstartup-notification context for this launch */
|
|
|
|
|
SnLauncherContext *context;
|
2012-09-05 15:00:08 -04:00
|
|
|
|
/** time at which this sequence should be deleted (after it was marked as
|
|
|
|
|
* completed) */
|
|
|
|
|
time_t delete_at;
|
2011-10-10 07:47:56 -04:00
|
|
|
|
|
|
|
|
|
TAILQ_ENTRY(Startup_Sequence) sequences;
|
|
|
|
|
};
|
|
|
|
|
|
2011-09-10 18:53:11 -04:00
|
|
|
|
/**
|
|
|
|
|
* Regular expression wrapper. It contains the pattern itself as a string (like
|
|
|
|
|
* ^foo[0-9]$) as well as a pointer to the compiled PCRE expression and the
|
|
|
|
|
* pcre_extra data returned by pcre_study().
|
|
|
|
|
*
|
|
|
|
|
* This makes it easier to have a useful logfile, including the matching or
|
|
|
|
|
* non-matching pattern.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct regex {
|
2011-09-11 18:41:46 -04:00
|
|
|
|
char *pattern;
|
2011-09-10 18:53:11 -04:00
|
|
|
|
pcre *regex;
|
|
|
|
|
pcre_extra *extra;
|
|
|
|
|
};
|
|
|
|
|
|
2009-02-24 08:18:08 -05:00
|
|
|
|
/******************************************************************************
|
|
|
|
|
* Major types
|
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
2009-06-29 15:54:51 -04:00
|
|
|
|
/**
|
|
|
|
|
* Holds a keybinding, consisting of a keycode combined with modifiers and the
|
2012-12-24 09:57:02 -05:00
|
|
|
|
* command which is executed as soon as the key is pressed (see
|
|
|
|
|
* src/config_parser.c)
|
2009-02-06 12:23:37 -05:00
|
|
|
|
*
|
|
|
|
|
*/
|
2009-02-10 14:49:47 -05:00
|
|
|
|
struct Binding {
|
2012-09-06 11:04:31 -04:00
|
|
|
|
/** If true, the binding should be executed upon a KeyRelease event, not a
|
|
|
|
|
* KeyPress (the default). */
|
2012-09-06 11:24:30 -04:00
|
|
|
|
enum {
|
|
|
|
|
/* This binding will only be executed upon KeyPress events */
|
|
|
|
|
B_UPON_KEYPRESS = 0,
|
|
|
|
|
/* This binding will be executed either upon a KeyRelease event, or… */
|
|
|
|
|
B_UPON_KEYRELEASE = 1,
|
|
|
|
|
/* …upon a KeyRelease event, even if the modifiers don’t match. This
|
|
|
|
|
* state is triggered from get_binding() when the corresponding
|
|
|
|
|
* KeyPress (!) happens, so that users can release the modifier keys
|
|
|
|
|
* before releasing the actual key. */
|
|
|
|
|
B_UPON_KEYRELEASE_IGNORE_MODS = 2,
|
|
|
|
|
} release;
|
2012-09-06 11:04:31 -04:00
|
|
|
|
|
2013-06-08 09:37:41 -04:00
|
|
|
|
uint32_t number_keycodes;
|
|
|
|
|
|
|
|
|
|
/** Keycode to bind */
|
|
|
|
|
uint32_t keycode;
|
|
|
|
|
|
|
|
|
|
/** Bitmask consisting of BIND_MOD_1, BIND_MODE_SWITCH, … */
|
|
|
|
|
uint32_t mods;
|
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Symbol the user specified in configfile, if any. This needs to be
|
|
|
|
|
* stored with the binding to be able to re-convert it into a keycode
|
|
|
|
|
* if the keyboard mapping changes (using Xmodmap for example) */
|
|
|
|
|
char *symbol;
|
2009-08-07 09:35:12 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Only in use if symbol != NULL. Gets set to the value to which the
|
|
|
|
|
* symbol got translated when binding. Useful for unbinding and
|
|
|
|
|
* checking which binding was used when a key press event comes in.
|
|
|
|
|
*
|
|
|
|
|
* This is an array of number_keycodes size. */
|
|
|
|
|
xcb_keycode_t *translated_to;
|
2009-08-07 09:35:12 -04:00
|
|
|
|
|
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Command, like in command mode */
|
|
|
|
|
char *command;
|
2009-08-07 09:35:12 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
TAILQ_ENTRY(Binding) bindings;
|
2009-02-10 14:49:47 -05:00
|
|
|
|
};
|
|
|
|
|
|
2009-06-29 15:54:51 -04:00
|
|
|
|
/**
|
2011-07-12 06:24:01 -04:00
|
|
|
|
* Holds a command specified by either an:
|
|
|
|
|
* - exec-line
|
|
|
|
|
* - exec_always-line
|
|
|
|
|
* in the config (see src/config.c)
|
2009-03-29 08:53:48 -04:00
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct Autostart {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Command, like in command mode */
|
|
|
|
|
char *command;
|
2011-10-25 17:18:17 -04:00
|
|
|
|
/** no_startup_id flag for start_application(). Determines whether a
|
|
|
|
|
* startup notification context/ID should be created. */
|
|
|
|
|
bool no_startup_id;
|
2010-04-13 11:52:23 -04:00
|
|
|
|
TAILQ_ENTRY(Autostart) autostarts;
|
2011-07-12 06:24:01 -04:00
|
|
|
|
TAILQ_ENTRY(Autostart) autostarts_always;
|
2009-05-16 11:32:36 -04:00
|
|
|
|
};
|
|
|
|
|
|
2009-06-29 15:54:51 -04:00
|
|
|
|
/**
|
2010-03-02 06:47:21 -05:00
|
|
|
|
* An Output is a physical output on your graphics driver. Outputs which
|
|
|
|
|
* are currently in use have (output->active == true). Each output has a
|
|
|
|
|
* position and a mode. An output usually corresponds to one connected
|
|
|
|
|
* screen (except if you are running multiple screens in clone mode).
|
2009-02-24 08:18:08 -05:00
|
|
|
|
*
|
|
|
|
|
*/
|
2010-03-02 06:47:21 -05:00
|
|
|
|
struct xoutput {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Output id, so that we can requery the output directly later */
|
|
|
|
|
xcb_randr_output_t id;
|
2010-11-21 16:12:34 -05:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Whether the output is currently active (has a CRTC attached with a
|
|
|
|
|
* valid mode) */
|
|
|
|
|
bool active;
|
2009-02-14 19:58:09 -05:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Internal flags, necessary for querying RandR screens (happens in
|
|
|
|
|
* two stages) */
|
|
|
|
|
bool changed;
|
|
|
|
|
bool to_be_disabled;
|
2011-01-27 09:40:02 -05:00
|
|
|
|
bool primary;
|
2010-03-05 08:32:48 -05:00
|
|
|
|
|
2013-06-08 09:37:41 -04:00
|
|
|
|
/** Name of the output */
|
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
|
|
/** Pointer to the Con which represents this output */
|
|
|
|
|
Con *con;
|
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** x, y, width, height */
|
|
|
|
|
Rect rect;
|
2009-02-14 19:58:09 -05:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
TAILQ_ENTRY(xoutput) outputs;
|
2009-02-14 19:58:09 -05:00
|
|
|
|
};
|
|
|
|
|
|
2011-12-30 05:23:15 -05:00
|
|
|
|
/**
|
|
|
|
|
* A 'Window' is a type which contains an xcb_window_t and all the related
|
|
|
|
|
* information (hints like _NET_WM_NAME for that window).
|
|
|
|
|
*
|
|
|
|
|
*/
|
2010-03-27 10:25:51 -04:00
|
|
|
|
struct Window {
|
|
|
|
|
xcb_window_t id;
|
|
|
|
|
|
2010-11-12 17:46:03 -05:00
|
|
|
|
/** Holds the xcb_window_t (just an ID) for the leader window (logical
|
|
|
|
|
* parent for toolwindows and similar floating windows) */
|
|
|
|
|
xcb_window_t leader;
|
2010-11-12 19:19:21 -05:00
|
|
|
|
xcb_window_t transient_for;
|
2010-11-12 17:46:03 -05:00
|
|
|
|
|
2013-06-08 09:37:41 -04:00
|
|
|
|
/** Pointers to the Assignments which were already ran for this Window
|
|
|
|
|
* (assignments run only once) */
|
|
|
|
|
uint32_t nr_assignments;
|
|
|
|
|
Assignment **ran_assignments;
|
|
|
|
|
|
2010-04-13 11:46:54 -04:00
|
|
|
|
char *class_class;
|
|
|
|
|
char *class_instance;
|
|
|
|
|
|
2012-08-07 15:23:06 -04:00
|
|
|
|
/** The name of the window. */
|
|
|
|
|
i3String *name;
|
2010-04-13 11:46:54 -04:00
|
|
|
|
|
2011-09-18 11:05:10 -04:00
|
|
|
|
/** The WM_WINDOW_ROLE of this window (for example, the pidgin buddy window
|
|
|
|
|
* sets "buddy list"). Useful to match specific windows in assignments or
|
|
|
|
|
* for_window. */
|
|
|
|
|
char *role;
|
|
|
|
|
|
2011-03-20 09:07:16 -04:00
|
|
|
|
/** Flag to force re-rendering the decoration upon changes */
|
|
|
|
|
bool name_x_changed;
|
|
|
|
|
|
2010-04-13 11:46:54 -04:00
|
|
|
|
/** Whether the application used _NET_WM_NAME */
|
2010-04-13 11:22:34 -04:00
|
|
|
|
bool uses_net_wm_name;
|
2010-08-15 06:18:27 -04:00
|
|
|
|
|
2011-03-18 12:07:56 -04:00
|
|
|
|
/** Whether the application needs to receive WM_TAKE_FOCUS */
|
|
|
|
|
bool needs_take_focus;
|
|
|
|
|
|
2012-01-18 14:16:57 -05:00
|
|
|
|
/** Whether this window accepts focus. We store this inverted so that the
|
|
|
|
|
* default will be 'accepts focus'. */
|
|
|
|
|
bool doesnt_accept_focus;
|
|
|
|
|
|
2010-08-15 06:18:27 -04:00
|
|
|
|
/** Whether the window says it is a dock window */
|
2011-02-21 08:27:32 -05:00
|
|
|
|
enum { W_NODOCK = 0, W_DOCK_TOP = 1, W_DOCK_BOTTOM = 2 } dock;
|
|
|
|
|
|
2013-06-08 09:37:41 -04:00
|
|
|
|
/** When this window was marked urgent. 0 means not urgent */
|
|
|
|
|
struct timeval urgent;
|
|
|
|
|
|
2011-02-21 08:27:32 -05:00
|
|
|
|
/** Pixels the window reserves. left/right/top/bottom */
|
|
|
|
|
struct reservedpx reserved;
|
2011-05-15 14:10:25 -04:00
|
|
|
|
|
2012-03-01 00:53:06 -05:00
|
|
|
|
/** Depth of the window */
|
|
|
|
|
uint16_t depth;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
};
|
|
|
|
|
|
2011-12-30 05:23:15 -05:00
|
|
|
|
/**
|
|
|
|
|
* A "match" is a data structure which acts like a mask or expression to match
|
|
|
|
|
* certain windows or not. For example, when using commands, you can specify a
|
|
|
|
|
* command like this: [title="*Firefox*"] kill. The title member of the match
|
|
|
|
|
* data structure will then be filled and i3 will check each window using
|
|
|
|
|
* match_matches_window() to find the windows affected by this command.
|
|
|
|
|
*
|
|
|
|
|
*/
|
2010-03-27 10:25:51 -04:00
|
|
|
|
struct Match {
|
2011-09-10 18:53:11 -04:00
|
|
|
|
struct regex *title;
|
|
|
|
|
struct regex *application;
|
|
|
|
|
struct regex *class;
|
|
|
|
|
struct regex *instance;
|
|
|
|
|
struct regex *mark;
|
2013-12-15 05:25:58 -05:00
|
|
|
|
struct regex *window_role;
|
2012-01-24 18:00:27 -05:00
|
|
|
|
enum {
|
|
|
|
|
U_DONTCHECK = -1,
|
|
|
|
|
U_LATEST = 0,
|
|
|
|
|
U_OLDEST = 1
|
|
|
|
|
} urgent;
|
2011-02-21 08:27:32 -05:00
|
|
|
|
enum {
|
|
|
|
|
M_DONTCHECK = -1,
|
|
|
|
|
M_NODOCK = 0,
|
|
|
|
|
M_DOCK_ANY = 1,
|
|
|
|
|
M_DOCK_TOP = 2,
|
|
|
|
|
M_DOCK_BOTTOM = 3
|
|
|
|
|
} dock;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
xcb_window_t id;
|
2010-04-16 16:57:21 -04:00
|
|
|
|
enum { M_ANY = 0, M_TILING, M_FLOATING } floating;
|
2013-06-08 09:37:41 -04:00
|
|
|
|
Con *con_id;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
|
2011-02-20 17:43:03 -05:00
|
|
|
|
/* Where the window looking for a match should be inserted:
|
|
|
|
|
*
|
|
|
|
|
* M_HERE = the matched container will be replaced by the window
|
|
|
|
|
* (layout saving)
|
2011-05-02 17:29:26 -04:00
|
|
|
|
* M_ASSIGN_WS = the matched container will be inserted in the target_ws.
|
2011-02-20 17:43:03 -05:00
|
|
|
|
* M_BELOW = the window will be inserted as a child of the matched container
|
|
|
|
|
* (dockareas)
|
|
|
|
|
*
|
|
|
|
|
*/
|
2011-05-02 17:29:26 -04:00
|
|
|
|
enum { M_HERE = 0, M_ASSIGN_WS, M_BELOW } insert_where;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
|
2013-06-08 09:37:41 -04:00
|
|
|
|
TAILQ_ENTRY(Match) matches;
|
|
|
|
|
|
2012-01-21 13:35:15 -05:00
|
|
|
|
/* Whether this match was generated when restarting i3 inplace.
|
|
|
|
|
* Leads to not setting focus when managing a new window, because the old
|
|
|
|
|
* focus stack should be restored. */
|
|
|
|
|
bool restart_mode;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
};
|
|
|
|
|
|
2011-05-23 12:41:17 -04:00
|
|
|
|
/**
|
|
|
|
|
* An Assignment makes specific windows go to a specific workspace/output or
|
|
|
|
|
* run a command for that window. With this mechanism, the user can -- for
|
2011-12-30 05:23:15 -05:00
|
|
|
|
* example -- assign his browser to workspace "www". Checking if a window is
|
|
|
|
|
* assigned works by comparing the Match data structure with the window (see
|
|
|
|
|
* match_matches_window()).
|
2011-05-23 12:41:17 -04:00
|
|
|
|
*
|
|
|
|
|
*/
|
2011-05-15 14:10:25 -04:00
|
|
|
|
struct Assignment {
|
|
|
|
|
/** type of this assignment:
|
|
|
|
|
*
|
|
|
|
|
* A_COMMAND = run the specified command for the matching window
|
|
|
|
|
* A_TO_WORKSPACE = assign the matching window to the specified workspace
|
|
|
|
|
* A_TO_OUTPUT = assign the matching window to the specified output
|
|
|
|
|
*
|
2011-05-23 12:41:17 -04:00
|
|
|
|
* While the type is a bitmask, only one value can be set at a time. It is
|
|
|
|
|
* a bitmask to allow filtering for multiple types, for example in the
|
|
|
|
|
* assignment_for() function.
|
|
|
|
|
*
|
2011-05-15 14:10:25 -04:00
|
|
|
|
*/
|
2011-05-23 12:41:17 -04:00
|
|
|
|
enum {
|
|
|
|
|
A_ANY = 0,
|
|
|
|
|
A_COMMAND = (1 << 0),
|
|
|
|
|
A_TO_WORKSPACE = (1 << 1),
|
|
|
|
|
A_TO_OUTPUT = (1 << 2)
|
|
|
|
|
} type;
|
2011-05-15 14:10:25 -04:00
|
|
|
|
|
|
|
|
|
/** the criteria to check if a window matches */
|
|
|
|
|
Match match;
|
|
|
|
|
|
|
|
|
|
/** destination workspace/output/command, depending on the type */
|
|
|
|
|
union {
|
|
|
|
|
char *command;
|
|
|
|
|
char *workspace;
|
|
|
|
|
char *output;
|
|
|
|
|
} dest;
|
|
|
|
|
|
2011-05-23 12:41:17 -04:00
|
|
|
|
TAILQ_ENTRY(Assignment) assignments;
|
2011-05-15 14:10:25 -04:00
|
|
|
|
};
|
|
|
|
|
|
2011-12-30 05:23:15 -05:00
|
|
|
|
/**
|
|
|
|
|
* A 'Con' represents everything from the X11 root window down to a single X11 window.
|
|
|
|
|
*
|
|
|
|
|
*/
|
2010-03-27 10:25:51 -04:00
|
|
|
|
struct Con {
|
|
|
|
|
bool mapped;
|
2013-06-08 09:37:41 -04:00
|
|
|
|
|
|
|
|
|
/* Should this container be marked urgent? This gets set when the window
|
|
|
|
|
* inside this container (if any) sets the urgency hint, for example. */
|
|
|
|
|
bool urgent;
|
|
|
|
|
|
|
|
|
|
/** This counter contains the number of UnmapNotify events for this
|
|
|
|
|
* container (or, more precisely, for its ->frame) which should be ignored.
|
|
|
|
|
* UnmapNotify events need to be ignored when they are caused by i3 itself,
|
|
|
|
|
* for example when reparenting or when unmapping the window on a workspace
|
|
|
|
|
* change. */
|
|
|
|
|
uint8_t ignore_unmap;
|
|
|
|
|
|
|
|
|
|
/* ids/pixmap/graphics context for the frame window */
|
|
|
|
|
bool pixmap_recreated;
|
|
|
|
|
xcb_window_t frame;
|
|
|
|
|
xcb_pixmap_t pixmap;
|
|
|
|
|
xcb_gcontext_t pm_gc;
|
|
|
|
|
|
2011-02-20 17:43:03 -05:00
|
|
|
|
enum {
|
|
|
|
|
CT_ROOT = 0,
|
|
|
|
|
CT_OUTPUT = 1,
|
|
|
|
|
CT_CON = 2,
|
|
|
|
|
CT_FLOATING_CON = 3,
|
|
|
|
|
CT_WORKSPACE = 4,
|
|
|
|
|
CT_DOCKAREA = 5
|
|
|
|
|
} type;
|
2013-06-08 09:37:41 -04:00
|
|
|
|
|
|
|
|
|
/** the workspace number, if this Con is of type CT_WORKSPACE and the
|
|
|
|
|
* workspace is not a named workspace (for named workspaces, num == -1) */
|
|
|
|
|
int num;
|
|
|
|
|
|
2010-03-27 10:25:51 -04:00
|
|
|
|
struct Con *parent;
|
|
|
|
|
|
|
|
|
|
struct Rect rect;
|
|
|
|
|
struct Rect window_rect;
|
|
|
|
|
struct Rect deco_rect;
|
2011-02-20 17:43:03 -05:00
|
|
|
|
/** the geometry this window requested when getting mapped */
|
|
|
|
|
struct Rect geometry;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
|
|
|
|
|
char *name;
|
|
|
|
|
|
2010-09-01 12:11:01 -04:00
|
|
|
|
/* a sticky-group is an identifier which bundles several containers to a
|
|
|
|
|
* group. The contents are shared between all of them, that is they are
|
|
|
|
|
* displayed on whichever of the containers is currently visible */
|
|
|
|
|
char *sticky_group;
|
|
|
|
|
|
2010-06-02 17:32:05 -04:00
|
|
|
|
/* user-definable mark to jump to this container later */
|
|
|
|
|
char *mark;
|
|
|
|
|
|
2010-03-27 10:25:51 -04:00
|
|
|
|
double percent;
|
|
|
|
|
|
2013-06-29 17:11:54 -04:00
|
|
|
|
/* aspect ratio from WM_NORMAL_HINTS (MPlayer uses this for example) */
|
|
|
|
|
double aspect_ratio;
|
2010-10-11 15:32:04 -04:00
|
|
|
|
/* the wanted size of the window, used in combination with size
|
|
|
|
|
* increments (see below). */
|
|
|
|
|
int base_width;
|
|
|
|
|
int base_height;
|
|
|
|
|
|
2010-11-14 17:44:13 -05:00
|
|
|
|
/* the x11 border pixel attribute */
|
|
|
|
|
int border_width;
|
2012-09-23 19:14:00 -04:00
|
|
|
|
int current_border_width;
|
2010-11-14 17:44:13 -05:00
|
|
|
|
|
2010-10-11 15:32:04 -04:00
|
|
|
|
/* minimum increment size specified for the window (in pixels) */
|
|
|
|
|
int width_increment;
|
|
|
|
|
int height_increment;
|
|
|
|
|
|
2010-03-27 10:25:51 -04:00
|
|
|
|
struct Window *window;
|
|
|
|
|
|
2012-09-22 07:48:22 -04:00
|
|
|
|
/* timer used for disabling urgency */
|
|
|
|
|
struct ev_timer *urgency_timer;
|
|
|
|
|
|
2011-03-20 09:07:16 -04:00
|
|
|
|
/** Cache for the decoration rendering */
|
|
|
|
|
struct deco_render_params *deco_render_params;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
|
|
|
|
|
/* Only workspace-containers can have floating clients */
|
|
|
|
|
TAILQ_HEAD(floating_head, Con) floating_head;
|
|
|
|
|
|
|
|
|
|
TAILQ_HEAD(nodes_head, Con) nodes_head;
|
|
|
|
|
TAILQ_HEAD(focus_head, Con) focus_head;
|
|
|
|
|
|
|
|
|
|
TAILQ_HEAD(swallow_head, Match) swallow_head;
|
|
|
|
|
|
|
|
|
|
enum { CF_NONE = 0, CF_OUTPUT = 1, CF_GLOBAL = 2 } fullscreen_mode;
|
2012-09-16 16:53:41 -04:00
|
|
|
|
/* layout is the layout of this container: one of split[v|h], stacked or
|
|
|
|
|
* tabbed. Special containers in the tree (above workspaces) have special
|
|
|
|
|
* layouts like dockarea or output.
|
|
|
|
|
*
|
|
|
|
|
* last_split_layout is one of splitv or splith to support the old "layout
|
|
|
|
|
* default" command which by now should be "layout splitv" or "layout
|
|
|
|
|
* splith" explicitly.
|
|
|
|
|
*
|
|
|
|
|
* workspace_layout is only for type == CT_WORKSPACE cons. When you change
|
|
|
|
|
* the layout of a workspace without any children, i3 cannot just set the
|
|
|
|
|
* layout (because workspaces need to be splitv/splith to allow focus
|
|
|
|
|
* parent and opening new containers). Instead, it stores the requested
|
|
|
|
|
* layout in workspace_layout and creates a new split container with that
|
|
|
|
|
* layout whenever a new container is attached to the workspace. */
|
2013-05-22 00:28:13 -04:00
|
|
|
|
layout_t layout, last_split_layout, workspace_layout;
|
2010-12-07 18:32:04 -05:00
|
|
|
|
border_style_t border_style;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
/** floating? (= not in tiling layout) This cannot be simply a bool
|
|
|
|
|
* because we want to keep track of whether the status was set by the
|
|
|
|
|
* application (by setting _NET_WM_WINDOW_TYPE appropriately) or by the
|
|
|
|
|
* user. The user’s choice overwrites automatic mode, of course. The
|
|
|
|
|
* order of the values is important because we check with >=
|
|
|
|
|
* FLOATING_AUTO_ON if a client is floating. */
|
|
|
|
|
enum {
|
|
|
|
|
FLOATING_AUTO_OFF = 0,
|
|
|
|
|
FLOATING_USER_OFF = 1,
|
|
|
|
|
FLOATING_AUTO_ON = 2,
|
|
|
|
|
FLOATING_USER_ON = 3
|
|
|
|
|
} floating;
|
|
|
|
|
|
|
|
|
|
TAILQ_ENTRY(Con) nodes;
|
|
|
|
|
TAILQ_ENTRY(Con) focused;
|
|
|
|
|
TAILQ_ENTRY(Con) all_cons;
|
|
|
|
|
TAILQ_ENTRY(Con) floating_windows;
|
2011-02-14 12:08:36 -05:00
|
|
|
|
|
|
|
|
|
/** callbacks */
|
|
|
|
|
void(*on_remove_child)(Con *);
|
2011-12-21 18:15:32 -05:00
|
|
|
|
|
|
|
|
|
enum {
|
2013-02-18 04:41:34 -05:00
|
|
|
|
/* Not a scratchpad window. */
|
2011-12-21 18:15:32 -05:00
|
|
|
|
SCRATCHPAD_NONE = 0,
|
2013-02-18 04:41:34 -05:00
|
|
|
|
|
|
|
|
|
/* Just moved to scratchpad, not resized by the user yet.
|
|
|
|
|
* Window will be auto-centered and sized appropriately. */
|
2011-12-21 18:15:32 -05:00
|
|
|
|
SCRATCHPAD_FRESH = 1,
|
2013-02-18 04:41:34 -05:00
|
|
|
|
|
|
|
|
|
/* The user changed position/size of the scratchpad window. */
|
2011-12-21 18:15:32 -05:00
|
|
|
|
SCRATCHPAD_CHANGED = 2
|
|
|
|
|
} scratchpad_state;
|
2012-01-21 13:35:15 -05:00
|
|
|
|
|
|
|
|
|
/* The ID of this container before restarting. Necessary to correctly
|
|
|
|
|
* interpret back-references in the JSON (such as the focus stack). */
|
|
|
|
|
int old_id;
|
2013-03-15 10:40:26 -04:00
|
|
|
|
|
|
|
|
|
/* Depth of the container window */
|
|
|
|
|
uint16_t depth;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
};
|
|
|
|
|
|
2009-02-07 22:04:35 -05:00
|
|
|
|
#endif
|