X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=include%2Fcon.h;h=cf55978dd337f2fbcd7398c4544503f21aa42dee;hb=f14efe85d14553569376d8c416944eeac9379275;hp=0d4df204d33c5d41c40864fc250fefd17c415d5c;hpb=834f4d7bc29cc2e0b4b151c62c8bc468943fa2d7;p=i3%2Fi3 diff --git a/include/con.h b/include/con.h index 0d4df204..cf55978d 100644 --- a/include/con.h +++ b/include/con.h @@ -1,13 +1,27 @@ -#ifndef _CON_H -#define _CON_H +/* + * vim:ts=4:sw=4:expandtab + * + * i3 - an improved dynamic tiling window manager + * © 2009 Michael Stapelberg and contributors (see also: LICENSE) + * + * con.c: Functions which deal with containers directly (creating containers, + * searching containers, getting specific properties from containers, + * …). + * + */ +#pragma once /** * Create a new container (and attach it to the given parent, if not NULL). - * This function initializes the data structures and creates the appropriate - * X11 IDs using x_con_init(). + * This function only initializes the data structures. + * + */ +Con *con_new_skeleton(Con *parent, i3Window *window); + +/* A wrapper for con_new_skeleton, to retain the old con_new behaviour * */ -Con *con_new(Con *parent); +Con *con_new(Con *parent, i3Window *window); /** * Sets input focus to the given container. Will be updated in X11 in the next @@ -22,6 +36,37 @@ void con_focus(Con *con); */ bool con_is_leaf(Con *con); +/** + * Returns true when this con is a leaf node with a managed X11 window (e.g., + * excluding dock containers) + */ +bool con_has_managed_window(Con *con); + +/** + * Returns true if a container should be considered split. + * + */ +bool con_is_split(Con *con); + +/** + * This will only return true for containers which have some parent with + * a tabbed / stacked parent of which they are not the currently focused child. + * + */ +bool con_is_hidden(Con *con); + +/** + * Returns whether the container or any of its children is sticky. + * + */ +bool con_is_sticky(Con *con); + +/** + * Returns true if this node has regular or floating children. + * + */ +bool con_has_children(Con *con); + /** * Returns true if this node accepts a window (if the node swallows windows, * it might already have swallowed enough and cannot hold any more). @@ -53,7 +98,13 @@ Con *con_parent_with_orientation(Con *con, orientation_t orientation); * Returns the first fullscreen node below this node. * */ -Con *con_get_fullscreen_con(Con *con); +Con *con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode); + +/** + * Returns true if the container is internal, such as __i3_scratch + * + */ +bool con_is_internal(Con *con); /** * Returns true if the node is floating. @@ -68,6 +119,12 @@ bool con_is_floating(Con *con); */ Con *con_inside_floating(Con *con); +/** + * Checks if the given container is inside a focused container. + * + */ +bool con_inside_focused(Con *con); + /** * Returns the container with the given client window ID or NULL if no such * container exists. @@ -83,11 +140,18 @@ Con *con_by_window_id(xcb_window_t window); Con *con_by_frame_id(xcb_window_t frame); /** - * Returns the first container which wants to swallow this window + * Returns the container with the given mark or NULL if no such container + * exists. + * + */ +Con *con_by_mark(const char *mark); + +/** + * Returns the first container below 'con' which wants to swallow this window * TODO: priority * */ -Con *con_for_window(i3Window *window, Match **store_match); +Con *con_for_window(Con *con, i3Window *window, Match **store_match); /** * Returns the number of children of this container. @@ -126,15 +190,48 @@ void con_fix_percent(Con *con); * entered when there already is a fullscreen container on this workspace. * */ -void con_toggle_fullscreen(Con *con); +void con_toggle_fullscreen(Con *con, int fullscreen_mode); + +/** + * Enables fullscreen mode for the given container, if necessary. + * + */ +void con_enable_fullscreen(Con *con, fullscreen_mode_t fullscreen_mode); + +/** + * Disables fullscreen mode for the given container, if necessary. + * + */ +void con_disable_fullscreen(Con *con); /** * Moves the given container to the currently focused container on the given * workspace. + * + * The fix_coordinates flag will translate the current coordinates (offset from + * the monitor position basically) to appropriate coordinates on the + * destination workspace. + * Not enabling this behaviour comes in handy when this function gets called by + * floating_maybe_reassign_ws, which will only "move" a floating window when it + * *already* changed its coordinates to a different output. + * + * The dont_warp flag disables pointer warping and will be set when this + * function is called while dragging a floating window. + * + * If ignore_focus is set, the container will be moved without modifying focus + * at all. + * * TODO: is there a better place for this function? * */ -void con_move_to_workspace(Con *con, Con *workspace); +void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, + bool dont_warp, bool ignore_focus); + +/** + * Moves the given container to the given mark. + * + */ +bool con_move_to_mark(Con *con, const char *mark); /** * Returns the orientation of the given container (for stacked containers, @@ -142,7 +239,7 @@ void con_move_to_workspace(Con *con, Con *workspace); * container). * */ -int con_orientation(Con *con); +orientation_t con_orientation(Con *con); /** * Returns the container which will be focused next when the given container @@ -167,6 +264,24 @@ Con *con_get_next(Con *con, char way, orientation_t orientation); */ Con *con_descend_focused(Con *con); +/** + * Returns the focused con inside this client, descending the tree as far as + * possible. This comes in handy when attaching a con to a workspace at the + * currently focused position, for example. + * + * Works like con_descend_focused but considers only tiling cons. + * + */ +Con *con_descend_tiling_focused(Con *con); + +/* + * Returns the leftmost, rightmost, etc. container in sub-tree. For example, if + * direction is D_LEFT, then we return the rightmost container and if direction + * is D_RIGHT, we return the leftmost container. This is because if we are + * moving D_LEFT, and thus want the rightmost container. + */ +Con *con_descend_direction(Con *con, direction_t direction); + /** * Returns a "relative" Rect which contains the amount of pixels that need to * be added to the original Rect to get the final position (obviously the @@ -175,6 +290,12 @@ Con *con_descend_focused(Con *con); */ Rect con_border_style_rect(Con *con); +/** + * Returns adjacent borders of the window. We need this if hide_edge_borders is + * enabled. + */ +adjacent_t con_adjacent_borders(Con *con); + /** * Use this function to get a container’s border style. This is important * because when inside a stack, the border style is always BS_NORMAL. @@ -182,15 +303,92 @@ Rect con_border_style_rect(Con *con); * borderless and the only element in the tabbed container, the border is not * rendered. * + * For children of a CT_DOCKAREA, the border style is always none. + * */ int con_border_style(Con *con); +/** + * Sets the given border style on con, correctly keeping the position/size of a + * floating window. + * + */ +void con_set_border_style(Con *con, int border_style, int border_width); + /** * This function changes the layout of a given container. Use it to handle * special cases like changing a whole workspace to stacked/tabbed (creates a * new split container before). * */ -void con_set_layout(Con *con, int layout); +void con_set_layout(Con *con, layout_t layout); + +/** + * This function toggles the layout of a given container. toggle_mode can be + * either 'default' (toggle only between stacked/tabbed/last_split_layout), + * 'split' (toggle only between splitv/splith) or 'all' (toggle between all + * layouts). + * + */ +void con_toggle_layout(Con *con, const char *toggle_mode); + +/** + * Determines the minimum size of the given con by looking at its children (for + * split/stacked/tabbed cons). Will be called when resizing floating cons + * + */ +Rect con_minimum_size(Con *con); -#endif +/** + * Returns true if changing the focus to con would be allowed considering + * the fullscreen focus constraints. Specifically, if a fullscreen container or + * any of its descendants is focused, this function returns true if and only if + * focusing con would mean that focus would still be visible on screen, i.e., + * the newly focused container would not be obscured by a fullscreen container. + * + * In the simplest case, if a fullscreen container or any of its descendants is + * fullscreen, this functions returns true if con is the fullscreen container + * itself or any of its descendants, as this means focus wouldn't escape the + * boundaries of the fullscreen container. + * + * In case the fullscreen container is of type CF_OUTPUT, this function returns + * true if con is on a different workspace, as focus wouldn't be obscured by + * the fullscreen container that is constrained to a different workspace. + * + * Note that this same logic can be applied to moving containers. If a + * container can be focused under the fullscreen focus constraints, it can also + * become a parent or sibling to the currently focused container. + * + */ +bool con_fullscreen_permits_focusing(Con *con); + +/** + * Checks if the given container has an urgent child. + * + */ +bool con_has_urgent_child(Con *con); + +/** + * Make all parent containers urgent if con is urgent or clear the urgent flag + * of all parent containers if there are no more urgent children left. + * + */ +void con_update_parents_urgency(Con *con); + +/** + * Set urgency flag to the container, all the parent containers and the workspace. + * + */ +void con_set_urgency(Con *con, bool urgent); + +/** + * Create a string representing the subtree under con. + * + */ +char *con_get_tree_representation(Con *con); + +/** + * force parent split containers to be redrawn + * + */ +void con_force_split_parents_redraw(Con *con);