2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
6 * These libraries and programs are free software; you can
7 * redistribute them and/or modify them under the terms of the GNU
8 * Lesser General Public License as published by the Free Software
9 * Foundation; either version 2 of the License, or (at your option)
12 * These libraries and programs are distributed in the hope that
13 * they will be useful, but WITHOUT ANY WARRANTY; without even the
14 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these librararies and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
24 * (c) Copyright 1989, 1990, 1991, 1992, 1993 OPEN SOFTWARE FOUNDATION, INC.
32 static char rcsid[] = "$TOG: WmResource.c /main/14 1997/04/15 10:30:02 dbl $"
36 * (c) Copyright 1987, 1988, 1989, 1990, 1993, 1994 HEWLETT-PACKARD COMPANY
37 * (c) Copyright 1993, 1994 International Business Machines Corp.
38 * (c) Copyright 1993, 1994 Sun Microsystems, Inc.
39 * (c) Copyright 1993, 1994 Novell, Inc.
47 #include "WmResNames.h"
49 #define MWM_NEED_IIMAGE
50 #include "WmIBitmap.h"
55 #include <Xm/RowColumn.h>
56 #ifndef MOTIF_ONE_DOT_ONE
57 #include <Xm/ScreenP.h> /* for XmGetXmScreen and screen.moveOpaque */
61 * include extern functions
63 #include "WmResource.h"
65 #include "WmGraphics.h"
67 #include "WmResParse.h"
69 #include "WmBackdrop.h"
70 #include "WmIconBox.h"
71 #include "WmWrkspace.h"
72 #include <Dt/GetDispRes.h>
73 #define cfileP (wmGD.pWmPB->pFile) /* fopen'ed configuration file or NULL */
78 * Function Declarations:
80 XmColorData *_WmGetDefaultColors ();
82 void _WmTopShadowPixmapDefault (Widget widget, int offset, XrmValue *value);
83 void _WmIconImageFDefault (Widget widget, int offset, XrmValue *value);
84 void _WmIconImageBDefault (Widget widget, int offset, XrmValue *value);
85 void _WmIconImageBSCDefault (Widget widget, int offset, XrmValue *value);
86 void _WmIconImageBSPDefault (Widget widget, int offset, XrmValue *value);
87 void _WmIconImageTSCDefault (Widget widget, int offset, XrmValue *value);
88 void _WmIconImageTSPDefault (Widget widget, int offset, XrmValue *value);
89 void _WmMatteFDefault (Widget widget, int offset, XrmValue *value);
90 void _WmMatteBDefault (Widget widget, int offset, XrmValue *value);
91 void _WmMatteBSCDefault (Widget widget, int offset, XrmValue *value);
92 void _WmMatteBSPDefault (Widget widget, int offset, XrmValue *value);
93 void _WmMatteTSCDefault (Widget widget, int offset, XrmValue *value);
94 void _WmMatteTSPDefault (Widget widget, int offset, XrmValue *value);
95 void _WmBackgroundDefault (Widget widget, int offset, XrmValue *value);
96 void _WmForegroundDefault (Widget widget, int offset, XrmValue *value);
97 void _WmBackgroundPixmapDefault (Widget widget, int offset, XrmValue *value);
98 void _WmBottomShadowColorDefault (Widget widget, int offset, XrmValue *value);
99 void _WmTopShadowColorDefault (Widget widget, int offset, XrmValue *value);
100 void _WmABackgroundDefault (Widget widget, int offset, XrmValue *value);
101 void _WmAForegroundDefault (Widget widget, int offset, XrmValue *value);
102 void _WmABackgroundPixmapDefault (Widget widget, int offset, XrmValue *value);
103 void _WmABottomShadowColorDefault (Widget widget, int offset, XrmValue *value);
104 void _WmATopShadowColorDefault (Widget widget, int offset, XrmValue *value);
105 void _WmATopShadowPixmapDefault (Widget widget, int offset, XrmValue *value);
106 void _WmFocusAutoRaiseDefault (Widget widget, int offset, XrmValue *value);
107 void _WmMultiClickTimeDefault (Widget widget, int offset, XrmValue *value);
108 void ProcessWmResources (void);
109 void ProcessGlobalScreenResources (void);
110 void SetStdGlobalResourceValues (void);
111 void ProcessScreenListResource (void);
112 void ProcessAppearanceResources (WmScreenData *pSD);
113 void MakeAppearanceResources (WmScreenData *pSD, AppearanceData *pAData, Boolean makeActiveResources);
114 void GetAppearanceGCs (WmScreenData *pSD, Pixel fg, Pixel bg, XFontStruct *font, Pixmap bg_pixmap, Pixel ts_color, Pixmap ts_pixmap, Pixel bs_color, Pixmap bs_pixmap, GC *pGC, GC *ptsGC, GC *pbsGC);
115 void ProcessScreenResources (WmScreenData *pSD, unsigned char *screenName);
116 void ProcessWorkspaceResources (WmWorkspaceData *pWS);
117 void ProcessClientResources (ClientData *pCD);
118 void SetStdClientResourceValues (ClientData *pCD);
119 void SetStdScreenResourceValues (WmScreenData *pSD);
120 GC GetHighlightGC (WmScreenData *pSD, Pixel fg, Pixel bg, Pixmap pixmap);
122 static void WriteOutXrmColors (WmScreenData *pSD);
125 void ProcessPresenceResources (WmScreenData *pSD);
126 void ProcessDefaultBackdropImages (WmScreenData *pSD);
127 void _WmBackdropBgDefault (Widget widget, int offset, XrmValue *value);
128 void _WmBackdropFgDefault (Widget widget, int offset, XrmValue *value);
129 void _WmBackdropColorSetDefault (Widget widget, int offset, XrmValue *value);
130 void _WmIconImageMaximumDefault (Widget widget, int offset, XrmValue *value);
131 void _WmSecondariesOnTopDefault (Widget widget, int offset, XrmValue *value);
132 int DefaultWsColorSetId (WmWorkspaceData *pWS);
134 void _WmGetDynamicDefault (Widget widget, unsigned char type, String defaultColor, Pixel newBackground, XrmValue *value);
135 Boolean SimilarAppearanceData (AppearanceData *pAD1, AppearanceData *pAD2);
143 /* builtin window menu specification */
145 #ifndef NO_MESSAGE_CATALOG
147 * Use the same name as builtin to let the message catalog menu
148 * take precedence over any menus that might match in sys.mwmrc
150 char defaultSystemMenuName[] = "_MwmWindowMenu_";
152 char defaultSystemMenuName[] = "DefaultWindowMenu";
153 #endif /* NO_MESSAGE_CATALOG */
154 char builtinSystemMenuName[] = "_MwmWindowMenu_";
156 #define BUILTINSYSTEMMENU "_MwmWindowMenu_\n\
158 Restore _R Alt<Key>F5 f.restore\n\
159 Move _M Alt<Key>F7 f.move\n\
160 Size _S Alt<Key>F8 f.resize\n\
161 Minimize _n Alt<Key>F9 f.minimize\n\
162 Maximize _x Alt<Key>F10 f.maximize\n\
163 Lower _L Alt<Key>F3 f.lower\n\
164 no-label f.separator\n\
165 Close _C Alt<Key>F4 f.kill\n\
167 #ifdef NO_MESSAGE_CATALOG
168 char builtinSystemMenu[] = BUILTINSYSTEMMENU;
169 #else /* !defined(NO_MESSAGE_CATALOG)*/
170 char *builtinSystemMenu = BUILTINSYSTEMMENU;
172 #define DEFAULT_DTWM_SYSTEMMENU "_MwmWindowMenu_\n\
174 Restore _R f.restore\n\
177 Minimize _n f.minimize\n\
178 Maximize _x f.maximize\n\
180 no-label f.separator\n\
181 \"Occupy Workspace...\" _O f.workspace_presence\n\
182 \"Occupy All Workspaces\" _A f.occupy_all\n\
183 \"Unoccupy Workspace\" _U f.remove\n\
184 no-label f.separator\n\
185 Close _C Alt<Key>F4 f.kill\n\
189 void InitBuiltinSystemMenu(void)
192 char *ResString = NULL;
193 char *MovString = NULL;
194 char *SizString = NULL;
195 char *MinString = NULL;
196 char *MaxString = NULL;
197 char *LowString = NULL;
199 char *OcpString = NULL;
200 char *OcaString = NULL;
201 char *RemString = NULL;
203 char *CloString = NULL;
210 tmpString = ((char *)GETMESSAGE(62, 60, "Restore _R Alt<Key>F5 f.restore"));
212 tmpString = ((char *)GETMESSAGE(62, 49, "Restore _R f.restore"));
215 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
217 Warning (((char *)GETMESSAGE(62, 2, "Insufficient memory for local default menu.")));
222 strcpy(ResString, tmpString);
228 tmpString = ((char *)GETMESSAGE(62, 61, "Move _M Alt<Key>F7 f.move"));
230 tmpString = ((char *)GETMESSAGE(62, 50, "Move _M f.move"));
233 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
235 Warning (((char *)GETMESSAGE(62, 4, "Insufficient memory for local default menu.")));
240 strcpy(MovString, tmpString);
246 tmpString = ((char *)GETMESSAGE(62, 62, "Size _S Alt<Key>F8 f.resize"));
248 tmpString = ((char *)GETMESSAGE(62, 51, "Size _S f.resize"));
251 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
253 Warning (((char *)GETMESSAGE(62, 6, "Insufficient memory for local default menu.")));
258 strcpy(SizString, tmpString);
264 tmpString = ((char *)GETMESSAGE(62, 63, "Minimize _n Alt<Key>F9 f.minimize"));
266 tmpString = ((char *)GETMESSAGE(62, 52, "Minimize _n f.minimize"));
269 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
271 Warning (((char *)GETMESSAGE(62, 8, "Insufficient memory for local default menu.")));
276 strcpy(MinString, tmpString);
282 tmpString = ((char *)GETMESSAGE(62, 64, "Maximize _x Alt<Key>F10 f.maximize"));
284 tmpString = ((char *)GETMESSAGE(62, 53, "Maximize _x f.maximize"));
287 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
289 Warning (((char *)GETMESSAGE(62, 10, "Insufficient memory for local default menu.")));
294 strcpy(MaxString, tmpString);
300 tmpString = ((char *)GETMESSAGE(62, 65, "Lower _L Alt<Key>F3 f.lower"));
302 tmpString = ((char *)GETMESSAGE(62, 54, "Lower _L f.lower"));
305 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
307 Warning (((char *)GETMESSAGE(62, 12, "Insufficient memory for local default menu.")));
312 strcpy(LowString, tmpString);
320 tmpString = ((char *)GETMESSAGE(62, 55, "Occupy\\ Workspace\\.\\.\\. _O f.workspace_presence"));
322 (char *)XtMalloc ((unsigned int)
323 (strlen(tmpString) + 1))) == NULL)
325 Warning (((char *)GETMESSAGE(62, 14, "Insufficient memory for local default menu.")));
330 strcpy(OcpString, tmpString);
335 tmpString = ((char *)GETMESSAGE(62, 56, "Occupy\\ All\\ Workspaces _A f.occupy_all"));
337 (char *)XtMalloc ((unsigned int)
338 (strlen(tmpString) + 1))) == NULL)
340 Warning (((char *)GETMESSAGE(62, 16, "Insufficient memory for local default menu.")));
345 strcpy(OcaString, tmpString);
350 tmpString = ((char *)GETMESSAGE(62, 57, "Unoccupy\\ Workspace _U f.remove"));
352 (char *)XtMalloc ((unsigned int)
353 (strlen(tmpString) + 1))) == NULL)
355 Warning (((char *)GETMESSAGE(62, 18, "Insufficient memory for local default menu.")));
360 strcpy(RemString, tmpString);
367 tmpString = ((char *)GETMESSAGE(62, 48, "Close _C Alt<Key>F4 f.kill"));
369 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
371 Warning (((char *)GETMESSAGE(62, 20, "Insufficient memory for local default menu.")));
376 strcpy(CloString, tmpString);
385 builtinSystemMenu = (char *)
386 XtNewString((String)DEFAULT_DTWM_SYSTEMMENU);
390 builtinSystemMenu = (char *)
391 XtNewString((String)BUILTINSYSTEMMENU);
394 builtinSystemMenu = (char *)
395 XtNewString((String)BUILTINSYSTEMMENU);
400 /* put it together */
401 strcpy(dsm, defaultSystemMenuName);
402 strcat(dsm, "\n{\n");
403 strcat(dsm, ResString);
405 strcat(dsm, MovString);
407 strcat(dsm, SizString);
409 strcat(dsm, MinString);
411 strcat(dsm, MaxString);
413 strcat(dsm, LowString);
415 strcat(dsm, " no-label f.separator\n");
419 strcat(dsm, OcpString);
421 strcat(dsm, OcaString);
423 strcat(dsm, RemString);
425 strcat(dsm, " no-label f.separator\n");
428 strcat(dsm, CloString);
431 if ((builtinSystemMenu =
432 (char *)XtMalloc ((unsigned int) (strlen(dsm) + 1))) == NULL)
434 Warning (((char *)GETMESSAGE(62, 21, "Insufficient memory for localized default system menu")));
438 builtinSystemMenu = (char *)
439 XtNewString((String)DEFAULT_DTWM_SYSTEMMENU);
443 builtinSystemMenu = (char *)
444 XtNewString((String)BUILTINSYSTEMMENU);
447 builtinSystemMenu = (char *)
448 XtNewString((String)BUILTINSYSTEMMENU);
453 strcpy(builtinSystemMenu, dsm);
457 if (ResString != NULL)
459 if (MovString != NULL)
461 if (SizString != NULL)
463 if (MinString != NULL)
465 if (MaxString != NULL)
467 if (LowString != NULL)
470 if (OcpString != NULL)
472 if (OcaString != NULL)
474 if (RemString != NULL)
477 if (CloString != NULL)
480 } /* END OF FUNCTION InitBuiltinSystemMenu */
481 #endif /* NO_MESSAGE_CATALOG */
483 char builtinSystemMenu[];
487 #define HARD_CODED_PRIMARY 3
489 char defaultRootMenuName[] = "DefaultRootMenu";
490 char builtinRootMenuName[] = "_MwmRootMenu_";
492 #define BUILTINROOTMENU "DefaultRootMenu\n\
494 \"Root Menu\" f.title\n\
495 \"New Window\" f.exec \"xterm &\"\n\
496 \"Shuffle Up\" f.circle_up\n\
497 \"Shuffle Down\" f.circle_down\n\
498 \"Refresh\" f.refresh\n\
499 \"Pack Icons\" f.pack_icons\n\
500 no-label f.separator\n\
501 \"Restart...\" f.restart\n\
503 char builtinRootMenu[] = BUILTINROOTMENU
505 char builtinRootMenu[];
509 /* builtin key bindings specification */
511 char defaultKeyBindingsName[] = "DefaultKeyBindings";
512 char builtinKeyBindingsName[] = "_MwmKeyBindings_";
514 #define BUILTINKEYBINDINGS "_MwmKeyBindings_\n\
516 Shift<Key>Escape window|icon f.post_wmenu\n\
517 Alt<Key>space window|icon f.post_wmenu\n\
518 Alt<Key>Tab root|icon|window f.next_key\n\
519 Alt Shift<Key>Tab root|icon|window f.prev_key\n\
520 Alt<Key>Escape root|icon|window f.circle_down\n\
521 Alt Shift<Key>Escape root|icon|window f.circle_up\n\
522 Alt Shift Ctrl<Key>exclam root|icon|window f.set_behavior\n\
523 Alt Ctrl<Key>1 root|icon|window f.set_behavior\n\
524 Alt<Key>F6 window f.next_key transient\n\
525 Alt Shift<Key>F6 window f.prev_key transient\n\
526 Shift<Key>F10 icon f.post_wmenu\n\
528 char builtinKeyBindings[] = BUILTINKEYBINDINGS
531 char builtinKeyBindings[];
535 * NOTE: Default Toggle Behavior key bindings. There are TWO key bindings as
536 * of 1.1.4 and 1.2. Make sure you make any modify builtinKeyBindings (above)
537 * whenever modifying behaviorKeyBindings.
540 char behaviorKeyBindingName[] = "_MwmBehaviorKey_";
542 #define BEHAVIORKEYBINDINGS "_MwmBehaviorKey_\n\
544 Alt Shift Ctrl<Key>exclam root|icon|window f.set_behavior\n\
545 Alt Ctrl<Key>1 root|icon|window f.set_behavior\n\
547 char behaviorKeyBindings[] = BEHAVIORKEYBINDINGS
550 char behaviorKeyBindings[];
554 /* default button bindings specification */
555 /* note - the %s will be replaced by the real DefaultRootMenu */
557 char defaultButtonBindingsName[] = "DefaultButtonBindings";
558 char builtinButtonBindingsName[] = "_MwmButtonBindings_";
560 # if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
561 # define BUILTINBUTTONBINDINGS "_MwmButtonBindings_\n\
563 <Btn1Down> icon|frame f.raise\n\
564 <Btn3Down> icon|frame f.post_wmenu\n\
565 <Btn3Down> root f.menu %s\n\
568 # define BUILTINBUTTONBINDINGS "_MwmButtonBindings_\n\
570 <Btn1Down> icon|frame f.raise\n\
571 <Btn3Down> icon|frame f.post_wmenu\n\
572 <Btn3Down> root f.menu DefaultRootMenu\n\
574 # endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
575 char builtinButtonBindings[] = BUILTINBUTTONBINDINGS
578 char builtinButtonBindings[];
582 static ClientData *_pCD;
583 static String _defaultBackground;
584 static String _defaultActiveBackground;
585 static AppearanceData *_pAppearanceData;
587 static WmWorkspaceData *pResWS;
588 static WmScreenData *pResSD;
591 static char _defaultColor1HEX[] = "#A8A8A8A8A8A8";
592 static char _defaultColor2HEX[] = "#5F5F92929E9E";
594 static char _defaultColor1[] = "LightGrey";
595 static char _defaultColor2[] = "CadetBlue";
596 #define DEFAULT_COLOR_NONE NULL
598 Const char _foreground[] = "foreground";
599 Const char _75_foreground[] = "75_foreground";
600 Const char _50_foreground[] = "50_foreground";
601 Const char _25_foreground[] = "25_foreground";
603 Const char *_Dither = XmCO_DITHER;
604 Const char *_NoDither = XmCO_NO_DITHER;
605 Const char CLIENT_FRAME_PART[] = "client";
606 Const char ICON_FRAME_PART[] = "icon";
607 Const char FEEDBACK_FRAME_PART[] = "feedback";
608 Const char MENU_ITEM_PART[] = "menu";
611 #define WmBGC XmBACKGROUND
612 #define WmFGC XmFOREGROUND
613 #define WmTSC XmTOP_SHADOW
614 #define WmBSC XmBOTTOM_SHADOW
616 #define MAX_SHORT 0xffff
619 #define BITMAPDIR "/usr/include/X11/bitmaps/"
623 /*************************************<->*************************************
630 * This data structure is used in the processing of mwm general
631 * appearance and behavior resources. These resources are specified
632 * with the following syntax:
634 * "Mwm*<resource_identifier>".
636 *************************************<->***********************************/
639 XtResource wmGlobalResources[] =
647 XtOffsetOf(WmGlobalData, autoKeyFocus),
657 XtOffsetOf(WmGlobalData, autoRaiseDelay),
667 XtOffsetOf(WmGlobalData, bitmapDirectory),
677 XtOffsetOf(WmGlobalData, blinkOnExec),
681 #endif /* MINIMAL_DT */
687 XtOffsetOf(WmGlobalData, frameStyle),
689 (XtPointer)WmRECESSED
697 XtOffsetOf(WmGlobalData, clientAutoPlace),
703 WmNcolormapFocusPolicy,
704 WmCColormapFocusPolicy,
707 XtOffsetOf(WmGlobalData, colormapFocusPolicy),
709 (XtPointer)CMAP_FOCUS_KEYBOARD
717 XtOffsetOf(WmGlobalData, configFile),
728 XtOffsetOf(WmGlobalData, cppCommand),
735 WmNdeiconifyKeyFocus,
736 WmCDeiconifyKeyFocus,
739 XtOffsetOf(WmGlobalData, deiconifyKeyFocus),
749 XtOffsetOf(WmGlobalData, doubleClickTime),
751 (XtPointer)_WmMultiClickTimeDefault
759 XtOffsetOf(WmGlobalData, enableWarp),
769 XtOffsetOf(WmGlobalData, enforceKeyFocus),
775 WmNframeExternalShadowWidth,
776 WmCFrameExternalShadowWidth,
779 XtOffsetOf(WmGlobalData, frameExternalShadowWidth),
790 XtOffsetOf(WmGlobalData, freezeOnConfig),
801 XtOffsetOf(WmGlobalData, useWindowOutline),
812 XtOffsetOf(WmGlobalData, iconAutoPlace),
818 WmNiconExternalShadowWidth,
819 WmCIconExternalShadowWidth,
822 XtOffsetOf(WmGlobalData, iconExternalShadowWidth),
833 XtOffsetOf(WmGlobalData, iconClick),
839 WmNinteractivePlacement,
840 WmCInteractivePlacement,
843 XtOffsetOf(WmGlobalData, interactivePlacement),
849 WmNkeyboardFocusPolicy,
850 WmCKeyboardFocusPolicy,
853 XtOffsetOf(WmGlobalData, keyboardFocusPolicy),
855 (XtPointer)KEYBOARD_FOCUS_EXPLICIT
863 XtOffsetOf(WmGlobalData, lowerOnIconify),
870 WmNmarqueeSelectGranularity,
871 WmCMarqueeSelectGranularity,
874 XtOffsetOf(WmGlobalData, marqueeSelectGranularity),
885 XtOffsetOf(WmGlobalData, moveThreshold),
895 XtOffsetOf(WmGlobalData, passButtons),
905 XtOffsetOf(WmGlobalData, passSelectButton),
915 XtOffsetOf(WmGlobalData, positionIsFrame),
925 XtOffsetOf(WmGlobalData, positionOnScreen),
935 XtOffsetOf(WmGlobalData, quitTimeout),
945 XtOffsetOf(WmGlobalData, raiseKeyFocus),
952 WmNrefreshByClearing,
953 WmCRefreshByClearing,
956 XtOffsetOf(WmGlobalData, refreshByClearing),
966 XtOffsetOf(WmGlobalData, rootButtonClick),
978 XtOffsetOf(WmGlobalData, sessionClientDB),
989 XtOffsetOf(WmGlobalData, showFeedback),
991 (XtPointer)(WM_SHOW_FB_DEFAULT)
999 XtOffsetOf(WmGlobalData, startupKeyFocus),
1005 WmNsystemButtonClick,
1006 WmCSystemButtonClick,
1009 XtOffsetOf(WmGlobalData, systemButtonClick),
1015 WmNsystemButtonClick2,
1016 WmCSystemButtonClick2,
1019 XtOffsetOf(WmGlobalData, systemButtonClick2),
1023 #if defined(PANELIST)
1029 XtOffsetOf(WmGlobalData, useFrontPanel),
1033 #endif /* PANELIST */
1040 XtOffsetOf(WmGlobalData, helpDirectory),
1042 (XtPointer)"DT/Dtwm/"
1052 XtOffsetOf(WmGlobalData, dtLite),
1056 #endif /* MINIMAL_DT */
1057 }; /* END OF wmGlobalResources[] */
1061 * These determine the screens to manage at startup.
1062 * These are broken out to enhance startup performance.
1064 XtResource wmGlobalScreenResources[] =
1071 XtOffsetOf(WmGlobalData, multiScreen),
1085 XtOffsetOf(WmGlobalData, screenList),
1090 { WmNbackdropDirectories,
1091 WmCBackdropDirectories,
1094 XtOffsetOf(WmGlobalData, backdropDirs),
1096 DEFAULT_BACKDROP_DIR
1103 /******************************<->*************************************
1105 * wmStdGlobalResources
1110 * This data structure is used in the processing of mwm general appearance
1111 * and behavior resources that are not automatically set for the standard
1112 * (default) behavior. These resources are specified with the following
1115 * "Mwm*<resource_identifier>".
1117 ******************************<->***********************************/
1119 XtResource wmStdGlobalResources[] =
1127 XtOffsetOf(WmGlobalData, bitmapDirectory),
1129 (XtPointer)BITMAPDIR
1137 XtOffsetOf(WmGlobalData, configFile),
1146 sizeof (FrameStyle),
1147 XtOffsetOf(WmGlobalData, frameStyle),
1149 (XtPointer)WmRECESSED
1157 XtOffsetOf(WmGlobalData, iconAutoPlace),
1167 XtOffsetOf(WmGlobalData, moveThreshold),
1177 XtOffsetOf(WmGlobalData, positionIsFrame),
1183 WmNpositionOnScreen,
1184 WmCPositionOnScreen,
1187 XtOffsetOf(WmGlobalData, positionOnScreen),
1197 XtOffsetOf(WmGlobalData, quitTimeout),
1207 XtOffsetOf(WmGlobalData, showFeedback),
1209 (XtPointer)(WM_SHOW_FB_DEFAULT)
1215 /******************************<->*************************************
1222 * This data structure is used in the processing of mwm screen specific
1223 * appearance and behavior resources. These resources are specified
1224 * with the following syntax:
1226 * "Mwm*screen<#>*<resource_identifier>".
1228 ******************************<->***********************************/
1230 XtResource wmScreenResources[] =
1237 XtOffsetOf (WmScreenData, buttonBindings),
1239 (XtPointer)defaultButtonBindingsName
1247 XtOffsetOf (WmScreenData, cleanText),
1253 WmNfeedbackGeometry,
1254 WmCFeedbackGeometry,
1257 XtOffsetOf (WmScreenData, feedbackGeometry),
1267 XtOffsetOf (WmScreenData, fadeNormalIcon),
1277 XtOffsetOf (WmScreenData, iconDecoration),
1279 (XtPointer)USE_ICON_DEFAULT_APPEARANCE
1284 WmNiconImageMaximum,
1285 WmCIconImageMaximum,
1288 XtOffsetOf (WmScreenData, iconImageMaximum),
1290 (XtPointer) _WmIconImageMaximumDefault
1294 WmNiconImageMaximum,
1295 WmCIconImageMaximum,
1298 XtOffsetOf (WmScreenData, iconImageMaximum),
1305 WmNiconImageMinimum,
1306 WmCIconImageMinimum,
1309 XtOffsetOf (WmScreenData, iconImageMinimum),
1319 XtOffsetOf (WmScreenData, iconPlacement),
1321 (XtPointer)(ICON_PLACE_LEFT_PRIMARY | ICON_PLACE_BOTTOM_SECONDARY)
1325 WmNiconPlacementMargin,
1326 WmCIconPlacementMargin,
1329 XtOffsetOf (WmScreenData, iconPlacementMargin),
1339 XtOffsetOf (WmScreenData, keyBindings),
1341 (XtPointer)defaultKeyBindingsName
1345 WmNframeBorderWidth,
1346 WmCFrameBorderWidth,
1349 XtOffsetOf (WmScreenData, frameBorderWidth),
1360 XtOffsetOf (WmScreenData, iconBoxGeometry),
1371 XtOffsetOf (WmScreenData, iconBoxName),
1373 (XtPointer)"iconbox"
1377 WmNiconBoxSBDisplayPolicy,
1378 WmCIconBoxSBDisplayPolicy,
1381 XtOffsetOf (WmScreenData, iconBoxSBDisplayPolicy),
1391 XtOffsetOf (WmScreenData, iconBoxScheme),
1401 XtOffsetOf (WmScreenData, iconBoxTitle),
1411 XtOffsetOf (WmScreenData, limitResize),
1417 WmNmaximumMaximumSize,
1418 WmCMaximumMaximumSize,
1421 XtOffsetOf (WmScreenData, maximumMaximumSize),
1427 WmNresizeBorderWidth,
1428 WmCFrameBorderWidth,
1431 XtOffsetOf (WmScreenData, resizeBorderWidth),
1441 XtOffsetOf (WmScreenData, resizeCursors),
1446 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
1452 XtOffsetOf (WmScreenData, rootMenu),
1454 (XtPointer)builtinRootMenuName
1456 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
1459 WmNtransientDecoration,
1460 WmCTransientDecoration,
1463 XtOffsetOf (WmScreenData, transientDecoration),
1465 (XtPointer)(WM_DECOR_SYSTEM | WM_DECOR_RESIZEH)
1469 WmNtransientFunctions,
1470 WmCTransientFunctions,
1473 XtOffsetOf (WmScreenData, transientFunctions),
1475 (XtPointer)(WM_FUNC_ALL & ~(MWM_FUNC_MAXIMIZE | MWM_FUNC_MINIMIZE))
1480 WmNsubpanelDecoration,
1481 WmCSubpanelDecoration,
1484 XtOffsetOf (WmScreenData, subpanelDecoration),
1486 (XtPointer)(WM_DECOR_SYSTEM)
1490 WmNsubpanelResources,
1491 WmCSubpanelResources,
1494 XtOffsetOf (WmScreenData, subpanelResources),
1498 #endif /* PANELIST */
1505 XtOffsetOf (WmScreenData, useIconBox),
1515 XtOffsetOf (WmScreenData, moveOpaque),
1527 XtOffsetOf (WmScreenData, helpResources),
1533 WmNinitialWorkspace,
1534 WmCInitialWorkspace,
1537 XtOffsetOf (WmScreenData, initialWorkspace),
1547 XtOffsetOf (WmScreenData, workspaceList),
1557 XtOffsetOf (WmScreenData, numWorkspaces),
1566 /******************************<->*************************************
1568 * wmStdScreenResources
1573 * This data structure is used in the processing of mwm screen specific
1574 * appearance and behavior resources that are not automatically set for
1575 * the standard (default) behavior. These resources are specified with
1576 * the following syntax:
1578 * "Mwm*screen<#>*<resource_identifier>".
1580 ******************************<->***********************************/
1582 XtResource wmStdScreenResources[] =
1585 WmNframeBorderWidth,
1586 WmCFrameBorderWidth,
1589 XtOffsetOf (WmScreenData, frameBorderWidth),
1596 WmNiconImageMaximum,
1597 WmCIconImageMaximum,
1600 XtOffsetOf (WmScreenData, iconImageMaximum),
1602 (XtPointer) _WmIconImageMaximumDefault
1606 WmNiconImageMaximum,
1607 WmCIconImageMaximum,
1610 XtOffsetOf (WmScreenData, iconImageMaximum),
1617 WmNiconImageMinimum,
1618 WmCIconImageMinimum,
1621 XtOffsetOf (WmScreenData, iconImageMinimum),
1627 WmNiconPlacementMargin,
1628 WmCIconPlacementMargin,
1631 XtOffsetOf (WmScreenData, iconPlacementMargin),
1637 WmNmaximumMaximumSize,
1638 WmCMaximumMaximumSize,
1641 XtOffsetOf (WmScreenData, maximumMaximumSize),
1647 WmNresizeBorderWidth,
1648 WmCFrameBorderWidth,
1651 XtOffsetOf (WmScreenData, resizeBorderWidth),
1659 /******************************<->*************************************
1661 * wmWorkspaceResources
1666 * This data structure is used in the processing of mwm workspace
1667 * specific appearance and behavior resources. These resources are
1668 * specified with the following syntax:
1670 * "Mwm*[screen<#>*]<workspace>*<resource_identifier>".
1672 ******************************<->***********************************/
1674 XtResource wmWorkspaceResources[] =
1681 XtOffsetOf (WmWorkspaceData, iconBoxGeometry),
1691 XtOffsetOf (WmWorkspaceData, title),
1698 XtResource *wmWorkspaceResources = NULL;
1703 /******************************<->*************************************
1705 * wmStdWorkspaceResources
1710 * This data structure is used in the processing of mwm workspace specific
1711 * appearance and behavior resources that are not automatically set for
1712 * the standard (default) behavior. These resources are specified with
1713 * the following syntax:
1715 * "Mwm*[screen<#>*]<workspace>*<resource_identifier>".
1717 *************************************<->***********************************/
1720 XtResource wmStdWorkspaceResources[] =
1727 XtOffsetOf (WmWorkspaceData, title),
1733 XtResource *wmStdWorkspaceResources = NULL;
1738 /*************************************<->*************************************
1740 * wmBackdropResources
1745 * This data structure is used in the processing of workspace specific
1746 * resources that apply to the backdrop.
1748 * These resources are specified with the following syntax:
1750 * "Mwm*[screen*][workspace*]backdrop*<resource_id>:"
1752 * NOTE: The order of these resources is important for correct
1753 * dynamic processing!!!!
1755 *************************************<->***********************************/
1757 XtResource wmBackdropResources[] =
1764 XtOffsetOf (BackdropData, colorSet),
1766 (XtPointer) _WmBackdropColorSetDefault
1774 XtOffsetOf (BackdropData, background),
1776 (XtPointer) _WmBackdropBgDefault
1784 XtOffsetOf (BackdropData, foreground),
1786 (XtPointer) _WmBackdropFgDefault
1794 XtOffsetOf (BackdropData, image),
1802 /*************************************<->*************************************
1804 * wmWsPresenceResources
1809 * This data structure is used in the processing of specific
1810 * resources that apply to the WorkspacePresence dialog.
1812 * These resources are specified with the following syntax:
1814 * "Mwm*[screen*][workspace*]workspacePresence*<resource_id>:"
1816 *************************************<->***********************************/
1818 XtResource wmWsPresenceResources[] =
1825 XtOffsetOf (WsPresenceData, title),
1833 /*************************************<->*************************************
1840 * This data structure is used in the processing of client specific
1841 * window manager resources. These resources are specified with the
1844 * "Mwm*<client_name_or_class>*<resource_identifier>"
1846 *************************************<->***********************************/
1848 XtResource wmClientResources[] =
1853 WmNabsentMapBehavior,
1854 WmCAbsentMapBehavior,
1855 WmRAbsentMapBehavior,
1857 XtOffsetOf (ClientData, absentMapBehavior),
1859 (XtPointer)(AMAP_BEHAVIOR_ADD)
1863 WmNclientDecoration,
1864 WmCClientDecoration,
1867 XtOffsetOf (ClientData, clientDecoration),
1869 (XtPointer)(WM_DECOR_DEFAULT)
1877 XtOffsetOf (ClientData, clientFunctions),
1879 (XtPointer)(WM_FUNC_DEFAULT)
1887 XtOffsetOf (ClientData, focusAutoRaise),
1889 (XtPointer)_WmFocusAutoRaiseDefault
1897 XtOffsetOf (ClientData, iconImage),
1903 WmNiconImageBackground,
1904 WmCIconImageBackground,
1907 XtOffsetOf (ClientData, iconImageBackground),
1909 (XtPointer)_WmIconImageBDefault
1913 WmNiconImageForeground,
1914 WmCIconImageForeground,
1917 XtOffsetOf (ClientData, iconImageForeground),
1919 (XtPointer)_WmIconImageFDefault
1923 WmNiconImageBottomShadowColor,
1924 WmCIconImageBottomShadowColor,
1927 XtOffsetOf (ClientData, iconImageBottomShadowColor),
1929 (XtPointer)_WmIconImageBSCDefault
1933 WmNiconImageBottomShadowPixmap,
1934 WmCIconImageBottomShadowPixmap,
1937 XtOffsetOf (ClientData, iconImageBottomShadowPStr),
1939 (XtPointer)_WmIconImageBSPDefault
1943 WmNiconImageTopShadowColor,
1944 WmCIconImageTopShadowColor,
1947 XtOffsetOf (ClientData, iconImageTopShadowColor),
1949 (XtPointer)_WmIconImageTSCDefault
1953 WmNiconImageTopShadowPixmap,
1954 WmCIconImageTopShadowPixmap,
1957 XtOffsetOf (ClientData, iconImageTopShadowPStr),
1959 (XtPointer)_WmIconImageTSPDefault
1963 WmNignoreWMSaveHints,
1964 WmCIgnoreWMSaveHints,
1967 XtOffsetOf (ClientData, ignoreWMSaveHints),
1977 XtOffsetOf (ClientData, matteWidth),
1983 WmNmaximumClientSize,
1984 WmCMaximumClientSize,
1987 XtOffsetOf (ClientData, maximumClientSize),
1994 WmNsecondariesOnTop,
1995 WmCSecondariesOnTop,
1998 XtOffsetOf (ClientData, secondariesOnTop),
2000 (XtPointer)_WmSecondariesOnTopDefault
2009 XtOffsetOf (ClientData, systemMenu),
2011 (XtPointer)defaultSystemMenuName
2019 XtOffsetOf (ClientData, useClientIcon),
2033 XtOffsetOf (ClientData, usePPosition),
2035 (XtPointer)(USE_PPOSITION_NONZERO)
2038 }; /* END OF STRUCTURE wmClientResources */
2042 /*************************************<->*************************************
2044 * wmStdClientResources
2049 * This data structure is used in the processing of client specific
2050 * window manager resources that are not automatically set for the standard
2051 * (default) behavior. These resources are specified with the
2054 * "Mwm*<client_name_or_class>*<resource_identifier>"
2056 *************************************<->***********************************/
2058 XtResource wmStdClientResources[] =
2066 XtOffsetOf (ClientData, iconImage),
2072 WmNiconImageBackground,
2073 WmCIconImageBackground,
2076 XtOffsetOf (ClientData, iconImageBackground),
2078 (XtPointer)_WmIconImageBDefault
2082 WmNiconImageForeground,
2083 WmCIconImageForeground,
2086 XtOffsetOf (ClientData, iconImageForeground),
2088 (XtPointer)_WmIconImageFDefault
2092 WmNiconImageBottomShadowColor,
2093 WmCIconImageBottomShadowColor,
2096 XtOffsetOf (ClientData, iconImageBottomShadowColor),
2098 (XtPointer)_WmIconImageBSCDefault
2102 WmNiconImageBottomShadowPixmap,
2103 WmCIconImageBottomShadowPixmap,
2106 XtOffsetOf (ClientData, iconImageBottomShadowPStr),
2108 (XtPointer)_WmIconImageBSPDefault
2112 WmNiconImageTopShadowColor,
2113 WmCIconImageTopShadowColor,
2116 XtOffsetOf (ClientData, iconImageTopShadowColor),
2118 (XtPointer)_WmIconImageTSCDefault
2122 WmNiconImageTopShadowPixmap,
2123 WmCIconImageTopShadowPixmap,
2126 XtOffsetOf (ClientData, iconImageTopShadowPStr),
2128 (XtPointer)_WmIconImageTSPDefault
2136 XtOffsetOf (ClientData, matteWidth),
2142 WmNmaximumClientSize,
2143 WmCMaximumClientSize,
2146 XtOffsetOf (ClientData, maximumClientSize),
2152 WmNsecondariesOnTop,
2153 WmCSecondariesOnTop,
2156 XtOffsetOf (ClientData, secondariesOnTop),
2158 (XtPointer)_WmSecondariesOnTopDefault
2167 XtOffsetOf (ClientData, useClientIcon),
2175 /*************************************<->*************************************
2177 * wmClientResourcesM
2182 * This data structure is used in the processing of client specific
2183 * window manager resources that affect the appearance of the client
2184 * matte. These resources are specified with the following syntax:
2186 * "Mwm*<client_name_or_class>*<resource_identifier>"
2188 *************************************<->***********************************/
2190 XtResource wmClientResourcesM[] =
2197 XtOffsetOf (ClientData, matteBackground),
2199 (XtPointer)_WmMatteBDefault
2207 XtOffsetOf (ClientData, matteForeground),
2209 (XtPointer)_WmMatteFDefault
2213 WmNmatteBottomShadowColor,
2214 WmCMatteBottomShadowColor,
2217 XtOffsetOf (ClientData, matteBottomShadowColor),
2219 (XtPointer)_WmMatteBSCDefault
2223 WmNmatteBottomShadowPixmap,
2224 WmCMatteBottomShadowPixmap,
2227 XtOffsetOf (ClientData, matteBottomShadowPStr),
2229 (XtPointer)_WmMatteBSPDefault
2233 WmNmatteTopShadowColor,
2234 WmCMatteTopShadowColor,
2237 XtOffsetOf (ClientData, matteTopShadowColor),
2239 (XtPointer)_WmMatteTSCDefault
2243 WmNmatteTopShadowPixmap,
2244 WmCMatteTopShadowPixmap,
2247 XtOffsetOf (ClientData, matteTopShadowPStr),
2249 (XtPointer)_WmMatteTSPDefault
2255 /*************************************<->*************************************
2257 * wmAppearanceResources
2262 * This data structure is used in the processing of component appearance
2263 * resources. These resources are specified with the following syntax:
2265 * "Mwm*<resource_identifier>"
2266 * "Mwm*client*<resource_identifier>"
2267 * "Mwm*icon*<resource_identifier>"
2268 * "Mwm*feedback*<resource_identifier>"
2270 *************************************<->***********************************/
2272 XtResource wmAppearanceResources[] =
2279 sizeof (XmFontList),
2280 XtOffsetOf (AppearanceData, fontList),
2290 XtOffsetOf (AppearanceData, saveUnder),
2300 XtOffsetOf (AppearanceData, background),
2302 (XtPointer)_WmBackgroundDefault
2310 XtOffsetOf (AppearanceData, foreground),
2312 (XtPointer)_WmForegroundDefault
2316 XmNbottomShadowColor,
2320 XtOffsetOf (AppearanceData, bottomShadowColor),
2322 (XtPointer)_WmBottomShadowColorDefault
2326 XmNbottomShadowPixmap,
2327 XmCBottomShadowPixmap,
2330 XtOffsetOf (AppearanceData, bottomShadowPStr),
2340 XtOffsetOf (AppearanceData, topShadowColor),
2342 (XtPointer)_WmTopShadowColorDefault
2346 XmNbackgroundPixmap,
2347 XmCBackgroundPixmap,
2350 XtOffsetOf (AppearanceData, backgroundPStr),
2352 (XtPointer)_WmBackgroundPixmapDefault
2360 XtOffsetOf (AppearanceData, topShadowPStr),
2362 (XtPointer)_WmTopShadowPixmapDefault
2366 WmNactiveBackground,
2370 XtOffsetOf (AppearanceData, activeBackground),
2372 (XtPointer)_WmABackgroundDefault
2376 WmNactiveForeground,
2380 XtOffsetOf (AppearanceData, activeForeground),
2382 (XtPointer)_WmAForegroundDefault
2386 WmNactiveBottomShadowColor,
2390 XtOffsetOf (AppearanceData, activeBottomShadowColor),
2392 (XtPointer)_WmABottomShadowColorDefault
2396 WmNactiveBottomShadowPixmap,
2397 XmCBottomShadowPixmap,
2400 XtOffsetOf (AppearanceData, activeBottomShadowPStr),
2406 WmNactiveTopShadowColor,
2410 XtOffsetOf (AppearanceData, activeTopShadowColor),
2412 (XtPointer)_WmATopShadowColorDefault
2416 WmNactiveBackgroundPixmap,
2417 XmCBackgroundPixmap,
2420 XtOffsetOf (AppearanceData, activeBackgroundPStr),
2422 (XtPointer)_WmABackgroundPixmapDefault
2426 WmNactiveTopShadowPixmap,
2430 XtOffsetOf (AppearanceData, activeTopShadowPStr),
2432 (XtPointer)_WmATopShadowPixmapDefault
2439 /*************************************<->*************************************
2441 * _WmIconImageFDefault (widget, offset, value)
2442 * _WmIconImageBDefault (widget, offset, value)
2443 * _WmIconImageBSCDefault (widget, offset, value)
2444 * _WmIconImageBSPDefault (widget, offset, value)
2445 * _WmIconImageTSCDefault (widget, offset, value)
2446 * _WmIconImageTSPDefault (widget, offset, value)
2447 * _WmMatteFDefault (widget, offset, value)
2448 * _WmMatteBDefault (widget, offset, value)
2449 * _WmMatteBSCDefault (widget, offset, value)
2450 * _WmMatteBSPDefault (widget, offset, value)
2451 * _WmMatteTSCDefault (widget, offset, value)
2452 * _WmMatteTSPDefault (widget, offset, value)
2457 * These functions are used to generate dynamic defaults for various
2458 * client-specific appearance related resources.
2463 * widget = this is the parent widget for the wm subpart
2465 * offset = this is the resource offset
2467 * value = this is a pointer to a XrmValue in which to store the result
2469 * _pCD = (static global) pointer to client data associated with resources
2474 * value = default resource value and size
2476 *************************************<->***********************************/
2479 _WmIconImageFDefault (Widget widget, int offset, XrmValue *value)
2481 _WmGetDynamicDefault (widget, WmFGC, 0,
2482 _pCD->iconImageBackground, value);
2484 } /* END OF FUNCTION _WmIconImageFDefault */
2487 _WmIconImageBDefault (Widget widget, int offset, XrmValue *value)
2489 value->addr = (char *)&(_pCD->pSD->iconAppearance.background);
2490 value->size = sizeof (Pixel);
2492 } /* END OF FUNCTION _WmIconImageBDefault */
2496 _WmIconImageBSCDefault (Widget widget, int offset, XrmValue *value)
2498 _WmGetDynamicDefault (widget, WmBSC, 0,
2499 _pCD->iconImageBackground, value);
2501 } /* END OF FUNCTION _WmIconImageBSCDefault */
2505 _WmIconImageBSPDefault (Widget widget, int offset, XrmValue *value)
2508 value->addr = (char *)_pCD->pSD->iconAppearance.bottomShadowPStr;
2509 value->size = sizeof (String);
2511 } /* END OF FUNCTION _WmIconImageBSCDefault */
2515 _WmIconImageTSCDefault (Widget widget, int offset, XrmValue *value)
2517 _WmGetDynamicDefault (widget, WmTSC, 0,
2518 _pCD->iconImageBackground, value);
2520 } /* END OF FUNCTION _WmIconImageTSCDefault */
2524 _WmIconImageTSPDefault (Widget widget, int offset, XrmValue *value)
2527 value->addr = (char *)_pCD->pSD->iconAppearance.topShadowPStr;
2528 value->size = sizeof (String);
2530 } /* END OF FUNCTION _WmIconImageTSPDefault */
2534 _WmMatteFDefault (Widget widget, int offset, XrmValue *value)
2536 _WmGetDynamicDefault (widget, WmFGC, 0,
2537 _pCD->matteBackground, value);
2539 } /* END OF FUNCTION _WmMatteFDefault */
2543 _WmMatteBDefault (Widget widget, int offset, XrmValue *value)
2545 value->addr = (char *)&(_pCD->pSD->clientAppearance.background);
2546 value->size = sizeof (Pixel);
2548 } /* END OF FUNCTION _WmMatteBDefault */
2552 _WmMatteBSCDefault (Widget widget, int offset, XrmValue *value)
2554 _WmGetDynamicDefault (widget, WmBSC, 0,
2555 _pCD->matteBackground, value);
2557 } /* END OF FUNCTION _WmMatteBSCDefault */
2561 _WmMatteBSPDefault (Widget widget, int offset, XrmValue *value)
2564 value->addr = (char *)_pCD->pSD->clientAppearance.bottomShadowPStr;
2565 value->size = sizeof (String);
2567 } /* END OF FUNCTION _WmMatteBSCDefault */
2571 _WmMatteTSCDefault (Widget widget, int offset, XrmValue *value)
2573 _WmGetDynamicDefault (widget, WmTSC, 0,
2574 _pCD->matteBackground, value);
2576 } /* END OF FUNCTION _WmMatteTSCDefault */
2580 _WmMatteTSPDefault (Widget widget, int offset, XrmValue *value)
2583 value->addr = (char *)_pCD->pSD->clientAppearance.topShadowPStr;
2584 value->size = sizeof (String);
2586 } /* END OF FUNCTION _WmMatteTSCDefault */
2590 /*************************************<->*************************************
2592 * _WmBackgroundDefault (widget, offset, value)
2593 * _WmForegroundDefault (widget, offset, value)
2594 * _WmBackgroundPixmapDefault (widget, offset, value)
2595 * _WmBottomShadowColorDefault (widget, offset, value)
2596 * _WmTopShadowColorDefault (widget, offset, value)
2597 * _WmTopShadowPixmapDefault (widget, offset, value)
2598 * _WmABackgroundDefault (widget, offset, value)
2599 * _WmAForegroundDefault (widget, offset, value)
2600 * _WmABackgroundPixmapDefault (widget, offset, value)
2601 * _WmABottomShadowColorDefault (widget, offset, value)
2602 * _WmRFBackgroundDefault (widget, offset, value)
2603 * _WmRFForegroundDefault (widget, offset, value)
2604 * _WmATopShadowColorDefault (widget, offset, value)
2605 * _WmATopShadowPixmapDefault (widget, offset, value)
2610 * These functions are used to generate dynamic defaults for various
2611 * component appearance related resources (not client-specific).
2616 * widget = this is the parent widget for the wm subpart
2618 * offset = this is the resource offset
2620 * value = this is a pointer to a XrmValue in which to store the result
2622 * _defaultBackground = (static global) default background color (inactive)
2624 * _defaultActiveBackground = (static global) default bg color (active)
2626 * _pAppearanceData = (static global) pointer to resouce set structure
2631 * value = default resource value and size
2633 *************************************<->***********************************/
2636 _WmBackgroundDefault (Widget widget, int offset, XrmValue *value)
2638 _WmGetDynamicDefault (widget, WmBGC, _defaultBackground, 0, value);
2640 } /* END OF FUNCTION _WmBackgroundDefault */
2644 _WmForegroundDefault (Widget widget, int offset, XrmValue *value)
2646 _WmGetDynamicDefault (widget, WmFGC, 0, _pAppearanceData->background,
2649 } /* END OF FUNCTION _WmForegroundDefault */
2653 _WmBackgroundPixmapDefault (Widget widget, int offset, XrmValue *value)
2655 static String string;
2658 if ((Monochrome (XtScreen (widget))) ||
2659 (_pAppearanceData->topShadowColor == _pAppearanceData->background))
2661 string = (String) _25_foreground;
2668 value->addr = (char *)string;
2669 value->size = sizeof (String);
2671 } /* END OF FUNCTION _WmBackgroundPixmapDefault */
2675 _WmBottomShadowColorDefault (Widget widget, int offset, XrmValue *value)
2677 _WmGetDynamicDefault (widget, WmBSC, 0, _pAppearanceData->background,
2680 } /* END OF FUNCTION _WmBottomShadowColorDefault */
2684 _WmTopShadowColorDefault (Widget widget, int offset, XrmValue *value)
2686 _WmGetDynamicDefault (widget, WmTSC, 0, _pAppearanceData->background,
2689 } /* END OF FUNCTION _WmTopShadowColorDefault */
2693 _WmTopShadowPixmapDefault (Widget widget, int offset, XrmValue *value)
2695 static String string;
2698 if ((Monochrome (XtScreen (widget))) ||
2699 (_pAppearanceData->topShadowColor == _pAppearanceData->background))
2701 /* Fix monochrome 3D appearance */
2702 string = (String) _50_foreground;
2703 if (_pAppearanceData->backgroundPStr != NULL)
2704 if (!strcmp(_pAppearanceData->backgroundPStr, _25_foreground) ||
2705 !strcmp(_pAppearanceData->backgroundPStr, _50_foreground))
2707 string = (String) _foreground;
2715 value->addr = (char *)string;
2716 value->size = sizeof (String);
2718 } /* END OF FUNCTION _WmTopShadowPixmapDefault */
2722 _WmABackgroundDefault (Widget widget, int offset, XrmValue *value)
2724 _WmGetDynamicDefault (widget, WmBGC, _defaultActiveBackground, 0, value);
2726 } /* END OF FUNCTION _WmABackgroundDefault */
2730 _WmAForegroundDefault (Widget widget, int offset, XrmValue *value)
2732 _WmGetDynamicDefault (widget, WmFGC, 0, _pAppearanceData->activeBackground,
2735 } /* END OF FUNCTION _WmAForegroundDefault */
2738 _WmABackgroundPixmapDefault (Widget widget, int offset, XrmValue *value)
2740 static String string;
2743 if ((Monochrome (XtScreen (widget))) ||
2744 (_pAppearanceData->activeTopShadowColor ==
2745 _pAppearanceData->activeBackground))
2747 string = (String) _50_foreground;
2754 value->addr = (char *)string;
2755 value->size = sizeof (String);
2757 } /* END OF FUNCTION _WmABackgroundPixmapDefault */
2760 _WmABottomShadowColorDefault (Widget widget, int offset, XrmValue *value)
2762 _WmGetDynamicDefault (widget, WmBSC, 0, _pAppearanceData->activeBackground,
2765 } /* END OF FUNCTION _WmABottomShadowColorDefault */
2769 _WmATopShadowColorDefault (Widget widget, int offset, XrmValue *value)
2771 _WmGetDynamicDefault (widget, WmTSC, 0, _pAppearanceData->activeBackground,
2774 } /* END OF FUNCTION _WmATopShadowColorDefault */
2778 _WmATopShadowPixmapDefault (Widget widget, int offset, XrmValue *value)
2780 static String string;
2782 if ((Monochrome (XtScreen (widget))) ||
2783 (_pAppearanceData->activeTopShadowColor ==
2784 _pAppearanceData->activeBackground))
2786 /* Fix monochrome 3D appearance */
2787 string = (String) _50_foreground;
2788 if (_pAppearanceData->activeBackgroundPStr != NULL)
2790 (_pAppearanceData->activeBackgroundPStr, _25_foreground) ||
2792 (_pAppearanceData->activeBackgroundPStr, _50_foreground))
2794 string = (String) _foreground;
2802 value->addr = (char *)string;
2803 value->size = sizeof (String);
2805 } /* END OF FUNCTION _WmATopShadowPixmapDefault */
2810 _WmBackdropBgDefault (Widget widget, int offset, XrmValue *value)
2812 static Pixel pixValue;
2813 unsigned int colorSetId = (unsigned int) pResWS->backdrop.colorSet;
2816 if (wmGD.statusColorServer == CSERVE_NORMAL)
2818 if ((colorSetId == 0) || (colorSetId > XmCO_MAX_NUM_COLORS))
2820 colorSetId = (unsigned int) DefaultWsColorSetId (pResWS);
2823 switch (pResWS->pSD->colorUse)
2825 case XmCO_BLACK_WHITE:
2826 pixValue = pResWS->pSD->pPixelData[colorSetId-1].bg;
2830 case XmCO_LOW_COLOR:
2831 case XmCO_MEDIUM_COLOR:
2832 case XmCO_HIGH_COLOR:
2833 pixValue = pResWS->pSD->pPixelData[colorSetId-1].bs;
2840 * Color server is unavailable. Has user specified a colorset?
2842 * If not, go monochrome.
2845 pixValue = WhitePixel (DISPLAY, pResWS->pSD->screen);
2848 /* return the dynamic default */
2850 value->addr = (char *) &pixValue;
2851 value->size = sizeof (Pixel);
2853 } /* END OF FUNCTION _WmBackdropBgDefault */
2856 _WmBackdropFgDefault (Widget widget, int offset, XrmValue *value)
2858 static Pixel pixValue;
2859 unsigned int colorSetId = (unsigned int) pResWS->backdrop.colorSet;
2862 if (wmGD.statusColorServer == CSERVE_NORMAL)
2864 if ((colorSetId == 0) || (colorSetId > XmCO_MAX_NUM_COLORS))
2866 colorSetId = (unsigned int) DefaultWsColorSetId (pResWS);
2869 switch (pResWS->pSD->colorUse)
2871 case XmCO_BLACK_WHITE:
2872 pixValue = pResWS->pSD->pPixelData[colorSetId-1].fg;
2876 case XmCO_LOW_COLOR:
2877 case XmCO_MEDIUM_COLOR:
2878 case XmCO_HIGH_COLOR:
2879 pixValue = pResWS->pSD->pPixelData[colorSetId-1].bg;
2886 * Color server is unavailable. Has user specified a colorset?
2888 * If not, go monochrome.
2891 pixValue = BlackPixel (DISPLAY, pResWS->pSD->screen);
2893 value->addr = (char *) &pixValue;
2894 value->size = sizeof (Pixel);
2896 } /* END OF FUNCTION _WmBackdropFgDefault */
2899 _WmBackdropColorSetDefault (Widget widget, int offset, XrmValue *value)
2901 static unsigned int colorSetId;
2903 if (wmGD.statusColorServer == CSERVE_NORMAL)
2905 colorSetId = (unsigned int) DefaultWsColorSetId (pResWS);
2909 colorSetId = 0; /* invalid color set */
2912 value->addr = (char *) &colorSetId;
2913 value->size = sizeof (Pixel);
2915 } /* END OF FUNCTION _WmBackdropColorSetIdDefault */
2918 _WmIconImageMaximumDefault (Widget widget, int offset, XrmValue *value)
2922 if ((pResSD->displayResolutionType == LOW_RES_DISPLAY) ||
2923 (pResSD->displayResolutionType == VGA_RES_DISPLAY))
2934 value->addr = (char *) &cval;
2935 value->size = sizeof (WHSize);
2937 } /* END OF FUNCTION _WmIconImageMaximumDefault */
2940 /*************************************<->*************************************
2942 * DefaultWsColorSetId (pWS)
2947 * This function returns the default colorSetId for a given workspace
2952 * pWS = ptr to workspace data
2956 * return = default color set ID.
2958 * "active" and "inactive" color sets are not used.
2960 *************************************<->***********************************/
2963 DefaultWsColorSetId (WmWorkspaceData *pWS)
2965 static int _ws_high_color_map[] = { 3, 5, 6, 7 };
2966 #define _WS_HIGH_COLOR_COUNT 4
2976 iIndex = (int) ((unsigned long)(pWS) -
2977 (unsigned long)(pSD->pWS))/sizeof(WmWorkspaceData);
2979 iIndex = 0; /* bad pWS or pSD, shouldn't get here */
2981 switch (pSD->colorUse)
2983 case XmCO_BLACK_WHITE:
2984 case XmCO_LOW_COLOR:
2986 (pSD->pInactivePixelSet-pSD->pPixelData)/sizeof(XmPixelSet);
2989 case XmCO_MEDIUM_COLOR:
2990 rval = HARD_CODED_PRIMARY;
2993 case XmCO_HIGH_COLOR:
2994 i = iIndex % _WS_HIGH_COLOR_COUNT;
2995 rval = _ws_high_color_map[i];
3002 } /* END OF FUNCTION DefaultWsColorSetId */
3008 /*************************************<->*************************************
3010 * _WmFocusAutoRaiseDefault (widget, offset, value)
3015 * This function generates a default value for the focusAutoRaise resource.
3020 * widget = this is the parent widget for the wm subpart
3022 * offset = this is the resource offset
3024 * value = this is a pointer to a XrmValue in which to store the result
3029 * value = default resource value and size
3031 *************************************<->***********************************/
3034 _WmFocusAutoRaiseDefault (Widget widget, int offset, XrmValue *value)
3036 static Boolean focusAutoRaise;
3038 if (wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_EXPLICIT)
3040 focusAutoRaise = True;
3044 focusAutoRaise = False;
3047 value->addr = (char *)&focusAutoRaise;
3048 value->size = sizeof (Boolean);
3050 } /* END OF FUNCTION _WmFocusAutoRaiseDefault */
3053 /*************************************<->*************************************
3055 * _WmMultiClickTimeDefault (widget, offset, value)
3060 * This function generates a default value for the doubleClickTime resource.
3061 * We dynamically default to the XtR4 multiClickTime value.
3065 * widget = this is the parent widget for the wm subpart
3067 * offset = this is the resource offset
3069 * value = this is a pointer to a XrmValue in which to store the result
3073 * value = default resource value and size
3075 *************************************<->***********************************/
3078 _WmMultiClickTimeDefault (Widget widget, int offset, XrmValue *value)
3080 static int multiClickTime;
3082 multiClickTime = XtGetMultiClickTime(XtDisplay(widget));
3084 value->addr = (char *)&multiClickTime;
3085 value->size = sizeof (int);
3087 } /* END OF FUNCTION _WmMultiClickTimeDefault */
3091 /*************************************<->*************************************
3093 * _WmSecondariesOnTopDefault (widget, offset, value)
3098 * This function generates a default value for the secondariesOnTop
3103 * widget = this is the parent widget for the wm subpart
3105 * offset = this is the resource offset
3107 * value = this is a pointer to a XrmValue in which to store the result
3111 * value = default resource value and size
3113 *************************************<->***********************************/
3116 _WmSecondariesOnTopDefault (Widget widget, int offset, XrmValue *value)
3118 static Boolean secondariesOnTop;
3121 * Inherit setting from primary window if this window is
3125 if (_pCD->transientLeader != NULL)
3126 secondariesOnTop = _pCD->transientLeader->secondariesOnTop;
3128 secondariesOnTop = True;
3130 value->addr = (char *)&secondariesOnTop;
3131 value->size = sizeof (Boolean);
3133 } /* END OF FUNCTION _WmSecondariesOnTopDefault */
3138 /******************************<->*************************************
3140 * ProcessWmResources ()
3145 * This function is used to retrieve and process window manager resources
3146 * that are not client-specific.
3151 * wmGlobalResources = pointer to wm resource list
3156 * wmGD = (global data filled out with resource values)
3158 *************************************<->***********************************/
3161 ProcessWmResources (void)
3165 * Process the mwm general appearance and behavior resources. Retrieve
3166 * a limited set of resource values if the window manager is starting
3167 * up with the standard behavior.
3170 if (wmGD.useStandardBehavior)
3172 XtGetApplicationResources (wmGD.topLevelW, (XtPointer) &wmGD,
3173 wmStdGlobalResources, XtNumber (wmStdGlobalResources), NULL, 0);
3176 * Fill in the standard resource values.
3179 SetStdGlobalResourceValues ();
3183 XtGetApplicationResources (wmGD.topLevelW, (XtPointer) &wmGD,
3184 wmGlobalResources, XtNumber (wmGlobalResources), NULL, 0);
3187 if (wmGD.autoRaiseDelay < 0)
3189 wmGD.autoRaiseDelay = 500;
3190 Warning (((char *)GETMESSAGE(62, 66, "Out of range autoRaiseDelay resource value. Must be non-negative")));
3193 } /* END OF FUNCTION ProcessWmResources */
3197 /******************************<->*************************************
3199 * ProcessGlobalScreenResources ()
3204 * This function is used to retrieve window manager resources to
3205 * determine the screens to manage.
3210 * wmGlobalScreenResources = pointer to wm resource list
3215 * wmGD = (global data filled out with resource values)
3217 *************************************<->***********************************/
3220 ProcessGlobalScreenResources (void)
3222 XtGetApplicationResources (wmGD.topLevelW, &wmGD,
3223 wmGlobalScreenResources,
3224 XtNumber (wmGlobalScreenResources), NULL, 0);
3226 if (wmGD.multiScreen)
3228 wmGD.numScreens = ScreenCount(DISPLAY);
3232 wmGD.numScreens = 1;
3235 if (wmGD.screenList != NULL)
3237 ProcessScreenListResource();
3243 /*************************************<->*************************************
3245 * SetStdGlobalResourceValues ()
3250 * This function sets resource data to standard values. This setting
3251 * is done in place of getting the values from the user settings in
3252 * the resource database.
3257 * wmGD = (global data filled out with resource values)
3259 *************************************<->***********************************/
3262 SetStdGlobalResourceValues (void)
3264 wmGD.autoKeyFocus = True;
3265 wmGD.clientAutoPlace = True;
3266 wmGD.colormapFocusPolicy = CMAP_FOCUS_KEYBOARD;
3267 wmGD.deiconifyKeyFocus = True;
3268 wmGD.doubleClickTime = 500;
3269 wmGD.freezeOnConfig = True;
3270 wmGD.iconAutoPlace = True;
3271 wmGD.iconClick = True;
3272 wmGD.interactivePlacement = False;
3273 wmGD.keyboardFocusPolicy = KEYBOARD_FOCUS_EXPLICIT;
3274 wmGD.lowerOnIconify = True;
3275 wmGD.passSelectButton = True;
3276 wmGD.startupKeyFocus = True;
3277 wmGD.systemButtonClick = True;
3278 wmGD.systemButtonClick2 = True;
3279 #if defined(PANELIST)
3280 wmGD.useFrontPanel=False;
3281 #endif /* PANELIST */
3283 } /* END OF FUNCTION SetStdGlobalResourceValues */
3287 /*************************************<->*************************************
3289 * ProcessScreenListResource ()
3294 * This processes the names in the screenList resource.
3299 * wmGlobalResources = pointer to wmGD.screenList
3306 *************************************<->***********************************/
3309 ProcessScreenListResource (void)
3311 unsigned char *lineP;
3312 unsigned char *string;
3316 lineP = (unsigned char *)wmGD.screenList;
3321 while (((string = GetString(&lineP)) != NULL) &&
3322 (sNum < ScreenCount(DISPLAY)))
3324 if (!(wmGD.screenNames[sNum] = (unsigned char *)
3325 WmRealloc ((char*)wmGD.screenNames[sNum], strlen((char*)string)+1)))
3327 ExitWM(WM_ERROR_EXIT_VALUE);
3331 strcpy((char *)wmGD.screenNames[sNum], (char *)string);
3338 * If the number of listed screens (sNum) is < screen count, fill in the
3339 * remaining screen names with the name of the first screen specified,
3344 string = wmGD.screenNames[0]; /* name of the first screen */
3345 while (sNum < ScreenCount(DISPLAY))
3347 if (!(wmGD.screenNames[sNum] = (unsigned char *)
3348 WmRealloc ((char*)wmGD.screenNames[sNum],
3349 strlen((char *)string)+1)))
3351 ExitWM(WM_ERROR_EXIT_VALUE);
3355 strcpy((char *)wmGD.screenNames[sNum], (char *)string);
3362 } /* END OF FUNCTION ProcessScreenListResource */
3366 /******************************<->*************************************
3368 * ProcessWmColors ()
3373 * Retrieve the color sets from the colorserver.
3381 * modifies parts of global pixel sets
3386 ******************************<->***********************************/
3389 ProcessWmColors (WmScreenData *pSD)
3391 short active, inactive, primary, secondary;
3393 if ((pSD->pPixelData = (XmPixelSet *)
3394 XtMalloc (XmCO_NUM_COLORS * sizeof(XmPixelSet))))
3399 * ASSUMPTION: If XmeGetPixelData() returns true,
3400 * we have a good color server at our disposal.
3404 if (XmeGetPixelData (pSD->screen, &pSD->colorUse,
3405 pSD->pPixelData, &active, &inactive,
3406 &primary, &secondary))
3408 pSD->pActivePixelSet = &(pSD->pPixelData[active]);
3409 pSD->pInactivePixelSet = &(pSD->pPixelData[inactive]);
3410 pSD->pPrimaryPixelSet = &(pSD->pPixelData[primary]);
3411 pSD->pSecondaryPixelSet = &(pSD->pPixelData[secondary]);
3413 /* Hack here. The index "4" is the proper array reference. */
3414 /* This is used because XmGetPixelData has not been properly */
3417 pSD->pTextPixelSet = &(pSD->pPixelData[3]);
3419 wmGD.statusColorServer = CSERVE_NORMAL;
3424 XtFree((char *)pSD->pPixelData);
3425 pSD->pPixelData = NULL;
3426 pSD->pActivePixelSet = NULL;
3427 pSD->pInactivePixelSet = NULL;
3428 pSD->pPrimaryPixelSet = NULL;
3429 pSD->pSecondaryPixelSet = NULL;
3430 pSD->pTextPixelSet = NULL;
3435 Warning (((char *)GETMESSAGE(62, 22, "Insufficient memory for color data")));
3436 ExitWM (WM_ERROR_EXIT_VALUE);
3439 } /* END OF FUNCTION ProcessWmColors */
3442 /******************************<->*************************************
3444 * WriteOutXrmColors ()
3449 * Update the XRM database with pixel values from the color server.
3453 * pSD = contains pixel sets
3457 * updated resource database
3461 * N.B. Must change to write out data on a PER-SCREEN basis.
3462 * e.g., "Dtwm*0*background"
3463 ******************************<->***********************************/
3466 WriteOutXrmColors (WmScreenData *pSD)
3470 int thisScreen = pSD->screen;
3471 XmPixelSet *tpixset, *ppixset;
3472 XmPixelSet *spixset;
3479 res_class = WM_RESOURCE_CLASS;
3483 res_class = DT_WM_RESOURCE_CLASS;
3486 screen_name = (String) wmGD.screenNames[pSD->screen];
3488 db = XtScreenDatabase(XScreenOfDisplay(DISPLAY, thisScreen));
3490 /** update the clients database with new colors **/
3491 value.size = sizeof(Pixel);
3495 * WM ACTIVE RESOURCES--e.g., for the active frame
3498 if (pSD->pActivePixelSet)
3500 tpixset = pSD->pActivePixelSet;
3501 spixset = pSD->pSecondaryPixelSet;
3503 if (pSD->colorUse == XmCO_BLACK_WHITE)
3507 * Limit ourselves here to the client (frame)
3512 /* activeForeground */
3513 value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3515 XrmPutResource (&db,
3516 ResCat (res_class, screen_name, WmNactiveForeground,
3517 NULL), XtRPixel, &value);
3519 /* activeBackground */
3520 value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3522 XrmPutResource (&db,
3523 ResCat (res_class, screen_name, WmNactiveBackground,
3524 NULL), XtRPixel, &value);
3526 XrmPutStringResource (&db, ResCat (res_class, screen_name,
3527 WmNactiveBackgroundPixmap, NULL),
3530 /* activeTopShadow */
3531 XrmPutStringResource (&db, ResCat (res_class, screen_name,
3532 WmNactiveTopShadowPixmap, NULL),
3535 value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3536 XrmPutResource (&db,
3537 ResCat (res_class, screen_name, WmNactiveTopShadowColor,
3538 NULL), XtRPixel, &value);
3540 /* activeBottomShadow */
3541 value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3542 XrmPutResource (&db,
3543 ResCat (res_class, screen_name,
3544 WmNactiveBottomShadowColor, NULL), XtRPixel, &value);
3546 XrmPutStringResource (&db, ResCat (res_class, screen_name,
3547 WmNactiveBottomShadowPixmap, NULL),
3551 else /* active colors for non-BW systems */
3553 value.addr = (XtPointer) &(tpixset->bg);
3554 XrmPutResource (&db,
3555 ResCat (res_class, screen_name, WmNactiveBackground, NULL),
3558 value.addr = (XtPointer) &(tpixset->fg);
3559 XrmPutResource (&db,
3560 ResCat (res_class, screen_name, WmNactiveForeground, NULL),
3563 value.addr = (XtPointer) &(tpixset->ts);
3564 XrmPutResource (&db,
3565 ResCat (res_class, screen_name, WmNactiveTopShadowColor, NULL),
3568 value.addr = (XtPointer) &(tpixset->bs);
3569 XrmPutResource (&db,
3570 ResCat (res_class, screen_name, WmNactiveBottomShadowColor, NULL),
3573 if (XmCO_DitherTopShadow(DISPLAY, thisScreen, tpixset))
3575 XrmPutStringResource (&db,
3576 ResCat (res_class, screen_name, WmNactiveTopShadowPixmap, NULL),
3581 if (XmCO_DitherBottomShadow(DISPLAY, thisScreen, tpixset))
3583 XrmPutStringResource (&db,
3584 ResCat (res_class, screen_name, WmNactiveBottomShadowPixmap,
3593 * WM INACTIVE colors--e.g., for dialogues
3596 if (pSD->pInactivePixelSet)
3598 tpixset = pSD->pInactivePixelSet;
3599 spixset = pSD->pSecondaryPixelSet;
3601 if (pSD->colorUse == XmCO_BLACK_WHITE)
3606 * Set colors/pixmaps for the frames--leave the
3607 * menus out of it so that their text won't look
3608 * unsatisfactory against a dithered background.
3613 value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3615 XrmPutResource (&db,
3616 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3617 WmNforeground), XtRPixel, &value);
3619 XrmPutResource (&db,
3620 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3621 WmNforeground), XtRPixel, &value);
3625 XrmPutStringResource (&db,
3626 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3627 WmNbackgroundPixmap), _Dither);
3629 XrmPutStringResource (&db,
3630 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3631 WmNbackgroundPixmap), _Dither);
3633 value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3634 XrmPutResource (&db,
3635 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3636 WmNbackground), XtRPixel, &value);
3638 XrmPutResource (&db,
3639 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3640 WmNbackground), XtRPixel, &value);
3643 XrmPutStringResource (&db,
3644 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3645 WmNtopShadowPixmap), _foreground);
3647 XrmPutStringResource (&db,
3648 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3649 WmNtopShadowPixmap), _foreground);
3651 value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3652 XrmPutResource (&db,
3653 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3654 WmNtopShadowColor), XtRPixel, &value);
3656 XrmPutResource (&db,
3657 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3658 WmNtopShadowColor), XtRPixel, &value);
3662 XrmPutStringResource (&db,
3663 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3664 WmNbottomShadowPixmap), _foreground);
3666 XrmPutStringResource (&db,
3667 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3668 WmNbottomShadowPixmap), _foreground);
3670 value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3672 XrmPutResource (&db,
3673 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3674 WmNbottomShadowColor), XtRPixel, &value);
3676 XrmPutResource (&db,
3677 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3678 WmNbottomShadowColor), XtRPixel, &value);
3682 * Ensure that the icon images have a black foreground and
3683 * a white background.
3686 value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3688 XrmPutResource (&db,
3689 ResCat (res_class, screen_name, WmNiconImageForeground,
3690 NULL), XtRPixel, &value);
3692 value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3694 XrmPutResource (&db,
3695 ResCat (res_class, screen_name, WmNiconImageBackground,
3696 NULL), XtRPixel, &value);
3698 /* Now deal with XmCO_BLACK_WHITE Menus */
3700 /* XmCO_BLACK_WHITE menu foreground */
3701 value.addr = (XtPointer) &(tpixset->fg);
3703 XrmPutResource (&db,
3704 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3705 WmNforeground), XtRPixel, &value);
3707 /* XmCO_BLACK_WHITE menu background */
3708 value.addr = (XtPointer) &(tpixset->bg);
3710 XrmPutResource (&db,
3711 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3712 WmNbackground), XtRPixel, &value);
3714 /* XmCO_BLACK_WHITE menu top shadow */
3716 XrmPutStringResource (&db,
3717 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3718 WmNtopShadowPixmap), _50_foreground);
3720 /* use foreground color for this pixmap */
3721 value.addr = (XtPointer) &(tpixset->fg);
3723 XrmPutResource (&db,
3724 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3725 WmNtopShadowColor), XtRPixel, &value);
3727 /* XmCO_BLACK_WHITE menu bottom shadow */
3729 XrmPutStringResource (&db,
3730 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3731 WmNbottomShadowPixmap), _75_foreground);
3733 /* use foreground color for this pixmap */
3734 value.addr = (XtPointer) &(tpixset->fg);
3736 XrmPutResource (&db,
3737 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3738 WmNbottomShadowColor), XtRPixel, &value);
3740 /* Finally, deal with XmCO_BLACK_WHITE Confirm Boxes */
3742 /* XmCO_BLACK_WHITE confirm box foreground */
3743 value.addr = (XtPointer) &(spixset->fg);
3745 XrmPutResource (&db,
3746 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3747 WmNforeground), XtRPixel, &value);
3749 /* XmCO_BLACK_WHITE confirm box background */
3750 value.addr = (XtPointer) &(spixset->bg);
3752 XrmPutResource (&db,
3753 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3754 WmNbackground), XtRPixel, &value);
3756 /* XmCO_BLACK_WHITE confirm box top shadow */
3758 XrmPutStringResource (&db,
3759 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3760 WmNtopShadowPixmap), _50_foreground);
3762 /* use foreground color */
3763 value.addr = (XtPointer) &(spixset->fg);
3765 XrmPutResource (&db,
3766 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3767 WmNtopShadowColor), XtRPixel, &value);
3769 /* XmCO_BLACK_WHITE confirm box bottom shadow */
3771 XrmPutStringResource (&db,
3772 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3773 WmNbottomShadowPixmap), _75_foreground);
3775 /* use foreground color */
3776 value.addr = (XtPointer) &(spixset->fg);
3778 XrmPutResource (&db,
3779 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3780 WmNbottomShadowColor), XtRPixel, &value);
3782 /* use select color for icon box trough color */
3784 value.addr = (XtPointer) &(tpixset->sc);
3786 XrmPutResource (&db,
3787 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3788 XmNtroughColor), XtRPixel, &value);
3790 /* use select color for arm and select colors in dialogs */
3792 value.addr = (XtPointer) &(spixset->sc);
3794 XrmPutResource (&db,
3795 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3796 XmNarmColor), XtRPixel, &value);
3798 XrmPutResource (&db,
3799 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3800 XmNselectColor), XtRPixel, &value);
3802 XrmPutResource (&db,
3803 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3804 XmNtroughColor), XtRPixel, &value);
3806 else /* inactive colors for non-BW systems */
3808 XmPixelSet *fpixset;
3811 * Set mwm component colors
3813 value.addr = (XtPointer) &(tpixset->bg);
3814 XrmPutResource (&db,
3815 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3816 WmNbackground), XtRPixel, &value);
3818 XrmPutResource (&db,
3819 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3820 WmNbackground), XtRPixel, &value);
3822 XrmPutResource (&db,
3823 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3824 WmNbackground), XtRPixel, &value);
3826 value.addr = (XtPointer) &(spixset->bg);
3827 XrmPutResource (&db,
3828 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3829 WmNbackground), XtRPixel, &value);
3831 value.addr = (XtPointer) &(tpixset->ts);
3832 XrmPutResource (&db,
3833 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3834 WmNtopShadowColor), XtRPixel, &value);
3836 XrmPutResource (&db,
3837 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3838 WmNtopShadowColor), XtRPixel, &value);
3840 XrmPutResource (&db,
3841 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3842 WmNtopShadowColor), XtRPixel, &value);
3844 value.addr = (XtPointer) &(spixset->ts);
3845 XrmPutResource (&db,
3846 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3847 WmNtopShadowColor), XtRPixel, &value);
3849 value.addr = (XtPointer) &(tpixset->bs);
3850 XrmPutResource (&db,
3851 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3852 WmNbottomShadowColor), XtRPixel, &value);
3854 XrmPutResource (&db,
3855 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3856 WmNbottomShadowColor), XtRPixel, &value);
3858 XrmPutResource (&db,
3859 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3860 WmNbottomShadowColor), XtRPixel, &value);
3862 value.addr = (XtPointer) &(spixset->bs);
3863 XrmPutResource (&db,
3864 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3865 WmNbottomShadowColor), XtRPixel, &value);
3867 value.addr = (XtPointer) &(tpixset->fg);
3868 XrmPutResource (&db,
3869 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3870 WmNforeground), XtRPixel, &value);
3872 XrmPutResource (&db,
3873 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3874 WmNforeground), XtRPixel, &value);
3876 XrmPutResource (&db,
3877 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3878 WmNforeground), XtRPixel, &value);
3880 value.addr = (XtPointer) &(spixset->fg);
3881 XrmPutResource (&db,
3882 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3883 WmNforeground), XtRPixel, &value);
3886 * Set select color only for menus and feedback mwm
3887 * parts. Client and Icon parts aren't real widgets.
3888 * Set client trough color for icon box.
3890 value.addr = (XtPointer) &(tpixset->sc);
3891 XrmPutResource (&db,
3892 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3893 XmNselectColor), XtRPixel, &value);
3895 XrmPutResource (&db,
3896 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3897 XmNarmColor), XtRPixel, &value);
3899 XrmPutResource (&db,
3900 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3901 XmNtroughColor), XtRPixel, &value);
3903 XrmPutResource (&db,
3904 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3905 XmNtroughColor), XtRPixel, &value);
3907 XrmPutResource (&db,
3908 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3909 XmNselectColor), XtRPixel, &value);
3911 value.addr = (XtPointer) &(spixset->sc);
3912 XrmPutResource (&db,
3913 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3914 XmNarmColor), XtRPixel, &value);
3916 XrmPutResource (&db,
3917 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3918 XmNtroughColor), XtRPixel, &value);
3921 * Set Dtwm dialog colors
3923 fpixset = pSD->pSecondaryPixelSet;
3925 value.addr = (XtPointer) &(fpixset->bg);
3926 XrmPutResource (&db,
3927 ResCat (res_class, screen_name, XmNbackground, NULL),
3930 value.addr = (XtPointer) &(fpixset->fg);
3931 XrmPutResource (&db,
3932 ResCat (res_class, screen_name, XmNforeground, NULL),
3935 value.addr = (XtPointer) &(fpixset->ts);
3936 XrmPutResource (&db,
3937 ResCat (res_class, screen_name, XmNtopShadowColor, NULL),
3940 value.addr = (XtPointer) &(fpixset->bs);
3941 XrmPutResource (&db,
3942 ResCat (res_class, screen_name, XmNbottomShadowColor, NULL),
3947 * Set up the select color, as for buttons in the dialogue
3951 value.addr = (XtPointer) &(fpixset->sc);
3952 XrmPutResource (&db,
3953 ResCat (res_class, screen_name, XmNselectColor, NULL),
3956 /* value.addr = (XtPointer) &(fpixset->sc); */
3957 XrmPutResource (&db,
3958 ResCat (res_class, screen_name, XmNarmColor, NULL),
3961 /* value.addr = (XtPointer) &(fpixset->sc); */
3962 XrmPutResource (&db,
3963 ResCat (res_class, screen_name, XmNtroughColor, NULL),
3966 if (XmCO_DitherTopShadow(DISPLAY, thisScreen, fpixset))
3968 XrmPutStringResource (&db,
3969 ResCat (res_class, screen_name, WmNtopShadowPixmap, NULL),
3972 if (pSD->colorUse == XmCO_BLACK_WHITE)
3974 XrmPutStringResource (&db,
3975 ResCat (res_class, screen_name,
3976 WmNbottomShadowPixmap, NULL),
3982 if (XmCO_DitherBottomShadow(DISPLAY, thisScreen, fpixset))
3984 XrmPutStringResource (&db,
3985 ResCat (res_class, screen_name, WmNbottomShadowPixmap, NULL),
3988 if (pSD->colorUse == XmCO_BLACK_WHITE)
3990 XrmPutStringResource (&db,
3991 ResCat (res_class, screen_name,
3992 WmNtopShadowPixmap, NULL),
3998 if (tpixset->bs != tpixset->ts)
4001 * If the inactive bottomshadow and topshadow are
4002 * different (i.e., valid), then make the icon image
4006 value.addr = (XtPointer) &(tpixset->bs);
4008 XrmPutResource (&db,
4009 ResCat (res_class, screen_name, WmNiconImageForeground,
4010 NULL), XtRPixel, &value);
4012 value.addr = (XtPointer) &(tpixset->ts);
4014 XrmPutResource (&db,
4015 ResCat (res_class, screen_name, WmNiconImageBackground,
4016 NULL), XtRPixel, &value);
4018 value.addr = (XtPointer) &(tpixset->bs);
4020 XrmPutResource (&db,
4021 ResCat (res_class, screen_name,
4022 WmNiconImageBottomShadowColor,
4023 NULL), XtRPixel, &value);
4025 value.addr = (XtPointer) &(tpixset->ts);
4027 XrmPutResource (&db,
4028 ResCat (res_class, screen_name,
4029 WmNiconImageTopShadowColor,
4030 NULL), XtRPixel, &value);
4035 * Ensure that the icon images have a black foreground and
4036 * a white background.
4040 value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
4042 XrmPutResource (&db,
4043 ResCat (res_class, screen_name, WmNiconImageForeground,
4044 NULL), XtRPixel, &value);
4046 value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
4048 XrmPutResource (&db,
4049 ResCat (res_class, screen_name, WmNiconImageBackground,
4050 NULL), XtRPixel, &value);
4056 if (pSD->pTextPixelSet)
4058 value.addr = (XtPointer) &(pSD->pTextPixelSet->bg);
4060 XrmPutResource (&db,
4061 ResCat (res_class, screen_name, "XmTextField",
4062 WmNbackground), XtRPixel, &value);
4064 XrmPutResource (&db,
4065 ResCat (res_class, screen_name, "XmText",
4066 WmNbackground), XtRPixel, &value);
4071 /******************************<->*************************************
4073 * ResCat (s1,s2,s3,s4)
4078 * Cats up to four strings together with '*' in between.
4083 * s1...s4 = pointers to Strings or NULL pointers (no string)
4087 * Return = pointer to statically allocated string that has
4088 * the passed in string cat'ed together with '*'s
4093 * Does no limit checking on the static buffer
4095 *************************************<->***********************************/
4098 ResCat (String s1, String s2, String s3, String s4)
4104 Boolean useResourceClass = True;
4106 wmGD.tmpBuffer[0] = '\0';
4112 if ((MwmBehavior) &&
4113 !strcmp (s1, WM_RESOURCE_CLASS))
4116 * if this routine is called with a class name
4117 * ("Mwm" or "Dtwm"), then DON'T use it.
4118 * We want our resources to be written out
4119 * as: *iconImageForeground: <pixel_val>
4121 * as opposed to: Dtwm*iconImageForeground: <pixel_val>
4125 useResourceClass = False;
4127 else if (!strcmp (s1, DT_WM_RESOURCE_CLASS))
4129 useResourceClass = False;
4133 strncat((char *)wmGD.tmpBuffer, s1, count);
4134 count -= strlen(s1);
4137 if (s2 && (count > 0))
4139 strncat ((char *)wmGD.tmpBuffer, "*", count);
4141 strncat ((char *)wmGD.tmpBuffer, s2, count);
4142 count -= strlen (s2);
4144 if (s3 && (count > 0))
4146 strncat ((char *)wmGD.tmpBuffer, "*", count);
4148 strncat ((char *)wmGD.tmpBuffer, s3, count);
4149 count -= strlen (s3);
4153 strncat ((char *)wmGD.tmpBuffer, "*", count);
4155 strncat ((char *)wmGD.tmpBuffer, s4, count);
4160 return ((String) wmGD.tmpBuffer);
4162 } /* END OF FUNCTION ResCat */
4166 /******************************<->*************************************
4168 * CheckForNoDither (pAD)
4173 * Checks for reserved string as pixmap name of dither that indicates
4174 * no dithering and replaces the string with a NULL.
4179 * pAD = pointer to appearance data
4183 * pAD = pointer to appearance data (may be modified)
4187 * This check is done to avoid repeated calls to XmGetPixmap when
4188 * managing windows. XmGetPixmap doesn't cache failures, and the
4189 * NoDither string should fail every time. We want to prevent
4190 * XmGetPixmap from call XtResolvePathName to rummage through
4193 *************************************<->***********************************/
4196 CheckForNoDither (AppearanceData *pAD)
4198 if (pAD->backgroundPStr &&
4199 !strcmp(pAD->backgroundPStr, _NoDither))
4201 pAD->backgroundPStr = NULL;
4203 if (pAD->bottomShadowPStr &&
4204 !strcmp(pAD->bottomShadowPStr, _NoDither))
4206 pAD->bottomShadowPStr = NULL;
4208 if (pAD->topShadowPStr &&
4209 !strcmp(pAD->topShadowPStr, _NoDither))
4211 pAD->topShadowPStr = NULL;
4213 if (pAD->activeBackgroundPStr &&
4214 !strcmp(pAD->activeBackgroundPStr, _NoDither))
4216 pAD->activeBackgroundPStr = NULL;
4218 if (pAD->activeBottomShadowPStr &&
4219 !strcmp(pAD->activeBottomShadowPStr, _NoDither))
4221 pAD->activeBottomShadowPStr = NULL;
4223 if (pAD->activeTopShadowPStr &&
4224 !strcmp(pAD->activeTopShadowPStr, _NoDither))
4226 pAD->activeTopShadowPStr = NULL;
4229 } /* END OF FUNCTION CheckForNoDither */
4235 /******************************<->*************************************
4237 * ProcessAppearanceResources (pSD)
4242 * Retrieve and process the general appearance resources for the mwm
4243 * subparts: "client", "icon", and "feedback"
4248 * pSD = pointer to screen data
4252 * modifies parts of global data wmGD.
4256 * o Changeable GCs are created with XCreateGC. The base GCs used for
4257 * text output will have clip_masks defined for them later.
4260 *************************************<->***********************************/
4263 ProcessAppearanceResources (WmScreenData *pSD)
4265 Widget clientW; /* dummy widget for resource fetching */
4271 * Get the client subpart resources:
4274 /* save info in static globals for dynamic default processing */
4275 _defaultBackground = _defaultColor1;
4276 _defaultActiveBackground = _defaultColor2;
4277 _pAppearanceData = &(pSD->clientAppearance);
4279 (void)XtGetSubresources (pSD->screenTopLevelW,
4280 (XtPointer) &(pSD->clientAppearance),
4281 WmNclient, WmCClient, wmAppearanceResources,
4282 XtNumber (wmAppearanceResources), NULL, 0);
4284 CheckForNoDither (&(pSD->clientAppearance));
4289 * Process the client resource values:
4292 /* make background, top and bottom shadow pixmaps */
4294 MakeAppearanceResources (pSD, &(pSD->clientAppearance), True);
4298 * Get the client.title subpart resources:
4301 /* insert "client" widget in hierarchy */
4304 clientW = XtCreateWidget (WmNclient, xmRowColumnWidgetClass,
4305 pSD->screenTopLevelW, (ArgList) args, i);
4308 /* fetch "client.title" subpart appearance resources */
4310 _pAppearanceData = &(pSD->clientTitleAppearance);
4312 (void)XtGetSubresources (clientW, (XtPointer) &(pSD->clientTitleAppearance),
4313 WmNtitle, WmCTitle, wmAppearanceResources,
4314 XtNumber (wmAppearanceResources), NULL, 0);
4316 CheckForNoDither (&(pSD->clientTitleAppearance));
4321 * Process the client.title resource values:
4326 * check if client title appearance is different from the rest of frame.
4328 if (SimilarAppearanceData (&(pSD->clientAppearance),
4329 &(pSD->clientTitleAppearance)))
4331 /* title bar doesn't need special graphic processing */
4332 pSD->decoupleTitleAppearance = False;
4336 /* make background, top and bottom shadow pixmaps */
4337 MakeAppearanceResources (pSD, &(pSD->clientTitleAppearance), True);
4338 pSD->decoupleTitleAppearance = True;
4341 XtDestroyWidget (clientW); /* all done with dummy widget */
4345 * Get the icon subpart resources:
4348 _pAppearanceData = &(pSD->iconAppearance);
4350 (void)XtGetSubresources (pSD->screenTopLevelW,
4351 (XtPointer) &(pSD->iconAppearance),
4352 WmNicon, WmCIcon, wmAppearanceResources,
4353 XtNumber (wmAppearanceResources), NULL, 0);
4355 CheckForNoDither (&(pSD->iconAppearance));
4360 * Process the icon resource values:
4363 /* make background, top and bottom shadow pixmaps */
4365 MakeAppearanceResources (pSD, &(pSD->iconAppearance), True);
4369 * Get the feedback subpart resources:
4370 * !!! only get "inactive" resources !!!
4373 _defaultBackground = _defaultColor2;
4374 _defaultActiveBackground = _defaultColor2;
4375 _pAppearanceData = &(pSD->feedbackAppearance);
4377 (void)XtGetSubresources (pSD->screenTopLevelW,
4378 (XtPointer) &(pSD->feedbackAppearance),
4379 WmNfeedback, WmCFeedback, wmAppearanceResources,
4380 XtNumber (wmAppearanceResources), NULL, 0);
4382 CheckForNoDither (&(pSD->feedbackAppearance));
4386 * Process the feedback resource values:
4389 /* make background, top and bottom shadow pixmaps */
4391 MakeAppearanceResources (pSD, &(pSD->feedbackAppearance), False);
4394 } /* END OF FUNCTION ProcessAppearanceResources */
4397 /*************************************<->*************************************
4399 * MakeAppearanceResources (pSD, pAData, makeActiveResources)
4404 * This function makes top, bottom and background pixmaps for a window
4405 * manager component. Inactive and active (if specified) GC's are
4411 * pSD = pointer to screen data
4413 * pAData = pointer to appearance data structure containing resource info
4415 * makeActiveResources = if True then make active resources
4419 * *pAData = pixmap and GC fields filled out
4421 *************************************<->***********************************/
4424 MakeAppearanceResources (WmScreenData *pSD, AppearanceData *pAData, Boolean makeActiveResources)
4429 * Extract a font from the font list.
4432 if (! XmeRenderTableGetDefaultFont(pAData->fontList, &(pAData->font)))
4434 sprintf((char *)wmGD.tmpBuffer, ((char *)GETMESSAGE(62, 23, "failed to load font: %.100s\0")), (char*) pAData->fontList);
4435 Warning((char *)wmGD.tmpBuffer);
4436 #if defined(CSRG_BASED) || defined(linux)
4437 /* HACK to try get _some_ font anyway (fontList seems to end up as an empty list on
4438 * some modern systems; investigate) */
4439 pAData->font = XLoadQueryFont(wmGD.display, "fixed");
4440 if (pAData->font == NULL) {
4441 ExitWM(WM_ERROR_EXIT_VALUE);
4444 ExitWM(WM_ERROR_EXIT_VALUE);
4449 #ifndef NO_MULTIBYTE
4451 * Calculate title bar's height and store it in pAData.
4453 pAData->titleHeight = (pAData->font)->ascent + (pAData->font)->descent
4454 + WM_TITLE_BAR_PADDING;
4459 * Make standard (inactive) appearance resources.
4462 /* background pixmap */
4464 if (pAData->backgroundPStr)
4466 pAData->backgroundPixmap = XmGetPixmap (
4467 ScreenOfDisplay (DISPLAY,
4469 pAData->backgroundPStr,
4471 pAData->background);
4473 if (pAData->backgroundPixmap == XmUNSPECIFIED_PIXMAP)
4475 pAData->backgroundPixmap = (Pixmap)NULL;
4480 pAData->backgroundPixmap = (Pixmap)NULL;
4483 /* top shadow pixmap */
4485 if (pAData->topShadowPStr)
4488 * Make sure top shadow color is not the same as background
4489 * otherwise the wrong pixmap will be generated.
4491 if (pAData->topShadowColor != pAData->background)
4492 foreground = pAData->topShadowColor;
4494 foreground = pAData->foreground;
4495 pAData->topShadowPixmap = XmGetPixmap (
4496 ScreenOfDisplay (DISPLAY,
4498 pAData->topShadowPStr,
4500 pAData->background);
4502 if (pAData->topShadowPixmap == XmUNSPECIFIED_PIXMAP)
4504 pAData->topShadowPixmap = (Pixmap)NULL;
4509 pAData->topShadowPixmap = (Pixmap)NULL;
4513 /* bottom shadow pixmap */
4515 if (pAData->bottomShadowPStr)
4518 * Make sure bottom shadow color is not the same as background
4519 * otherwise the wrong pixmap will be generated.
4521 if (pAData->bottomShadowColor != pAData->background)
4522 foreground = pAData->bottomShadowColor;
4524 foreground = pAData->foreground;
4525 pAData->bottomShadowPixmap = XmGetPixmap (
4526 ScreenOfDisplay (DISPLAY,
4528 pAData->bottomShadowPStr,
4530 pAData->background);
4532 if (pAData->bottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
4534 pAData->bottomShadowPixmap = (Pixmap)NULL;
4539 pAData->bottomShadowPixmap = (Pixmap)NULL;
4542 /* inactive appearance GC */
4544 GetAppearanceGCs (pSD,
4548 pAData->backgroundPixmap,
4549 pAData->topShadowColor,
4550 pAData->topShadowPixmap,
4551 pAData->bottomShadowColor,
4552 pAData->bottomShadowPixmap,
4553 &(pAData->inactiveGC),
4554 &(pAData->inactiveTopShadowGC),
4555 &(pAData->inactiveBottomShadowGC));
4560 * Make active apppearance resources if specified.
4563 if (!makeActiveResources)
4568 /* active background pixmap */
4570 if (pAData->activeBackgroundPStr)
4572 pAData->activeBackgroundPixmap = XmGetPixmap (
4573 ScreenOfDisplay (DISPLAY,
4575 pAData->activeBackgroundPStr,
4576 pAData->activeForeground,
4577 pAData->activeBackground);
4579 if (pAData->activeBackgroundPixmap == XmUNSPECIFIED_PIXMAP)
4581 pAData->activeBackgroundPixmap = (Pixmap)NULL;
4586 pAData->activeBackgroundPixmap = (Pixmap)NULL;
4589 /* active top shadow pixmap */
4591 if (pAData->activeTopShadowPStr)
4593 pAData->activeTopShadowPixmap = XmGetPixmap (
4594 ScreenOfDisplay (DISPLAY,
4596 pAData->activeTopShadowPStr,
4597 pAData->activeTopShadowColor,
4598 pAData->activeBackground);
4600 if (pAData->activeTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
4602 pAData->activeTopShadowPixmap = (Pixmap)NULL;
4607 pAData->activeTopShadowPixmap = (Pixmap)NULL;
4611 /* active bottom shadow pixmap */
4613 if (pAData->activeBottomShadowPStr)
4615 pAData->activeBottomShadowPixmap = XmGetPixmap (
4616 ScreenOfDisplay (DISPLAY,
4618 pAData->activeBottomShadowPStr,
4619 pAData->activeBottomShadowColor,
4620 pAData->activeBackground);
4622 if (pAData->activeBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
4624 pAData->activeBottomShadowPixmap = (Pixmap)NULL;
4629 pAData->activeBottomShadowPixmap = (Pixmap)NULL;
4632 /* inactive appearance GC */
4634 GetAppearanceGCs (pSD,
4635 pAData->activeForeground,
4636 pAData->activeBackground,
4638 pAData->activeBackgroundPixmap,
4639 pAData->activeTopShadowColor,
4640 pAData->activeTopShadowPixmap,
4641 pAData->activeBottomShadowColor,
4642 pAData->activeBottomShadowPixmap,
4643 &(pAData->activeGC),
4644 &(pAData->activeTopShadowGC),
4645 &(pAData->activeBottomShadowGC));
4648 } /* END OF FUNCTION MakeAppearanceResources */
4652 /*************************************<->*************************************
4654 * GetAppearanceGCs (pSD, fg, bg, font, bg_pixmap, ts_color,
4655 * ts_pixmap, bs_color, bs_pixmap, pGC, ptsGC, pbsGC)
4660 * Creates the appearance GCs for any of the icon, client, or feedback
4666 * pSD - pointer to screen data
4667 * fg - base foreground color
4668 * bg - base background color
4670 * bg_pixmap - background pixmap
4671 * ts_color - top shadow color
4672 * ts_pixmap - top shadow pixmap
4673 * bs_color - bottom shadow color
4674 * bs_pixmap - bottom shadow pixmap
4675 * pGC - pointer to location to receive base GC
4676 * ptsGC - pointer to location to receive top shadow GC
4677 * pbsGC - pointer to location to receive bottom shadow GC
4682 * *ptsGC - top shadow GC
4683 * *pbsGC - bottom shadow GC
4690 *************************************<->***********************************/
4693 GetAppearanceGCs (WmScreenData *pSD, Pixel fg, Pixel bg, XFontStruct *font, Pixmap bg_pixmap, Pixel ts_color, Pixmap ts_pixmap, Pixel bs_color, Pixmap bs_pixmap, GC *pGC, GC *ptsGC, GC *pbsGC)
4703 mask = GCForeground | GCBackground | GCFont;
4704 gcv.foreground = fg;
4705 gcv.background = bg;
4706 gcv.font = font->fid;
4711 gcv.tile = bg_pixmap;
4714 *pGC = XCreateGC (DISPLAY, pSD->rootWindow, mask, &gcv);
4717 * !!! Need GC error detection !!!
4720 *ptsGC = GetHighlightGC (pSD, ts_color, bg, ts_pixmap);
4722 *pbsGC = GetHighlightGC (pSD, bs_color, bg, bs_pixmap);
4724 } /* END OF FUNCTION GetAppearanceGCs */
4729 /*************************************<->*************************************
4731 * ProcessScreenResources (pSD, screenName)
4736 * This function retrieves resources that are screen specific. If the
4737 * window manager is providing standard behavior then retrieve the limited
4738 * set of resources that don't affect standard behavior and set the
4739 * values of the other resources to the standard values.
4744 * pSD = pointer to screen data
4745 * screenName = name of screen
4750 * pSD = resource data for screen is set
4755 * o Gets subresources based on workspace name
4757 *************************************<->***********************************/
4760 ProcessScreenResources (WmScreenData *pSD, unsigned char *screenName)
4763 pResSD = pSD; /* save current screen data for default processing */
4765 * Use the screen name (e.g., "0") as the default resource name.
4768 if (wmGD.useStandardBehavior)
4770 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4771 (String) screenName,
4772 (String) screenName,
4773 wmStdScreenResources,
4774 XtNumber (wmStdScreenResources), NULL, 0);
4777 * Fill in the standard resource values.
4780 SetStdScreenResourceValues (pSD);
4784 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4785 (String)screenName, (String) screenName,
4787 XtNumber (wmScreenResources), NULL, 0);
4789 #ifndef MOTIF_ONE_DOT_ONE
4790 pSD->moveOpaque = (((XmScreen) XmGetXmScreen(XtScreen(pSD->screenTopLevelW)))
4791 -> screen.moveOpaque);
4797 * Retrieve screen specific resources.
4800 if (wmGD.useStandardBehavior)
4802 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4803 (String) screenName, (String)screenName, wmStdScreenResources,
4804 XtNumber (wmStdScreenResources), NULL, 0);
4807 * Fill in the standard resource values.
4810 SetStdScreenResourceValues (pSD);
4814 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4815 (String)screenName, (String)screenName, wmScreenResources,
4816 XtNumber (wmScreenResources), NULL, 0);
4818 #ifndef MOTIF_ONE_DOT_ONE
4819 pSD->moveOpaque =(((XmScreen) XmGetXmScreen(XtScreen(pSD->screenTopLevelW)))
4820 -> screen.moveOpaque);
4826 * Do some additional processing on the window manager resource values.
4830 if (pSD->iconImageMinimum.width < ICON_IMAGE_MIN_WIDTH)
4832 pSD->iconImageMinimum.width = ICON_IMAGE_MIN_WIDTH;
4834 else if (pSD->iconImageMinimum.width > ICON_IMAGE_MAX_WIDTH)
4836 pSD->iconImageMinimum.width = ICON_IMAGE_MAX_WIDTH;
4839 if (pSD->iconImageMinimum.height < ICON_IMAGE_MIN_HEIGHT)
4841 pSD->iconImageMinimum.height = ICON_IMAGE_MIN_HEIGHT;
4843 else if (pSD->iconImageMinimum.height > ICON_IMAGE_MAX_HEIGHT)
4845 pSD->iconImageMinimum.height = ICON_IMAGE_MAX_HEIGHT;
4848 if (pSD->iconImageMaximum.width < pSD->iconImageMinimum.width)
4850 pSD->iconImageMaximum.width = pSD->iconImageMinimum.width;
4852 else if (pSD->iconImageMaximum.width > ICON_IMAGE_MAX_WIDTH)
4854 pSD->iconImageMaximum.width = ICON_IMAGE_MAX_WIDTH;
4857 if (pSD->iconImageMaximum.height < pSD->iconImageMinimum.height)
4859 pSD->iconImageMaximum.height = pSD->iconImageMinimum.height;
4861 else if (pSD->iconImageMaximum.height > ICON_IMAGE_MAX_HEIGHT)
4863 pSD->iconImageMaximum.height = ICON_IMAGE_MAX_HEIGHT;
4866 if (pSD->iconPlacementMargin > MAXIMUM_ICON_MARGIN)
4868 pSD->iconPlacementMargin = MAXIMUM_ICON_MARGIN;
4871 if (pSD->maximumMaximumSize.width <= 0)
4873 pSD->maximumMaximumSize.width =
4874 2 * DisplayWidth (DISPLAY, pSD->screen);
4877 if (pSD->maximumMaximumSize.height <= 0)
4879 pSD->maximumMaximumSize.height =
4880 2 * DisplayHeight (DISPLAY, pSD->screen);
4884 * Set the icon appearance default based on whether or not the icon box
4888 if (pSD->iconDecoration & USE_ICON_DEFAULT_APPEARANCE)
4890 if (pSD->useIconBox)
4892 pSD->iconDecoration = ICON_APPEARANCE_ICONBOX;
4896 pSD->iconDecoration = ICON_APPEARANCE_STANDALONE;
4901 * If resizeBorderWidth or frameBorderWidth is unset then initialize
4902 * to dynamic defaults.
4905 if ((pSD->resizeBorderWidth == (Dimension)BIGSIZE) ||
4906 (pSD->frameBorderWidth == (Dimension)BIGSIZE))
4908 double xres, yres, avg_res;
4910 xres = (((double) DisplayWidth(DISPLAY, pSD->screen)) /
4911 ((double) DisplayWidthMM(DISPLAY, pSD->screen)));
4912 yres = (((double) DisplayHeight(DISPLAY, pSD->screen)) /
4913 ((double) DisplayHeightMM(DISPLAY, pSD->screen)));
4915 avg_res = (xres + yres) / 2.0;
4917 /* Multiply times width in mm (avg. 7-8 pixels) */
4918 if (pSD->resizeBorderWidth == (Dimension)BIGSIZE)
4920 pSD->resizeBorderWidth = (int) (avg_res * 2.2);
4922 /* limit size because big borders look ugly */
4924 if (wmGD.frameStyle == WmSLAB)
4927 if (pSD->resizeBorderWidth > 6) pSD->resizeBorderWidth = 6;
4932 if (pSD->resizeBorderWidth > 7) pSD->resizeBorderWidth = 7;
4937 /* Multiply times width in mm (avg. 5-6 pixels) */
4938 if (pSD->frameBorderWidth == (Dimension)BIGSIZE)
4940 pSD->frameBorderWidth = (int) (avg_res * 1.7);
4942 /* limit size because big borders look ugly */
4943 if (wmGD.frameStyle == WmSLAB)
4945 if (pSD->frameBorderWidth > 4) pSD->frameBorderWidth = 4;
4949 if (pSD->frameBorderWidth > 5) pSD->frameBorderWidth = 5;
4955 pSD->externalBevel = FRAME_EXTERNAL_SHADOW_WIDTH;
4956 pSD->joinBevel = FRAME_INTERNAL_SHADOW_WIDTH;
4957 if (pSD->frameBorderWidth <
4958 (pSD->externalBevel + MIN_INTERNAL_BEVEL))
4960 pSD->frameBorderWidth =
4961 pSD->externalBevel + MIN_INTERNAL_BEVEL;
4963 else if (pSD->frameBorderWidth > MAXIMUM_FRAME_BORDER_WIDTH)
4965 pSD->frameBorderWidth = MAXIMUM_FRAME_BORDER_WIDTH;
4968 if (pSD->resizeBorderWidth <
4969 (pSD->externalBevel + MIN_INTERNAL_BEVEL))
4971 pSD->resizeBorderWidth =
4972 (pSD->externalBevel + MIN_INTERNAL_BEVEL);
4974 else if (pSD->resizeBorderWidth > MAXIMUM_FRAME_BORDER_WIDTH)
4976 pSD->resizeBorderWidth = MAXIMUM_FRAME_BORDER_WIDTH;
4981 * Update the resource database.
4983 WriteOutXrmColors (pSD);
4988 * Process the component appearance resources for client,
4989 * icon and feedback parts of mwm.
4992 ProcessAppearanceResources (pSD);
4996 * Process the workspace list and name the initial
5000 ProcessWorkspaceList (pSD);
5003 * Process default backdrop images to be used in low-color
5006 ProcessDefaultBackdropImages (pSD);
5010 * Save the default icon pixmap in global data. We'll use it only
5014 pSD->builtinIconPixmap =
5015 XCreateBitmapFromData (DISPLAY, pSD->rootWindow, (char *)iImage_bits,
5016 iImage_width, iImage_height);
5018 } /* END OF FUNCTION ProcessScreenResources */
5022 /*************************************<->*************************************
5024 * ProcessDefaultBackdropImages (pSD)
5029 * This function processes the default backdrop images to be used
5030 * in low color or black and white workspaces.
5035 * pSD = pointer to screen data
5040 * pSD = resource data for screen is set
5046 *************************************<->***********************************/
5049 ProcessDefaultBackdropImages (WmScreenData *pSD)
5051 } /* END OF FUNCTION ProcessDefaultBackdropImages */
5055 /*************************************<->*************************************
5057 * ProcessWorkspaceList (pSD)
5062 * This function processes the workspaceCount and workspaceList
5063 * resources for a particular screen. It creates space for the initial
5064 * workspace data structures and adds in names for workspaces.
5069 * pSD = pointer to screen data
5074 * pSD = resource data for screen is set
5079 * NOTE: The workspaceCount resource has precedence over the
5080 * workspaceList resource. workspaceCount determines the number of
5081 * workspaces to create for the screen. Once the number is determined,
5082 * workspaceList is used to fill in the "names." If workspaceList is
5083 * not present or doesn't have enough names, then missing names are
5084 * generated automatically. If workspaceList is present and
5085 * workspaceCount is not present, then the workspaceCount is determined
5086 * by the number of names in workspaceList.
5088 *************************************<->***********************************/
5091 ProcessWorkspaceList (WmScreenData *pSD)
5093 int i, wsNameCount, wsNamesAlloced;
5094 WmWorkspaceData *pwsI;
5095 unsigned char *lineP = NULL;
5096 unsigned char *string;
5097 Boolean bHaveWorkspaceList;
5098 Boolean bHaveWorkspaceCount;
5099 char **ppchWsNames = NULL;
5102 * Validate initial resource settings
5104 bHaveWorkspaceCount = (pSD->numWorkspaces >= 1);
5105 bHaveWorkspaceList = (pSD->workspaceList != NULL);
5107 if (bHaveWorkspaceList)
5110 * Parse out array of workspace names
5112 wsNamesAlloced = WS_ALLOC_AMOUNT;
5113 ppchWsNames = (char **) XtMalloc (wsNamesAlloced * sizeof (char *));
5114 if (pSD->workspaceList)
5116 lineP = (unsigned char *) pSD->workspaceList;
5120 lineP = (unsigned char *)NULL;
5124 while (((string = GetString(&lineP)) != NULL))
5126 ppchWsNames[wsNameCount] = (char *) string;
5128 if (++wsNameCount >= wsNamesAlloced)
5131 * Need to add more workspaces
5133 wsNamesAlloced += WS_ALLOC_AMOUNT;
5134 if (!(ppchWsNames = (char **) XtRealloc
5135 ((char *)ppchWsNames,
5136 wsNamesAlloced * sizeof(char *))))
5138 ExitWM (WM_ERROR_EXIT_VALUE);
5143 if (!bHaveWorkspaceCount)
5145 pSD->numWorkspaces = wsNameCount;
5148 else if (!bHaveWorkspaceCount)
5151 * Neither workspaceCount nor workspaceList specified!!
5152 * Assume one workspace.
5154 pSD->numWorkspaces = 1;
5157 if (pSD->numWorkspaces > MAX_WORKSPACE_COUNT)
5158 pSD->numWorkspaces = MAX_WORKSPACE_COUNT;
5161 * Allocate the array of workspace data
5163 pSD->numWsDataAllocated = (pSD->numWorkspaces + WS_ALLOC_AMOUNT);
5164 pSD->numWsDataAllocated -= pSD->numWsDataAllocated % WS_ALLOC_AMOUNT;
5165 if (!(pSD->pWS = (WmWorkspaceData *)
5166 XtMalloc (pSD->numWsDataAllocated * sizeof(WmWorkspaceData))))
5168 ExitWM (WM_ERROR_EXIT_VALUE);
5173 for (i = 0; i < pSD->numWorkspaces; i++, pwsI++)
5175 if (bHaveWorkspaceList && i < wsNameCount)
5177 string = (unsigned char *) ppchWsNames[i];
5181 string = GenerateWorkspaceName (pSD, i);
5183 if (!(pwsI->name = (String) XtMalloc (1+strlen((char *)string))))
5185 Warning (((char *)GETMESSAGE(62, 27, "Insufficient memory for workspace data")));
5186 ExitWM(WM_ERROR_EXIT_VALUE);
5190 strcpy(pwsI->name, (char *)string);
5194 if (ppchWsNames) XtFree ((char *) ppchWsNames);
5196 } /* END OF FUNCTION ProcessWorkspaceList */
5201 /******************************<->*************************************
5203 * ProcessWorkspaceResources (pWS)
5208 * This function retrieves resources that are workspace specific. If the
5209 * window manager is providing standard behavior then retrieve the limited
5210 * set of resources that don't affect standard behavior and set the
5211 * values of the other resources to the standard values.
5216 * pWS = pointer to workspace data
5221 * pWS = resource data for workspace is set
5226 * o Gets subresources based on workspace name
5228 ******************************<->***********************************/
5231 ProcessWorkspaceResources (WmWorkspaceData *pWS)
5235 * Retrieve workspace specific resources.
5238 pResWS = pWS; /* save current ws for default processing */
5241 if (wmGD.useStandardBehavior)
5243 XtGetSubresources (pWS->pSD->screenTopLevelW, (XtPointer) pWS,
5244 pWS->name, pWS->name, wmStdWorkspaceResources,
5245 XtNumber (wmStdWorkspaceResources), NULL, 0);
5248 * Fill in the standard resource values.
5250 * (no code for this right now)
5253 pWS->iconBoxGeometry = NULL;
5258 XtGetSubresources (pWS->pSD->screenTopLevelW, (XtPointer) pWS,
5259 pWS->name, pWS->name, wmWorkspaceResources,
5260 XtNumber (wmWorkspaceResources), NULL, 0);
5263 /* Dup iconbox geometry, it may be free'd later on. */
5265 if (pWS->iconBoxGeometry)
5267 pWS->iconBoxGeometry = XtNewString (pWS->iconBoxGeometry);
5273 if (pWS->title == NULL)
5276 * Setup default workspace title
5278 pWS->title = XmStringCreateLocalized(pWS->name);
5283 * Copy resource just in case there's a duplicate
5284 * Duplicates point to the same data, freeing on
5285 * rename can cause a crash.
5287 pWS->title = XmStringCopy(pWS->title);
5292 * Dup iconbox geometry, it may be free'd later on.
5294 if (pWS->iconBoxGeometry)
5296 pWS->iconBoxGeometry = XtNewString (pWS->iconBoxGeometry);
5300 * Get backdrop resources
5302 XtGetSubresources (pWS->workspaceTopLevelW,
5303 (XtPointer) &(pWS->backdrop),
5304 WmNbackdrop, WmCBackdrop, wmBackdropResources,
5305 XtNumber (wmBackdropResources), NULL, 0);
5307 ProcessBackdropResources (pWS, NULL);
5310 } /* END OF FUNCTION ProcessWorkspaceResources */
5314 /******************************<->*************************************
5316 * ProcessPresenceResources (pSD)
5321 * This function retrieves resources for the workspace presence
5326 * pSD = pointer to screen data
5331 * pSD = resource data for workspace presence dialog are set
5336 * o Gets subresources
5338 ******************************<->***********************************/
5341 ProcessPresenceResources (WmScreenData *pSD)
5343 #ifndef NO_MESSAGE_CATALOG
5344 static char *default_ws_pres_title = NULL;
5346 static char *default_ws_pres_title = "Workspace Presence";
5350 unsigned char *pch1, *pch2;
5352 #ifndef NO_MESSAGE_CATALOG
5354 * Set up localized default title string on initial time through
5356 if (default_ws_pres_title == NULL)
5360 * catgets returns a pointer to an area that is over written
5361 * on each call to catgets.
5364 tmpString = ((char *)GETMESSAGE(62, 59, "Occupy Workspace"));
5365 if ((default_ws_pres_title =
5366 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
5368 Warning (((char *)GETMESSAGE(62, 31, "Insufficient memory for local message string")));
5369 default_ws_pres_title = "Occupy Workspace";
5373 strcpy(default_ws_pres_title, tmpString);
5378 if (pSD->presence.shellW)
5380 XtGetSubresources (pSD->presence.shellW, (XtPointer) &pSD->presence,
5381 WmNworkspacePresence, WmCWorkspacePresence,
5382 wmWsPresenceResources,
5383 XtNumber (wmWsPresenceResources), NULL, 0);
5387 if (pSD->presence.title)
5389 pch1 = (unsigned char *)
5390 WmXmStringToString (pSD->presence.title);
5392 if (pch1 && (pch2 = (unsigned char *)
5393 XtMalloc (1+strlen((char *)pch1))))
5395 strcpy ((char *)pch2, (char *)pch1);
5401 pch2 = (unsigned char *) default_ws_pres_title;
5405 XtSetArg (args[n], XmNtitle, pch2); n++;
5406 XtSetValues (pSD->presence.shellW, args, n);
5409 } /* END OF FUNCTION ProcessPresenceResources */
5413 /*************************************<->*************************************
5415 * ProcessClientResources (pCD)
5420 * This function retrieves resources that are client specific. If the
5421 * window manager is providing standard behavior then retrieve the limited
5422 * set of resources that don't affect standard behavior and set the
5423 * values of the other resources to the standard values.
5428 * pCD = pointer to client data
5433 * pCD = resource data for client is set
5438 * o Gets subresources based on client name and class.
5439 * o Creates GC for the client Matte, if there is one.
5441 *************************************<->***********************************/
5444 ProcessClientResources (ClientData *pCD)
5448 WmScreenData *pSD = pCD->pSD;
5451 * Retrieve basic client specific resources.
5454 _pCD = pCD; /* save in static global for dynamic default processing */
5455 clientName = (pCD->clientName) ? pCD->clientName : WmNdefaults;
5456 clientClass = (pCD->clientClass) ? pCD->clientClass : WmNdefaults;
5458 if (wmGD.useStandardBehavior)
5460 XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5461 clientClass, wmStdClientResources, XtNumber (wmStdClientResources),
5465 * Fill in the standard resource values.
5468 SetStdClientResourceValues (pCD);
5472 XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5473 clientClass, wmClientResources, XtNumber (wmClientResources), NULL,
5477 #ifdef NO_MESSAGE_CATALOG
5479 * If (window menu spec is not found) then use the builtin
5483 if ((pCD->systemMenu == defaultSystemMenuName) &&
5484 (pSD->defaultSystemMenuUseBuiltin == TRUE))
5486 pCD->systemMenu = builtinSystemMenuName;
5491 * If the client decorations or client functions have been defaulted
5492 * fix up the fields in the ProcessMwmHints function.
5496 /* make top and bottom shadow pixmaps */
5498 if (pCD->iconImageBottomShadowPStr)
5500 if ((pCD->iconImageBottomShadowPStr ==
5501 pSD->iconAppearance.bottomShadowPStr) &&
5502 (pCD->iconImageBottomShadowColor ==
5503 pSD->iconAppearance.bottomShadowColor) &&
5504 (pCD->iconImageBackground ==
5505 pSD->iconAppearance.background))
5507 pCD->iconImageBottomShadowPixmap =
5508 pSD->iconAppearance.bottomShadowPixmap;
5512 pCD->iconImageBottomShadowPixmap =
5513 XmGetPixmap ( ScreenOfDisplay (DISPLAY,
5515 pCD->iconImageBottomShadowPStr,
5516 pCD->iconImageBottomShadowColor,
5517 pCD->iconImageBackground);
5519 if (pCD->iconImageBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
5521 pCD->iconImageBottomShadowPixmap = (Pixmap)NULL;
5527 pCD->iconImageBottomShadowPixmap = (Pixmap)NULL;
5530 if (pCD->iconImageTopShadowPStr)
5532 if ((pCD->iconImageTopShadowPStr ==
5533 pSD->iconAppearance.topShadowPStr) &&
5534 (pCD->iconImageTopShadowColor ==
5535 pSD->iconAppearance.topShadowColor) &&
5536 (pCD->iconImageBackground == pSD->iconAppearance.background))
5538 pCD->iconImageTopShadowPixmap =
5539 pSD->iconAppearance.topShadowPixmap;
5543 pCD->iconImageTopShadowPixmap =
5544 XmGetPixmap ( ScreenOfDisplay (DISPLAY,
5546 pCD->iconImageTopShadowPStr,
5547 pCD->iconImageTopShadowColor,
5548 pCD->iconImageBackground);
5550 if (pCD->iconImageTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
5552 pCD->iconImageTopShadowPixmap = (Pixmap)NULL;
5558 pCD->iconImageTopShadowPixmap = (Pixmap)NULL;
5561 if ((pCD->internalBevel < MIN_INTERNAL_BEVEL) ||
5562 (pCD->internalBevel > MAX_INTERNAL_BEVEL))
5564 pCD->internalBevel = MAX_INTERNAL_BEVEL;
5569 * Retrieve matte resources and make internal matte resources.
5572 if (pCD->matteWidth > 0)
5574 XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5575 clientClass, wmClientResourcesM, XtNumber (wmClientResourcesM),
5578 /* make top and bottom shadow pixmaps */
5581 if (pCD->matteBottomShadowPStr &&
5582 (!strcmp(pCD->matteBottomShadowPStr, _NoDither)))
5584 pCD->matteBottomShadowPStr = NULL;
5587 if (pCD->matteBottomShadowPStr)
5589 if ((pCD->matteBottomShadowPStr ==
5590 pSD->clientAppearance.bottomShadowPStr) &&
5591 (pCD->matteBottomShadowColor ==
5592 pSD->clientAppearance.bottomShadowColor) &&
5593 (pCD->matteBackground == pSD->clientAppearance.background))
5595 pCD->matteBottomShadowPixmap =
5596 pSD->clientAppearance.bottomShadowPixmap;
5600 pCD->matteBottomShadowPixmap =
5601 XmGetPixmap (ScreenOfDisplay (DISPLAY,
5603 pCD->matteBottomShadowPStr,
5604 pCD->matteBottomShadowColor,
5605 pCD->matteBackground);
5607 if (pCD->matteBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
5609 pCD->matteBottomShadowPixmap = (Pixmap)NULL;
5615 pCD->matteBottomShadowPixmap = (Pixmap)NULL;
5619 if (pCD->matteTopShadowPStr &&
5620 (!strcmp(pCD->matteTopShadowPStr, _NoDither)))
5622 pCD->matteTopShadowPStr = NULL;
5625 if (pCD->matteTopShadowPStr)
5627 if ((pCD->matteTopShadowPStr ==
5628 pSD->clientAppearance.topShadowPStr) &&
5629 (pCD->matteTopShadowColor ==
5630 pSD->clientAppearance.topShadowColor) &&
5631 (pCD->matteBackground == pSD->clientAppearance.background))
5633 pCD->matteTopShadowPixmap =
5634 pSD->clientAppearance.topShadowPixmap;
5638 pCD->matteTopShadowPixmap =
5639 XmGetPixmap (ScreenOfDisplay (DISPLAY,
5641 pCD->matteTopShadowPStr,
5642 pCD->matteTopShadowColor,
5643 pCD->matteBackground);
5645 if (pCD->matteTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
5647 pCD->matteTopShadowPixmap = (Pixmap)NULL;
5653 pCD->matteTopShadowPixmap = (Pixmap)NULL;
5657 /* make top and bottom shadow GC's */
5659 pCD->clientMatteTopShadowGC = GetHighlightGC (pCD->pSD,
5660 pCD->matteTopShadowColor,
5661 pCD->matteBackground,
5662 pCD->matteTopShadowPixmap);
5664 pCD->clientMatteBottomShadowGC = GetHighlightGC (pCD->pSD,
5665 pCD->matteBottomShadowColor,
5666 pCD->matteBackground,
5667 pCD->matteBottomShadowPixmap);
5670 } /* END OF FUNCTION ProcessClientResources */
5674 /*************************************<->*************************************
5676 * SetStdClientResourceValues (pCD)
5681 * This function sets client resource data to standard values. This setting
5682 * is done in place of getting the values from the user settings in
5683 * the resource database.
5687 * pCD = pointer to the client data
5692 * pCD = (client data filled out with resource values)
5694 *************************************<->***********************************/
5697 SetStdClientResourceValues (ClientData *pCD)
5699 pCD->clientDecoration = WM_DECOR_DEFAULT;
5700 pCD->clientFunctions = WM_FUNC_DEFAULT;
5701 pCD->focusAutoRaise = True;
5702 pCD->systemMenu = builtinSystemMenuName;
5703 pCD->usePPosition = USE_PPOSITION_NONZERO;
5704 pCD->ignoreWMSaveHints = True;
5706 } /* END OF FUNCTION SetStdClientResourceValues */
5710 /******************************<->*************************************
5712 * SetStdScreenResourceValues (pSD)
5717 * This function sets screen resource data to standard values. This setting
5718 * is done in place of getting the values from the user settings in
5719 * the resource database.
5723 * pSD = pointer to the screen data
5728 * pSD = (screen data filled out with resource values)
5730 ******************************<->***********************************/
5733 SetStdScreenResourceValues (WmScreenData *pSD)
5735 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
5736 pSD->rootMenu = builtinRootMenuName;
5737 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
5738 pSD->buttonBindings = builtinButtonBindingsName;
5739 pSD->cleanText = True;
5740 pSD->iconDecoration =
5741 (ICON_LABEL_PART | ICON_IMAGE_PART | ICON_ACTIVE_LABEL_PART);
5742 pSD->iconPlacement =
5743 (ICON_PLACE_LEFT_PRIMARY | ICON_PLACE_BOTTOM_SECONDARY);
5744 pSD->keyBindings = builtinKeyBindingsName;
5745 pSD->limitResize = True;
5746 pSD->resizeCursors = True;
5747 pSD->transientDecoration = (WM_DECOR_SYSTEM | WM_DECOR_RESIZEH);
5748 pSD->transientFunctions =
5749 (WM_FUNC_ALL & ~(MWM_FUNC_MAXIMIZE | MWM_FUNC_MINIMIZE |
5751 pSD->useIconBox = False;
5753 pSD->feedbackGeometry = NULL;
5754 pSD->moveOpaque = False;
5756 } /* END OF FUNCTION SetStdScreenResourceValues */
5759 /*************************************<->*************************************
5761 * GetHighlightGC (pSD, fg, bg, pixmap)
5766 * Get a graphic context for either drawing top- or bottom-shadow
5772 * pSD = pointer to screen data
5773 * fg = foreground color
5774 * bg = background color
5775 * pixmap = pixmap for highlight
5779 * RETRUN = GC with the input parameters incorporated.
5781 *************************************<->***********************************/
5783 GC GetHighlightGC (WmScreenData *pSD, Pixel fg, Pixel bg, Pixmap pixmap)
5789 mask = GCForeground | GCBackground | GCLineWidth | GCFillStyle;
5790 gcv.background = bg;
5791 gcv.foreground = fg;
5796 mask |= GCFillStyle | GCTile;
5797 gcv.fill_style = FillTiled;
5802 gcv.fill_style = FillSolid;
5807 * NOTE: If additional mask bits are added, modify WmGetGC()
5808 * in WmGraphics.c to check those values for matches.
5811 return (WmGetGC (pSD, mask, &gcv));
5812 #endif /* OLD_CODE */
5814 return (XtGetGC (pSD->screenTopLevelW, mask, &gcv));
5816 } /* END OF FUNCTION GetHighlightGC */
5820 /*************************************<->*************************************
5822 * _WmGetDynamicDefault (widget, type, defaultColor, newBackground, value)
5827 * This function is used to generate a default color of the requested
5828 * type. Default colors are generated for a 3-D appearance.
5833 * widget = this is the widget that is associated with the resource or
5834 * that is the reference widget for the wm subpart.
5836 * type = this is the type of color resource (e.g., top shadow color).
5838 * defaultColor = pointer to default color name/specification.
5840 * newBackground = background pixel for generating 3-D colors.
5845 * value = pointer to the XrmValue in which to store the color
5847 *************************************<->***********************************/
5850 _WmGetDynamicDefault (Widget widget, unsigned char type, String defaultColor, Pixel newBackground, XrmValue *value)
5852 static Screen *oldScreen = NULL;
5853 static Screen *newScreen;
5854 static Colormap oldColormap;
5855 static Colormap newColormap;
5856 static Pixel newValue;
5857 static Pixel background;
5858 static String oldDefaultColor = DEFAULT_COLOR_NONE;
5859 static XmColorData colorData;
5861 /* initialize the return value */
5863 value->size = sizeof (newValue);
5864 value->addr = (char *)&newValue;
5868 * Process monochrome defaults first.
5871 newScreen = XtScreen (widget);
5873 if (Monochrome (newScreen))
5878 * Check color server sets for this screen.
5880 if (wmGD.statusColorServer == CSERVE_NORMAL)
5885 for (i = 0; i < wmGD.numScreens; i++)
5887 if (XScreenNumberOfScreen(newScreen) == wmGD.Screens[i].screen)
5889 pSD = &wmGD.Screens[i];
5898 for (i = 0; i < XmCO_MAX_NUM_COLORS; i++)
5900 if (pSD->pPixelData[i].bg == newBackground)
5904 case WmFGC: newValue = pSD->pPixelData[i].fg; break;
5905 case WmBGC: newValue = pSD->pPixelData[i].bg; break;
5906 case WmTSC: newValue = pSD->pPixelData[i].ts; break;
5907 case WmBSC: newValue = pSD->pPixelData[i].bs; break;
5921 case WmFGC: newValue = BlackPixelOfScreen (newScreen); break;
5922 case WmBGC: newValue = WhitePixelOfScreen (newScreen); break;
5923 case WmTSC: newValue = WhitePixelOfScreen (newScreen); break;
5924 case WmBSC: newValue = BlackPixelOfScreen (newScreen); break;
5934 * Check to see if appropriate colors are available from the
5935 * previous request; if the color is a background color then get
5936 * default colors. Generate 3-D colors if necessary. Maintain
5937 * new colors in static variables for later reuse.
5940 newColormap = widget->core.colormap;
5942 if ((oldScreen != NULL) && (oldScreen == newScreen) &&
5943 (oldColormap == newColormap) && (type != WmBGC) &&
5944 (background == newBackground))
5947 else if ((oldScreen == newScreen) && (oldColormap == newColormap) &&
5948 (type == WmBGC) && (oldDefaultColor == defaultColor))
5951 else if (type == WmBGC)
5954 * Find or generate a background color and associated 3-D colors.
5957 oldDefaultColor = defaultColor;
5959 * Fix for CR 5152 - Due to the use of Realloc in the color caches,
5960 * a static pointer is not acceptable. Change it
5961 * to a static structure to maintain the data
5963 colorData = *_WmGetDefaultColors (newScreen, newColormap, defaultColor);
5968 * Find or generate a color based on the associated background color.
5971 oldDefaultColor = DEFAULT_COLOR_NONE;
5972 background = newBackground;
5974 XmGetColors(newScreen, newColormap, background,
5975 &colorData.foreground.pixel,
5976 &colorData.top_shadow.pixel,
5977 &colorData.bottom_shadow.pixel,
5978 &colorData.select.pixel);
5981 oldScreen = newScreen;
5982 oldColormap = newColormap;
5986 * Set up the return value.
5989 colorData.allocated |= type;
5992 case XmBACKGROUND: newValue = colorData.background.pixel; break;
5993 case XmFOREGROUND: newValue = colorData.foreground.pixel; break;
5994 case XmTOP_SHADOW: newValue = colorData.top_shadow.pixel; break;
5995 case XmBOTTOM_SHADOW: newValue = colorData.bottom_shadow.pixel; break;
5996 case XmSELECT: newValue = colorData.select.pixel; break;
5997 default: newValue = colorData.background.pixel; break;
6000 } /* END OF FUNCTION _WmGetDynamicDefault */
6004 /*************************************<->*************************************
6006 * _WmGetDefaultColors (screen, colormap, defaultColor)
6011 * This function is used to find or generate default 3-D colors based on a
6012 * default background color.
6017 * screen = screen for which colors are to be generated.
6019 * colormap = colormap that is to be used to make colors.
6021 * defaultColor = pointer to a default color name/specification.
6026 * RETURN = pointer to WmColorData structure containing 3-D colors.
6028 *************************************<->***********************************/
6030 XmColorData * _WmGetDefaultColors (screen, colormap, defaultColor)
6033 String defaultColor;
6036 static XmColorData *defaultSet[2] = {NULL, NULL};
6037 static int defaultCount[2] = {0, 0};
6038 static int defaultSize[2] = {0, 0};
6040 register XmColorData *set;
6044 Display *display = DisplayOfScreen (screen);
6048 * Fix for CR 5152 - Due to the use of Realloc with _XmGetColors, it is
6049 * necessary to maintain a separate cache of color
6050 * data. The Realloc may cause the data to be moved,
6051 * and the cache would contain pointers into the heap.
6055 * Look through the cache to see if the defaults are already in the
6056 * cache. There is a list of cached defaults for each default color.
6059 if (defaultColor == _defaultColor2)
6068 set = defaultSet[setId];
6069 count = defaultCount[setId];
6070 size = defaultSize[setId];
6072 for (i = 0; i < count; i++)
6074 if (((set + i)->screen == screen) && ((set + i)->color_map == colormap))
6081 * No match in the cache, make a new entry and generate the colors.
6086 size = (defaultSize[setId] += 10);
6087 set = defaultSet[setId] =
6088 (XmColorData *)WmRealloc ((char *) defaultSet[setId],
6089 sizeof (XmColorData) * size);
6093 * Make the default background color for the resource set.
6096 if(!XParseColor (display, colormap, defaultColor, &colorDef))
6098 if(!(strcmp(defaultColor, _defaultColor1)))
6100 XParseColor (display, colormap, _defaultColor1HEX, &colorDef);
6104 XParseColor (display, colormap, _defaultColor2HEX, &colorDef);
6108 XAllocColor (display, colormap, &colorDef);
6112 * Generate the 3-D colors and save them in the defaults cache.
6115 XmGetColors(screen, colormap, colorDef.pixel,
6116 &set[count].foreground.pixel,
6117 &set[count].top_shadow.pixel,
6118 &set[count].bottom_shadow.pixel,
6119 &set[count].select.pixel);
6121 set[count].background.pixel = colorDef.pixel;
6123 set[count].screen = screen;
6124 set[count].color_map = colormap;
6125 set[count].allocated = True;
6127 XQueryColor(DISPLAY, colormap, &(set[count].background));
6128 XQueryColor(DISPLAY, colormap, &(set[count].foreground));
6129 XQueryColor(DISPLAY, colormap, &(set[count].top_shadow));
6130 XQueryColor(DISPLAY, colormap, &(set[count].bottom_shadow));
6131 XQueryColor(DISPLAY, colormap, &(set[count].select));
6133 (defaultCount[setId])++;
6135 return (set + count);
6138 } /* END OF FUNCTION _WmGetDefaultColors */
6142 /*************************************<->*************************************
6144 * WmRealloc (ptr, size)
6149 * This function is used reallocate a block of storage that has been
6155 * ptr = pointer to storage that is to be realloc'ed; if NULL malloc an
6156 * initial block of storage.
6158 * size = size of new storage
6162 * RETURN = pointer to realloc'ed block of storage
6164 *************************************<->***********************************/
6166 char * WmRealloc (ptr, size)
6173 ptr = (char *)XtRealloc (ptr, size);
6177 ptr = (char *)XtMalloc (size);
6182 Warning (((char *)GETMESSAGE(62, 37, "Insufficient memory for window manager data")));
6187 } /* END OF FUNCTION WmRealloc */
6191 /*************************************<->*************************************
6193 * WmMalloc (ptr, size)
6198 * This function is used malloc a block of storage. If a previous block
6199 * of storage is being replace the old block is free'd.
6204 * ptr = pointer to storage that is to be replaced (free'd).
6206 * size = size of new storage
6210 * RETURN = pointer to malloc'ed block of storage
6212 *************************************<->***********************************/
6214 char * WmMalloc (ptr, size)
6224 ptr = (char *)XtMalloc (size);
6228 Warning (((char *)GETMESSAGE(62, 38, "Insufficient memory for window manager data")));
6233 } /* END OF FUNCTION WmMalloc */
6237 /*************************************<->*************************************
6239 * SetupDefaultResources (pSD)
6244 * This function is used to setup default (builtin) resources for the
6250 * pSD = pointer to screen data
6251 * wmGD = (defaultKeyBindingsString, ...)
6253 * builtinKeyBindingsName = name of default key bindings set
6260 *************************************<->***********************************/
6263 SetupDefaultResources (pSD)
6268 KeySpec *nextKeySpec;
6274 * If (using DefaultBindings mechanism and bindings are not found in .mwmrc)
6275 * then use the builtin bindings.
6277 if (!pSD->keySpecs && !wmGD.useStandardBehavior)
6280 * Print warning if user is NOT using "DefaultKeyBindings".
6282 if (strcmp (pSD->keyBindings, defaultKeyBindingsName))
6284 MWarning (((char *)GETMESSAGE(62, 67, "Key bindings %s not found, using builtin key bindings\n")),
6287 pSD->keyBindings = builtinKeyBindingsName;
6290 if (!pSD->buttonSpecs && !wmGD.useStandardBehavior)
6293 * Print warning if user is NOT using "DefaultButtonBindings".
6295 if (strcmp (pSD->buttonBindings, defaultButtonBindingsName))
6297 MWarning (((char *)GETMESSAGE(62, 68, "Button bindings %s not found, using builtin button bindings\n")),
6298 pSD->buttonBindings);
6300 pSD->buttonBindings = builtinButtonBindingsName;
6303 if (pSD->keyBindings == builtinKeyBindingsName)
6306 * Default key specifications are to be used and no default
6307 * set has been provided by the user. Make the built-in default
6311 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
6313 * Before parsing the string, substitute the real name for
6314 * the default rootmenu using the resource rootMenu
6315 * for the %s in the string.
6320 buffer = (char *) XtMalloc(strlen(builtinKeyBindings) +
6321 strlen(pSD->rootMenu) + 1);
6322 sprintf(buffer, builtinKeyBindings, pSD->rootMenu);
6324 ParseKeyStr (pSD, (unsigned char *)buffer);
6326 ParseKeyStr (pSD, (unsigned char *)builtinKeyBindings);
6327 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
6332 * Add the switch behavior key binding to the front of the list
6333 * of user specified key bindings that have been parsed.
6336 nextKeySpec = pSD->keySpecs;
6337 keyBindings = pSD->keyBindings;
6338 pSD->keyBindings = behaviorKeyBindingName;
6339 pSD->keySpecs = NULL;
6341 ParseKeyStr (pSD, (unsigned char *)behaviorKeyBindings);
6345 /* Skip past the TWO key definitions (1.2 & 1.1.4) */
6346 pSD->keySpecs->nextKeySpec->nextKeySpec = nextKeySpec;
6350 pSD->keySpecs = nextKeySpec;
6352 pSD->keyBindings = keyBindings;
6355 if (pSD->buttonBindings == builtinButtonBindingsName)
6358 * Default button specifications are to be used and no default
6359 * set has been provided by the user. Make the built-in default
6363 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
6365 * Before parsing the string, substitute the real name for
6366 * the default rootmenu using the resource rootMenu
6367 * for the %s in the string.
6372 buffer = (char *) XtMalloc(strlen(builtinButtonBindings) +
6373 strlen(pSD->rootMenu) + 1);
6374 sprintf(buffer, builtinButtonBindings, pSD->rootMenu);
6376 ParseButtonStr (pSD, (unsigned char *)buffer);
6378 ParseButtonStr (pSD, (unsigned char *)builtinButtonBindings);
6379 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
6382 #ifdef NO_MESSAGE_CATALOG
6384 * Set defaultSystemMenuUseBuiltin to FALSE if DefaultWindowMenu spec
6388 menuSpec = pSD->menuSpecs;
6391 if (!strcmp(menuSpec->name, defaultSystemMenuName))
6393 pSD->defaultSystemMenuUseBuiltin = FALSE;
6396 menuSpec = menuSpec->nextMenuSpec;
6400 } /* END OF FUNCTION SetupDefaultResources */
6404 /*************************************<->*************************************
6406 * SimilarAppearanceData (pAD1, pAD2)
6411 * This function returns True if the two passed sets of AppearanceData
6412 * are similar. This is designed to compare appearance data before
6413 * creation of the GCs.
6418 * pAD1 pointer to AppearanceData 1
6419 * pAD2 pointer to AppearanceData 2
6424 * Function returns True if similar, False otherwise.
6428 * This function is only used to compare the client
6429 * and client*title appearance data.
6430 *************************************<->***********************************/
6432 Boolean SimilarAppearanceData (AppearanceData *pAD1, AppearanceData *pAD2)
6437 if ((pAD1->fontList == pAD2->fontList) &&
6438 (pAD1->background == pAD2->background) &&
6439 (pAD1->foreground == pAD2->foreground) &&
6440 (pAD1->backgroundPStr == pAD2->backgroundPStr) &&
6441 (pAD1->backgroundPixmap == pAD2->backgroundPixmap) &&
6442 (pAD1->bottomShadowColor == pAD2->bottomShadowColor) &&
6443 (pAD1->bottomShadowPStr == pAD2->bottomShadowPStr) &&
6444 (pAD1->bottomShadowPixmap == pAD2->bottomShadowPixmap) &&
6445 (pAD1->topShadowColor == pAD2->topShadowColor) &&
6446 (pAD1->topShadowPStr == pAD2->topShadowPStr) &&
6447 (pAD1->topShadowPixmap == pAD2->topShadowPixmap) &&
6448 (pAD1->activeBackground == pAD2->activeBackground) &&
6449 (pAD1->activeForeground == pAD2->activeForeground) &&
6450 (pAD1->activeBackgroundPStr == pAD2->activeBackgroundPStr) &&
6451 (pAD1->activeBackgroundPixmap == pAD2->activeBackgroundPixmap) &&
6452 (pAD1->activeBottomShadowColor == pAD2->activeBottomShadowColor) &&
6453 (pAD1->activeBottomShadowPStr == pAD2->activeBottomShadowPStr) &&
6454 (pAD1->activeBottomShadowPixmap == pAD2->activeBottomShadowPixmap) &&
6455 (pAD1->activeTopShadowColor == pAD2->activeTopShadowColor) &&
6456 (pAD1->activeTopShadowPStr == pAD2->activeTopShadowPStr) &&
6457 (pAD1->activeTopShadowPixmap == pAD2->activeTopShadowPixmap) )
6460 * !!! Should find out why all the Pixmap resources are unset !!!
6463 if ((pAD1->fontList == pAD2->fontList) &&
6464 (pAD1->background == pAD2->background) &&
6465 (pAD1->foreground == pAD2->foreground) &&
6466 (pAD1->backgroundPStr == pAD2->backgroundPStr) &&
6467 (pAD1->bottomShadowColor == pAD2->bottomShadowColor) &&
6468 (pAD1->bottomShadowPStr == pAD2->bottomShadowPStr) &&
6469 (pAD1->topShadowColor == pAD2->topShadowColor) &&
6470 (pAD1->topShadowPStr == pAD2->topShadowPStr) &&
6471 (pAD1->activeBackground == pAD2->activeBackground) &&
6472 (pAD1->activeForeground == pAD2->activeForeground) &&
6473 (pAD1->activeBackgroundPStr == pAD2->activeBackgroundPStr) &&
6474 (pAD1->activeBottomShadowColor == pAD2->activeBottomShadowColor) &&
6475 (pAD1->activeBottomShadowPStr == pAD2->activeBottomShadowPStr) &&
6476 (pAD1->activeTopShadowColor == pAD2->activeTopShadowColor) &&
6477 (pAD1->activeTopShadowPStr == pAD2->activeTopShadowPStr) )
6489 } /* END OF FUNCTION SimilarAppearanceData */
6493 /*************************************<->*************************************
6495 * Monochrome (screen)
6500 * This function returns True if the screen passed it to be treated
6501 * as monochrome for the purpose of assigning default resources.
6506 * screen pointer to Screen
6511 * Function returns True if monochrome (or Static Gray), False otherwise.
6513 *************************************<->***********************************/
6516 Monochrome (Screen *screen)
6522 if (wmGD.statusColorServer == CSERVE_NORMAL)
6524 for (scr = 0; scr < wmGD.numScreens; scr++)
6526 pSD = &(wmGD.Screens[scr]);
6530 if (XScreenOfDisplay (DISPLAY, pSD->screen) == screen)
6532 if (pSD->colorUse == XmCO_BLACK_WHITE)
6545 * If we don't know the answer to our question by now,
6546 * fall back to the old mwm way of determining monochromicity.
6550 return ((DefaultDepthOfScreen(screen) == 1));
6551 } /* END OF FUNCTION Monochrome */
6554 /**************************** eof ***************************/