]> git.sur5r.net Git - i3/i3/blob - include/data.h
d60ec3cda6974f74aef977fbdb822b9f4c9e30c8
[i3/i3] / include / data.h
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 _DATA_H
11 #define _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 <xcb/xcb_atom.h>
18 #include <stdbool.h>
19 #include <pcre.h>
20 #include <sys/time.h>
21
22 #include "libi3.h"
23 #include "queue.h"
24
25 /*
26  * To get the big concept: There are helper structures like struct
27  * Workspace_Assignment. Every struct which is also defined as type (see
28  * forward definitions) is considered to be a major structure, thus important.
29  *
30  * The following things are all stored in a 'Con', from very high level (the
31  * biggest Cons) to very small (a single window):
32  *
33  * 1) X11 root window (as big as all your outputs combined)
34  * 2) output (like LVDS1)
35  * 3) content container, dockarea containers
36  * 4) workspaces
37  * 5) split containers
38  * ... (you can arbitrarily nest split containers)
39  * 6) X11 window containers
40  *
41  */
42
43 /* Forward definitions */
44 typedef struct Binding Binding;
45 typedef struct Rect Rect;
46 typedef struct xoutput Output;
47 typedef struct Con Con;
48 typedef struct Match Match;
49 typedef struct Assignment Assignment;
50 typedef struct Window i3Window;
51
52
53 /******************************************************************************
54  * Helper types
55  *****************************************************************************/
56 typedef enum { D_LEFT, D_RIGHT, D_UP, D_DOWN } direction_t;
57 typedef enum { NO_ORIENTATION = 0, HORIZ, VERT } orientation_t;
58 typedef enum { BS_NORMAL = 0, BS_NONE = 1, BS_1PIXEL = 2 } border_style_t;
59
60 /** parameter to specify whether tree_close() and x_window_kill() should kill
61  * only this specific window or the whole X11 client */
62 typedef enum { DONT_KILL_WINDOW = 0, KILL_WINDOW = 1, KILL_CLIENT = 2 } kill_window_t;
63
64 /** describes if the window is adjacent to the output (physical screen) edges. */
65 typedef enum { ADJ_NONE = 0,
66                ADJ_LEFT_SCREEN_EDGE = (1 << 0),
67                ADJ_RIGHT_SCREEN_EDGE = (1 << 1),
68                ADJ_UPPER_SCREEN_EDGE = (1 << 2),
69                ADJ_LOWER_SCREEN_EDGE = (1 << 4)} adjacent_t;
70
71 enum {
72     BIND_NONE = 0,
73     BIND_SHIFT = XCB_MOD_MASK_SHIFT,        /* (1 << 0) */
74     BIND_CONTROL = XCB_MOD_MASK_CONTROL,    /* (1 << 2) */
75     BIND_MOD1 = XCB_MOD_MASK_1,             /* (1 << 3) */
76     BIND_MOD2 = XCB_MOD_MASK_2,             /* (1 << 4) */
77     BIND_MOD3 = XCB_MOD_MASK_3,             /* (1 << 5) */
78     BIND_MOD4 = XCB_MOD_MASK_4,             /* (1 << 6) */
79     BIND_MOD5 = XCB_MOD_MASK_5,             /* (1 << 7) */
80     BIND_MODE_SWITCH = (1 << 8)
81 };
82
83 /**
84  * Stores a rectangle, for example the size of a window, the child window etc.
85  * It needs to be packed so that the compiler will not add any padding bytes.
86  * (it is used in src/ewmh.c for example)
87  *
88  * Note that x and y can contain signed values in some cases (for example when
89  * used for the coordinates of a window, which can be set outside of the
90  * visible area, but not when specifying the position of a workspace for the
91  * _NET_WM_WORKAREA hint). Not declaring x/y as int32_t saves us a lot of
92  * typecasts.
93  *
94  */
95 struct Rect {
96     uint32_t x;
97     uint32_t y;
98     uint32_t width;
99     uint32_t height;
100 } __attribute__((packed));
101
102 /**
103  * Stores the reserved pixels on each screen edge read from a
104  * _NET_WM_STRUT_PARTIAL.
105  *
106  */
107 struct reservedpx {
108     uint32_t left;
109     uint32_t right;
110     uint32_t top;
111     uint32_t bottom;
112 };
113
114 /**
115  * Stores a width/height pair, used as part of deco_render_params to check
116  * whether the rects width/height have changed.
117  *
118  */
119 struct width_height {
120     uint32_t w;
121     uint32_t h;
122 };
123
124 /**
125  * Stores the parameters for rendering a window decoration. This structure is
126  * cached in every Con and no re-rendering will be done if the parameters have
127  * not changed (only the pixmaps will be copied).
128  *
129  */
130 struct deco_render_params {
131     struct Colortriple *color;
132     int border_style;
133     struct width_height con_rect;
134     struct width_height con_window_rect;
135     Rect con_deco_rect;
136     uint32_t background;
137     bool con_is_leaf;
138 };
139
140 /**
141  * Stores which workspace (by name) goes to which output.
142  *
143  */
144 struct Workspace_Assignment {
145     char *name;
146     char *output;
147
148     TAILQ_ENTRY(Workspace_Assignment) ws_assignments;
149 };
150
151 struct Ignore_Event {
152     int sequence;
153     int response_type;
154     time_t added;
155
156     SLIST_ENTRY(Ignore_Event) ignore_events;
157 };
158
159 /**
160  * Stores internal information about a startup sequence, like the workspace it
161  * was initiated on.
162  *
163  */
164 struct Startup_Sequence {
165     /** startup ID for this sequence, generated by libstartup-notification */
166     char *id;
167     /** workspace on which this startup was initiated */
168     char *workspace;
169     /** libstartup-notification context for this launch */
170     SnLauncherContext *context;
171     /** time at which this sequence should be deleted (after it was marked as
172      * completed) */
173     time_t delete_at;
174
175     TAILQ_ENTRY(Startup_Sequence) sequences;
176 };
177
178 /**
179  * Regular expression wrapper. It contains the pattern itself as a string (like
180  * ^foo[0-9]$) as well as a pointer to the compiled PCRE expression and the
181  * pcre_extra data returned by pcre_study().
182  *
183  * This makes it easier to have a useful logfile, including the matching or
184  * non-matching pattern.
185  *
186  */
187 struct regex {
188     char *pattern;
189     pcre *regex;
190     pcre_extra *extra;
191 };
192
193 /******************************************************************************
194  * Major types
195  *****************************************************************************/
196
197 /**
198  * Holds a keybinding, consisting of a keycode combined with modifiers and the
199  * command which is executed as soon as the key is pressed (see src/cfgparse.y)
200  *
201  */
202 struct Binding {
203     /** Symbol the user specified in configfile, if any. This needs to be
204      * stored with the binding to be able to re-convert it into a keycode
205      * if the keyboard mapping changes (using Xmodmap for example) */
206     char *symbol;
207
208     /** Only in use if symbol != NULL. Gets set to the value to which the
209      * symbol got translated when binding. Useful for unbinding and
210      * checking which binding was used when a key press event comes in.
211      *
212      * This is an array of number_keycodes size. */
213     xcb_keycode_t *translated_to;
214
215     uint32_t number_keycodes;
216
217     /** Keycode to bind */
218     uint32_t keycode;
219
220     /** Bitmask consisting of BIND_MOD_1, BIND_MODE_SWITCH, … */
221     uint32_t mods;
222
223     /** Command, like in command mode */
224     char *command;
225
226     TAILQ_ENTRY(Binding) bindings;
227 };
228
229 /**
230  * Holds a command specified by either an:
231  * - exec-line
232  * - exec_always-line
233  * in the config (see src/config.c)
234  *
235  */
236 struct Autostart {
237     /** Command, like in command mode */
238     char *command;
239     /** no_startup_id flag for start_application(). Determines whether a
240      * startup notification context/ID should be created. */
241     bool no_startup_id;
242     TAILQ_ENTRY(Autostart) autostarts;
243     TAILQ_ENTRY(Autostart) autostarts_always;
244 };
245
246 /**
247  * An Output is a physical output on your graphics driver. Outputs which
248  * are currently in use have (output->active == true). Each output has a
249  * position and a mode. An output usually corresponds to one connected
250  * screen (except if you are running multiple screens in clone mode).
251  *
252  */
253 struct xoutput {
254     /** Output id, so that we can requery the output directly later */
255     xcb_randr_output_t id;
256     /** Name of the output */
257     char *name;
258
259     /** Pointer to the Con which represents this output */
260     Con *con;
261
262     /** Whether the output is currently active (has a CRTC attached with a
263      * valid mode) */
264     bool active;
265
266     /** Internal flags, necessary for querying RandR screens (happens in
267      * two stages) */
268     bool changed;
269     bool to_be_disabled;
270     bool primary;
271
272     /** x, y, width, height */
273     Rect rect;
274
275     TAILQ_ENTRY(xoutput) outputs;
276 };
277
278 /**
279  * A 'Window' is a type which contains an xcb_window_t and all the related
280  * information (hints like _NET_WM_NAME for that window).
281  *
282  */
283 struct Window {
284     xcb_window_t id;
285
286     /** Holds the xcb_window_t (just an ID) for the leader window (logical
287      * parent for toolwindows and similar floating windows) */
288     xcb_window_t leader;
289     xcb_window_t transient_for;
290
291     char *class_class;
292     char *class_instance;
293
294     /** The name of the window. */
295     i3String *name;
296
297     /** The WM_WINDOW_ROLE of this window (for example, the pidgin buddy window
298      * sets "buddy list"). Useful to match specific windows in assignments or
299      * for_window. */
300     char *role;
301
302     /** Flag to force re-rendering the decoration upon changes */
303     bool name_x_changed;
304
305     /** Whether the application used _NET_WM_NAME */
306     bool uses_net_wm_name;
307
308     /** Whether the application needs to receive WM_TAKE_FOCUS */
309     bool needs_take_focus;
310
311     /** When this window was marked urgent. 0 means not urgent */
312     struct timeval urgent;
313
314     /** Whether this window accepts focus. We store this inverted so that the
315      * default will be 'accepts focus'. */
316     bool doesnt_accept_focus;
317
318     /** Whether the window says it is a dock window */
319     enum { W_NODOCK = 0, W_DOCK_TOP = 1, W_DOCK_BOTTOM = 2 } dock;
320
321     /** Pixels the window reserves. left/right/top/bottom */
322     struct reservedpx reserved;
323
324     /** Pointers to the Assignments which were already ran for this Window
325      * (assignments run only once) */
326     uint32_t nr_assignments;
327     Assignment **ran_assignments;
328
329     /** Depth of the window */
330     uint16_t depth;
331 };
332
333 /**
334  * A "match" is a data structure which acts like a mask or expression to match
335  * certain windows or not. For example, when using commands, you can specify a
336  * command like this: [title="*Firefox*"] kill. The title member of the match
337  * data structure will then be filled and i3 will check each window using
338  * match_matches_window() to find the windows affected by this command.
339  *
340  */
341 struct Match {
342     struct regex *title;
343     struct regex *application;
344     struct regex *class;
345     struct regex *instance;
346     struct regex *mark;
347     struct regex *role;
348     enum {
349         U_DONTCHECK = -1,
350         U_LATEST = 0,
351         U_OLDEST = 1
352     } urgent;
353     enum {
354         M_DONTCHECK = -1,
355         M_NODOCK = 0,
356         M_DOCK_ANY = 1,
357         M_DOCK_TOP = 2,
358         M_DOCK_BOTTOM = 3
359     } dock;
360     xcb_window_t id;
361     Con *con_id;
362     enum { M_ANY = 0, M_TILING, M_FLOATING } floating;
363
364     /* Where the window looking for a match should be inserted:
365      *
366      * M_HERE   = the matched container will be replaced by the window
367      *            (layout saving)
368      * M_ASSIGN_WS = the matched container will be inserted in the target_ws.
369      * M_BELOW  = the window will be inserted as a child of the matched container
370      *            (dockareas)
371      *
372      */
373     enum { M_HERE = 0, M_ASSIGN_WS, M_BELOW } insert_where;
374
375     /* Whether this match was generated when restarting i3 inplace.
376      * Leads to not setting focus when managing a new window, because the old
377      * focus stack should be restored. */
378     bool restart_mode;
379
380     TAILQ_ENTRY(Match) matches;
381 };
382
383 /**
384  * An Assignment makes specific windows go to a specific workspace/output or
385  * run a command for that window. With this mechanism, the user can -- for
386  * example -- assign his browser to workspace "www". Checking if a window is
387  * assigned works by comparing the Match data structure with the window (see
388  * match_matches_window()).
389  *
390  */
391 struct Assignment {
392     /** type of this assignment:
393      *
394      * A_COMMAND = run the specified command for the matching window
395      * A_TO_WORKSPACE = assign the matching window to the specified workspace
396      * A_TO_OUTPUT = assign the matching window to the specified output
397      *
398      * While the type is a bitmask, only one value can be set at a time. It is
399      * a bitmask to allow filtering for multiple types, for example in the
400      * assignment_for() function.
401      *
402      */
403     enum {
404         A_ANY          = 0,
405         A_COMMAND      = (1 << 0),
406         A_TO_WORKSPACE = (1 << 1),
407         A_TO_OUTPUT    = (1 << 2)
408     } type;
409
410     /** the criteria to check if a window matches */
411     Match match;
412
413     /** destination workspace/output/command, depending on the type */
414     union {
415         char *command;
416         char *workspace;
417         char *output;
418     } dest;
419
420     TAILQ_ENTRY(Assignment) assignments;
421 };
422
423 /**
424  * A 'Con' represents everything from the X11 root window down to a single X11 window.
425  *
426  */
427 struct Con {
428     bool mapped;
429     /** whether this is a split container or not */
430     bool split;
431     enum {
432         CT_ROOT = 0,
433         CT_OUTPUT = 1,
434         CT_CON = 2,
435         CT_FLOATING_CON = 3,
436         CT_WORKSPACE = 4,
437         CT_DOCKAREA = 5
438     } type;
439     struct Con *parent;
440
441     struct Rect rect;
442     struct Rect window_rect;
443     struct Rect deco_rect;
444     /** the geometry this window requested when getting mapped */
445     struct Rect geometry;
446
447     char *name;
448
449     /** the workspace number, if this Con is of type CT_WORKSPACE and the
450      * workspace is not a named workspace (for named workspaces, num == -1) */
451     int num;
452
453     /* a sticky-group is an identifier which bundles several containers to a
454      * group. The contents are shared between all of them, that is they are
455      * displayed on whichever of the containers is currently visible */
456     char *sticky_group;
457
458     /* user-definable mark to jump to this container later */
459     char *mark;
460
461     double percent;
462
463     /* proportional width/height, calculated from WM_NORMAL_HINTS, used to
464      * apply an aspect ratio to windows (think of MPlayer) */
465     int proportional_width;
466     int proportional_height;
467     /* the wanted size of the window, used in combination with size
468      * increments (see below). */
469     int base_width;
470     int base_height;
471
472     /* the x11 border pixel attribute */
473     int border_width;
474
475     /* minimum increment size specified for the window (in pixels) */
476     int width_increment;
477     int height_increment;
478
479     struct Window *window;
480
481     /* Should this container be marked urgent? This gets set when the window
482      * inside this container (if any) sets the urgency hint, for example. */
483     bool urgent;
484
485     /* ids/pixmap/graphics context for the frame window */
486     xcb_window_t frame;
487     xcb_pixmap_t pixmap;
488     xcb_gcontext_t pm_gc;
489     bool pixmap_recreated;
490
491     /** Cache for the decoration rendering */
492     struct deco_render_params *deco_render_params;
493
494     /* Only workspace-containers can have floating clients */
495     TAILQ_HEAD(floating_head, Con) floating_head;
496
497     TAILQ_HEAD(nodes_head, Con) nodes_head;
498     TAILQ_HEAD(focus_head, Con) focus_head;
499
500     TAILQ_HEAD(swallow_head, Match) swallow_head;
501
502     enum { CF_NONE = 0, CF_OUTPUT = 1, CF_GLOBAL = 2 } fullscreen_mode;
503     enum {
504         L_DEFAULT = 0,
505         L_STACKED = 1,
506         L_TABBED = 2,
507         L_DOCKAREA = 3,
508         L_OUTPUT = 4,
509         L_SPLITV = 5,
510         L_SPLITH = 6
511     } layout, last_split_layout;
512     border_style_t border_style;
513     /** floating? (= not in tiling layout) This cannot be simply a bool
514      * because we want to keep track of whether the status was set by the
515      * application (by setting _NET_WM_WINDOW_TYPE appropriately) or by the
516      * user. The user’s choice overwrites automatic mode, of course. The
517      * order of the values is important because we check with >=
518      * FLOATING_AUTO_ON if a client is floating. */
519     enum {
520         FLOATING_AUTO_OFF = 0,
521         FLOATING_USER_OFF = 1,
522         FLOATING_AUTO_ON = 2,
523         FLOATING_USER_ON = 3
524     } floating;
525
526     /** This counter contains the number of UnmapNotify events for this
527      * container (or, more precisely, for its ->frame) which should be ignored.
528      * UnmapNotify events need to be ignored when they are caused by i3 itself,
529      * for example when reparenting or when unmapping the window on a workspace
530      * change. */
531     uint8_t ignore_unmap;
532
533     TAILQ_ENTRY(Con) nodes;
534     TAILQ_ENTRY(Con) focused;
535     TAILQ_ENTRY(Con) all_cons;
536     TAILQ_ENTRY(Con) floating_windows;
537
538     /** callbacks */
539     void(*on_remove_child)(Con *);
540
541     enum {
542         SCRATCHPAD_NONE = 0,
543         SCRATCHPAD_FRESH = 1,
544         SCRATCHPAD_CHANGED = 2
545     } scratchpad_state;
546
547     /* The ID of this container before restarting. Necessary to correctly
548      * interpret back-references in the JSON (such as the focus stack). */
549     int old_id;
550 };
551
552 #endif