i3
data.h
Go to the documentation of this file.
1 /*
2  * vim:ts=4:sw=4:expandtab
3  *
4  * i3 - an improved dynamic tiling window manager
5  * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
6  *
7  * include/data.h: This file defines all data structures used by i3
8  *
9  */
10 #ifndef I3_DATA_H
11 #define I3_DATA_H
12 
13 #define SN_API_NOT_YET_FROZEN 1
14 #include <libsn/sn-launcher.h>
15 
16 #include <xcb/randr.h>
17 #include <stdbool.h>
18 #include <pcre.h>
19 #include <sys/time.h>
20 
21 #include "libi3.h"
22 #include "queue.h"
23 
24 /*
25  * To get the big concept: There are helper structures like struct
26  * Workspace_Assignment. Every struct which is also defined as type (see
27  * forward definitions) is considered to be a major structure, thus important.
28  *
29  * The following things are all stored in a 'Con', from very high level (the
30  * biggest Cons) to very small (a single window):
31  *
32  * 1) X11 root window (as big as all your outputs combined)
33  * 2) output (like LVDS1)
34  * 3) content container, dockarea containers
35  * 4) workspaces
36  * 5) split containers
37  * ... (you can arbitrarily nest split containers)
38  * 6) X11 window containers
39  *
40  */
41 
42 /* Forward definitions */
43 typedef struct Binding Binding;
44 typedef struct Rect Rect;
45 typedef struct xoutput Output;
46 typedef struct Con Con;
47 typedef struct Match Match;
48 typedef struct Assignment Assignment;
49 typedef struct Window i3Window;
50 
51 
52 /******************************************************************************
53  * Helper types
54  *****************************************************************************/
55 typedef enum { D_LEFT, D_RIGHT, D_UP, D_DOWN } direction_t;
56 typedef enum { NO_ORIENTATION = 0, HORIZ, VERT } orientation_t;
57 typedef enum { BS_NORMAL = 0, BS_NONE = 1, BS_PIXEL = 2 } border_style_t;
58 
61 typedef enum { DONT_KILL_WINDOW = 0, KILL_WINDOW = 1, KILL_CLIENT = 2 } kill_window_t;
62 
64 typedef enum { ADJ_NONE = 0,
69 
70 enum {
71  BIND_NONE = 0,
72  BIND_SHIFT = XCB_MOD_MASK_SHIFT, /* (1 << 0) */
73  BIND_CONTROL = XCB_MOD_MASK_CONTROL, /* (1 << 2) */
74  BIND_MOD1 = XCB_MOD_MASK_1, /* (1 << 3) */
75  BIND_MOD2 = XCB_MOD_MASK_2, /* (1 << 4) */
76  BIND_MOD3 = XCB_MOD_MASK_3, /* (1 << 5) */
77  BIND_MOD4 = XCB_MOD_MASK_4, /* (1 << 6) */
78  BIND_MOD5 = XCB_MOD_MASK_5, /* (1 << 7) */
79  BIND_MODE_SWITCH = (1 << 8)
80 };
81 
85 typedef enum {
86  L_DEFAULT = 0,
87  L_STACKED = 1,
88  L_TABBED = 2,
90  L_OUTPUT = 4,
91  L_SPLITV = 5,
93 } layout_t;
94 
107 struct Rect {
108  uint32_t x;
109  uint32_t y;
110  uint32_t width;
111  uint32_t height;
112 } __attribute__((packed));
113 
119 struct reservedpx {
120  uint32_t left;
121  uint32_t right;
122  uint32_t top;
123  uint32_t bottom;
124 };
125 
131 struct width_height {
132  uint32_t w;
133  uint32_t h;
134 };
135 
148  uint32_t background;
151 };
152 
158  char *name;
159  char *output;
160 
162 };
163 
164 struct Ignore_Event {
165  int sequence;
167  time_t added;
168 
169  SLIST_ENTRY(Ignore_Event) ignore_events;
170 };
171 
179  char *id;
181  char *workspace;
183  SnLauncherContext *context;
186  time_t delete_at;
187 
188  TAILQ_ENTRY(Startup_Sequence) sequences;
189 };
190 
200 struct regex {
201  char *pattern;
202  pcre *regex;
203  pcre_extra *extra;
204 };
205 
206 /******************************************************************************
207  * Major types
208  *****************************************************************************/
209 
216 struct Binding {
219  enum {
220  /* This binding will only be executed upon KeyPress events */
221  B_UPON_KEYPRESS = 0,
222  /* This binding will be executed either upon a KeyRelease event, or… */
223  B_UPON_KEYRELEASE = 1,
224  /* …upon a KeyRelease event, even if the modifiers don’t match. This
225  * state is triggered from get_binding() when the corresponding
226  * KeyPress (!) happens, so that users can release the modifier keys
227  * before releasing the actual key. */
228  B_UPON_KEYRELEASE_IGNORE_MODS = 2,
229  } release;
230 
231  uint32_t number_keycodes;
232 
234  uint32_t keycode;
235 
237  uint32_t mods;
238 
242  char *symbol;
243 
249  xcb_keycode_t *translated_to;
250 
251 
253  char *command;
254 
256 };
257 
265 struct Autostart {
267  char *command;
271  TAILQ_ENTRY(Autostart) autostarts;
272  TAILQ_ENTRY(Autostart) autostarts_always;
273 };
274 
282 struct xoutput {
284  xcb_randr_output_t id;
285 
288  bool active;
289 
292  bool changed;
294  bool primary;
295 
297  char *name;
298 
301 
304 
305  TAILQ_ENTRY(xoutput) outputs;
306 };
307 
313 struct Window {
314  xcb_window_t id;
315 
318  xcb_window_t leader;
319  xcb_window_t transient_for;
320 
323  uint32_t nr_assignments;
325 
326  char *class_class;
328 
331 
335  char *role;
336 
339 
342 
345 
349 
351  enum { W_NODOCK = 0, W_DOCK_TOP = 1, W_DOCK_BOTTOM = 2 } dock;
352 
354  struct timeval urgent;
355 
357  struct reservedpx reserved;
358 
360  uint16_t depth;
361 };
362 
371 struct Match {
372  struct regex *title;
374  struct regex *class;
375  struct regex *instance;
376  struct regex *mark;
377  struct regex *role;
378  enum {
379  U_DONTCHECK = -1,
380  U_LATEST = 0,
381  U_OLDEST = 1
382  } urgent;
383  enum {
384  M_DONTCHECK = -1,
385  M_NODOCK = 0,
386  M_DOCK_ANY = 1,
387  M_DOCK_TOP = 2,
388  M_DOCK_BOTTOM = 3
389  } dock;
390  xcb_window_t id;
391  enum { M_ANY = 0, M_TILING, M_FLOATING } floating;
393 
394  /* Where the window looking for a match should be inserted:
395  *
396  * M_HERE = the matched container will be replaced by the window
397  * (layout saving)
398  * M_ASSIGN_WS = the matched container will be inserted in the target_ws.
399  * M_BELOW = the window will be inserted as a child of the matched container
400  * (dockareas)
401  *
402  */
403  enum { M_HERE = 0, M_ASSIGN_WS, M_BELOW } insert_where;
404 
405  TAILQ_ENTRY(Match) matches;
406 
407  /* Whether this match was generated when restarting i3 inplace.
408  * Leads to not setting focus when managing a new window, because the old
409  * focus stack should be restored. */
410  bool restart_mode;
411 };
412 
421 struct Assignment {
433  enum {
434  A_ANY = 0,
435  A_COMMAND = (1 << 0),
436  A_TO_WORKSPACE = (1 << 1),
437  A_TO_OUTPUT = (1 << 2)
438  } type;
439 
442 
444  union {
445  char *command;
446  char *workspace;
447  char *output;
448  } dest;
449 
450  TAILQ_ENTRY(Assignment) assignments;
451 };
452 
457 struct Con {
458  bool mapped;
459 
460  /* Should this container be marked urgent? This gets set when the window
461  * inside this container (if any) sets the urgency hint, for example. */
462  bool urgent;
463 
469  uint8_t ignore_unmap;
470 
471  /* ids/pixmap/graphics context for the frame window */
473  xcb_window_t frame;
474  xcb_pixmap_t pixmap;
475  xcb_gcontext_t pm_gc;
476 
477  enum {
478  CT_ROOT = 0,
479  CT_OUTPUT = 1,
480  CT_CON = 2,
481  CT_FLOATING_CON = 3,
482  CT_WORKSPACE = 4,
483  CT_DOCKAREA = 5
484  } type;
485 
488  int num;
489 
490  struct Con *parent;
491 
492  struct Rect rect;
493  struct Rect window_rect;
494  struct Rect deco_rect;
496  struct Rect geometry;
497 
498  char *name;
499 
500  /* a sticky-group is an identifier which bundles several containers to a
501  * group. The contents are shared between all of them, that is they are
502  * displayed on whichever of the containers is currently visible */
504 
505  /* user-definable mark to jump to this container later */
506  char *mark;
507 
508  double percent;
509 
510  /* aspect ratio from WM_NORMAL_HINTS (MPlayer uses this for example) */
511  double aspect_ratio;
512  /* the wanted size of the window, used in combination with size
513  * increments (see below). */
516 
517  /* the x11 border pixel attribute */
520 
521  /* minimum increment size specified for the window (in pixels) */
524 
525  struct Window *window;
526 
527  /* timer used for disabling urgency */
528  struct ev_timer *urgency_timer;
529 
532 
533  /* Only workspace-containers can have floating clients */
534  TAILQ_HEAD(floating_head, Con) floating_head;
535 
536  TAILQ_HEAD(nodes_head, Con) nodes_head;
537  TAILQ_HEAD(focus_head, Con) focus_head;
538 
539  TAILQ_HEAD(swallow_head, Match) swallow_head;
540 
541  enum { CF_NONE = 0, CF_OUTPUT = 1, CF_GLOBAL = 2 } fullscreen_mode;
542  /* layout is the layout of this container: one of split[v|h], stacked or
543  * tabbed. Special containers in the tree (above workspaces) have special
544  * layouts like dockarea or output.
545  *
546  * last_split_layout is one of splitv or splith to support the old "layout
547  * default" command which by now should be "layout splitv" or "layout
548  * splith" explicitly.
549  *
550  * workspace_layout is only for type == CT_WORKSPACE cons. When you change
551  * the layout of a workspace without any children, i3 cannot just set the
552  * layout (because workspaces need to be splitv/splith to allow focus
553  * parent and opening new containers). Instead, it stores the requested
554  * layout in workspace_layout and creates a new split container with that
555  * layout whenever a new container is attached to the workspace. */
556  layout_t layout, last_split_layout, workspace_layout;
564  enum {
565  FLOATING_AUTO_OFF = 0,
566  FLOATING_USER_OFF = 1,
567  FLOATING_AUTO_ON = 2,
568  FLOATING_USER_ON = 3
569  } floating;
570 
571  TAILQ_ENTRY(Con) nodes;
572  TAILQ_ENTRY(Con) focused;
573  TAILQ_ENTRY(Con) all_cons;
574  TAILQ_ENTRY(Con) floating_windows;
575 
577  void(*on_remove_child)(Con *);
578 
579  enum {
580  /* Not a scratchpad window. */
581  SCRATCHPAD_NONE = 0,
582 
583  /* Just moved to scratchpad, not resized by the user yet.
584  * Window will be auto-centered and sized appropriately. */
585  SCRATCHPAD_FRESH = 1,
586 
587  /* The user changed position/size of the scratchpad window. */
588  SCRATCHPAD_CHANGED = 2
589  } scratchpad_state;
590 
591  /* The ID of this container before restarting. Necessary to correctly
592  * interpret back-references in the JSON (such as the focus stack). */
593  int old_id;
594 
595  /* Depth of the container window */
596  uint16_t depth;
597 };
598 
599 #endif
Assignment ** ran_assignments
Definition: data.h:324
char * name
Name of the output.
Definition: data.h:297
border_style_t
Definition: data.h:57
uint8_t ignore_unmap
This counter contains the number of UnmapNotify events for this container (or, more precisely...
Definition: data.h:469
A &#39;Con&#39; represents everything from the X11 root window down to a single X11 window.
Definition: data.h:457
char * output
Definition: data.h:447
char * symbol
Symbol the user specified in configfile, if any.
Definition: data.h:242
struct all_cons_head all_cons
Definition: tree.c:17
Stores which workspace (by name) goes to which output.
Definition: data.h:157
uint32_t bottom
Definition: data.h:123
kill_window_t
parameter to specify whether tree_close() and x_window_kill() should kill only this specific window o...
Definition: data.h:61
Definition: data.h:55
#define SLIST_ENTRY(type)
Definition: queue.h:102
Definition: data.h:56
bool to_be_disabled
Definition: data.h:293
Stores a rectangle, for example the size of a window, the child window etc.
Definition: data.h:107
Definition: data.h:56
uint32_t y
Definition: data.h:109
bool urgent
Definition: data.h:462
border_style_t border_style
Definition: data.h:557
Definition: data.h:74
int height_increment
Definition: data.h:523
char * role
The WM_WINDOW_ROLE of this window (for example, the pidgin buddy window sets &quot;buddy list&quot;)...
Definition: data.h:335
An Assignment makes specific windows go to a specific workspace/output or run a command for that wind...
Definition: data.h:421
pcre_extra * extra
Definition: data.h:203
adjacent_t
describes if the window is adjacent to the output (physical screen) edges.
Definition: data.h:64
char * sticky_group
Definition: data.h:503
bool name_x_changed
Flag to force re-rendering the decoration upon changes.
Definition: data.h:338
struct width_height con_rect
Definition: data.h:145
struct _i3String i3String
Opaque data structure for storing strings.
Definition: libi3.h:29
char * class_class
Definition: data.h:326
char * pattern
Definition: data.h:201
int width_increment
Definition: data.h:522
struct width_height con_window_rect
Definition: data.h:146
i3String * name
The name of the window.
Definition: data.h:330
Definition: data.h:55
A &quot;match&quot; is a data structure which acts like a mask or expression to match certain windows or not...
Definition: data.h:371
struct Window * window
Definition: data.h:525
layout_t
Container layouts.
Definition: data.h:85
int response_type
Definition: data.h:166
struct regex * instance
Definition: data.h:375
Definition: data.h:77
char * mark
Definition: data.h:506
int border_style
Definition: data.h:144
int border_width
Definition: data.h:518
int current_border_width
Definition: data.h:519
uint32_t h
Definition: data.h:133
xcb_window_t id
Definition: data.h:390
xcb_randr_output_t id
Output id, so that we can requery the output directly later.
Definition: data.h:284
Definition: data.h:78
Definition: data.h:55
struct Colortriple * color
Definition: data.h:143
int base_width
Definition: data.h:514
Holds a keybinding, consisting of a keycode combined with modifiers and the command which is executed...
Definition: data.h:216
Con * con_id
Definition: data.h:392
bool doesnt_accept_focus
Whether this window accepts focus.
Definition: data.h:348
uint32_t right
Definition: data.h:121
char * workspace
workspace on which this startup was initiated
Definition: data.h:181
double aspect_ratio
Definition: data.h:511
Definition: data.h:64
struct regex * role
Definition: data.h:377
struct regex * mark
Definition: data.h:376
Definition: data.h:91
A &#39;Window&#39; is a type which contains an xcb_window_t and all the related information (hints like _NET_...
Definition: data.h:313
bool uses_net_wm_name
Whether the application used _NET_WM_NAME.
Definition: data.h:341
char * command
Command, like in command mode.
Definition: data.h:253
struct ws_assignments_head ws_assignments
Definition: main.c:88
#define TAILQ_HEAD(name, type)
Definition: queue.h:306
Rect con_deco_rect
Definition: data.h:147
char * id
startup ID for this sequence, generated by libstartup-notification
Definition: data.h:179
uint32_t number_keycodes
Definition: data.h:231
bool con_is_leaf
Definition: data.h:150
SnLauncherContext * context
libstartup-notification context for this launch
Definition: data.h:183
struct outputs_head outputs
Definition: randr.c:28
Definition: data.h:90
Stores the reserved pixels on each screen edge read from a _NET_WM_STRUT_PARTIAL. ...
Definition: data.h:119
struct autostarts_head autostarts
Definition: main.c:78
Rect rect
x, y, width, height
Definition: data.h:303
xcb_window_t leader
Holds the xcb_window_t (just an ID) for the leader window (logical parent for toolwindows and similar...
Definition: data.h:318
uint16_t depth
Definition: data.h:596
Stores the parameters for rendering a window decoration.
Definition: data.h:142
Definition: data.h:71
bool no_startup_id
no_startup_id flag for start_application().
Definition: data.h:270
Definition: data.h:88
Definition: data.h:57
xcb_window_t id
Definition: data.h:314
struct regex * application
Definition: data.h:373
char * class_instance
Definition: data.h:327
time_t added
Definition: data.h:167
struct autostarts_always_head autostarts_always
Definition: main.c:81
bool primary
Definition: data.h:294
Definition: data.h:87
time_t delete_at
time at which this sequence should be deleted (after it was marked as completed)
Definition: data.h:186
TAILQ_ENTRY(Workspace_Assignment) ws_assignments
Stores a width/height pair, used as part of deco_render_params to check whether the rects width/heigh...
Definition: data.h:131
orientation_t
Definition: data.h:56
uint32_t left
Definition: data.h:120
Con * focused
Definition: tree.c:15
int old_id
Definition: data.h:593
xcb_pixmap_t pixmap
Definition: data.h:474
bool active
Whether the output is currently active (has a CRTC attached with a valid mode)
Definition: data.h:288
Definition: data.h:76
An Output is a physical output on your graphics driver.
Definition: data.h:282
bool changed
Internal flags, necessary for querying RandR screens (happens in two stages)
Definition: data.h:292
uint16_t depth
Depth of the window.
Definition: data.h:360
Definition: data.h:55
xcb_window_t frame
Definition: data.h:473
uint32_t keycode
Keycode to bind.
Definition: data.h:234
struct deco_render_params * deco_render_params
Cache for the decoration rendering.
Definition: data.h:531
Definition: data.h:92
char * workspace
Definition: data.h:446
Definition: data.h:57
struct ev_timer * urgency_timer
Definition: data.h:528
int num
the workspace number, if this Con is of type CT_WORKSPACE and the workspace is not a named workspace ...
Definition: data.h:488
Stores internal information about a startup sequence, like the workspace it was initiated on...
Definition: data.h:177
layout_t workspace_layout
Definition: data.h:556
Part of the struct Config.
Definition: config.h:53
char * name
Definition: data.h:498
uint32_t background
Definition: data.h:148
uint32_t mods
Bitmask consisting of BIND_MOD_1, BIND_MODE_SWITCH, …
Definition: data.h:237
struct Con * parent
Definition: data.h:490
uint32_t x
Definition: data.h:108
layout_t parent_layout
Definition: data.h:149
char * command
Command, like in command mode.
Definition: data.h:267
bool pixmap_recreated
Definition: data.h:472
xcb_window_t transient_for
Definition: data.h:319
struct bindings_head * bindings
Definition: main.c:75
int base_height
Definition: data.h:515
Con * con
Pointer to the Con which represents this output.
Definition: data.h:300
pcre * regex
Definition: data.h:202
uint32_t nr_assignments
Pointers to the Assignments which were already ran for this Window (assignments run only once) ...
Definition: data.h:323
uint32_t height
Definition: data.h:111
Match match
the criteria to check if a window matches
Definition: data.h:441
Regular expression wrapper.
Definition: data.h:200
Definition: data.h:57
xcb_keycode_t * translated_to
Only in use if symbol != NULL.
Definition: data.h:249
double percent
Definition: data.h:508
xcb_gcontext_t pm_gc
Definition: data.h:475
struct regex * title
Definition: data.h:372
int sequence
Definition: data.h:165
char * command
Definition: data.h:445
struct reservedpx __attribute__
struct assignments_head assignments
Definition: main.c:84
Holds a command specified by either an:
Definition: data.h:265
Definition: data.h:75
uint32_t top
Definition: data.h:122
Definition: data.h:86
uint32_t w
Definition: data.h:132
bool needs_take_focus
Whether the application needs to receive WM_TAKE_FOCUS.
Definition: data.h:344
direction_t
Definition: data.h:55
uint32_t width
Definition: data.h:110
bool mapped
Definition: data.h:458