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