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