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
|
2011-05-23 12:41:17 -04:00
|
|
|
|
* © 2009-2011 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
|
|
|
|
*/
|
2010-03-02 06:47:21 -05:00
|
|
|
|
#include <xcb/randr.h>
|
2009-04-19 14:44:34 -04:00
|
|
|
|
#include <xcb/xcb_atom.h>
|
2009-02-14 02:38:07 -05:00
|
|
|
|
#include <stdbool.h>
|
2011-09-10 18:53:11 -04:00
|
|
|
|
#include <pcre.h>
|
2009-02-07 22:04:35 -05:00
|
|
|
|
|
|
|
|
|
#ifndef _DATA_H
|
|
|
|
|
#define _DATA_H
|
2009-02-24 08:18:08 -05:00
|
|
|
|
#include "queue.h"
|
|
|
|
|
|
2009-02-06 11:49:45 -05:00
|
|
|
|
/*
|
2009-06-29 15:54:51 -04:00
|
|
|
|
* To get the big concept: There are helper structures like struct Colorpixel
|
|
|
|
|
* or struct Stack_Window. Everything which is also defined as type (see
|
|
|
|
|
* forward definitions) is considered to be a major structure, thus important.
|
2009-02-24 08:18:08 -05:00
|
|
|
|
*
|
|
|
|
|
* Let’s start from the biggest to the smallest:
|
|
|
|
|
*
|
2010-03-27 10:25:51 -04:00
|
|
|
|
* TODO
|
2009-02-06 11:49:45 -05:00
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2009-02-07 20:39:56 -05:00
|
|
|
|
/* Forward definitions */
|
2009-02-09 23:50:35 -05:00
|
|
|
|
typedef struct Font i3Font;
|
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;
|
2011-01-06 21:01:58 -05:00
|
|
|
|
typedef enum { BS_NORMAL = 0, BS_NONE = 1, BS_1PIXEL = 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;
|
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
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;
|
|
|
|
|
bool con_is_leaf;
|
|
|
|
|
xcb_font_t font;
|
|
|
|
|
};
|
|
|
|
|
|
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-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 {
|
|
|
|
|
const char *pattern;
|
|
|
|
|
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
|
|
|
|
|
* command which is executed as soon as the key is pressed (see src/command.c)
|
2009-02-06 12:23:37 -05:00
|
|
|
|
*
|
|
|
|
|
*/
|
2009-02-10 14:49:47 -05:00
|
|
|
|
struct Binding {
|
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
|
|
|
|
uint32_t number_keycodes;
|
2009-08-07 09:35:12 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Keycode to bind */
|
|
|
|
|
uint32_t keycode;
|
2009-08-07 09:35:12 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Bitmask consisting of BIND_MOD_1, BIND_MODE_SWITCH, … */
|
|
|
|
|
uint32_t mods;
|
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;
|
|
|
|
|
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
|
|
|
|
/**
|
2009-03-01 16:00:54 -05:00
|
|
|
|
* Data structure for cached font information:
|
|
|
|
|
* - font id in X11 (load it once)
|
|
|
|
|
* - font height (multiple calls needed to get it)
|
2009-02-06 12:23:37 -05:00
|
|
|
|
*
|
|
|
|
|
*/
|
2009-02-07 20:39:56 -05:00
|
|
|
|
struct Font {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** The height of the font, built from font_ascent + font_descent */
|
|
|
|
|
int height;
|
|
|
|
|
/** The xcb-id for the font */
|
|
|
|
|
xcb_font_t id;
|
2009-02-07 20:39:56 -05:00
|
|
|
|
};
|
2009-02-06 12:23:37 -05:00
|
|
|
|
|
2009-02-07 22:04:35 -05: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;
|
|
|
|
|
/** Name of the output */
|
|
|
|
|
char *name;
|
2010-03-02 06:47:21 -05:00
|
|
|
|
|
2010-11-21 16:12:34 -05:00
|
|
|
|
/** Pointer to the Con which represents this output */
|
|
|
|
|
Con *con;
|
|
|
|
|
|
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
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
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
|
|
|
|
|
2010-04-13 11:46:54 -04:00
|
|
|
|
char *class_class;
|
|
|
|
|
char *class_instance;
|
|
|
|
|
|
2010-08-15 06:18:05 -04:00
|
|
|
|
/** The name of the window as it will be passed to X11 (in UCS2 if the
|
2010-04-13 11:46:54 -04:00
|
|
|
|
* application supports _NET_WM_NAME, in COMPOUND_TEXT otherwise). */
|
|
|
|
|
char *name_x;
|
|
|
|
|
|
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
|
|
|
|
/** The name of the window as used in JSON (in UTF-8 if the application
|
|
|
|
|
* supports _NET_WM_NAME, in COMPOUND_TEXT otherwise) */
|
|
|
|
|
char *name_json;
|
|
|
|
|
|
|
|
|
|
/** The length of the name in glyphs (not bytes) */
|
2010-04-13 11:22:34 -04:00
|
|
|
|
int name_len;
|
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;
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
/** Pixels the window reserves. left/right/top/bottom */
|
|
|
|
|
struct reservedpx reserved;
|
2011-05-15 14:10:25 -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-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;
|
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 09:30:07 -04:00
|
|
|
|
Con *con_id;
|
2010-04-16 16:57:21 -04:00
|
|
|
|
enum { M_ANY = 0, M_TILING, M_FLOATING } floating;
|
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
|
|
|
|
|
|
|
|
|
TAILQ_ENTRY(Match) matches;
|
|
|
|
|
};
|
|
|
|
|
|
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
|
|
|
|
|
* example -- make specific windows floating or 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-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
|
|
|
|
};
|
|
|
|
|
|
2010-03-27 10:25:51 -04:00
|
|
|
|
struct Con {
|
|
|
|
|
bool mapped;
|
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;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
orientation_t orientation;
|
|
|
|
|
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-11-21 17:35:49 -05: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-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;
|
|
|
|
|
|
2010-10-11 15:32:04 -04:00
|
|
|
|
/* proportional width/height, calculated from WM_NORMAL_HINTS, used to
|
|
|
|
|
* apply an aspect ratio to windows (think of MPlayer) */
|
|
|
|
|
int proportional_width;
|
|
|
|
|
int proportional_height;
|
|
|
|
|
/* 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;
|
|
|
|
|
|
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;
|
|
|
|
|
|
2010-06-02 11:51:58 -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;
|
|
|
|
|
|
2011-03-20 09:07:16 -04:00
|
|
|
|
/* ids/pixmap/graphics context for the frame window */
|
2010-03-27 10:25:51 -04:00
|
|
|
|
xcb_window_t frame;
|
2011-03-20 09:07:16 -04:00
|
|
|
|
xcb_pixmap_t pixmap;
|
|
|
|
|
xcb_gcontext_t pm_gc;
|
|
|
|
|
bool pixmap_recreated;
|
|
|
|
|
|
|
|
|
|
/** 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;
|
2011-02-20 17:43:03 -05:00
|
|
|
|
enum { L_DEFAULT = 0, L_STACKED = 1, L_TABBED = 2, L_DOCKAREA = 3, L_OUTPUT = 4 } 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;
|
|
|
|
|
|
2010-11-20 13:11:43 -05:00
|
|
|
|
/** 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;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
|
|
|
|
|
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 *);
|
2010-03-27 10:25:51 -04:00
|
|
|
|
};
|
|
|
|
|
|
2009-02-07 22:04:35 -05:00
|
|
|
|
#endif
|