2 #define I3__FILE__ "floating.c"
14 extern xcb_connection_t *
conn;
23 Rect outputs_dimensions = {0, 0, 0, 0};
28 return outputs_dimensions;
39 const int floating_sane_min_height = 50;
40 const int floating_sane_min_width = 75;
41 Rect floating_sane_max_dimensions;
106 bool set_focus = (con ==
focused);
109 LOG(
"Container is a dock window, not enabling floating mode.\n");
114 LOG(
"Container is already in floating mode, not doing anything.\n");
122 if (con->
type == CT_WORKSPACE) {
123 LOG(
"This is a workspace, creating new container around content\n");
125 LOG(
"Workspace is empty, aborting\n");
135 memcpy(&(new->rect), &(con->
rect),
sizeof(
Rect));
138 if (old_focused ==
TAILQ_END(&(con->focus_head)))
142 DLOG(
"Moving cons\n");
151 DLOG(
"Attaching new split to ws\n");
176 nc->
type = CT_FLOATING_CON;
187 DLOG(
"Old container empty after setting this child to floating, closing\n");
192 sasprintf(&name,
"[i3 con] floatingcon around %p", con);
201 Rect zero = {0, 0, 0, 0};
205 if (memcmp(&(nc->
rect), &zero,
sizeof(
Rect)) == 0) {
206 DLOG(
"Geometry not set, combining children\n");
248 DLOG(
"Centering above leader\n");
265 if (!current_output || current_output->
con != correct_output) {
266 DLOG(
"This floating window is on the wrong output, fixing coordinates (currently (%d, %d))\n",
285 nc->
rect.
y -= deco_height;
287 DLOG(
"Corrected y = %d (deco_height = %d)\n", nc->
rect.
y, deco_height);
308 ELOG(
"No output found at destination coordinates, centering floating window on current ws\n");
315 LOG(
"Container isn't floating, not doing anything.\n");
319 const bool set_focus = (con ==
focused);
338 if (focused->
type == CT_WORKSPACE)
366 LOG(
"already floating, re-setting to tiling\n");
380 DLOG(
"Raising floating con %p / %s\n", con, con->
name);
396 ELOG(
"No output found at destination coordinates?\n");
401 DLOG(
"still the same ws\n");
405 DLOG(
"Need to re-assign!\n");
409 DLOG(
"Moving con %p / %s to workspace %p / %s\n", con, con->
name, ws, ws->
name);
416 const struct xcb_button_press_event_t *
event = extra;
419 con->rect.x = old_rect->x + (new_x -
event->root_x);
420 con->rect.y = old_rect->y + (new_y -
event->root_y);
440 DLOG(
"floating_drag_window\n");
473 const xcb_button_press_event_t *
event;
478 const xcb_button_press_event_t *
event = params->
event;
481 int32_t dest_x = con->rect.x;
482 int32_t dest_y = con->rect.y;
484 uint32_t dest_height;
486 double ratio = (double)old_rect->width / old_rect->height;
491 dest_width = old_rect->width - (new_x -
event->root_x);
493 dest_width = old_rect->width + (new_x -
event->root_x);
496 dest_height = old_rect->height - (new_y -
event->root_y);
498 dest_height = old_rect->height + (new_y -
event->root_y);
502 dest_width =
max(dest_width, (
int)(dest_height * ratio));
503 dest_height =
max(dest_height, (
int)(dest_width / ratio));
506 con->rect = (
Rect) {dest_x, dest_y, dest_width, dest_height};
513 if (corner & BORDER_LEFT)
514 dest_x = old_rect->x + (old_rect->width - con->rect.width);
516 if (corner & BORDER_TOP)
517 dest_y = old_rect->y + (old_rect->height - con->rect.height);
519 con->rect.x = dest_x;
520 con->rect.y = dest_y;
535 const xcb_button_press_event_t *
event) {
536 DLOG(
"floating_resize_window\n");
542 if (event->event_x <= (int16_t)(con->
rect.
width / 2))
548 if (event->event_y <= (int16_t)(con->
rect.
height / 2)) {
595 xcb_motion_notify_event_t *last_motion_notify = NULL;
596 xcb_generic_event_t *event;
598 while ((event = xcb_poll_for_event(
conn)) != NULL) {
599 if (event->response_type == 0) {
600 xcb_generic_error_t *error = (xcb_generic_error_t *)event;
601 DLOG(
"X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
602 error->sequence, error->error_code);
608 int type = (
event->response_type & 0x7F);
611 case XCB_BUTTON_RELEASE:
616 DLOG(
"A key was pressed during drag, reverting changes.");
621 case XCB_UNMAP_NOTIFY: {
622 xcb_unmap_notify_event_t *unmap_event = (xcb_unmap_notify_event_t *)event;
626 DLOG(
"UnmapNotify for window 0x%08x (container %p)\n", unmap_event->window, con);
629 DLOG(
"UnmapNotify for a managed window on the current workspace, aborting\n");
638 case XCB_MOTION_NOTIFY:
640 FREE(last_motion_notify);
641 last_motion_notify = (xcb_motion_notify_event_t *)event;
645 DLOG(
"Passing to original handler\n");
650 if (last_motion_notify != (xcb_motion_notify_event_t *)event)
657 if (last_motion_notify == NULL)
663 last_motion_notify->root_x,
664 last_motion_notify->root_y,
666 free(last_motion_notify);
683 xcb_grab_pointer_cookie_t cookie;
684 xcb_grab_pointer_reply_t *reply;
685 xcb_generic_error_t *error;
687 cookie = xcb_grab_pointer(
conn,
690 XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION,
697 if ((reply = xcb_grab_pointer_reply(
conn, cookie, &error)) == NULL) {
698 ELOG(
"Could not grab pointer (error_code = %d)\n", error->error_code);
706 xcb_grab_keyboard_cookie_t keyb_cookie;
707 xcb_grab_keyboard_reply_t *keyb_reply;
709 keyb_cookie = xcb_grab_keyboard(
conn,
717 if ((keyb_reply = xcb_grab_keyboard_reply(
conn, keyb_cookie, &error)) == NULL) {
718 ELOG(
"Could not grab keyboard (error_code = %d)\n", error->error_code);
720 xcb_ungrab_pointer(
conn, XCB_CURRENT_TIME);
745 xcb_ungrab_keyboard(
conn, XCB_CURRENT_TIME);
746 xcb_ungrab_pointer(
conn, XCB_CURRENT_TIME);
763 ELOG(
"No output found at destination coordinates. Not repositioning.\n");
784 DLOG(
"Fixing coordinates of floating window %p (rect (%d, %d), %d x %d)\n",
786 DLOG(
"old_rect = (%d, %d), %d x %d\n",
787 old_rect->
x, old_rect->
y, old_rect->
width, old_rect->
height);
788 DLOG(
"new_rect = (%d, %d), %d x %d\n",
789 new_rect->
x, new_rect->
y, new_rect->
width, new_rect->
height);
792 int32_t rel_x = con->
rect.
x - old_rect->
x + (int32_t)(con->
rect.
width / 2);
793 int32_t rel_y = con->
rect.
y - old_rect->
y + (int32_t)(con->
rect.
height / 2);
796 DLOG(
"rel_x = %d, rel_y = %d, fraction_x = %f, fraction_y = %f, output->w = %d, output->h = %d\n",
797 rel_x, rel_y, (
double)rel_x / old_rect->
width, (
double)rel_y / old_rect->
height,
800 con->
rect.
x = (int32_t)new_rect->
x + (
double)(rel_x * (int32_t)new_rect->
width) / (int32_t)old_rect->
width - (int32_t)(con->
rect.
width / 2);
801 con->
rect.
y = (int32_t)new_rect->
y + (
double)(rel_y * (int32_t)new_rect->
height) / (int32_t)old_rect->
height - (int32_t)(con->
rect.
height / 2);
802 DLOG(
"Resulting coordinates: x = %d, y = %d\n", con->
rect.
x, con->
rect.
y);
810 void floating_move(xcb_connection_t *
conn, Client *currently_focused,
direction_t direction) {
811 DLOG(
"floating move\n");
813 Rect destination = currently_focused->rect;
814 Rect *screen = &(currently_focused->workspace->output->rect);
835 if ((int32_t)(destination.
x + destination.
width - 5) <= (int32_t)screen->
x ||
836 (int32_t)(destination.
x + 5) >= (int32_t)(screen->
x + screen->
width) ||
837 (int32_t)(destination.
y + destination.
height - 5) <= (int32_t)screen->
y ||
838 (int32_t)(destination.
y + 5) >= (int32_t)(screen->
y + screen->
height)) {
839 DLOG(
"boundary check failed, not moving\n");
843 currently_focused->rect = destination;
844 reposition_client(conn, currently_focused);
857 void floating_toggle_hide(xcb_connection_t *conn, Workspace *workspace) {
860 workspace->floating_hidden = !workspace->floating_hidden;
861 DLOG(
"floating_hidden is now: %d\n", workspace->floating_hidden);
862 TAILQ_FOREACH(client, &(workspace->floating_clients), floating_clients) {
863 if (workspace->floating_hidden)
864 client_unmap(conn, client);
865 else client_map(conn, client);
870 if (workspace->floating_hidden)
871 SLIST_FOREACH(client, &(workspace->focus_stack), focus_clients) {
872 if (client_is_floating(client))
874 set_focus(conn, client,
true);
enum Con::@20 scratchpad_state
static Rect total_outputs_dimensions(void)
void floating_resize_window(Con *con, const bool proportional, const xcb_button_press_event_t *event)
Called when the user clicked on a floating window while holding the floating_modifier and the right m...
bool floating_maybe_reassign_ws(Con *con)
Checks if con’s coordinates are within its workspace and re-assigns it to the actual workspace if not...
#define SLIST_FOREACH(var, head, field)
bool con_is_floating(Con *con)
Returns true if the node is floating.
void tree_render(void)
Renders the tree, that is rendering all outputs using render_con() and pushing the changes to X11 usi...
#define TAILQ_REMOVE(head, elm, field)
void con_attach(Con *con, Con *parent, bool ignore_focus)
Attaches the given container to the given parent.
int32_t floating_minimum_width
int render_deco_height(void)
Con * con_get_workspace(Con *con)
Gets the workspace container this node is on.
int32_t floating_maximum_height
Stores a rectangle, for example the size of a window, the child window etc.
void con_detach(Con *con)
Detaches the given container from its current parent.
void floating_disable(Con *con, bool automatic)
Disables floating mode for the given container by re-attaching the container to its old parent...
void floating_drag_window(Con *con, const xcb_button_press_event_t *event)
Called when the user clicked on the titlebar of a floating window.
Con * con_descend_focused(Con *con)
Returns the focused con inside this client, descending the tree as far as possible.
Rect rect
x, y, width, height
void x_push_node(Con *con)
This function pushes the properties of each node of the layout tree to X11 if they have changed (like...
int32_t floating_maximum_width
Maximum and minimum dimensions of a floating window.
void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp)
Moves the given container to the currently focused container on the given workspace.
Con * con_descend_tiling_focused(Con *con)
Returns the focused con inside this client, descending the tree as far as possible.
struct ev_loop * main_loop
#define TAILQ_FIRST(head)
drag_result_t
This is the return value of a drag operation like drag_pointer.
An Output is a physical output on your graphics driver.
void floating_reposition(Con *con, Rect newrect)
Repositions the CT_FLOATING_CON to have the coordinates specified by newrect, but only if the coordin...
Con * con_new(Con *parent, i3Window *window)
enum Con::@19 floating
floating? (= not in tiling layout) This cannot be simply a bool because we want to keep track of whet...
border_style_t border_style
void x_set_warp_to(Rect *rect)
Set warp_to coordinates.
Con * con_by_window_id(xcb_window_t window)
Returns the container with the given client window ID or NULL if no such container exists...
border_t
On which border was the dragging initiated?
int sasprintf(char **strp, const char *fmt,...)
Safe-wrapper around asprintf which exits if it returns -1 (meaning that there is no more memory avail...
void floating_raise_con(Con *con)
Raises the given container in the list of floating containers.
void floating_check_size(Con *floating_con)
Called when a floating window is created or resized.
drag_result_t drag_pointer(Con *con, const xcb_button_press_event_t *event, xcb_window_t confine_to, border_t border, int cursor, callback_t callback, const void *extra)
This function grabs your pointer and keyboard and lets you drag stuff around (borders).
bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool force_set_focus)
Closes the given container including all children.
Rect con_border_style_rect(Con *con)
Returns a "relative" Rect which contains the amount of pixels that need to be added to the original R...
struct outputs_head outputs
Con * con
Pointer to the Con which represents this output.
struct Rect geometry
the geometry this window requested when getting mapped
void x_push_changes(Con *con)
Pushes all changes (state of each node, see x_push_node() and the window stack) to X11...
bool contained_by_output(Rect rect)
void(* callback_t)(Con *, Rect *, uint32_t, uint32_t, const void *)
Callback for dragging.
void main_set_x11_cb(bool enable)
Enable or disable the main X11 event handling function.
void x_set_name(Con *con, const char *name)
Sets the WM_NAME property (so, no UTF8, but used only for debugging anyways) of the given name...
xcb_cursor_t xcursor_get_cursor(enum xcursor_cursor_t c)
void con_focus(Con *con)
Sets input focus to the given container.
#define TAILQ_EMPTY(head)
int con_num_children(Con *con)
Returns the number of children of this container.
DRAGGING_CB(drag_window_callback)
A 'Con' represents everything from the X11 root window down to a single X11 window.
static void xcb_drag_check_cb(EV_P_ ev_check *w, int revents)
Output * get_output_containing(unsigned int x, unsigned int y)
Returns the active (!) output which contains the coordinates x, y or NULL if there is no output which...
border_style_t default_floating_border
The default border style for new floating windows.
void fake_absolute_configure_notify(Con *con)
Generates a configure_notify_event with absolute coordinates (relative to the X root window...
#define TAILQ_INSERT_TAIL(head, elm, field)
int con_border_style(Con *con)
Use this function to get a container’s border style.
Con * output_get_content(Con *output)
Returns the output container below the given output container.
Con * con_get_output(Con *con)
Gets the output container (first container with CT_OUTPUT in hierarchy) this node is on...
int32_t floating_minimum_height
void floating_enable(Con *con, bool automatic)
Enables floating mode for the given container by detaching it from its parent, creating a new contain...
void floating_fix_coordinates(Con *con, Rect *old_rect, Rect *new_rect)
Fixes the coordinates of the floating window whenever the window gets reassigned to a different outpu...
#define TAILQ_FOREACH(var, head, field)
void con_fix_percent(Con *con)
Updates the percent attribute of the children of the given container.
void toggle_floating_mode(Con *con, bool automatic)
Calls floating_enable() for tiling containers and floating_disable() for floating containers...
xcb_window_t leader
Holds the xcb_window_t (just an ID) for the leader window (logical parent for toolwindows and similar...
const xcb_button_press_event_t * event
void render_con(Con *con, bool render_fullscreen)
"Renders" the given container (and its children), meaning that all rects are updated correctly...
void handle_event(int type, xcb_generic_event_t *event)
Takes an xcb_generic_event_t and calls the appropriate handler, based on the event type...