+
+ *dw = nw - ow;
+ *dh = nh - oh;
+
+ /* take aspect ratios into account for resistance */
+ if (!keyboard &&
+ (moveresize_client->max_ratio || moveresize_client->min_ratio))
+ {
+ if (*dh != trydh) { /* got resisted */
+ /* resize the width based on the height */
+ if (moveresize_client->min_ratio) {
+ if (nh * moveresize_client->min_ratio > nw)
+ nw = (gint)(nh * moveresize_client->min_ratio);
+ }
+ if (moveresize_client->max_ratio) {
+ if (nh * moveresize_client->max_ratio < nw)
+ nw = (gint)(nh * moveresize_client->max_ratio);
+ }
+ }
+ if (*dw != trydw) { /* got resisted */
+ /* resize the height based on the width */
+ if (moveresize_client->min_ratio) {
+ if (nh * moveresize_client->min_ratio > nw)
+ nh = (gint)(nw / moveresize_client->min_ratio);
+ }
+ if (moveresize_client->max_ratio) {
+ if (nh * moveresize_client->max_ratio < nw)
+ nh = (gint)(nw / moveresize_client->max_ratio);
+ }
+ }
+ }
+
+ /* make sure it's all valid */
+ client_try_configure(moveresize_client, &x, &y, &nw, &nh, &lw, &lh, TRUE);
+
+ *dw = nw - ow;
+ *dh = nh - oh;
+}
+
+static void edge_warp_move_ptr(void)
+{
+ gint x, y;
+ const Rect* a;
+
+ screen_pointer_pos(&x, &y);
+ a = screen_physical_area_all_monitors();
+
+ switch (edge_warp_dir) {
+ case OB_DIRECTION_NORTH:
+ y = a->height - 1;
+ break;
+ case OB_DIRECTION_EAST:
+ x = a->x;
+ break;
+ case OB_DIRECTION_SOUTH:
+ y = a->y;
+ break;
+ case OB_DIRECTION_WEST:
+ x = a->width - 1;
+ break;
+ default:
+ g_assert_not_reached();
+ }
+
+ XWarpPointer(obt_display, 0, obt_root(ob_screen), 0, 0, 0, 0, x, y);
+}
+
+static gboolean edge_warp_delay_func(gpointer data)
+{
+ guint d;
+
+ /* only fire every second time. so it's fast the first time, but slower
+ after that */
+ if (edge_warp_odd) {
+ d = screen_find_desktop(screen_desktop, edge_warp_dir, TRUE, FALSE);
+ if (d != screen_desktop) {
+ if (config_mouse_screenedgewarp) edge_warp_move_ptr();
+ screen_set_desktop(d, TRUE);
+ }
+ }
+ edge_warp_odd = !edge_warp_odd;
+
+ return TRUE; /* do repeat ! */
+}
+
+static void do_edge_warp(gint x, gint y)
+{
+ guint i;
+ ObDirection dir;
+
+ if (!config_mouse_screenedgetime) return;
+
+ dir = -1;
+
+ for (i = 0; i < screen_num_monitors; ++i) {
+ const Rect *a = screen_physical_area_monitor(i);
+
+ if (!RECT_CONTAINS(*a, x, y))
+ continue;
+
+ if (x == RECT_LEFT(*a)) dir = OB_DIRECTION_WEST;
+ if (x == RECT_RIGHT(*a)) dir = OB_DIRECTION_EAST;
+ if (y == RECT_TOP(*a)) dir = OB_DIRECTION_NORTH;
+ if (y == RECT_BOTTOM(*a)) dir = OB_DIRECTION_SOUTH;
+
+ /* try check for xinerama boundaries */
+ if ((x + 1 == RECT_LEFT(*a) || x - 1 == RECT_RIGHT(*a)) &&
+ (dir == OB_DIRECTION_WEST || dir == OB_DIRECTION_EAST))
+ {
+ dir = -1;
+ }
+ if ((y + 1 == RECT_TOP(*a) || y - 1 == RECT_BOTTOM(*a)) &&
+ (dir == OB_DIRECTION_NORTH || dir == OB_DIRECTION_SOUTH))
+ {
+ dir = -1;
+ }
+ }
+
+ if (dir != edge_warp_dir) {
+ cancel_edge_warp();
+ if (dir != (ObDirection)-1) {
+ edge_warp_odd = TRUE; /* switch on the first timeout */
+ edge_warp_timer = g_timeout_add(config_mouse_screenedgetime,
+ edge_warp_delay_func, NULL);
+ }
+ edge_warp_dir = dir;
+ }
+}
+
+static void cancel_edge_warp(void)
+{
+ if (edge_warp_timer) g_source_remove(edge_warp_timer);
+ edge_warp_timer = 0;
+}
+
+static void move_with_keys(KeySym sym, guint state)
+{
+ gint dx = 0, dy = 0, ox = cur_x, oy = cur_y;
+ gint opx, px, opy, py;
+ gint dist = 0;
+
+ /* shift means jump to edge */
+ if (state & obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_SHIFT))
+ {
+ gint x, y;
+ ObDirection dir;
+
+ if (sym == XK_Right)
+ dir = OB_DIRECTION_EAST;
+ else if (sym == XK_Left)
+ dir = OB_DIRECTION_WEST;
+ else if (sym == XK_Down)
+ dir = OB_DIRECTION_SOUTH;
+ else /* sym == XK_Up */
+ dir = OB_DIRECTION_NORTH;
+
+ client_find_move_directional(moveresize_client, dir, &x, &y);
+ dx = x - moveresize_client->area.x;
+ dy = y - moveresize_client->area.y;
+ } else {
+ /* control means fine grained */
+ if (state &
+ obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_CONTROL))
+ {
+ dist = 1;
+ }
+ else
+ dist = KEY_DIST;
+
+ if (sym == XK_Right)
+ dx = dist;
+ else if (sym == XK_Left)
+ dx = -dist;
+ else if (sym == XK_Down)
+ dy = dist;
+ else /* if (sym == XK_Up) */
+ dy = -dist;
+ }
+
+ screen_pointer_pos(&opx, &opy);
+ XWarpPointer(obt_display, None, None, 0, 0, 0, 0, dx, dy);
+ /* steal the motion events this causes */
+ XSync(obt_display, FALSE);
+ {
+ XEvent ce;
+ while (xqueue_remove_local(&ce, xqueue_match_type,
+ GINT_TO_POINTER(MotionNotify)));
+ }
+ screen_pointer_pos(&px, &py);
+
+ cur_x += dx;
+ cur_y += dy;
+ do_move(TRUE, dist);
+
+ /* because the cursor moves even though the window does
+ not nessesarily (resistance), this adjusts where the curor
+ thinks it started so that it keeps up with where the window
+ actually is */
+ start_x += (px - opx) - (cur_x - ox);
+ start_y += (py - opy) - (cur_y - oy);
+}
+
+static void resize_with_keys(KeySym sym, guint state)
+{
+ gint dw = 0, dh = 0, pdx = 0, pdy = 0, opx, opy, px, py;
+ gint resist = 0;
+ ObDirection dir;
+
+ /* pick the edge if it needs to move */
+ if (sym == XK_Right) {
+ dir = OB_DIRECTION_EAST;
+ if (key_resize_edge != OB_DIRECTION_WEST &&
+ key_resize_edge != OB_DIRECTION_EAST)
+ {
+ key_resize_edge = OB_DIRECTION_EAST;
+ return;
+ }
+ } else if (sym == XK_Left) {
+ dir = OB_DIRECTION_WEST;
+ if (key_resize_edge != OB_DIRECTION_WEST &&
+ key_resize_edge != OB_DIRECTION_EAST)
+ {
+ key_resize_edge = OB_DIRECTION_WEST;
+ return;
+ }
+ } else if (sym == XK_Up) {
+ dir = OB_DIRECTION_NORTH;
+ if (key_resize_edge != OB_DIRECTION_NORTH &&
+ key_resize_edge != OB_DIRECTION_SOUTH)
+ {
+ key_resize_edge = OB_DIRECTION_NORTH;
+ return;
+ }
+ } else /* if (sym == XK_Down) */ {
+ dir = OB_DIRECTION_SOUTH;
+ if (key_resize_edge != OB_DIRECTION_NORTH &&
+ key_resize_edge != OB_DIRECTION_SOUTH)
+ {
+ key_resize_edge = OB_DIRECTION_SOUTH;
+ return;
+ }
+ }
+
+ /* shift means jump to edge */
+ if (state & obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_SHIFT))
+ {
+ gint x, y, w, h;
+
+ if (sym == XK_Right)
+ dir = OB_DIRECTION_EAST;
+ else if (sym == XK_Left)
+ dir = OB_DIRECTION_WEST;
+ else if (sym == XK_Down)
+ dir = OB_DIRECTION_SOUTH;
+ else /* if (sym == XK_Up)) */
+ dir = OB_DIRECTION_NORTH;
+
+ client_find_resize_directional(moveresize_client, key_resize_edge,
+ key_resize_edge == dir,
+ &x, &y, &w, &h);
+ dw = w - moveresize_client->area.width;
+ dh = h - moveresize_client->area.height;
+ } else {
+ gint distw, disth;
+
+ /* control means fine grained */
+ if (moveresize_client->size_inc.width > 1) {
+ distw = moveresize_client->size_inc.width;
+ resist = 1;
+ }
+ else if (state &
+ obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_CONTROL))
+ {
+ distw = 1;
+ resist = 1;
+ }
+ else {
+ distw = KEY_DIST;
+ resist = KEY_DIST;
+ }
+ if (moveresize_client->size_inc.height > 1) {
+ disth = moveresize_client->size_inc.height;
+ resist = 1;
+ }
+ else if (state &
+ obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_CONTROL))
+ {
+ disth = 1;
+ resist = 1;
+ }
+ else {
+ disth = KEY_DIST;
+ resist = KEY_DIST;
+ }
+
+ if (key_resize_edge == OB_DIRECTION_WEST) {
+ if (dir == OB_DIRECTION_WEST)
+ dw = distw;
+ else
+ dw = -distw;
+ }
+ else if (key_resize_edge == OB_DIRECTION_EAST) {
+ if (dir == OB_DIRECTION_EAST)
+ dw = distw;
+ else
+ dw = -distw;
+ }
+ else if (key_resize_edge == OB_DIRECTION_NORTH) {
+ if (dir == OB_DIRECTION_NORTH)
+ dh = disth;
+ else
+ dh = -disth;
+ }
+ else /*if (key_resize_edge == OB_DIRECTION_SOUTH)*/ {
+ if (dir == OB_DIRECTION_SOUTH)
+ dh = disth;
+ else
+ dh = -disth;
+ }
+ }
+
+ if (moveresize_client->max_horz &&
+ (key_resize_edge == OB_DIRECTION_WEST ||
+ key_resize_edge == OB_DIRECTION_EAST))
+ {
+ /* unmax horz */
+ was_max_horz = TRUE;
+ pre_max_area.x = moveresize_client->pre_max_area.x;
+ pre_max_area.width = moveresize_client->pre_max_area.width;
+
+ moveresize_client->pre_max_area.x = cur_x;
+ moveresize_client->pre_max_area.width = cur_w;
+ client_maximize(moveresize_client, FALSE, 1);
+ }
+ else if (moveresize_client->max_vert &&
+ (key_resize_edge == OB_DIRECTION_NORTH ||
+ key_resize_edge == OB_DIRECTION_SOUTH))
+ {
+ /* unmax vert */
+ was_max_vert = TRUE;
+ pre_max_area.y = moveresize_client->pre_max_area.y;
+ pre_max_area.height = moveresize_client->pre_max_area.height;
+
+ moveresize_client->pre_max_area.y = cur_y;
+ moveresize_client->pre_max_area.height = cur_h;
+ client_maximize(moveresize_client, FALSE, 2);
+ }
+
+ calc_resize(TRUE, resist, &dw, &dh, dir);
+ if (key_resize_edge == OB_DIRECTION_WEST)
+ cur_x -= dw;
+ else if (key_resize_edge == OB_DIRECTION_NORTH)
+ cur_y -= dh;
+ cur_w += dw;
+ cur_h += dh;
+
+ /* how to move the pointer to keep up with the change */
+ if (key_resize_edge == OB_DIRECTION_WEST)
+ pdx = -dw;
+ else if (key_resize_edge == OB_DIRECTION_EAST)
+ pdx = dw;
+ else if (key_resize_edge == OB_DIRECTION_NORTH)
+ pdy = -dh;
+ else if (key_resize_edge == OB_DIRECTION_SOUTH)
+ pdy = dh;
+
+ screen_pointer_pos(&opx, &opy);
+ XWarpPointer(obt_display, None, None, 0, 0, 0, 0, pdx, pdy);
+ /* steal the motion events this causes */
+ XSync(obt_display, FALSE);
+ {
+ XEvent ce;
+ while (xqueue_remove_local(&ce, xqueue_match_type,
+ GINT_TO_POINTER(MotionNotify)));
+ }
+ screen_pointer_pos(&px, &py);
+
+ do_resize();
+
+ /* because the cursor moves even though the window does
+ not nessesarily (resistance), this adjusts where the cursor
+ thinks it started so that it keeps up with where the window
+ actually is */
+ start_x += (px - opx) - dw;
+ start_y += (py - opy) - dh;
+