* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
*
* floating.c: Floating windows.
*
*
*/
static Rect total_outputs_dimensions(void) {
+ if (TAILQ_EMPTY(&outputs))
+ return (Rect){0, 0, root_screen->width_in_pixels, root_screen->height_in_pixels};
+
Output *output;
/* Use Rect to encapsulate dimensions, ignoring x/y */
Rect outputs_dimensions = {0, 0, 0, 0};
Con *focused_con = con_descend_focused(floating_con);
/* obey size increments */
- if (focused_con->height_increment || focused_con->width_increment) {
+ if (focused_con->window != NULL && (focused_con->window->height_increment || focused_con->window->width_increment)) {
Rect border_rect = con_border_style_rect(focused_con);
/* We have to do the opposite calculations that render_con() do
if (con_border_style(focused_con) == BS_NORMAL)
border_rect.height += render_deco_height();
- if (focused_con->height_increment &&
- floating_con->rect.height >= focused_con->base_height + border_rect.height) {
- floating_con->rect.height -= focused_con->base_height + border_rect.height;
- floating_con->rect.height -= floating_con->rect.height % focused_con->height_increment;
- floating_con->rect.height += focused_con->base_height + border_rect.height;
+ if (focused_con->window->height_increment &&
+ floating_con->rect.height >= focused_con->window->base_height + border_rect.height) {
+ floating_con->rect.height -= focused_con->window->base_height + border_rect.height;
+ floating_con->rect.height -= floating_con->rect.height % focused_con->window->height_increment;
+ floating_con->rect.height += focused_con->window->base_height + border_rect.height;
}
- if (focused_con->width_increment &&
- floating_con->rect.width >= focused_con->base_width + border_rect.width) {
- floating_con->rect.width -= focused_con->base_width + border_rect.width;
- floating_con->rect.width -= floating_con->rect.width % focused_con->width_increment;
- floating_con->rect.width += focused_con->base_width + border_rect.width;
+ if (focused_con->window->width_increment &&
+ floating_con->rect.width >= focused_con->window->base_width + border_rect.width) {
+ floating_con->rect.width -= focused_con->window->base_width + border_rect.width;
+ floating_con->rect.width -= floating_con->rect.width % focused_con->window->width_increment;
+ floating_con->rect.width += focused_con->window->base_width + border_rect.width;
}
}
DLOG("Original rect: (%d, %d) with %d x %d\n", con->rect.x, con->rect.y, con->rect.width, con->rect.height);
DLOG("Geometry = (%d, %d) with %d x %d\n", con->geometry.x, con->geometry.y, con->geometry.width, con->geometry.height);
- Rect zero = { 0, 0, 0, 0 };
+ Rect zero = {0, 0, 0, 0};
nc->rect = con->geometry;
/* If the geometry was not set (split containers), we need to determine a
* sensible one by combining the geometry of all children */
nc->rect.width -= border_style_rect.width;
/* Add some more pixels for the title bar */
- if(con_border_style(con) == BS_NORMAL)
+ if (con_border_style(con) == BS_NORMAL)
nc->rect.height += deco_height;
/* Honor the X11 border */
if (con->window && con->window->leader != XCB_NONE &&
(leader = con_by_window_id(con->window->leader)) != NULL) {
DLOG("Centering above leader\n");
- nc->rect.x = leader->rect.x + (leader->rect.width / 2) - (nc->rect.width / 2);
- nc->rect.y = leader->rect.y + (leader->rect.height / 2) - (nc->rect.height / 2);
+ floating_center(nc, leader->rect);
} else {
/* center the window on workspace as fallback */
- nc->rect.x = ws->rect.x + (ws->rect.width / 2) - (nc->rect.width / 2);
- nc->rect.y = ws->rect.y + (ws->rect.height / 2) - (nc->rect.height / 2);
+ floating_center(nc, ws->rect);
}
}
/* Sanity check: Are the coordinates on the appropriate output? If not, we
* need to change them */
Output *current_output = get_output_containing(nc->rect.x +
- (nc->rect.width / 2), nc->rect.y + (nc->rect.height / 2));
+ (nc->rect.width / 2),
+ nc->rect.y + (nc->rect.height / 2));
Con *correct_output = con_get_output(ws);
if (!current_output || current_output->con != correct_output) {
/* Check if we need to re-assign it to a different workspace because of its
* coordinates and exit if that was done successfully. */
- if (floating_maybe_reassign_ws(nc))
+ if (floating_maybe_reassign_ws(nc)) {
+ ipc_send_window_event("floating", con);
return;
+ }
/* Sanitize coordinates: Check if they are on any output */
- if (get_output_containing(nc->rect.x, nc->rect.y) != NULL)
+ if (get_output_containing(nc->rect.x, nc->rect.y) != NULL) {
+ ipc_send_window_event("floating", con);
return;
+ }
ELOG("No output found at destination coordinates, centering floating window on current ws\n");
- nc->rect.x = ws->rect.x + (ws->rect.width / 2) - (nc->rect.width / 2);
- nc->rect.y = ws->rect.y + (ws->rect.height / 2) - (nc->rect.height / 2);
+ floating_center(nc, ws->rect);
+
+ ipc_send_window_event("floating", con);
}
void floating_disable(Con *con, bool automatic) {
* workspace itself */
if (focused->type == CT_WORKSPACE)
con->parent = focused;
- else con->parent = focused->parent;
+ else
+ con->parent = focused->parent;
/* con_fix_percent will adjust the percent value */
con->percent = 0.0;
if (set_focus)
con_focus(con);
+
+ ipc_send_window_event("floating", con);
}
/*
*
*/
void toggle_floating_mode(Con *con, bool automatic) {
+ /* forbid the command to toggle floating on a CT_FLOATING_CON */
+ if (con->type == CT_FLOATING_CON) {
+ ELOG("Cannot toggle floating mode on con = %p because it is of type CT_FLOATING_CON.\n", con);
+ return;
+ }
+
/* see if the client is already floating */
if (con_is_floating(con)) {
LOG("already floating, re-setting to tiling\n");
Con *content = output_get_content(output->con);
Con *ws = TAILQ_FIRST(&(content->focus_head));
DLOG("Moving con %p / %s to workspace %p / %s\n", con, con->name, ws, ws->name);
- con_move_to_workspace(con, ws, false, true);
+ con_move_to_workspace(con, ws, false, true, false);
con_focus(con_descend_focused(con));
return true;
}
+/*
+ * Centers a floating con above the specified rect.
+ *
+ */
+void floating_center(Con *con, Rect rect) {
+ con->rect.x = rect.x + (rect.width / 2) - (con->rect.width / 2);
+ con->rect.y = rect.y + (rect.height / 2) - (con->rect.height / 2);
+}
+
+/*
+ * Moves the given floating con to the current pointer position.
+ *
+ */
+void floating_move_to_pointer(Con *con) {
+ assert(con->type == CT_FLOATING_CON);
+
+ xcb_query_pointer_reply_t *reply = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, root), NULL);
+ if (reply == NULL) {
+ ELOG("could not query pointer position, not moving this container\n");
+ return;
+ }
+
+ Output *output = get_output_containing(reply->root_x, reply->root_y);
+ if (output == NULL) {
+ ELOG("The pointer is not on any output, cannot move the container here.\n");
+ return;
+ }
+
+ /* Determine where to put the window. */
+ int32_t x = reply->root_x - con->rect.width / 2;
+ int32_t y = reply->root_y - con->rect.height / 2;
+ FREE(reply);
+
+ /* Correct target coordinates to be in-bounds. */
+ x = MAX(x, (int32_t)output->rect.x);
+ y = MAX(y, (int32_t)output->rect.y);
+ if (x + con->rect.width > output->rect.x + output->rect.width)
+ x = output->rect.x + output->rect.width - con->rect.width;
+ if (y + con->rect.height > output->rect.y + output->rect.height)
+ y = output->rect.y + output->rect.height - con->rect.height;
+
+ /* Update container's coordinates to position it correctly. */
+ floating_reposition(con, (Rect){x, y, con->rect.width, con->rect.height});
+}
+
DRAGGING_CB(drag_window_callback) {
const struct xcb_button_press_event_t *event = extra;
uint32_t dest_width;
uint32_t dest_height;
- double ratio = (double) old_rect->width / old_rect->height;
+ double ratio = (double)old_rect->width / old_rect->height;
/* First guess: We resize by exactly the amount the mouse moved,
* taking into account in which corner the client was grabbed */
if (corner & BORDER_LEFT)
dest_width = old_rect->width - (new_x - event->root_x);
- else dest_width = old_rect->width + (new_x - event->root_x);
+ else
+ dest_width = old_rect->width + (new_x - event->root_x);
if (corner & BORDER_TOP)
dest_height = old_rect->height - (new_y - event->root_y);
- else dest_height = old_rect->height + (new_y - event->root_y);
+ else
+ dest_height = old_rect->height + (new_y - event->root_y);
/* User wants to keep proportions, so we may have to adjust our values */
if (params->proportional) {
- dest_width = max(dest_width, (int) (dest_height * ratio));
- dest_height = max(dest_height, (int) (dest_width / ratio));
+ dest_width = max(dest_width, (int)(dest_height * ratio));
+ dest_height = max(dest_height, (int)(dest_width / ratio));
}
- con->rect = (Rect) { dest_x, dest_y, dest_width, dest_height };
+ con->rect = (Rect){dest_x, dest_y, dest_width, dest_height};
/* Obey window size */
floating_check_size(con);
if (event->event_x <= (int16_t)(con->rect.width / 2))
corner |= BORDER_LEFT;
- else corner |= BORDER_RIGHT;
+ else
+ corner |= BORDER_RIGHT;
int cursor = 0;
if (event->event_y <= (int16_t)(con->rect.height / 2)) {
corner |= BORDER_TOP;
- cursor = (corner & BORDER_LEFT) ?
- XCURSOR_CURSOR_TOP_LEFT_CORNER : XCURSOR_CURSOR_TOP_RIGHT_CORNER;
- }
- else {
+ cursor = (corner & BORDER_LEFT) ? XCURSOR_CURSOR_TOP_LEFT_CORNER : XCURSOR_CURSOR_TOP_RIGHT_CORNER;
+ } else {
corner |= BORDER_BOTTOM;
- cursor = (corner & BORDER_LEFT) ?
- XCURSOR_CURSOR_BOTTOM_LEFT_CORNER : XCURSOR_CURSOR_BOTTOM_RIGHT_CORNER;
+ cursor = (corner & BORDER_LEFT) ? XCURSOR_CURSOR_BOTTOM_LEFT_CORNER : XCURSOR_CURSOR_BOTTOM_RIGHT_CORNER;
}
- struct resize_window_callback_params params = { corner, proportional, event };
+ struct resize_window_callback_params params = {corner, proportional, event};
/* get the initial rect in case of revert/cancel */
Rect initial_rect = con->rect;
};
static void xcb_drag_check_cb(EV_P_ ev_check *w, int revents) {
- struct drag_x11_cb *dragloop = (struct drag_x11_cb*)w;
+ struct drag_x11_cb *dragloop = (struct drag_x11_cb *)w;
xcb_motion_notify_event_t *last_motion_notify = NULL;
xcb_generic_event_t *event;
while ((event = xcb_poll_for_event(conn)) != NULL) {
if (event->response_type == 0) {
- xcb_generic_error_t *error = (xcb_generic_error_t*)event;
+ xcb_generic_error_t *error = (xcb_generic_error_t *)event;
DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
error->sequence, error->error_code);
free(event);
break;
case XCB_KEY_PRESS:
- DLOG("A key was pressed during drag, reverting changes.");
+ DLOG("A key was pressed during drag, reverting changes.\n");
dragloop->result = DRAG_REVERT;
handle_event(type, event);
break;
case XCB_UNMAP_NOTIFY: {
- xcb_unmap_notify_event_t *unmap_event = (xcb_unmap_notify_event_t*)event;
+ xcb_unmap_notify_event_t *unmap_event = (xcb_unmap_notify_event_t *)event;
Con *con = con_by_window_id(unmap_event->window);
if (con != NULL) {
case XCB_MOTION_NOTIFY:
/* motion_notify events are saved for later */
FREE(last_motion_notify);
- last_motion_notify = (xcb_motion_notify_event_t*)event;
+ last_motion_notify = (xcb_motion_notify_event_t *)event;
break;
default:
break;
}
- if (last_motion_notify != (xcb_motion_notify_event_t*)event)
+ if (last_motion_notify != (xcb_motion_notify_event_t *)event)
free(event);
if (dragloop->result != DRAGGING)
return;
dragloop->callback(
- dragloop->con,
- &(dragloop->old_rect),
- last_motion_notify->root_x,
- last_motion_notify->root_y,
- dragloop->extra);
+ dragloop->con,
+ &(dragloop->old_rect),
+ last_motion_notify->root_x,
+ last_motion_notify->root_y,
+ dragloop->extra);
free(last_motion_notify);
}
-
/*
* This function grabs your pointer and keyboard and lets you drag stuff around
* (borders). Every time you move your mouse, an XCB_MOTION_NOTIFY event will
*
*/
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)
-{
- xcb_cursor_t xcursor = (cursor && xcursor_supported) ?
- xcursor_get_cursor(cursor) : XCB_NONE;
+ confine_to,
+ border_t border, int cursor, callback_t callback, const void *extra) {
+ xcb_cursor_t xcursor = (cursor && xcursor_supported) ? xcursor_get_cursor(cursor) : XCB_NONE;
/* Grab the pointer */
xcb_grab_pointer_cookie_t cookie;
xcb_generic_error_t *error;
cookie = xcb_grab_pointer(conn,
- false, /* get all pointer events specified by the following mask */
- root, /* grab the root window */
- XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION, /* which events to let through */
- XCB_GRAB_MODE_ASYNC, /* pointer events should continue as normal */
- XCB_GRAB_MODE_ASYNC, /* keyboard mode */
- confine_to, /* confine_to = in which window should the cursor stay */
- xcursor, /* possibly display a special cursor */
- XCB_CURRENT_TIME);
+ false, /* get all pointer events specified by the following mask */
+ root, /* grab the root window */
+ XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION, /* which events to let through */
+ XCB_GRAB_MODE_ASYNC, /* pointer events should continue as normal */
+ XCB_GRAB_MODE_ASYNC, /* keyboard mode */
+ confine_to, /* confine_to = in which window should the cursor stay */
+ xcursor, /* possibly display a special cursor */
+ XCB_CURRENT_TIME);
if ((reply = xcb_grab_pointer_reply(conn, cookie, &error)) == NULL) {
ELOG("Could not grab pointer (error_code = %d)\n", error->error_code);
xcb_grab_keyboard_reply_t *keyb_reply;
keyb_cookie = xcb_grab_keyboard(conn,
- false, /* get all keyboard events */
- root, /* grab the root window */
- XCB_CURRENT_TIME,
- XCB_GRAB_MODE_ASYNC, /* continue processing pointer events as normal */
- XCB_GRAB_MODE_ASYNC /* keyboard mode */
- );
+ false, /* get all keyboard events */
+ root, /* grab the root window */
+ XCB_CURRENT_TIME,
+ XCB_GRAB_MODE_ASYNC, /* continue processing pointer events as normal */
+ XCB_GRAB_MODE_ASYNC /* keyboard mode */
+ );
if ((keyb_reply = xcb_grab_keyboard_reply(conn, keyb_cookie, &error)) == NULL) {
ELOG("Could not grab keyboard (error_code = %d)\n", error->error_code);
tree_render();
}
+/*
+ * Sets size of the CT_FLOATING_CON to specified dimensions. Might limit the
+ * actual size with regard to size constraints taken from user settings.
+ * Additionally, the dimensions may be upscaled until they're divisible by the
+ * window's size hints.
+ *
+ */
+void floating_resize(Con *floating_con, int x, int y) {
+ DLOG("floating resize to %dx%d px\n", x, y);
+ Rect *rect = &floating_con->rect;
+ Con *focused_con = con_descend_focused(floating_con);
+ if (focused_con->window == NULL) {
+ DLOG("No window is focused. Not resizing.\n");
+ return;
+ }
+ int wi = focused_con->window->width_increment;
+ int hi = focused_con->window->height_increment;
+ rect->width = x;
+ rect->height = y;
+ if (wi)
+ rect->width += (wi - 1 - rect->width) % wi;
+ if (hi)
+ rect->height += (hi - 1 - rect->height) % hi;
+
+ floating_check_size(floating_con);
+
+ /* If this is a scratchpad window, don't auto center it from now on. */
+ if (floating_con->scratchpad_state == SCRATCHPAD_FRESH)
+ floating_con->scratchpad_state = SCRATCHPAD_CHANGED;
+}
+
/*
* Fixes the coordinates of the floating window whenever the window gets
* reassigned to a different output (or when the output’s rect changes).
new_rect->x, new_rect->y, new_rect->width, new_rect->height);
/* First we get the x/y coordinates relative to the x/y coordinates
* of the output on which the window is on */
- int32_t rel_x = con->rect.x - old_rect->x + (int32_t)(con->rect.width / 2);
+ int32_t rel_x = con->rect.x - old_rect->x + (int32_t)(con->rect.width / 2);
int32_t rel_y = con->rect.y - old_rect->y + (int32_t)(con->rect.height / 2);
/* Then we calculate a fraction, for example 0.63 for a window
* which is at y = 1212 of a 1920 px high output */
DLOG("rel_x = %d, rel_y = %d, fraction_x = %f, fraction_y = %f, output->w = %d, output->h = %d\n",
- rel_x, rel_y, (double)rel_x / old_rect->width, (double)rel_y / old_rect->height,
- old_rect->width, old_rect->height);
+ rel_x, rel_y, (double)rel_x / old_rect->width, (double)rel_y / old_rect->height,
+ old_rect->width, old_rect->height);
/* Here we have to multiply at first. Or we will lose precision when not compiled with -msse2 */
- 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);
- 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);
+ 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);
+ 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);
DLOG("Resulting coordinates: x = %d, y = %d\n", con->rect.x, con->rect.y);
}