cde/programs/dtstyle/Screen.c

   1 /************************************<+>*************************************/
   2 /****************************************************************************/
   3 /**                                                                        **/
   4 /**   File:        Screen.c                                                **/
   5 /**                                                                        **/
   6 /**   Project:     DT 1.0                                                  **/
   7 /**                                                                        **/
   8 /**   Description: Controls the Dtstyle Screen dialog                      **/
   9 /**                                                                        **/
  10 /**                                                                        **/
  11 /**                                                                        **/
  12 /**                                                                        **/
  13 /****************************************************************************/
  14 /************************************<+>*************************************/
  15
  16 /*$TOG: Screen.c /main/9 1997/07/14 17:44:42 samborn $*/
  17
  18 #include <X11/Xlib.h>
  19 #include <Xm/MwmUtil.h>
  20
  21 #include <Xm/Xm.h>
  22 #include <Xm/XmP.h>
  23 #include <Xm/DrawingA.h>
  24 #include <Xm/Form.h>
  25 #include <Xm/List.h>
  26 #include <Xm/Frame.h>
  27 #include <Xm/LabelG.h>
  28 #include <Xm/PushBG.h>
  29 #include <Xm/PushB.h>
  30 #include <Xm/RowColumn.h>
  31 #include <Xm/Scale.h>
  32 #include <Xm/ToggleBG.h>
  33 #include <Xm/VendorSEP.h>
  34 #include <Xm/Protocols.h>
  35
  36 #include <stdio.h>
  37 #include <signal.h>
  38
  39 #include <X11/Intrinsic.h>
  40 #include <X11/Xutil.h>
  41 #include <X11/Xatom.h>
  42
  43 #include <Dt/Action.h>
  44 #include <Dt/UserMsg.h>
  45 #include <Dt/SaverP.h>
  46 #include <Dt/DialogBox.h>
  47 #include <Dt/Icon.h>
  48 #include <Dt/TitleBox.h>
  49 #include <Dt/Message.h>
  50 #include <Dt/HourGlass.h>
  51
  52 #include "Help.h"
  53 #include "Main.h"
  54 #include "SaveRestore.h"
  55 #include "Protocol.h"
  56
  57 /*+++++++++++++++++++++++++++++++++++++++*/
  58 /* include extern functions              */
  59 /*+++++++++++++++++++++++++++++++++++++++*/
  60 #include "Screen.h"
  61
  62 /*+++++++++++++++++++++++++++++++++++++++*/
  63 /* Local #defines                        */
  64 /*+++++++++++++++++++++++++++++++++++++++*/
  65 #ifndef MIN
  66 #define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
  67 #endif
  68 #define TIMEOUT_MIN         1
  69 #define TIMEOUT_MAX         120
  70 #define CYCLETIME_MIN       0
  71 #define CYCLE_DEFAULT       3   /* 1-120 */
  72 #define LOCK_DEFAULT        30  /* 1-120 */
  73 #define SAVER_DEFAULT       10  /* 0-120 */
  74 #define SAVER_HEIGHT        238
  75 #define SAVER_WIDTH         298
  76
  77 /*+++++++++++++++++++++++++++++++++++++++*/
  78 /* Internal Functions                    */
  79 /*+++++++++++++++++++++++++++++++++++++++*/
  80
  81 static Widget build_screenDialog( Widget shell) ;
  82
  83 static void formLayoutCB(Widget w,
  84                          XtPointer client_data,
  85                          XtPointer call_data) ;
  86
  87 static void no_svr_ext_formLayoutCB(Widget w,
  88                                     XtPointer client_data,
  89                                     XtPointer call_data) ;
  90
  91 static void _DtmapCB_screenDialog(Widget w,
  92                                   XtPointer client_data,
  93                                   XtPointer call_data) ;
  94
  95 static void no_svr_ext_DtmapCB_screenDialog(Widget w,
  96                                   XtPointer client_data,
  97                                   XtPointer call_data) ;
  98
  99 static void timeOutvalueChangedCB(Widget w,
 100                                   XtPointer client_data,
 101                                   XtPointer call_data) ;
 102
 103 static void no_svr_ext_timeOutvalueChangedCB(Widget w,
 104                                   XtPointer client_data,
 105                                   XtPointer call_data) ;
 106
 107 static void saverToggleCB(Widget w,
 108                           XtPointer client_data,
 109                           XtPointer call_data) ;
 110
 111 static void no_svr_ext_saverToggleCB(Widget w,
 112                           XtPointer client_data,
 113                           XtPointer call_data) ;
 114
 115 static void saversToggleCB(Widget w,
 116                           XtPointer client_data,
 117                           XtPointer call_data) ;
 118
 119 static void lockToggleCB(Widget w,
 120                          XtPointer client_data,
 121                          XtPointer call_data) ;
 122
 123 static void systemDefaultCB(Widget w,
 124                             XtPointer client_data,
 125                             XtPointer call_data) ;
 126
 127 static void no_svr_ext_systemDefaultCB(Widget w,
 128                             XtPointer client_data,
 129                             XtPointer call_data) ;
 130
 131 static void ButtonCB(Widget w,
 132                      XtPointer client_data,
 133                      XtPointer call_data) ;
 134
 135 static void no_svr_ext_ButtonCB(Widget w,
 136                      XtPointer client_data,
 137                      XtPointer call_data) ;
 138
 139 static XmString * MakeListStrings(char **list ) ;
 140
 141 static  void FreeListStrings(XmString *xmlist,
 142                              int count) ;
 143
 144 static void ListCB(Widget w,
 145                    XtPointer client_data,
 146                    XtPointer call_data) ;
 147
 148 static void IconHandler(Widget shell,
 149                         XtPointer client_data,
 150                         XEvent *event,
 151                         Boolean *dispatch) ;
 152
 153 static void UnmapCB(Widget w,
 154                     XtPointer client_data,
 155                     XtPointer call_data) ;
 156
 157
 158 /*+++++++++++++++++++++++++++++++++++++++*/
 159 /* Internal Variables                    */
 160 /*+++++++++++++++++++++++++++++++++++++++*/
 161 typedef struct {
 162     Widget      pictLabel;
 163     Widget      systemDefault;
 164     Widget      saverFrame;
 165     Widget      saverForm;
 166     Widget      saverArea;
 167     Widget      saverAreaFrame;
 168     Widget      saverLabel;
 169     Widget      prevLabel;
 170     Widget      saverOn;
 171     Widget      saverOff;
 172     Widget      saverRadioBox;
 173     Widget      saverList;
 174     Widget      timeOutLabel;
 175     Widget      timeOutScale;
 176     Widget      saverMinutesLabel;
 177     Widget      cycleTimeLabel;
 178     Widget      cycleTimeScale;
 179     Widget      cycleMinutesLabel;
 180     Widget      lockFrame;
 181     Widget      lockForm;
 182     Widget      lockLabel;
 183     Widget      lockOn;
 184     Widget      lockOff;
 185     Widget      lockRadioBox;
 186     Widget      lockingRadioBox;
 187     Widget      lockOutLabel;
 188     Widget      lockOutScale;
 189     Widget      lockMinutesLabel;
 190     Widget      useSaversOn;        /* used for graying saverList and saverArea in no saver extn mode */
 191     Widget      useSaversOff;       /* used for graying saverList and saverArea in no saver extn mode */
 192     int         interval;
 193     int         blanking;
 194     int         exposures;
 195     int         newTimeout;          /* the min value of savertimeout and locktimeout */
 196     int         origTimeout;         /* the original value of the min of savertimeout and locktimeout */
 197     int         xTimeout;            /* the value of the timeout extracted from the X server */
 198     Boolean     timeMismatch;        /* use to keep track of mismatch between xTimeout and newTimeout */
 199     int         saverTimeout;        /* the value of savertimeout */
 200     int         lockTimeout;         /* the value of locktimeout */
 201     int         cycleTimeout;        /* the value of cycletimeout */
 202     int         saverTimeout_xrdb;   /* the value of savertimeout from xrdb, in case saver is off */
 203     int         lockTimeout_xrdb;    /* the value of locktimeout from xrdb, in case lock is off */
 204     int         new_blanking;
 205     Boolean     systemDefaultFlag;
 206
 207 } ScreenData;                        /* using the savers toggle when the saver extn is not present */
 208
 209 static ScreenData  screen;
 210 static saveRestore save = {FALSE, 0,};
 211
 212 typedef struct {
 213   char    *saversList;                  /* list of available savers */
 214   char    *selsaversList;               /* list of selected savers */
 215   char   **saverActionNames;            /* array of saver names */
 216   char   **saverActionDesc;             /* array of saver action descriptions */
 217   char   **selsaverActionNames;         /* array of originally selected saver names */
 218   int     *selPositions;                /* array of currently selected saver positions */
 219   int     *origSelPositions;            /* array of originally selected saver positions */
 220   int      saverCount;                  /* number of available savers */
 221   int      selsaverCount;               /* number of currently selected screen savers */
 222   int      orig_selsaverCount;          /* number of originally selected screen savers */
 223   int      previous_selsaverCount;      /* number of previously selected screen savers */
 224   char    *current_saver;               /* name of current screen saver actions */
 225   char    *current_saverDesc;           /* description of current screen saver actions */
 226   int      current_position;            /* the clicked on position in the scrolled list */
 227   int      shadow;                      /* shadow width of saver area */
 228   Pixel    bg;                          /* bg color of the style manager dialogs */
 229   Pixel    black;                       /* value of the black pixel */
 230   void    *saverstate;                  /* current running screen saver state */
 231 } Savers, *SaversPtr;
 232 static Savers savers;
 233
 234
 235
 236
 237 /*++++++++++++++++++++++++++++++++++++++++*/
 238 /* build_saverList                        */
 239 /* parses a space separated list of       */
 240 /* savers to build a an array of saver    */
 241 /* names. Returns the array and the saver */
 242 /* count.                                 */
 243 /*++++++++++++++++++++++++++++++++++++++++*/
 244
 245 char **
 246 build_saverList(char * str,
 247                  int * count)
 248 {
 249    char tokenSep[] = " ";
 250    char * token;
 251    char ** saverList = NULL;
 252    register int i = 0;
 253    char * tmpStr, *tmpStr2;
 254    int len = strlen(str);
 255
 256
 257    *count = 0;
 258
 259    tmpStr = (char *)XtCalloc(1, len + 1);
 260    tmpStr2 = tmpStr;
 261    strcpy(tmpStr, str);
 262    token = strtok(tmpStr, tokenSep);
 263    while(token != NULL)
 264      {
 265        ++(i);
 266        token = strtok(NULL, tokenSep);
 267      }
 268
 269    if (i == 0)
 270        return (NULL);
 271
 272    saverList = (char **) XtCalloc(1, i * sizeof(char *));
 273    if( saverList )
 274      {
 275        strcpy(tmpStr, str);
 276        while (isspace(*tmpStr))
 277            tmpStr++;
 278        token = strtok(tmpStr, tokenSep);
 279        *count=0;
 280        while(token != NULL)
 281          {
 282            if (DtActionExists(token))
 283              {
 284                saverList[*count] = (char *) XtCalloc(1, strlen( token ) + 1);
 285                strcpy(saverList[*count], token);
 286                ++(*count);
 287              }
 288            tmpStr += strlen(token);
 289            if (tmpStr >= tmpStr2 + len )
 290                token = NULL;
 291            else
 292                {
 293                    do tmpStr++;
 294                    while (isspace(*tmpStr));
 295                    token = strtok(tmpStr, tokenSep);
 296                }
 297          }
 298      }
 299    if (tmpStr2)
 300        XtFree ((char *) tmpStr2);
 301    return(saverList);
 302  }
 303
 304 /*+++++++++++++++++++++++++++++++++++++++*/
 305 /* build_selsaverList                    */
 306 /*+++++++++++++++++++++++++++++++++++++++*/
 307
 308 char **
 309 build_selsaverList(char * envStr,
 310                  int * count)
 311 {
 312    char tokenSep[] = " ";
 313    char * token;
 314    char ** saverList = NULL;
 315    register int i = 0;
 316    char * tmpStr;
 317    int len = strlen(envStr);
 318    *count = 0;
 319
 320    tmpStr = (char *)XtCalloc(1, len + 1);
 321    strcpy(tmpStr, envStr);
 322    token = strtok(tmpStr, tokenSep);
 323    while(token != NULL)
 324      {
 325        ++(i);
 326        token = strtok(NULL, tokenSep);
 327      }
 328
 329    if (i == 0)
 330        return (NULL);
 331
 332    saverList = (char **) XtCalloc(1, i * sizeof(char *));
 333    if( saverList )
 334      {
 335        strcpy(tmpStr, envStr);
 336        token = strtok(tmpStr, tokenSep);
 337        *count=0;
 338        while(token != NULL)
 339          {
 340            saverList[*count] = (char *) XtCalloc(1, strlen( token ) + 1);
 341            strcpy(saverList[*count], token);
 342            token = strtok(NULL, tokenSep);
 343            ++(*count);
 344          }
 345      }
 346
 347    XtFree ((char *) tmpStr);
 348    return(saverList);
 349  }
 350
 351 /*+++++++++++++++++++++++++++++++++++++++*/
 352 /* build_saverDesc                       */
 353 /*+++++++++++++++++++++++++++++++++++++++*/
 354
 355 char **
 356 build_saverDesc(char ** names,
 357                  int count)
 358 {
 359   char          **saverDesc = NULL;
 360   char           *tmpstr;
 361   int             i;
 362
 363   saverDesc = (char **) XtCalloc(1, count * sizeof(char *));
 364
 365   for (i=0; i<count; i++)
 366     {
 367       tmpstr = DtActionDescription(savers.saverActionNames[i]);
 368       if (tmpstr == NULL)
 369         {
 370           saverDesc[i] = (char *) XtMalloc(strlen(savers.saverActionNames[i]) + 1);
 371           strcpy(saverDesc[i], savers.saverActionNames[i]);
 372         }
 373       else
 374         {
 375           saverDesc[i] = (char *) XtMalloc(strlen(tmpstr) + 1);
 376           strcpy(saverDesc[i], tmpstr);
 377         }
 378       XtFree((char *) tmpstr);
 379     }
 380   return(saverDesc);
 381 }
 382
 383
 384 /*+++++++++++++++++++++++++++++++++++++++*/
 385 /* build_selectedList                    */
 386 /* takes an array of names and a count   */
 387 /* and returns a space separated list    */
 388 /*+++++++++++++++++++++++++++++++++++++++*/
 389
 390 char *
 391 build_selectedList(char ** saverList,
 392                     int     count)
 393 {
 394
 395    char * selectedList = NULL;
 396    register int i = 0;
 397    char * tmpStr;
 398    int len = 0;
 399    int tmplen = 0;
 400
 401    if (saverList == NULL)
 402      return(NULL);
 403
 404    for (i=0; i<count; i++)
 405      {
 406        len += strlen(saverList[i]) + 1;
 407      }
 408
 409    selectedList = (char *)XtMalloc(len + 1);
 410    selectedList[0] = '\0';
 411    for (i=0; i<count; i++)
 412      {
 413        strcat(selectedList, saverList[i]);
 414        strcat(selectedList, " ");
 415      }
 416
 417    return(selectedList);
 418  }
 419
 420
 421 /*+++++++++++++++++++++++++++++++++++++++*/
 422 /* free_saverList                        */
 423 /*+++++++++++++++++++++++++++++++++++++++*/
 424
 425 void
 426 free_saverList(char ** saverList,
 427                     int count)
 428
 429 {
 430   register int   i;
 431
 432   if (saverList == NULL)
 433     return;
 434   for (i=0; i<count; i++)
 435     XtFree((char *) saverList[i]);
 436
 437   XtFree ((char *) saverList);
 438
 439 }
 440
 441 /*+++++++++++++++++++++++++++++++++++++++*/
 442 /* popup_screenBB                        */
 443 /*+++++++++++++++++++++++++++++++++++++++*/
 444
 445 void
 446 popup_screenBB(
 447         Widget shell )
 448 {
 449     if (style.screenDialog == NULL) {
 450       _DtTurnOnHourGlass(shell);
 451       build_screenDialog(shell);
 452       XtManageChild(style.screenDialog);
 453       _DtTurnOffHourGlass(shell);
 454     }
 455     else
 456     {
 457       XtManageChild(style.screenDialog);
 458       raiseWindow(XtWindow(XtParent(style.screenDialog)));
 459     }
 460 }
 461
 462 /*+++++++++++++++++++++++++++++++++++++++*/
 463 /* build_screenDialog                    */
 464 /*+++++++++++++++++++++++++++++++++++++++*/
 465 static Widget
 466 build_screenDialog(
 467         Widget shell )
 468 {
 469     register int     i, m, n;
 470     Arg              args[MAX_ARGS];
 471     Widget           form;
 472     Boolean          sel_matched = False;
 473     int              sel_found = 1;
 474     int              old_selsaverCount = 0;
 475     Widget           widget_list1[12];
 476     Widget           widget_list2[12];
 477     int              list1_count = 0;
 478     int              list2_count = 0;
 479     XmString         button_string[NUM_LABELS];
 480     XmString         string;
 481     XmString         *listStrings;
 482     XColor           color;
 483     Colormap         cmap;
 484     Dimension        MaxLabelWidth = 0;
 485     Dimension        LabelWidth = 0;
 486     Atom             delete_window_atom;
 487     Boolean          low_res = False;
 488
 489     /* initialize saver data */
 490     savers.shadow = 2;
 491     savers.saverstate = NULL;
 492     savers.saverCount = 0;
 493     savers.selsaverCount = 0;
 494     savers.previous_selsaverCount = 0;
 495     savers.saversList = NULL;
 496     savers.selsaverActionNames = NULL;
 497     savers.selPositions = NULL;
 498     savers.selsaversList = NULL;
 499     savers.saverActionNames = NULL;
 500     savers.saverActionDesc = NULL;
 501     savers.current_saver = NULL;
 502     savers.current_saverDesc = NULL;
 503     savers.current_position = 0;
 504     savers.black = BlackPixel(style.display, DefaultScreen(XtDisplay(shell)));
 505
 506     /* load the actions data base */
 507     DtDbLoad();
 508
 509     if (_DtGetDisplayResolution(style.display, style.screenNum) == 1)
 510       low_res = True;
 511
 512     /* Set up DialogBoxDialog button labels */
 513     button_string[0] = CMPSTR(_DtOkString);
 514     button_string[1] = CMPSTR(_DtCancelString);
 515     button_string[2] = CMPSTR(_DtHelpString);
 516
 517     /* Create toplevel DialogBox */
 518     /* saveRestore - Note that save.poscnt has been initialized elsewhere. */
 519     /* save.posArgs may contain information from restoreScreen().*/
 520
 521     XtSetArg(save.posArgs[save.poscnt], XmNbuttonCount, NUM_LABELS);
 522       save.poscnt++;
 523     XtSetArg(save.posArgs[save.poscnt], XmNbuttonLabelStrings, button_string);
 524       save.poscnt++;
 525     XtSetArg (save.posArgs[save.poscnt], XmNdefaultPosition, False);
 526       save.poscnt++;
 527     style.screenDialog =
 528       __DtCreateDialogBoxDialog(shell, "ScreenDialog", save.posArgs, save.poscnt);
 529
 530     XmStringFree(button_string[0]);
 531     XmStringFree(button_string[1]);
 532     XmStringFree(button_string[2]);
 533
 534     widget_list1[0] = _DtDialogBoxGetButton(style.screenDialog,2);
 535     n=0;
 536     XtSetArg(args[n], XmNautoUnmanage, False); n++;
 537     XtSetArg(args[n], XmNcancelButton, widget_list1[0]); n++;
 538     XtSetValues (style.screenDialog, args, n);
 539
 540
 541     /* Set the title */
 542     n=0;
 543     XtSetArg(args[n], XmNtitle, ((char *)GETMESSAGE(12, 1, "Style Manager - Screen"))); n++;
 544     XtSetArg(args[n], XmNuseAsyncGeometry, True); n++;
 545     XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC); n++;
 546     XtSetValues (XtParent(style.screenDialog), args, n);
 547
 548     /* Create the main form */
 549     n = 0;
 550     XtSetArg(args[n], XmNallowOverlap, False); n++;
 551     XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
 552     form=XmCreateForm(style.screenDialog, "Form", args, n);
 553
 554     /* Create the visual */
 555     n = 0;
 556     XtSetArg(args[n], XmNfillMode, XmFILL_SELF); n++;
 557     XtSetArg(args[n], XmNbehavior, XmICON_LABEL); n++;
 558     XtSetArg(args[n], XmNpixmapForeground, style.secBSCol); n++;
 559     XtSetArg(args[n], XmNpixmapBackground, style.secTSCol); n++;
 560     XtSetArg(args[n], XmNstring, NULL); n++;
 561     XtSetArg(args[n], XmNshadowThickness, 0); n++;
 562     XtSetArg(args[n], XmNimageName, SCREEN_ICON); n++;
 563     XtSetArg(args[n], XmNtraversalOn, False); n++;
 564     widget_list1[list1_count++] =
 565     screen.pictLabel= _DtCreateIcon(form, "screenLabelPixmap", args, n);
 566
 567     /* Create the default button */
 568     n = 0;
 569     XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT);  n++;
 570     XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH);  n++;
 571     string = CMPSTR(((char *)GETMESSAGE(12, 3, "Default")));
 572     XtSetArg(args[n], XmNlabelString, string); n++;
 573     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 574     widget_list1[list1_count++] =
 575     screen.systemDefault= XmCreatePushButtonGadget(form, "systemDefault", args, n);
 576     XmStringFree(string);
 577
 578     /* Create the screen lock title box */
 579     n = 0;
 580     if (style.smState.smLockOnTimeoutStatus)
 581       string = CMPSTR(((char *)GETMESSAGE(12, 8, "Screen Lock")));
 582     else
 583       string = CMPSTR(((char *)GETMESSAGE(12, 18, "Front Panel Lock")));
 584     XtSetArg(args[n], XmNtitleString, string);  n++;
 585     widget_list1[list1_count++] =
 586       screen.lockFrame= _DtCreateTitleBox(form, "lockFrame", args, n);
 587     XmStringFree(string);
 588
 589
 590     /* Create a form for the screen lock widgets  */
 591     n = 0;
 592     XtSetArg(args[n], XmNallowOverlap, False); n++;
 593     XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
 594     screen.lockForm= XmCreateForm(screen.lockFrame, "lockForm", args, n);
 595
 596
 597     /* Create the screen saver title box   */
 598     n = 0;
 599     if (style.smState.smLockOnTimeoutStatus)
 600       string = CMPSTR(((char *)GETMESSAGE(12, 4, "Screen Saver")));
 601     else
 602       string = CMPSTR(((char *)GETMESSAGE(12, 15, "Auto Screen Blanking")));
 603     XtSetArg(args[n], XmNtitleString, string);  n++;
 604     widget_list1[list1_count++] =
 605     screen.saverFrame= _DtCreateTitleBox(form, "saverFrame", args, n);
 606     XmStringFree(string);
 607
 608     /* Create a form for the screen saver widgets */
 609     n = 0;
 610     XtSetArg(args[n], XmNallowOverlap, False); n++;
 611     XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
 612     screen.saverForm= XmCreateForm(screen.saverFrame, "saverForm", args, n);
 613
 614
 615     /* Create the cycle time labels and slider     */
 616     n = 0;
 617     if (style.smState.smLockOnTimeoutStatus)
 618       string = CMPSTR(((char *)GETMESSAGE(12, 6, "Time Per Saver")));
 619     else
 620       string = CMPSTR(((char *)GETMESSAGE(12, 20, "Time Per Background")));
 621     XtSetArg(args[n], XmNlabelString, string); n++;
 622     /* only if saver extensions are present */
 623     if (style.smState.smLockOnTimeoutStatus)
 624       screen.cycleTimeLabel = XmCreateLabelGadget(screen.saverForm,"cycleTimeLabel", args, n);
 625     else
 626       screen.cycleTimeLabel = XmCreateLabelGadget(screen.lockForm,"cycleTimeLabel", args, n);
 627     XmStringFree(string);
 628
 629     n = 0;
 630     XtSetArg(args[n], XmNminimum, CYCLETIME_MIN); n++;
 631     XtSetArg(args[n], XmNmaximum, TIMEOUT_MAX); n++;
 632     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 633     XtSetArg(args[n], XmNprocessingDirection, XmMAX_ON_RIGHT); n++;
 634     XtSetArg(args[n], XmNshowValue, True); n++;
 635     XtSetArg(args[n], XmNhighlightThickness, SCALE_HIGHLIGHT_THICKNESS); n++;
 636     if (style.smState.smLockOnTimeoutStatus)
 637       screen.cycleTimeScale= XmCreateScale(screen.saverForm,"cycleTimeScale", args, n);
 638     else
 639       screen.cycleTimeScale= XmCreateScale(screen.lockForm,"cycleTimeScale", args, n);
 640
 641     n = 0;
 642     string = CMPSTR(((char *)GETMESSAGE(12, 7, "minutes")));
 643     XtSetArg(args[n], XmNlabelString, string); n++;
 644     if (style.smState.smLockOnTimeoutStatus)
 645       screen.cycleMinutesLabel= XmCreateLabelGadget(screen.saverForm,"cycleMinutes", args, n);
 646     else
 647       screen.cycleMinutesLabel= XmCreateLabelGadget(screen.lockForm,"cycleMinutes", args, n);
 648     XmStringFree(string);
 649
 650     /* Create the screen saver on/off radio buttons and label */
 651     n = 0;
 652     if (style.smState.smLockOnTimeoutStatus)
 653       string = CMPSTR(((char *)GETMESSAGE(12, 12, "Screen Saver:")));
 654     else
 655       string = CMPSTR(((char *)GETMESSAGE(12, 16, "Screen Blanker:")));
 656     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 657     XtSetArg(args[n], XmNlabelString, string); n++;
 658     screen.saverLabel= XmCreateLabelGadget(screen.saverForm, "saverLabel", args, n);
 659     XmStringFree(string);
 660
 661     n = 0;
 662     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 663     screen.saverRadioBox= XmCreateRadioBox(screen.saverForm, "saverRadioBox", args, n);
 664
 665     n = 0;
 666     string = CMPSTR(((char *)GETMESSAGE(12, 10, "On")));
 667     XtSetArg(args[n], XmNlabelString, string); n++;
 668     screen.saverOn= XmCreateToggleButtonGadget(screen.saverRadioBox, "saverOn", args, n);
 669     XmStringFree(string);
 670
 671     n = 0;
 672     string = CMPSTR(((char *)GETMESSAGE(12, 11, "Off")));
 673     XtSetArg(args[n], XmNlabelString, string); n++;
 674     screen.saverOff= XmCreateToggleButtonGadget(screen.saverRadioBox, "saverOff", args, n);
 675     XmStringFree(string);
 676
 677     /* Create the screen saver list */
 678     n = 0;
 679     XtSetArg (args[n], XmNautomaticSelection, True);              n++;
 680     XtSetArg (args[n], XmNselectionPolicy, XmMULTIPLE_SELECT);      n++;
 681     XtSetArg (args[n], XmNlistSizePolicy, XmRESIZE_IF_POSSIBLE);      n++;
 682     if (low_res) {
 683       XtSetArg (args[n], XmNheight, 100); n++; }
 684     else {
 685       XtSetArg (args[n], XmNheight, SAVER_HEIGHT); n++; }
 686     XtSetArg (args[n], XmNhighlightColor, 0);      n++;
 687     /* choose the parent of saverList depending on the presence of saver extensions */
 688     if (style.smState.smLockOnTimeoutStatus)
 689       screen.saverList = XmCreateScrolledList (screen.saverForm, "saversList", args, n);
 690     else
 691       screen.saverList = XmCreateScrolledList (screen.lockForm, "saversList", args, n);
 692     /* use the environment variable DTSCREENSAVERLIST to get the list of */
 693     /* available screen saver actions, load them into the scrolled list*/
 694     savers.saversList = getenv ("DTSCREENSAVERLIST");
 695     /* if DTSCREENSAVER is not set, set saver count to zero */
 696     if (savers.saversList == NULL) {
 697         savers.saverCount = 0;
 698         savers.selsaverCount=0;
 699     } else {
 700         savers.saverActionNames = build_saverList(savers.saversList, &savers.saverCount);
 701         savers.saverActionDesc = build_saverDesc(savers.saverActionNames, savers.saverCount);
 702         /* convert to XmString */
 703         listStrings = MakeListStrings(savers.saverActionDesc);
 704         XmListAddItems (screen.saverList, listStrings, savers.saverCount, 0);
 705         XtAddCallback (screen.saverList, XmNmultipleSelectionCallback,
 706                        ListCB, (XtPointer)NULL);
 707         FreeListStrings (listStrings, savers.saverCount);
 708
 709         /* check the state to see which item(s) should be selected, if none are */
 710         /* selected or if none in the selected list match the  available list then */
 711         /* set the selection to the last position by default. This should be blank */
 712         /* if the DTSCREENSAVERLIST environment variable is set to default */
 713         savers.selsaverActionNames =
 714           build_selsaverList(style.smSaver.saverList, &savers.selsaverCount);
 715
 716         /* since savers.selsaverCount may be changed below, we save */
 717         /* number of originally selected savers in order to accurately free the */
 718         /* savers.selsaverActionNames array below. */
 719         old_selsaverCount = savers.selsaverCount;
 720
 721         if (savers.selsaverCount) {
 722           savers.selPositions = (int *) XtMalloc(sizeof(int) * savers.selsaverCount);
 723           for (n=0; n<savers.selsaverCount; n++) {
 724             /* determine if this selected saver matches one in valid saver list */
 725             for (m=0; (m < savers.saverCount) &&
 726                       ((sel_found = strcmp(savers.selsaverActionNames[n],
 727                                            savers.saverActionNames[m])) != 0); m++) {}
 728             if (sel_found == 0) {
 729               XmListSelectPos (screen.saverList, m+1, False);
 730               savers.selPositions[n]=m+1;
 731               sel_matched = True;
 732             } else {
 733               /* This selected saver isn't valid, need to get rid of it.
 734                  Do this by shifting each selected saver in the array
 735                  back one position, i.e. n = n+1, n+1 = n+2, ....
 736                  This overwrites the nth element and leaves the empty
 737                  space at the end of the array.  */
 738               for (i=n; i < (savers.selsaverCount - 1); i++)
 739                 savers.selsaverActionNames[i] = savers.selsaverActionNames[i+1];
 740
 741               /* reduce # of selected savers */
 742               savers.selsaverCount--;
 743
 744               /* reset selected saver array position counter back one position for
 745                  next loop test */
 746               n--;
 747             } /* if (sel_found == 0) */
 748           } /* for n<savers.selsaverCount */
 749         } /* if (savers.selsaverCount)  */
 750
 751         /* if there are still savers selected that match valid saver names */
 752         if (savers.selsaverCount) {
 753           /* set current saver to first selection */
 754           savers.current_saver = savers.saverActionNames[savers.selPositions[0] - 1];
 755           savers.current_saverDesc = savers.saverActionDesc[savers.selPositions[0] - 1];
 756           savers.current_position = savers.selPositions[0];
 757         } else {
 758           /* highlight last saver */
 759           XmListSelectPos (screen.saverList, savers.saverCount, False);
 760
 761           /* set current saver to last one */
 762           savers.current_saver = savers.saverActionNames[savers.saverCount - 1];
 763           savers.current_saverDesc = savers.saverActionDesc[savers.saverCount - 1];
 764
 765           savers.selPositions = (int *) XtMalloc(sizeof(int));
 766           savers.selPositions[0] = savers.saverCount;
 767           savers.selsaverCount = 1;
 768           savers.current_position = 1;
 769         }
 770         /* save the selected positions for later use */
 771         savers.origSelPositions = (int *) XtMalloc(sizeof(int) * savers.selsaverCount);
 772         for (i=0; i<savers.selsaverCount; i++)
 773             savers.origSelPositions[i] = savers.selPositions[i];
 774         savers.orig_selsaverCount = savers.selsaverCount;
 775
 776         savers.previous_selsaverCount = savers.selsaverCount;
 777         free_saverList(savers.selsaverActionNames, old_selsaverCount);
 778       }
 779
 780     /* Create frame for the saver area */
 781     n = 0;
 782     XtSetArg (args[n], XmNshadowType, XmSHADOW_IN);                     n++;
 783     XtSetArg (args[n], XmNshadowThickness, savers.shadow);           n++;
 784     XtSetArg (args[n], XmNhighlightThickness, 0);                       n++;
 785     XtSetArg (args[n], XmNtraversalOn, False);                          n++;
 786     /* depending on the presence of saver extensions choose the parent of saverAreaFrame */
 787     if (style.smState.smLockOnTimeoutStatus)
 788       screen.saverAreaFrame = XmCreateFrame(screen.saverForm, "saverAreaFrame", args, n);
 789     else
 790       screen.saverAreaFrame = XmCreateFrame(screen.lockForm, "saverAreaFrame", args, n);
 791
 792     /* Create saver area  for the screen savers */
 793     n = 0;
 794     XtSetArg (args[n], XmNtraversalOn, False); n++;
 795     if (low_res) {
 796       XtSetArg (args[n], XmNwidth, 180); n++; }
 797     else {
 798       XtSetArg (args[n], XmNwidth, SAVER_WIDTH); n++; }
 799     screen.saverArea = XmCreateDrawingArea (screen.saverAreaFrame, "saverArea", args, n);
 800     /* get the initial secondary color pixel value for dtstyle for later use */
 801     XtVaGetValues(screen.saverArea, XmNbackground, &savers.bg, NULL);
 802
 803     /* label for the previewed saver  */
 804     n = 0;
 805     if (savers.saverCount)
 806         string = XmStringCreateLocalized (savers.current_saverDesc);
 807     else
 808         string = XmStringCreateLocalized (" ");
 809     XtSetArg(args[n], XmNlabelString, string); n++;
 810     if (style.smState.smLockOnTimeoutStatus)
 811         screen.prevLabel = XmCreateLabelGadget(screen.saverForm,"prevLabel", args, n);
 812     else
 813         screen.prevLabel = XmCreateLabelGadget(screen.lockForm,"prevLabel", args, n);
 814     XmStringFree(string);
 815
 816     /* Create the screen saver labels and slider */
 817     n = 0;
 818     if (style.smState.smLockOnTimeoutStatus)
 819       string = CMPSTR(((char *)GETMESSAGE(12, 5, "Start Saver")));
 820     else
 821       string = CMPSTR(((char *)GETMESSAGE(12, 17, "Start Blanker")));
 822     XtSetArg(args[n], XmNlabelString, string); n++;
 823     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 824     screen.timeOutLabel= XmCreateLabelGadget(screen.saverForm,"timeOutLabel", args, n);
 825     XmStringFree(string);
 826
 827     n = 0;
 828     XtSetArg(args[n], XmNminimum, TIMEOUT_MIN); n++;
 829     XtSetArg(args[n], XmNmaximum, TIMEOUT_MAX); n++;
 830     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 831     XtSetArg(args[n], XmNprocessingDirection, XmMAX_ON_RIGHT); n++;
 832     XtSetArg(args[n], XmNshowValue, True); n++;
 833     XtSetArg(args[n], XmNhighlightThickness, SCALE_HIGHLIGHT_THICKNESS); n++;
 834     screen.timeOutScale= XmCreateScale(screen.saverForm,"timeOutScale", args, n);
 835
 836     n = 0;
 837     string = CMPSTR(((char *)GETMESSAGE(12, 7, "minutes")));
 838     XtSetArg(args[n], XmNlabelString, string); n++;
 839     screen.saverMinutesLabel= XmCreateLabelGadget(screen.saverForm,"saverMinutes", args, n);
 840     XmStringFree(string);
 841
 842     /* Create the screen lock on/off radio buttons and label  */
 843     /* mapped only when saver extensions are present */
 844     n = 0;
 845     string = CMPSTR(((char *)GETMESSAGE(12, 13, "Screen Lock:")));
 846     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 847     XtSetArg(args[n], XmNlabelString, string); n++;
 848     screen.lockLabel= XmCreateLabelGadget(screen.lockForm, "lockLabel", args, n);
 849     XmStringFree(string);
 850
 851     n = 0;
 852     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 853     screen.lockRadioBox= XmCreateRadioBox(screen.lockForm, "lockRadioBox", args, n);
 854
 855     n = 0;
 856     string = CMPSTR(((char *)GETMESSAGE(12, 10, "On")));
 857     XtSetArg(args[n], XmNlabelString, string); n++;
 858     XtSetArg(args[n], XmNset, style.smState.smCoverScreen ? True : False); n++;
 859     screen.lockOn= XmCreateToggleButtonGadget(screen.lockRadioBox, "lockOn", args, n);
 860     XmStringFree(string);
 861
 862     n = 0;
 863     string = CMPSTR(((char *)GETMESSAGE(12, 11, "Off")));
 864     XtSetArg(args[n], XmNlabelString, string); n++;
 865     XtSetArg(args[n], XmNset, style.smState.smCoverScreen ? False : True); n++;
 866     screen.lockOff= XmCreateToggleButtonGadget(screen.lockRadioBox, "lockOff", args, n);
 867     XmStringFree(string);
 868
 869
 870     /* Create the screen lock labels and slider */
 871     /* mapped only when saver extensions are present */
 872     n = 0;
 873     string = CMPSTR(((char *)GETMESSAGE(12, 14, "Start Lock")));
 874     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 875     XtSetArg(args[n], XmNlabelString, string); n++;
 876     screen.lockOutLabel= XmCreateLabelGadget(screen.lockForm,"lockOutLabel", args, n);
 877     XmStringFree(string);
 878
 879     n = 0;
 880     XtSetArg(args[n], XmNminimum, TIMEOUT_MIN); n++;
 881     XtSetArg(args[n], XmNmaximum, TIMEOUT_MAX); n++;
 882     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 883     XtSetArg(args[n], XmNprocessingDirection, XmMAX_ON_RIGHT); n++;
 884     XtSetArg(args[n], XmNshowValue, True); n++;
 885     XtSetArg(args[n], XmNhighlightThickness, SCALE_HIGHLIGHT_THICKNESS); n++;
 886     screen.lockOutScale= XmCreateScale(screen.lockForm,"lockOutScale", args, n);
 887
 888
 889     n = 0;
 890     string = CMPSTR(((char *)GETMESSAGE(12, 7, "minutes")));
 891     XtSetArg(args[n], XmNlabelString, string); n++;
 892     screen.lockMinutesLabel= XmCreateLabelGadget(screen.lockForm,"lockMinutes", args, n);
 893     XmStringFree(string);
 894
 895     /* Create the radio buttons for lock savers */
 896     /* mapped only when saver extensions are not present */
 897     n = 0;
 898     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 899     XtSetArg(args[n], XmNspacing, 25); n++;
 900     screen.lockingRadioBox= XmCreateRadioBox(screen.lockForm, "lockingRadioBox", args, n);
 901
 902     n = 0;
 903     string = CMPSTR(((char *)GETMESSAGE(12, 21, "Use Backgrounds For Lock")));
 904     XtSetArg(args[n], XmNlabelString, string); n++;
 905     screen.useSaversOn= XmCreateToggleButtonGadget(screen.lockingRadioBox, "useSaversOn", args, n);
 906     XmStringFree(string);
 907
 908
 909
 910     n = 0;
 911     string = CMPSTR(((char *)GETMESSAGE(12, 22, "Transparent Lock")));
 912     XtSetArg(args[n], XmNlabelString, string); n++;
 913     screen.useSaversOff= XmCreateToggleButtonGadget(screen.lockingRadioBox, "useSaversOff", args, n);
 914     XmStringFree(string);
 915
 916     /* add callbacks */
 917
 918     /* Configure dialog based on the presence of screen saver extensions */
 919     if (!style.smState.smLockOnTimeoutStatus)
 920       {
 921         XtAddCallback(style.screenDialog, XmNmapCallback, no_svr_ext_formLayoutCB, NULL);
 922         XtAddCallback(style.screenDialog, XmNmapCallback, no_svr_ext_DtmapCB_screenDialog, shell);
 923         XtAddCallback(screen.systemDefault, XmNactivateCallback, no_svr_ext_systemDefaultCB, NULL);
 924         XtAddCallback(screen.timeOutScale, XmNvalueChangedCallback,
 925                       no_svr_ext_timeOutvalueChangedCB, NULL);
 926         XtAddCallback(screen.saverOn, XmNvalueChangedCallback,
 927                       no_svr_ext_saverToggleCB, NULL);
 928         XtAddCallback(screen.saverOff, XmNvalueChangedCallback,
 929                       no_svr_ext_saverToggleCB, NULL);
 930         XtAddCallback(screen.useSaversOn, XmNvalueChangedCallback,
 931                       saversToggleCB, NULL);
 932         XtAddCallback(screen.useSaversOff, XmNvalueChangedCallback,
 933                       saversToggleCB, NULL);
 934
 935         XtAddCallback(style.screenDialog, XmNcallback, no_svr_ext_ButtonCB, NULL);
 936       }
 937     else
 938       {
 939         XtAddCallback(style.screenDialog, XmNmapCallback, formLayoutCB, NULL);
 940         XtAddCallback(style.screenDialog, XmNmapCallback, _DtmapCB_screenDialog, shell);
 941         XtAddCallback(screen.systemDefault, XmNactivateCallback, systemDefaultCB, NULL);
 942         XtAddCallback(screen.timeOutScale, XmNvalueChangedCallback,
 943                       timeOutvalueChangedCB, NULL);
 944         XtAddCallback(screen.lockOutScale, XmNvalueChangedCallback,
 945                       timeOutvalueChangedCB, NULL);
 946         XtAddCallback(screen.saverOn, XmNvalueChangedCallback,
 947                       saverToggleCB, NULL);
 948         XtAddCallback(screen.saverOff, XmNvalueChangedCallback,
 949                       saverToggleCB, NULL);
 950         XtAddCallback(screen.lockOn, XmNvalueChangedCallback,
 951                       lockToggleCB, NULL);
 952         XtAddCallback(screen.lockOff, XmNvalueChangedCallback,
 953                       lockToggleCB, NULL);
 954         XtAddCallback(style.screenDialog, XmNcallback, ButtonCB, NULL);
 955       }
 956     XtAddCallback(style.screenDialog, XmNunmapCallback, UnmapCB, shell);
 957     XtAddCallback(style.screenDialog, XmNhelpCallback,
 958                   (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_SCREEN_DIALOG);
 959
 960     /* calculate the max label width for labels */
 961     if ((LabelWidth = XtWidth(screen.saverLabel)) > MaxLabelWidth)
 962       MaxLabelWidth = LabelWidth;
 963     if ((LabelWidth = XtWidth(screen.timeOutLabel)) > MaxLabelWidth)
 964       MaxLabelWidth = LabelWidth;
 965     if ((LabelWidth = XtWidth(screen.cycleTimeLabel)) > MaxLabelWidth)
 966       MaxLabelWidth = LabelWidth;
 967     if (style.smState.smLockOnTimeoutStatus)
 968       {
 969         if ((LabelWidth = XtWidth(screen.lockLabel)) > MaxLabelWidth)
 970           MaxLabelWidth = LabelWidth;
 971         if ((LabelWidth = XtWidth(screen.lockOutLabel)) > MaxLabelWidth)
 972           MaxLabelWidth = LabelWidth;
 973       }
 974
 975     XtVaSetValues(screen.saverLabel, XmNwidth, MaxLabelWidth, NULL);
 976     XtVaSetValues(screen.timeOutLabel, XmNwidth, MaxLabelWidth, NULL);
 977     XtVaSetValues(screen.cycleTimeLabel, XmNwidth, MaxLabelWidth, NULL);
 978     if (style.smState.smLockOnTimeoutStatus)
 979       {
 980         XtVaSetValues(screen.lockLabel, XmNwidth, MaxLabelWidth, NULL);
 981         XtVaSetValues(screen.lockOutLabel, XmNwidth, MaxLabelWidth, NULL);
 982       }
 983
 984     /* manage widgets */
 985     XtManageChildren(widget_list1,list1_count);
 986     XtManageChild(form);
 987     XtManageChild(screen.saverForm);
 988     XtManageChild(screen.cycleTimeLabel);
 989     XtManageChild(screen.cycleTimeScale);
 990     XtManageChild(screen.saverLabel);
 991     XtManageChild(screen.prevLabel);
 992     XtManageChild(screen.saverRadioBox);
 993     XtManageChild(screen.saverOn);
 994     XtManageChild(screen.saverOff);
 995     XtManageChild(screen.timeOutLabel);
 996     XtManageChild(screen.timeOutScale);
 997     XtManageChild(screen.saverMinutesLabel);
 998     XtManageChild(screen.saverList);
 999     XtManageChild(screen.saverAreaFrame);
1000     XtManageChild(screen.saverArea);
1001     XtManageChild(screen.cycleMinutesLabel);
1002     XtManageChild(screen.saverList);
1003     XtManageChild(screen.lockForm);
1004     /* manage the lock label, scale and minutes label only if */
1005     /* saver extensions are present */
1006     if (style.smState.smLockOnTimeoutStatus)
1007      {
1008        XtManageChild(screen.lockLabel);
1009        XtManageChild(screen.lockRadioBox);
1010        XtManageChild(screen.lockOn);
1011        XtManageChild(screen.lockOff);
1012        XtManageChild(screen.lockOutLabel);
1013        XtManageChild(screen.lockOutScale);
1014        XtManageChild(screen.lockMinutesLabel);
1015      }
1016     else
1017       {
1018         XtManageChild(screen.lockingRadioBox);
1019         XtManageChild(screen.useSaversOn);
1020         XtManageChild(screen.useSaversOff);
1021       }
1022    XtAddEventHandler(style.shell, StructureNotifyMask, False, IconHandler, NULL);
1023
1024     return(style.screenDialog);
1025 }
1026
1027
1028 /*+++++++++++++++++++++++++++++++++++++++*/
1029 /* formLayoutCB                          */
1030 /*+++++++++++++++++++++++++++++++++++++++*/
1031 static void
1032 formLayoutCB(
1033         Widget w,
1034         XtPointer client_data,
1035         XtPointer call_data )
1036 {
1037     register int     n;
1038     Arg              args[MAX_ARGS];
1039     Dimension        ScaleHeight;
1040     Dimension        LabelHeight;
1041     Dimension        RadioHeight;
1042     Dimension        RadioOffset, ScaleOffset;
1043
1044     /* calculate width and height information */
1045     ScaleHeight = XtHeight(screen.timeOutScale);
1046     LabelHeight = XtHeight(screen.timeOutLabel);
1047     RadioHeight = XtHeight(screen.saverRadioBox);
1048     RadioOffset = ((Dimension) (RadioHeight - LabelHeight) / 2) - 2;
1049     ScaleOffset = 0;
1050
1051     /* do form attachments */
1052
1053     /* Picture Label */
1054     n=0;
1055     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
1056     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1057     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1058     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1059     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1060     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
1061     XtSetValues (screen.pictLabel, args, n);
1062
1063     /* system Default */
1064     n=0;
1065     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
1066     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1067     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1068     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);       n++;
1069     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1070     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1071     XtSetValues (screen.systemDefault, args, n);
1072
1073     /* lock titlebox */
1074     n=0;
1075     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);     n++;
1076     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_FORM);       n++;
1077     XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing);    n++;
1078     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1079     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1080     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1081     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1082     XtSetValues (screen.lockFrame, args, n);
1083
1084
1085     /* lock label */
1086     n=0;
1087     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);     n++;
1088     XtSetArg (args[n], XmNtopOffset,         style.verticalSpacing);    n++;
1089     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1090     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1091     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1092     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);         n++;
1093     XtSetValues (screen.lockLabel, args, n);
1094
1095
1096     /* lock Radiobox */
1097     n=0;
1098
1099     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_OPPOSITE_WIDGET);     n++;
1100     XtSetArg(args[n], XmNtopWidget,          screen.lockLabel);  n++;
1101     XtSetArg(args[n], XmNtopOffset,          -RadioOffset);  n++;
1102     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1103     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET);       n++;
1104     XtSetArg(args[n], XmNleftWidget,         screen.lockLabel);  n++;
1105     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1106     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);         n++;
1107     XtSetValues (screen.lockRadioBox, args, n);
1108
1109
1110     /* lockOut  Label */
1111     n=0;
1112     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);     n++;
1113     XtSetArg(args[n], XmNtopWidget,          screen.lockLabel);  n++;
1114     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing + ScaleHeight - LabelHeight);  n++;
1115     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);     n++;
1116     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1117     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1118     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
1119     XtSetValues (screen.lockOutLabel, args, n);
1120
1121
1122    /* lockOut Scale */
1123     n=0;
1124     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1125     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1126     XtSetArg(args[n], XmNbottomWidget,       screen.lockOutLabel);n++;
1127     XtSetArg(args[n], XmNbottomOffset,       ScaleOffset); n++;
1128     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET);     n++;
1129     XtSetArg(args[n], XmNleftWidget,         screen.lockOutLabel);n++;
1130     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1131     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);       n++;
1132     XtSetArg(args[n], XmNrightWidget,        screen.lockMinutesLabel);n++;
1133     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1134     XtSetValues (screen.lockOutScale, args, n);
1135
1136
1137     /* Minutes label */
1138     n=0;
1139     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1140     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1141     XtSetArg(args[n], XmNbottomWidget,       screen.lockOutLabel);n++;
1142     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);     n++;
1143     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1144     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1145     XtSetValues (screen.lockMinutesLabel, args, n);
1146
1147
1148     /* saver titlebox */
1149     n=0;
1150     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);     n++;
1151     XtSetArg(args[n], XmNtopWidget,          screen.pictLabel);  n++;
1152     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1153     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_WIDGET);       n++;
1154     XtSetArg(args[n], XmNbottomWidget,       screen.lockFrame);  n++;
1155     XtSetArg(args[n], XmNbottomOffset,       2*style.verticalSpacing);    n++;
1156     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1157     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1158     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1159     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing); n++;
1160     XtSetValues (screen.saverFrame, args, n);
1161
1162     /* cycleTime Label */
1163     n=0;
1164     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);     n++;
1165     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_FORM);       n++;
1166     XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing);  n++;
1167     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1168     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1169     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
1170     XtSetValues (screen.cycleTimeLabel, args, n);
1171
1172     /* cycleTime Scale */
1173     n=0;
1174     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1175     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1176     XtSetArg(args[n], XmNbottomWidget,       screen.cycleTimeLabel);n++;
1177     XtSetArg(args[n], XmNbottomOffset,       ScaleOffset);n++;
1178     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET);     n++;
1179     XtSetArg(args[n], XmNleftWidget,         screen.cycleTimeLabel);n++;
1180     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1181     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);       n++;
1182     XtSetArg(args[n], XmNrightWidget,        screen.cycleMinutesLabel);n++;
1183     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1184     XtSetValues (screen.cycleTimeScale, args, n);
1185
1186     /* Minutes label */
1187     n=0;
1188     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1189     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1190     XtSetArg(args[n], XmNbottomWidget,       screen.cycleTimeLabel);n++;
1191     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);     n++;
1192     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1193     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1194     XtSetValues (screen.cycleMinutesLabel, args, n);
1195
1196     /* TimeOut Label */
1197     n=0;
1198     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);     n++;
1199     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_WIDGET);       n++;
1200     XtSetArg(args[n], XmNbottomWidget,       screen.cycleTimeLabel);n++;
1201     XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing + ScaleHeight - LabelHeight);  n++;
1202     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1203     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1204     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
1205     XtSetValues (screen.timeOutLabel, args, n);
1206
1207     /* Minutes label */
1208     n=0;
1209     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1210     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1211     XtSetArg(args[n], XmNbottomWidget,       screen.timeOutLabel);n++;
1212     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);     n++;
1213     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1214     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1215     XtSetValues (screen.saverMinutesLabel, args, n);
1216
1217     /* TimeOut Scale */
1218     n=0;
1219     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE); n++;
1220     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1221     XtSetArg(args[n], XmNbottomWidget,       screen.timeOutLabel);n++;
1222     XtSetArg(args[n], XmNbottomOffset,       ScaleOffset); n++;
1223     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET); n++;
1224     XtSetArg(args[n], XmNleftWidget,         screen.timeOutLabel);n++;
1225     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1226     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);       n++;
1227     XtSetArg(args[n], XmNrightWidget,        screen.saverMinutesLabel);n++;
1228     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1229     XtSetValues (screen.timeOutScale, args, n);
1230
1231     /* saver label */
1232     n=0;
1233     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);     n++;
1234     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1235     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1236     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1237     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1238     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);         n++;
1239     XtSetValues (screen.saverLabel, args, n);
1240
1241
1242     /* saver Radiobox */
1243     n=0;
1244     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_OPPOSITE_WIDGET); n++;
1245     XtSetArg(args[n], XmNtopWidget,          screen.saverLabel);  n++;
1246     XtSetArg(args[n], XmNtopOffset,          -RadioOffset);  n++;
1247     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);     n++;
1248     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET);       n++;
1249     XtSetArg(args[n], XmNleftWidget,         screen.saverLabel);  n++;
1250     XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1251     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);         n++;
1252     XtSetValues (screen.saverRadioBox, args, n);
1253
1254
1255     /* preview label */
1256     n=0;
1257     XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);       n++;
1258     XtSetArg(args[n], XmNtopWidget,          screen.saverLabel);  n++;
1259     XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);  n++;
1260     XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);     n++;
1261     XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);       n++;
1262     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
1263     XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1264     XtSetValues (screen.prevLabel, args, n);
1265
1266     /* scrolled list  */
1267     n = 0;
1268     XtSetArg (args[n], XmNtopAttachment,      XmATTACH_WIDGET);          n++;
1269     XtSetArg (args[n], XmNtopWidget,          screen.prevLabel);  n++;
1270     XtSetArg (args[n], XmNtopOffset,          style.verticalSpacing/2);    n++;
1271     XtSetArg (args[n], XmNrightAttachment,    XmATTACH_NONE);        n++;
1272     XtSetArg (args[n], XmNleftAttachment,     XmATTACH_FORM);        n++;
1273     XtSetArg(args[n],  XmNleftOffset,         style.horizontalSpacing);  n++;
1274     XtSetArg (args[n], XmNbottomAttachment,   XmATTACH_WIDGET);       n++;
1275     XtSetArg(args[n],  XmNbottomWidget,       screen.timeOutLabel);       n++;
1276     XtSetArg(args[n],  XmNbottomOffset,       5*style.verticalSpacing);  n++;
1277     XtSetValues (XtParent(screen.saverList),  args, n);
1278
1279
1280     /* saverArea */
1281     n=0;
1282     XtSetArg (args[n], XmNtopAttachment,      XmATTACH_OPPOSITE_WIDGET);   n++;
1283     XtSetArg(args[n], XmNtopWidget,           XtParent(screen.saverList));  n++;
1284     XtSetArg (args[n], XmNleftAttachment,     XmATTACH_WIDGET);         n++;
1285     XtSetArg(args[n], XmNleftWidget,          XtParent(screen.saverList));  n++;
1286     XtSetArg(args[n], XmNleftOffset,          style.horizontalSpacing);  n++;
1287     XtSetArg (args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
1288     XtSetArg(args[n], XmNrightOffset,         style.horizontalSpacing);  n++;
1289     XtSetArg (args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET);   n++;
1290     XtSetArg(args[n], XmNbottomWidget,        XtParent(screen.saverList));  n++;
1291     XtSetValues (screen.saverAreaFrame, args, n);
1292
1293
1294     XtRemoveCallback(style.screenDialog, XmNmapCallback, formLayoutCB, NULL);
1295
1296 }
1297
1298 /*+++++++++++++++++++++++++++++++++++++++*/
1299 /* no_svr_ext_formLayoutCB               */
1300 /*+++++++++++++++++++++++++++++++++++++++*/
1301 static void
1302 no_svr_ext_formLayoutCB(
1303         Widget w,
1304         XtPointer client_data,
1305         XtPointer call_data )
1306 {
1307   register int     n;
1308   Arg              args[MAX_ARGS];
1309   Dimension        ScaleHeight;
1310   Dimension        LabelHeight;
1311   Dimension        RadioHeight;
1312   Dimension        RadioOffset, ScaleOffset;
1313
1314   /* calculate width and height information */
1315   ScaleHeight = XtHeight(XtParent(screen.timeOutScale));
1316   LabelHeight = XtHeight(screen.timeOutLabel);
1317   RadioHeight = XtHeight(screen.saverRadioBox);
1318
1319   RadioOffset = ((Dimension) (RadioHeight - LabelHeight) / 2) - 2;
1320   ScaleOffset = 0;
1321   /* do form attachments */
1322
1323   /* Picture Label */
1324   n=0;
1325   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
1326   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1327   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1328   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1329   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1330   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
1331   XtSetValues (screen.pictLabel, args, n);
1332
1333   /* system Default */
1334   n=0;
1335   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
1336   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1337   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1338   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);       n++;
1339   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1340   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1341   XtSetValues (screen.systemDefault, args, n);
1342
1343
1344   /* saver titlebox */
1345   n=0;
1346   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);     n++;
1347   XtSetArg(args[n], XmNtopWidget,          screen.pictLabel);  n++;
1348   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1349   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1350   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1351   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1352   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1353   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing); n++;
1354   XtSetValues (screen.saverFrame, args, n);
1355
1356   /* saver label */
1357   n=0;
1358   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);     n++;
1359   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1360   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1361   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1362   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1363   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);         n++;
1364   XtSetValues (screen.saverLabel, args, n);
1365
1366   /* saver Radiobox */
1367   n=0;
1368   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_OPPOSITE_WIDGET); n++;
1369   XtSetArg(args[n], XmNtopWidget,          screen.saverLabel);  n++;
1370   XtSetArg(args[n], XmNtopOffset,          -RadioOffset);  n++;
1371   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);     n++;
1372   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET);       n++;
1373   XtSetArg(args[n], XmNleftWidget,         screen.saverLabel);  n++;
1374   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1375   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);         n++;
1376   XtSetValues (screen.saverRadioBox, args, n);
1377
1378   /* TimeOut Label */
1379   n=0;
1380   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET); n++;
1381   XtSetArg(args[n], XmNtopWidget,          screen.saverLabel);  n++;
1382   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing + ScaleHeight - LabelHeight); n++;
1383   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);       n++;
1384   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1385   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1386   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
1387   XtSetValues (screen.timeOutLabel, args, n);
1388
1389   /* TimeOut Scale */
1390   n=0;
1391   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1392   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1393   XtSetArg(args[n], XmNbottomWidget,       screen.timeOutLabel);n++;
1394   XtSetArg(args[n], XmNbottomOffset,       ScaleOffset); n++;
1395   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET);     n++;
1396   XtSetArg(args[n], XmNleftWidget,         screen.timeOutLabel);n++;
1397   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1398   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);       n++;
1399   XtSetArg(args[n], XmNrightWidget,        screen.saverMinutesLabel);n++;
1400   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1401   XtSetValues (screen.timeOutScale, args, n);
1402
1403   /* Minutes label */
1404   n=0;
1405   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1406   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1407   XtSetArg(args[n], XmNbottomWidget,       screen.timeOutLabel);n++;
1408   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);     n++;
1409   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1410   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1411   XtSetValues (screen.saverMinutesLabel, args, n);
1412
1413   /* lock titlebox */
1414   n=0;
1415   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);     n++;
1416   XtSetArg(args[n], XmNtopWidget,          screen.saverFrame);  n++;
1417   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1418   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_FORM);       n++;
1419   XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing);    n++;
1420   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1421   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1422   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1423   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1424   XtSetValues (screen.lockFrame, args, n);
1425
1426   /* locking radiobox */
1427   n=0;
1428   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_FORM);       n++;
1429   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);  n++;
1430   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_NONE);     n++;
1431   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1432   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);         n++;
1433   XtSetValues (screen.lockingRadioBox, args, n);
1434
1435   /* preview label */
1436   n=0;
1437   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_WIDGET);     n++;
1438   XtSetArg(args[n], XmNtopWidget,          screen.lockingRadioBox);  n++;
1439   XtSetArg(args[n], XmNtopOffset,          style.verticalSpacing);  n++;
1440   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);       n++;
1441   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
1442   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1443   XtSetValues (screen.prevLabel, args, n);
1444
1445   /* cycleTime Label */
1446   n=0;
1447   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);     n++;
1448   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_FORM);       n++;
1449   XtSetArg(args[n], XmNbottomOffset,       style.verticalSpacing);  n++;
1450   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_FORM);       n++;
1451   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1452   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_NONE);       n++;
1453   XtSetValues (screen.cycleTimeLabel, args, n);
1454
1455   /* cycleTime Scale */
1456   n=0;
1457   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1458   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1459   XtSetArg(args[n], XmNbottomWidget,       screen.cycleTimeLabel);n++;
1460   XtSetArg(args[n], XmNbottomOffset,       ScaleOffset); n++;
1461   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_WIDGET);     n++;
1462   XtSetArg(args[n], XmNleftWidget,         screen.cycleTimeLabel);n++;
1463   XtSetArg(args[n], XmNleftOffset,         style.horizontalSpacing);  n++;
1464   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);       n++;
1465   XtSetArg(args[n], XmNrightWidget,        screen.cycleMinutesLabel);n++;
1466   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1467   XtSetValues (screen.cycleTimeScale, args, n);
1468
1469   /* Minutes label */
1470   n=0;
1471   XtSetArg(args[n], XmNtopAttachment,      XmATTACH_NONE);       n++;
1472   XtSetArg(args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET); n++;
1473   XtSetArg(args[n], XmNbottomWidget,       screen.cycleTimeLabel);n++;
1474   XtSetArg(args[n], XmNleftAttachment,     XmATTACH_NONE);     n++;
1475   XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);       n++;
1476   XtSetArg(args[n], XmNrightOffset,        style.horizontalSpacing);  n++;
1477   XtSetValues (screen.cycleMinutesLabel, args, n);
1478
1479   /* scrolled list  */
1480   n = 0;
1481   XtSetArg (args[n], XmNtopAttachment,      XmATTACH_WIDGET);          n++;
1482   XtSetArg (args[n], XmNtopWidget,          screen.prevLabel);  n++;
1483   XtSetArg (args[n], XmNtopOffset,          style.verticalSpacing);    n++;
1484   XtSetArg (args[n], XmNrightAttachment,    XmATTACH_NONE);        n++;
1485   XtSetArg (args[n], XmNleftAttachment,     XmATTACH_FORM);        n++;
1486   XtSetArg(args[n],  XmNleftOffset,         style.horizontalSpacing);  n++;
1487   XtSetArg (args[n], XmNbottomAttachment,   XmATTACH_WIDGET);       n++;
1488   XtSetArg(args[n],  XmNbottomWidget,       screen.cycleTimeLabel);       n++;
1489   XtSetArg(args[n],  XmNbottomOffset,       5*style.verticalSpacing);  n++;
1490   XtSetValues (XtParent(screen.saverList),  args, n);
1491
1492
1493   /* saverArea */
1494   n=0;
1495   XtSetArg (args[n], XmNtopAttachment,      XmATTACH_OPPOSITE_WIDGET);   n++;
1496   XtSetArg(args[n], XmNtopWidget,           XtParent(screen.saverList));  n++;
1497   XtSetArg (args[n], XmNleftAttachment,     XmATTACH_WIDGET);         n++;
1498   XtSetArg(args[n], XmNleftWidget,          XtParent(screen.saverList));  n++;
1499   XtSetArg(args[n], XmNleftOffset,          style.horizontalSpacing);  n++;
1500   XtSetArg (args[n], XmNrightAttachment,    XmATTACH_FORM);         n++;
1501   XtSetArg(args[n], XmNrightOffset,         style.horizontalSpacing);  n++;
1502   XtSetArg (args[n], XmNbottomAttachment,   XmATTACH_OPPOSITE_WIDGET);   n++;
1503   XtSetArg(args[n], XmNbottomWidget,        XtParent(screen.saverList));  n++;
1504   XtSetValues (screen.saverAreaFrame, args, n);
1505
1506
1507   XtRemoveCallback(style.screenDialog, XmNmapCallback, no_svr_ext_formLayoutCB, NULL);
1508   }
1509
1510 /*+++++++++++++++++++++++++++++++++++++++*/
1511 /* _DtmapCB_screenDialog                 */
1512 /*+++++++++++++++++++++++++++++++++++++++*/
1513
1514 static void
1515 _DtmapCB_screenDialog(
1516         Widget w,
1517         XtPointer client_data,
1518         XtPointer call_data )
1519 {
1520   static int    first_time = 1;
1521   register int  n;
1522   Arg           args[MAX_ARGS];
1523   XmString      string;
1524   Boolean       lock_on, saver_on;
1525
1526   if (first_time)
1527     {
1528       DtWsmRemoveWorkspaceFunctions(style.display, XtWindow(XtParent(w)));
1529
1530       if (!save.restoreFlag)
1531         putDialog ((Widget)client_data, w);
1532
1533       /*  Retrieve the value for the saver slider from xrdb */
1534       screen.saverTimeout_xrdb = atoi((char *)style.xrdb.timeoutScale);
1535       if (screen.saverTimeout_xrdb < 1)
1536         screen.saverTimeout_xrdb = 10;
1537
1538       /*  Retrieve the value for the lock slider from xrdb */
1539       screen.lockTimeout_xrdb = atoi((char *)style.xrdb.lockoutScale);
1540       if (screen.lockTimeout_xrdb < 1)
1541         screen.lockTimeout_xrdb = 30;
1542
1543       /* initialize the value of savertimeout and locktimeout and cycle time to the */
1544       /* initial state or to the values retrieved from xrdb if the corresponding*/
1545       /* initial state is zero */
1546       if (style.smState.smSaverTimeout)
1547         screen.saverTimeout = style.smState.smSaverTimeout / 60;
1548       else
1549         screen.saverTimeout = screen.saverTimeout_xrdb;
1550
1551       if (style.smState.smLockTimeout)
1552         screen.lockTimeout = style.smState.smLockTimeout / 60;
1553       else
1554         screen.lockTimeout = screen.lockTimeout_xrdb;
1555
1556       if (style.smState.smCycleTimeout)
1557         screen.cycleTimeout = style.smState.smCycleTimeout / 60;
1558       else
1559         screen.cycleTimeout = 0;
1560
1561
1562       /* set the value of the scales */
1563       XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
1564       XtVaSetValues(screen.lockOutScale, XmNvalue, screen.lockTimeout, NULL);
1565       XtVaSetValues(screen.cycleTimeScale, XmNvalue, screen.cycleTimeout , NULL);
1566
1567       /* set the value of the saver toggles */
1568       XmToggleButtonGadgetSetState(screen.saverOn,
1569                                    style.smState.smSaverTimeout  ? True : False, False);
1570       XmToggleButtonGadgetSetState(screen.saverOff,
1571                                    !style.smState.smSaverTimeout  ? True : False, False );
1572       XmToggleButtonGadgetSetState(screen.lockOn,
1573                                    style.smState.smLockTimeout  ? True : False, False);
1574       XmToggleButtonGadgetSetState(screen.lockOff,
1575                                    !style.smState.smLockTimeout  ? True : False, False);
1576
1577       /* make saver widgets insensitive if screen saver is off */
1578       /* also blank out the preview label widget */
1579       if (XmToggleButtonGadgetGetState(screen.saverOff))
1580         {
1581           XtSetSensitive(screen.saverList, False);
1582           XtSetSensitive(screen.saverArea, False);
1583           XtSetSensitive(screen.timeOutLabel, False);
1584           XtSetSensitive(screen.timeOutScale, False);
1585           XtSetSensitive(screen.saverMinutesLabel, False);
1586           XtSetSensitive(screen.cycleTimeLabel, False);
1587           XtSetSensitive(screen.cycleTimeScale, False);
1588           XtSetSensitive(screen.cycleMinutesLabel, False);
1589           XtUnmanageChild(screen.prevLabel);
1590         }
1591       /* make saver widgets sensitive if screen saver is on */
1592       /* also manage the preview label widget */
1593       if (XmToggleButtonGadgetGetState(screen.saverOn))
1594         {
1595           XtSetSensitive(screen.saverList, True);
1596           XtSetSensitive(screen.saverArea, True);
1597           XtSetSensitive(screen.timeOutLabel, True);
1598           XtSetSensitive(screen.timeOutScale, True);
1599           XtSetSensitive(screen.saverMinutesLabel, True);
1600           XtManageChild(screen.prevLabel);
1601           /* make cycletime scale sensitive if selected savers are more than 1 */
1602           if (savers.selsaverCount > 1)
1603             {
1604               XtSetSensitive(screen.cycleTimeLabel, True);
1605               XtSetSensitive(screen.cycleTimeScale, True);
1606               XtSetSensitive(screen.cycleMinutesLabel, True);
1607             }
1608           else
1609             {
1610               XtSetSensitive(screen.cycleTimeLabel, False);
1611               XtSetSensitive(screen.cycleTimeScale, False);
1612               XtSetSensitive(screen.cycleMinutesLabel, False);
1613             }
1614         }
1615       /* make lock widgets insensitive if lock screen is off */
1616       if (XmToggleButtonGadgetGetState(screen.lockOff))
1617         {
1618           XtSetSensitive(screen.lockOutLabel, False);
1619           XtSetSensitive(screen.lockOutScale, False);
1620           XtSetSensitive(screen.lockMinutesLabel, False);
1621         }
1622       /* make lock widgets sensitive if lock screen is on */
1623           if (XmToggleButtonGadgetGetState(screen.lockOn))
1624             {
1625               XtSetSensitive(screen.lockOutLabel, True);
1626               XtSetSensitive(screen.lockOutScale, True);
1627               XtSetSensitive(screen.lockMinutesLabel, True);
1628             }
1629
1630
1631       if (!style.smState.smSaverTimeout)
1632         screen.origTimeout = screen.newTimeout = style.smState.smLockTimeout;
1633       else
1634         if (!style.smState.smLockTimeout)
1635           screen.origTimeout = screen.newTimeout = style.smState.smSaverTimeout;
1636         else
1637           screen.origTimeout =
1638             screen.newTimeout =
1639               MIN(style.smState.smSaverTimeout, style.smState.smLockTimeout);
1640
1641       first_time = 0;
1642     }
1643   /* check the saver values from X  -  need to do this everytime dialog is mapped because */
1644   /* the user may have changed settings thru X while style manager has been running */
1645   /* if the value of the timeout retrieved from X is not equal to the new timeout set in the */
1646   /* style manager interface, then set both lock time and saver time scales to value retrieved from */
1647   /* X, otherwise leave them alone */
1648
1649   XGetScreenSaver(style.display, &screen.xTimeout, &screen.interval,
1650                   &screen.blanking, &screen.exposures);
1651
1652   screen.new_blanking = DontPreferBlanking;
1653
1654   if (screen.xTimeout < 0)
1655     screen.xTimeout = 0;
1656   else
1657     if ((screen.xTimeout < 60) && (screen.xTimeout > 1))
1658       screen.xTimeout = 60;
1659     else
1660       if (screen.xTimeout > TIMEOUT_MAX * 60)
1661         screen.xTimeout = TIMEOUT_MAX * 60;
1662
1663   if (screen.xTimeout < 0)
1664     screen.xTimeout = 0;
1665   else
1666     if ((screen.xTimeout < 60) && (screen.xTimeout > 1))
1667       screen.xTimeout = 60;
1668     else
1669       if (screen.xTimeout > TIMEOUT_MAX * 60)
1670         screen.xTimeout = TIMEOUT_MAX * 60;
1671
1672   screen.timeMismatch = False;
1673   if (screen.xTimeout != screen.newTimeout)
1674     {
1675       screen.timeMismatch = True;
1676       screen.newTimeout = screen.xTimeout;
1677       if (screen.xTimeout)
1678         {
1679           screen.saverTimeout = screen.xTimeout / 60;
1680           screen.lockTimeout = screen.xTimeout / 60;
1681         }
1682       else
1683         {
1684           screen.saverTimeout = screen.saverTimeout_xrdb;
1685           screen.lockTimeout = screen.lockTimeout_xrdb;
1686         }
1687       /* set the value of the saver widgets */
1688       XmToggleButtonGadgetSetState(screen.saverOn, screen.xTimeout ? True : False, False);
1689       XmToggleButtonGadgetSetState(screen.saverOff, !screen.xTimeout ? True : False, False);
1690       XmToggleButtonGadgetSetState(screen.lockOn, screen.xTimeout ? True : False, False);
1691       XmToggleButtonGadgetSetState(screen.lockOff, !screen.xTimeout ? True : False, False);
1692
1693       /* set the value of the scales */
1694       XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
1695       XtVaSetValues(screen.lockOutScale, XmNvalue, screen.lockTimeout_xrdb, NULL);
1696
1697       /* make saver widgets insensitive if screen saver is off */
1698       /* also blankout the preview label widget */
1699       if (XmToggleButtonGadgetGetState(screen.saverOff))
1700         {
1701           XtSetSensitive(screen.saverList, False);
1702           XtSetSensitive(screen.saverArea, False);
1703           XtSetSensitive(screen.timeOutLabel, False);
1704           XtSetSensitive(screen.timeOutScale, False);
1705           XtSetSensitive(screen.saverMinutesLabel, False);
1706           XtSetSensitive(screen.cycleTimeLabel, False);
1707           XtSetSensitive(screen.cycleTimeScale, False);
1708           XtSetSensitive(screen.cycleMinutesLabel, False);
1709           XtUnmanageChild(screen.prevLabel);
1710         }
1711       /* make saver widgets sensitive if screen saver is on */
1712       /* also manage the preview label widget */
1713       if (XmToggleButtonGadgetGetState(screen.saverOn))
1714         {
1715           XtSetSensitive(screen.saverList, True);
1716           XtSetSensitive(screen.saverArea, True);
1717           XtSetSensitive(screen.timeOutLabel, True);
1718           XtSetSensitive(screen.timeOutScale, True);
1719           XtSetSensitive(screen.saverMinutesLabel, True);
1720           XtManageChild(screen.prevLabel);
1721           /* make cycletime scale sensitive if selected savers are more than 1 */
1722           if (savers.selsaverCount > 1)
1723             {
1724               XtSetSensitive(screen.cycleTimeLabel, True);
1725               XtSetSensitive(screen.cycleTimeScale, True);
1726               XtSetSensitive(screen.cycleMinutesLabel, True);
1727             }
1728           else
1729             {
1730               XtSetSensitive(screen.cycleTimeLabel, False);
1731               XtSetSensitive(screen.cycleTimeScale, False);
1732               XtSetSensitive(screen.cycleMinutesLabel, False);
1733             }
1734         }
1735
1736       /* make lock widgets insensitive if lock screen is off */
1737       if (XmToggleButtonGadgetGetState(screen.lockOff))
1738         {
1739           XtSetSensitive(screen.lockOutLabel, False);
1740           XtSetSensitive(screen.lockOutScale, False);
1741           XtSetSensitive(screen.lockMinutesLabel, False);
1742         }
1743
1744       /* make lock widgets sensitive if lock screen is on */
1745       if (XmToggleButtonGadgetGetState(screen.lockOn))
1746         {
1747           XtSetSensitive(screen.lockOutLabel, True);
1748           XtSetSensitive(screen.lockOutScale, True);
1749           XtSetSensitive(screen.lockMinutesLabel, True);
1750         }
1751
1752     }
1753
1754   /* run the current screen saver only if screen saver is turned on and a valid saver exists*/
1755   if (XmToggleButtonGadgetGetState(screen.saverOn) && savers.saverCount && !savers.saverstate)
1756     {
1757       XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
1758
1759       savers.saverstate = _DtSaverStart(style.display, &screen.saverArea, 1,
1760                       savers.current_saver, style.screenDialog);
1761       string = XmStringCreateLocalized (savers.current_saverDesc);
1762       XtVaSetValues(screen.prevLabel, XmNlabelString, string, NULL);
1763       XmStringFree(string);
1764     }
1765 }
1766
1767 /*+++++++++++++++++++++++++++++++++++++++*/
1768 /* no_svr_ext_DtmapCB_screenDialog       */
1769 /*+++++++++++++++++++++++++++++++++++++++*/
1770
1771 static void
1772 no_svr_ext_DtmapCB_screenDialog(
1773         Widget w,
1774         XtPointer client_data,
1775         XtPointer call_data )
1776 {
1777   static int    first_time = 1;
1778   register int  n;
1779   Arg           args[MAX_ARGS];
1780   XmString      string;
1781   int           mintime;
1782
1783   if (first_time)
1784     {
1785       DtWsmRemoveWorkspaceFunctions(style.display, XtWindow(XtParent(w)));
1786
1787       if (!save.restoreFlag)
1788         putDialog ((Widget)client_data, w);
1789
1790       /*  Retrieve the value for the saver slider from xrdb */
1791       screen.saverTimeout_xrdb = atoi((char *)style.xrdb.timeoutScale);
1792       if (screen.saverTimeout_xrdb < 1)
1793         screen.saverTimeout_xrdb = 10;
1794
1795       if (style.smState.smCycleTimeout)
1796         screen.cycleTimeout = style.smState.smCycleTimeout / 60;
1797       else
1798         screen.cycleTimeout = 0;
1799
1800       /* set the value of the cycle time scale */
1801       XtVaSetValues(screen.cycleTimeScale, XmNvalue, screen.cycleTimeout , NULL);
1802
1803       /* set the initial condition for the locking RadioBoxes */
1804
1805       XmToggleButtonGadgetSetState(screen.useSaversOn,
1806                                    style.smState.smSaverTimeout  ? True : False, False);
1807       XmToggleButtonGadgetSetState(screen.useSaversOff,
1808                                    style.smState.smSaverTimeout  ? False : True, False);
1809
1810       if (style.smState.smSaverTimeout)
1811         {
1812           XtSetSensitive(screen.saverList, True);
1813           XtSetSensitive(screen.saverArea, True);
1814           if (savers.selsaverCount > 1)
1815             {
1816               XtSetSensitive(screen.cycleTimeLabel, True);
1817               XtSetSensitive(screen.cycleTimeScale, True);
1818               XtSetSensitive(screen.cycleMinutesLabel, True);
1819             }
1820           else
1821             {
1822               XtSetSensitive(screen.cycleTimeLabel, False);
1823               XtSetSensitive(screen.cycleTimeScale, False);
1824               XtSetSensitive(screen.cycleMinutesLabel, False);
1825             }
1826           XtManageChild(screen.prevLabel);
1827           SmNewSaverTime(60);
1828         }
1829       else
1830         {
1831           XtSetSensitive(screen.saverList, False);
1832           XtSetSensitive(screen.saverArea, False);
1833           XtSetSensitive(screen.cycleTimeLabel, False);
1834           XtSetSensitive(screen.cycleTimeScale, False);
1835           XtSetSensitive(screen.cycleMinutesLabel, False);
1836           XtUnmanageChild(screen.prevLabel);
1837           SmNewSaverTime(0);
1838         }
1839       screen.newTimeout = screen.origTimeout = 0;
1840
1841       first_time = 0;
1842     }
1843
1844   /* check the saver values from X  -  need to do this everytime dialog is mapped because */
1845   /* the user may have changed settings thru X while style manager has been running */
1846   /* if the value of the timeout retrieved from X is not equal to the new timeout set in the */
1847   /* style manager interface, then set both lock time and saver time scales to value retrieved from */
1848   /* X, otherwise leave them alone */
1849
1850   XGetScreenSaver(style.display, &screen.xTimeout, &screen.interval,
1851                   &screen.blanking, &screen.exposures);
1852
1853   screen.new_blanking = PreferBlanking;
1854
1855   if (screen.xTimeout < 0)
1856     screen.xTimeout = 0;
1857   else
1858     if ((screen.xTimeout < 60) && (screen.xTimeout > 1))
1859       screen.xTimeout = 60;
1860     else
1861       if (screen.xTimeout > TIMEOUT_MAX * 60)
1862         screen.xTimeout = TIMEOUT_MAX * 60;
1863
1864   if (screen.xTimeout != screen.newTimeout)
1865     {
1866       screen.origTimeout = screen.newTimeout = screen.xTimeout;
1867       screen.saverTimeout = screen.xTimeout / 60;
1868     }
1869
1870   /* set the value of the saver widgets */
1871   XmToggleButtonGadgetSetState(screen.saverOn, screen.newTimeout ? True : False, False);
1872   XmToggleButtonGadgetSetState(screen.saverOff, !screen.newTimeout ? True : False, False);
1873
1874   if (!screen.saverTimeout)
1875     screen.saverTimeout = screen.saverTimeout_xrdb;
1876
1877   XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
1878
1879   /* make saver widgets insensitive if screen saver is off */
1880   if (XmToggleButtonGadgetGetState(screen.saverOff))
1881     {
1882       XtSetSensitive(screen.timeOutLabel, False);
1883       XtSetSensitive(screen.timeOutScale, False);
1884       XtSetSensitive(screen.saverMinutesLabel, False);
1885     }
1886   /* make saver widgets sensitive if screen saver is on */
1887   if (XmToggleButtonGadgetGetState(screen.saverOn))
1888     {
1889       XtSetSensitive(screen.timeOutLabel, True);
1890       XtSetSensitive(screen.timeOutScale, True);
1891       XtSetSensitive(screen.saverMinutesLabel, True);
1892     }
1893
1894
1895   /* run the current screen saver only if the useSaversOn toggle is enabled and valid saver exist*/
1896   if (XmToggleButtonGadgetGetState(screen.useSaversOn) && savers.saverCount && !savers.saverstate)
1897     {
1898       XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
1899       savers.saverstate = _DtSaverStart(style.display, &screen.saverArea, 1,
1900                                    savers.current_saver, style.screenDialog);
1901       string = XmStringCreateLocalized (savers.current_saverDesc);
1902       XtVaSetValues(screen.prevLabel, XmNlabelString, string, NULL);
1903       XmStringFree(string);
1904     }
1905
1906 }
1907
1908 /*****************************************/
1909 /* timeOutvalueChangedCB                 */
1910 /* set the timeout to be the minimum of  */
1911 /* the lock scale and timeout scale      */
1912 /*****************************************/
1913 static void
1914 timeOutvalueChangedCB(
1915         Widget w,
1916         XtPointer client_data,
1917         XtPointer call_data )
1918 {
1919     register int     n;
1920     Arg              args[MAX_ARGS];
1921
1922     n=0;
1923     XtSetArg(args[n], XmNvalue, &screen.saverTimeout); n++;
1924     XtGetValues(screen.timeOutScale, args, n);
1925
1926     n=0;
1927     XtSetArg(args[n], XmNvalue, &screen.lockTimeout); n++;
1928     XtGetValues(screen.lockOutScale, args, n);
1929
1930     /* set newTimeout to the min value of lock scale and saver scale */
1931     /* unless either screen saver or lock is off */
1932     if (!XmToggleButtonGadgetGetState(screen.lockOn))
1933           screen.newTimeout = screen.saverTimeout * 60;
1934     else
1935       if (!XmToggleButtonGadgetGetState(screen.saverOn))
1936         screen.newTimeout = screen.lockTimeout * 60;
1937       else
1938         screen.newTimeout = MIN(screen.saverTimeout, screen.lockTimeout) * 60;
1939
1940     /* register new timeout with X */
1941      XSetScreenSaver(style.display, screen.newTimeout,
1942          screen.interval, screen.new_blanking, screen.exposures);
1943
1944     screen.systemDefaultFlag = False;
1945 }
1946 /*****************************************/
1947 /* no_svr_ext_timeOutvalueChangedCB      */
1948 /* set the timeout to be the minimum of  */
1949 /* the lock scale and timeout scale      */
1950 /*****************************************/
1951 static void
1952 no_svr_ext_timeOutvalueChangedCB(
1953         Widget w,
1954         XtPointer client_data,
1955         XtPointer call_data )
1956 {
1957     register int     n;
1958     Arg              args[MAX_ARGS];
1959
1960     n=0;
1961     XtSetArg(args[n], XmNvalue, &screen.saverTimeout); n++;
1962     XtGetValues(screen.timeOutScale, args, n);
1963
1964     /* set newTimeout to the value of saver scale */
1965     screen.newTimeout = screen.saverTimeout * 60;
1966
1967     /* register new timeout with X */
1968      XSetScreenSaver(style.display, screen.newTimeout,
1969          screen.interval, screen.new_blanking, screen.exposures);
1970     screen.systemDefaultFlag = False;
1971 }
1972
1973 /*+++++++++++++++++++++++++++++++++++++++*/
1974 /* saverToggleCB                         */
1975 /*+++++++++++++++++++++++++++++++++++++++*/
1976 static void
1977 saverToggleCB(
1978         Widget w,
1979         XtPointer client_data,
1980         XtPointer call_data )
1981 {
1982   register int     n;
1983   Arg              args[MAX_ARGS];
1984   Boolean          set;
1985   XmString string;
1986   XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
1987
1988   set = (Boolean) cb->set;
1989
1990
1991   if (w == screen.saverOff && !set )
1992     {
1993       return;
1994     }
1995
1996   if (w == screen.saverOff && set)
1997     {
1998       /* Terminate the screen saver that is currently running */
1999       if (savers.saverstate)
2000         {
2001           _DtSaverStop(style.display, savers.saverstate);
2002           savers.saverstate = NULL;
2003           XSync(style.display, False);
2004           XClearWindow(style.display, XtWindow(screen.saverArea));
2005         }
2006       XtSetSensitive(screen.saverList, False);
2007       XtSetSensitive(screen.saverArea, False);
2008       XtSetSensitive(screen.timeOutLabel, False);
2009       XtSetSensitive(screen.timeOutScale, False);
2010       XtSetSensitive(screen.saverMinutesLabel, False);
2011       XtSetSensitive(screen.cycleTimeLabel, False);
2012       XtSetSensitive(screen.cycleTimeScale, False);
2013       XtSetSensitive(screen.cycleMinutesLabel, False);
2014       /* do not display preview string */
2015       XtUnmanageChild(screen.prevLabel);
2016       /* set the background color of the saver window to the */
2017       /* secondary color ID */
2018       XSync(style.display, False);
2019       XtVaSetValues(screen.saverArea, XmNbackground, savers.bg, NULL);
2020       XClearWindow(style.display, XtWindow(screen.saverArea));
2021       /* set the new timeout for the X server - note that since */
2022       /* screen saver is disabled, the new timeout is now the value of the */
2023       /* lock slider or zero if lock is disabled  */
2024       if (XmToggleButtonGadgetGetState(screen.lockOn))
2025         screen.newTimeout = screen.lockTimeout * 60;
2026       else
2027         screen.newTimeout = 0;
2028       /* let the session manger know not to run any savers */
2029       SmNewSaverTime(0);
2030     }
2031
2032
2033   if (w == screen.saverOn && !set)
2034     {
2035       return;
2036     }
2037
2038   if (w == screen.saverOn && set)
2039     {
2040       XtSetSensitive(screen.saverList, True);
2041       XtSetSensitive(screen.saverArea, True);
2042       XtSetSensitive(screen.timeOutLabel, True);
2043       XtSetSensitive(screen.timeOutScale, True);
2044       XtSetSensitive(screen.saverMinutesLabel , True);
2045       if (savers.selsaverCount > 1)
2046         {
2047           XtSetSensitive(screen.cycleTimeLabel, True);
2048           XtSetSensitive(screen.cycleTimeScale, True);
2049           XtSetSensitive(screen.cycleMinutesLabel, True );
2050         }
2051       else
2052         {
2053           XtSetSensitive(screen.cycleTimeLabel, False);
2054           XtSetSensitive(screen.cycleTimeScale, False);
2055           XtSetSensitive(screen.cycleMinutesLabel, False);
2056         }
2057
2058       if (savers.saverCount)
2059         {
2060           /* display the preview label */
2061           XtManageChild(screen.prevLabel);
2062           /* Restart the screen saver that is is currently selected */
2063           if (!savers.saverstate)
2064             {
2065               XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
2066               savers.saverstate = _DtSaverStart(style.display,
2067                       &screen.saverArea, 1, savers.current_saver,
2068                       style.screenDialog);
2069             }
2070           /* set the new timeout for the X server - note that since */
2071           /* screen saver is enabled, the new timeout is now the value of the */
2072           /* saver slider or the minimum of the timeout sliders */
2073         }
2074       if (!XmToggleButtonGadgetGetState(screen.lockOn))
2075         screen.newTimeout = screen.saverTimeout * 60;
2076       else
2077         screen.newTimeout = MIN(screen.saverTimeout, screen.lockTimeout) * 60;
2078       /* let the session manger know to run savers */
2079       SmNewSaverTime(screen.newTimeout);
2080     }
2081
2082   XSetScreenSaver(style.display, screen.newTimeout,
2083                   screen.interval, screen.new_blanking, screen.exposures);
2084
2085   screen.systemDefaultFlag = False;
2086 }
2087 /*+++++++++++++++++++++++++++++++++++++++*/
2088 /* no_svr_ext_saverToggleCB              */
2089 /*+++++++++++++++++++++++++++++++++++++++*/
2090 static void
2091 no_svr_ext_saverToggleCB(
2092         Widget w,
2093         XtPointer client_data,
2094         XtPointer call_data )
2095 {
2096     register int     n;
2097     Arg              args[MAX_ARGS];
2098     Boolean          set;
2099     XmString string;
2100     XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
2101
2102     set = (Boolean) cb->set;
2103
2104
2105     if (w == screen.saverOff && !set )
2106       {
2107       return;
2108       }
2109
2110     if (w == screen.saverOff && set)
2111       {
2112         XtSetSensitive(screen.timeOutLabel, False);
2113         XtSetSensitive(screen.timeOutScale, False);
2114         XtSetSensitive(screen.saverMinutesLabel, False);
2115         /* set the new timeout for the X server - note that since */
2116         /* screen saver is disabled, the new timeout is now zero */
2117         screen.newTimeout = 0;
2118       }
2119
2120     if (w == screen.saverOn && !set)
2121       {
2122         return;
2123       }
2124
2125     if (w == screen.saverOn && set)
2126       {
2127         XtSetSensitive(screen.timeOutLabel, True);
2128         XtSetSensitive(screen.timeOutScale, True);
2129         XtSetSensitive(screen.saverMinutesLabel , True);
2130         /* register the new timeout with the X server - note that since */
2131         /* screen saver is enabled, the new timeout is now the value of the */
2132         /* saver slider */
2133         screen.newTimeout = screen.saverTimeout * 60;
2134       }
2135
2136     XSetScreenSaver(style.display, screen.newTimeout,
2137                         screen.interval, screen.new_blanking, screen.exposures);
2138
2139     screen.systemDefaultFlag = False;
2140   }
2141
2142 /*+++++++++++++++++++++++++++++++++++++++*/
2143 /* lock ToggleCB                         */
2144 /*+++++++++++++++++++++++++++++++++++++++*/
2145 static void
2146 lockToggleCB(
2147         Widget w,
2148         XtPointer client_data,
2149         XtPointer call_data )
2150 {
2151     register int     n;
2152     Arg              args[MAX_ARGS];
2153     Boolean          set;
2154     XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
2155
2156     set = (Boolean) cb->set;
2157
2158
2159     if (w == screen.lockOff && !set )
2160       {
2161       return;
2162       }
2163
2164     if (w == screen.lockOff && set)
2165       {
2166         XtSetSensitive(screen.lockOutLabel, False);
2167         XtSetSensitive(screen.lockOutScale, False);
2168         XtSetSensitive(screen.lockMinutesLabel, False);
2169
2170         /* register the new timeout with the X server - note that since */
2171         /* lock is disabled, the new timeout is now the value of the */
2172         /* saver slider or zero if saver is disabled */
2173         if (XmToggleButtonGadgetGetState(screen.saverOn))
2174           screen.newTimeout = screen.saverTimeout * 60;
2175         else
2176           screen.newTimeout = 0;
2177
2178         XSetScreenSaver(style.display, screen.newTimeout,
2179                         screen.interval, screen.new_blanking, screen.exposures);
2180       }
2181
2182     if (w == screen.lockOn && !set)
2183       {
2184       return;
2185       }
2186
2187     if (w == screen.lockOn && set)
2188       {
2189         XtSetSensitive(screen.lockOutLabel, True);
2190         XtSetSensitive(screen.lockOutScale, True);
2191         XtSetSensitive(screen.lockMinutesLabel, True);
2192
2193         /* register the new timeout with the X server - note that since */
2194         /* lock is disabled, the new timeout is now the value of the */
2195         /* lock slider or the minimum of the two timeout sliders */
2196         if (!XmToggleButtonGadgetGetState(screen.saverOn))
2197           screen.newTimeout = screen.lockTimeout * 60;
2198         else
2199           screen.newTimeout = MIN(screen.saverTimeout, screen.lockTimeout) * 60;
2200
2201         XSetScreenSaver(style.display, screen.newTimeout,
2202                         screen.interval, screen.new_blanking, screen.exposures);
2203       }
2204     screen.systemDefaultFlag = False;
2205
2206 }
2207
2208 /*+++++++++++++++++++++++++++++++++++++++*/
2209 /* saversToggleCB                        */
2210 /*+++++++++++++++++++++++++++++++++++++++*/
2211 static void
2212 saversToggleCB(
2213         Widget w,
2214         XtPointer client_data,
2215         XtPointer call_data )
2216 {
2217   register int     n;
2218   Arg              args[MAX_ARGS];
2219   Boolean          set;
2220   XmString string;
2221   XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
2222
2223   set = (Boolean) cb->set;
2224
2225   if (w == screen.useSaversOff && !set )
2226       {
2227       return;
2228       }
2229
2230     if (w == screen.useSaversOff && set)
2231       {
2232         /* Terminate the screen saver that is currently running */
2233         if (savers.saverstate)
2234           {
2235             _DtSaverStop(style.display, savers.saverstate);
2236             savers.saverstate = NULL;
2237             XSync(style.display, False);
2238             XClearWindow(style.display, XtWindow(screen.saverArea));
2239           }
2240
2241         XtSetSensitive(screen.saverList, False);
2242         XtSetSensitive(screen.saverArea, False);
2243         XtSetSensitive(screen.cycleTimeLabel, False);
2244         XtSetSensitive(screen.cycleTimeScale, False);
2245         XtSetSensitive(screen.cycleMinutesLabel, False);
2246         /* do not display preview string */
2247         XtUnmanageChild(screen.prevLabel);
2248         /* set the background color of the saver window to the */
2249         /* secondary color ID */
2250         XSync(style.display, False);
2251         XtVaSetValues(screen.saverArea, XmNbackground, savers.bg, NULL);
2252         XClearWindow(style.display, XtWindow(screen.saverArea));
2253         /* let the session manger know not to run any savers */
2254         SmNewSaverTime(0);
2255       }
2256
2257     if (w == screen.useSaversOn && !set)
2258       {
2259       return;
2260       }
2261
2262     if (w == screen.useSaversOn && set)
2263       {
2264         XtSetSensitive(screen.saverList, True);
2265         XtSetSensitive(screen.saverArea, True);
2266         if (savers.selsaverCount > 1)
2267           {
2268             XtSetSensitive(screen.cycleTimeLabel, True);
2269             XtSetSensitive(screen.cycleTimeScale, True);
2270             XtSetSensitive(screen.cycleMinutesLabel, True);
2271           }
2272         if (savers.saverCount)
2273           {
2274             /* display the preview label */
2275             XtManageChild(screen.prevLabel);
2276             /* Restart the screen saver that is is currently selected */
2277             if (!savers.saverstate)
2278               {
2279                 XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
2280                 savers.saverstate = _DtSaverStart(style.display,
2281                                                   &screen.saverArea, 1, savers.current_saver,                                     style.screenDialog);
2282               }
2283           }
2284         /* let the session manger know to run the savers */
2285         SmNewSaverTime(screen.saverTimeout*60);
2286
2287       }
2288 }
2289
2290 /*+++++++++++++++++++++++++++++++++++++++*/
2291 /* systemDefaultCB                       */
2292 /*+++++++++++++++++++++++++++++++++++++++*/
2293 static void
2294 systemDefaultCB(
2295                 Widget w,
2296                 XtPointer client_data,
2297                 XtPointer call_data )
2298 {
2299   register int  n;
2300   Arg           args[MAX_ARGS];
2301
2302   screen.saverTimeout = SAVER_DEFAULT;
2303   n=0;
2304   XtSetArg(args[n], XmNvalue, screen.saverTimeout); n++;
2305   XtSetValues(screen.timeOutScale, args, n);
2306
2307   screen.lockTimeout = LOCK_DEFAULT;
2308   n=0;
2309   XtSetArg(args[n], XmNvalue, screen.lockTimeout); n++;
2310   XtSetValues(screen.lockOutScale, args, n);
2311   XmToggleButtonGadgetSetState(screen.lockOff, True, True);
2312
2313   screen.cycleTimeout = CYCLE_DEFAULT;
2314   n=0;
2315   XtSetArg(args[n], XmNvalue, screen.cycleTimeout); n++;
2316   XtSetValues(screen.cycleTimeScale, args, n);
2317   XmToggleButtonGadgetSetState(screen.saverOn, True, True);
2318
2319   screen.newTimeout = MIN(SAVER_DEFAULT, LOCK_DEFAULT) * 60;
2320   /* register new timeout with X */
2321   XSetScreenSaver(style.display, screen.newTimeout,
2322                   screen.interval, screen.new_blanking, screen.exposures);
2323   screen.systemDefaultFlag = True;
2324 }
2325
2326 /*+++++++++++++++++++++++++++++++++++++++*/
2327 /* no_svr_ext_systemDefaultCB            */
2328 /*+++++++++++++++++++++++++++++++++++++++*/
2329 static void
2330 no_svr_ext_systemDefaultCB(
2331         Widget w,
2332         XtPointer client_data,
2333         XtPointer call_data )
2334 {
2335   register int  n;
2336   Arg           args[MAX_ARGS];
2337
2338   screen.saverTimeout = SAVER_DEFAULT;
2339   n=0;
2340   XtSetArg(args[n], XmNvalue, screen.saverTimeout); n++;
2341   XtSetValues(screen.timeOutScale, args, n);
2342
2343   screen.cycleTimeout = CYCLE_DEFAULT;
2344   n=0;
2345   XtSetArg(args[n], XmNvalue, screen.cycleTimeout); n++;
2346   XtSetValues(screen.cycleTimeScale, args, n);
2347
2348   XmToggleButtonGadgetSetState(screen.saverOn, True, True);
2349   XmToggleButtonGadgetSetState(screen.useSaversOn, True, True);
2350
2351   screen.newTimeout = SAVER_DEFAULT * 60;
2352   /* register new timeout with X */
2353   XSetScreenSaver(style.display, screen.newTimeout,
2354                   screen.interval, screen.new_blanking, screen.exposures);
2355
2356   screen.systemDefaultFlag = True;
2357 }
2358
2359 /*+++++++++++++++++++++++++++++++++++++++*/
2360 /* ButtonCB                              */
2361 /* callback for PushButtons in DialogBox */
2362 /*+++++++++++++++++++++++++++++++++++++++*/
2363 static void
2364 ButtonCB(
2365          Widget w,
2366          XtPointer client_data,
2367          XtPointer call_data )
2368 {
2369   register int        i, n, m;
2370   Arg                 args[MAX_ARGS];
2371   Boolean             sel_matched = False;
2372   Boolean             lockset;
2373   Boolean             saverset;
2374   Boolean             flag;
2375   static char         screenres[48];
2376   int                 mintime;
2377
2378   DtDialogBoxCallbackStruct *cb = (DtDialogBoxCallbackStruct *) call_data;
2379
2380   switch (cb->button_position)
2381     {
2382     case OK_BUTTON:
2383
2384       XtUnmanageChild (w);
2385       /* terminate the saver that is currently running */
2386       if (savers.saverstate)
2387         {
2388           _DtSaverStop(style.display, savers.saverstate);
2389           savers.saverstate = NULL;
2390         }
2391
2392       /* write saver timeout resource to xrdb to save scale value */
2393       /* when screen saver is turned off */
2394       saverset = XmToggleButtonGadgetGetState(screen.saverOn);
2395       if (!saverset)
2396         {
2397           sprintf (screenres, "Dtstyle*timeoutScale: %d\n", screen.saverTimeout);
2398           _DtAddToResource (style.display, screenres);
2399         }
2400
2401       /* write lock timeout resource to xrdb to save scale value */
2402       /* when lock is turned off */
2403       lockset = XmToggleButtonGadgetGetState(screen.lockOn);
2404       if (!lockset)
2405         {
2406           sprintf (screenres, "Dtstyle*lockoutScale: %d\n", screen.lockTimeout);
2407           _DtAddToResource (style.display, screenres);
2408         }
2409
2410       /* if sendSettings is true send message to Session Manager */
2411       if(style.smState.smSendSettings)
2412         {
2413           if(screen.systemDefaultFlag)
2414             {
2415               SmDefaultScreenSettings();
2416             }
2417           else
2418             {
2419
2420               SmNewScreenSettings(saverset||lockset ? screen.newTimeout : 0,
2421                                   screen.new_blanking,
2422                                   screen.interval,
2423                                   screen.exposures);
2424             }
2425         }
2426
2427
2428
2429       if (savers.saverCount)
2430         {
2431           savers.selsaverActionNames = (char **) XtMalloc(sizeof(char *) *
2432                                                           savers.selsaverCount);
2433
2434           for (i=0; i<savers.selsaverCount; i++)
2435             {
2436               char *tmp = savers.saverActionNames[savers.selPositions[i] - 1];
2437               savers.selsaverActionNames[i] = (char *) XtMalloc(strlen(tmp) + 1);
2438               strcpy(savers.selsaverActionNames[i], tmp);
2439             }
2440
2441           if (savers.selsaversList != NULL)
2442             XtFree((char*) savers.selsaversList);
2443
2444           savers.selsaversList = build_selectedList(savers.selsaverActionNames,
2445                                                 savers.selsaverCount);
2446         }
2447
2448       else
2449         savers.selsaversList = NULL;
2450
2451       /* save the selected positions for later use */
2452       savers.orig_selsaverCount = savers.selsaverCount;
2453       if (savers.origSelPositions != NULL)
2454         XtFree((char *) savers.origSelPositions);
2455       savers.origSelPositions = (int *) XtMalloc(sizeof(int) * savers.orig_selsaverCount);
2456       for (i=0; i<savers.orig_selsaverCount; i++)
2457         savers.origSelPositions[i] = savers.selPositions[i];
2458
2459       /* free the allocated selected savers */
2460       free_saverList(savers.selsaverActionNames, savers.selsaverCount);
2461       savers.selsaverActionNames = NULL;
2462
2463       XtVaGetValues(screen.cycleTimeScale, XmNvalue, &screen.cycleTimeout, NULL);
2464
2465       /* send new saver time, lock time and time per saver to SM if they have changed, */
2466       /* flag value indicates which value has changed */
2467
2468       SmNewSaverSettings(saverset ? screen.saverTimeout*60 : 0,
2469                          lockset ? screen.lockTimeout*60 : 0,
2470                          screen.cycleTimeout*60,
2471                          savers.selsaversList);
2472
2473       style.smState.smSaverTimeout = saverset ? screen.saverTimeout*60 : 0;
2474       style.smState.smLockTimeout = lockset ? screen.lockTimeout*60 : 0;
2475       style.smState.smCycleTimeout = screen.cycleTimeout*60;
2476       style.smSaver.saverList = savers.selsaversList;
2477
2478       screen.origTimeout = screen.newTimeout;
2479       XSetScreenSaver(style.display, style.smState.smSaverTimeout,
2480                       style.smState.smCycleTimeout,
2481                       screen.new_blanking,
2482                       screen.exposures);
2483
2484       break;
2485
2486     case CANCEL_BUTTON:
2487       XtUnmanageChild(w);
2488
2489       /* initialize the value of savertimeout and locktimeout and cycle time to the */
2490       /* current state or to the values retrieved from xrdb if the corresponding */
2491       /* initial state is zero */
2492       if (style.smState.smSaverTimeout)
2493         screen.saverTimeout = style.smState.smSaverTimeout / 60;
2494       else
2495         screen.saverTimeout = screen.saverTimeout_xrdb;
2496
2497       if (style.smState.smLockTimeout)
2498         screen.lockTimeout = style.smState.smLockTimeout / 60;
2499       else
2500         screen.lockTimeout = screen.lockTimeout_xrdb;
2501
2502       if (style.smState.smCycleTimeout)
2503         screen.cycleTimeout = style.smState.smCycleTimeout / 60;
2504       else
2505         screen.cycleTimeout = 0;
2506
2507
2508       /* reset the value of the scales */
2509       XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
2510       XtVaSetValues(screen.lockOutScale, XmNvalue, screen.lockTimeout, NULL);
2511       XtVaSetValues(screen.cycleTimeScale, XmNvalue, screen.cycleTimeout , NULL);
2512
2513       /* reset the value of the saver toggles */
2514       XmToggleButtonGadgetSetState(screen.saverOn, style.smState.smSaverTimeout  ? True : False, True);
2515       XmToggleButtonGadgetSetState(screen.saverOff, !style.smState.smSaverTimeout  ? True : False, True);
2516       XmToggleButtonGadgetSetState(screen.lockOn, style.smState.smLockTimeout  ? True : False, True);
2517       XmToggleButtonGadgetSetState(screen.lockOff, !style.smState.smLockTimeout  ? True : False, True);
2518
2519       /* reset the X timeout */
2520       screen.newTimeout = screen.origTimeout;
2521       XSetScreenSaver(style.display, screen.origTimeout, screen.interval,
2522                       screen.blanking, screen.exposures);
2523
2524       /* if timeMismatch is true, set the timeout to xTimeout so that the next time */
2525       /* the interface is mapped the correct timeouts show up */
2526       if (screen.timeMismatch)
2527         XSetScreenSaver(style.display, screen.xTimeout, screen.interval,
2528                         screen.blanking,screen.exposures);
2529
2530
2531       if (savers.saverCount)
2532           {
2533             /* reset the list selection back to the current state */
2534             /* first deselect all items */
2535             XmListDeselectAllItems(screen.saverList);
2536             for (i=0; i<savers.orig_selsaverCount; i++)
2537               XmListSelectPos(screen.saverList, savers.origSelPositions[i], False);
2538             /* set the current saver to be the first saver in the selected list */
2539             savers.current_saver = savers.saverActionNames[savers.origSelPositions[0] - 1];
2540             savers.current_saverDesc = savers.saverActionDesc[savers.origSelPositions[0] - 1];
2541             savers.current_position = savers.origSelPositions[0];
2542           }
2543
2544       /* Need to make sure the savers.selPositions array reflects the accurate
2545          current selections.  If the user invokes the Screen dialog, then cancels,
2546          then reinvokes and OKs without making any changes to the selections, the
2547          savers.selPositions array is assumed to contain the accurate selections.
2548          Unless we reset it here to the origSelPositions, it may be inaccurate.
2549       */
2550
2551       XtFree((char *) savers.selPositions);
2552       savers.selPositions = (int *) XtMalloc(sizeof(int) * savers.orig_selsaverCount);
2553
2554       for (i=0; i<savers.orig_selsaverCount; i++)
2555         savers.selPositions[i] = savers.origSelPositions[i];
2556
2557       savers.selsaverCount = savers.orig_selsaverCount;
2558
2559       break;
2560
2561
2562       break;
2563
2564
2565     case HELP_BUTTON:
2566       XtCallCallbacks(style.screenDialog, XmNhelpCallback, (XtPointer)NULL);
2567       break;
2568
2569     default:
2570       break;
2571     }
2572 }
2573
2574 /*+++++++++++++++++++++++++++++++++++++++*/
2575 /* no_svr_ext_ButtonCB                   */
2576 /* callback for PushButtons in DialogBox */
2577 /*+++++++++++++++++++++++++++++++++++++++*/
2578 static void
2579 no_svr_ext_ButtonCB(
2580                      Widget w,
2581                      XtPointer client_data,
2582                      XtPointer call_data )
2583 {
2584   register int        i, n, m;
2585   Arg                 args[MAX_ARGS];
2586   Boolean             sel_matched = False;
2587   Boolean             saverset;
2588   Boolean             flag;
2589   static char         screenres[48];
2590   int                 mintime;
2591
2592   DtDialogBoxCallbackStruct *cb = (DtDialogBoxCallbackStruct *) call_data;
2593
2594   switch (cb->button_position)
2595     {
2596     case OK_BUTTON:
2597
2598       XtUnmanageChild (w);
2599       /* terminate the saver that is currently running */
2600       if (savers.saverstate)
2601         {
2602           _DtSaverStop(style.display, savers.saverstate);
2603           savers.saverstate = NULL;
2604         }
2605
2606       /* write saver timeout resource to xrdb to save scale value */
2607       /* when screen saver is turned off */
2608       saverset = XmToggleButtonGadgetGetState(screen.saverOn);
2609       if (!saverset)
2610         {
2611           sprintf (screenres, "Dtstyle*timeoutScale: %d\n", screen.saverTimeout);
2612           _DtAddToResource (style.display, screenres);
2613         }
2614
2615       /* if sendSettings is true send message to Session Manager */
2616       if(style.smState.smSendSettings)
2617         {
2618           if(screen.systemDefaultFlag)
2619             {
2620               SmDefaultScreenSettings();
2621             }
2622           else
2623             {
2624               SmNewScreenSettings(saverset ? screen.newTimeout : 0,
2625                                   screen.new_blanking,
2626                                   screen.interval,
2627                                   screen.exposures);
2628             }
2629         }
2630
2631
2632
2633       if (savers.saverCount)
2634         {
2635           savers.selsaverActionNames = (char **) XtMalloc(sizeof(char *) *
2636                                                           savers.selsaverCount);
2637
2638           for (i=0; i<savers.selsaverCount; i++)
2639             {
2640               char *tmp = savers.saverActionNames[savers.selPositions[i] - 1];
2641               savers.selsaverActionNames[i] = (char *) XtMalloc(strlen(tmp) + 1);
2642               strcpy(savers.selsaverActionNames[i], tmp);
2643             }
2644
2645           if (savers.selsaversList != NULL)
2646             XtFree((char*) savers.selsaversList);
2647
2648           savers.selsaversList = build_selectedList(savers.selsaverActionNames,
2649                                                 savers.selsaverCount);
2650         }
2651
2652       else
2653         savers.selsaversList = NULL;
2654
2655       /* save the selected positions for later use */
2656       savers.orig_selsaverCount = savers.selsaverCount;
2657       if (savers.origSelPositions != NULL)
2658         XtFree((char *) savers.origSelPositions);
2659       savers.origSelPositions = (int *) XtMalloc(sizeof(int) * savers.orig_selsaverCount);
2660       for (i=0; i<savers.orig_selsaverCount; i++)
2661         savers.origSelPositions[i] = savers.selPositions[i];
2662
2663       /* free the allocated selected savers */
2664       free_saverList(savers.selsaverActionNames, savers.selsaverCount);
2665       savers.selsaverActionNames = NULL;
2666
2667       XtVaGetValues(screen.cycleTimeScale, XmNvalue, &screen.cycleTimeout, NULL);
2668
2669       /* send new saver time, lock time and time per saver to SM if they have changed, */
2670       /* flag value indicates which value has changed */
2671       /* send zero to the session manger if no savers selected */
2672
2673       if(!XmToggleButtonGadgetGetState(screen.useSaversOn))
2674         saverset = False;
2675       else
2676         saverset = True;
2677       SmNewSaverSettings(saverset ? screen.saverTimeout*60 : 0,
2678                          style.smState.smLockTimeout,
2679                          screen.cycleTimeout*60,
2680                          savers.selsaversList);
2681
2682       style.smState.smSaverTimeout = saverset ? screen.saverTimeout*60 : 0;
2683       style.smState.smCycleTimeout = screen.cycleTimeout*60;
2684       style.smSaver.saverList = savers.selsaversList;
2685
2686       screen.origTimeout = screen.newTimeout;
2687       XSetScreenSaver(style.display, style.smState.smSaverTimeout,
2688                       style.smState.smCycleTimeout,
2689                       screen.new_blanking,
2690                       screen.exposures);
2691
2692       break;
2693
2694     case CANCEL_BUTTON:
2695       XtUnmanageChild(w);
2696
2697       /* initialize the value of savertimeout and cycle time to the */
2698       /* original value */
2699
2700       if (screen.origTimeout)
2701         screen.saverTimeout = screen.origTimeout / 60;
2702       else
2703       screen.saverTimeout = screen.saverTimeout_xrdb;
2704
2705
2706       if (style.smState.smCycleTimeout)
2707         screen.cycleTimeout = style.smState.smCycleTimeout / 60;
2708       else
2709         screen.cycleTimeout = 0;
2710
2711       /* reset the value of the scales */
2712       XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
2713       XtVaSetValues(screen.cycleTimeScale, XmNvalue, screen.cycleTimeout , NULL);
2714
2715       /* reset the value of the saver toggles */
2716       XmToggleButtonGadgetSetState(screen.saverOn, screen.origTimeout  ? True : False, True);
2717       XmToggleButtonGadgetSetState(screen.saverOff, !screen.origTimeout  ? True : False, True);
2718
2719       /* reset the value of the locking radio box toggles */
2720       if (style.smState.smSaverTimeout)
2721         {
2722           XmToggleButtonGadgetSetState(screen.useSaversOn, True, False);
2723           XmToggleButtonGadgetSetState(screen.useSaversOff, False, False);
2724           XtSetSensitive(screen.saverList, True);
2725           XtSetSensitive(screen.saverArea, True);
2726           if (savers.selsaverCount > 1)
2727             {
2728               XtSetSensitive(screen.cycleTimeLabel, True);
2729               XtSetSensitive(screen.cycleTimeScale, True);
2730               XtSetSensitive(screen.cycleMinutesLabel, True);
2731             }
2732           if (savers.saverCount)
2733               /* display the preview label */
2734               XtManageChild(screen.prevLabel);
2735
2736           /* let the session manger know to run the savers */
2737           SmNewSaverTime(screen.saverTimeout*60);
2738         }
2739       else
2740         {
2741           XmToggleButtonGadgetSetState(screen.useSaversOff, True, False);
2742           XmToggleButtonGadgetSetState(screen.useSaversOn, False, False);
2743           XtSetSensitive(screen.saverList, False);
2744           XtSetSensitive(screen.saverArea, False);
2745           XtSetSensitive(screen.cycleTimeLabel, False);
2746           XtSetSensitive(screen.cycleTimeScale, False);
2747           XtSetSensitive(screen.cycleMinutesLabel, False);
2748           /* do not display preview string */
2749           XtUnmanageChild(screen.prevLabel);
2750           /* set the background color of the saver window to the */
2751           /* secondary color ID */
2752           XSync(style.display, False);
2753           XtVaSetValues(screen.saverArea, XmNbackground, savers.bg, NULL);
2754           XClearWindow(style.display, XtWindow(screen.saverArea));
2755           /* let the session manger know not to run any savers */
2756           SmNewSaverTime(0);
2757         }
2758
2759       /* reset the X timeout */
2760       screen.newTimeout = screen.origTimeout;
2761       XSetScreenSaver(style.display, screen.origTimeout, screen.interval,
2762                       screen.blanking,screen.exposures);
2763
2764
2765       if (savers.saverCount)
2766         {
2767         /* reset the list selection back to the current state */
2768           /* first deselect all items */
2769           XmListDeselectAllItems(screen.saverList);
2770           for (i=0; i<savers.orig_selsaverCount; i++)
2771             XmListSelectPos(screen.saverList, savers.origSelPositions[i], False);
2772           /* set the current saver to be the first saver in the selected list */
2773           savers.current_saver = savers.saverActionNames[savers.origSelPositions[0] - 1];
2774           savers.current_saverDesc = savers.saverActionDesc[savers.origSelPositions[0] - 1];
2775           savers.current_position = savers.origSelPositions[0];
2776         }
2777
2778       /* Need to make sure the savers.selPositions array reflects the accurate
2779          current selections.  If the user invokes the Screen dialog, then cancels,
2780          then reinvokes and OKs without making any changes to the selections, the
2781          savers.selPositions array is assumed to contain the accurate selections.
2782          Unless we reset it here to the origSelPositions, it may be inaccurate.
2783       */
2784
2785       XtFree((char *) savers.selPositions);
2786       if (savers.orig_selsaverCount > 0) {
2787         savers.selPositions =
2788           (int *) XtMalloc(sizeof(int) * savers.orig_selsaverCount);
2789
2790         for (i=0; i<savers.orig_selsaverCount; i++)
2791           savers.selPositions[i] = savers.origSelPositions[i];
2792       }
2793
2794       savers.selsaverCount = savers.orig_selsaverCount;
2795
2796       break;
2797
2798
2799     case HELP_BUTTON:
2800       XtCallCallbacks(style.screenDialog, XmNhelpCallback, (XtPointer)NULL);
2801       break;
2802
2803     default:
2804       break;
2805     }
2806 }
2807
2808 /************************************************************************/
2809 /* restoreScreen()                                                      */
2810 /* restore any state information saved with saveScreen.                 */
2811 /* This is called from restoreSession with the application              */
2812 /* shell and the special xrm database retrieved for restore.            */
2813 /************************************************************************/
2814 void
2815 restoreScreen(
2816         Widget shell,
2817         XrmDatabase db )
2818 {
2819     XrmName xrm_name[5];
2820     XrmRepresentation rep_type;
2821     XrmValue value;
2822
2823     xrm_name [0] = XrmStringToQuark ("Screen");
2824     xrm_name [2] = NULL;
2825
2826     /* get x position */
2827     xrm_name [1] = XrmStringToQuark ("x");
2828     if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value)){
2829       XtSetArg (save.posArgs[save.poscnt], XmNx, atoi((char *)value.addr)); save.poscnt++;
2830       save.restoreFlag = True;
2831     }
2832
2833     /* get y position */
2834     xrm_name [1] = XrmStringToQuark ("y");
2835     if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value)){
2836       XtSetArg (save.posArgs[save.poscnt], XmNy, atoi((char *)value.addr)); save.poscnt++;
2837     }
2838
2839     xrm_name [1] = XrmStringToQuark ("ismapped");
2840     XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value);
2841     /* Are we supposed to be mapped? */
2842     if (strcmp(value.addr, "True") == 0)
2843       popup_screenBB(shell);
2844 }
2845
2846 /*******************************************************************************/
2847 /* saveScreen()                                                                */
2848 /* This routine will write out to the passed file descriptor any state         */
2849 /* information this dialog needs.  It is called from saveSessionCB with the    */
2850 /* file already opened.                                                        */
2851 /* All information is saved in xrm format.  There is no restriction            */
2852 /* on what can be saved.  It doesn't have to be defined or be part of any      */
2853 /* widget or Xt definition.  Just name and save it here and recover it in      */
2854 /* restoreBackdrop.  The suggested minimum is whether you are mapped, and your */
2855 /* location.                                                                   */
2856 /*******************************************************************************/
2857 void
2858 saveScreen(
2859         int fd )
2860 {
2861     Position x,y;
2862     char *bufr = style.tmpBigStr;     /* size=[1024], make bigger if needed */
2863     XmVendorShellExtObject  vendorExt;
2864     XmWidgetExtData         extData;
2865
2866     if (style.screenDialog != NULL)
2867     {
2868         if (XtIsManaged(style.screenDialog))
2869             sprintf(bufr, "*Screen.ismapped: True\n");
2870         else
2871             sprintf(bufr, "*Screen.ismapped: False\n");
2872
2873         /* Get and write out the geometry info for our Window */
2874         x = XtX(XtParent(style.screenDialog));
2875         y = XtY(XtParent(style.screenDialog));
2876
2877         /* Modify x & y to take into account window mgr frames */
2878         /* This is pretty bogus, but I don't know a better way to do it. */
2879         extData = _XmGetWidgetExtData(style.shell, XmSHELL_EXTENSION);
2880         vendorExt = (XmVendorShellExtObject)extData->widget;
2881         x -= vendorExt->vendor.xOffset;
2882         y -= vendorExt->vendor.yOffset;
2883
2884         sprintf(bufr, "%s*Screen.x: %d\n", bufr, x);
2885         sprintf(bufr, "%s*Screen.y: %d\n", bufr, y);
2886
2887         write (fd, bufr, strlen(bufr));
2888     }
2889 }
2890
2891
2892 /************************************************************************/
2893 /*   MakeListStrings()                                                  */
2894 /*           Make XmStrings from the saver names, to pass into list.    */
2895 /************************************************************************/
2896 static XmString *
2897 MakeListStrings( char ** list )
2898 {
2899     register int   i;
2900     XmString      *xmList;
2901
2902     xmList = (XmString *) XtMalloc(savers.saverCount * sizeof(XmString));
2903
2904     for (i = 0; i < savers.saverCount; i++)
2905     {
2906         xmList[i] = XmStringCreateLocalized (list[i]);
2907     }
2908
2909     return (xmList);
2910 }
2911
2912
2913 /************************************************************************/
2914 /*   FreeListStrings()                                                  */
2915 /************************************************************************/
2916
2917 static void
2918 FreeListStrings(XmString *xmlist,
2919                 int count)
2920 {
2921   int         i;
2922
2923   for (i = 0; i < count; i++)
2924     {
2925       if (xmlist[i])
2926         XmStringFree(xmlist[i]);
2927     }
2928   XtFree ((char *)xmlist);
2929 }
2930
2931
2932 /************************************************************************/
2933 /* ListCB()                                                             */
2934 /* Get the lastly selected Screen saver client running in the preview   */
2935 /* area. For a multiple selection by dragging, the last item in the     */
2936 /* selection is the client that is previewed.                           */
2937 /************************************************************************/
2938 static void
2939 ListCB(
2940         Widget w,
2941         XtPointer client_data,
2942         XtPointer call_data )
2943 {
2944   XmListCallbackStruct  *cb = (XmListCallbackStruct *)call_data;
2945   register int           i;
2946   Boolean                runsaver = False;
2947   XmString               string;
2948
2949
2950   /* If no items are left in the selection (i.e. the last selected item */
2951   /* was deselected) then  force the previously selected item to remain */
2952   /* selected */
2953
2954   if (cb->selected_item_count == 0)
2955     {
2956       XmListSelectPos(screen.saverList, cb->item_position, False);
2957       savers.selsaverCount = 1;
2958       if (savers.selPositions != NULL)
2959         XtFree ((char *) savers.selPositions);
2960       savers.selPositions = (int *) XtMalloc(sizeof(int));
2961       savers.selPositions[0] = cb->item_position;
2962       savers.current_saver = savers.saverActionNames[savers.selPositions[0] - 1];
2963       savers.current_saverDesc = savers.saverActionDesc[savers.selPositions[0] - 1];
2964       return;
2965     }
2966
2967   /*  make a copy of the selected item positions for later use */
2968
2969   if (savers.selPositions != NULL)
2970     XtFree ((char *) savers.selPositions);
2971
2972   savers.selPositions = (int *) XtMalloc(sizeof(int) * cb->selected_item_count);
2973   for (i=0; i< cb->selected_item_count; i++)
2974     {
2975       savers.selPositions[i] = cb->selected_item_positions[i];
2976     }
2977
2978   savers.selsaverCount = cb->selected_item_count;
2979   if (savers.selsaverCount < 2)
2980     {
2981       XtSetSensitive(screen.cycleTimeScale, False);
2982       XtSetSensitive(screen.cycleTimeLabel, False);
2983       XtSetSensitive(screen.cycleMinutesLabel, False);
2984     }
2985   else
2986     if (savers.previous_selsaverCount < 2)
2987       {
2988         XtSetSensitive(screen.cycleTimeScale, True);
2989         XtSetSensitive(screen.cycleTimeLabel, True);
2990         XtSetSensitive(screen.cycleMinutesLabel, True);
2991       }
2992
2993   savers.previous_selsaverCount = savers.selsaverCount;
2994
2995   /* Find out if the item is selected or deselected.  When an item */
2996   /* is deselected item_position is set to the deselected item which has */
2997   /* the keyboard focus. However, the deselected screen saver must not be  */
2998   /* previewed. Therfore before a screen saver is started, its position must */
2999   /* exist in the selected_item_positions array. If not then just return without */
3000   /* altering the current (previewed) saver unless the deselected saver was the */
3001   /* current saver. In that case kill the current saver and preview the last */
3002   /* item from the selected list. */
3003   for (i=0; i<cb->selected_item_count; i++)
3004     {
3005       if(cb->selected_item_positions[i] == cb->item_position)
3006         runsaver=True;
3007     }
3008
3009   if (!runsaver)
3010     {
3011       i = cb->selected_item_positions[(cb->selected_item_count-1)];
3012       if (savers.current_position == cb->item_position)
3013         {
3014             if (savers.saverstate)
3015               {
3016                 /* Terminate the screen saver that is currently running */
3017                 _DtSaverStop(style.display, savers.saverstate);
3018                 XSync(style.display, False);
3019                 savers.saverstate = NULL;
3020               }
3021             savers.current_saver = savers.saverActionNames[i-1];
3022             savers.current_saverDesc = savers.saverActionDesc[i-1];
3023             savers.current_position = i;
3024             XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
3025             savers.saverstate = _DtSaverStart(style.display, &screen.saverArea,
3026                                   1, savers.current_saver, style.screenDialog);
3027             string = XmStringCreateLocalized (savers.current_saverDesc);
3028             XtVaSetValues(screen.prevLabel, XmNlabelString, string, NULL);
3029             XmStringFree(string);
3030           }
3031       return;
3032     }
3033
3034   /* The item position returned is the selcted item */
3035   /* Start screen saver. _DtSaverStop() must be called to terminate the */
3036   /* screen saver. */
3037   if (savers.saverstate)
3038     {
3039       /* Terminate the screen saver that is currently running */
3040       _DtSaverStop(style.display, savers.saverstate);
3041       XSync(style.display, False);
3042       savers.saverstate = NULL;
3043     }
3044
3045   XSync(style.display, False);
3046   XClearWindow(style.display, XtWindow(screen.saverArea));
3047   XSync(style.display, False);
3048   XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
3049
3050   savers.current_position = cb->item_position;
3051   savers.current_saver = savers.saverActionNames[savers.current_position - 1];
3052   savers.current_saverDesc = savers.saverActionDesc[savers.current_position - 1];
3053   savers.saverstate = _DtSaverStart(style.display, &screen.saverArea, 1,
3054                                    savers.current_saver, style.screenDialog);
3055   /* update the preview label with the current running saver */
3056   XtVaSetValues(screen.prevLabel, XmNlabelString, cb->item, NULL);
3057 }
3058
3059
3060
3061 /************************************************************************/
3062 /* IconHandler()                                                        */
3063 /* Kills the currently previewed saver when the user iconifies the      */
3064 /* style manager.  An XtEventHandler.                                   */
3065 /************************************************************************/
3066 static void
3067 IconHandler(
3068         Widget shell,
3069         XtPointer client_data,
3070         XEvent *event,
3071         Boolean *dispatch)
3072 {
3073
3074   XmString string;
3075
3076   if (event->type == UnmapNotify)
3077     {
3078       /* terminate the saver that is currently running */
3079       if (savers.saverstate)
3080         {
3081           _DtSaverStop(style.display, savers.saverstate);
3082           savers.saverstate = NULL;
3083         }
3084     }
3085   /* run the current screen saver only if the useSaversOn/saverOn toggle is enabled
3086      and valid saver exist and one is not already running*/
3087   else if (savers.saverCount && event->type == 19 && !savers.saverstate)
3088     if (style.smState.smLockOnTimeoutStatus)
3089       {
3090         if (XmToggleButtonGadgetGetState(screen.saverOn) && savers.saverCount)
3091           {
3092             XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
3093             savers.saverstate = _DtSaverStart(style.display, &screen.saverArea, 1,
3094                                               savers.current_saver, style.screenDialog);
3095             string = XmStringCreateLocalized (savers.current_saverDesc);
3096             XtVaSetValues(screen.prevLabel, XmNlabelString, string, NULL);
3097             XmStringFree(string);
3098           }
3099       }
3100     else
3101       {
3102         if (XmToggleButtonGadgetGetState(screen.useSaversOn) && savers.saverCount)
3103           {
3104             XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
3105             savers.saverstate = _DtSaverStart(style.display, &screen.saverArea, 1,
3106                                               savers.current_saver, style.screenDialog);
3107             string = XmStringCreateLocalized (savers.current_saverDesc);
3108             XtVaSetValues(screen.prevLabel, XmNlabelString, string, NULL);
3109             XmStringFree(string);
3110           }
3111       }
3112 }
3113
3114
3115 /************************************************************************/
3116 /* UnmapCB()                                                            */
3117 /* Kills the currently previewed saver when the user iconifies the      */
3118 /* style manager or unmaps the screen dialog.                           */
3119 /************************************************************************/
3120
3121 static void
3122 UnmapCB(
3123         Widget w,
3124         XtPointer client_data,
3125         XtPointer call_data )
3126 {
3127   /* terminate the saver that is currently running */
3128   if (savers.saverstate)
3129     {
3130       _DtSaverStop(style.display, savers.saverstate);
3131       savers.saverstate = NULL;
3132     }
3133
3134 }
3135
3136
3137
3138
3139
3140
3141
3142
3143