cde/programs/dtstyle/Dtwm.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  ****************************************************************************
  25  **
  26  **   File:        Dtwm.c
  27  **
  28  **   Project:     DT 3.0
  29  **
  30  **   Description: Controls the Dtstyle Window Manager customization dialog
  31  **
  32  **
  33  **  (c) Copyright Hewlett-Packard Company, 1990, 1993.
  34  **
  35  **
  36  **
  37  ****************************************************************************
  38  ************************************<+>*************************************/
  39 /* $XConsortium: Dtwm.c /main/4 1995/10/30 13:09:13 rswiston $ */
  40 /*+++++++++++++++++++++++++++++++++++++++*/
  41 /* include files                         */
  42 /*+++++++++++++++++++++++++++++++++++++++*/
  43
  44 #include <X11/Xlib.h>
  45 #include <Xm/MwmUtil.h>
  46
  47 #include <Xm/XmP.h>
  48 #include <Xm/Xm.h>
  49 #include <Xm/Form.h>
  50 #include <Xm/LabelG.h>
  51 #include <Xm/PushBG.h>
  52 #include <Xm/RowColumn.h>
  53 #include <Xm/ToggleBG.h>
  54 #include <Xm/SeparatoG.h>
  55 #include <Xm/VendorSEP.h>
  56 #include <Xm/MessageB.h>
  57
  58 #include <Dt/DialogBox.h>
  59 #include <Dt/Icon.h>
  60 #include <Dt/TitleBox.h>
  61
  62 #include <Dt/Message.h>
  63 #include <Dt/HourGlass.h>
  64 #include <Dt/Wsm.h>
  65
  66 #include "Help.h"
  67 #include "Main.h"
  68 #include "SaveRestore.h"
  69 #include "Protocol.h"
  70
  71 #include <ctype.h>
  72
  73 /*+++++++++++++++++++++++++++++++++++++++*/
  74 /* include extern functions              */
  75 /*+++++++++++++++++++++++++++++++++++++++*/
  76 #include "Dtwm.h"
  77
  78 /*+++++++++++++++++++++++++++++++++++++++*/
  79 /* Local #defines                        */
  80 /*+++++++++++++++++++++++++++++++++++++++*/
  81 #define POINTER 0
  82 #define EXPLICIT 1
  83
  84 #define POINTER_STR         "pointer"
  85 #define EXPLICIT_STR        "explicit"
  86
  87 #define NUM_PLACEMENT_ICONS 8
  88 #define TOP_LEFT            0
  89 #define TOP_RIGHT           1
  90 #define BOTTOM_LEFT         2
  91 #define BOTTOM_RIGHT        3
  92 #define LEFT_TOP            4
  93 #define LEFT_BOTTOM         5
  94 #define RIGHT_TOP           6
  95 #define RIGHT_BOTTOM        7
  96 #define WARN_MSG  ((char *)GETMESSAGE(18, 12, "The workspace manager must be restarted in\n\
  97 order for your changes to take effect.\n\
  98 Press OK to restart the workspace manager\n\
  99 or Cancel to reset the changes."))
 100
 101 /*+++++++++++++++++++++++++++++++++++++++*/
 102 /* Internal Functions                    */
 103 /*+++++++++++++++++++++++++++++++++++++++*/
 104
 105 static Widget build_dtwmDlg ( Widget shell ) ;
 106 static void formLayoutCB ( Widget, XtPointer, XtPointer ) ;
 107 static void _DtmapCB_dtwmDlg ( Widget, XtPointer, XtPointer ) ;
 108 static void systemDefaultCB ( Widget, XtPointer, XtPointer ) ;
 109 static void ButtonCB ( Widget, XtPointer, XtPointer ) ;
 110 static void getDtwmValues ( ) ;
 111 static void _DtWmParseToLower (unsigned char  *string) ;
 112 static void okWarnCB ( Widget, XtPointer, XtPointer ) ;
 113 static void cancelWarnCB ( Widget, XtPointer, XtPointer ) ;
 114
 115 /*+++++++++++++++++++++++++++++++++++++++*/
 116 /* Internal Variables                    */
 117 /*+++++++++++++++++++++++++++++++++++++++*/
 118
 119 typedef struct {
 120     Widget      pictLabel;
 121     Widget      systemDefault;
 122     Widget      windowFocusTB;
 123     Widget      focusPolicyRC;
 124     Widget      focusSeparator;
 125     Widget      autoRaiseTG;
 126     Widget      secStackTG;
 127     Widget      moveOpaqueTG;
 128     Widget      iconPlacementTB;
 129     Widget      useIconBoxRC;
 130     Widget      pointerTG;
 131     Widget      explicitTG;
 132     Widget      iconBoxTG;
 133     Widget      desktopTG;
 134     Boolean     systemDefaultFlag;
 135     int         origKeyboardFocusPolicy;
 136     int         origFocusAutoRaise;
 137     int         origSecStack;
 138     int         origMoveOpaque;
 139     int         origUseIconBox;
 140     Widget      warnDialog;
 141 } Dtwm, *DtwmPtr;
 142
 143 static Dtwm dtwm;
 144 static saveRestore save = {FALSE, 0, };
 145
 146 static char dtwmRes[150]="";
 147
 148 static char *icon[] = {
 149     "iconTL",
 150     "iconTR",
 151     "iconBL",
 152     "iconBR",
 153     "iconLT",
 154     "iconLB",
 155     "iconRT",
 156     "iconRB"
 157 };
 158
 159 static char *placementStr[] = {
 160     "top left",
 161     "top right",
 162     "bottom left",
 163     "bottom right",
 164     "left top",
 165     "left bottom",
 166     "right top",
 167     "right bottom"
 168 };
 169
 170 /*+++++++++++++++++++++++++++++++++++++++*/
 171 /* popup_dtwmBB                         */
 172 /*+++++++++++++++++++++++++++++++++++++++*/
 173
 174 void
 175 popup_dtwmBB(
 176         Widget shell )
 177 {
 178     if (style.dtwmDialog == NULL) {
 179       _DtTurnOnHourGlass(shell);
 180       build_dtwmDlg(shell);
 181       getDtwmValues();
 182       XtManageChild(style.dtwmDialog);
 183       _DtTurnOffHourGlass(shell);
 184     }
 185     else
 186     {
 187         XtManageChild(style.dtwmDialog);
 188         raiseWindow(XtWindow(XtParent(style.dtwmDialog)));
 189     }
 190     dtwm.systemDefaultFlag = False;
 191 }
 192
 193 /*+++++++++++++++++++++++++++++++++++++++*/
 194 /* getDtwmValues                        */
 195 /*+++++++++++++++++++++++++++++++++++++++*/
 196
 197 static void
 198 getDtwmValues( )
 199 {
 200     char *str_type_return;
 201     XrmValue value_return;
 202     XrmValue    cvt_value;
 203     XrmDatabase db;
 204     Boolean status;
 205     char *string;
 206
 207     db = XtDatabase(style.display);
 208
 209     /* Get KeyboardFocusPolicy value */
 210     if (status = XrmGetResource (db, "dtwm.keyboardFocusPolicy",
 211                                  "Dtwm.KeyboardFocusPolicy",
 212                                  &str_type_return, &value_return))
 213     {
 214         /* make local copy of string */
 215         string = (char *) XtMalloc( value_return.size );
 216         strcpy (string, value_return.addr);
 217
 218         /* convert to lower case */
 219         _DtWmParseToLower((unsigned char *)string);
 220
 221         if (strcmp(string, "pointer") == 0)
 222         {
 223             XmToggleButtonGadgetSetState (dtwm.pointerTG, True, True);
 224             dtwm.origKeyboardFocusPolicy = POINTER;
 225         }
 226         if (strcmp(string, "explicit") == 0)
 227         {
 228             XmToggleButtonGadgetSetState (dtwm.explicitTG, True, True);
 229             dtwm.origKeyboardFocusPolicy = EXPLICIT;
 230         }
 231         XtFree (string);
 232     }
 233     else /* KeyboardFocusPolicy not specified */
 234     {
 235         /* set the Dtwm default value - explicit */
 236         XmToggleButtonGadgetSetState (dtwm.explicitTG, True, True);
 237         dtwm.origKeyboardFocusPolicy = EXPLICIT;
 238     }
 239
 240     /* Get FocusAutoRaise value */
 241     if (status = XrmGetResource (db, "dtwm.focusAutoRaise",
 242                                      "Dtwm.FocusAutoRaise",
 243                                      &str_type_return, &value_return))
 244     {
 245         /* make local copy of string */
 246         string = (char *) XtMalloc( value_return.size );
 247         strcpy (string, value_return.addr);
 248
 249         /* convert to lower case */
 250         _DtWmParseToLower((unsigned char *)string);
 251
 252         dtwm.origFocusAutoRaise =
 253                (strcmp(string, "true") ? False : True);
 254         XmToggleButtonGadgetSetState (dtwm.autoRaiseTG,
 255                dtwm.origFocusAutoRaise, True);
 256
 257         XtFree (string);
 258     }
 259     else /* FocusAutoRaise not specified */
 260     {
 261         /* set the Dtwm default value:
 262          *  True when keyboardFocusPolicy is explicit
 263          *  False when keyboardFocusPolicy is pointer
 264          */
 265         dtwm.origFocusAutoRaise =
 266                 ((dtwm.origKeyboardFocusPolicy == EXPLICIT) ? True : False);
 267         XmToggleButtonGadgetSetState (dtwm.autoRaiseTG,
 268                 dtwm.origFocusAutoRaise, True);
 269     }
 270
 271     /* Get SecStack value from secondaries OnTop resource*/
 272     if (status = XrmGetResource (db, "dtwm.secondariesOnTop",
 273                                      "Dtwm.secondariesOnTop",
 274                                      &str_type_return, &value_return))
 275     {
 276         /* make local copy of string */
 277         string = (char *) XtMalloc( value_return.size );
 278         strcpy (string, value_return.addr);
 279
 280         /* convert to lower case */
 281         _DtWmParseToLower((unsigned char *)string);
 282
 283         dtwm.origSecStack =
 284                (strcmp(string, "true") ? False : True);
 285         XmToggleButtonGadgetSetState (dtwm.secStackTG,
 286                !dtwm.origSecStack, True);
 287
 288         XtFree (string);
 289     }
 290     else /* SecStack resource not specified */
 291       {
 292 #ifdef sun
 293         dtwm.origSecStack = False;
 294         XmToggleButtonGadgetSetState (dtwm.secStackTG,
 295                                       !dtwm.origSecStack, False);
 296 #else
 297         dtwm.origSecStack = True;
 298         XmToggleButtonGadgetSetState (dtwm.secStackTG,
 299                                       !dtwm.origSecStack, True);
 300 #endif
 301       }
 302     /* Get UseIconBox value */
 303     if (status = XrmGetResource (db, "dtwm.useIconBox",
 304                                  "Dtwm.UseIconBox",
 305                                  &str_type_return, &value_return))
 306     {
 307         /* make local copy of string */
 308         string = (char *) XtMalloc( value_return.size );
 309         strcpy (string, value_return.addr);
 310
 311         /* convert to lower case */
 312         _DtWmParseToLower((unsigned char *)string);
 313
 314         dtwm.origUseIconBox =
 315               (strcmp(string, "true") ? False : True);
 316         if (dtwm.origUseIconBox)
 317             XmToggleButtonGadgetSetState (dtwm.iconBoxTG, True, True);
 318         else
 319             XmToggleButtonGadgetSetState (dtwm.desktopTG, True, True);
 320
 321         XtFree (string);
 322     }
 323     else /* UseIconBox not specified */
 324     {
 325         /* set the Dtwm default value - False, desktop - True*/
 326         dtwm.origUseIconBox =  False;
 327         XmToggleButtonGadgetSetState (dtwm.desktopTG, True, True);
 328     }
 329
 330     /* Get MoveOpaque value */
 331     if (status = XrmGetResource (db, "dtwm.moveOpaque",
 332                                      "Dtwm.MoveOpaque",
 333                                      &str_type_return, &value_return))
 334     {
 335         /* make local copy of string */
 336         string = (char *) XtMalloc( value_return.size );
 337         strcpy (string, value_return.addr);
 338
 339         /* convert to lower case */
 340         _DtWmParseToLower((unsigned char *)string);
 341
 342         dtwm.origMoveOpaque =
 343                (strcmp(string, "true") ? False : True);
 344         XmToggleButtonGadgetSetState (dtwm.moveOpaqueTG,
 345                dtwm.origMoveOpaque, True);
 346
 347         XtFree (string);
 348     }
 349     else /* MoveOpaque not specified */
 350     {
 351         /* set the Dtwm default value: False */
 352
 353         dtwm.origMoveOpaque =  False;
 354         XmToggleButtonGadgetSetState (dtwm.moveOpaqueTG,
 355                 dtwm.origMoveOpaque, True);
 356     }
 357
 358 }
 359
 360 /*+++++++++++++++++++++++++++++++++++++++*/
 361 /* build__dtwmDlg                        */
 362 /*+++++++++++++++++++++++++++++++++++++++*/
 363 static Widget
 364 build_dtwmDlg(
 365         Widget shell )
 366 {
 367     register int     i, n;
 368     Arg              args[MAX_ARGS];
 369     XmString         button_string[NUM_LABELS];
 370     XmString         string;
 371     Widget           form;
 372     Widget           windowFocusForm;
 373     Widget           iconPlacementForm;
 374     int              count = 0;
 375     Widget           widgetList1[6];
 376
 377     /* get dtwm resource values  */
 378
 379     /* Set up DialogBoxDialog button labels */
 380     button_string[0] = CMPSTR(_DtOkString);
 381     button_string[1] = CMPSTR(_DtCancelString);
 382     button_string[2] = CMPSTR(_DtHelpString);
 383
 384     /* Create toplevel DialogBox */
 385     /* saveRestore
 386      * Note that save.poscnt has been initialized elsewhere.
 387      * save.posArgs may contain information from restoreBeep().*/
 388
 389     XtSetArg(save.posArgs[save.poscnt], XmNbuttonCount, NUM_LABELS);  save.poscnt++;
 390     XtSetArg(save.posArgs[save.poscnt], XmNbuttonLabelStrings, button_string);  save.poscnt++;
 391     XtSetArg(save.posArgs[save.poscnt], XmNdefaultPosition, False);
 392     save.poscnt++;
 393     style.dtwmDialog =
 394         __DtCreateDialogBoxDialog(shell, "dtwmDialog", save.posArgs, save.poscnt);
 395     XtAddCallback(style.dtwmDialog, XmNhelpCallback,
 396             (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_DTWM_DIALOG);
 397
 398     XmStringFree(button_string[0]);
 399     XmStringFree(button_string[1]);
 400     XmStringFree(button_string[2]);
 401
 402     widgetList1[0] = _DtDialogBoxGetButton(style.dtwmDialog,2);
 403     n=0;
 404     XtSetArg(args[n], XmNautoUnmanage, False); n++;
 405     XtSetArg(args[n], XmNcancelButton, widgetList1[0]); n++;
 406     XtSetValues (style.dtwmDialog, args, n);
 407
 408     n=0;
 409     XtSetArg(args[n], XmNtitle, ((char *)GETMESSAGE(18, 1, "Style Manager - Window"))); n++;
 410     XtSetArg (args[n], XmNuseAsyncGeometry, True); n++;
 411     XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC); n++;
 412     XtSetValues (XtParent(style.dtwmDialog), args, n);
 413
 414     n = 0;
 415     XtSetArg(args[n], XmNallowOverlap, False); n++;
 416     XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
 417     form = XmCreateForm(style.dtwmDialog, "dtwmForm", args, n);
 418
 419     n = 0;
 420     XtSetArg(args[n], XmNfillMode, XmFILL_SELF); n++;
 421     XtSetArg(args[n], XmNbehavior, XmICON_LABEL); n++;
 422     XtSetArg(args[n], XmNpixmapForeground, style.secBSCol); n++;
 423     XtSetArg(args[n], XmNpixmapBackground, style.secTSCol); n++;
 424     XtSetArg(args[n], XmNstring, NULL); n++;
 425     XtSetArg(args[n], XmNshadowThickness, 0); n++;
 426     XtSetArg(args[n], XmNimageName, DTWM_ICON); n++;
 427     XtSetArg(args[n], XmNtraversalOn, False); n++;
 428     widgetList1[count++] =
 429     dtwm.pictLabel = _DtCreateIcon(form, "dtwmpictLabel", args, n);
 430
 431     n = 0;
 432     XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT);  n++;
 433     XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH);  n++;
 434     string = CMPSTR(((char *)GETMESSAGE(18, 2, "Default")));
 435     XtSetArg(args[n], XmNlabelString, string); n++;
 436     widgetList1[count++] = dtwm.systemDefault =
 437         XmCreatePushButtonGadget(form, "systemDefault", args, n);
 438     XmStringFree(string);
 439
 440     n = 0;
 441     string = CMPSTR((char *)GETMESSAGE(18, 3, "Window Behavior"));
 442     XtSetArg(args[n], XmNtitleString, string);  n++;
 443     widgetList1[count++] = dtwm.windowFocusTB
 444         = _DtCreateTitleBox(form, "windowFocusTB", args, n);
 445     XmStringFree(string);
 446
 447     n = 0;
 448     XtSetArg(args[n], XmNallowOverlap, False); n++;
 449     XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
 450     windowFocusForm =
 451         XmCreateForm(dtwm.windowFocusTB, "windowFocusForm", args, n);
 452
 453     n = 0;
 454     string = CMPSTR((char *)GETMESSAGE(18, 4, "Window Icons"));
 455     XtSetArg(args[n], XmNtitleString, string);  n++;
 456     widgetList1[count++] = dtwm.iconPlacementTB
 457         = _DtCreateTitleBox(form, "iconPlacementTB", args, n);
 458     XmStringFree(string);
 459
 460     n = 0;
 461     XtSetArg(args[n], XmNallowOverlap, False); n++;
 462     XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
 463     iconPlacementForm =
 464         XmCreateForm(dtwm.iconPlacementTB, "iconPlacementForm", args, n);
 465
 466     n = 0;
 467     XtSetArg(args[n], XmNmarginWidth, 0); n++;
 468     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 469     dtwm.focusPolicyRC =
 470         XmCreateRadioBox(windowFocusForm, "focusPolicyRC", args, n);
 471
 472     n = 0;
 473     string = CMPSTR((char *)GETMESSAGE(18, 13, "Point In Window To Make Active"));
 474     XtSetArg(args[n], XmNlabelString, string); n++;
 475     dtwm.pointerTG =
 476         XmCreateToggleButtonGadget(dtwm.focusPolicyRC, "pointerTG", args, n);
 477     XmStringFree(string);
 478
 479     n = 0;
 480     string = CMPSTR((char *)GETMESSAGE(18, 14, "Click In Window To Make Active"));
 481     XtSetArg(args[n], XmNlabelString, string); n++;
 482     dtwm.explicitTG =
 483         XmCreateToggleButtonGadget(dtwm.focusPolicyRC, "explicitTG", args, n);
 484     XmStringFree(string);
 485
 486     n = 0;
 487     XtSetArg(args[n], XmNmargin, 0); n++;
 488     dtwm.focusSeparator =
 489         XmCreateSeparatorGadget(windowFocusForm, "focusSeparator", args, n);
 490
 491     n = 0;
 492     string = CMPSTR((char *)GETMESSAGE(18, 15, "Raise Window When Made Active"));
 493     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 494     XtSetArg(args[n], XmNlabelString, string);  n++;
 495     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
 496     dtwm.autoRaiseTG =
 497         XmCreateToggleButtonGadget(windowFocusForm, "autoRaiseTG", args, n);
 498     XmStringFree(string);
 499
 500
 501     n = 0;
 502     string = CMPSTR((char *)GETMESSAGE(18, 11, "Allow Primary Windows On Top"));
 503     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 504     XtSetArg(args[n], XmNlabelString, string);  n++;
 505     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
 506     dtwm.secStackTG =
 507         XmCreateToggleButtonGadget(windowFocusForm, "secStackTG", args, n);
 508     XmStringFree(string);
 509
 510     n = 0;
 511     string = CMPSTR((char *)GETMESSAGE(18, 16, "Show Contents During Move"));
 512     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 513     XtSetArg(args[n], XmNlabelString, string);  n++;
 514     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);  n++;
 515     dtwm.moveOpaqueTG =
 516         XmCreateToggleButtonGadget(windowFocusForm, "moveOpaqueTG", args, n);
 517     XmStringFree(string);
 518
 519     n = 0;
 520     XtSetArg(args[n], XmNmarginWidth, 0); n++;
 521     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 522     dtwm.useIconBoxRC =
 523         XmCreateRadioBox(iconPlacementForm, "useIconBoxRC", args, n);
 524
 525     n = 0;
 526     string = CMPSTR((char *)GETMESSAGE(18, 9, "Use Icon Box"));
 527     XtSetArg(args[n], XmNlabelString, string); n++;
 528     dtwm.iconBoxTG =
 529         XmCreateToggleButtonGadget(dtwm.useIconBoxRC, "iconBoxTG", args, n);
 530     XmStringFree(string);
 531
 532     n = 0;
 533     string = CMPSTR((char *)GETMESSAGE(18, 10, "Place On Workspace"));
 534     XtSetArg(args[n], XmNlabelString, string); n++;
 535     dtwm.desktopTG =
 536         XmCreateToggleButtonGadget(dtwm.useIconBoxRC, "desktopTG", args, n);
 537     XmStringFree(string);
 538
 539     XtAddCallback(style.dtwmDialog, XmNmapCallback, formLayoutCB, NULL);
 540     XtAddCallback(style.dtwmDialog, XmNmapCallback, _DtmapCB_dtwmDlg, shell);
 541     XtAddCallback(style.dtwmDialog, XmNcallback, ButtonCB, NULL);
 542     XtAddCallback(dtwm.systemDefault, XmNactivateCallback, systemDefaultCB, NULL);
 543
 544     XtManageChild(form);
 545     XtManageChildren(widgetList1,count);
 546
 547     XtManageChild(windowFocusForm);
 548     XtManageChild(iconPlacementForm);
 549
 550     XtManageChild(dtwm.focusPolicyRC);
 551     XtManageChild(dtwm.pointerTG);
 552     XtManageChild(dtwm.explicitTG);
 553
 554     XtManageChild(dtwm.focusSeparator);
 555     XtManageChild(dtwm.autoRaiseTG);
 556     XtManageChild(dtwm.secStackTG);
 557     XtManageChild(dtwm.moveOpaqueTG);
 558
 559     XtManageChild(dtwm.useIconBoxRC);
 560     XtManageChild(dtwm.iconBoxTG);
 561     XtManageChild(dtwm.desktopTG);
 562
 563     return(style.dtwmDialog);
 564 }
 565
 566
 567 /*+++++++++++++++++++++++++++++++++++++++*/
 568 /* formLayoutCB                          */
 569 /*+++++++++++++++++++++++++++++++++++++++*/
 570 static void
 571 formLayoutCB(
 572         Widget w,
 573         XtPointer client_data,
 574         XtPointer call_data )
 575 {
 576     int              n;
 577     Arg              args[MAX_ARGS];
 578
 579     /* Picture Label */
 580     n=0;
 581     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
 582     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
 583     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
 584     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
 585     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
 586     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
 587     XtSetValues (dtwm.pictLabel, args, n);
 588
 589     /* system Default */
 590     n=0;
 591     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
 592     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
 593     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
 594     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);       n++;
 595     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
 596     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
 597     XtSetValues (dtwm.systemDefault, args, n);
 598
 599     /* Window Focus TitleBox */
 600     n=0;
 601     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);     n++;
 602     XtSetArg(args[n], XmNtopWidget,          dtwm.pictLabel);     n++;
 603     XtSetArg(args[n], XmNtopOffset,          style.horizontalSpacing);  n++;
 604     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
 605     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
 606     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
 607     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM); n++;
 608     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
 609     XtSetValues (dtwm.windowFocusTB, args, n);
 610
 611     /* Icon Placement TitleBox */
 612     n=0;
 613     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);     n++;
 614     XtSetArg(args[n], XmNtopWidget,          dtwm.windowFocusTB); n++;
 615     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
 616     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_FORM);       n++;
 617     XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing);    n++;
 618     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
 619     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
 620     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM); n++;
 621     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
 622     XtSetValues (dtwm.iconPlacementTB, args, n);
 623
 624     /* FocusPolicy RC */
 625     n=0;
 626     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
 627     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
 628     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
 629     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
 630     XtSetArg(args[n], XmNleftOffset,         0);  n++;
 631     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
 632     XtSetArg(args[n], XmNrightOffset,        0);  n++;
 633     XtSetValues (dtwm.focusPolicyRC, args, n);
 634
 635     /* FocusSeparator */
 636     n=0;
 637     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);       n++;
 638     XtSetArg(args[n], XmNtopWidget,          dtwm.focusPolicyRC);   n++;
 639     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing); n++;
 640     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);         n++;
 641     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);         n++;
 642     XtSetArg(args[n], XmNleftOffset,         0);  n++;
 643     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
 644     XtSetArg(args[n], XmNrightOffset,        0);  n++;
 645     XtSetValues (dtwm.focusSeparator, args, n);
 646
 647     /* AutoRaise TG */
 648     n=0;
 649     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);       n++;
 650     XtSetArg(args[n], XmNtopWidget,          dtwm.focusSeparator);  n++;
 651     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing); n++;
 652     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);         n++;
 653     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);         n++;
 654     XtSetArg(args[n], XmNleftOffset,         0);  n++;
 655     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
 656     XtSetArg(args[n], XmNrightOffset,        0);  n++;
 657     XtSetValues (dtwm.autoRaiseTG, args, n);
 658
 659     /* secStack TG */
 660     n=0;
 661     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);       n++;
 662     XtSetArg(args[n], XmNtopWidget,          dtwm.autoRaiseTG);     n++;
 663     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing-3); n++;
 664     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);         n++;
 665     XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing); n++;
 666     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);         n++;
 667     XtSetArg(args[n], XmNleftOffset,         0);  n++;
 668     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
 669     XtSetArg(args[n], XmNrightOffset,        0);  n++;
 670     XtSetValues (dtwm.secStackTG, args, n);
 671
 672
 673     /* MoveOpaque TG */
 674     n=0;
 675     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);       n++;
 676     XtSetArg(args[n], XmNtopWidget,          dtwm.secStackTG);     n++;
 677     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing-3); n++;
 678     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_FORM);         n++;
 679     XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing); n++;
 680     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);         n++;
 681     XtSetArg(args[n], XmNleftOffset,         0);  n++;
 682     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
 683     XtSetArg(args[n], XmNrightOffset,        0);  n++;
 684     XtSetValues (dtwm.moveOpaqueTG, args, n);
 685
 686     /* Use Icon Box RC */
 687     n=0;
 688     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
 689     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
 690     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_FORM);       n++;
 691     XtSetArg(args[n], XmNbottomOffset,       0);    n++;
 692     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
 693     XtSetArg(args[n], XmNleftOffset,         0);  n++;
 694     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
 695     XtSetArg(args[n], XmNrightOffset,        0);  n++;
 696     XtSetValues (dtwm.useIconBoxRC, args, n);
 697
 698     XtRemoveCallback(style.dtwmDialog, XmNmapCallback, formLayoutCB, NULL);
 699 }
 700
 701 /*+++++++++++++++++++++++++++++++++++++++*/
 702 /* _DtmapCB_dtwmDlg                        */
 703 /*+++++++++++++++++++++++++++++++++++++++*/
 704 static void
 705 _DtmapCB_dtwmDlg(
 706         Widget w,
 707         XtPointer client_data,
 708         XtPointer call_data )
 709 {
 710
 711     static int  first_time = 1;
 712     int         n;
 713     Arg         args[MAX_ARGS];
 714
 715
 716     DtWsmRemoveWorkspaceFunctions(style.display, XtWindow(XtParent(w)));
 717
 718     if (!save.restoreFlag)
 719         putDialog ((Widget)client_data, w);
 720
 721     XtRemoveCallback(style.dtwmDialog, XmNmapCallback, _DtmapCB_dtwmDlg, NULL);
 722
 723 }
 724
 725
 726 /*+++++++++++++++++++++++++++++++++++++++*/
 727 /* systemDefaultCB                       */
 728 /*+++++++++++++++++++++++++++++++++++++++*/
 729 static void
 730 systemDefaultCB(
 731         Widget w,
 732         XtPointer client_data,
 733         XtPointer call_data )
 734 {
 735
 736     /* KeyboardFocusPolicy:  explicit */
 737     XmToggleButtonGadgetSetState (dtwm.explicitTG, True, True);
 738
 739     /* FocusAutoRaise:  True */
 740     XmToggleButtonGadgetSetState (dtwm.autoRaiseTG, True, True);
 741
 742 #ifdef sun
 743     /* Sun default is secStack: False */
 744     XmToggleButtonGadgetSetState (dtwm.secStackTG, True, True);
 745 #else
 746     /* secStack:  True */
 747     XmToggleButtonGadgetSetState (dtwm.secStackTG, False, True);
 748 #endif
 749
 750     /* OpaqueMove:  False */
 751     XmToggleButtonGadgetSetState (dtwm.moveOpaqueTG, False, True);
 752
 753     /* PlaceOnDesktop:  True */
 754     XmToggleButtonGadgetSetState (dtwm.desktopTG, True, True);
 755
 756 }
 757
 758 /*+++++++++++++++++++++++++++++++++++++++*/
 759 /* ButtonCB                              */
 760 /* callback for PushButtons in DialogBox */
 761 /*+++++++++++++++++++++++++++++++++++++++*/
 762 static void
 763 ButtonCB(
 764         Widget w,
 765         XtPointer client_data,
 766         XtPointer call_data )
 767 {
 768   int         n;
 769   Arg         args[MAX_ARGS];
 770   char        *resPtr;
 771   Boolean     state;
 772   Boolean     changeFlag = 0;
 773   DtDialogBoxCallbackStruct *cb = (DtDialogBoxCallbackStruct *) call_data;
 774
 775   switch (cb->button_position)
 776     {
 777     case OK_BUTTON:
 778
 779       XtUnmanageChild (w);
 780
 781       /* create the Dtwm resource specs for xrdb */
 782
 783       state = XmToggleButtonGadgetGetState (dtwm.explicitTG);
 784       if ( state != dtwm.origKeyboardFocusPolicy)
 785         {
 786           sprintf(dtwmRes, "Dtwm.keyboardFocusPolicy: %s\n",
 787                   XmToggleButtonGadgetGetState (dtwm.pointerTG)
 788                   ? POINTER_STR : EXPLICIT_STR);
 789           changeFlag = 1;
 790         }
 791
 792       /* write out FocusAutoRaise if toggle has changed or if
 793        * KeyboardFocusPolicy has changed.  FAR default value is
 794        * based off of KFP so must set explicitly or visible toggle
 795        * will be inacurate */
 796       state = XmToggleButtonGadgetGetState (dtwm.autoRaiseTG);
 797       if (state !=  dtwm.origFocusAutoRaise || changeFlag)
 798         {
 799           sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*focusAutoRaise: %s\n",
 800                   XmToggleButtonGadgetGetState (dtwm.autoRaiseTG)
 801                   ? "True" : "False");
 802           changeFlag = 1;
 803         }
 804
 805       state = !XmToggleButtonGadgetGetState (dtwm.secStackTG);
 806       if ( state != dtwm.origSecStack)
 807         {
 808           sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*secondariesOnTop: %s\n",
 809                   XmToggleButtonGadgetGetState (dtwm.secStackTG)
 810                   ? "False" : "True");
 811           changeFlag = 1;
 812         }
 813
 814       state = XmToggleButtonGadgetGetState (dtwm.moveOpaqueTG);
 815       if ( state != dtwm.origMoveOpaque)
 816         {
 817           sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*moveOpaque: %s\n",
 818                   XmToggleButtonGadgetGetState (dtwm.moveOpaqueTG)
 819                   ? "True" : "False");
 820           changeFlag = 1;
 821         }
 822
 823       state = XmToggleButtonGadgetGetState (dtwm.iconBoxTG);
 824       if (state != dtwm.origUseIconBox)
 825         {
 826           sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*useIconBox: %s\n",
 827                   XmToggleButtonGadgetGetState (dtwm.iconBoxTG)
 828                   ? "True" : "False");
 829           changeFlag = 1;
 830         }
 831
 832       if (changeFlag)
 833         {
 834           if (dtwm.warnDialog == NULL)
 835             {
 836               n = 0;
 837               XtSetArg(args[n], XmNokLabelString, CMPSTR(_DtOkString)); n++;
 838               XtSetArg(args[n], XmNcancelLabelString, CMPSTR(_DtCancelString)); n++;
 839               XtSetArg(args[n], XmNborderWidth, 3); n++;
 840               XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC ); n++;
 841               XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
 842               XtSetArg(args[n], XmNdialogTitle, CMPSTR((char *)GETMESSAGE(2,2, "Notice"))); n++;
 843               XtSetArg(args[n], XmNmessageString, CMPSTR(WARN_MSG)); n++;
 844               dtwm.warnDialog = XmCreateInformationDialog(style.shell, "warnDialog", args, n);
 845
 846               XtUnmanageChild (XmMessageBoxGetChild(dtwm.warnDialog, XmDIALOG_HELP_BUTTON));
 847
 848               XtAddCallback(dtwm.warnDialog, XmNokCallback, okWarnCB,
 849                             client_data);
 850               XtAddCallback(dtwm.warnDialog, XmNcancelCallback, cancelWarnCB,
 851                             client_data);
 852             }
 853           XtManageChild(dtwm.warnDialog);
 854
 855         }
 856       break;
 857
 858
 859     case CANCEL_BUTTON:
 860
 861       /* reset to dtwm values from when dialog is mapped */
 862       XtUnmanageChild(w);
 863
 864       XmToggleButtonGadgetSetState (dtwm.pointerTG,
 865                                     dtwm.origKeyboardFocusPolicy ? POINTER : EXPLICIT , True);
 866
 867       XmToggleButtonGadgetSetState (dtwm.explicitTG,
 868                                     dtwm.origKeyboardFocusPolicy ? EXPLICIT : POINTER , True);
 869
 870       XmToggleButtonGadgetSetState (dtwm.autoRaiseTG,
 871                                     dtwm.origFocusAutoRaise ? True : False , True);
 872
 873       XmToggleButtonGadgetSetState (dtwm.secStackTG,
 874                                     dtwm.origSecStack ? False : True , True);
 875
 876       XmToggleButtonGadgetSetState (dtwm.moveOpaqueTG,
 877                                     dtwm.origMoveOpaque ? True : False , True);
 878
 879       XmToggleButtonGadgetSetState (dtwm.iconBoxTG,
 880                                     dtwm.origUseIconBox ? True : False , True);
 881
 882       XmToggleButtonGadgetSetState (dtwm.desktopTG,
 883                                     dtwm.origUseIconBox ? False : True , True);
 884
 885       break;
 886
 887   case HELP_BUTTON:
 888     XtCallCallbacks(style.dtwmDialog, XmNhelpCallback, (XtPointer)NULL);
 889     break;
 890
 891   default:
 892     break;
 893   }
 894 }
 895
 896
 897 /************************************************************************
 898  * restoreDtwm()
 899  * /u1/shakib/ncode
 900  * restore any state information saved with savedtwm.
 901  * This is called from restoreSession with the application
 902  * shell and the special xrm database retrieved for restore.
 903  ************************************************************************/
 904 void
 905 restoreDtwm(
 906         Widget shell,
 907         XrmDatabase db )
 908 {
 909     XrmName xrm_name[5];
 910     XrmRepresentation rep_type;
 911     XrmValue value;
 912
 913     xrm_name [0] = XrmStringToQuark ("dtwmDlg");
 914     xrm_name [2] = NULL;
 915
 916     /* get x position */
 917     xrm_name [1] = XrmStringToQuark ("x");
 918     if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value)){
 919       XtSetArg (save.posArgs[save.poscnt], XmNx, atoi((char *)value.addr)); save.poscnt++;
 920       save.restoreFlag = True;
 921     }
 922
 923     /* get y position */
 924     xrm_name [1] = XrmStringToQuark ("y");
 925     if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value)){
 926       XtSetArg (save.posArgs[save.poscnt], XmNy, atoi((char *)value.addr)); save.poscnt++;
 927     }
 928
 929     xrm_name [1] = XrmStringToQuark ("ismapped");
 930     XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value);
 931     /* Are we supposed to be mapped? */
 932     if (strcmp(value.addr, "True") == 0)
 933       popup_dtwmBB(shell);
 934 }
 935
 936 /************************************************************************
 937  * saveDtwm()
 938  *
 939  * This routine will write out to the passed file descriptor any state
 940  * information this dialog needs.  It is called from saveSessionCB with the
 941  * file already opened.
 942  * All information is saved in xrm format.  There is no restriction
 943  * on what can be saved.  It doesn't have to be defined or be part of any
 944  * widget or Xt definition.  Just name and save it here and recover it in
 945  * restoreBackdrop.  The suggested minimum is whether you are mapped, and your
 946  * location.
 947  ************************************************************************/
 948 void
 949 saveDtwm(
 950         int fd )
 951 {
 952     Position x,y;
 953     Dimension width, height;
 954     char *bufr = style.tmpBigStr;     /* size=[1024], make bigger if needed */
 955     XmVendorShellExtObject  vendorExt;
 956     XmWidgetExtData         extData;
 957
 958     if (style.dtwmDialog != NULL)
 959     {
 960         if (XtIsManaged(style.dtwmDialog))
 961             sprintf(bufr, "*dtwmDlg.ismapped: True\n");
 962         else
 963             sprintf(bufr, "*dtwmDlg.ismapped: False\n");
 964
 965         /* Get and write out the geometry info for our Window */
 966         x = XtX(XtParent(style.dtwmDialog));
 967         y = XtY(XtParent(style.dtwmDialog));
 968
 969         /* Modify x & y to take into account window mgr frames
 970          * This is pretty bogus, but I don't know a better way to do it.
 971          */
 972         extData = _XmGetWidgetExtData(style.shell, XmSHELL_EXTENSION);
 973         vendorExt = (XmVendorShellExtObject)extData->widget;
 974         x -= vendorExt->vendor.xOffset;
 975         y -= vendorExt->vendor.yOffset;
 976
 977         width = XtWidth(style.dtwmDialog);
 978         height = XtHeight(style.dtwmDialog);
 979
 980         sprintf(bufr, "%s*dtwmDlg.x: %d\n", bufr, x);
 981         sprintf(bufr, "%s*dtwmDlg.y: %d\n", bufr, y);
 982         sprintf(bufr, "%s*dtwmDlg.width: %d\n", bufr, width);
 983         sprintf(bufr, "%s*dtwmDlg.height: %d\n", bufr, height);
 984         write (fd, bufr, strlen(bufr));
 985     }
 986 }
 987
 988 \f
 989 /*************************************<->*************************************
 990  *
 991  *  _DtWmParseToLower (string)
 992  *
 993  *
 994  *  Description:
 995  *  -----------
 996  *  Lower all characters in a string.
 997  *
 998  *
 999  *  Inputs:
1000  *  ------
1001  *  string = NULL-terminated character string or NULL
1002  *
1003  *
1004  *  Outputs:
1005  *  -------
1006  *  string = NULL-terminated lower case character string or NULL
1007  *
1008  *
1009  *  Comments:
1010  *  --------
1011  *  Can handle multi-byte characters
1012  *
1013  *************************************<->***********************************/
1014
1015 static
1016 void _DtWmParseToLower (unsigned char  *string)
1017 {
1018     unsigned char *pch = string;
1019 #ifdef MULTIBYTE
1020     int            chlen;
1021
1022     while ((chlen = mblen ((char *)pch, MB_CUR_MAX)) > 0)
1023     {
1024         if ((chlen == 1) && (isupper (*pch)))
1025         {
1026             *pch = tolower(*pch);
1027         }
1028         pch += chlen;
1029     }
1030 #else
1031     while (*pch != NULL)
1032     {
1033         if (isupper (*pch))
1034         {
1035             *pch = tolower(*pch);
1036         }
1037         pch++;
1038     }
1039 #endif
1040
1041 } /* END OF FUNCTION _DtWmParseToLower */
1042
1043
1044
1045
1046 /*+++++++++++++++++++++++++++++++++++++++*/
1047 /* cancelWarnCB - callback for the      */
1048 /* cancel button of the warnDialog      */
1049 /*+++++++++++++++++++++++++++++++++++++++*/
1050
1051 static void
1052 cancelWarnCB(
1053         Widget w,
1054         XtPointer client_data,
1055         XtPointer call_data )
1056 {
1057   XmToggleButtonGadgetSetState (dtwm.pointerTG,
1058                                 dtwm.origKeyboardFocusPolicy ? POINTER : EXPLICIT , True);
1059
1060   XmToggleButtonGadgetSetState (dtwm.explicitTG,
1061             dtwm.origKeyboardFocusPolicy ? EXPLICIT : POINTER , True);
1062
1063   XmToggleButtonGadgetSetState (dtwm.autoRaiseTG,
1064                                 dtwm.origFocusAutoRaise ? True : False , True);
1065
1066   XmToggleButtonGadgetSetState (dtwm.secStackTG,
1067             dtwm.origSecStack ? False : True , True);
1068
1069   XmToggleButtonGadgetSetState (dtwm.moveOpaqueTG,
1070                                 dtwm.origMoveOpaque ? True : False , True);
1071
1072   XmToggleButtonGadgetSetState (dtwm.iconBoxTG,
1073             dtwm.origUseIconBox ? True : False , True);
1074
1075   XmToggleButtonGadgetSetState (dtwm.desktopTG,
1076                                 dtwm.origUseIconBox ? False : True , True);
1077 }
1078
1079
1080
1081
1082 /*+++++++++++++++++++++++++++++++++++++++*/
1083 /* okWarnCB - callback for the           */
1084 /* OK button of the warnDialog           */
1085 /*+++++++++++++++++++++++++++++++++++++++*/
1086
1087 static void
1088 okWarnCB(
1089         Widget w,
1090         XtPointer client_data,
1091         XtPointer call_data )
1092 {
1093   dtwm.origKeyboardFocusPolicy = XmToggleButtonGadgetGetState (dtwm.explicitTG);
1094   dtwm.origFocusAutoRaise = XmToggleButtonGadgetGetState (dtwm.autoRaiseTG);
1095   dtwm.origSecStack = !XmToggleButtonGadgetGetState (dtwm.secStackTG);
1096   dtwm.origMoveOpaque = XmToggleButtonGadgetGetState (dtwm.moveOpaqueTG);
1097   dtwm.origUseIconBox = XmToggleButtonGadgetGetState (dtwm.iconBoxTG);
1098
1099
1100   /* write out resources to xrdb */
1101   _DtAddToResource(style.display, dtwmRes);
1102
1103   /* force the workspace manager to restart */
1104   _DtWmRestartNoConfirm(style.display, style.root);
1105 }
1106
1107
1108
1109
1110
1111