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 Michael Stapelberg and contributors (see also: LICENSE)
   6  *
   7  * include/data.h: This file defines all data structures used by i3
   8  *
   9  */
  10 #pragma once
  11
  12 #define SN_API_NOT_YET_FROZEN 1
  13 #include <libsn/sn-launcher.h>
  14
  15 #include <xcb/randr.h>
  16 #include <stdbool.h>
  17 #include <pcre.h>
  18 #include <sys/time.h>
  19
  20 #include "libi3.h"
  21 #include "queue.h"
  22
  23 /*
  24  * To get the big concept: There are helper structures like struct
  25  * Workspace_Assignment. Every struct which is also defined as type (see
  26  * forward definitions) is considered to be a major structure, thus important.
  27  *
  28  * The following things are all stored in a 'Con', from very high level (the
  29  * biggest Cons) to very small (a single window):
  30  *
  31  * 1) X11 root window (as big as all your outputs combined)
  32  * 2) output (like LVDS1)
  33  * 3) content container, dockarea containers
  34  * 4) workspaces
  35  * 5) split containers
  36  * ... (you can arbitrarily nest split containers)
  37  * 6) X11 window containers
  38  *
  39  */
  40
  41 /* Forward definitions */
  42 typedef struct Binding Binding;
  43 typedef struct Rect Rect;
  44 typedef struct xoutput Output;
  45 typedef struct Con Con;
  46 typedef struct Match Match;
  47 typedef struct Assignment Assignment;
  48 typedef struct Window i3Window;
  49 typedef struct mark_t mark_t;
  50
  51 /******************************************************************************
  52  * Helper types
  53  *****************************************************************************/
  54 typedef enum { D_LEFT,
  55                D_RIGHT,
  56                D_UP,
  57                D_DOWN } direction_t;
  58 typedef enum { NO_ORIENTATION = 0,
  59                HORIZ,
  60                VERT } orientation_t;
  61 typedef enum { BS_NORMAL = 0,
  62                BS_NONE = 1,
  63                BS_PIXEL = 2 } border_style_t;
  64
  65 /** parameter to specify whether tree_close_internal() and x_window_kill() should kill
  66  * only this specific window or the whole X11 client */
  67 typedef enum { DONT_KILL_WINDOW = 0,
  68                KILL_WINDOW = 1,
  69                KILL_CLIENT = 2 } kill_window_t;
  70
  71 /** describes if the window is adjacent to the output (physical screen) edges. */
  72 typedef enum { ADJ_NONE = 0,
  73                ADJ_LEFT_SCREEN_EDGE = (1 << 0),
  74                ADJ_RIGHT_SCREEN_EDGE = (1 << 1),
  75                ADJ_UPPER_SCREEN_EDGE = (1 << 2),
  76                ADJ_LOWER_SCREEN_EDGE = (1 << 4) } adjacent_t;
  77
  78 typedef enum { HEBM_NONE = ADJ_NONE,
  79                HEBM_VERTICAL = ADJ_LEFT_SCREEN_EDGE | ADJ_RIGHT_SCREEN_EDGE,
  80                HEBM_HORIZONTAL = ADJ_UPPER_SCREEN_EDGE | ADJ_LOWER_SCREEN_EDGE,
  81                HEBM_BOTH = HEBM_VERTICAL | HEBM_HORIZONTAL,
  82                HEBM_SMART = (1 << 5) } hide_edge_borders_mode_t;
  83
  84 typedef enum { MM_REPLACE,
  85                MM_ADD } mark_mode_t;
  86
  87 /**
  88  * Container layouts. See Con::layout.
  89  */
  90 typedef enum {
  91     L_DEFAULT = 0,
  92     L_STACKED = 1,
  93     L_TABBED = 2,
  94     L_DOCKAREA = 3,
  95     L_OUTPUT = 4,
  96     L_SPLITV = 5,
  97     L_SPLITH = 6
  98 } layout_t;
  99
 100 /**
 101  * Binding input types. See Binding::input_type.
 102  */
 103 typedef enum {
 104     B_KEYBOARD = 0,
 105     B_MOUSE = 1
 106 } input_type_t;
 107
 108 /**
 109  * Bitmask for matching XCB_XKB_GROUP_1 to XCB_XKB_GROUP_4.
 110  */
 111 typedef enum {
 112     I3_XKB_GROUP_MASK_ANY = 0,
 113     I3_XKB_GROUP_MASK_1 = (1 << 0),
 114     I3_XKB_GROUP_MASK_2 = (1 << 1),
 115     I3_XKB_GROUP_MASK_3 = (1 << 2),
 116     I3_XKB_GROUP_MASK_4 = (1 << 3)
 117 } i3_xkb_group_mask_t;
 118
 119 /**
 120  * The lower 16 bits contain a xcb_key_but_mask_t, the higher 16 bits contain
 121  * an i3_xkb_group_mask_t. This type is necessary for the fallback logic to
 122  * work when handling XKB groups (see ticket #1775) and makes the code which
 123  * locates keybindings upon KeyPress/KeyRelease events simpler.
 124  */
 125 typedef uint32_t i3_event_state_mask_t;
 126
 127 /**
 128  * Mouse pointer warping modes.
 129  */
 130 typedef enum {
 131     POINTER_WARPING_OUTPUT = 0,
 132     POINTER_WARPING_NONE = 1
 133 } warping_t;
 134
 135 /**
 136  * Stores a rectangle, for example the size of a window, the child window etc.
 137  * It needs to be packed so that the compiler will not add any padding bytes.
 138  * (it is used in src/ewmh.c for example)
 139  *
 140  * Note that x and y can contain signed values in some cases (for example when
 141  * used for the coordinates of a window, which can be set outside of the
 142  * visible area, but not when specifying the position of a workspace for the
 143  * _NET_WM_WORKAREA hint). Not declaring x/y as int32_t saves us a lot of
 144  * typecasts.
 145  *
 146  */
 147 struct Rect {
 148     uint32_t x;
 149     uint32_t y;
 150     uint32_t width;
 151     uint32_t height;
 152 } __attribute__((packed));
 153
 154 /**
 155  * Stores the reserved pixels on each screen edge read from a
 156  * _NET_WM_STRUT_PARTIAL.
 157  *
 158  */
 159 struct reservedpx {
 160     uint32_t left;
 161     uint32_t right;
 162     uint32_t top;
 163     uint32_t bottom;
 164 };
 165
 166 /**
 167  * Stores a width/height pair, used as part of deco_render_params to check
 168  * whether the rects width/height have changed.
 169  *
 170  */
 171 struct width_height {
 172     uint32_t w;
 173     uint32_t h;
 174 };
 175
 176 /**
 177  * Stores the parameters for rendering a window decoration. This structure is
 178  * cached in every Con and no re-rendering will be done if the parameters have
 179  * not changed (only the pixmaps will be copied).
 180  *
 181  */
 182 struct deco_render_params {
 183     struct Colortriple *color;
 184     int border_style;
 185     struct width_height con_rect;
 186     struct width_height con_window_rect;
 187     Rect con_deco_rect;
 188     color_t background;
 189     layout_t parent_layout;
 190     bool con_is_leaf;
 191 };
 192
 193 /**
 194  * Stores which workspace (by name or number) goes to which output.
 195  *
 196  */
 197 struct Workspace_Assignment {
 198     char *name;
 199     char *output;
 200
 201     TAILQ_ENTRY(Workspace_Assignment) ws_assignments;
 202 };
 203
 204 struct Ignore_Event {
 205     int sequence;
 206     int response_type;
 207     time_t added;
 208
 209     SLIST_ENTRY(Ignore_Event) ignore_events;
 210 };
 211
 212 /**
 213  * Stores internal information about a startup sequence, like the workspace it
 214  * was initiated on.
 215  *
 216  */
 217 struct Startup_Sequence {
 218     /** startup ID for this sequence, generated by libstartup-notification */
 219     char *id;
 220     /** workspace on which this startup was initiated */
 221     char *workspace;
 222     /** libstartup-notification context for this launch */
 223     SnLauncherContext *context;
 224     /** time at which this sequence should be deleted (after it was marked as
 225      * completed) */
 226     time_t delete_at;
 227
 228     TAILQ_ENTRY(Startup_Sequence) sequences;
 229 };
 230
 231 /**
 232  * Regular expression wrapper. It contains the pattern itself as a string (like
 233  * ^foo[0-9]$) as well as a pointer to the compiled PCRE expression and the
 234  * pcre_extra data returned by pcre_study().
 235  *
 236  * This makes it easier to have a useful logfile, including the matching or
 237  * non-matching pattern.
 238  *
 239  */
 240 struct regex {
 241     char *pattern;
 242     pcre *regex;
 243     pcre_extra *extra;
 244 };
 245
 246 /******************************************************************************
 247  * Major types
 248  *****************************************************************************/
 249
 250 /**
 251  * Holds a keybinding, consisting of a keycode combined with modifiers and the
 252  * command which is executed as soon as the key is pressed (see
 253  * src/config_parser.c)
 254  *
 255  */
 256 struct Binding {
 257     /* The type of input this binding is for. (Mouse bindings are not yet
 258      * implemented. All bindings are currently assumed to be keyboard bindings.) */
 259     input_type_t input_type;
 260
 261     /** If true, the binding should be executed upon a KeyRelease event, not a
 262      * KeyPress (the default). */
 263     enum {
 264         /* This binding will only be executed upon KeyPress events */
 265         B_UPON_KEYPRESS = 0,
 266         /* This binding will be executed either upon a KeyRelease event, or… */
 267         B_UPON_KEYRELEASE = 1,
 268         /* …upon a KeyRelease event, even if the modifiers don’t match. This
 269          * state is triggered from get_binding() when the corresponding
 270          * KeyPress (!) happens, so that users can release the modifier keys
 271          * before releasing the actual key. */
 272         B_UPON_KEYRELEASE_IGNORE_MODS = 2,
 273     } release;
 274
 275     /** If this is true for a mouse binding, the binding should be executed
 276      * when the button is pressed over the window border. */
 277     bool border;
 278
 279     /** If this is true for a mouse binding, the binding should be executed
 280      * when the button is pressed over any part of the window, not just the
 281      * title bar (default). */
 282     bool whole_window;
 283
 284     uint32_t number_keycodes;
 285
 286     /** Keycode to bind */
 287     uint32_t keycode;
 288
 289     /** Bitmask which is applied against event->state for KeyPress and
 290      * KeyRelease events to determine whether this binding applies to the
 291      * current state. */
 292     i3_event_state_mask_t event_state_mask;
 293
 294     /** Symbol the user specified in configfile, if any. This needs to be
 295      * stored with the binding to be able to re-convert it into a keycode
 296      * if the keyboard mapping changes (using Xmodmap for example) */
 297     char *symbol;
 298
 299     /** Only in use if symbol != NULL. Gets set to the value to which the
 300      * symbol got translated when binding. Useful for unbinding and
 301      * checking which binding was used when a key press event comes in.
 302      *
 303      * This is an array of number_keycodes size. */
 304     xcb_keycode_t *translated_to;
 305
 306     /** Command, like in command mode */
 307     char *command;
 308
 309     TAILQ_ENTRY(Binding) bindings;
 310 };
 311
 312 /**
 313  * Holds a command specified by either an:
 314  * - exec-line
 315  * - exec_always-line
 316  * in the config (see src/config.c)
 317  *
 318  */
 319 struct Autostart {
 320     /** Command, like in command mode */
 321     char *command;
 322     /** no_startup_id flag for start_application(). Determines whether a
 323      * startup notification context/ID should be created. */
 324     bool no_startup_id;
 325     TAILQ_ENTRY(Autostart) autostarts;
 326     TAILQ_ENTRY(Autostart) autostarts_always;
 327 };
 328
 329 /**
 330  * An Output is a physical output on your graphics driver. Outputs which
 331  * are currently in use have (output->active == true). Each output has a
 332  * position and a mode. An output usually corresponds to one connected
 333  * screen (except if you are running multiple screens in clone mode).
 334  *
 335  */
 336 struct xoutput {
 337     /** Output id, so that we can requery the output directly later */
 338     xcb_randr_output_t id;
 339
 340     /** Whether the output is currently active (has a CRTC attached with a
 341      * valid mode) */
 342     bool active;
 343
 344     /** Internal flags, necessary for querying RandR screens (happens in
 345      * two stages) */
 346     bool changed;
 347     bool to_be_disabled;
 348     bool primary;
 349
 350     /** Name of the output */
 351     char *name;
 352
 353     /** Pointer to the Con which represents this output */
 354     Con *con;
 355
 356     /** x, y, width, height */
 357     Rect rect;
 358
 359     TAILQ_ENTRY(xoutput) outputs;
 360 };
 361
 362 /**
 363  * A 'Window' is a type which contains an xcb_window_t and all the related
 364  * information (hints like _NET_WM_NAME for that window).
 365  *
 366  */
 367 struct Window {
 368     xcb_window_t id;
 369
 370     /** Holds the xcb_window_t (just an ID) for the leader window (logical
 371      * parent for toolwindows and similar floating windows) */
 372     xcb_window_t leader;
 373     xcb_window_t transient_for;
 374
 375     /** Pointers to the Assignments which were already ran for this Window
 376      * (assignments run only once) */
 377     uint32_t nr_assignments;
 378     Assignment **ran_assignments;
 379
 380     char *class_class;
 381     char *class_instance;
 382
 383     /** The name of the window. */
 384     i3String *name;
 385
 386     /** The WM_WINDOW_ROLE of this window (for example, the pidgin buddy window
 387      * sets "buddy list"). Useful to match specific windows in assignments or
 388      * for_window. */
 389     char *role;
 390
 391     /** Flag to force re-rendering the decoration upon changes */
 392     bool name_x_changed;
 393
 394     /** Whether the application used _NET_WM_NAME */
 395     bool uses_net_wm_name;
 396
 397     /** Whether the application needs to receive WM_TAKE_FOCUS */
 398     bool needs_take_focus;
 399
 400     /** Whether this window accepts focus. We store this inverted so that the
 401      * default will be 'accepts focus'. */
 402     bool doesnt_accept_focus;
 403
 404     /** The _NET_WM_WINDOW_TYPE for this window. */
 405     xcb_atom_t window_type;
 406
 407     /** The _NET_WM_DESKTOP for this window. */
 408     uint32_t wm_desktop;
 409
 410     /** Whether the window says it is a dock window */
 411     enum { W_NODOCK = 0,
 412            W_DOCK_TOP = 1,
 413            W_DOCK_BOTTOM = 2 } dock;
 414
 415     /** When this window was marked urgent. 0 means not urgent */
 416     struct timeval urgent;
 417
 418     /** Pixels the window reserves. left/right/top/bottom */
 419     struct reservedpx reserved;
 420
 421     /** Depth of the window */
 422     uint16_t depth;
 423
 424     /* the wanted size of the window, used in combination with size
 425      * increments (see below). */
 426     int base_width;
 427     int base_height;
 428
 429     /* minimum increment size specified for the window (in pixels) */
 430     int width_increment;
 431     int height_increment;
 432
 433     /* aspect ratio from WM_NORMAL_HINTS (MPlayer uses this for example) */
 434     double aspect_ratio;
 435 };
 436
 437 /**
 438  * A "match" is a data structure which acts like a mask or expression to match
 439  * certain windows or not. For example, when using commands, you can specify a
 440  * command like this: [title="*Firefox*"] kill. The title member of the match
 441  * data structure will then be filled and i3 will check each window using
 442  * match_matches_window() to find the windows affected by this command.
 443  *
 444  */
 445 struct Match {
 446     /* Set if a criterion was specified incorrectly. */
 447     char *error;
 448
 449     struct regex *title;
 450     struct regex *application;
 451     struct regex *class;
 452     struct regex *instance;
 453     struct regex *mark;
 454     struct regex *window_role;
 455     struct regex *workspace;
 456     xcb_atom_t window_type;
 457     enum {
 458         U_DONTCHECK = -1,
 459         U_LATEST = 0,
 460         U_OLDEST = 1
 461     } urgent;
 462     enum {
 463         M_DONTCHECK = -1,
 464         M_NODOCK = 0,
 465         M_DOCK_ANY = 1,
 466         M_DOCK_TOP = 2,
 467         M_DOCK_BOTTOM = 3
 468     } dock;
 469     xcb_window_t id;
 470     enum { M_ANY = 0,
 471            M_TILING,
 472            M_FLOATING } floating;
 473     Con *con_id;
 474
 475     /* Where the window looking for a match should be inserted:
 476      *
 477      * M_HERE   = the matched container will be replaced by the window
 478      *            (layout saving)
 479      * M_ASSIGN_WS = the matched container will be inserted in the target_ws.
 480      * M_BELOW  = the window will be inserted as a child of the matched container
 481      *            (dockareas)
 482      *
 483      */
 484     enum { M_HERE = 0,
 485            M_ASSIGN_WS,
 486            M_BELOW } insert_where;
 487
 488     TAILQ_ENTRY(Match) matches;
 489
 490     /* Whether this match was generated when restarting i3 inplace.
 491      * Leads to not setting focus when managing a new window, because the old
 492      * focus stack should be restored. */
 493     bool restart_mode;
 494 };
 495
 496 /**
 497  * An Assignment makes specific windows go to a specific workspace/output or
 498  * run a command for that window. With this mechanism, the user can -- for
 499  * example -- assign their browser to workspace "www". Checking if a window is
 500  * assigned works by comparing the Match data structure with the window (see
 501  * match_matches_window()).
 502  *
 503  */
 504 struct Assignment {
 505     /** type of this assignment:
 506      *
 507      * A_COMMAND = run the specified command for the matching window
 508      * A_TO_WORKSPACE = assign the matching window to the specified workspace
 509      * A_NO_FOCUS = don't focus matched window when it is managed
 510      *
 511      * While the type is a bitmask, only one value can be set at a time. It is
 512      * a bitmask to allow filtering for multiple types, for example in the
 513      * assignment_for() function.
 514      *
 515      */
 516     enum {
 517         A_ANY = 0,
 518         A_COMMAND = (1 << 0),
 519         A_TO_WORKSPACE = (1 << 1),
 520         A_NO_FOCUS = (1 << 2)
 521     } type;
 522
 523     /** the criteria to check if a window matches */
 524     Match match;
 525
 526     /** destination workspace/command, depending on the type */
 527     union {
 528         char *command;
 529         char *workspace;
 530     } dest;
 531
 532     TAILQ_ENTRY(Assignment) assignments;
 533 };
 534
 535 /** Fullscreen modes. Used by Con.fullscreen_mode. */
 536 typedef enum { CF_NONE = 0,
 537                CF_OUTPUT = 1,
 538                CF_GLOBAL = 2 } fullscreen_mode_t;
 539
 540 struct mark_t {
 541     char *name;
 542
 543     TAILQ_ENTRY(mark_t) marks;
 544 };
 545
 546 /**
 547  * A 'Con' represents everything from the X11 root window down to a single X11 window.
 548  *
 549  */
 550 struct Con {
 551     bool mapped;
 552
 553     /* Should this container be marked urgent? This gets set when the window
 554      * inside this container (if any) sets the urgency hint, for example. */
 555     bool urgent;
 556
 557     /** This counter contains the number of UnmapNotify events for this
 558      * container (or, more precisely, for its ->frame) which should be ignored.
 559      * UnmapNotify events need to be ignored when they are caused by i3 itself,
 560      * for example when reparenting or when unmapping the window on a workspace
 561      * change. */
 562     uint8_t ignore_unmap;
 563
 564     /* The surface used for the frame window. */
 565     surface_t frame;
 566     surface_t frame_buffer;
 567     bool pixmap_recreated;
 568
 569     enum {
 570         CT_ROOT = 0,
 571         CT_OUTPUT = 1,
 572         CT_CON = 2,
 573         CT_FLOATING_CON = 3,
 574         CT_WORKSPACE = 4,
 575         CT_DOCKAREA = 5
 576     } type;
 577
 578     /** the workspace number, if this Con is of type CT_WORKSPACE and the
 579      * workspace is not a named workspace (for named workspaces, num == -1) */
 580     int num;
 581
 582     struct Con *parent;
 583
 584     /* The position and size for this con. These coordinates are absolute. Note
 585      * that the rect of a container does not include the decoration. */
 586     struct Rect rect;
 587     /* The position and size of the actual client window. These coordinates are
 588      * relative to the container's rect. */
 589     struct Rect window_rect;
 590     /* The position and size of the container's decoration. These coordinates
 591      * are relative to the container's parent's rect. */
 592     struct Rect deco_rect;
 593     /** the geometry this window requested when getting mapped */
 594     struct Rect geometry;
 595
 596     char *name;
 597
 598     /** The format with which the window's name should be displayed. */
 599     char *title_format;
 600
 601     /* a sticky-group is an identifier which bundles several containers to a
 602      * group. The contents are shared between all of them, that is they are
 603      * displayed on whichever of the containers is currently visible */
 604     char *sticky_group;
 605
 606     /* user-definable marks to jump to this container later */
 607     TAILQ_HEAD(marks_head, mark_t) marks_head;
 608     /* cached to decide whether a redraw is needed */
 609     bool mark_changed;
 610
 611     double percent;
 612
 613     /* the x11 border pixel attribute */
 614     int border_width;
 615     int current_border_width;
 616
 617     struct Window *window;
 618
 619     /* timer used for disabling urgency */
 620     struct ev_timer *urgency_timer;
 621
 622     /** Cache for the decoration rendering */
 623     struct deco_render_params *deco_render_params;
 624
 625     /* Only workspace-containers can have floating clients */
 626     TAILQ_HEAD(floating_head, Con) floating_head;
 627
 628     TAILQ_HEAD(nodes_head, Con) nodes_head;
 629     TAILQ_HEAD(focus_head, Con) focus_head;
 630
 631     TAILQ_HEAD(swallow_head, Match) swallow_head;
 632
 633     fullscreen_mode_t fullscreen_mode;
 634
 635     /* Whether this window should stick to the glass. This corresponds to
 636      * the _NET_WM_STATE_STICKY atom and will only be respected if the
 637      * window is floating. */
 638     bool sticky;
 639
 640     /* layout is the layout of this container: one of split[v|h], stacked or
 641      * tabbed. Special containers in the tree (above workspaces) have special
 642      * layouts like dockarea or output.
 643      *
 644      * last_split_layout is one of splitv or splith to support the old "layout
 645      * default" command which by now should be "layout splitv" or "layout
 646      * splith" explicitly.
 647      *
 648      * workspace_layout is only for type == CT_WORKSPACE cons. When you change
 649      * the layout of a workspace without any children, i3 cannot just set the
 650      * layout (because workspaces need to be splitv/splith to allow focus
 651      * parent and opening new containers). Instead, it stores the requested
 652      * layout in workspace_layout and creates a new split container with that
 653      * layout whenever a new container is attached to the workspace. */
 654     layout_t layout, last_split_layout, workspace_layout;
 655     border_style_t border_style;
 656     /** floating? (= not in tiling layout) This cannot be simply a bool
 657      * because we want to keep track of whether the status was set by the
 658      * application (by setting _NET_WM_WINDOW_TYPE appropriately) or by the
 659      * user. The user’s choice overwrites automatic mode, of course. The
 660      * order of the values is important because we check with >=
 661      * FLOATING_AUTO_ON if a client is floating. */
 662     enum {
 663         FLOATING_AUTO_OFF = 0,
 664         FLOATING_USER_OFF = 1,
 665         FLOATING_AUTO_ON = 2,
 666         FLOATING_USER_ON = 3
 667     } floating;
 668
 669     TAILQ_ENTRY(Con) nodes;
 670     TAILQ_ENTRY(Con) focused;
 671     TAILQ_ENTRY(Con) all_cons;
 672     TAILQ_ENTRY(Con) floating_windows;
 673
 674     /** callbacks */
 675     void (*on_remove_child)(Con *);
 676
 677     enum {
 678         /* Not a scratchpad window. */
 679         SCRATCHPAD_NONE = 0,
 680
 681         /* Just moved to scratchpad, not resized by the user yet.
 682          * Window will be auto-centered and sized appropriately. */
 683         SCRATCHPAD_FRESH = 1,
 684
 685         /* The user changed position/size of the scratchpad window. */
 686         SCRATCHPAD_CHANGED = 2
 687     } scratchpad_state;
 688
 689     /* The ID of this container before restarting. Necessary to correctly
 690      * interpret back-references in the JSON (such as the focus stack). */
 691     int old_id;
 692
 693     /* Depth of the container window */
 694     uint16_t depth;
 695 };