?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix ExplainWindowPlacement when using "NoUSPosition" style.
[fvwm.git] / fvwm / builtins.c
blob39178dc81bc2532df61fc14a4115b58dfa9f7460
1 /* -*-c-*- */
2 /* This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17 /*
18 * This module is all original code
19 * by Rob Nation
20 * Copyright 1993, Robert Nation
21 * You may use this code for any purpose, as long as the original
22 * copyright remains in the source code and all documentation
23 */
24
25 /* ---------------------------- included header files ---------------------- */
26
27 #include "config.h"
28
29 #include <stdio.h>
30 #include <unistd.h>
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <fcntl.h>
34 #include <errno.h>
35 #include <X11/keysym.h>
36
37 #include "libs/fvwmlib.h"
38 #include "libs/fvwmsignal.h"
39 #include "libs/setpgrp.h"
40 #include "libs/Grab.h"
41 #include "libs/Parse.h"
42 #include "libs/ColorUtils.h"
43 #include "libs/Graphics.h"
44 #include "libs/wild.h"
45 #include "libs/envvar.h"
46 #include "libs/ClientMsg.h"
47 #include "libs/Picture.h"
48 #include "libs/PictureUtils.h"
49 #include "libs/FGettext.h"
50 #include "libs/charmap.h"
51 #include "libs/wcontext.h"
52 #include "libs/Flocale.h"
53 #include "libs/Ficonv.h"
54 #include "fvwm.h"
55 #include "externs.h"
56 #include "colorset.h"
57 #include "bindings.h"
58 #include "misc.h"
59 #include "cursor.h"
60 #include "functions.h"
61 #include "commands.h"
62 #include "screen.h"
63 #include "builtins.h"
64 #include "module_interface.h"
65 #include "borders.h"
66 #include "frame.h"
67 #include "events.h"
68 #include "ewmh.h"
69 #include "virtual.h"
70 #include "decorations.h"
71 #include "add_window.h"
72 #include "update.h"
73 #include "style.h"
74 #include "move_resize.h"
75 #include "menus.h"
76 #ifdef HAVE_STROKE
77 #include "stroke.h"
78 #endif /* HAVE_STROKE */
79
80 /* ---------------------------- local definitions -------------------------- */
81
82 /* ---------------------------- local macros ------------------------------- */
83
84 /* ---------------------------- imports ------------------------------------ */
85
86 extern float rgpctMovementDefault[32];
87 extern int cpctMovementDefault;
88 extern int cmsDelayDefault;
89
90 /* ---------------------------- included code files ------------------------ */
91
92 /* ---------------------------- local types -------------------------------- */
93 typedef enum {FakeMouseEvent, FakeKeyEvent} FakeEventType;
94 /* ---------------------------- forward declarations ----------------------- */
95
96 /* ---------------------------- local variables ---------------------------- */
97
98 static char *exec_shell_name="/bin/sh";
99
100 /* button state strings must match the enumerated states */
101 static char *button_states[BS_MaxButtonStateName + 1] =
102 {
103 "ActiveUp",
104 "ActiveDown",
105 "InactiveUp",
106 "InactiveDown",
107 "ToggledActiveUp",
108 "ToggledActiveDown",
109 "ToggledInactiveUp",
110 "ToggledInactiveDown",
111 "Active",
112 "Inactive",
113 "ToggledActive",
114 "ToggledInactive",
115 "AllNormal",
116 "AllToggled",
117 "AllActive",
118 "AllInactive",
119 "AllUp",
120 "AllDown",
121 "AllActiveUp",
122 "AllActiveDown",
123 "AllInactiveUp",
124 "AllInactiveDown",
125 NULL
126 };
127
128 /* ---------------------------- exported variables (globals) --------------- */
129
130 char *ModulePath = FVWM_MODULEDIR;
131 int moduleTimeout = DEFAULT_MODULE_TIMEOUT;
132
133 /* ---------------------------- local functions ---------------------------- */
134
135 /** Prepend rather than replace the image path.
136 Used for obsolete PixmapPath and IconPath **/
137 static void obsolete_imagepaths( const char* pre_path )
138 {
139 char* tmp = stripcpy( pre_path );
140 char* path = alloca(strlen( tmp ) + strlen(PictureGetImagePath()) + 2 );
141
142 strcpy( path, tmp );
143 free( tmp );
144
145 strcat( path, ":" );
146 strcat( path, PictureGetImagePath() );
147
148 PictureSetImagePath( path );
149
150 return;
151 }
152
153 /*
154 *
155 * Reads a title button description (veliaa@rpi.edu)
156 *
157 */
158 static char *ReadTitleButton(
159 char *s, TitleButton *tb, Boolean append, int button)
160 {
161 char *end = NULL;
162 char *spec;
163 char *t;
164 int i;
165 int bs;
166 int bs_start, bs_end;
167 int pstyle = 0;
168 DecorFace tmpdf;
169
170 Bool multiple;
171 int use_mask = 0;
172 int set_mask = 0;
173
174 s = SkipSpaces(s, NULL, 0);
175 t = GetNextTokenIndex(s, button_states, 0, &bs);
176 if (bs != BS_All)
177 {
178 s = SkipSpaces(t, NULL, 0);
179 }
180
181 if (bs == BS_All)
182 {
183 use_mask = 0;
184 set_mask = 0;
185 }
186 else if (bs == BS_Active)
187 {
188 use_mask = BS_MASK_INACTIVE | BS_MASK_TOGGLED;
189 set_mask = 0;
190 }
191 else if (bs == BS_Inactive)
192 {
193 use_mask = BS_MASK_INACTIVE | BS_MASK_TOGGLED;
194 set_mask = BS_MASK_INACTIVE;
195 }
196 else if (bs == BS_ToggledActive)
197 {
198 use_mask = BS_MASK_INACTIVE | BS_MASK_TOGGLED;
199 set_mask = BS_MASK_TOGGLED;
200 }
201 else if (bs == BS_ToggledInactive)
202 {
203 use_mask = BS_MASK_INACTIVE | BS_MASK_TOGGLED;
204 set_mask = BS_MASK_INACTIVE | BS_MASK_TOGGLED;
205 }
206 else if (bs == BS_AllNormal)
207 {
208 use_mask = BS_MASK_TOGGLED;
209 set_mask = 0;
210 }
211 else if (bs == BS_AllToggled)
212 {
213 use_mask = BS_MASK_TOGGLED;
214 set_mask = BS_MASK_TOGGLED;
215 }
216 else if (bs == BS_AllActive)
217 {
218 use_mask = BS_MASK_INACTIVE;
219 set_mask = 0;
220 }
221 else if (bs == BS_AllInactive)
222 {
223 use_mask = BS_MASK_INACTIVE;
224 set_mask = BS_MASK_INACTIVE;
225 }
226 else if (bs == BS_AllUp)
227 {
228 use_mask = BS_MASK_DOWN;
229 set_mask = 0;
230 }
231 else if (bs == BS_AllDown)
232 {
233 use_mask = BS_MASK_DOWN;
234 set_mask = BS_MASK_DOWN;
235 }
236 else if (bs == BS_AllActiveUp)
237 {
238 use_mask = BS_MASK_INACTIVE | BS_MASK_DOWN;
239 set_mask = 0;
240 }
241 else if (bs == BS_AllActiveDown)
242 {
243 use_mask = BS_MASK_INACTIVE | BS_MASK_DOWN;
244 set_mask = BS_MASK_DOWN;
245 }
246 else if (bs == BS_AllInactiveUp)
247 {
248 use_mask = BS_MASK_INACTIVE | BS_MASK_DOWN;
249 set_mask = BS_MASK_INACTIVE;
250 }
251 else if (bs == BS_AllInactiveDown)
252 {
253 use_mask = BS_MASK_INACTIVE | BS_MASK_DOWN;
254 set_mask = BS_MASK_INACTIVE | BS_MASK_DOWN;
255 }
256
257 if ((bs & BS_MaxButtonStateMask) == bs)
258 {
259 multiple = False;
260 bs_start = bs;
261 bs_end = bs;
262 }
263 else
264 {
265 multiple = True;
266 bs_start = 0;
267 bs_end = BS_MaxButtonState - 1;
268 for (i = bs_start; (i & use_mask) != set_mask && i <= bs_end;
269 i++)
270 {
271 bs_start++;
272 }
273 }
274
275 if (*s == '(')
276 {
277 int len;
278 pstyle = 1;
279 if (!(end = strchr(++s, ')')))
280 {
281 fvwm_msg(
282 ERR, "ReadTitleButton",
283 "missing parenthesis: %s", s);
284 return NULL;
285 }
286 s = SkipSpaces(s, NULL, 0);
287 len = end - s + 1;
288 spec = safemalloc(len);
289 strncpy(spec, s, len - 1);
290 spec[len - 1] = 0;
291 }
292 else
293 {
294 spec = s;
295 }
296
297 spec = SkipSpaces(spec, NULL, 0);
298 /* setup temporary in case button read fails */
299 memset(&tmpdf, 0, sizeof(DecorFace));
300 DFS_FACE_TYPE(tmpdf.style) = SimpleButton;
301
302 if (strncmp(spec, "--", 2) == 0)
303 {
304 /* only change flags */
305 Bool verbose = True;
306 for (i = bs_start; i <= bs_end; ++i)
307 {
308 if (multiple && (i & use_mask) != set_mask)
309 {
310 continue;
311 }
312 ReadDecorFace(spec, &TB_STATE(*tb)[i], button, verbose);
313 verbose = False;
314 }
315 }
316 else if (ReadDecorFace(spec, &tmpdf, button, True))
317 {
318 if (append)
319 {
320 DecorFace *head = &TB_STATE(*tb)[bs_start];
321 DecorFace *tail = head;
322 DecorFace *next;
323
324 while (tail->next)
325 {
326 tail = tail->next;
327 }
328 tail->next = (DecorFace *)safemalloc(sizeof(DecorFace));
329 memcpy(tail->next, &tmpdf, sizeof(DecorFace));
330 if (DFS_FACE_TYPE(tail->next->style) == VectorButton &&
331 DFS_FACE_TYPE((&TB_STATE(*tb)[bs_start])->style) ==
332 DefaultVectorButton)
333 {
334 /* override the default vector style */
335 memcpy(
336 &tail->next->style, &head->style,
337 sizeof(DecorFaceStyle));
338 DFS_FACE_TYPE(tail->next->style) = VectorButton;
339 next = head->next;
340 head->next = NULL;
341 FreeDecorFace(dpy, head);
342 memcpy(head, next, sizeof(DecorFace));
343 free(next);
344 }
345 for (i = bs_start + 1; i <= bs_end; ++i)
346 {
347 if (multiple && (i & use_mask) != set_mask)
348 {
349 continue;
350 }
351 head = &TB_STATE(*tb)[i];
352 tail = head;
353 while (tail->next)
354 {
355 tail = tail->next;
356 }
357 tail->next = (DecorFace *)safemalloc(
358 sizeof(DecorFace));
359 memset(
360 &DFS_FLAGS(tail->next->style), 0,
361 sizeof(DFS_FLAGS(tail->next->style)));
362 DFS_FACE_TYPE(tail->next->style) =
363 SimpleButton;
364 tail->next->next = NULL;
365 ReadDecorFace(spec, tail->next, button, False);
366 if (DFS_FACE_TYPE(tail->next->style) ==
367 VectorButton &&
368 DFS_FACE_TYPE((&TB_STATE(*tb)[i])->style) ==
369 DefaultVectorButton)
370 {
371 /* override the default vector style */
372 memcpy(
373 &tail->next->style,
374 &head->style,
375 sizeof(DecorFaceStyle));
376 DFS_FACE_TYPE(tail->next->style) =
377 VectorButton;
378 next = head->next;
379 head->next = NULL;
380 FreeDecorFace(dpy, head);
381 memcpy(head, next, sizeof(DecorFace));
382 free(next);
383 }
384 }
385 }
386 else
387 {
388 FreeDecorFace(dpy, &TB_STATE(*tb)[bs_start]);
389 memcpy(
390 &(TB_STATE(*tb)[bs_start]), &tmpdf,
391 sizeof(DecorFace));
392 for (i = bs_start + 1; i <= bs_end; ++i)
393 {
394 if (multiple && (i & use_mask) != set_mask)
395 {
396 continue;
397 }
398 ReadDecorFace(
399 spec, &TB_STATE(*tb)[i], button, False);
400 }
401 }
402 }
403 if (pstyle)
404 {
405 free(spec);
406 end++;
407 end = SkipSpaces(end, NULL, 0);
408 }
409
410 return end;
411 }
412
413 /* Remove the given decor from all windows */
414 static void __remove_window_decors(F_CMD_ARGS, FvwmDecor *d)
415 {
416 const exec_context_t *exc2;
417 exec_context_changes_t ecc;
418 FvwmWindow *t;
419
420 for (t = Scr.FvwmRoot.next; t; t = t->next)
421 {
422 if (t->decor == d)
423 {
424 /* remove the extra title height now because we delete
425 * the current decor before calling ChangeDecor(). */
426 t->g.frame.height -= t->decor->title_height;
427 t->decor = NULL;
428 ecc.w.fw = t;
429 ecc.w.wcontext = C_WINDOW;
430 exc2 = exc_clone_context(
431 exc, &ecc, ECC_FW | ECC_WCONTEXT);
432 execute_function(
433 cond_rc, exc2, "ChangeDecor Default", 0);
434 exc_destroy_context(exc2);
435 }
436 }
437
438 return;
439 }
440
441 static void do_title_style(F_CMD_ARGS, Bool do_add)
442 {
443 char *parm;
444 char *prev;
445 #ifdef USEDECOR
446 FvwmDecor *decor = Scr.cur_decor ? Scr.cur_decor : &Scr.DefaultDecor;
447 #else
448 FvwmDecor *decor = &Scr.DefaultDecor;
449 #endif
450
451 Scr.flags.do_need_window_update = 1;
452 decor->flags.has_changed = 1;
453 decor->titlebar.flags.has_changed = 1;
454
455 for (prev = action ; (parm = PeekToken(action, &action)); prev = action)
456 {
457 if (!do_add && StrEquals(parm,"centered"))
458 {
459 TB_JUSTIFICATION(decor->titlebar) = JUST_CENTER;
460 }
461 else if (!do_add && StrEquals(parm,"leftjustified"))
462 {
463 TB_JUSTIFICATION(decor->titlebar) = JUST_LEFT;
464 }
465 else if (!do_add && StrEquals(parm,"rightjustified"))
466 {
467 TB_JUSTIFICATION(decor->titlebar) = JUST_RIGHT;
468 }
469 else if (!do_add && StrEquals(parm,"height"))
470 {
471 int height = 0;
472 int next = 0;
473
474 if (!action ||
475 sscanf(action, "%d%n", &height, &next) <= 0 ||
476 height < MIN_FONT_HEIGHT ||
477 height > MAX_FONT_HEIGHT)
478 {
479 if (height != 0)
480 {
481 fvwm_msg(ERR, "do_title_style",
482 "bad height argument (height"
483 " must be from 5 to 256)");
484 height = 0;
485 }
486 }
487 if (decor->title_height != height ||
488 decor->min_title_height != 0)
489 {
490 decor->title_height = height;
491 decor->min_title_height = 0;
492 decor->flags.has_title_height_changed = 1;
493 }
494 if (action)
495 action += next;
496 }
497 else if (!do_add && StrEquals(parm,"MinHeight"))
498 {
499 int height = 0;
500 int next = 0;
501
502 if (!action ||
503 sscanf(action, "%d%n", &height, &next) <= 0 ||
504 height < MIN_FONT_HEIGHT ||
505 height > MAX_FONT_HEIGHT)
506 {
507 if (height < MIN_FONT_HEIGHT)
508 height = MIN_FONT_HEIGHT;
509 else if (height > MAX_FONT_HEIGHT)
510 height = 0;
511 }
512 if (decor->min_title_height != height)
513 {
514 decor->title_height = 0;
515 decor->min_title_height = height;
516 decor->flags.has_title_height_changed = 1;
517 }
518 if (action)
519 action += next;
520 }
521 else
522 {
523 action = ReadTitleButton(
524 prev, &decor->titlebar, do_add, -1);
525 }
526 }
527
528 return;
529 }
530
531 /*
532 *
533 * Reads a multi-pixmap titlebar config. (tril@igs.net)
534 *
535 */
536 static char *ReadMultiPixmapDecor(char *s, DecorFace *df)
537 {
538 static char *pm_names[TBMP_NUM_PIXMAPS+1] =
539 {
540 "Main",
541 "LeftMain",
542 "RightMain",
543 "LeftButtons",
544 "RightButtons",
545 "UnderText",
546 "LeftOfText",
547 "RightOfText",
548 "LeftEnd",
549 "RightEnd",
550 "Buttons",
551 NULL
552 };
553 FvwmPicture **pm;
554 FvwmAcs *acs;
555 Pixel *pixels;
556 char *token;
557 Bool stretched;
558 Bool load_pixmap = False;
559 int pm_id, i = 0;
560 FvwmPictureAttributes fpa;
561
562 df->style.face_type = MultiPixmap;
563 df->u.mp.pixmaps = pm =
564 (FvwmPicture**)safecalloc(
565 TBMP_NUM_PIXMAPS, sizeof(FvwmPicture*));
566 df->u.mp.acs = acs =
567 (FvwmAcs *)safemalloc(TBMP_NUM_PIXMAPS * sizeof(FvwmAcs));
568 df->u.mp.pixels = pixels =
569 (Pixel *)safemalloc(TBMP_NUM_PIXMAPS * sizeof(Pixel));
570 for(i=0; i < TBMP_NUM_PIXMAPS; i++)
571 {
572 acs[i].cs = -1;
573 acs[i].alpha_percent = 100;
574 }
575 s = GetNextTokenIndex(s, pm_names, 0, &pm_id);
576 while (pm_id >= 0)
577 {
578 stretched = False;
579 load_pixmap = False;
580 s = DoPeekToken(s, &token, ",()", NULL, NULL);
581 if (StrEquals(token, "stretched"))
582 {
583 stretched = True;
584 s = DoPeekToken(s, &token, ",", NULL, NULL);
585 }
586 else if (StrEquals(token, "tiled"))
587 {
588 s = DoPeekToken(s, &token, ",", NULL, NULL);
589 }
590 if (!token)
591 {
592 break;
593 }
594 if (pm[pm_id] || acs[pm_id].cs >= 0 ||
595 (df->u.mp.solid_flags & (1 << pm_id)))
596 {
597 fvwm_msg(WARN, "ReadMultiPixmapDecor",
598 "Ignoring: already-specified %s",
599 pm_names[i]);
600 continue;
601 }
602 if (stretched)
603 {
604 df->u.mp.stretch_flags |= (1 << pm_id);
605 }
606 if (strncasecmp (token, "Colorset", 8) == 0)
607 {
608 int val;
609 char *tmp;
610
611 tmp = DoPeekToken(s, &token, ",", NULL, NULL);
612 if (!GetIntegerArguments(token, NULL, &val, 1) ||
613 val < 0)
614 {
615 fvwm_msg(
616 ERR, "ReadMultiPixmapDecor",
617 "Colorset shoule take one or two "
618 "positive integers as argument");
619 }
620 else
621 {
622 acs[pm_id].cs = val;
623 alloc_colorset(val);
624 s = tmp;
625 tmp = DoPeekToken(s, &token, ",", NULL, NULL);
626 if (GetIntegerArguments(token, NULL, &val, 1))
627 {
628 acs[pm_id].alpha_percent =
629 max(0, min(100,val));
630 s = tmp;
631 }
632 }
633 }
634 else if (strncasecmp(token, "TiledPixmap", 11) == 0)
635 {
636 s = DoPeekToken(s, &token, ",", NULL, NULL);
637 load_pixmap = True;
638 }
639 else if (strncasecmp(token, "AdjustedPixmap", 14) == 0)
640 {
641 s = DoPeekToken(s, &token, ",", NULL, NULL);
642 load_pixmap = True;
643 df->u.mp.stretch_flags |= (1 << pm_id);
644 }
645 else if (strncasecmp(token, "Solid", 5) == 0)
646 {
647 s = DoPeekToken(s, &token, ",", NULL, NULL);
648 if (token)
649 {
650 df->u.mp.pixels[pm_id] = GetColor(token);
651 df->u.mp.solid_flags |= (1 << pm_id);
652 }
653 }
654 else
655 {
656 load_pixmap = True;
657 }
658 if (load_pixmap && token)
659 {
660 fpa.mask = (Pdepth <= 8)? FPAM_DITHER:0; /* ? */
661 pm[pm_id] = PCacheFvwmPicture(
662 dpy, Scr.NoFocusWin, NULL, token, fpa);
663 if (!pm[pm_id])
664 {
665 fvwm_msg(ERR, "ReadMultiPixmapDecor",
666 "Pixmap '%s' could not be loaded",
667 token);
668 }
669 }
670 if (pm_id == TBMP_BUTTONS)
671 {
672 if (pm[TBMP_LEFT_BUTTONS])
673 {
674 PDestroyFvwmPicture(dpy, pm[TBMP_LEFT_BUTTONS]);
675 }
676 if (pm[TBMP_RIGHT_BUTTONS])
677 {
678 PDestroyFvwmPicture(dpy, pm[TBMP_RIGHT_BUTTONS]);
679 }
680 df->u.mp.stretch_flags &= ~(1 << TBMP_LEFT_BUTTONS);
681 df->u.mp.stretch_flags &= ~(1 << TBMP_RIGHT_BUTTONS);
682 df->u.mp.solid_flags &= ~(1 << TBMP_LEFT_BUTTONS);
683 df->u.mp.solid_flags &= ~(1 << TBMP_RIGHT_BUTTONS);
684 if (pm[TBMP_BUTTONS])
685 {
686 pm[TBMP_LEFT_BUTTONS] =
687 PCloneFvwmPicture(pm[TBMP_BUTTONS]);
688 acs[TBMP_LEFT_BUTTONS].cs = -1;
689 pm[TBMP_RIGHT_BUTTONS] =
690 PCloneFvwmPicture(pm[TBMP_BUTTONS]);
691 acs[TBMP_RIGHT_BUTTONS].cs = -1;
692 }
693 else
694 {
695 pm[TBMP_RIGHT_BUTTONS] =
696 pm[TBMP_LEFT_BUTTONS] = NULL;
697 acs[TBMP_RIGHT_BUTTONS].cs =
698 acs[TBMP_LEFT_BUTTONS].cs =
699 acs[TBMP_BUTTONS].cs;
700 acs[TBMP_RIGHT_BUTTONS].alpha_percent =
701 acs[TBMP_LEFT_BUTTONS].alpha_percent =
702 acs[TBMP_BUTTONS].alpha_percent;
703 pixels[TBMP_LEFT_BUTTONS] =
704 pixels[TBMP_RIGHT_BUTTONS] =
705 pixels[TBMP_BUTTONS];
706 }
707 if (stretched)
708 {
709 df->u.mp.stretch_flags |=
710 (1 << TBMP_LEFT_BUTTONS) |
711 (1 << TBMP_RIGHT_BUTTONS);
712 }
713 if (df->u.mp.solid_flags & (1 << TBMP_BUTTONS))
714 {
715 df->u.mp.solid_flags |=
716 (1 << TBMP_LEFT_BUTTONS);
717 df->u.mp.solid_flags |=
718 (1 << TBMP_RIGHT_BUTTONS);
719 }
720 if (pm[TBMP_BUTTONS])
721 {
722 PDestroyFvwmPicture(dpy, pm[TBMP_BUTTONS]);
723 pm[TBMP_BUTTONS] = NULL;
724 }
725 acs[TBMP_BUTTONS].cs = -1;
726 df->u.mp.solid_flags &= ~(1 << TBMP_BUTTONS);
727 }
728 s = SkipSpaces(s, NULL, 0);
729 s = GetNextTokenIndex(s, pm_names, 0, &pm_id);
730 }
731
732 if (!(pm[TBMP_MAIN] || acs[TBMP_MAIN].cs >= 0 ||
733 (df->u.mp.solid_flags & TBMP_MAIN))
734 &&
735 !(pm[TBMP_LEFT_MAIN] || acs[TBMP_LEFT_MAIN].cs >= 0 ||
736 (df->u.mp.solid_flags & TBMP_LEFT_MAIN))
737 &&
738 !(pm[TBMP_RIGHT_MAIN] || acs[TBMP_RIGHT_MAIN].cs >= 0 ||
739 (df->u.mp.solid_flags & TBMP_RIGHT_MAIN)))
740 {
741 fvwm_msg(ERR, "ReadMultiPixmapDecor",
742 "No Main pixmap/colorset/solid found for TitleStyle "
743 "MultiPixmap (you must specify either Main, "
744 "or both LeftMain and RightMain)");
745 for (i=0; i < TBMP_NUM_PIXMAPS; i++)
746 {
747 if (pm[i])
748 {
749 PDestroyFvwmPicture(dpy, pm[i]);
750 }
751 else if (!!(df->u.mp.solid_flags & i))
752 {
753 PictureFreeColors(
754 dpy, Pcmap, &df->u.mp.pixels[i], 1, 0,
755 False);
756 }
757 }
758 free(pm);
759 free(acs);
760 free(pixels);
761 return NULL;
762 }
763
764 return s;
765 }
766
767 /*
768 *
769 * DestroyFvwmDecor -- frees all memory assocated with an FvwmDecor
770 * structure, but does not free the FvwmDecor itself
771 *
772 */
773 static void DestroyFvwmDecor(FvwmDecor *decor)
774 {
775 int i;
776 /* reset to default button set (frees allocated mem) */
777 DestroyAllButtons(decor);
778 for (i = 0; i < BS_MaxButtonState; ++i)
779 {
780 FreeDecorFace(dpy, &TB_STATE(decor->titlebar)[i]);
781 }
782 FreeDecorFace(dpy, &decor->BorderStyle.active);
783 FreeDecorFace(dpy, &decor->BorderStyle.inactive);
784 #ifdef USEDECOR
785 if (decor->tag)
786 {
787 free(decor->tag);
788 decor->tag = NULL;
789 }
790 #endif
791
792 return;
793 }
794
795 static void SetLayerButtonFlag(
796 int layer, int multi, int set, FvwmDecor *decor, TitleButton *tb)
797 {
798 int i;
799 int start = 0;
800 int add = 2;
801
802 if (multi)
803 {
804 if (multi == 2)
805 {
806 start = 1;
807 }
808 else if (multi == 3)
809 {
810 add = 1;
811 }
812 for (i = start; i < NUMBER_OF_TITLE_BUTTONS; i += add)
813 {
814 if (set)
815 {
816 TB_FLAGS(decor->buttons[i]).has_layer = 1;
817 TB_LAYER(decor->buttons[i]) = layer;
818 }
819 else
820 {
821 TB_FLAGS(decor->buttons[i]).has_layer = 0;
822 }
823 }
824 }
825 else
826 {
827 if (set)
828 {
829 TB_FLAGS(*tb).has_layer = 1;
830 TB_LAYER(*tb) = layer;
831 }
832 else
833 {
834 TB_FLAGS(*tb).has_layer = 0;
835 }
836 }
837
838 return;
839 }
840
841 /*
842 *
843 * Changes a button decoration style (changes by veliaa@rpi.edu)
844 *
845 */
846 static void SetMWMButtonFlag(
847 mwm_flags flag, int multi, int set, FvwmDecor *decor, TitleButton *tb)
848 {
849 int i;
850 int start = 0;
851 int add = 2;
852
853 if (multi)
854 {
855 if (multi == 2)
856 {
857 start = 1;
858 }
859 else if (multi == 3)
860 {
861 add = 1;
862 }
863 for (i = start; i < NUMBER_OF_TITLE_BUTTONS; i += add)
864 {
865 if (set)
866 {
867 TB_MWM_DECOR_FLAGS(decor->buttons[i]) |= flag;
868 }
869 else
870 {
871 TB_MWM_DECOR_FLAGS(decor->buttons[i]) &= ~flag;
872 }
873 }
874 }
875 else
876 {
877 if (set)
878 {
879 TB_MWM_DECOR_FLAGS(*tb) |= flag;
880 }
881 else
882 {
883 TB_MWM_DECOR_FLAGS(*tb) &= ~flag;
884 }
885 }
886
887 return;
888 }
889
890 static void do_button_style(F_CMD_ARGS, Bool do_add)
891 {
892 int i;
893 int multi = 0;
894 int button = 0;
895 int do_return;
896 char *text = NULL;
897 char *prev = NULL;
898 char *parm = NULL;
899 TitleButton *tb = NULL;
900 #ifdef USEDECOR
901 FvwmDecor *decor = Scr.cur_decor ? Scr.cur_decor : &Scr.DefaultDecor;
902 #else
903 FvwmDecor *decor = &Scr.DefaultDecor;
904 #endif
905
906 parm = PeekToken(action, &text);
907 if (parm && isdigit(*parm))
908 {
909 button = atoi(parm);
910 button = BUTTON_INDEX(button);
911 }
912
913 if (parm == NULL || button >= NUMBER_OF_TITLE_BUTTONS || button < 0)
914 {
915 fvwm_msg(
916 ERR, "ButtonStyle", "Bad button style (1) in line %s",
917 action);
918 return;
919 }
920
921 Scr.flags.do_need_window_update = 1;
922
923 do_return = 0;
924 if (!isdigit(*parm))
925 {
926 if (StrEquals(parm,"left"))
927 {
928 multi = 1; /* affect all left buttons */
929 }
930 else if (StrEquals(parm,"right"))
931 {
932 multi = 2; /* affect all right buttons */
933 }
934 else if (StrEquals(parm,"all"))
935 {
936 multi = 3; /* affect all buttons */
937 }
938 else
939 {
940 /* we're either resetting buttons or an invalid button
941 * set was specified */
942 if (StrEquals(parm,"reset"))
943 {
944 ResetAllButtons(decor);
945 }
946 else
947 {
948 fvwm_msg(
949 ERR, "ButtonStyle",
950 "Bad button style (2) in line %s",
951 action);
952 }
953 multi = 3;
954 do_return = 1;
955 }
956 }
957 /* mark button style and decor as changed */
958 decor->flags.has_changed = 1;
959 if (multi == 0)
960 {
961 /* a single button was specified */
962 tb = &decor->buttons[button];
963 TB_FLAGS(*tb).has_changed = 1;
964 }
965 else
966 {
967 for (i = 0; i < NUMBER_OF_TITLE_BUTTONS; ++i)
968 {
969 if (((multi & 1) && !(i & 1)) ||
970 ((multi & 2) && (i & 1)))
971 {
972 TB_FLAGS(decor->buttons[i]).has_changed = 1;
973 }
974 }
975 }
976 if (do_return == 1)
977 {
978 return;
979 }
980 for (prev = text; (parm = PeekToken(text, &text)); prev = text)
981 {
982 if (!do_add && strcmp(parm,"-") == 0)
983 {
984 char *tok;
985 text = GetNextToken(text, &tok);
986 while (tok)
987 {
988 int set = 1;
989 char *old_tok = NULL;
990
991 if (*tok == '!')
992 {
993 /* flag negate */
994 set = 0;
995 old_tok = tok;
996 tok++;
997 }
998 if (StrEquals(tok,"Clear"))
999 {
1000 if (multi)
1001 {
1002 for (i = 0;
1003 i < NUMBER_OF_TITLE_BUTTONS; ++i)
1004 {
1005 if (((multi & 1) &&
1006 !(i & 1)) ||
1007 ((multi & 2) &&
1008 (i & 1)))
1009 {
1010 TB_JUSTIFICATION(decor->buttons[i]) =
1011 (set) ? JUST_CENTER : JUST_RIGHT;
1012 memset(&TB_FLAGS(decor->buttons[i]), (set) ? 0 : 0xff,
1013 sizeof(TB_FLAGS(decor->buttons[i])));
1014 /* ? not very useful if set == 0 ? */
1015 }
1016 }
1017 }
1018 else
1019 {
1020 TB_JUSTIFICATION(*tb) = (set) ?
1021 JUST_CENTER :
1022 JUST_RIGHT;
1023 memset(&TB_FLAGS(*tb), (set) ?
1024 0 : 0xff,
1025 sizeof(TB_FLAGS(*tb)));
1026 /* ? not very useful if
1027 * set == 0 ? */
1028 }
1029 }
1030 else if (StrEquals(tok, "MWMDecorMenu"))
1031 {
1032 SetMWMButtonFlag(
1033 MWM_DECOR_MENU, multi, set,
1034 decor, tb);
1035 }
1036 else if (StrEquals(tok, "MWMDecorMin"))
1037 {
1038 SetMWMButtonFlag(
1039 MWM_DECOR_MINIMIZE, multi, set,
1040 decor, tb);
1041 }
1042 else if (StrEquals(tok, "MWMDecorMax"))
1043 {
1044 SetMWMButtonFlag(
1045 MWM_DECOR_MAXIMIZE, multi, set,
1046 decor, tb);
1047 }
1048 else if (StrEquals(tok, "MWMDecorShade"))
1049 {
1050 SetMWMButtonFlag(
1051 MWM_DECOR_SHADE, multi, set,
1052 decor, tb);
1053 }
1054 else if (StrEquals(tok, "MWMDecorStick"))
1055 {
1056 SetMWMButtonFlag(
1057 MWM_DECOR_STICK, multi, set,
1058 decor, tb);
1059 }
1060 else if (StrEquals(tok, "MwmDecorLayer"))
1061 {
1062 int layer, got_number;
1063 char *ltok;
1064 text = GetNextToken(text, &ltok);
1065 if (ltok)
1066 {
1067 got_number =
1068 (sscanf(ltok, "%d",
1069 &layer) == 1);
1070 free (ltok);
1071 }
1072 else
1073 {
1074 got_number = 0;
1075 }
1076 if (!ltok || !got_number)
1077 {
1078 fvwm_msg(ERR, "ButtonStyle",
1079 "could not read"
1080 " integer value for"
1081 " layer -- line: %s",
1082 text);
1083 }
1084 else
1085 {
1086 SetLayerButtonFlag(
1087 layer, multi, set,
1088 decor, tb);
1089 }
1090
1091 }
1092 else
1093 {
1094 fvwm_msg(ERR, "ButtonStyle",
1095 "unknown title button flag"
1096 " %s -- line: %s", tok, text);
1097 }
1098 if (set)
1099 {
1100 free(tok);
1101 }
1102 else
1103 {
1104 free(old_tok);
1105 }
1106 text = GetNextToken(text, &tok);
1107 }
1108 break;
1109 }
1110 else
1111 {
1112 if (multi)
1113 {
1114 for (i = 0; i < NUMBER_OF_TITLE_BUTTONS; ++i)
1115 {
1116 if (((multi & 1) && !(i & 1)) ||
1117 ((multi & 2) && (i & 1)))
1118 {
1119 text = ReadTitleButton(
1120 prev,
1121 &decor->buttons[i],
1122 do_add, i);
1123 }
1124 }
1125 }
1126 else if (!(text = ReadTitleButton(
1127 prev, tb, do_add, button)))
1128 {
1129 break;
1130 }
1131 }
1132 }
1133
1134 return;
1135 }
1136
1137 static
1138 int update_decorface_colorset(DecorFace *df, int cset)
1139 {
1140 DecorFace *tdf;
1141 int has_changed = 0;
1142
1143 for(tdf = df; tdf != NULL; tdf = tdf->next)
1144 {
1145 if (DFS_FACE_TYPE(tdf->style) == ColorsetButton &&
1146 tdf->u.acs.cs == cset)
1147 {
1148 tdf->flags.has_changed = 1;
1149 has_changed = 1;
1150 }
1151 else if (DFS_FACE_TYPE(tdf->style) == MultiPixmap)
1152 {
1153 int i;
1154
1155 for (i = 0; i < TBMP_NUM_PIXMAPS; i++)
1156 {
1157 if (tdf->u.mp.acs[i].cs == cset)
1158 {
1159 tdf->flags.has_changed = 1;
1160 has_changed = 1;
1161 }
1162 }
1163 }
1164 }
1165
1166 return has_changed;
1167 }
1168
1169 static
1170 int update_titlebutton_colorset(TitleButton *tb, int cset)
1171 {
1172 int i;
1173 int has_changed = 0;
1174
1175 for(i = 0; i < BS_MaxButtonState; i++)
1176 {
1177 tb->state[i].flags.has_changed =
1178 update_decorface_colorset(&(tb->state[i]), cset);
1179 has_changed |= tb->state[i].flags.has_changed;
1180 }
1181 return has_changed;
1182 }
1183
1184 static
1185 void update_decors_colorset(int cset)
1186 {
1187 int i;
1188 int has_changed;
1189 FvwmDecor *decor = &Scr.DefaultDecor;
1190
1191 #ifdef USEDECOR
1192 for(decor = &Scr.DefaultDecor; decor != NULL; decor = decor->next)
1193 #endif
1194 {
1195 has_changed = 0;
1196 for(i = 0; i < NUMBER_OF_TITLE_BUTTONS; i++)
1197 {
1198 decor->flags.has_changed |= update_titlebutton_colorset(
1199 &(decor->buttons[i]), cset);
1200 }
1201 decor->flags.has_changed |= update_titlebutton_colorset(
1202 &(decor->titlebar), cset);
1203 decor->flags.has_changed |= update_decorface_colorset(
1204 &(decor->BorderStyle.active), cset);
1205 decor->flags.has_changed |= update_decorface_colorset(
1206 &(decor->BorderStyle.inactive), cset);
1207 if (decor->flags.has_changed)
1208 {
1209 Scr.flags.do_need_window_update = 1;
1210 }
1211 }
1212 }
1213
1214 static Bool __parse_vector_line_one_coord(
1215 char **ret_action, int *pcoord, int *poff, char *action)
1216 {
1217 int offset;
1218 int n;
1219
1220 *ret_action = action;
1221 n = sscanf(action, "%d%n", pcoord, &offset);
1222 if (n < 1)
1223 {
1224 return False;
1225 }
1226 action += offset;
1227 /* check for offest */
1228 if (*action == '+' || *action == '-')
1229 {
1230 n = sscanf(action, "%dp%n", poff, &offset);
1231 if (n < 1)
1232 {
1233 return False;
1234 }
1235 if (*poff < -128)
1236 {
1237 *poff = -128;
1238 }
1239 else if (*poff > 127)
1240 {
1241 *poff = 127;
1242 }
1243 action += offset;
1244 }
1245 else
1246 {
1247 *poff = 0;
1248 }
1249 *ret_action = action;
1250
1251 return True;
1252 }
1253
1254 static Bool __parse_vector_line(
1255 char **ret_action, int *px, int *py, int *pxoff, int *pyoff, int *pc,
1256 char *action)
1257 {
1258 Bool is_valid = True;
1259 int offset;
1260 int n;
1261
1262 *ret_action = action;
1263 if (__parse_vector_line_one_coord(&action, px, pxoff, action) == False)
1264 {
1265 return False;
1266 }
1267 if (*action != 'x')
1268 {
1269 return False;
1270 }
1271 action++;
1272 if (__parse_vector_line_one_coord(&action, py, pyoff, action) == False)
1273 {
1274 return False;
1275 }
1276 if (*action != '@')
1277 {
1278 return False;
1279 }
1280 action++;
1281 /* read the line style */
1282 n = sscanf(action, "%d%n", pc, &offset);
1283 if (n < 1)
1284 {
1285 return False;
1286 }
1287 action += offset;
1288 *ret_action = action;
1289
1290 return is_valid;
1291 }
1292
1293 /* ---------------------------- interface functions ------------------------ */
1294
1295 void refresh_window(Window w, Bool window_update)
1296 {
1297 XSetWindowAttributes attributes;
1298 unsigned long valuemask;
1299
1300 valuemask = CWOverrideRedirect | CWBackingStore | CWSaveUnder |
1301 CWBackPixmap;
1302 attributes.override_redirect = True;
1303 attributes.save_under = False;
1304 attributes.background_pixmap = None;
1305 attributes.backing_store = NotUseful;
1306 w = XCreateWindow(
1307 dpy, w, 0, 0, Scr.MyDisplayWidth, Scr.MyDisplayHeight, 0,
1308 CopyFromParent, CopyFromParent, CopyFromParent, valuemask,
1309 &attributes);
1310 XMapWindow(dpy, w);
1311 if (Scr.flags.do_need_window_update && window_update)
1312 {
1313 flush_window_updates();
1314 }
1315 XDestroyWindow(dpy, w);
1316 XSync(dpy, 0);
1317 handle_all_expose();
1318
1319 return;
1320 }
1321
1322 void ApplyDefaultFontAndColors(void)
1323 {
1324 XGCValues gcv;
1325 unsigned long gcm;
1326 int cset = Scr.DefaultColorset;
1327
1328 /* make GC's */
1329 gcm = GCFunction|GCLineWidth|GCForeground|GCBackground;
1330 gcv.function = GXcopy;
1331 if (Scr.DefaultFont->font)
1332 {
1333 gcm |= GCFont;
1334 gcv.font = Scr.DefaultFont->font->fid;
1335 }
1336 gcv.line_width = 0;
1337 if (cset >= 0)
1338 {
1339 gcv.foreground = Colorset[cset].fg;
1340 gcv.background = Colorset[cset].bg;
1341 }
1342 else
1343 {
1344 gcv.foreground = Scr.StdFore;
1345 gcv.background = Scr.StdBack;
1346 }
1347 if (Scr.StdGC)
1348 {
1349 XChangeGC(dpy, Scr.StdGC, gcm, &gcv);
1350 }
1351 else
1352 {
1353 Scr.StdGC = fvwmlib_XCreateGC(dpy, Scr.NoFocusWin, gcm, &gcv);
1354 }
1355
1356 gcm = GCFunction|GCLineWidth|GCForeground;
1357 if (cset >= 0)
1358 {
1359 gcv.foreground = Colorset[cset].hilite;
1360 }
1361 else
1362 {
1363 gcv.foreground = Scr.StdHilite;
1364 }
1365 if (Scr.StdReliefGC)
1366 {
1367 XChangeGC(dpy, Scr.StdReliefGC, gcm, &gcv);
1368 }
1369 else
1370 {
1371 Scr.StdReliefGC = fvwmlib_XCreateGC(
1372 dpy, Scr.NoFocusWin, gcm, &gcv);
1373 }
1374 if (cset >= 0)
1375 {
1376 gcv.foreground = Colorset[cset].shadow;
1377 }
1378 else
1379 {
1380 gcv.foreground = Scr.StdShadow;
1381 }
1382 if (Scr.StdShadowGC)
1383 {
1384 XChangeGC(dpy, Scr.StdShadowGC, gcm, &gcv);
1385 }
1386 else
1387 {
1388 Scr.StdShadowGC = fvwmlib_XCreateGC(
1389 dpy, Scr.NoFocusWin, gcm, &gcv);
1390 }
1391 /* update the geometry window for move/resize */
1392 if (Scr.SizeWindow != None)
1393 {
1394 resize_geometry_window();
1395 }
1396 UpdateAllMenuStyles();
1397
1398 return;
1399 }
1400
1401 void FreeDecorFace(Display *dpy, DecorFace *df)
1402 {
1403 int i;
1404
1405 switch (DFS_FACE_TYPE(df->style))
1406 {
1407 case GradientButton:
1408 if (df->u.grad.d_pixels != NULL && df->u.grad.d_npixels)
1409 {
1410 PictureFreeColors(
1411 dpy, Pcmap, df->u.grad.d_pixels,
1412 df->u.grad.d_npixels, 0, False);
1413 free(df->u.grad.d_pixels);
1414 }
1415 else if (Pdepth <= 8 && df->u.grad.xcs != NULL &&
1416 df->u.grad.npixels > 0 && !df->u.grad.do_dither)
1417 {
1418 Pixel *p;
1419 int i;
1420
1421 p = (Pixel *)safemalloc(
1422 df->u.grad.npixels * sizeof(Pixel));
1423 for(i=0; i < df->u.grad.npixels; i++)
1424 {
1425 p[i] = df->u.grad.xcs[i].pixel;
1426 }
1427 PictureFreeColors(
1428 dpy, Pcmap, p, df->u.grad.npixels, 0, False);
1429 free(p);
1430 }
1431 if (df->u.grad.xcs != NULL)
1432 {
1433 free(df->u.grad.xcs);
1434 }
1435 break;
1436
1437 case PixmapButton:
1438 case TiledPixmapButton:
1439 case StretchedPixmapButton:
1440 case AdjustedPixmapButton:
1441 case ShrunkPixmapButton:
1442 if (df->u.p)
1443 {
1444 PDestroyFvwmPicture(dpy, df->u.p);
1445 }
1446 break;
1447
1448 case MultiPixmap:
1449 if (df->u.mp.pixmaps)
1450 {
1451 for (i = 0; i < TBMP_NUM_PIXMAPS; i++)
1452 {
1453 if (df->u.mp.pixmaps[i])
1454 {
1455 PDestroyFvwmPicture(
1456 dpy, df->u.mp.pixmaps[i]);
1457 }
1458 else if (!!(df->u.mp.solid_flags & i))
1459 {
1460 PictureFreeColors(
1461 dpy, Pcmap, &df->u.mp.pixels[i],
1462 1, 0, False);
1463 }
1464 }
1465 free(df->u.mp.pixmaps);
1466 }
1467 if (df->u.mp.acs)
1468 {
1469 free(df->u.mp.acs);
1470 }
1471 if (df->u.mp.pixels)
1472 {
1473 free(df->u.mp.pixels);
1474 }
1475 break;
1476 case VectorButton:
1477 case DefaultVectorButton:
1478 if (df->u.vector.x)
1479 {
1480 free (df->u.vector.x);
1481 }
1482 if (df->u.vector.y)
1483 {
1484 free (df->u.vector.y);
1485 }
1486 /* free offsets for coord */
1487 if (df->u.vector.xoff)
1488 {
1489 free(df->u.vector.xoff);
1490 }
1491 if (df->u.vector.yoff)
1492 {
1493 free(df->u.vector.yoff);
1494 }
1495 if (df->u.vector.c)
1496 {
1497 free (df->u.vector.c);
1498 }
1499 break;
1500 default:
1501 /* see below */
1502 break;
1503 }
1504 /* delete any compound styles */
1505 if (df->next)
1506 {
1507 FreeDecorFace(dpy, df->next);
1508 free(df->next);
1509 }
1510 df->next = NULL;
1511 memset(&df->style, 0, sizeof(df->style));
1512 memset(&df->u, 0, sizeof(df->u));
1513 DFS_FACE_TYPE(df->style) = SimpleButton;
1514
1515 return;
1516 }
1517
1518 /*
1519 *
1520 * Reads a button face line into a structure (veliaa@rpi.edu)
1521 *
1522 */
1523 Bool ReadDecorFace(char *s, DecorFace *df, int button, int verbose)
1524 {
1525 int offset;
1526 char style[256], *file;
1527 char *action = s;
1528
1529 /* some variants of scanf do not increase the assign count when %n is
1530 * used, so a return value of 1 is no error. */
1531 if (sscanf(s, "%255s%n", style, &offset) < 1)
1532 {
1533 if (verbose)
1534 {
1535 fvwm_msg(ERR, "ReadDecorFace", "error in face `%s'", s);
1536 }
1537 return False;
1538 }
1539 style[255] = 0;
1540
1541 if (strncasecmp(style, "--", 2) != 0)
1542 {
1543 s += offset;
1544
1545 FreeDecorFace(dpy, df);
1546
1547 /* determine button style */
1548 if (strncasecmp(style,"Simple",6)==0)
1549 {
1550 memset(&df->style, 0, sizeof(df->style));
1551 DFS_FACE_TYPE(df->style) = SimpleButton;
1552 }
1553 else if (strncasecmp(style,"Default",7)==0)
1554 {
1555 int b = -1, n = sscanf(s, "%d%n", &b, &offset);
1556
1557 if (n < 1)
1558 {
1559 if (button == -1)
1560 {
1561 if (verbose)
1562 {
1563 fvwm_msg(
1564 ERR,"ReadDecorFace",
1565 "need default button"
1566 " number to load");
1567 }
1568 return False;
1569 }
1570 b = button;
1571 }
1572 else
1573 {
1574 b = BUTTON_INDEX(b);
1575 s += offset;
1576 }
1577 if (b >= 0 && b < NUMBER_OF_TITLE_BUTTONS)
1578 {
1579 LoadDefaultButton(df, b);
1580 }
1581 else
1582 {
1583 if (verbose)
1584 {
1585 fvwm_msg(
1586 ERR, "ReadDecorFace",
1587 "button number out of range:"
1588 " %d", b);
1589 }
1590 return False;
1591 }
1592 }
1593 else if (strncasecmp(style,"Vector",6)==0 ||
1594 (strlen(style)<=2 && isdigit(*style)))
1595 {
1596 /* normal coordinate list button style */
1597 int i, num_coords, num;
1598 struct vector_coords *vc = &df->u.vector;
1599
1600 /* get number of points */
1601 if (strncasecmp(style,"Vector",6)==0)
1602 {
1603 num = sscanf(s,"%d%n",&num_coords,&offset);
1604 s += offset;
1605 }
1606 else
1607 {
1608 num = sscanf(style,"%d",&num_coords);
1609 }
1610
1611 if (num < 1 || num_coords<2 ||
1612 num_coords > MAX_TITLE_BUTTON_VECTOR_LINES)
1613 {
1614 if (verbose)
1615 {
1616 fvwm_msg(
1617 ERR, "ReadDecorFace",
1618 "Bad button style (2) in line:"
1619 " %s",action);
1620 }
1621 return False;
1622 }
1623
1624 vc->num = num_coords;
1625 vc->use_fgbg = 0;
1626 vc->x = (signed char*)safemalloc(sizeof(char) *
1627 num_coords);
1628 vc->y = (signed char*)safemalloc(sizeof(char) *
1629 num_coords);
1630 vc->xoff = (signed char*)safemalloc(sizeof(char) *
1631 num_coords);
1632 vc->yoff = (signed char*)safemalloc(sizeof(char) *
1633 num_coords);
1634 vc->c = (signed char*)safemalloc(sizeof(char) *
1635 num_coords);
1636
1637 /* get the points */
1638 for (i = 0; i < vc->num; ++i)
1639 {
1640 int x;
1641 int y;
1642 int xoff = 0;
1643 int yoff = 0;
1644 int c;
1645
1646 if (__parse_vector_line(
1647 &s, &x, &y, &xoff, &yoff, &c, s) ==
1648 False)
1649 {
1650 break;
1651 }
1652 if (x < 0)
1653 {
1654 x = 0;
1655 }
1656 if (x > 100)
1657 {
1658 x = 100;
1659 }
1660 if (y < 0)
1661 {
1662 y = 0;
1663 }
1664 if (y > 100)
1665 {
1666 y = 100;
1667 }
1668 if (c < 0 || c > 4)
1669 {
1670 c = 4;
1671 }
1672 vc->x[i] = x;
1673 vc->y[i] = y;
1674 vc->c[i] = c;
1675 vc->xoff[i] = xoff;
1676 vc->yoff[i] = yoff;
1677 if (c == 2 || c == 3)
1678 {
1679 vc->use_fgbg = 1;
1680 }
1681 }
1682 if (i < vc->num)
1683 {
1684 if (verbose)
1685 {
1686 fvwm_msg(
1687 ERR, "ReadDecorFace",
1688 "Bad button style (3) in line"
1689 " %s", action);
1690 }
1691 free(vc->x);
1692 free(vc->y);
1693 free(vc->c);
1694 free(vc->xoff);
1695 free(vc->yoff);
1696 vc->x = NULL;
1697 vc->y = NULL;
1698 vc->c = NULL;
1699 vc->xoff = NULL;
1700 vc->yoff = NULL;
1701 return False;
1702 }
1703 memset(&df->style, 0, sizeof(df->style));
1704 DFS_FACE_TYPE(df->style) = VectorButton;
1705 }
1706 else if (strncasecmp(style,"Solid",5)==0)
1707 {
1708 s = GetNextToken(s, &file);
1709 if (file)
1710 {
1711 memset(&df->style, 0, sizeof(df->style));
1712 DFS_FACE_TYPE(df->style) = SolidButton;
1713 df->u.back = GetColor(file);
1714 free(file);
1715 }
1716 else
1717 {
1718 if (verbose)
1719 {
1720 fvwm_msg(
1721 ERR, "ReadDecorFace",
1722 "no color given for Solid"
1723 " face type: %s", action);
1724 }
1725 return False;
1726 }
1727 }
1728 else if (strncasecmp(style+1, "Gradient", 8)==0)
1729 {
1730 char **s_colors;
1731 int npixels, nsegs, *perc;
1732 XColor *xcs;
1733 Bool do_dither = False;
1734
1735 if (!IsGradientTypeSupported(style[0]))
1736 {
1737 return False;
1738 }
1739 /* translate the gradient string into an array of
1740 * colors etc */
1741 npixels = ParseGradient(
1742 s, &s, &s_colors, &perc, &nsegs);
1743 while (*s && isspace(*s))
1744 {
1745 s++;
1746 }
1747 if (npixels <= 0)
1748 {
1749 return False;
1750 }
1751 /* grab the colors */
1752 if (Pdepth <= 16)
1753 {
1754 do_dither = True;
1755 }
1756 xcs = AllocAllGradientColors(
1757 s_colors, perc, nsegs, npixels, do_dither);
1758 if (xcs == None)
1759 return False;
1760 df->u.grad.xcs = xcs;
1761 df->u.grad.npixels = npixels;
1762 df->u.grad.do_dither = do_dither;
1763 df->u.grad.d_pixels = NULL;
1764 memset(&df->style, 0, sizeof(df->style));
1765 DFS_FACE_TYPE(df->style) = GradientButton;
1766 df->u.grad.gradient_type = toupper(style[0]);
1767 }
1768 else if (strncasecmp(style,"Pixmap",6)==0
1769 || strncasecmp(style,"TiledPixmap",11)==0
1770 || strncasecmp(style,"StretchedPixmap",15)==0
1771 || strncasecmp(style,"AdjustedPixmap",14)==0
1772 || strncasecmp(style,"ShrunkPixmap",12)==0)
1773 {
1774 FvwmPictureAttributes fpa;
1775
1776 s = GetNextToken(s, &file);
1777 fpa.mask = (Pdepth <= 8)? FPAM_DITHER:0; /* ? */
1778 df->u.p = PCacheFvwmPicture(
1779 dpy, Scr.NoFocusWin, NULL, file, fpa);
1780 if (df->u.p == NULL)
1781 {
1782 if (file)
1783 {
1784 if (verbose)
1785 {
1786 fvwm_msg(
1787 ERR, "ReadDecorFace",
1788 "couldn't load pixmap"
1789 " %s", file);
1790 }
1791 free(file);
1792 }
1793 return False;
1794 }
1795 if (file)
1796 {
1797 free(file);
1798 file = NULL;
1799 }
1800
1801 memset(&df->style, 0, sizeof(df->style));
1802 if (strncasecmp(style,"Tiled",5)==0)
1803 {
1804 DFS_FACE_TYPE(df->style) = TiledPixmapButton;
1805 }
1806 else if (strncasecmp(style,"Stretched",9)==0)
1807 {
1808 DFS_FACE_TYPE(df->style) =
1809 StretchedPixmapButton;
1810 }
1811 else if (strncasecmp(style,"Adjusted",8)==0)
1812 {
1813 DFS_FACE_TYPE(df->style) =
1814 AdjustedPixmapButton;
1815 }
1816 else if (strncasecmp(style,"Shrunk",6)==0)
1817 {
1818 DFS_FACE_TYPE(df->style) =
1819 ShrunkPixmapButton;
1820 }
1821 else
1822 {
1823 DFS_FACE_TYPE(df->style) = PixmapButton;
1824 }
1825 }
1826 else if (strncasecmp(style,"MultiPixmap",11)==0)
1827 {
1828 if (button != -1)
1829 {
1830 if (verbose)
1831 {
1832 fvwm_msg(
1833 ERR, "ReadDecorFace",
1834 "MultiPixmap is only valid"
1835 " for TitleStyle");
1836 }
1837 return False;
1838 }
1839 s = ReadMultiPixmapDecor(s, df);
1840 if (!s)
1841 {
1842 return False;
1843 }
1844 }
1845 else if (FMiniIconsSupported &&
1846 strncasecmp (style, "MiniIcon", 8) == 0)
1847 {
1848 memset(&df->style, 0, sizeof(df->style));
1849 DFS_FACE_TYPE(df->style) = MiniIconButton;
1850 /* pixmap read in when the window is created */
1851 df->u.p = NULL;
1852 }
1853 else if (strncasecmp (style, "Colorset", 8) == 0)
1854 {
1855 int val[2];
1856 int n;
1857
1858 n = GetIntegerArguments(s, NULL, val, 2);
1859 if (n == 0)
1860 {
1861 }
1862 memset(&df->style, 0, sizeof(df->style));
1863 if (n > 0 && val[0] >= 0)
1864 {
1865
1866 df->u.acs.cs = val[0];
1867 alloc_colorset(val[0]);
1868 DFS_FACE_TYPE(df->style) = ColorsetButton;
1869 }
1870 df->u.acs.alpha_percent = 100;
1871 if (n > 1)
1872 {
1873 df->u.acs.alpha_percent =
1874 max(0, min(100,val[1]));
1875 }
1876 s = SkipNTokens(s, n);
1877 }
1878 else
1879 {
1880 if (verbose)
1881 {
1882 fvwm_msg(
1883 ERR, "ReadDecorFace",
1884 "unknown style %s: %s", style, action);
1885 }
1886 return False;
1887 }
1888 }
1889
1890 /* Process button flags ("--" signals start of flags,
1891 it is also checked for above) */
1892 s = GetNextToken(s, &file);
1893 if (file && (strcmp(file,"--")==0))
1894 {
1895 char *tok;
1896 s = GetNextToken(s, &tok);
1897 while (tok && *tok)
1898 {
1899 int set = 1;
1900 char *old_tok = NULL;
1901
1902 if (*tok == '!')
1903 { /* flag negate */
1904 set = 0;
1905 old_tok = tok;
1906 tok++;
1907 }
1908 if (StrEquals(tok,"Clear"))
1909 {
1910 memset(&DFS_FLAGS(df->style), (set) ? 0 : 0xff,
1911 sizeof(DFS_FLAGS(df->style)));
1912 /* ? what is set == 0 good for ? */
1913 }
1914 else if (StrEquals(tok,"Left"))
1915 {
1916 if (set)
1917 {
1918 DFS_H_JUSTIFICATION(df->style) =
1919 JUST_LEFT;
1920 }
1921 else
1922 {
1923 DFS_H_JUSTIFICATION(df->style) =
1924 JUST_RIGHT;
1925 }
1926 }
1927 else if (StrEquals(tok,"Right"))
1928 {
1929 if (set)
1930 {
1931 DFS_H_JUSTIFICATION(df->style) =
1932 JUST_RIGHT;
1933 }
1934 else
1935 {
1936 DFS_H_JUSTIFICATION(df->style) =
1937 JUST_LEFT;
1938 }
1939 }
1940 else if (StrEquals(tok,"Centered"))
1941 {
1942 DFS_H_JUSTIFICATION(df->style) = JUST_CENTER;
1943 DFS_V_JUSTIFICATION(df->style) = JUST_CENTER;
1944 }
1945 else if (StrEquals(tok,"Top"))
1946 {
1947 if (set)
1948 {
1949 DFS_V_JUSTIFICATION(df->style) =
1950 JUST_TOP;
1951 }
1952 else
1953 {
1954 DFS_V_JUSTIFICATION(df->style) =
1955 JUST_BOTTOM;
1956 }
1957 }
1958 else if (StrEquals(tok,"Bottom"))
1959 {
1960 if (set)
1961 {
1962 DFS_V_JUSTIFICATION(df->style) =
1963 JUST_BOTTOM;
1964 }
1965 else
1966 {
1967 DFS_V_JUSTIFICATION(df->style) =
1968 JUST_TOP;
1969 }
1970 }
1971 else if (StrEquals(tok,"Flat"))
1972 {
1973 if (set)
1974 {
1975 DFS_BUTTON_RELIEF(df->style) =
1976 DFS_BUTTON_IS_FLAT;
1977 }
1978 else if (DFS_BUTTON_RELIEF(df->style) ==
1979 DFS_BUTTON_IS_FLAT)
1980 {
1981 DFS_BUTTON_RELIEF(df->style) =
1982 DFS_BUTTON_IS_UP;
1983 }
1984 }
1985 else if (StrEquals(tok,"Sunk"))
1986 {
1987 if (set)
1988 {
1989 DFS_BUTTON_RELIEF(df->style) =
1990 DFS_BUTTON_IS_SUNK;
1991 }
1992 else if (DFS_BUTTON_RELIEF(df->style) ==
1993 DFS_BUTTON_IS_SUNK)
1994 {
1995 DFS_BUTTON_RELIEF(df->style) =
1996 DFS_BUTTON_IS_UP;
1997 }
1998 }
1999 else if (StrEquals(tok,"Raised"))
2000 {
2001 if (set)
2002 {
2003 DFS_BUTTON_RELIEF(df->style) =
2004 DFS_BUTTON_IS_UP;
2005 }
2006 else
2007 {
2008 DFS_BUTTON_RELIEF(df->style) =
2009 DFS_BUTTON_IS_SUNK;
2010 }
2011 }
2012 else if (StrEquals(tok,"UseTitleStyle"))
2013 {
2014 if (set)
2015 {
2016 DFS_USE_TITLE_STYLE(df->style) = 1;
2017 DFS_USE_BORDER_STYLE(df->style) = 0;
2018 }
2019 else
2020 DFS_USE_TITLE_STYLE(df->style) = 0;
2021 }
2022 else if (StrEquals(tok,"HiddenHandles"))
2023 {
2024 DFS_HAS_HIDDEN_HANDLES(df->style) = !!set;
2025 }
2026 else if (StrEquals(tok,"NoInset"))
2027 {
2028 DFS_HAS_NO_INSET(df->style) = !!set;
2029 }
2030 else if (StrEquals(tok,"UseBorderStyle"))
2031 {
2032 if (set)
2033 {
2034 DFS_USE_BORDER_STYLE(df->style) = 1;
2035 DFS_USE_TITLE_STYLE(df->style) = 0;
2036 }
2037 else
2038 {
2039 DFS_USE_BORDER_STYLE(df->style) = 0;
2040 }
2041 }
2042 else if (verbose)
2043 {
2044 fvwm_msg(
2045 ERR, "ReadDecorFace",
2046 "unknown button face flag '%s'"
2047 " -- line: %s", tok, action);
2048 }
2049 if (set)
2050 {
2051 free(tok);
2052 }
2053 else
2054 {
2055 free(old_tok);
2056 }
2057 s = GetNextToken(s, &tok);
2058 }
2059 }
2060 if (file)
2061 {
2062 free(file);
2063 }
2064
2065 return True;
2066 }
2067
2068 #ifdef USEDECOR
2069 /*
2070 *
2071 * Diverts a style definition to an FvwmDecor structure (veliaa@rpi.edu)
2072 *
2073 */
2074 void AddToDecor(F_CMD_ARGS, FvwmDecor *decor)
2075 {
2076 if (!action)
2077 {
2078 return;
2079 }
2080 while (*action && isspace((unsigned char)*action))
2081 {
2082 ++action;
2083 }
2084 if (!*action)
2085 {
2086 return;
2087 }
2088 Scr.cur_decor = decor;
2089 execute_function(cond_rc, exc, action, 0);
2090 Scr.cur_decor = NULL;
2091
2092 return;
2093 }
2094
2095 /*
2096 *
2097 * InitFvwmDecor -- initializes an FvwmDecor structure to defaults
2098 *
2099 */
2100 void InitFvwmDecor(FvwmDecor *decor)
2101 {
2102 int i;
2103 DecorFace tmpdf;
2104
2105 /* zero out the structures */
2106 memset(decor, 0, sizeof (FvwmDecor));
2107 memset(&tmpdf, 0, sizeof(DecorFace));
2108
2109 /* initialize title-bar button styles */
2110 DFS_FACE_TYPE(tmpdf.style) = SimpleButton;
2111 for (i = 0; i < NUMBER_OF_TITLE_BUTTONS; ++i)
2112 {
2113 int j = 0;
2114 for (; j < BS_MaxButtonState; ++j)
2115 {
2116 TB_STATE(decor->buttons[i])[j] = tmpdf;
2117 }
2118 }
2119 /* reset to default button set */
2120 ResetAllButtons(decor);
2121 /* initialize title-bar styles */
2122 for (i = 0; i < BS_MaxButtonState; ++i)
2123 {
2124 DFS_FACE_TYPE(
2125 TB_STATE(decor->titlebar)[i].style) = SimpleButton;
2126 }
2127
2128 /* initialize border texture styles */
2129 DFS_FACE_TYPE(decor->BorderStyle.active.style) = SimpleButton;
2130 DFS_FACE_TYPE(decor->BorderStyle.inactive.style) = SimpleButton;
2131
2132 return;
2133 }
2134
2135 void reset_decor_changes(void)
2136 {
2137 #ifndef USEDECOR
2138 Scr.DefaultDecor.flags.has_changed = 0;
2139 Scr.DefaultDecor.flags.has_title_height_changed = 0;
2140 #else
2141 FvwmDecor *decor;
2142 for (decor = &Scr.DefaultDecor; decor; decor = decor->next)
2143 {
2144 decor->flags.has_changed = 0;
2145 decor->flags.has_title_height_changed = 0;
2146 }
2147 /* todo: must reset individual change flags too */
2148 #endif
2149
2150 return;
2151 }
2152
2153 void update_fvwm_colorset(int cset)
2154 {
2155 if (cset == Scr.DefaultColorset)
2156 {
2157 Scr.flags.do_need_window_update = 1;
2158 Scr.flags.has_default_color_changed = 1;
2159 }
2160 UpdateMenuColorset(cset);
2161 update_style_colorset(cset);
2162 update_decors_colorset(cset);
2163
2164 return;
2165 }
2166
2167 /* ---------------------------- builtin commands --------------------------- */
2168
2169 void CMD_Beep(F_CMD_ARGS)
2170 {
2171 #if 1 /*!!!*/
2172 parse_colorset(11, "RootTransparent");
2173 #endif
2174 XBell(dpy, 0);
2175
2176 return;
2177 }
2178
2179 void CMD_Nop(F_CMD_ARGS)
2180 {
2181 return;
2182 }
2183
2184 void CMD_EscapeFunc(F_CMD_ARGS)
2185 {
2186 return;
2187 }
2188
2189 void CMD_CursorMove(F_CMD_ARGS)
2190 {
2191 int x = 0, y = 0;
2192 int val1, val2, val1_unit, val2_unit;
2193 int virtual_x, virtual_y;
2194 int pan_x, pan_y;
2195 int x_pages, y_pages;
2196
2197 if (GetTwoArguments(action, &val1, &val2, &val1_unit, &val2_unit) != 2)
2198 {
2199 fvwm_msg(ERR, "movecursor", "CursorMove needs 2 arguments");
2200 return;
2201 }
2202 if (FQueryPointer(dpy, Scr.Root, &JunkRoot, &JunkChild,
2203 &x, &y, &JunkX, &JunkY, &JunkMask) == False)
2204 {
2205 /* pointer is on a different screen */
2206 return;
2207 }
2208 x = x + val1 * val1_unit / 100;
2209 y = y + val2 * val2_unit / 100;
2210 virtual_x = Scr.Vx;
2211 virtual_y = Scr.Vy;
2212 if (x >= 0)
2213 {
2214 x_pages = x / Scr.MyDisplayWidth;
2215 }
2216 else
2217 {
2218 x_pages = ((x + 1) / Scr.MyDisplayWidth) - 1;
2219 }
2220 virtual_x += x_pages * Scr.MyDisplayWidth;
2221 x -= x_pages * Scr.MyDisplayWidth;
2222 if (virtual_x < 0)
2223 {
2224 x += virtual_x;
2225 virtual_x = 0;
2226 }
2227 else if (virtual_x > Scr.VxMax)
2228 {
2229 x += virtual_x - Scr.VxMax;
2230 virtual_x = Scr.VxMax;
2231 }
2232
2233 if (y >= 0)
2234 {
2235 y_pages = y / Scr.MyDisplayHeight;
2236 }
2237 else
2238 {
2239 y_pages = ((y + 1) / Scr.MyDisplayHeight) - 1;
2240 }
2241 virtual_y += y_pages * Scr.MyDisplayHeight;
2242 y -= y_pages * Scr.MyDisplayHeight;
2243 if (virtual_y < 0)
2244 {
2245 y += virtual_y;
2246 virtual_y = 0;
2247 }
2248 else if (virtual_y > Scr.VyMax)
2249 {
2250 y += virtual_y - Scr.VyMax;
2251 virtual_y = Scr.VyMax;
2252 }
2253 if (virtual_x != Scr.Vx || virtual_y != Scr.Vy)
2254 MoveViewport(virtual_x, virtual_y, True);
2255 pan_x = (Scr.EdgeScrollX != 0) ? 2 : 0;
2256 pan_y = (Scr.EdgeScrollY != 0) ? 2 : 0;
2257 /* prevent paging if EdgeScroll is active */
2258 if (x >= Scr.MyDisplayWidth - pan_x)
2259 {
2260 x = Scr.MyDisplayWidth - pan_x -1;
2261 }
2262 else if (x < pan_x)
2263 {
2264 x = pan_x;
2265 }
2266 if (y >= Scr.MyDisplayHeight - pan_y)
2267 {
2268 y = Scr.MyDisplayHeight - pan_y - 1;
2269 }
2270 else if (y < pan_y)
2271 {
2272 y = pan_y;
2273 }
2274 FWarpPointerUpdateEvpos(
2275 exc->x.elast, dpy, None, Scr.Root, 0, 0, Scr.MyDisplayWidth,
2276 Scr.MyDisplayHeight, x, y);
2277
2278 return;
2279 }
2280
2281 void CMD_Delete(F_CMD_ARGS)
2282 {
2283 FvwmWindow * const fw = exc->w.fw;
2284
2285 if (!is_function_allowed(F_DELETE, NULL, fw, RQORIG_PROGRAM_US, True))
2286 {
2287 XBell(dpy, 0);
2288
2289 return;
2290 }
2291 if (IS_TEAR_OFF_MENU(fw))
2292 {
2293 /* 'soft' delete tear off menus. Note: we can't send the
2294 * message to the menu window directly because it was created
2295 * using a different display. The client message would never
2296 * be read from there. */
2297 send_clientmessage(
2298 dpy, FW_W_PARENT(fw), _XA_WM_DELETE_WINDOW,
2299 CurrentTime);
2300
2301 return;
2302 }
2303 if (WM_DELETES_WINDOW(fw))
2304 {
2305 send_clientmessage(
2306 dpy, FW_W(fw), _XA_WM_DELETE_WINDOW, CurrentTime);
2307
2308 return;
2309 }
2310 else
2311 {
2312 XBell(dpy, 0);
2313 }
2314 XFlush(dpy);
2315
2316 return;
2317 }
2318
2319 void CMD_Destroy(F_CMD_ARGS)
2320 {
2321 FvwmWindow * const fw = exc->w.fw;
2322
2323 if (IS_TEAR_OFF_MENU(fw))
2324 {
2325 CMD_Delete(F_PASS_ARGS);
2326 return;
2327 }
2328 if (!is_function_allowed(F_DESTROY, NULL, fw, True, True))
2329 {
2330 XBell(dpy, 0);
2331 return;
2332 }
2333 if (
2334 XGetGeometry(
2335 dpy, FW_W(fw), &JunkRoot, &JunkX, &JunkY,
2336 (unsigned int*)&JunkWidth, (unsigned int*)&JunkHeight,
2337 (unsigned int*)&JunkBW, (unsigned int*)&JunkDepth)
2338 != 0)
2339 {
2340 XKillClient(dpy, FW_W(fw));
2341 }
2342 destroy_window(fw);
2343 XFlush(dpy);
2344
2345 return;
2346 }
2347
2348 void CMD_Close(F_CMD_ARGS)
2349 {
2350 FvwmWindow * const fw = exc->w.fw;
2351
2352 if (IS_TEAR_OFF_MENU(fw))
2353 {
2354 CMD_Delete(F_PASS_ARGS);
2355 return;
2356 }
2357 if (!is_function_allowed(F_CLOSE, NULL, fw, True, True))
2358 {
2359 XBell(dpy, 0);
2360 return;
2361 }
2362 if (WM_DELETES_WINDOW(fw))
2363 {
2364 send_clientmessage(
2365 dpy, FW_W(fw), _XA_WM_DELETE_WINDOW, CurrentTime);
2366 return;
2367 }
2368 if (
2369 XGetGeometry(
2370 dpy, FW_W(fw), &JunkRoot, &JunkX, &JunkY,
2371 (unsigned int*)&JunkWidth, (unsigned int*)&JunkHeight,
2372 (unsigned int*)&JunkBW, (unsigned int*)&JunkDepth)
2373 != 0)
2374 {
2375 XKillClient(dpy, FW_W(fw));
2376 }
2377
2378 destroy_window(fw);
2379 XFlush(dpy);
2380
2381 return;
2382 }
2383
2384 void CMD_Restart(F_CMD_ARGS)
2385 {
2386 Done(1, action);
2387
2388 return;
2389 }
2390
2391 void CMD_ExecUseShell(F_CMD_ARGS)
2392 {
2393 char *arg=NULL;
2394 static char shell_set = 0;
2395
2396 if (shell_set)
2397 {
2398 free(exec_shell_name);
2399 }
2400 shell_set = 1;
2401 action = GetNextToken(action,&arg);
2402 if (arg) /* specific shell was specified */
2403 {
2404 exec_shell_name = arg;
2405 }
2406 else /* no arg, so use $SHELL -- not working??? */
2407 {
2408 if (getenv("SHELL"))
2409 {
2410 exec_shell_name = safestrdup(getenv("SHELL"));
2411 }
2412 else
2413 {
2414 /* if $SHELL not set, use default */
2415 exec_shell_name = safestrdup("/bin/sh");
2416 }
2417 }
2418 }
2419
2420 void CMD_Exec(F_CMD_ARGS)
2421 {
2422 char *cmd=NULL;
2423
2424 /* if it doesn't already have an 'exec' as the first word, add that
2425 * to keep down number of procs started */
2426 /* need to parse string better to do this right though, so not doing
2427 * this for now... */
2428 #if 0
2429 if (strncasecmp(action,"exec",4)!=0)
2430 {
2431 cmd = (char *)safemalloc(strlen(action)+6);
2432 strcpy(cmd,"exec ");
2433 strcat(cmd,action);
2434 }
2435 else
2436 #endif
2437 {
2438 cmd = safestrdup(action);
2439 }
2440 if (!cmd)
2441 {
2442 return;
2443 }
2444 /* Use to grab the pointer here, but the fork guarantees that
2445 * we wont be held up waiting for the function to finish,
2446 * so the pointer-gram just caused needless delay and flashing
2447 * on the screen */
2448 /* Thought I'd try vfork and _exit() instead of regular fork().
2449 * The man page says that its better. */
2450 /* Not everyone has vfork! */
2451 /* According to the man page, vfork should never be used at all.
2452 */
2453
2454 if (!(fork())) /* child process */
2455 {
2456 /* This is for fixing a problem with rox filer */
2457 int fd;
2458
2459 fvmm_deinstall_signals();
2460 fd = open("/dev/null", O_RDONLY, 0);
2461 dup2(fd,STDIN_FILENO);
2462
2463 if (fd != STDIN_FILENO)
2464 close(fd);
2465
2466 if (fvwm_setpgrp() == -1)
2467 {
2468 fvwm_msg(ERR, "exec_function", "setpgrp failed (%s)",
2469 strerror(errno));
2470 exit(100);
2471 }
2472 if (execl(exec_shell_name, exec_shell_name, "-c", cmd, NULL) ==
2473 -1)
2474 {
2475 fvwm_msg(ERR, "exec_function", "execl failed (%s)",
2476 strerror(errno));
2477 exit(100);
2478 }
2479 }
2480 free(cmd);
2481
2482 return;
2483 }
2484
2485 void CMD_Refresh(F_CMD_ARGS)
2486 {
2487 refresh_window(Scr.Root, True);
2488
2489 return;
2490 }
2491
2492 void CMD_RefreshWindow(F_CMD_ARGS)
2493 {
2494 FvwmWindow * const fw = exc->w.fw;
2495
2496 refresh_window(
2497 (exc->w.wcontext == C_ICON) ?
2498 FW_W_ICON_TITLE(fw) : FW_W_FRAME(fw), True);
2499
2500 return;
2501 }
2502
2503 void CMD_Wait(F_CMD_ARGS)
2504 {
2505 Bool done = False;
2506 Bool redefine_cursor = False;
2507 Bool is_ungrabbed;
2508 char *escape;
2509 Window nonewin = None;
2510 char *wait_string, *rest;
2511 FvwmWindow *t;
2512
2513 /* try to get a single token */
2514 rest = GetNextToken(action, &wait_string);
2515 if (wait_string)
2516 {
2517 while (*rest && isspace((unsigned char)*rest))
2518 {
2519 rest++;
2520 }
2521 if (*rest)
2522 {
2523 int i;
2524 char *temp;
2525
2526 /* nope, multiple tokens - try old syntax */
2527
2528 /* strip leading and trailing whitespace */
2529 temp = action;
2530 while (*temp && isspace((unsigned char)*temp))
2531 {
2532 temp++;
2533 }
2534 wait_string = safestrdup(temp);
2535 for (i = strlen(wait_string) - 1; i >= 0 &&
2536 isspace(wait_string[i]); i--)
2537 {
2538 wait_string[i] = 0;
2539 }
2540 }
2541 }
2542 else
2543 {
2544 wait_string = safestrdup("");
2545 }
2546
2547 is_ungrabbed = UngrabEm(GRAB_NORMAL);
2548 while (!done && !isTerminated)
2549 {
2550 XEvent e;
2551 if (BUSY_WAIT & Scr.BusyCursor)
2552 {
2553 XDefineCursor(dpy, Scr.Root, Scr.FvwmCursors[CRS_WAIT]);
2554 redefine_cursor = True;
2555 }
2556 if (My_XNextEvent(dpy, &e))
2557 {
2558 dispatch_event(&e);
2559 if (XFindContext(
2560 dpy, e.xmap.window, FvwmContext,
2561 (caddr_t *)&t) == XCNOENT)
2562 {
2563 t = NULL;
2564 }
2565
2566 if (e.type == MapNotify && e.xmap.event == Scr.Root)
2567 {
2568 if (!*wait_string)
2569 {
2570 done = True;
2571 }
2572 if (t && matchWildcards(
2573 wait_string, t->name.name) == True)
2574 {
2575 done = True;
2576 }
2577 else if (t && t->class.res_class &&
2578 matchWildcards(
2579 wait_string,
2580 t->class.res_class) == True)
2581 {
2582 done = True;
2583 }
2584 else if (t && t->class.res_name &&
2585 matchWildcards(
2586 wait_string,
2587 t->class.res_name) == True)
2588 {
2589 done = True;
2590 }
2591 }
2592 else if (e.type == KeyPress)
2593 {
2594 /* should I be using <t> or <exc->w.fw>?
2595 * DV: t
2596 */
2597 int context;
2598 XClassHint *class;
2599 char *name;
2600
2601 context = GetContext(&t, t, &e, &nonewin);
2602 if (t != NULL)
2603 {
2604 class = &(t->class);
2605 name = t->name.name;
2606 }
2607 else
2608 {
2609 class = NULL;
2610 name = NULL;
2611 }
2612 escape = CheckBinding(
2613 Scr.AllBindings, STROKE_ARG(0)
2614 e.xkey.keycode, e.xkey.state,
2615 GetUnusedModifiers(), context,
2616 BIND_KEYPRESS, class, name);
2617 if (escape != NULL)
2618 {
2619 if (!strcasecmp(escape,"escapefunc"))
2620 {
2621 done = True;
2622 }
2623 }
2624 }
2625 }
2626 }
2627 if (redefine_cursor)
2628 {
2629 XDefineCursor(dpy, Scr.Root, Scr.FvwmCursors[CRS_ROOT]);
2630 }
2631 if (is_ungrabbed)
2632 {
2633 GrabEm(CRS_NONE, GRAB_NORMAL);
2634 }
2635 free(wait_string);
2636
2637 return;
2638 }
2639
2640 void CMD_Quit(F_CMD_ARGS)
2641 {
2642 if (master_pid != getpid())
2643 {
2644 kill(master_pid, SIGTERM);
2645 }
2646 Done(0,NULL);
2647
2648 return;
2649 }
2650
2651 void CMD_QuitScreen(F_CMD_ARGS)
2652 {
2653 Done(0,NULL);
2654
2655 return;
2656 }
2657
2658 void CMD_Echo(F_CMD_ARGS)
2659 {
2660 int len;
2661
2662 if (!action)
2663 {
2664 action = "";
2665 }
2666 len = strlen(action);
2667 if (len != 0)
2668 {
2669 if (action[len-1]=='\n')
2670 {
2671 action[len-1]='\0';
2672 }
2673 }
2674 fvwm_msg(ECHO,"Echo",action);
2675
2676 return;
2677 }
2678
2679 void CMD_PrintInfo(F_CMD_ARGS)
2680 {
2681 int verbose;
2682 char *rest, *subject = NULL;
2683
2684 rest = GetNextToken(action, &subject);
2685 if (!rest || GetIntegerArguments(rest, NULL, &verbose, 1) != 1)
2686 {
2687 verbose = 0;
2688 }
2689 if (StrEquals(subject, "Colors"))
2690 {
2691 PicturePrintColorInfo(verbose);
2692 }
2693 else if (StrEquals(subject, "Locale"))
2694 {
2695 FlocalePrintLocaleInfo(dpy, verbose);
2696 }
2697 else if (StrEquals(subject, "NLS"))
2698 {
2699 FGettextPrintLocalePath(verbose);
2700 }
2701 else if (StrEquals(subject, "style"))
2702 {
2703 print_styles(verbose);
2704 }
2705 else if (StrEquals(subject, "ImageCache"))
2706 {
2707 PicturePrintImageCache(verbose);
2708 }
2709 else if (StrEquals(subject, "Bindings"))
2710 {
2711 print_bindings();
2712 }
2713 else
2714 {
2715 fvwm_msg(ERR, "PrintInfo",
2716 "Unknown subject '%s'", action);
2717 }
2718 if (subject)
2719 {
2720 free(subject);
2721 }
2722 return;
2723 }
2724
2725 void CMD_ColormapFocus(F_CMD_ARGS)
2726 {
2727 if (MatchToken(action,"FollowsFocus"))
2728 {
2729 Scr.ColormapFocus = COLORMAP_FOLLOWS_FOCUS;
2730 }
2731 else if (MatchToken(action,"FollowsMouse"))
2732 {
2733 Scr.ColormapFocus = COLORMAP_FOLLOWS_MOUSE;
2734 }
2735 else
2736 {
2737 fvwm_msg(ERR, "SetColormapFocus",
2738 "ColormapFocus requires 1 arg: FollowsFocus or"
2739 " FollowsMouse");
2740 return;
2741 }
2742
2743 return;
2744 }
2745
2746 void CMD_ClickTime(F_CMD_ARGS)
2747 {
2748 int val;
2749
2750 if (GetIntegerArguments(action, NULL, &val, 1) != 1)
2751 {
2752 Scr.ClickTime = DEFAULT_CLICKTIME;
2753 }
2754 else
2755 {
2756 Scr.ClickTime = (val < 0)? 0 : val;
2757 }
2758
2759 /* Use a negative value during startup and change sign afterwards. This
2760 * speeds things up quite a bit. */
2761 if (fFvwmInStartup)
2762 {
2763 Scr.ClickTime = -Scr.ClickTime;
2764 }
2765
2766 return;
2767 }
2768
2769
2770 void CMD_ImagePath(F_CMD_ARGS)
2771 {
2772 PictureSetImagePath( action );
2773
2774 return;
2775 }
2776
2777 void CMD_IconPath(F_CMD_ARGS)
2778 {
2779 fvwm_msg(ERR, "iconPath_function",
2780 "IconPath is deprecated since 2.3.0; use ImagePath instead.");
2781 obsolete_imagepaths( action );
2782
2783 return;
2784 }
2785
2786 void CMD_PixmapPath(F_CMD_ARGS)
2787 {
2788 fvwm_msg(ERR, "pixmapPath_function",
2789 "PixmapPath is deprecated since 2.3.0; use ImagePath"
2790 " instead." );
2791 obsolete_imagepaths( action );
2792
2793 return;
2794 }
2795
2796 void CMD_LocalePath(F_CMD_ARGS)
2797 {
2798 FGettextSetLocalePath( action );
2799
2800 return;
2801 }
2802
2803 void CMD_ModulePath(F_CMD_ARGS)
2804 {
2805 static int need_to_free = 0;
2806
2807 setPath( &ModulePath, action, need_to_free );
2808 need_to_free = 1;
2809
2810 return;
2811 }
2812
2813 void CMD_ModuleTimeout(F_CMD_ARGS)
2814 {
2815 int timeout;
2816
2817 moduleTimeout = DEFAULT_MODULE_TIMEOUT;
2818 if (GetIntegerArguments(action, NULL, &timeout, 1) == 1 && timeout > 0)
2819 {
2820 moduleTimeout = timeout;
2821 }
2822
2823 return;
2824 }
2825
2826 void CMD_HilightColor(F_CMD_ARGS)
2827 {
2828 char *fore;
2829 char *back;
2830 #ifdef USEDECOR
2831 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
2832 {
2833 fvwm_msg(
2834 ERR, "SetHiColor",
2835 "Decors do not support the HilightColor command"
2836 " anymore. Please use"
2837 " 'Style <stylename> HilightFore <forecolor>' and"
2838 " 'Style <stylename> HilightBack <backcolor>' instead."
2839 " Sorry for the inconvenience.");
2840 return;
2841 }
2842 #endif
2843 action = GetNextToken(action, &fore);
2844 GetNextToken(action, &back);
2845 if (fore && back)
2846 {
2847 action = safemalloc(strlen(fore) + strlen(back) + 29);
2848 sprintf(action, "* HilightFore %s, HilightBack %s", fore, back);
2849 CMD_Style(F_PASS_ARGS);
2850 }
2851 if (fore)
2852 {
2853 free(fore);
2854 }
2855 if (back)
2856 {
2857 free(back);
2858 }
2859
2860 return;
2861 }
2862
2863 void CMD_HilightColorset(F_CMD_ARGS)
2864 {
2865 char *newaction;
2866
2867 #ifdef USEDECOR
2868 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
2869 {
2870 fvwm_msg(
2871 ERR, "SetHiColorset",
2872 "Decors do not support the HilightColorset command "
2873 "anymore. Please use "
2874 "'Style <stylename> HilightColorset <colorset>'"
2875 " instead. Sorry for the inconvenience.");
2876 return;
2877 }
2878 #endif
2879 if (action)
2880 {
2881 newaction = safemalloc(strlen(action) + 32);
2882 sprintf(newaction, "* HilightColorset %s", action);
2883 action = newaction;
2884 CMD_Style(F_PASS_ARGS);
2885 free(newaction);
2886 }
2887
2888 return;
2889 }
2890
2891 void CMD_TitleStyle(F_CMD_ARGS)
2892 {
2893 do_title_style(F_PASS_ARGS, False);
2894
2895 return;
2896 } /* SetTitleStyle */
2897
2898 /*
2899 *
2900 * Appends a titlestyle (veliaa@rpi.edu)
2901 *
2902 */
2903 void CMD_AddTitleStyle(F_CMD_ARGS)
2904 {
2905 do_title_style(F_PASS_ARGS, True);
2906
2907 return;
2908 }
2909
2910 void CMD_PropertyChange(F_CMD_ARGS)
2911 {
2912 char string[256];
2913 char *token;
2914 char *rest;
2915 int ret;
2916 unsigned long argument;
2917 unsigned long data1;
2918 unsigned long data2;
2919
2920 /* argument */
2921 token = PeekToken(action, &rest);
2922 if (token == NULL)
2923 {
2924 return;
2925 }
2926 ret = sscanf(token, "%lu", &argument);
2927 if (ret < 1)
2928 {
2929 return;
2930 }
2931 /* data1 */
2932 data1 = 0;
2933 token = PeekToken(rest, &rest);
2934 if (token != NULL)
2935 {
2936 ret = sscanf(token, "%lu", &data1);
2937 if (ret < 1)
2938 {
2939 rest = NULL;
2940 }
2941 }
2942 /* data2 */
2943 data2 = 0;
2944 token = PeekToken(rest, &rest);
2945 if (token != NULL)
2946 {
2947 ret = sscanf(token, "%lu", &data2);
2948 if (ret < 1)
2949 {
2950 rest = NULL;
2951 }
2952 }
2953 /* string */
2954 memset(string, 0, 256);
2955 if (rest != NULL)
2956 {
2957 ret = sscanf(rest, "%255c", &(string[0]));
2958 }
2959 BroadcastPropertyChange(argument, data1, data2, string);
2960
2961 return;
2962 }
2963
2964 void CMD_DefaultIcon(F_CMD_ARGS)
2965 {
2966 if (Scr.DefaultIcon)
2967 {
2968 free(Scr.DefaultIcon);
2969 }
2970 GetNextToken(action, &Scr.DefaultIcon);
2971
2972 return;
2973 }
2974
2975 void CMD_DefaultColorset(F_CMD_ARGS)
2976 {
2977 int cset;
2978
2979 if (GetIntegerArguments(action, NULL, &cset, 1) != 1)
2980 {
2981 return;
2982 }
2983 Scr.DefaultColorset = cset;
2984 if (Scr.DefaultColorset < 0)
2985 {
2986 Scr.DefaultColorset = -1;
2987 }
2988 alloc_colorset(Scr.DefaultColorset);
2989 Scr.flags.do_need_window_update = 1;
2990 Scr.flags.has_default_color_changed = 1;
2991
2992 return;
2993 }
2994
2995 void CMD_DefaultColors(F_CMD_ARGS)
2996 {
2997 char *fore = NULL;
2998 char *back = NULL;
2999
3000 action = GetNextToken(action, &fore);
3001 if (action)
3002 {
3003 action = GetNextToken(action, &back);
3004 }
3005 if (!back)
3006 {
3007 back = safestrdup(DEFAULT_BACK_COLOR);
3008 }
3009 if (!fore)
3010 {
3011 fore = safestrdup(DEFAULT_FORE_COLOR);
3012 }
3013 if (!StrEquals(fore, "-"))
3014 {
3015 PictureFreeColors(dpy, Pcmap, &Scr.StdFore, 1, 0, True);
3016 Scr.StdFore = GetColor(fore);
3017 }
3018 if (!StrEquals(back, "-"))
3019 {
3020 PictureFreeColors(dpy, Pcmap, &Scr.StdBack, 3, 0, True);
3021 Scr.StdBack = GetColor(back);
3022 Scr.StdHilite = GetHilite(Scr.StdBack);
3023 Scr.StdShadow = GetShadow(Scr.StdBack);
3024 }
3025 free(fore);
3026 free(back);
3027
3028 Scr.DefaultColorset = -1;
3029 Scr.flags.do_need_window_update = 1;
3030 Scr.flags.has_default_color_changed = 1;
3031
3032 return;
3033 }
3034
3035 void CMD_DefaultFont(F_CMD_ARGS)
3036 {
3037 char *font;
3038 FlocaleFont *new_font;
3039 FvwmWindow *t;
3040
3041 font = PeekToken(action, &action);
3042 if (!font)
3043 {
3044 /* Try 'fixed', pass NULL font name */
3045 }
3046 if (!(new_font = FlocaleLoadFont(dpy, font, "fvwm")))
3047 {
3048 if (Scr.DefaultFont == NULL)
3049 {
3050 exit(1);
3051 }
3052 else
3053 {
3054 return;
3055 }
3056 }
3057 FlocaleUnloadFont(dpy, Scr.DefaultFont);
3058 Scr.DefaultFont = new_font;
3059 /* we should do that here because a redraw can happen before
3060 flush_window_updates is called ... */
3061 for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
3062 {
3063 if (USING_DEFAULT_ICON_FONT(t))
3064 {
3065 t->icon_font = Scr.DefaultFont;
3066 }
3067 if (USING_DEFAULT_WINDOW_FONT(t))
3068 {
3069 t->title_font = Scr.DefaultFont;
3070 }
3071 }
3072 /* set flags to indicate that the font has changed */
3073 Scr.flags.do_need_window_update = 1;
3074 Scr.flags.has_default_font_changed = 1;
3075
3076 return;
3077 }
3078
3079 void CMD_IconFont(F_CMD_ARGS)
3080 {
3081 char *newaction;
3082
3083 #ifdef USEDECOR
3084 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
3085 {
3086 fvwm_msg(
3087 ERR, "LoadIconFont",
3088 "Decors do not support the IconFont command anymore."
3089 " Please use 'Style <stylename> IconFont <fontname>'"
3090 " instead. Sorry for the inconvenience.");
3091 return;
3092 }
3093 #endif
3094 if (action)
3095 {
3096 newaction = safemalloc(strlen(action) + 16);
3097 sprintf(newaction, "* IconFont %s", action);
3098 action = newaction;
3099 CMD_Style(F_PASS_ARGS);
3100 free(newaction);
3101 }
3102
3103 return;
3104 }
3105
3106 void CMD_WindowFont(F_CMD_ARGS)
3107 {
3108 char *newaction;
3109
3110 #ifdef USEDECOR
3111 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
3112 {
3113 fvwm_msg(
3114 ERR, "LoadWindowFont",
3115 "Decors do not support the WindowFont command anymore."
3116 " Please use 'Style <stylename> Font <fontname>'"
3117 " instead. Sorry for the inconvenience.");
3118 return;
3119 }
3120 #endif
3121 if (action)
3122 {
3123 newaction = safemalloc(strlen(action) + 16);
3124 sprintf(newaction, "* Font %s", action);
3125 action = newaction;
3126 CMD_Style(F_PASS_ARGS);
3127 free(newaction);
3128 }
3129
3130 return;
3131 }
3132
3133 /*
3134 *
3135 * Changes the window's FvwmDecor pointer (veliaa@rpi.edu)
3136 *
3137 */
3138 void CMD_ChangeDecor(F_CMD_ARGS)
3139 {
3140 char *item;
3141 int old_height;
3142 FvwmDecor *decor = &Scr.DefaultDecor;
3143 FvwmDecor *found = NULL;
3144 FvwmWindow * const fw = exc->w.fw;
3145
3146 item = PeekToken(action, &action);
3147 if (!action || !item)
3148 {
3149 return;
3150 }
3151 /* search for tag */
3152 for (; decor; decor = decor->next)
3153 {
3154 if (decor->tag && StrEquals(item, decor->tag))
3155 {
3156 found = decor;
3157 break;
3158 }
3159 }
3160 if (!found)
3161 {
3162 XBell(dpy, 0);
3163 return;
3164 }
3165 SET_DECOR_CHANGED(fw, 1);
3166 old_height = (fw->decor) ? fw->decor->title_height : 0;
3167 fw->decor = found;
3168 apply_decor_change(fw);
3169
3170 return;
3171 }
3172
3173 /*
3174 *
3175 * Destroys an FvwmDecor (veliaa@rpi.edu)
3176 *
3177 */
3178 void CMD_DestroyDecor(F_CMD_ARGS)
3179 {
3180 char *item;
3181 FvwmDecor *decor = Scr.DefaultDecor.next;
3182 FvwmDecor *prev = &Scr.DefaultDecor, *found = NULL;
3183 Bool do_recreate = False;
3184
3185 item = PeekToken(action, &action);
3186 if (!item)
3187 {
3188 return;
3189 }
3190 if (StrEquals(item, "recreate"))
3191 {
3192 do_recreate = True;
3193 item = PeekToken(action, NULL);
3194 }
3195 if (!item)
3196 {
3197 return;
3198 }
3199
3200 /* search for tag */
3201 for (; decor; decor = decor->next)
3202 {
3203 if (decor->tag && StrEquals(item, decor->tag))
3204 {
3205 found = decor;
3206 break;
3207 }
3208 prev = decor;
3209 }
3210
3211 if (found && (found != &Scr.DefaultDecor || do_recreate))
3212 {
3213 if (!do_recreate)
3214 {
3215 __remove_window_decors(F_PASS_ARGS, found);
3216 }
3217 DestroyFvwmDecor(found);
3218 if (do_recreate)
3219 {
3220 int i;
3221
3222 InitFvwmDecor(found);
3223 found->tag = safestrdup(item);
3224 Scr.flags.do_need_window_update = 1;
3225 found->flags.has_changed = 1;
3226 found->flags.has_title_height_changed = 0;
3227 found->titlebar.flags.has_changed = 1;
3228 for (i = 0; i < NUMBER_OF_TITLE_BUTTONS; ++i)
3229 {
3230 TB_FLAGS(found->buttons[i]).has_changed = 1;
3231 }
3232 }
3233 else
3234 {
3235 prev->next = found->next;
3236 free(found);
3237 }
3238 }
3239
3240 return;
3241 }
3242
3243 /*
3244 *
3245 * Initiates an AddToDecor (veliaa@rpi.edu)
3246 *
3247 */
3248 void CMD_AddToDecor(F_CMD_ARGS)
3249 {
3250 FvwmDecor *decor;
3251 FvwmDecor *found = NULL;
3252 char *item = NULL;
3253
3254 action = GetNextToken(action, &item);
3255 if (!item)
3256 {
3257 return;
3258 }
3259 if (!action)
3260 {
3261 free(item);
3262 return;
3263 }
3264 /* search for tag */
3265 for (decor = &Scr.DefaultDecor; decor; decor = decor->next)
3266 {
3267 if (decor->tag && StrEquals(item, decor->tag))
3268 {
3269 found = decor;
3270 break;
3271 }
3272 }
3273 if (!found)
3274 {
3275 /* then make a new one */
3276 found = (FvwmDecor *)safemalloc(sizeof( FvwmDecor ));
3277 InitFvwmDecor(found);
3278 found->tag = item; /* tag it */
3279 /* add it to list */
3280 for (decor = &Scr.DefaultDecor; decor->next;
3281 decor = decor->next)
3282 {
3283 /* nop */
3284 }
3285 decor->next = found;
3286 }
3287 else
3288 {
3289 free(item);
3290 }
3291
3292 if (found)
3293 {
3294 AddToDecor(F_PASS_ARGS, found);
3295 /* Set + state to last decor */
3296 set_last_added_item(ADDED_DECOR, found);
3297 }
3298
3299 return;
3300 }
3301 #endif /* USEDECOR */
3302
3303
3304 /*
3305 *
3306 * Updates window decoration styles (veliaa@rpi.edu)
3307 *
3308 */
3309 void CMD_UpdateDecor(F_CMD_ARGS)
3310 {
3311 FvwmWindow *fw2;
3312 #ifdef USEDECOR
3313 FvwmDecor *decor, *found = NULL;
3314 FvwmWindow *hilight = Scr.Hilite;
3315 char *item = NULL;
3316
3317 action = GetNextToken(action, &item);
3318 if (item)
3319 {
3320 /* search for tag */
3321 for (decor = &Scr.DefaultDecor; decor; decor = decor->next)
3322 {
3323 if (decor->tag && StrEquals(item, decor->tag))
3324 {
3325 found = decor;
3326 break;
3327 }
3328 }
3329 free(item);
3330 }
3331 #endif
3332
3333 for (fw2 = Scr.FvwmRoot.next; fw2; fw2 = fw2->next)
3334 {
3335 #ifdef USEDECOR
3336 /* update specific decor, or all */
3337 if (found)
3338 {
3339 if (fw2->decor == found)
3340 {
3341 border_draw_decorations(
3342 fw2, PART_ALL, True, True, CLEAR_ALL,
3343 NULL, NULL);
3344 border_draw_decorations(
3345 fw2, PART_ALL, False, True, CLEAR_ALL,
3346 NULL, NULL);
3347 }
3348 }
3349 else
3350 #endif
3351 {
3352 border_draw_decorations(
3353 fw2, PART_ALL, True, True, CLEAR_ALL, NULL,
3354 NULL);
3355 border_draw_decorations(
3356 fw2, PART_ALL, False, True, CLEAR_ALL, NULL,
3357 NULL);
3358 }
3359 }
3360 border_draw_decorations(
3361 hilight, PART_ALL, True, True, CLEAR_ALL, NULL, NULL);
3362 }
3363
3364 void CMD_ButtonStyle(F_CMD_ARGS)
3365 {
3366 do_button_style(F_PASS_ARGS, False);
3367
3368 return;
3369 }
3370
3371 /*
3372 *
3373 * Appends a button decoration style (veliaa@rpi.edu)
3374 *
3375 */
3376 void CMD_AddButtonStyle(F_CMD_ARGS)
3377 {
3378 do_button_style(F_PASS_ARGS, True);
3379
3380 return;
3381 }
3382
3383 void CMD_SetEnv(F_CMD_ARGS)
3384 {
3385 char *szVar = NULL;
3386 char *szValue = NULL;
3387 char *szPutenv = NULL;
3388
3389 action = GetNextToken(action, &szVar);
3390 if (!szVar)
3391 {
3392 return;
3393 }
3394 action = GetNextToken(action, &szValue);
3395 if (!szValue)
3396 {
3397 szValue = safestrdup("");
3398 }
3399 szPutenv = safemalloc(strlen(szVar) + strlen(szValue) + 2);
3400 sprintf(szPutenv,"%s=%s", szVar, szValue);
3401 flib_putenv(szVar, szPutenv);
3402 free(szVar);
3403 free(szPutenv);
3404 free(szValue);
3405
3406 return;
3407 }
3408
3409 void CMD_UnsetEnv(F_CMD_ARGS)
3410 {
3411 char *szVar = NULL;
3412
3413 szVar = PeekToken(action, &action);
3414 if (!szVar)
3415 {
3416 return;
3417 }
3418 flib_unsetenv(szVar);
3419
3420 return;
3421 }
3422
3423 void CMD_GlobalOpts(F_CMD_ARGS)
3424 {
3425 char *opt;
3426 char *replace;
3427 char buf[64];
3428 int i;
3429 Bool is_bugopt;
3430 char *optlist[] = {
3431 "WindowShadeShrinks",
3432 "WindowShadeScrolls",
3433 "SmartPlacementIsReallySmart",
3434 "SmartPlacementIsNormal",
3435 "ClickToFocusDoesntPassClick",
3436 "ClickToFocusPassesClick",
3437 "ClickToFocusDoesntRaise",
3438 "ClickToFocusRaises",
3439 "MouseFocusClickDoesntRaise",
3440 "MouseFocusClickRaises",
3441 "NoStipledTitles",
3442 "StipledTitles",
3443 "CaptureHonorsStartsOnPage",
3444 "CaptureIgnoresStartsOnPage",
3445 "RecaptureHonorsStartsOnPage",
3446 "RecaptureIgnoresStartsOnPage",
3447 "ActivePlacementHonorsStartsOnPage",
3448 "ActivePlacementIgnoresStartsOnPage",
3449 "RaiseOverNativeWindows",
3450 "IgnoreNativeWindows",
3451 NULL
3452 };
3453 char *replacelist[] = {
3454 /* These options are mapped to the Style * command */
3455 NULL, /* NULL means to use "Style * <optionname>" */
3456 NULL,
3457 "* MinOverlapPlacement",
3458 "* TileCascadePlacement",
3459 "* ClickToFocusPassesClickOff",
3460 "* ClickToFocusPassesClick",
3461 "* ClickToFocusRaisesOff",
3462 "* ClickToFocusRaises",
3463 "* MouseFocusClickRaisesOff",
3464 "* MouseFocusClickRaises",
3465 "* StippledTitleOff",
3466 "* StippledTitle",
3467 NULL,
3468 NULL,
3469 NULL,
3470 NULL,
3471 "* ManualPlacementHonorsStartsOnPage",
3472 "* ManualPlacementIgnoresStartsOnPage",
3473 /* These options are mapped to the BugOpts command */
3474 "RaiseOverNativeWindows on",
3475 "RaiseOverNativeWindows off"
3476 };
3477
3478 fvwm_msg(ERR, "SetGlobalOptions",
3479 "The GlobalOpts command is obsolete.");
3480 for (action = GetNextSimpleOption(action, &opt); opt;
3481 action = GetNextSimpleOption(action, &opt))
3482 {
3483 replace = NULL;
3484 is_bugopt = False;
3485
3486 i = GetTokenIndex(opt, optlist, 0, NULL);
3487 if (i > -1)
3488 {
3489 char *cmd;
3490 char *tmp;
3491
3492 replace = replacelist[i];
3493 if (replace == NULL)
3494 {
3495 replace = &(buf[0]);
3496 sprintf(buf, "* %s", opt);
3497 }
3498 else if (*replace != '*')
3499 {
3500 is_bugopt = True;
3501 }
3502 tmp = action;
3503 action = replace;
3504 if (!is_bugopt)
3505 {
3506 CMD_Style(F_PASS_ARGS);
3507 cmd = "Style";
3508 }
3509 else
3510 {
3511 CMD_BugOpts(F_PASS_ARGS);
3512 cmd = "BugOpts";
3513 }
3514 action = tmp;
3515 fvwm_msg(
3516 ERR, "SetGlobalOptions",
3517 "Please replace 'GlobalOpts %s' with '%s %s'.",
3518 opt, cmd, replace);
3519 }
3520 else
3521 {
3522 fvwm_msg(ERR, "SetGlobalOptions",
3523 "Unknown Global Option '%s'", opt);
3524 }
3525 /* should never be null, but checking anyways... */
3526 if (opt)
3527 {
3528 free(opt);
3529 }
3530 }
3531 if (opt)
3532 {
3533 free(opt);
3534 }
3535
3536 return;
3537 }
3538
3539 void CMD_BugOpts(F_CMD_ARGS)
3540 {
3541 char *opt;
3542 int toggle;
3543 char *optstring;
3544
3545 /* fvwm_msg(DBG,"SetGlobalOptions","init action == '%s'\n",action); */
3546 while (action && *action && *action != '\n')
3547 {
3548 action = GetNextFullOption(action, &optstring);
3549 if (!optstring)
3550 {
3551 /* no more options */
3552 return;
3553 }
3554 toggle = ParseToggleArgument(
3555 SkipNTokens(optstring,1), NULL, 2, False);
3556 opt = PeekToken(optstring, NULL);
3557 free(optstring);
3558
3559 if (!opt)
3560 {
3561 return;
3562 }
3563 /* toggle = ParseToggleArgument(rest, &rest, 2, False);*/
3564
3565 if (StrEquals(opt, "FlickeringMoveWorkaround"))
3566 {
3567 switch (toggle)
3568 {
3569 case -1:
3570 Scr.bo.do_disable_configure_notify ^= 1;
3571 break;
3572 case 0:
3573 case 1:
3574 Scr.bo.do_disable_configure_notify = toggle;
3575 break;
3576 default:
3577 Scr.bo.do_disable_configure_notify = 0;
3578 break;
3579 }
3580 }
3581 else if (StrEquals(opt, "MixedVisualWorkaround"))
3582 {
3583 switch (toggle)
3584 {
3585 case -1:
3586 Scr.bo.do_install_root_cmap ^= 1;
3587 break;
3588 case 0:
3589 case 1:
3590 Scr.bo.do_install_root_cmap = toggle;
3591 break;
3592 default:
3593 Scr.bo.do_install_root_cmap = 0;
3594 break;
3595 }
3596 }
3597 else if (StrEquals(opt, "ModalityIsEvil"))
3598 {
3599 switch (toggle)
3600 {
3601 case -1:
3602 Scr.bo.is_modality_evil ^= 1;
3603 break;
3604 case 0:
3605 case 1:
3606 Scr.bo.is_modality_evil = toggle;
3607 break;
3608 default:
3609 Scr.bo.is_modality_evil = 0;
3610 break;
3611 }
3612 if (Scr.bo.is_modality_evil)
3613 {
3614 SetMWM_INFO(Scr.NoFocusWin);
3615 }
3616 }
3617 else if (StrEquals(opt, "RaiseOverNativeWindows"))
3618 {
3619 switch (toggle)
3620 {
3621 case -1:
3622 Scr.bo.is_raise_hack_needed ^= 1;
3623 break;
3624 case 0:
3625 case 1:
3626 Scr.bo.is_raise_hack_needed = toggle;
3627 break;
3628 default:
3629 Scr.bo.is_raise_hack_needed = 0;
3630 break;
3631 }
3632 }
3633 else if (StrEquals(opt, "RaiseOverUnmanaged"))
3634 {
3635 switch (toggle)
3636 {
3637 case -1:
3638 Scr.bo.do_raise_over_unmanaged ^= 1;
3639 break;
3640 case 0:
3641 case 1:
3642 Scr.bo.do_raise_over_unmanaged = toggle;
3643 break;
3644 default:
3645 Scr.bo.do_raise_over_unmanaged = 0;
3646 break;
3647 }
3648 }
3649 else if (StrEquals(opt, "FlickeringQtDialogsWorkaround"))
3650 {
3651 switch (toggle)
3652 {
3653 case -1:
3654 Scr.bo.do_enable_flickering_qt_dialogs_workaround ^= 1;
3655 break;
3656 case 0:
3657 case 1:
3658 Scr.bo.do_enable_flickering_qt_dialogs_workaround = toggle;
3659 break;
3660 default:
3661 Scr.bo.do_enable_flickering_qt_dialogs_workaround = 0;
3662 break;
3663 }
3664 }
3665 else if (StrEquals(opt, "QtDragnDropWorkaround") )
3666 {
3667 switch (toggle)
3668 {
3669 case -1:
3670 Scr.bo.do_enable_qt_drag_n_drop_workaround ^= 1;
3671 break;
3672 case 0:
3673 case 1:
3674 Scr.bo.do_enable_qt_drag_n_drop_workaround = toggle;
3675 break;
3676 default:
3677 Scr.bo.do_enable_qt_drag_n_drop_workaround = 0;
3678 break;
3679 }
3680 }
3681 else if (EWMH_BugOpts(opt, toggle))
3682 {
3683 /* work is done in EWMH_BugOpts */
3684 }
3685 else if (StrEquals(opt, "DisplayNewWindowNames"))
3686 {
3687 switch (toggle)
3688 {
3689 case -1:
3690 Scr.bo.do_display_new_window_names ^= 1;
3691 break;
3692 case 0:
3693 case 1:
3694 Scr.bo.do_display_new_window_names = toggle;
3695 break;
3696 default:
3697 Scr.bo.do_display_new_window_names = 0;
3698 break;
3699 }
3700 }
3701 else if (StrEquals(opt, "ExplainWindowPlacement"))
3702 {
3703 switch (toggle)
3704 {
3705 case -1:
3706 Scr.bo.do_explain_window_placement ^= 1;
3707 break;
3708 case 0:
3709 case 1:
3710 Scr.bo.do_explain_window_placement = toggle;
3711 break;
3712 default:
3713 Scr.bo.do_explain_window_placement = 0;
3714 break;
3715 }
3716 }
3717 else if (StrEquals(opt, "DebugCRMotionMethod"))
3718 {
3719 switch (toggle)
3720 {
3721 case -1:
3722 Scr.bo.do_debug_cr_motion_method ^= 1;
3723 break;
3724 case 0:
3725 case 1:
3726 Scr.bo.do_debug_cr_motion_method = toggle;
3727 break;
3728 default:
3729 Scr.bo.do_debug_cr_motion_method = 0;
3730 break;
3731 }
3732 }
3733 else if (StrEquals(opt, "TransliterateUtf8"))
3734 {
3735 FiconvSetTransliterateUtf8(toggle);
3736 }
3737 else
3738 {
3739 fvwm_msg(ERR, "SetBugOptions",
3740 "Unknown Bug Option '%s'", opt);
3741 }
3742 }
3743
3744 return;
3745 }
3746
3747 void CMD_Emulate(F_CMD_ARGS)
3748 {
3749 char *style;
3750
3751 style = PeekToken(action, NULL);
3752 if (!style || StrEquals(style, "fvwm"))
3753 {
3754 Scr.gs.do_emulate_mwm = False;
3755 Scr.gs.do_emulate_win = False;
3756 }
3757 else if (StrEquals(style, "mwm"))
3758 {
3759 Scr.gs.do_emulate_mwm = True;
3760 Scr.gs.do_emulate_win = False;
3761 }
3762 else if (StrEquals(style, "win"))
3763 {
3764 Scr.gs.do_emulate_mwm = False;
3765 Scr.gs.do_emulate_win = True;
3766 }
3767 else
3768 {
3769 fvwm_msg(ERR, "Emulate", "Unknown style '%s'", style);
3770 return;
3771 }
3772 Scr.flags.do_need_window_update = 1;
3773 Scr.flags.has_default_font_changed = 1;
3774 Scr.flags.has_default_color_changed = 1;
3775
3776 return;
3777 }
3778
3779 void CMD_ColorLimit(F_CMD_ARGS)
3780 {
3781 fvwm_msg(
3782 WARN, "ColorLimit", "ColorLimit is obsolete,\n\tuse the "
3783 "fvwm -color-limit option");
3784
3785 return;
3786 }
3787
3788
3789 /* set animation parameters */
3790 void CMD_SetAnimation(F_CMD_ARGS)
3791 {
3792 char *opt;
3793 int delay;
3794 float pct;
3795 int i = 0;
3796
3797 opt = PeekToken(action, &action);
3798 if (!opt || sscanf(opt,"%d",&delay) != 1)
3799 {
3800 fvwm_msg(ERR,"SetAnimation",
3801 "Improper milli-second delay as first argument");
3802 return;
3803 }
3804 if (delay > 500)
3805 {
3806 fvwm_msg(WARN,"SetAnimation",
3807 "Using longer than .5 seconds as between frame"
3808 " animation delay");
3809 }
3810 cmsDelayDefault = delay;
3811 for (opt = PeekToken(action, &action); opt;
3812 opt = PeekToken(action, &action))
3813 {
3814 if (sscanf(opt,"%f",&pct) != 1)
3815 {
3816 fvwm_msg(ERR,"SetAnimation",
3817 "Use fractional values ending in 1.0 as args"
3818 " 2 and on");
3819 return;
3820 }
3821 rgpctMovementDefault[i++] = pct;
3822 }
3823 /* No pct entries means don't change them at all */
3824 if (i > 0 && rgpctMovementDefault[i-1] != 1.0)
3825 {
3826 rgpctMovementDefault[i++] = 1.0;
3827 }
3828
3829 return;
3830 }
3831
3832 /* Determine which modifiers are required with a keycode to make <keysym>. */
3833 static Bool FKeysymToKeycode (Display *dpy, KeySym keysym,
3834 unsigned int *keycode, unsigned int *modifiers)
3835 {
3836 int m;
3837
3838 *keycode = XKeysymToKeycode(dpy, keysym);
3839 *modifiers = 0;
3840
3841 for (m = 0; m <= 8; ++m)
3842 {
3843 KeySym ks = XKeycodeToKeysym(dpy, *keycode, m);
3844 if (ks == keysym)
3845 {
3846 switch (m)
3847 {
3848 case 0: /* No modifiers */
3849 break;
3850 case 1: /* Shift modifier */
3851 *modifiers |= ShiftMask;
3852 break;
3853 default:
3854 fvwm_msg(ERR, "FKeysymToKeycode",
3855 "Unhandled modifier %d", m);
3856 break;
3857 }
3858 return True;
3859 }
3860 }
3861 return False;
3862 }
3863
3864 static void __fake_event(F_CMD_ARGS, FakeEventType type)
3865 {
3866 char *token;
3867 char *optlist[] = {
3868 "press", "p",
3869 "release", "r",
3870 "wait", "w",
3871 "modifiers", "m",
3872 "depth", "d",
3873 NULL
3874 };
3875 unsigned int mask = 0;
3876 Window root = Scr.Root;
3877 int maxdepth = 0;
3878 static char args[128];
3879 strncpy(args, action, sizeof(args) - 1);
3880
3881 /* get the mask of pressed/released buttons/keys */
3882 FQueryPointer(
3883 dpy, Scr.Root, &root, &JunkRoot, &JunkX, &JunkY, &JunkX,
3884 &JunkY, &mask);
3885
3886 token = PeekToken(action, &action);
3887 while (token && action)
3888 {
3889 int index = GetTokenIndex(token, optlist, 0, NULL);
3890 int val, depth;
3891 XEvent e;
3892 Window w;
3893 Window child_w;
3894 int x = 0;
3895 int y = 0;
3896 int rx = 0;
3897 int ry = 0;
3898 Bool do_unset;
3899 long add_mask = 0;
3900 KeySym keysym = NoSymbol;
3901
3902 XFlush(dpy);
3903 do_unset = True;
3904 switch (index)
3905 {
3906 case 0:
3907 case 1:
3908 do_unset = False;
3909 /* fall through */
3910 case 2:
3911 case 3:
3912 /* key/button press or release */
3913 if (type == FakeMouseEvent)
3914 {
3915 if ((GetIntegerArguments(
3916 action, &action, &val, 1) != 1) ||
3917 val < 1 ||
3918 val > NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
3919 {
3920 fvwm_msg(
3921 ERR, "__fake_event",
3922 "Invalid button specifier in"
3923 " \"%s\" for FakeClick.", args);
3924 return; /* error */
3925 }
3926 }
3927 else /* type == FakeKeyEvent */
3928 {
3929 char *key = PeekToken(action, &action);
3930 if (key == NULL)
3931 {
3932 fvwm_msg(
3933 ERR, "__fake_event",
3934 "No keysym specifier in \"%s\""
3935 " for FakeKeypress.", args);
3936 return;
3937 }
3938
3939 /* Do *NOT* use FvwmStringToKeysym() as it is
3940 * case insensitive. */
3941 keysym = XStringToKeysym(key);
3942 if (keysym == NoSymbol)
3943 {
3944 fvwm_msg(
3945 ERR, "__fake_event",
3946 "Invalid keysym specifier (%s)"
3947 " in \"%s\" for FakeKeypress.",
3948 key, args);
3949 return;
3950 }
3951 }
3952
3953 w = None;
3954 child_w = root;
3955 for (depth = 1;
3956 depth != maxdepth &&
3957 w != child_w && child_w != None;
3958 depth++)
3959 {
3960 w = child_w;
3961 if (FQueryPointer(
3962 dpy, w, &root, &child_w,
3963 &rx, &ry, &x, &y,
3964 &JunkMask) == False)
3965 {
3966 /* pointer is on a different
3967 * screen - that's okay here */
3968 }
3969 }
3970
3971 if (type == FakeMouseEvent)
3972 {
3973 e.type = (do_unset) ?
3974 ButtonRelease : ButtonPress;
3975 e.xbutton.display = dpy;
3976 e.xbutton.window = w;
3977 e.xbutton.subwindow = None;
3978 e.xbutton.root = root;
3979 e.xbutton.time = fev_get_evtime();
3980 e.xbutton.x = x;
3981 e.xbutton.y = y;
3982 e.xbutton.x_root = rx;
3983 e.xbutton.y_root = ry;
3984 e.xbutton.button = val;
3985 e.xbutton.state = mask;
3986 e.xbutton.same_screen = (Scr.Root == root);
3987 /* SS: I think this mask handling code is
3988 * buggy.
3989 * The value of <mask> is overridden during a
3990 * "wait" operation. Also why are we only using
3991 * Button1Mask? What if the user has requested
3992 * a FakeClick using some other button? */
3993 /* DV: Button1Mask is actually a bit. Shifting
3994 * it by (val -1) bits to the left gives
3995 * Button2Mask, Button3Mask etc. */
3996 if (do_unset)
3997 {
3998 mask &= ~(Button1Mask << (val - 1));
3999 }
4000 else
4001 {
4002 mask |= (Button1Mask << (val - 1));
4003 }
4004 add_mask = (do_unset) ?
4005 ButtonPressMask : ButtonReleaseMask;
4006 }
4007 else
4008 {
4009 /* type == FakeKeyEvent */
4010 e.type = (do_unset ? KeyRelease : KeyPress);
4011 e.xkey.display = dpy;
4012 e.xkey.subwindow = None;
4013 e.xkey.root = root;
4014 e.xkey.time = fev_get_evtime();
4015 e.xkey.x = x;
4016 e.xkey.y = y;
4017 e.xkey.x_root = rx;
4018 e.xkey.y_root = ry;
4019 e.xkey.same_screen = (Scr.Root == root);
4020
4021 w = e.xkey.window = exc->w.w;
4022
4023 if (FKeysymToKeycode(
4024 dpy, keysym, &(e.xkey.keycode),
4025 &(e.xkey.state)) != True)
4026 {
4027 fvwm_msg(DBG, "__fake_event",
4028 "FKeysymToKeycode failed");
4029 return;
4030 }
4031 e.xkey.state |= mask;
4032 add_mask = (do_unset) ?
4033 KeyReleaseMask : KeyPressMask;
4034 }
4035 FSendEvent(dpy, w, True,
4036 SubstructureNotifyMask | add_mask, &e);
4037 XFlush(dpy);
4038 break;
4039 case 4:
4040 case 5:
4041 /* wait */
4042 if ((GetIntegerArguments(
4043 action, &action, &val, 1) != 1) ||
4044 val <= 0 || val > 1000000)
4045 {
4046 fvwm_msg(ERR, "__fake_event",
4047 "Invalid wait value in \"%s\"", args);
4048 return;
4049 }
4050
4051 usleep(1000 * val);
4052 if (FQueryPointer(
4053 dpy, Scr.Root, &root, &JunkRoot,
4054 &JunkX, &JunkY, &JunkX, &JunkY,
4055 &mask) == False)
4056 {
4057 /* pointer is on a different screen -
4058 * that's okay here */
4059 }
4060 break;
4061 case 6:
4062 case 7:
4063 /* set modifier */
4064 if (GetIntegerArguments(action, &action, &val, 1) != 1)
4065 {
4066 fvwm_msg(
4067 ERR, "__fake_event",
4068 "Invalid modifier value in \"%s\"",
4069 args);
4070 return;
4071 }
4072 do_unset = False;
4073 if (val < 0)
4074 {
4075 do_unset = True;
4076 val = -val;
4077 }
4078 if (val == 6)
4079 {
4080 val = ShiftMask;
4081 }
4082 else if (val == 7)
4083 {
4084 val = LockMask;
4085 }
4086 else if (val == 8)
4087 {
4088 val = ControlMask;
4089 }
4090 else if (val >=1 && val <= 5)
4091 {
4092 val = (Mod1Mask << (val - 1));
4093 }
4094 else
4095 {
4096 /* error */
4097 return;
4098 }
4099 /* SS: Could be buggy if a "modifier" operation
4100 * preceeds a "wait" operation. */
4101 if (do_unset)
4102 {
4103 mask &= ~val;
4104 }
4105 else
4106 {
4107 mask |= val;
4108 }
4109 break;
4110 case 8:
4111 case 9:
4112 /* new max depth */
4113 if (GetIntegerArguments(action, &action, &val, 1) != 1)
4114 {
4115 fvwm_msg(ERR, "__fake_event",
4116 "Invalid depth value in \"%s\"", args);
4117 return;
4118 }
4119 maxdepth = val;
4120 break;
4121 default:
4122 fvwm_msg(ERR, "__fake_event",
4123 "Invalid command (%s) in \"%s\"", token, args);
4124 return;
4125 }
4126 if (action)
4127 {
4128 token = PeekToken(action, &action);
4129 }
4130 }
4131
4132 return;
4133 }
4134
4135 void CMD_FakeClick(F_CMD_ARGS)
4136 {
4137 __fake_event(F_PASS_ARGS, FakeMouseEvent);
4138
4139 return;
4140 }
4141
4142 void CMD_FakeKeypress(F_CMD_ARGS)
4143 {
4144 __fake_event(F_PASS_ARGS, FakeKeyEvent);
4145
4146 return;
4147 }
4148
4149 /* A function to handle stroke (olicha Nov 11, 1999) */
4150 #ifdef HAVE_STROKE
4151 void CMD_StrokeFunc(F_CMD_ARGS)
4152 {
4153 int finished = 0;
4154 int abort = 0;
4155 int modifiers = exc->x.etrigger->xbutton.state;
4156 int start_event_type = exc->x.etrigger->type;
4157 char sequence[STROKE_MAX_SEQUENCE + 1];
4158 char *stroke_action, *name;
4159 char *opt = NULL;
4160 Bool finish_on_release = True;
4161 KeySym keysym;
4162 Bool restore_repeat = False;
4163 Bool echo_sequence = False;
4164 Bool draw_motion = False;
4165 int i = 0;
4166 int *x = NULL;
4167 int *y = NULL;
4168 const int STROKE_CHUNK_SIZE = 0xff;
4169 int coords_size = STROKE_CHUNK_SIZE;
4170 Window JunkRoot, JunkChild;
4171 int JunkX, JunkY;
4172 int tmpx, tmpy;
4173 unsigned int JunkMask;
4174 Bool feed_back = False;
4175 int stroke_width = 1;
4176 XEvent e;
4177 XClassHint *class;
4178
4179
4180
4181 if (!GrabEm(CRS_STROKE, GRAB_NORMAL))
4182 {
4183 XBell(dpy, 0);
4184 return;
4185 }
4186 x = (int*)safemalloc(coords_size * sizeof(int));
4187 y = (int*)safemalloc(coords_size * sizeof(int));
4188 e = *exc->x.etrigger;
4189 /* set the default option */
4190 if (e.type == KeyPress || e.type == ButtonPress)
4191 {
4192 finish_on_release = True;
4193 }
4194 else
4195 {
4196 finish_on_release = False;
4197 }
4198
4199 /* parse the option */
4200 for (action = GetNextSimpleOption(action, &opt); opt;
4201 action = GetNextSimpleOption(action, &opt))
4202 {
4203 if (StrEquals("NotStayPressed",opt))
4204 {
4205 finish_on_release = False;
4206 }
4207 else if (StrEquals("EchoSequence",opt))
4208 {
4209 echo_sequence = True;
4210 }
4211 else if (StrEquals("DrawMotion",opt))
4212 {
4213 draw_motion = True;
4214 }
4215 else if (StrEquals("FeedBack",opt))
4216 {
4217 feed_back = True;
4218 }
4219 else if (StrEquals("StrokeWidth",opt))
4220 {
4221 /* stroke width takes a positive integer argument */
4222 if (opt)
4223 {
4224 free(opt);
4225 }
4226 action = GetNextToken(action, &opt);
4227 if (!opt)
4228 {
4229 fvwm_msg(
4230 WARN, "StrokeWidth",
4231 "needs an integer argument");
4232 }
4233 /* we allow stroke_width == 0 which means drawing a
4234 * `fast' line of width 1; the upper level of 100 is
4235 * arbitrary */
4236 else if (!sscanf(opt, "%d", &stroke_width) ||
4237 stroke_width < 0 || stroke_width > 100)
4238 {
4239 fvwm_msg(
4240 WARN, "StrokeWidth",
4241 "Bad integer argument %d",
4242 stroke_width);
4243 stroke_width = 1;
4244 }
4245 }
4246 else
4247 {
4248 fvwm_msg(WARN,"StrokeFunc","Unknown option %s", opt);
4249 }
4250 if (opt)
4251 {
4252 free(opt);
4253 }
4254 }
4255 if (opt)
4256 {
4257 free(opt);
4258 }
4259
4260 /* Force auto repeat off and grab the Keyboard to get proper
4261 * KeyRelease events if we need it.
4262 * Some computers do not support KeyRelease events, can we
4263 * check this here ? No ? */
4264 if (start_event_type == KeyPress && finish_on_release)
4265 {
4266 XKeyboardState kstate;
4267
4268 XGetKeyboardControl(dpy, &kstate);
4269 if (kstate.global_auto_repeat == AutoRepeatModeOn)
4270 {
4271 XAutoRepeatOff(dpy);
4272 restore_repeat = True;
4273 }
4274 MyXGrabKeyboard(dpy);
4275 }
4276
4277 /* be ready to get a stroke sequence */
4278 stroke_init();
4279
4280 if (draw_motion)
4281 {
4282 MyXGrabServer(dpy);
4283 if (FQueryPointer(
4284 dpy, Scr.Root, &JunkRoot, &JunkChild, &x[0], &y[0],
4285 &JunkX, &JunkY, &JunkMask) == False)
4286 {
4287 /* pointer is on a different screen */
4288 x[0] = 0;
4289 y[0] = 0;
4290 }
4291 XSetLineAttributes(
4292 dpy,Scr.XorGC,stroke_width,LineSolid,CapButt,JoinMiter);
4293 }
4294
4295 while (!finished && !abort)
4296 {
4297 /* block until there is an event */
4298 FMaskEvent(
4299 dpy, ButtonPressMask | ButtonReleaseMask |
4300 KeyPressMask | KeyReleaseMask | ButtonMotionMask |
4301 PointerMotionMask, &e);
4302 switch (e.type)
4303 {
4304 case MotionNotify:
4305 if (e.xmotion.same_screen == False)
4306 {
4307 continue;
4308 }
4309 if (e.xany.window != Scr.Root)
4310 {
4311 if (FQueryPointer(
4312 dpy, Scr.Root, &JunkRoot,
4313 &JunkChild, &tmpx, &tmpy, &JunkX,
4314 &JunkY, &JunkMask) == False)
4315 {
4316 /* pointer is on a different screen */
4317 tmpx = 0;
4318 tmpy = 0;
4319 }
4320 }
4321 else
4322 {
4323 tmpx = e.xmotion.x;
4324 tmpy = e.xmotion.y;
4325 }
4326 stroke_record(tmpx,tmpy);
4327 if (draw_motion && (x[i] != tmpx || y[i] != tmpy))
4328 {
4329 i++;
4330 if (i >= coords_size)
4331 {
4332 coords_size += STROKE_CHUNK_SIZE;
4333 x = (int*)saferealloc(
4334 (void *)x, coords_size *
4335 sizeof(int));
4336 y = (int*)saferealloc(
4337 (void *)y, coords_size *
4338 sizeof(int));
4339 }
4340 x[i] = tmpx;
4341 y[i] = tmpy;
4342 XDrawLine(
4343 dpy, Scr.Root, Scr.XorGC, x[i-1],
4344 y[i-1], x[i], y[i]);
4345 }
4346 break;
4347 case ButtonRelease:
4348 if (finish_on_release && start_event_type ==
4349 ButtonPress)
4350 {
4351 finished = 1;
4352 }
4353 break;
4354 case KeyRelease:
4355 if (finish_on_release && start_event_type == KeyPress)
4356 {
4357 finished = 1;
4358 }
4359 break;
4360 case KeyPress:
4361 keysym = XLookupKeysym(&e.xkey, 0);
4362 /* abort if Escape or Delete is pressed (as in menus.c)
4363 */
4364 if (keysym == XK_Escape || keysym == XK_Delete ||
4365 keysym == XK_KP_Separator)
4366 {
4367 abort = 1;
4368 }
4369 /* finish on enter or space (as in menus.c) */
4370 if (keysym == XK_Return || keysym == XK_KP_Enter ||
4371 keysym == XK_space)
4372 {
4373 finished = 1;
4374 }
4375 break;
4376 case ButtonPress:
4377 if (!finish_on_release)
4378 {
4379 finished = 1;
4380 }
4381 break;
4382 default:
4383 break;
4384 }
4385 }
4386
4387 if (draw_motion)
4388 {
4389 while (i > 0)
4390 {
4391 XDrawLine(
4392 dpy, Scr.Root, Scr.XorGC, x[i-1], y[i-1], x[i],
4393 y[i]);
4394 i--;
4395 }
4396 XSetLineAttributes(dpy,Scr.XorGC,0,LineSolid,CapButt,JoinMiter);
4397 MyXUngrabServer(dpy);
4398 }
4399 if (x != NULL)
4400 {
4401 free(x);
4402 free(y);
4403 }
4404 if (start_event_type == KeyPress && finish_on_release)
4405 {
4406 MyXUngrabKeyboard(dpy);
4407 }
4408 UngrabEm(GRAB_NORMAL);
4409 if (restore_repeat)
4410 {
4411 XAutoRepeatOn(dpy);
4412 }
4413
4414 /* get the stroke sequence */
4415 stroke_trans(sequence);
4416
4417 if (echo_sequence)
4418 {
4419 char num_seq[STROKE_MAX_SEQUENCE + 1];
4420
4421 for (i = 0; sequence[i] != '\0';i++)
4422 {
4423 /* Telephone to numeric pad */
4424 if ('7' <= sequence[i] && sequence[i] <= '9')
4425 {
4426 num_seq[i] = sequence[i]-6;
4427 }
4428 else if ('1' <= sequence[i] && sequence[i] <= '3')
4429 {
4430 num_seq[i] = sequence[i]+6;
4431 }
4432 else
4433 {
4434 num_seq[i] = sequence[i];
4435 }
4436 }
4437 num_seq[i++] = '\0';
4438 fvwm_msg(INFO, "StrokeFunc", "stroke sequence: %s (N%s)",
4439 sequence, num_seq);
4440 }
4441 if (abort)
4442 {
4443 return;
4444 }
4445 if (exc->w.fw == NULL)
4446 {
4447 class = NULL;
4448 name = NULL;
4449 }
4450 else
4451 {
4452 class = &exc->w.fw->class;
4453 name = exc->w.fw->name.name;
4454 }
4455 /* check for a binding */
4456 stroke_action = CheckBinding(
4457 Scr.AllBindings, sequence, 0, modifiers, GetUnusedModifiers(),
4458 exc->w.wcontext, BIND_STROKE, class, name);
4459
4460 /* execute the action */
4461 if (stroke_action != NULL)
4462 {
4463 const exec_context_t *exc2;
4464 exec_context_changes_t ecc;
4465
4466 if (feed_back && atoi(sequence) != 0)
4467 {
4468 GrabEm(CRS_WAIT, GRAB_BUSY);
4469 usleep(200000);
4470 UngrabEm(GRAB_BUSY);
4471 }
4472 ecc.x.etrigger = &e;
4473 exc2 = exc_clone_context(exc, &ecc, ECC_ETRIGGER);
4474 execute_function(cond_rc, exc2, stroke_action, 0);
4475 exc_destroy_context(exc2);
4476 }
4477
4478 return;
4479 }
4480 #endif /* HAVE_STROKE */
4481
4482 void CMD_State(F_CMD_ARGS)
4483 {
4484 unsigned int state;
4485 int toggle;
4486 int n;
4487 FvwmWindow * const fw = exc->w.fw;
4488
4489 n = GetIntegerArguments(action, &action, (int *)&state, 1);
4490 if (n <= 0)
4491 {
4492 return;
4493 }
4494 if (state < 0 || state > 31)
4495 {
4496 fvwm_msg(ERR, "CMD_State", "Illegal state %d\n", state);
4497 return;
4498 }
4499 toggle = ParseToggleArgument(action, NULL, -1, 0);
4500 state = (1 << state);
4501 switch (toggle)
4502 {
4503 case -1:
4504 TOGGLE_USER_STATES(fw, state);
4505 break;
4506 case 0:
4507 CLEAR_USER_STATES(fw, state);
4508 break;
4509 case 1:
4510 default:
4511 SET_USER_STATES(fw, state);
4512 break;
4513 }
4514
4515 return;
4516 }
CVS import of FVWM to Git.