cde/programs/dtstyle/Dtwm.c

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