?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update Serbian translation from master branch
[wmaker-crm.git] / src / moveres.c
blob24a1bb7046e97c75d30f4f0c7a18bfb30acc78b4
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 int head, x, y;
1203 unsigned int width, height;
1204 WMRect rect;
1205
1206 scr = wwin->screen_ptr;
1207 head = wGetHeadForWindow(wwin);
1208 rect = wGetRectForHead(scr, head);
1209
1210 x = rect.pos.x;
1211 y = rect.pos.y;
1212 width = rect.size.width;
1213 height = rect.size.height;
1214
1215 switch (direction) {
1216 case SNAP_LEFT:
1217 width /= 2;
1218 break;
1219
1220 case SNAP_RIGHT:
1221 width /= 2;
1222 x += width;
1223 break;
1224
1225 case SNAP_TOP:
1226 if (!wPreferences.snap_to_top_maximizes_fullscreen)
1227 height /= 2;
1228 break;
1229
1230 case SNAP_BOTTOM:
1231 height /= 2;
1232 y += height;
1233 break;
1234
1235 case SNAP_TOPLEFT:
1236 width /= 2;
1237 height /= 2;
1238 break;
1239
1240 case SNAP_TOPRIGHT:
1241 width /= 2;
1242 height /= 2;
1243 x += width;
1244 break;
1245
1246 case SNAP_BOTTOMLEFT:
1247 width /= 2;
1248 height /= 2;
1249 y += height;
1250 break;
1251
1252 case SNAP_BOTTOMRIGHT:
1253 width /= 2;
1254 height /= 2;
1255 x += width;
1256 y += height;
1257 break;
1258 }
1259
1260 drawTransparentFrame(wwin, x, y, width, height);
1261 }
1262
1263 static int get_snap_direction(WScreen *scr, int x, int y)
1264 {
1265 int edge, corner;
1266
1267 edge = wPreferences.snap_edge_detect;
1268 corner = wPreferences.snap_corner_detect;
1269
1270 if (x < corner && y < corner)
1271 return SNAP_TOPLEFT;
1272 if (x < corner && y >= scr->scr_height - corner)
1273 return SNAP_BOTTOMLEFT;
1274 if (x < edge)
1275 return SNAP_LEFT;
1276
1277 if (x >= scr->scr_width - corner && y < corner)
1278 return SNAP_TOPRIGHT;
1279 if (x >= scr->scr_width - corner && y >= scr->scr_height - corner)
1280 return SNAP_BOTTOMRIGHT;
1281 if (x >= scr->scr_width - edge)
1282 return SNAP_RIGHT;
1283
1284 if (y < edge)
1285 return SNAP_TOP;
1286 if (y >= scr->scr_height - edge)
1287 return SNAP_BOTTOM;
1288 return SNAP_NONE;
1289 }
1290
1291 static void do_snap(WWindow *wwin, MoveData *data, Bool opaqueMove)
1292 {
1293 int directions;
1294 WScreen *scr;
1295
1296 directions = 0;
1297 scr = wwin->screen_ptr;
1298
1299 /* erase frames */
1300 if (!opaqueMove)
1301 drawFrames(wwin, scr->selected_windows, data->realX - wwin->frame_x, data->realY - wwin->frame_y);
1302 draw_snap_frame(wwin, data->snap);
1303
1304 switch (data->snap) {
1305 case SNAP_NONE:
1306 return;
1307 case SNAP_LEFT:
1308 directions = MAX_VERTICAL | MAX_LEFTHALF;
1309 break;
1310 case SNAP_RIGHT:
1311 directions = MAX_VERTICAL | MAX_RIGHTHALF;
1312 break;
1313 case SNAP_TOP:
1314 if (wPreferences.snap_to_top_maximizes_fullscreen)
1315 directions = MAX_HORIZONTAL | MAX_VERTICAL;
1316 else
1317 directions = MAX_HORIZONTAL | MAX_TOPHALF;
1318 break;
1319 case SNAP_BOTTOM:
1320 directions = MAX_HORIZONTAL | MAX_BOTTOMHALF;
1321 break;
1322 case SNAP_TOPLEFT:
1323 directions = MAX_TOPHALF | MAX_LEFTHALF;
1324 break;
1325 case SNAP_TOPRIGHT:
1326 directions = MAX_TOPHALF | MAX_RIGHTHALF;
1327 break;
1328 case SNAP_BOTTOMLEFT:
1329 directions = MAX_BOTTOMHALF | MAX_LEFTHALF;
1330 break;
1331 case SNAP_BOTTOMRIGHT:
1332 directions = MAX_BOTTOMHALF | MAX_RIGHTHALF;
1333 break;
1334 }
1335
1336 if (directions)
1337 handleMaximize(wwin, directions);
1338 data->snap = SNAP_NONE;
1339 }
1340
1341 #define _KS KEY_CONTROL_WINDOW_WEIGHT
1342
1343 #define MOVABLE_BIT 0x01
1344 #define RESIZABLE_BIT 0x02
1345
1346 int wKeyboardMoveResizeWindow(WWindow * wwin)
1347 {
1348 WScreen *scr = wwin->screen_ptr;
1349 Window root = scr->root_win;
1350 XEvent event;
1351 int w = wwin->frame->core->width;
1352 int h = wwin->frame->core->height;
1353 int scr_width = wwin->screen_ptr->scr_width;
1354 int scr_height = wwin->screen_ptr->scr_height;
1355 int vert_border = wwin->frame->top_width + wwin->frame->bottom_width;
1356 int src_x = wwin->frame_x;
1357 int src_y = wwin->frame_y;
1358 int original_w = w;
1359 int original_h = h;
1360 int done, off_x, off_y, ww, wh;
1361 int kspeed = _KS;
1362 int opaqueMoveResize = wPreferences.opaque_move_resize_keyboard;
1363 Time lastTime = 0;
1364 KeyCode shiftl, shiftr, ctrlmode;
1365 KeySym keysym = NoSymbol;
1366 int moment = 0;
1367 int modes = ((IS_MOVABLE(wwin) ? MOVABLE_BIT : 0) | (IS_RESIZABLE(wwin) ? RESIZABLE_BIT : 0));
1368 int head = ((wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1)
1369 ? wGetHeadForWindow(wwin)
1370 : scr->xine_info.primary_head);
1371
1372 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
1373 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
1374 ctrlmode = done = off_x = off_y = 0;
1375
1376 if (modes == RESIZABLE_BIT) {
1377 ctrlmode = 1;
1378 }
1379
1380 XSync(dpy, False);
1381 wusleep(10000);
1382 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
1383
1384 if (!wwin->flags.selected) {
1385 wUnselectWindows(scr);
1386 }
1387 XGrabServer(dpy);
1388 XGrabPointer(dpy, scr->root_win, True, PointerMotionMask
1389 | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
1390 GrabModeAsync, None, wPreferences.cursor[WCUR_NORMAL], CurrentTime);
1391
1392
1393
1394 if (!opaqueMoveResize) {
1395 if (wwin->flags.shaded || scr->selected_windows) {
1396 if (scr->selected_windows)
1397 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1398 else
1399 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1400 } else {
1401 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1402 }
1403 }
1404 if ((wwin->flags.shaded || scr->selected_windows) && (!scr->selected_windows)) {
1405 mapPositionDisplay(wwin, src_x, src_y, w, h);
1406
1407 }
1408 ww = w;
1409 wh = h;
1410 while (1) {
1411 /*
1412 looper.ox=off_x;
1413 looper.oy=off_y;
1414 */
1415 do {
1416 WMMaskEvent(dpy, KeyPressMask | ButtonReleaseMask
1417 | ButtonPressMask | ExposureMask, &event);
1418 if (event.type == Expose) {
1419 WMHandleEvent(&event);
1420 }
1421 } while (event.type == Expose);
1422
1423 if (!opaqueMoveResize) {
1424 if (wwin->flags.shaded || scr->selected_windows) {
1425 if (scr->selected_windows)
1426 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1427 else
1428 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1429 /*** I HATE EDGE RESISTANCE - ]d ***/
1430 } else {
1431 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, ww, wh);
1432 }
1433 }
1434
1435 if (ctrlmode)
1436 showGeometry(wwin, src_x + off_x, src_y + off_y, src_x + off_x + ww, src_y + off_y + wh,
1437 0);
1438
1439 XUngrabServer(dpy);
1440 XSync(dpy, False);
1441
1442 switch (event.type) {
1443 case KeyPress:
1444 /* accelerate */
1445 if (event.xkey.time - lastTime > 50) {
1446 kspeed /= (1 + (event.xkey.time - lastTime) / 100);
1447 } else {
1448 if (kspeed < 20) {
1449 kspeed++;
1450 }
1451 }
1452 if (kspeed < _KS)
1453 kspeed = _KS;
1454 lastTime = event.xkey.time;
1455 if (modes == (MOVABLE_BIT | RESIZABLE_BIT)) {
1456 if ((event.xkey.state & ControlMask) && !wwin->flags.shaded) {
1457 ctrlmode = 1;
1458 wUnselectWindows(scr);
1459 } else {
1460 ctrlmode = 0;
1461 }
1462 }
1463 if (event.xkey.keycode == shiftl || event.xkey.keycode == shiftr) {
1464 if (ctrlmode)
1465 cycleGeometryDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh, 0);
1466 else
1467 cyclePositionDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh);
1468 } else {
1469
1470 keysym = XLookupKeysym(&event.xkey, 0);
1471 switch (keysym) {
1472 case XK_Return:
1473 #ifdef XK_KP_Enter
1474 case XK_KP_Enter:
1475 #endif
1476 done = 2;
1477 break;
1478 case XK_Escape:
1479 done = 1;
1480 break;
1481 case XK_Up:
1482 #ifdef XK_KP_Up
1483 case XK_KP_Up:
1484 #endif
1485 case XK_k:
1486 if (ctrlmode) {
1487 if (moment != UP)
1488 h = wh;
1489 h -= kspeed;
1490 moment = UP;
1491 if (h < 1)
1492 h = 1;
1493 } else
1494 off_y -= kspeed;
1495 break;
1496 case XK_Down:
1497 #ifdef XK_KP_Down
1498 case XK_KP_Down:
1499 #endif
1500 case XK_j:
1501 if (ctrlmode) {
1502 if (moment != DOWN)
1503 h = wh;
1504 h += kspeed;
1505 moment = DOWN;
1506 } else
1507 off_y += kspeed;
1508 break;
1509 case XK_Left:
1510 #ifdef XK_KP_Left
1511 case XK_KP_Left:
1512 #endif
1513 case XK_h:
1514 if (ctrlmode) {
1515 if (moment != LEFT)
1516 w = ww;
1517 w -= kspeed;
1518 if (w < 1)
1519 w = 1;
1520 moment = LEFT;
1521 } else
1522 off_x -= kspeed;
1523 break;
1524 case XK_Right:
1525 #ifdef XK_KP_Right
1526 case XK_KP_Right:
1527 #endif
1528 case XK_l:
1529 if (ctrlmode) {
1530 if (moment != RIGHT)
1531 w = ww;
1532 w += kspeed;
1533 moment = RIGHT;
1534 } else
1535 off_x += kspeed;
1536 break;
1537 }
1538
1539 ww = w;
1540 wh = h;
1541 wh -= vert_border;
1542 wWindowConstrainSize(wwin, (unsigned int *)&ww, (unsigned int *)&wh);
1543 wh += vert_border;
1544
1545 if (wPreferences.ws_cycle) {
1546 if (src_x + off_x + ww < 20) {
1547 if (!scr->current_workspace)
1548 wWorkspaceChange(scr, scr->workspace_count - 1);
1549 else
1550 wWorkspaceChange(scr, scr->current_workspace - 1);
1551
1552 off_x += scr_width;
1553 } else if (src_x + off_x + 20 > scr_width) {
1554 if (scr->current_workspace == scr->workspace_count - 1)
1555 wWorkspaceChange(scr, 0);
1556 else
1557 wWorkspaceChange(scr, scr->current_workspace + 1);
1558
1559 off_x -= scr_width;
1560 }
1561 } else {
1562 if (src_x + off_x + ww < 20)
1563 off_x = 20 - ww - src_x;
1564 else if (src_x + off_x + 20 > scr_width)
1565 off_x = scr_width - 20 - src_x;
1566 }
1567
1568 if (src_y + off_y + wh < 20) {
1569 off_y = 20 - wh - src_y;
1570 } else if (src_y + off_y + 20 > scr_height) {
1571 off_y = scr_height - 20 - src_y;
1572 }
1573 }
1574 break;
1575 case ButtonPress:
1576 case ButtonRelease:
1577 done = 1;
1578 break;
1579 case Expose:
1580 WMHandleEvent(&event);
1581 while (XCheckTypedEvent(dpy, Expose, &event)) {
1582 WMHandleEvent(&event);
1583 }
1584 break;
1585
1586 default:
1587 WMHandleEvent(&event);
1588 break;
1589 }
1590
1591 XGrabServer(dpy);
1592 /*xxx */
1593
1594 if (wwin->flags.shaded && !scr->selected_windows) {
1595 moveGeometryDisplayCentered(scr, src_x + off_x + w / 2, src_y + off_y + h / 2);
1596 } else {
1597 if (ctrlmode) {
1598 WMUnmapWidget(scr->gview);
1599 mapGeometryDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh);
1600 } else if (!scr->selected_windows) {
1601 WMUnmapWidget(scr->gview);
1602 mapPositionDisplay(wwin, src_x + off_x, src_y + off_y, ww, wh);
1603 }
1604 }
1605
1606 if (!opaqueMoveResize) {
1607 if (wwin->flags.shaded || scr->selected_windows) {
1608 if (scr->selected_windows)
1609 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1610 else
1611 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1612 } else {
1613 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, ww, wh);
1614 }
1615 }
1616
1617 if (ctrlmode) {
1618 showGeometry(wwin, src_x + off_x, src_y + off_y, src_x + off_x + ww, src_y + off_y + wh,
1619 0);
1620 } else if (!scr->selected_windows)
1621 showPosition(wwin, src_x + off_x, src_y + off_y);
1622
1623 if (opaqueMoveResize) {
1624 XUngrabServer(dpy);
1625 wWindowConfigure(wwin, src_x + off_x, src_y + off_y, ww, wh - vert_border);
1626 };
1627
1628 if (done) {
1629 if (!opaqueMoveResize) { /* ctrlmode => resize */
1630 if (wwin->flags.shaded || scr->selected_windows) {
1631 if (scr->selected_windows)
1632 drawFrames(wwin, scr->selected_windows, off_x, off_y);
1633 else
1634 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, w, h);
1635 } else {
1636 drawTransparentFrame(wwin, src_x + off_x, src_y + off_y, ww, wh);
1637 }
1638 }
1639
1640 if (ctrlmode) {
1641 showGeometry(wwin, src_x + off_x, src_y + off_y, src_x + off_x + ww,
1642 src_y + off_y + wh, 0);
1643 WMUnmapWidget(scr->gview);
1644 } else
1645 WMUnmapWidget(scr->gview);
1646
1647 XUngrabKeyboard(dpy, CurrentTime);
1648 XUngrabPointer(dpy, CurrentTime);
1649 XUngrabServer(dpy);
1650
1651 if (done == 2) {
1652 if (wwin->flags.shaded || scr->selected_windows) {
1653 if (!scr->selected_windows) {
1654 wWindowMove(wwin, src_x + off_x, src_y + off_y);
1655 wWindowSynthConfigureNotify(wwin);
1656 } else {
1657 WMArrayIterator iter;
1658 WWindow *foo;
1659
1660 doWindowMove(wwin, scr->selected_windows, off_x, off_y);
1661
1662 WM_ITERATE_ARRAY(scr->selected_windows, foo, iter) {
1663 wWindowSynthConfigureNotify(foo);
1664 }
1665 }
1666 } else {
1667 if (ww != original_w)
1668 wwin->flags.maximized &= ~(MAX_HORIZONTAL | MAX_TOPHALF | MAX_BOTTOMHALF | MAX_MAXIMUS | MAX_CENTRAL);
1669
1670 if (wh != original_h)
1671 wwin->flags.maximized &= ~(MAX_VERTICAL | MAX_LEFTHALF | MAX_RIGHTHALF | MAX_MAXIMUS | MAX_CENTRAL);
1672
1673 wWindowConfigure(wwin, src_x + off_x, src_y + off_y, ww, wh - vert_border);
1674 wWindowSynthConfigureNotify(wwin);
1675 }
1676 wWindowChangeWorkspace(wwin, scr->current_workspace);
1677 wSetFocusTo(scr, wwin);
1678 }
1679
1680 if (wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1 &&
1681 head != wGetHeadForWindow(wwin)) {
1682 wArrangeIcons(scr, True);
1683 }
1684
1685 update_saved_geometry(wwin);
1686
1687 return 1;
1688 }
1689 }
1690 }
1691
1692 /*
1693 *----------------------------------------------------------------------
1694 * wMouseMoveWindow--
1695 * Move the named window and the other selected ones (if any),
1696 * interactively. Also shows the position of the window, if only one
1697 * window is being moved.
1698 * If the window is not on the selected window list, the selected
1699 * windows are deselected.
1700 * If shift is pressed during the operation, the position display
1701 * is changed to another type.
1702 *
1703 * Returns:
1704 * True if the window was moved, False otherwise.
1705 *
1706 * Side effects:
1707 * The window(s) position is changed, and the client(s) are
1708 * notified about that.
1709 * The position display configuration may be changed.
1710 *----------------------------------------------------------------------
1711 */
1712 int wMouseMoveWindow(WWindow * wwin, XEvent * ev)
1713 {
1714 WScreen *scr = wwin->screen_ptr;
1715 XEvent event;
1716 Window root = scr->root_win;
1717 KeyCode shiftl, shiftr;
1718 Bool done = False;
1719 int started = 0;
1720 int warped = 0;
1721 /* This needs not to change while moving, else bad things can happen */
1722 int opaqueMove = wPreferences.opaque_move;
1723 MoveData moveData;
1724 int head = ((wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1)
1725 ? wGetHeadForWindow(wwin)
1726 : scr->xine_info.primary_head);
1727
1728 if (!IS_MOVABLE(wwin))
1729 return False;
1730
1731 if (wPreferences.opaque_move && !wPreferences.use_saveunders) {
1732 XSetWindowAttributes attr;
1733
1734 attr.save_under = True;
1735 XChangeWindowAttributes(dpy, wwin->frame->core->window, CWSaveUnder, &attr);
1736 }
1737
1738 initMoveData(wwin, &moveData);
1739
1740 moveData.mouseX = ev->xmotion.x_root;
1741 moveData.mouseY = ev->xmotion.y_root;
1742
1743 if (!wwin->flags.selected) {
1744 /* this window is not selected, unselect others and move only wwin */
1745 wUnselectWindows(scr);
1746 }
1747 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
1748 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
1749 while (!done) {
1750 if (warped) {
1751 int junk;
1752 Window junkw;
1753
1754 /* XWarpPointer() doesn't seem to generate Motion events, so
1755 * we've got to simulate them */
1756 XQueryPointer(dpy, root, &junkw, &junkw, &event.xmotion.x_root,
1757 &event.xmotion.y_root, &junk, &junk, (unsigned *)&junk);
1758 } else {
1759 WMMaskEvent(dpy, KeyPressMask | ButtonMotionMask
1760 | PointerMotionHintMask
1761 | ButtonReleaseMask | ButtonPressMask | ExposureMask, &event);
1762
1763 if (event.type == MotionNotify) {
1764 /* compress MotionNotify events */
1765 while (XCheckMaskEvent(dpy, ButtonMotionMask, &event)) ;
1766 if (!checkMouseSamplingRate(&event))
1767 continue;
1768 }
1769 }
1770 switch (event.type) {
1771 case KeyPress:
1772 if ((event.xkey.keycode == shiftl || event.xkey.keycode == shiftr)
1773 && started && !scr->selected_windows) {
1774
1775 if (!opaqueMove) {
1776 drawFrames(wwin, scr->selected_windows,
1777 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1778 }
1779
1780 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1781 showPosition(wwin, moveData.realX, moveData.realY);
1782 XUngrabServer(dpy);
1783 }
1784 cyclePositionDisplay(wwin, moveData.realX, moveData.realY,
1785 moveData.winWidth, moveData.winHeight);
1786
1787 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1788 XGrabServer(dpy);
1789 showPosition(wwin, moveData.realX, moveData.realY);
1790 }
1791
1792 if (!opaqueMove) {
1793 drawFrames(wwin, scr->selected_windows,
1794 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1795 }
1796 /*} else {
1797 WMHandleEvent(&event); this causes problems needs fixing */
1798 }
1799 break;
1800
1801 case MotionNotify:
1802 if (IS_RESIZABLE(wwin) && wPreferences.window_snapping) {
1803 int snap_direction;
1804
1805 snap_direction = get_snap_direction(scr, moveData.mouseX, moveData.mouseY);
1806
1807 if (!wPreferences.no_autowrap &&
1808 snap_direction != SNAP_TOP &&
1809 snap_direction != SNAP_BOTTOM)
1810 snap_direction = SNAP_NONE;
1811
1812 if (moveData.snap != snap_direction) {
1813 /* erase old frame */
1814 if (moveData.snap)
1815 draw_snap_frame(wwin, moveData.snap);
1816 /* draw new frame */
1817 if (snap_direction)
1818 draw_snap_frame(wwin, snap_direction);
1819 moveData.snap = snap_direction;
1820 }
1821 }
1822
1823 if (started) {
1824 /* erase snap frame */
1825 if (moveData.snap)
1826 draw_snap_frame(wwin, moveData.snap);
1827
1828 updateWindowPosition(wwin, &moveData,
1829 scr->selected_windows == NULL
1830 && wPreferences.edge_resistance > 0,
1831 opaqueMove, event.xmotion.x_root, event.xmotion.y_root);
1832
1833 /* redraw snap frame */
1834 if (moveData.snap)
1835 draw_snap_frame(wwin, moveData.snap);
1836
1837 if (!warped && !wPreferences.no_autowrap) {
1838 int oldWorkspace = scr->current_workspace;
1839
1840 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1841 showPosition(wwin, moveData.realX, moveData.realY);
1842 XUngrabServer(dpy);
1843 }
1844 if (!opaqueMove) {
1845 drawFrames(wwin, scr->selected_windows,
1846 moveData.realX - wwin->frame_x,
1847 moveData.realY - wwin->frame_y);
1848 }
1849 if (checkWorkspaceChange(wwin, &moveData, opaqueMove)) {
1850 if (scr->current_workspace != oldWorkspace
1851 && wPreferences.edge_resistance > 0
1852 && scr->selected_windows == NULL)
1853 updateMoveData(wwin, &moveData);
1854 warped = 1;
1855 }
1856 if (!opaqueMove) {
1857 drawFrames(wwin, scr->selected_windows,
1858 moveData.realX - wwin->frame_x,
1859 moveData.realY - wwin->frame_y);
1860 }
1861 if (wPreferences.move_display == WDIS_NEW && !scr->selected_windows) {
1862 XSync(dpy, False);
1863 showPosition(wwin, moveData.realX, moveData.realY);
1864 XGrabServer(dpy);
1865 }
1866 } else {
1867 warped = 0;
1868 }
1869 } else if (abs(ev->xmotion.x_root - event.xmotion.x_root) >= MOVE_THRESHOLD
1870 || abs(ev->xmotion.y_root - event.xmotion.y_root) >= MOVE_THRESHOLD) {
1871
1872 if (wwin->flags.maximized) {
1873 if (wPreferences.drag_maximized_window == DRAGMAX_RESTORE) {
1874 float titlebar_ratio;
1875 int new_x, new_y;
1876
1877 titlebar_ratio = (moveData.mouseX - wwin->frame_x) /
1878 (float)wwin->frame->core->width;
1879 new_y = wwin->frame_y;
1880 wUnmaximizeWindow(wwin);
1881 new_x = moveData.mouseX - titlebar_ratio * wwin->frame->core->width;
1882 wWindowMove(wwin, new_x, new_y);
1883 moveData.realX = moveData.calcX = wwin->frame_x;
1884 moveData.realY = moveData.calcY = wwin->frame_y;
1885 }
1886 if (wPreferences.drag_maximized_window == DRAGMAX_UNMAXIMIZE) {
1887 wwin->flags.maximized = 0;
1888 wwin->flags.old_maximized = 0;
1889 }
1890 }
1891
1892 XChangeActivePointerGrab(dpy, ButtonMotionMask
1893 | ButtonReleaseMask | ButtonPressMask,
1894 wPreferences.cursor[WCUR_MOVE], CurrentTime);
1895 started = 1;
1896 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
1897
1898 if (!scr->selected_windows)
1899 mapPositionDisplay(wwin, moveData.realX, moveData.realY,
1900 moveData.winWidth, moveData.winHeight);
1901
1902 if (started && !opaqueMove)
1903 drawFrames(wwin, scr->selected_windows, 0, 0);
1904
1905 if (!opaqueMove || (wPreferences.move_display == WDIS_NEW
1906 && !scr->selected_windows)) {
1907 XGrabServer(dpy);
1908 if (wPreferences.move_display == WDIS_NEW)
1909 showPosition(wwin, moveData.realX, moveData.realY);
1910 }
1911 }
1912
1913 break;
1914
1915 case ButtonPress:
1916 break;
1917
1918 case ButtonRelease:
1919 if (event.xbutton.button != ev->xbutton.button)
1920 break;
1921
1922 if (started) {
1923 XEvent e;
1924
1925 if (moveData.snap)
1926 do_snap(wwin, &moveData, opaqueMove);
1927 else if (!opaqueMove) {
1928 drawFrames(wwin, scr->selected_windows,
1929 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1930 XSync(dpy, 0);
1931 doWindowMove(wwin, scr->selected_windows,
1932 moveData.realX - wwin->frame_x,
1933 moveData.realY - wwin->frame_y);
1934 }
1935 #ifndef CONFIGURE_WINDOW_WHILE_MOVING
1936 wWindowSynthConfigureNotify(wwin);
1937 #endif
1938 XUngrabKeyboard(dpy, CurrentTime);
1939 XUngrabServer(dpy);
1940 if (!opaqueMove) {
1941 wWindowChangeWorkspace(wwin, scr->current_workspace);
1942 wSetFocusTo(scr, wwin);
1943 }
1944 if (wPreferences.move_display == WDIS_NEW)
1945 showPosition(wwin, moveData.realX, moveData.realY);
1946
1947 /* discard all enter/leave events that happened until
1948 * the time the button was released */
1949 while (XCheckTypedEvent(dpy, EnterNotify, &e)) {
1950 if (e.xcrossing.time > event.xbutton.time) {
1951 XPutBackEvent(dpy, &e);
1952 break;
1953 }
1954 }
1955 while (XCheckTypedEvent(dpy, LeaveNotify, &e)) {
1956 if (e.xcrossing.time > event.xbutton.time) {
1957 XPutBackEvent(dpy, &e);
1958 break;
1959 }
1960 }
1961
1962 if (!scr->selected_windows) {
1963 /* get rid of the geometry window */
1964 WMUnmapWidget(scr->gview);
1965 }
1966 }
1967 done = True;
1968 break;
1969
1970 default:
1971 if (started && !opaqueMove) {
1972 drawFrames(wwin, scr->selected_windows,
1973 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1974 XUngrabServer(dpy);
1975 WMHandleEvent(&event);
1976 XSync(dpy, False);
1977 XGrabServer(dpy);
1978 drawFrames(wwin, scr->selected_windows,
1979 moveData.realX - wwin->frame_x, moveData.realY - wwin->frame_y);
1980 } else {
1981 WMHandleEvent(&event);
1982 }
1983 break;
1984 }
1985 }
1986
1987 if (wPreferences.opaque_move && !wPreferences.use_saveunders) {
1988 XSetWindowAttributes attr;
1989
1990 attr.save_under = False;
1991 XChangeWindowAttributes(dpy, wwin->frame->core->window, CWSaveUnder, &attr);
1992
1993 }
1994
1995 freeMoveData(&moveData);
1996
1997 if (started && wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1 &&
1998 head != wGetHeadForWindow(wwin)) {
1999 wArrangeIcons(scr, True);
2000 }
2001
2002 if (started)
2003 update_saved_geometry(wwin);
2004
2005 return started;
2006 }
2007
2008 #define RESIZEBAR 1
2009 #define HCONSTRAIN 2
2010
2011 static int getResizeDirection(WWindow * wwin, int x, int y, int dy, int flags)
2012 {
2013 int w = wwin->frame->core->width - 1;
2014 int cw = wwin->frame->resizebar_corner_width;
2015 int dir;
2016
2017 /* if not resizing through the resizebar */
2018 if (!(flags & RESIZEBAR)) {
2019
2020 int xdir = (abs(x) < (wwin->client.width / 2)) ? LEFT : RIGHT;
2021 int ydir = (abs(y) < (wwin->client.height / 2)) ? UP : DOWN;
2022
2023 /* How much resize space is allowed */
2024 int spacew = wwin->client.width / 3;
2025 int spaceh = wwin->client.height / 3;
2026
2027 /* Determine where x fits */
2028 if ((abs(x) > wwin->client.width/2 - spacew/2) &&
2029 (abs(x) < wwin->client.width/2 + spacew/2)) {
2030 /* Resize vertically */
2031 xdir = 0;
2032 } else if ((abs(y) > wwin->client.height/2 - spaceh/2) &&
2033 (abs(y) < wwin->client.height/2 + spaceh/2)) {
2034 /* Resize horizontally */
2035 ydir = 0;
2036 }
2037 return (xdir | ydir);
2038 }
2039
2040 /* window is too narrow. allow diagonal resize */
2041 if (cw * 2 >= w) {
2042 int ydir;
2043
2044 if (flags & HCONSTRAIN)
2045 ydir = 0;
2046 else
2047 ydir = DOWN;
2048 if (x < cw)
2049 return (LEFT | ydir);
2050 else
2051 return (RIGHT | ydir);
2052 }
2053 /* vertical resize */
2054 if ((x > cw) && (x < w - cw))
2055 return DOWN;
2056
2057 if (x < cw)
2058 dir = LEFT;
2059 else
2060 dir = RIGHT;
2061
2062 if ((abs(dy) > 0) && !(flags & HCONSTRAIN))
2063 dir |= DOWN;
2064
2065 return dir;
2066 }
2067
2068 void wMouseResizeWindow(WWindow * wwin, XEvent * ev)
2069 {
2070 XEvent event;
2071 WScreen *scr = wwin->screen_ptr;
2072 Window root = scr->root_win;
2073 int vert_border = wwin->frame->top_width + wwin->frame->bottom_width;
2074 int fw = wwin->frame->core->width;
2075 int fh = wwin->frame->core->height;
2076 int fx = wwin->frame_x;
2077 int fy = wwin->frame_y;
2078 int is_resizebar = (wwin->frame->resizebar && ev->xany.window == wwin->frame->resizebar->window);
2079 int orig_x, orig_y;
2080 int started;
2081 int dw, dh;
2082 int rw = fw, rh = fh;
2083 int rx1, ry1, rx2, ry2;
2084 int res = 0;
2085 KeyCode shiftl, shiftr;
2086 int orig_fx = fx;
2087 int orig_fy = fy;
2088 int orig_fw = fw;
2089 int orig_fh = fh;
2090 int original_fw = fw;
2091 int original_fh = fh;
2092 int head = ((wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1)
2093 ? wGetHeadForWindow(wwin)
2094 : scr->xine_info.primary_head);
2095 int opaqueResize = wPreferences.opaque_resize;
2096
2097 if (!IS_RESIZABLE(wwin))
2098 return;
2099
2100 if (wwin->flags.shaded) {
2101 wwarning("internal error: tryein");
2102 return;
2103 }
2104 orig_x = ev->xbutton.x_root;
2105 orig_y = ev->xbutton.y_root;
2106
2107 started = 0;
2108 wUnselectWindows(scr);
2109 rx1 = fx;
2110 rx2 = fx + fw - 1;
2111 ry1 = fy;
2112 ry2 = fy + fh - 1;
2113 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
2114 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
2115
2116 while (1) {
2117 WMMaskEvent(dpy, KeyPressMask | ButtonMotionMask
2118 | ButtonReleaseMask | PointerMotionHintMask | ButtonPressMask | ExposureMask, &event);
2119 if (!checkMouseSamplingRate(&event))
2120 continue;
2121
2122 switch (event.type) {
2123 case KeyPress:
2124 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2125 if (!opaqueResize) {
2126 if ((event.xkey.keycode == shiftl || event.xkey.keycode == shiftr)
2127 && started) {
2128 drawTransparentFrame(wwin, fx, fy, fw, fh);
2129 cycleGeometryDisplay(wwin, fx, fy, fw, fh, res);
2130 drawTransparentFrame(wwin, fx, fy, fw, fh);
2131 }
2132 };
2133 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2134 break;
2135
2136 case MotionNotify:
2137 if (started) {
2138 while (XCheckMaskEvent(dpy, ButtonMotionMask, &event)) ;
2139
2140 dw = 0;
2141 dh = 0;
2142
2143 orig_fx = fx;
2144 orig_fy = fy;
2145 orig_fw = fw;
2146 orig_fh = fh;
2147
2148 if (res & LEFT)
2149 dw = orig_x - event.xmotion.x_root;
2150 else if (res & RIGHT)
2151 dw = event.xmotion.x_root - orig_x;
2152 if (res & UP)
2153 dh = orig_y - event.xmotion.y_root;
2154 else if (res & DOWN)
2155 dh = event.xmotion.y_root - orig_y;
2156
2157 orig_x = event.xmotion.x_root;
2158 orig_y = event.xmotion.y_root;
2159
2160 rw += dw;
2161 rh += dh;
2162 fw = rw;
2163 fh = rh - vert_border;
2164 wWindowConstrainSize(wwin, (unsigned int *)&fw, (unsigned int *)&fh);
2165 fh += vert_border;
2166 if (res & LEFT)
2167 fx = rx2 - fw + 1;
2168 else if (res & RIGHT)
2169 fx = rx1;
2170 if (res & UP)
2171 fy = ry2 - fh + 1;
2172 else if (res & DOWN)
2173 fy = ry1;
2174 } else if (abs(orig_x - event.xmotion.x_root) >= MOVE_THRESHOLD
2175 || abs(orig_y - event.xmotion.y_root) >= MOVE_THRESHOLD) {
2176 int tx, ty;
2177 Window junkw;
2178 int flags;
2179
2180 XTranslateCoordinates(dpy, root, wwin->frame->core->window,
2181 orig_x, orig_y, &tx, &ty, &junkw);
2182
2183 /* check if resizing through resizebar */
2184 if (is_resizebar)
2185 flags = RESIZEBAR;
2186 else
2187 flags = 0;
2188
2189 if (is_resizebar && ((ev->xbutton.state & ShiftMask)
2190 || abs(orig_y - event.xmotion.y_root) < HRESIZE_THRESHOLD))
2191 flags |= HCONSTRAIN;
2192
2193 res = getResizeDirection(wwin, tx, ty, orig_y - event.xmotion.y_root, flags);
2194
2195 if (res == (UP | LEFT))
2196 XChangeActivePointerGrab(dpy, ButtonMotionMask
2197 | ButtonReleaseMask | ButtonPressMask,
2198 wPreferences.cursor[WCUR_TOPLEFTRESIZE], CurrentTime);
2199 else if (res == (UP | RIGHT))
2200 XChangeActivePointerGrab(dpy, ButtonMotionMask
2201 | ButtonReleaseMask | ButtonPressMask,
2202 wPreferences.cursor[WCUR_TOPRIGHTRESIZE], CurrentTime);
2203 else if (res == (DOWN | LEFT))
2204 XChangeActivePointerGrab(dpy, ButtonMotionMask
2205 | ButtonReleaseMask | ButtonPressMask,
2206 wPreferences.cursor[WCUR_BOTTOMLEFTRESIZE], CurrentTime);
2207 else if (res == (DOWN | RIGHT))
2208 XChangeActivePointerGrab(dpy, ButtonMotionMask
2209 | ButtonReleaseMask | ButtonPressMask,
2210 wPreferences.cursor[WCUR_BOTTOMRIGHTRESIZE], CurrentTime);
2211 else if (res == DOWN || res == UP)
2212 XChangeActivePointerGrab(dpy, ButtonMotionMask
2213 | ButtonReleaseMask | ButtonPressMask,
2214 wPreferences.cursor[WCUR_VERTICALRESIZE], CurrentTime);
2215 else if (res & (DOWN | UP))
2216 XChangeActivePointerGrab(dpy, ButtonMotionMask
2217 | ButtonReleaseMask | ButtonPressMask,
2218 wPreferences.cursor[WCUR_VERTICALRESIZE], CurrentTime);
2219 else if (res & (LEFT | RIGHT))
2220 XChangeActivePointerGrab(dpy, ButtonMotionMask
2221 | ButtonReleaseMask | ButtonPressMask,
2222 wPreferences.cursor[WCUR_HORIZONRESIZE], CurrentTime);
2223
2224 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
2225
2226 XGrabServer(dpy);
2227
2228 /* Draw the resize frame for the first time. */
2229 mapGeometryDisplay(wwin, fx, fy, fw, fh);
2230
2231 if (!opaqueResize)
2232 drawTransparentFrame(wwin, fx, fy, fw, fh);
2233
2234 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2235
2236 started = 1;
2237 }
2238 if (started) {
2239 if (!opaqueResize)
2240 drawTransparentFrame(wwin, orig_fx, orig_fy, orig_fw, orig_fh);
2241
2242 if (wPreferences.size_display == WDIS_FRAME_CENTER)
2243 moveGeometryDisplayCentered(scr, fx + fw / 2, fy + fh / 2);
2244
2245 if (!opaqueResize)
2246 drawTransparentFrame(wwin, fx, fy, fw, fh);
2247
2248 if (fh != orig_fh || fw != orig_fw) {
2249 if (wPreferences.size_display == WDIS_NEW)
2250 showGeometry(wwin, orig_fx, orig_fy, orig_fx + orig_fw,
2251 orig_fy + orig_fh, res);
2252
2253 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2254 }
2255
2256 if (opaqueResize) {
2257 /* Fist clean the geometry line */
2258 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2259 /* Now, continue drawing */
2260 XUngrabServer(dpy);
2261 moveGeometryDisplayCentered(scr, fx + fw / 2, fy + fh / 2);
2262 wWindowConfigure(wwin, fx, fy, fw, fh - vert_border);
2263 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2264 };
2265 }
2266 break;
2267
2268 case ButtonPress:
2269 break;
2270
2271 case ButtonRelease:
2272 if (event.xbutton.button != ev->xbutton.button)
2273 break;
2274
2275 if (started) {
2276 showGeometry(wwin, fx, fy, fx + fw, fy + fh, res);
2277
2278 if (!opaqueResize)
2279 drawTransparentFrame(wwin, fx, fy, fw, fh);
2280
2281 XUngrabKeyboard(dpy, CurrentTime);
2282 WMUnmapWidget(scr->gview);
2283 XUngrabServer(dpy);
2284
2285 if (fw != original_fw)
2286 wwin->flags.maximized &= ~(MAX_HORIZONTAL | MAX_TOPHALF | MAX_BOTTOMHALF | MAX_MAXIMUS | MAX_CENTRAL);
2287
2288 if (fh != original_fh)
2289 wwin->flags.maximized &= ~(MAX_VERTICAL | MAX_LEFTHALF | MAX_RIGHTHALF | MAX_MAXIMUS | MAX_CENTRAL);
2290
2291 wWindowConfigure(wwin, fx, fy, fw, fh - vert_border);
2292 wWindowSynthConfigureNotify(wwin);
2293 }
2294 return;
2295
2296 default:
2297 WMHandleEvent(&event);
2298 }
2299 }
2300
2301 if (wPreferences.auto_arrange_icons && wXineramaHeads(scr) > 1 && head != wGetHeadForWindow(wwin))
2302 wArrangeIcons(scr, True);
2303 }
2304
2305 #undef LEFT
2306 #undef RIGHT
2307 #undef UP
2308 #undef DOWN
2309 #undef HCONSTRAIN
2310 #undef RESIZEBAR
2311
2312 void wUnselectWindows(WScreen * scr)
2313 {
2314 WWindow *wwin;
2315
2316 if (!scr->selected_windows)
2317 return;
2318
2319 while (WMGetArrayItemCount(scr->selected_windows)) {
2320 wwin = WMGetFromArray(scr->selected_windows, 0);
2321 if (wwin->flags.miniaturized && wwin->icon && wwin->icon->selected)
2322 wIconSelect(wwin->icon);
2323
2324 wSelectWindow(wwin, False);
2325 }
2326 WMFreeArray(scr->selected_windows);
2327 scr->selected_windows = NULL;
2328 }
2329
2330 static void selectWindowsInside(WScreen * scr, int x1, int y1, int x2, int y2)
2331 {
2332 WWindow *tmpw;
2333
2334 /* select the windows and put them in the selected window list */
2335 tmpw = scr->focused_window;
2336 while (tmpw != NULL) {
2337 if (!(tmpw->flags.miniaturized || tmpw->flags.hidden)) {
2338 if ((tmpw->frame->workspace == scr->current_workspace || IS_OMNIPRESENT(tmpw))
2339 && (tmpw->frame_x >= x1) && (tmpw->frame_y >= y1)
2340 && (tmpw->frame->core->width + tmpw->frame_x <= x2)
2341 && (tmpw->frame->core->height + tmpw->frame_y <= y2)) {
2342 wSelectWindow(tmpw, True);
2343 }
2344 }
2345 tmpw = tmpw->prev;
2346 }
2347 }
2348
2349 void wSelectWindows(WScreen * scr, XEvent * ev)
2350 {
2351 XEvent event;
2352 Window root = scr->root_win;
2353 GC gc = scr->frame_gc;
2354 int xp = ev->xbutton.x_root;
2355 int yp = ev->xbutton.y_root;
2356 int w = 0, h = 0;
2357 int x = xp, y = yp;
2358
2359 if (XGrabPointer(dpy, scr->root_win, False, ButtonMotionMask
2360 | ButtonReleaseMask | ButtonPressMask, GrabModeAsync,
2361 GrabModeAsync, None, wPreferences.cursor[WCUR_NORMAL], CurrentTime) != Success) {
2362 return;
2363 }
2364 XGrabServer(dpy);
2365
2366 wUnselectWindows(scr);
2367
2368 XDrawRectangle(dpy, root, gc, xp, yp, w, h);
2369 while (1) {
2370 WMMaskEvent(dpy, ButtonReleaseMask | PointerMotionMask | ButtonPressMask, &event);
2371
2372 switch (event.type) {
2373 case MotionNotify:
2374 XDrawRectangle(dpy, root, gc, x, y, w, h);
2375 x = event.xmotion.x_root;
2376 if (x < xp) {
2377 w = xp - x;
2378 } else {
2379 w = x - xp;
2380 x = xp;
2381 }
2382 y = event.xmotion.y_root;
2383 if (y < yp) {
2384 h = yp - y;
2385 } else {
2386 h = y - yp;
2387 y = yp;
2388 }
2389 XDrawRectangle(dpy, root, gc, x, y, w, h);
2390 break;
2391
2392 case ButtonPress:
2393 break;
2394
2395 case ButtonRelease:
2396 if (event.xbutton.button != ev->xbutton.button)
2397 break;
2398
2399 XDrawRectangle(dpy, root, gc, x, y, w, h);
2400 XUngrabServer(dpy);
2401 XUngrabPointer(dpy, CurrentTime);
2402 selectWindowsInside(scr, x, y, x + w, y + h);
2403 return;
2404
2405 default:
2406 WMHandleEvent(&event);
2407 break;
2408 }
2409 }
2410 }
2411
2412 void InteractivePlaceWindow(WWindow * wwin, int *x_ret, int *y_ret, unsigned width, unsigned height)
2413 {
2414 WScreen *scr = wwin->screen_ptr;
2415 Window root = scr->root_win;
2416 int x, y, h = 0;
2417 XEvent event;
2418 KeyCode shiftl, shiftr;
2419 Window junkw;
2420 int junk;
2421
2422 if (XGrabPointer(dpy, root, True, PointerMotionMask | ButtonPressMask,
2423 GrabModeAsync, GrabModeAsync, None, wPreferences.cursor[WCUR_NORMAL], CurrentTime) != Success) {
2424 *x_ret = 0;
2425 *y_ret = 0;
2426 return;
2427 }
2428 if (HAS_TITLEBAR(wwin)) {
2429 h = WMFontHeight(scr->title_font) + (wPreferences.window_title_clearance +
2430 TITLEBAR_EXTEND_SPACE) * 2;
2431
2432 if (h > wPreferences.window_title_max_height)
2433 h = wPreferences.window_title_max_height;
2434
2435 if (h < wPreferences.window_title_min_height)
2436 h = wPreferences.window_title_min_height;
2437
2438 height += h;
2439 }
2440 if (HAS_RESIZEBAR(wwin)) {
2441 height += RESIZEBAR_HEIGHT;
2442 }
2443 XGrabKeyboard(dpy, root, False, GrabModeAsync, GrabModeAsync, CurrentTime);
2444 XQueryPointer(dpy, root, &junkw, &junkw, &x, &y, &junk, &junk, (unsigned *)&junk);
2445 mapPositionDisplay(wwin, x - width / 2, y - h / 2, width, height);
2446
2447 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2448
2449 shiftl = XKeysymToKeycode(dpy, XK_Shift_L);
2450 shiftr = XKeysymToKeycode(dpy, XK_Shift_R);
2451 while (1) {
2452 WMMaskEvent(dpy, PointerMotionMask | ButtonPressMask | ExposureMask | KeyPressMask, &event);
2453
2454 if (!checkMouseSamplingRate(&event))
2455 continue;
2456
2457 switch (event.type) {
2458 case KeyPress:
2459 if ((event.xkey.keycode == shiftl)
2460 || (event.xkey.keycode == shiftr)) {
2461 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2462 cyclePositionDisplay(wwin, x - width / 2, y - h / 2, width, height);
2463 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2464 }
2465 break;
2466
2467 case MotionNotify:
2468 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2469
2470 x = event.xmotion.x_root;
2471 y = event.xmotion.y_root;
2472
2473 if (wPreferences.move_display == WDIS_FRAME_CENTER)
2474 moveGeometryDisplayCentered(scr, x, y + (height - h) / 2);
2475
2476 showPosition(wwin, x - width / 2, y - h / 2);
2477
2478 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2479
2480 break;
2481
2482 case ButtonPress:
2483 drawTransparentFrame(wwin, x - width / 2, y - h / 2, width, height);
2484 XSync(dpy, 0);
2485 *x_ret = x - width / 2;
2486 *y_ret = y - h / 2;
2487 XUngrabPointer(dpy, CurrentTime);
2488 XUngrabKeyboard(dpy, CurrentTime);
2489 /* get rid of the geometry window */
2490 WMUnmapWidget(scr->gview);
2491 return;
2492
2493 default:
2494 WMHandleEvent(&event);
2495 break;
2496 }
2497 }
2498 }
The Window Maker window manager