2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
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)
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
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
23 /************************************<+>*************************************/
24 /****************************************************************************/
26 /** File: Screen.c **/
28 /** Project: DT 1.0 **/
30 /** Description: Controls the Dtstyle Screen dialog **/
35 /****************************************************************************/
36 /************************************<+>*************************************/
38 /*$TOG: Screen.c /main/9 1997/07/14 17:44:42 samborn $*/
41 #include <Xm/MwmUtil.h>
45 #include <Xm/DrawingA.h>
49 #include <Xm/LabelG.h>
50 #include <Xm/PushBG.h>
52 #include <Xm/RowColumn.h>
54 #include <Xm/ToggleBG.h>
55 #include <Xm/VendorSEP.h>
56 #include <Xm/Protocols.h>
61 #include <X11/Intrinsic.h>
62 #include <X11/Xutil.h>
63 #include <X11/Xatom.h>
65 #include <Dt/Action.h>
66 #include <Dt/UserMsg.h>
67 #include <Dt/SaverP.h>
68 #include <Dt/DialogBox.h>
70 #include <Dt/TitleBox.h>
71 #include <Dt/Message.h>
72 #include <Dt/HourGlass.h>
76 #include "SaveRestore.h"
79 /*+++++++++++++++++++++++++++++++++++++++*/
80 /* include extern functions */
81 /*+++++++++++++++++++++++++++++++++++++++*/
84 /*+++++++++++++++++++++++++++++++++++++++*/
86 /*+++++++++++++++++++++++++++++++++++++++*/
88 #define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
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
99 /*+++++++++++++++++++++++++++++++++++++++*/
100 /* Internal Functions */
101 /*+++++++++++++++++++++++++++++++++++++++*/
103 static Widget build_screenDialog( Widget shell) ;
105 static void formLayoutCB(Widget w,
106 XtPointer client_data,
107 XtPointer call_data) ;
109 static void no_svr_ext_formLayoutCB(Widget w,
110 XtPointer client_data,
111 XtPointer call_data) ;
113 static void _DtmapCB_screenDialog(Widget w,
114 XtPointer client_data,
115 XtPointer call_data) ;
117 static void no_svr_ext_DtmapCB_screenDialog(Widget w,
118 XtPointer client_data,
119 XtPointer call_data) ;
121 static void timeOutvalueChangedCB(Widget w,
122 XtPointer client_data,
123 XtPointer call_data) ;
125 static void no_svr_ext_timeOutvalueChangedCB(Widget w,
126 XtPointer client_data,
127 XtPointer call_data) ;
129 static void saverToggleCB(Widget w,
130 XtPointer client_data,
131 XtPointer call_data) ;
133 static void no_svr_ext_saverToggleCB(Widget w,
134 XtPointer client_data,
135 XtPointer call_data) ;
137 static void saversToggleCB(Widget w,
138 XtPointer client_data,
139 XtPointer call_data) ;
141 static void lockToggleCB(Widget w,
142 XtPointer client_data,
143 XtPointer call_data) ;
145 static void systemDefaultCB(Widget w,
146 XtPointer client_data,
147 XtPointer call_data) ;
149 static void no_svr_ext_systemDefaultCB(Widget w,
150 XtPointer client_data,
151 XtPointer call_data) ;
153 static void ButtonCB(Widget w,
154 XtPointer client_data,
155 XtPointer call_data) ;
157 static void no_svr_ext_ButtonCB(Widget w,
158 XtPointer client_data,
159 XtPointer call_data) ;
161 static XmString * MakeListStrings(char **list ) ;
163 static void FreeListStrings(XmString *xmlist,
166 static void ListCB(Widget w,
167 XtPointer client_data,
168 XtPointer call_data) ;
170 static void IconHandler(Widget shell,
171 XtPointer client_data,
175 static void UnmapCB(Widget w,
176 XtPointer client_data,
177 XtPointer call_data) ;
180 /*+++++++++++++++++++++++++++++++++++++++*/
181 /* Internal Variables */
182 /*+++++++++++++++++++++++++++++++++++++++*/
185 Widget systemDefault;
189 Widget saverAreaFrame;
194 Widget saverRadioBox;
198 Widget saverMinutesLabel;
199 Widget cycleTimeLabel;
200 Widget cycleTimeScale;
201 Widget cycleMinutesLabel;
208 Widget lockingRadioBox;
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 */
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 */
227 Boolean systemDefaultFlag;
229 } ScreenData; /* using the savers toggle when the saver extn is not present */
231 static ScreenData screen;
232 static saveRestore save = {FALSE, 0,};
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;
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 */
265 /*++++++++++++++++++++++++++++++++++++++++*/
268 build_saverList(char * str,
271 char tokenSep[] = " ";
273 char ** saverList = NULL;
275 char * tmpStr, *tmpStr2;
276 int len = strlen(str);
281 tmpStr = (char *)XtCalloc(1, len + 1);
284 token = strtok(tmpStr, tokenSep);
288 token = strtok(NULL, tokenSep);
294 saverList = (char **) XtCalloc(1, i * sizeof(char *));
298 while (isspace(*tmpStr))
300 token = strtok(tmpStr, tokenSep);
304 if (DtActionExists(token))
306 saverList[*count] = (char *) XtCalloc(1, strlen( token ) + 1);
307 strcpy(saverList[*count], token);
310 tmpStr += strlen(token);
311 if (tmpStr >= tmpStr2 + len )
316 while (isspace(*tmpStr));
317 token = strtok(tmpStr, tokenSep);
322 XtFree ((char *) tmpStr2);
326 /*+++++++++++++++++++++++++++++++++++++++*/
327 /* build_selsaverList */
328 /*+++++++++++++++++++++++++++++++++++++++*/
331 build_selsaverList(char * envStr,
334 char tokenSep[] = " ";
336 char ** saverList = NULL;
339 int len = strlen(envStr);
342 tmpStr = (char *)XtCalloc(1, len + 1);
343 strcpy(tmpStr, envStr);
344 token = strtok(tmpStr, tokenSep);
348 token = strtok(NULL, tokenSep);
354 saverList = (char **) XtCalloc(1, i * sizeof(char *));
357 strcpy(tmpStr, envStr);
358 token = strtok(tmpStr, tokenSep);
362 saverList[*count] = (char *) XtCalloc(1, strlen( token ) + 1);
363 strcpy(saverList[*count], token);
364 token = strtok(NULL, tokenSep);
369 XtFree ((char *) tmpStr);
373 /*+++++++++++++++++++++++++++++++++++++++*/
374 /* build_saverDesc */
375 /*+++++++++++++++++++++++++++++++++++++++*/
378 build_saverDesc(char ** names,
381 char **saverDesc = NULL;
385 saverDesc = (char **) XtCalloc(1, count * sizeof(char *));
387 for (i=0; i<count; i++)
389 tmpstr = DtActionDescription(savers.saverActionNames[i]);
392 saverDesc[i] = (char *) XtMalloc(strlen(savers.saverActionNames[i]) + 1);
393 strcpy(saverDesc[i], savers.saverActionNames[i]);
397 saverDesc[i] = (char *) XtMalloc(strlen(tmpstr) + 1);
398 strcpy(saverDesc[i], tmpstr);
400 XtFree((char *) tmpstr);
406 /*+++++++++++++++++++++++++++++++++++++++*/
407 /* build_selectedList */
408 /* takes an array of names and a count */
409 /* and returns a space separated list */
410 /*+++++++++++++++++++++++++++++++++++++++*/
413 build_selectedList(char ** saverList,
417 char * selectedList = NULL;
423 if (saverList == NULL)
426 for (i=0; i<count; i++)
428 len += strlen(saverList[i]) + 1;
431 selectedList = (char *)XtMalloc(len + 1);
432 selectedList[0] = '\0';
433 for (i=0; i<count; i++)
435 strcat(selectedList, saverList[i]);
436 strcat(selectedList, " ");
439 return(selectedList);
443 /*+++++++++++++++++++++++++++++++++++++++*/
445 /*+++++++++++++++++++++++++++++++++++++++*/
448 free_saverList(char ** saverList,
454 if (saverList == NULL)
456 for (i=0; i<count; i++)
457 XtFree((char *) saverList[i]);
459 XtFree ((char *) saverList);
463 /*+++++++++++++++++++++++++++++++++++++++*/
465 /*+++++++++++++++++++++++++++++++++++++++*/
471 if (style.screenDialog == NULL) {
472 _DtTurnOnHourGlass(shell);
473 build_screenDialog(shell);
474 XtManageChild(style.screenDialog);
475 _DtTurnOffHourGlass(shell);
479 XtManageChild(style.screenDialog);
480 raiseWindow(XtWindow(XtParent(style.screenDialog)));
484 /*+++++++++++++++++++++++++++++++++++++++*/
485 /* build_screenDialog */
486 /*+++++++++++++++++++++++++++++++++++++++*/
491 register int i, m, n;
494 Boolean sel_matched = False;
496 int old_selsaverCount = 0;
497 Widget widget_list1[12];
498 Widget widget_list2[12];
501 XmString button_string[NUM_LABELS];
503 XmString *listStrings;
506 Dimension MaxLabelWidth = 0;
507 Dimension LabelWidth = 0;
508 Atom delete_window_atom;
509 Boolean low_res = False;
511 /* initialize saver data */
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)));
528 /* load the actions data base */
531 if (_DtGetDisplayResolution(style.display, style.screenNum) == 1)
534 /* Set up DialogBoxDialog button labels */
535 button_string[0] = CMPSTR(_DtOkString);
536 button_string[1] = CMPSTR(_DtCancelString);
537 button_string[2] = CMPSTR(_DtHelpString);
539 /* Create toplevel DialogBox */
540 /* saveRestore - Note that save.poscnt has been initialized elsewhere. */
541 /* save.posArgs may contain information from restoreScreen().*/
543 XtSetArg(save.posArgs[save.poscnt], XmNbuttonCount, NUM_LABELS);
545 XtSetArg(save.posArgs[save.poscnt], XmNbuttonLabelStrings, button_string);
547 XtSetArg (save.posArgs[save.poscnt], XmNdefaultPosition, False);
550 __DtCreateDialogBoxDialog(shell, "ScreenDialog", save.posArgs, save.poscnt);
552 XmStringFree(button_string[0]);
553 XmStringFree(button_string[1]);
554 XmStringFree(button_string[2]);
556 widget_list1[0] = _DtDialogBoxGetButton(style.screenDialog,2);
558 XtSetArg(args[n], XmNautoUnmanage, False); n++;
559 XtSetArg(args[n], XmNcancelButton, widget_list1[0]); n++;
560 XtSetValues (style.screenDialog, args, n);
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);
570 /* Create the main form */
572 XtSetArg(args[n], XmNallowOverlap, False); n++;
573 XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
574 form=XmCreateForm(style.screenDialog, "Form", args, n);
576 /* Create the visual */
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);
589 /* Create the default button */
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);
600 /* Create the screen lock title box */
602 if (style.smState.smLockOnTimeoutStatus)
603 string = CMPSTR(((char *)GETMESSAGE(12, 8, "Screen Lock")));
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);
612 /* Create a form for the screen lock widgets */
614 XtSetArg(args[n], XmNallowOverlap, False); n++;
615 XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
616 screen.lockForm= XmCreateForm(screen.lockFrame, "lockForm", args, n);
619 /* Create the screen saver title box */
621 if (style.smState.smLockOnTimeoutStatus)
622 string = CMPSTR(((char *)GETMESSAGE(12, 4, "Screen Saver")));
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);
630 /* Create a form for the screen saver widgets */
632 XtSetArg(args[n], XmNallowOverlap, False); n++;
633 XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
634 screen.saverForm= XmCreateForm(screen.saverFrame, "saverForm", args, n);
637 /* Create the cycle time labels and slider */
639 if (style.smState.smLockOnTimeoutStatus)
640 string = CMPSTR(((char *)GETMESSAGE(12, 6, "Time Per Saver")));
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);
648 screen.cycleTimeLabel = XmCreateLabelGadget(screen.lockForm,"cycleTimeLabel", args, n);
649 XmStringFree(string);
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);
661 screen.cycleTimeScale= XmCreateScale(screen.lockForm,"cycleTimeScale", args, n);
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);
669 screen.cycleMinutesLabel= XmCreateLabelGadget(screen.lockForm,"cycleMinutes", args, n);
670 XmStringFree(string);
672 /* Create the screen saver on/off radio buttons and label */
674 if (style.smState.smLockOnTimeoutStatus)
675 string = CMPSTR(((char *)GETMESSAGE(12, 12, "Screen Saver:")));
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);
684 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
685 screen.saverRadioBox= XmCreateRadioBox(screen.saverForm, "saverRadioBox", args, n);
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);
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);
699 /* Create the screen saver list */
701 XtSetArg (args[n], XmNautomaticSelection, True); n++;
702 XtSetArg (args[n], XmNselectionPolicy, XmMULTIPLE_SELECT); n++;
703 XtSetArg (args[n], XmNlistSizePolicy, XmRESIZE_IF_POSSIBLE); n++;
705 XtSetArg (args[n], XmNheight, 100); n++; }
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);
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;
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);
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);
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;
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;
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];
763 /* reduce # of selected savers */
764 savers.selsaverCount--;
766 /* reset selected saver array position counter back one position for
769 } /* if (sel_found == 0) */
770 } /* for n<savers.selsaverCount */
771 } /* if (savers.selsaverCount) */
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];
780 /* highlight last saver */
781 XmListSelectPos (screen.saverList, savers.saverCount, False);
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];
787 savers.selPositions = (int *) XtMalloc(sizeof(int));
788 savers.selPositions[0] = savers.saverCount;
789 savers.selsaverCount = 1;
790 savers.current_position = 1;
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;
798 savers.previous_selsaverCount = savers.selsaverCount;
799 free_saverList(savers.selsaverActionNames, old_selsaverCount);
802 /* Create frame for the saver area */
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);
812 screen.saverAreaFrame = XmCreateFrame(screen.lockForm, "saverAreaFrame", args, n);
814 /* Create saver area for the screen savers */
816 XtSetArg (args[n], XmNtraversalOn, False); n++;
818 XtSetArg (args[n], XmNwidth, 180); n++; }
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);
825 /* label for the previewed saver */
827 if (savers.saverCount)
828 string = XmStringCreateLocalized (savers.current_saverDesc);
830 string = XmStringCreateLocalized (" ");
831 XtSetArg(args[n], XmNlabelString, string); n++;
832 if (style.smState.smLockOnTimeoutStatus)
833 screen.prevLabel = XmCreateLabelGadget(screen.saverForm,"prevLabel", args, n);
835 screen.prevLabel = XmCreateLabelGadget(screen.lockForm,"prevLabel", args, n);
836 XmStringFree(string);
838 /* Create the screen saver labels and slider */
840 if (style.smState.smLockOnTimeoutStatus)
841 string = CMPSTR(((char *)GETMESSAGE(12, 5, "Start Saver")));
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);
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);
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);
864 /* Create the screen lock on/off radio buttons and label */
865 /* mapped only when saver extensions are present */
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);
874 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
875 screen.lockRadioBox= XmCreateRadioBox(screen.lockForm, "lockRadioBox", args, n);
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);
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);
892 /* Create the screen lock labels and slider */
893 /* mapped only when saver extensions are present */
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);
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);
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);
917 /* Create the radio buttons for lock savers */
918 /* mapped only when saver extensions are not present */
920 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
921 XtSetArg(args[n], XmNspacing, 25); n++;
922 screen.lockingRadioBox= XmCreateRadioBox(screen.lockForm, "lockingRadioBox", args, n);
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);
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);
940 /* Configure dialog based on the presence of screen saver extensions */
941 if (!style.smState.smLockOnTimeoutStatus)
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);
957 XtAddCallback(style.screenDialog, XmNcallback, no_svr_ext_ButtonCB, NULL);
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,
974 XtAddCallback(screen.lockOff, XmNvalueChangedCallback,
976 XtAddCallback(style.screenDialog, XmNcallback, ButtonCB, NULL);
978 XtAddCallback(style.screenDialog, XmNunmapCallback, UnmapCB, shell);
979 XtAddCallback(style.screenDialog, XmNhelpCallback,
980 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_SCREEN_DIALOG);
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)
991 if ((LabelWidth = XtWidth(screen.lockLabel)) > MaxLabelWidth)
992 MaxLabelWidth = LabelWidth;
993 if ((LabelWidth = XtWidth(screen.lockOutLabel)) > MaxLabelWidth)
994 MaxLabelWidth = LabelWidth;
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)
1002 XtVaSetValues(screen.lockLabel, XmNwidth, MaxLabelWidth, NULL);
1003 XtVaSetValues(screen.lockOutLabel, XmNwidth, MaxLabelWidth, NULL);
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)
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);
1040 XtManageChild(screen.lockingRadioBox);
1041 XtManageChild(screen.useSaversOn);
1042 XtManageChild(screen.useSaversOff);
1044 XtAddEventHandler(style.shell, StructureNotifyMask, False, IconHandler, NULL);
1046 return(style.screenDialog);
1050 /*+++++++++++++++++++++++++++++++++++++++*/
1052 /*+++++++++++++++++++++++++++++++++++++++*/
1056 XtPointer client_data,
1057 XtPointer call_data )
1061 Dimension ScaleHeight;
1062 Dimension LabelHeight;
1063 Dimension RadioHeight;
1064 Dimension RadioOffset, ScaleOffset;
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;
1073 /* do form attachments */
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);
1085 /* system Default */
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);
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);
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);
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);
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);
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);
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);
1170 /* saver titlebox */
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);
1184 /* cycleTime Label */
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);
1194 /* cycleTime Scale */
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);
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);
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);
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);
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);
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);
1264 /* saver Radiobox */
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);
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);
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);
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);
1316 XtRemoveCallback(style.screenDialog, XmNmapCallback, formLayoutCB, NULL);
1320 /*+++++++++++++++++++++++++++++++++++++++*/
1321 /* no_svr_ext_formLayoutCB */
1322 /*+++++++++++++++++++++++++++++++++++++++*/
1324 no_svr_ext_formLayoutCB(
1326 XtPointer client_data,
1327 XtPointer call_data )
1331 Dimension ScaleHeight;
1332 Dimension LabelHeight;
1333 Dimension RadioHeight;
1334 Dimension RadioOffset, ScaleOffset;
1336 /* calculate width and height information */
1337 ScaleHeight = XtHeight(XtParent(screen.timeOutScale));
1338 LabelHeight = XtHeight(screen.timeOutLabel);
1339 RadioHeight = XtHeight(screen.saverRadioBox);
1341 RadioOffset = ((Dimension) (RadioHeight - LabelHeight) / 2) - 2;
1343 /* do form attachments */
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);
1355 /* system Default */
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);
1366 /* saver titlebox */
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);
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);
1388 /* saver Radiobox */
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);
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);
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);
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);
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);
1448 /* locking radiobox */
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);
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);
1467 /* cycleTime Label */
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);
1477 /* cycleTime Scale */
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);
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);
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);
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);
1529 XtRemoveCallback(style.screenDialog, XmNmapCallback, no_svr_ext_formLayoutCB, NULL);
1532 /*+++++++++++++++++++++++++++++++++++++++*/
1533 /* _DtmapCB_screenDialog */
1534 /*+++++++++++++++++++++++++++++++++++++++*/
1537 _DtmapCB_screenDialog(
1539 XtPointer client_data,
1540 XtPointer call_data )
1542 static int first_time = 1;
1546 Boolean lock_on, saver_on;
1550 DtWsmRemoveWorkspaceFunctions(style.display, XtWindow(XtParent(w)));
1552 if (!save.restoreFlag)
1553 putDialog ((Widget)client_data, w);
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;
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;
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;
1571 screen.saverTimeout = screen.saverTimeout_xrdb;
1573 if (style.smState.smLockTimeout)
1574 screen.lockTimeout = style.smState.smLockTimeout / 60;
1576 screen.lockTimeout = screen.lockTimeout_xrdb;
1578 if (style.smState.smCycleTimeout)
1579 screen.cycleTimeout = style.smState.smCycleTimeout / 60;
1581 screen.cycleTimeout = 0;
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);
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);
1599 /* make saver widgets insensitive if screen saver is off */
1600 /* also blank out the preview label widget */
1601 if (XmToggleButtonGadgetGetState(screen.saverOff))
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);
1613 /* make saver widgets sensitive if screen saver is on */
1614 /* also manage the preview label widget */
1615 if (XmToggleButtonGadgetGetState(screen.saverOn))
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)
1626 XtSetSensitive(screen.cycleTimeLabel, True);
1627 XtSetSensitive(screen.cycleTimeScale, True);
1628 XtSetSensitive(screen.cycleMinutesLabel, True);
1632 XtSetSensitive(screen.cycleTimeLabel, False);
1633 XtSetSensitive(screen.cycleTimeScale, False);
1634 XtSetSensitive(screen.cycleMinutesLabel, False);
1637 /* make lock widgets insensitive if lock screen is off */
1638 if (XmToggleButtonGadgetGetState(screen.lockOff))
1640 XtSetSensitive(screen.lockOutLabel, False);
1641 XtSetSensitive(screen.lockOutScale, False);
1642 XtSetSensitive(screen.lockMinutesLabel, False);
1644 /* make lock widgets sensitive if lock screen is on */
1645 if (XmToggleButtonGadgetGetState(screen.lockOn))
1647 XtSetSensitive(screen.lockOutLabel, True);
1648 XtSetSensitive(screen.lockOutScale, True);
1649 XtSetSensitive(screen.lockMinutesLabel, True);
1653 if (!style.smState.smSaverTimeout)
1654 screen.origTimeout = screen.newTimeout = style.smState.smLockTimeout;
1656 if (!style.smState.smLockTimeout)
1657 screen.origTimeout = screen.newTimeout = style.smState.smSaverTimeout;
1659 screen.origTimeout =
1661 MIN(style.smState.smSaverTimeout, style.smState.smLockTimeout);
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 */
1671 XGetScreenSaver(style.display, &screen.xTimeout, &screen.interval,
1672 &screen.blanking, &screen.exposures);
1674 screen.new_blanking = DontPreferBlanking;
1676 if (screen.xTimeout < 0)
1677 screen.xTimeout = 0;
1679 if ((screen.xTimeout < 60) && (screen.xTimeout > 1))
1680 screen.xTimeout = 60;
1682 if (screen.xTimeout > TIMEOUT_MAX * 60)
1683 screen.xTimeout = TIMEOUT_MAX * 60;
1685 if (screen.xTimeout < 0)
1686 screen.xTimeout = 0;
1688 if ((screen.xTimeout < 60) && (screen.xTimeout > 1))
1689 screen.xTimeout = 60;
1691 if (screen.xTimeout > TIMEOUT_MAX * 60)
1692 screen.xTimeout = TIMEOUT_MAX * 60;
1694 screen.timeMismatch = False;
1695 if (screen.xTimeout != screen.newTimeout)
1697 screen.timeMismatch = True;
1698 screen.newTimeout = screen.xTimeout;
1699 if (screen.xTimeout)
1701 screen.saverTimeout = screen.xTimeout / 60;
1702 screen.lockTimeout = screen.xTimeout / 60;
1706 screen.saverTimeout = screen.saverTimeout_xrdb;
1707 screen.lockTimeout = screen.lockTimeout_xrdb;
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);
1715 /* set the value of the scales */
1716 XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
1717 XtVaSetValues(screen.lockOutScale, XmNvalue, screen.lockTimeout_xrdb, NULL);
1719 /* make saver widgets insensitive if screen saver is off */
1720 /* also blankout the preview label widget */
1721 if (XmToggleButtonGadgetGetState(screen.saverOff))
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);
1733 /* make saver widgets sensitive if screen saver is on */
1734 /* also manage the preview label widget */
1735 if (XmToggleButtonGadgetGetState(screen.saverOn))
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)
1746 XtSetSensitive(screen.cycleTimeLabel, True);
1747 XtSetSensitive(screen.cycleTimeScale, True);
1748 XtSetSensitive(screen.cycleMinutesLabel, True);
1752 XtSetSensitive(screen.cycleTimeLabel, False);
1753 XtSetSensitive(screen.cycleTimeScale, False);
1754 XtSetSensitive(screen.cycleMinutesLabel, False);
1758 /* make lock widgets insensitive if lock screen is off */
1759 if (XmToggleButtonGadgetGetState(screen.lockOff))
1761 XtSetSensitive(screen.lockOutLabel, False);
1762 XtSetSensitive(screen.lockOutScale, False);
1763 XtSetSensitive(screen.lockMinutesLabel, False);
1766 /* make lock widgets sensitive if lock screen is on */
1767 if (XmToggleButtonGadgetGetState(screen.lockOn))
1769 XtSetSensitive(screen.lockOutLabel, True);
1770 XtSetSensitive(screen.lockOutScale, True);
1771 XtSetSensitive(screen.lockMinutesLabel, True);
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)
1779 XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
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);
1789 /*+++++++++++++++++++++++++++++++++++++++*/
1790 /* no_svr_ext_DtmapCB_screenDialog */
1791 /*+++++++++++++++++++++++++++++++++++++++*/
1794 no_svr_ext_DtmapCB_screenDialog(
1796 XtPointer client_data,
1797 XtPointer call_data )
1799 static int first_time = 1;
1807 DtWsmRemoveWorkspaceFunctions(style.display, XtWindow(XtParent(w)));
1809 if (!save.restoreFlag)
1810 putDialog ((Widget)client_data, w);
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;
1817 if (style.smState.smCycleTimeout)
1818 screen.cycleTimeout = style.smState.smCycleTimeout / 60;
1820 screen.cycleTimeout = 0;
1822 /* set the value of the cycle time scale */
1823 XtVaSetValues(screen.cycleTimeScale, XmNvalue, screen.cycleTimeout , NULL);
1825 /* set the initial condition for the locking RadioBoxes */
1827 XmToggleButtonGadgetSetState(screen.useSaversOn,
1828 style.smState.smSaverTimeout ? True : False, False);
1829 XmToggleButtonGadgetSetState(screen.useSaversOff,
1830 style.smState.smSaverTimeout ? False : True, False);
1832 if (style.smState.smSaverTimeout)
1834 XtSetSensitive(screen.saverList, True);
1835 XtSetSensitive(screen.saverArea, True);
1836 if (savers.selsaverCount > 1)
1838 XtSetSensitive(screen.cycleTimeLabel, True);
1839 XtSetSensitive(screen.cycleTimeScale, True);
1840 XtSetSensitive(screen.cycleMinutesLabel, True);
1844 XtSetSensitive(screen.cycleTimeLabel, False);
1845 XtSetSensitive(screen.cycleTimeScale, False);
1846 XtSetSensitive(screen.cycleMinutesLabel, False);
1848 XtManageChild(screen.prevLabel);
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);
1861 screen.newTimeout = screen.origTimeout = 0;
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 */
1872 XGetScreenSaver(style.display, &screen.xTimeout, &screen.interval,
1873 &screen.blanking, &screen.exposures);
1875 screen.new_blanking = PreferBlanking;
1877 if (screen.xTimeout < 0)
1878 screen.xTimeout = 0;
1880 if ((screen.xTimeout < 60) && (screen.xTimeout > 1))
1881 screen.xTimeout = 60;
1883 if (screen.xTimeout > TIMEOUT_MAX * 60)
1884 screen.xTimeout = TIMEOUT_MAX * 60;
1886 if (screen.xTimeout != screen.newTimeout)
1888 screen.origTimeout = screen.newTimeout = screen.xTimeout;
1889 screen.saverTimeout = screen.xTimeout / 60;
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);
1896 if (!screen.saverTimeout)
1897 screen.saverTimeout = screen.saverTimeout_xrdb;
1899 XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
1901 /* make saver widgets insensitive if screen saver is off */
1902 if (XmToggleButtonGadgetGetState(screen.saverOff))
1904 XtSetSensitive(screen.timeOutLabel, False);
1905 XtSetSensitive(screen.timeOutScale, False);
1906 XtSetSensitive(screen.saverMinutesLabel, False);
1908 /* make saver widgets sensitive if screen saver is on */
1909 if (XmToggleButtonGadgetGetState(screen.saverOn))
1911 XtSetSensitive(screen.timeOutLabel, True);
1912 XtSetSensitive(screen.timeOutScale, True);
1913 XtSetSensitive(screen.saverMinutesLabel, True);
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)
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);
1930 /*****************************************/
1931 /* timeOutvalueChangedCB */
1932 /* set the timeout to be the minimum of */
1933 /* the lock scale and timeout scale */
1934 /*****************************************/
1936 timeOutvalueChangedCB(
1938 XtPointer client_data,
1939 XtPointer call_data )
1945 XtSetArg(args[n], XmNvalue, &screen.saverTimeout); n++;
1946 XtGetValues(screen.timeOutScale, args, n);
1949 XtSetArg(args[n], XmNvalue, &screen.lockTimeout); n++;
1950 XtGetValues(screen.lockOutScale, args, n);
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;
1957 if (!XmToggleButtonGadgetGetState(screen.saverOn))
1958 screen.newTimeout = screen.lockTimeout * 60;
1960 screen.newTimeout = MIN(screen.saverTimeout, screen.lockTimeout) * 60;
1962 /* register new timeout with X */
1963 XSetScreenSaver(style.display, screen.newTimeout,
1964 screen.interval, screen.new_blanking, screen.exposures);
1966 screen.systemDefaultFlag = False;
1968 /*****************************************/
1969 /* no_svr_ext_timeOutvalueChangedCB */
1970 /* set the timeout to be the minimum of */
1971 /* the lock scale and timeout scale */
1972 /*****************************************/
1974 no_svr_ext_timeOutvalueChangedCB(
1976 XtPointer client_data,
1977 XtPointer call_data )
1983 XtSetArg(args[n], XmNvalue, &screen.saverTimeout); n++;
1984 XtGetValues(screen.timeOutScale, args, n);
1986 /* set newTimeout to the value of saver scale */
1987 screen.newTimeout = screen.saverTimeout * 60;
1989 /* register new timeout with X */
1990 XSetScreenSaver(style.display, screen.newTimeout,
1991 screen.interval, screen.new_blanking, screen.exposures);
1992 screen.systemDefaultFlag = False;
1995 /*+++++++++++++++++++++++++++++++++++++++*/
1997 /*+++++++++++++++++++++++++++++++++++++++*/
2001 XtPointer client_data,
2002 XtPointer call_data )
2008 XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
2010 set = (Boolean) cb->set;
2013 if (w == screen.saverOff && !set )
2018 if (w == screen.saverOff && set)
2020 /* Terminate the screen saver that is currently running */
2021 if (savers.saverstate)
2023 _DtSaverStop(style.display, savers.saverstate);
2024 savers.saverstate = NULL;
2025 XSync(style.display, False);
2026 XClearWindow(style.display, XtWindow(screen.saverArea));
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;
2049 screen.newTimeout = 0;
2050 /* let the session manger know not to run any savers */
2055 if (w == screen.saverOn && !set)
2060 if (w == screen.saverOn && set)
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)
2069 XtSetSensitive(screen.cycleTimeLabel, True);
2070 XtSetSensitive(screen.cycleTimeScale, True);
2071 XtSetSensitive(screen.cycleMinutesLabel, True );
2075 XtSetSensitive(screen.cycleTimeLabel, False);
2076 XtSetSensitive(screen.cycleTimeScale, False);
2077 XtSetSensitive(screen.cycleMinutesLabel, False);
2080 if (savers.saverCount)
2082 /* display the preview label */
2083 XtManageChild(screen.prevLabel);
2084 /* Restart the screen saver that is is currently selected */
2085 if (!savers.saverstate)
2087 XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
2088 savers.saverstate = _DtSaverStart(style.display,
2089 &screen.saverArea, 1, savers.current_saver,
2090 style.screenDialog);
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 */
2096 if (!XmToggleButtonGadgetGetState(screen.lockOn))
2097 screen.newTimeout = screen.saverTimeout * 60;
2099 screen.newTimeout = MIN(screen.saverTimeout, screen.lockTimeout) * 60;
2100 /* let the session manger know to run savers */
2101 SmNewSaverTime(screen.newTimeout);
2104 XSetScreenSaver(style.display, screen.newTimeout,
2105 screen.interval, screen.new_blanking, screen.exposures);
2107 screen.systemDefaultFlag = False;
2109 /*+++++++++++++++++++++++++++++++++++++++*/
2110 /* no_svr_ext_saverToggleCB */
2111 /*+++++++++++++++++++++++++++++++++++++++*/
2113 no_svr_ext_saverToggleCB(
2115 XtPointer client_data,
2116 XtPointer call_data )
2122 XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
2124 set = (Boolean) cb->set;
2127 if (w == screen.saverOff && !set )
2132 if (w == screen.saverOff && set)
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;
2142 if (w == screen.saverOn && !set)
2147 if (w == screen.saverOn && set)
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 */
2155 screen.newTimeout = screen.saverTimeout * 60;
2158 XSetScreenSaver(style.display, screen.newTimeout,
2159 screen.interval, screen.new_blanking, screen.exposures);
2161 screen.systemDefaultFlag = False;
2164 /*+++++++++++++++++++++++++++++++++++++++*/
2166 /*+++++++++++++++++++++++++++++++++++++++*/
2170 XtPointer client_data,
2171 XtPointer call_data )
2176 XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
2178 set = (Boolean) cb->set;
2181 if (w == screen.lockOff && !set )
2186 if (w == screen.lockOff && set)
2188 XtSetSensitive(screen.lockOutLabel, False);
2189 XtSetSensitive(screen.lockOutScale, False);
2190 XtSetSensitive(screen.lockMinutesLabel, False);
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;
2198 screen.newTimeout = 0;
2200 XSetScreenSaver(style.display, screen.newTimeout,
2201 screen.interval, screen.new_blanking, screen.exposures);
2204 if (w == screen.lockOn && !set)
2209 if (w == screen.lockOn && set)
2211 XtSetSensitive(screen.lockOutLabel, True);
2212 XtSetSensitive(screen.lockOutScale, True);
2213 XtSetSensitive(screen.lockMinutesLabel, True);
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;
2221 screen.newTimeout = MIN(screen.saverTimeout, screen.lockTimeout) * 60;
2223 XSetScreenSaver(style.display, screen.newTimeout,
2224 screen.interval, screen.new_blanking, screen.exposures);
2226 screen.systemDefaultFlag = False;
2230 /*+++++++++++++++++++++++++++++++++++++++*/
2231 /* saversToggleCB */
2232 /*+++++++++++++++++++++++++++++++++++++++*/
2236 XtPointer client_data,
2237 XtPointer call_data )
2243 XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct *)call_data;
2245 set = (Boolean) cb->set;
2247 if (w == screen.useSaversOff && !set )
2252 if (w == screen.useSaversOff && set)
2254 /* Terminate the screen saver that is currently running */
2255 if (savers.saverstate)
2257 _DtSaverStop(style.display, savers.saverstate);
2258 savers.saverstate = NULL;
2259 XSync(style.display, False);
2260 XClearWindow(style.display, XtWindow(screen.saverArea));
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 */
2279 if (w == screen.useSaversOn && !set)
2284 if (w == screen.useSaversOn && set)
2286 XtSetSensitive(screen.saverList, True);
2287 XtSetSensitive(screen.saverArea, True);
2288 if (savers.selsaverCount > 1)
2290 XtSetSensitive(screen.cycleTimeLabel, True);
2291 XtSetSensitive(screen.cycleTimeScale, True);
2292 XtSetSensitive(screen.cycleMinutesLabel, True);
2294 if (savers.saverCount)
2296 /* display the preview label */
2297 XtManageChild(screen.prevLabel);
2298 /* Restart the screen saver that is is currently selected */
2299 if (!savers.saverstate)
2301 XtVaSetValues(screen.saverArea, XmNbackground, savers.black, NULL);
2302 savers.saverstate = _DtSaverStart(style.display,
2303 &screen.saverArea, 1, savers.current_saver, style.screenDialog);
2306 /* let the session manger know to run the savers */
2307 SmNewSaverTime(screen.saverTimeout*60);
2312 /*+++++++++++++++++++++++++++++++++++++++*/
2313 /* systemDefaultCB */
2314 /*+++++++++++++++++++++++++++++++++++++++*/
2318 XtPointer client_data,
2319 XtPointer call_data )
2324 screen.saverTimeout = SAVER_DEFAULT;
2326 XtSetArg(args[n], XmNvalue, screen.saverTimeout); n++;
2327 XtSetValues(screen.timeOutScale, args, n);
2329 screen.lockTimeout = LOCK_DEFAULT;
2331 XtSetArg(args[n], XmNvalue, screen.lockTimeout); n++;
2332 XtSetValues(screen.lockOutScale, args, n);
2333 XmToggleButtonGadgetSetState(screen.lockOff, True, True);
2335 screen.cycleTimeout = CYCLE_DEFAULT;
2337 XtSetArg(args[n], XmNvalue, screen.cycleTimeout); n++;
2338 XtSetValues(screen.cycleTimeScale, args, n);
2339 XmToggleButtonGadgetSetState(screen.saverOn, True, True);
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;
2348 /*+++++++++++++++++++++++++++++++++++++++*/
2349 /* no_svr_ext_systemDefaultCB */
2350 /*+++++++++++++++++++++++++++++++++++++++*/
2352 no_svr_ext_systemDefaultCB(
2354 XtPointer client_data,
2355 XtPointer call_data )
2360 screen.saverTimeout = SAVER_DEFAULT;
2362 XtSetArg(args[n], XmNvalue, screen.saverTimeout); n++;
2363 XtSetValues(screen.timeOutScale, args, n);
2365 screen.cycleTimeout = CYCLE_DEFAULT;
2367 XtSetArg(args[n], XmNvalue, screen.cycleTimeout); n++;
2368 XtSetValues(screen.cycleTimeScale, args, n);
2370 XmToggleButtonGadgetSetState(screen.saverOn, True, True);
2371 XmToggleButtonGadgetSetState(screen.useSaversOn, True, True);
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);
2378 screen.systemDefaultFlag = True;
2381 /*+++++++++++++++++++++++++++++++++++++++*/
2383 /* callback for PushButtons in DialogBox */
2384 /*+++++++++++++++++++++++++++++++++++++++*/
2388 XtPointer client_data,
2389 XtPointer call_data )
2391 register int i, n, m;
2393 Boolean sel_matched = False;
2397 static char screenres[48];
2400 DtDialogBoxCallbackStruct *cb = (DtDialogBoxCallbackStruct *) call_data;
2402 switch (cb->button_position)
2406 XtUnmanageChild (w);
2407 /* terminate the saver that is currently running */
2408 if (savers.saverstate)
2410 _DtSaverStop(style.display, savers.saverstate);
2411 savers.saverstate = NULL;
2414 /* write saver timeout resource to xrdb to save scale value */
2415 /* when screen saver is turned off */
2416 saverset = XmToggleButtonGadgetGetState(screen.saverOn);
2419 sprintf (screenres, "Dtstyle*timeoutScale: %d\n", screen.saverTimeout);
2420 _DtAddToResource (style.display, screenres);
2423 /* write lock timeout resource to xrdb to save scale value */
2424 /* when lock is turned off */
2425 lockset = XmToggleButtonGadgetGetState(screen.lockOn);
2428 sprintf (screenres, "Dtstyle*lockoutScale: %d\n", screen.lockTimeout);
2429 _DtAddToResource (style.display, screenres);
2432 /* if sendSettings is true send message to Session Manager */
2433 if(style.smState.smSendSettings)
2435 if(screen.systemDefaultFlag)
2437 SmDefaultScreenSettings();
2442 SmNewScreenSettings(saverset||lockset ? screen.newTimeout : 0,
2443 screen.new_blanking,
2451 if (savers.saverCount)
2453 savers.selsaverActionNames = (char **) XtMalloc(sizeof(char *) *
2454 savers.selsaverCount);
2456 for (i=0; i<savers.selsaverCount; i++)
2458 char *tmp = savers.saverActionNames[savers.selPositions[i] - 1];
2459 savers.selsaverActionNames[i] = (char *) XtMalloc(strlen(tmp) + 1);
2460 strcpy(savers.selsaverActionNames[i], tmp);
2463 if (savers.selsaversList != NULL)
2464 XtFree((char*) savers.selsaversList);
2466 savers.selsaversList = build_selectedList(savers.selsaverActionNames,
2467 savers.selsaverCount);
2471 savers.selsaversList = NULL;
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];
2481 /* free the allocated selected savers */
2482 free_saverList(savers.selsaverActionNames, savers.selsaverCount);
2483 savers.selsaverActionNames = NULL;
2485 XtVaGetValues(screen.cycleTimeScale, XmNvalue, &screen.cycleTimeout, NULL);
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 */
2490 SmNewSaverSettings(saverset ? screen.saverTimeout*60 : 0,
2491 lockset ? screen.lockTimeout*60 : 0,
2492 screen.cycleTimeout*60,
2493 savers.selsaversList);
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;
2500 screen.origTimeout = screen.newTimeout;
2501 XSetScreenSaver(style.display, style.smState.smSaverTimeout,
2502 style.smState.smCycleTimeout,
2503 screen.new_blanking,
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;
2517 screen.saverTimeout = screen.saverTimeout_xrdb;
2519 if (style.smState.smLockTimeout)
2520 screen.lockTimeout = style.smState.smLockTimeout / 60;
2522 screen.lockTimeout = screen.lockTimeout_xrdb;
2524 if (style.smState.smCycleTimeout)
2525 screen.cycleTimeout = style.smState.smCycleTimeout / 60;
2527 screen.cycleTimeout = 0;
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);
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);
2541 /* reset the X timeout */
2542 screen.newTimeout = screen.origTimeout;
2543 XSetScreenSaver(style.display, screen.origTimeout, screen.interval,
2544 screen.blanking, screen.exposures);
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);
2553 if (savers.saverCount)
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];
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.
2573 XtFree((char *) savers.selPositions);
2574 savers.selPositions = (int *) XtMalloc(sizeof(int) * savers.orig_selsaverCount);
2576 for (i=0; i<savers.orig_selsaverCount; i++)
2577 savers.selPositions[i] = savers.origSelPositions[i];
2579 savers.selsaverCount = savers.orig_selsaverCount;
2588 XtCallCallbacks(style.screenDialog, XmNhelpCallback, (XtPointer)NULL);
2596 /*+++++++++++++++++++++++++++++++++++++++*/
2597 /* no_svr_ext_ButtonCB */
2598 /* callback for PushButtons in DialogBox */
2599 /*+++++++++++++++++++++++++++++++++++++++*/
2601 no_svr_ext_ButtonCB(
2603 XtPointer client_data,
2604 XtPointer call_data )
2606 register int i, n, m;
2608 Boolean sel_matched = False;
2611 static char screenres[48];
2614 DtDialogBoxCallbackStruct *cb = (DtDialogBoxCallbackStruct *) call_data;
2616 switch (cb->button_position)
2620 XtUnmanageChild (w);
2621 /* terminate the saver that is currently running */
2622 if (savers.saverstate)
2624 _DtSaverStop(style.display, savers.saverstate);
2625 savers.saverstate = NULL;
2628 /* write saver timeout resource to xrdb to save scale value */
2629 /* when screen saver is turned off */
2630 saverset = XmToggleButtonGadgetGetState(screen.saverOn);
2633 sprintf (screenres, "Dtstyle*timeoutScale: %d\n", screen.saverTimeout);
2634 _DtAddToResource (style.display, screenres);
2637 /* if sendSettings is true send message to Session Manager */
2638 if(style.smState.smSendSettings)
2640 if(screen.systemDefaultFlag)
2642 SmDefaultScreenSettings();
2646 SmNewScreenSettings(saverset ? screen.newTimeout : 0,
2647 screen.new_blanking,
2655 if (savers.saverCount)
2657 savers.selsaverActionNames = (char **) XtMalloc(sizeof(char *) *
2658 savers.selsaverCount);
2660 for (i=0; i<savers.selsaverCount; i++)
2662 char *tmp = savers.saverActionNames[savers.selPositions[i] - 1];
2663 savers.selsaverActionNames[i] = (char *) XtMalloc(strlen(tmp) + 1);
2664 strcpy(savers.selsaverActionNames[i], tmp);
2667 if (savers.selsaversList != NULL)
2668 XtFree((char*) savers.selsaversList);
2670 savers.selsaversList = build_selectedList(savers.selsaverActionNames,
2671 savers.selsaverCount);
2675 savers.selsaversList = NULL;
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];
2685 /* free the allocated selected savers */
2686 free_saverList(savers.selsaverActionNames, savers.selsaverCount);
2687 savers.selsaverActionNames = NULL;
2689 XtVaGetValues(screen.cycleTimeScale, XmNvalue, &screen.cycleTimeout, NULL);
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 */
2695 if(!XmToggleButtonGadgetGetState(screen.useSaversOn))
2699 SmNewSaverSettings(saverset ? screen.saverTimeout*60 : 0,
2700 style.smState.smLockTimeout,
2701 screen.cycleTimeout*60,
2702 savers.selsaversList);
2704 style.smState.smSaverTimeout = saverset ? screen.saverTimeout*60 : 0;
2705 style.smState.smCycleTimeout = screen.cycleTimeout*60;
2706 style.smSaver.saverList = savers.selsaversList;
2708 screen.origTimeout = screen.newTimeout;
2709 XSetScreenSaver(style.display, style.smState.smSaverTimeout,
2710 style.smState.smCycleTimeout,
2711 screen.new_blanking,
2719 /* initialize the value of savertimeout and cycle time to the */
2720 /* original value */
2722 if (screen.origTimeout)
2723 screen.saverTimeout = screen.origTimeout / 60;
2725 screen.saverTimeout = screen.saverTimeout_xrdb;
2728 if (style.smState.smCycleTimeout)
2729 screen.cycleTimeout = style.smState.smCycleTimeout / 60;
2731 screen.cycleTimeout = 0;
2733 /* reset the value of the scales */
2734 XtVaSetValues(screen.timeOutScale, XmNvalue, screen.saverTimeout, NULL);
2735 XtVaSetValues(screen.cycleTimeScale, XmNvalue, screen.cycleTimeout , NULL);
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);
2741 /* reset the value of the locking radio box toggles */
2742 if (style.smState.smSaverTimeout)
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)
2750 XtSetSensitive(screen.cycleTimeLabel, True);
2751 XtSetSensitive(screen.cycleTimeScale, True);
2752 XtSetSensitive(screen.cycleMinutesLabel, True);
2754 if (savers.saverCount)
2755 /* display the preview label */
2756 XtManageChild(screen.prevLabel);
2758 /* let the session manger know to run the savers */
2759 SmNewSaverTime(screen.saverTimeout*60);
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 */
2781 /* reset the X timeout */
2782 screen.newTimeout = screen.origTimeout;
2783 XSetScreenSaver(style.display, screen.origTimeout, screen.interval,
2784 screen.blanking,screen.exposures);
2787 if (savers.saverCount)
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];
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.
2807 XtFree((char *) savers.selPositions);
2808 if (savers.orig_selsaverCount > 0) {
2809 savers.selPositions =
2810 (int *) XtMalloc(sizeof(int) * savers.orig_selsaverCount);
2812 for (i=0; i<savers.orig_selsaverCount; i++)
2813 savers.selPositions[i] = savers.origSelPositions[i];
2816 savers.selsaverCount = savers.orig_selsaverCount;
2822 XtCallCallbacks(style.screenDialog, XmNhelpCallback, (XtPointer)NULL);
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 /************************************************************************/
2841 XrmName xrm_name[5];
2842 XrmRepresentation rep_type;
2845 xrm_name [0] = XrmStringToQuark ("Screen");
2846 xrm_name [2] = NULL;
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;
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++;
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);
2868 /*******************************************************************************/
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 */
2878 /*******************************************************************************/
2884 char *bufr = style.tmpBigStr; /* size=[1024], make bigger if needed */
2885 XmVendorShellExtObject vendorExt;
2886 XmWidgetExtData extData;
2888 if (style.screenDialog != NULL)
2890 if (XtIsManaged(style.screenDialog))
2891 sprintf(bufr, "*Screen.ismapped: True\n");
2893 sprintf(bufr, "*Screen.ismapped: False\n");
2895 /* Get and write out the geometry info for our Window */
2896 x = XtX(XtParent(style.screenDialog));
2897 y = XtY(XtParent(style.screenDialog));
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;
2906 sprintf(bufr, "%s*Screen.x: %d\n", bufr, x);
2907 sprintf(bufr, "%s*Screen.y: %d\n", bufr, y);
2909 write (fd, bufr, strlen(bufr));
2914 /************************************************************************/
2915 /* MakeListStrings() */
2916 /* Make XmStrings from the saver names, to pass into list. */
2917 /************************************************************************/
2919 MakeListStrings( char ** list )
2924 xmList = (XmString *) XtMalloc(savers.saverCount * sizeof(XmString));
2926 for (i = 0; i < savers.saverCount; i++)
2928 xmList[i] = XmStringCreateLocalized (list[i]);
2935 /************************************************************************/
2936 /* FreeListStrings() */
2937 /************************************************************************/
2940 FreeListStrings(XmString *xmlist,
2945 for (i = 0; i < count; i++)
2948 XmStringFree(xmlist[i]);
2950 XtFree ((char *)xmlist);
2954 /************************************************************************/
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 /************************************************************************/
2963 XtPointer client_data,
2964 XtPointer call_data )
2966 XmListCallbackStruct *cb = (XmListCallbackStruct *)call_data;
2968 Boolean runsaver = False;
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 */
2976 if (cb->selected_item_count == 0)
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];
2989 /* make a copy of the selected item positions for later use */
2991 if (savers.selPositions != NULL)
2992 XtFree ((char *) savers.selPositions);
2994 savers.selPositions = (int *) XtMalloc(sizeof(int) * cb->selected_item_count);
2995 for (i=0; i< cb->selected_item_count; i++)
2997 savers.selPositions[i] = cb->selected_item_positions[i];
3000 savers.selsaverCount = cb->selected_item_count;
3001 if (savers.selsaverCount < 2)
3003 XtSetSensitive(screen.cycleTimeScale, False);
3004 XtSetSensitive(screen.cycleTimeLabel, False);
3005 XtSetSensitive(screen.cycleMinutesLabel, False);
3008 if (savers.previous_selsaverCount < 2)
3010 XtSetSensitive(screen.cycleTimeScale, True);
3011 XtSetSensitive(screen.cycleTimeLabel, True);
3012 XtSetSensitive(screen.cycleMinutesLabel, True);
3015 savers.previous_selsaverCount = savers.selsaverCount;
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++)
3027 if(cb->selected_item_positions[i] == cb->item_position)
3033 i = cb->selected_item_positions[(cb->selected_item_count-1)];
3034 if (savers.current_position == cb->item_position)
3036 if (savers.saverstate)
3038 /* Terminate the screen saver that is currently running */
3039 _DtSaverStop(style.display, savers.saverstate);
3040 XSync(style.display, False);
3041 savers.saverstate = NULL;
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);
3056 /* The item position returned is the selcted item */
3057 /* Start screen saver. _DtSaverStop() must be called to terminate the */
3059 if (savers.saverstate)
3061 /* Terminate the screen saver that is currently running */
3062 _DtSaverStop(style.display, savers.saverstate);
3063 XSync(style.display, False);
3064 savers.saverstate = NULL;
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);
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);
3083 /************************************************************************/
3085 /* Kills the currently previewed saver when the user iconifies the */
3086 /* style manager. An XtEventHandler. */
3087 /************************************************************************/
3091 XtPointer client_data,
3098 if (event->type == UnmapNotify)
3100 /* terminate the saver that is currently running */
3101 if (savers.saverstate)
3103 _DtSaverStop(style.display, savers.saverstate);
3104 savers.saverstate = NULL;
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)
3112 if (XmToggleButtonGadgetGetState(screen.saverOn) && savers.saverCount)
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);
3124 if (XmToggleButtonGadgetGetState(screen.useSaversOn) && savers.saverCount)
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);
3137 /************************************************************************/
3139 /* Kills the currently previewed saver when the user iconifies the */
3140 /* style manager or unmaps the screen dialog. */
3141 /************************************************************************/
3146 XtPointer client_data,
3147 XtPointer call_data )
3149 /* terminate the saver that is currently running */
3150 if (savers.saverstate)
3152 _DtSaverStop(style.display, savers.saverstate);
3153 savers.saverstate = NULL;