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 ExitWM(WM_ERROR_EXIT_VALUE);
4439 #ifndef NO_MULTIBYTE
4441 * Calculate title bar's height and store it in pAData.
4443 pAData->titleHeight = (pAData->font)->ascent + (pAData->font)->descent
4444 + WM_TITLE_BAR_PADDING;
4449 * Make standard (inactive) appearance resources.
4452 /* background pixmap */
4454 if (pAData->backgroundPStr)
4456 pAData->backgroundPixmap = XmGetPixmap (
4457 ScreenOfDisplay (DISPLAY,
4459 pAData->backgroundPStr,
4461 pAData->background);
4463 if (pAData->backgroundPixmap == XmUNSPECIFIED_PIXMAP)
4465 pAData->backgroundPixmap = (Pixmap)NULL;
4470 pAData->backgroundPixmap = (Pixmap)NULL;
4473 /* top shadow pixmap */
4475 if (pAData->topShadowPStr)
4478 * Make sure top shadow color is not the same as background
4479 * otherwise the wrong pixmap will be generated.
4481 if (pAData->topShadowColor != pAData->background)
4482 foreground = pAData->topShadowColor;
4484 foreground = pAData->foreground;
4485 pAData->topShadowPixmap = XmGetPixmap (
4486 ScreenOfDisplay (DISPLAY,
4488 pAData->topShadowPStr,
4490 pAData->background);
4492 if (pAData->topShadowPixmap == XmUNSPECIFIED_PIXMAP)
4494 pAData->topShadowPixmap = (Pixmap)NULL;
4499 pAData->topShadowPixmap = (Pixmap)NULL;
4503 /* bottom shadow pixmap */
4505 if (pAData->bottomShadowPStr)
4508 * Make sure bottom shadow color is not the same as background
4509 * otherwise the wrong pixmap will be generated.
4511 if (pAData->bottomShadowColor != pAData->background)
4512 foreground = pAData->bottomShadowColor;
4514 foreground = pAData->foreground;
4515 pAData->bottomShadowPixmap = XmGetPixmap (
4516 ScreenOfDisplay (DISPLAY,
4518 pAData->bottomShadowPStr,
4520 pAData->background);
4522 if (pAData->bottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
4524 pAData->bottomShadowPixmap = (Pixmap)NULL;
4529 pAData->bottomShadowPixmap = (Pixmap)NULL;
4532 /* inactive appearance GC */
4534 GetAppearanceGCs (pSD,
4538 pAData->backgroundPixmap,
4539 pAData->topShadowColor,
4540 pAData->topShadowPixmap,
4541 pAData->bottomShadowColor,
4542 pAData->bottomShadowPixmap,
4543 &(pAData->inactiveGC),
4544 &(pAData->inactiveTopShadowGC),
4545 &(pAData->inactiveBottomShadowGC));
4550 * Make active apppearance resources if specified.
4553 if (!makeActiveResources)
4558 /* active background pixmap */
4560 if (pAData->activeBackgroundPStr)
4562 pAData->activeBackgroundPixmap = XmGetPixmap (
4563 ScreenOfDisplay (DISPLAY,
4565 pAData->activeBackgroundPStr,
4566 pAData->activeForeground,
4567 pAData->activeBackground);
4569 if (pAData->activeBackgroundPixmap == XmUNSPECIFIED_PIXMAP)
4571 pAData->activeBackgroundPixmap = (Pixmap)NULL;
4576 pAData->activeBackgroundPixmap = (Pixmap)NULL;
4579 /* active top shadow pixmap */
4581 if (pAData->activeTopShadowPStr)
4583 pAData->activeTopShadowPixmap = XmGetPixmap (
4584 ScreenOfDisplay (DISPLAY,
4586 pAData->activeTopShadowPStr,
4587 pAData->activeTopShadowColor,
4588 pAData->activeBackground);
4590 if (pAData->activeTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
4592 pAData->activeTopShadowPixmap = (Pixmap)NULL;
4597 pAData->activeTopShadowPixmap = (Pixmap)NULL;
4601 /* active bottom shadow pixmap */
4603 if (pAData->activeBottomShadowPStr)
4605 pAData->activeBottomShadowPixmap = XmGetPixmap (
4606 ScreenOfDisplay (DISPLAY,
4608 pAData->activeBottomShadowPStr,
4609 pAData->activeBottomShadowColor,
4610 pAData->activeBackground);
4612 if (pAData->activeBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
4614 pAData->activeBottomShadowPixmap = (Pixmap)NULL;
4619 pAData->activeBottomShadowPixmap = (Pixmap)NULL;
4622 /* inactive appearance GC */
4624 GetAppearanceGCs (pSD,
4625 pAData->activeForeground,
4626 pAData->activeBackground,
4628 pAData->activeBackgroundPixmap,
4629 pAData->activeTopShadowColor,
4630 pAData->activeTopShadowPixmap,
4631 pAData->activeBottomShadowColor,
4632 pAData->activeBottomShadowPixmap,
4633 &(pAData->activeGC),
4634 &(pAData->activeTopShadowGC),
4635 &(pAData->activeBottomShadowGC));
4638 } /* END OF FUNCTION MakeAppearanceResources */
4642 /*************************************<->*************************************
4644 * GetAppearanceGCs (pSD, fg, bg, font, bg_pixmap, ts_color,
4645 * ts_pixmap, bs_color, bs_pixmap, pGC, ptsGC, pbsGC)
4650 * Creates the appearance GCs for any of the icon, client, or feedback
4656 * pSD - pointer to screen data
4657 * fg - base foreground color
4658 * bg - base background color
4660 * bg_pixmap - background pixmap
4661 * ts_color - top shadow color
4662 * ts_pixmap - top shadow pixmap
4663 * bs_color - bottom shadow color
4664 * bs_pixmap - bottom shadow pixmap
4665 * pGC - pointer to location to receive base GC
4666 * ptsGC - pointer to location to receive top shadow GC
4667 * pbsGC - pointer to location to receive bottom shadow GC
4672 * *ptsGC - top shadow GC
4673 * *pbsGC - bottom shadow GC
4680 *************************************<->***********************************/
4683 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)
4693 mask = GCForeground | GCBackground | GCFont;
4694 gcv.foreground = fg;
4695 gcv.background = bg;
4696 gcv.font = font->fid;
4701 gcv.tile = bg_pixmap;
4704 *pGC = XCreateGC (DISPLAY, pSD->rootWindow, mask, &gcv);
4707 * !!! Need GC error detection !!!
4710 *ptsGC = GetHighlightGC (pSD, ts_color, bg, ts_pixmap);
4712 *pbsGC = GetHighlightGC (pSD, bs_color, bg, bs_pixmap);
4714 } /* END OF FUNCTION GetAppearanceGCs */
4719 /*************************************<->*************************************
4721 * ProcessScreenResources (pSD, screenName)
4726 * This function retrieves resources that are screen specific. If the
4727 * window manager is providing standard behavior then retrieve the limited
4728 * set of resources that don't affect standard behavior and set the
4729 * values of the other resources to the standard values.
4734 * pSD = pointer to screen data
4735 * screenName = name of screen
4740 * pSD = resource data for screen is set
4745 * o Gets subresources based on workspace name
4747 *************************************<->***********************************/
4750 ProcessScreenResources (WmScreenData *pSD, unsigned char *screenName)
4753 pResSD = pSD; /* save current screen data for default processing */
4755 * Use the screen name (e.g., "0") as the default resource name.
4758 if (wmGD.useStandardBehavior)
4760 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4761 (String) screenName,
4762 (String) screenName,
4763 wmStdScreenResources,
4764 XtNumber (wmStdScreenResources), NULL, 0);
4767 * Fill in the standard resource values.
4770 SetStdScreenResourceValues (pSD);
4774 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4775 (String)screenName, (String) screenName,
4777 XtNumber (wmScreenResources), NULL, 0);
4779 #ifndef MOTIF_ONE_DOT_ONE
4780 pSD->moveOpaque = (((XmScreen) XmGetXmScreen(XtScreen(pSD->screenTopLevelW)))
4781 -> screen.moveOpaque);
4787 * Retrieve screen specific resources.
4790 if (wmGD.useStandardBehavior)
4792 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4793 (String) screenName, (String)screenName, wmStdScreenResources,
4794 XtNumber (wmStdScreenResources), NULL, 0);
4797 * Fill in the standard resource values.
4800 SetStdScreenResourceValues (pSD);
4804 XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4805 (String)screenName, (String)screenName, wmScreenResources,
4806 XtNumber (wmScreenResources), NULL, 0);
4808 #ifndef MOTIF_ONE_DOT_ONE
4809 pSD->moveOpaque =(((XmScreen) XmGetXmScreen(XtScreen(pSD->screenTopLevelW)))
4810 -> screen.moveOpaque);
4816 * Do some additional processing on the window manager resource values.
4820 if (pSD->iconImageMinimum.width < ICON_IMAGE_MIN_WIDTH)
4822 pSD->iconImageMinimum.width = ICON_IMAGE_MIN_WIDTH;
4824 else if (pSD->iconImageMinimum.width > ICON_IMAGE_MAX_WIDTH)
4826 pSD->iconImageMinimum.width = ICON_IMAGE_MAX_WIDTH;
4829 if (pSD->iconImageMinimum.height < ICON_IMAGE_MIN_HEIGHT)
4831 pSD->iconImageMinimum.height = ICON_IMAGE_MIN_HEIGHT;
4833 else if (pSD->iconImageMinimum.height > ICON_IMAGE_MAX_HEIGHT)
4835 pSD->iconImageMinimum.height = ICON_IMAGE_MAX_HEIGHT;
4838 if (pSD->iconImageMaximum.width < pSD->iconImageMinimum.width)
4840 pSD->iconImageMaximum.width = pSD->iconImageMinimum.width;
4842 else if (pSD->iconImageMaximum.width > ICON_IMAGE_MAX_WIDTH)
4844 pSD->iconImageMaximum.width = ICON_IMAGE_MAX_WIDTH;
4847 if (pSD->iconImageMaximum.height < pSD->iconImageMinimum.height)
4849 pSD->iconImageMaximum.height = pSD->iconImageMinimum.height;
4851 else if (pSD->iconImageMaximum.height > ICON_IMAGE_MAX_HEIGHT)
4853 pSD->iconImageMaximum.height = ICON_IMAGE_MAX_HEIGHT;
4856 if (pSD->iconPlacementMargin > MAXIMUM_ICON_MARGIN)
4858 pSD->iconPlacementMargin = MAXIMUM_ICON_MARGIN;
4861 if (pSD->maximumMaximumSize.width <= 0)
4863 pSD->maximumMaximumSize.width =
4864 2 * DisplayWidth (DISPLAY, pSD->screen);
4867 if (pSD->maximumMaximumSize.height <= 0)
4869 pSD->maximumMaximumSize.height =
4870 2 * DisplayHeight (DISPLAY, pSD->screen);
4874 * Set the icon appearance default based on whether or not the icon box
4878 if (pSD->iconDecoration & USE_ICON_DEFAULT_APPEARANCE)
4880 if (pSD->useIconBox)
4882 pSD->iconDecoration = ICON_APPEARANCE_ICONBOX;
4886 pSD->iconDecoration = ICON_APPEARANCE_STANDALONE;
4891 * If resizeBorderWidth or frameBorderWidth is unset then initialize
4892 * to dynamic defaults.
4895 if ((pSD->resizeBorderWidth == (Dimension)BIGSIZE) ||
4896 (pSD->frameBorderWidth == (Dimension)BIGSIZE))
4898 double xres, yres, avg_res;
4900 xres = (((double) DisplayWidth(DISPLAY, pSD->screen)) /
4901 ((double) DisplayWidthMM(DISPLAY, pSD->screen)));
4902 yres = (((double) DisplayHeight(DISPLAY, pSD->screen)) /
4903 ((double) DisplayHeightMM(DISPLAY, pSD->screen)));
4905 avg_res = (xres + yres) / 2.0;
4907 /* Multiply times width in mm (avg. 7-8 pixels) */
4908 if (pSD->resizeBorderWidth == (Dimension)BIGSIZE)
4910 pSD->resizeBorderWidth = (int) (avg_res * 2.2);
4912 /* limit size because big borders look ugly */
4914 if (wmGD.frameStyle == WmSLAB)
4917 if (pSD->resizeBorderWidth > 6) pSD->resizeBorderWidth = 6;
4922 if (pSD->resizeBorderWidth > 7) pSD->resizeBorderWidth = 7;
4927 /* Multiply times width in mm (avg. 5-6 pixels) */
4928 if (pSD->frameBorderWidth == (Dimension)BIGSIZE)
4930 pSD->frameBorderWidth = (int) (avg_res * 1.7);
4932 /* limit size because big borders look ugly */
4933 if (wmGD.frameStyle == WmSLAB)
4935 if (pSD->frameBorderWidth > 4) pSD->frameBorderWidth = 4;
4939 if (pSD->frameBorderWidth > 5) pSD->frameBorderWidth = 5;
4945 pSD->externalBevel = FRAME_EXTERNAL_SHADOW_WIDTH;
4946 pSD->joinBevel = FRAME_INTERNAL_SHADOW_WIDTH;
4947 if (pSD->frameBorderWidth <
4948 (pSD->externalBevel + MIN_INTERNAL_BEVEL))
4950 pSD->frameBorderWidth =
4951 pSD->externalBevel + MIN_INTERNAL_BEVEL;
4953 else if (pSD->frameBorderWidth > MAXIMUM_FRAME_BORDER_WIDTH)
4955 pSD->frameBorderWidth = MAXIMUM_FRAME_BORDER_WIDTH;
4958 if (pSD->resizeBorderWidth <
4959 (pSD->externalBevel + MIN_INTERNAL_BEVEL))
4961 pSD->resizeBorderWidth =
4962 (pSD->externalBevel + MIN_INTERNAL_BEVEL);
4964 else if (pSD->resizeBorderWidth > MAXIMUM_FRAME_BORDER_WIDTH)
4966 pSD->resizeBorderWidth = MAXIMUM_FRAME_BORDER_WIDTH;
4971 * Update the resource database.
4973 WriteOutXrmColors (pSD);
4978 * Process the component appearance resources for client,
4979 * icon and feedback parts of mwm.
4982 ProcessAppearanceResources (pSD);
4986 * Process the workspace list and name the initial
4990 ProcessWorkspaceList (pSD);
4993 * Process default backdrop images to be used in low-color
4996 ProcessDefaultBackdropImages (pSD);
5000 * Save the default icon pixmap in global data. We'll use it only
5004 pSD->builtinIconPixmap =
5005 XCreateBitmapFromData (DISPLAY, pSD->rootWindow, (char *)iImage_bits,
5006 iImage_width, iImage_height);
5008 } /* END OF FUNCTION ProcessScreenResources */
5012 /*************************************<->*************************************
5014 * ProcessDefaultBackdropImages (pSD)
5019 * This function processes the default backdrop images to be used
5020 * in low color or black and white workspaces.
5025 * pSD = pointer to screen data
5030 * pSD = resource data for screen is set
5036 *************************************<->***********************************/
5039 ProcessDefaultBackdropImages (WmScreenData *pSD)
5041 } /* END OF FUNCTION ProcessDefaultBackdropImages */
5045 /*************************************<->*************************************
5047 * ProcessWorkspaceList (pSD)
5052 * This function processes the workspaceCount and workspaceList
5053 * resources for a particular screen. It creates space for the initial
5054 * workspace data structures and adds in names for workspaces.
5059 * pSD = pointer to screen data
5064 * pSD = resource data for screen is set
5069 * NOTE: The workspaceCount resource has precedence over the
5070 * workspaceList resource. workspaceCount determines the number of
5071 * workspaces to create for the screen. Once the number is determined,
5072 * workspaceList is used to fill in the "names." If workspaceList is
5073 * not present or doesn't have enough names, then missing names are
5074 * generated automatically. If workspaceList is present and
5075 * workspaceCount is not present, then the workspaceCount is determined
5076 * by the number of names in workspaceList.
5078 *************************************<->***********************************/
5081 ProcessWorkspaceList (WmScreenData *pSD)
5083 int i, wsNameCount, wsNamesAlloced;
5084 WmWorkspaceData *pwsI;
5085 unsigned char *lineP = NULL;
5086 unsigned char *string;
5087 Boolean bHaveWorkspaceList;
5088 Boolean bHaveWorkspaceCount;
5089 char **ppchWsNames = NULL;
5092 * Validate initial resource settings
5094 bHaveWorkspaceCount = (pSD->numWorkspaces >= 1);
5095 bHaveWorkspaceList = (pSD->workspaceList != NULL);
5097 if (bHaveWorkspaceList)
5100 * Parse out array of workspace names
5102 wsNamesAlloced = WS_ALLOC_AMOUNT;
5103 ppchWsNames = (char **) XtMalloc (wsNamesAlloced * sizeof (char *));
5104 if (pSD->workspaceList)
5106 lineP = (unsigned char *) pSD->workspaceList;
5110 lineP = (unsigned char *)NULL;
5114 while (((string = GetString(&lineP)) != NULL))
5116 ppchWsNames[wsNameCount] = (char *) string;
5118 if (++wsNameCount >= wsNamesAlloced)
5121 * Need to add more workspaces
5123 wsNamesAlloced += WS_ALLOC_AMOUNT;
5124 if (!(ppchWsNames = (char **) XtRealloc
5125 ((char *)ppchWsNames,
5126 wsNamesAlloced * sizeof(char *))))
5128 ExitWM (WM_ERROR_EXIT_VALUE);
5133 if (!bHaveWorkspaceCount)
5135 pSD->numWorkspaces = wsNameCount;
5138 else if (!bHaveWorkspaceCount)
5141 * Neither workspaceCount nor workspaceList specified!!
5142 * Assume one workspace.
5144 pSD->numWorkspaces = 1;
5147 if (pSD->numWorkspaces > MAX_WORKSPACE_COUNT)
5148 pSD->numWorkspaces = MAX_WORKSPACE_COUNT;
5151 * Allocate the array of workspace data
5153 pSD->numWsDataAllocated = (pSD->numWorkspaces + WS_ALLOC_AMOUNT);
5154 pSD->numWsDataAllocated -= pSD->numWsDataAllocated % WS_ALLOC_AMOUNT;
5155 if (!(pSD->pWS = (WmWorkspaceData *)
5156 XtMalloc (pSD->numWsDataAllocated * sizeof(WmWorkspaceData))))
5158 ExitWM (WM_ERROR_EXIT_VALUE);
5163 for (i = 0; i < pSD->numWorkspaces; i++, pwsI++)
5165 if (bHaveWorkspaceList && i < wsNameCount)
5167 string = (unsigned char *) ppchWsNames[i];
5171 string = GenerateWorkspaceName (pSD, i);
5173 if (!(pwsI->name = (String) XtMalloc (1+strlen((char *)string))))
5175 Warning (((char *)GETMESSAGE(62, 27, "Insufficient memory for workspace data")));
5176 ExitWM(WM_ERROR_EXIT_VALUE);
5180 strcpy(pwsI->name, (char *)string);
5184 if (ppchWsNames) XtFree ((char *) ppchWsNames);
5186 } /* END OF FUNCTION ProcessWorkspaceList */
5191 /******************************<->*************************************
5193 * ProcessWorkspaceResources (pWS)
5198 * This function retrieves resources that are workspace specific. If the
5199 * window manager is providing standard behavior then retrieve the limited
5200 * set of resources that don't affect standard behavior and set the
5201 * values of the other resources to the standard values.
5206 * pWS = pointer to workspace data
5211 * pWS = resource data for workspace is set
5216 * o Gets subresources based on workspace name
5218 ******************************<->***********************************/
5221 ProcessWorkspaceResources (WmWorkspaceData *pWS)
5225 * Retrieve workspace specific resources.
5228 pResWS = pWS; /* save current ws for default processing */
5231 if (wmGD.useStandardBehavior)
5233 XtGetSubresources (pWS->pSD->screenTopLevelW, (XtPointer) pWS,
5234 pWS->name, pWS->name, wmStdWorkspaceResources,
5235 XtNumber (wmStdWorkspaceResources), NULL, 0);
5238 * Fill in the standard resource values.
5240 * (no code for this right now)
5243 pWS->iconBoxGeometry = NULL;
5248 XtGetSubresources (pWS->pSD->screenTopLevelW, (XtPointer) pWS,
5249 pWS->name, pWS->name, wmWorkspaceResources,
5250 XtNumber (wmWorkspaceResources), NULL, 0);
5253 /* Dup iconbox geometry, it may be free'd later on. */
5255 if (pWS->iconBoxGeometry)
5257 pWS->iconBoxGeometry = XtNewString (pWS->iconBoxGeometry);
5263 if (pWS->title == NULL)
5266 * Setup default workspace title
5268 pWS->title = XmStringCreateLocalized(pWS->name);
5273 * Copy resource just in case there's a duplicate
5274 * Duplicates point to the same data, freeing on
5275 * rename can cause a crash.
5277 pWS->title = XmStringCopy(pWS->title);
5282 * Dup iconbox geometry, it may be free'd later on.
5284 if (pWS->iconBoxGeometry)
5286 pWS->iconBoxGeometry = XtNewString (pWS->iconBoxGeometry);
5290 * Get backdrop resources
5292 XtGetSubresources (pWS->workspaceTopLevelW,
5293 (XtPointer) &(pWS->backdrop),
5294 WmNbackdrop, WmCBackdrop, wmBackdropResources,
5295 XtNumber (wmBackdropResources), NULL, 0);
5297 ProcessBackdropResources (pWS, NULL);
5300 } /* END OF FUNCTION ProcessWorkspaceResources */
5304 /******************************<->*************************************
5306 * ProcessPresenceResources (pSD)
5311 * This function retrieves resources for the workspace presence
5316 * pSD = pointer to screen data
5321 * pSD = resource data for workspace presence dialog are set
5326 * o Gets subresources
5328 ******************************<->***********************************/
5331 ProcessPresenceResources (WmScreenData *pSD)
5333 #ifndef NO_MESSAGE_CATALOG
5334 static char *default_ws_pres_title = NULL;
5336 static char *default_ws_pres_title = "Workspace Presence";
5340 unsigned char *pch1, *pch2;
5342 #ifndef NO_MESSAGE_CATALOG
5344 * Set up localized default title string on initial time through
5346 if (default_ws_pres_title == NULL)
5350 * catgets returns a pointer to an area that is over written
5351 * on each call to catgets.
5354 tmpString = ((char *)GETMESSAGE(62, 59, "Occupy Workspace"));
5355 if ((default_ws_pres_title =
5356 (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
5358 Warning (((char *)GETMESSAGE(62, 31, "Insufficient memory for local message string")));
5359 default_ws_pres_title = "Occupy Workspace";
5363 strcpy(default_ws_pres_title, tmpString);
5368 if (pSD->presence.shellW)
5370 XtGetSubresources (pSD->presence.shellW, (XtPointer) &pSD->presence,
5371 WmNworkspacePresence, WmCWorkspacePresence,
5372 wmWsPresenceResources,
5373 XtNumber (wmWsPresenceResources), NULL, 0);
5377 if (pSD->presence.title)
5379 pch1 = (unsigned char *)
5380 WmXmStringToString (pSD->presence.title);
5382 if (pch1 && (pch2 = (unsigned char *)
5383 XtMalloc (1+strlen((char *)pch1))))
5385 strcpy ((char *)pch2, (char *)pch1);
5391 pch2 = (unsigned char *) default_ws_pres_title;
5395 XtSetArg (args[n], XmNtitle, pch2); n++;
5396 XtSetValues (pSD->presence.shellW, args, n);
5399 } /* END OF FUNCTION ProcessPresenceResources */
5403 /*************************************<->*************************************
5405 * ProcessClientResources (pCD)
5410 * This function retrieves resources that are client specific. If the
5411 * window manager is providing standard behavior then retrieve the limited
5412 * set of resources that don't affect standard behavior and set the
5413 * values of the other resources to the standard values.
5418 * pCD = pointer to client data
5423 * pCD = resource data for client is set
5428 * o Gets subresources based on client name and class.
5429 * o Creates GC for the client Matte, if there is one.
5431 *************************************<->***********************************/
5434 ProcessClientResources (ClientData *pCD)
5438 WmScreenData *pSD = pCD->pSD;
5441 * Retrieve basic client specific resources.
5444 _pCD = pCD; /* save in static global for dynamic default processing */
5445 clientName = (pCD->clientName) ? pCD->clientName : WmNdefaults;
5446 clientClass = (pCD->clientClass) ? pCD->clientClass : WmNdefaults;
5448 if (wmGD.useStandardBehavior)
5450 XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5451 clientClass, wmStdClientResources, XtNumber (wmStdClientResources),
5455 * Fill in the standard resource values.
5458 SetStdClientResourceValues (pCD);
5462 XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5463 clientClass, wmClientResources, XtNumber (wmClientResources), NULL,
5467 #ifdef NO_MESSAGE_CATALOG
5469 * If (window menu spec is not found) then use the builtin
5473 if ((pCD->systemMenu == defaultSystemMenuName) &&
5474 (pSD->defaultSystemMenuUseBuiltin == TRUE))
5476 pCD->systemMenu = builtinSystemMenuName;
5481 * If the client decorations or client functions have been defaulted
5482 * fix up the fields in the ProcessMwmHints function.
5486 /* make top and bottom shadow pixmaps */
5488 if (pCD->iconImageBottomShadowPStr)
5490 if ((pCD->iconImageBottomShadowPStr ==
5491 pSD->iconAppearance.bottomShadowPStr) &&
5492 (pCD->iconImageBottomShadowColor ==
5493 pSD->iconAppearance.bottomShadowColor) &&
5494 (pCD->iconImageBackground ==
5495 pSD->iconAppearance.background))
5497 pCD->iconImageBottomShadowPixmap =
5498 pSD->iconAppearance.bottomShadowPixmap;
5502 pCD->iconImageBottomShadowPixmap =
5503 XmGetPixmap ( ScreenOfDisplay (DISPLAY,
5505 pCD->iconImageBottomShadowPStr,
5506 pCD->iconImageBottomShadowColor,
5507 pCD->iconImageBackground);
5509 if (pCD->iconImageBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
5511 pCD->iconImageBottomShadowPixmap = (Pixmap)NULL;
5517 pCD->iconImageBottomShadowPixmap = (Pixmap)NULL;
5520 if (pCD->iconImageTopShadowPStr)
5522 if ((pCD->iconImageTopShadowPStr ==
5523 pSD->iconAppearance.topShadowPStr) &&
5524 (pCD->iconImageTopShadowColor ==
5525 pSD->iconAppearance.topShadowColor) &&
5526 (pCD->iconImageBackground == pSD->iconAppearance.background))
5528 pCD->iconImageTopShadowPixmap =
5529 pSD->iconAppearance.topShadowPixmap;
5533 pCD->iconImageTopShadowPixmap =
5534 XmGetPixmap ( ScreenOfDisplay (DISPLAY,
5536 pCD->iconImageTopShadowPStr,
5537 pCD->iconImageTopShadowColor,
5538 pCD->iconImageBackground);
5540 if (pCD->iconImageTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
5542 pCD->iconImageTopShadowPixmap = (Pixmap)NULL;
5548 pCD->iconImageTopShadowPixmap = (Pixmap)NULL;
5551 if ((pCD->internalBevel < MIN_INTERNAL_BEVEL) ||
5552 (pCD->internalBevel > MAX_INTERNAL_BEVEL))
5554 pCD->internalBevel = MAX_INTERNAL_BEVEL;
5559 * Retrieve matte resources and make internal matte resources.
5562 if (pCD->matteWidth > 0)
5564 XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5565 clientClass, wmClientResourcesM, XtNumber (wmClientResourcesM),
5568 /* make top and bottom shadow pixmaps */
5571 if (pCD->matteBottomShadowPStr &&
5572 (!strcmp(pCD->matteBottomShadowPStr, _NoDither)))
5574 pCD->matteBottomShadowPStr = NULL;
5577 if (pCD->matteBottomShadowPStr)
5579 if ((pCD->matteBottomShadowPStr ==
5580 pSD->clientAppearance.bottomShadowPStr) &&
5581 (pCD->matteBottomShadowColor ==
5582 pSD->clientAppearance.bottomShadowColor) &&
5583 (pCD->matteBackground == pSD->clientAppearance.background))
5585 pCD->matteBottomShadowPixmap =
5586 pSD->clientAppearance.bottomShadowPixmap;
5590 pCD->matteBottomShadowPixmap =
5591 XmGetPixmap (ScreenOfDisplay (DISPLAY,
5593 pCD->matteBottomShadowPStr,
5594 pCD->matteBottomShadowColor,
5595 pCD->matteBackground);
5597 if (pCD->matteBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
5599 pCD->matteBottomShadowPixmap = (Pixmap)NULL;
5605 pCD->matteBottomShadowPixmap = (Pixmap)NULL;
5609 if (pCD->matteTopShadowPStr &&
5610 (!strcmp(pCD->matteTopShadowPStr, _NoDither)))
5612 pCD->matteTopShadowPStr = NULL;
5615 if (pCD->matteTopShadowPStr)
5617 if ((pCD->matteTopShadowPStr ==
5618 pSD->clientAppearance.topShadowPStr) &&
5619 (pCD->matteTopShadowColor ==
5620 pSD->clientAppearance.topShadowColor) &&
5621 (pCD->matteBackground == pSD->clientAppearance.background))
5623 pCD->matteTopShadowPixmap =
5624 pSD->clientAppearance.topShadowPixmap;
5628 pCD->matteTopShadowPixmap =
5629 XmGetPixmap (ScreenOfDisplay (DISPLAY,
5631 pCD->matteTopShadowPStr,
5632 pCD->matteTopShadowColor,
5633 pCD->matteBackground);
5635 if (pCD->matteTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
5637 pCD->matteTopShadowPixmap = (Pixmap)NULL;
5643 pCD->matteTopShadowPixmap = (Pixmap)NULL;
5647 /* make top and bottom shadow GC's */
5649 pCD->clientMatteTopShadowGC = GetHighlightGC (pCD->pSD,
5650 pCD->matteTopShadowColor,
5651 pCD->matteBackground,
5652 pCD->matteTopShadowPixmap);
5654 pCD->clientMatteBottomShadowGC = GetHighlightGC (pCD->pSD,
5655 pCD->matteBottomShadowColor,
5656 pCD->matteBackground,
5657 pCD->matteBottomShadowPixmap);
5660 } /* END OF FUNCTION ProcessClientResources */
5664 /*************************************<->*************************************
5666 * SetStdClientResourceValues (pCD)
5671 * This function sets client resource data to standard values. This setting
5672 * is done in place of getting the values from the user settings in
5673 * the resource database.
5677 * pCD = pointer to the client data
5682 * pCD = (client data filled out with resource values)
5684 *************************************<->***********************************/
5687 SetStdClientResourceValues (ClientData *pCD)
5689 pCD->clientDecoration = WM_DECOR_DEFAULT;
5690 pCD->clientFunctions = WM_FUNC_DEFAULT;
5691 pCD->focusAutoRaise = True;
5692 pCD->systemMenu = builtinSystemMenuName;
5693 pCD->usePPosition = USE_PPOSITION_NONZERO;
5694 pCD->ignoreWMSaveHints = True;
5696 } /* END OF FUNCTION SetStdClientResourceValues */
5700 /******************************<->*************************************
5702 * SetStdScreenResourceValues (pSD)
5707 * This function sets screen resource data to standard values. This setting
5708 * is done in place of getting the values from the user settings in
5709 * the resource database.
5713 * pSD = pointer to the screen data
5718 * pSD = (screen data filled out with resource values)
5720 ******************************<->***********************************/
5723 SetStdScreenResourceValues (WmScreenData *pSD)
5725 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
5726 pSD->rootMenu = builtinRootMenuName;
5727 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
5728 pSD->buttonBindings = builtinButtonBindingsName;
5729 pSD->cleanText = True;
5730 pSD->iconDecoration =
5731 (ICON_LABEL_PART | ICON_IMAGE_PART | ICON_ACTIVE_LABEL_PART);
5732 pSD->iconPlacement =
5733 (ICON_PLACE_LEFT_PRIMARY | ICON_PLACE_BOTTOM_SECONDARY);
5734 pSD->keyBindings = builtinKeyBindingsName;
5735 pSD->limitResize = True;
5736 pSD->resizeCursors = True;
5737 pSD->transientDecoration = (WM_DECOR_SYSTEM | WM_DECOR_RESIZEH);
5738 pSD->transientFunctions =
5739 (WM_FUNC_ALL & ~(MWM_FUNC_MAXIMIZE | MWM_FUNC_MINIMIZE |
5741 pSD->useIconBox = False;
5743 pSD->feedbackGeometry = NULL;
5744 pSD->moveOpaque = False;
5746 } /* END OF FUNCTION SetStdScreenResourceValues */
5749 /*************************************<->*************************************
5751 * GetHighlightGC (pSD, fg, bg, pixmap)
5756 * Get a graphic context for either drawing top- or bottom-shadow
5762 * pSD = pointer to screen data
5763 * fg = foreground color
5764 * bg = background color
5765 * pixmap = pixmap for highlight
5769 * RETRUN = GC with the input parameters incorporated.
5771 *************************************<->***********************************/
5773 GC GetHighlightGC (WmScreenData *pSD, Pixel fg, Pixel bg, Pixmap pixmap)
5779 mask = GCForeground | GCBackground | GCLineWidth | GCFillStyle;
5780 gcv.background = bg;
5781 gcv.foreground = fg;
5786 mask |= GCFillStyle | GCTile;
5787 gcv.fill_style = FillTiled;
5792 gcv.fill_style = FillSolid;
5797 * NOTE: If additional mask bits are added, modify WmGetGC()
5798 * in WmGraphics.c to check those values for matches.
5801 return (WmGetGC (pSD, mask, &gcv));
5802 #endif /* OLD_CODE */
5804 return (XtGetGC (pSD->screenTopLevelW, mask, &gcv));
5806 } /* END OF FUNCTION GetHighlightGC */
5810 /*************************************<->*************************************
5812 * _WmGetDynamicDefault (widget, type, defaultColor, newBackground, value)
5817 * This function is used to generate a default color of the requested
5818 * type. Default colors are generated for a 3-D appearance.
5823 * widget = this is the widget that is associated with the resource or
5824 * that is the reference widget for the wm subpart.
5826 * type = this is the type of color resource (e.g., top shadow color).
5828 * defaultColor = pointer to default color name/specification.
5830 * newBackground = background pixel for generating 3-D colors.
5835 * value = pointer to the XrmValue in which to store the color
5837 *************************************<->***********************************/
5840 _WmGetDynamicDefault (Widget widget, unsigned char type, String defaultColor, Pixel newBackground, XrmValue *value)
5842 static Screen *oldScreen = NULL;
5843 static Screen *newScreen;
5844 static Colormap oldColormap;
5845 static Colormap newColormap;
5846 static Pixel newValue;
5847 static Pixel background;
5848 static String oldDefaultColor = DEFAULT_COLOR_NONE;
5849 static XmColorData colorData;
5851 /* initialize the return value */
5853 value->size = sizeof (newValue);
5854 value->addr = (char *)&newValue;
5858 * Process monochrome defaults first.
5861 newScreen = XtScreen (widget);
5863 if (Monochrome (newScreen))
5868 * Check color server sets for this screen.
5870 if (wmGD.statusColorServer == CSERVE_NORMAL)
5875 for (i = 0; i < wmGD.numScreens; i++)
5877 if (XScreenNumberOfScreen(newScreen) == wmGD.Screens[i].screen)
5879 pSD = &wmGD.Screens[i];
5888 for (i = 0; i < XmCO_MAX_NUM_COLORS; i++)
5890 if (pSD->pPixelData[i].bg == newBackground)
5894 case WmFGC: newValue = pSD->pPixelData[i].fg; break;
5895 case WmBGC: newValue = pSD->pPixelData[i].bg; break;
5896 case WmTSC: newValue = pSD->pPixelData[i].ts; break;
5897 case WmBSC: newValue = pSD->pPixelData[i].bs; break;
5911 case WmFGC: newValue = BlackPixelOfScreen (newScreen); break;
5912 case WmBGC: newValue = WhitePixelOfScreen (newScreen); break;
5913 case WmTSC: newValue = WhitePixelOfScreen (newScreen); break;
5914 case WmBSC: newValue = BlackPixelOfScreen (newScreen); break;
5924 * Check to see if appropriate colors are available from the
5925 * previous request; if the color is a background color then get
5926 * default colors. Generate 3-D colors if necessary. Maintain
5927 * new colors in static variables for later reuse.
5930 newColormap = widget->core.colormap;
5932 if ((oldScreen != NULL) && (oldScreen == newScreen) &&
5933 (oldColormap == newColormap) && (type != WmBGC) &&
5934 (background == newBackground))
5937 else if ((oldScreen == newScreen) && (oldColormap == newColormap) &&
5938 (type == WmBGC) && (oldDefaultColor == defaultColor))
5941 else if (type == WmBGC)
5944 * Find or generate a background color and associated 3-D colors.
5947 oldDefaultColor = defaultColor;
5949 * Fix for CR 5152 - Due to the use of Realloc in the color caches,
5950 * a static pointer is not acceptable. Change it
5951 * to a static structure to maintain the data
5953 colorData = *_WmGetDefaultColors (newScreen, newColormap, defaultColor);
5958 * Find or generate a color based on the associated background color.
5961 oldDefaultColor = DEFAULT_COLOR_NONE;
5962 background = newBackground;
5964 XmGetColors(newScreen, newColormap, background,
5965 &colorData.foreground.pixel,
5966 &colorData.top_shadow.pixel,
5967 &colorData.bottom_shadow.pixel,
5968 &colorData.select.pixel);
5971 oldScreen = newScreen;
5972 oldColormap = newColormap;
5976 * Set up the return value.
5979 colorData.allocated |= type;
5982 case XmBACKGROUND: newValue = colorData.background.pixel; break;
5983 case XmFOREGROUND: newValue = colorData.foreground.pixel; break;
5984 case XmTOP_SHADOW: newValue = colorData.top_shadow.pixel; break;
5985 case XmBOTTOM_SHADOW: newValue = colorData.bottom_shadow.pixel; break;
5986 case XmSELECT: newValue = colorData.select.pixel; break;
5987 default: newValue = colorData.background.pixel; break;
5990 } /* END OF FUNCTION _WmGetDynamicDefault */
5994 /*************************************<->*************************************
5996 * _WmGetDefaultColors (screen, colormap, defaultColor)
6001 * This function is used to find or generate default 3-D colors based on a
6002 * default background color.
6007 * screen = screen for which colors are to be generated.
6009 * colormap = colormap that is to be used to make colors.
6011 * defaultColor = pointer to a default color name/specification.
6016 * RETURN = pointer to WmColorData structure containing 3-D colors.
6018 *************************************<->***********************************/
6020 XmColorData * _WmGetDefaultColors (screen, colormap, defaultColor)
6023 String defaultColor;
6026 static XmColorData *defaultSet[2] = {NULL, NULL};
6027 static int defaultCount[2] = {0, 0};
6028 static int defaultSize[2] = {0, 0};
6030 register XmColorData *set;
6034 Display *display = DisplayOfScreen (screen);
6038 * Fix for CR 5152 - Due to the use of Realloc with _XmGetColors, it is
6039 * necessary to maintain a separate cache of color
6040 * data. The Realloc may cause the data to be moved,
6041 * and the cache would contain pointers into the heap.
6045 * Look through the cache to see if the defaults are already in the
6046 * cache. There is a list of cached defaults for each default color.
6049 if (defaultColor == _defaultColor2)
6058 set = defaultSet[setId];
6059 count = defaultCount[setId];
6060 size = defaultSize[setId];
6062 for (i = 0; i < count; i++)
6064 if (((set + i)->screen == screen) && ((set + i)->color_map == colormap))
6071 * No match in the cache, make a new entry and generate the colors.
6076 size = (defaultSize[setId] += 10);
6077 set = defaultSet[setId] =
6078 (XmColorData *)WmRealloc ((char *) defaultSet[setId],
6079 sizeof (XmColorData) * size);
6083 * Make the default background color for the resource set.
6086 if(!XParseColor (display, colormap, defaultColor, &colorDef))
6088 if(!(strcmp(defaultColor, _defaultColor1)))
6090 XParseColor (display, colormap, _defaultColor1HEX, &colorDef);
6094 XParseColor (display, colormap, _defaultColor2HEX, &colorDef);
6098 XAllocColor (display, colormap, &colorDef);
6102 * Generate the 3-D colors and save them in the defaults cache.
6105 XmGetColors(screen, colormap, colorDef.pixel,
6106 &set[count].foreground.pixel,
6107 &set[count].top_shadow.pixel,
6108 &set[count].bottom_shadow.pixel,
6109 &set[count].select.pixel);
6111 set[count].background.pixel = colorDef.pixel;
6113 set[count].screen = screen;
6114 set[count].color_map = colormap;
6115 set[count].allocated = True;
6117 XQueryColor(DISPLAY, colormap, &(set[count].background));
6118 XQueryColor(DISPLAY, colormap, &(set[count].foreground));
6119 XQueryColor(DISPLAY, colormap, &(set[count].top_shadow));
6120 XQueryColor(DISPLAY, colormap, &(set[count].bottom_shadow));
6121 XQueryColor(DISPLAY, colormap, &(set[count].select));
6123 (defaultCount[setId])++;
6125 return (set + count);
6128 } /* END OF FUNCTION _WmGetDefaultColors */
6132 /*************************************<->*************************************
6134 * WmRealloc (ptr, size)
6139 * This function is used reallocate a block of storage that has been
6145 * ptr = pointer to storage that is to be realloc'ed; if NULL malloc an
6146 * initial block of storage.
6148 * size = size of new storage
6152 * RETURN = pointer to realloc'ed block of storage
6154 *************************************<->***********************************/
6156 char * WmRealloc (ptr, size)
6163 ptr = (char *)XtRealloc (ptr, size);
6167 ptr = (char *)XtMalloc (size);
6172 Warning (((char *)GETMESSAGE(62, 37, "Insufficient memory for window manager data")));
6177 } /* END OF FUNCTION WmRealloc */
6181 /*************************************<->*************************************
6183 * WmMalloc (ptr, size)
6188 * This function is used malloc a block of storage. If a previous block
6189 * of storage is being replace the old block is free'd.
6194 * ptr = pointer to storage that is to be replaced (free'd).
6196 * size = size of new storage
6200 * RETURN = pointer to malloc'ed block of storage
6202 *************************************<->***********************************/
6204 char * WmMalloc (ptr, size)
6214 ptr = (char *)XtMalloc (size);
6218 Warning (((char *)GETMESSAGE(62, 38, "Insufficient memory for window manager data")));
6223 } /* END OF FUNCTION WmMalloc */
6227 /*************************************<->*************************************
6229 * SetupDefaultResources (pSD)
6234 * This function is used to setup default (builtin) resources for the
6240 * pSD = pointer to screen data
6241 * wmGD = (defaultKeyBindingsString, ...)
6243 * builtinKeyBindingsName = name of default key bindings set
6250 *************************************<->***********************************/
6253 SetupDefaultResources (pSD)
6258 KeySpec *nextKeySpec;
6264 * If (using DefaultBindings mechanism and bindings are not found in .mwmrc)
6265 * then use the builtin bindings.
6267 if (!pSD->keySpecs && !wmGD.useStandardBehavior)
6270 * Print warning if user is NOT using "DefaultKeyBindings".
6272 if (strcmp (pSD->keyBindings, defaultKeyBindingsName))
6274 MWarning (((char *)GETMESSAGE(62, 67, "Key bindings %s not found, using builtin key bindings\n")),
6277 pSD->keyBindings = builtinKeyBindingsName;
6280 if (!pSD->buttonSpecs && !wmGD.useStandardBehavior)
6283 * Print warning if user is NOT using "DefaultButtonBindings".
6285 if (strcmp (pSD->buttonBindings, defaultButtonBindingsName))
6287 MWarning (((char *)GETMESSAGE(62, 68, "Button bindings %s not found, using builtin button bindings\n")),
6288 pSD->buttonBindings);
6290 pSD->buttonBindings = builtinButtonBindingsName;
6293 if (pSD->keyBindings == builtinKeyBindingsName)
6296 * Default key specifications are to be used and no default
6297 * set has been provided by the user. Make the built-in default
6301 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
6303 * Before parsing the string, substitute the real name for
6304 * the default rootmenu using the resource rootMenu
6305 * for the %s in the string.
6310 buffer = (char *) XtMalloc(strlen(builtinKeyBindings) +
6311 strlen(pSD->rootMenu) + 1);
6312 sprintf(buffer, builtinKeyBindings, pSD->rootMenu);
6314 ParseKeyStr (pSD, (unsigned char *)buffer);
6316 ParseKeyStr (pSD, (unsigned char *)builtinKeyBindings);
6317 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
6322 * Add the switch behavior key binding to the front of the list
6323 * of user specified key bindings that have been parsed.
6326 nextKeySpec = pSD->keySpecs;
6327 keyBindings = pSD->keyBindings;
6328 pSD->keyBindings = behaviorKeyBindingName;
6329 pSD->keySpecs = NULL;
6331 ParseKeyStr (pSD, (unsigned char *)behaviorKeyBindings);
6335 /* Skip past the TWO key definitions (1.2 & 1.1.4) */
6336 pSD->keySpecs->nextKeySpec->nextKeySpec = nextKeySpec;
6340 pSD->keySpecs = nextKeySpec;
6342 pSD->keyBindings = keyBindings;
6345 if (pSD->buttonBindings == builtinButtonBindingsName)
6348 * Default button specifications are to be used and no default
6349 * set has been provided by the user. Make the built-in default
6353 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
6355 * Before parsing the string, substitute the real name for
6356 * the default rootmenu using the resource rootMenu
6357 * for the %s in the string.
6362 buffer = (char *) XtMalloc(strlen(builtinButtonBindings) +
6363 strlen(pSD->rootMenu) + 1);
6364 sprintf(buffer, builtinButtonBindings, pSD->rootMenu);
6366 ParseButtonStr (pSD, (unsigned char *)buffer);
6368 ParseButtonStr (pSD, (unsigned char *)builtinButtonBindings);
6369 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
6372 #ifdef NO_MESSAGE_CATALOG
6374 * Set defaultSystemMenuUseBuiltin to FALSE if DefaultWindowMenu spec
6378 menuSpec = pSD->menuSpecs;
6381 if (!strcmp(menuSpec->name, defaultSystemMenuName))
6383 pSD->defaultSystemMenuUseBuiltin = FALSE;
6386 menuSpec = menuSpec->nextMenuSpec;
6390 } /* END OF FUNCTION SetupDefaultResources */
6394 /*************************************<->*************************************
6396 * SimilarAppearanceData (pAD1, pAD2)
6401 * This function returns True if the two passed sets of AppearanceData
6402 * are similar. This is designed to compare appearance data before
6403 * creation of the GCs.
6408 * pAD1 pointer to AppearanceData 1
6409 * pAD2 pointer to AppearanceData 2
6414 * Function returns True if similar, False otherwise.
6418 * This function is only used to compare the client
6419 * and client*title appearance data.
6420 *************************************<->***********************************/
6422 Boolean SimilarAppearanceData (AppearanceData *pAD1, AppearanceData *pAD2)
6427 if ((pAD1->fontList == pAD2->fontList) &&
6428 (pAD1->background == pAD2->background) &&
6429 (pAD1->foreground == pAD2->foreground) &&
6430 (pAD1->backgroundPStr == pAD2->backgroundPStr) &&
6431 (pAD1->backgroundPixmap == pAD2->backgroundPixmap) &&
6432 (pAD1->bottomShadowColor == pAD2->bottomShadowColor) &&
6433 (pAD1->bottomShadowPStr == pAD2->bottomShadowPStr) &&
6434 (pAD1->bottomShadowPixmap == pAD2->bottomShadowPixmap) &&
6435 (pAD1->topShadowColor == pAD2->topShadowColor) &&
6436 (pAD1->topShadowPStr == pAD2->topShadowPStr) &&
6437 (pAD1->topShadowPixmap == pAD2->topShadowPixmap) &&
6438 (pAD1->activeBackground == pAD2->activeBackground) &&
6439 (pAD1->activeForeground == pAD2->activeForeground) &&
6440 (pAD1->activeBackgroundPStr == pAD2->activeBackgroundPStr) &&
6441 (pAD1->activeBackgroundPixmap == pAD2->activeBackgroundPixmap) &&
6442 (pAD1->activeBottomShadowColor == pAD2->activeBottomShadowColor) &&
6443 (pAD1->activeBottomShadowPStr == pAD2->activeBottomShadowPStr) &&
6444 (pAD1->activeBottomShadowPixmap == pAD2->activeBottomShadowPixmap) &&
6445 (pAD1->activeTopShadowColor == pAD2->activeTopShadowColor) &&
6446 (pAD1->activeTopShadowPStr == pAD2->activeTopShadowPStr) &&
6447 (pAD1->activeTopShadowPixmap == pAD2->activeTopShadowPixmap) )
6450 * !!! Should find out why all the Pixmap resources are unset !!!
6453 if ((pAD1->fontList == pAD2->fontList) &&
6454 (pAD1->background == pAD2->background) &&
6455 (pAD1->foreground == pAD2->foreground) &&
6456 (pAD1->backgroundPStr == pAD2->backgroundPStr) &&
6457 (pAD1->bottomShadowColor == pAD2->bottomShadowColor) &&
6458 (pAD1->bottomShadowPStr == pAD2->bottomShadowPStr) &&
6459 (pAD1->topShadowColor == pAD2->topShadowColor) &&
6460 (pAD1->topShadowPStr == pAD2->topShadowPStr) &&
6461 (pAD1->activeBackground == pAD2->activeBackground) &&
6462 (pAD1->activeForeground == pAD2->activeForeground) &&
6463 (pAD1->activeBackgroundPStr == pAD2->activeBackgroundPStr) &&
6464 (pAD1->activeBottomShadowColor == pAD2->activeBottomShadowColor) &&
6465 (pAD1->activeBottomShadowPStr == pAD2->activeBottomShadowPStr) &&
6466 (pAD1->activeTopShadowColor == pAD2->activeTopShadowColor) &&
6467 (pAD1->activeTopShadowPStr == pAD2->activeTopShadowPStr) )
6479 } /* END OF FUNCTION SimilarAppearanceData */
6483 /*************************************<->*************************************
6485 * Monochrome (screen)
6490 * This function returns True if the screen passed it to be treated
6491 * as monochrome for the purpose of assigning default resources.
6496 * screen pointer to Screen
6501 * Function returns True if monochrome (or Static Gray), False otherwise.
6503 *************************************<->***********************************/
6506 Monochrome (Screen *screen)
6512 if (wmGD.statusColorServer == CSERVE_NORMAL)
6514 for (scr = 0; scr < wmGD.numScreens; scr++)
6516 pSD = &(wmGD.Screens[scr]);
6520 if (XScreenOfDisplay (DISPLAY, pSD->screen) == screen)
6522 if (pSD->colorUse == XmCO_BLACK_WHITE)
6535 * If we don't know the answer to our question by now,
6536 * fall back to the old mwm way of determining monochromicity.
6540 return ((DefaultDepthOfScreen(screen) == 1));
6541 } /* END OF FUNCTION Monochrome */
6544 /**************************** eof ***************************/