git.sur5r.net Git - i3/i3/blob - include/data.h

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