1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 moveresize.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 See the COPYING file for a copy of the GNU General Public License.
21 #include "framerender.h"
29 #include "moveresize.h"
33 #include "obrender/render.h"
34 #include "obrender/theme.h"
35 #include "obt/display.h"
36 #include "obt/xqueue.h"
38 #include "obt/keyboard.h"
43 /* how far windows move and resize with the keyboard arrows */
45 #define SYNC_TIMEOUTS 4
47 gboolean moveresize_in_progress
= FALSE
;
48 ObClient
*moveresize_client
= NULL
;
50 XSyncAlarm moveresize_alarm
= None
;
53 static gboolean moving
= FALSE
; /* TRUE - moving, FALSE - resizing */
55 /* starting geometry for the window being moved/resized, so it can be
57 static gint start_x
, start_y
, start_cx
, start_cy
, start_cw
, start_ch
;
58 static gboolean was_max_horz
, was_max_vert
;
59 static Rect pre_max_area
;
60 static gint cur_x
, cur_y
, cur_w
, cur_h
;
62 static guint32 corner
;
63 static ObDirection edge_warp_dir
= -1;
64 static gboolean edge_warp_odd
= FALSE
;
65 static guint edge_warp_timer
= 0;
66 static ObDirection key_resize_edge
= -1;
67 static guint waiting_for_sync
;
69 static guint sync_timer
= 0;
72 static ObPopup
*popup
= NULL
;
74 static void do_move(gboolean keyboard
, gint keydist
);
75 static void do_resize(void);
76 static void do_edge_warp(gint x
, gint y
);
77 static void cancel_edge_warp();
79 static gboolean
sync_timeout_func(gpointer data
);
82 static void client_dest(ObClient
*client
, gpointer data
)
84 if (moveresize_client
== client
)
88 void moveresize_startup(gboolean reconfig
)
91 popup_set_text_align(popup
, RR_JUSTIFY_CENTER
);
94 client_add_destroy_notify(client_dest
, NULL
);
97 void moveresize_shutdown(gboolean reconfig
)
100 if (moveresize_in_progress
)
101 moveresize_end(FALSE
);
102 client_remove_destroy_notify(client_dest
);
109 static void popup_coords(ObClient
*c
, const gchar
*format
, gint a
, gint b
)
113 text
= g_strdup_printf(format
, a
, b
);
114 if (config_resize_popup_pos
== OB_RESIZE_POS_TOP
)
115 popup_position(popup
, SouthGravity
,
117 + c
->frame
->area
.width
/2,
118 c
->frame
->area
.y
- ob_rr_theme
->fbwidth
);
119 else if (config_resize_popup_pos
== OB_RESIZE_POS_CENTER
)
120 popup_position(popup
, CenterGravity
,
121 c
->frame
->area
.x
+ c
->frame
->area
.width
/ 2,
122 c
->frame
->area
.y
+ c
->frame
->area
.height
/ 2);
124 const Rect
*area
= screen_physical_area_active();
127 x
= config_resize_popup_fixed
.x
.pos
;
128 if (config_resize_popup_fixed
.x
.center
)
129 x
= area
->x
+ area
->width
/2;
130 else if (config_resize_popup_fixed
.x
.opposite
)
131 x
= RECT_RIGHT(*area
) - x
;
135 y
= config_resize_popup_fixed
.y
.pos
;
136 if (config_resize_popup_fixed
.y
.center
)
137 y
= area
->y
+ area
->height
/2;
138 else if (config_resize_popup_fixed
.y
.opposite
)
139 y
= RECT_RIGHT(*area
) - y
;
143 if (config_resize_popup_fixed
.x
.center
) {
144 if (config_resize_popup_fixed
.y
.center
)
145 gravity
= CenterGravity
;
146 else if (config_resize_popup_fixed
.y
.opposite
)
147 gravity
= SouthGravity
;
149 gravity
= NorthGravity
;
151 else if (config_resize_popup_fixed
.x
.opposite
) {
152 if (config_resize_popup_fixed
.y
.center
)
153 gravity
= EastGravity
;
154 else if (config_resize_popup_fixed
.y
.opposite
)
155 gravity
= SouthEastGravity
;
157 gravity
= NorthEastGravity
;
160 if (config_resize_popup_fixed
.y
.center
)
161 gravity
= WestGravity
;
162 else if (config_resize_popup_fixed
.y
.opposite
)
163 gravity
= SouthWestGravity
;
165 gravity
= NorthWestGravity
;
168 popup_position(popup
, gravity
, x
, y
);
170 popup_show(popup
, text
);
174 void moveresize_start(ObClient
*c
, gint x
, gint y
, guint b
, guint32 cnr
)
177 gboolean mv
= (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE
) ||
178 cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD
));
182 if (moveresize_in_progress
|| !c
->frame
->visible
||
184 (c
->functions
& OB_CLIENT_FUNC_MOVE
) :
185 (c
->functions
& OB_CLIENT_FUNC_RESIZE
)))
188 if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT
)) {
189 cur
= OB_CURSOR_NORTHWEST
;
192 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP
)) {
193 cur
= OB_CURSOR_NORTH
;
196 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT
)) {
197 cur
= OB_CURSOR_NORTHEAST
;
200 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT
))
201 cur
= OB_CURSOR_EAST
;
202 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT
))
203 cur
= OB_CURSOR_SOUTHEAST
;
204 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOM
))
205 cur
= OB_CURSOR_SOUTH
;
206 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT
)) {
207 cur
= OB_CURSOR_SOUTHWEST
;
210 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT
)) {
211 cur
= OB_CURSOR_WEST
;
214 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD
))
215 cur
= OB_CURSOR_SOUTHEAST
;
216 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE
))
217 cur
= OB_CURSOR_MOVE
;
218 else if (cnr
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD
))
219 cur
= OB_CURSOR_MOVE
;
221 g_assert_not_reached();
223 /* keep the pointer bounded to the screen for move/resize */
224 if (!grab_pointer(FALSE
, TRUE
, cur
))
226 if (!grab_keyboard()) {
231 frame_end_iconify_animation(c
->frame
);
234 moveresize_client
= c
;
235 start_cx
= c
->area
.x
;
236 start_cy
= c
->area
.y
;
237 start_cw
= c
->area
.width
;
238 start_ch
= c
->area
.height
;
239 /* these adjustments for the size_inc make resizing a terminal more
240 friendly. you essentially start the resize in the middle of the
241 increment instead of at 0, so you have to move half an increment
242 either way instead of a full increment one and 1 px the other. */
243 start_x
= x
- (mv
? 0 : left
* c
->size_inc
.width
/ 2);
244 start_y
= y
- (mv
? 0 : up
* c
->size_inc
.height
/ 2);
247 key_resize_edge
= -1;
249 /* default to not putting max back on cancel */
250 was_max_horz
= was_max_vert
= FALSE
;
253 have to change start_cx and start_cy if going to do this..
254 if (corner == prop_atoms.net_wm_moveresize_move_keyboard ||
255 corner == prop_atoms.net_wm_moveresize_size_keyboard)
256 XWarpPointer(ob_display, None, c->window, 0, 0, 0, 0,
257 c->area.width / 2, c->area.height / 2);
265 moveresize_in_progress
= TRUE
;
266 waiting_for_sync
= 0;
269 if (config_resize_redraw
&& !moving
&& obt_display_extension_sync
&&
270 moveresize_client
->sync_request
&& moveresize_client
->sync_counter
&&
271 !moveresize_client
->not_responding
)
273 /* Initialize values for the resize syncing, and create an alarm for
274 the client's xsync counter */
277 XSyncAlarmAttributes aa
;
279 /* set the counter to an initial value */
280 XSyncIntToValue(&val
, 0);
281 XSyncSetCounter(obt_display
, moveresize_client
->sync_counter
, val
);
283 /* this will be incremented when we tell the client what we're
285 moveresize_client
->sync_counter_value
= 0;
287 /* the next sequence we're waiting for with the alarm */
288 XSyncIntToValue(&val
, 1);
290 /* set an alarm on the counter */
291 aa
.trigger
.counter
= moveresize_client
->sync_counter
;
292 aa
.trigger
.wait_value
= val
;
293 aa
.trigger
.value_type
= XSyncAbsolute
;
294 aa
.trigger
.test_type
= XSyncPositiveTransition
;
296 XSyncIntToValue(&aa
.delta
, 1);
297 moveresize_alarm
= XSyncCreateAlarm(obt_display
,
309 void moveresize_end(gboolean cancel
)
318 /* turn off the alarm */
319 if (moveresize_alarm
!= None
) {
320 XSyncDestroyAlarm(obt_display
, moveresize_alarm
);
321 moveresize_alarm
= None
;
324 if (sync_timer
) g_source_remove(sync_timer
);
329 /* don't use client_move() here, use the same width/height as
330 we've been using during the move, otherwise we get different results
331 when moving maximized windows between monitors of different sizes !
333 client_configure(moveresize_client
,
334 (cancel
? start_cx
: cur_x
),
335 (cancel
? start_cy
: cur_y
),
336 (cancel
? start_cw
: cur_w
),
337 (cancel
? start_ch
: cur_h
),
340 /* restore the client's maximized state. do this after putting the window
341 back in its original spot to minimize visible flicker */
342 if (cancel
&& (was_max_horz
|| was_max_vert
)) {
343 const gboolean h
= moveresize_client
->max_horz
;
344 const gboolean v
= moveresize_client
->max_vert
;
346 client_maximize(moveresize_client
, TRUE
,
347 was_max_horz
&& was_max_vert
? 0 :
348 (was_max_horz
? 1 : 2));
350 /* replace the premax values with the ones we had saved if
351 the client doesn't have any already set */
352 if (was_max_horz
&& !h
) {
353 moveresize_client
->pre_max_area
.x
= pre_max_area
.x
;
354 moveresize_client
->pre_max_area
.width
= pre_max_area
.width
;
356 if (was_max_vert
&& !v
) {
357 moveresize_client
->pre_max_area
.y
= pre_max_area
.y
;
358 moveresize_client
->pre_max_area
.height
= pre_max_area
.height
;
362 /* dont edge warp after its ended */
365 moveresize_in_progress
= FALSE
;
366 moveresize_client
= NULL
;
369 static void do_move(gboolean keyboard
, gint keydist
)
373 if (keyboard
) resist
= keydist
- 1; /* resist for one key press */
374 else resist
= config_resist_win
;
375 resist_move_windows(moveresize_client
, resist
, &cur_x
, &cur_y
);
376 if (!keyboard
) resist
= config_resist_edge
;
377 resist_move_monitors(moveresize_client
, resist
, &cur_x
, &cur_y
);
379 client_configure(moveresize_client
, cur_x
, cur_y
, cur_w
, cur_h
,
381 if (config_resize_popup_show
== 2) /* == "Always" */
382 popup_coords(moveresize_client
, "%d x %d",
383 moveresize_client
->frame
->area
.x
,
384 moveresize_client
->frame
->area
.y
);
387 static void do_resize(void)
389 gint x
, y
, w
, h
, lw
, lh
;
391 /* see if it is actually going to resize
392 USE cur_x AND cur_y HERE ! Otherwise the try_configure won't know
393 what struts to use !!
399 client_try_configure(moveresize_client
, &x
, &y
, &w
, &h
,
401 if (!(w
== moveresize_client
->area
.width
&&
402 h
== moveresize_client
->area
.height
) &&
403 /* if waiting_for_sync == 0, then we aren't waiting.
404 if it is > SYNC_TIMEOUTS, then we have timed out
405 that many times already, so forget about waiting more */
406 (waiting_for_sync
== 0 || waiting_for_sync
> SYNC_TIMEOUTS
))
409 if (config_resize_redraw
&& obt_display_extension_sync
&&
410 /* don't send another sync when one is pending */
411 waiting_for_sync
== 0 &&
412 moveresize_client
->sync_request
&&
413 moveresize_client
->sync_counter
&&
414 !moveresize_client
->not_responding
)
419 /* increment the value we're waiting for */
420 ++moveresize_client
->sync_counter_value
;
421 XSyncIntToValue(&val
, moveresize_client
->sync_counter_value
);
423 /* tell the client what we're waiting for */
424 ce
.xclient
.type
= ClientMessage
;
425 ce
.xclient
.message_type
= OBT_PROP_ATOM(WM_PROTOCOLS
);
426 ce
.xclient
.display
= obt_display
;
427 ce
.xclient
.window
= moveresize_client
->window
;
428 ce
.xclient
.format
= 32;
429 ce
.xclient
.data
.l
[0] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST
);
430 ce
.xclient
.data
.l
[1] = event_time();
431 ce
.xclient
.data
.l
[2] = XSyncValueLow32(val
);
432 ce
.xclient
.data
.l
[3] = XSyncValueHigh32(val
);
433 ce
.xclient
.data
.l
[4] = 0l;
434 XSendEvent(obt_display
, moveresize_client
->window
, FALSE
,
437 waiting_for_sync
= 1;
439 if (sync_timer
) g_source_remove(sync_timer
);
440 sync_timer
= g_timeout_add(2000, sync_timeout_func
, NULL
);
444 /* force a ConfigureNotify, it is part of the spec for SYNC resizing
445 and MUST follow the sync counter notification */
446 client_configure(moveresize_client
, cur_x
, cur_y
, cur_w
, cur_h
,
450 /* this would be better with a fixed width font ... XXX can do it better
451 if there are 2 text boxes */
452 if (config_resize_popup_show
== 2 || /* == "Always" */
453 (config_resize_popup_show
== 1 && /* == "Nonpixel" */
454 moveresize_client
->size_inc
.width
> 1 &&
455 moveresize_client
->size_inc
.height
> 1))
456 popup_coords(moveresize_client
, "%d x %d", lw
, lh
);
460 static gboolean
sync_timeout_func(gpointer data
)
462 ++waiting_for_sync
; /* we timed out waiting for our sync... */
463 do_resize(); /* ...so let any pending resizes through */
465 if (waiting_for_sync
> SYNC_TIMEOUTS
) {
467 return FALSE
; /* don't repeat */
470 return TRUE
; /* keep waiting */
474 static void calc_resize(gboolean keyboard
, gint keydist
, gint
*dw
, gint
*dh
,
477 gint resist
, x
= 0, y
= 0, lw
, lh
, ow
, oh
, nw
, nh
;
486 (moveresize_client
->max_ratio
|| moveresize_client
->min_ratio
))
489 case OB_DIRECTION_NORTH
:
490 case OB_DIRECTION_SOUTH
:
491 /* resize the width based on the height */
492 if (moveresize_client
->min_ratio
) {
493 if (nh
* moveresize_client
->min_ratio
> nw
)
494 nw
= (gint
)(nh
* moveresize_client
->min_ratio
);
496 if (moveresize_client
->max_ratio
) {
497 if (nh
* moveresize_client
->max_ratio
< nw
)
498 nw
= (gint
)(nh
* moveresize_client
->max_ratio
);
502 /* resize the height based on the width */
503 if (moveresize_client
->min_ratio
) {
504 if (nh
* moveresize_client
->min_ratio
> nw
)
505 nh
= (gint
)(nw
/ moveresize_client
->min_ratio
);
507 if (moveresize_client
->max_ratio
) {
508 if (nh
* moveresize_client
->max_ratio
< nw
)
509 nh
= (gint
)(nw
/ moveresize_client
->max_ratio
);
514 /* see its actual size (apply aspect ratios) */
515 client_try_configure(moveresize_client
, &x
, &y
, &nw
, &nh
, &lw
, &lh
,
521 /* resist_size_* needs the frame size */
522 nw
+= moveresize_client
->frame
->size
.left
+
523 moveresize_client
->frame
->size
.right
;
524 nh
+= moveresize_client
->frame
->size
.top
+
525 moveresize_client
->frame
->size
.bottom
;
527 if (keyboard
) resist
= keydist
- 1; /* resist for one key press */
528 else resist
= config_resist_win
;
529 resist_size_windows(moveresize_client
, resist
, &nw
, &nh
, dir
);
530 if (!keyboard
) resist
= config_resist_edge
;
531 resist_size_monitors(moveresize_client
, resist
, &nw
, &nh
, dir
);
533 nw
-= moveresize_client
->frame
->size
.left
+
534 moveresize_client
->frame
->size
.right
;
535 nh
-= moveresize_client
->frame
->size
.top
+
536 moveresize_client
->frame
->size
.bottom
;
541 /* take aspect ratios into account for resistance */
543 (moveresize_client
->max_ratio
|| moveresize_client
->min_ratio
))
545 if (*dh
!= trydh
) { /* got resisted */
546 /* resize the width based on the height */
547 if (moveresize_client
->min_ratio
) {
548 if (nh
* moveresize_client
->min_ratio
> nw
)
549 nw
= (gint
)(nh
* moveresize_client
->min_ratio
);
551 if (moveresize_client
->max_ratio
) {
552 if (nh
* moveresize_client
->max_ratio
< nw
)
553 nw
= (gint
)(nh
* moveresize_client
->max_ratio
);
556 if (*dw
!= trydw
) { /* got resisted */
557 /* resize the height based on the width */
558 if (moveresize_client
->min_ratio
) {
559 if (nh
* moveresize_client
->min_ratio
> nw
)
560 nh
= (gint
)(nw
/ moveresize_client
->min_ratio
);
562 if (moveresize_client
->max_ratio
) {
563 if (nh
* moveresize_client
->max_ratio
< nw
)
564 nh
= (gint
)(nw
/ moveresize_client
->max_ratio
);
569 /* make sure it's all valid */
570 client_try_configure(moveresize_client
, &x
, &y
, &nw
, &nh
, &lw
, &lh
, TRUE
);
576 static void edge_warp_move_ptr(void)
581 screen_pointer_pos(&x
, &y
);
582 a
= screen_physical_area_all_monitors();
584 switch (edge_warp_dir
) {
585 case OB_DIRECTION_NORTH
:
588 case OB_DIRECTION_EAST
:
591 case OB_DIRECTION_SOUTH
:
594 case OB_DIRECTION_WEST
:
598 g_assert_not_reached();
601 XWarpPointer(obt_display
, 0, obt_root(ob_screen
), 0, 0, 0, 0, x
, y
);
604 static gboolean
edge_warp_delay_func(gpointer data
)
608 /* only fire every second time. so it's fast the first time, but slower
611 d
= screen_find_desktop(screen_desktop
, edge_warp_dir
, TRUE
, FALSE
);
612 if (d
!= screen_desktop
) {
613 if (config_mouse_screenedgewarp
) edge_warp_move_ptr();
614 screen_set_desktop(d
, TRUE
);
617 edge_warp_odd
= !edge_warp_odd
;
619 return TRUE
; /* do repeat ! */
622 static void do_edge_warp(gint x
, gint y
)
627 if (!config_mouse_screenedgetime
) return;
631 for (i
= 0; i
< screen_num_monitors
; ++i
) {
632 const Rect
*a
= screen_physical_area_monitor(i
);
634 if (!RECT_CONTAINS(*a
, x
, y
))
637 if (x
== RECT_LEFT(*a
)) dir
= OB_DIRECTION_WEST
;
638 if (x
== RECT_RIGHT(*a
)) dir
= OB_DIRECTION_EAST
;
639 if (y
== RECT_TOP(*a
)) dir
= OB_DIRECTION_NORTH
;
640 if (y
== RECT_BOTTOM(*a
)) dir
= OB_DIRECTION_SOUTH
;
642 /* try check for xinerama boundaries */
643 if ((x
+ 1 == RECT_LEFT(*a
) || x
- 1 == RECT_RIGHT(*a
)) &&
644 (dir
== OB_DIRECTION_WEST
|| dir
== OB_DIRECTION_EAST
))
648 if ((y
+ 1 == RECT_TOP(*a
) || y
- 1 == RECT_BOTTOM(*a
)) &&
649 (dir
== OB_DIRECTION_NORTH
|| dir
== OB_DIRECTION_SOUTH
))
655 if (dir
!= edge_warp_dir
) {
657 if (dir
!= (ObDirection
)-1) {
658 edge_warp_odd
= TRUE
; /* switch on the first timeout */
659 edge_warp_timer
= g_timeout_add(config_mouse_screenedgetime
,
660 edge_warp_delay_func
, NULL
);
666 static void cancel_edge_warp(void)
668 if (edge_warp_timer
) g_source_remove(edge_warp_timer
);
672 static void move_with_keys(KeySym sym
, guint state
)
674 gint dx
= 0, dy
= 0, ox
= cur_x
, oy
= cur_y
;
675 gint opx
, px
, opy
, py
;
678 /* shift means jump to edge */
679 if (state
& obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_SHIFT
))
685 dir
= OB_DIRECTION_EAST
;
686 else if (sym
== XK_Left
)
687 dir
= OB_DIRECTION_WEST
;
688 else if (sym
== XK_Down
)
689 dir
= OB_DIRECTION_SOUTH
;
690 else /* sym == XK_Up */
691 dir
= OB_DIRECTION_NORTH
;
693 client_find_move_directional(moveresize_client
, dir
, &x
, &y
);
694 dx
= x
- moveresize_client
->area
.x
;
695 dy
= y
- moveresize_client
->area
.y
;
697 /* control means fine grained */
699 obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_CONTROL
))
708 else if (sym
== XK_Left
)
710 else if (sym
== XK_Down
)
712 else /* if (sym == XK_Up) */
716 screen_pointer_pos(&opx
, &opy
);
717 XWarpPointer(obt_display
, None
, None
, 0, 0, 0, 0, dx
, dy
);
718 /* steal the motion events this causes */
719 XSync(obt_display
, FALSE
);
722 while (xqueue_remove_local(&ce
, xqueue_match_type
,
723 GINT_TO_POINTER(MotionNotify
)));
725 screen_pointer_pos(&px
, &py
);
731 /* because the cursor moves even though the window does
732 not nessesarily (resistance), this adjusts where the curor
733 thinks it started so that it keeps up with where the window
735 start_x
+= (px
- opx
) - (cur_x
- ox
);
736 start_y
+= (py
- opy
) - (cur_y
- oy
);
739 static void resize_with_keys(KeySym sym
, guint state
)
741 gint dw
= 0, dh
= 0, pdx
= 0, pdy
= 0, opx
, opy
, px
, py
;
745 /* pick the edge if it needs to move */
746 if (sym
== XK_Right
) {
747 dir
= OB_DIRECTION_EAST
;
748 if (key_resize_edge
!= OB_DIRECTION_WEST
&&
749 key_resize_edge
!= OB_DIRECTION_EAST
)
751 key_resize_edge
= OB_DIRECTION_EAST
;
754 } else if (sym
== XK_Left
) {
755 dir
= OB_DIRECTION_WEST
;
756 if (key_resize_edge
!= OB_DIRECTION_WEST
&&
757 key_resize_edge
!= OB_DIRECTION_EAST
)
759 key_resize_edge
= OB_DIRECTION_WEST
;
762 } else if (sym
== XK_Up
) {
763 dir
= OB_DIRECTION_NORTH
;
764 if (key_resize_edge
!= OB_DIRECTION_NORTH
&&
765 key_resize_edge
!= OB_DIRECTION_SOUTH
)
767 key_resize_edge
= OB_DIRECTION_NORTH
;
770 } else /* if (sym == XK_Down) */ {
771 dir
= OB_DIRECTION_SOUTH
;
772 if (key_resize_edge
!= OB_DIRECTION_NORTH
&&
773 key_resize_edge
!= OB_DIRECTION_SOUTH
)
775 key_resize_edge
= OB_DIRECTION_SOUTH
;
780 /* shift means jump to edge */
781 if (state
& obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_SHIFT
))
786 dir
= OB_DIRECTION_EAST
;
787 else if (sym
== XK_Left
)
788 dir
= OB_DIRECTION_WEST
;
789 else if (sym
== XK_Down
)
790 dir
= OB_DIRECTION_SOUTH
;
791 else /* if (sym == XK_Up)) */
792 dir
= OB_DIRECTION_NORTH
;
794 client_find_resize_directional(moveresize_client
, key_resize_edge
,
795 key_resize_edge
== dir
,
797 dw
= w
- moveresize_client
->area
.width
;
798 dh
= h
- moveresize_client
->area
.height
;
802 /* control means fine grained */
803 if (moveresize_client
->size_inc
.width
> 1) {
804 distw
= moveresize_client
->size_inc
.width
;
808 obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_CONTROL
))
817 if (moveresize_client
->size_inc
.height
> 1) {
818 disth
= moveresize_client
->size_inc
.height
;
822 obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_CONTROL
))
832 if (key_resize_edge
== OB_DIRECTION_WEST
) {
833 if (dir
== OB_DIRECTION_WEST
)
838 else if (key_resize_edge
== OB_DIRECTION_EAST
) {
839 if (dir
== OB_DIRECTION_EAST
)
844 else if (key_resize_edge
== OB_DIRECTION_NORTH
) {
845 if (dir
== OB_DIRECTION_NORTH
)
850 else /*if (key_resize_edge == OB_DIRECTION_SOUTH)*/ {
851 if (dir
== OB_DIRECTION_SOUTH
)
858 if (moveresize_client
->max_horz
&&
859 (key_resize_edge
== OB_DIRECTION_WEST
||
860 key_resize_edge
== OB_DIRECTION_EAST
))
864 pre_max_area
.x
= moveresize_client
->pre_max_area
.x
;
865 pre_max_area
.width
= moveresize_client
->pre_max_area
.width
;
867 moveresize_client
->pre_max_area
.x
= cur_x
;
868 moveresize_client
->pre_max_area
.width
= cur_w
;
869 client_maximize(moveresize_client
, FALSE
, 1);
871 else if (moveresize_client
->max_vert
&&
872 (key_resize_edge
== OB_DIRECTION_NORTH
||
873 key_resize_edge
== OB_DIRECTION_SOUTH
))
877 pre_max_area
.y
= moveresize_client
->pre_max_area
.y
;
878 pre_max_area
.height
= moveresize_client
->pre_max_area
.height
;
880 moveresize_client
->pre_max_area
.y
= cur_y
;
881 moveresize_client
->pre_max_area
.height
= cur_h
;
882 client_maximize(moveresize_client
, FALSE
, 2);
885 calc_resize(TRUE
, resist
, &dw
, &dh
, dir
);
886 if (key_resize_edge
== OB_DIRECTION_WEST
)
888 else if (key_resize_edge
== OB_DIRECTION_NORTH
)
893 /* how to move the pointer to keep up with the change */
894 if (key_resize_edge
== OB_DIRECTION_WEST
)
896 else if (key_resize_edge
== OB_DIRECTION_EAST
)
898 else if (key_resize_edge
== OB_DIRECTION_NORTH
)
900 else if (key_resize_edge
== OB_DIRECTION_SOUTH
)
903 screen_pointer_pos(&opx
, &opy
);
904 XWarpPointer(obt_display
, None
, None
, 0, 0, 0, 0, pdx
, pdy
);
905 /* steal the motion events this causes */
906 XSync(obt_display
, FALSE
);
909 while (xqueue_remove_local(&ce
, xqueue_match_type
,
910 GINT_TO_POINTER(MotionNotify
)));
912 screen_pointer_pos(&px
, &py
);
916 /* because the cursor moves even though the window does
917 not nessesarily (resistance), this adjusts where the cursor
918 thinks it started so that it keeps up with where the window
920 start_x
+= (px
- opx
) - dw
;
921 start_y
+= (py
- opy
) - dh
;
925 gboolean
moveresize_event(XEvent
*e
)
927 gboolean used
= FALSE
;
929 if (!moveresize_in_progress
) return FALSE
;
931 if (e
->type
== ButtonPress
) {
933 start_x
= e
->xbutton
.x_root
;
934 start_y
= e
->xbutton
.y_root
;
935 button
= e
->xbutton
.button
; /* this will end it now */
937 used
= e
->xbutton
.button
== button
;
938 } else if (e
->type
== ButtonRelease
) {
939 if (!button
|| e
->xbutton
.button
== button
) {
940 moveresize_end(FALSE
);
943 } else if (e
->type
== MotionNotify
) {
945 cur_x
= start_cx
+ e
->xmotion
.x_root
- start_x
;
946 cur_y
= start_cy
+ e
->xmotion
.y_root
- start_y
;
948 do_edge_warp(e
->xmotion
.x_root
, e
->xmotion
.y_root
);
953 if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT
)) {
954 dw
= -(e
->xmotion
.x_root
- start_x
);
955 dh
= -(e
->xmotion
.y_root
- start_y
);
956 dir
= OB_DIRECTION_NORTHWEST
;
957 } else if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP
)) {
959 dh
= -(e
->xmotion
.y_root
- start_y
);
960 dir
= OB_DIRECTION_NORTH
;
962 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT
)) {
963 dw
= (e
->xmotion
.x_root
- start_x
);
964 dh
= -(e
->xmotion
.y_root
- start_y
);
965 dir
= OB_DIRECTION_NORTHEAST
;
966 } else if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT
)) {
967 dw
= (e
->xmotion
.x_root
- start_x
);
969 dir
= OB_DIRECTION_EAST
;
971 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT
)) {
972 dw
= (e
->xmotion
.x_root
- start_x
);
973 dh
= (e
->xmotion
.y_root
- start_y
);
974 dir
= OB_DIRECTION_SOUTHEAST
;
975 } else if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOM
))
978 dh
= (e
->xmotion
.y_root
- start_y
);
979 dir
= OB_DIRECTION_SOUTH
;
981 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT
)) {
982 dw
= -(e
->xmotion
.x_root
- start_x
);
983 dh
= (e
->xmotion
.y_root
- start_y
);
984 dir
= OB_DIRECTION_SOUTHWEST
;
985 } else if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT
)) {
986 dw
= -(e
->xmotion
.x_root
- start_x
);
988 dir
= OB_DIRECTION_WEST
;
990 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD
)) {
991 dw
= (e
->xmotion
.x_root
- start_x
);
992 dh
= (e
->xmotion
.y_root
- start_y
);
993 dir
= OB_DIRECTION_SOUTHEAST
;
995 g_assert_not_reached();
997 /* override the client's max state if desired */
998 if (ABS(dw
) >= config_resist_edge
) {
999 if (moveresize_client
->max_horz
) {
1001 was_max_horz
= TRUE
;
1002 pre_max_area
.x
= moveresize_client
->pre_max_area
.x
;
1003 pre_max_area
.width
= moveresize_client
->pre_max_area
.width
;
1005 moveresize_client
->pre_max_area
.x
= cur_x
;
1006 moveresize_client
->pre_max_area
.width
= cur_w
;
1007 client_maximize(moveresize_client
, FALSE
, 1);
1010 else if (was_max_horz
&& !moveresize_client
->max_horz
) {
1011 /* remax horz and put the premax back */
1012 client_maximize(moveresize_client
, TRUE
, 1);
1013 moveresize_client
->pre_max_area
.x
= pre_max_area
.x
;
1014 moveresize_client
->pre_max_area
.width
= pre_max_area
.width
;
1017 if (ABS(dh
) >= config_resist_edge
) {
1018 if (moveresize_client
->max_vert
) {
1020 was_max_vert
= TRUE
;
1021 pre_max_area
.y
= moveresize_client
->pre_max_area
.y
;
1022 pre_max_area
.height
=
1023 moveresize_client
->pre_max_area
.height
;
1025 moveresize_client
->pre_max_area
.y
= cur_y
;
1026 moveresize_client
->pre_max_area
.height
= cur_h
;
1027 client_maximize(moveresize_client
, FALSE
, 2);
1030 else if (was_max_vert
&& !moveresize_client
->max_vert
) {
1031 /* remax vert and put the premax back */
1032 client_maximize(moveresize_client
, TRUE
, 2);
1033 moveresize_client
->pre_max_area
.y
= pre_max_area
.y
;
1034 moveresize_client
->pre_max_area
.height
= pre_max_area
.height
;
1037 dw
-= cur_w
- start_cw
;
1038 dh
-= cur_h
- start_ch
;
1040 calc_resize(FALSE
, 0, &dw
, &dh
, dir
);
1044 if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT
) ||
1045 corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT
) ||
1046 corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT
))
1050 if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT
) ||
1051 corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP
) ||
1052 corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT
))
1060 } else if (e
->type
== KeyPress
) {
1061 KeySym sym
= obt_keyboard_keypress_to_keysym(e
);
1063 if (sym
== XK_Escape
) {
1064 moveresize_end(TRUE
);
1066 } else if (sym
== XK_Return
|| sym
== XK_KP_Enter
) {
1067 moveresize_end(FALSE
);
1069 } else if (sym
== XK_Right
|| sym
== XK_Left
||
1070 sym
== XK_Up
|| sym
== XK_Down
)
1072 if (corner
== OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD
)) {
1073 resize_with_keys(sym
, e
->xkey
.state
);
1075 } else if (corner
==
1076 OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD
))
1078 move_with_keys(sym
, e
->xkey
.state
);
1084 else if (e
->type
== obt_display_extension_sync_basep
+ XSyncAlarmNotify
)
1086 waiting_for_sync
= 0; /* we got our sync... */
1087 do_resize(); /* ...so try resize if there is more change pending */
1092 if (used
&& moveresize_client
== focus_client
)
1093 event_update_user_time();