Output *output;
/* Use Rect to encapsulate dimensions, ignoring x/y */
Rect outputs_dimensions = {0, 0, 0, 0};
- TAILQ_FOREACH(output, &outputs, outputs) {
+ TAILQ_FOREACH (output, &outputs, outputs) {
outputs_dimensions.height += output->rect.height;
outputs_dimensions.width += output->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 */
if (memcmp(&(nc->rect), &zero, sizeof(Rect)) == 0) {
DLOG("Geometry not set, combining children\n");
Con *child;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
DLOG("child geometry: %d x %d\n", child->geometry.width, child->geometry.height);
nc->rect.width += child->geometry.width;
nc->rect.height = max(nc->rect.height, child->geometry.height);
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 */
/* 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) {
* 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;
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_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);
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);
}
projects / i3 / i3 / blobdiff