?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add "BugOpts QtDragnDropWorkaround"
[fvwm.git] / fvwm / builtins.c
blob5811b4c99f53055b440485c14b179ce9f758c51b
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 if (fvwm_setpgrp() == -1)
2463 {
2464 fvwm_msg(ERR, "exec_function", "setpgrp failed (%s)",
2465 strerror(errno));
2466 exit(100);
2467 }
2468 if (execl(exec_shell_name, exec_shell_name, "-c", cmd, NULL) ==
2469 -1)
2470 {
2471 fvwm_msg(ERR, "exec_function", "execl failed (%s)",
2472 strerror(errno));
2473 exit(100);
2474 }
2475 }
2476 free(cmd);
2477
2478 return;
2479 }
2480
2481 void CMD_Refresh(F_CMD_ARGS)
2482 {
2483 refresh_window(Scr.Root, True);
2484
2485 return;
2486 }
2487
2488 void CMD_RefreshWindow(F_CMD_ARGS)
2489 {
2490 FvwmWindow * const fw = exc->w.fw;
2491
2492 refresh_window(
2493 (exc->w.wcontext == C_ICON) ?
2494 FW_W_ICON_TITLE(fw) : FW_W_FRAME(fw), True);
2495
2496 return;
2497 }
2498
2499 void CMD_Wait(F_CMD_ARGS)
2500 {
2501 Bool done = False;
2502 Bool redefine_cursor = False;
2503 Bool is_ungrabbed;
2504 char *escape;
2505 Window nonewin = None;
2506 char *wait_string, *rest;
2507 FvwmWindow *t;
2508
2509 /* try to get a single token */
2510 rest = GetNextToken(action, &wait_string);
2511 if (wait_string)
2512 {
2513 while (*rest && isspace((unsigned char)*rest))
2514 {
2515 rest++;
2516 }
2517 if (*rest)
2518 {
2519 int i;
2520 char *temp;
2521
2522 /* nope, multiple tokens - try old syntax */
2523
2524 /* strip leading and trailing whitespace */
2525 temp = action;
2526 while (*temp && isspace((unsigned char)*temp))
2527 {
2528 temp++;
2529 }
2530 wait_string = safestrdup(temp);
2531 for (i = strlen(wait_string) - 1; i >= 0 &&
2532 isspace(wait_string[i]); i--)
2533 {
2534 wait_string[i] = 0;
2535 }
2536 }
2537 }
2538 else
2539 {
2540 wait_string = safestrdup("");
2541 }
2542
2543 is_ungrabbed = UngrabEm(GRAB_NORMAL);
2544 while (!done && !isTerminated)
2545 {
2546 XEvent e;
2547 if (BUSY_WAIT & Scr.BusyCursor)
2548 {
2549 XDefineCursor(dpy, Scr.Root, Scr.FvwmCursors[CRS_WAIT]);
2550 redefine_cursor = True;
2551 }
2552 if (My_XNextEvent(dpy, &e))
2553 {
2554 dispatch_event(&e);
2555 if (XFindContext(
2556 dpy, e.xmap.window, FvwmContext,
2557 (caddr_t *)&t) == XCNOENT)
2558 {
2559 t = NULL;
2560 }
2561
2562 if (e.type == MapNotify && e.xmap.event == Scr.Root)
2563 {
2564 if (!*wait_string)
2565 {
2566 done = True;
2567 }
2568 if (t && matchWildcards(
2569 wait_string, t->name.name) == True)
2570 {
2571 done = True;
2572 }
2573 else if (t && t->class.res_class &&
2574 matchWildcards(
2575 wait_string,
2576 t->class.res_class) == True)
2577 {
2578 done = True;
2579 }
2580 else if (t && t->class.res_name &&
2581 matchWildcards(
2582 wait_string,
2583 t->class.res_name) == True)
2584 {
2585 done = True;
2586 }
2587 }
2588 else if (e.type == KeyPress)
2589 {
2590 /* should I be using <t> or <exc->w.fw>?
2591 * DV: t
2592 */
2593 int context;
2594 XClassHint *class;
2595 char *name;
2596
2597 context = GetContext(&t, t, &e, &nonewin);
2598 if (t != NULL)
2599 {
2600 class = &(t->class);
2601 name = t->name.name;
2602 }
2603 else
2604 {
2605 class = NULL;
2606 name = NULL;
2607 }
2608 escape = CheckBinding(
2609 Scr.AllBindings, STROKE_ARG(0)
2610 e.xkey.keycode, e.xkey.state,
2611 GetUnusedModifiers(), context,
2612 BIND_KEYPRESS, class, name);
2613 if (escape != NULL)
2614 {
2615 if (!strcasecmp(escape,"escapefunc"))
2616 {
2617 done = True;
2618 }
2619 }
2620 }
2621 }
2622 }
2623 if (redefine_cursor)
2624 {
2625 XDefineCursor(dpy, Scr.Root, Scr.FvwmCursors[CRS_ROOT]);
2626 }
2627 if (is_ungrabbed)
2628 {
2629 GrabEm(CRS_NONE, GRAB_NORMAL);
2630 }
2631 free(wait_string);
2632
2633 return;
2634 }
2635
2636 void CMD_Quit(F_CMD_ARGS)
2637 {
2638 if (master_pid != getpid())
2639 {
2640 kill(master_pid, SIGTERM);
2641 }
2642 Done(0,NULL);
2643
2644 return;
2645 }
2646
2647 void CMD_QuitScreen(F_CMD_ARGS)
2648 {
2649 Done(0,NULL);
2650
2651 return;
2652 }
2653
2654 void CMD_Echo(F_CMD_ARGS)
2655 {
2656 int len;
2657
2658 if (!action)
2659 {
2660 action = "";
2661 }
2662 len = strlen(action);
2663 if (len != 0)
2664 {
2665 if (action[len-1]=='\n')
2666 {
2667 action[len-1]='\0';
2668 }
2669 }
2670 fvwm_msg(ECHO,"Echo",action);
2671
2672 return;
2673 }
2674
2675 void CMD_PrintInfo(F_CMD_ARGS)
2676 {
2677 int verbose;
2678 char *rest, *subject = NULL;
2679
2680 rest = GetNextToken(action, &subject);
2681 if (!rest || GetIntegerArguments(rest, NULL, &verbose, 1) != 1)
2682 {
2683 verbose = 0;
2684 }
2685 if (StrEquals(subject, "Colors"))
2686 {
2687 PicturePrintColorInfo(verbose);
2688 }
2689 else if (StrEquals(subject, "Locale"))
2690 {
2691 FlocalePrintLocaleInfo(dpy, verbose);
2692 }
2693 else if (StrEquals(subject, "NLS"))
2694 {
2695 FGettextPrintLocalePath(verbose);
2696 }
2697 else if (StrEquals(subject, "style"))
2698 {
2699 print_styles(verbose);
2700 }
2701 else if (StrEquals(subject, "ImageCache"))
2702 {
2703 PicturePrintImageCache(verbose);
2704 }
2705 else if (StrEquals(subject, "Bindings"))
2706 {
2707 print_bindings();
2708 }
2709 else
2710 {
2711 fvwm_msg(ERR, "PrintInfo",
2712 "Unknown subject '%s'", action);
2713 }
2714 if (subject)
2715 {
2716 free(subject);
2717 }
2718 return;
2719 }
2720
2721 void CMD_ColormapFocus(F_CMD_ARGS)
2722 {
2723 if (MatchToken(action,"FollowsFocus"))
2724 {
2725 Scr.ColormapFocus = COLORMAP_FOLLOWS_FOCUS;
2726 }
2727 else if (MatchToken(action,"FollowsMouse"))
2728 {
2729 Scr.ColormapFocus = COLORMAP_FOLLOWS_MOUSE;
2730 }
2731 else
2732 {
2733 fvwm_msg(ERR, "SetColormapFocus",
2734 "ColormapFocus requires 1 arg: FollowsFocus or"
2735 " FollowsMouse");
2736 return;
2737 }
2738
2739 return;
2740 }
2741
2742 void CMD_ClickTime(F_CMD_ARGS)
2743 {
2744 int val;
2745
2746 if (GetIntegerArguments(action, NULL, &val, 1) != 1)
2747 {
2748 Scr.ClickTime = DEFAULT_CLICKTIME;
2749 }
2750 else
2751 {
2752 Scr.ClickTime = (val < 0)? 0 : val;
2753 }
2754
2755 /* Use a negative value during startup and change sign afterwards. This
2756 * speeds things up quite a bit. */
2757 if (fFvwmInStartup)
2758 {
2759 Scr.ClickTime = -Scr.ClickTime;
2760 }
2761
2762 return;
2763 }
2764
2765
2766 void CMD_ImagePath(F_CMD_ARGS)
2767 {
2768 PictureSetImagePath( action );
2769
2770 return;
2771 }
2772
2773 void CMD_IconPath(F_CMD_ARGS)
2774 {
2775 fvwm_msg(ERR, "iconPath_function",
2776 "IconPath is deprecated since 2.3.0; use ImagePath instead.");
2777 obsolete_imagepaths( action );
2778
2779 return;
2780 }
2781
2782 void CMD_PixmapPath(F_CMD_ARGS)
2783 {
2784 fvwm_msg(ERR, "pixmapPath_function",
2785 "PixmapPath is deprecated since 2.3.0; use ImagePath"
2786 " instead." );
2787 obsolete_imagepaths( action );
2788
2789 return;
2790 }
2791
2792 void CMD_LocalePath(F_CMD_ARGS)
2793 {
2794 FGettextSetLocalePath( action );
2795
2796 return;
2797 }
2798
2799 void CMD_ModulePath(F_CMD_ARGS)
2800 {
2801 static int need_to_free = 0;
2802
2803 setPath( &ModulePath, action, need_to_free );
2804 need_to_free = 1;
2805
2806 return;
2807 }
2808
2809 void CMD_ModuleTimeout(F_CMD_ARGS)
2810 {
2811 int timeout;
2812
2813 moduleTimeout = DEFAULT_MODULE_TIMEOUT;
2814 if (GetIntegerArguments(action, NULL, &timeout, 1) == 1 && timeout > 0)
2815 {
2816 moduleTimeout = timeout;
2817 }
2818
2819 return;
2820 }
2821
2822 void CMD_HilightColor(F_CMD_ARGS)
2823 {
2824 char *fore;
2825 char *back;
2826 #ifdef USEDECOR
2827 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
2828 {
2829 fvwm_msg(
2830 ERR, "SetHiColor",
2831 "Decors do not support the HilightColor command"
2832 " anymore. Please use"
2833 " 'Style <stylename> HilightFore <forecolor>' and"
2834 " 'Style <stylename> HilightBack <backcolor>' instead."
2835 " Sorry for the inconvenience.");
2836 return;
2837 }
2838 #endif
2839 action = GetNextToken(action, &fore);
2840 GetNextToken(action, &back);
2841 if (fore && back)
2842 {
2843 action = safemalloc(strlen(fore) + strlen(back) + 29);
2844 sprintf(action, "* HilightFore %s, HilightBack %s", fore, back);
2845 CMD_Style(F_PASS_ARGS);
2846 }
2847 if (fore)
2848 {
2849 free(fore);
2850 }
2851 if (back)
2852 {
2853 free(back);
2854 }
2855
2856 return;
2857 }
2858
2859 void CMD_HilightColorset(F_CMD_ARGS)
2860 {
2861 char *newaction;
2862
2863 #ifdef USEDECOR
2864 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
2865 {
2866 fvwm_msg(
2867 ERR, "SetHiColorset",
2868 "Decors do not support the HilightColorset command "
2869 "anymore. Please use "
2870 "'Style <stylename> HilightColorset <colorset>'"
2871 " instead. Sorry for the inconvenience.");
2872 return;
2873 }
2874 #endif
2875 if (action)
2876 {
2877 newaction = safemalloc(strlen(action) + 32);
2878 sprintf(newaction, "* HilightColorset %s", action);
2879 action = newaction;
2880 CMD_Style(F_PASS_ARGS);
2881 free(newaction);
2882 }
2883
2884 return;
2885 }
2886
2887 void CMD_TitleStyle(F_CMD_ARGS)
2888 {
2889 do_title_style(F_PASS_ARGS, False);
2890
2891 return;
2892 } /* SetTitleStyle */
2893
2894 /*
2895 *
2896 * Appends a titlestyle (veliaa@rpi.edu)
2897 *
2898 */
2899 void CMD_AddTitleStyle(F_CMD_ARGS)
2900 {
2901 do_title_style(F_PASS_ARGS, True);
2902
2903 return;
2904 }
2905
2906 void CMD_PropertyChange(F_CMD_ARGS)
2907 {
2908 char string[256];
2909 char *token;
2910 char *rest;
2911 int ret;
2912 unsigned long argument;
2913 unsigned long data1;
2914 unsigned long data2;
2915
2916 /* argument */
2917 token = PeekToken(action, &rest);
2918 if (token == NULL)
2919 {
2920 return;
2921 }
2922 ret = sscanf(token, "%lu", &argument);
2923 if (ret < 1)
2924 {
2925 return;
2926 }
2927 /* data1 */
2928 data1 = 0;
2929 token = PeekToken(rest, &rest);
2930 if (token != NULL)
2931 {
2932 ret = sscanf(token, "%lu", &data1);
2933 if (ret < 1)
2934 {
2935 rest = NULL;
2936 }
2937 }
2938 /* data2 */
2939 data2 = 0;
2940 token = PeekToken(rest, &rest);
2941 if (token != NULL)
2942 {
2943 ret = sscanf(token, "%lu", &data2);
2944 if (ret < 1)
2945 {
2946 rest = NULL;
2947 }
2948 }
2949 /* string */
2950 memset(string, 0, 256);
2951 if (rest != NULL)
2952 {
2953 ret = sscanf(rest, "%255c", &(string[0]));
2954 }
2955 BroadcastPropertyChange(argument, data1, data2, string);
2956
2957 return;
2958 }
2959
2960 void CMD_DefaultIcon(F_CMD_ARGS)
2961 {
2962 if (Scr.DefaultIcon)
2963 {
2964 free(Scr.DefaultIcon);
2965 }
2966 GetNextToken(action, &Scr.DefaultIcon);
2967
2968 return;
2969 }
2970
2971 void CMD_DefaultColorset(F_CMD_ARGS)
2972 {
2973 int cset;
2974
2975 if (GetIntegerArguments(action, NULL, &cset, 1) != 1)
2976 {
2977 return;
2978 }
2979 Scr.DefaultColorset = cset;
2980 if (Scr.DefaultColorset < 0)
2981 {
2982 Scr.DefaultColorset = -1;
2983 }
2984 alloc_colorset(Scr.DefaultColorset);
2985 Scr.flags.do_need_window_update = 1;
2986 Scr.flags.has_default_color_changed = 1;
2987
2988 return;
2989 }
2990
2991 void CMD_DefaultColors(F_CMD_ARGS)
2992 {
2993 char *fore = NULL;
2994 char *back = NULL;
2995
2996 action = GetNextToken(action, &fore);
2997 if (action)
2998 {
2999 action = GetNextToken(action, &back);
3000 }
3001 if (!back)
3002 {
3003 back = safestrdup(DEFAULT_BACK_COLOR);
3004 }
3005 if (!fore)
3006 {
3007 fore = safestrdup(DEFAULT_FORE_COLOR);
3008 }
3009 if (!StrEquals(fore, "-"))
3010 {
3011 PictureFreeColors(dpy, Pcmap, &Scr.StdFore, 1, 0, True);
3012 Scr.StdFore = GetColor(fore);
3013 }
3014 if (!StrEquals(back, "-"))
3015 {
3016 PictureFreeColors(dpy, Pcmap, &Scr.StdBack, 3, 0, True);
3017 Scr.StdBack = GetColor(back);
3018 Scr.StdHilite = GetHilite(Scr.StdBack);
3019 Scr.StdShadow = GetShadow(Scr.StdBack);
3020 }
3021 free(fore);
3022 free(back);
3023
3024 Scr.DefaultColorset = -1;
3025 Scr.flags.do_need_window_update = 1;
3026 Scr.flags.has_default_color_changed = 1;
3027
3028 return;
3029 }
3030
3031 void CMD_DefaultFont(F_CMD_ARGS)
3032 {
3033 char *font;
3034 FlocaleFont *new_font;
3035 FvwmWindow *t;
3036
3037 font = PeekToken(action, &action);
3038 if (!font)
3039 {
3040 /* Try 'fixed', pass NULL font name */
3041 }
3042 if (!(new_font = FlocaleLoadFont(dpy, font, "fvwm")))
3043 {
3044 if (Scr.DefaultFont == NULL)
3045 {
3046 exit(1);
3047 }
3048 else
3049 {
3050 return;
3051 }
3052 }
3053 FlocaleUnloadFont(dpy, Scr.DefaultFont);
3054 Scr.DefaultFont = new_font;
3055 /* we should do that here because a redraw can happen before
3056 flush_window_updates is called ... */
3057 for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
3058 {
3059 if (USING_DEFAULT_ICON_FONT(t))
3060 {
3061 t->icon_font = Scr.DefaultFont;
3062 }
3063 if (USING_DEFAULT_WINDOW_FONT(t))
3064 {
3065 t->title_font = Scr.DefaultFont;
3066 }
3067 }
3068 /* set flags to indicate that the font has changed */
3069 Scr.flags.do_need_window_update = 1;
3070 Scr.flags.has_default_font_changed = 1;
3071
3072 return;
3073 }
3074
3075 void CMD_IconFont(F_CMD_ARGS)
3076 {
3077 char *newaction;
3078
3079 #ifdef USEDECOR
3080 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
3081 {
3082 fvwm_msg(
3083 ERR, "LoadIconFont",
3084 "Decors do not support the IconFont command anymore."
3085 " Please use 'Style <stylename> IconFont <fontname>'"
3086 " instead. Sorry for the inconvenience.");
3087 return;
3088 }
3089 #endif
3090 if (action)
3091 {
3092 newaction = safemalloc(strlen(action) + 16);
3093 sprintf(newaction, "* IconFont %s", action);
3094 action = newaction;
3095 CMD_Style(F_PASS_ARGS);
3096 free(newaction);
3097 }
3098
3099 return;
3100 }
3101
3102 void CMD_WindowFont(F_CMD_ARGS)
3103 {
3104 char *newaction;
3105
3106 #ifdef USEDECOR
3107 if (Scr.cur_decor && Scr.cur_decor != &Scr.DefaultDecor)
3108 {
3109 fvwm_msg(
3110 ERR, "LoadWindowFont",
3111 "Decors do not support the WindowFont command anymore."
3112 " Please use 'Style <stylename> Font <fontname>'"
3113 " instead. Sorry for the inconvenience.");
3114 return;
3115 }
3116 #endif
3117 if (action)
3118 {
3119 newaction = safemalloc(strlen(action) + 16);
3120 sprintf(newaction, "* Font %s", action);
3121 action = newaction;
3122 CMD_Style(F_PASS_ARGS);
3123 free(newaction);
3124 }
3125
3126 return;
3127 }
3128
3129 /*
3130 *
3131 * Changes the window's FvwmDecor pointer (veliaa@rpi.edu)
3132 *
3133 */
3134 void CMD_ChangeDecor(F_CMD_ARGS)
3135 {
3136 char *item;
3137 int old_height;
3138 FvwmDecor *decor = &Scr.DefaultDecor;
3139 FvwmDecor *found = NULL;
3140 FvwmWindow * const fw = exc->w.fw;
3141
3142 item = PeekToken(action, &action);
3143 if (!action || !item)
3144 {
3145 return;
3146 }
3147 /* search for tag */
3148 for (; decor; decor = decor->next)
3149 {
3150 if (decor->tag && StrEquals(item, decor->tag))
3151 {
3152 found = decor;
3153 break;
3154 }
3155 }
3156 if (!found)
3157 {
3158 XBell(dpy, 0);
3159 return;
3160 }
3161 SET_DECOR_CHANGED(fw, 1);
3162 old_height = (fw->decor) ? fw->decor->title_height : 0;
3163 fw->decor = found;
3164 apply_decor_change(fw);
3165
3166 return;
3167 }
3168
3169 /*
3170 *
3171 * Destroys an FvwmDecor (veliaa@rpi.edu)
3172 *
3173 */
3174 void CMD_DestroyDecor(F_CMD_ARGS)
3175 {
3176 char *item;
3177 FvwmDecor *decor = Scr.DefaultDecor.next;
3178 FvwmDecor *prev = &Scr.DefaultDecor, *found = NULL;
3179 Bool do_recreate = False;
3180
3181 item = PeekToken(action, &action);
3182 if (!item)
3183 {
3184 return;
3185 }
3186 if (StrEquals(item, "recreate"))
3187 {
3188 do_recreate = True;
3189 item = PeekToken(action, NULL);
3190 }
3191 if (!item)
3192 {
3193 return;
3194 }
3195
3196 /* search for tag */
3197 for (; decor; decor = decor->next)
3198 {
3199 if (decor->tag && StrEquals(item, decor->tag))
3200 {
3201 found = decor;
3202 break;
3203 }
3204 prev = decor;
3205 }
3206
3207 if (found && (found != &Scr.DefaultDecor || do_recreate))
3208 {
3209 if (!do_recreate)
3210 {
3211 __remove_window_decors(F_PASS_ARGS, found);
3212 }
3213 DestroyFvwmDecor(found);
3214 if (do_recreate)
3215 {
3216 int i;
3217
3218 InitFvwmDecor(found);
3219 found->tag = safestrdup(item);
3220 Scr.flags.do_need_window_update = 1;
3221 found->flags.has_changed = 1;
3222 found->flags.has_title_height_changed = 0;
3223 found->titlebar.flags.has_changed = 1;
3224 for (i = 0; i < NUMBER_OF_TITLE_BUTTONS; ++i)
3225 {
3226 TB_FLAGS(found->buttons[i]).has_changed = 1;
3227 }
3228 }
3229 else
3230 {
3231 prev->next = found->next;
3232 free(found);
3233 }
3234 }
3235
3236 return;
3237 }
3238
3239 /*
3240 *
3241 * Initiates an AddToDecor (veliaa@rpi.edu)
3242 *
3243 */
3244 void CMD_AddToDecor(F_CMD_ARGS)
3245 {
3246 FvwmDecor *decor;
3247 FvwmDecor *found = NULL;
3248 char *item = NULL;
3249
3250 action = GetNextToken(action, &item);
3251 if (!item)
3252 {
3253 return;
3254 }
3255 if (!action)
3256 {
3257 free(item);
3258 return;
3259 }
3260 /* search for tag */
3261 for (decor = &Scr.DefaultDecor; decor; decor = decor->next)
3262 {
3263 if (decor->tag && StrEquals(item, decor->tag))
3264 {
3265 found = decor;
3266 break;
3267 }
3268 }
3269 if (!found)
3270 {
3271 /* then make a new one */
3272 found = (FvwmDecor *)safemalloc(sizeof( FvwmDecor ));
3273 InitFvwmDecor(found);
3274 found->tag = item; /* tag it */
3275 /* add it to list */
3276 for (decor = &Scr.DefaultDecor; decor->next;
3277 decor = decor->next)
3278 {
3279 /* nop */
3280 }
3281 decor->next = found;
3282 }
3283 else
3284 {
3285 free(item);
3286 }
3287
3288 if (found)
3289 {
3290 AddToDecor(F_PASS_ARGS, found);
3291 /* Set + state to last decor */
3292 set_last_added_item(ADDED_DECOR, found);
3293 }
3294
3295 return;
3296 }
3297 #endif /* USEDECOR */
3298
3299
3300 /*
3301 *
3302 * Updates window decoration styles (veliaa@rpi.edu)
3303 *
3304 */
3305 void CMD_UpdateDecor(F_CMD_ARGS)
3306 {
3307 FvwmWindow *fw2;
3308 #ifdef USEDECOR
3309 FvwmDecor *decor, *found = NULL;
3310 FvwmWindow *hilight = Scr.Hilite;
3311 char *item = NULL;
3312
3313 action = GetNextToken(action, &item);
3314 if (item)
3315 {
3316 /* search for tag */
3317 for (decor = &Scr.DefaultDecor; decor; decor = decor->next)
3318 {
3319 if (decor->tag && StrEquals(item, decor->tag))
3320 {
3321 found = decor;
3322 break;
3323 }
3324 }
3325 free(item);
3326 }
3327 #endif
3328
3329 for (fw2 = Scr.FvwmRoot.next; fw2; fw2 = fw2->next)
3330 {
3331 #ifdef USEDECOR
3332 /* update specific decor, or all */
3333 if (found)
3334 {
3335 if (fw2->decor == found)
3336 {
3337 border_draw_decorations(
3338 fw2, PART_ALL, True, True, CLEAR_ALL,
3339 NULL, NULL);
3340 border_draw_decorations(
3341 fw2, PART_ALL, False, True, CLEAR_ALL,
3342 NULL, NULL);
3343 }
3344 }
3345 else
3346 #endif
3347 {
3348 border_draw_decorations(
3349 fw2, PART_ALL, True, True, CLEAR_ALL, NULL,
3350 NULL);
3351 border_draw_decorations(
3352 fw2, PART_ALL, False, True, CLEAR_ALL, NULL,
3353 NULL);
3354 }
3355 }
3356 border_draw_decorations(
3357 hilight, PART_ALL, True, True, CLEAR_ALL, NULL, NULL);
3358 }
3359
3360 void CMD_ButtonStyle(F_CMD_ARGS)
3361 {
3362 do_button_style(F_PASS_ARGS, False);
3363
3364 return;
3365 }
3366
3367 /*
3368 *
3369 * Appends a button decoration style (veliaa@rpi.edu)
3370 *
3371 */
3372 void CMD_AddButtonStyle(F_CMD_ARGS)
3373 {
3374 do_button_style(F_PASS_ARGS, True);
3375
3376 return;
3377 }
3378
3379 void CMD_SetEnv(F_CMD_ARGS)
3380 {
3381 char *szVar = NULL;
3382 char *szValue = NULL;
3383 char *szPutenv = NULL;
3384
3385 action = GetNextToken(action, &szVar);
3386 if (!szVar)
3387 {
3388 return;
3389 }
3390 action = GetNextToken(action, &szValue);
3391 if (!szValue)
3392 {
3393 szValue = safestrdup("");
3394 }
3395 szPutenv = safemalloc(strlen(szVar) + strlen(szValue) + 2);
3396 sprintf(szPutenv,"%s=%s", szVar, szValue);
3397 flib_putenv(szVar, szPutenv);
3398 free(szVar);
3399 free(szPutenv);
3400 free(szValue);
3401
3402 return;
3403 }
3404
3405 void CMD_UnsetEnv(F_CMD_ARGS)
3406 {
3407 char *szVar = NULL;
3408
3409 szVar = PeekToken(action, &action);
3410 if (!szVar)
3411 {
3412 return;
3413 }
3414 flib_unsetenv(szVar);
3415
3416 return;
3417 }
3418
3419 void CMD_GlobalOpts(F_CMD_ARGS)
3420 {
3421 char *opt;
3422 char *replace;
3423 char buf[64];
3424 int i;
3425 Bool is_bugopt;
3426 char *optlist[] = {
3427 "WindowShadeShrinks",
3428 "WindowShadeScrolls",
3429 "SmartPlacementIsReallySmart",
3430 "SmartPlacementIsNormal",
3431 "ClickToFocusDoesntPassClick",
3432 "ClickToFocusPassesClick",
3433 "ClickToFocusDoesntRaise",
3434 "ClickToFocusRaises",
3435 "MouseFocusClickDoesntRaise",
3436 "MouseFocusClickRaises",
3437 "NoStipledTitles",
3438 "StipledTitles",
3439 "CaptureHonorsStartsOnPage",
3440 "CaptureIgnoresStartsOnPage",
3441 "RecaptureHonorsStartsOnPage",
3442 "RecaptureIgnoresStartsOnPage",
3443 "ActivePlacementHonorsStartsOnPage",
3444 "ActivePlacementIgnoresStartsOnPage",
3445 "RaiseOverNativeWindows",
3446 "IgnoreNativeWindows",
3447 NULL
3448 };
3449 char *replacelist[] = {
3450 /* These options are mapped to the Style * command */
3451 NULL, /* NULL means to use "Style * <optionname>" */
3452 NULL,
3453 "* MinOverlapPlacement",
3454 "* TileCascadePlacement",
3455 "* ClickToFocusPassesClickOff",
3456 "* ClickToFocusPassesClick",
3457 "* ClickToFocusRaisesOff",
3458 "* ClickToFocusRaises",
3459 "* MouseFocusClickRaisesOff",
3460 "* MouseFocusClickRaises",
3461 "* StippledTitleOff",
3462 "* StippledTitle",
3463 NULL,
3464 NULL,
3465 NULL,
3466 NULL,
3467 "* ManualPlacementHonorsStartsOnPage",
3468 "* ManualPlacementIgnoresStartsOnPage",
3469 /* These options are mapped to the BugOpts command */
3470 "RaiseOverNativeWindows on",
3471 "RaiseOverNativeWindows off"
3472 };
3473
3474 fvwm_msg(ERR, "SetGlobalOptions",
3475 "The GlobalOpts command is obsolete.");
3476 for (action = GetNextSimpleOption(action, &opt); opt;
3477 action = GetNextSimpleOption(action, &opt))
3478 {
3479 replace = NULL;
3480 is_bugopt = False;
3481
3482 i = GetTokenIndex(opt, optlist, 0, NULL);
3483 if (i > -1)
3484 {
3485 char *cmd;
3486 char *tmp;
3487
3488 replace = replacelist[i];
3489 if (replace == NULL)
3490 {
3491 replace = &(buf[0]);
3492 sprintf(buf, "* %s", opt);
3493 }
3494 else if (*replace != '*')
3495 {
3496 is_bugopt = True;
3497 }
3498 tmp = action;
3499 action = replace;
3500 if (!is_bugopt)
3501 {
3502 CMD_Style(F_PASS_ARGS);
3503 cmd = "Style";
3504 }
3505 else
3506 {
3507 CMD_BugOpts(F_PASS_ARGS);
3508 cmd = "BugOpts";
3509 }
3510 action = tmp;
3511 fvwm_msg(
3512 ERR, "SetGlobalOptions",
3513 "Please replace 'GlobalOpts %s' with '%s %s'.",
3514 opt, cmd, replace);
3515 }
3516 else
3517 {
3518 fvwm_msg(ERR, "SetGlobalOptions",
3519 "Unknown Global Option '%s'", opt);
3520 }
3521 /* should never be null, but checking anyways... */
3522 if (opt)
3523 {
3524 free(opt);
3525 }
3526 }
3527 if (opt)
3528 {
3529 free(opt);
3530 }
3531
3532 return;
3533 }
3534
3535 void CMD_BugOpts(F_CMD_ARGS)
3536 {
3537 char *opt;
3538 int toggle;
3539 char *optstring;
3540
3541 /* fvwm_msg(DBG,"SetGlobalOptions","init action == '%s'\n",action); */
3542 while (action && *action && *action != '\n')
3543 {
3544 action = GetNextFullOption(action, &optstring);
3545 if (!optstring)
3546 {
3547 /* no more options */
3548 return;
3549 }
3550 toggle = ParseToggleArgument(
3551 SkipNTokens(optstring,1), NULL, 2, False);
3552 opt = PeekToken(optstring, NULL);
3553 free(optstring);
3554
3555 if (!opt)
3556 {
3557 return;
3558 }
3559 /* toggle = ParseToggleArgument(rest, &rest, 2, False);*/
3560
3561 if (StrEquals(opt, "FlickeringMoveWorkaround"))
3562 {
3563 switch (toggle)
3564 {
3565 case -1:
3566 Scr.bo.do_disable_configure_notify ^= 1;
3567 break;
3568 case 0:
3569 case 1:
3570 Scr.bo.do_disable_configure_notify = toggle;
3571 break;
3572 default:
3573 Scr.bo.do_disable_configure_notify = 0;
3574 break;
3575 }
3576 }
3577 else if (StrEquals(opt, "MixedVisualWorkaround"))
3578 {
3579 switch (toggle)
3580 {
3581 case -1:
3582 Scr.bo.do_install_root_cmap ^= 1;
3583 break;
3584 case 0:
3585 case 1:
3586 Scr.bo.do_install_root_cmap = toggle;
3587 break;
3588 default:
3589 Scr.bo.do_install_root_cmap = 0;
3590 break;
3591 }
3592 }
3593 else if (StrEquals(opt, "ModalityIsEvil"))
3594 {
3595 switch (toggle)
3596 {
3597 case -1:
3598 Scr.bo.is_modality_evil ^= 1;
3599 break;
3600 case 0:
3601 case 1:
3602 Scr.bo.is_modality_evil = toggle;
3603 break;
3604 default:
3605 Scr.bo.is_modality_evil = 0;
3606 break;
3607 }
3608 if (Scr.bo.is_modality_evil)
3609 {
3610 SetMWM_INFO(Scr.NoFocusWin);
3611 }
3612 }
3613 else if (StrEquals(opt, "RaiseOverNativeWindows"))
3614 {
3615 switch (toggle)
3616 {
3617 case -1:
3618 Scr.bo.is_raise_hack_needed ^= 1;
3619 break;
3620 case 0:
3621 case 1:
3622 Scr.bo.is_raise_hack_needed = toggle;
3623 break;
3624 default:
3625 Scr.bo.is_raise_hack_needed = 0;
3626 break;
3627 }
3628 }
3629 else if (StrEquals(opt, "RaiseOverUnmanaged"))
3630 {
3631 switch (toggle)
3632 {
3633 case -1:
3634 Scr.bo.do_raise_over_unmanaged ^= 1;
3635 break;
3636 case 0:
3637 case 1:
3638 Scr.bo.do_raise_over_unmanaged = toggle;
3639 break;
3640 default:
3641 Scr.bo.do_raise_over_unmanaged = 0;
3642 break;
3643 }
3644 }
3645 else if (StrEquals(opt, "FlickeringQtDialogsWorkaround"))
3646 {
3647 switch (toggle)
3648 {
3649 case -1:
3650 Scr.bo.do_enable_flickering_qt_dialogs_workaround ^= 1;
3651 break;
3652 case 0:
3653 case 1:
3654 Scr.bo.do_enable_flickering_qt_dialogs_workaround = toggle;
3655 break;
3656 default:
3657 Scr.bo.do_enable_flickering_qt_dialogs_workaround = 0;
3658 break;
3659 }
3660 }
3661 else if (StrEquals(opt, "QtDragnDropWorkaround") )
3662 {
3663 switch (toggle)
3664 {
3665 case -1:
3666 Scr.bo.do_enable_qt_drag_n_drop_workaround ^= 1;
3667 break;
3668 case 0:
3669 case 1:
3670 Scr.bo.do_enable_qt_drag_n_drop_workaround = toggle;
3671 break;
3672 default:
3673 Scr.bo.do_enable_qt_drag_n_drop_workaround = 0;
3674 break;
3675 }
3676 fprintf(stderr, "BugOpts QtDragnDropWorkaround: %d\n",
3677 Scr.bo.do_enable_qt_drag_n_drop_workaround);
3678 }
3679 else if (EWMH_BugOpts(opt, toggle))
3680 {
3681 /* work is done in EWMH_BugOpts */
3682 }
3683 else if (StrEquals(opt, "DisplayNewWindowNames"))
3684 {
3685 switch (toggle)
3686 {
3687 case -1:
3688 Scr.bo.do_display_new_window_names ^= 1;
3689 break;
3690 case 0:
3691 case 1:
3692 Scr.bo.do_display_new_window_names = toggle;
3693 break;
3694 default:
3695 Scr.bo.do_display_new_window_names = 0;
3696 break;
3697 }
3698 }
3699 else if (StrEquals(opt, "ExplainWindowPlacement"))
3700 {
3701 switch (toggle)
3702 {
3703 case -1:
3704 Scr.bo.do_explain_window_placement ^= 1;
3705 break;
3706 case 0:
3707 case 1:
3708 Scr.bo.do_explain_window_placement = toggle;
3709 break;
3710 default:
3711 Scr.bo.do_explain_window_placement = 0;
3712 break;
3713 }
3714 }
3715 else if (StrEquals(opt, "DebugCRMotionMethod"))
3716 {
3717 switch (toggle)
3718 {
3719 case -1:
3720 Scr.bo.do_debug_cr_motion_method ^= 1;
3721 break;
3722 case 0:
3723 case 1:
3724 Scr.bo.do_debug_cr_motion_method = toggle;
3725 break;
3726 default:
3727 Scr.bo.do_debug_cr_motion_method = 0;
3728 break;
3729 }
3730 }
3731 else if (StrEquals(opt, "TransliterateUtf8"))
3732 {
3733 FiconvSetTransliterateUtf8(toggle);
3734 }
3735 else
3736 {
3737 fvwm_msg(ERR, "SetBugOptions",
3738 "Unknown Bug Option '%s'", opt);
3739 }
3740 }
3741
3742 return;
3743 }
3744
3745 void CMD_Emulate(F_CMD_ARGS)
3746 {
3747 char *style;
3748
3749 style = PeekToken(action, NULL);
3750 if (!style || StrEquals(style, "fvwm"))
3751 {
3752 Scr.gs.do_emulate_mwm = False;
3753 Scr.gs.do_emulate_win = False;
3754 }
3755 else if (StrEquals(style, "mwm"))
3756 {
3757 Scr.gs.do_emulate_mwm = True;
3758 Scr.gs.do_emulate_win = False;
3759 }
3760 else if (StrEquals(style, "win"))
3761 {
3762 Scr.gs.do_emulate_mwm = False;
3763 Scr.gs.do_emulate_win = True;
3764 }
3765 else
3766 {
3767 fvwm_msg(ERR, "Emulate", "Unknown style '%s'", style);
3768 return;
3769 }
3770 Scr.flags.do_need_window_update = 1;
3771 Scr.flags.has_default_font_changed = 1;
3772 Scr.flags.has_default_color_changed = 1;
3773
3774 return;
3775 }
3776
3777 void CMD_ColorLimit(F_CMD_ARGS)
3778 {
3779 fvwm_msg(
3780 WARN, "ColorLimit", "ColorLimit is obsolete,\n\tuse the "
3781 "fvwm -color-limit option");
3782
3783 return;
3784 }
3785
3786
3787 /* set animation parameters */
3788 void CMD_SetAnimation(F_CMD_ARGS)
3789 {
3790 char *opt;
3791 int delay;
3792 float pct;
3793 int i = 0;
3794
3795 opt = PeekToken(action, &action);
3796 if (!opt || sscanf(opt,"%d",&delay) != 1)
3797 {
3798 fvwm_msg(ERR,"SetAnimation",
3799 "Improper milli-second delay as first argument");
3800 return;
3801 }
3802 if (delay > 500)
3803 {
3804 fvwm_msg(WARN,"SetAnimation",
3805 "Using longer than .5 seconds as between frame"
3806 " animation delay");
3807 }
3808 cmsDelayDefault = delay;
3809 for (opt = PeekToken(action, &action); opt;
3810 opt = PeekToken(action, &action))
3811 {
3812 if (sscanf(opt,"%f",&pct) != 1)
3813 {
3814 fvwm_msg(ERR,"SetAnimation",
3815 "Use fractional values ending in 1.0 as args"
3816 " 2 and on");
3817 return;
3818 }
3819 rgpctMovementDefault[i++] = pct;
3820 }
3821 /* No pct entries means don't change them at all */
3822 if (i > 0 && rgpctMovementDefault[i-1] != 1.0)
3823 {
3824 rgpctMovementDefault[i++] = 1.0;
3825 }
3826
3827 return;
3828 }
3829
3830 /* Determine which modifiers are required with a keycode to make <keysym>. */
3831 static Bool FKeysymToKeycode (Display *dpy, KeySym keysym,
3832 unsigned int *keycode, unsigned int *modifiers)
3833 {
3834 int m;
3835
3836 *keycode = XKeysymToKeycode(dpy, keysym);
3837 *modifiers = 0;
3838
3839 for (m = 0; m <= 8; ++m)
3840 {
3841 KeySym ks = XKeycodeToKeysym(dpy, *keycode, m);
3842 if (ks == keysym)
3843 {
3844 switch (m)
3845 {
3846 case 0: /* No modifiers */
3847 break;
3848 case 1: /* Shift modifier */
3849 *modifiers |= ShiftMask;
3850 break;
3851 default:
3852 fvwm_msg(ERR, "FKeysymToKeycode",
3853 "Unhandled modifier %d", m);
3854 break;
3855 }
3856 return True;
3857 }
3858 }
3859 return False;
3860 }
3861
3862 static void __fake_event(F_CMD_ARGS, FakeEventType type)
3863 {
3864 char *token;
3865 char *optlist[] = {
3866 "press", "p",
3867 "release", "r",
3868 "wait", "w",
3869 "modifiers", "m",
3870 "depth", "d",
3871 NULL
3872 };
3873 unsigned int mask = 0;
3874 Window root = Scr.Root;
3875 int maxdepth = 0;
3876 static char args[128];
3877 strncpy(args, action, sizeof(args) - 1);
3878
3879 /* get the mask of pressed/released buttons/keys */
3880 FQueryPointer(
3881 dpy, Scr.Root, &root, &JunkRoot, &JunkX, &JunkY, &JunkX,
3882 &JunkY, &mask);
3883
3884 token = PeekToken(action, &action);
3885 while (token && action)
3886 {
3887 int index = GetTokenIndex(token, optlist, 0, NULL);
3888 int val, depth;
3889 XEvent e;
3890 Window w;
3891 Window child_w;
3892 int x = 0;
3893 int y = 0;
3894 int rx = 0;
3895 int ry = 0;
3896 Bool do_unset;
3897 long add_mask = 0;
3898 KeySym keysym = NoSymbol;
3899
3900 XFlush(dpy);
3901 do_unset = True;
3902 switch (index)
3903 {
3904 case 0:
3905 case 1:
3906 do_unset = False;
3907 /* fall through */
3908 case 2:
3909 case 3:
3910 /* key/button press or release */
3911 if (type == FakeMouseEvent)
3912 {
3913 if ((GetIntegerArguments(
3914 action, &action, &val, 1) != 1) ||
3915 val < 1 ||
3916 val > NUMBER_OF_EXTENDED_MOUSE_BUTTONS)
3917 {
3918 fvwm_msg(
3919 ERR, "__fake_event",
3920 "Invalid button specifier in"
3921 " \"%s\" for FakeClick.", args);
3922 return; /* error */
3923 }
3924 }
3925 else /* type == FakeKeyEvent */
3926 {
3927 char *key = PeekToken(action, &action);
3928 if (key == NULL)
3929 {
3930 fvwm_msg(
3931 ERR, "__fake_event",
3932 "No keysym specifier in \"%s\""
3933 " for FakeKeypress.", args);
3934 return;
3935 }
3936
3937 /* Do *NOT* use FvwmStringToKeysym() as it is
3938 * case insensitive. */
3939 keysym = XStringToKeysym(key);
3940 if (keysym == NoSymbol)
3941 {
3942 fvwm_msg(
3943 ERR, "__fake_event",
3944 "Invalid keysym specifier (%s)"
3945 " in \"%s\" for FakeKeypress.",
3946 key, args);
3947 return;
3948 }
3949 }
3950
3951 w = None;
3952 child_w = root;
3953 for (depth = 1;
3954 depth != maxdepth &&
3955 w != child_w && child_w != None;
3956 depth++)
3957 {
3958 w = child_w;
3959 if (FQueryPointer(
3960 dpy, w, &root, &child_w,
3961 &rx, &ry, &x, &y,
3962 &JunkMask) == False)
3963 {
3964 /* pointer is on a different
3965 * screen - that's okay here */
3966 }
3967 }
3968
3969 if (type == FakeMouseEvent)
3970 {
3971 e.type = (do_unset) ?
3972 ButtonRelease : ButtonPress;
3973 e.xbutton.display = dpy;
3974 e.xbutton.window = w;
3975 e.xbutton.subwindow = None;
3976 e.xbutton.root = root;
3977 e.xbutton.time = fev_get_evtime();
3978 e.xbutton.x = x;
3979 e.xbutton.y = y;
3980 e.xbutton.x_root = rx;
3981 e.xbutton.y_root = ry;
3982 e.xbutton.button = val;
3983 e.xbutton.state = mask;
3984 e.xbutton.same_screen = (Scr.Root == root);
3985 /* SS: I think this mask handling code is
3986 * buggy.
3987 * The value of <mask> is overridden during a
3988 * "wait" operation. Also why are we only using
3989 * Button1Mask? What if the user has requested
3990 * a FakeClick using some other button? */
3991 /* DV: Button1Mask is actually a bit. Shifting
3992 * it by (val -1) bits to the left gives
3993 * Button2Mask, Button3Mask etc. */
3994 if (do_unset)
3995 {
3996 mask &= ~(Button1Mask << (val - 1));
3997 }
3998 else
3999 {
4000 mask |= (Button1Mask << (val - 1));
4001 }
4002 add_mask = (do_unset) ?
4003 ButtonPressMask : ButtonReleaseMask;
4004 }
4005 else
4006 {
4007 /* type == FakeKeyEvent */
4008 e.type = (do_unset ? KeyRelease : KeyPress);
4009 e.xkey.display = dpy;
4010 e.xkey.subwindow = None;
4011 e.xkey.root = root;
4012 e.xkey.time = fev_get_evtime();
4013 e.xkey.x = x;
4014 e.xkey.y = y;
4015 e.xkey.x_root = rx;
4016 e.xkey.y_root = ry;
4017 e.xkey.same_screen = (Scr.Root == root);
4018
4019 w = e.xkey.window = exc->w.w;
4020
4021 if (FKeysymToKeycode(
4022 dpy, keysym, &(e.xkey.keycode),
4023 &(e.xkey.state)) != True)
4024 {
4025 fvwm_msg(DBG, "__fake_event",
4026 "FKeysymToKeycode failed");
4027 return;
4028 }
4029 e.xkey.state |= mask;
4030 add_mask = (do_unset) ?
4031 KeyReleaseMask : KeyPressMask;
4032 }
4033 FSendEvent(dpy, w, True,
4034 SubstructureNotifyMask | add_mask, &e);
4035 XFlush(dpy);
4036 break;
4037 case 4:
4038 case 5:
4039 /* wait */
4040 if ((GetIntegerArguments(
4041 action, &action, &val, 1) != 1) ||
4042 val <= 0 || val > 1000000)
4043 {
4044 fvwm_msg(ERR, "__fake_event",
4045 "Invalid wait value in \"%s\"", args);
4046 return;
4047 }
4048
4049 usleep(1000 * val);
4050 if (FQueryPointer(
4051 dpy, Scr.Root, &root, &JunkRoot,
4052 &JunkX, &JunkY, &JunkX, &JunkY,
4053 &mask) == False)
4054 {
4055 /* pointer is on a different screen -
4056 * that's okay here */
4057 }
4058 break;
4059 case 6:
4060 case 7:
4061 /* set modifier */
4062 if (GetIntegerArguments(action, &action, &val, 1) != 1)
4063 {
4064 fvwm_msg(
4065 ERR, "__fake_event",
4066 "Invalid modifier value in \"%s\"",
4067 args);
4068 return;
4069 }
4070 do_unset = False;
4071 if (val < 0)
4072 {
4073 do_unset = True;
4074 val = -val;
4075 }
4076 if (val == 6)
4077 {
4078 val = ShiftMask;
4079 }
4080 else if (val == 7)
4081 {
4082 val = LockMask;
4083 }
4084 else if (val == 8)
4085 {
4086 val = ControlMask;
4087 }
4088 else if (val >=1 && val <= 5)
4089 {
4090 val = (Mod1Mask << (val - 1));
4091 }
4092 else
4093 {
4094 /* error */
4095 return;
4096 }
4097 /* SS: Could be buggy if a "modifier" operation
4098 * preceeds a "wait" operation. */
4099 if (do_unset)
4100 {
4101 mask &= ~val;
4102 }
4103 else
4104 {
4105 mask |= val;
4106 }
4107 break;
4108 case 8:
4109 case 9:
4110 /* new max depth */
4111 if (GetIntegerArguments(action, &action, &val, 1) != 1)
4112 {
4113 fvwm_msg(ERR, "__fake_event",
4114 "Invalid depth value in \"%s\"", args);
4115 return;
4116 }
4117 maxdepth = val;
4118 break;
4119 default:
4120 fvwm_msg(ERR, "__fake_event",
4121 "Invalid command (%s) in \"%s\"", token, args);
4122 return;
4123 }
4124 if (action)
4125 {
4126 token = PeekToken(action, &action);
4127 }
4128 }
4129
4130 return;
4131 }
4132
4133 void CMD_FakeClick(F_CMD_ARGS)
4134 {
4135 __fake_event(F_PASS_ARGS, FakeMouseEvent);
4136
4137 return;
4138 }
4139
4140 void CMD_FakeKeypress(F_CMD_ARGS)
4141 {
4142 __fake_event(F_PASS_ARGS, FakeKeyEvent);
4143
4144 return;
4145 }
4146
4147 /* A function to handle stroke (olicha Nov 11, 1999) */
4148 #ifdef HAVE_STROKE
4149 void CMD_StrokeFunc(F_CMD_ARGS)
4150 {
4151 int finished = 0;
4152 int abort = 0;
4153 int modifiers = exc->x.etrigger->xbutton.state;
4154 int start_event_type = exc->x.etrigger->type;
4155 char sequence[STROKE_MAX_SEQUENCE + 1];
4156 char *stroke_action, *name;
4157 char *opt = NULL;
4158 Bool finish_on_release = True;
4159 KeySym keysym;
4160 Bool restore_repeat = False;
4161 Bool echo_sequence = False;
4162 Bool draw_motion = False;
4163 int i = 0;
4164 int *x = NULL;
4165 int *y = NULL;
4166 const int STROKE_CHUNK_SIZE = 0xff;
4167 int coords_size = STROKE_CHUNK_SIZE;
4168 Window JunkRoot, JunkChild;
4169 int JunkX, JunkY;
4170 int tmpx, tmpy;
4171 unsigned int JunkMask;
4172 Bool feed_back = False;
4173 int stroke_width = 1;
4174 XEvent e;
4175 XClassHint *class;
4176
4177
4178
4179 if (!GrabEm(CRS_STROKE, GRAB_NORMAL))
4180 {
4181 XBell(dpy, 0);
4182 return;
4183 }
4184 x = (int*)safemalloc(coords_size * sizeof(int));
4185 y = (int*)safemalloc(coords_size * sizeof(int));
4186 e = *exc->x.etrigger;
4187 /* set the default option */
4188 if (e.type == KeyPress || e.type == ButtonPress)
4189 {
4190 finish_on_release = True;
4191 }
4192 else
4193 {
4194 finish_on_release = False;
4195 }
4196
4197 /* parse the option */
4198 for (action = GetNextSimpleOption(action, &opt); opt;
4199 action = GetNextSimpleOption(action, &opt))
4200 {
4201 if (StrEquals("NotStayPressed",opt))
4202 {
4203 finish_on_release = False;
4204 }
4205 else if (StrEquals("EchoSequence",opt))
4206 {
4207 echo_sequence = True;
4208 }
4209 else if (StrEquals("DrawMotion",opt))
4210 {
4211 draw_motion = True;
4212 }
4213 else if (StrEquals("FeedBack",opt))
4214 {
4215 feed_back = True;
4216 }
4217 else if (StrEquals("StrokeWidth",opt))
4218 {
4219 /* stroke width takes a positive integer argument */
4220 if (opt)
4221 {
4222 free(opt);
4223 }
4224 action = GetNextToken(action, &opt);
4225 if (!opt)
4226 {
4227 fvwm_msg(
4228 WARN, "StrokeWidth",
4229 "needs an integer argument");
4230 }
4231 /* we allow stroke_width == 0 which means drawing a
4232 * `fast' line of width 1; the upper level of 100 is
4233 * arbitrary */
4234 else if (!sscanf(opt, "%d", &stroke_width) ||
4235 stroke_width < 0 || stroke_width > 100)
4236 {
4237 fvwm_msg(
4238 WARN, "StrokeWidth",
4239 "Bad integer argument %d",
4240 stroke_width);
4241 stroke_width = 1;
4242 }
4243 }
4244 else
4245 {
4246 fvwm_msg(WARN,"StrokeFunc","Unknown option %s", opt);
4247 }
4248 if (opt)
4249 {
4250 free(opt);
4251 }
4252 }
4253 if (opt)
4254 {
4255 free(opt);
4256 }
4257
4258 /* Force auto repeat off and grab the Keyboard to get proper
4259 * KeyRelease events if we need it.
4260 * Some computers do not support KeyRelease events, can we
4261 * check this here ? No ? */
4262 if (start_event_type == KeyPress && finish_on_release)
4263 {
4264 XKeyboardState kstate;
4265
4266 XGetKeyboardControl(dpy, &kstate);
4267 if (kstate.global_auto_repeat == AutoRepeatModeOn)
4268 {
4269 XAutoRepeatOff(dpy);
4270 restore_repeat = True;
4271 }
4272 MyXGrabKeyboard(dpy);
4273 }
4274
4275 /* be ready to get a stroke sequence */
4276 stroke_init();
4277
4278 if (draw_motion)
4279 {
4280 MyXGrabServer(dpy);
4281 if (FQueryPointer(
4282 dpy, Scr.Root, &JunkRoot, &JunkChild, &x[0], &y[0],
4283 &JunkX, &JunkY, &JunkMask) == False)
4284 {
4285 /* pointer is on a different screen */
4286 x[0] = 0;
4287 y[0] = 0;
4288 }
4289 XSetLineAttributes(
4290 dpy,Scr.XorGC,stroke_width,LineSolid,CapButt,JoinMiter);
4291 }
4292
4293 while (!finished && !abort)
4294 {
4295 /* block until there is an event */
4296 FMaskEvent(
4297 dpy, ButtonPressMask | ButtonReleaseMask |
4298 KeyPressMask | KeyReleaseMask | ButtonMotionMask |
4299 PointerMotionMask, &e);
4300 switch (e.type)
4301 {
4302 case MotionNotify:
4303 if (e.xmotion.same_screen == False)
4304 {
4305 continue;
4306 }
4307 if (e.xany.window != Scr.Root)
4308 {
4309 if (FQueryPointer(
4310 dpy, Scr.Root, &JunkRoot,
4311 &JunkChild, &tmpx, &tmpy, &JunkX,
4312 &JunkY, &JunkMask) == False)
4313 {
4314 /* pointer is on a different screen */
4315 tmpx = 0;
4316 tmpy = 0;
4317 }
4318 }
4319 else
4320 {
4321 tmpx = e.xmotion.x;
4322 tmpy = e.xmotion.y;
4323 }
4324 stroke_record(tmpx,tmpy);
4325 if (draw_motion && (x[i] != tmpx || y[i] != tmpy))
4326 {
4327 i++;
4328 if (i >= coords_size)
4329 {
4330 coords_size += STROKE_CHUNK_SIZE;
4331 x = (int*)saferealloc(
4332 (void *)x, coords_size *
4333 sizeof(int));
4334 y = (int*)saferealloc(
4335 (void *)y, coords_size *
4336 sizeof(int));
4337 }
4338 x[i] = tmpx;
4339 y[i] = tmpy;
4340 XDrawLine(
4341 dpy, Scr.Root, Scr.XorGC, x[i-1],
4342 y[i-1], x[i], y[i]);
4343 }
4344 break;
4345 case ButtonRelease:
4346 if (finish_on_release && start_event_type ==
4347 ButtonPress)
4348 {
4349 finished = 1;
4350 }
4351 break;
4352 case KeyRelease:
4353 if (finish_on_release && start_event_type == KeyPress)
4354 {
4355 finished = 1;
4356 }
4357 break;
4358 case KeyPress:
4359 keysym = XLookupKeysym(&e.xkey, 0);
4360 /* abort if Escape or Delete is pressed (as in menus.c)
4361 */
4362 if (keysym == XK_Escape || keysym == XK_Delete ||
4363 keysym == XK_KP_Separator)
4364 {
4365 abort = 1;
4366 }
4367 /* finish on enter or space (as in menus.c) */
4368 if (keysym == XK_Return || keysym == XK_KP_Enter ||
4369 keysym == XK_space)
4370 {
4371 finished = 1;
4372 }
4373 break;
4374 case ButtonPress:
4375 if (!finish_on_release)
4376 {
4377 finished = 1;
4378 }
4379 break;
4380 default:
4381 break;
4382 }
4383 }
4384
4385 if (draw_motion)
4386 {
4387 while (i > 0)
4388 {
4389 XDrawLine(
4390 dpy, Scr.Root, Scr.XorGC, x[i-1], y[i-1], x[i],
4391 y[i]);
4392 i--;
4393 }
4394 XSetLineAttributes(dpy,Scr.XorGC,0,LineSolid,CapButt,JoinMiter);
4395 MyXUngrabServer(dpy);
4396 }
4397 if (x != NULL)
4398 {
4399 free(x);
4400 free(y);
4401 }
4402 if (start_event_type == KeyPress && finish_on_release)
4403 {
4404 MyXUngrabKeyboard(dpy);
4405 }
4406 UngrabEm(GRAB_NORMAL);
4407 if (restore_repeat)
4408 {
4409 XAutoRepeatOn(dpy);
4410 }
4411
4412 /* get the stroke sequence */
4413 stroke_trans(sequence);
4414
4415 if (echo_sequence)
4416 {
4417 char num_seq[STROKE_MAX_SEQUENCE + 1];
4418
4419 for (i = 0; sequence[i] != '\0';i++)
4420 {
4421 /* Telephone to numeric pad */
4422 if ('7' <= sequence[i] && sequence[i] <= '9')
4423 {
4424 num_seq[i] = sequence[i]-6;
4425 }
4426 else if ('1' <= sequence[i] && sequence[i] <= '3')
4427 {
4428 num_seq[i] = sequence[i]+6;
4429 }
4430 else
4431 {
4432 num_seq[i] = sequence[i];
4433 }
4434 }
4435 num_seq[i++] = '\0';
4436 fvwm_msg(INFO, "StrokeFunc", "stroke sequence: %s (N%s)",
4437 sequence, num_seq);
4438 }
4439 if (abort)
4440 {
4441 return;
4442 }
4443 if (exc->w.fw == NULL)
4444 {
4445 class = NULL;
4446 name = NULL;
4447 }
4448 else
4449 {
4450 class = &exc->w.fw->class;
4451 name = exc->w.fw->name.name;
4452 }
4453 /* check for a binding */
4454 stroke_action = CheckBinding(
4455 Scr.AllBindings, sequence, 0, modifiers, GetUnusedModifiers(),
4456 exc->w.wcontext, BIND_STROKE, class, name);
4457
4458 /* execute the action */
4459 if (stroke_action != NULL)
4460 {
4461 const exec_context_t *exc2;
4462 exec_context_changes_t ecc;
4463
4464 if (feed_back && atoi(sequence) != 0)
4465 {
4466 GrabEm(CRS_WAIT, GRAB_BUSY);
4467 usleep(200000);
4468 UngrabEm(GRAB_BUSY);
4469 }
4470 ecc.x.etrigger = &e;
4471 exc2 = exc_clone_context(exc, &ecc, ECC_ETRIGGER);
4472 execute_function(cond_rc, exc2, stroke_action, 0);
4473 exc_destroy_context(exc2);
4474 }
4475
4476 return;
4477 }
4478 #endif /* HAVE_STROKE */
4479
4480 void CMD_State(F_CMD_ARGS)
4481 {
4482 unsigned int state;
4483 int toggle;
4484 int n;
4485 FvwmWindow * const fw = exc->w.fw;
4486
4487 n = GetIntegerArguments(action, &action, (int *)&state, 1);
4488 if (n <= 0)
4489 {
4490 return;
4491 }
4492 if (state < 0 || state > 31)
4493 {
4494 fvwm_msg(ERR, "CMD_State", "Illegal state %d\n", state);
4495 return;
4496 }
4497 toggle = ParseToggleArgument(action, NULL, -1, 0);
4498 state = (1 << state);
4499 switch (toggle)
4500 {
4501 case -1:
4502 TOGGLE_USER_STATES(fw, state);
4503 break;
4504 case 0:
4505 CLEAR_USER_STATES(fw, state);
4506 break;
4507 case 1:
4508 default:
4509 SET_USER_STATES(fw, state);
4510 break;
4511 }
4512
4513 return;
4514 }
CVS import of FVWM to Git.