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
|
2010-04-13 11:52:23 -04:00
|
|
|
|
* © 2009-2010 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
|
|
|
|
*/
|
2009-02-07 22:04:35 -05:00
|
|
|
|
#include <xcb/xcb.h>
|
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>
|
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;
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2009-06-29 15:54:51 -04:00
|
|
|
|
/**
|
2009-02-24 08:18:08 -05:00
|
|
|
|
* Used for the cache of colorpixels.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct Colorpixel {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
uint32_t pixel;
|
|
|
|
|
char *hex;
|
|
|
|
|
SLIST_ENTRY(Colorpixel) colorpixels;
|
2009-02-24 08:18:08 -05:00
|
|
|
|
};
|
|
|
|
|
|
2009-07-17 12:32:40 -04:00
|
|
|
|
struct Cached_Pixmap {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
xcb_pixmap_t id;
|
2009-07-17 12:32:40 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/* We’re going to paint on it, so a graphics context will be needed */
|
|
|
|
|
xcb_gcontext_t gc;
|
2009-07-17 12:32:40 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/* The rect with which the pixmap was created */
|
|
|
|
|
Rect rect;
|
2009-07-17 12:32:40 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/* The rect of the object to which this pixmap belongs. Necessary to
|
|
|
|
|
* find out when we need to re-create the pixmap. */
|
|
|
|
|
Rect *referred_rect;
|
2009-07-17 12:32:40 -04:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
xcb_drawable_t referred_drawable;
|
2009-07-17 12:32:40 -04:00
|
|
|
|
};
|
|
|
|
|
|
2009-03-09 19:51:15 -04:00
|
|
|
|
struct Ignore_Event {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
int sequence;
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
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
|
|
|
|
/**
|
2009-03-29 08:53:48 -04:00
|
|
|
|
* Holds a command specified by an exec-line in the config (see src/config.c)
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct Autostart {
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Command, like in command mode */
|
|
|
|
|
char *command;
|
|
|
|
|
TAILQ_ENTRY(Autostart) autostarts;
|
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 name of the font, that is what the pattern resolves to */
|
|
|
|
|
char *name;
|
|
|
|
|
/** A copy of the pattern to build a cache */
|
|
|
|
|
char *pattern;
|
|
|
|
|
/** The height of the font, built from font_ascent + font_descent */
|
|
|
|
|
int height;
|
|
|
|
|
/** The xcb-id for the font */
|
|
|
|
|
xcb_font_t id;
|
|
|
|
|
|
|
|
|
|
TAILQ_ENTRY(Font) fonts;
|
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
|
|
|
|
|
2011-01-04 18:16:10 -05:00
|
|
|
|
#if 0
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** The bar window */
|
|
|
|
|
xcb_window_t bar;
|
|
|
|
|
xcb_gcontext_t bargc;
|
2009-03-04 06:09:43 -05:00
|
|
|
|
|
2010-04-13 11:52:23 -04:00
|
|
|
|
/** Contains all clients with _NET_WM_WINDOW_TYPE ==
|
|
|
|
|
* _NET_WM_WINDOW_TYPE_DOCK */
|
|
|
|
|
SLIST_HEAD(dock_clients_head, Client) dock_clients;
|
2011-01-04 18:16:10 -05:00
|
|
|
|
#endif
|
2009-04-11 08:29:15 -04: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;
|
|
|
|
|
|
|
|
|
|
/** 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
|
|
|
|
|
|
|
|
|
/** Whether the window says it is a dock window */
|
|
|
|
|
bool dock;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct Match {
|
|
|
|
|
enum { M_WINDOW, M_CON } what;
|
|
|
|
|
|
|
|
|
|
char *title;
|
|
|
|
|
int title_len;
|
|
|
|
|
char *application;
|
|
|
|
|
char *class;
|
|
|
|
|
char *instance;
|
2010-06-02 17:32:05 -04:00
|
|
|
|
char *mark;
|
2010-08-15 06:18:27 -04:00
|
|
|
|
int 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
|
|
|
|
|
2010-04-16 16:57:21 -04:00
|
|
|
|
enum { M_GLOBAL = 0, M_OUTPUT, M_WORKSPACE } levels;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
|
2010-04-16 16:57:21 -04:00
|
|
|
|
enum { M_USER = 0, M_RESTART } source;
|
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)
|
|
|
|
|
* M_ACTIVE = the window will be inserted next to the currently focused
|
|
|
|
|
* container below the matched container
|
|
|
|
|
* (assignments)
|
|
|
|
|
* M_BELOW = the window will be inserted as a child of the matched container
|
|
|
|
|
* (dockareas)
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
enum { M_HERE = 0, M_ACTIVE, M_BELOW } insert_where;
|
2010-03-27 10:25:51 -04:00
|
|
|
|
|
|
|
|
|
TAILQ_ENTRY(Match) matches;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
2010-03-27 10:25:51 -04:00
|
|
|
|
/* ids/gc for the frame window */
|
|
|
|
|
xcb_window_t frame;
|
|
|
|
|
xcb_gcontext_t gc;
|
|
|
|
|
|
|
|
|
|
/* 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
|