?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* Memory management fixes.
[fvwm.git] / modules / FvwmProxy / FvwmProxy.c
blob96b247f700de9bc2599315889ba2ee9c05f8f7ff
1 /* -*-c-*- */
2 /* vim: set ts=8 shiftwidth=8: */
3 /* This module, FvwmProxy, is an original work by Jason Weber.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20
21 /* ---------------------------- included header files ----------------------- */
22
23 #include "config.h"
24 #include <stdio.h>
25
26 #include "libs/Module.h"
27 #include "libs/fvwmlib.h"
28 #include "libs/FRenderInit.h"
29 #include "libs/FRender.h"
30 #include "libs/Colorset.h"
31 #include "libs/Flocale.h"
32 #include "libs/gravity.h"
33 #include "libs/FScreen.h"
34 #include "libs/Picture.h"
35 #include "libs/PictureGraphics.h"
36 #include "libs/charmap.h"
37 #include "libs/modifiers.h"
38 #include "libs/ColorUtils.h"
39 #include "libs/Graphics.h"
40 #include "libs/Parse.h"
41 #include "libs/Strings.h"
42 #include "libs/System.h"
43 #include "libs/wild.h"
44
45 #include "FvwmProxy.h"
46
47 /* ---------------------------- local definitions --------------------------- */
48
49 /* defaults for things we put in a configuration file */
50
51 #define PROXY_COMMAND_DEBUG False
52 #define PROXY_GROUP_DEBUG False
53
54 #define PROXY_KEY_POLLING True
55 #define PROXY_MOVE False /* move window when proxy is dragged */
56 #define PROXY_ICONIFIED False /* show proxy when iconified */
57 #define PROXY_WIDTH 180
58 #define PROXY_HEIGHT 60
59 #define PROXY_SEPARATION 10
60 #define PROXY_MINWIDTH 15
61 #define PROXY_MINHEIGHT 10
62 #define PROXY_SLOT_SIZE 16
63 #define PROXY_SLOT_SPACE 4
64 #define PROXY_GROUP_SLOT 2
65 #define PROXY_GROUP_COUNT 6
66 #define PROXY_STAMP_LIMIT 8
67
68 #define STARTUP_DEBUG False /* store output before log is opened */
69
70 #define CMD_SELECT "WindowListFunc $[w.id]"
71 #define CMD_CLICK1 "Raise"
72 #define CMD_CLICK3 "Lower"
73 #define CMD_DEFAULT "Nop"
74
75 /* ---------------------------- local macros -------------------------------- */
76
77 /* ---------------------------- imports ------------------------------------- */
78
79 /* ---------------------------- included code files ------------------------- */
80
81 /* ---------------------------- local types --------------------------------- */
82
83 /* ---------------------------- forward declarations ------------------------ */
84
85 /* ---------------------------- local variables ----------------------------- */
86
87 static char *ImagePath = NULL;
88 static char *MyName;
89 static int x_fd;
90 static fd_set_size_t fd_width;
91 static int fd[2];
92 static Display *dpy;
93 static unsigned long screen;
94 static GC fg_gc;
95 static GC hi_gc;
96 static GC sh_gc;
97 static GC miniIconGC;
98 static Window rootWindow;
99 static Window focusWindow;
100 static XTextProperty windowName;
101 static int deskNumber=0;
102 static int mousex,mousey;
103 static ProxyWindow *firstProxy=NULL;
104 static ProxyWindow *lastProxy=NULL;
105 static ProxyWindow *selectProxy=NULL;
106 static ProxyWindow *startProxy=NULL;
107 static ProxyWindow *enterProxy=NULL;
108 static ProxyWindow *last_rotation_instigator=NULL;
109 static ProxyGroup *firstProxyGroup=NULL;
110 static FvwmPicture **pictureArray=NULL;
111 static int numSlots=0;
112 static int miniIconSlot=0;
113 static XGCValues xgcv;
114 static int are_windows_shown = 0;
115 static int watching_modifiers = 0;
116 static int waiting_to_config = 0;
117 static int waiting_to_stamp = 0;
118 static int pending_do = 0;
119 static unsigned int held_modifiers=0;
120 static int watched_modifiers=0;
121 static FlocaleWinString *FwinString;
122
123 static int cset_normal = 0;
124 static int cset_select = 0;
125 static int cset_iconified = 0;
126 static char *font_name = NULL;
127 static char *small_font_name = NULL;
128 static FlocaleFont *Ffont;
129 static FlocaleFont *Ffont_small;
130 static int enterSelect=False;
131 static int showMiniIcons=True;
132 static int proxyIconified=PROXY_ICONIFIED;
133 static int proxyMove=PROXY_MOVE;
134 static int proxyWidth=PROXY_WIDTH;
135 static int proxyHeight=PROXY_HEIGHT;
136 static int proxySeparation=PROXY_SEPARATION;
137 static int slotWidth=PROXY_SLOT_SIZE;
138 static int slotHeight=PROXY_SLOT_SIZE;
139 static int slotSpace=PROXY_SLOT_SPACE;
140 static int groupSlot=PROXY_GROUP_SLOT;
141 static int groupCount=PROXY_GROUP_COUNT;
142 static int stampLimit=PROXY_STAMP_LIMIT;
143
144 static GeometryStamp* stampQueue=NULL;
145 static int stamp= 0;
146 static int stampMin=0;
147 static int stampMax=0;
148
149 static char commandBuffer[256];
150 static char resultBuffer[256];
151
152 typedef enum
153 {
154 PROXY_ACTION_SELECT = 0,
155 PROXY_ACTION_SHOW,
156 PROXY_ACTION_HIDE,
157 PROXY_ACTION_ABORT,
158 PROXY_ACTION_MARK,
159 PROXY_ACTION_UNMARK,
160 PROXY_ACTION_MODIFIER_RELEASE,
161 /* this one *must* be last */
162 PROXY_ACTION_CLICK,
163 PROXY_ACTION_LAST = PROXY_ACTION_CLICK +
164 NUMBER_OF_EXTENDED_MOUSE_BUTTONS
165 } proxy_action_t;
166
167 #define GROUP_COLORS 7
168 static char* group_color[GROUP_COLORS][2] =
169 {
170 {"#dddddd", "#777777"},
171 {"#ffcccc", "#ff0000"},
172 {"#ccffcc", "#00ff00"},
173 {"#ccccff", "#0000ff"},
174 {"#ffccff", "#ff00ff"},
175 {"#ffffcc", "#ffff00"},
176 {"#ccffff", "#00ffff"}
177 };
178
179 char *action_list[PROXY_ACTION_LAST];
180 char **slot_action_list[NUMBER_OF_EXTENDED_MOUSE_BUTTONS];
181
182 static WindowName* new_WindowName(void);
183 static ProxyGroup* FindProxyGroup(char* groupname);
184
185 static int (*originalXErrorHandler)(Display *,XErrorEvent *);
186 static int (*originalXIOErrorHandler)(Display *);
187
188 /* ---------------------------- exported variables (globals) ---------------- */
189
190 /* ---------------------------- local functions (options) ------------------- */
191
192 static void ExpandSlots(int slots)
193 {
194 int m;
195 int n;
196 if(slots>numSlots)
197 {
198 pictureArray=(FvwmPicture**)realloc(pictureArray,
199 sizeof(FvwmPicture*)*(slots));
200 for(m=0;m<NUMBER_OF_EXTENDED_MOUSE_BUTTONS;m++)
201 {
202 slot_action_list[m]=(char**)realloc(
203 slot_action_list[m],
204 sizeof(char*)*(slots));
205 for(n=numSlots;n<slots;n++)
206 {
207 slot_action_list[m][n]=NULL;
208 }
209 }
210 for(n=numSlots;n<slots;n++)
211 {
212 pictureArray[n]=NULL;
213 }
214 numSlots=slots;
215 }
216 }
217
218 static void LinkSlotAction(char *string)
219 {
220 char *token;
221 int slot;
222
223 token = PeekToken(string, &string);
224 slot=atoi(token);
225
226 token = PeekToken(string, &string);
227 if (strncasecmp(token, "Click", 5) == 0)
228 {
229 int b;
230 int i;
231 i = sscanf(token + 5, "%d", &b);
232 if (i > 0 && b >=1 && b <= NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
233 {
234 ExpandSlots(slot+1);
235 if (slot_action_list[b-1][slot] != NULL)
236 {
237 free(slot_action_list[b-1][slot]);
238 }
239 slot_action_list[b-1][slot] = safestrdup(string);
240 #if PROXY_GROUP_DEBUG
241 fprintf(stderr,"slot_action_list[%d][%d]=\"%s\"\n",
242 b-1,slot,slot_action_list[b-1][slot]);
243 #endif
244 }
245 }
246 }
247
248 static void LinkAction(char *string)
249 {
250 char *token;
251
252 token = PeekToken(string, &string);
253 if (strncasecmp(token, "Click", 5) == 0)
254 {
255 int b;
256 int i;
257 i = sscanf(token + 5, "%d", &b);
258 if (i > 0 && b >=1 && b <= NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
259 {
260 if (action_list[PROXY_ACTION_CLICK + b - 1] != NULL)
261 {
262 free(action_list[PROXY_ACTION_CLICK + b - 1]);
263 }
264 action_list[PROXY_ACTION_CLICK + b - 1] =
265 safestrdup(string);
266 }
267 }
268 else if (StrEquals(token, "Select"))
269 {
270 if (action_list[PROXY_ACTION_SELECT] != NULL)
271 {
272 free(action_list[PROXY_ACTION_SELECT]);
273 }
274 action_list[PROXY_ACTION_SELECT] = safestrdup(string);
275 }
276 else if (StrEquals(token, "Show"))
277 {
278 if (action_list[PROXY_ACTION_SHOW] != NULL)
279 {
280 free(action_list[PROXY_ACTION_SHOW]);
281 }
282 action_list[PROXY_ACTION_SHOW] = safestrdup(string);
283 }
284 else if (StrEquals(token, "Hide"))
285 {
286 if (action_list[PROXY_ACTION_HIDE] != NULL)
287 {
288 free(action_list[PROXY_ACTION_HIDE]);
289 }
290 action_list[PROXY_ACTION_HIDE] = safestrdup(string);
291 }
292 else if (StrEquals(token, "Abort"))
293 {
294 if (action_list[PROXY_ACTION_ABORT] != NULL)
295 {
296 free(action_list[PROXY_ACTION_ABORT]);
297 }
298 action_list[PROXY_ACTION_ABORT] = safestrdup(string);
299 }
300 else if (StrEquals(token, "Mark"))
301 {
302 if (action_list[PROXY_ACTION_MARK] != NULL)
303 {
304 free(action_list[PROXY_ACTION_MARK]);
305 }
306 action_list[PROXY_ACTION_MARK] = safestrdup(string);
307 }
308 else if (StrEquals(token, "Unmark"))
309 {
310 if (action_list[PROXY_ACTION_UNMARK] != NULL)
311 {
312 free(action_list[PROXY_ACTION_UNMARK]);
313 }
314 action_list[PROXY_ACTION_UNMARK] = safestrdup(string);
315 }
316 else if (StrEquals(token, "ModifierRelease"))
317 {
318 token = PeekToken(string, &string);
319
320 if (action_list[PROXY_ACTION_MODIFIER_RELEASE] != NULL)
321 {
322 free(action_list[PROXY_ACTION_MODIFIER_RELEASE]);
323 }
324
325 modifiers_string_to_modmask(token, (int *)&watched_modifiers);
326 action_list[PROXY_ACTION_MODIFIER_RELEASE] = safestrdup(string);
327 }
328
329 return;
330 }
331
332 #if 0
333 static void parse_cmd(char **ret_cmd, char *cmd)
334 {
335 if (*ret_cmd != NULL)
336 {
337 free(*ret_cmd);
338 *ret_cmd = NULL;
339 }
340 if (cmd != NULL)
341 {
342 *ret_cmd = safestrdup(cmd);
343 }
344
345 return;
346 }
347 #endif
348
349 FvwmPicture* loadPicture(char* name)
350 {
351 FvwmPicture *picture=NULL;
352 FvwmPictureAttributes fpa;
353
354 if(!name)
355 {
356 return NULL;
357 }
358
359 fpa.mask = FPAM_NO_COLOR_LIMIT;
360 picture = PGetFvwmPicture(dpy, RootWindow(dpy,screen),
361 ImagePath, name, fpa);
362 if (!picture)
363 {
364 fprintf(stderr, "loadPixmap failed to load \"%s\"\n", name);
365 }
366 return picture;
367 }
368
369 static Bool parse_options(void)
370 {
371 int m;
372 char *tline;
373
374 memset(action_list, 0, sizeof(action_list));
375 action_list[PROXY_ACTION_SELECT] = strdup(CMD_SELECT);
376 action_list[PROXY_ACTION_CLICK + 0] = strdup(CMD_CLICK1);
377 if (NUMBER_OF_EXTENDED_MOUSE_BUTTONS > 2)
378 {
379 action_list[PROXY_ACTION_CLICK + 2] = strdup(CMD_CLICK3);
380 }
381 for (m=0;m<PROXY_ACTION_LAST;m++)
382 {
383 if (action_list[m]==NULL)
384 {
385 action_list[m] = strdup(CMD_DEFAULT);
386 }
387 }
388
389 InitGetConfigLine(fd, CatString3("*", MyName, 0));
390 for (GetConfigLine(fd, &tline); tline != NULL;
391 GetConfigLine(fd, &tline))
392 {
393 char *resource;
394 char *token;
395 char *next;
396
397 token = PeekToken(tline, &next);
398 if (StrEquals(token, "Colorset"))
399 {
400 LoadColorset(next);
401 continue;
402 }
403 if (StrEquals(token, "ImagePath"))
404 {
405 if (ImagePath)
406 {
407 free(ImagePath);
408 }
409 CopyString(&ImagePath, next);
410 continue;
411 }
412
413 tline = GetModuleResource(tline, &resource, MyName);
414 if (resource == NULL)
415 {
416 continue;
417 }
418
419 /* dump leading whitespace */
420 while (*tline==' ' || *tline=='\t')
421 tline++;
422 if (!strncasecmp(resource,"Action",6))
423 {
424 LinkAction(tline);
425 }
426 else if (!strncasecmp(resource,"SlotAction",10))
427 {
428 LinkSlotAction(tline);
429 }
430 else if (StrEquals(resource, "Colorset"))
431 {
432 if (sscanf(tline, "%d", &cset_normal) < 1)
433 {
434 cset_normal = 0;
435 }
436 }
437 else if (StrEquals(resource, "SelectColorset"))
438 {
439 if (sscanf(tline, "%d", &cset_select) < 1)
440 {
441 cset_select = 0;
442 }
443 }
444 else if (StrEquals(resource, "IconifiedColorset"))
445 {
446 if (sscanf(tline, "%d", &cset_iconified) < 1)
447 {
448 cset_iconified = 0;
449 }
450 }
451 else if (StrEquals(resource, "Font"))
452 {
453 if (font_name != NULL)
454 {
455 free(font_name);
456 }
457 font_name = safestrdup(tline);
458 }
459 else if (StrEquals(resource, "SmallFont"))
460 {
461 if (small_font_name != NULL)
462 {
463 free(small_font_name);
464 }
465 small_font_name = safestrdup(tline);
466 }
467 else if (StrEquals(resource, "ShowMiniIcons"))
468 {
469 showMiniIcons = ParseToggleArgument(tline, NULL, 0, 1);
470 }
471 else if (StrEquals(resource, "EnterSelect"))
472 {
473 enterSelect = ParseToggleArgument(tline, NULL, 0, 1);
474 }
475 else if (StrEquals(resource, "ProxyMove"))
476 {
477 proxyMove = ParseToggleArgument(tline, NULL, 0, 1);
478 }
479 else if (StrEquals(resource, "ProxyIconified"))
480 {
481 proxyIconified = ParseToggleArgument(tline, NULL, 0, 1);
482 }
483 else if (StrEquals(resource, "Width"))
484 {
485 if (sscanf(tline, "%d", &proxyWidth) < 1)
486 proxyWidth=PROXY_MINWIDTH;
487 }
488 else if (StrEquals(resource, "Height"))
489 {
490 if (sscanf(tline, "%d", &proxyHeight) < 1)
491 proxyHeight=PROXY_MINHEIGHT;
492 }
493 else if (StrEquals(resource, "Separation"))
494 {
495 if (sscanf(tline, "%d", &proxySeparation) < 1)
496 proxySeparation=False;
497 }
498 else if (StrEquals(resource, "UndoLimit"))
499 {
500 if (sscanf(tline, "%d", &stampLimit) < 1)
501 stampLimit=PROXY_STAMP_LIMIT;
502 }
503 else if (StrEquals(resource, "SlotWidth"))
504 {
505 if (sscanf(tline, "%d", &slotWidth) < 1)
506 slotWidth=PROXY_SLOT_SIZE;
507 }
508 else if (StrEquals(resource, "SlotHeight"))
509 {
510 if (sscanf(tline, "%d", &slotHeight) < 1)
511 slotHeight=PROXY_SLOT_SIZE;
512 }
513 else if (StrEquals(resource, "SlotSpace"))
514 {
515 if (sscanf(tline, "%d", &slotSpace) < 1)
516 slotSpace=PROXY_SLOT_SPACE;
517 }
518 else if (StrEquals(resource, "GroupSlot"))
519 {
520 if (sscanf(tline, "%d", &groupSlot) < 0)
521 groupSlot=PROXY_GROUP_SLOT;
522 }
523 else if (StrEquals(resource, "GroupCount"))
524 {
525 if (sscanf(tline, "%d", &groupCount) < 0)
526 groupCount=PROXY_GROUP_COUNT;
527 }
528 else if (StrEquals(resource, "SlotStyle"))
529 {
530 int slot= -1;
531 char style[128];
532 char name[128];
533 int bytes=0;
534 int args = sscanf(tline, "%d%s%*[^\"]\"%[^\"]\"%n",
535 &slot,style,name,&bytes);
536 #if PROXY_GROUP_DEBUG
537 fprintf(stderr,
538 "SlotStyle: %d \"%s\" -> %d \"%s\" \"%s\"\n",
539 args,tline,slot,style,name);
540 #endif
541 if (args>=3 && StrEquals(style, "Pixmap"))
542 {
543 ExpandSlots(slot+1);
544 pictureArray[slot]=loadPicture(name);
545 }
546 else if (args>=2 && StrEquals(style, "MiniIcon"))
547 {
548 miniIconSlot=slot;
549 }
550 }
551 else if (StrEquals(resource, "Group"))
552 {
553 char groupname[128];
554 char directive[128];
555 char tail[128];
556 char pattern[128];
557 int bytes=0;
558 int args = sscanf(tline, "\"%[^\"]\"%s%n",
559 groupname,directive,&bytes);
560 ProxyGroup* proxygroup;
561
562 strncpy(tail,&tline[bytes],128);
563 tail[127]=0;
564 args = sscanf(tail, "%*[^\"]\"%[^\"]\"",pattern);
565
566 #if PROXY_GROUP_DEBUG
567 fprintf(stderr,
568 "Group: %d \"%s\" -> \"%s\" \"%s\" \"%s\"\n",
569 args,tline,groupname,directive,pattern);
570 #endif
571
572 proxygroup=FindProxyGroup(groupname);
573 if (StrEquals(directive, "IgnoreIDs"))
574 {
575 proxygroup->flags.ignore_ids=1;
576 }
577 else if (StrEquals(directive, "AutoInclude"))
578 {
579 proxygroup->flags.auto_include=1;
580 }
581 else if (StrEquals(directive, "AutoSoft"))
582 {
583 proxygroup->flags.auto_include=1;
584 proxygroup->flags.auto_soft=1;
585 }
586 else if (StrEquals(directive, "Isolated"))
587 {
588 proxygroup->flags.isolated=1;
589 }
590 else if (StrEquals(directive, "Include") ||
591 StrEquals(directive, "SoftInclude"))
592 {
593 WindowName* include=new_WindowName();
594 include->name=strdup(pattern);
595 include->flags.is_soft=
596 StrEquals(directive, "SoftInclude");
597 include->next=proxygroup->includes;
598 proxygroup->includes=include;
599 #if PROXY_GROUP_DEBUG
600 fprintf(stderr,"Include \"%s\"\n",
601 pattern);
602 #endif
603 }
604 else if (StrEquals(directive, "Exclude"))
605 {
606 WindowName* exclude=new_WindowName();
607 exclude->name=strdup(pattern);
608 exclude->next=proxygroup->excludes;
609 proxygroup->excludes=exclude;
610 #if PROXY_GROUP_DEBUG
611 fprintf(stderr,"Exclude \"%s\"\n",
612 pattern);
613 #endif
614 }
615 }
616 else
617 {
618 fprintf(stderr,"Unknown: \"%s\"\n",tline);
619 }
620
621 free(resource);
622 }
623
624 return True;
625 }
626
627 /* ---------------------------- local functions (classes) ------------------- */
628
629 /* classes */
630
631 static void ProxyWindow_ProxyWindow(ProxyWindow *p)
632 {
633 memset(p, 0, sizeof *p);
634 }
635
636 static ProxyWindow *new_ProxyWindow(void)
637 {
638 ProxyWindow *p=(ProxyWindow *)safemalloc(sizeof(ProxyWindow));
639 ProxyWindow_ProxyWindow(p);
640 return p;
641 }
642
643 static void delete_ProxyWindow(ProxyWindow *p)
644 {
645 if (p)
646 {
647 if (p->name)
648 {
649 free(p->name);
650 }
651 if (p->iconname)
652 {
653 free(p->iconname);
654 }
655 if (p->proxy != None)
656 {
657 XDestroyWindow(dpy, p->proxy);
658 }
659 free(p);
660 }
661 }
662
663 static void WindowName_WindowName(WindowName *p)
664 {
665 memset(p, 0, sizeof *p);
666 }
667
668 static WindowName *new_WindowName(void)
669 {
670 WindowName *p=(WindowName *)safemalloc(sizeof(WindowName));
671 WindowName_WindowName(p);
672 return p;
673 }
674
675 static void delete_WindowName(WindowName *p)
676 {
677 if (p)
678 {
679 delete_WindowName(p->next);
680 free(p->name);
681 free(p);
682 }
683 }
684
685 static void ProxyGroup_ProxyGroup(ProxyGroup *p)
686 {
687 memset(p, 0, sizeof *p);
688 }
689
690 static ProxyGroup *new_ProxyGroup(void)
691 {
692 ProxyGroup *p=(ProxyGroup *)safemalloc(sizeof(ProxyGroup));
693 ProxyGroup_ProxyGroup(p);
694 return p;
695 }
696
697 static void delete_ProxyGroup(ProxyGroup *p)
698 {
699 if (p)
700 {
701 delete_ProxyGroup(p->next);
702 delete_WindowName(p->includes);
703 delete_WindowName(p->excludes);
704 free(p->name);
705 free(p);
706 }
707 }
708
709 /* ---------------------------- error handlers ------------------------------ */
710
711 static int myXErrorHandler(Display *display,XErrorEvent *error_event)
712 {
713 const long messagelen=256;
714 char buffer[messagelen],function[messagelen];
715 char request_number[16];
716
717 sprintf(request_number,"%d",error_event->request_code);
718 sprintf(buffer,"UNKNOWN");
719 XGetErrorDatabaseText(display,"XRequest",
720 request_number,buffer,function,messagelen);
721
722 fprintf(stderr, "non-fatal X error as follows, display %p"
723 " op %d:%d \"%s\" serial %u error %d\n",
724 display,
725 error_event->request_code,error_event->minor_code,
726 function,(unsigned int)error_event->serial,
727 error_event->error_code);
728
729 return 0;
730 }
731
732 static int myXIOErrorHandler(Display *display)
733 {
734 fprintf(stderr, "fatal IO Error on display %p\n", display);
735 originalXIOErrorHandler(display);
736
737 /* should never get this far */
738 return 0;
739 }
740
741 /* ---------------------------- local functions ----------------------------- */
742
743 static void send_command_to_fvwm(char *command, Window w)
744 {
745 if (command == NULL || *command == 0)
746 {
747 return;
748 }
749 #if PROXY_COMMAND_DEBUG
750 fprintf(stderr,"SendText: \"%s\"\n", command);
751 #endif
752 SendText(fd, command, w);
753
754 return;
755 }
756
757 static int GetProperty(Window w,char* propertyname)
758 {
759 Atom atom,actual_type;
760 char *atom_name;
761 int actual_format;
762 unsigned long nitems;
763 unsigned long bytes_after;
764 unsigned char *prop;
765 int status;
766 int result=0;
767 int byte;
768 int bytes;
769
770 atom = XInternAtom(dpy, propertyname, True);
771 atom_name = XGetAtomName (dpy,atom);
772
773 status = XGetWindowProperty(dpy, w, atom, 0L, 1024,
774 False, AnyPropertyType,
775 &actual_type,
776 &actual_format, &nitems,
777 &bytes_after,
778 &prop);
779 if (status!=0)
780 {
781 /* fprintf(stderr,"GetProperty: cannot get %s\n",propertyname);
782 */
783 return 0;
784 }
785 if (!prop) {
786 /* fprintf(stderr,"GetProperty: no properties\n");
787 */
788 return 0;
789 }
790
791 bytes=actual_format/8;
792 for(byte=bytes-1;byte>=0;byte--)
793 {
794 result=result*256+prop[byte];
795 }
796 XFree(prop);
797 return result;
798 }
799
800 static int GetProcessId(Window w)
801 {
802 return GetProperty(w, "_NET_WM_PID");
803 }
804
805 static int GetLeader(Window w)
806 {
807 int result=GetProperty(w, "WM_CLIENT_LEADER");
808 if(!result)
809 {
810 XWMHints* hints=XGetWMHints(dpy,w);
811 if(hints && hints->flags&WindowGroupHint)
812 {
813 result=hints->window_group;
814 XFree(hints);
815 }
816 }
817 return result;
818 }
819
820 static int GetParentProcessId(int pid)
821 {
822 int ppid=0;
823 int bytes;
824 FILE* statusfile;
825
826 sprintf(commandBuffer,"/proc/%d/stat",pid);
827 statusfile=fopen(commandBuffer,"r");
828 if(!statusfile)
829 {
830 return 0;
831 }
832 bytes=fread(resultBuffer,32,1,statusfile);
833 sscanf(resultBuffer,"%*d %*[^)]) %*s %d",&ppid);
834 fclose(statusfile);
835 return ppid;
836 }
837
838 static ProxyGroup* FindProxyGroup(char* groupname)
839 {
840 ProxyGroup* proxygroup=firstProxyGroup;
841 while(proxygroup)
842 {
843 if(StrEquals(proxygroup->name, groupname))
844 {
845 return proxygroup;
846 }
847 proxygroup=proxygroup->next;
848 }
849 proxygroup=new_ProxyGroup();
850 proxygroup->next=firstProxyGroup;
851 proxygroup->name=strdup(groupname);
852 firstProxyGroup=proxygroup;
853 return proxygroup;
854 }
855
856 static int MatchWindowName(WindowName* namelist,char* name)
857 {
858 WindowName* include=namelist;
859 while(include)
860 {
861 if(matchWildcards(include->name, name))
862 {
863 return 1;
864 }
865 include=include->next;
866 }
867
868 return 0;
869 }
870
871 static ProxyGroup* FindProxyGroupWithWindowName(char* name)
872 {
873 ProxyGroup* proxygroup=firstProxyGroup;
874 #if PROXY_GROUP_DEBUG
875 fprintf(stderr,"FindProxyGroupWithWindowName(%s)\n",name);
876 #endif
877
878 while(proxygroup)
879 {
880 if(MatchWindowName(proxygroup->includes, name))
881 {
882 #if PROXY_GROUP_DEBUG
883 fprintf(stderr," found in %s\n",proxygroup->name);
884 #endif
885 return proxygroup;
886 }
887 proxygroup=proxygroup->next;
888 }
889
890 return NULL;
891 }
892
893 static ProxyWindow *FindProxy(Window window)
894 {
895 ProxyWindow *proxy=firstProxy;
896
897 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
898 {
899 if (proxy->proxy==window || proxy->window==window)
900 {
901 return proxy;
902 }
903 }
904
905 return NULL;
906 }
907
908 static void DrawPicture(
909 Window window, int x, int y, FvwmPicture *picture, int cset)
910 {
911 FvwmRenderAttributes fra;
912
913 if (!picture || picture->picture == None)
914 return;
915
916 fra.mask = FRAM_DEST_IS_A_WINDOW;
917 if (cset >= 0)
918 {
919 fra.mask |= FRAM_HAVE_ICON_CSET;
920 fra.colorset = &Colorset[cset];
921 }
922 PGraphicsRenderPicture(
923 dpy, window, picture, &fra, window, miniIconGC, None, None,
924 0, 0, picture->width, picture->height,
925 x, y, picture->width, picture->height, False);
926 }
927
928 static void DrawWindow(
929 ProxyWindow *proxy, int x,int y,int w,int h)
930 {
931 int texty,maxy;
932 int cset;
933 FvwmPicture *picture = &proxy->picture;
934 int drawMiniIcon=(showMiniIcons && proxy->picture.picture != None);
935 int group;
936 int m;
937 char *big_name;
938 char *small_name;
939 int overrun=0;
940
941 if (!proxy || proxy->proxy == None)
942 {
943 return;
944 }
945
946 x=0;
947 y=0;
948 w=proxy->proxyw;
949 h=proxy->proxyh;
950
951 texty=(h+ Ffont->ascent - Ffont->descent)/2; /* center */
952 if (drawMiniIcon)
953 {
954 texty+=4;
955 }
956
957 maxy=h-Ffont->descent-4;
958 if (texty>maxy)
959 {
960 texty=maxy;
961 }
962
963 cset = (proxy==selectProxy) ? cset_select :
964 ((proxy->flags.is_iconified) ? cset_iconified : cset_normal);
965 XSetForeground(dpy,fg_gc,Colorset[cset].fg);
966 XSetBackground(dpy,fg_gc,Colorset[cset].bg);
967 XSetForeground(dpy,sh_gc,Colorset[cset].shadow);
968 XSetForeground(dpy,hi_gc,Colorset[cset].hilite);
969
970 /* FIXME: use clip redrawing (not really essential here) */
971 if (FLF_FONT_HAS_ALPHA(Ffont,cset) || PICTURE_HAS_ALPHA(picture,cset))
972 {
973 XClearWindow(dpy,proxy->proxy);
974 }
975 RelieveRectangle(dpy,proxy->proxy, 0,0, w - 1,h - 1, hi_gc,sh_gc, 2);
976
977 big_name = proxy->iconname;
978 if(big_name==NULL || !big_name[0])
979 {
980 big_name = proxy->name;
981 }
982 small_name = proxy->name;
983 if(small_name == NULL)
984 {
985 small_name=big_name;
986 }
987 if (big_name != NULL && big_name[0])
988 {
989 int text_width = FlocaleTextWidth(
990 Ffont,big_name,strlen(big_name));
991 int edge=(w-text_width)/2;
992
993 if (edge<5)
994 {
995 edge=5;
996 }
997 if(w-text_width<5)
998 {
999 overrun=1;
1000 }
1001
1002 FwinString->str = big_name;
1003 FwinString->win = proxy->proxy;
1004 FwinString->x = edge;
1005 FwinString->y = texty;
1006 FwinString->gc = fg_gc;
1007 FwinString->flags.has_colorset = False;
1008 if (cset >= 0)
1009 {
1010 FwinString->colorset = &Colorset[cset];
1011 FwinString->flags.has_colorset = True;
1012 }
1013 FlocaleDrawString(dpy, Ffont, FwinString, 0);
1014 }
1015 if (small_name != NULL && small_name[0] &&
1016 (overrun || strcmp(small_name,big_name)) && Ffont_small!=NULL)
1017 {
1018 int text_width = FlocaleTextWidth(
1019 Ffont_small,small_name,strlen(small_name));
1020 int edge=(w-text_width)/2;
1021
1022 if (edge<5)
1023 {
1024 edge=w-text_width-5;
1025 }
1026
1027 FwinString->str = small_name;
1028 FwinString->win = proxy->proxy;
1029 FwinString->x = edge;
1030 FwinString->y = h-Ffont_small->descent-3;
1031 FwinString->gc = hi_gc;
1032 FwinString->flags.has_colorset = False;
1033 if (cset >= 0)
1034 {
1035 FwinString->colorset = &Colorset[cset];
1036 FwinString->flags.has_colorset = True;
1037 }
1038 FlocaleDrawString(dpy, Ffont_small, FwinString, 0);
1039 }
1040 if (drawMiniIcon && miniIconSlot>0)
1041 {
1042 int widgetx=slotSpace+(slotWidth+slotSpace)*(miniIconSlot-1);
1043 DrawPicture(proxy->proxy, widgetx, slotSpace, picture, cset);
1044 }
1045 for(group=1;group<groupCount+1;group++)
1046 {
1047 int lit=(proxy->group==group);
1048 int widgetx=slotSpace+
1049 (slotWidth+slotSpace)*(groupSlot+group-2);
1050 int color_index=group%GROUP_COLORS;
1051 int drawsoft=lit && proxy->flags.is_soft;
1052 int drawisolated=lit && proxy->flags.is_isolated;
1053
1054 if(drawsoft)
1055 {
1056 XSetForeground(dpy,fg_gc,GetColor(
1057 group_color[color_index][0]));
1058 XFillRectangle(dpy,proxy->proxy,fg_gc,
1059 widgetx,slotSpace,
1060 slotWidth,slotHeight);
1061
1062 XSetForeground(dpy,sh_gc,GetColor("black"));
1063 RelieveRectangle(dpy,proxy->proxy,
1064 widgetx,slotSpace,
1065 slotWidth,slotHeight/2,
1066 hi_gc,sh_gc, 1);
1067 }
1068 XSetForeground(dpy,fg_gc,GetColor(
1069 group_color[color_index][proxy->group==group]));
1070 XFillRectangle(dpy,proxy->proxy,fg_gc,
1071 widgetx,slotSpace,
1072 slotWidth,
1073 drawsoft? slotHeight/2: slotHeight);
1074
1075 XSetForeground(dpy,sh_gc,GetColor(lit? "black": "white"));
1076 XSetForeground(dpy,hi_gc,GetColor(lit? "black": "white"));
1077 RelieveRectangle(dpy,proxy->proxy,
1078 widgetx,slotSpace,
1079 slotWidth,slotHeight,
1080 hi_gc,sh_gc, 2);
1081 if(drawisolated)
1082 {
1083 RelieveRectangle(dpy,proxy->proxy,
1084 widgetx+4,slotSpace+4,
1085 slotWidth-8,slotHeight-8,
1086 hi_gc,sh_gc, 2);
1087 }
1088 }
1089 for(m=0;m<numSlots;m++)
1090 {
1091 int widgetx=slotSpace+(slotWidth+slotSpace)*(m-1);
1092 DrawPicture(proxy->proxy, widgetx, slotSpace, pictureArray[m],
1093 cset);
1094 }
1095 }
1096
1097 static void DrawProxy(ProxyWindow *proxy)
1098 {
1099 if (proxy)
1100 {
1101 DrawWindow(
1102 proxy, proxy->proxyx, proxy->proxyy, proxy->proxyw,
1103 proxy->proxyh);
1104 }
1105 }
1106
1107 static void DrawProxyBackground(ProxyWindow *proxy)
1108 {
1109 int cset;
1110
1111 if (proxy == NULL || proxy->proxy == None)
1112 {
1113 return;
1114 }
1115 cset = (proxy==selectProxy) ? cset_select :
1116 ((proxy->flags.is_iconified) ? cset_iconified : cset_normal);
1117 XSetForeground(dpy,fg_gc,Colorset[cset].fg);
1118 XSetBackground(dpy,fg_gc,Colorset[cset].bg);
1119 SetWindowBackground(
1120 dpy, proxy->proxy, proxy->proxyw, proxy->proxyh,
1121 &Colorset[cset], Pdepth, fg_gc, True);
1122 }
1123
1124 static void OpenOneWindow(ProxyWindow *proxy)
1125 {
1126 int border=0;
1127 unsigned long valuemask=CWOverrideRedirect;
1128 XSetWindowAttributes attributes;
1129
1130 if (proxy == NULL)
1131 {
1132 return;
1133 }
1134 if (proxy->desk != deskNumber ||
1135 (!proxyIconified && proxy->flags.is_iconified) )
1136 {
1137 return;
1138 }
1139 if (proxy->flags.is_shown)
1140 {
1141 return;
1142 }
1143 if (proxy->proxy == None)
1144 {
1145 long eventMask=ButtonPressMask|ExposureMask|ButtonMotionMask;
1146
1147 if (enterSelect)
1148 {
1149 eventMask|=EnterWindowMask;
1150 }
1151 attributes.override_redirect = True;
1152 proxy->proxy = XCreateWindow(
1153 dpy, rootWindow, proxy->proxyx, proxy->proxyy,
1154 proxy->proxyw, proxy->proxyh,border,
1155 DefaultDepth(dpy,screen), InputOutput, Pvisual,
1156 valuemask, &attributes);
1157 XSelectInput(dpy,proxy->proxy,eventMask);
1158 }
1159 else
1160 {
1161 XMoveWindow(dpy, proxy->proxy, proxy->proxyx, proxy->proxyy);
1162 }
1163 XMapRaised(dpy, proxy->proxy);
1164 DrawProxyBackground(proxy);
1165 proxy->flags.is_shown = 1;
1166
1167 return;
1168 }
1169
1170 static void OpenWindows(void)
1171 {
1172 ProxyWindow *proxy;
1173
1174 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1175 {
1176 OpenOneWindow(proxy);
1177 }
1178
1179 selectProxy = NULL;
1180 return;
1181 }
1182
1183 static void CloseOneWindow(ProxyWindow *proxy)
1184 {
1185 if (proxy == NULL)
1186 {
1187 return;
1188 }
1189 if (proxy->flags.is_shown)
1190 {
1191 XUnmapWindow(dpy, proxy->proxy);
1192 proxy->flags.is_shown = 0;
1193 }
1194
1195 return;
1196 }
1197
1198 static void CloseWindows(void)
1199 {
1200 ProxyWindow *proxy;
1201
1202 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1203 {
1204 CloseOneWindow(proxy);
1205 }
1206
1207 return;
1208 }
1209
1210 static Bool SortProxiesOnce(void)
1211 {
1212 Bool change=False;
1213
1214 ProxyWindow *proxy;
1215 ProxyWindow *next;
1216
1217 int x1,x2;
1218 int y1,y2;
1219
1220 lastProxy=NULL;
1221 for (proxy=firstProxy; proxy != NULL && proxy->next != NULL;
1222 proxy=proxy->next)
1223 {
1224 x1=proxy->proxyx;
1225 x2=proxy->next->proxyx;
1226 y1=proxy->proxyy;
1227 y2=proxy->next->proxyy;
1228
1229 /* sort x, then y, then arbitrarily on pointer */
1230 if ( x1>x2 || (x1==x2 && y1>y2) ||
1231 (x1==x2 && y1==y2 &&
1232 proxy->window>proxy->next->window))
1233 {
1234 change=True;
1235 next=proxy->next;
1236
1237 if (lastProxy)
1238 lastProxy->next=next;
1239 else
1240 firstProxy=next;
1241 proxy->next=next->next;
1242 next->next=proxy;
1243 }
1244
1245 lastProxy=proxy;
1246 }
1247
1248 lastProxy=NULL;
1249 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1250 {
1251 proxy->prev=lastProxy;
1252 lastProxy=proxy;
1253 }
1254
1255 return change;
1256 }
1257
1258 static void SortProxies(void)
1259 {
1260 while (SortProxiesOnce() == True)
1261 {
1262 /* nothing */
1263 }
1264
1265 return;
1266 }
1267
1268 static Bool AdjustOneWindow(ProxyWindow *proxy)
1269 {
1270 Bool rc = False;
1271 ProxyWindow *other=proxy->next;
1272
1273 for (other=proxy->next; other; other=other->next)
1274 {
1275 int dx;
1276 int dy;
1277
1278 if(other->desk != deskNumber)
1279 {
1280 continue;
1281 }
1282 dx = abs(proxy->proxyx-other->proxyx);
1283 dy = abs(proxy->proxyy-other->proxyy);
1284 if (dx<(proxyWidth+proxySeparation) &&
1285 dy<proxyHeight+proxySeparation )
1286 {
1287 rc = True;
1288 if (proxyWidth-dx<proxyHeight-dy)
1289 {
1290 if (proxy->proxyx<=other->proxyx)
1291 {
1292 other->proxyx=
1293 proxy->proxyx+ proxy->proxyw+
1294 proxySeparation;
1295 }
1296 else
1297 {
1298 proxy->proxyx=
1299 other->proxyx+ other->proxyw+
1300 proxySeparation;
1301 }
1302 }
1303 else
1304 {
1305 if (proxy->proxyy<=other->proxyy)
1306 {
1307 other->proxyy=
1308 proxy->proxyy+ proxy->proxyh+
1309 proxySeparation;
1310 }
1311 else
1312 {
1313 proxy->proxyy=
1314 other->proxyy+ other->proxyh+
1315 proxySeparation;
1316 }
1317 }
1318 }
1319 }
1320
1321 return rc;
1322 }
1323
1324 static void AdjustWindows(void)
1325 {
1326 Bool collision=True;
1327
1328 while (collision == True)
1329 {
1330 ProxyWindow *proxy;
1331
1332 collision=False;
1333 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1334 {
1335 if(proxy->desk != deskNumber)
1336 continue;
1337
1338 if (AdjustOneWindow(proxy) == True)
1339 {
1340 collision = True;
1341 }
1342 }
1343 }
1344 }
1345
1346 static void RecenterProxy(ProxyWindow *proxy)
1347 {
1348 proxy->proxyx=proxy->x + (proxy->w-proxy->proxyw)/2;
1349 proxy->proxyy=proxy->y + (proxy->h-proxy->proxyh)/2;
1350 }
1351
1352 static void RecalcProxyTweaks(void)
1353 {
1354 ProxyWindow *proxy;
1355 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1356 {
1357 proxy->tweakx=proxy->proxyx -
1358 (proxy->x + (proxy->w-proxy->proxyw)/2);
1359 proxy->tweaky=proxy->proxyy -
1360 (proxy->y + (proxy->h-proxy->proxyh)/2);
1361 }
1362 }
1363 static void TweakProxy(ProxyWindow *proxy)
1364 {
1365 proxy->proxyx += proxy->tweakx;
1366 proxy->proxyy += proxy->tweaky;
1367 }
1368
1369 static void ReshuffleWindows(void)
1370 {
1371 ProxyWindow *proxy;
1372
1373 #if PROXY_GROUP_DEBUG
1374 fprintf(stderr, "ReshuffleWindows\n");
1375 #endif
1376
1377 if (are_windows_shown)
1378 {
1379 CloseWindows();
1380 }
1381 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1382 {
1383 RecenterProxy(proxy);
1384 }
1385 AdjustWindows();
1386 SortProxies();
1387 if (are_windows_shown)
1388 {
1389 OpenWindows();
1390 }
1391 RecalcProxyTweaks();
1392
1393 return;
1394 }
1395
1396 static void UpdateOneWindow(ProxyWindow *proxy)
1397 {
1398 if (proxy == NULL)
1399 {
1400 return;
1401 }
1402 if (proxy->flags.is_shown)
1403 {
1404 ReshuffleWindows();
1405 }
1406
1407 return;
1408 }
1409
1410 static void SendResolve(ProxyWindow *proxy)
1411 {
1412 SendFvwmPipe(fd, "SendToModule FvwmProxy Resolve",
1413 proxy->window);
1414 }
1415
1416 static void WaitToConfig(ProxyWindow *proxy)
1417 {
1418 proxy->pending_config++;
1419 if(!waiting_to_config)
1420 {
1421 waiting_to_config=1;
1422 SendResolve(proxy);
1423 }
1424 }
1425
1426 static void IsolateGroup(ProxyWindow *instigator,int isolate)
1427 {
1428 ProxyWindow *proxy;
1429
1430 #if PROXY_GROUP_DEBUG
1431 fprintf(stderr, "IsolateGroup %p %d\n",
1432 instigator,isolate);
1433 #endif
1434
1435 if(!instigator->group)
1436 {
1437 return;
1438 }
1439
1440 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1441 {
1442 if(proxy==instigator)
1443 {
1444 continue;
1445 }
1446 if (proxy->desk == deskNumber &&
1447 proxy->group==instigator->group)
1448 {
1449 proxy->flags.is_isolated=isolate;
1450
1451 DrawProxyBackground(proxy);
1452 DrawProxy(proxy);
1453 }
1454 }
1455 }
1456
1457 static void IconifyGroup(ProxyWindow *instigator,int iconify)
1458 {
1459 ProxyWindow *proxy;
1460
1461 #if PROXY_GROUP_DEBUG
1462 fprintf(stderr, "IconifyGroup %p %d\n",
1463 instigator,iconify);
1464 #endif
1465
1466 if(!instigator->group)
1467 {
1468 return;
1469 }
1470
1471 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1472 {
1473 if(proxy==instigator)
1474 {
1475 continue;
1476 }
1477 if (proxy->desk == deskNumber &&
1478 proxy->group==instigator->group)
1479 {
1480 sprintf(commandBuffer,"Iconify %s",
1481 iconify? "On": "Off");
1482 send_command_to_fvwm(commandBuffer,proxy->window);
1483 }
1484 }
1485 }
1486
1487 static void RaiseLowerGroup(Window w,int raise)
1488 {
1489 ProxyWindow *instigator;
1490 ProxyWindow *proxy;
1491
1492 instigator = FindProxy(w);
1493 if(instigator==NULL || instigator->flags.is_isolated)
1494 {
1495 return;
1496 }
1497
1498
1499 #if PROXY_GROUP_DEBUG
1500 fprintf(stderr, "RaiseLowerGroup %p %d %d\n",
1501 instigator,raise,instigator->raised);
1502 #endif
1503
1504 if(abs(instigator->raised)>10)
1505 {
1506 exit(1);
1507 }
1508
1509 if(instigator->raised == (raise? 1: -1))
1510 {
1511 return;
1512 }
1513
1514 instigator->raised=0;
1515
1516 if(instigator->flags.is_iconified || !instigator->group)
1517 {
1518 return;
1519 }
1520
1521 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1522 {
1523 if(proxy==instigator || proxy->raised == (raise? 1: -1))
1524 {
1525 continue;
1526 }
1527 if (proxy->desk == deskNumber &&
1528 proxy->group==instigator->group)
1529 {
1530 if(raise)
1531 {
1532 #if PROXY_GROUP_DEBUG
1533 fprintf(stderr, "Raise %p\n",proxy);
1534 #endif
1535
1536 proxy->raised=1;
1537 XRaiseWindow(dpy, proxy->window);
1538 }
1539 else
1540 {
1541 #if PROXY_GROUP_DEBUG
1542 fprintf(stderr, "Lower %p\n",proxy);
1543 #endif
1544
1545 proxy->raised= -1;
1546 XLowerWindow(dpy, proxy->window);
1547 }
1548 }
1549 }
1550 /* make sure instigator ends on on top/bottom */
1551 if(raise)
1552 {
1553 #if PROXY_GROUP_DEBUG
1554 fprintf(stderr, "ReRaise %p\n",instigator);
1555 #endif
1556
1557 instigator->raised=1;
1558 XRaiseWindow(dpy, instigator->window);
1559 }
1560 else
1561 {
1562 #if PROXY_GROUP_DEBUG
1563 fprintf(stderr, "ReLower %p\n",instigator);
1564 #endif
1565
1566 instigator->raised= -1;
1567 XLowerWindow(dpy, instigator->window);
1568 }
1569 }
1570
1571 static void ClearRaised(void)
1572 {
1573 ProxyWindow *proxy;
1574
1575 #if PROXY_GROUP_DEBUG
1576 fprintf(stderr, "ClearRaised\n");
1577 #endif
1578
1579 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1580 {
1581 proxy->raised=0;
1582 }
1583 }
1584
1585 static void ShiftWindows(ProxyWindow *instigator,int dx,int dy)
1586 {
1587 ProxyWindow *proxy;
1588
1589 if((are_windows_shown && !instigator->flags.is_isolated) ||
1590 !instigator->group || instigator->flags.is_soft)
1591 {
1592 return;
1593 }
1594
1595 #if PROXY_GROUP_DEBUG
1596 fprintf(stderr, "ShiftWindows %d %d %d\n",
1597 instigator->group,dx,dy);
1598 #endif
1599
1600 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1601 {
1602 if(proxy==instigator)
1603 {
1604 continue;
1605 }
1606 if (proxy->desk == deskNumber &&
1607 proxy->group==instigator->group)
1608 {
1609 proxy->x+=dx;
1610 proxy->y+=dy;
1611 /*
1612 XMoveWindow(dpy, proxy->window,
1613 proxy->x+proxy->border_width,
1614 proxy->y+proxy->title_height+
1615 proxy->border_width);
1616 */
1617 #if PROXY_GROUP_DEBUG
1618 fprintf(stderr, "shift %d %d (%d %d)\n",
1619 proxy->x,proxy->y, dx,dy);
1620 #endif
1621 WaitToConfig(proxy);
1622 }
1623 }
1624 }
1625
1626 static void CatchWindows(ProxyWindow *instigator,int vertical,int from,int to,
1627 int direction)
1628 {
1629 ProxyWindow *proxy;
1630
1631 if((are_windows_shown && !instigator->flags.is_isolated) ||
1632 !instigator->group || instigator->flags.is_soft)
1633 {
1634 return;
1635 }
1636
1637 #if PROXY_GROUP_DEBUG
1638 fprintf(stderr, "CatchWindows %d %d %d %d\n",
1639 instigator->group,vertical,from,to);
1640 #endif
1641
1642 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1643 {
1644 if(proxy==instigator)
1645 {
1646 continue;
1647 }
1648 if (proxy->desk == deskNumber &&
1649 proxy->group==instigator->group &&
1650 !proxy->flags.is_soft)
1651 {
1652 int changed=0;
1653 int newx=proxy->x;
1654 int newy=proxy->y;
1655 int neww=proxy->goal_width;
1656 int newh=proxy->goal_height;
1657 const int incx=proxy->incx;
1658 const int incy=proxy->incy;
1659 /* int threshold=(vertical? incy: incx)-1;
1660 */
1661 int threshold=0;
1662 int least=from;
1663 int most=from;
1664
1665 if(direction<0)
1666 {
1667 least-=threshold;
1668 }
1669 else
1670 {
1671 most+=threshold;
1672 }
1673
1674 #if PROXY_GROUP_DEBUG
1675 fprintf(stderr,
1676 "check %p %d %d size %d %d"
1677 " goal %d %d inc %d %d\n",
1678 proxy,proxy->x,proxy->y,proxy->w,proxy->h,
1679 proxy->goal_width,proxy->goal_height,
1680 incx,incy);
1681 #endif
1682
1683 if(vertical)
1684 {
1685 if(newy>=least && newy<=most)
1686 {
1687 newy=to;
1688 newh-=to-from;
1689 changed=1;
1690 }
1691 else if(newy+newh>=least &&
1692 newy+newh<=most)
1693 {
1694 newh=to-newy;
1695 changed=1;
1696 }
1697 }
1698 else
1699 {
1700 if(newx>=least && newx<=most)
1701 {
1702 newx=to;
1703 neww-=to-from;
1704 changed=1;
1705 }
1706 else if(newx+neww>=least &&
1707 newx+neww<=most)
1708 {
1709 neww=to-newx;
1710 changed=1;
1711 }
1712 }
1713 if(changed)
1714 {
1715 #if PROXY_GROUP_DEBUG
1716 fprintf(stderr, "change %d %d %d %d\n",
1717 newx,newy,neww,newh);
1718 #endif
1719 if(newx!=proxy->x || newy!=proxy->y)
1720 {
1721 #if PROXY_GROUP_DEBUG
1722 fprintf(stderr, "move\n");
1723 #endif
1724 /*
1725 XMoveWindow(dpy, proxy->window,
1726 newx+bw,
1727 newy+th+bw);
1728 */
1729 WaitToConfig(proxy);
1730
1731 /* in case more motion of instigator
1732 precedes this window's config */
1733 proxy->x=newx;
1734 proxy->y=newy;
1735 }
1736 if(neww<proxy->w ||
1737 neww>=proxy->w+incx ||
1738 newh<proxy->h ||
1739 newh>=proxy->h+incy)
1740 {
1741 #if PROXY_GROUP_DEBUG
1742 fprintf(stderr, "resize\n");
1743 #endif
1744 /*
1745 XResizeWindow(dpy, proxy->window,
1746 neww-2*bw,
1747 newh-2*bw-th);
1748 */
1749 WaitToConfig(proxy);
1750
1751 /* in case more motion of instigator
1752 precedes this window's config */
1753 if(neww<proxy->w)
1754 {
1755 proxy->w-=((proxy->w-neww-1)/
1756 incx+1)*incx;
1757 }
1758 else if(neww>=proxy->w+incx)
1759 {
1760 proxy->w+=(neww-proxy->w)/incx
1761 *incx;
1762 }
1763 if(newh<proxy->h)
1764 {
1765 proxy->h-=((proxy->h-newh-1)/
1766 incy+1)*incy;
1767 }
1768 else if(newh>=proxy->h+incy)
1769 {
1770 proxy->h+=(newh-proxy->h)/incy
1771 *incy;
1772 }
1773 }
1774 proxy->goal_width=neww;
1775 proxy->goal_height=newh;
1776
1777 }
1778 }
1779 }
1780 }
1781
1782 static void MoveProxiedWindow(ProxyWindow* proxy,int x,int y,int w,int h)
1783 {
1784 #if 1
1785 sprintf(commandBuffer,"ResizeMove frame %dp %dp +%dp +%dp",
1786 w,
1787 h,
1788 x,
1789 y);
1790 send_command_to_fvwm(commandBuffer,proxy->window);
1791 #else
1792 const int bw=proxy->border_width;
1793 const int th=proxy->title_height;
1794
1795 XMoveResizeWindow(dpy, proxy->window,
1796 x+bw,
1797 y+th+bw,
1798 w-2*bw,
1799 h-2*bw-th);
1800 #endif
1801 }
1802
1803 static void ResolvePendingWindows(void)
1804 {
1805 ProxyWindow *proxy;
1806
1807 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1808 {
1809 if(proxy->pending_config)
1810 {
1811 MoveProxiedWindow(proxy,proxy->x,proxy->y,
1812 proxy->goal_width,proxy->goal_height);
1813 }
1814 }
1815 }
1816
1817 int FindUniqueGroup(int desk)
1818 {
1819 ProxyWindow *proxy;
1820
1821 /* find unique group */
1822 int group=1;
1823 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1824 {
1825 if (proxy->desk == desk && proxy->group==group)
1826 {
1827 group++;
1828 proxy=firstProxy;
1829 continue;
1830 }
1831 }
1832 #if PROXY_GROUP_DEBUG
1833 fprintf(stderr,"FindUniqueGroup desk %d group %d\n",desk,group);
1834 #endif
1835 return group;
1836 }
1837
1838 static void MoveGroupToDesk(ProxyWindow *instigator,int desk)
1839 {
1840 ProxyWindow *proxy;
1841 int old_desk;
1842 int old_group;
1843 int group;
1844
1845 #if PROXY_GROUP_DEBUG
1846 fprintf(stderr, "MoveGroupToDesk %p %d\n",
1847 instigator,desk);
1848 #endif
1849
1850 if(!instigator->group)
1851 {
1852 return;
1853 }
1854
1855 old_desk=instigator->desk;
1856 old_group=instigator->group;
1857 group=FindUniqueGroup(desk);
1858
1859 sprintf(commandBuffer, "MoveToDesk 0 %d", desk);
1860 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1861 {
1862 if (proxy->desk == old_desk &&
1863 proxy->group==old_group)
1864 {
1865 proxy->desk=desk;
1866 proxy->group=group;
1867
1868 send_command_to_fvwm( commandBuffer, proxy->window);
1869
1870 DrawProxyBackground(proxy);
1871 DrawProxy(proxy);
1872 }
1873 }
1874 }
1875
1876
1877 static ProxyWindow* FindNeighborInGroup(ProxyWindow* instigator,
1878 int not_iconified)
1879 {
1880 ProxyWindow *proxy;
1881
1882 if(!instigator)
1883 {
1884 return NULL;
1885 }
1886
1887 #if PROXY_GROUP_DEBUG
1888 fprintf(stderr,"FindNeighborInGroup %p %p desk %d group %d\n",
1889 instigator,instigator->proxy_group,instigator->desk,
1890 instigator->group);
1891 #endif
1892
1893 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1894 {
1895 #if PROXY_GROUP_DEBUG
1896 fprintf(stderr," vs %p %p desk %d group %d\n",
1897 proxy,proxy->proxy_group,proxy->desk,proxy->group);
1898 #endif
1899 if (proxy!= instigator && proxy->desk == instigator->desk &&
1900 proxy->group &&
1901 proxy->group==instigator->group &&
1902 (!not_iconified || !proxy->flags.is_iconified))
1903 {
1904 return proxy;
1905 }
1906 }
1907
1908 return NULL;
1909 }
1910
1911 static ProxyWindow* FindNeighborForProxy(ProxyWindow* instigator)
1912 {
1913 ProxyWindow *proxy;
1914 ProxyWindow *neighbor=NULL;
1915 int group;
1916
1917 if(!instigator)
1918 {
1919 return NULL;
1920 }
1921
1922 #if PROXY_GROUP_DEBUG
1923 fprintf(stderr,"FindNeighborForProxy %p %p desk %d\n",
1924 instigator,instigator->proxy_group,instigator->desk);
1925 #endif
1926
1927 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1928 {
1929 #if PROXY_GROUP_DEBUG
1930 fprintf(stderr," vs %p %p desk %d group %d\n",
1931 proxy,proxy->proxy_group,proxy->desk,proxy->group);
1932 #endif
1933 if (proxy!= instigator && proxy->desk == instigator->desk &&
1934 proxy->proxy_group==instigator->proxy_group)
1935 {
1936 if(proxy->proxy_group->flags.isolated &&
1937 !instigator->flags.is_isolated)
1938 {
1939 SendFvwmPipe(fd,
1940 "SendToModule FvwmProxy IsolateToggle",
1941 proxy->window);
1942 }
1943 if(proxy->group)
1944 {
1945 return proxy;
1946 }
1947 neighbor=proxy;
1948 }
1949 }
1950
1951 if(!neighbor)
1952 {
1953 #if PROXY_GROUP_DEBUG
1954 fprintf(stderr,"not found\n");
1955 #endif
1956 return NULL;
1957 }
1958
1959 group=FindUniqueGroup(instigator->desk);
1960
1961 /* assign group to all proxies with given pid */
1962 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
1963 {
1964 if (proxy->desk == instigator->desk &&
1965 proxy->proxy_group==instigator->proxy_group)
1966 {
1967 #if PROXY_GROUP_DEBUG
1968 fprintf(stderr,"unique group %d reassign %s\n",
1969 group,proxy->name);
1970 #endif
1971 proxy->group=group;
1972 }
1973 }
1974
1975 #if PROXY_GROUP_DEBUG
1976 fprintf(stderr,"group %d\n",group);
1977 #endif
1978 return neighbor;
1979 }
1980
1981 static ProxyWindow* FindNeighborForProcess(ProxyWindow* proxy,
1982 int desk,int pid,int ppid)
1983 {
1984 ProxyWindow *other;
1985 ProxyWindow *neighbor=NULL;
1986 int group;
1987 int auto_include=0;
1988
1989 if(!pid)
1990 {
1991 return 0;
1992 }
1993
1994 /* find existing group for pid */
1995 for (other=firstProxy; other != NULL; other=other->next)
1996 {
1997 if (other->desk == desk && other->proxy_group &&
1998 (other->pid==pid || (ppid && other->pid==ppid) ||
1999 other->ppid==pid) &&
2000 (MatchWindowName(other->proxy_group->includes,
2001 proxy->name) ||
2002 (auto_include=other->proxy_group->flags.auto_include)))
2003 {
2004 proxy->flags.is_soft=auto_include &&
2005 other->proxy_group->flags.auto_soft;
2006 if(other->proxy_group->flags.isolated &&
2007 !proxy->flags.is_isolated)
2008 {
2009 SendFvwmPipe(fd,
2010 "SendToModule FvwmProxy IsolateToggle",
2011 proxy->window);
2012 }
2013 #if PROXY_GROUP_DEBUG
2014 fprintf(stderr,
2015 "pid %d %d found %d %d group %d soft %d\n",
2016 pid,ppid,other->pid,other->ppid,
2017 other->group,proxy->flags.is_soft);
2018 #endif
2019 if(other->group)
2020 {
2021 return other;
2022 }
2023 neighbor=other;
2024 }
2025 }
2026 if(!neighbor)
2027 {
2028 #if PROXY_GROUP_DEBUG
2029 fprintf(stderr,"FindNeighborForProcess pid %d %d not found\n",
2030 pid,ppid);
2031 #endif
2032 return NULL;
2033 }
2034
2035 group=FindUniqueGroup(desk);
2036
2037 /* assign pid to all proxies with given pid */
2038 for (other=firstProxy; other != NULL; other=other->next)
2039 {
2040 if (other->desk == desk && other->proxy_group &&
2041 (other->pid==pid || (ppid && other->pid==ppid) ||
2042 other->ppid==pid))
2043 {
2044 #if PROXY_GROUP_DEBUG
2045 fprintf(stderr,"unique group %d reassign %s\n",
2046 group,other->name);
2047 #endif
2048 other->group=group;
2049 }
2050 }
2051
2052 #if PROXY_GROUP_DEBUG
2053 fprintf(stderr,"FindNeighborForProcess pid %d new %d\n",pid,group);
2054 #endif
2055 return neighbor;
2056 }
2057
2058 static ProxyWindow* FindNeighborForLeader(ProxyWindow* proxy,
2059 int desk,int leader)
2060 {
2061 ProxyWindow *other;
2062 ProxyWindow *neighbor=NULL;
2063 int group;
2064 int auto_include=0;
2065
2066 if(!leader)
2067 {
2068 return 0;
2069 }
2070
2071 /* find existing group for leader */
2072 for (other=firstProxy; other != NULL; other=other->next)
2073 {
2074 if (other->desk == desk && other->proxy_group &&
2075 other->leader==leader &&
2076 (MatchWindowName(other->proxy_group->includes,
2077 proxy->name) ||
2078 (auto_include=other->proxy_group->flags.auto_include)))
2079 {
2080 proxy->flags.is_soft=auto_include &&
2081 other->proxy_group->flags.auto_soft;
2082 if(other->proxy_group->flags.isolated &&
2083 !proxy->flags.is_isolated)
2084 {
2085 SendFvwmPipe(fd,
2086 "SendToModule FvwmProxy IsolateToggle",
2087 proxy->window);
2088 }
2089 #if PROXY_GROUP_DEBUG
2090 fprintf(stderr,"leader %d found %d group %d soft %d\n",
2091 leader,other->leader,
2092 other->group,proxy->flags.is_soft);
2093 #endif
2094 if(other->group)
2095 {
2096 return other;
2097 }
2098 neighbor=other;
2099 }
2100 }
2101 if(!neighbor)
2102 {
2103 #if PROXY_GROUP_DEBUG
2104 fprintf(stderr,"FindNeighborForLeader leader %d not found\n",
2105 leader);
2106 #endif
2107 return NULL;
2108 }
2109
2110 group=FindUniqueGroup(desk);
2111
2112 /* assign leader to all proxies with given leader */
2113 for (other=firstProxy; other != NULL; other=other->next)
2114 {
2115 if (other->desk == desk && other->leader==leader &&
2116 other->proxy_group)
2117 {
2118 #if PROXY_GROUP_DEBUG
2119 fprintf(stderr,"unique group %d reassign %s\n",
2120 group,other->name);
2121 #endif
2122 other->group=group;
2123 }
2124 }
2125
2126 #if PROXY_GROUP_DEBUG
2127 fprintf(stderr,"FindNeighborForLeader leader %x new %d\n",
2128 leader,group);
2129 #endif
2130 return neighbor;
2131 }
2132
2133 static ProxyWindow* FindNeighborForApplication(ProxyWindow* proxy)
2134 {
2135 ProxyWindow* neighbor=FindNeighborForLeader(proxy,proxy->desk,
2136 proxy->leader);
2137 if(!neighbor)
2138 {
2139 neighbor=FindNeighborForProcess(proxy,proxy->desk,
2140 proxy->pid,proxy->ppid);
2141 }
2142 return neighbor;
2143 }
2144
2145 static int ProxyGroupCheckSoft(ProxyGroup* proxy_group,
2146 ProxyWindow* proxy)
2147 {
2148 WindowName* include=proxy_group->includes;
2149 while(include)
2150 {
2151 if(matchWildcards(include->name, proxy->name))
2152 {
2153 return include->flags.is_soft;
2154 }
2155 include=include->next;
2156 }
2157 return 0;
2158 }
2159
2160 static void UpdateProxyGroup(ProxyWindow* proxy)
2161 {
2162 ProxyWindow* neighbor;
2163 #if PROXY_GROUP_DEBUG
2164 fprintf(stderr,"UpdateProxyGroup %s\n",proxy->name);
2165 #endif
2166
2167 if(proxy->proxy_group)
2168 {
2169 return;
2170 }
2171 if(!proxy->proxy_group)
2172 {
2173 neighbor=FindNeighborForApplication(proxy);
2174 /*
2175 proxy->group=0;
2176 */
2177 proxy->proxy_group=NULL;
2178 if(neighbor && neighbor->proxy_group)
2179 {
2180 proxy->group=neighbor->group;
2181 proxy->proxy_group=neighbor->proxy_group;
2182 }
2183 }
2184 if(!proxy->proxy_group)
2185 {
2186 proxy->proxy_group=
2187 FindProxyGroupWithWindowName(proxy->name);
2188 }
2189 if(proxy->proxy_group &&
2190 MatchWindowName(proxy->proxy_group->excludes,proxy->name))
2191 {
2192 proxy->proxy_group=NULL;
2193 proxy->group=0;
2194 }
2195 if(proxy->proxy_group && !proxy->group &&
2196 proxy->proxy_group->flags.ignore_ids)
2197 {
2198 neighbor=FindNeighborForProxy(proxy);
2199 if(neighbor)
2200 {
2201 proxy->group=neighbor->group;
2202 }
2203 }
2204
2205 if(proxy->proxy_group)
2206 {
2207 #if PROXY_GROUP_DEBUG
2208 fprintf(stderr," ProxyGroup %s\n",proxy->proxy_group->name);
2209 #endif
2210
2211 proxy->flags.is_soft=proxy->flags.is_soft ||
2212 ProxyGroupCheckSoft(proxy->proxy_group,proxy);
2213 }
2214 }
2215
2216 static void UpdateProxyGroupForAll(void)
2217 {
2218 ProxyWindow *proxy;
2219
2220 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
2221 {
2222 UpdateProxyGroup(proxy);
2223 }
2224 }
2225
2226 static void AdhereGroup(ProxyWindow *instigator)
2227 {
2228 ProxyWindow *proxy;
2229
2230 #if PROXY_GROUP_DEBUG
2231 fprintf(stderr, "AdhereGroup %p\n", instigator);
2232 #endif
2233
2234 if(!instigator)
2235 {
2236 return;
2237 }
2238
2239 if(!instigator->group || instigator->flags.is_soft)
2240 {
2241 return;
2242 }
2243
2244 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
2245 {
2246 if(proxy==instigator)
2247 {
2248 continue;
2249 }
2250 if (proxy->desk == instigator->desk &&
2251 proxy->group==instigator->group)
2252 {
2253 if(!proxy->flags.is_soft &&
2254 (proxy->x != instigator->x ||
2255 proxy->y != instigator->y ||
2256 proxy->goal_width != instigator->goal_width ||
2257 proxy->goal_height != instigator->goal_height))
2258 {
2259 proxy->x=instigator->x;
2260 proxy->y=instigator->y;
2261 proxy->goal_width=instigator->goal_width;
2262 proxy->goal_height=instigator->goal_height;
2263
2264 MoveProxiedWindow(proxy,proxy->x,proxy->y,
2265 proxy->goal_width,proxy->goal_height);
2266 }
2267 }
2268 }
2269 }
2270
2271 static void SetGroup(ProxyWindow* proxy, int group)
2272 {
2273 ProxyWindow *neighbor;
2274
2275 proxy->group=group;
2276 if(group)
2277 {
2278 neighbor=FindNeighborInGroup(proxy,0);
2279 if(neighbor)
2280 {
2281 proxy->flags.is_isolated = neighbor->flags.is_isolated;
2282 if(proxy->flags.is_isolated)
2283 {
2284 AdhereGroup(neighbor);
2285 }
2286 }
2287 if(proxy->flags.is_isolated && !proxy->flags.is_iconified)
2288 {
2289 IconifyGroup(proxy,1);
2290 }
2291 }
2292 else
2293 {
2294 proxy->flags.is_soft=0;
2295 proxy->flags.is_isolated=0;
2296 }
2297 }
2298
2299 void DumpStampQueue(void)
2300 {
2301 #if PROXY_GROUP_DEBUG
2302 int m;
2303
2304 fprintf(stderr,"DumpStampQueue stamp %d min %d max %d\n",
2305 stamp,stampMin,stampMax);
2306 for(m=0;m<stampLimit;m++)
2307 {
2308 fprintf(stderr,"stampQueue[%d] %x %d %d %d %d\n",m,
2309 (int)(stampQueue[m].window),
2310 stampQueue[m].x,
2311 stampQueue[m].y,
2312 stampQueue[m].w,
2313 stampQueue[m].h);
2314 }
2315 #endif
2316 }
2317
2318 void StoreStamp(Window window,int x,int y,int w,int h)
2319 {
2320 #if PROXY_GROUP_DEBUG
2321 fprintf(stderr,"StoreStamp %x %d %d %d %d\n",(int)window,x,y,w,h);
2322 #endif
2323
2324 stamp=(stamp+1)%stampLimit;
2325 stampMax=stamp;
2326 if(stampMin==stampMax)
2327 {
2328 stampMin=(stampMax+1)%stampLimit;
2329 }
2330
2331 stampQueue[stamp].window=window;
2332 stampQueue[stamp].x=x;
2333 stampQueue[stamp].y=y;
2334 stampQueue[stamp].w=w;
2335 stampQueue[stamp].h=h;
2336
2337 DumpStampQueue();
2338 }
2339
2340 void UndoStamp(void)
2341 {
2342 ProxyWindow *proxy;
2343
2344 if(stamp==stampMin)
2345 {
2346 #if PROXY_GROUP_DEBUG
2347 fprintf(stderr,"UndoStamp empty, stamp %d min %d max %d\n",
2348 stamp,stampMin,stampMax);
2349 #endif
2350 return;
2351 }
2352 proxy = FindProxy(stampQueue[stamp].window);
2353 if(!proxy)
2354 {
2355 #if PROXY_GROUP_DEBUG
2356 fprintf(stderr,"UndoStamp no proxy for window\n");
2357 #endif
2358 return;
2359 }
2360
2361 pending_do++;
2362 MoveProxiedWindow(proxy,
2363 stampQueue[stamp].x,
2364 stampQueue[stamp].y,
2365 stampQueue[stamp].w,
2366 stampQueue[stamp].h);
2367
2368 stampQueue[stamp].window=proxy->window;
2369 stampQueue[stamp].x=proxy->x;
2370 stampQueue[stamp].y=proxy->y;
2371 stampQueue[stamp].w=proxy->w;
2372 stampQueue[stamp].h=proxy->h;
2373
2374 stamp=(stamp-1+stampLimit)%stampLimit;
2375
2376 DumpStampQueue();
2377
2378 SendResolve(proxy);
2379 }
2380
2381 void RedoStamp(void)
2382 {
2383 ProxyWindow *proxy;
2384
2385 if(stamp==stampMax)
2386 {
2387 #if PROXY_GROUP_DEBUG
2388 fprintf(stderr,"RedoStamp empty, stamp %d min %d max %d\n",
2389 stamp,stampMin,stampMax);
2390 #endif
2391 return;
2392 }
2393
2394 stamp=(stamp+1)%stampLimit;
2395
2396 proxy = FindProxy(stampQueue[stamp].window);
2397 if(!proxy)
2398 {
2399 #if PROXY_GROUP_DEBUG
2400 fprintf(stderr,"RedoStamp no proxy for window\n");
2401 #endif
2402 return;
2403 }
2404
2405 pending_do++;
2406 MoveProxiedWindow(proxy,
2407 stampQueue[stamp].x,
2408 stampQueue[stamp].y,
2409 stampQueue[stamp].w,
2410 stampQueue[stamp].h);
2411
2412 stampQueue[stamp].window=proxy->window;
2413 stampQueue[stamp].x=proxy->x;
2414 stampQueue[stamp].y=proxy->y;
2415 stampQueue[stamp].w=proxy->w;
2416 stampQueue[stamp].h=proxy->h;
2417
2418 DumpStampQueue();
2419
2420 SendResolve(proxy);
2421 }
2422
2423 static void ConfigureWindow(FvwmPacket *packet)
2424 {
2425 unsigned long* body = packet->body;
2426
2427 struct ConfigWinPacket *cfgpacket=(void *)body;
2428 int wx=cfgpacket->frame_x;
2429 int wy=cfgpacket->frame_y;
2430 int desk=cfgpacket->desk;
2431 int wsx=cfgpacket->frame_width;
2432 int wsy=cfgpacket->frame_height;
2433 int border_width=cfgpacket->border_width;
2434 int title_height=cfgpacket->title_height;
2435 int incx=cfgpacket->hints_width_inc;
2436 int incy=cfgpacket->hints_height_inc;
2437 Window target=cfgpacket->w;
2438 int leader;
2439 int pid;
2440 int ppid;
2441 ProxyWindow *proxy;
2442 int is_new_window = 0;
2443
2444 if (DO_SKIP_WINDOW_LIST(cfgpacket))
2445 {
2446 return;
2447 }
2448 #if PROXY_GROUP_DEBUG
2449 fprintf(stderr,"\n");
2450 #endif
2451 leader=GetLeader(target);
2452 pid=GetProcessId(target);
2453 ppid=GetParentProcessId(pid);
2454 proxy = FindProxy(target);
2455 if (proxy == NULL)
2456 {
2457 is_new_window = 1;
2458 proxy=new_ProxyWindow();
2459 proxy->next = firstProxy;
2460 firstProxy = proxy;
2461 proxy->window=target;
2462
2463 /* unreliable on existing windows
2464 on 2.5.10, reporting false just after M_ICONIFY */
2465 proxy->flags.is_iconified = !!IS_ICONIFIED(cfgpacket);
2466 }
2467
2468 #if PROXY_GROUP_DEBUG
2469 fprintf(stderr,
2470 "Config %p %x ld %x pid=%d %d\n"
2471 " pos %d %d sz %d %d"
2472 " was %d %d sz %d %d goal %d %d"
2473 " bdr %d %d pend %d %d\n",
2474 proxy,(int)target,leader,pid,ppid,
2475 wx,wy,wsx,wsy,
2476 proxy->x,proxy->y,
2477 proxy->w,proxy->h,
2478 proxy->goal_width,proxy->goal_height,
2479 border_width,title_height,
2480 proxy->pending_config,
2481 pending_do);
2482 #endif
2483
2484 if(proxy->pending_config)
2485 {
2486 proxy->pending_config=0;
2487 }
2488 else
2489 {
2490 if(!pending_do && !waiting_to_stamp &&
2491 (is_new_window || proxy->x!=wx || proxy->y!=wy ||
2492 proxy->w!=wsx || proxy->h!=wsy))
2493 {
2494 waiting_to_stamp=1;
2495 sprintf(commandBuffer,
2496 "SendToModule FvwmProxy Stamp %d %d %d %d",
2497 proxy->x,proxy->y,proxy->w,proxy->h);
2498 SendFvwmPipe(fd, commandBuffer, proxy->window);
2499 }
2500
2501 if (is_new_window)
2502 {
2503 proxy->goal_width=wsx;
2504 proxy->goal_height=wsy;
2505 }
2506 else
2507 {
2508 int shifted=0;
2509 int wasx=proxy->x;
2510 int wasy=proxy->y;
2511 int wasw=proxy->w;
2512 int wash=proxy->h;
2513 int wasgw=proxy->goal_width;
2514 int wasgh=proxy->goal_height;
2515 if(proxy->x!=wx && proxy->w==wsx)
2516 {
2517 ShiftWindows(proxy,wx-proxy->x,wy-proxy->y);
2518 shifted=1;
2519 }
2520 else
2521 {
2522 if(wasx!=wx)
2523 {
2524 CatchWindows(proxy,0,proxy->x,wx,-1);
2525 proxy->goal_width=wsx;
2526 }
2527 if(wasx+wasw!=wx+wsx)
2528 {
2529 CatchWindows(proxy,0,
2530 wasx+wasgw,
2531 wx+wsx,1);
2532 proxy->goal_width=wsx;
2533 }
2534 }
2535
2536 if(proxy->y!=wy && proxy->h==wsy)
2537 {
2538 if(!shifted)
2539 {
2540 ShiftWindows(proxy,0,wy-proxy->y);
2541 }
2542 }
2543 else
2544 {
2545 if(wasy!=wy)
2546 {
2547 CatchWindows(proxy,1,proxy->y,wy,-1);
2548 proxy->goal_height=wsy;
2549 }
2550 if(wasy+wash!=wy+wsy)
2551 {
2552 CatchWindows(proxy,1,
2553 wasy+wasgh,
2554 wy+wsy,1);
2555 proxy->goal_height=wsy;
2556 }
2557 }
2558 /*
2559 if(wx!=proxy->x || wy!=proxy->y ||
2560 wsx!=proxy->w || wsy!=proxy->h)
2561 {
2562 StoreStamp(target,proxy->x,proxy->y,
2563 proxy->w,proxy->h);
2564 }
2565 */
2566 }
2567 }
2568
2569 if(!is_new_window && proxy->desk!=desk)
2570 {
2571 MoveGroupToDesk(proxy,desk);
2572 }
2573
2574 proxy->leader=leader;
2575 proxy->pid=pid;
2576 proxy->ppid=ppid;
2577 proxy->x=wx;
2578 proxy->y=wy;
2579 proxy->desk=desk;
2580 proxy->w=wsx;
2581 proxy->h=wsy;
2582 proxy->proxyw=proxyWidth;
2583 proxy->proxyh=proxyHeight;
2584 proxy->border_width=border_width;
2585 proxy->title_height=title_height;
2586 proxy->incx=incx;
2587 proxy->incy=incy;
2588
2589 RecenterProxy(proxy);
2590 if (!is_new_window)
2591 {
2592 TweakProxy(proxy);
2593 }
2594
2595 if (are_windows_shown)
2596 {
2597 if (is_new_window)
2598 {
2599 ReshuffleWindows();
2600 }
2601 else
2602 {
2603 CloseOneWindow(proxy);
2604 OpenOneWindow(proxy);
2605 }
2606 }
2607
2608 if(proxy->flags.is_isolated)
2609 {
2610 AdhereGroup(proxy);
2611 }
2612
2613 return;
2614 }
2615
2616 static void IconifyWindow(ProxyWindow *proxy, int is_iconified)
2617 {
2618 if (proxy == NULL)
2619 {
2620 return;
2621 }
2622 is_iconified = !!is_iconified;
2623 if(proxy->flags.is_iconified != is_iconified)
2624 {
2625 proxy->flags.is_iconified = is_iconified;
2626 if (!proxyIconified && is_iconified)
2627 {
2628 if (proxy->flags.is_shown)
2629 {
2630 CloseOneWindow(proxy);
2631 }
2632 }
2633 else
2634 {
2635 if (are_windows_shown)
2636 {
2637 /* ReshuffleWindows();
2638 */
2639 OpenOneWindow(proxy);
2640 }
2641 }
2642
2643 DrawProxyBackground(proxy);
2644
2645 if(proxy->flags.is_isolated)
2646 {
2647 if(!is_iconified)
2648 {
2649 IconifyGroup(proxy, 1);
2650 }
2651 }
2652 else
2653 {
2654 IconifyGroup(proxy,is_iconified);
2655 }
2656 }
2657
2658 return;
2659 }
2660
2661 static void IsolateCheck(ProxyWindow *instigator,int force_other)
2662 {
2663 if(instigator->flags.is_isolated)
2664 {
2665 if(!force_other && !instigator->flags.is_iconified)
2666 {
2667 IconifyGroup(instigator,1);
2668 AdhereGroup(instigator);
2669 }
2670 else
2671 {
2672 ProxyWindow *neighbor=
2673 FindNeighborInGroup(instigator,1);
2674 if(neighbor)
2675 {
2676 IconifyGroup(neighbor,1);
2677 }
2678 else
2679 {
2680 neighbor=FindNeighborInGroup(instigator,0);
2681 if(neighbor && force_other)
2682 {
2683 sprintf(commandBuffer,"Iconify Off");
2684 send_command_to_fvwm(commandBuffer,
2685 neighbor->window);
2686 }
2687 }
2688 AdhereGroup(neighbor);
2689 }
2690 }
2691 }
2692
2693 static void DestroyWindow(Window w)
2694 {
2695 ProxyWindow *proxy;
2696 ProxyWindow *prev;
2697
2698 for (proxy=firstProxy, prev = NULL; proxy != NULL;
2699 prev = proxy, proxy=proxy->next)
2700 {
2701 if (proxy->proxy==w || proxy->window==w)
2702 break;
2703 }
2704 if (proxy == NULL)
2705 {
2706 return;
2707 }
2708 if (prev == NULL)
2709 {
2710 firstProxy = proxy->next;
2711 }
2712 else
2713 {
2714 prev->next = proxy->next;
2715 }
2716 if (selectProxy == proxy)
2717 {
2718 selectProxy = NULL;
2719 }
2720 if (enterProxy == proxy)
2721 {
2722 enterProxy = NULL;
2723 }
2724 if(!proxy->flags.is_iconified)
2725 {
2726 IsolateCheck(proxy,1);
2727 }
2728 CloseOneWindow(proxy);
2729 delete_ProxyWindow(proxy);
2730
2731 return;
2732 }
2733
2734 static unsigned int GetModifiers(void)
2735 {
2736 Window root_return, child_return;
2737 int root_x_return, root_y_return;
2738 int win_x_return, win_y_return;
2739 unsigned int mask_return;
2740
2741 if (FQueryPointer(
2742 dpy,rootWindow,&root_return,
2743 &child_return,
2744 &root_x_return,&root_y_return,
2745 &win_x_return,&win_y_return,
2746 &mask_return) == False)
2747 {
2748 /* pointer is on another screen - ignore */
2749 }
2750
2751 /* mask_return
2752 0x01 shift
2753 0x02 caplock
2754 0x04 ctrl
2755 0x08 alt
2756 0x40 logo
2757 */
2758 return mask_return;
2759 }
2760
2761 static void StartProxies(void)
2762 {
2763 if (are_windows_shown)
2764 {
2765 return;
2766 }
2767
2768 held_modifiers=GetModifiers();
2769 enterProxy=NULL;
2770 selectProxy=NULL;
2771
2772 if(action_list[PROXY_ACTION_MODIFIER_RELEASE])
2773 watching_modifiers=1;
2774
2775 send_command_to_fvwm(action_list[PROXY_ACTION_SHOW], None);
2776 are_windows_shown = 1;
2777 CloseWindows();
2778 ReshuffleWindows();
2779 OpenWindows();
2780
2781 return;
2782 }
2783
2784 static void MarkProxy(ProxyWindow *new_proxy)
2785 {
2786 ProxyWindow *old_proxy;
2787
2788 old_proxy = selectProxy;
2789 selectProxy = new_proxy;
2790 if (selectProxy != old_proxy)
2791 {
2792 if (old_proxy != NULL)
2793 {
2794 DrawProxyBackground(old_proxy);
2795 DrawProxy(old_proxy);
2796 }
2797 if (selectProxy != NULL)
2798 {
2799 DrawProxyBackground(selectProxy);
2800 DrawProxy(selectProxy);
2801 }
2802 }
2803 if (old_proxy != NULL)
2804 send_command_to_fvwm(action_list[PROXY_ACTION_UNMARK],
2805 old_proxy->window);
2806 if (selectProxy != NULL)
2807 send_command_to_fvwm(action_list[PROXY_ACTION_MARK],
2808 selectProxy->window);
2809
2810 return;
2811 }
2812
2813 static void HideProxies(void)
2814 {
2815 if (!are_windows_shown)
2816 {
2817 return;
2818 }
2819 are_windows_shown = 0;
2820 CloseWindows();
2821
2822 return;
2823 }
2824
2825 static void SelectProxy(void)
2826 {
2827 ProxyWindow *proxy;
2828
2829 HideProxies();
2830 if (selectProxy)
2831 send_command_to_fvwm(action_list[PROXY_ACTION_SELECT],
2832 selectProxy->window);
2833
2834 send_command_to_fvwm(action_list[PROXY_ACTION_HIDE], None);
2835
2836 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
2837 if (proxy==selectProxy)
2838 {
2839 startProxy=proxy;
2840 break;
2841 }
2842
2843 selectProxy=NULL;
2844
2845 return;
2846 }
2847
2848 static void AbortProxies(void)
2849 {
2850 HideProxies();
2851 send_command_to_fvwm(action_list[PROXY_ACTION_ABORT], None);
2852 selectProxy = NULL;
2853
2854 return;
2855 }
2856
2857 static void RotateIsolated(ProxyWindow *instigator,int direction)
2858 {
2859 int found=0;
2860 ProxyWindow *proxy;
2861 ProxyWindow *first=NULL;
2862 ProxyWindow *adjacent=NULL;
2863
2864 #if PROXY_GROUP_DEBUG
2865 fprintf(stderr,"RotateIsolated %p %p %d\n",
2866 instigator,last_rotation_instigator,direction);
2867 #endif
2868
2869 /* rotation can lose focus, so we store it */
2870 if(!instigator || !instigator->group ||
2871 !instigator->flags.is_isolated)
2872 {
2873 instigator=last_rotation_instigator;
2874 }
2875 if(!instigator || !instigator->group ||
2876 !instigator->flags.is_isolated)
2877 {
2878 return;
2879 }
2880 last_rotation_instigator=instigator;
2881
2882 for (proxy=firstProxy; proxy != NULL; proxy=proxy->next)
2883 {
2884 if(proxy->desk == instigator->desk &&
2885 proxy->group==instigator->group)
2886 {
2887 if(!proxy->flags.is_iconified)
2888 {
2889 if(direction<0 && adjacent)
2890 {
2891 break;
2892 }
2893 found=1;
2894 }
2895 else
2896 {
2897 if(direction<0)
2898 {
2899 adjacent=proxy;
2900 }
2901 else if(found)
2902 {
2903 adjacent=proxy;
2904 break;
2905 }
2906 else if(!first)
2907 {
2908 first=proxy;
2909 }
2910 }
2911 }
2912 }
2913
2914 if(!adjacent)
2915 {
2916 adjacent=first;
2917 }
2918 if(adjacent)
2919 {
2920 sprintf(commandBuffer,"Iconify Off");
2921 send_command_to_fvwm(commandBuffer,adjacent->window);
2922 }
2923
2924 return;
2925 }
2926
2927 static void change_cset(int cset)
2928 {
2929 if (cset == cset_normal || cset == cset_iconified)
2930 {
2931 ProxyWindow *proxy;
2932
2933 for (proxy = firstProxy; proxy != NULL; proxy = proxy->next)
2934 {
2935 DrawProxyBackground(proxy);
2936 }
2937 }
2938 else if (cset == cset_select && selectProxy != NULL)
2939 {
2940 DrawProxyBackground(selectProxy);
2941 }
2942
2943 return;
2944 }
2945
2946 static void ProcessMessage(FvwmPacket* packet)
2947 {
2948 unsigned long type = packet->type;
2949 unsigned long* body = packet->body;
2950 FvwmWinPacketBodyHeader *bh = (void *)body;
2951 ProxyWindow *proxy;
2952 int x=0;
2953 int y=0;
2954 int w=0;
2955 int h=0;
2956
2957 if(type!=M_RAISE_WINDOW && type!=M_LOWER_WINDOW &&
2958 type!=M_FOCUS_CHANGE && type!=M_ICON_NAME &&
2959 type!=M_MINI_ICON && type!=M_STRING)
2960 {
2961 ClearRaised();
2962 }
2963
2964 switch (type)
2965 {
2966 case M_CONFIGURE_WINDOW:
2967 case M_ADD_WINDOW:
2968 ConfigureWindow(packet);
2969 break;
2970 case M_DESTROY_WINDOW:
2971 DestroyWindow(bh->w);
2972 break;
2973 case M_ICONIFY:
2974 IconifyWindow(FindProxy(bh->w), 1);
2975 break;
2976 case M_DEICONIFY:
2977 IconifyWindow(FindProxy(bh->w), 0);
2978 break;
2979 case M_RAISE_WINDOW:
2980 RaiseLowerGroup(bh->w,1);
2981 break;
2982 case M_LOWER_WINDOW:
2983 RaiseLowerGroup(bh->w,0);
2984 break;
2985 case M_WINDOW_NAME:
2986 proxy = FindProxy(bh->w);
2987 if (proxy != NULL)
2988 {
2989 if (proxy->name != NULL)
2990 {
2991 free(proxy->name);
2992 }
2993 proxy->name = safestrdup((char*)&body[3]);
2994 #if PROXY_GROUP_DEBUG
2995 fprintf(stderr,"M_WINDOW_NAME %s\n",proxy->name);
2996 #endif
2997 UpdateProxyGroup(proxy);
2998 UpdateProxyGroupForAll();
2999 }
3000 break;
3001 case M_ICON_NAME:
3002 proxy = FindProxy(bh->w);
3003 if (proxy != NULL)
3004 {
3005 if (proxy->iconname != NULL)
3006 {
3007 free(proxy->iconname);
3008 }
3009 proxy->iconname = safestrdup((char*)&body[3]);
3010 #if PROXY_GROUP_DEBUG
3011 fprintf(stderr,"M_ICON_NAME %s\n",proxy->iconname);
3012 #endif
3013 /* UpdateOneWindow(proxy);
3014 */
3015 DrawProxyBackground(proxy);
3016 DrawProxy(proxy);
3017 }
3018 break;
3019 case M_NEW_DESK:
3020 if (deskNumber!=body[0])
3021 {
3022 deskNumber=body[0];
3023 if (are_windows_shown)
3024 {
3025 ReshuffleWindows();
3026 }
3027 }
3028 break;
3029 case M_NEW_PAGE:
3030 deskNumber=body[2];
3031 ReshuffleWindows();
3032 break;
3033 case M_MINI_ICON:
3034 proxy = FindProxy(bh->w);
3035 if (proxy != NULL)
3036 {
3037 proxy->picture.width=body[3];
3038 proxy->picture.height=body[4];
3039 proxy->picture.depth=body[5];
3040 proxy->picture.picture=body[6];
3041 proxy->picture.mask=body[7];
3042 proxy->picture.alpha=body[8];
3043 UpdateOneWindow(proxy);
3044 }
3045 break;
3046 case M_FOCUS_CHANGE:
3047 {
3048 focusWindow=bh->w;
3049 if(bh->w != 0)
3050 {
3051 last_rotation_instigator=NULL;
3052 }
3053 }
3054 break;
3055 case M_STRING:
3056 {
3057 char *message=(char*)&body[3];
3058 char *token;
3059 char *next;
3060 int prev;
3061 int isolate_check=0;
3062 int reshuffle=0;
3063
3064 #if PROXY_GROUP_DEBUG
3065 fprintf(stderr, "M_STRING \"%s\"\n", message);
3066 #endif
3067
3068 token = PeekToken(message, &next);
3069 prev=(StrEquals(token, "Prev"));
3070 if (StrEquals(token, "Next") || prev)
3071 {
3072 ProxyWindow *lastSelect=selectProxy;
3073 ProxyWindow *newSelect=selectProxy;
3074 ProxyWindow *first=prev? lastProxy: firstProxy;
3075
3076 /* auto-show if not already shown */
3077 if (!are_windows_shown)
3078 StartProxies();
3079
3080 if (startProxy && startProxy->desk==deskNumber)
3081 {
3082 newSelect=startProxy;
3083 startProxy=NULL;
3084 }
3085 else
3086 {
3087 if (newSelect)
3088 {
3089 if (prev)
3090 newSelect=newSelect->prev;
3091 else
3092 newSelect=newSelect->next;
3093 }
3094 if (!newSelect)
3095 newSelect=first;
3096 while (newSelect!=lastSelect &&
3097 newSelect->desk!=deskNumber)
3098 {
3099 if (prev)
3100 newSelect=newSelect->prev;
3101 else
3102 newSelect=newSelect->next;
3103 if (!newSelect && lastSelect)
3104 newSelect=first;
3105 }
3106 }
3107
3108 MarkProxy(newSelect);
3109 }
3110 else if (StrEquals(token, "Circulate"))
3111 {
3112 Window w;
3113
3114 /* auto-show if not already shown */
3115 if (!are_windows_shown)
3116 StartProxies();
3117
3118 w = (selectProxy) ? selectProxy->window : focusWindow;
3119
3120 strcpy(commandBuffer,next);
3121 strcat(commandBuffer," SendToModule FvwmProxy Mark");
3122 if (next)
3123 SendFvwmPipe(fd,commandBuffer,w);
3124 }
3125 else if (StrEquals(token, "Show"))
3126 {
3127 StartProxies();
3128 }
3129 else if (StrEquals(token, "Hide"))
3130 {
3131 SelectProxy();
3132 }
3133 else if (StrEquals(token, "ShowToggle"))
3134 {
3135 if (are_windows_shown)
3136 {
3137 SelectProxy();
3138 }
3139 else
3140 {
3141 StartProxies();
3142 }
3143 }
3144 else if (StrEquals(token, "Abort"))
3145 {
3146 AbortProxies();
3147 }
3148 else if (StrEquals(token, "Mark"))
3149 {
3150 #if 0
3151 Window w;
3152
3153 if (next == NULL)
3154 {
3155 proxy = NULL;
3156 }
3157 else if (sscanf(next, "0x%x", (int *)&w) < 1)
3158 {
3159 proxy = NULL;
3160 }
3161 else
3162 #endif
3163 {
3164 focusWindow=bh->w;
3165 proxy = FindProxy(bh->w);
3166 }
3167 MarkProxy(proxy);
3168 }
3169 else if (StrEquals(token, "Resolve"))
3170 {
3171 waiting_to_config=0;
3172 pending_do=0;
3173 ResolvePendingWindows();
3174 reshuffle=1;
3175 }
3176 else if (StrEquals(token, "Stamp"))
3177 {
3178 token = PeekToken(message, &next);
3179 sscanf(next,"%d%d%d%d",&x,&y,&w,&h);
3180
3181 waiting_to_stamp=0;
3182 proxy = FindProxy(bh->w);
3183 if(proxy && w && h)
3184 {
3185 StoreStamp(bh->w,x,y,w,h);
3186 }
3187 reshuffle=1;
3188 }
3189 else if (StrEquals(token, "Undo"))
3190 {
3191 UndoStamp();
3192 reshuffle=1;
3193 }
3194 else if (StrEquals(token, "Redo"))
3195 {
3196 RedoStamp();
3197 reshuffle=1;
3198 }
3199 else if (StrEquals(token, "PrevIsolated"))
3200 {
3201 RotateIsolated(FindProxy(bh->w),-1);
3202 }
3203 else if (StrEquals(token, "NextIsolated"))
3204 {
3205 RotateIsolated(FindProxy(bh->w),1);
3206 }
3207 else if (StrEquals(token, "SoftToggle"))
3208 {
3209 proxy = FindProxy(bh->w);
3210 if(proxy)
3211 {
3212 proxy->flags.is_soft= proxy->group?
3213 !proxy->flags.is_soft: 0;
3214 isolate_check=1;
3215
3216 DrawProxyBackground(proxy);
3217 DrawProxy(proxy);
3218 }
3219 }
3220 else if (StrEquals(token, "IsolateToggle"))
3221 {
3222 proxy = FindProxy(bh->w);
3223 if(proxy)
3224 {
3225 proxy->flags.is_isolated= proxy->group?
3226 !proxy->flags.is_isolated: 0;
3227 IsolateGroup(proxy,proxy->flags.is_isolated);
3228 isolate_check=1;
3229
3230 DrawProxyBackground(proxy);
3231 DrawProxy(proxy);
3232 reshuffle=1;
3233 }
3234 }
3235 if(isolate_check)
3236 {
3237 IsolateCheck(proxy,0);
3238 }
3239 if(reshuffle)
3240 {
3241 /* windows may have moved, so update proxy windows */
3242 if (are_windows_shown)
3243 {
3244 ReshuffleWindows();
3245 }
3246 }
3247 break;
3248 }
3249 case M_CONFIG_INFO:
3250 {
3251 char *tline, *token;
3252
3253 tline = (char*)&(body[3]);
3254 token = PeekToken(tline, &tline);
3255 if (StrEquals(token, "Colorset"))
3256 {
3257 int cset;
3258 cset = LoadColorset(tline);
3259 change_cset(cset);
3260 }
3261 break;
3262 }
3263 }
3264
3265 return;
3266 }
3267
3268 static int My_XNextEvent(Display *dpy,XEvent *event)
3269 {
3270 fd_set in_fdset;
3271
3272 struct timeval timevalue,*timeout=&timevalue;
3273 timevalue.tv_sec = 0;
3274 timevalue.tv_usec = 100000;
3275
3276 if (FPending(dpy))
3277 {
3278 FNextEvent(dpy,event);
3279 return 1;
3280 }
3281
3282 FD_ZERO(&in_fdset);
3283 FD_SET(x_fd,&in_fdset);
3284 FD_SET(fd[1],&in_fdset);
3285
3286 if ( fvwmSelect(fd_width, &in_fdset, 0, 0, timeout) > 0)
3287 {
3288 if (FD_ISSET(x_fd, &in_fdset))
3289 {
3290 if (FPending(dpy))
3291 {
3292 FNextEvent(dpy,event);
3293 return 1;
3294 }
3295 }
3296
3297 if (FD_ISSET(fd[1], &in_fdset))
3298 {
3299 FvwmPacket* packet = ReadFvwmPacket(fd[1]);
3300 if (!packet)
3301 {
3302 exit(0);
3303 }
3304
3305 ProcessMessage(packet);
3306 }
3307 }
3308
3309 return 0;
3310 }
3311
3312 static void DispatchEvent(XEvent *pEvent)
3313 {
3314 Window window=pEvent->xany.window;
3315 ProxyWindow *proxy;
3316 int dx,dy;
3317
3318 switch(pEvent->xany.type)
3319 {
3320 case Expose:
3321 proxy = FindProxy(window);
3322 if (proxy != NULL)
3323 {
3324 DrawWindow(
3325 proxy, pEvent->xexpose.x, pEvent->xexpose.y,
3326 pEvent->xexpose.width, pEvent->xexpose.height);
3327 }
3328 break;
3329 case ButtonPress:
3330 proxy = FindProxy(window);
3331 if (proxy)
3332 {
3333 int button=pEvent->xbutton.button;
3334 int wx=pEvent->xbutton.x;
3335 int wy=pEvent->xbutton.y;
3336 if (button >= 1 &&
3337 button <= NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
3338 {
3339 if(wy < slotSpace+slotHeight)
3340 {
3341 int index=(wx-slotSpace)/
3342 (slotWidth+slotSpace)+1;
3343 int group=index-groupSlot+1;
3344
3345 if(index<numSlots)
3346 {
3347 char* action=slot_action_list[
3348 button-1][index];
3349 if(action)
3350 {
3351 SendFvwmPipe(fd,action,
3352 proxy->window);
3353 }
3354 }
3355 if(group && group<=groupCount)
3356 {
3357 SetGroup(proxy,
3358 proxy->group==group?
3359 0: group);
3360 DrawProxyBackground(proxy);
3361 DrawProxy(proxy);
3362 }
3363 }
3364 else
3365 {
3366 SendFvwmPipe(fd,
3367 action_list[PROXY_ACTION_CLICK
3368 + button-1],
3369 proxy->window);
3370 }
3371 }
3372 }
3373 mousex=pEvent->xbutton.x_root;
3374 mousey=pEvent->xbutton.y_root;
3375 break;
3376 case MotionNotify:
3377 proxy = FindProxy(window);
3378 dx=pEvent->xbutton.x_root-mousex;
3379 dy=pEvent->xbutton.y_root-mousey;
3380 if (proxy && proxyMove)
3381 {
3382 sprintf(commandBuffer,"Silent Move w+%dp w+%dp",dx,dy);
3383 send_command_to_fvwm(commandBuffer,proxy->window);
3384 }
3385
3386 mousex=pEvent->xbutton.x_root;
3387 mousey=pEvent->xbutton.y_root;
3388 break;
3389 case EnterNotify:
3390 proxy = FindProxy(pEvent->xcrossing.window);
3391 if (pEvent->xcrossing.mode == NotifyNormal)
3392 {
3393 MarkProxy(proxy);
3394 enterProxy = proxy;
3395 }
3396 else if (pEvent->xcrossing.mode == NotifyUngrab &&
3397 proxy != NULL && proxy != selectProxy &&
3398 proxy != enterProxy)
3399 {
3400 MarkProxy(proxy);
3401 enterProxy = proxy;
3402 }
3403 break;
3404 default:
3405 fprintf(stderr, "Unrecognized XEvent %d\n", pEvent->xany.type);
3406 break;
3407 }
3408
3409 return;
3410 }
3411
3412 static void Loop(int *fd)
3413 {
3414 XEvent event;
3415 long result;
3416
3417 while (1)
3418 {
3419 if ((result=My_XNextEvent(dpy,&event))==1)
3420 {
3421 DispatchEvent(&event);
3422 }
3423
3424 #if PROXY_KEY_POLLING
3425 if(are_windows_shown && watching_modifiers)
3426 {
3427 unsigned int mask_return=GetModifiers();
3428 if(!(mask_return&watched_modifiers))
3429 {
3430 watching_modifiers=0;
3431 send_command_to_fvwm(
3432 action_list
3433 [PROXY_ACTION_MODIFIER_RELEASE],
3434 None);
3435 }
3436 }
3437 #endif
3438 }
3439 }
3440
3441 /* ---------------------------- interface functions ------------------------- */
3442
3443 int main(int argc, char **argv)
3444 {
3445 char *titles[1];
3446
3447 if (argc < 6)
3448 {
3449 fprintf(
3450 stderr,
3451 "FvwmProxy should only be executed by fvwm!\n");
3452 exit(1);
3453 }
3454
3455 FlocaleInit(LC_CTYPE, "", "", "FvwmProxy");
3456 MyName = GetFileNameFromPath(argv[0]);
3457
3458 fd[0] = atoi(argv[1]);
3459 fd[1] = atoi(argv[2]);
3460
3461 originalXIOErrorHandler=XSetIOErrorHandler(myXIOErrorHandler);
3462 originalXErrorHandler=XSetErrorHandler(myXErrorHandler);
3463
3464 if (!(dpy=XOpenDisplay(NULL)))
3465 {
3466 fprintf(stderr,"can't open display\n");
3467 exit (1);
3468 }
3469 titles[0]="FvwmProxy";
3470 if (XStringListToTextProperty(titles,1,&windowName) == 0)
3471 {
3472 fprintf(stderr,"Proxy_CreateBar() could not allocate space"
3473 " for window title");
3474 }
3475
3476 flib_init_graphics(dpy);
3477 FlocaleAllocateWinString(&FwinString);
3478 screen = DefaultScreen(dpy);
3479 rootWindow = RootWindow(dpy,screen);
3480 xgcv.plane_mask=AllPlanes;
3481 miniIconGC=fvwmlib_XCreateGC(dpy,rootWindow,GCPlaneMask,&xgcv);
3482 fg_gc = fvwmlib_XCreateGC(dpy,rootWindow,GCPlaneMask,&xgcv);
3483 hi_gc = fvwmlib_XCreateGC(dpy,rootWindow,GCPlaneMask,&xgcv);
3484 sh_gc = fvwmlib_XCreateGC(dpy,rootWindow,GCPlaneMask,&xgcv);
3485
3486 x_fd = XConnectionNumber(dpy);
3487 fd_width = GetFdWidth();
3488
3489 SetMessageMask(
3490 fd, M_STRING| M_RAISE_WINDOW| M_LOWER_WINDOW|
3491 M_CONFIGURE_WINDOW| M_ADD_WINDOW| M_FOCUS_CHANGE|
3492 M_DESTROY_WINDOW| M_NEW_DESK| M_NEW_PAGE| M_ICON_NAME|
3493 M_WINDOW_NAME| M_MINI_ICON| M_ICONIFY| M_DEICONIFY|
3494 M_CONFIG_INFO| M_END_CONFIG_INFO);
3495
3496 if (parse_options() == False)
3497 exit(1);
3498 stampQueue=(GeometryStamp*)safemalloc(
3499 sizeof(GeometryStamp)*stampLimit);
3500 if ((Ffont = FlocaleLoadFont(dpy, font_name, MyName)) == NULL)
3501 {
3502 fprintf(stderr,"%s: Couldn't load font \"%s\". Exiting!\n",
3503 MyName, font_name);
3504 exit(1);
3505 }
3506 if (Ffont->font != NULL)
3507 {
3508 XSetFont(dpy,fg_gc,Ffont->font->fid);
3509 }
3510 Ffont_small=NULL;
3511 if(small_font_name)
3512 {
3513 if((Ffont_small =
3514 FlocaleLoadFont(dpy, small_font_name, MyName)) == NULL)
3515 {
3516 fprintf(stderr,
3517 "%s: Couldn't load small font \"%s\"\n",
3518 MyName, small_font_name);
3519 }
3520 }
3521 if (Ffont_small != NULL && Ffont_small->font != NULL)
3522 {
3523 XSetFont(dpy,hi_gc,Ffont_small->font->fid);
3524 }
3525 SendInfo(fd,"Send_WindowList",0);
3526 SendFinishedStartupNotification(fd);
3527 Loop(fd);
3528
3529 free(stampQueue);
3530 return 0;
3531 }
CVS import of FVWM to Git.