koma/i3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first step of the big refactoring ("tree" branch).

Browse Source 
From here on, we can track changes. It made no sense to put the
development up to this point into git.
This commit is contained in:
Michael Stapelberg
2010-03-27 15:25:51 +01:00
parent 41b6631f68
commit c145f7e529
48 changed files with 2583 additions and 1270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
include/all.h Normal file
View File

@ -0,0 +1,52 @@
/*
* This header file includes all relevant files of i3 and the most often used
* system header files. This reduces boilerplate (the amount of code duplicated
* at the beginning of each source file) and is not significantly slower at
* compile-time.
*
*/
#ifndef _ALL_H
#define _ALL_H
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <locale.h>
#include <getopt.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <glob.h>
#include <errno.h>
#include <err.h>
#include <stdint.h>
#include <xcb/xcb.h>
#include <xcb/xcb_aux.h>
#include <xcb/xcb_event.h>
#include <xcb/xcb_keysyms.h>
#include <xcb/xcb_icccm.h>
#include "util.h"
#include "commands.h"
#include "ipc.h"
#include "tree.h"
#include "log.h"
#include "xcb.h"
#include "manage.h"
#include "workspace.h"
#include "i3.h"
#include "x.h"
#include "click.h"
#include "floating.h"
#include "config.h"
#include "handlers.h"
#include "randr.h"
#include "xinerama.h"
#include "con.h"
#include "load_layout.h"
#include "render.h"
#endif

4
include/commands.h
View File

@ -13,10 +13,12 @@
#include <xcb/xcb.h>
#if 0
bool focus_window_in_container(xcb_connection_t *conn, Container *container,
direction_t direction);
#endif
/** Parses a command, see file CMDMODE for more information */
void parse_command(xcb_connection_t *conn, const char *command);
void parse_command(const char *command);
#endif

20
include/con.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef _CON_H
#define _CON_H
Con *con_new(Con *parent);
bool con_is_leaf(Con *con);
bool con_accepts_window(Con *con);
Con *con_get_output(Con *con);
Con *con_get_workspace(Con *con);
Con *con_get_fullscreen_con(Con *con);
bool con_is_floating(Con *con);
Con *con_by_window_id(xcb_window_t window);
Con *con_by_frame_id(xcb_window_t frame);
Con *con_for_window(i3Window *window, Match **store_match);
void con_attach(Con *con, Con *parent);
void con_detach(Con *con);
enum { WINDOW_ADD = 0, WINDOW_REMOVE = 1 };
void con_fix_percent(Con *con, int action);
#endif

3
include/config.h
View File

@ -124,6 +124,9 @@ struct Config {
} bar;
};
char *glob_path(const char *path);
bool path_exists(const char *path);
/**
* Reads the configuration from ~/.i3/config or /etc/i3/config if not found.
*

384
include/data.h
View File

@ -26,42 +26,25 @@
*
* Let’s start from the biggest to the smallest:
*
* - 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).
*
* - Each Output contains Workspaces. The concept is known from various
* other window managers. Basically, a workspace is a specific set of
* windows, usually grouped thematically (irc, www, work, …). You can switch
* between these.
*
* - Each Workspace has a table, which is our layout abstraction. You manage
* your windows by moving them around in your table. It grows as necessary.
*
* - Each cell of the table has a container, which can be in default or
* stacking mode. In default mode, each client is given equally much space
* in the container. In stacking mode, only one client is shown at a time,
* but all the titlebars are rendered at the top.
*
* - Inside the container are clients, which is X11-speak for a window.
* TODO
*
*/
/* Forward definitions */
typedef struct Cell Cell;
typedef struct Font i3Font;
typedef struct Container Container;
typedef struct Client Client;
typedef struct Binding Binding;
typedef struct Workspace Workspace;
typedef struct Rect Rect;
typedef struct xoutput Output;
typedef struct Con Con;
typedef struct Match Match;
typedef struct Window i3Window;
/******************************************************************************
* Helper types
*****************************************************************************/
typedef enum { D_LEFT, D_RIGHT, D_UP, D_DOWN } direction_t;
typedef enum { HORIZ, VERT, NO_ORIENTATION } orientation_t;
enum {
BIND_NONE = 0,
@ -94,15 +77,6 @@ struct Rect {
uint32_t height;
} __attribute__((packed));
/**
* Defines a position in the table
*
*/
struct Cell {
int row;
int column;
};
/**
* Used for the cache of colorpixels.
*
@ -129,22 +103,6 @@ struct Cached_Pixmap {
xcb_drawable_t referred_drawable;
};
/**
* Contains data for the windows needed to draw the titlebars on in stacking
* mode
*
*/
struct Stack_Window {
xcb_window_t window;
struct Cached_Pixmap pixmap;
Rect rect;
/** Backpointer to the container this stack window is in */
Container *container;
SLIST_ENTRY(Stack_Window) stack_windows;
};
struct Ignore_Event {
int sequence;
time_t added;
@ -167,86 +125,6 @@ struct keyvalue_element {
* Major types
*****************************************************************************/
/**
* The concept of Workspaces is known from various other window
* managers. Basically, a workspace is a specific set of windows, usually
* grouped thematically (irc, www, work, …). You can switch between these.
*
*/
struct Workspace {
/** Number of this workspace, starting from 0 */
int num;
/** Name of the workspace (in UTF-8) */
char *utf8_name;
/** Name of the workspace (in UCS-2) */
char *name;
/** Length of the workspace’s name (in glyphs) */
int name_len;
/** Width of the workspace’s name (in pixels) rendered in config.font */
int text_width;
/** x, y, width, height */
Rect rect;
/** table dimensions */
int cols;
/** table dimensions */
int rows;
/** These are stored here only while this workspace is _not_ shown
* (see show_workspace()) */
int current_row;
/** These are stored here only while this workspace is _not_ shown
* (see show_workspace()) */
int current_col;
/** Should clients on this workspace be automatically floating? */
bool auto_float;
/** Are the floating clients on this workspace currently hidden? */
bool floating_hidden;
/** The name of the RandR output this screen should be on */
char *preferred_output;
/** True if any client on this workspace has its urgent flag set */
bool urgent;
/** the client who is started in fullscreen mode on this workspace,
* NULL if there is none */
Client *fullscreen_client;
/** The focus stack contains the clients in the correct order of focus
so that the focus can be reverted correctly when a client is
closed */
SLIST_HEAD(focus_stack_head, Client) focus_stack;
/** This tail queue contains the floating clients in order of when
* they were first set to floating (new floating clients are just
* appended) */
TAILQ_HEAD(floating_clients_head, Client) floating_clients;
/** Backpointer to the output this workspace is on */
Output *output;
/** This is a two-dimensional dynamic array of
* Container-pointers. I’ve always wanted to be a three-star
* programmer :) */
Container ***table;
/** width_factor and height_factor contain the amount of space
* (percentage) a column/row has of all the space which is available
* for resized windows. This ensures that non-resized windows (newly
* opened, for example) have the same size as always */
float *width_factor;
float *height_factor;
TAILQ_ENTRY(Workspace) workspaces;
};
/**
* 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)
@ -329,172 +207,6 @@ struct Font {
TAILQ_ENTRY(Font) fonts;
};
/**
* A client is X11-speak for a window.
*
*/
struct Client {
/** initialized will be set to true if the client was fully
* initialized by manage_window() and all functions can be used
* normally */
bool initialized;
/** if you set a client to floating and set it back to managed, it
* does remember its old position and *tries* to get back there */
Cell old_position;
/** Backpointer. A client is inside a container */
Container *container;
/** Because dock clients don’t have a container, we have this
* workspace-backpointer */
Workspace *workspace;
/** x, y, width, height of the frame */
Rect rect;
/** Position in floating mode and in tiling mode are saved
* separately */
Rect floating_rect;
/** x, y, width, height of the child (relative to its frame) */
Rect child_rect;
/** contains the size calculated from the hints set by the window or 0
* if the client did not send any hints */
int proportional_height;
int proportional_width;
int base_height;
int base_width;
/** The amount of pixels which X will draw around the client. */
int border_width;
/** contains the minimum increment size as specified for the window
* (in pixels). */
int width_increment;
int height_increment;
/** Height which was determined by reading the _NET_WM_STRUT_PARTIAL
* top/bottom of the screen reservation */
int desired_height;
/** Name (= window title) */
char *name;
/** name_len stores the real string length (glyphs) of the window
* title if the client uses _NET_WM_NAME. Otherwise, it is set to -1
* to indicate that name should be just passed to X as 8-bit string
* and therefore will not be rendered correctly. This behaviour is to
* support legacy applications which do not set _NET_WM_NAME */
int name_len;
/** This will be set to true as soon as the first _NET_WM_NAME comes
* in. If set to true, legacy window names are ignored. */
bool uses_net_wm_name;
/** Holds the WM_CLASS (which consists of two strings, the instance
* and the class), useful for matching the client in commands */
char *window_class_instance;
char *window_class_class;
/** Holds the client’s mark, for vim-like jumping */
char *mark;
/** Holds the xcb_window_t (just an ID) for the leader window (logical
* parent for toolwindows and similar floating windows) */
xcb_window_t leader;
/** fullscreen is pretty obvious */
bool fullscreen;
/** 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 WM_CLASS to tools for example) 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;
/** Ensure TITLEBAR_TOP maps to 0 because we use calloc for
* initialization later */
enum { TITLEBAR_TOP = 0, TITLEBAR_LEFT, TITLEBAR_RIGHT, TITLEBAR_BOTTOM, TITLEBAR_OFF } titlebar_position;
/** Contains a bool specifying whether this window should not be drawn
* with the usual decorations */
bool borderless;
/** If a client is set as a dock, it is placed at the very bottom of
* the screen and its requested size is used */
bool dock;
/** True if the client set the urgency flag in its WM_HINTS property */
bool urgent;
/* After leaving fullscreen mode, a client needs to be reconfigured
* (configuration = setting X, Y, width and height). By setting the
* force_reconfigure flag, render_layout() will reconfigure the
* client. */
bool force_reconfigure;
/* When reparenting a window, an unmap-notify is sent. As we delete
* windows when they’re unmapped, we need to ignore that
* one. Therefore, this flag is set when reparenting. */
bool awaiting_useless_unmap;
/* XCB contexts */
xcb_window_t frame; /**< Our window: The frame around the
* client */
xcb_gcontext_t titlegc; /**< The titlebar’s graphic context
* inside the frame */
xcb_window_t child; /**< The client’s window */
/** The following entry provides the necessary list pointers to use
* Client with LIST_* macros */
CIRCLEQ_ENTRY(Client) clients;
SLIST_ENTRY(Client) dock_clients;
SLIST_ENTRY(Client) focus_clients;
TAILQ_ENTRY(Client) floating_clients;
};
/**
* A container is either in default, stacking or tabbed mode. There is one for
* each cell of the table.
*
*/
struct Container {
/* Those are speaking for themselves: */
Client *currently_focused;
int colspan;
int rowspan;
/* Position of the container inside our table */
int row;
int col;
/* Xinerama: X/Y of the container */
int x;
int y;
/* Width/Height of the container. Changeable by the user */
int width;
int height;
/* When in stacking mode, we draw the titlebars of each client onto a
* separate window */
struct Stack_Window stack_win;
/* Backpointer to the workspace this container is in */
Workspace *workspace;
/* Ensure MODE_DEFAULT maps to 0 because we use calloc for
* initialization later */
enum { MODE_DEFAULT = 0, MODE_STACK, MODE_TABBED } mode;
/* When in stacking, one can either have unlimited windows inside the
* container or set a limit for the rows or columns the stack window
* should display to use the screen more efficiently. */
enum { STACK_LIMIT_NONE = 0, STACK_LIMIT_COLS, STACK_LIMIT_ROWS } stack_limit;
/* The number of columns or rows to limit to, see stack_limit */
int stack_limit_value;
CIRCLEQ_HEAD(client_head, Client) clients;
};
/**
* An Output is a physical output on your graphics driver. Outputs which
@ -518,9 +230,6 @@ struct xoutput {
bool changed;
bool to_be_disabled;
/** Current workspace selected on this virtual screen */
Workspace *current_workspace;
/** x, y, width, height */
Rect rect;
@ -535,4 +244,85 @@ struct xoutput {
TAILQ_ENTRY(xoutput) outputs;
};
struct Window {
xcb_window_t id;
const char *class;
};
struct Match {
enum { M_WINDOW, M_CON } what;
char *title;
int title_len;
char *application;
char *class;
char *instance;
xcb_window_t id;
bool floating;
enum { M_GLOBAL, M_OUTPUT, M_WORKSPACE } levels;
enum { M_USER, M_RESTART } source;
/* wo das fenster eingefügt werden soll. bei here wird es direkt
* diesem Con zugewiesen, also layout saving. bei active ist es
* ein assignment, welches an der momentan fokussierten stelle einfügt */
enum { M_HERE, M_ACTIVE } insert_where;
TAILQ_ENTRY(Match) matches;
};
struct Con {
bool mapped;
enum { CT_ROOT = 0, CT_OUTPUT = 1, CT_CON = 2, CT_FLOATING_CON = 3 } type;
orientation_t orientation;
struct Con *parent;
/* parent before setting it to floating */
struct Con *old_parent;
struct Rect rect;
struct Rect window_rect;
struct Rect deco_rect;
char *name;
double percent;
struct Window *window;
/* 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;
enum { L_DEFAULT = 0, L_STACKED = 1, L_TABBED = 2 } layout;
/** 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;
TAILQ_ENTRY(Con) nodes;
TAILQ_ENTRY(Con) focused;
TAILQ_ENTRY(Con) all_cons;
TAILQ_ENTRY(Con) floating_windows;
};
#endif

21
include/floating.h
View File

@ -11,14 +11,15 @@
#ifndef _FLOATING_H
#define _FLOATING_H
#include "tree.h"
/** Callback for dragging */
typedef void(*callback_t)(xcb_connection_t*, Client*, Rect*, uint32_t, uint32_t, void*);
typedef void(*callback_t)(Con*, Rect*, uint32_t, uint32_t, void*);
/** Macro to create a callback function for dragging */
#define DRAGGING_CB(name) \
static void name(xcb_connection_t *conn, Client *client, \
Rect *old_rect, uint32_t new_x, uint32_t new_y, \
void *extra)
static void name(Con *con, Rect *old_rect, uint32_t new_x, \
uint32_t new_y, void *extra)
/** On which border was the dragging initiated? */
typedef enum { BORDER_LEFT = (1 << 0),
@ -36,9 +37,9 @@ typedef enum { BORDER_LEFT = (1 << 0),
* the user.
*
*/
void toggle_floating_mode(xcb_connection_t *conn, Client *client,
bool automatic);
void toggle_floating_mode(Con *con, bool automatic);
#if 0
/**
* Removes the floating client from its workspace and attaches it to the new
* workspace. This is centralized here because it may happen if you move it
@ -56,13 +57,14 @@ void floating_assign_to_workspace(Client *client, Workspace *new_workspace);
int floating_border_click(xcb_connection_t *conn, Client *client,
xcb_button_press_event_t *event);
#endif
/**
* Called when the user clicked on the titlebar of a floating window.
* Calls the drag_pointer function with the drag_window callback
*
*/
void floating_drag_window(xcb_connection_t *conn, Client *client,
xcb_button_press_event_t *event);
void floating_drag_window(Con *con, xcb_button_press_event_t *event);
#if 0
/**
* Called when the user clicked on a floating window while holding the
@ -97,6 +99,7 @@ void floating_move(xcb_connection_t *conn, Client *currently_focused,
*/
void floating_toggle_hide(xcb_connection_t *conn, Workspace *workspace);
#endif
/**
* This function grabs your pointer and lets you drag stuff around (borders).
* Every time you move your mouse, an XCB_MOTION_NOTIFY event will be received
@ -105,7 +108,7 @@ void floating_toggle_hide(xcb_connection_t *conn, Workspace *workspace);
* the event and the new coordinates (x, y).
*
*/
void drag_pointer(xcb_connection_t *conn, Client *client, xcb_button_press_event_t *event,
void drag_pointer(Con *con, xcb_button_press_event_t *event,
xcb_window_t confine_to, border_t border, callback_t callback,
void *extra);

2
include/handlers.h
View File

@ -21,6 +21,7 @@
int handle_key_press(void *ignored, xcb_connection_t *conn,
xcb_key_press_event_t *event);
#if 0
/**
* When the user moves the mouse pointer onto a window, this callback gets
* called.
@ -200,5 +201,6 @@ int handle_transient_for(void *data, xcb_connection_t *conn, uint8_t state,
int handle_clientleader_change(void *data, xcb_connection_t *conn,
uint8_t state, xcb_window_t window,
xcb_atom_t name, xcb_get_property_reply_t *prop);
#endif
#endif

2
include/i3.h
View File

@ -23,7 +23,7 @@
#define NUM_ATOMS 21
extern xcb_connection_t *global_conn;
extern xcb_connection_t *conn;
extern xcb_key_symbols_t *keysyms;
extern char **start_argv;
extern Display *xkbdpy;

15
include/i3/ipc.h
View File

@ -27,13 +27,8 @@
#define I3_IPC_MESSAGE_TYPE_COMMAND 0
/** Requests the current workspaces from i3 */
#define I3_IPC_MESSAGE_TYPE_GET_WORKSPACES 1
#define I3_IPC_MESSAGE_TYPE_GET_TREE 1
/** Subscribe to the specified events */
#define I3_IPC_MESSAGE_TYPE_SUBSCRIBE 2
/** Requests the current outputs from i3 */
#define I3_IPC_MESSAGE_TYPE_GET_OUTPUTS 3
/*
* Messages from i3 to clients
@ -44,13 +39,7 @@
#define I3_IPC_REPLY_TYPE_COMMAND 0
/** Workspaces reply type */
#define I3_IPC_REPLY_TYPE_WORKSPACES 1
/** Subscription reply type */
#define I3_IPC_REPLY_TYPE_SUBSCRIBE 2
/** Outputs reply type */
#define I3_IPC_REPLY_TYPE_OUTPUTS 3
#define I3_IPC_REPLY_TYPE_TREE 1
/*
* Events from i3 to clients. Events have the first bit set high.

8
include/ipc.h
View File

@ -13,6 +13,12 @@
#define _IPC_H
#include <ev.h>
#include <stdbool.h>
#include <yajl/yajl_gen.h>
#include <yajl/yajl_parse.h>
#include "data.h"
#include "tree.h"
#include "i3/ipc.h"
@ -74,4 +80,6 @@ void ipc_send_event(const char *event, uint32_t message_type, const char *payloa
*/
void ipc_shutdown();
void dump_node(yajl_gen gen, Con *con, bool inplace_restart);
#endif

6
include/load_layout.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef _LOAD_LAYOUT_H
#define _LOAD_LAYOUT_H
void tree_append_json(const char *filename);
#endif

10
include/manage.h
View File

@ -20,8 +20,7 @@
* manage them
*
*/
void manage_existing_windows(xcb_connection_t *conn, xcb_property_handlers_t
*prophs, xcb_window_t root);
void manage_existing_windows(xcb_window_t root);
/**
* Restores the geometry of each window by reparenting it to the root window
@ -31,17 +30,17 @@ void manage_existing_windows(xcb_connection_t *conn, xcb_property_handlers_t
* side-effects which are to be expected when continuing to run i3.
*
*/
void restore_geometry(xcb_connection_t *conn);
void restore_geometry();
/**
* Do some sanity checks and then reparent the window.
*
*/
void manage_window(xcb_property_handlers_t *prophs, xcb_connection_t *conn,
xcb_window_t window,
void manage_window(xcb_window_t window,
xcb_get_window_attributes_cookie_t cookie,
bool needs_to_be_mapped);
#if 0
/**
* reparent_window() gets called when a new window was opened and becomes a
* child of the root window, or it gets called by us when we manage the
@ -56,3 +55,4 @@ void reparent_window(xcb_connection_t *conn, xcb_window_t child,
uint32_t border_width);
#endif
#endif

6
include/randr.h
View File

@ -22,7 +22,7 @@ extern struct outputs_head outputs;
* XRandR information to setup workspaces for each screen.
*
*/
void initialize_randr(xcb_connection_t *conn, int *event_base);
void randr_init(int *event_base);
/**
* Disables RandR support by creating exactly one output with the size of the
@ -35,13 +35,13 @@ void disable_randr(xcb_connection_t *conn);
* Initializes the specified output, assigning the specified workspace to it.
*
*/
void initialize_output(xcb_connection_t *conn, Output *output, Workspace *workspace);
//void initialize_output(xcb_connection_t *conn, Output *output, Workspace *workspace);
/**
* (Re-)queries the outputs via RandR and stores them in the list of outputs.
*
*/
void randr_query_outputs(xcb_connection_t *conn);
void randr_query_outputs();
/**
* Returns the first output which is active.

10
include/render.h Normal file
View File

@ -0,0 +1,10 @@
/*
* vim:ts=4:sw=4:expandtab
*/
#ifndef _RENDER_H
#define _RENDER_H
void render_con(Con *con);
#endif

72
include/table.h
View File

@ -1,72 +0,0 @@
/*
* vim:ts=8:expandtab
*
* i3 - an improved dynamic tiling window manager
*
* (c) 2009 Michael Stapelberg and contributors
*
* See file LICENSE for license information.
*
*/
#include <stdbool.h>
#include <xcb/xcb.h>
#include "data.h"
#ifndef _TABLE_H
#define _TABLE_H
#define CUR_TABLE (c_ws->table)
#define CUR_CELL (CUR_TABLE[current_col][current_row])
extern Workspace *c_ws;
extern TAILQ_HEAD(workspaces_head, Workspace) *workspaces;
//extern int num_workspaces;
extern int current_col;
extern int current_row;
/** Initialize table */
void init_table();
/** Add one row to the table */
void expand_table_rows(Workspace *workspace);
/** Adds one row at the head of the table */
void expand_table_rows_at_head(Workspace *workspace);
/** Add one column to the table */
void expand_table_cols(Workspace *workspace);
/**
* Inserts one column at the table’s head
*
*/
void expand_table_cols_at_head(Workspace *workspace);
/**
* Performs simple bounds checking for the given column/row
*
*/
bool cell_exists(Workspace *ws, int col, int row);
/**
* Shrinks the table by "compacting" it, that is, removing completely empty
* rows/columns
*
*/
void cleanup_table(xcb_connection_t *conn, Workspace *workspace);
/**
* Fixes col/rowspan (makes sure there are no overlapping windows)
*
*/
void fix_colrowspan(xcb_connection_t *conn, Workspace *workspace);
/**
* Prints the table’s contents in human-readable form for debugging
*
*/
void dump_table(xcb_connection_t *conn, Workspace *workspace);
#endif

28
include/tree.h Normal file
View File

@ -0,0 +1,28 @@
/*
* vim:ts=4:sw=4:expandtab
*/
#ifndef _TREE_H
#define _TREE_H
extern Con *croot;
/* TODO: i am not sure yet how much access to the focused container should
* be permitted to source files */
extern Con *focused;
TAILQ_HEAD(all_cons_head, Con);
extern struct all_cons_head all_cons;
void tree_init();
Con *tree_open_con(Con *con);
void tree_split(Con *con, orientation_t orientation);
void con_focus(Con *con);
void level_up();
void level_down();
void tree_render();
void tree_close_con();
void tree_next(char way, orientation_t orientation);
void tree_move(char way, orientation_t orientation);
void tree_close(Con *con);
bool tree_restore();
#endif

11
include/util.h
View File

@ -62,6 +62,13 @@ void *smalloc(size_t size);
*/
void *scalloc(size_t size);
/**
* Safe-wrapper around realloc which exits if realloc returns NULL (meaning
* that there is no more memory available).
*
*/
void *srealloc(void *ptr, size_t size);
/**
* Safe-wrapper around strdup which exits if malloc returns NULL (meaning that
* there is no more memory available)
@ -118,6 +125,7 @@ void check_error(xcb_connection_t *conn, xcb_void_cookie_t cookie,
*/
char *convert_utf8_to_ucs2(char *input, int *real_strlen);
#if 0
/**
* Returns the client which comes next in focus stack (= was selected before) for
* the given container, optionally excluding the given client.
@ -125,7 +133,9 @@ char *convert_utf8_to_ucs2(char *input, int *real_strlen);
*/
Client *get_last_focused_client(xcb_connection_t *conn, Container *container,
Client *exclude);
#endif
#if 0
/**
* Sets the given client as focused by updating the data structures correctly,
* updating the X input focus and finally re-decorating both windows (to
@ -156,6 +166,7 @@ void switch_layout_mode(xcb_connection_t *conn, Container *container, int mode);
*/
Client *get_matching_client(xcb_connection_t *conn,
const char *window_classtitle, Client *specific);
#endif
/*
* Restart i3 in-place

10
include/workspace.h
View File

@ -11,6 +11,7 @@
#include <xcb/xcb.h>
#include "data.h"
#include "tree.h"
#include "randr.h"
#ifndef _WORKSPACE_H
@ -22,8 +23,9 @@
* memory and initializing the data structures correctly).
*
*/
Workspace *workspace_get(int number);
Con *workspace_get(const char *num);
#if 0
/**
* Sets the name (or just its number) for the given workspace. This has to
* be called for every workspace as the rendering function
@ -41,9 +43,11 @@ void workspace_set_name(Workspace *ws, const char *name);
*/
bool workspace_is_visible(Workspace *ws);
#endif
/** Switches to the given workspace */
void workspace_show(xcb_connection_t *conn, int workspace);
void workspace_show(const char *num);
#if 0
/**
* Assigns the given workspace to the given screen by correctly updating its
* state and reconfiguring all the clients on this workspace.
@ -106,5 +110,5 @@ int workspace_width(Workspace *ws);
*
*/
int workspace_height(Workspace *ws);
#endif
#endif

15
include/x.h Normal file
View File

@ -0,0 +1,15 @@
/*
* vim:ts=4:sw=4:expandtab
*/
#ifndef _X_H
#define _X_H
void x_con_init(Con *con);
void x_con_kill(Con *con);
void x_window_kill(xcb_window_t window);
void x_draw_decoration(Con *con);
void x_push_changes(Con *con);
void x_raise_con(Con *con);
#endif

4
include/xcb.h
View File

@ -85,7 +85,7 @@ i3Font *load_font(xcb_connection_t *conn, const char *pattern);
* validity. This has to be done by the caller.
*
*/
uint32_t get_colorpixel(xcb_connection_t *conn, char *hex);
uint32_t get_colorpixel(char *hex);
/**
* Convenience wrapper around xcb_create_window which takes care of depth,
@ -127,12 +127,14 @@ void xcb_draw_rect(xcb_connection_t *conn, xcb_drawable_t drawable,
*/
void fake_configure_notify(xcb_connection_t *conn, Rect r, xcb_window_t window);
#if 0
/**
* Generates a configure_notify_event with absolute coordinates (relative to
* the X root window, not to the client’s frame) for the given client.
*
*/
void fake_absolute_configure_notify(xcb_connection_t *conn, Client *client);
#endif
/**
* Finds out which modifier mask is the one for numlock, as the user may

2
include/xinerama.h
View File

@ -18,6 +18,6 @@
* Xinerama information to setup workspaces for each screen.
*
*/
void initialize_xinerama(xcb_connection_t *conn);
void xinerama_init();
#endif