?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
debian: Update with version 0.95.7-2 packaging.
[wmaker-crm.git] / src / moveres.c
blob5472ceb125bb845030ce1818670d757e6804419b
1 /*
2 * Window Maker window manager
3 *
4 * Copyright (c) 1997-2003 Alfredo K. Kojima
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include "wconfig.h"
22
23 #include <X11/Xlib.h>
24 #include <X11/Xutil.h>
25 #include <X11/keysym.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <unistd.h>
29 #include <string.h>
30
31 #include "WindowMaker.h"
32 #include "framewin.h"
33 #include "window.h"
34 #include "client.h"
35 #include "icon.h"
36 #include "dock.h"
37 #include "actions.h"
38 #include "workspace.h"
39 #include "placement.h"
40
41 #include "geomview.h"
42 #include "screen.h"
43 #include "xinerama.h"
44
45 #include <WINGs/WINGsP.h>
46
47 /* How many different types of geometry/position
48 display thingies are there? */
49 #define NUM_DISPLAYS 5
50
51 #define LEFT 1
52 #define RIGHT 2
53 #define UP 4
54 #define DOWN 8
55
56 /* True if window currently has a border. This also includes borderless
57 * windows which are currently selected
58 */
59 #define HAS_BORDER_WITH_SELECT(w) ((w)->flags.selected || HAS_BORDER(w))
60
61
62 /*
63 *----------------------------------------------------------------------
64 * checkMouseSamplingRate-
65 * For lowering the mouse motion sampling rate for machines where
66 * it's too high (SGIs). If it returns False then the event should be
67 * ignored.
68 *----------------------------------------------------------------------
69 */
70 static Bool checkMouseSamplingRate(XEvent * ev)
71 {
72 static Time previousMotion = 0;
73
74 if (ev->type == MotionNotify) {
75 if (ev->xmotion.time - previousMotion < DELAY_BETWEEN_MOUSE_SAMPLING) {
76 return False;
77 } else {
78 previousMotion = ev->xmotion.time;
79 }
80 }
81 return True;
82 }
83
84 /*
85 *----------------------------------------------------------------------
86 * moveGeometryDisplayCentered
87 *
88 * routine that moves the geometry/position window on scr so it is
89 * centered over the given coordinates (x,y). Also the window position
90 * is clamped so it stays on the screen at all times.
91 *----------------------------------------------------------------------
92 */
93 static void moveGeometryDisplayCentered(WScreen * scr, int x, int y)
94 {
95 unsigned int w = WMWidgetWidth(scr->gview);
96 unsigned int h = WMWidgetHeight(scr->gview);
97 int x1 = 0, y1 = 0, x2 = scr->scr_width, y2 = scr->scr_height;
98
99 x -= w / 2;
100 y -= h / 2;
101
102 /* dead area check */
103 if (scr->xine_info.count) {
104 WMRect rect;
105 int head, flags;
106
107 rect.pos.x = x;
108 rect.pos.y = y;
109 rect.size.width = w;
110 rect.size.height = h;
111
112 head = wGetRectPlacementInfo(scr, rect, &flags);
113
114 if (flags & (XFLAG_DEAD | XFLAG_PARTIAL)) {
115 rect = wGetRectForHead(scr, head);
116 x1 = rect.pos.x;
117 y1 = rect.pos.y;
118 x2 = x1 + rect.size.width;
119 y2 = y1 + rect.size.height;
120 }
121 }
122
123 if (x < x1 + 1)
124 x = x1 + 1;
125 else if (x > (x2 - w))
126 x = x2 - w;
127
128 if (y < y1 + 1)
129 y = y1 + 1;
130 else if (y > (y2 - h))
131 y = y2 - h;
132
133 WMMoveWidget(scr->gview, x, y);
134 }
135
136 static void showPosition(WWindow * wwin, int x, int y)
137 {
138 WScreen *scr = wwin->screen_ptr;
139
140 if (wPreferences.move_display == WDIS_NEW) {
141 #if 0
142 int width = wwin->frame->core->width;
143 int height = wwin->frame->core->height;
144
145 GC lgc = scr->line_gc;
146 XSetForeground(dpy, lgc, scr->line_pixel);
147 sprintf(num, "%i", x);
148
149 XDrawLine(dpy, scr->root_win, lgc, 0, y - 1, scr->scr_width, y - 1);
150 XDrawLine(dpy, scr->root_win, lgc, 0, y + height + 2, scr->scr_width, y + height + 2);
151 XDrawLine(dpy, scr->root_win, lgc, x - 1, 0, x - 1, scr->scr_height);
152 XDrawLine(dpy, scr->root_win, lgc, x + width + 2, 0, x + width + 2, scr->scr_height);
153 #endif
154 } else {
155 WSetGeometryViewShownPosition(scr->gview, x, y);
156 }
157 }
158
159 static void cyclePositionDisplay(WWindow * wwin, int x, int y, int w, int h)
160 {
161 WScreen *scr = wwin->screen_ptr;
162 WMRect rect;
163
164 wPreferences.move_display++;
165 wPreferences.move_display %= NUM_DISPLAYS;
166
167 if (wPreferences.move_display == WDIS_NEW) {
168 wPreferences.move_display++;
169 wPreferences.move_display %= NUM_DISPLAYS;
170 }
171
172 if (wPreferences.move_display == WDIS_NONE) {
173 WMUnmapWidget(scr->gview);
174 } else {
175 if (wPreferences.move_display == WDIS_CENTER) {
176 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
177 moveGeometryDisplayCentered(scr, rect.pos.x + rect.size.width / 2,
178 rect.pos.y + rect.size.height / 2);
179 } else if (wPreferences.move_display == WDIS_TOPLEFT) {
180 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
181 moveGeometryDisplayCentered(scr, rect.pos.x + 1, rect.pos.y + 1);
182 } else if (wPreferences.move_display == WDIS_FRAME_CENTER) {
183 moveGeometryDisplayCentered(scr, x + w / 2, y + h / 2);
184 }
185 WMMapWidget(scr->gview);
186 }
187 }
188
189 static void mapPositionDisplay(WWindow * wwin, int x, int y, int w, int h)
190 {
191 WScreen *scr = wwin->screen_ptr;
192 WMRect rect;
193
194 if (wPreferences.move_display == WDIS_NEW || wPreferences.move_display == WDIS_NONE) {
195 return;
196 } else if (wPreferences.move_display == WDIS_CENTER) {
197 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
198 moveGeometryDisplayCentered(scr, rect.pos.x + rect.size.width / 2,
199 rect.pos.y + rect.size.height / 2);
200 } else if (wPreferences.move_display == WDIS_TOPLEFT) {
201 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
202 moveGeometryDisplayCentered(scr, rect.pos.x + 1, rect.pos.y + 1);
203 } else if (wPreferences.move_display == WDIS_FRAME_CENTER) {
204 moveGeometryDisplayCentered(scr, x + w / 2, y + h / 2);
205 }
206 WMMapWidget(scr->gview);
207 WSetGeometryViewShownPosition(scr->gview, x, y);
208 }
209
210 static void showGeometry(WWindow * wwin, int x1, int y1, int x2, int y2, int direction)
211 {
212 WScreen *scr = wwin->screen_ptr;
213 Window root = scr->root_win;
214 GC gc = scr->line_gc;
215 int ty, by, my, x, y, mx, s;
216 char num[16];
217 XSegment segment[4];
218 int fw, fh;
219
220 /* This seems necessary for some odd reason (too lazy to write x1-1 and
221 * x2-1 everywhere below in the code). But why only for x? */
222 x1--;
223 x2--;
224
225 if (HAS_BORDER_WITH_SELECT(wwin)) {
226 x1 += scr->frame_border_width;
227 x2 += scr->frame_border_width;
228 y1 += scr->frame_border_width;
229 y2 += scr->frame_border_width;
230 }
231
232 ty = y1 + wwin->frame->top_width;
233 by = y2 - wwin->frame->bottom_width;
234
235 if (wPreferences.size_display == WDIS_NEW) {
236 fw = XTextWidth(scr->tech_draw_font, "8888", 4);
237 fh = scr->tech_draw_font->ascent + scr->tech_draw_font->descent;
238
239 XSetForeground(dpy, gc, scr->line_pixel);
240
241 /* vertical geometry */
242 if (((direction & LEFT) && (x2 < scr->scr_width - fw)) || (x1 < fw)) {
243 x = x2;
244 s = -15;
245 } else {
246 x = x1;
247 s = 15;
248 }
249 my = (ty + by) / 2;
250
251 /* top arrow & end bar */
252 segment[0].x1 = x - (s + 6);
253 segment[0].y1 = ty;
254 segment[0].x2 = x - (s - 10);
255 segment[0].y2 = ty;
256
257 /* arrowhead */
258 segment[1].x1 = x - (s - 2);
259 segment[1].y1 = ty + 1;
260 segment[1].x2 = x - (s - 5);
261 segment[1].y2 = ty + 7;
262
263 segment[2].x1 = x - (s - 2);
264 segment[2].y1 = ty + 1;
265 segment[2].x2 = x - (s + 1);
266 segment[2].y2 = ty + 7;
267
268 /* line */
269 segment[3].x1 = x - (s - 2);
270 segment[3].y1 = ty + 1;
271 segment[3].x2 = x - (s - 2);
272 segment[3].y2 = my - fh / 2 - 1;
273
274 XDrawSegments(dpy, root, gc, segment, 4);
275
276 /* bottom arrow & end bar */
277 segment[0].y1 = by;
278 segment[0].y2 = by;
279
280 /* arrowhead */
281 segment[1].y1 = by - 1;
282 segment[1].y2 = by - 7;
283
284 segment[2].y1 = by - 1;
285 segment[2].y2 = by - 7;
286
287 /* line */
288 segment[3].y1 = my + fh / 2 + 2;
289 segment[3].y2 = by - 1;
290
291 XDrawSegments(dpy, root, gc, segment, 4);
292
293 snprintf(num, sizeof(num), "%i", (by - ty - wwin->normal_hints->base_height) /
294 wwin->normal_hints->height_inc);
295 fw = XTextWidth(scr->tech_draw_font, num, strlen(num));
296
297 /* Display the height. */
298 XSetFont(dpy, gc, scr->tech_draw_font->fid);
299 XDrawString(dpy, root, gc, x - s + 3 - fw / 2, my + scr->tech_draw_font->ascent - fh / 2 + 1, num,
300 strlen(num));
301
302 /* horizontal geometry */
303 if (y1 < 15) {
304 y = y2;
305 s = -15;
306 } else {
307 y = y1;
308 s = 15;
309 }
310 mx = x1 + (x2 - x1) / 2;
311 snprintf(num, sizeof(num), "%i", (x2 - x1 - wwin->normal_hints->base_width) /
312 wwin->normal_hints->width_inc);
313 fw = XTextWidth(scr->tech_draw_font, num, strlen(num));
314
315 /* left arrow & end bar */
316 segment[0].x1 = x1;
317 segment[0].y1 = y - (s + 6);
318 segment[0].x2 = x1;
319 segment[0].y2 = y - (s - 10);
320
321 /* arrowhead */
322 segment[1].x1 = x1 + 7;
323 segment[1].y1 = y - (s + 1);
324 segment[1].x2 = x1 + 1;
325 segment[1].y2 = y - (s - 2);
326
327 segment[2].x1 = x1 + 1;
328 segment[2].y1 = y - (s - 2);
329 segment[2].x2 = x1 + 7;
330 segment[2].y2 = y - (s - 5);
331
332 /* line */
333 segment[3].x1 = x1 + 1;
334 segment[3].y1 = y - (s - 2);
335 segment[3].x2 = mx - fw / 2 - 2;
336 segment[3].y2 = y - (s - 2);
337
338 XDrawSegments(dpy, root, gc, segment, 4);
339
340 /* right arrow & end bar */
341 segment[0].x1 = x2 + 1;
342 segment[0].x2 = x2 + 1;
343
344 /* arrowhead */
345 segment[1].x1 = x2 - 6;
346 segment[1].x2 = x2;
347
348 segment[2].x1 = x2;
349 segment[2].x2 = x2 - 6;
350
351 /* line */
352 segment[3].x1 = mx + fw / 2 + 2;
353 segment[3].x2 = x2;
354
355 XDrawSegments(dpy, root, gc, segment, 4);
356
357 /* Display the width. */
358 XDrawString(dpy, root, gc, mx - fw / 2 + 1, y - s + scr->tech_draw_font->ascent - fh / 2 + 1, num,
359 strlen(num));
360 } else {
361 WSetGeometryViewShownSize(scr->gview, (x2 - x1 - wwin->normal_hints->base_width)
362 / wwin->normal_hints->width_inc,
363 (by - ty - wwin->normal_hints->base_height)
364 / wwin->normal_hints->height_inc);
365 }
366 }
367
368 static void cycleGeometryDisplay(WWindow * wwin, int x, int y, int w, int h, int dir)
369 {
370 WScreen *scr = wwin->screen_ptr;
371 WMRect rect;
372
373 wPreferences.size_display++;
374 wPreferences.size_display %= NUM_DISPLAYS;
375
376 if (wPreferences.size_display == WDIS_NEW || wPreferences.size_display == WDIS_NONE) {
377 WMUnmapWidget(scr->gview);
378 } else {
379 if (wPreferences.size_display == WDIS_CENTER) {
380 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
381 moveGeometryDisplayCentered(scr, rect.pos.x + rect.size.width / 2,
382 rect.pos.y + rect.size.height / 2);
383 } else if (wPreferences.size_display == WDIS_TOPLEFT) {
384 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
385 moveGeometryDisplayCentered(scr, rect.pos.x + 1, rect.pos.y + 1);
386 } else if (wPreferences.size_display == WDIS_FRAME_CENTER) {
387 moveGeometryDisplayCentered(scr, x + w / 2, y + h / 2);
388 }
389 WMMapWidget(scr->gview);
390 showGeometry(wwin, x, y, x + w, y + h, dir);
391 }
392 }
393
394 static void mapGeometryDisplay(WWindow * wwin, int x, int y, int w, int h)
395 {
396 WScreen *scr = wwin->screen_ptr;
397 WMRect rect;
398
399 if (wPreferences.size_display == WDIS_NEW || wPreferences.size_display == WDIS_NONE)
400 return;
401
402 if (wPreferences.size_display == WDIS_CENTER) {
403 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
404 moveGeometryDisplayCentered(scr, rect.pos.x + rect.size.width / 2,
405 rect.pos.y + rect.size.height / 2);
406 } else if (wPreferences.size_display == WDIS_TOPLEFT) {
407 rect = wGetRectForHead(scr, wGetHeadForWindow(wwin));
408 moveGeometryDisplayCentered(scr, rect.pos.x + 1, rect.pos.y + 1);
409 } else if (wPreferences.size_display == WDIS_FRAME_CENTER) {
410 moveGeometryDisplayCentered(scr, x + w / 2, y + h / 2);
411 }
412 WMMapWidget(scr->gview);
413 showGeometry(wwin, x, y, x + w, y + h, 0);
414 }
415
416 static void doWindowMove(WWindow * wwin, WMArray * array, int dx, int dy)
417 {
418 WWindow *tmpw;
419 WScreen *scr = wwin->screen_ptr;
420 int x, y;
421
422 if (!array || !WMGetArrayItemCount(array)) {
423 wWindowMove(wwin, wwin->frame_x + dx, wwin->frame_y + dy);
424 } else {
425 WMArrayIterator iter;
426
427 WM_ITERATE_ARRAY(array, tmpw, iter) {
428 x = tmpw->frame_x + dx;
429 y = tmpw->frame_y + dy;
430
431 #if 1 /* XXX: with xinerama patch was #if 0, check this */
432 /* don't let windows become unreachable */
433
434 if (x + (int)tmpw->frame->core->width < 20)
435 x = 20 - (int)tmpw->frame->core->width;
436 else if (x + 20 > scr->scr_width)
437 x = scr->scr_width - 20;
438
439 if (y + (int)tmpw->frame->core->height < 20)
440 y = 20 - (int)tmpw->frame->core->height;
441 else if (y + 20 > scr->scr_height)
442 y = scr->scr_height - 20;
443 #else
444 wScreenBringInside(scr, &x, &y,
445 (int)tmpw->frame->core->width, (int)tmpw->frame->core->height);
446 #endif
447
448 wWindowMove(tmpw, x, y);
449 }
450 }
451 }
452
453 static void drawTransparentFrame(WWindow * wwin, int x, int y, int width, int height)
454 {
455 Window root = wwin->screen_ptr->root_win;
456 GC gc = wwin->screen_ptr->frame_gc;
457 int h = 0;
458 int bottom = 0;
459
460 if (HAS_BORDER_WITH_SELECT(wwin)) {
461 x += wwin->screen_ptr->frame_border_width;
462 y += wwin->screen_ptr->frame_border_width;
463 }
464
465 if (HAS_TITLEBAR(wwin) && !wwin->flags.shaded) {
466 h = WMFontHeight(wwin->screen_ptr->title_font) + (wPreferences.window_title_clearance +
467 TITLEBAR_EXTEND_SPACE) * 2;
468
469 if (h > wPreferences.window_title_max_height)
470 h = wPreferences.window_title_max_height;
471
472 if (h < wPreferences.window_title_min_height)
473 h = wPreferences.window_title_min_height;
474 }
475 if (HAS_RESIZEBAR(wwin) && !wwin->flags.shaded) {
476 /* Can't use wwin-frame->bottom_width because, in some cases
477 (e.g. interactive placement), frame does not point to anything. */
478 bottom = RESIZEBAR_HEIGHT;
479 }
480 XDrawRectangle(dpy, root, gc, x - 1, y - 1, width + 1, height + 1);
481
482 if (h > 0) {
483 XDrawLine(dpy, root, gc, x, y + h - 1, x + width, y + h - 1);
484 }
485 if (bottom > 0) {
486 XDrawLine(dpy, root, gc, x, y + height - bottom, x + width, y + height - bottom);
487 }
488 }
489
490 static void drawFrames(WWindow * wwin, WMArray * array, int dx, int dy)
491 {
492 WWindow *tmpw;
493 int scr_width = wwin->screen_ptr->scr_width;
494 int scr_height = wwin->screen_ptr->scr_height;
495 int x, y;
496
497 if (!array) {
498
499 x = wwin->frame_x + dx;
500 y = wwin->frame_y + dy;
501
502 drawTransparentFrame(wwin, x, y, wwin->frame->core->width, wwin->frame->core->height);
503
504 } else {
505 WMArrayIterator iter;
506
507 WM_ITERATE_ARRAY(array, tmpw, iter) {
508 x = tmpw->frame_x + dx;
509 y = tmpw->frame_y + dy;
510
511 /* don't let windows become unreachable */
512 #if 1 /* XXX: was 0 in XINERAMA patch, check */
513 if (x + (int)tmpw->frame->core->width < 20)
514 x = 20 - (int)tmpw->frame->core->width;
515 else if (x + 20 > scr_width)
516 x = scr_width - 20;
517
518 if (y + (int)tmpw->frame->core->height < 20)
519 y = 20 - (int)tmpw->frame->core->height;
520 else if (y + 20 > scr_height)
521 y = scr_height - 20;
522
523 #else
524 wScreenBringInside(wwin->screen_ptr, &x, &y,
525 (int)tmpw->frame->core->width, (int)tmpw->frame->core->height);
526 #endif
527
528 drawTransparentFrame(tmpw, x, y, tmpw->frame->core->width, tmpw->frame->core->height);
529 }
530 }
531 }
532
533 static void flushMotion(void)
534 {
535 XEvent ev;
536
537 XSync(dpy, False);
538 while (XCheckMaskEvent(dpy, ButtonMotionMask, &ev)) ;
539 }
540
541 static void crossWorkspace(WScreen * scr, WWindow * wwin, int opaque_move, int new_workspace, int rewind)
542 {
543 /* do not let window be unmapped */
544 if (opaque_move) {
545 wwin->flags.changing_workspace = 1;
546 wWindowChangeWorkspace(wwin, new_workspace);
547 }
548 /* go to new workspace */
549 wWorkspaceChange(scr, new_workspace);
550
551 wwin->flags.changing_workspace = 0;
552
553 if (rewind)
554 XWarpPointer(dpy, None, None, 0, 0, 0, 0, scr->scr_width - 20, 0);
555 else
556 XWarpPointer(dpy, None, None, 0, 0, 0, 0, -(scr->scr_width - 20), 0);
557
558 flushMotion();
559
560 if (!opaque_move) {
561 XGrabPointer(dpy, scr->root_win, True, PointerMotionMask
562 | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
563 GrabModeAsync, None, wPreferences.cursor[WCUR_MOVE], CurrentTime);
564 }
565 }
566
567 typedef struct {
568 /* arrays of WWindows sorted by the respective border position */
569 WWindow **topList; /* top border */
570 WWindow **leftList; /* left border */
571 WWindow **rightList; /* right border */
572 WWindow **bottomList; /* bottom border */
573 int count;
574
575 /* index of window in the above lists indicating the relative position
576 * of the window with the others */
577 int topIndex;
578 int leftIndex;
579 int rightIndex;
580 int bottomIndex;
581
582 int rubCount; /* for workspace switching */
583
584 int winWidth, winHeight; /* width/height of the window */
585 int realX, realY; /* actual position of the window */
586 int calcX, calcY; /* calculated position of window */
587 int omouseX, omouseY; /* old mouse position */
588 int mouseX, mouseY; /* last known position of the pointer */
589
590 enum {
591 SNAP_NONE,
592 SNAP_LEFT,
593 SNAP_RIGHT,
594 SNAP_TOP,
595 SNAP_BOTTOM,
596 SNAP_TOPLEFT,
597 SNAP_TOPRIGHT,
598 SNAP_BOTTOMLEFT,
599 SNAP_BOTTOMRIGHT
600 } snap;
601 } MoveData;
602
603 #define WTOP(w) (w)->frame_y
604 #define WLEFT(w) (w)->frame_x
605 #define WRIGHT(w) ((w)->frame_x + (int)(w)->frame->core->width - 1 + \
606 (HAS_BORDER_WITH_SELECT(w) ? 2*(w)->screen_ptr->frame_border_width : 0))
607 #define WBOTTOM(w) ((w)->frame_y + (int)(w)->frame->core->height - 1 + \
608 (HAS_BORDER_WITH_SELECT(w) ? 2*(w)->screen_ptr->frame_border_width : 0))
609
610 static int compareWTop(const void *a, const void *b)
611 {
612 WWindow *wwin1 = *(WWindow **) a;
613 WWindow *wwin2 = *(WWindow **) b;
614
615 if (WTOP(wwin1) > WTOP(wwin2))
616 return -1;
617 else if (WTOP(wwin1) < WTOP(wwin2))
618 return 1;
619 else
620 return 0;
621 }
622
623 static int compareWLeft(const void *a, const void *b)
624 {
625 WWindow *wwin1 = *(WWindow **) a;
626 WWindow *wwin2 = *(WWindow **) b;
627
628 if (WLEFT(wwin1) > WLEFT(wwin2))
629 return -1;
630 else if (WLEFT(wwin1) < WLEFT(wwin2))
631 return 1;
632 else
633 return 0;
634 }
635
636 static int compareWRight(const void *a, const void *b)
637 {
638 WWindow *wwin1 = *(WWindow **) a;
639 WWindow *wwin2 = *(WWindow **) b;
640
641 if (WRIGHT(wwin1) < WRIGHT(wwin2))
642 return -1;
643 else if (WRIGHT(wwin1) > WRIGHT(wwin2))
644 return 1;
645 else
646 return 0;
647 }
648
649 static int compareWBottom(const void *a, const void *b)
650 {
651 WWindow *wwin1 = *(WWindow **) a;
652 WWindow *wwin2 = *(WWindow **) b;
653
654 if (WBOTTOM(wwin1) < WBOTTOM(wwin2))
655 return -1;
656 else if (WBOTTOM(wwin1) > WBOTTOM(wwin2))
657 return 1;
658 else
659 return 0;
660 }
661
662 static void updateResistance(MoveData *data, int newX, int newY)
663 {
664 int i;
665 int newX2 = newX + data->winWidth;
666 int newY2 = newY + data->winHeight;
667 Bool ok = False;
668
669 if (newX < data->realX) {
670 if (data->rightIndex > 0 && newX < WRIGHT(data->rightList[data->rightIndex - 1])) {
671 ok = True;
672 } else if (data->leftIndex <= data->count - 1 && newX2 <= WLEFT(data->leftList[data->leftIndex])) {
673 ok = True;
674 }
675 } else if (newX > data->realX) {
676 if (data->leftIndex > 0 && newX2 > WLEFT(data->leftList[data->leftIndex - 1])) {
677 ok = True;
678 } else if (data->rightIndex <= data->count - 1
679 && newX >= WRIGHT(data->rightList[data->rightIndex])) {
680 ok = True;
681 }
682 }
683
684 if (!ok) {
685 if (newY < data->realY) {
686 if (data->bottomIndex > 0 && newY < WBOTTOM(data->bottomList[data->bottomIndex - 1])) {
687 ok = True;
688 } else if (data->topIndex <= data->count - 1
689 && newY2 <= WTOP(data->topList[data->topIndex])) {
690 ok = True;
691 }
692 } else if (newY > data->realY) {
693 if (data->topIndex > 0 && newY2 > WTOP(data->topList[data->topIndex - 1])) {
694 ok = True;
695 } else if (data->bottomIndex <= data->count - 1
696 && newY >= WBOTTOM(data->bottomList[data->bottomIndex])) {
697 ok = True;
698 }
699 }
700 }
701
702 if (!ok)
703 return;
704
705 /* TODO: optimize this */
706 if (data->realY < WBOTTOM(data->bottomList[0])) {
707 data->bottomIndex = 0;
708 }
709 if (data->realX < WRIGHT(data->rightList[0])) {
710 data->rightIndex = 0;
711 }
712 if ((data->realX + data->winWidth) > WLEFT(data->leftList[0])) {
713 data->leftIndex = 0;
714 }
715 if ((data->realY + data->winHeight) > WTOP(data->topList[0])) {
716 data->topIndex = 0;
717 }
718 for (i = 0; i < data->count; i++) {
719 if (data->realY > WBOTTOM(data->bottomList[i])) {
720 data->bottomIndex = i + 1;
721 }
722 if (data->realX > WRIGHT(data->rightList[i])) {
723 data->rightIndex = i + 1;
724 }
725 if ((data->realX + data->winWidth) < WLEFT(data->leftList[i])) {
726 data->leftIndex = i + 1;
727 }
728 if ((data->realY + data->winHeight) < WTOP(data->topList[i])) {
729 data->topIndex = i + 1;
730 }
731 }
732 }
733
734 static void freeMoveData(MoveData * data)
735 {
736 if (data->topList)
737 wfree(data->topList);
738 if (data->leftList)
739 wfree(data->leftList);
740 if (data->rightList)
741 wfree(data->rightList);
742 if (data->bottomList)
743 wfree(data->bottomList);
744 }
745
746 static void updateMoveData(WWindow * wwin, MoveData * data)
747 {
748 WScreen *scr = wwin->screen_ptr;
749 WWindow *tmp;
750 int i;
751
752 data->count = 0;
753 tmp = scr->focused_window;
754 while (tmp) {
755 if (tmp != wwin && scr->current_workspace == tmp->frame->workspace
756 && !tmp->flags.miniaturized
757 && !tmp->flags.hidden && !tmp->flags.obscured && !WFLAGP(tmp, sunken)) {
758 data->topList[data->count] = tmp;
759 data->leftList[data->count] = tmp;
760 data->rightList[data->count] = tmp;
761 data->bottomList[data->count] = tmp;
762 data->count++;
763 }
764 tmp = tmp->prev;
765 }
766
767 if (data->count == 0) {
768 data->topIndex = 0;
769 data->leftIndex = 0;
770 data->rightIndex = 0;
771 data->bottomIndex = 0;
772 return;
773 }
774
775 /* order from closest to the border of the screen to farthest */
776
777 qsort(data->topList, data->count, sizeof(data->topList[0]), compareWTop);
778 qsort(data->leftList, data->count, sizeof(data->leftList[0]), compareWLeft);
779 qsort(data->rightList, data->count, sizeof(data->rightList[0]), compareWRight);
780 qsort(data->bottomList, data->count, sizeof(data->bottomList[0]), compareWBottom);
781
782 /* figure the position of the window relative to the others */
783
784 data->topIndex = -1;
785 data->leftIndex = -1;
786 data->rightIndex = -1;
787 data->bottomIndex = -1;
788
789 if (WTOP(wwin) < WBOTTOM(data->bottomList[0])) {
790 data->bottomIndex = 0;
791 }
792 if (WLEFT(wwin) < WRIGHT(data->rightList[0])) {
793 data->rightIndex = 0;
794 }
795 if (WRIGHT(wwin) > WLEFT(data->leftList[0])) {
796 data->leftIndex = 0;
797 }
798 if (WBOTTOM(wwin) > WTOP(data->topList[0])) {
799 data->topIndex = 0;
800 }
801 for (i = 0; i < data->count; i++) {
802 if (WTOP(wwin) >= WBOTTOM(data->bottomList[i])) {
803 data->bottomIndex = i + 1;
804 }
805 if (WLEFT(wwin) >= WRIGHT(data->rightList[i])) {
806 data->rightIndex = i + 1;
807 }
808 if (WRIGHT(wwin) <= WLEFT(data->leftList[i])) {
809 data->leftIndex = i + 1;
810 }
811 if (WBOTTOM(wwin) <= WTOP(data->topList[i])) {
812 data->topIndex = i + 1;
813 }
814 }
815 }
816
817 static void initMoveData(WWindow * wwin, MoveData * data)
818 {
819 int i;
820 WWindow *tmp;
821
822 memset(data, 0, sizeof(MoveData));
823
824 for (i = 0, tmp = wwin->screen_ptr->focused_window; tmp != NULL; tmp = tmp->prev, i++) ;
825
826 if (i > 1) {
827 data->topList = wmalloc(sizeof(WWindow *) * i);
828 data->leftList = wmalloc(sizeof(WWindow *) * i);
829 data->rightList = wmalloc(sizeof(WWindow *) * i);
830 data->bottomList = wmalloc(sizeof(WWindow *) * i);
831
832 updateMoveData(wwin, data);
833 }
834
835 data->realX = wwin->frame_x;
836 data->realY = wwin->frame_y;
837 data->calcX = wwin->frame_x;
838 data->calcY = wwin->frame_y;
839
840 data->winWidth = wwin->frame->core->width + (HAS_BORDER_WITH_SELECT(wwin) ? 2 * wwin->screen_ptr->frame_border_width : 0);
841 data->winHeight = wwin->frame->core->height + (HAS_BORDER_WITH_SELECT(wwin) ? 2 * wwin->screen_ptr->frame_border_width : 0);
842
843 data->snap = SNAP_NONE;
844 }
845
846 static Bool checkWorkspaceChange(WWindow * wwin, MoveData * data, Bool opaqueMove)
847 {
848 WScreen *scr = wwin->screen_ptr;
849 Bool changed = False;
850
851 if (data->mouseX <= 1) {
852 if (scr->current_workspace > 0) {
853 crossWorkspace(scr, wwin, opaqueMove, scr->current_workspace - 1, True);
854 changed = True;
855 data->rubCount = 0;
856 } else if (scr->current_workspace == 0 && wPreferences.ws_cycle) {
857 crossWorkspace(scr, wwin, opaqueMove, scr->workspace_count - 1, True);
858 changed = True;
859 data->rubCount = 0;
860 }
861 } else if (data->mouseX >= scr->scr_width - 2) {
862 if (scr->current_workspace == scr->workspace_count - 1) {
863 if (wPreferences.ws_cycle || scr->workspace_count == MAX_WORKSPACES) {
864 crossWorkspace(scr, wwin, opaqueMove, 0, False);
865 changed = True;
866 data->rubCount = 0;
867 }
868 /* if user insists on trying to go to next workspace even when
869 * it's already the last, create a new one */
870 else if (data->omouseX == data->mouseX && wPreferences.ws_advance) {
871
872 /* detect user "rubbing" the window against the edge */
873 if (data->rubCount > 0 && data->omouseY - data->mouseY > MOVE_THRESHOLD) {
874
875 data->rubCount = -(data->rubCount + 1);
876
877 } else if (data->rubCount <= 0 && data->mouseY - data->omouseY > MOVE_THRESHOLD) {
878
879 data->rubCount = -data->rubCount + 1;
880 }
881 }
882 /* create a new workspace */
883 if (abs(data->rubCount) > 2) {
884 /* go to next workspace */
885 wWorkspaceNew(scr);
886
887 crossWorkspace(scr, wwin, opaqueMove, scr->current_workspace + 1, False);
888 changed = True;
889 data->rubCount = 0;
890 }
891 } else if (scr->current_workspace < scr->workspace_count) {
892 /* go to next workspace */
893 crossWorkspace(scr, wwin, opaqueMove, scr->current_workspace + 1, False);
894 changed = True;
895 data->rubCount = 0;
896 }
897 } else {
898 data->rubCount = 0;
899 }
900
901 return changed;
902 }
903
904 static void
905 updateWindowPosition(WWindow * wwin, MoveData * data, Bool doResistance,
906 Bool opaqueMove, int newMouseX, int newMouseY)
907 {
908 WScreen *scr = wwin->screen_ptr;
909 int dx, dy; /* how much mouse moved */
910 int winL, winR, winT, winB; /* requested new window position */
911 int newX, newY; /* actual new window position */
912 Bool hresist, vresist;
913 Bool attract;
914
915 hresist = False;
916 vresist = False;
917
918 /* check the direction of the movement */
919 dx = newMouseX - data->mouseX;
920 dy = newMouseY - data->mouseY;
921
922 data->omouseX = data->mouseX;
923 data->omouseY = data->mouseY;
924 data->mouseX = newMouseX;
925 data->mouseY = newMouseY;
926
927 winL = data->calcX + dx;
928 winR = data->calcX + data->winWidth + dx;
929 winT = data->calcY + dy;
930 winB = data->calcY + data->winHeight + dy;
931
932 newX = data->realX;
933 newY = data->realY;
934
935 if (doResistance) {
936 int l_edge, r_edge;
937 int edge_l, edge_r;
938 int t_edge, b_edge;
939 int edge_t, edge_b;
940 int resist;
941
942 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
943 attract = wPreferences.attract;
944 /* horizontal movement: check horizontal edge resistances */
945 if (dx || dy) {
946 WMRect rect;
947 int i, head;
948 /* window is the leftmost window: check against screen edge */
949
950 /* Add inter head resistance 1/2 (if needed) */
951 head = wGetHeadForPointerLocation(scr);
952 rect = wGetRectForHead(scr, head);
953
954 l_edge = WMAX(scr->totalUsableArea[head].x1, rect.pos.x);
955 edge_l = l_edge - resist;
956 edge_r = WMIN(scr->totalUsableArea[head].x2, rect.pos.x + rect.size.width);
957 r_edge = edge_r + resist;
958
959 /* 1 */
960 if ((data->rightIndex >= 0) && (data->rightIndex <= data->count)) {
961 WWindow *looprw;
962
963 for (i = data->rightIndex - 1; i >= 0; i--) {
964 looprw = data->rightList[i];
965 if (!(data->realY > WBOTTOM(looprw)
966 || (data->realY + data->winHeight) < WTOP(looprw))) {
967 if (attract || ((data->realX < (WRIGHT(looprw) + 2)) && dx < 0)) {
968 l_edge = WRIGHT(looprw) + 1;
969 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
970 }
971 break;
972 }
973 }
974
975 if (attract) {
976 for (i = data->rightIndex; i < data->count; i++) {
977 looprw = data->rightList[i];
978 if (!(data->realY > WBOTTOM(looprw)
979 || (data->realY + data->winHeight) < WTOP(looprw))) {
980 r_edge = WRIGHT(looprw) + 1;
981 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
982 break;
983 }
984 }
985 }
986 }
987
988 if ((data->leftIndex >= 0) && (data->leftIndex <= data->count)) {
989 WWindow *looprw;
990
991 for (i = data->leftIndex - 1; i >= 0; i--) {
992 looprw = data->leftList[i];
993 if (!(data->realY > WBOTTOM(looprw)
994 || (data->realY + data->winHeight) < WTOP(looprw))) {
995 if (attract
996 || (((data->realX + data->winWidth) > (WLEFT(looprw) - 1))
997 && dx > 0)) {
998 edge_r = WLEFT(looprw);
999 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
1000 }
1001 break;
1002 }
1003 }
1004
1005 if (attract)
1006 for (i = data->leftIndex; i < data->count; i++) {
1007 looprw = data->leftList[i];
1008 if (!(data->realY > WBOTTOM(looprw)
1009 || (data->realY + data->winHeight) < WTOP(looprw))) {
1010 edge_l = WLEFT(looprw);
1011 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
1012 break;
1013 }
1014 }
1015 }
1016
1017 /*
1018 printf("%d %d\n",winL,winR);
1019 printf("l_ %d r_ %d _l %d _r %d\n",l_edge,r_edge,edge_l,edge_r);
1020 */
1021
1022 if ((winL - l_edge) < (r_edge - winL)) {
1023 if (resist > 0) {
1024 if ((attract && winL <= l_edge + resist && winL >= l_edge - resist)
1025 || (dx < 0 && winL <= l_edge && winL >= l_edge - resist)) {
1026 newX = l_edge;
1027 hresist = True;
1028 }
1029 }
1030 } else {
1031 if (resist > 0 && attract && winL >= r_edge - resist && winL <= r_edge + resist) {
1032 newX = r_edge;
1033 hresist = True;
1034 }
1035 }
1036
1037 if ((winR - edge_l) < (edge_r - winR)) {
1038 if (resist > 0 && attract && winR <= edge_l + resist && winR >= edge_l - resist) {
1039 newX = edge_l - data->winWidth;
1040 hresist = True;
1041 }
1042 } else {
1043 if (resist > 0) {
1044 if ((attract && winR >= edge_r - resist && winR <= edge_r + resist)
1045 || (dx > 0 && winR >= edge_r && winR <= edge_r + resist)) {
1046 newX = edge_r - data->winWidth;
1047 hresist = True;
1048 }
1049 }
1050 }
1051
1052 /* VeRT */
1053 /* Add inter head resistance 2/2 (if needed) */
1054 t_edge = WMAX(scr->totalUsableArea[head].y1, rect.pos.y);
1055 edge_t = t_edge - resist;
1056 edge_b = WMIN(scr->totalUsableArea[head].y2, rect.pos.y + rect.size.height);
1057 b_edge = edge_b + resist;
1058
1059 if ((data->bottomIndex >= 0) && (data->bottomIndex <= data->count)) {
1060 WWindow *looprw;
1061
1062 for (i = data->bottomIndex - 1; i >= 0; i--) {
1063 looprw = data->bottomList[i];
1064 if (!(data->realX > WRIGHT(looprw)
1065 || (data->realX + data->winWidth) < WLEFT(looprw))) {
1066 if (attract || ((data->realY < (WBOTTOM(looprw) + 2)) && dy < 0)) {
1067 t_edge = WBOTTOM(looprw) + 1;
1068 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
1069 }
1070 break;
1071 }
1072 }
1073
1074 if (attract) {
1075 for (i = data->bottomIndex; i < data->count; i++) {
1076 looprw = data->bottomList[i];
1077 if (!(data->realX > WRIGHT(looprw)
1078 || (data->realX + data->winWidth) < WLEFT(looprw))) {
1079 b_edge = WBOTTOM(looprw) + 1;
1080 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
1081 break;
1082 }
1083 }
1084 }
1085 }
1086
1087 if ((data->topIndex >= 0) && (data->topIndex <= data->count)) {
1088 WWindow *looprw;
1089
1090 for (i = data->topIndex - 1; i >= 0; i--) {
1091 looprw = data->topList[i];
1092 if (!(data->realX > WRIGHT(looprw)
1093 || (data->realX + data->winWidth) < WLEFT(looprw))) {
1094 if (attract
1095 || (((data->realY + data->winHeight) > (WTOP(looprw) - 1))
1096 && dy > 0)) {
1097 edge_b = WTOP(looprw);
1098 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
1099 }
1100 break;
1101 }
1102 }
1103
1104 if (attract)
1105 for (i = data->topIndex; i < data->count; i++) {
1106 looprw = data->topList[i];
1107 if (!(data->realX > WRIGHT(looprw)
1108 || (data->realX + data->winWidth) < WLEFT(looprw))) {
1109 edge_t = WTOP(looprw);
1110 resist = WIN_RESISTANCE(wPreferences.edge_resistance);
1111 break;
1112 }
1113 }
1114 }
1115
1116 if ((winT - t_edge) < (b_edge - winT)) {
1117 if (resist > 0) {
1118 if ((attract && winT <= t_edge + resist && winT >= t_edge - resist)
1119 || (dy < 0 && winT <= t_edge && winT >= t_edge - resist)) {
1120 newY = t_edge;
1121 vresist = True;
1122 }
1123 }
1124 } else {
1125 if (resist > 0 && attract && winT >= b_edge - resist && winT <= b_edge + resist) {
1126 newY = b_edge;
1127 vresist = True;
1128 }
1129 }
1130
1131 if ((winB - edge_t) < (edge_b - winB)) {
1132 if (resist > 0 && attract && winB <= edge_t + resist && winB >= edge_t - resist) {
1133 newY = edge_t - data->winHeight;
1134 vresist = True;
1135 }
1136 } else {
1137 if (resist > 0) {
1138 if ((attract && winB >= edge_b - resist && winB <= edge_b + resist)
1139 || (dy > 0 && winB >= edge_b && winB <= edge_b + resist)) {
1140 newY = edge_b - data->winHeight;
1141 vresist = True;
1142 }
1143 }
1144 }
1145 }
1146 /* END VeRT */
1147
1148 }
1149
1150 /* update window position */
1151 data->calcX += dx;
1152 data->calcY += dy;
1153
1154 if (((dx > 0 && data->calcX - data->realX > 0)
1155 || (dx < 0 && data->calcX - data->realX < 0)) && !hresist)
1156 newX = data->calcX;
1157
1158 if (((dy > 0 && data->calcY - data->realY > 0)
1159 || (dy < 0 && data->calcY - data->realY < 0)) && !vresist)
1160 newY = data->calcY;
1161
1162 if (data->realX != newX || data->realY != newY) {
1163
1164 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1165 showPosition(wwin, data->realX, data->realY);
1166 }
1167 if (opaqueMove) {
1168 doWindowMove(wwin, scr->selected_windows, newX - wwin->frame_x, newY - wwin->frame_y);
1169 } else {
1170 /* erase frames */
1171 drawFrames(wwin, scr->selected_windows,
1172 data->realX - wwin->frame_x, data->realY - wwin->frame_y);
1173 }
1174
1175 if (!scr->selected_windows && wPreferences.move_display == WDIS_FRAME_CENTER) {
1176
1177 moveGeometryDisplayCentered(scr, newX + data->winWidth / 2, newY + data->winHeight / 2);
1178 }
1179
1180 if (!opaqueMove) {
1181 /* draw frames */
1182 drawFrames(wwin, scr->selected_windows, newX - wwin->frame_x, newY - wwin->frame_y);
1183 }
1184
1185 if (!scr->selected_windows) {
1186 showPosition(wwin, newX, newY);
1187 }
1188 }
1189
1190 /* recalc relative window position */
1191 if (doResistance && (data->realX != newX || data->realY != newY)) {
1192 updateResistance(data, newX, newY);
1193 }
1194
1195 data->realX = newX;
1196 data->realY = newY;
1197 }
1198
1199 static void draw_snap_frame(WWindow *wwin, int direction)
1200 {
1201 WScreen *scr;
1202
1203 scr = wwin->screen_ptr;
1204
1205 switch (direction) {
1206 case SNAP_LEFT:
1207 drawTransparentFrame(wwin, 0, 0, scr->scr_width/2, scr->scr_height);
1208 break;
1209
1210 case SNAP_RIGHT:
1211 drawTransparentFrame(wwin, scr->scr_width/2, 0, scr->scr_width/2, scr->scr_height);
1212 break;
1213
1214 case SNAP_TOP:
1215 drawTransparentFrame(wwin, 0, 0, scr->scr_width, scr->scr_height/2);
1216 break;
1217
1218 case SNAP_BOTTOM:
1219 drawTransparentFrame(wwin, 0, scr->scr_height/2, scr->scr_width, scr->scr_height/2);
1220 break;
1221
1222 case SNAP_TOPLEFT:
1223 drawTransparentFrame(wwin, 0, 0, scr->scr_width/2, scr->scr_height/2);
1224 break;
1225
1226 case SNAP_TOPRIGHT:
1227 drawTransparentFrame(wwin, scr->scr_width/2, 0, scr->scr_width/2, scr->scr_height/2);
1228 break;
1229
1230 case SNAP_BOTTOMLEFT:
1231 drawTransparentFrame(wwin, 0, scr->scr_height/2, scr->scr_width/2, scr->scr_height/2);
1232 break;
1233
1234 case SNAP_BOTTOMRIGHT:
1235 drawTransparentFrame(wwin, scr->scr_width/2, scr->scr_height/2,
1236 scr->scr_width/2, scr->scr_height/2);
1237 break;
1238 }
1239 }
1240
1241 static int get_snap_direction(WScreen *scr, int x, int y)
1242 {
1243 int edge, corner;
1244
1245 edge = wPreferences.snap_edge_detect;
1246 corner = wPreferences.snap_corner_detect;
1247
1248 if (x < corner && y < corner)
1249 return SNAP_TOPLEFT;
1250 if (x < corner && y >= scr->scr_height - corner)
1251 return SNAP_BOTTOMLEFT;
1252 if (x < edge)
1253 return SNAP_LEFT;
1254
1255 if (x >= scr->scr_width - corner && y < corner)
1256 return SNAP_TOPRIGHT;
1257 if (x >= scr->scr_width - corner && y >= scr->scr_height - corner)
1258 return SNAP_BOTTOMRIGHT;
1259 if (x >= scr->scr_width - edge)
1260 return SNAP_RIGHT;
1261
1262 if (y < edge)
1263 return SNAP_TOP;
1264 if (y >= scr->scr_height - edge)
1265 return SNAP_BOTTOM;
1266 return SNAP_NONE;
1267 }
1268
1269 static void do_snap(WWindow *wwin, MoveData *data, Bool opaqueMove)
1270 {
1271 int directions;
1272 WScreen *scr;
1273
1274 directions = 0;
1275 scr = wwin->screen_ptr;
1276
1277 /* erase frames */
1278 if (!opaqueMove)
1279 drawFrames(wwin, scr->selected_windows, data->realX - wwin->frame_x, data->realY - wwin->frame_y);
1280 draw_snap_frame(wwin, data->snap);
1281
1282 switch (data->snap) {
1283 case SNAP_NONE:
1284 return;
1285 case SNAP_LEFT:
1286 directions = MAX_VERTICAL | MAX_LEFTHALF;
1287 break;
1288 case SNAP_RIGHT:
1289 directions = MAX_VERTICAL | MAX_RIGHTHALF;
1290 break;
1291 case SNAP_TOP:
1292 directions = MAX_HORIZONTAL | MAX_TOPHALF;
1293 break;
1294 case SNAP_BOTTOM:
1295 directions = MAX_HORIZONTAL | MAX_BOTTOMHALF;
1296 break;
1297 case SNAP_TOPLEFT:
1298 directions = MAX_TOPHALF | MAX_LEFTHALF;
1299 break;
1300 case SNAP_TOPRIGHT:
1301 directions = MAX_TOPHALF | MAX_RIGHTHALF;
1302 break;
1303 case SNAP_BOTTOMLEFT:
1304 directions = MAX_BOTTOMHALF | MAX_LEFTHALF;
1305 break;
1306 case SNAP_BOTTOMRIGHT:
1307 directions = MAX_BOTTOMHALF | MAX_RIGHTHALF;
1308 break;
1309 }
1310
1311 if (directions)
1312 handleMaximize(wwin, directions);
1313 data->snap = SNAP_NONE;
1314 }
1315
1316 #define _KS KEY_CONTROL_WINDOW_WEIGHT
1317
1318 #define MOVABLE_BIT 0x01
1319 #define RESIZABLE_BIT 0x02
1320
1321 int wKeyboardMoveResizeWindow(WWindow * wwin)
1322 {
1323 WScreen *scr = wwin->screen_ptr;
1324 Window root = scr->root_win;
1325 XEvent event;
1326 int w = wwin->frame->core->width;
1327 int h = wwin->frame->core->height;
1328 int scr_width = wwin->screen_ptr->scr_width;
1329 int scr_height = wwin->screen_ptr->scr_height;
1330 int vert_border = wwin->frame->top_width + wwin->frame->bottom_width;
1331 int src_x = wwin->frame_x;
1332 int src_y = wwin->frame_y;
1333 int original_w = w;
1334 int original_h = h;
1335 int done, off_x, off_y, ww, wh;
1336 int kspeed = _KS;
1337 int opaqueMoveResize = wPreferences.opaque_move_resize_keyboard;
1338 Time lastTime = 0;
1339 KeyCode shiftl, shiftr, ctrlmode;
1340 KeySym keysym = NoSymbol;
1341 int moment = 0;
1342 int modes = ((IS_MOVABLE(wwin) ? MOVABLE_BIT : 0) | (IS_RESIZABLE(wwin) ? RESIZABLE_BIT : 0));
1343 int head = ((wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1)
1344 ? wGetHeadForWindow(wwin)
1345 : scr->xine_info.primary_head);
1346
1347 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
1348 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
1349 ctrlmode = done = off_x = off_y = 0;
1350
1351 if (modes == RESIZABLE_BIT) {
1352 ctrlmode = 1;
1353 }
1354
1355 XSync(dpy, False);
1356 wusleep(10000);
1357 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
1358
1359 if (!wwin->flags.selected) {
1360 wUnselectWindows(scr);
1361 }
1362 XGrabServer(dpy);
1363 XGrabPointer(dpy, scr->root_win, True, PointerMotionMask
1364 | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
1365 GrabModeAsync, None, wPreferences.cursor[WCUR_NORMAL], CurrentTime);
1366
1367
1368
1369 if (!opaqueMoveResize) {
1370 if (wwin->flags.shaded || scr->selected_windows) {
1371 if (scr->selected_windows)
1372 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1373 else
1374 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1375 } else {
1376 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1377 }
1378 }
1379 if ((wwin->flags.shaded || scr->selected_windows) && (!scr->selected_windows)) {
1380 mapPositionDisplay(wwin, src_x, src_y, w, h);
1381
1382 }
1383 ww = w;
1384 wh = h;
1385 while (1) {
1386 /*
1387 looper.ox=off_x;
1388 looper.oy=off_y;
1389 */
1390 do {
1391 WMMaskEvent(dpy, KeyPressMask | ButtonReleaseMask
1392 | ButtonPressMask | ExposureMask, &event);
1393 if (event.type == Expose) {
1394 WMHandleEvent(&event);
1395 }
1396 } while (event.type == Expose);
1397
1398 if (!opaqueMoveResize) {
1399 if (wwin->flags.shaded || scr->selected_windows) {
1400 if (scr->selected_windows)
1401 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1402 else
1403 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1404 /*** I HATE EDGE RESISTANCE - ]d ***/
1405 } else {
1406 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, ww, wh);
1407 }
1408 }
1409
1410 if (ctrlmode)
1411 showGeometry(wwin, src_x + off_x, src_y + off_y, src_x + off_x + ww, src_y + off_y + wh,
1412 0);
1413
1414 XUngrabServer(dpy);
1415 XSync(dpy, False);
1416
1417 switch (event.type) {
1418 case KeyPress:
1419 /* accelerate */
1420 if (event.xkey.time - lastTime > 50) {
1421 kspeed /= (1 + (event.xkey.time - lastTime) / 100);
1422 } else {
1423 if (kspeed < 20) {
1424 kspeed++;
1425 }
1426 }
1427 if (kspeed < _KS)
1428 kspeed = _KS;
1429 lastTime = event.xkey.time;
1430 if (modes == (MOVABLE_BIT | RESIZABLE_BIT)) {
1431 if ((event.xkey.state & ControlMask) && !wwin->flags.shaded) {
1432 ctrlmode = 1;
1433 wUnselectWindows(scr);
1434 } else {
1435 ctrlmode = 0;
1436 }
1437 }
1438 if (event.xkey.keycode == shiftl || event.xkey.keycode == shiftr) {
1439 if (ctrlmode)
1440 cycleGeometryDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh, 0);
1441 else
1442 cyclePositionDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh);
1443 } else {
1444
1445 keysym = XLookupKeysym(&event.xkey, 0);
1446 switch (keysym) {
1447 case XK_Return:
1448 #ifdef XK_KP_Enter
1449 case XK_KP_Enter:
1450 #endif
1451 done = 2;
1452 break;
1453 case XK_Escape:
1454 done = 1;
1455 break;
1456 case XK_Up:
1457 #ifdef XK_KP_Up
1458 case XK_KP_Up:
1459 #endif
1460 case XK_k:
1461 if (ctrlmode) {
1462 if (moment != UP)
1463 h = wh;
1464 h -= kspeed;
1465 moment = UP;
1466 if (h < 1)
1467 h = 1;
1468 } else
1469 off_y -= kspeed;
1470 break;
1471 case XK_Down:
1472 #ifdef XK_KP_Down
1473 case XK_KP_Down:
1474 #endif
1475 case XK_j:
1476 if (ctrlmode) {
1477 if (moment != DOWN)
1478 h = wh;
1479 h += kspeed;
1480 moment = DOWN;
1481 } else
1482 off_y += kspeed;
1483 break;
1484 case XK_Left:
1485 #ifdef XK_KP_Left
1486 case XK_KP_Left:
1487 #endif
1488 case XK_h:
1489 if (ctrlmode) {
1490 if (moment != LEFT)
1491 w = ww;
1492 w -= kspeed;
1493 if (w < 1)
1494 w = 1;
1495 moment = LEFT;
1496 } else
1497 off_x -= kspeed;
1498 break;
1499 case XK_Right:
1500 #ifdef XK_KP_Right
1501 case XK_KP_Right:
1502 #endif
1503 case XK_l:
1504 if (ctrlmode) {
1505 if (moment != RIGHT)
1506 w = ww;
1507 w += kspeed;
1508 moment = RIGHT;
1509 } else
1510 off_x += kspeed;
1511 break;
1512 }
1513
1514 ww = w;
1515 wh = h;
1516 wh -= vert_border;
1517 wWindowConstrainSize(wwin, (unsigned int *)&ww, (unsigned int *)&wh);
1518 wh += vert_border;
1519
1520 if (wPreferences.ws_cycle) {
1521 if (src_x + off_x + ww < 20) {
1522 if (!scr->current_workspace)
1523 wWorkspaceChange(scr, scr->workspace_count - 1);
1524 else
1525 wWorkspaceChange(scr, scr->current_workspace - 1);
1526
1527 off_x += scr_width;
1528 } else if (src_x + off_x + 20 > scr_width) {
1529 if (scr->current_workspace == scr->workspace_count - 1)
1530 wWorkspaceChange(scr, 0);
1531 else
1532 wWorkspaceChange(scr, scr->current_workspace + 1);
1533
1534 off_x -= scr_width;
1535 }
1536 } else {
1537 if (src_x + off_x + ww < 20)
1538 off_x = 20 - ww - src_x;
1539 else if (src_x + off_x + 20 > scr_width)
1540 off_x = scr_width - 20 - src_x;
1541 }
1542
1543 if (src_y + off_y + wh < 20) {
1544 off_y = 20 - wh - src_y;
1545 } else if (src_y + off_y + 20 > scr_height) {
1546 off_y = scr_height - 20 - src_y;
1547 }
1548 }
1549 break;
1550 case ButtonPress:
1551 case ButtonRelease:
1552 done = 1;
1553 break;
1554 case Expose:
1555 WMHandleEvent(&event);
1556 while (XCheckTypedEvent(dpy, Expose, &event)) {
1557 WMHandleEvent(&event);
1558 }
1559 break;
1560
1561 default:
1562 WMHandleEvent(&event);
1563 break;
1564 }
1565
1566 XGrabServer(dpy);
1567 /*xxx */
1568
1569 if (wwin->flags.shaded && !scr->selected_windows) {
1570 moveGeometryDisplayCentered(scr, src_x + off_x + w / 2, src_y + off_y + h / 2);
1571 } else {
1572 if (ctrlmode) {
1573 WMUnmapWidget(scr->gview);
1574 mapGeometryDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh);
1575 } else if (!scr->selected_windows) {
1576 WMUnmapWidget(scr->gview);
1577 mapPositionDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh);
1578 }
1579 }
1580
1581 if (!opaqueMoveResize) {
1582 if (wwin->flags.shaded || scr->selected_windows) {
1583 if (scr->selected_windows)
1584 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1585 else
1586 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1587 } else {
1588 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, ww, wh);
1589 }
1590 }
1591
1592 if (ctrlmode) {
1593 showGeometry(wwin, src_x + off_x, src_y + off_y, src_x + off_x + ww, src_y + off_y + wh,
1594 0);
1595 } else if (!scr->selected_windows)
1596 showPosition(wwin, src_x + off_x, src_y + off_y);
1597
1598 if (opaqueMoveResize) {
1599 XUngrabServer(dpy);
1600 wWindowConfigure(wwin, src_x + off_x, src_y + off_y, ww, wh - vert_border);
1601 };
1602
1603 if (done) {
1604 if (!opaqueMoveResize) { /* ctrlmode => resize */
1605 if (wwin->flags.shaded || scr->selected_windows) {
1606 if (scr->selected_windows)
1607 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1608 else
1609 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1610 } else {
1611 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, ww, wh);
1612 }
1613 }
1614
1615 if (ctrlmode) {
1616 showGeometry(wwin, src_x + off_x, src_y + off_y, src_x + off_x + ww,
1617 src_y + off_y + wh, 0);
1618 WMUnmapWidget(scr->gview);
1619 } else
1620 WMUnmapWidget(scr->gview);
1621
1622 XUngrabKeyboard(dpy, CurrentTime);
1623 XUngrabPointer(dpy, CurrentTime);
1624 XUngrabServer(dpy);
1625
1626 if (done == 2) {
1627 if (wwin->flags.shaded || scr->selected_windows) {
1628 if (!scr->selected_windows) {
1629 wWindowMove(wwin, src_x + off_x, src_y + off_y);
1630 wWindowSynthConfigureNotify(wwin);
1631 } else {
1632 WMArrayIterator iter;
1633 WWindow *foo;
1634
1635 doWindowMove(wwin, scr->selected_windows, off_x, off_y);
1636
1637 WM_ITERATE_ARRAY(scr->selected_windows, foo, iter) {
1638 wWindowSynthConfigureNotify(foo);
1639 }
1640 }
1641 } else {
1642 if (ww != original_w)
1643 wwin->flags.maximized &= ~(MAX_HORIZONTAL | MAX_TOPHALF | MAX_BOTTOMHALF | MAX_MAXIMUS);
1644
1645 if (wh != original_h)
1646 wwin->flags.maximized &= ~(MAX_VERTICAL | MAX_LEFTHALF | MAX_RIGHTHALF | MAX_MAXIMUS);
1647
1648 wWindowConfigure(wwin, src_x + off_x, src_y + off_y, ww, wh - vert_border);
1649 wWindowSynthConfigureNotify(wwin);
1650 }
1651 wWindowChangeWorkspace(wwin, scr->current_workspace);
1652 wSetFocusTo(scr, wwin);
1653 }
1654
1655 if (wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1 &&
1656 head != wGetHeadForWindow(wwin)) {
1657 wArrangeIcons(scr, True);
1658 }
1659
1660 update_saved_geometry(wwin);
1661
1662 return 1;
1663 }
1664 }
1665 }
1666
1667 /*
1668 *----------------------------------------------------------------------
1669 * wMouseMoveWindow--
1670 * Move the named window and the other selected ones (if any),
1671 * interactively. Also shows the position of the window, if only one
1672 * window is being moved.
1673 * If the window is not on the selected window list, the selected
1674 * windows are deselected.
1675 * If shift is pressed during the operation, the position display
1676 * is changed to another type.
1677 *
1678 * Returns:
1679 * True if the window was moved, False otherwise.
1680 *
1681 * Side effects:
1682 * The window(s) position is changed, and the client(s) are
1683 * notified about that.
1684 * The position display configuration may be changed.
1685 *----------------------------------------------------------------------
1686 */
1687 int wMouseMoveWindow(WWindow * wwin, XEvent * ev)
1688 {
1689 WScreen *scr = wwin->screen_ptr;
1690 XEvent event;
1691 Window root = scr->root_win;
1692 KeyCode shiftl, shiftr;
1693 Bool done = False;
1694 int started = 0;
1695 int warped = 0;
1696 /* This needs not to change while moving, else bad things can happen */
1697 int opaqueMove = wPreferences.opaque_move;
1698 MoveData moveData;
1699 int head = ((wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1)
1700 ? wGetHeadForWindow(wwin)
1701 : scr->xine_info.primary_head);
1702
1703 if (!IS_MOVABLE(wwin))
1704 return False;
1705
1706 if (wPreferences.opaque_move && !wPreferences.use_saveunders) {
1707 XSetWindowAttributes attr;
1708
1709 attr.save_under = True;
1710 XChangeWindowAttributes(dpy, wwin->frame->core->window, CWSaveUnder, &attr);
1711 }
1712
1713 initMoveData(wwin, &moveData);
1714
1715 moveData.mouseX = ev->xmotion.x_root;
1716 moveData.mouseY = ev->xmotion.y_root;
1717
1718 if (!wwin->flags.selected) {
1719 /* this window is not selected, unselect others and move only wwin */
1720 wUnselectWindows(scr);
1721 }
1722 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
1723 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
1724 while (!done) {
1725 if (warped) {
1726 int junk;
1727 Window junkw;
1728
1729 /* XWarpPointer() doesn't seem to generate Motion events, so
1730 * we've got to simulate them */
1731 XQueryPointer(dpy, root, &junkw, &junkw, &event.xmotion.x_root,
1732 &event.xmotion.y_root, &junk, &junk, (unsigned *)&junk);
1733 } else {
1734 WMMaskEvent(dpy, KeyPressMask | ButtonMotionMask
1735 | PointerMotionHintMask
1736 | ButtonReleaseMask | ButtonPressMask | ExposureMask, &event);
1737
1738 if (event.type == MotionNotify) {
1739 /* compress MotionNotify events */
1740 while (XCheckMaskEvent(dpy, ButtonMotionMask, &event)) ;
1741 if (!checkMouseSamplingRate(&event))
1742 continue;
1743 }
1744 }
1745 switch (event.type) {
1746 case KeyPress:
1747 if ((event.xkey.keycode == shiftl || event.xkey.keycode == shiftr)
1748 && started && !scr->selected_windows) {
1749
1750 if (!opaqueMove) {
1751 drawFrames(wwin, scr->selected_windows,
1752 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1753 }
1754
1755 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1756 showPosition(wwin, moveData.realX, moveData.realY);
1757 XUngrabServer(dpy);
1758 }
1759 cyclePositionDisplay(wwin, moveData.realX, moveData.realY,
1760 moveData.winWidth, moveData.winHeight);
1761
1762 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1763 XGrabServer(dpy);
1764 showPosition(wwin, moveData.realX, moveData.realY);
1765 }
1766
1767 if (!opaqueMove) {
1768 drawFrames(wwin, scr->selected_windows,
1769 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1770 }
1771 /*} else {
1772 WMHandleEvent(&event); this causes problems needs fixing */
1773 }
1774 break;
1775
1776 case MotionNotify:
1777 if (IS_RESIZABLE(wwin) && wPreferences.window_snapping) {
1778 int snap_direction;
1779
1780 snap_direction = get_snap_direction(scr, moveData.mouseX, moveData.mouseY);
1781
1782 if (!wPreferences.no_autowrap &&
1783 snap_direction != SNAP_TOP &&
1784 snap_direction != SNAP_BOTTOM)
1785 snap_direction = SNAP_NONE;
1786
1787 if (moveData.snap != snap_direction) {
1788 /* erase old frame */
1789 if (moveData.snap)
1790 draw_snap_frame(wwin, moveData.snap);
1791 /* draw new frame */
1792 if (snap_direction)
1793 draw_snap_frame(wwin, snap_direction);
1794 moveData.snap = snap_direction;
1795 }
1796 }
1797
1798 if (started) {
1799 /* erase snap frame */
1800 if (moveData.snap)
1801 draw_snap_frame(wwin, moveData.snap);
1802
1803 updateWindowPosition(wwin, &moveData,
1804 scr->selected_windows == NULL
1805 && wPreferences.edge_resistance > 0,
1806 opaqueMove, event.xmotion.x_root, event.xmotion.y_root);
1807
1808 /* redraw snap frame */
1809 if (moveData.snap)
1810 draw_snap_frame(wwin, moveData.snap);
1811
1812 if (!warped && !wPreferences.no_autowrap) {
1813 int oldWorkspace = scr->current_workspace;
1814
1815 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1816 showPosition(wwin, moveData.realX, moveData.realY);
1817 XUngrabServer(dpy);
1818 }
1819 if (!opaqueMove) {
1820 drawFrames(wwin, scr->selected_windows,
1821 moveData.realX - wwin->frame_x,
1822 moveData.realY - wwin->frame_y);
1823 }
1824 if (checkWorkspaceChange(wwin, &moveData, opaqueMove)) {
1825 if (scr->current_workspace != oldWorkspace
1826 && wPreferences.edge_resistance > 0
1827 && scr->selected_windows == NULL)
1828 updateMoveData(wwin, &moveData);
1829 warped = 1;
1830 }
1831 if (!opaqueMove) {
1832 drawFrames(wwin, scr->selected_windows,
1833 moveData.realX - wwin->frame_x,
1834 moveData.realY - wwin->frame_y);
1835 }
1836 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1837 XSync(dpy, False);
1838 showPosition(wwin, moveData.realX, moveData.realY);
1839 XGrabServer(dpy);
1840 }
1841 } else {
1842 warped = 0;
1843 }
1844 } else if (abs(ev->xmotion.x_root - event.xmotion.x_root) >= MOVE_THRESHOLD
1845 || abs(ev->xmotion.y_root - event.xmotion.y_root) >= MOVE_THRESHOLD) {
1846
1847 if (wwin->flags.maximized) {
1848 if (wPreferences.drag_maximized_window == DRAGMAX_RESTORE) {
1849 float titlebar_ratio;
1850 int new_x, new_y;
1851
1852 titlebar_ratio = (moveData.mouseX - wwin->frame_x) /
1853 (float)wwin->frame->core->width;
1854 new_y = wwin->frame_y;
1855 wUnmaximizeWindow(wwin);
1856 new_x = moveData.mouseX - titlebar_ratio * wwin->frame->core->width;
1857 wWindowMove(wwin, new_x, new_y);
1858 moveData.realX = moveData.calcX = wwin->frame_x;
1859 moveData.realY = moveData.calcY = wwin->frame_y;
1860 }
1861 if (wPreferences.drag_maximized_window == DRAGMAX_UNMAXIMIZE) {
1862 wwin->flags.maximized = 0;
1863 wwin->flags.old_maximized = 0;
1864 }
1865 }
1866
1867 XChangeActivePointerGrab(dpy, ButtonMotionMask
1868 | ButtonReleaseMask | ButtonPressMask,
1869 wPreferences.cursor[WCUR_MOVE], CurrentTime);
1870 started = 1;
1871 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
1872
1873 if (!scr->selected_windows)
1874 mapPositionDisplay(wwin, moveData.realX, moveData.realY,
1875 moveData.winWidth, moveData.winHeight);
1876
1877 if (started && !opaqueMove)
1878 drawFrames(wwin, scr->selected_windows, 0, 0);
1879
1880 if (!opaqueMove || (wPreferences.move_display == WDIS_NEW
1881 && !scr->selected_windows)) {
1882 XGrabServer(dpy);
1883 if (wPreferences.move_display == WDIS_NEW)
1884 showPosition(wwin, moveData.realX, moveData.realY);
1885 }
1886 }
1887
1888 break;
1889
1890 case ButtonPress:
1891 break;
1892
1893 case ButtonRelease:
1894 if (event.xbutton.button != ev->xbutton.button)
1895 break;
1896
1897 if (started) {
1898 XEvent e;
1899
1900 if (moveData.snap)
1901 do_snap(wwin, &moveData, opaqueMove);
1902 else if (!opaqueMove) {
1903 drawFrames(wwin, scr->selected_windows,
1904 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1905 XSync(dpy, 0);
1906 doWindowMove(wwin, scr->selected_windows,
1907 moveData.realX - wwin->frame_x,
1908 moveData.realY - wwin->frame_y);
1909 }
1910 #ifndef CONFIGURE_WINDOW_WHILE_MOVING
1911 wWindowSynthConfigureNotify(wwin);
1912 #endif
1913 XUngrabKeyboard(dpy, CurrentTime);
1914 XUngrabServer(dpy);
1915 if (!opaqueMove) {
1916 wWindowChangeWorkspace(wwin, scr->current_workspace);
1917 wSetFocusTo(scr, wwin);
1918 }
1919 if (wPreferences.move_display == WDIS_NEW)
1920 showPosition(wwin, moveData.realX, moveData.realY);
1921
1922 /* discard all enter/leave events that happened until
1923 * the time the button was released */
1924 while (XCheckTypedEvent(dpy, EnterNotify, &e)) {
1925 if (e.xcrossing.time > event.xbutton.time) {
1926 XPutBackEvent(dpy, &e);
1927 break;
1928 }
1929 }
1930 while (XCheckTypedEvent(dpy, LeaveNotify, &e)) {
1931 if (e.xcrossing.time > event.xbutton.time) {
1932 XPutBackEvent(dpy, &e);
1933 break;
1934 }
1935 }
1936
1937 if (!scr->selected_windows) {
1938 /* get rid of the geometry window */
1939 WMUnmapWidget(scr->gview);
1940 }
1941 }
1942 done = True;
1943 break;
1944
1945 default:
1946 if (started && !opaqueMove) {
1947 drawFrames(wwin, scr->selected_windows,
1948 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1949 XUngrabServer(dpy);
1950 WMHandleEvent(&event);
1951 XSync(dpy, False);
1952 XGrabServer(dpy);
1953 drawFrames(wwin, scr->selected_windows,
1954 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1955 } else {
1956 WMHandleEvent(&event);
1957 }
1958 break;
1959 }
1960 }
1961
1962 if (wPreferences.opaque_move && !wPreferences.use_saveunders) {
1963 XSetWindowAttributes attr;
1964
1965 attr.save_under = False;
1966 XChangeWindowAttributes(dpy, wwin->frame->core->window, CWSaveUnder, &attr);
1967
1968 }
1969
1970 freeMoveData(&moveData);
1971
1972 if (started && wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1 &&
1973 head != wGetHeadForWindow(wwin)) {
1974 wArrangeIcons(scr, True);
1975 }
1976
1977 if (started)
1978 update_saved_geometry(wwin);
1979
1980 return started;
1981 }
1982
1983 #define RESIZEBAR 1
1984 #define HCONSTRAIN 2
1985
1986 static int getResizeDirection(WWindow * wwin, int x, int y, int dy, int flags)
1987 {
1988 int w = wwin->frame->core->width - 1;
1989 int cw = wwin->frame->resizebar_corner_width;
1990 int dir;
1991
1992 /* if not resizing through the resizebar */
1993 if (!(flags & RESIZEBAR)) {
1994
1995 int xdir = (abs(x) < (wwin->client.width / 2)) ? LEFT : RIGHT;
1996 int ydir = (abs(y) < (wwin->client.height / 2)) ? UP : DOWN;
1997
1998 /* How much resize space is allowed */
1999 int spacew = abs(wwin->client.width / 3);
2000 int spaceh = abs(wwin->client.height / 3);
2001
2002 /* Determine where x fits */
2003 if ((abs(x) > wwin->client.width/2 - spacew/2) &&
2004 (abs(x) < wwin->client.width/2 + spacew/2)) {
2005 /* Resize vertically */
2006 xdir = 0;
2007 } else if ((abs(y) > wwin->client.height/2 - spaceh/2) &&
2008 (abs(y) < wwin->client.height/2 + spaceh/2)) {
2009 /* Resize horizontally */
2010 ydir = 0;
2011 }
2012 return (xdir | ydir);
2013 }
2014
2015 /* window is too narrow. allow diagonal resize */
2016 if (cw * 2 >= w) {
2017 int ydir;
2018
2019 if (flags & HCONSTRAIN)
2020 ydir = 0;
2021 else
2022 ydir = DOWN;
2023 if (x < cw)
2024 return (LEFT | ydir);
2025 else
2026 return (RIGHT | ydir);
2027 }
2028 /* vertical resize */
2029 if ((x > cw) && (x < w - cw))
2030 return DOWN;
2031
2032 if (x < cw)
2033 dir = LEFT;
2034 else
2035 dir = RIGHT;
2036
2037 if ((abs(dy) > 0) && !(flags & HCONSTRAIN))
2038 dir |= DOWN;
2039
2040 return dir;
2041 }
2042
2043 void wMouseResizeWindow(WWindow * wwin, XEvent * ev)
2044 {
2045 XEvent event;
2046 WScreen *scr = wwin->screen_ptr;
2047 Window root = scr->root_win;
2048 int vert_border = wwin->frame->top_width + wwin->frame->bottom_width;
2049 int fw = wwin->frame->core->width;
2050 int fh = wwin->frame->core->height;
2051 int fx = wwin->frame_x;
2052 int fy = wwin->frame_y;
2053 int is_resizebar = (wwin->frame->resizebar && ev->xany.window == wwin->frame->resizebar->window);
2054 int orig_x, orig_y;
2055 int started;
2056 int dw, dh;
2057 int rw = fw, rh = fh;
2058 int rx1, ry1, rx2, ry2;
2059 int res = 0;
2060 KeyCode shiftl, shiftr;
2061 int orig_fx = fx;
2062 int orig_fy = fy;
2063 int orig_fw = fw;
2064 int orig_fh = fh;
2065 int original_fw = fw;
2066 int original_fh = fh;
2067 int head = ((wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1)
2068 ? wGetHeadForWindow(wwin)
2069 : scr->xine_info.primary_head);
2070 int opaqueResize = wPreferences.opaque_resize;
2071
2072 if (!IS_RESIZABLE(wwin))
2073 return;
2074
2075 if (wwin->flags.shaded) {
2076 wwarning("internal error: tryein");
2077 return;
2078 }
2079 orig_x = ev->xbutton.x_root;
2080 orig_y = ev->xbutton.y_root;
2081
2082 started = 0;
2083 wUnselectWindows(scr);
2084 rx1 = fx;
2085 rx2 = fx + fw - 1;
2086 ry1 = fy;
2087 ry2 = fy + fh - 1;
2088 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
2089 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
2090
2091 while (1) {
2092 WMMaskEvent(dpy, KeyPressMask | ButtonMotionMask
2093 | ButtonReleaseMask | PointerMotionHintMask | ButtonPressMask | ExposureMask, &event);
2094 if (!checkMouseSamplingRate(&event))
2095 continue;
2096
2097 switch (event.type) {
2098 case KeyPress:
2099 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2100 if (!opaqueResize) {
2101 if ((event.xkey.keycode == shiftl || event.xkey.keycode == shiftr)
2102 && started) {
2103 drawTransparentFrame(wwin, fx, fy, fw, fh);
2104 cycleGeometryDisplay(wwin, fx, fy, fw, fh, res);
2105 drawTransparentFrame(wwin, fx, fy, fw, fh);
2106 }
2107 };
2108 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2109 break;
2110
2111 case MotionNotify:
2112 if (started) {
2113 while (XCheckMaskEvent(dpy, ButtonMotionMask, &event)) ;
2114
2115 dw = 0;
2116 dh = 0;
2117
2118 orig_fx = fx;
2119 orig_fy = fy;
2120 orig_fw = fw;
2121 orig_fh = fh;
2122
2123 if (res & LEFT)
2124 dw = orig_x - event.xmotion.x_root;
2125 else if (res & RIGHT)
2126 dw = event.xmotion.x_root - orig_x;
2127 if (res & UP)
2128 dh = orig_y - event.xmotion.y_root;
2129 else if (res & DOWN)
2130 dh = event.xmotion.y_root - orig_y;
2131
2132 orig_x = event.xmotion.x_root;
2133 orig_y = event.xmotion.y_root;
2134
2135 rw += dw;
2136 rh += dh;
2137 fw = rw;
2138 fh = rh - vert_border;
2139 wWindowConstrainSize(wwin, (unsigned int *)&fw, (unsigned int *)&fh);
2140 fh += vert_border;
2141 if (res & LEFT)
2142 fx = rx2 - fw + 1;
2143 else if (res & RIGHT)
2144 fx = rx1;
2145 if (res & UP)
2146 fy = ry2 - fh + 1;
2147 else if (res & DOWN)
2148 fy = ry1;
2149 } else if (abs(orig_x - event.xmotion.x_root) >= MOVE_THRESHOLD
2150 || abs(orig_y - event.xmotion.y_root) >= MOVE_THRESHOLD) {
2151 int tx, ty;
2152 Window junkw;
2153 int flags;
2154
2155 XTranslateCoordinates(dpy, root, wwin->frame->core->window,
2156 orig_x, orig_y, &tx, &ty, &junkw);
2157
2158 /* check if resizing through resizebar */
2159 if (is_resizebar)
2160 flags = RESIZEBAR;
2161 else
2162 flags = 0;
2163
2164 if (is_resizebar && ((ev->xbutton.state & ShiftMask)
2165 || abs(orig_y - event.xmotion.y_root) < HRESIZE_THRESHOLD))
2166 flags |= HCONSTRAIN;
2167
2168 res = getResizeDirection(wwin, tx, ty, orig_y - event.xmotion.y_root, flags);
2169
2170 if (res == (UP | LEFT))
2171 XChangeActivePointerGrab(dpy, ButtonMotionMask
2172 | ButtonReleaseMask | ButtonPressMask,
2173 wPreferences.cursor[WCUR_TOPLEFTRESIZE], CurrentTime);
2174 else if (res == (UP | RIGHT))
2175 XChangeActivePointerGrab(dpy, ButtonMotionMask
2176 | ButtonReleaseMask | ButtonPressMask,
2177 wPreferences.cursor[WCUR_TOPRIGHTRESIZE], CurrentTime);
2178 else if (res == (DOWN | LEFT))
2179 XChangeActivePointerGrab(dpy, ButtonMotionMask
2180 | ButtonReleaseMask | ButtonPressMask,
2181 wPreferences.cursor[WCUR_BOTTOMLEFTRESIZE], CurrentTime);
2182 else if (res == (DOWN | RIGHT))
2183 XChangeActivePointerGrab(dpy, ButtonMotionMask
2184 | ButtonReleaseMask | ButtonPressMask,
2185 wPreferences.cursor[WCUR_BOTTOMRIGHTRESIZE], CurrentTime);
2186 else if (res == DOWN || res == UP)
2187 XChangeActivePointerGrab(dpy, ButtonMotionMask
2188 | ButtonReleaseMask | ButtonPressMask,
2189 wPreferences.cursor[WCUR_VERTICALRESIZE], CurrentTime);
2190 else if (res & (DOWN | UP))
2191 XChangeActivePointerGrab(dpy, ButtonMotionMask
2192 | ButtonReleaseMask | ButtonPressMask,
2193 wPreferences.cursor[WCUR_VERTICALRESIZE], CurrentTime);
2194 else if (res & (LEFT | RIGHT))
2195 XChangeActivePointerGrab(dpy, ButtonMotionMask
2196 | ButtonReleaseMask | ButtonPressMask,
2197 wPreferences.cursor[WCUR_HORIZONRESIZE], CurrentTime);
2198
2199 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
2200
2201 XGrabServer(dpy);
2202
2203 /* Draw the resize frame for the first time. */
2204 mapGeometryDisplay(wwin, fx, fy, fw, fh);
2205
2206 if (!opaqueResize)
2207 drawTransparentFrame(wwin, fx, fy, fw, fh);
2208
2209 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2210
2211 started = 1;
2212 }
2213 if (started) {
2214 if (!opaqueResize)
2215 drawTransparentFrame(wwin, orig_fx, orig_fy, orig_fw, orig_fh);
2216
2217 if (wPreferences.size_display == WDIS_FRAME_CENTER)
2218 moveGeometryDisplayCentered(scr, fx + fw / 2, fy + fh / 2);
2219
2220 if (!opaqueResize)
2221 drawTransparentFrame(wwin, fx, fy, fw, fh);
2222
2223 if (fh != orig_fh || fw != orig_fw) {
2224 if (wPreferences.size_display == WDIS_NEW)
2225 showGeometry(wwin, orig_fx, orig_fy, orig_fx + orig_fw,
2226 orig_fy + orig_fh, res);
2227
2228 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2229 }
2230
2231 if (opaqueResize) {
2232 /* Fist clean the geometry line */
2233 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2234 /* Now, continue drawing */
2235 XUngrabServer(dpy);
2236 moveGeometryDisplayCentered(scr, fx + fw / 2, fy + fh / 2);
2237 wWindowConfigure(wwin, fx, fy, fw, fh - vert_border);
2238 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2239 };
2240 }
2241 break;
2242
2243 case ButtonPress:
2244 break;
2245
2246 case ButtonRelease:
2247 if (event.xbutton.button != ev->xbutton.button)
2248 break;
2249
2250 if (started) {
2251 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2252
2253 if (!opaqueResize)
2254 drawTransparentFrame(wwin, fx, fy, fw, fh);
2255
2256 XUngrabKeyboard(dpy, CurrentTime);
2257 WMUnmapWidget(scr->gview);
2258 XUngrabServer(dpy);
2259
2260 if (fw != original_fw)
2261 wwin->flags.maximized &= ~(MAX_HORIZONTAL | MAX_TOPHALF | MAX_BOTTOMHALF | MAX_MAXIMUS);
2262
2263 if (fh != original_fh)
2264 wwin->flags.maximized &= ~(MAX_VERTICAL | MAX_LEFTHALF | MAX_RIGHTHALF | MAX_MAXIMUS);
2265
2266 wWindowConfigure(wwin, fx, fy, fw, fh - vert_border);
2267 wWindowSynthConfigureNotify(wwin);
2268 }
2269 return;
2270
2271 default:
2272 WMHandleEvent(&event);
2273 }
2274 }
2275
2276 if (wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1 && head != wGetHeadForWindow(wwin))
2277 wArrangeIcons(scr, True);
2278 }
2279
2280 #undef LEFT
2281 #undef RIGHT
2282 #undef UP
2283 #undef DOWN
2284 #undef HCONSTRAIN
2285 #undef RESIZEBAR
2286
2287 void wUnselectWindows(WScreen * scr)
2288 {
2289 WWindow *wwin;
2290
2291 if (!scr->selected_windows)
2292 return;
2293
2294 while (WMGetArrayItemCount(scr->selected_windows)) {
2295 wwin = WMGetFromArray(scr->selected_windows, 0);
2296 if (wwin->flags.miniaturized && wwin->icon && wwin->icon->selected)
2297 wIconSelect(wwin->icon);
2298
2299 wSelectWindow(wwin, False);
2300 }
2301 WMFreeArray(scr->selected_windows);
2302 scr->selected_windows = NULL;
2303 }
2304
2305 static void selectWindowsInside(WScreen * scr, int x1, int y1, int x2, int y2)
2306 {
2307 WWindow *tmpw;
2308
2309 /* select the windows and put them in the selected window list */
2310 tmpw = scr->focused_window;
2311 while (tmpw != NULL) {
2312 if (!(tmpw->flags.miniaturized || tmpw->flags.hidden)) {
2313 if ((tmpw->frame->workspace == scr->current_workspace || IS_OMNIPRESENT(tmpw))
2314 && (tmpw->frame_x >= x1) && (tmpw->frame_y >= y1)
2315 && (tmpw->frame->core->width + tmpw->frame_x <= x2)
2316 && (tmpw->frame->core->height + tmpw->frame_y <= y2)) {
2317 wSelectWindow(tmpw, True);
2318 }
2319 }
2320 tmpw = tmpw->prev;
2321 }
2322 }
2323
2324 void wSelectWindows(WScreen * scr, XEvent * ev)
2325 {
2326 XEvent event;
2327 Window root = scr->root_win;
2328 GC gc = scr->frame_gc;
2329 int xp = ev->xbutton.x_root;
2330 int yp = ev->xbutton.y_root;
2331 int w = 0, h = 0;
2332 int x = xp, y = yp;
2333
2334 if (XGrabPointer(dpy, scr->root_win, False, ButtonMotionMask
2335 | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
2336 GrabModeAsync, None, wPreferences.cursor[WCUR_NORMAL], CurrentTime) != Success) {
2337 return;
2338 }
2339 XGrabServer(dpy);
2340
2341 wUnselectWindows(scr);
2342
2343 XDrawRectangle(dpy, root, gc, xp, yp, w, h);
2344 while (1) {
2345 WMMaskEvent(dpy, ButtonReleaseMask | PointerMotionMask | ButtonPressMask, &event);
2346
2347 switch (event.type) {
2348 case MotionNotify:
2349 XDrawRectangle(dpy, root, gc, x, y, w, h);
2350 x = event.xmotion.x_root;
2351 if (x < xp) {
2352 w = xp - x;
2353 } else {
2354 w = x - xp;
2355 x = xp;
2356 }
2357 y = event.xmotion.y_root;
2358 if (y < yp) {
2359 h = yp - y;
2360 } else {
2361 h = y - yp;
2362 y = yp;
2363 }
2364 XDrawRectangle(dpy, root, gc, x, y, w, h);
2365 break;
2366
2367 case ButtonPress:
2368 break;
2369
2370 case ButtonRelease:
2371 if (event.xbutton.button != ev->xbutton.button)
2372 break;
2373
2374 XDrawRectangle(dpy, root, gc, x, y, w, h);
2375 XUngrabServer(dpy);
2376 XUngrabPointer(dpy, CurrentTime);
2377 selectWindowsInside(scr, x, y, x + w, y + h);
2378 return;
2379
2380 default:
2381 WMHandleEvent(&event);
2382 break;
2383 }
2384 }
2385 }
2386
2387 void InteractivePlaceWindow(WWindow * wwin, int *x_ret, int *y_ret, unsigned width, unsigned height)
2388 {
2389 WScreen *scr = wwin->screen_ptr;
2390 Window root = scr->root_win;
2391 int x, y, h = 0;
2392 XEvent event;
2393 KeyCode shiftl, shiftr;
2394 Window junkw;
2395 int junk;
2396
2397 if (XGrabPointer(dpy, root, True, PointerMotionMask | ButtonPressMask,
2398 GrabModeAsync, GrabModeAsync, None, wPreferences.cursor[WCUR_NORMAL], CurrentTime) != Success) {
2399 *x_ret = 0;
2400 *y_ret = 0;
2401 return;
2402 }
2403 if (HAS_TITLEBAR(wwin)) {
2404 h = WMFontHeight(scr->title_font) + (wPreferences.window_title_clearance +
2405 TITLEBAR_EXTEND_SPACE) * 2;
2406
2407 if (h > wPreferences.window_title_max_height)
2408 h = wPreferences.window_title_max_height;
2409
2410 if (h < wPreferences.window_title_min_height)
2411 h = wPreferences.window_title_min_height;
2412
2413 height += h;
2414 }
2415 if (HAS_RESIZEBAR(wwin)) {
2416 height += RESIZEBAR_HEIGHT;
2417 }
2418 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
2419 XQueryPointer(dpy, root, &junkw, &junkw, &x, &y, &junk, &junk, (unsigned *)&junk);
2420 mapPositionDisplay(wwin, x - width / 2, y - h / 2, width, height);
2421
2422 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2423
2424 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
2425 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
2426 while (1) {
2427 WMMaskEvent(dpy, PointerMotionMask | ButtonPressMask | ExposureMask | KeyPressMask, &event);
2428
2429 if (!checkMouseSamplingRate(&event))
2430 continue;
2431
2432 switch (event.type) {
2433 case KeyPress:
2434 if ((event.xkey.keycode == shiftl)
2435 || (event.xkey.keycode == shiftr)) {
2436 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2437 cyclePositionDisplay(wwin, x - width / 2, y - h / 2, width, height);
2438 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2439 }
2440 break;
2441
2442 case MotionNotify:
2443 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2444
2445 x = event.xmotion.x_root;
2446 y = event.xmotion.y_root;
2447
2448 if (wPreferences.move_display == WDIS_FRAME_CENTER)
2449 moveGeometryDisplayCentered(scr, x, y + (height - h) / 2);
2450
2451 showPosition(wwin, x - width / 2, y - h / 2);
2452
2453 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2454
2455 break;
2456
2457 case ButtonPress:
2458 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2459 XSync(dpy, 0);
2460 *x_ret = x - width / 2;
2461 *y_ret = y - h / 2;
2462 XUngrabPointer(dpy, CurrentTime);
2463 XUngrabKeyboard(dpy, CurrentTime);
2464 /* get rid of the geometry window */
2465 WMUnmapWidget(scr->gview);
2466 return;
2467
2468 default:
2469 WMHandleEvent(&event);
2470 break;
2471 }
2472 }
2473 }
The Window Maker window manager