cde/programs/dtwm/WmResource.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   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)
  10  * any later version.
  11  *
  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
  16  * details.
  17  *
  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
  22  */
  23 /*
  24  * (c) Copyright 1989, 1990, 1991, 1992, 1993 OPEN SOFTWARE FOUNDATION, INC.
  25  * ALL RIGHTS RESERVED
  26 */
  27 /*
  28  * Motif Release 1.2.3
  29 */
  30 #ifdef REV_INFO
  31 #ifndef lint
  32 static char rcsid[] = "$TOG: WmResource.c /main/14 1997/04/15 10:30:02 dbl $"
  33 #endif
  34 #endif
  35 /*
  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.
  40  */
  41
  42 /*
  43  * Included Files:
  44  */
  45
  46 #include "WmGlobal.h"
  47 #include "WmResNames.h"
  48
  49 #define MWM_NEED_IIMAGE
  50 #include "WmIBitmap.h"
  51
  52 #include <stdio.h>
  53
  54 #include <Xm/XmP.h>
  55 #include <Xm/RowColumn.h>
  56 #ifndef MOTIF_ONE_DOT_ONE
  57 #include <Xm/ScreenP.h>         /* for XmGetXmScreen and screen.moveOpaque */
  58 #endif
  59
  60 /*
  61  * include extern functions
  62  */
  63 #include "WmResource.h"
  64 #include "WmError.h"
  65 #include "WmGraphics.h"
  66 #include "WmMenu.h"
  67 #include "WmResParse.h"
  68 #ifdef WSM
  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 */
  74 #endif /* WSM */
  75 #include "WmXSMP.h"
  76
  77 /*
  78  * Function Declarations:
  79  */
  80 XmColorData *_WmGetDefaultColors ();
  81
  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);
 121 #ifdef WSM
 122 static void WriteOutXrmColors (WmScreenData *pSD);
 123 #endif /* WSM */
 124 #ifdef WSM
 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);
 133 #endif /* WSM */
 134 void _WmGetDynamicDefault (Widget widget, unsigned char type, String defaultColor, Pixel newBackground, XrmValue *value);
 135 Boolean SimilarAppearanceData (AppearanceData *pAD1, AppearanceData *pAD2);
 136
 137
 138
 139 /*
 140  * Global Variables:
 141  */
 142
 143 /* builtin window menu specification */
 144
 145 #ifndef NO_MESSAGE_CATALOG
 146 /*
 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
 149  */
 150 char defaultSystemMenuName[] = "_MwmWindowMenu_";
 151 #else
 152 char defaultSystemMenuName[] = "DefaultWindowMenu";
 153 #endif  /* NO_MESSAGE_CATALOG */
 154 char builtinSystemMenuName[] = "_MwmWindowMenu_";
 155 #ifndef MCCABE
 156 #define BUILTINSYSTEMMENU "_MwmWindowMenu_\n\
 157 {\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\
 166 }"
 167 #ifdef NO_MESSAGE_CATALOG
 168 char builtinSystemMenu[] = BUILTINSYSTEMMENU;
 169 #else /* !defined(NO_MESSAGE_CATALOG)*/
 170 char *builtinSystemMenu = BUILTINSYSTEMMENU;
 171 #ifdef WSM
 172 #define DEFAULT_DTWM_SYSTEMMENU "_MwmWindowMenu_\n\
 173 {\n\
 174         Restore         _R      f.restore\n\
 175         Move            _M      f.move\n\
 176         Size            _S      f.resize\n\
 177         Minimize        _n      f.minimize\n\
 178         Maximize        _x      f.maximize\n\
 179         Lower           _L      f.lower\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\
 186 }"
 187 #endif /* WSM */
 188
 189 void InitBuiltinSystemMenu(void)
 190 {
 191     char * tmpString;
 192     char *ResString = NULL;
 193     char *MovString = NULL;
 194     char *SizString = NULL;
 195     char *MinString = NULL;
 196     char *MaxString = NULL;
 197     char *LowString = NULL;
 198 #ifdef WSM
 199     char *OcpString = NULL;
 200     char *OcaString = NULL;
 201     char *RemString = NULL;
 202 #endif /* WSM */
 203     char *CloString = NULL;
 204     char dsm[2048];
 205     Boolean gotItAll;
 206     gotItAll = True;
 207     if(gotItAll)
 208     {
 209 #ifdef sun
 210         tmpString = ((char *)GETMESSAGE(62, 60, "Restore _R  Alt<Key>F5 f.restore"));
 211 #else
 212         tmpString = ((char *)GETMESSAGE(62, 49, "Restore _R  f.restore"));
 213 #endif
 214         if ((ResString =
 215              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
 216         {
 217             Warning (((char *)GETMESSAGE(62, 2, "Insufficient memory for local default menu.")));
 218             gotItAll = False;
 219         }
 220         else
 221         {
 222             strcpy(ResString, tmpString);
 223         }
 224     }
 225     if(gotItAll)
 226     {
 227 #ifdef sun
 228         tmpString = ((char *)GETMESSAGE(62, 61, "Move _M  Alt<Key>F7 f.move"));
 229 #else
 230         tmpString = ((char *)GETMESSAGE(62, 50, "Move _M  f.move"));
 231 #endif
 232         if ((MovString =
 233              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
 234         {
 235             Warning (((char *)GETMESSAGE(62, 4, "Insufficient memory for local default menu.")));
 236             gotItAll = False;
 237         }
 238         else
 239         {
 240             strcpy(MovString, tmpString);
 241         }
 242     }
 243     if(gotItAll)
 244     {
 245 #ifdef sun
 246         tmpString = ((char *)GETMESSAGE(62, 62, "Size _S  Alt<Key>F8 f.resize"));
 247 #else
 248         tmpString = ((char *)GETMESSAGE(62, 51, "Size _S  f.resize"));
 249 #endif
 250         if ((SizString =
 251              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
 252         {
 253             Warning (((char *)GETMESSAGE(62, 6, "Insufficient memory for local default menu.")));
 254             gotItAll = False;
 255         }
 256         else
 257         {
 258             strcpy(SizString, tmpString);
 259         }
 260     }
 261     if(gotItAll)
 262     {
 263 #ifdef sun
 264         tmpString = ((char *)GETMESSAGE(62, 63, "Minimize _n  Alt<Key>F9 f.minimize"));
 265 #else
 266         tmpString = ((char *)GETMESSAGE(62, 52, "Minimize _n  f.minimize"));
 267 #endif
 268         if ((MinString =
 269              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
 270         {
 271             Warning (((char *)GETMESSAGE(62, 8, "Insufficient memory for local default menu.")));
 272             gotItAll = False;
 273         }
 274         else
 275         {
 276             strcpy(MinString, tmpString);
 277         }
 278     }
 279     if(gotItAll)
 280     {
 281 #ifdef sun
 282         tmpString = ((char *)GETMESSAGE(62, 64, "Maximize _x  Alt<Key>F10 f.maximize"));
 283 #else
 284         tmpString = ((char *)GETMESSAGE(62, 53, "Maximize _x  f.maximize"));
 285 #endif
 286         if ((MaxString =
 287              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
 288         {
 289             Warning (((char *)GETMESSAGE(62, 10, "Insufficient memory for local default menu.")));
 290             gotItAll = False;
 291         }
 292         else
 293         {
 294             strcpy(MaxString, tmpString);
 295         }
 296     }
 297     if(gotItAll)
 298     {
 299 #ifdef sun
 300         tmpString = ((char *)GETMESSAGE(62, 65, "Lower _L  Alt<Key>F3 f.lower"));
 301 #else
 302         tmpString = ((char *)GETMESSAGE(62, 54, "Lower _L  f.lower"));
 303 #endif
 304         if ((LowString =
 305              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
 306         {
 307             Warning (((char *)GETMESSAGE(62, 12, "Insufficient memory for local default menu.")));
 308             gotItAll = False;
 309         }
 310         else
 311         {
 312             strcpy(LowString, tmpString);
 313         }
 314     }
 315 #ifdef WSM
 316     if (DtwmBehavior)
 317     {
 318         if(gotItAll)
 319         {
 320             tmpString = ((char *)GETMESSAGE(62, 55, "Occupy\\ Workspace\\.\\.\\. _O  f.workspace_presence"));
 321             if ((OcpString =
 322                  (char *)XtMalloc ((unsigned int)
 323                                  (strlen(tmpString) + 1))) == NULL)
 324             {
 325                 Warning (((char *)GETMESSAGE(62, 14, "Insufficient memory for local default menu.")));
 326                 gotItAll = False;
 327             }
 328             else
 329             {
 330                 strcpy(OcpString, tmpString);
 331             }
 332         }
 333         if(gotItAll)
 334         {
 335             tmpString = ((char *)GETMESSAGE(62, 56, "Occupy\\ All\\ Workspaces _A  f.occupy_all"));
 336             if ((OcaString =
 337                  (char *)XtMalloc ((unsigned int)
 338                                  (strlen(tmpString) + 1))) == NULL)
 339             {
 340                 Warning (((char *)GETMESSAGE(62, 16, "Insufficient memory for local default menu.")));
 341                 gotItAll = False;
 342             }
 343             else
 344             {
 345                 strcpy(OcaString, tmpString);
 346             }
 347         }
 348         if(gotItAll)
 349         {
 350             tmpString = ((char *)GETMESSAGE(62, 57, "Unoccupy\\ Workspace _U  f.remove"));
 351             if ((RemString =
 352                  (char *)XtMalloc ((unsigned int)
 353                                  (strlen(tmpString) + 1))) == NULL)
 354             {
 355                 Warning (((char *)GETMESSAGE(62, 18, "Insufficient memory for local default menu.")));
 356                 gotItAll = False;
 357             }
 358             else
 359             {
 360                 strcpy(RemString, tmpString);
 361             }
 362         }
 363     } /* if DTWM */
 364 #endif /* WSM */
 365     if(gotItAll)
 366     {
 367         tmpString = ((char *)GETMESSAGE(62, 48, "Close _C Alt<Key>F4 f.kill"));
 368         if ((CloString =
 369              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
 370         {
 371             Warning (((char *)GETMESSAGE(62, 20, "Insufficient memory for local default menu.")));
 372             gotItAll = False;
 373         }
 374         else
 375         {
 376             strcpy(CloString, tmpString);
 377         }
 378     }
 379
 380     if (!gotItAll)
 381     {
 382 #ifdef WSM
 383         if (DtwmBehavior)
 384         {
 385             builtinSystemMenu = (char *)
 386                         XtNewString((String)DEFAULT_DTWM_SYSTEMMENU);
 387         }
 388         else
 389         {
 390             builtinSystemMenu = (char *)
 391                         XtNewString((String)BUILTINSYSTEMMENU);
 392         }
 393 #else /* WSM */
 394         builtinSystemMenu = (char *)
 395                         XtNewString((String)BUILTINSYSTEMMENU);
 396 #endif /* WSM */
 397     }
 398     else
 399     {
 400         /* put it together */
 401         strcpy(dsm, defaultSystemMenuName);
 402         strcat(dsm, "\n{\n");
 403         strcat(dsm, ResString);
 404         strcat(dsm, "\n");
 405         strcat(dsm, MovString);
 406         strcat(dsm, "\n");
 407         strcat(dsm, SizString);
 408         strcat(dsm, "\n");
 409         strcat(dsm, MinString);
 410         strcat(dsm, "\n");
 411         strcat(dsm, MaxString);
 412         strcat(dsm, "\n");
 413         strcat(dsm, LowString);
 414         strcat(dsm, "\n");
 415         strcat(dsm, " no-label  f.separator\n");
 416 #ifdef WSM
 417         if (DtwmBehavior)
 418         {
 419             strcat(dsm, OcpString);
 420             strcat(dsm, "\n");
 421             strcat(dsm, OcaString);
 422             strcat(dsm, "\n");
 423             strcat(dsm, RemString);
 424             strcat(dsm, "\n");
 425             strcat(dsm, " no-label  f.separator\n");
 426         }
 427 #endif /* WSM */
 428         strcat(dsm, CloString);
 429         strcat(dsm, "\n}");
 430
 431         if ((builtinSystemMenu =
 432              (char *)XtMalloc ((unsigned int) (strlen(dsm) + 1))) == NULL)
 433         {
 434            Warning (((char *)GETMESSAGE(62, 21, "Insufficient memory for localized default system menu")));
 435 #ifdef WSM
 436             if (DtwmBehavior)
 437             {
 438                 builtinSystemMenu = (char *)
 439                         XtNewString((String)DEFAULT_DTWM_SYSTEMMENU);
 440             }
 441             else
 442             {
 443                 builtinSystemMenu = (char *)
 444                         XtNewString((String)BUILTINSYSTEMMENU);
 445             }
 446 #else /* WSM */
 447             builtinSystemMenu = (char *)
 448                         XtNewString((String)BUILTINSYSTEMMENU);
 449 #endif /* WSM */
 450         }
 451         else
 452         {
 453             strcpy(builtinSystemMenu, dsm);
 454         }
 455     }
 456
 457     if (ResString != NULL)
 458        XtFree(ResString);
 459     if (MovString != NULL)
 460        XtFree(MovString);
 461     if (SizString != NULL)
 462        XtFree(SizString);
 463     if (MinString != NULL)
 464        XtFree(MinString);
 465     if (MaxString != NULL)
 466        XtFree(MaxString);
 467     if (LowString != NULL)
 468        XtFree(LowString);
 469 #ifdef WSM
 470     if (OcpString != NULL)
 471        XtFree(OcpString);
 472     if (OcaString != NULL)
 473        XtFree(OcaString);
 474     if (RemString != NULL)
 475        XtFree(RemString);
 476 #endif /* WSM */
 477     if (CloString != NULL)
 478        XtFree(CloString);
 479
 480 } /* END OF FUNCTION  InitBuiltinSystemMenu */
 481 #endif /* NO_MESSAGE_CATALOG */
 482 #else /* MCCABE */
 483 char builtinSystemMenu[];
 484 #endif /* MCCABE */
 485
 486 #ifdef WSM
 487 #define HARD_CODED_PRIMARY   3
 488 #endif /* WSM */
 489 char defaultRootMenuName[] = "DefaultRootMenu";
 490 char builtinRootMenuName[] = "_MwmRootMenu_";
 491 #ifndef MCCABE
 492 #define BUILTINROOTMENU "DefaultRootMenu\n\
 493 {\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\
 502 }";
 503 char builtinRootMenu[] = BUILTINROOTMENU
 504 #else /* MCCABE */
 505 char builtinRootMenu[];
 506 #endif /* MCCABE */
 507
 508
 509 /* builtin key bindings specification */
 510
 511 char defaultKeyBindingsName[] = "DefaultKeyBindings";
 512 char builtinKeyBindingsName[] = "_MwmKeyBindings_";
 513 #ifndef MCCABE
 514 #define BUILTINKEYBINDINGS "_MwmKeyBindings_\n\
 515 {\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\
 527 }";
 528 char builtinKeyBindings[] = BUILTINKEYBINDINGS
 529
 530 #else
 531 char builtinKeyBindings[];
 532 #endif
 533
 534 /*
 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.
 538  */
 539
 540 char behaviorKeyBindingName[] = "_MwmBehaviorKey_";
 541 #ifndef MCCABE
 542 #define BEHAVIORKEYBINDINGS "_MwmBehaviorKey_\n\
 543 {\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\
 546 }";
 547 char behaviorKeyBindings[] = BEHAVIORKEYBINDINGS
 548
 549 #else
 550 char behaviorKeyBindings[];
 551 #endif
 552
 553
 554 /* default button bindings specification */
 555 /* note - the %s will be replaced by the real DefaultRootMenu */
 556
 557 char defaultButtonBindingsName[] = "DefaultButtonBindings";
 558 char builtinButtonBindingsName[] = "_MwmButtonBindings_";
 559 #ifndef MCCABE
 560 # if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
 561 #  define BUILTINBUTTONBINDINGS "_MwmButtonBindings_\n\
 562 {\n\
 563         <Btn1Down>      icon|frame      f.raise\n\
 564         <Btn3Down>      icon|frame      f.post_wmenu\n\
 565         <Btn3Down>      root            f.menu %s\n\
 566 }";
 567 # else
 568 #  define BUILTINBUTTONBINDINGS "_MwmButtonBindings_\n\
 569 {\n\
 570         <Btn1Down>      icon|frame      f.raise\n\
 571         <Btn3Down>      icon|frame      f.post_wmenu\n\
 572         <Btn3Down>      root            f.menu DefaultRootMenu\n\
 573 }";
 574 # endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
 575 char builtinButtonBindings[] = BUILTINBUTTONBINDINGS
 576
 577 #else
 578 char builtinButtonBindings[];
 579 #endif
 580
 581
 582 static ClientData *_pCD;
 583 static String _defaultBackground;
 584 static String _defaultActiveBackground;
 585 static AppearanceData *_pAppearanceData;
 586 #ifdef WSM
 587 static WmWorkspaceData *pResWS;
 588 static WmScreenData *pResSD;
 589 #endif /* WSM */
 590
 591 static char _defaultColor1HEX[] = "#A8A8A8A8A8A8";
 592 static char _defaultColor2HEX[] = "#5F5F92929E9E";
 593
 594 static char _defaultColor1[] = "LightGrey";
 595 static char _defaultColor2[] = "CadetBlue";
 596 #define DEFAULT_COLOR_NONE      NULL
 597
 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";
 602 #ifdef WSM
 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";
 609 #endif /* WSM */
 610
 611 #define WmBGC          XmBACKGROUND
 612 #define WmFGC          XmFOREGROUND
 613 #define WmTSC          XmTOP_SHADOW
 614 #define WmBSC          XmBOTTOM_SHADOW
 615
 616 #define MAX_SHORT       0xffff
 617
 618 #ifndef BITMAPDIR
 619 #define BITMAPDIR "/usr/include/X11/bitmaps/"
 620 #endif
 621
 622 \f
 623 /*************************************<->*************************************
 624  *
 625  *  wmGlobalResources
 626  *
 627  *
 628  *  Description:
 629  *  -----------
 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:
 633  *
 634  *      "Mwm*<resource_identifier>".
 635  *
 636  *************************************<->***********************************/
 637
 638
 639 XtResource wmGlobalResources[] =
 640 {
 641
 642     {
 643         WmNautoKeyFocus,
 644         WmCAutoKeyFocus,
 645         XtRBoolean,
 646         sizeof (Boolean),
 647         XtOffsetOf(WmGlobalData, autoKeyFocus),
 648         XtRImmediate,
 649         (XtPointer)True
 650     },
 651
 652     {
 653         WmNautoRaiseDelay,
 654         WmCAutoRaiseDelay,
 655         XtRInt,
 656         sizeof (int),
 657         XtOffsetOf(WmGlobalData, autoRaiseDelay),
 658         XtRImmediate,
 659         (XtPointer)500
 660     },
 661
 662     {
 663         WmNbitmapDirectory,
 664         WmCBitmapDirectory,
 665         XtRString,
 666         sizeof (String),
 667         XtOffsetOf(WmGlobalData, bitmapDirectory),
 668         XtRString,
 669         (XtPointer)BITMAPDIR
 670     },
 671 #ifdef MINIMAL_DT
 672     {
 673         WmNblinkOnExec,
 674         WmCBlinkOnExec,
 675         XtRBoolean,
 676         sizeof (Boolean),
 677         XtOffsetOf(WmGlobalData, blinkOnExec),
 678         XtRImmediate,
 679         (XtPointer)False
 680     },
 681 #endif /* MINIMAL_DT */
 682     {
 683         WmNframeStyle,
 684         WmCFrameStyle,
 685         WmRFrameStyle,
 686         sizeof (FrameStyle),
 687         XtOffsetOf(WmGlobalData, frameStyle),
 688         XtRImmediate,
 689         (XtPointer)WmRECESSED
 690     },
 691
 692     {
 693         WmNclientAutoPlace,
 694         WmCClientAutoPlace,
 695         XtRBoolean,
 696         sizeof (Boolean),
 697         XtOffsetOf(WmGlobalData, clientAutoPlace),
 698         XtRImmediate,
 699         (XtPointer)True
 700     },
 701
 702     {
 703         WmNcolormapFocusPolicy,
 704         WmCColormapFocusPolicy,
 705         WmRCFocusPolicy,
 706         sizeof (int),
 707         XtOffsetOf(WmGlobalData, colormapFocusPolicy),
 708         XtRImmediate,
 709         (XtPointer)CMAP_FOCUS_KEYBOARD
 710     },
 711
 712     {
 713         WmNconfigFile,
 714         WmCConfigFile,
 715         XtRString,
 716         sizeof (String),
 717         XtOffsetOf(WmGlobalData, configFile),
 718         XtRImmediate,
 719         (XtPointer)NULL
 720     },
 721 #ifdef WSM
 722
 723     {
 724         WmNcppCommand,
 725         WmCCppCommand,
 726         XtRString,
 727         sizeof (String),
 728         XtOffsetOf(WmGlobalData, cppCommand),
 729         XtRImmediate,
 730         (XtPointer)NULL
 731     },
 732 #endif /* WSM */
 733
 734     {
 735         WmNdeiconifyKeyFocus,
 736         WmCDeiconifyKeyFocus,
 737         XtRBoolean,
 738         sizeof (Boolean),
 739         XtOffsetOf(WmGlobalData, deiconifyKeyFocus),
 740         XtRImmediate,
 741         (XtPointer)True
 742     },
 743
 744     {
 745         WmNdoubleClickTime,
 746         WmCDoubleClickTime,
 747         XtRInt,
 748         sizeof (int),
 749         XtOffsetOf(WmGlobalData, doubleClickTime),
 750         XtRCallProc,
 751         (XtPointer)_WmMultiClickTimeDefault
 752     },
 753
 754     {
 755         WmNenableWarp,
 756         WmCEnableWarp,
 757         XtRBoolean,
 758         sizeof (Boolean),
 759         XtOffsetOf(WmGlobalData, enableWarp),
 760         XtRImmediate,
 761         (XtPointer)True
 762     },
 763
 764     {
 765         WmNenforceKeyFocus,
 766         WmCEnforceKeyFocus,
 767         XtRBoolean,
 768         sizeof (Boolean),
 769         XtOffsetOf(WmGlobalData, enforceKeyFocus),
 770         XtRImmediate,
 771         (XtPointer)True
 772     },
 773 #ifdef WSM
 774     {
 775         WmNframeExternalShadowWidth,
 776         WmCFrameExternalShadowWidth,
 777         XtRDimension,
 778         sizeof (Dimension),
 779         XtOffsetOf(WmGlobalData, frameExternalShadowWidth),
 780         XtRImmediate,
 781         (XtPointer)2
 782     },
 783 #endif /* WSM */
 784
 785     {
 786         WmNfreezeOnConfig,
 787         WmCFreezeOnConfig,
 788         XtRBoolean,
 789         sizeof (Boolean),
 790         XtOffsetOf(WmGlobalData, freezeOnConfig),
 791         XtRImmediate,
 792         (XtPointer)True
 793     },
 794 #ifdef WSM
 795
 796     {
 797         WmNuseWindowOutline,
 798         WmCUseWindowOutline,
 799         XtRBoolean,
 800         sizeof (Boolean),
 801         XtOffsetOf(WmGlobalData, useWindowOutline),
 802         XtRImmediate,
 803         (XtPointer)False
 804     },
 805 #endif /* WSM */
 806
 807     {
 808         WmNiconAutoPlace,
 809         WmCIconAutoPlace,
 810         XtRBoolean,
 811         sizeof (Boolean),
 812         XtOffsetOf(WmGlobalData, iconAutoPlace),
 813         XtRImmediate,
 814         (XtPointer)True
 815     },
 816 #ifdef WSM
 817     {
 818         WmNiconExternalShadowWidth,
 819         WmCIconExternalShadowWidth,
 820         XtRDimension,
 821         sizeof (Dimension),
 822         XtOffsetOf(WmGlobalData, iconExternalShadowWidth),
 823         XtRImmediate,
 824         (XtPointer)2
 825     },
 826 #endif /* WSM */
 827
 828     {
 829         WmNiconClick,
 830         WmCIconClick,
 831         XtRBoolean,
 832         sizeof (Boolean),
 833         XtOffsetOf(WmGlobalData, iconClick),
 834         XtRImmediate,
 835         (XtPointer)True
 836     },
 837
 838     {
 839         WmNinteractivePlacement,
 840         WmCInteractivePlacement,
 841         XtRBoolean,
 842         sizeof (Boolean),
 843         XtOffsetOf(WmGlobalData, interactivePlacement),
 844         XtRImmediate,
 845         (XtPointer)False
 846     },
 847
 848     {
 849         WmNkeyboardFocusPolicy,
 850         WmCKeyboardFocusPolicy,
 851         WmRKFocusPolicy,
 852         sizeof (int),
 853         XtOffsetOf(WmGlobalData, keyboardFocusPolicy),
 854         XtRImmediate,
 855         (XtPointer)KEYBOARD_FOCUS_EXPLICIT
 856     },
 857
 858     {
 859         WmNlowerOnIconify,
 860         WmCLowerOnIconify,
 861         XtRBoolean,
 862         sizeof (Boolean),
 863         XtOffsetOf(WmGlobalData, lowerOnIconify),
 864         XtRImmediate,
 865         (XtPointer)True
 866     },
 867 #ifdef WSM
 868
 869     {
 870         WmNmarqueeSelectGranularity,
 871         WmCMarqueeSelectGranularity,
 872         XtRInt,
 873         sizeof (int),
 874         XtOffsetOf(WmGlobalData, marqueeSelectGranularity),
 875         XtRImmediate,
 876         (XtPointer)0
 877     },
 878 #endif /* WSM */
 879
 880     {
 881         WmNmoveThreshold,
 882         WmCMoveThreshold,
 883         XtRInt,
 884         sizeof (int),
 885         XtOffsetOf(WmGlobalData, moveThreshold),
 886         XtRImmediate,
 887         (XtPointer)4
 888     },
 889
 890     {
 891         WmNpassButtons,
 892         WmCPassButtons,
 893         XtRBoolean,
 894         sizeof (Boolean),
 895         XtOffsetOf(WmGlobalData, passButtons),
 896         XtRImmediate,
 897         (XtPointer)False
 898     },
 899
 900     {
 901         WmNpassSelectButton,
 902         WmCPassSelectButton,
 903         XtRBoolean,
 904         sizeof (Boolean),
 905         XtOffsetOf(WmGlobalData, passSelectButton),
 906         XtRImmediate,
 907         (XtPointer)True
 908     },
 909
 910     {
 911         WmNpositionIsFrame,
 912         WmCPositionIsFrame,
 913         XtRBoolean,
 914         sizeof (Boolean),
 915         XtOffsetOf(WmGlobalData, positionIsFrame),
 916         XtRImmediate,
 917         (XtPointer)True
 918     },
 919
 920     {
 921         WmNpositionOnScreen,
 922         WmCPositionOnScreen,
 923         XtRBoolean,
 924         sizeof (Boolean),
 925         XtOffsetOf(WmGlobalData, positionOnScreen),
 926         XtRImmediate,
 927         (XtPointer)True
 928     },
 929
 930     {
 931         WmNquitTimeout,
 932         WmCQuitTimeout,
 933         XtRInt,
 934         sizeof (int),
 935         XtOffsetOf(WmGlobalData, quitTimeout),
 936         XtRImmediate,
 937         (XtPointer)1000
 938     },
 939
 940     {
 941         WmNraiseKeyFocus,
 942         WmCRaiseKeyFocus,
 943         XtRBoolean,
 944         sizeof (Boolean),
 945         XtOffsetOf(WmGlobalData, raiseKeyFocus),
 946         XtRImmediate,
 947         (XtPointer)False
 948     },
 949 #ifdef WSM
 950
 951     {
 952         WmNrefreshByClearing,
 953         WmCRefreshByClearing,
 954         XtRBoolean,
 955         sizeof (Boolean),
 956         XtOffsetOf(WmGlobalData, refreshByClearing),
 957         XtRImmediate,
 958         (XtPointer)True
 959     },
 960
 961     {
 962         WmNrootButtonClick,
 963         WmCRootButtonClick,
 964         XtRBoolean,
 965         sizeof (Boolean),
 966         XtOffsetOf(WmGlobalData, rootButtonClick),
 967         XtRImmediate,
 968         (XtPointer)True
 969     },
 970 #endif /* WSM */
 971
 972 #ifndef WSM
 973     {
 974         WmNsessionClientDB,
 975         WmCSessionClientDB,
 976         XtRString,
 977         sizeof(String),
 978         XtOffsetOf(WmGlobalData, sessionClientDB),
 979         XtRImmediate,
 980         (XtPointer)NULL
 981     },
 982 #endif /* ! WSM */
 983
 984     {
 985         WmNshowFeedback,
 986         WmCShowFeedback,
 987         WmRShowFeedback,
 988         sizeof (int),
 989         XtOffsetOf(WmGlobalData, showFeedback),
 990         XtRImmediate,
 991         (XtPointer)(WM_SHOW_FB_DEFAULT)
 992     },
 993
 994     {
 995         WmNstartupKeyFocus,
 996         WmCStartupKeyFocus,
 997         XtRBoolean,
 998         sizeof (Boolean),
 999         XtOffsetOf(WmGlobalData, startupKeyFocus),
1000         XtRImmediate,
1001         (XtPointer)True
1002     },
1003
1004     {
1005         WmNsystemButtonClick,
1006         WmCSystemButtonClick,
1007         XtRBoolean,
1008         sizeof (Boolean),
1009         XtOffsetOf(WmGlobalData, systemButtonClick),
1010         XtRImmediate,
1011         (XtPointer)True
1012     },
1013
1014     {
1015         WmNsystemButtonClick2,
1016         WmCSystemButtonClick2,
1017         XtRBoolean,
1018         sizeof (Boolean),
1019         XtOffsetOf(WmGlobalData, systemButtonClick2),
1020         XtRImmediate,
1021         (XtPointer)True
1022     },
1023 #if defined(PANELIST)
1024     {
1025         WmNuseFrontPanel,
1026         WmCUseFrontPanel,
1027         XtRBoolean,
1028         sizeof (Boolean),
1029         XtOffsetOf(WmGlobalData, useFrontPanel),
1030         XtRImmediate,
1031         (XtPointer)True
1032     },
1033 #endif /* PANELIST */
1034 #ifdef WSM
1035     {
1036         WmNhelpDirectory,
1037         WmCHelpDirectory,
1038         XtRString,
1039         sizeof (String),
1040         XtOffsetOf(WmGlobalData, helpDirectory),
1041         XtRImmediate,
1042         (XtPointer)"DT/Dtwm/"
1043     },
1044
1045 #endif /* WSM */
1046 #ifdef MINIMAL_DT
1047     {
1048         WmNdtLite,
1049         WmCDtLite,
1050         XtRBoolean,
1051         sizeof (Boolean),
1052         XtOffsetOf(WmGlobalData, dtLite),
1053         XtRImmediate,
1054         (XtPointer)False
1055     }
1056 #endif /* MINIMAL_DT */
1057 }; /* END OF wmGlobalResources[] */
1058
1059
1060 /*
1061  * These determine the screens to manage at startup.
1062  * These are broken out to enhance startup performance.
1063  */
1064 XtResource wmGlobalScreenResources[] =
1065 {
1066     {
1067         WmNmultiScreen,
1068         WmCMultiScreen,
1069         XtRBoolean,
1070         sizeof (Boolean),
1071         XtOffsetOf(WmGlobalData, multiScreen),
1072         XtRImmediate,
1073 #ifdef WSM
1074         (XtPointer)True
1075 #else /* WSM */
1076         (XtPointer)False
1077 #endif /* WSM */
1078     },
1079
1080     {
1081         WmNscreens,
1082         WmCScreens,
1083         XtRString,
1084         sizeof (String),
1085         XtOffsetOf(WmGlobalData, screenList),
1086         XtRImmediate,
1087         (XtPointer)NULL
1088     },
1089 #ifdef WSM
1090     {   WmNbackdropDirectories,
1091         WmCBackdropDirectories,
1092         XmRString,
1093         sizeof(char *),
1094         XtOffsetOf(WmGlobalData, backdropDirs),
1095         XmRString,
1096         DEFAULT_BACKDROP_DIR
1097     },
1098 #endif /* WSM */
1099 };
1100
1101
1102 \f
1103 /******************************<->*************************************
1104  *
1105  *  wmStdGlobalResources
1106  *
1107  *
1108  *  Description:
1109  *  -----------
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
1113  *  syntax:
1114  *
1115  *      "Mwm*<resource_identifier>".
1116  *
1117  ******************************<->***********************************/
1118
1119 XtResource wmStdGlobalResources[] =
1120 {
1121
1122     {
1123         WmNbitmapDirectory,
1124         WmCBitmapDirectory,
1125         XtRString,
1126         sizeof (String),
1127         XtOffsetOf(WmGlobalData, bitmapDirectory),
1128         XtRString,
1129         (XtPointer)BITMAPDIR
1130     },
1131
1132     {
1133         WmNconfigFile,
1134         WmCConfigFile,
1135         XtRString,
1136         sizeof (String),
1137         XtOffsetOf(WmGlobalData, configFile),
1138         XtRImmediate,
1139         (XtPointer)NULL
1140     },
1141
1142     {
1143         WmNframeStyle,
1144         WmCFrameStyle,
1145         WmRFrameStyle,
1146         sizeof (FrameStyle),
1147         XtOffsetOf(WmGlobalData, frameStyle),
1148         XtRImmediate,
1149         (XtPointer)WmRECESSED
1150     },
1151
1152     {
1153         WmNiconAutoPlace,
1154         WmCIconAutoPlace,
1155         XtRBoolean,
1156         sizeof (Boolean),
1157         XtOffsetOf(WmGlobalData, iconAutoPlace),
1158         XtRImmediate,
1159         (XtPointer)True
1160     },
1161
1162     {
1163         WmNmoveThreshold,
1164         WmCMoveThreshold,
1165         XtRInt,
1166         sizeof (int),
1167         XtOffsetOf(WmGlobalData, moveThreshold),
1168         XtRImmediate,
1169         (XtPointer)4
1170     },
1171
1172     {
1173         WmNpositionIsFrame,
1174         WmCPositionIsFrame,
1175         XtRBoolean,
1176         sizeof (Boolean),
1177         XtOffsetOf(WmGlobalData, positionIsFrame),
1178         XtRImmediate,
1179         (XtPointer)True
1180     },
1181
1182     {
1183         WmNpositionOnScreen,
1184         WmCPositionOnScreen,
1185         XtRBoolean,
1186         sizeof (Boolean),
1187         XtOffsetOf(WmGlobalData, positionOnScreen),
1188         XtRImmediate,
1189         (XtPointer)True
1190     },
1191
1192     {
1193         WmNquitTimeout,
1194         WmCQuitTimeout,
1195         XtRInt,
1196         sizeof (int),
1197         XtOffsetOf(WmGlobalData, quitTimeout),
1198         XtRImmediate,
1199         (XtPointer)1000
1200     },
1201
1202     {
1203         WmNshowFeedback,
1204         WmCShowFeedback,
1205         WmRShowFeedback,
1206         sizeof (int),
1207         XtOffsetOf(WmGlobalData, showFeedback),
1208         XtRImmediate,
1209         (XtPointer)(WM_SHOW_FB_DEFAULT)
1210     },
1211
1212 };
1213
1214 \f
1215 /******************************<->*************************************
1216  *
1217  *  wmScreenResources
1218  *
1219  *
1220  *  Description:
1221  *  -----------
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:
1225  *
1226  *      "Mwm*screen<#>*<resource_identifier>".
1227  *
1228  ******************************<->***********************************/
1229
1230 XtResource wmScreenResources[] =
1231 {
1232     {
1233         WmNbuttonBindings,
1234         WmCButtonBindings,
1235         XtRString,
1236         sizeof (String),
1237         XtOffsetOf (WmScreenData, buttonBindings),
1238         XtRString,
1239         (XtPointer)defaultButtonBindingsName
1240     },
1241
1242     {
1243         WmNcleanText,
1244         WmCCleanText,
1245         XtRBoolean,
1246         sizeof (Boolean),
1247         XtOffsetOf (WmScreenData, cleanText),
1248         XtRImmediate,
1249         (XtPointer)True
1250     },
1251
1252     {
1253         WmNfeedbackGeometry,
1254         WmCFeedbackGeometry,
1255         XtRString,
1256         sizeof (String),
1257         XtOffsetOf (WmScreenData, feedbackGeometry),
1258         XtRString,
1259         (XtPointer)NULL
1260     },
1261
1262     {
1263         WmNfadeNormalIcon,
1264         WmCFadeNormalIcon,
1265         XtRBoolean,
1266         sizeof (Boolean),
1267         XtOffsetOf (WmScreenData, fadeNormalIcon),
1268         XtRImmediate,
1269         (XtPointer)False
1270     },
1271
1272     {
1273         WmNiconDecoration,
1274         WmCIconDecoration,
1275         WmRIconDecor,
1276         sizeof (int),
1277         XtOffsetOf (WmScreenData, iconDecoration),
1278         XtRImmediate,
1279         (XtPointer)USE_ICON_DEFAULT_APPEARANCE
1280     },
1281
1282 #ifdef WSM
1283     {
1284         WmNiconImageMaximum,
1285         WmCIconImageMaximum,
1286         WmRSize,
1287         sizeof (WHSize),
1288         XtOffsetOf (WmScreenData, iconImageMaximum),
1289         XtRCallProc,
1290         (XtPointer) _WmIconImageMaximumDefault
1291     },
1292 #else /* WSM */
1293     {
1294         WmNiconImageMaximum,
1295         WmCIconImageMaximum,
1296         WmRSize,
1297         sizeof (WHSize),
1298         XtOffsetOf (WmScreenData, iconImageMaximum),
1299         XtRString,
1300         "50x50"
1301     },
1302 #endif /* WSM */
1303
1304     {
1305         WmNiconImageMinimum,
1306         WmCIconImageMinimum,
1307         WmRSize,
1308         sizeof (WHSize),
1309         XtOffsetOf (WmScreenData, iconImageMinimum),
1310         XtRString,
1311         "16x16"
1312     },
1313
1314     {
1315         WmNiconPlacement,
1316         WmCIconPlacement,
1317         WmRIconPlacement,
1318         sizeof (int),
1319         XtOffsetOf (WmScreenData, iconPlacement),
1320         XtRImmediate,
1321         (XtPointer)(ICON_PLACE_LEFT_PRIMARY | ICON_PLACE_BOTTOM_SECONDARY)
1322     },
1323
1324     {
1325         WmNiconPlacementMargin,
1326         WmCIconPlacementMargin,
1327         XtRInt,
1328         sizeof (int),
1329         XtOffsetOf (WmScreenData, iconPlacementMargin),
1330         XtRImmediate,
1331         (XtPointer)-1
1332     },
1333
1334     {
1335         WmNkeyBindings,
1336         WmCKeyBindings,
1337         XtRString,
1338         sizeof (String),
1339         XtOffsetOf (WmScreenData, keyBindings),
1340         XtRString,
1341         (XtPointer)defaultKeyBindingsName
1342     },
1343
1344     {
1345         WmNframeBorderWidth,
1346         WmCFrameBorderWidth,
1347         XtRInt,
1348         sizeof (int),
1349         XtOffsetOf (WmScreenData, frameBorderWidth),
1350         XtRImmediate,
1351         (XtPointer) BIGSIZE
1352     },
1353 #ifndef WSM
1354
1355     {
1356         WmNiconBoxGeometry,
1357         WmCIconBoxGeometry,
1358         XtRString,
1359         sizeof (String),
1360         XtOffsetOf (WmScreenData, iconBoxGeometry),
1361         XtRString,
1362         (XtPointer)NULL
1363     },
1364 #endif /* WSM */
1365
1366     {
1367         WmNiconBoxName,
1368         WmCIconBoxName,
1369         XtRString,
1370         sizeof (String),
1371         XtOffsetOf (WmScreenData, iconBoxName),
1372         XtRString,
1373         (XtPointer)"iconbox"
1374     },
1375
1376     {
1377         WmNiconBoxSBDisplayPolicy,
1378         WmCIconBoxSBDisplayPolicy,
1379         XtRString,
1380         sizeof (String),
1381         XtOffsetOf (WmScreenData, iconBoxSBDisplayPolicy),
1382         XtRString,
1383         (XtPointer)"all"
1384     },
1385
1386     {
1387         WmNiconBoxScheme,
1388         WmCIconBoxScheme,
1389         XtRInt,
1390         sizeof (int),
1391         XtOffsetOf (WmScreenData, iconBoxScheme),
1392         XtRImmediate,
1393         (XtPointer)0
1394     },
1395
1396     {
1397         WmNiconBoxTitle,
1398         WmCIconBoxTitle,
1399         XmRXmString,
1400         sizeof (XmString),
1401         XtOffsetOf (WmScreenData, iconBoxTitle),
1402         XmRXmString,
1403         (XtPointer)NULL
1404     },
1405
1406     {
1407         WmNlimitResize,
1408         WmCLimitResize,
1409         XtRBoolean,
1410         sizeof (Boolean),
1411         XtOffsetOf (WmScreenData, limitResize),
1412         XtRImmediate,
1413         (XtPointer)True
1414     },
1415
1416     {
1417         WmNmaximumMaximumSize,
1418         WmCMaximumMaximumSize,
1419         WmRSize,
1420         sizeof (WHSize),
1421         XtOffsetOf (WmScreenData, maximumMaximumSize),
1422         XtRString,
1423         "0x0"
1424     },
1425
1426     {
1427         WmNresizeBorderWidth,
1428         WmCFrameBorderWidth,
1429         XtRInt,
1430         sizeof (int),
1431         XtOffsetOf (WmScreenData, resizeBorderWidth),
1432         XtRImmediate,
1433         (XtPointer) BIGSIZE
1434     },
1435
1436     {
1437         WmNresizeCursors,
1438         WmCResizeCursors,
1439         XtRBoolean,
1440         sizeof (Boolean),
1441         XtOffsetOf (WmScreenData, resizeCursors),
1442         XtRImmediate,
1443         (XtPointer)True
1444     },
1445
1446 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
1447     {
1448         WmNrootMenu,
1449         WmCRootMenu,
1450         XtRString,
1451         sizeof (String),
1452         XtOffsetOf (WmScreenData, rootMenu),
1453         XtRString,
1454         (XtPointer)builtinRootMenuName
1455     },
1456 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
1457
1458     {
1459         WmNtransientDecoration,
1460         WmCTransientDecoration,
1461         WmRClientDecor,
1462         sizeof (int),
1463         XtOffsetOf (WmScreenData, transientDecoration),
1464         XtRImmediate,
1465         (XtPointer)(WM_DECOR_SYSTEM | WM_DECOR_RESIZEH)
1466     },
1467
1468     {
1469         WmNtransientFunctions,
1470         WmCTransientFunctions,
1471         WmRClientFunction,
1472         sizeof (int),
1473         XtOffsetOf (WmScreenData, transientFunctions),
1474         XtRImmediate,
1475         (XtPointer)(WM_FUNC_ALL & ~(MWM_FUNC_MAXIMIZE | MWM_FUNC_MINIMIZE))
1476     },
1477
1478 #ifdef PANELIST
1479     {
1480         WmNsubpanelDecoration,
1481         WmCSubpanelDecoration,
1482         WmRClientDecor,
1483         sizeof (int),
1484         XtOffsetOf (WmScreenData, subpanelDecoration),
1485         XtRImmediate,
1486         (XtPointer)(WM_DECOR_SYSTEM)
1487     },
1488
1489     {
1490         WmNsubpanelResources,
1491         WmCSubpanelResources,
1492         XtRString,
1493         sizeof (String),
1494         XtOffsetOf (WmScreenData, subpanelResources),
1495         XtRString,
1496         (XtPointer)NULL
1497     },
1498 #endif /* PANELIST */
1499
1500     {
1501         WmNuseIconBox,
1502         WmCUseIconBox,
1503         XtRBoolean,
1504         sizeof (Boolean),
1505         XtOffsetOf (WmScreenData, useIconBox),
1506         XtRImmediate,
1507         (XtPointer)False
1508     },
1509
1510     {
1511         WmNmoveOpaque,
1512         WmCMoveOpaque,
1513         XtRBoolean,
1514         sizeof (Boolean),
1515         XtOffsetOf (WmScreenData, moveOpaque),
1516         XtRImmediate,
1517         (XtPointer)False
1518
1519 #ifdef WSM
1520     },
1521
1522     {
1523         WmNhelpResources,
1524         WmCHelpResources,
1525         XtRString,
1526         sizeof (String),
1527         XtOffsetOf (WmScreenData, helpResources),
1528         XtRString,
1529         (XtPointer)NULL
1530     },
1531
1532     {
1533         WmNinitialWorkspace,
1534         WmCInitialWorkspace,
1535         XtRString,
1536         sizeof (String),
1537         XtOffsetOf (WmScreenData, initialWorkspace),
1538         XtRString,
1539         (XtPointer)NULL
1540     },
1541
1542     {
1543         WmNworkspaceList,
1544         WmCWorkspaceList,
1545         XtRString,
1546         sizeof (String),
1547         XtOffsetOf (WmScreenData, workspaceList),
1548         XtRImmediate,
1549         (XtPointer)NULL
1550     },
1551
1552     {
1553         WmNworkspaceCount,
1554         WmCWorkspaceCount,
1555         XtRInt,
1556         sizeof (int),
1557         XtOffsetOf (WmScreenData, numWorkspaces),
1558         XtRImmediate,
1559         (XtPointer)0
1560 #endif /* WSM */
1561     }
1562
1563 };
1564
1565 \f
1566 /******************************<->*************************************
1567  *
1568  *  wmStdScreenResources
1569  *
1570  *
1571  *  Description:
1572  *  -----------
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:
1577  *
1578  *      "Mwm*screen<#>*<resource_identifier>".
1579  *
1580  ******************************<->***********************************/
1581
1582 XtResource wmStdScreenResources[] =
1583 {
1584     {
1585         WmNframeBorderWidth,
1586         WmCFrameBorderWidth,
1587         XtRInt,
1588         sizeof (int),
1589         XtOffsetOf (WmScreenData, frameBorderWidth),
1590         XtRImmediate,
1591         (XtPointer) BIGSIZE
1592     },
1593
1594 #ifdef WSM
1595     {
1596         WmNiconImageMaximum,
1597         WmCIconImageMaximum,
1598         WmRSize,
1599         sizeof (WHSize),
1600         XtOffsetOf (WmScreenData, iconImageMaximum),
1601         XtRCallProc,
1602         (XtPointer) _WmIconImageMaximumDefault
1603     },
1604 #else /* WSM */
1605     {
1606         WmNiconImageMaximum,
1607         WmCIconImageMaximum,
1608         WmRSize,
1609         sizeof (WHSize),
1610         XtOffsetOf (WmScreenData, iconImageMaximum),
1611         XtRString,
1612         "50x50"
1613     },
1614 #endif /* WSM */
1615
1616     {
1617         WmNiconImageMinimum,
1618         WmCIconImageMinimum,
1619         WmRSize,
1620         sizeof (WHSize),
1621         XtOffsetOf (WmScreenData, iconImageMinimum),
1622         XtRString,
1623         "32x32"
1624     },
1625
1626     {
1627         WmNiconPlacementMargin,
1628         WmCIconPlacementMargin,
1629         XtRInt,
1630         sizeof (int),
1631         XtOffsetOf (WmScreenData, iconPlacementMargin),
1632         XtRImmediate,
1633         (XtPointer)-1
1634     },
1635
1636     {
1637         WmNmaximumMaximumSize,
1638         WmCMaximumMaximumSize,
1639         WmRSize,
1640         sizeof (WHSize),
1641         XtOffsetOf (WmScreenData, maximumMaximumSize),
1642         XtRString,
1643         "0x0"
1644     },
1645
1646     {
1647         WmNresizeBorderWidth,
1648         WmCFrameBorderWidth,
1649         XtRInt,
1650         sizeof (int),
1651         XtOffsetOf (WmScreenData, resizeBorderWidth),
1652         XtRImmediate,
1653         (XtPointer) BIGSIZE
1654     }
1655 };
1656
1657
1658 \f
1659 /******************************<->*************************************
1660  *
1661  *  wmWorkspaceResources
1662  *
1663  *
1664  *  Description:
1665  *  -----------
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:
1669  *
1670  *      "Mwm*[screen<#>*]<workspace>*<resource_identifier>".
1671  *
1672  ******************************<->***********************************/
1673 #ifdef WSM
1674 XtResource wmWorkspaceResources[] =
1675 {
1676     {
1677         WmNiconBoxGeometry,
1678         WmCIconBoxGeometry,
1679         XtRString,
1680         sizeof (String),
1681         XtOffsetOf (WmWorkspaceData, iconBoxGeometry),
1682         XtRString,
1683         (XtPointer)NULL
1684     },
1685
1686     {
1687         WmNtitle,
1688         WmCTitle,
1689         XmRXmString,
1690         sizeof (XmString),
1691         XtOffsetOf (WmWorkspaceData, title),
1692         XmRXmString,
1693         (XtPointer)NULL
1694     }
1695
1696 };
1697 #else /* WSM */
1698 XtResource *wmWorkspaceResources = NULL;
1699 #endif /* WSM */
1700
1701
1702 \f
1703 /******************************<->*************************************
1704  *
1705  *  wmStdWorkspaceResources
1706  *
1707  *
1708  *  Description:
1709  *  -----------
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:
1714  *
1715  *      "Mwm*[screen<#>*]<workspace>*<resource_identifier>".
1716  *
1717  *************************************<->***********************************/
1718
1719 #ifdef WSM
1720 XtResource wmStdWorkspaceResources[] =
1721 {
1722     {
1723         WmNtitle,
1724         WmCTitle,
1725         XmRXmString,
1726         sizeof (XmString),
1727         XtOffsetOf (WmWorkspaceData, title),
1728         XmRXmString,
1729         (XtPointer)NULL
1730     }
1731 };
1732 #else /* WSM */
1733 XtResource *wmStdWorkspaceResources = NULL;
1734 #endif /* WSM */
1735
1736 #ifdef WSM
1737 \f
1738 /*************************************<->*************************************
1739  *
1740  *  wmBackdropResources
1741  *
1742  *
1743  *  Description:
1744  *  -----------
1745  *  This data structure is used in the processing of workspace specific
1746  *  resources that apply to the backdrop.
1747  *
1748  *  These resources are specified with the following syntax:
1749  *
1750  *      "Mwm*[screen*][workspace*]backdrop*<resource_id>:"
1751  *
1752  *  NOTE: The order of these resources is important for correct
1753  *        dynamic processing!!!!
1754  *
1755  *************************************<->***********************************/
1756
1757 XtResource wmBackdropResources[] =
1758 {
1759     {
1760         WmNcolorSetId,
1761         WmCColorSetId,
1762         XtRInt,
1763         sizeof (int),
1764         XtOffsetOf (BackdropData, colorSet),
1765         XtRCallProc,
1766         (XtPointer) _WmBackdropColorSetDefault
1767     },
1768
1769     {
1770         WmNimageBackground,
1771         WmCImageBackground,
1772         XtRPixel,
1773         sizeof (Pixel),
1774         XtOffsetOf (BackdropData, background),
1775         XtRCallProc,
1776         (XtPointer) _WmBackdropBgDefault
1777     },
1778
1779     {
1780         WmNimageForeground,
1781         WmCImageForeground,
1782         XtRPixel,
1783         sizeof (Pixel),
1784         XtOffsetOf (BackdropData, foreground),
1785         XtRCallProc,
1786         (XtPointer) _WmBackdropFgDefault
1787     },
1788
1789     {
1790         WmNimage,
1791         WmCImage,
1792         XtRString,
1793         sizeof (String),
1794         XtOffsetOf (BackdropData, image),
1795         XtRString,
1796         (XtPointer)NULL
1797     },
1798
1799 };
1800
1801 \f
1802 /*************************************<->*************************************
1803  *
1804  *  wmWsPresenceResources
1805  *
1806  *
1807  *  Description:
1808  *  -----------
1809  *  This data structure is used in the processing of specific
1810  *  resources that apply to the WorkspacePresence dialog.
1811  *
1812  *  These resources are specified with the following syntax:
1813  *
1814  *      "Mwm*[screen*][workspace*]workspacePresence*<resource_id>:"
1815  *
1816  *************************************<->***********************************/
1817
1818 XtResource wmWsPresenceResources[] =
1819 {
1820     {
1821         WmNtitle,
1822         WmCTitle,
1823         XmRXmString,
1824         sizeof (XmString),
1825         XtOffsetOf (WsPresenceData, title),
1826         XmRXmString,
1827         (XtPointer)NULL
1828     }
1829 };
1830 #endif /* WSM */
1831
1832 \f
1833 /*************************************<->*************************************
1834  *
1835  *  wmClientResources
1836  *
1837  *
1838  *  Description:
1839  *  -----------
1840  *  This data structure is used in the processing of client specific
1841  *  window manager resources.  These resources are specified with the
1842  *  following syntax:
1843  *
1844  *      "Mwm*<client_name_or_class>*<resource_identifier>"
1845  *
1846  *************************************<->***********************************/
1847
1848 XtResource wmClientResources[] =
1849 {
1850
1851 #ifdef WSM
1852     {
1853         WmNabsentMapBehavior,
1854         WmCAbsentMapBehavior,
1855         WmRAbsentMapBehavior,
1856         sizeof (int),
1857         XtOffsetOf (ClientData, absentMapBehavior),
1858         XtRImmediate,
1859         (XtPointer)(AMAP_BEHAVIOR_ADD)
1860     },
1861 #endif /* WSM */
1862     {
1863         WmNclientDecoration,
1864         WmCClientDecoration,
1865         WmRClientDecor,
1866         sizeof (int),
1867         XtOffsetOf (ClientData, clientDecoration),
1868         XtRImmediate,
1869         (XtPointer)(WM_DECOR_DEFAULT)
1870     },
1871
1872     {
1873         WmNclientFunctions,
1874         WmCClientFunctions,
1875         WmRClientFunction,
1876         sizeof (int),
1877         XtOffsetOf (ClientData, clientFunctions),
1878         XtRImmediate,
1879         (XtPointer)(WM_FUNC_DEFAULT)
1880     },
1881
1882     {
1883         WmNfocusAutoRaise,
1884         WmCFocusAutoRaise,
1885         XtRBoolean,
1886         sizeof (Boolean),
1887         XtOffsetOf (ClientData, focusAutoRaise),
1888         XtRCallProc,
1889         (XtPointer)_WmFocusAutoRaiseDefault
1890     },
1891
1892     {
1893         WmNiconImage,
1894         WmCIconImage,
1895         XtRString,
1896         sizeof (String),
1897         XtOffsetOf (ClientData, iconImage),
1898         XtRString,
1899         (XtPointer)NULL
1900     },
1901
1902     {
1903         WmNiconImageBackground,
1904         WmCIconImageBackground,
1905         XtRPixel,
1906         sizeof (Pixel),
1907         XtOffsetOf (ClientData, iconImageBackground),
1908         XtRCallProc,
1909         (XtPointer)_WmIconImageBDefault
1910     },
1911
1912     {
1913         WmNiconImageForeground,
1914         WmCIconImageForeground,
1915         XtRPixel,
1916         sizeof (Pixel),
1917         XtOffsetOf (ClientData, iconImageForeground),
1918         XtRCallProc,
1919         (XtPointer)_WmIconImageFDefault
1920     },
1921
1922     {
1923         WmNiconImageBottomShadowColor,
1924         WmCIconImageBottomShadowColor,
1925         XtRPixel,
1926         sizeof (Pixel),
1927         XtOffsetOf (ClientData, iconImageBottomShadowColor),
1928         XtRCallProc,
1929         (XtPointer)_WmIconImageBSCDefault
1930     },
1931
1932     {
1933         WmNiconImageBottomShadowPixmap,
1934         WmCIconImageBottomShadowPixmap,
1935         XtRString,
1936         sizeof (String),
1937         XtOffsetOf (ClientData, iconImageBottomShadowPStr),
1938         XtRCallProc,
1939         (XtPointer)_WmIconImageBSPDefault
1940     },
1941
1942     {
1943         WmNiconImageTopShadowColor,
1944         WmCIconImageTopShadowColor,
1945         XtRPixel,
1946         sizeof (Pixel),
1947         XtOffsetOf (ClientData, iconImageTopShadowColor),
1948         XtRCallProc,
1949         (XtPointer)_WmIconImageTSCDefault
1950     },
1951
1952     {
1953         WmNiconImageTopShadowPixmap,
1954         WmCIconImageTopShadowPixmap,
1955         XtRString,
1956         sizeof (String),
1957         XtOffsetOf (ClientData, iconImageTopShadowPStr),
1958         XtRCallProc,
1959         (XtPointer)_WmIconImageTSPDefault
1960     },
1961
1962     {
1963         WmNignoreWMSaveHints,
1964         WmCIgnoreWMSaveHints,
1965         XtRBoolean,
1966         sizeof (Boolean),
1967         XtOffsetOf (ClientData, ignoreWMSaveHints),
1968         XtRImmediate,
1969         (XtPointer)True
1970     },
1971
1972     {
1973         WmNmatteWidth,
1974         WmCMatteWidth,
1975         XtRInt,
1976         sizeof (int),
1977         XtOffsetOf (ClientData, matteWidth),
1978         XtRImmediate,
1979         (XtPointer)0
1980     },
1981
1982     {
1983         WmNmaximumClientSize,
1984         WmCMaximumClientSize,
1985         WmRSize,
1986         sizeof (WHSize),
1987         XtOffsetOf (ClientData, maximumClientSize),
1988         XtRString,
1989         "0x0"
1990     },
1991 #ifdef WSM
1992
1993     {
1994         WmNsecondariesOnTop,
1995         WmCSecondariesOnTop,
1996         XtRBoolean,
1997         sizeof (Boolean),
1998         XtOffsetOf (ClientData, secondariesOnTop),
1999         XtRCallProc,
2000         (XtPointer)_WmSecondariesOnTopDefault
2001     },
2002 #endif /* WSM */
2003
2004     {
2005         WmNsystemMenu,
2006         WmCSystemMenu,
2007         XtRString,
2008         sizeof (String),
2009         XtOffsetOf (ClientData, systemMenu),
2010         XtRString,
2011         (XtPointer)defaultSystemMenuName
2012     },
2013
2014     {
2015         WmNuseClientIcon,
2016         WmCUseClientIcon,
2017         XtRBoolean,
2018         sizeof (Boolean),
2019         XtOffsetOf (ClientData, useClientIcon),
2020         XtRImmediate,
2021 #ifdef WSM
2022         (XtPointer)True
2023 #else
2024         (XtPointer)False
2025 #endif /* WSM */
2026     },
2027
2028     {
2029         WmNusePPosition,
2030         WmCUsePPosition,
2031         WmRUsePPosition,
2032         sizeof (int),
2033         XtOffsetOf (ClientData, usePPosition),
2034         XtRImmediate,
2035         (XtPointer)(USE_PPOSITION_NONZERO)
2036     }
2037
2038 }; /* END OF STRUCTURE wmClientResources */
2039
2040
2041 \f
2042 /*************************************<->*************************************
2043  *
2044  *  wmStdClientResources
2045  *
2046  *
2047  *  Description:
2048  *  -----------
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
2052  *  following syntax:
2053  *
2054  *      "Mwm*<client_name_or_class>*<resource_identifier>"
2055  *
2056  *************************************<->***********************************/
2057
2058 XtResource wmStdClientResources[] =
2059 {
2060
2061     {
2062         WmNiconImage,
2063         WmCIconImage,
2064         XtRString,
2065         sizeof (String),
2066         XtOffsetOf (ClientData, iconImage),
2067         XtRString,
2068         (XtPointer)NULL
2069     },
2070
2071     {
2072         WmNiconImageBackground,
2073         WmCIconImageBackground,
2074         XtRPixel,
2075         sizeof (Pixel),
2076         XtOffsetOf (ClientData, iconImageBackground),
2077         XtRCallProc,
2078         (XtPointer)_WmIconImageBDefault
2079     },
2080
2081     {
2082         WmNiconImageForeground,
2083         WmCIconImageForeground,
2084         XtRPixel,
2085         sizeof (Pixel),
2086         XtOffsetOf (ClientData, iconImageForeground),
2087         XtRCallProc,
2088         (XtPointer)_WmIconImageFDefault
2089     },
2090
2091     {
2092         WmNiconImageBottomShadowColor,
2093         WmCIconImageBottomShadowColor,
2094         XtRPixel,
2095         sizeof (Pixel),
2096         XtOffsetOf (ClientData, iconImageBottomShadowColor),
2097         XtRCallProc,
2098         (XtPointer)_WmIconImageBSCDefault
2099     },
2100
2101     {
2102         WmNiconImageBottomShadowPixmap,
2103         WmCIconImageBottomShadowPixmap,
2104         XtRString,
2105         sizeof (String),
2106         XtOffsetOf (ClientData, iconImageBottomShadowPStr),
2107         XtRCallProc,
2108         (XtPointer)_WmIconImageBSPDefault
2109     },
2110
2111     {
2112         WmNiconImageTopShadowColor,
2113         WmCIconImageTopShadowColor,
2114         XtRPixel,
2115         sizeof (Pixel),
2116         XtOffsetOf (ClientData, iconImageTopShadowColor),
2117         XtRCallProc,
2118         (XtPointer)_WmIconImageTSCDefault
2119     },
2120
2121     {
2122         WmNiconImageTopShadowPixmap,
2123         WmCIconImageTopShadowPixmap,
2124         XtRString,
2125         sizeof (String),
2126         XtOffsetOf (ClientData, iconImageTopShadowPStr),
2127         XtRCallProc,
2128         (XtPointer)_WmIconImageTSPDefault
2129     },
2130
2131     {
2132         WmNmatteWidth,
2133         WmCMatteWidth,
2134         XtRInt,
2135         sizeof (int),
2136         XtOffsetOf (ClientData, matteWidth),
2137         XtRImmediate,
2138         (XtPointer)0
2139     },
2140
2141     {
2142         WmNmaximumClientSize,
2143         WmCMaximumClientSize,
2144         WmRSize,
2145         sizeof (WHSize),
2146         XtOffsetOf (ClientData, maximumClientSize),
2147         XtRString,
2148         "0x0"
2149     },
2150 #ifdef WSM
2151     {
2152         WmNsecondariesOnTop,
2153         WmCSecondariesOnTop,
2154         XtRBoolean,
2155         sizeof (Boolean),
2156         XtOffsetOf (ClientData, secondariesOnTop),
2157         XtRCallProc,
2158         (XtPointer)_WmSecondariesOnTopDefault
2159     },
2160 #endif /* WSM */
2161
2162     {
2163         WmNuseClientIcon,
2164         WmCUseClientIcon,
2165         XtRBoolean,
2166         sizeof (Boolean),
2167         XtOffsetOf (ClientData, useClientIcon),
2168         XtRImmediate,
2169         (XtPointer)False
2170     }
2171 };
2172
2173
2174 \f
2175 /*************************************<->*************************************
2176  *
2177  *  wmClientResourcesM
2178  *
2179  *
2180  *  Description:
2181  *  -----------
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:
2185  *
2186  *      "Mwm*<client_name_or_class>*<resource_identifier>"
2187  *
2188  *************************************<->***********************************/
2189
2190 XtResource wmClientResourcesM[] =
2191 {
2192     {
2193         WmNmatteBackground,
2194         WmCMatteBackground,
2195         XtRPixel,
2196         sizeof (Pixel),
2197         XtOffsetOf (ClientData, matteBackground),
2198         XtRCallProc,
2199         (XtPointer)_WmMatteBDefault
2200     },
2201
2202     {
2203         WmNmatteForeground,
2204         WmCMatteForeground,
2205         XtRPixel,
2206         sizeof (Pixel),
2207         XtOffsetOf (ClientData, matteForeground),
2208         XtRCallProc,
2209         (XtPointer)_WmMatteFDefault
2210     },
2211
2212     {
2213         WmNmatteBottomShadowColor,
2214         WmCMatteBottomShadowColor,
2215         XtRPixel,
2216         sizeof (Pixel),
2217         XtOffsetOf (ClientData, matteBottomShadowColor),
2218         XtRCallProc,
2219         (XtPointer)_WmMatteBSCDefault
2220     },
2221
2222     {
2223         WmNmatteBottomShadowPixmap,
2224         WmCMatteBottomShadowPixmap,
2225         XtRString,
2226         sizeof (String),
2227         XtOffsetOf (ClientData, matteBottomShadowPStr),
2228         XtRCallProc,
2229         (XtPointer)_WmMatteBSPDefault
2230     },
2231
2232     {
2233         WmNmatteTopShadowColor,
2234         WmCMatteTopShadowColor,
2235         XtRPixel,
2236         sizeof (Pixel),
2237         XtOffsetOf (ClientData, matteTopShadowColor),
2238         XtRCallProc,
2239         (XtPointer)_WmMatteTSCDefault
2240     },
2241
2242     {
2243         WmNmatteTopShadowPixmap,
2244         WmCMatteTopShadowPixmap,
2245         XtRString,
2246         sizeof (String),
2247         XtOffsetOf (ClientData, matteTopShadowPStr),
2248         XtRCallProc,
2249         (XtPointer)_WmMatteTSPDefault
2250     }
2251 };
2252
2253
2254 \f
2255 /*************************************<->*************************************
2256  *
2257  *  wmAppearanceResources
2258  *
2259  *
2260  *  Description:
2261  *  -----------
2262  *  This data structure is used in the processing of component appearance
2263  *  resources.  These resources are specified with the following syntax:
2264  *
2265  *      "Mwm*<resource_identifier>"
2266  *      "Mwm*client*<resource_identifier>"
2267  *      "Mwm*icon*<resource_identifier>"
2268  *      "Mwm*feedback*<resource_identifier>"
2269  *
2270  *************************************<->***********************************/
2271
2272 XtResource wmAppearanceResources[] =
2273 {
2274
2275     {
2276         XmNfontList,
2277         XmCFontList,
2278         XmRFontList,
2279         sizeof (XmFontList),
2280         XtOffsetOf (AppearanceData, fontList),
2281         XtRString,
2282         "fixed"
2283     },
2284
2285     {
2286         WmNsaveUnder,
2287         WmCSaveUnder,
2288         XtRBoolean,
2289         sizeof (Boolean),
2290         XtOffsetOf (AppearanceData, saveUnder),
2291         XtRImmediate,
2292         (XtPointer)False
2293     },
2294
2295     {
2296         XtNbackground,
2297         XtCBackground,
2298         XtRPixel,
2299         sizeof (Pixel),
2300         XtOffsetOf (AppearanceData, background),
2301         XtRCallProc,
2302         (XtPointer)_WmBackgroundDefault
2303     },
2304
2305     {
2306         XtNforeground,
2307         XtCForeground,
2308         XtRPixel,
2309         sizeof (Pixel),
2310         XtOffsetOf (AppearanceData, foreground),
2311         XtRCallProc,
2312         (XtPointer)_WmForegroundDefault
2313     },
2314
2315     {
2316         XmNbottomShadowColor,
2317         XtCForeground,
2318         XtRPixel,
2319         sizeof (Pixel),
2320         XtOffsetOf (AppearanceData, bottomShadowColor),
2321         XtRCallProc,
2322         (XtPointer)_WmBottomShadowColorDefault
2323     },
2324
2325     {
2326         XmNbottomShadowPixmap,
2327         XmCBottomShadowPixmap,
2328         XtRString,
2329         sizeof (String),
2330         XtOffsetOf (AppearanceData, bottomShadowPStr),
2331         XtRString,
2332         (XtPointer)NULL
2333     },
2334
2335     {
2336         XmNtopShadowColor,
2337         XtCForeground,
2338         XtRPixel,
2339         sizeof (Pixel),
2340         XtOffsetOf (AppearanceData, topShadowColor),
2341         XtRCallProc,
2342         (XtPointer)_WmTopShadowColorDefault
2343     },
2344
2345     {
2346         XmNbackgroundPixmap,
2347         XmCBackgroundPixmap,
2348         XtRString,
2349         sizeof (String),
2350         XtOffsetOf (AppearanceData, backgroundPStr),
2351         XtRCallProc,
2352         (XtPointer)_WmBackgroundPixmapDefault
2353     },
2354
2355     {
2356         XmNtopShadowPixmap,
2357         XmCTopShadowPixmap,
2358         XtRString,
2359         sizeof (String),
2360         XtOffsetOf (AppearanceData, topShadowPStr),
2361         XtRCallProc,
2362         (XtPointer)_WmTopShadowPixmapDefault
2363     },
2364
2365     {
2366         WmNactiveBackground,
2367         XtCBackground,
2368         XtRPixel,
2369         sizeof (Pixel),
2370         XtOffsetOf (AppearanceData, activeBackground),
2371         XtRCallProc,
2372         (XtPointer)_WmABackgroundDefault
2373     },
2374
2375     {
2376         WmNactiveForeground,
2377         XtCForeground,
2378         XtRPixel,
2379         sizeof (Pixel),
2380         XtOffsetOf (AppearanceData, activeForeground),
2381         XtRCallProc,
2382         (XtPointer)_WmAForegroundDefault
2383     },
2384
2385     {
2386         WmNactiveBottomShadowColor,
2387         XtCForeground,
2388         XtRPixel,
2389         sizeof (Pixel),
2390         XtOffsetOf (AppearanceData, activeBottomShadowColor),
2391         XtRCallProc,
2392         (XtPointer)_WmABottomShadowColorDefault
2393     },
2394
2395     {
2396         WmNactiveBottomShadowPixmap,
2397         XmCBottomShadowPixmap,
2398         XtRString,
2399         sizeof (String),
2400         XtOffsetOf (AppearanceData, activeBottomShadowPStr),
2401         XtRString,
2402         (XtPointer)NULL
2403     },
2404
2405     {
2406         WmNactiveTopShadowColor,
2407         XtCForeground,
2408         XtRPixel,
2409         sizeof (Pixel),
2410         XtOffsetOf (AppearanceData, activeTopShadowColor),
2411         XtRCallProc,
2412         (XtPointer)_WmATopShadowColorDefault
2413     },
2414
2415     {
2416         WmNactiveBackgroundPixmap,
2417         XmCBackgroundPixmap,
2418         XtRString,
2419         sizeof (String),
2420         XtOffsetOf (AppearanceData, activeBackgroundPStr),
2421         XtRCallProc,
2422         (XtPointer)_WmABackgroundPixmapDefault
2423     },
2424
2425     {
2426         WmNactiveTopShadowPixmap,
2427         XmCTopShadowPixmap,
2428         XtRString,
2429         sizeof (String),
2430         XtOffsetOf (AppearanceData, activeTopShadowPStr),
2431         XtRCallProc,
2432         (XtPointer)_WmATopShadowPixmapDefault
2433     }
2434
2435 };
2436
2437
2438 \f
2439 /*************************************<->*************************************
2440  *
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)
2453  *
2454  *
2455  *  Description:
2456  *  -----------
2457  *  These functions are used to generate dynamic defaults for various
2458  *  client-specific appearance related resources.
2459  *
2460  *
2461  *  Inputs:
2462  *  ------
2463  *  widget = this is the parent widget for the wm subpart
2464  *
2465  *  offset = this is the resource offset
2466  *
2467  *  value = this is a pointer to a XrmValue in which to store the result
2468  *
2469  *  _pCD = (static global) pointer to client data associated with resources
2470  *
2471  *
2472  *  Outputs:
2473  *  -------
2474  *  value = default resource value and size
2475  *
2476  *************************************<->***********************************/
2477
2478 void
2479 _WmIconImageFDefault (Widget widget, int offset, XrmValue *value)
2480 {
2481     _WmGetDynamicDefault (widget, WmFGC, 0,
2482         _pCD->iconImageBackground, value);
2483
2484 } /* END OF FUNCTION _WmIconImageFDefault */
2485
2486 void
2487 _WmIconImageBDefault (Widget widget, int offset, XrmValue *value)
2488 {
2489     value->addr = (char *)&(_pCD->pSD->iconAppearance.background);
2490     value->size = sizeof (Pixel);
2491
2492 } /* END OF FUNCTION _WmIconImageBDefault */
2493
2494
2495 void
2496 _WmIconImageBSCDefault (Widget widget, int offset, XrmValue *value)
2497 {
2498     _WmGetDynamicDefault (widget, WmBSC, 0,
2499         _pCD->iconImageBackground, value);
2500
2501 } /* END OF FUNCTION _WmIconImageBSCDefault */
2502
2503
2504 void
2505 _WmIconImageBSPDefault (Widget widget, int offset, XrmValue *value)
2506 {
2507
2508     value->addr = (char *)_pCD->pSD->iconAppearance.bottomShadowPStr;
2509     value->size = sizeof (String);
2510
2511 } /* END OF FUNCTION _WmIconImageBSCDefault */
2512
2513
2514 void
2515 _WmIconImageTSCDefault (Widget widget, int offset, XrmValue *value)
2516 {
2517     _WmGetDynamicDefault (widget, WmTSC, 0,
2518         _pCD->iconImageBackground, value);
2519
2520 } /* END OF FUNCTION _WmIconImageTSCDefault */
2521
2522
2523 void
2524 _WmIconImageTSPDefault (Widget widget, int offset, XrmValue *value)
2525 {
2526
2527     value->addr = (char *)_pCD->pSD->iconAppearance.topShadowPStr;
2528     value->size = sizeof (String);
2529
2530 } /* END OF FUNCTION _WmIconImageTSPDefault */
2531
2532
2533 void
2534 _WmMatteFDefault (Widget widget, int offset, XrmValue *value)
2535 {
2536     _WmGetDynamicDefault (widget, WmFGC, 0,
2537         _pCD->matteBackground, value);
2538
2539 } /* END OF FUNCTION _WmMatteFDefault */
2540
2541
2542 void
2543 _WmMatteBDefault (Widget widget, int offset, XrmValue *value)
2544 {
2545     value->addr = (char *)&(_pCD->pSD->clientAppearance.background);
2546     value->size = sizeof (Pixel);
2547
2548 } /* END OF FUNCTION _WmMatteBDefault */
2549
2550
2551 void
2552 _WmMatteBSCDefault (Widget widget, int offset, XrmValue *value)
2553 {
2554     _WmGetDynamicDefault (widget, WmBSC, 0,
2555         _pCD->matteBackground, value);
2556
2557 } /* END OF FUNCTION _WmMatteBSCDefault */
2558
2559
2560 void
2561 _WmMatteBSPDefault (Widget widget, int offset, XrmValue *value)
2562 {
2563
2564     value->addr = (char *)_pCD->pSD->clientAppearance.bottomShadowPStr;
2565     value->size = sizeof (String);
2566
2567 } /* END OF FUNCTION _WmMatteBSCDefault */
2568
2569
2570 void
2571 _WmMatteTSCDefault (Widget widget, int offset, XrmValue *value)
2572 {
2573     _WmGetDynamicDefault (widget, WmTSC, 0,
2574         _pCD->matteBackground, value);
2575
2576 } /* END OF FUNCTION _WmMatteTSCDefault */
2577
2578
2579 void
2580 _WmMatteTSPDefault (Widget widget, int offset, XrmValue *value)
2581 {
2582
2583     value->addr = (char *)_pCD->pSD->clientAppearance.topShadowPStr;
2584     value->size = sizeof (String);
2585
2586 } /* END OF FUNCTION _WmMatteTSCDefault */
2587
2588
2589 \f
2590 /*************************************<->*************************************
2591  *
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)
2606  *
2607  *
2608  *  Description:
2609  *  -----------
2610  *  These functions are used to generate dynamic defaults for various
2611  *  component appearance related resources (not client-specific).
2612  *
2613  *
2614  *  Inputs:
2615  *  ------
2616  *  widget = this is the parent widget for the wm subpart
2617  *
2618  *  offset = this is the resource offset
2619  *
2620  *  value = this is a pointer to a XrmValue in which to store the result
2621  *
2622  *  _defaultBackground = (static global) default background color (inactive)
2623  *
2624  *  _defaultActiveBackground = (static global) default bg color (active)
2625  *
2626  *  _pAppearanceData = (static global) pointer to resouce set structure
2627  *
2628  *
2629  *  Outputs:
2630  *  -------
2631  *  value = default resource value and size
2632  *
2633  *************************************<->***********************************/
2634
2635 void
2636 _WmBackgroundDefault (Widget widget, int offset, XrmValue *value)
2637 {
2638     _WmGetDynamicDefault (widget, WmBGC, _defaultBackground, 0, value);
2639
2640 } /* END OF FUNCTION _WmBackgroundDefault */
2641
2642
2643 void
2644 _WmForegroundDefault (Widget widget, int offset, XrmValue *value)
2645 {
2646     _WmGetDynamicDefault (widget, WmFGC, 0, _pAppearanceData->background,
2647         value);
2648
2649 } /* END OF FUNCTION _WmForegroundDefault */
2650
2651
2652 void
2653 _WmBackgroundPixmapDefault (Widget widget, int offset, XrmValue *value)
2654 {
2655     static String string;
2656
2657
2658     if ((Monochrome (XtScreen (widget))) ||
2659         (_pAppearanceData->topShadowColor == _pAppearanceData->background))
2660     {
2661         string = (String) _25_foreground;
2662     }
2663     else
2664     {
2665         string = NULL;
2666     }
2667
2668     value->addr = (char *)string;
2669     value->size = sizeof (String);
2670
2671 } /* END OF FUNCTION _WmBackgroundPixmapDefault */
2672
2673
2674 void
2675 _WmBottomShadowColorDefault (Widget widget, int offset, XrmValue *value)
2676 {
2677     _WmGetDynamicDefault (widget, WmBSC, 0, _pAppearanceData->background,
2678         value);
2679
2680 } /* END OF FUNCTION _WmBottomShadowColorDefault */
2681
2682
2683 void
2684 _WmTopShadowColorDefault (Widget widget, int offset, XrmValue *value)
2685 {
2686     _WmGetDynamicDefault (widget, WmTSC, 0, _pAppearanceData->background,
2687         value);
2688
2689 } /* END OF FUNCTION _WmTopShadowColorDefault */
2690
2691
2692 void
2693 _WmTopShadowPixmapDefault (Widget widget, int offset, XrmValue *value)
2694 {
2695     static String string;
2696
2697
2698     if ((Monochrome (XtScreen (widget))) ||
2699         (_pAppearanceData->topShadowColor == _pAppearanceData->background))
2700     {
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))
2706             {
2707                 string = (String) _foreground;
2708             }
2709     }
2710     else
2711     {
2712         string = NULL;
2713     }
2714
2715     value->addr = (char *)string;
2716     value->size = sizeof (String);
2717
2718 } /* END OF FUNCTION _WmTopShadowPixmapDefault */
2719
2720
2721 void
2722 _WmABackgroundDefault (Widget widget, int offset, XrmValue *value)
2723 {
2724     _WmGetDynamicDefault (widget, WmBGC, _defaultActiveBackground, 0, value);
2725
2726 } /* END OF FUNCTION _WmABackgroundDefault */
2727
2728
2729 void
2730 _WmAForegroundDefault (Widget widget, int offset, XrmValue *value)
2731 {
2732     _WmGetDynamicDefault (widget, WmFGC, 0, _pAppearanceData->activeBackground,
2733         value);
2734
2735 } /* END OF FUNCTION _WmAForegroundDefault */
2736
2737 void
2738 _WmABackgroundPixmapDefault (Widget widget, int offset, XrmValue *value)
2739 {
2740     static String string;
2741
2742
2743     if ((Monochrome (XtScreen (widget))) ||
2744         (_pAppearanceData->activeTopShadowColor ==
2745                                         _pAppearanceData->activeBackground))
2746     {
2747         string = (String) _50_foreground;
2748     }
2749     else
2750     {
2751         string = NULL;
2752     }
2753
2754     value->addr = (char *)string;
2755     value->size = sizeof (String);
2756
2757 } /* END OF FUNCTION _WmABackgroundPixmapDefault */
2758
2759 void
2760 _WmABottomShadowColorDefault (Widget widget, int offset, XrmValue *value)
2761 {
2762     _WmGetDynamicDefault (widget, WmBSC, 0, _pAppearanceData->activeBackground,
2763         value);
2764
2765 } /* END OF FUNCTION _WmABottomShadowColorDefault */
2766
2767
2768 void
2769 _WmATopShadowColorDefault (Widget widget, int offset, XrmValue *value)
2770 {
2771     _WmGetDynamicDefault (widget, WmTSC, 0, _pAppearanceData->activeBackground,
2772         value);
2773
2774 } /* END OF FUNCTION _WmATopShadowColorDefault */
2775
2776
2777 void
2778 _WmATopShadowPixmapDefault (Widget widget, int offset, XrmValue *value)
2779 {
2780     static String string;
2781
2782     if ((Monochrome (XtScreen (widget))) ||
2783         (_pAppearanceData->activeTopShadowColor ==
2784                                      _pAppearanceData->activeBackground))
2785     {
2786         /* Fix monochrome 3D appearance */
2787         string = (String) _50_foreground;
2788         if (_pAppearanceData->activeBackgroundPStr != NULL)
2789             if (!strcmp
2790                     (_pAppearanceData->activeBackgroundPStr, _25_foreground) ||
2791                 !strcmp
2792                     (_pAppearanceData->activeBackgroundPStr, _50_foreground))
2793             {
2794                 string = (String) _foreground;
2795             }
2796     }
2797     else
2798     {
2799         string = NULL;
2800     }
2801
2802     value->addr = (char *)string;
2803     value->size = sizeof (String);
2804
2805 } /* END OF FUNCTION _WmATopShadowPixmapDefault */
2806
2807
2808 #ifdef WSM
2809 void
2810 _WmBackdropBgDefault (Widget widget, int offset, XrmValue *value)
2811 {
2812     static Pixel pixValue;
2813     unsigned int colorSetId = (unsigned int) pResWS->backdrop.colorSet;
2814
2815     if (wmGD.statusColorServer == CSERVE_NORMAL)
2816     {
2817         if ((colorSetId == 0) || (colorSetId > XmCO_MAX_NUM_COLORS))
2818         {
2819             colorSetId = (unsigned int) DefaultWsColorSetId (pResWS);
2820         }
2821
2822         switch (pResWS->pSD->colorUse)
2823         {
2824             case XmCO_BLACK_WHITE:
2825                 pixValue = pResWS->pSD->pPixelData[colorSetId-1].bg;
2826                 break;
2827
2828             default:
2829             case XmCO_LOW_COLOR:
2830             case XmCO_MEDIUM_COLOR:
2831             case XmCO_HIGH_COLOR:
2832                 pixValue = pResWS->pSD->pPixelData[colorSetId-1].bs;
2833                 break;
2834         }
2835     }
2836     else
2837     {
2838         /*
2839          *  Color server is unavailable.  Has user specified a colorset?
2840          *
2841          *  If not, go monochrome.
2842          *
2843          */
2844             pixValue = WhitePixel (DISPLAY, pResWS->pSD->screen);
2845     }
2846
2847     /* return the dynamic default */
2848
2849     value->addr = (char *) &pixValue;
2850     value->size = sizeof (Pixel);
2851
2852 } /* END OF FUNCTION _WmBackdropBgDefault */
2853
2854 void
2855 _WmBackdropFgDefault (Widget widget, int offset, XrmValue *value)
2856 {
2857     static Pixel pixValue;
2858     unsigned int colorSetId = (unsigned int) pResWS->backdrop.colorSet;
2859
2860     if (wmGD.statusColorServer == CSERVE_NORMAL)
2861     {
2862         if ((colorSetId == 0) || (colorSetId > XmCO_MAX_NUM_COLORS))
2863         {
2864             colorSetId = (unsigned int) DefaultWsColorSetId (pResWS);
2865         }
2866
2867         switch (pResWS->pSD->colorUse)
2868         {
2869             case XmCO_BLACK_WHITE:
2870                 pixValue = pResWS->pSD->pPixelData[colorSetId-1].fg;
2871                 break;
2872
2873             default:
2874             case XmCO_LOW_COLOR:
2875             case XmCO_MEDIUM_COLOR:
2876             case XmCO_HIGH_COLOR:
2877                 pixValue = pResWS->pSD->pPixelData[colorSetId-1].bg;
2878                 break;
2879         }
2880     }
2881     else
2882     {
2883         /*
2884          *  Color server is unavailable.  Has user specified a colorset?
2885          *
2886          *  If not, go monochrome.
2887          *
2888          */
2889             pixValue = BlackPixel (DISPLAY, pResWS->pSD->screen);
2890     }
2891     value->addr = (char *) &pixValue;
2892     value->size = sizeof (Pixel);
2893
2894 } /* END OF FUNCTION _WmBackdropFgDefault */
2895
2896 void
2897 _WmBackdropColorSetDefault (Widget widget, int offset, XrmValue *value)
2898 {
2899     static unsigned int colorSetId;
2900
2901     if (wmGD.statusColorServer == CSERVE_NORMAL)
2902     {
2903         colorSetId = (unsigned int) DefaultWsColorSetId (pResWS);
2904     }
2905     else
2906     {
2907         colorSetId = 0; /* invalid color set */
2908     }
2909
2910     value->addr = (char *) &colorSetId;
2911     value->size = sizeof (Pixel);
2912
2913 } /* END OF FUNCTION _WmBackdropColorSetIdDefault */
2914
2915 void
2916 _WmIconImageMaximumDefault (Widget widget, int offset, XrmValue *value)
2917 {
2918     static WHSize cval;
2919
2920     if ((pResSD->displayResolutionType == LOW_RES_DISPLAY) ||
2921         (pResSD->displayResolutionType == VGA_RES_DISPLAY))
2922     {
2923         cval.width = 32;
2924         cval.height = 32;
2925     }
2926     else
2927     {
2928         cval.width = 48;
2929         cval.height = 48;
2930     }
2931
2932     value->addr = (char *)  &cval;
2933     value->size = sizeof (WHSize);
2934
2935 } /* END OF FUNCTION _WmIconImageMaximumDefault */
2936
2937 \f
2938 /*************************************<->*************************************
2939  *
2940  *  DefaultWsColorSetId (pWS)
2941  *
2942  *
2943  *  Description:
2944  *  -----------
2945  *  This function returns the default colorSetId for a given workspace
2946  *
2947  *
2948  *  Inputs:
2949  *  ------
2950  *  pWS = ptr to workspace data
2951  *
2952  *  Outputs:
2953  *  -------
2954  *  return = default color set ID.
2955  *
2956  *  "active" and "inactive" color sets are not used.
2957  *
2958  *************************************<->***********************************/
2959
2960 int
2961 DefaultWsColorSetId (WmWorkspaceData *pWS)
2962 {
2963     static int _ws_high_color_map[] = { 3, 5, 6, 7 };
2964 #define        _WS_HIGH_COLOR_COUNT     4
2965     int i;
2966     WmScreenData *pSD;
2967     int iIndex;
2968     int rval = 8;
2969
2970     if (pWS)
2971     {
2972         pSD = pWS->pSD;
2973
2974         iIndex = (int) ((unsigned long)(pWS) -
2975                           (unsigned long)(pSD->pWS))/sizeof(WmWorkspaceData);
2976         if (iIndex < 0)
2977             iIndex = 0; /* bad pWS or pSD, shouldn't get here */
2978
2979         switch (pSD->colorUse)
2980         {
2981             case XmCO_BLACK_WHITE:
2982             case XmCO_LOW_COLOR:
2983                 rval = 1 +
2984                   (pSD->pInactivePixelSet-pSD->pPixelData)/sizeof(XmPixelSet);
2985                 break;
2986
2987             case XmCO_MEDIUM_COLOR:
2988                 rval = HARD_CODED_PRIMARY;
2989                 break;
2990
2991             case XmCO_HIGH_COLOR:
2992                 i = iIndex % _WS_HIGH_COLOR_COUNT;
2993                 rval = _ws_high_color_map[i];
2994                 break;
2995         }
2996     }
2997
2998     return (rval);
2999
3000 } /* END OF FUNCTION DefaultWsColorSetId */
3001
3002 #endif /* WSM */
3003
3004
3005 \f
3006 /*************************************<->*************************************
3007  *
3008  *  _WmFocusAutoRaiseDefault (widget, offset, value)
3009  *
3010  *
3011  *  Description:
3012  *  -----------
3013  *  This function generates a default value for the focusAutoRaise resource.
3014  *
3015  *
3016  *  Inputs:
3017  *  ------
3018  *  widget = this is the parent widget for the wm subpart
3019  *
3020  *  offset = this is the resource offset
3021  *
3022  *  value = this is a pointer to a XrmValue in which to store the result
3023  *
3024  *
3025  *  Outputs:
3026  *  -------
3027  *  value = default resource value and size
3028  *
3029  *************************************<->***********************************/
3030
3031 void
3032 _WmFocusAutoRaiseDefault (Widget widget, int offset, XrmValue *value)
3033 {
3034     static Boolean focusAutoRaise;
3035
3036     if (wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_EXPLICIT)
3037     {
3038         focusAutoRaise = True;
3039     }
3040     else
3041     {
3042         focusAutoRaise = False;
3043     }
3044
3045     value->addr = (char *)&focusAutoRaise;
3046     value->size = sizeof (Boolean);
3047
3048 } /* END OF FUNCTION _WmFocusAutoRaiseDefault */
3049
3050 \f
3051 /*************************************<->*************************************
3052  *
3053  *  _WmMultiClickTimeDefault (widget, offset, value)
3054  *
3055  *
3056  *  Description:
3057  *  -----------
3058  *  This function generates a default value for the doubleClickTime resource.
3059  *  We dynamically default to the XtR4 multiClickTime value.
3060  *
3061  *  Inputs:
3062  *  ------
3063  *  widget = this is the parent widget for the wm subpart
3064  *
3065  *  offset = this is the resource offset
3066  *
3067  *  value = this is a pointer to a XrmValue in which to store the result
3068  *
3069  *  Outputs:
3070  *  -------
3071  *  value = default resource value and size
3072  *
3073  *************************************<->***********************************/
3074
3075 void
3076 _WmMultiClickTimeDefault (Widget widget, int offset, XrmValue *value)
3077 {
3078     static int multiClickTime;
3079
3080     multiClickTime = XtGetMultiClickTime(XtDisplay(widget));
3081
3082     value->addr = (char *)&multiClickTime;
3083     value->size = sizeof (int);
3084
3085 } /* END OF FUNCTION _WmMultiClickTimeDefault */
3086
3087 #ifdef WSM
3088 \f
3089 /*************************************<->*************************************
3090  *
3091  *  _WmSecondariesOnTopDefault (widget, offset, value)
3092  *
3093  *
3094  *  Description:
3095  *  -----------
3096  *  This function generates a default value for the secondariesOnTop
3097  *  resource.
3098  *
3099  *  Inputs:
3100  *  ------
3101  *  widget = this is the parent widget for the wm subpart
3102  *
3103  *  offset = this is the resource offset
3104  *
3105  *  value = this is a pointer to a XrmValue in which to store the result
3106  *
3107  *  Outputs:
3108  *  -------
3109  *  value = default resource value and size
3110  *
3111  *************************************<->***********************************/
3112
3113 void
3114 _WmSecondariesOnTopDefault (Widget widget, int offset, XrmValue *value)
3115 {
3116     static Boolean secondariesOnTop;
3117
3118     /*
3119      * Inherit setting from primary window if this window is
3120      * secondary.
3121      */
3122
3123     if (_pCD->transientLeader != NULL)
3124         secondariesOnTop = _pCD->transientLeader->secondariesOnTop;
3125     else
3126         secondariesOnTop = True;
3127
3128     value->addr = (char *)&secondariesOnTop;
3129     value->size = sizeof (Boolean);
3130
3131 } /* END OF FUNCTION _WmSecondariesOnTopDefault */
3132 #endif /* WSM */
3133
3134
3135 \f
3136 /******************************<->*************************************
3137  *
3138  *  ProcessWmResources ()
3139  *
3140  *
3141  *  Description:
3142  *  -----------
3143  *  This function is used to retrieve and process window manager resources
3144  *  that are not client-specific.
3145  *
3146  *
3147  *  Inputs:
3148  *  ------
3149  *  wmGlobalResources = pointer to wm resource list
3150  *
3151  *
3152  *  Outputs:
3153  *  -------
3154  *  wmGD = (global data filled out with resource values)
3155  *
3156  *************************************<->***********************************/
3157
3158 void
3159 ProcessWmResources (void)
3160 {
3161
3162     /*
3163      * Process the mwm general appearance and behavior resources.  Retrieve
3164      * a limited set of resource values if the window manager is starting
3165      * up with the standard behavior.
3166      */
3167
3168     if (wmGD.useStandardBehavior)
3169     {
3170         XtGetApplicationResources (wmGD.topLevelW, (XtPointer) &wmGD,
3171             wmStdGlobalResources, XtNumber (wmStdGlobalResources), NULL, 0);
3172
3173         /*
3174          * Fill in the standard resource values.
3175          */
3176
3177         SetStdGlobalResourceValues ();
3178     }
3179     else
3180     {
3181         XtGetApplicationResources (wmGD.topLevelW, (XtPointer) &wmGD,
3182             wmGlobalResources, XtNumber (wmGlobalResources), NULL, 0);
3183     }
3184
3185     if (wmGD.autoRaiseDelay < 0)
3186     {
3187        wmGD.autoRaiseDelay = 500;
3188        Warning (((char *)GETMESSAGE(62, 66, "Out of range autoRaiseDelay resource value. Must be non-negative")));
3189     }
3190
3191 } /* END OF FUNCTION ProcessWmResources */
3192
3193
3194 \f
3195 /******************************<->*************************************
3196  *
3197  *  ProcessGlobalScreenResources ()
3198  *
3199  *
3200  *  Description:
3201  *  -----------
3202  *  This function is used to retrieve window manager resources to
3203  *  determine the screens to manage.
3204  *
3205  *
3206  *  Inputs:
3207  *  ------
3208  *  wmGlobalScreenResources = pointer to wm resource list
3209  *
3210  *
3211  *  Outputs:
3212  *  -------
3213  *  wmGD = (global data filled out with resource values)
3214  *
3215  *************************************<->***********************************/
3216
3217 void
3218 ProcessGlobalScreenResources (void)
3219 {
3220     XtGetApplicationResources (wmGD.topLevelW, &wmGD,
3221         wmGlobalScreenResources,
3222         XtNumber (wmGlobalScreenResources), NULL, 0);
3223
3224     if (wmGD.multiScreen)
3225     {
3226         wmGD.numScreens = ScreenCount(DISPLAY);
3227     }
3228     else
3229     {
3230         wmGD.numScreens = 1;
3231     }
3232
3233     if (wmGD.screenList != NULL)
3234     {
3235         ProcessScreenListResource();
3236     }
3237 }
3238
3239
3240 \f
3241 /*************************************<->*************************************
3242  *
3243  *  SetStdGlobalResourceValues ()
3244  *
3245  *
3246  *  Description:
3247  *  -----------
3248  *  This function sets resource data to standard values.  This setting
3249  *  is done in place of getting the values from the user settings in
3250  *  the resource database.
3251  *
3252  *
3253  *  Outputs:
3254  *  -------
3255  *  wmGD = (global data filled out with resource values)
3256  *
3257  *************************************<->***********************************/
3258
3259 void
3260 SetStdGlobalResourceValues (void)
3261 {
3262     wmGD.autoKeyFocus = True;
3263     wmGD.clientAutoPlace = True;
3264     wmGD.colormapFocusPolicy = CMAP_FOCUS_KEYBOARD;
3265     wmGD.deiconifyKeyFocus = True;
3266     wmGD.doubleClickTime = 500;
3267     wmGD.freezeOnConfig = True;
3268     wmGD.iconAutoPlace = True;
3269     wmGD.iconClick = True;
3270     wmGD.interactivePlacement = False;
3271     wmGD.keyboardFocusPolicy = KEYBOARD_FOCUS_EXPLICIT;
3272     wmGD.lowerOnIconify = True;
3273     wmGD.passSelectButton = True;
3274     wmGD.startupKeyFocus = True;
3275     wmGD.systemButtonClick = True;
3276     wmGD.systemButtonClick2 = True;
3277 #if defined(PANELIST)
3278     wmGD.useFrontPanel=False;
3279 #endif /* PANELIST */
3280
3281 } /* END OF FUNCTION SetStdGlobalResourceValues */
3282
3283
3284 \f
3285 /*************************************<->*************************************
3286  *
3287  *  ProcessScreenListResource ()
3288  *
3289  *
3290  *  Description:
3291  *  -----------
3292  *  This processes the names in the screenList resource.
3293  *
3294  *
3295  *  Inputs:
3296  *  ------
3297  *  wmGlobalResources = pointer to wmGD.screenList
3298  *
3299  *
3300  *  Outputs:
3301  *  -------
3302  *  wmGD.screenNames
3303  *
3304  *************************************<->***********************************/
3305
3306 void
3307 ProcessScreenListResource (void)
3308 {
3309     unsigned char *lineP;
3310     unsigned char *string;
3311     int sNum = 0;
3312     int nameCount = 0;
3313
3314     lineP = (unsigned char *)wmGD.screenList;
3315
3316     /*
3317      *  Parse screenList.
3318      */
3319     while (((string = GetString(&lineP)) != NULL) &&
3320            (sNum < ScreenCount(DISPLAY)))
3321     {
3322         if (!(wmGD.screenNames[sNum] = (unsigned char *)
3323             WmRealloc ((char*)wmGD.screenNames[sNum], strlen((char*)string)+1)))
3324         {
3325             ExitWM(WM_ERROR_EXIT_VALUE);
3326         }
3327         else
3328         {
3329             strcpy((char *)wmGD.screenNames[sNum], (char *)string);
3330             nameCount++;
3331             sNum++;
3332         }
3333     }
3334
3335     /*
3336      * If the number of listed screens (sNum) is < screen count, fill in the
3337      * remaining screen names with the name of the first screen specified,
3338      * if such exists.
3339      */
3340     if (nameCount > 0)
3341     {
3342         string = wmGD.screenNames[0];    /* name of the first screen */
3343         while (sNum < ScreenCount(DISPLAY))
3344         {
3345             if (!(wmGD.screenNames[sNum] = (unsigned char *)
3346                 WmRealloc ((char*)wmGD.screenNames[sNum],
3347                                 strlen((char *)string)+1)))
3348             {
3349                 ExitWM(WM_ERROR_EXIT_VALUE);
3350             }
3351             else
3352             {
3353                 strcpy((char *)wmGD.screenNames[sNum], (char *)string);
3354                 sNum++;
3355             }
3356         }
3357     }
3358
3359
3360 } /* END OF FUNCTION ProcessScreenListResource */
3361
3362 #ifdef WSM
3363 \f
3364 /******************************<->*************************************
3365  *
3366  *  ProcessWmColors ()
3367  *
3368  *
3369  *  Description:
3370  *  -----------
3371  *  Retrieve the color sets from the colorserver.
3372  *
3373  *  Inputs:
3374  *  ------
3375  *  none
3376  *
3377  *  Outputs:
3378  *  -------
3379  *  modifies parts of global pixel sets
3380  *
3381  *  Comments:
3382  *  --------
3383  *
3384  ******************************<->***********************************/
3385
3386 void
3387 ProcessWmColors (WmScreenData *pSD)
3388 {
3389     short active, inactive, primary, secondary;
3390
3391     if ((pSD->pPixelData = (XmPixelSet *)
3392             XtMalloc (XmCO_NUM_COLORS * sizeof(XmPixelSet))))
3393     {
3394         /*
3395          *
3396          *
3397          *  ASSUMPTION:  If XmeGetPixelData() returns true,
3398          *  we have a good color server at our disposal.
3399          *
3400          *
3401          */
3402         if (XmeGetPixelData (pSD->screen, &pSD->colorUse,
3403                                 pSD->pPixelData, &active, &inactive,
3404                                 &primary, &secondary))
3405         {
3406             pSD->pActivePixelSet = &(pSD->pPixelData[active]);
3407             pSD->pInactivePixelSet = &(pSD->pPixelData[inactive]);
3408             pSD->pPrimaryPixelSet = &(pSD->pPixelData[primary]);
3409             pSD->pSecondaryPixelSet = &(pSD->pPixelData[secondary]);
3410
3411             /*  Hack here.  The index "4" is the proper array reference.   */
3412             /*  This is used because XmGetPixelData has not been properly  */
3413             /*  updated.                                                   */
3414
3415             pSD->pTextPixelSet = &(pSD->pPixelData[3]);
3416
3417             wmGD.statusColorServer = CSERVE_NORMAL;
3418
3419         }
3420         else
3421         {
3422             XtFree((char *)pSD->pPixelData);
3423             pSD->pPixelData = NULL;
3424             pSD->pActivePixelSet = NULL;
3425             pSD->pInactivePixelSet = NULL;
3426             pSD->pPrimaryPixelSet = NULL;
3427             pSD->pSecondaryPixelSet = NULL;
3428             pSD->pTextPixelSet = NULL;
3429         }
3430     }
3431     else
3432     {
3433         Warning (((char *)GETMESSAGE(62, 22, "Insufficient memory for color data")));
3434         ExitWM (WM_ERROR_EXIT_VALUE);
3435     }
3436
3437 } /* END OF FUNCTION ProcessWmColors */
3438
3439 \f
3440 /******************************<->*************************************
3441  *
3442  *  WriteOutXrmColors ()
3443  *
3444  *
3445  *  Description:
3446  *  -----------
3447  *  Update the XRM database with pixel values from the color server.
3448  *
3449  *  Inputs:
3450  *  ------
3451  *  pSD    = contains pixel sets
3452  *
3453  *  Outputs:
3454  *  -------
3455  *  updated resource database
3456  *
3457  *  Comments:
3458  *  --------
3459  *  N.B.  Must change to write out data on a PER-SCREEN basis.
3460  *        e.g., "Dtwm*0*background"
3461  ******************************<->***********************************/
3462
3463 static void
3464 WriteOutXrmColors (WmScreenData *pSD)
3465 {
3466     XrmDatabase     db;
3467     XrmValue        value;
3468     int             thisScreen = pSD->screen;
3469     XmPixelSet     *tpixset;
3470     XmPixelSet     *spixset;
3471
3472     char *res_class;
3473     String screen_name;
3474
3475     if (MwmBehavior)
3476     {
3477         res_class = WM_RESOURCE_CLASS;
3478     }
3479     else
3480     {
3481         res_class = DT_WM_RESOURCE_CLASS;
3482     }
3483
3484     screen_name = (String) wmGD.screenNames[pSD->screen];
3485
3486     db = XtScreenDatabase(XScreenOfDisplay(DISPLAY, thisScreen));
3487
3488     /** update the clients database with new colors **/
3489     value.size = sizeof(Pixel);
3490
3491     /*
3492      *
3493      *    WM ACTIVE RESOURCES--e.g., for the active frame
3494      *
3495      */
3496     if (pSD->pActivePixelSet)
3497     {
3498         tpixset = pSD->pActivePixelSet;
3499         spixset = pSD->pSecondaryPixelSet;
3500
3501         if (pSD->colorUse == XmCO_BLACK_WHITE)
3502         {
3503             /*
3504              *
3505              *  Limit ourselves here to the client (frame)
3506              *  visuals
3507              *
3508              */
3509
3510             /* activeForeground */
3511             value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3512
3513             XrmPutResource (&db,
3514                 ResCat (res_class, screen_name, WmNactiveForeground,
3515                         NULL), XtRPixel, &value);
3516
3517             /* activeBackground */
3518             value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3519
3520             XrmPutResource (&db,
3521                 ResCat (res_class, screen_name, WmNactiveBackground,
3522                         NULL), XtRPixel, &value);
3523
3524             XrmPutStringResource (&db, ResCat (res_class, screen_name,
3525                      WmNactiveBackgroundPixmap, NULL),
3526                     _foreground);
3527
3528             /* activeTopShadow */
3529             XrmPutStringResource (&db, ResCat (res_class, screen_name,
3530                     WmNactiveTopShadowPixmap, NULL),
3531                 _Dither);
3532
3533             value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3534             XrmPutResource (&db,
3535                 ResCat (res_class, screen_name, WmNactiveTopShadowColor,
3536                         NULL), XtRPixel, &value);
3537
3538             /* activeBottomShadow */
3539             value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3540             XrmPutResource (&db,
3541                 ResCat (res_class, screen_name,
3542                         WmNactiveBottomShadowColor, NULL), XtRPixel, &value);
3543
3544             XrmPutStringResource (&db, ResCat (res_class, screen_name,
3545                     WmNactiveBottomShadowPixmap, NULL),
3546                     _foreground);
3547         }
3548
3549         else /* active colors for non-BW systems */
3550         {
3551             value.addr = (XtPointer) &(tpixset->bg);
3552             XrmPutResource (&db,
3553                 ResCat (res_class, screen_name, WmNactiveBackground, NULL),
3554                 XtRPixel, &value);
3555
3556             value.addr = (XtPointer) &(tpixset->fg);
3557             XrmPutResource (&db,
3558                 ResCat (res_class, screen_name, WmNactiveForeground, NULL),
3559                 XtRPixel, &value);
3560
3561                 value.addr = (XtPointer) &(tpixset->ts);
3562                 XrmPutResource (&db,
3563                     ResCat (res_class, screen_name, WmNactiveTopShadowColor, NULL),
3564                     XtRPixel, &value);
3565
3566                 value.addr = (XtPointer) &(tpixset->bs);
3567                 XrmPutResource (&db,
3568                     ResCat (res_class, screen_name, WmNactiveBottomShadowColor, NULL),
3569                     XtRPixel, &value);
3570
3571                 if (XmCO_DitherTopShadow(DISPLAY, thisScreen, tpixset))
3572                 {
3573                     XrmPutStringResource (&db,
3574                         ResCat (res_class, screen_name, WmNactiveTopShadowPixmap, NULL),
3575                         _Dither);
3576
3577                 }
3578
3579                 if (XmCO_DitherBottomShadow(DISPLAY, thisScreen, tpixset))
3580                 {
3581                     XrmPutStringResource (&db,
3582                         ResCat (res_class, screen_name, WmNactiveBottomShadowPixmap,
3583                                 NULL),
3584                         _Dither);
3585
3586                 }
3587         }
3588     }
3589     /*
3590      *
3591      *    WM INACTIVE colors--e.g., for dialogues
3592      *
3593      */
3594     if (pSD->pInactivePixelSet)
3595     {
3596         tpixset = pSD->pInactivePixelSet;
3597         spixset = pSD->pSecondaryPixelSet;
3598
3599         if (pSD->colorUse == XmCO_BLACK_WHITE)
3600         {
3601
3602            /*
3603             *
3604             *  Set colors/pixmaps for the frames--leave the
3605             *  menus out of it so that their text won't look
3606             *  unsatisfactory against a dithered background.
3607             *
3608             */
3609
3610             /* foreground */
3611             value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3612
3613             XrmPutResource (&db,
3614                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3615                         WmNforeground), XtRPixel, &value);
3616
3617             XrmPutResource (&db,
3618                 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3619                         WmNforeground), XtRPixel, &value);
3620
3621
3622             /* background */
3623             XrmPutStringResource (&db,
3624                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3625                         WmNbackgroundPixmap), _Dither);
3626
3627             XrmPutStringResource (&db,
3628                 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3629                         WmNbackgroundPixmap), _Dither);
3630
3631             value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3632             XrmPutResource (&db,
3633                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3634                         WmNbackground), XtRPixel, &value);
3635
3636             XrmPutResource (&db,
3637                 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3638                         WmNbackground), XtRPixel, &value);
3639
3640             /* topshadow */
3641             XrmPutStringResource (&db,
3642                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3643                         WmNtopShadowPixmap), _foreground);
3644
3645             XrmPutStringResource (&db,
3646                 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3647                         WmNtopShadowPixmap), _foreground);
3648
3649             value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3650             XrmPutResource (&db,
3651                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3652                         WmNtopShadowColor), XtRPixel, &value);
3653
3654             XrmPutResource (&db,
3655                 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3656                         WmNtopShadowColor), XtRPixel, &value);
3657
3658
3659             /* bottomshadow */
3660             XrmPutStringResource (&db,
3661                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3662                         WmNbottomShadowPixmap), _foreground);
3663
3664             XrmPutStringResource (&db,
3665                 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3666                         WmNbottomShadowPixmap), _foreground);
3667
3668             value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3669
3670             XrmPutResource (&db,
3671                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3672                         WmNbottomShadowColor), XtRPixel, &value);
3673
3674             XrmPutResource (&db,
3675                 ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3676                         WmNbottomShadowColor), XtRPixel, &value);
3677
3678                 /*
3679                  *
3680                  *  Ensure that the icon images have a black foreground and
3681                  *  a white background.
3682                  *
3683                  */
3684                     value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
3685
3686                     XrmPutResource (&db,
3687                         ResCat (res_class, screen_name, WmNiconImageForeground,
3688                                 NULL), XtRPixel, &value);
3689
3690                     value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
3691
3692                     XrmPutResource (&db,
3693                         ResCat (res_class, screen_name, WmNiconImageBackground,
3694                                 NULL), XtRPixel, &value);
3695
3696             /* Now deal with XmCO_BLACK_WHITE Menus */
3697
3698             /* XmCO_BLACK_WHITE menu foreground */
3699             value.addr = (XtPointer) &(tpixset->fg);
3700
3701             XrmPutResource (&db,
3702                 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3703                         WmNforeground), XtRPixel, &value);
3704
3705             /* XmCO_BLACK_WHITE menu background */
3706             value.addr = (XtPointer) &(tpixset->bg);
3707
3708             XrmPutResource (&db,
3709                 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3710                         WmNbackground), XtRPixel, &value);
3711
3712             /* XmCO_BLACK_WHITE menu top shadow */
3713
3714             XrmPutStringResource (&db,
3715                 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3716                         WmNtopShadowPixmap), _50_foreground);
3717
3718             /* use foreground color for this pixmap */
3719             value.addr = (XtPointer) &(tpixset->fg);
3720
3721             XrmPutResource (&db,
3722                 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3723                         WmNtopShadowColor), XtRPixel, &value);
3724
3725             /* XmCO_BLACK_WHITE menu bottom shadow */
3726
3727             XrmPutStringResource (&db,
3728                 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3729                         WmNbottomShadowPixmap), _75_foreground);
3730
3731             /* use foreground color for this pixmap */
3732             value.addr = (XtPointer) &(tpixset->fg);
3733
3734             XrmPutResource (&db,
3735                 ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3736                         WmNbottomShadowColor), XtRPixel, &value);
3737
3738             /* Finally, deal with XmCO_BLACK_WHITE Confirm Boxes */
3739
3740             /* XmCO_BLACK_WHITE confirm box foreground */
3741             value.addr = (XtPointer) &(spixset->fg);
3742
3743             XrmPutResource (&db,
3744                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3745                         WmNforeground), XtRPixel, &value);
3746
3747             /* XmCO_BLACK_WHITE confirm box background */
3748             value.addr = (XtPointer) &(spixset->bg);
3749
3750             XrmPutResource (&db,
3751                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3752                         WmNbackground), XtRPixel, &value);
3753
3754             /* XmCO_BLACK_WHITE confirm box top shadow */
3755
3756             XrmPutStringResource (&db,
3757                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3758                         WmNtopShadowPixmap), _50_foreground);
3759
3760             /* use foreground color */
3761             value.addr = (XtPointer) &(spixset->fg);
3762
3763             XrmPutResource (&db,
3764                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3765                         WmNtopShadowColor), XtRPixel, &value);
3766
3767             /* XmCO_BLACK_WHITE confirm box bottom shadow */
3768
3769             XrmPutStringResource (&db,
3770                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3771                         WmNbottomShadowPixmap), _75_foreground);
3772
3773             /* use foreground color */
3774             value.addr = (XtPointer) &(spixset->fg);
3775
3776             XrmPutResource (&db,
3777                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3778                         WmNbottomShadowColor), XtRPixel, &value);
3779
3780             /* use select color for icon box trough color */
3781
3782             value.addr = (XtPointer) &(tpixset->sc);
3783
3784             XrmPutResource (&db,
3785                 ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3786                         XmNtroughColor), XtRPixel, &value);
3787
3788             /* use select color for arm and select colors in dialogs */
3789
3790             value.addr = (XtPointer) &(spixset->sc);
3791
3792             XrmPutResource (&db,
3793                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3794                         XmNarmColor), XtRPixel, &value);
3795
3796             XrmPutResource (&db,
3797                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3798                         XmNselectColor), XtRPixel, &value);
3799
3800             XrmPutResource (&db,
3801                 ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3802                         XmNtroughColor), XtRPixel, &value);
3803         }
3804         else /* inactive colors for non-BW systems */
3805         {
3806                 XmPixelSet     *fpixset;
3807
3808                 /*
3809                  * Set mwm component colors
3810                  */
3811                 value.addr = (XtPointer) &(tpixset->bg);
3812                 XrmPutResource (&db,
3813                     ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3814                             WmNbackground), XtRPixel, &value);
3815
3816                 XrmPutResource (&db,
3817                     ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3818                             WmNbackground), XtRPixel, &value);
3819
3820                 XrmPutResource (&db,
3821                     ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3822                             WmNbackground), XtRPixel, &value);
3823
3824                 value.addr = (XtPointer) &(spixset->bg);
3825                 XrmPutResource (&db,
3826                     ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3827                             WmNbackground), XtRPixel, &value);
3828
3829                 value.addr = (XtPointer) &(tpixset->ts);
3830                 XrmPutResource (&db,
3831                     ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3832                             WmNtopShadowColor), XtRPixel, &value);
3833
3834                 XrmPutResource (&db,
3835                     ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3836                             WmNtopShadowColor), XtRPixel, &value);
3837
3838                 XrmPutResource (&db,
3839                     ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3840                             WmNtopShadowColor), XtRPixel, &value);
3841
3842                 value.addr = (XtPointer) &(spixset->ts);
3843                 XrmPutResource (&db,
3844                     ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3845                             WmNtopShadowColor), XtRPixel, &value);
3846
3847                 value.addr = (XtPointer) &(tpixset->bs);
3848                 XrmPutResource (&db,
3849                     ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3850                             WmNbottomShadowColor), XtRPixel, &value);
3851
3852                 XrmPutResource (&db,
3853                     ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3854                             WmNbottomShadowColor), XtRPixel, &value);
3855
3856                 XrmPutResource (&db,
3857                     ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3858                             WmNbottomShadowColor), XtRPixel, &value);
3859
3860                 value.addr = (XtPointer) &(spixset->bs);
3861                 XrmPutResource (&db,
3862                     ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3863                             WmNbottomShadowColor), XtRPixel, &value);
3864
3865                 value.addr = (XtPointer) &(tpixset->fg);
3866                 XrmPutResource (&db,
3867                     ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3868                             WmNforeground), XtRPixel, &value);
3869
3870                 XrmPutResource (&db,
3871                     ResCat (res_class, screen_name, (char *)ICON_FRAME_PART,
3872                             WmNforeground), XtRPixel, &value);
3873
3874                 XrmPutResource (&db,
3875                     ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3876                             WmNforeground), XtRPixel, &value);
3877
3878                 value.addr = (XtPointer) &(spixset->fg);
3879                 XrmPutResource (&db,
3880                     ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3881                             WmNforeground), XtRPixel, &value);
3882
3883                 /*
3884                  * Set select color only for menus and feedback mwm
3885                  * parts. Client and Icon parts aren't real widgets.
3886                  * Set client trough color for icon box.
3887                  */
3888                 value.addr = (XtPointer) &(tpixset->sc);
3889                 XrmPutResource (&db,
3890                    ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3891                             XmNselectColor), XtRPixel, &value);
3892
3893                 XrmPutResource (&db,
3894                    ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3895                             XmNarmColor), XtRPixel, &value);
3896
3897                 XrmPutResource (&db,
3898                    ResCat (res_class, screen_name, (char *)MENU_ITEM_PART,
3899                             XmNtroughColor), XtRPixel, &value);
3900
3901                 XrmPutResource (&db,
3902                    ResCat (res_class, screen_name, (char *)CLIENT_FRAME_PART,
3903                             XmNtroughColor), XtRPixel, &value);
3904
3905                 XrmPutResource (&db,
3906                    ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3907                             XmNselectColor), XtRPixel, &value);
3908
3909                 value.addr = (XtPointer) &(spixset->sc);
3910                 XrmPutResource (&db,
3911                    ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3912                             XmNarmColor), XtRPixel, &value);
3913
3914                 XrmPutResource (&db,
3915                    ResCat (res_class, screen_name, (char *)FEEDBACK_FRAME_PART,
3916                             XmNtroughColor), XtRPixel, &value);
3917
3918                 /*
3919                  * Set Dtwm dialog colors
3920                  */
3921                 fpixset = pSD->pSecondaryPixelSet;
3922
3923                 value.addr = (XtPointer) &(fpixset->bg);
3924                 XrmPutResource (&db,
3925                     ResCat (res_class, screen_name, XmNbackground, NULL),
3926                     XtRPixel, &value);
3927
3928                 value.addr = (XtPointer) &(fpixset->fg);
3929                 XrmPutResource (&db,
3930                     ResCat (res_class, screen_name, XmNforeground, NULL),
3931                     XtRPixel, &value);
3932
3933                 value.addr = (XtPointer) &(fpixset->ts);
3934                 XrmPutResource (&db,
3935                     ResCat (res_class, screen_name, XmNtopShadowColor, NULL),
3936                     XtRPixel, &value);
3937
3938                 value.addr = (XtPointer) &(fpixset->bs);
3939                 XrmPutResource (&db,
3940                     ResCat (res_class, screen_name, XmNbottomShadowColor, NULL),
3941                     XtRPixel, &value);
3942
3943                 /*
3944                  *
3945                  *  Set up the select color, as for buttons in the dialogue
3946                  *  boxes.
3947                  *
3948                  */
3949                  value.addr = (XtPointer) &(fpixset->sc);
3950                  XrmPutResource (&db,
3951                     ResCat (res_class, screen_name, XmNselectColor, NULL),
3952                         XtRPixel, &value);
3953
3954                  /* value.addr = (XtPointer) &(fpixset->sc); */
3955                  XrmPutResource (&db,
3956                     ResCat (res_class, screen_name, XmNarmColor, NULL),
3957                         XtRPixel, &value);
3958
3959                  /* value.addr = (XtPointer) &(fpixset->sc); */
3960                  XrmPutResource (&db,
3961                     ResCat (res_class, screen_name, XmNtroughColor, NULL),
3962                         XtRPixel, &value);
3963
3964                 if (XmCO_DitherTopShadow(DISPLAY, thisScreen, fpixset))
3965                 {
3966                     XrmPutStringResource (&db,
3967                         ResCat (res_class, screen_name, WmNtopShadowPixmap, NULL),
3968                         _Dither);
3969
3970                     if (pSD->colorUse == XmCO_BLACK_WHITE)
3971                     {
3972                         XrmPutStringResource (&db,
3973                             ResCat (res_class, screen_name,
3974                                 WmNbottomShadowPixmap, NULL),
3975                             _NoDither);
3976
3977                     }
3978                 }
3979
3980                 if (XmCO_DitherBottomShadow(DISPLAY, thisScreen, fpixset))
3981                 {
3982                     XrmPutStringResource (&db,
3983                         ResCat (res_class, screen_name, WmNbottomShadowPixmap, NULL),
3984                         _Dither);
3985
3986                     if (pSD->colorUse == XmCO_BLACK_WHITE)
3987                     {
3988                         XrmPutStringResource (&db,
3989                             ResCat (res_class, screen_name,
3990                                 WmNtopShadowPixmap, NULL),
3991                             _NoDither);
3992
3993                     }
3994                 }
3995
3996                 if (tpixset->bs != tpixset->ts)
3997                 /*
3998                  *
3999                  *   If the inactive bottomshadow and topshadow are
4000                  *   different (i.e., valid), then make the icon image
4001                  *   use those colors.
4002                  */
4003                 {
4004                     value.addr = (XtPointer) &(tpixset->bs);
4005
4006                     XrmPutResource (&db,
4007                         ResCat (res_class, screen_name, WmNiconImageForeground,
4008                                 NULL), XtRPixel, &value);
4009
4010                     value.addr = (XtPointer) &(tpixset->ts);
4011
4012                     XrmPutResource (&db,
4013                         ResCat (res_class, screen_name, WmNiconImageBackground,
4014                                 NULL), XtRPixel, &value);
4015
4016                     value.addr = (XtPointer) &(tpixset->bs);
4017
4018                     XrmPutResource (&db,
4019                         ResCat (res_class, screen_name,
4020                                 WmNiconImageBottomShadowColor,
4021                                 NULL), XtRPixel, &value);
4022
4023                     value.addr = (XtPointer) &(tpixset->ts);
4024
4025                     XrmPutResource (&db,
4026                         ResCat (res_class, screen_name,
4027                                 WmNiconImageTopShadowColor,
4028                                 NULL), XtRPixel, &value);
4029                 }
4030                 else
4031                 /*
4032                  *
4033                  *  Ensure that the icon images have a black foreground and
4034                  *  a white background.
4035                  *
4036                  */
4037                 {
4038                     value.addr = (XtPointer) &(BlackPixel(DISPLAY, pSD->screen));
4039
4040                     XrmPutResource (&db,
4041                         ResCat (res_class, screen_name, WmNiconImageForeground,
4042                                 NULL), XtRPixel, &value);
4043
4044                     value.addr = (XtPointer) &(WhitePixel(DISPLAY, pSD->screen));
4045
4046                     XrmPutResource (&db,
4047                         ResCat (res_class, screen_name, WmNiconImageBackground,
4048                                 NULL), XtRPixel, &value);
4049                 }
4050         }
4051     }
4052
4053
4054     if (pSD->pTextPixelSet)
4055     {
4056        value.addr = (XtPointer) &(pSD->pTextPixelSet->bg);
4057
4058        XrmPutResource (&db,
4059           ResCat (res_class, screen_name, "XmTextField",
4060                   WmNbackground), XtRPixel, &value);
4061
4062        XrmPutResource (&db,
4063           ResCat (res_class, screen_name, "XmText",
4064                   WmNbackground), XtRPixel, &value);
4065     }
4066 }
4067
4068 \f
4069 /******************************<->*************************************
4070  *
4071  *  ResCat (s1,s2,s3,s4)
4072  *
4073  *
4074  *  Description:
4075  *  -----------
4076  *  Cats up to four strings together with '*' in between.
4077  *
4078  *
4079  *  Inputs:
4080  *  ------
4081  *  s1...s4 = pointers to Strings or NULL pointers (no string)
4082  *
4083  *  Outputs:
4084  *  -------
4085  *  Return = pointer to statically allocated string that has
4086  *           the passed in string cat'ed together with '*'s
4087  *           in between.
4088  *
4089  *  Comments:
4090  *  --------
4091  *  Does no limit checking on the static buffer
4092  *
4093  *************************************<->***********************************/
4094
4095 String
4096 ResCat (String s1, String s2, String s3, String s4)
4097 {
4098
4099
4100     int count;
4101
4102     Boolean useResourceClass = True;
4103
4104     wmGD.tmpBuffer[0] = '\0';
4105
4106     count = MAXBUF - 1;
4107
4108     if (s1)
4109     {
4110         if ((MwmBehavior) &&
4111             !strcmp (s1, WM_RESOURCE_CLASS))
4112         /*
4113          *
4114          *  if this routine is called with a class name
4115          *  ("Mwm" or "Dtwm"), then DON'T use it.
4116          *  We want our resources to be written out
4117          *  as:  *iconImageForeground:   <pixel_val>
4118          *
4119          *  as opposed to:  Dtwm*iconImageForeground:   <pixel_val>
4120          *
4121          */
4122         {
4123                 useResourceClass = False;
4124         }
4125         else if (!strcmp (s1, DT_WM_RESOURCE_CLASS))
4126         {
4127                 useResourceClass = False;
4128         }
4129         else
4130         {
4131             strncat((char *)wmGD.tmpBuffer, s1, count);
4132             count -= strlen(s1);
4133         }
4134
4135         if (s2 && (count > 0))
4136         {
4137             strncat ((char *)wmGD.tmpBuffer, "*", count);
4138             count -= 1;
4139             strncat ((char *)wmGD.tmpBuffer, s2, count);
4140             count -= strlen (s2);
4141
4142             if (s3 && (count > 0))
4143             {
4144                 strncat ((char *)wmGD.tmpBuffer, "*", count);
4145                 count -= 1;
4146                 strncat ((char *)wmGD.tmpBuffer, s3, count);
4147                 count -= strlen (s3);
4148
4149                 if (s4)
4150                 {
4151                     strncat ((char *)wmGD.tmpBuffer, "*", count);
4152                     count -= 1;
4153                     strncat ((char *)wmGD.tmpBuffer, s4, count);
4154                 }
4155             }
4156         }
4157     }
4158     return ((String) wmGD.tmpBuffer);
4159
4160 } /* END OF FUNCTION ResCat */
4161
4162
4163 \f
4164 /******************************<->*************************************
4165  *
4166  *  CheckForNoDither (pAD)
4167  *
4168  *
4169  *  Description:
4170  *  -----------
4171  *  Checks for reserved string as pixmap name of dither that indicates
4172  *  no dithering and replaces the string with a NULL.
4173  *
4174  *
4175  *  Inputs:
4176  *  ------
4177  *  pAD   = pointer to appearance data
4178  *
4179  *  Outputs:
4180  *  -------
4181  *  pAD   = pointer to appearance data (may be modified)
4182  *
4183  *  Comments:
4184  *  ---------
4185  *  This check is done to avoid repeated calls to XmGetPixmap when
4186  *  managing windows. XmGetPixmap doesn't cache failures, and the
4187  *  NoDither string should fail every time. We want to prevent
4188  *  XmGetPixmap from call XtResolvePathName to rummage through
4189  *  the file system.
4190  *
4191  *************************************<->***********************************/
4192
4193 void
4194 CheckForNoDither (AppearanceData *pAD)
4195 {
4196     if (pAD->backgroundPStr &&
4197         !strcmp(pAD->backgroundPStr, _NoDither))
4198     {
4199         pAD->backgroundPStr = NULL;
4200     }
4201     if (pAD->bottomShadowPStr &&
4202         !strcmp(pAD->bottomShadowPStr, _NoDither))
4203     {
4204         pAD->bottomShadowPStr = NULL;
4205     }
4206     if (pAD->topShadowPStr &&
4207         !strcmp(pAD->topShadowPStr, _NoDither))
4208     {
4209         pAD->topShadowPStr = NULL;
4210     }
4211     if (pAD->activeBackgroundPStr &&
4212         !strcmp(pAD->activeBackgroundPStr, _NoDither))
4213     {
4214         pAD->activeBackgroundPStr = NULL;
4215     }
4216     if (pAD->activeBottomShadowPStr &&
4217         !strcmp(pAD->activeBottomShadowPStr, _NoDither))
4218     {
4219         pAD->activeBottomShadowPStr = NULL;
4220     }
4221     if (pAD->activeTopShadowPStr &&
4222         !strcmp(pAD->activeTopShadowPStr, _NoDither))
4223     {
4224         pAD->activeTopShadowPStr = NULL;
4225     }
4226
4227 } /* END OF FUNCTION CheckForNoDither */
4228
4229 #endif /* WSM */
4230
4231
4232 \f
4233 /******************************<->*************************************
4234  *
4235  *  ProcessAppearanceResources (pSD)
4236  *
4237  *
4238  *  Description:
4239  *  -----------
4240  *  Retrieve and process the general appearance resources for the mwm
4241  *  subparts: "client", "icon", and "feedback"
4242  *
4243  *
4244  *  Inputs:
4245  *  ------
4246  *  pSD   = pointer to screen data
4247  *
4248  *  Outputs:
4249  *  -------
4250  *  modifies parts of global data wmGD.
4251  *
4252  *  Comments:
4253  *  --------
4254  *  o Changeable GCs are created with XCreateGC. The base GCs used for
4255  *    text output will have clip_masks defined for them later.
4256  *
4257  *
4258  *************************************<->***********************************/
4259
4260 void
4261 ProcessAppearanceResources (WmScreenData *pSD)
4262 {
4263     Widget clientW;             /* dummy widget for resource fetching */
4264     int i;
4265     Arg args[10];
4266
4267
4268     /*
4269      * Get the client subpart resources:
4270      */
4271
4272     /* save info in static globals for dynamic default processing */
4273     _defaultBackground = _defaultColor1;
4274     _defaultActiveBackground = _defaultColor2;
4275     _pAppearanceData = &(pSD->clientAppearance);
4276
4277     (void)XtGetSubresources (pSD->screenTopLevelW,
4278               (XtPointer) &(pSD->clientAppearance),
4279               WmNclient, WmCClient, wmAppearanceResources,
4280               XtNumber (wmAppearanceResources), NULL, 0);
4281 #ifdef WSM
4282     CheckForNoDither (&(pSD->clientAppearance));
4283 #endif /* WSM */
4284
4285
4286     /*
4287      * Process the client resource values:
4288      */
4289
4290     /* make background, top and bottom shadow pixmaps */
4291
4292     MakeAppearanceResources (pSD, &(pSD->clientAppearance), True);
4293
4294
4295     /*
4296      * Get the client.title subpart resources:
4297      */
4298
4299         /* insert "client" widget in hierarchy */
4300
4301     i = 0;
4302     clientW = XtCreateWidget (WmNclient, xmRowColumnWidgetClass,
4303                         pSD->screenTopLevelW, (ArgList) args, i);
4304
4305
4306         /* fetch "client.title" subpart appearance resources */
4307
4308     _pAppearanceData = &(pSD->clientTitleAppearance);
4309
4310     (void)XtGetSubresources (clientW, (XtPointer) &(pSD->clientTitleAppearance),
4311               WmNtitle, WmCTitle, wmAppearanceResources,
4312               XtNumber (wmAppearanceResources), NULL, 0);
4313 #ifdef WSM
4314     CheckForNoDither (&(pSD->clientTitleAppearance));
4315 #endif /* WSM */
4316
4317
4318     /*
4319      * Process the client.title resource values:
4320      */
4321
4322
4323     /*
4324      * check if client title appearance is different from the rest of frame.
4325      */
4326     if (SimilarAppearanceData (&(pSD->clientAppearance),
4327                                &(pSD->clientTitleAppearance)))
4328     {
4329         /* title bar doesn't need special graphic processing */
4330         pSD->decoupleTitleAppearance = False;
4331     }
4332     else
4333     {
4334         /* make background, top and bottom shadow pixmaps */
4335         MakeAppearanceResources (pSD, &(pSD->clientTitleAppearance), True);
4336         pSD->decoupleTitleAppearance = True;
4337     }
4338
4339     XtDestroyWidget (clientW);  /* all done with dummy widget */
4340
4341
4342     /*
4343      * Get the icon subpart resources:
4344      */
4345
4346     _pAppearanceData = &(pSD->iconAppearance);
4347
4348     (void)XtGetSubresources (pSD->screenTopLevelW,
4349               (XtPointer) &(pSD->iconAppearance),
4350               WmNicon, WmCIcon, wmAppearanceResources,
4351               XtNumber (wmAppearanceResources), NULL, 0);
4352 #ifdef WSM
4353     CheckForNoDither (&(pSD->iconAppearance));
4354 #endif /* WSM */
4355
4356
4357     /*
4358      * Process the icon resource values:
4359      */
4360
4361     /* make background, top and bottom shadow pixmaps */
4362
4363     MakeAppearanceResources (pSD, &(pSD->iconAppearance), True);
4364
4365
4366     /*
4367      * Get the feedback subpart resources:
4368      * !!! only get "inactive" resources !!!
4369      */
4370
4371     _defaultBackground = _defaultColor2;
4372     _defaultActiveBackground = _defaultColor2;
4373     _pAppearanceData = &(pSD->feedbackAppearance);
4374
4375     (void)XtGetSubresources (pSD->screenTopLevelW,
4376               (XtPointer) &(pSD->feedbackAppearance),
4377               WmNfeedback, WmCFeedback, wmAppearanceResources,
4378               XtNumber (wmAppearanceResources), NULL, 0);
4379 #ifdef WSM
4380     CheckForNoDither (&(pSD->feedbackAppearance));
4381 #endif /* WSM */
4382
4383     /*
4384      * Process the feedback resource values:
4385      */
4386
4387     /* make background, top and bottom shadow pixmaps */
4388
4389     MakeAppearanceResources (pSD, &(pSD->feedbackAppearance), False);
4390
4391
4392 } /* END OF FUNCTION ProcessAppearanceResources */
4393
4394 \f
4395 /*************************************<->*************************************
4396  *
4397  *  MakeAppearanceResources (pSD, pAData, makeActiveResources)
4398  *
4399  *
4400  *  Description:
4401  *  -----------
4402  *  This function makes top, bottom and background pixmaps for a window
4403  *  manager component.  Inactive and active (if specified) GC's are
4404  *  also made.
4405  *
4406  *
4407  *  Inputs:
4408  *  ------
4409  *  pSD = pointer to screen data
4410  *
4411  *  pAData = pointer to appearance data structure containing resource info
4412  *
4413  *  makeActiveResources = if True then make active resources
4414  *
4415  *  Outputs:
4416  *  -------
4417  *  *pAData = pixmap and GC fields filled out
4418  *
4419  *************************************<->***********************************/
4420
4421 void
4422 MakeAppearanceResources (WmScreenData *pSD, AppearanceData *pAData, Boolean makeActiveResources)
4423 {
4424     Pixel foreground;
4425
4426     /*
4427      * Extract a font from the font list.
4428      */
4429
4430     if (! XmeRenderTableGetDefaultFont(pAData->fontList, &(pAData->font)))
4431     {
4432         sprintf((char *)wmGD.tmpBuffer, ((char *)GETMESSAGE(62, 23, "failed to load font: %.100s\0")), (char*) pAData->fontList);
4433         Warning((char *)wmGD.tmpBuffer);
4434 #if defined(CSRG_BASED) || defined(linux)
4435         /* HACK to try get _some_ font anyway (fontList seems to end up as an empty list on
4436          * some modern systems; investigate) */
4437         pAData->font = XLoadQueryFont(wmGD.display, "fixed");
4438         if (pAData->font == NULL) {
4439             ExitWM(WM_ERROR_EXIT_VALUE);
4440         }
4441 #else
4442         ExitWM(WM_ERROR_EXIT_VALUE);
4443 #endif
4444
4445     }
4446
4447 #ifndef NO_MULTIBYTE
4448     /*
4449      *  Calculate title bar's height and store it in pAData.
4450      */
4451     pAData->titleHeight = (pAData->font)->ascent + (pAData->font)->descent
4452         + WM_TITLE_BAR_PADDING;
4453 #endif
4454
4455
4456     /*
4457      * Make standard (inactive) appearance resources.
4458      */
4459
4460     /* background pixmap */
4461
4462     if (pAData->backgroundPStr)
4463     {
4464         pAData->backgroundPixmap = XmGetPixmap (
4465                                        ScreenOfDisplay (DISPLAY,
4466                                            pSD->screen),
4467                                        pAData->backgroundPStr,
4468                                        pAData->foreground,
4469                                        pAData->background);
4470
4471         if (pAData->backgroundPixmap == XmUNSPECIFIED_PIXMAP)
4472         {
4473             pAData->backgroundPixmap = (Pixmap)NULL;
4474         }
4475     }
4476     else
4477     {
4478         pAData->backgroundPixmap = (Pixmap)NULL;
4479     }
4480
4481     /* top shadow pixmap */
4482
4483     if (pAData->topShadowPStr)
4484     {
4485         /*
4486          * Make sure top shadow color is not the same as background
4487          * otherwise the wrong pixmap will be generated.
4488          */
4489         if (pAData->topShadowColor != pAData->background)
4490             foreground = pAData->topShadowColor;
4491         else
4492             foreground = pAData->foreground;
4493         pAData->topShadowPixmap = XmGetPixmap (
4494                                        ScreenOfDisplay (DISPLAY,
4495                                            pSD->screen),
4496                                        pAData->topShadowPStr,
4497                                        foreground,
4498                                        pAData->background);
4499
4500         if (pAData->topShadowPixmap == XmUNSPECIFIED_PIXMAP)
4501         {
4502             pAData->topShadowPixmap = (Pixmap)NULL;
4503         }
4504     }
4505     else
4506     {
4507         pAData->topShadowPixmap = (Pixmap)NULL;
4508     }
4509
4510
4511     /* bottom shadow pixmap */
4512
4513     if (pAData->bottomShadowPStr)
4514     {
4515         /*
4516          * Make sure bottom shadow color is not the same as background
4517          * otherwise the wrong pixmap will be generated.
4518          */
4519         if (pAData->bottomShadowColor != pAData->background)
4520             foreground = pAData->bottomShadowColor;
4521         else
4522             foreground = pAData->foreground;
4523         pAData->bottomShadowPixmap = XmGetPixmap (
4524                                        ScreenOfDisplay (DISPLAY,
4525                                            pSD->screen),
4526                                        pAData->bottomShadowPStr,
4527                                        foreground,
4528                                        pAData->background);
4529
4530         if (pAData->bottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
4531         {
4532             pAData->bottomShadowPixmap = (Pixmap)NULL;
4533         }
4534     }
4535     else
4536     {
4537         pAData->bottomShadowPixmap = (Pixmap)NULL;
4538     }
4539
4540     /* inactive appearance GC */
4541
4542     GetAppearanceGCs (pSD,
4543                       pAData->foreground,
4544                       pAData->background,
4545                       pAData->font,
4546                       pAData->backgroundPixmap,
4547                       pAData->topShadowColor,
4548                       pAData->topShadowPixmap,
4549                       pAData->bottomShadowColor,
4550                       pAData->bottomShadowPixmap,
4551                       &(pAData->inactiveGC),
4552                       &(pAData->inactiveTopShadowGC),
4553                       &(pAData->inactiveBottomShadowGC));
4554
4555
4556
4557     /*
4558      * Make active apppearance resources if specified.
4559      */
4560
4561     if (!makeActiveResources)
4562     {
4563         return;
4564     }
4565
4566     /* active background pixmap */
4567
4568     if (pAData->activeBackgroundPStr)
4569     {
4570         pAData->activeBackgroundPixmap = XmGetPixmap (
4571                                              ScreenOfDisplay (DISPLAY,
4572                                                  pSD->screen),
4573                                              pAData->activeBackgroundPStr,
4574                                              pAData->activeForeground,
4575                                              pAData->activeBackground);
4576
4577         if (pAData->activeBackgroundPixmap == XmUNSPECIFIED_PIXMAP)
4578         {
4579             pAData->activeBackgroundPixmap = (Pixmap)NULL;
4580         }
4581     }
4582     else
4583     {
4584         pAData->activeBackgroundPixmap = (Pixmap)NULL;
4585     }
4586
4587     /* active top shadow pixmap */
4588
4589     if (pAData->activeTopShadowPStr)
4590     {
4591         pAData->activeTopShadowPixmap = XmGetPixmap (
4592                                             ScreenOfDisplay (DISPLAY,
4593                                                 pSD->screen),
4594                                             pAData->activeTopShadowPStr,
4595                                             pAData->activeTopShadowColor,
4596                                             pAData->activeBackground);
4597
4598         if (pAData->activeTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
4599         {
4600             pAData->activeTopShadowPixmap = (Pixmap)NULL;
4601         }
4602     }
4603     else
4604     {
4605         pAData->activeTopShadowPixmap = (Pixmap)NULL;
4606     }
4607
4608
4609     /* active bottom shadow pixmap */
4610
4611     if (pAData->activeBottomShadowPStr)
4612     {
4613         pAData->activeBottomShadowPixmap = XmGetPixmap (
4614                                                ScreenOfDisplay (DISPLAY,
4615                                                    pSD->screen),
4616                                                pAData->activeBottomShadowPStr,
4617                                                pAData->activeBottomShadowColor,
4618                                                pAData->activeBackground);
4619
4620         if (pAData->activeBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
4621         {
4622             pAData->activeBottomShadowPixmap = (Pixmap)NULL;
4623         }
4624     }
4625     else
4626     {
4627         pAData->activeBottomShadowPixmap = (Pixmap)NULL;
4628     }
4629
4630     /* inactive appearance GC */
4631
4632     GetAppearanceGCs (pSD,
4633                       pAData->activeForeground,
4634                       pAData->activeBackground,
4635                       pAData->font,
4636                       pAData->activeBackgroundPixmap,
4637                       pAData->activeTopShadowColor,
4638                       pAData->activeTopShadowPixmap,
4639                       pAData->activeBottomShadowColor,
4640                       pAData->activeBottomShadowPixmap,
4641                       &(pAData->activeGC),
4642                       &(pAData->activeTopShadowGC),
4643                       &(pAData->activeBottomShadowGC));
4644
4645
4646 } /* END OF FUNCTION MakeAppearanceResources */
4647
4648
4649 \f
4650 /*************************************<->*************************************
4651  *
4652  *  GetAppearanceGCs (pSD, fg, bg, font, bg_pixmap, ts_color,
4653  *                    ts_pixmap, bs_color, bs_pixmap, pGC, ptsGC, pbsGC)
4654  *
4655  *
4656  *  Description:
4657  *  -----------
4658  *  Creates the appearance GCs for any of the icon, client, or feedback
4659  *  resources.
4660  *
4661  *
4662  *  Inputs:
4663  *  ------
4664  *  pSD         - pointer to screen data
4665  *  fg          - base foreground color
4666  *  bg          - base background color
4667  *  font        - font
4668  *  bg_pixmap   - background pixmap
4669  *  ts_color    - top shadow color
4670  *  ts_pixmap   - top shadow pixmap
4671  *  bs_color    - bottom shadow color
4672  *  bs_pixmap   - bottom shadow pixmap
4673  *  pGC         - pointer to location to receive base GC
4674  *  ptsGC       - pointer to location to receive top shadow GC
4675  *  pbsGC       - pointer to location to receive bottom shadow GC
4676  *
4677  *  Outputs:
4678  *  -------
4679  *  *pGC        - base GC
4680  *  *ptsGC      - top shadow GC
4681  *  *pbsGC      - bottom shadow GC
4682  *
4683  *
4684  *  Comments:
4685  *  --------
4686  *
4687  *
4688  *************************************<->***********************************/
4689
4690 void
4691 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)
4692 {
4693     XGCValues gcv;
4694     XtGCMask  mask;
4695
4696
4697     /*
4698      * Get base GC
4699      */
4700
4701     mask = GCForeground | GCBackground | GCFont;
4702     gcv.foreground = fg;
4703     gcv.background = bg;
4704     gcv.font = font->fid;
4705
4706     if (bg_pixmap)
4707     {
4708         mask |= GCTile;
4709         gcv.tile = bg_pixmap;
4710     }
4711
4712     *pGC = XCreateGC (DISPLAY, pSD->rootWindow, mask, &gcv);
4713
4714     /*
4715      * !!! Need GC error detection !!!
4716      */
4717
4718     *ptsGC = GetHighlightGC (pSD, ts_color, bg, ts_pixmap);
4719
4720     *pbsGC = GetHighlightGC (pSD, bs_color, bg, bs_pixmap);
4721
4722 } /* END OF FUNCTION GetAppearanceGCs */
4723
4724
4725
4726 \f
4727 /*************************************<->*************************************
4728  *
4729  *  ProcessScreenResources (pSD, screenName)
4730  *
4731  *
4732  *  Description:
4733  *  -----------
4734  *  This function retrieves resources that are screen specific.  If the
4735  *  window manager is providing standard behavior then retrieve the limited
4736  *  set of resources that don't affect standard behavior and set the
4737  *  values of the other resources to the standard values.
4738  *
4739  *
4740  *  Inputs:
4741  *  ------
4742  *  pSD = pointer to screen data
4743  *  screenName = name of screen
4744  *
4745  *
4746  *  Outputs:
4747  *  -------
4748  *  pSD = resource data for screen is set
4749  *
4750  *
4751  *  Comments:
4752  *  --------
4753  *  o Gets subresources based on workspace name
4754  *
4755  *************************************<->***********************************/
4756
4757 void
4758 ProcessScreenResources (WmScreenData *pSD, unsigned char *screenName)
4759 {
4760 #ifdef WSM
4761     pResSD = pSD;       /* save current screen data for default processing */
4762     /*
4763      * Use the screen name (e.g., "0") as the default resource name.
4764      */
4765
4766     if (wmGD.useStandardBehavior)
4767     {
4768         XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4769             (String) screenName,
4770             (String) screenName,
4771             wmStdScreenResources,
4772             XtNumber (wmStdScreenResources), NULL, 0);
4773
4774         /*
4775          * Fill in the standard resource values.
4776          */
4777
4778         SetStdScreenResourceValues (pSD);
4779     }
4780     else
4781     {
4782         XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4783             (String)screenName, (String) screenName,
4784             wmScreenResources,
4785             XtNumber (wmScreenResources), NULL, 0);
4786
4787 #ifndef MOTIF_ONE_DOT_ONE
4788         pSD->moveOpaque = (((XmScreen) XmGetXmScreen(XtScreen(pSD->screenTopLevelW)))
4789                            -> screen.moveOpaque);
4790 #endif
4791     }
4792
4793 #else /* WSM */
4794     /*
4795      * Retrieve screen specific resources.
4796      */
4797
4798     if (wmGD.useStandardBehavior)
4799     {
4800         XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4801             (String) screenName, (String)screenName, wmStdScreenResources,
4802             XtNumber (wmStdScreenResources), NULL, 0);
4803
4804         /*
4805          * Fill in the standard resource values.
4806          */
4807
4808         SetStdScreenResourceValues (pSD);
4809     }
4810     else
4811     {
4812         XtGetSubresources (wmGD.topLevelW, (XtPointer) pSD,
4813             (String)screenName, (String)screenName, wmScreenResources,
4814             XtNumber (wmScreenResources), NULL, 0);
4815
4816 #ifndef MOTIF_ONE_DOT_ONE
4817         pSD->moveOpaque =(((XmScreen) XmGetXmScreen(XtScreen(pSD->screenTopLevelW)))
4818                           -> screen.moveOpaque);
4819 #endif
4820     }
4821 #endif /* WSM */
4822
4823     /*
4824      * Do some additional processing on the window manager resource values.
4825      */
4826
4827
4828     if (pSD->iconImageMinimum.width < ICON_IMAGE_MIN_WIDTH)
4829     {
4830         pSD->iconImageMinimum.width = ICON_IMAGE_MIN_WIDTH;
4831     }
4832     else if (pSD->iconImageMinimum.width > ICON_IMAGE_MAX_WIDTH)
4833     {
4834         pSD->iconImageMinimum.width = ICON_IMAGE_MAX_WIDTH;
4835     }
4836
4837     if (pSD->iconImageMinimum.height < ICON_IMAGE_MIN_HEIGHT)
4838     {
4839         pSD->iconImageMinimum.height = ICON_IMAGE_MIN_HEIGHT;
4840     }
4841     else if (pSD->iconImageMinimum.height > ICON_IMAGE_MAX_HEIGHT)
4842     {
4843         pSD->iconImageMinimum.height = ICON_IMAGE_MAX_HEIGHT;
4844     }
4845
4846     if (pSD->iconImageMaximum.width < pSD->iconImageMinimum.width)
4847     {
4848         pSD->iconImageMaximum.width = pSD->iconImageMinimum.width;
4849     }
4850     else if (pSD->iconImageMaximum.width > ICON_IMAGE_MAX_WIDTH)
4851     {
4852         pSD->iconImageMaximum.width = ICON_IMAGE_MAX_WIDTH;
4853     }
4854
4855     if (pSD->iconImageMaximum.height < pSD->iconImageMinimum.height)
4856     {
4857         pSD->iconImageMaximum.height = pSD->iconImageMinimum.height;
4858     }
4859     else if (pSD->iconImageMaximum.height > ICON_IMAGE_MAX_HEIGHT)
4860     {
4861         pSD->iconImageMaximum.height = ICON_IMAGE_MAX_HEIGHT;
4862     }
4863
4864     if (pSD->iconPlacementMargin > MAXIMUM_ICON_MARGIN)
4865     {
4866         pSD->iconPlacementMargin = MAXIMUM_ICON_MARGIN;
4867     }
4868
4869     if (pSD->maximumMaximumSize.width <= 0)
4870     {
4871         pSD->maximumMaximumSize.width =
4872                         2 * DisplayWidth (DISPLAY, pSD->screen);
4873     }
4874
4875     if (pSD->maximumMaximumSize.height <= 0)
4876     {
4877         pSD->maximumMaximumSize.height =
4878                         2 * DisplayHeight (DISPLAY, pSD->screen);
4879     }
4880
4881     /*
4882      * Set the icon appearance default based on whether or not the icon box
4883      * is being used.
4884      */
4885
4886     if (pSD->iconDecoration & USE_ICON_DEFAULT_APPEARANCE)
4887     {
4888         if (pSD->useIconBox)
4889         {
4890             pSD->iconDecoration = ICON_APPEARANCE_ICONBOX;
4891         }
4892         else
4893         {
4894             pSD->iconDecoration = ICON_APPEARANCE_STANDALONE;
4895         }
4896     }
4897
4898     /*
4899      * If resizeBorderWidth or frameBorderWidth is unset then initialize
4900      * to dynamic defaults.
4901      */
4902
4903     if ((pSD->resizeBorderWidth == (Dimension)BIGSIZE) ||
4904         (pSD->frameBorderWidth == (Dimension)BIGSIZE))
4905     {
4906         double xres, yres, avg_res;
4907
4908         xres = (((double) DisplayWidth(DISPLAY, pSD->screen)) /
4909                 ((double) DisplayWidthMM(DISPLAY, pSD->screen)));
4910         yres = (((double) DisplayHeight(DISPLAY, pSD->screen)) /
4911                 ((double) DisplayHeightMM(DISPLAY, pSD->screen)));
4912
4913         avg_res = (xres + yres) / 2.0;
4914
4915         /* Multiply times width in mm (avg. 7-8 pixels) */
4916         if (pSD->resizeBorderWidth == (Dimension)BIGSIZE)
4917         {
4918             pSD->resizeBorderWidth = (int) (avg_res * 2.2);
4919
4920             /* limit size because big borders look ugly */
4921 #ifndef WSM
4922             if (wmGD.frameStyle == WmSLAB)
4923             {
4924 #endif /* WSM */
4925                 if (pSD->resizeBorderWidth > 6) pSD->resizeBorderWidth = 6;
4926 #ifndef WSM
4927             }
4928             else
4929             {
4930                 if (pSD->resizeBorderWidth > 7) pSD->resizeBorderWidth = 7;
4931             }
4932 #endif /* WSM */
4933         }
4934
4935         /* Multiply times width in mm (avg. 5-6 pixels) */
4936         if (pSD->frameBorderWidth == (Dimension)BIGSIZE)
4937         {
4938             pSD->frameBorderWidth = (int) (avg_res * 1.7);
4939
4940             /* limit size because big borders look ugly */
4941             if (wmGD.frameStyle == WmSLAB)
4942             {
4943                 if (pSD->frameBorderWidth > 4) pSD->frameBorderWidth = 4;
4944             }
4945             else
4946             {
4947                 if (pSD->frameBorderWidth > 5) pSD->frameBorderWidth = 5;
4948             }
4949         }
4950     }
4951
4952
4953     pSD->externalBevel = FRAME_EXTERNAL_SHADOW_WIDTH;
4954     pSD->joinBevel = FRAME_INTERNAL_SHADOW_WIDTH;
4955     if (pSD->frameBorderWidth <
4956            (pSD->externalBevel + MIN_INTERNAL_BEVEL))
4957     {
4958         pSD->frameBorderWidth =
4959             pSD->externalBevel + MIN_INTERNAL_BEVEL;
4960     }
4961     else if (pSD->frameBorderWidth > MAXIMUM_FRAME_BORDER_WIDTH)
4962     {
4963         pSD->frameBorderWidth = MAXIMUM_FRAME_BORDER_WIDTH;
4964     }
4965
4966     if (pSD->resizeBorderWidth <
4967            (pSD->externalBevel + MIN_INTERNAL_BEVEL))
4968     {
4969         pSD->resizeBorderWidth =
4970             (pSD->externalBevel + MIN_INTERNAL_BEVEL);
4971     }
4972     else if (pSD->resizeBorderWidth > MAXIMUM_FRAME_BORDER_WIDTH)
4973     {
4974         pSD->resizeBorderWidth = MAXIMUM_FRAME_BORDER_WIDTH;
4975     }
4976 #ifdef WSM
4977
4978     /*
4979      * Update the resource database.
4980      */
4981     WriteOutXrmColors (pSD);
4982
4983 #endif /* WSM */
4984
4985     /*
4986      * Process the component appearance resources for client,
4987      * icon and feedback parts of mwm.
4988      */
4989
4990      ProcessAppearanceResources (pSD);
4991
4992 #ifdef WSM
4993     /*
4994      * Process the workspace list and name the initial
4995      * workspaces
4996      */
4997
4998      ProcessWorkspaceList (pSD);
4999
5000      /*
5001       * Process default backdrop images to be used in low-color
5002       * situations
5003       */
5004      ProcessDefaultBackdropImages (pSD);
5005
5006 #endif /* WSM */
5007     /*
5008      * Save the default icon pixmap in global data. We'll use it only
5009      * as a last resort.
5010      */
5011
5012     pSD->builtinIconPixmap =
5013         XCreateBitmapFromData (DISPLAY, pSD->rootWindow, (char *)iImage_bits,
5014                                        iImage_width, iImage_height);
5015
5016 } /* END OF FUNCTION ProcessScreenResources */
5017
5018 #ifdef WSM
5019 \f
5020 /*************************************<->*************************************
5021  *
5022  *  ProcessDefaultBackdropImages (pSD)
5023  *
5024  *
5025  *  Description:
5026  *  -----------
5027  *  This function processes the default backdrop images to be used
5028  *  in low color or black and white workspaces.
5029  *
5030  *
5031  *  Inputs:
5032  *  ------
5033  *  pSD = pointer to screen data
5034  *
5035  *
5036  *  Outputs:
5037  *  -------
5038  *  pSD = resource data for screen is set
5039  *
5040  *
5041  *  Comments:
5042  *  --------
5043  *
5044  *************************************<->***********************************/
5045
5046 void
5047 ProcessDefaultBackdropImages (WmScreenData *pSD)
5048 {
5049 } /* END OF FUNCTION ProcessDefaultBackdropImages */
5050
5051
5052 \f
5053 /*************************************<->*************************************
5054  *
5055  *  ProcessWorkspaceList (pSD)
5056  *
5057  *
5058  *  Description:
5059  *  -----------
5060  *  This function processes the workspaceCount and workspaceList
5061  *  resources for a particular screen. It creates space for the initial
5062  *  workspace data structures and adds in names for workspaces.
5063  *
5064  *
5065  *  Inputs:
5066  *  ------
5067  *  pSD = pointer to screen data
5068  *
5069  *
5070  *  Outputs:
5071  *  -------
5072  *  pSD = resource data for screen is set
5073  *
5074  *
5075  *  Comments:
5076  *  --------
5077  *  NOTE: The workspaceCount resource has precedence over the
5078  *  workspaceList resource. workspaceCount determines the number of
5079  *  workspaces to create for the screen. Once the number is determined,
5080  *  workspaceList is used to fill in the "names." If workspaceList is
5081  *  not present or doesn't have enough names, then missing names are
5082  *  generated automatically. If workspaceList is present and
5083  *  workspaceCount is not present, then the workspaceCount is determined
5084  *  by the number of names in workspaceList.
5085  *
5086  *************************************<->***********************************/
5087
5088 void
5089 ProcessWorkspaceList (WmScreenData *pSD)
5090 {
5091     int i, wsNameCount, wsNamesAlloced;
5092     WmWorkspaceData *pwsI;
5093     unsigned char *lineP = NULL;
5094     unsigned char *string;
5095     Boolean bHaveWorkspaceList;
5096     Boolean bHaveWorkspaceCount;
5097     char **ppchWsNames = NULL;
5098
5099     /*
5100      * Validate initial resource settings
5101      */
5102     bHaveWorkspaceCount = (pSD->numWorkspaces >= 1);
5103     bHaveWorkspaceList = (pSD->workspaceList != NULL);
5104
5105     if (bHaveWorkspaceList)
5106     {
5107         /*
5108          * Parse out array of workspace names
5109          */
5110         wsNamesAlloced = WS_ALLOC_AMOUNT;
5111         ppchWsNames = (char **) XtMalloc (wsNamesAlloced * sizeof (char *));
5112         if (pSD->workspaceList)
5113         {
5114             lineP = (unsigned char *) pSD->workspaceList;
5115         }
5116         else
5117         {
5118             lineP = (unsigned char *)NULL;
5119         }
5120         wsNameCount = 0;
5121
5122         while (((string = GetString(&lineP)) != NULL))
5123         {
5124             ppchWsNames[wsNameCount] = (char *) string;
5125
5126             if (++wsNameCount >= wsNamesAlloced)
5127             {
5128                /*
5129                 *  Need to add more workspaces
5130                 */
5131                 wsNamesAlloced += WS_ALLOC_AMOUNT;
5132                 if (!(ppchWsNames = (char **) XtRealloc
5133                           ((char *)ppchWsNames,
5134                             wsNamesAlloced * sizeof(char *))))
5135                 {
5136                     ExitWM (WM_ERROR_EXIT_VALUE);
5137                 }
5138             }
5139         }
5140
5141         if (!bHaveWorkspaceCount)
5142         {
5143             pSD->numWorkspaces = wsNameCount;
5144         }
5145     }
5146     else if (!bHaveWorkspaceCount)
5147     {
5148         /*
5149          * Neither workspaceCount nor workspaceList specified!!
5150          * Assume one workspace.
5151          */
5152         pSD->numWorkspaces = 1;
5153     }
5154
5155     if (pSD->numWorkspaces > MAX_WORKSPACE_COUNT)
5156             pSD->numWorkspaces = MAX_WORKSPACE_COUNT;
5157
5158     /*
5159      *  Allocate the array of workspace data
5160      */
5161     pSD->numWsDataAllocated = (pSD->numWorkspaces + WS_ALLOC_AMOUNT);
5162     pSD->numWsDataAllocated -= pSD->numWsDataAllocated % WS_ALLOC_AMOUNT;
5163     if (!(pSD->pWS = (WmWorkspaceData *)
5164             XtMalloc (pSD->numWsDataAllocated * sizeof(WmWorkspaceData))))
5165     {
5166         ExitWM (WM_ERROR_EXIT_VALUE);
5167     }
5168
5169     pwsI = pSD->pWS;
5170
5171     for (i = 0; i < pSD->numWorkspaces; i++, pwsI++)
5172     {
5173         if (bHaveWorkspaceList && i < wsNameCount)
5174         {
5175             string = (unsigned char *) ppchWsNames[i];
5176         }
5177         else
5178         {
5179             string = GenerateWorkspaceName (pSD, i);
5180         }
5181         if (!(pwsI->name = (String) XtMalloc (1+strlen((char *)string))))
5182         {
5183             Warning (((char *)GETMESSAGE(62, 27, "Insufficient memory for workspace data")));
5184             ExitWM(WM_ERROR_EXIT_VALUE);
5185         }
5186         else
5187         {
5188             strcpy(pwsI->name, (char *)string);
5189         }
5190     }
5191
5192     if (ppchWsNames) XtFree ((char *) ppchWsNames);
5193
5194 } /* END OF FUNCTION ProcessWorkspaceList */
5195
5196 #endif /* WSM */
5197
5198 \f
5199 /******************************<->*************************************
5200  *
5201  *  ProcessWorkspaceResources (pWS)
5202  *
5203  *
5204  *  Description:
5205  *  -----------
5206  *  This function retrieves resources that are workspace specific.  If the
5207  *  window manager is providing standard behavior then retrieve the limited
5208  *  set of resources that don't affect standard behavior and set the
5209  *  values of the other resources to the standard values.
5210  *
5211  *
5212  *  Inputs:
5213  *  ------
5214  *  pWS = pointer to workspace data
5215  *
5216  *
5217  *  Outputs:
5218  *  -------
5219  *  pWS = resource data for workspace is set
5220  *
5221  *
5222  *  Comments:
5223  *  --------
5224  *  o Gets subresources based on workspace name
5225  *
5226  ******************************<->***********************************/
5227
5228 void
5229 ProcessWorkspaceResources (WmWorkspaceData *pWS)
5230 {
5231
5232     /*
5233      * Retrieve workspace specific resources.
5234      */
5235 #ifdef WSM
5236     pResWS = pWS;       /* save current ws for default processing */
5237 #endif /* WSM */
5238
5239     if (wmGD.useStandardBehavior)
5240     {
5241         XtGetSubresources (pWS->pSD->screenTopLevelW, (XtPointer) pWS,
5242             pWS->name, pWS->name, wmStdWorkspaceResources,
5243             XtNumber (wmStdWorkspaceResources), NULL, 0);
5244
5245         /*
5246          * Fill in the standard resource values.
5247          *
5248          * (no code for this right now)
5249          */
5250 #ifdef WSM
5251         pWS->iconBoxGeometry = NULL;
5252 #endif /* WSM */
5253     }
5254     else
5255     {
5256         XtGetSubresources (pWS->pSD->screenTopLevelW, (XtPointer) pWS,
5257             pWS->name, pWS->name, wmWorkspaceResources,
5258             XtNumber (wmWorkspaceResources), NULL, 0);
5259
5260 #ifdef WSM
5261         /*  Dup iconbox geometry, it may be free'd later on.  */
5262
5263         if (pWS->iconBoxGeometry)
5264         {
5265             pWS->iconBoxGeometry = XtNewString (pWS->iconBoxGeometry);
5266         }
5267 #endif /* WSM */
5268     }
5269
5270 #ifdef WSM
5271     if (pWS->title == NULL)
5272     {
5273         /*
5274          * Setup default workspace title
5275          */
5276         pWS->title = XmStringCreateLocalized(pWS->name);
5277     }
5278     else
5279     {
5280        /*
5281         * Copy resource just in case there's a duplicate
5282         * Duplicates point to the same data, freeing on
5283         * rename can cause a crash.
5284         */
5285         pWS->title = XmStringCopy(pWS->title);
5286
5287     }
5288
5289     /*
5290      * Dup iconbox geometry, it may be free'd later on.
5291      */
5292     if (pWS->iconBoxGeometry)
5293     {
5294         pWS->iconBoxGeometry = XtNewString (pWS->iconBoxGeometry);
5295     }
5296
5297     /*
5298      * Get backdrop resources
5299      */
5300     XtGetSubresources (pWS->workspaceTopLevelW,
5301         (XtPointer) &(pWS->backdrop),
5302         WmNbackdrop, WmCBackdrop, wmBackdropResources,
5303         XtNumber (wmBackdropResources), NULL, 0);
5304
5305     ProcessBackdropResources (pWS, 0);
5306 #endif /* WSM */
5307
5308 } /* END OF FUNCTION ProcessWorkspaceResources */
5309
5310 #ifdef WSM
5311 \f
5312 /******************************<->*************************************
5313  *
5314  *  ProcessPresenceResources (pSD)
5315  *
5316  *
5317  *  Description:
5318  *  -----------
5319  *  This function retrieves resources for the workspace presence
5320  *  dialog.
5321  *
5322  *  Inputs:
5323  *  ------
5324  *  pSD = pointer to screen data
5325  *
5326  *
5327  *  Outputs:
5328  *  -------
5329  *  pSD = resource data for workspace presence dialog are set
5330  *
5331  *
5332  *  Comments:
5333  *  --------
5334  *  o Gets subresources
5335  *
5336  ******************************<->***********************************/
5337
5338 void
5339 ProcessPresenceResources (WmScreenData *pSD)
5340 {
5341 #ifndef NO_MESSAGE_CATALOG
5342     static char *default_ws_pres_title = NULL;
5343 #else
5344     static char *default_ws_pres_title = "Workspace Presence";
5345 #endif
5346     Arg args[5];
5347     int n;
5348     unsigned char *pch1, *pch2;
5349
5350 #ifndef NO_MESSAGE_CATALOG
5351     /*
5352      * Set up localized default title string on initial time through
5353      */
5354     if (default_ws_pres_title == NULL)
5355     {
5356         char * tmpString;
5357         /*
5358          * catgets returns a pointer to an area that is over written
5359          * on each call to catgets.
5360          */
5361
5362         tmpString = ((char *)GETMESSAGE(62, 59, "Occupy Workspace"));
5363         if ((default_ws_pres_title =
5364              (char *)XtMalloc ((unsigned int) (strlen(tmpString) + 1))) == NULL)
5365         {
5366             Warning (((char *)GETMESSAGE(62, 31, "Insufficient memory for local message string")));
5367             default_ws_pres_title = "Occupy Workspace";
5368         }
5369         else
5370         {
5371             strcpy(default_ws_pres_title, tmpString);
5372         }
5373     }
5374 #endif
5375
5376     if (pSD->presence.shellW)
5377     {
5378         XtGetSubresources (pSD->presence.shellW, (XtPointer) &pSD->presence,
5379                 WmNworkspacePresence, WmCWorkspacePresence,
5380                 wmWsPresenceResources,
5381                 XtNumber (wmWsPresenceResources), NULL, 0);
5382
5383         pch2 = NULL;
5384
5385         if (pSD->presence.title)
5386         {
5387             pch1 = (unsigned char *)
5388                     WmXmStringToString (pSD->presence.title);
5389
5390             if (pch1 && (pch2 = (unsigned char *)
5391                                 XtMalloc (1+strlen((char *)pch1))))
5392             {
5393                 strcpy ((char *)pch2, (char *)pch1);
5394             }
5395         }
5396
5397         if (!pch2)
5398         {
5399             pch2 = (unsigned char *) default_ws_pres_title;
5400         }
5401
5402         n = 0;
5403         XtSetArg (args[n], XmNtitle, pch2);             n++;
5404         XtSetValues (pSD->presence.shellW, args, n);
5405     }
5406
5407 } /* END OF FUNCTION ProcessPresenceResources */
5408 #endif /* WSM */
5409
5410 \f
5411 /*************************************<->*************************************
5412  *
5413  *  ProcessClientResources (pCD)
5414  *
5415  *
5416  *  Description:
5417  *  -----------
5418  *  This function retrieves resources that are client specific.  If the
5419  *  window manager is providing standard behavior then retrieve the limited
5420  *  set of resources that don't affect standard behavior and set the
5421  *  values of the other resources to the standard values.
5422  *
5423  *
5424  *  Inputs:
5425  *  ------
5426  *  pCD = pointer to client data
5427  *
5428  *
5429  *  Outputs:
5430  *  -------
5431  *  pCD = resource data for client is set
5432  *
5433  *
5434  *  Comments:
5435  *  --------
5436  *  o Gets subresources based on client name and class.
5437  *  o Creates GC for the client Matte, if there is one.
5438  *
5439  *************************************<->***********************************/
5440
5441 void
5442 ProcessClientResources (ClientData *pCD)
5443 {
5444     String clientName;
5445     String clientClass;
5446     WmScreenData *pSD = pCD->pSD;
5447
5448     /*
5449      * Retrieve basic client specific resources.
5450      */
5451
5452     _pCD = pCD; /* save in static global for dynamic default processing */
5453     clientName = (pCD->clientName) ? pCD->clientName : WmNdefaults;
5454     clientClass = (pCD->clientClass) ? pCD->clientClass : WmNdefaults;
5455
5456     if (wmGD.useStandardBehavior)
5457     {
5458         XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5459             clientClass, wmStdClientResources, XtNumber (wmStdClientResources),
5460             NULL, 0);
5461
5462         /*
5463          * Fill in the standard resource values.
5464          */
5465
5466         SetStdClientResourceValues (pCD);
5467     }
5468     else
5469     {
5470         XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5471             clientClass, wmClientResources, XtNumber (wmClientResources), NULL,
5472             0);
5473     }
5474
5475 #ifdef NO_MESSAGE_CATALOG
5476     /*
5477      * If (window menu spec is not found) then use the builtin
5478      * system menu.
5479      */
5480
5481     if ((pCD->systemMenu == defaultSystemMenuName) &&
5482         (pSD->defaultSystemMenuUseBuiltin == TRUE))
5483     {
5484         pCD->systemMenu = builtinSystemMenuName;
5485     }
5486 #endif
5487
5488     /*
5489      * If the client decorations or client functions have been defaulted
5490      * fix up the fields in the ProcessMwmHints function.
5491      */
5492
5493
5494     /* make top and bottom shadow pixmaps */
5495
5496     if (pCD->iconImageBottomShadowPStr)
5497     {
5498         if ((pCD->iconImageBottomShadowPStr ==
5499                     pSD->iconAppearance.bottomShadowPStr) &&
5500             (pCD->iconImageBottomShadowColor ==
5501                     pSD->iconAppearance.bottomShadowColor) &&
5502             (pCD->iconImageBackground ==
5503                     pSD->iconAppearance.background))
5504         {
5505             pCD->iconImageBottomShadowPixmap =
5506                     pSD->iconAppearance.bottomShadowPixmap;
5507         }
5508         else
5509         {
5510             pCD->iconImageBottomShadowPixmap =
5511                             XmGetPixmap ( ScreenOfDisplay (DISPLAY,
5512                                               pSD->screen),
5513                                           pCD->iconImageBottomShadowPStr,
5514                                           pCD->iconImageBottomShadowColor,
5515                                           pCD->iconImageBackground);
5516
5517             if (pCD->iconImageBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
5518             {
5519                 pCD->iconImageBottomShadowPixmap = (Pixmap)NULL;
5520             }
5521         }
5522     }
5523     else
5524     {
5525         pCD->iconImageBottomShadowPixmap = (Pixmap)NULL;
5526     }
5527
5528     if (pCD->iconImageTopShadowPStr)
5529     {
5530         if ((pCD->iconImageTopShadowPStr ==
5531                                 pSD->iconAppearance.topShadowPStr) &&
5532             (pCD->iconImageTopShadowColor ==
5533                                 pSD->iconAppearance.topShadowColor) &&
5534             (pCD->iconImageBackground == pSD->iconAppearance.background))
5535         {
5536             pCD->iconImageTopShadowPixmap =
5537                                         pSD->iconAppearance.topShadowPixmap;
5538         }
5539         else
5540         {
5541             pCD->iconImageTopShadowPixmap =
5542                             XmGetPixmap ( ScreenOfDisplay (DISPLAY,
5543                                               pSD->screen),
5544                                           pCD->iconImageTopShadowPStr,
5545                                           pCD->iconImageTopShadowColor,
5546                                           pCD->iconImageBackground);
5547
5548             if (pCD->iconImageTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
5549             {
5550                 pCD->iconImageTopShadowPixmap = (Pixmap)NULL;
5551             }
5552         }
5553     }
5554     else
5555     {
5556         pCD->iconImageTopShadowPixmap = (Pixmap)NULL;
5557     }
5558
5559     if ((pCD->internalBevel < MIN_INTERNAL_BEVEL)  ||
5560         (pCD->internalBevel > MAX_INTERNAL_BEVEL))
5561     {
5562         pCD->internalBevel = MAX_INTERNAL_BEVEL;
5563     }
5564
5565
5566     /*
5567      * Retrieve matte resources and make internal matte resources.
5568      */
5569
5570     if (pCD->matteWidth > 0)
5571     {
5572         XtGetSubresources (pSD->screenTopLevelW, (XtPointer) pCD, clientName,
5573             clientClass, wmClientResourcesM, XtNumber (wmClientResourcesM),
5574             NULL, 0);
5575
5576         /* make top and bottom shadow pixmaps */
5577
5578 #ifdef WSM
5579         if (pCD->matteBottomShadowPStr &&
5580             (!strcmp(pCD->matteBottomShadowPStr, _NoDither)))
5581         {
5582             pCD->matteBottomShadowPStr = NULL;
5583         }
5584 #endif /* WSM */
5585         if (pCD->matteBottomShadowPStr)
5586         {
5587             if ((pCD->matteBottomShadowPStr ==
5588                                     pSD->clientAppearance.bottomShadowPStr) &&
5589                 (pCD->matteBottomShadowColor ==
5590                                     pSD->clientAppearance.bottomShadowColor) &&
5591                 (pCD->matteBackground == pSD->clientAppearance.background))
5592             {
5593                 pCD->matteBottomShadowPixmap =
5594                                 pSD->clientAppearance.bottomShadowPixmap;
5595             }
5596             else
5597             {
5598                 pCD->matteBottomShadowPixmap =
5599                                 XmGetPixmap (ScreenOfDisplay (DISPLAY,
5600                                                  pSD->screen),
5601                                              pCD->matteBottomShadowPStr,
5602                                              pCD->matteBottomShadowColor,
5603                                              pCD->matteBackground);
5604
5605                 if (pCD->matteBottomShadowPixmap == XmUNSPECIFIED_PIXMAP)
5606                 {
5607                     pCD->matteBottomShadowPixmap = (Pixmap)NULL;
5608                 }
5609             }
5610         }
5611         else
5612         {
5613             pCD->matteBottomShadowPixmap = (Pixmap)NULL;
5614         }
5615
5616 #ifdef WSM
5617         if (pCD->matteTopShadowPStr &&
5618             (!strcmp(pCD->matteTopShadowPStr, _NoDither)))
5619         {
5620             pCD->matteTopShadowPStr = NULL;
5621         }
5622 #endif /* WSM */
5623         if (pCD->matteTopShadowPStr)
5624         {
5625             if ((pCD->matteTopShadowPStr ==
5626                                     pSD->clientAppearance.topShadowPStr) &&
5627                 (pCD->matteTopShadowColor ==
5628                                     pSD->clientAppearance.topShadowColor) &&
5629                 (pCD->matteBackground == pSD->clientAppearance.background))
5630             {
5631                 pCD->matteTopShadowPixmap =
5632                                         pSD->clientAppearance.topShadowPixmap;
5633             }
5634             else
5635             {
5636                 pCD->matteTopShadowPixmap =
5637                                 XmGetPixmap (ScreenOfDisplay (DISPLAY,
5638                                                  pSD->screen),
5639                                              pCD->matteTopShadowPStr,
5640                                              pCD->matteTopShadowColor,
5641                                              pCD->matteBackground);
5642
5643                 if (pCD->matteTopShadowPixmap == XmUNSPECIFIED_PIXMAP)
5644                 {
5645                     pCD->matteTopShadowPixmap = (Pixmap)NULL;
5646                 }
5647             }
5648         }
5649         else
5650         {
5651             pCD->matteTopShadowPixmap = (Pixmap)NULL;
5652         }
5653
5654
5655         /* make top and bottom shadow GC's */
5656
5657         pCD->clientMatteTopShadowGC = GetHighlightGC (pCD->pSD,
5658                                           pCD->matteTopShadowColor,
5659                                           pCD->matteBackground,
5660                                           pCD->matteTopShadowPixmap);
5661
5662         pCD->clientMatteBottomShadowGC = GetHighlightGC (pCD->pSD,
5663                                           pCD->matteBottomShadowColor,
5664                                           pCD->matteBackground,
5665                                           pCD->matteBottomShadowPixmap);
5666     }
5667
5668 } /* END OF FUNCTION ProcessClientResources */
5669
5670
5671 \f
5672 /*************************************<->*************************************
5673  *
5674  *  SetStdClientResourceValues (pCD)
5675  *
5676  *
5677  *  Description:
5678  *  -----------
5679  *  This function sets client resource data to standard values.  This setting
5680  *  is done in place of getting the values from the user settings in
5681  *  the resource database.
5682  *
5683  *  Input:
5684  *  -----
5685  *  pCD = pointer to the client data
5686  *
5687  *
5688  *  Output:
5689  *  ------
5690  *  pCD = (client data filled out with resource values)
5691  *
5692  *************************************<->***********************************/
5693
5694 void
5695 SetStdClientResourceValues (ClientData *pCD)
5696 {
5697     pCD->clientDecoration = WM_DECOR_DEFAULT;
5698     pCD->clientFunctions = WM_FUNC_DEFAULT;
5699     pCD->focusAutoRaise = True;
5700     pCD->systemMenu = builtinSystemMenuName;
5701     pCD->usePPosition = USE_PPOSITION_NONZERO;
5702     pCD->ignoreWMSaveHints = True;
5703
5704 } /* END OF FUNCTION SetStdClientResourceValues */
5705
5706
5707 \f
5708 /******************************<->*************************************
5709  *
5710  *  SetStdScreenResourceValues (pSD)
5711  *
5712  *
5713  *  Description:
5714  *  -----------
5715  *  This function sets screen resource data to standard values.  This setting
5716  *  is done in place of getting the values from the user settings in
5717  *  the resource database.
5718  *
5719  *  Input:
5720  *  -----
5721  *  pSD = pointer to the screen data
5722  *
5723  *
5724  *  Output:
5725  *  ------
5726  *  pSD = (screen data filled out with resource values)
5727  *
5728  ******************************<->***********************************/
5729
5730 void
5731 SetStdScreenResourceValues (WmScreenData *pSD)
5732 {
5733 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
5734     pSD->rootMenu = builtinRootMenuName;
5735 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
5736     pSD->buttonBindings = builtinButtonBindingsName;
5737     pSD->cleanText = True;
5738     pSD->iconDecoration =
5739                 (ICON_LABEL_PART | ICON_IMAGE_PART | ICON_ACTIVE_LABEL_PART);
5740     pSD->iconPlacement =
5741                 (ICON_PLACE_LEFT_PRIMARY | ICON_PLACE_BOTTOM_SECONDARY);
5742     pSD->keyBindings = builtinKeyBindingsName;
5743     pSD->limitResize = True;
5744     pSD->resizeCursors = True;
5745     pSD->transientDecoration = (WM_DECOR_SYSTEM | WM_DECOR_RESIZEH);
5746     pSD->transientFunctions =
5747                 (WM_FUNC_ALL & ~(MWM_FUNC_MAXIMIZE | MWM_FUNC_MINIMIZE |
5748                                  MWM_FUNC_RESIZE));
5749     pSD->useIconBox = False;
5750
5751     pSD->feedbackGeometry = NULL;
5752     pSD->moveOpaque = False;
5753
5754 } /* END OF FUNCTION SetStdScreenResourceValues */
5755
5756 \f
5757 /*************************************<->*************************************
5758  *
5759  *  GetHighlightGC (pSD, fg, bg, pixmap)
5760  *
5761  *
5762  *  Description:
5763  *  -----------
5764  *  Get a graphic context for either drawing top- or bottom-shadow
5765  *  highlights.
5766  *
5767  *
5768  *  Inputs:
5769  *  ------
5770  *  pSD = pointer to screen data
5771  *  fg = foreground color
5772  *  bg = background color
5773  *  pixmap = pixmap for highlight
5774  *
5775  *  Outputs:
5776  *  -------
5777  *  RETRUN = GC with the input parameters incorporated.
5778  *
5779  *************************************<->***********************************/
5780
5781 GC GetHighlightGC (WmScreenData *pSD, Pixel fg, Pixel bg, Pixmap pixmap)
5782 {
5783     XGCValues gcv;
5784     XtGCMask  mask;
5785
5786
5787     mask = GCForeground | GCBackground | GCLineWidth | GCFillStyle;
5788     gcv.background = bg;
5789     gcv.foreground = fg;
5790     gcv.line_width = 1;
5791
5792     if (pixmap)
5793     {
5794         mask |= GCFillStyle | GCTile;
5795         gcv.fill_style = FillTiled;
5796         gcv.tile = pixmap;
5797     }
5798     else
5799     {
5800         gcv.fill_style = FillSolid;
5801     }
5802
5803 #ifdef OLD_CODE
5804     /*
5805      * NOTE: If additional mask bits are added, modify WmGetGC()
5806      * in WmGraphics.c to check those values for matches.
5807      */
5808
5809     return (WmGetGC (pSD, mask, &gcv));
5810 #endif /* OLD_CODE */
5811
5812     return (XtGetGC (pSD->screenTopLevelW, mask, &gcv));
5813
5814 } /* END OF FUNCTION GetHighlightGC */
5815
5816
5817 \f
5818 /*************************************<->*************************************
5819  *
5820  *  _WmGetDynamicDefault (widget, type, defaultColor, newBackground, value)
5821  *
5822  *
5823  *  Description:
5824  *  -----------
5825  *  This function is used to generate a default color of the requested
5826  *  type.  Default colors are generated for a 3-D appearance.
5827  *
5828  *
5829  *  Inputs:
5830  *  ------
5831  *  widget = this is the widget that is associated with the resource or
5832  *           that is the reference widget for the wm subpart.
5833  *
5834  *  type = this is the type of color resource (e.g., top shadow color).
5835  *
5836  *  defaultColor = pointer to default color name/specification.
5837  *
5838  *  newBackground = background pixel for generating 3-D colors.
5839  *
5840  *
5841  *  Outputs:
5842  *  -------
5843  *  value = pointer to the XrmValue in which to store the color
5844  *
5845  *************************************<->***********************************/
5846
5847 void
5848 _WmGetDynamicDefault (Widget widget, unsigned char type, String defaultColor, Pixel newBackground, XrmValue *value)
5849 {
5850     static Screen *oldScreen = NULL;
5851     static Screen *newScreen;
5852     static Colormap oldColormap;
5853     static Colormap newColormap;
5854     static Pixel newValue;
5855     static Pixel background;
5856     static String oldDefaultColor = DEFAULT_COLOR_NONE;
5857     static XmColorData colorData;
5858
5859     /* initialize the return value */
5860
5861     value->size = sizeof (newValue);
5862     value->addr = (char *)&newValue;
5863
5864
5865     /*
5866      * Process monochrome defaults first.
5867      */
5868
5869     newScreen = XtScreen (widget);
5870
5871     if (Monochrome (newScreen))
5872     {
5873 #ifdef WSM
5874     Boolean ok = False;
5875     /*
5876      * Check color server sets for this screen.
5877      */
5878     if (wmGD.statusColorServer == CSERVE_NORMAL)
5879     {
5880         WmScreenData *pSD;
5881         int i;
5882
5883         for (i = 0; i < wmGD.numScreens; i++)
5884         {
5885             if (XScreenNumberOfScreen(newScreen) == wmGD.Screens[i].screen)
5886             {
5887                 pSD = &wmGD.Screens[i];
5888                 ok = True;
5889                 break;
5890             }
5891         }
5892
5893         if (ok)
5894         {
5895             ok = False;
5896             for (i = 0; i < XmCO_MAX_NUM_COLORS; i++)
5897             {
5898                 if (pSD->pPixelData[i].bg == newBackground)
5899                 {
5900                     switch (type)
5901                       {
5902                       case WmFGC: newValue = pSD->pPixelData[i].fg; break;
5903                       case WmBGC: newValue = pSD->pPixelData[i].bg; break;
5904                       case WmTSC: newValue = pSD->pPixelData[i].ts; break;
5905                       case WmBSC: newValue = pSD->pPixelData[i].bs; break;
5906                       }
5907
5908                     ok = True;
5909                 }
5910             }
5911         }
5912
5913     }
5914     if (!ok)
5915     {
5916 #endif /* WSM */
5917         switch (type)
5918           {
5919           case WmFGC: newValue = BlackPixelOfScreen (newScreen); break;
5920           case WmBGC: newValue = WhitePixelOfScreen (newScreen); break;
5921           case WmTSC: newValue = WhitePixelOfScreen (newScreen); break;
5922           case WmBSC: newValue = BlackPixelOfScreen (newScreen); break;
5923           }
5924 #ifdef WSM
5925     }
5926 #endif /* WSM */
5927         return;
5928     }
5929
5930
5931     /*
5932      * Check to see if appropriate colors are available from the
5933      * previous request; if the color is a background color then get
5934      * default colors.  Generate 3-D colors if necessary.  Maintain
5935      * new colors in static variables for later reuse.
5936      */
5937
5938     newColormap = widget->core.colormap;
5939
5940     if ((oldScreen != NULL) && (oldScreen == newScreen) &&
5941         (oldColormap == newColormap) && (type != WmBGC) &&
5942         (background == newBackground))
5943     {
5944     }
5945     else if ((oldScreen == newScreen) && (oldColormap == newColormap) &&
5946              (type == WmBGC) && (oldDefaultColor == defaultColor))
5947     {
5948     }
5949     else if (type == WmBGC)
5950     {
5951         /*
5952          * Find or generate a background color and associated 3-D colors.
5953          */
5954
5955         oldDefaultColor = defaultColor;
5956 /*
5957  * Fix for CR 5152 - Due to the use of Realloc in the color caches,
5958  *                   a static pointer is not acceptable.  Change it
5959  *                   to a static structure to maintain the data
5960  */
5961         colorData = *_WmGetDefaultColors (newScreen, newColormap, defaultColor);
5962     }
5963     else
5964     {
5965         /*
5966          * Find or generate a color based on the associated background color.
5967          */
5968
5969         oldDefaultColor = DEFAULT_COLOR_NONE;
5970         background = newBackground;
5971
5972         XmGetColors(newScreen, newColormap, background,
5973                     &colorData.foreground.pixel,
5974                     &colorData.top_shadow.pixel,
5975                     &colorData.bottom_shadow.pixel,
5976                     &colorData.select.pixel);
5977     }
5978
5979     oldScreen = newScreen;
5980     oldColormap = newColormap;
5981
5982
5983     /*
5984      * Set up the return value.
5985      */
5986
5987     colorData.allocated |= type;
5988     switch (type)
5989       {
5990       case XmBACKGROUND:    newValue = colorData.background.pixel;    break;
5991       case XmFOREGROUND:    newValue = colorData.foreground.pixel;    break;
5992       case XmTOP_SHADOW:    newValue = colorData.top_shadow.pixel;    break;
5993       case XmBOTTOM_SHADOW: newValue = colorData.bottom_shadow.pixel; break;
5994       case XmSELECT:        newValue = colorData.select.pixel;        break;
5995       default:              newValue = colorData.background.pixel;    break;
5996       }
5997
5998 } /* END OF FUNCTION _WmGetDynamicDefault */
5999
6000
6001 \f
6002 /*************************************<->*************************************
6003  *
6004  *  _WmGetDefaultColors (screen, colormap, defaultColor)
6005  *
6006  *
6007  *  Description:
6008  *  -----------
6009  *  This function is used to find or generate default 3-D colors based on a
6010  *  default background color.
6011  *
6012  *
6013  *  Inputs:
6014  *  ------
6015  *  screen = screen for which colors are to be generated.
6016  *
6017  *  colormap = colormap that is to be used to make colors.
6018  *
6019  *  defaultColor = pointer to a default color name/specification.
6020  *
6021  *
6022  *  Outputs:
6023  *  -------
6024  *  RETURN = pointer to WmColorData structure containing 3-D colors.
6025  *
6026  *************************************<->***********************************/
6027
6028 XmColorData * _WmGetDefaultColors (screen, colormap, defaultColor)
6029         Screen *screen;
6030         Colormap colormap;
6031         String defaultColor;
6032
6033 {
6034     static XmColorData *defaultSet[2] = {NULL, NULL};
6035     static int defaultCount[2] = {0, 0};
6036     static int defaultSize[2] = {0, 0};
6037     int setId;
6038     register XmColorData *set;
6039     register int count;
6040     register int size;
6041     register int i;
6042     Display *display = DisplayOfScreen (screen);
6043     XColor colorDef;
6044
6045 /*
6046  * Fix for CR 5152 - Due to the use of Realloc with _XmGetColors, it is
6047  *                   necessary to maintain a separate cache of color
6048  *                   data.  The Realloc may cause the data to be moved,
6049  *                   and the cache would contain pointers into the heap.
6050  */
6051
6052     /*
6053      * Look through the cache to see if the defaults are already in the
6054      * cache.  There is a list of cached defaults for each default color.
6055      */
6056
6057     if (defaultColor == _defaultColor2)
6058     {
6059         setId = 1;
6060     }
6061     else
6062     {
6063         setId = 0;
6064     }
6065
6066     set = defaultSet[setId];
6067     count = defaultCount[setId];
6068     size = defaultSize[setId];
6069
6070     for (i = 0; i < count; i++)
6071     {
6072         if (((set + i)->screen == screen) && ((set + i)->color_map == colormap))
6073         {
6074             return (set + i);
6075         }
6076     }
6077
6078     /*
6079      * No match in the cache, make a new entry and generate the colors.
6080      */
6081
6082     if (count == size)
6083     {
6084         size = (defaultSize[setId] += 10);
6085         set = defaultSet[setId] =
6086                 (XmColorData *)WmRealloc ((char *) defaultSet[setId],
6087                                     sizeof (XmColorData) * size);
6088     }
6089
6090     /*
6091      * Make the default background color for the resource set.
6092      */
6093
6094     if(!XParseColor (display, colormap, defaultColor, &colorDef))
6095     {
6096         if(!(strcmp(defaultColor, _defaultColor1)))
6097         {
6098             XParseColor (display, colormap, _defaultColor1HEX, &colorDef);
6099         }
6100         else
6101         {
6102             XParseColor (display, colormap, _defaultColor2HEX, &colorDef);
6103         }
6104     }
6105
6106     XAllocColor (display, colormap, &colorDef);
6107
6108
6109     /*
6110      * Generate the 3-D colors and save them in the defaults cache.
6111      */
6112
6113     XmGetColors(screen, colormap, colorDef.pixel,
6114                 &set[count].foreground.pixel,
6115                 &set[count].top_shadow.pixel,
6116                 &set[count].bottom_shadow.pixel,
6117                 &set[count].select.pixel);
6118
6119     set[count].background.pixel = colorDef.pixel;
6120
6121     set[count].screen    = screen;
6122     set[count].color_map = colormap;
6123     set[count].allocated = True;
6124
6125     XQueryColor(DISPLAY, colormap, &(set[count].background));
6126     XQueryColor(DISPLAY, colormap, &(set[count].foreground));
6127     XQueryColor(DISPLAY, colormap, &(set[count].top_shadow));
6128     XQueryColor(DISPLAY, colormap, &(set[count].bottom_shadow));
6129     XQueryColor(DISPLAY, colormap, &(set[count].select));
6130
6131     (defaultCount[setId])++;
6132
6133     return (set + count);
6134
6135
6136 } /* END OF FUNCTION _WmGetDefaultColors */
6137
6138
6139 \f
6140 /*************************************<->*************************************
6141  *
6142  *  WmRealloc (ptr, size)
6143  *
6144  *
6145  *  Description:
6146  *  -----------
6147  *  This function is used reallocate a block of storage that has been
6148  *  malloc'ed.
6149  *
6150  *
6151  *  Inputs:
6152  *  ------
6153  *  ptr = pointer to storage that is to be realloc'ed; if NULL malloc an
6154  *        initial block of storage.
6155  *
6156  *  size = size of new storage
6157  *
6158  *  Outputs:
6159  *  -------
6160  *  RETURN = pointer to realloc'ed block of storage
6161  *
6162  *************************************<->***********************************/
6163
6164 char * WmRealloc (ptr, size)
6165         char *ptr;
6166         unsigned size;
6167
6168 {
6169     if (ptr)
6170     {
6171         ptr = (char *)XtRealloc (ptr, size);
6172     }
6173     else
6174     {
6175         ptr = (char *)XtMalloc (size);
6176     }
6177
6178     if (ptr == NULL)
6179     {
6180         Warning (((char *)GETMESSAGE(62, 37, "Insufficient memory for window manager data")));
6181     }
6182
6183     return (ptr);
6184
6185 } /* END OF FUNCTION WmRealloc */
6186
6187
6188 \f
6189 /*************************************<->*************************************
6190  *
6191  *  WmMalloc (ptr, size)
6192  *
6193  *
6194  *  Description:
6195  *  -----------
6196  *  This function is used malloc a block of storage.  If a previous block
6197  *  of storage is being replace the old block is free'd.
6198  *
6199  *
6200  *  Inputs:
6201  *  ------
6202  *  ptr = pointer to storage that is to be replaced (free'd).
6203  *
6204  *  size = size of new storage
6205  *
6206  *  Outputs:
6207  *  -------
6208  *  RETURN = pointer to malloc'ed block of storage
6209  *
6210  *************************************<->***********************************/
6211
6212 char * WmMalloc (ptr, size)
6213         char *ptr;
6214         unsigned size;
6215
6216 {
6217     if (ptr)
6218     {
6219         XtFree (ptr);
6220     }
6221
6222     ptr = (char *)XtMalloc (size);
6223
6224     if (ptr == NULL)
6225     {
6226         Warning (((char *)GETMESSAGE(62, 38, "Insufficient memory for window manager data")));
6227     }
6228
6229     return (ptr);
6230
6231 } /* END OF FUNCTION WmMalloc */
6232
6233
6234 \f
6235 /*************************************<->*************************************
6236  *
6237  *  SetupDefaultResources (pSD)
6238  *
6239  *
6240  *  Description:
6241  *  -----------
6242  *  This function is used to setup default (builtin) resources for the
6243  *  key bindings.
6244  *
6245  *
6246  *  Inputs:
6247  *  ------
6248  *  pSD = pointer to screen data
6249  *  wmGD = (defaultKeyBindingsString, ...)
6250  *
6251  *  builtinKeyBindingsName = name of default key bindings set
6252  *
6253  *
6254  *  Outputs:
6255  *  -------
6256  *   None
6257  *
6258  *************************************<->***********************************/
6259
6260 void
6261 SetupDefaultResources (pSD)
6262
6263 WmScreenData *pSD;
6264
6265 {
6266     KeySpec *nextKeySpec;
6267     String keyBindings;
6268     MenuSpec *menuSpec;
6269
6270
6271 /*
6272  * If (using DefaultBindings mechanism and bindings are not found in .mwmrc)
6273  *      then use the builtin bindings.
6274  */
6275     if (!pSD->keySpecs && !wmGD.useStandardBehavior)
6276     {
6277         /*
6278          * Print warning if user is NOT using "DefaultKeyBindings".
6279          */
6280         if (strcmp (pSD->keyBindings, defaultKeyBindingsName))
6281         {
6282            MWarning (((char *)GETMESSAGE(62, 67, "Key bindings %s not found, using builtin key bindings\n")),
6283            pSD->keyBindings);
6284         }
6285         pSD->keyBindings = builtinKeyBindingsName;
6286     }
6287
6288     if (!pSD->buttonSpecs && !wmGD.useStandardBehavior)
6289     {
6290         /*
6291          * Print warning if user is NOT using "DefaultButtonBindings".
6292          */
6293         if (strcmp (pSD->buttonBindings, defaultButtonBindingsName))
6294         {
6295            MWarning (((char *)GETMESSAGE(62, 68, "Button bindings %s not found, using builtin button bindings\n")),
6296                      pSD->buttonBindings);
6297         }
6298         pSD->buttonBindings = builtinButtonBindingsName;
6299     }
6300
6301     if (pSD->keyBindings == builtinKeyBindingsName)
6302     {
6303         /*
6304          * Default key specifications are to be used and no default
6305          * set has been provided by the user.  Make the built-in default
6306          * set.
6307          */
6308
6309 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
6310         /*
6311          * Before parsing the string, substitute the real name for
6312          * the default rootmenu using the resource rootMenu
6313          * for the %s in the string.
6314          */
6315
6316         char *buffer;
6317
6318         buffer = (char *) XtMalloc(strlen(builtinKeyBindings) +
6319                                    strlen(pSD->rootMenu) + 1);
6320         sprintf(buffer, builtinKeyBindings, pSD->rootMenu);
6321
6322         ParseKeyStr (pSD, (unsigned char *)buffer);
6323 #else
6324         ParseKeyStr (pSD, (unsigned char *)builtinKeyBindings);
6325 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
6326     }
6327     else
6328     {
6329         /*
6330          * Add the switch behavior key binding to the front of the list
6331          * of user specified key bindings that have been parsed.
6332          */
6333
6334         nextKeySpec = pSD->keySpecs;
6335         keyBindings = pSD->keyBindings;
6336         pSD->keyBindings = behaviorKeyBindingName;
6337         pSD->keySpecs = NULL;
6338
6339         ParseKeyStr (pSD, (unsigned char *)behaviorKeyBindings);
6340
6341         if (pSD->keySpecs)
6342         {
6343             /* Skip past the TWO key definitions (1.2 & 1.1.4) */
6344             pSD->keySpecs->nextKeySpec->nextKeySpec = nextKeySpec;
6345         }
6346         else
6347         {
6348             pSD->keySpecs = nextKeySpec;
6349         }
6350         pSD->keyBindings = keyBindings;
6351     }
6352
6353     if (pSD->buttonBindings == builtinButtonBindingsName)
6354     {
6355         /*
6356          * Default button specifications are to be used and no default
6357          * set has been provided by the user.  Make the built-in default
6358          * set.
6359          */
6360
6361 #if ((!defined(WSM)) || defined(MWM_QATS_PROTOCOL))
6362         /*
6363          * Before parsing the string, substitute the real name for
6364          * the default rootmenu using the resource rootMenu
6365          * for the %s in the string.
6366          */
6367
6368         char *buffer;
6369
6370         buffer = (char *) XtMalloc(strlen(builtinButtonBindings) +
6371                                    strlen(pSD->rootMenu) + 1);
6372         sprintf(buffer, builtinButtonBindings, pSD->rootMenu);
6373
6374         ParseButtonStr (pSD, (unsigned char *)buffer);
6375 #else
6376         ParseButtonStr (pSD, (unsigned char *)builtinButtonBindings);
6377 #endif /* !defined(WSM) || defined(MWM_QATS_PROTOCOL) */
6378     }
6379
6380 #ifdef NO_MESSAGE_CATALOG
6381     /*
6382      * Set defaultSystemMenuUseBuiltin to FALSE if DefaultWindowMenu spec
6383      * is found.
6384      */
6385
6386     menuSpec = pSD->menuSpecs;
6387     while ( menuSpec )
6388     {
6389         if (!strcmp(menuSpec->name, defaultSystemMenuName))
6390         {
6391                 pSD->defaultSystemMenuUseBuiltin = FALSE;
6392                 break;
6393         }
6394         menuSpec = menuSpec->nextMenuSpec;
6395     }
6396 #endif
6397
6398 } /* END OF FUNCTION SetupDefaultResources */
6399
6400
6401 \f
6402 /*************************************<->*************************************
6403  *
6404  *  SimilarAppearanceData (pAD1, pAD2)
6405  *
6406  *
6407  *  Description:
6408  *  -----------
6409  *  This function returns True if the two passed sets of AppearanceData
6410  *  are similar. This is designed to compare appearance data before
6411  *  creation of the GCs.
6412  *
6413  *
6414  *  Inputs:
6415  *  ------
6416  *  pAD1        pointer to AppearanceData 1
6417  *  pAD2        pointer to AppearanceData 2
6418  *
6419  *
6420  *  Outputs:
6421  *  -------
6422  *  Function returns True if similar, False otherwise.
6423  *
6424  *  Comments:
6425  *  ---------
6426  *  This function is only used to compare the client
6427  *  and client*title appearance data.
6428  *************************************<->***********************************/
6429
6430 Boolean SimilarAppearanceData (AppearanceData *pAD1, AppearanceData *pAD2)
6431 {
6432     Boolean rval;
6433
6434 #ifdef notdef
6435     if ((pAD1->fontList == pAD2->fontList) &&
6436         (pAD1->background == pAD2->background) &&
6437         (pAD1->foreground == pAD2->foreground) &&
6438         (pAD1->backgroundPStr == pAD2->backgroundPStr) &&
6439         (pAD1->backgroundPixmap == pAD2->backgroundPixmap) &&
6440         (pAD1->bottomShadowColor == pAD2->bottomShadowColor) &&
6441         (pAD1->bottomShadowPStr == pAD2->bottomShadowPStr) &&
6442         (pAD1->bottomShadowPixmap == pAD2->bottomShadowPixmap) &&
6443         (pAD1->topShadowColor == pAD2->topShadowColor) &&
6444         (pAD1->topShadowPStr == pAD2->topShadowPStr) &&
6445         (pAD1->topShadowPixmap == pAD2->topShadowPixmap) &&
6446         (pAD1->activeBackground == pAD2->activeBackground) &&
6447         (pAD1->activeForeground == pAD2->activeForeground) &&
6448         (pAD1->activeBackgroundPStr == pAD2->activeBackgroundPStr) &&
6449         (pAD1->activeBackgroundPixmap == pAD2->activeBackgroundPixmap) &&
6450         (pAD1->activeBottomShadowColor == pAD2->activeBottomShadowColor) &&
6451         (pAD1->activeBottomShadowPStr == pAD2->activeBottomShadowPStr) &&
6452         (pAD1->activeBottomShadowPixmap == pAD2->activeBottomShadowPixmap) &&
6453         (pAD1->activeTopShadowColor == pAD2->activeTopShadowColor) &&
6454         (pAD1->activeTopShadowPStr == pAD2->activeTopShadowPStr) &&
6455         (pAD1->activeTopShadowPixmap == pAD2->activeTopShadowPixmap) )
6456 #else
6457     /*
6458      * !!! Should find out why all the Pixmap resources are unset !!!
6459      */
6460
6461     if ((pAD1->fontList == pAD2->fontList) &&
6462         (pAD1->background == pAD2->background) &&
6463         (pAD1->foreground == pAD2->foreground) &&
6464         (pAD1->backgroundPStr == pAD2->backgroundPStr) &&
6465         (pAD1->bottomShadowColor == pAD2->bottomShadowColor) &&
6466         (pAD1->bottomShadowPStr == pAD2->bottomShadowPStr) &&
6467         (pAD1->topShadowColor == pAD2->topShadowColor) &&
6468         (pAD1->topShadowPStr == pAD2->topShadowPStr) &&
6469         (pAD1->activeBackground == pAD2->activeBackground) &&
6470         (pAD1->activeForeground == pAD2->activeForeground) &&
6471         (pAD1->activeBackgroundPStr == pAD2->activeBackgroundPStr) &&
6472         (pAD1->activeBottomShadowColor == pAD2->activeBottomShadowColor) &&
6473         (pAD1->activeBottomShadowPStr == pAD2->activeBottomShadowPStr) &&
6474         (pAD1->activeTopShadowColor == pAD2->activeTopShadowColor) &&
6475         (pAD1->activeTopShadowPStr == pAD2->activeTopShadowPStr) )
6476 #endif
6477     {
6478         rval = True;
6479     }
6480     else
6481     {
6482         rval = False;
6483     }
6484
6485     return (rval);
6486
6487 } /* END OF FUNCTION SimilarAppearanceData */
6488
6489 #ifdef WSM
6490 \f
6491 /*************************************<->*************************************
6492  *
6493  *  Monochrome (screen)
6494  *
6495  *
6496  *  Description:
6497  *  -----------
6498  *  This function returns True if the screen passed it to be treated
6499  *  as monochrome for the purpose of assigning default resources.
6500  *
6501  *
6502  *  Inputs:
6503  *  ------
6504  *  screen      pointer to Screen
6505  *
6506  *
6507  *  Outputs:
6508  *  -------
6509  *  Function returns True if monochrome (or Static Gray), False otherwise.
6510  *
6511  *************************************<->***********************************/
6512
6513 Boolean
6514 Monochrome (Screen *screen)
6515 {
6516     WmScreenData *pSD;
6517
6518     int scr;
6519
6520     if (wmGD.statusColorServer == CSERVE_NORMAL)
6521     {
6522         for (scr = 0; scr < wmGD.numScreens; scr++)
6523         {
6524             pSD = &(wmGD.Screens[scr]);
6525
6526             if (pSD->managed)
6527             {
6528                 if (XScreenOfDisplay (DISPLAY, pSD->screen) == screen)
6529                 {
6530                     if (pSD->colorUse == XmCO_BLACK_WHITE)
6531                     {
6532                         return(True);
6533                     }
6534                     else
6535                     {
6536                         return(False);
6537                     }
6538                 }
6539             }
6540         }
6541     }
6542     /*
6543      *   If we don't know the answer to our question by now,
6544      *   fall back to the old mwm way of determining monochromicity.
6545      *
6546      */
6547
6548     return ((DefaultDepthOfScreen(screen) == 1));
6549 } /* END OF FUNCTION Monochrome */
6550 #endif /* WSM */
6551 #ifdef WSM
6552 /****************************   eof    ***************************/
6553 #endif /* WSM */