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