cde/programs/dtstyle/Screen.c

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