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