cde/programs/dtfile/Prefs.c

   1 /* $XConsortium: Prefs.c /main/7 1996/10/23 17:04:25 mustafa $ */
   2 /************************************<+>*************************************
   3  ****************************************************************************
   4  *
   5  *   FILE:           Prefs.c
   6  *
   7  *   COMPONENT_NAME: Desktop File Manager (dtfile)
   8  *
   9  *   Description:    Source file for the change directory dialog.
  10  *
  11  *   FUNCTIONS: ApplyCallback
  12  *              Create
  13  *              Destroy
  14  *              DirectionToString
  15  *              FreeValues
  16  *              GetDefaultValues
  17  *              GetPreferencesValues
  18  *              GetResourceValues
  19  *              GetValues
  20  *              InstallChange
  21  *              InstallClose
  22  *              OkCallback
  23  *              OrderToString
  24  *              RandomToString
  25  *              ResetCallback
  26  *              SetValues
  27  *              ShowTypeToString
  28  *              StringToDirection
  29  *              StringToOrder
  30  *              StringToRandom
  31  *              StringToShowType
  32  *              StringToTreeFiles
  33  *              StringToView
  34  *              ToggleCallback
  35  *              TreeFilesToString
  36  *              ViewToString
  37  *              WriteResourceValues
  38  *
  39  *   (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
  40  *   (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
  41  *   (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
  42  *   (c) Copyright 1993, 1994, 1995 Novell, Inc.
  43  *
  44  ****************************************************************************
  45  ************************************<+>*************************************/
  46
  47
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <limits.h>
  51
  52
  53 #include <Xm/XmP.h>
  54 #include <Xm/Xm.h>
  55 #include <Xm/DialogS.h>
  56 #include <Xm/MessageB.h>
  57 #include <Xm/BulletinB.h>
  58 #include <Xm/Form.h>
  59 #include <Xm/Frame.h>
  60 #include <Xm/LabelG.h>
  61 #include <Xm/PushBG.h>
  62 #include <Xm/ToggleBG.h>
  63 #include <Xm/SeparatoG.h>
  64 #include <Xm/VendorSEP.h>
  65 #include <Xm/MwmUtil.h>
  66 #include <Xm/Protocols.h>
  67
  68 #include <Dt/TitleBox.h>
  69
  70 #include <Dt/DtNlUtils.h>
  71 #include "Encaps.h"
  72 #include "SharedProcs.h"
  73
  74 #include <X11/ShellP.h>
  75 #include <X11/Shell.h>
  76 #include <X11/Xatom.h>
  77
  78 #include "FileMgr.h"
  79 #include "Desktop.h"
  80 #include "Main.h"
  81 #include "Prefs.h"
  82 #include "Help.h"
  83
  84 /********    Static Function Declarations    ********/
  85
  86 static void Create(
  87                         Display *display,
  88                         Widget parent,
  89                         Widget *return_widget,
  90                         XtPointer *dialog) ;
  91 static void InstallChange(
  92                         PreferencesRec *preferences_rec,
  93                         XtCallbackProc callback,
  94                         XtPointer client_data) ;
  95 static void InstallClose(
  96                         PreferencesRec *preferences_rec,
  97                         XtCallbackProc callback,
  98                         XtPointer client_data) ;
  99 static void Destroy(
 100                         PreferencesRec *preferences_rec) ;
 101 static XtPointer GetValues(
 102                         PreferencesRec *preferences_rec) ;
 103 static XtPointer GetDefaultValues( void ) ;
 104 static XtPointer GetResourceValues(
 105                         XrmDatabase data_base,
 106                         char **name_list) ;
 107 static void SetValues(
 108                         PreferencesRec *preferences_rec,
 109                         PreferencesData *preferences_data) ;
 110 static void WriteResourceValues(
 111                         DialogData *values,
 112                         int fd,
 113                         char **name_list) ;
 114 static void FreeValues(
 115                         PreferencesData *preferences_data) ;
 116 static void ResetCallback(
 117                         Widget w,
 118                         XtPointer client_data,
 119                         XtPointer call_data) ;
 120 static void ToggleCallback(
 121                         Widget w,
 122                         XtPointer client_data,
 123                         XtPointer call_data) ;
 124 static void OkCallback(
 125                         Widget w,
 126                         PreferencesApply *apply_data,
 127                         XtPointer call_data) ;
 128 static void ApplyCallback(
 129                         Widget w,
 130                         PreferencesApply *apply_data,
 131                         XtPointer call_data) ;
 132 static void GetPreferencesValues(
 133                         PreferencesRec *preferences_rec,
 134                         PreferencesData *preferences_data) ;
 135
 136 /********    End Static Function Declarations    ********/
 137
 138
 139 static char * Order_by_file_type = "order_by_file_type";
 140 static char * Order_by_alphabetical = "order_by_alphabetical";
 141 static char * Order_by_date = "order_by_date";
 142 static char * Order_by_size = "order_by_size";
 143 static char * By_name = "by_name";
 144 static char * By_name_and_icon = "by_name_and_icon";
 145 static char * By_name_and_small_icon = "by_name_and_small_icon";
 146 static char * By_attributes = "by_attributes";
 147 static char * Direction_descending = "direction_descending";
 148 static char * Direction_ascending = "direction_ascending";
 149 static char * Single_directory = "single_directory";
 150 static char * DirectoryTree = "directory_tree";
 151 static char * Tree_files_never = "never";
 152 static char * Tree_files_choose = "choose";
 153 static char * Tree_files_always = "always";
 154 static char * PreferencesName = "Preferences";
 155 static char * Random_on = "random_on";
 156 static char * Random_off = "random_off";
 157
 158
 159 /*  Resource definitions for the preferences dialog  */
 160
 161 static DialogResource resources[] =
 162 {
 163    { "showType", SHOW_TYPE, sizeof(unsigned char),
 164      XtOffset(PreferencesDataPtr, show_type),
 165      (XtPointer) SINGLE_DIRECTORY, ShowTypeToString },
 166
 167    { "treeFiles", TREE_FILES, sizeof(unsigned char),
 168      XtOffset(PreferencesDataPtr, tree_files),
 169      (XtPointer) TREE_FILES_NEVER, TreeFilesToString },
 170
 171    { "view_single", VIEW, sizeof(unsigned char),
 172      XtOffset(PreferencesDataPtr, view_single),
 173      (XtPointer) BY_NAME_AND_ICON, ViewToString },
 174
 175    { "view_tree", VIEW, sizeof(unsigned char),
 176      XtOffset(PreferencesDataPtr, view_tree),
 177      (XtPointer) BY_NAME_AND_SMALL_ICON, ViewToString },
 178
 179    { "order", ORDER, sizeof(unsigned char),
 180      XtOffset(PreferencesDataPtr, order),
 181      (XtPointer) ORDER_BY_ALPHABETICAL, OrderToString },
 182
 183    { "direction", DIRECTION_RESRC, sizeof(unsigned char),
 184      XtOffset(PreferencesDataPtr, direction),
 185      (XtPointer) DIRECTION_ASCENDING, DirectionToString },
 186
 187    { "positionEnabled", RANDOM, sizeof(unsigned char),
 188      XtOffset(PreferencesDataPtr, positionEnabled),
 189      (XtPointer) RANDOM_OFF, RandomToString },
 190 };
 191
 192 /*  Callback function definitions  */
 193
 194 /*
 195  *  The Dialog Class structure.
 196  */
 197 static DialogClass preferencesClassRec =
 198 {
 199    resources,
 200    XtNumber(resources),
 201    Create,
 202    (DialogInstallChangeProc) InstallChange,
 203    (DialogInstallCloseProc) InstallClose,
 204    (DialogDestroyProc) Destroy,
 205    (DialogGetValuesProc) GetValues,
 206    GetDefaultValues,
 207    GetResourceValues,
 208    (DialogSetValuesProc) SetValues,
 209    WriteResourceValues,
 210    (DialogFreeValuesProc) FreeValues,
 211    (DialogMapWindowProc) _DtGenericMapWindow,
 212    NULL,
 213 };
 214
 215 DialogClass * preferencesClass = (DialogClass *) &preferencesClassRec;
 216
 217 int showType;
 218
 219
 220 /************************************************************************
 221  *
 222  *  Create
 223  *
 224  ************************************************************************/
 225
 226 static void
 227 Create(
 228         Display *display,
 229         Widget parent,
 230         Widget *return_widget,
 231         XtPointer *dialog )
 232 {
 233    PreferencesRec * preferences_rec;
 234    Widget shell;
 235    Widget form;
 236    Widget show_frame;
 237    Widget view_frame;
 238    Widget order_frame;
 239    Widget direction_frame;
 240    Widget group_form;
 241    Widget separator;
 242    Widget temp;
 243    Widget headers_frame;
 244    Widget position_frame;
 245    Widget titleWidget;
 246    XmString label_string;
 247    Arg args[15];
 248    Dimension offset, screenHeight;
 249    int n;
 250    char * tmpStr;
 251
 252    /*  Allocate the change directory dialog instance record.  */
 253
 254    preferences_rec = (PreferencesRec *) XtMalloc (sizeof (PreferencesRec));
 255
 256    screenHeight = HeightOfScreen( XtScreen( parent ) );
 257    /* We are supporting 3 sizes. They are: 1200, 1024, 480
 258       For the sake of simplicity, process two of them.
 259    */
 260    if( screenHeight >= (Dimension) 1024 )
 261      offset = (Dimension)5;
 262    else
 263      offset = (Dimension)1;
 264
 265    /*  Create the shell, bulletin board and form used for the dialog.  */
 266
 267    n = 0;
 268    XtSetArg (args[n], XmNmwmFunctions, MWM_FUNC_MOVE
 269              | MWM_FUNC_CLOSE);                                 ++n;
 270    XtSetArg (args[n], XmNmwmDecorations, MWM_DECOR_BORDER
 271              | MWM_DECOR_TITLE);                                ++n;
 272    XtSetArg (args[n], XmNallowShellResize, False);              ++n;
 273    preferences_rec->shell = shell =
 274                  XmCreateDialogShell (parent, "preferences", args, n);
 275
 276
 277    /* Set the useAsyncGeo on the shell */
 278    XtSetArg (args[0], XmNuseAsyncGeometry, True);
 279    XtSetValues (XtParent(shell), args, 1);
 280
 281    n = 0;
 282    XtSetArg (args[n], XmNmarginWidth, 1);                       n++;
 283    XtSetArg (args[n], XmNmarginHeight, 1);                      n++;
 284    XtSetArg (args[n], XmNshadowThickness, 1);                   n++;
 285    XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);             n++;
 286    XtSetArg (args[n], XmNautoUnmanage, False);                  n++;
 287    form = XmCreateForm (shell, "form", args, n);
 288    XtAddCallback(form, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 289                  HELP_PREFERENCES_DIALOG_STR);
 290
 291
 292    /* Create the headers status line */
 293    label_string = XmStringCreateLocalized ((GETMESSAGE(23,23, "Headers")));
 294    n = 0;
 295    XtSetArg (args[n], XmNtitleString, label_string);            n++;
 296    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 297    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 298    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
 299    XtSetArg (args[n], XmNrightOffset, offset);                  n++;
 300    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 301    XtSetArg (args[n], XmNleftOffset, offset);                   n++;
 302    XtSetArg (args[n], XmNmarginWidth, offset);                  n++;
 303    XtSetArg (args[n], XmNmarginHeight, offset);                 n++;
 304    headers_frame = _DtCreateTitleBox(form, "headers_frame", args, n);
 305    XtManageChild (headers_frame);
 306    XtAddCallback(headers_frame, XmNhelpCallback,
 307                  (XtCallbackProc)HelpRequestCB,
 308                  HELP_PREFERENCES_HEADERS_STR);
 309    XmStringFree(label_string);
 310
 311    titleWidget = _DtTitleBoxGetTitleArea(headers_frame);
 312
 313    XtSetArg (args[0], XmNtraversalOn, False);
 314    XtSetValues (titleWidget, args, 1);
 315
 316
 317    group_form = XmCreateForm (headers_frame, "group_form", args, 0);
 318    XtManageChild (group_form);
 319
 320    label_string = XmStringCreateLocalized ((GETMESSAGE(23,24, "Iconic Path")));
 321    n = 0;
 322    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 323    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 324    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 325    preferences_rec->show_iconic_path = temp =
 326       XmCreateToggleButtonGadget (group_form, "show_iconic_path", args, n);
 327    XtManageChild (temp);
 328    XmStringFree (label_string);
 329    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 330                   (XtPointer) preferences_rec);
 331    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 332                  HELP_PREFERENCES_HEADERS_STR);
 333
 334    label_string = XmStringCreateLocalized ((GETMESSAGE(23,36, "Text Path")));
 335    n = 0;
 336    XtSetArg (args[n], XmNlabelString, label_string);                    n++;
 337    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);                 n++;
 338    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);              n++;
 339    XtSetArg (args[n], XmNleftWidget, preferences_rec->show_iconic_path);n++;
 340    XtSetArg (args[n], XmNleftOffset, 10);                               n++;
 341    preferences_rec->show_current_dir = temp =
 342       XmCreateToggleButtonGadget (group_form, "show_current_dir", args, n);
 343    XtManageChild (temp);
 344    XmStringFree (label_string);
 345    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback, (XtPointer) preferences_rec);
 346    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 347                  HELP_PREFERENCES_HEADERS_STR);
 348
 349    label_string = XmStringCreateLocalized ((GETMESSAGE(23,37, "Message Line")));
 350    n = 0;
 351    XtSetArg (args[n], XmNlabelString, label_string);                    n++;
 352    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);                 n++;
 353    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);              n++;
 354    XtSetArg (args[n], XmNleftWidget, preferences_rec->show_current_dir);n++;
 355    XtSetArg (args[n], XmNleftOffset, 10);                               n++;
 356    preferences_rec->show_status_line = temp =
 357       XmCreateToggleButtonGadget (group_form, "show_status_line", args, n);
 358    XtManageChild (temp);
 359    XmStringFree (label_string);
 360    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback, (XtPointer) preferences_rec);
 361    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 362                  HELP_PREFERENCES_HEADERS_STR);
 363
 364
 365    /* Create the positioning status line */
 366    label_string = XmStringCreateLocalized ((GETMESSAGE(23,18, "Placement")));
 367    n = 0;
 368    XtSetArg (args[n], XmNtitleString, label_string);         n++;
 369    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);    n++;
 370    XtSetArg (args[n], XmNtopWidget, headers_frame);          n++;
 371    XtSetArg (args[n], XmNtopOffset, offset);                 n++;
 372    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);    n++;
 373    XtSetArg (args[n], XmNrightOffset, offset);               n++;
 374    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);     n++;
 375    XtSetArg (args[n], XmNleftOffset, offset);                n++;
 376    XtSetArg (args[n], XmNmarginWidth, offset);               n++;
 377    XtSetArg (args[n], XmNmarginHeight, offset);              n++;
 378    position_frame = _DtCreateTitleBox(form, "position_frame", args, n);
 379    XtManageChild (position_frame);
 380    XtAddCallback(position_frame, XmNhelpCallback,
 381                  (XtCallbackProc)HelpRequestCB,
 382                  HELP_PREFERENCES_PLACEMENT_STR);
 383    XmStringFree(label_string);
 384
 385    titleWidget = _DtTitleBoxGetTitleArea(position_frame);
 386
 387    XtSetArg (args[0], XmNtraversalOn, False);
 388    XtSetValues (titleWidget, args, 1);
 389
 390
 391    group_form = XmCreateForm (position_frame, "group_form", args, 0);
 392    XtManageChild (group_form);
 393
 394    label_string = XmStringCreateLocalized ((GETMESSAGE(23,20, "As Placed")));
 395    n = 0;
 396    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 397    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 398    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 399    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 400    preferences_rec->random_on = temp =
 401       XmCreateToggleButtonGadget (group_form, "random_on", args, n);
 402    XtManageChild (temp);
 403    XmStringFree (label_string);
 404    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 405                   (XtPointer) preferences_rec);
 406    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 407                  HELP_PREFERENCES_PLACEMENT_STR);
 408
 409    label_string = XmStringCreateLocalized ((GETMESSAGE(23,35, "Rows and Columns")));
 410    n = 0;
 411    XtSetArg (args[n], XmNlabelString, label_string);              n++;
 412    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);           n++;
 413    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);        n++;
 414    XtSetArg (args[n], XmNleftWidget, preferences_rec->random_on); n++;
 415    XtSetArg (args[n], XmNleftOffset, 10);                         n++;
 416    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);           n++;
 417    preferences_rec->random_off = temp =
 418       XmCreateToggleButtonGadget (group_form, "random_off", args, n);
 419    XtManageChild (temp);
 420    XmStringFree (label_string);
 421    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback, (XtPointer) preferences_rec);
 422    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 423                  HELP_PREFERENCES_PLACEMENT_STR);
 424
 425
 426    /*  Create the show container and widgets  */
 427
 428    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 7, "Show")));
 429    n = 0;
 430    XtSetArg (args[n], XmNtitleString, label_string);            n++;
 431    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 432    XtSetArg (args[n], XmNtopWidget, position_frame);            n++;
 433    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 434    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 435    XtSetArg (args[n], XmNleftOffset, offset);                   n++;
 436    XtSetArg (args[n], XmNmarginWidth, offset);                  n++;
 437    XtSetArg (args[n], XmNmarginHeight, offset);                 n++;
 438    show_frame = _DtCreateTitleBox (form, "show_frame", args, n);
 439    XtManageChild (show_frame);
 440    XmStringFree (label_string);
 441    XtAddCallback(show_frame, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 442                  HELP_PREFERENCES_SHOW_STR);
 443
 444    titleWidget = _DtTitleBoxGetTitleArea(show_frame);
 445
 446    XtSetArg (args[0], XmNtraversalOn, False);
 447    XtSetValues (titleWidget, args, 1);
 448
 449    group_form = XmCreateForm (show_frame, "show_form", args, 0);
 450    XtManageChild (group_form);
 451
 452    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 8, "By Single Folder")));
 453    n = 0;
 454    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 455    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 456    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 457    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 458    preferences_rec->show_single = temp =
 459       XmCreateToggleButtonGadget (group_form, "by_single_directory", args, n);
 460    XtManageChild (temp);
 461    XmStringFree (label_string);
 462    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 463                   (XtPointer) preferences_rec);
 464    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 465                  HELP_PREFERENCES_SHOW_STR);
 466
 467
 468    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 9, "By Tree")));
 469    n = 0;
 470    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 471    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 472    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 473    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 474    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 475    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 476    preferences_rec->show_multiple = temp =
 477       XmCreateToggleButtonGadget (group_form, "by_directory_tree", args, n);
 478    XtManageChild (temp);
 479    XmStringFree (label_string);
 480    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 481                   (XtPointer) preferences_rec);
 482    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 483                  HELP_PREFERENCES_SHOW_STR);
 484
 485    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 27, "Folders only")));
 486    n = 0;
 487    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 488    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 489    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 490    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 491    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 492    XtSetArg (args[n], XmNleftOffset, 25);                       n++;
 493    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 494    preferences_rec->tree_files_never = temp =
 495       XmCreateToggleButtonGadget (group_form, "tree_files_never", args, n);
 496    XtManageChild (temp);
 497    XmStringFree (label_string);
 498    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 499                   (XtPointer) preferences_rec);
 500    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 501                  HELP_PREFERENCES_SHOW_STR);
 502
 503    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 28, "Folders, then Files")));
 504    n = 0;
 505    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 506    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 507    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 508    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 509    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 510    XtSetArg (args[n], XmNleftOffset, 25);                       n++;
 511    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 512    preferences_rec->tree_files_choose = temp =
 513       XmCreateToggleButtonGadget (group_form, "tree_files_choose", args, n);
 514    XtManageChild (temp);
 515    XmStringFree (label_string);
 516    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 517                   (XtPointer) preferences_rec);
 518    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 519                  HELP_PREFERENCES_SHOW_STR);
 520
 521    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 29, "Folders and Files")));
 522    n = 0;
 523    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 524    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 525    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 526    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 527    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 528    XtSetArg (args[n], XmNleftOffset, 25);                       n++;
 529    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 530    preferences_rec->tree_files_always = temp =
 531       XmCreateToggleButtonGadget (group_form, "tree_files_always", args, n);
 532    XtManageChild (temp);
 533    XmStringFree (label_string);
 534    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 535                   (XtPointer) preferences_rec);
 536    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 537                  HELP_PREFERENCES_SHOW_STR);
 538
 539
 540    /*  Create the view container and widgets  */
 541
 542    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23,31, "Representation")));
 543    n = 0;
 544    XtSetArg (args[n], XmNtitleString, label_string);            n++;
 545    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 546    XtSetArg (args[n], XmNtopWidget, position_frame);            n++;
 547    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 548    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 549    XtSetArg (args[n], XmNleftOffset, 10);                       n++;
 550    XtSetArg (args[n], XmNleftWidget, show_frame);               n++;
 551    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
 552    XtSetArg (args[n], XmNrightOffset, offset);                  n++;
 553    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 554    XtSetArg (args[n], XmNbottomWidget, show_frame);             n++;
 555    XtSetArg (args[n], XmNmarginWidth, offset);                  n++;
 556    XtSetArg (args[n], XmNmarginHeight, offset);                 n++;
 557    view_frame = _DtCreateTitleBox(form, "view_frame", args, n);
 558    XtManageChild (view_frame);
 559    XmStringFree (label_string);
 560    XtAddCallback(view_frame, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 561                  HELP_PREFERENCES_VIEW_STR);
 562
 563    titleWidget = _DtTitleBoxGetTitleArea(view_frame);
 564
 565    XtSetArg (args[0], XmNtraversalOn, False);
 566    XtSetValues (titleWidget, args, 1);
 567
 568    group_form = XmCreateForm (view_frame, "view_form", args, 0);
 569    XtManageChild (group_form);
 570
 571    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23,32, "By Name Only")));
 572    n = 0;
 573    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 574    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 575    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 576    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 577    preferences_rec->by_name = temp =
 578       XmCreateToggleButtonGadget (group_form, "by_name", args, n);
 579    XtManageChild (temp);
 580    XmStringFree (label_string);
 581    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 582                   (XtPointer) preferences_rec);
 583    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 584                  HELP_PREFERENCES_VIEW_STR);
 585
 586
 587    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23,33, "By Large Icons")));
 588    n = 0;
 589    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 590    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 591    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 592    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 593    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 594    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 595    preferences_rec->by_name_and_icon = temp =
 596       XmCreateToggleButtonGadget (group_form, "by_name_and_icon", args, n);
 597    XtManageChild (temp);
 598    XmStringFree (label_string);
 599    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 600                   (XtPointer) preferences_rec);
 601    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 602                  HELP_PREFERENCES_VIEW_STR);
 603
 604
 605    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23,34, "By Small Icons")));
 606    n = 0;
 607    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 608    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 609    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 610    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 611    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 612    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 613    preferences_rec->by_name_and_small_icon = temp =
 614      XmCreateToggleButtonGadget (group_form, "by_name_and_small_icon", args, n);
 615    XtManageChild (temp);
 616    XmStringFree (label_string);
 617    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 618                   (XtPointer) preferences_rec);
 619    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 620                  HELP_PREFERENCES_VIEW_STR);
 621
 622
 623
 624    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23,6, "By Name, date, size ...")));
 625    n = 0;
 626    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 627    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 628    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 629    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 630    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 631    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 632    preferences_rec->by_attributes = temp =
 633       XmCreateToggleButtonGadget (group_form, "by_attributes", args, n);
 634    XtManageChild (temp);
 635    XmStringFree (label_string);
 636    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 637                   (XtPointer) preferences_rec);
 638    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 639                  HELP_PREFERENCES_VIEW_STR);
 640
 641
 642    /*  Create the file order container and widgets  */
 643
 644    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 10, "Order")));
 645    n = 0;
 646    XtSetArg (args[n], XmNtitleString, label_string);            n++;
 647    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 648    XtSetArg (args[n], XmNtopWidget, view_frame);                n++;
 649    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 650    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 651    XtSetArg (args[n], XmNleftOffset, offset);                   n++;
 652    XtSetArg (args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET);    n++;
 653    XtSetArg (args[n], XmNrightWidget, show_frame);              n++;
 654    XtSetArg (args[n], XmNmarginWidth, offset);                  n++;
 655    XtSetArg (args[n], XmNmarginHeight, offset);                 n++;
 656    order_frame = _DtCreateTitleBox (form, "order_frame", args, n);
 657    XtManageChild (order_frame);
 658    XmStringFree (label_string);
 659    XtAddCallback(order_frame, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 660                  HELP_PREFERENCES_ORDER_STR);
 661
 662    titleWidget = _DtTitleBoxGetTitleArea(order_frame);
 663
 664    XtSetArg (args[0], XmNtraversalOn, False);
 665    XtSetValues (titleWidget, args, 1);
 666
 667    group_form = XmCreateForm (order_frame, "order_form", args, 0);
 668    XtManageChild (group_form);
 669
 670    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 12, "Alphabetically")));
 671    n = 0;
 672    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 673    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 674    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 675    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 676    preferences_rec->order_alphabetical = temp =
 677       XmCreateToggleButtonGadget (group_form, "alphabetically", args, n);
 678    XtManageChild (temp);
 679    XmStringFree (label_string);
 680    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 681                   (XtPointer) preferences_rec);
 682    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 683                  HELP_PREFERENCES_ORDER_STR);
 684
 685
 686    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 11, "By File Type")));
 687    n = 0;
 688    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 689    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 690    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 691    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 692    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 693    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 694    preferences_rec->order_file_type = temp =
 695       XmCreateToggleButtonGadget (group_form, "by_file_type", args, n);
 696    XtManageChild (temp);
 697    XmStringFree (label_string);
 698    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 699                   (XtPointer) preferences_rec);
 700    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 701                  HELP_PREFERENCES_ORDER_STR);
 702
 703
 704    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 13, "By Date")));
 705    n = 0;
 706    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 707    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 708    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 709    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 710    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 711    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 712    preferences_rec->order_date = temp =
 713       XmCreateToggleButtonGadget (group_form, "by_date", args, n);
 714    XtManageChild (temp);
 715    XmStringFree (label_string);
 716    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 717                   (XtPointer) preferences_rec);
 718    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 719                  HELP_PREFERENCES_ORDER_STR);
 720
 721
 722    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 14, "By Size")));
 723
 724    n = 0;
 725    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 726    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 727    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 728    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 729    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 730    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 731    preferences_rec->order_size = temp =
 732       XmCreateToggleButtonGadget (group_form, "by_size", args, n);
 733    XtManageChild (temp);
 734    XmStringFree (label_string);
 735    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 736                   (XtPointer) preferences_rec);
 737    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 738                  HELP_PREFERENCES_ORDER_STR);
 739
 740
 741    /*  Create the file direction container and widgets  */
 742
 743    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 15, "Direction")));
 744    n = 0;
 745    XtSetArg (args[n], XmNtitleString, label_string);            n++;
 746    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 747    XtSetArg (args[n], XmNtopWidget, view_frame);                n++;
 748    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 749    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 750    XtSetArg (args[n], XmNbottomWidget, order_frame);            n++;
 751    XtSetArg (args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);     n++;
 752    XtSetArg (args[n], XmNleftWidget, view_frame);               n++;
 753    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
 754    XtSetArg (args[n], XmNrightOffset, offset);                  n++;
 755    XtSetArg (args[n], XmNmarginWidth, offset);                  n++;
 756    XtSetArg (args[n], XmNmarginHeight, offset);                 n++;
 757    direction_frame = _DtCreateTitleBox (form, "direction_frame", args, n);
 758    XtManageChild (direction_frame);
 759    XmStringFree (label_string);
 760    XtAddCallback(direction_frame, XmNhelpCallback,
 761                  (XtCallbackProc)HelpRequestCB,
 762                  HELP_PREFERENCES_DIRECTION_STR);
 763
 764    titleWidget = _DtTitleBoxGetTitleArea(direction_frame);
 765
 766    XtSetArg (args[0], XmNtraversalOn, False);
 767    XtSetValues (titleWidget, args, 1);
 768
 769    group_form = XmCreateForm (direction_frame, "direction_form", args, 0);
 770    XtManageChild (group_form);
 771
 772    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 16, "Ascending")));
 773
 774    n = 0;
 775    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 776    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 777    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 778    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 779    preferences_rec->direction_ascending = temp =
 780       XmCreateToggleButtonGadget (group_form, "ascending", args, n);
 781    XtManageChild (temp);
 782    XmStringFree (label_string);
 783    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 784                   (XtPointer) preferences_rec);
 785    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 786                  HELP_PREFERENCES_DIRECTION_STR);
 787
 788
 789    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(23, 17, "Descending")));
 790
 791    n = 0;
 792    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 793    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 794    XtSetArg (args[n], XmNtopWidget, temp);                      n++;
 795    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 796    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 797    XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY);         n++;
 798    preferences_rec->direction_descending = temp =
 799       XmCreateToggleButtonGadget (group_form, "descending", args, n);
 800    XtManageChild (temp);
 801    XmStringFree (label_string);
 802    XtAddCallback (temp, XmNvalueChangedCallback, ToggleCallback,
 803                   (XtPointer) preferences_rec);
 804    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 805                  HELP_PREFERENCES_DIRECTION_STR);
 806
 807
 808    /*  Create a separator between the buttons  */
 809
 810    n = 0;
 811    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 812    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
 813    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 814    XtSetArg (args[n], XmNtopWidget, order_frame);               n++;
 815    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 816    separator =  XmCreateSeparatorGadget (form, "separator", args, n);
 817    XtManageChild (separator);
 818
 819
 820    /*  Create the ok, apply, reset, cancel and help buttons  */
 821
 822    n = 0;
 823    XtSetArg (args[n], XmNlabelString, okXmString);              n++;
 824    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 825    XtSetArg (args[n], XmNleftPosition, 1);                      n++;
 826    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 827    XtSetArg (args[n], XmNrightPosition, 19);                    n++;
 828    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 829    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 830    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 831    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 832    XtSetArg (args[n], XmNbottomOffset, offset);                 n++;
 833    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
 834    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 835    preferences_rec->ok = temp =
 836       XmCreatePushButtonGadget (form, "ok", args, n);
 837    XtManageChild (temp);
 838    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 839                  HELP_PREFERENCES_DIALOG_STR);
 840
 841    n = 0;
 842    XtSetArg (args[n], XmNlabelString, applyXmString);           n++;
 843    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 844    XtSetArg (args[n], XmNleftPosition, 21);                     n++;
 845    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 846    XtSetArg (args[n], XmNrightPosition, 39);                    n++;
 847    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 848    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 849    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 850    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 851    XtSetArg (args[n], XmNbottomOffset, offset);                 n++;
 852    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
 853    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 854    preferences_rec->apply = temp =
 855       XmCreatePushButtonGadget (form, "apply", args, n);
 856    XtManageChild (temp);
 857    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 858                  HELP_PREFERENCES_DIALOG_STR);
 859
 860
 861    label_string = XmStringCreateLocalized ((GETMESSAGE(23,30, "Defaults")));
 862
 863    n = 0;
 864    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 865    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 866    XtSetArg (args[n], XmNleftPosition, 41);                     n++;
 867    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 868    XtSetArg (args[n], XmNrightPosition, 59);                    n++;
 869    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 870    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 871    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 872    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 873    XtSetArg (args[n], XmNbottomOffset, offset);                 n++;
 874    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
 875    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 876    preferences_rec->reset = temp =
 877       XmCreatePushButtonGadget (form, "defaults", args, n);
 878    XmStringFree (label_string);
 879    XtManageChild (temp);
 880    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 881                  HELP_PREFERENCES_DIALOG_STR);
 882    XtAddCallback (temp, XmNactivateCallback, ResetCallback,
 883                   (XtPointer) preferences_rec);
 884
 885
 886    n = 0;
 887    XtSetArg (args[n], XmNlabelString, cancelXmString);          n++;
 888    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 889    XtSetArg (args[n], XmNleftPosition, 61);                     n++;
 890    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 891    XtSetArg (args[n], XmNrightPosition, 79);                    n++;
 892    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 893    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 894    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 895    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 896    XtSetArg (args[n], XmNbottomOffset, offset);                 n++;
 897    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
 898    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 899    preferences_rec->close = temp =
 900       XmCreatePushButtonGadget (form, "close", args, n);
 901    XtManageChild (temp);
 902    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 903                  HELP_PREFERENCES_DIALOG_STR);
 904
 905
 906    n = 0;
 907    XtSetArg (args[n], XmNlabelString, helpXmString);            n++;
 908    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 909    XtSetArg (args[n], XmNleftPosition, 81);                     n++;
 910    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 911    XtSetArg (args[n], XmNrightPosition, 99);                    n++;
 912    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 913    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 914    XtSetArg (args[n], XmNtopOffset, offset);                    n++;
 915    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 916    XtSetArg (args[n], XmNbottomOffset, offset);                 n++;
 917    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
 918    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 919    preferences_rec->help = temp =
 920       XmCreatePushButtonGadget (form, "help", args, n);
 921    XtManageChild (temp);
 922    XtAddCallback(temp, XmNactivateCallback, (XtCallbackProc)HelpRequestCB,
 923                  HELP_PREFERENCES_DIALOG_STR);
 924    XtAddCallback(temp, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 925                  HELP_PREFERENCES_DIALOG_STR);
 926
 927
 928    XtSetArg (args[0], XmNcancelButton, preferences_rec->close);
 929    XtSetArg (args[1], XmNdefaultButton, preferences_rec->ok);
 930    XtSetValues (form, args, 2);
 931
 932
 933    /*  Set the return values for the dialog widget and dialog instance.  */
 934
 935    *return_widget = form;
 936    *dialog = (XtPointer) preferences_rec;
 937 }
 938
 939
 940
 941
 942 /************************************************************************
 943  *
 944  *  InstallChange
 945  *
 946  ************************************************************************/
 947
 948 static void
 949 InstallChange(
 950         PreferencesRec *preferences_rec,
 951         XtCallbackProc callback,
 952         XtPointer client_data )
 953 {
 954    PreferencesApply * apply_data;
 955
 956
 957    /*  Setup the callback data to be sent to the Ok callback.   */
 958    /*  This contains the encapsulation callback to invoke upon  */
 959    /*  the data within the dialog being changed.                */
 960
 961    apply_data = (PreferencesApply *) XtMalloc (sizeof (PreferencesApply));
 962    apply_data->callback = callback;
 963    apply_data->client_data = client_data;
 964    apply_data->preferences_rec = (XtPointer) preferences_rec;
 965    preferences_rec->apply_data = apply_data;
 966
 967
 968    /*  Add the callbacks for list item insertion.  */
 969
 970    XtAddCallback (preferences_rec->apply, XmNactivateCallback,
 971                   (XtCallbackProc)ApplyCallback, (XtPointer) apply_data);
 972
 973    XtAddCallback (preferences_rec->ok, XmNactivateCallback,
 974                   (XtCallbackProc)OkCallback, (XtPointer) apply_data);
 975 }
 976
 977
 978
 979
 980 /************************************************************************
 981  *
 982  *  InstallClose
 983  *
 984  ************************************************************************/
 985
 986 static void
 987 InstallClose(
 988         PreferencesRec *preferences_rec,
 989         XtCallbackProc callback,
 990         XtPointer client_data )
 991 {
 992    Atom delete_window_atom;
 993
 994    XtAddCallback (preferences_rec->close,
 995                   XmNactivateCallback, callback, client_data);
 996
 997    delete_window_atom = XmInternAtom (XtDisplay(preferences_rec->shell),
 998                                       "WM_DELETE_WINDOW", True);
 999    XmRemoveWMProtocols( preferences_rec->shell, &delete_window_atom, 1 );
1000    XmAddWMProtocolCallback( preferences_rec->shell, delete_window_atom,
1001                             callback, (XtPointer) client_data );
1002 }
1003
1004
1005
1006
1007 /************************************************************************
1008  *
1009  *  Destroy
1010  *
1011  ************************************************************************/
1012
1013 static void
1014 Destroy(
1015         PreferencesRec *preferences_rec )
1016 {
1017    XtDestroyWidget (preferences_rec->shell);
1018    XtFree ((char *) preferences_rec->apply_data);
1019    XtFree ((char *) preferences_rec);
1020 }
1021
1022
1023
1024
1025 /************************************************************************
1026  *
1027  *  GetValues
1028  *
1029  ************************************************************************/
1030
1031 static XtPointer
1032 GetValues(
1033         PreferencesRec *preferences_rec )
1034 {
1035    PreferencesData * preferences_data;
1036    Arg args[4];
1037
1038
1039    /*  Allocate and initialize the change dir dialog data.  */
1040
1041    preferences_data = (PreferencesData *) XtMalloc (sizeof (PreferencesData));
1042
1043    preferences_data->displayed = True;
1044
1045    XtSetArg (args[0], XmNx, &preferences_data->x);
1046    XtSetArg (args[1], XmNy, &preferences_data->y);
1047    XtSetArg (args[2], XmNwidth, &preferences_data->width);
1048    XtSetArg (args[3], XmNheight, &preferences_data->height);
1049    XtGetValues (preferences_rec->shell, args, 4);
1050
1051    GetPreferencesValues (preferences_rec, preferences_data);
1052
1053    return ((XtPointer) preferences_data);
1054 }
1055
1056
1057
1058
1059 /************************************************************************
1060  *
1061  *  GetDefaultValues
1062  *
1063  ************************************************************************/
1064
1065 static XtPointer
1066 GetDefaultValues( void )
1067 {
1068    PreferencesData * preferences_data;
1069
1070    /*  Allocate and initialize the default change dir dialog data.  */
1071
1072    preferences_data = (PreferencesData *) XtMalloc (sizeof (PreferencesData));
1073
1074    preferences_data->displayed = False;
1075    preferences_data->x = 0;
1076    preferences_data->y = 0;
1077    preferences_data->height = 0;
1078    preferences_data->width = 0;
1079
1080    preferences_data->show_type = SINGLE_DIRECTORY;
1081    preferences_data->tree_files = TREE_FILES_NEVER;
1082    preferences_data->view_single = BY_NAME_AND_ICON;
1083    preferences_data->view_tree = BY_NAME_AND_SMALL_ICON;
1084    preferences_data->order = ORDER_BY_ALPHABETICAL;
1085    preferences_data->direction = DIRECTION_ASCENDING;
1086    preferences_data->positionEnabled = RANDOM_OFF;
1087
1088    return ((XtPointer) preferences_data);
1089 }
1090
1091
1092
1093
1094 /************************************************************************
1095  *
1096  *  GetResourceValues
1097  *
1098  ************************************************************************/
1099
1100 static XtPointer
1101 GetResourceValues(
1102         XrmDatabase data_base,
1103         char **name_list )
1104 {
1105    PreferencesData * preferences_data;
1106
1107
1108    /*  Allocate and get the resources for change dir dialog data.  */
1109
1110    preferences_data = (PreferencesData *) XtMalloc (sizeof (PreferencesData));
1111
1112    _DtDialogGetResources (data_base, name_list, PreferencesName,
1113                        (char *)preferences_data, resources,
1114                        preferencesClass->resource_count);
1115
1116    return ((XtPointer) preferences_data);
1117 }
1118
1119
1120
1121
1122 /************************************************************************
1123  *
1124  *  SetValues
1125  *
1126  ************************************************************************/
1127
1128 static void
1129 SetValues(
1130         PreferencesRec *preferences_rec,
1131         PreferencesData *preferences_data )
1132 {
1133    Arg true_args[1];
1134    Arg false_args[1];
1135    unsigned char *viewP;
1136
1137
1138    XtSetArg (true_args[0], XmNset, True);
1139    XtSetArg (false_args[0], XmNset, False);
1140
1141    if (preferences_data->show_type == SINGLE_DIRECTORY)
1142    {
1143       XtSetValues (preferences_rec->show_single, true_args, 1);
1144       XtSetValues (preferences_rec->show_multiple, false_args, 1);
1145       if( trashFileMgrData
1146           &&(PreferencesData *)trashFileMgrData->preferences->data ==
1147                                                          preferences_data)
1148          XtSetSensitive (XtParent (preferences_rec->show_multiple), False);
1149       else
1150          XtSetSensitive (XtParent (preferences_rec->show_multiple), True);
1151
1152       XtSetSensitive (preferences_rec->tree_files_never, False);
1153       XtSetSensitive (preferences_rec->tree_files_choose, False);
1154       XtSetSensitive (preferences_rec->tree_files_always, False);
1155       viewP = &preferences_data->view_single;
1156
1157       if (*viewP == BY_ATTRIBUTES)
1158          XtSetSensitive (XtParent (preferences_rec->random_on), False);
1159       else
1160          XtSetSensitive (XtParent (preferences_rec->random_on), True);
1161
1162    }
1163    else
1164    {
1165       XtSetValues (preferences_rec->show_single, false_args, 1);
1166       XtSetValues (preferences_rec->show_multiple, true_args, 1);
1167       XtSetSensitive (XtParent (preferences_rec->random_on), False);
1168       XtSetSensitive (preferences_rec->tree_files_never, True);
1169       XtSetSensitive (preferences_rec->tree_files_choose, True);
1170       XtSetSensitive (preferences_rec->tree_files_always, True);
1171       viewP = &preferences_data->view_tree;
1172    }
1173
1174    if (preferences_data->tree_files == TREE_FILES_NEVER)
1175    {
1176       XtSetValues (preferences_rec->tree_files_never, true_args, 1);
1177       XtSetValues (preferences_rec->tree_files_choose, false_args, 1);
1178       XtSetValues (preferences_rec->tree_files_always, false_args, 1);
1179    }
1180    else if (preferences_data->tree_files == TREE_FILES_CHOOSE)
1181    {
1182       XtSetValues (preferences_rec->tree_files_never, false_args, 1);
1183       XtSetValues (preferences_rec->tree_files_choose, true_args, 1);
1184       XtSetValues (preferences_rec->tree_files_always, false_args, 1);
1185    }
1186    else /* preferences_data->tree_files == TREE_FILES_ALWAYS */
1187    {
1188       XtSetValues (preferences_rec->tree_files_never, false_args, 1);
1189       XtSetValues (preferences_rec->tree_files_choose, false_args, 1);
1190       XtSetValues (preferences_rec->tree_files_always, true_args, 1);
1191    }
1192
1193    preferences_rec->view_single = preferences_data->view_single;
1194    preferences_rec->view_tree = preferences_data->view_tree;
1195
1196    if (*viewP == BY_NAME)
1197    {
1198       XtSetValues (preferences_rec->by_name, true_args, 1);
1199       XtSetValues (preferences_rec->by_name_and_icon, false_args, 1);
1200       XtSetValues (preferences_rec->by_name_and_small_icon, false_args, 1);
1201       XtSetValues (preferences_rec->by_attributes, false_args, 1);
1202    }
1203    else if (*viewP == BY_NAME_AND_ICON)
1204    {
1205       XtSetValues (preferences_rec->by_name, false_args, 1);
1206       XtSetValues (preferences_rec->by_name_and_icon, true_args, 1);
1207       XtSetValues (preferences_rec->by_name_and_small_icon, false_args, 1);
1208       XtSetValues (preferences_rec->by_attributes, false_args, 1);
1209    }
1210    else if (*viewP == BY_NAME_AND_SMALL_ICON)
1211    {
1212       XtSetValues (preferences_rec->by_name, false_args, 1);
1213       XtSetValues (preferences_rec->by_name_and_icon, false_args, 1);
1214       XtSetValues (preferences_rec->by_name_and_small_icon, true_args, 1);
1215       XtSetValues (preferences_rec->by_attributes, false_args, 1);
1216    }
1217    else if (*viewP == BY_ATTRIBUTES)
1218    {
1219       XtSetValues (preferences_rec->by_name, false_args, 1);
1220       XtSetValues (preferences_rec->by_name_and_icon, false_args, 1);
1221       XtSetValues (preferences_rec->by_name_and_small_icon, false_args, 1);
1222       XtSetValues (preferences_rec->by_attributes, true_args, 1);
1223    }
1224
1225    if (preferences_data->order == ORDER_BY_FILE_TYPE)
1226    {
1227       XtSetValues (preferences_rec->order_file_type, true_args, 1);
1228       XtSetValues (preferences_rec->order_alphabetical, false_args, 1);
1229       XtSetValues (preferences_rec->order_date, false_args, 1);
1230       XtSetValues (preferences_rec->order_size, false_args, 1);
1231    }
1232    else if (preferences_data->order == ORDER_BY_ALPHABETICAL)
1233    {
1234       XtSetValues (preferences_rec->order_file_type, false_args, 1);
1235       XtSetValues (preferences_rec->order_alphabetical, true_args, 1);
1236       XtSetValues (preferences_rec->order_date, false_args, 1);
1237       XtSetValues (preferences_rec->order_size, false_args, 1);
1238    }
1239    else if (preferences_data->order == ORDER_BY_DATE)
1240    {
1241       XtSetValues (preferences_rec->order_file_type, false_args, 1);
1242       XtSetValues (preferences_rec->order_alphabetical, false_args, 1);
1243       XtSetValues (preferences_rec->order_date, true_args, 1);
1244       XtSetValues (preferences_rec->order_size, false_args, 1);
1245    }
1246    else if (preferences_data->order == ORDER_BY_SIZE)
1247    {
1248       XtSetValues (preferences_rec->order_file_type, false_args, 1);
1249       XtSetValues (preferences_rec->order_alphabetical, false_args, 1);
1250       XtSetValues (preferences_rec->order_date, false_args, 1);
1251       XtSetValues (preferences_rec->order_size, true_args, 1);
1252    }
1253
1254    if (preferences_data->direction == DIRECTION_ASCENDING)
1255    {
1256       XtSetValues (preferences_rec->direction_ascending, true_args, 1);
1257       XtSetValues (preferences_rec->direction_descending, false_args, 1);
1258    }
1259    if (preferences_data->direction == DIRECTION_DESCENDING)
1260    {
1261       XtSetValues (preferences_rec->direction_ascending, false_args, 1);
1262       XtSetValues (preferences_rec->direction_descending, true_args, 1);
1263    }
1264
1265    if (preferences_data->positionEnabled == RANDOM_ON)
1266    {
1267       XtSetValues (preferences_rec->random_on, true_args, 1);
1268       XtSetValues (preferences_rec->random_off, false_args, 1);
1269    }
1270    if (preferences_data->positionEnabled == RANDOM_OFF)
1271    {
1272       XtSetValues (preferences_rec->random_off, true_args, 1);
1273       XtSetValues (preferences_rec->random_on, false_args, 1);
1274    }
1275
1276    if( trashFileMgrData
1277        &&(PreferencesData *)trashFileMgrData->preferences->data ==
1278           preferences_data )
1279    {
1280      XtSetSensitive( preferences_rec->show_iconic_path, False );
1281      XtSetSensitive( preferences_rec->show_current_dir, False );
1282      XtSetSensitive( preferences_rec->show_status_line, False );
1283      XtSetSensitive( preferences_rec->random_on, False );
1284    }
1285    else if( showFilesystem )
1286    {
1287      XtSetSensitive( preferences_rec->show_iconic_path, True );
1288      XtSetSensitive( preferences_rec->show_current_dir, True );
1289      XtSetSensitive( preferences_rec->show_status_line, True );
1290      XtSetSensitive( preferences_rec->random_on, True );
1291
1292
1293      if (preferences_data->show_iconic_path)
1294        XtSetValues (preferences_rec->show_iconic_path, true_args, 1);
1295      else
1296        XtSetValues (preferences_rec->show_iconic_path, false_args, 1);
1297
1298      if (preferences_data->show_current_dir)
1299        XtSetValues (preferences_rec->show_current_dir, true_args, 1);
1300      else
1301        XtSetValues (preferences_rec->show_current_dir, false_args, 1);
1302
1303      if (preferences_data->show_status_line)
1304        XtSetValues (preferences_rec->show_status_line, true_args, 1);
1305      else
1306        XtSetValues (preferences_rec->show_status_line, false_args, 1);
1307    }
1308    else
1309    {
1310      XtSetSensitive( preferences_rec->show_iconic_path, False );
1311      XtSetSensitive( preferences_rec->show_current_dir, False );
1312      XtSetSensitive( preferences_rec->show_status_line, False );
1313      XtSetSensitive( preferences_rec->random_on, True );
1314    }
1315 }
1316
1317
1318
1319
1320 /************************************************************************
1321  *
1322  *  WriteResourceValues
1323  *
1324  ************************************************************************/
1325
1326 static void
1327 WriteResourceValues(
1328         DialogData *values,
1329         int fd,
1330         char **name_list )
1331 {
1332    PreferencesData * preferences_data = (PreferencesData *) values->data;
1333    PreferencesRec * preferences_rec;
1334    Arg args[2];
1335
1336
1337    /*  If the dialog is currently displayed, update the geometry  */
1338    /*  fields to their current values.                            */
1339
1340    if (preferences_data->displayed == True)
1341    {
1342       _DtGenericUpdateWindowPosition(values);
1343       preferences_rec = (PreferencesRec *) _DtGetDialogInstance (values);
1344    }
1345
1346    _DtDialogPutResources (fd, name_list, PreferencesName, values->data,
1347                        resources, preferencesClass->resource_count);
1348 }
1349
1350
1351
1352
1353 /************************************************************************
1354  *
1355  *  FreeValues
1356  *
1357  ************************************************************************/
1358
1359 static void
1360 FreeValues(
1361         PreferencesData *preferences_data )
1362 {
1363    XtFree ((char *) preferences_data);
1364 }
1365
1366
1367
1368
1369 /************************************************************************
1370  *
1371  *  ResetCallback
1372  *
1373  ************************************************************************/
1374
1375 static void
1376 ResetCallback(
1377         Widget w,
1378         XtPointer client_data,
1379         XtPointer call_data )
1380 {
1381    PreferencesRec * preferences_rec = (PreferencesRec *) client_data;
1382    DialogData * dialog_data;
1383    PreferencesData * preferences_data;
1384
1385    dialog_data = _DtGetInstanceData ((XtPointer)preferences_rec);
1386    preferences_data = (PreferencesData *) dialog_data->data;
1387
1388    preferences_data->show_type = SINGLE_DIRECTORY;
1389    preferences_data->tree_files = TREE_FILES_NEVER;
1390    preferences_data->view_single = BY_NAME_AND_ICON;
1391    preferences_data->view_tree = BY_NAME_AND_SMALL_ICON;
1392    preferences_data->order = ORDER_BY_ALPHABETICAL;
1393    preferences_data->direction = DIRECTION_ASCENDING;
1394    preferences_data->positionEnabled = RANDOM_OFF;
1395    preferences_data->show_iconic_path = True;
1396    preferences_data->show_current_dir = True;
1397    preferences_data->show_status_line = True;
1398
1399    /*  Get the current data for the dialog and redisplay.  */
1400
1401    SetValues  (preferences_rec, (PreferencesData *) dialog_data->data);
1402 }
1403
1404
1405
1406
1407 /************************************************************************
1408  *
1409  *  ToggleCallback
1410  *      Handle the one of many processing for the toggles.
1411  *
1412  ************************************************************************/
1413
1414 static void
1415 ToggleCallback(
1416         Widget w,
1417         XtPointer client_data,
1418         XtPointer call_data )
1419 {
1420    PreferencesRec * preferences_rec;
1421    DialogData * dialog_data;
1422    PreferencesData * preferences_data;
1423    Boolean set;
1424    unsigned char *viewP;
1425    Arg args[1];
1426    Arg false_args[1];
1427    Arg true_args[1];
1428    int tmp_view;
1429
1430
1431    preferences_rec = (PreferencesRec *) client_data;
1432    dialog_data = _DtGetInstanceData ((XtPointer)preferences_rec);
1433    preferences_data = (PreferencesData *) dialog_data->data;
1434
1435    XtSetArg (false_args[0], XmNset, False);
1436    XtSetArg (true_args[0], XmNset, True);
1437
1438    XtSetArg (args[0], XmNset, &set);
1439    XtGetValues (preferences_rec->show_multiple, args, 1);
1440    if (set)
1441      viewP = &preferences_rec->view_tree;
1442    else
1443      viewP = &preferences_rec->view_single;
1444
1445    if (w == preferences_rec->show_single)
1446    {
1447       XtSetValues (preferences_rec->show_multiple, false_args, 1);
1448       XtSetValues (preferences_rec->show_single, true_args, 1);
1449
1450       XtSetSensitive (XtParent (preferences_rec->random_on), True);
1451       XtSetSensitive (preferences_rec->tree_files_never, False);
1452       XtSetSensitive (preferences_rec->tree_files_choose, False);
1453       XtSetSensitive (preferences_rec->tree_files_always, False);
1454
1455       if (preferences_rec->view_single == BY_NAME)
1456          w = preferences_rec->by_name;
1457       else if (preferences_rec->view_single == BY_NAME_AND_ICON)
1458          w = preferences_rec->by_name_and_icon;
1459       else if (preferences_rec->view_single == BY_NAME_AND_SMALL_ICON)
1460          w = preferences_rec->by_name_and_small_icon;
1461       else
1462       {
1463          w = preferences_rec->by_attributes;
1464          XtSetSensitive (XtParent (preferences_rec->random_on), False);
1465       }
1466       showType = SINGLE_DIRECTORY;
1467       ToggleCallback (w, client_data, call_data);
1468    }
1469    else if (w == preferences_rec->show_multiple)
1470    {
1471       XtSetValues (preferences_rec->show_single, false_args, 1);
1472       XtSetValues (preferences_rec->show_multiple, true_args, 1);
1473
1474       XtSetSensitive (XtParent (preferences_rec->random_on), False);
1475       XtSetSensitive (preferences_rec->tree_files_never, True);
1476       XtSetSensitive (preferences_rec->tree_files_choose, True);
1477       XtSetSensitive (preferences_rec->tree_files_always, True);
1478
1479       if (preferences_rec->view_tree == BY_NAME)
1480          w = preferences_rec->by_name;
1481       else if (preferences_rec->view_tree == BY_NAME_AND_ICON)
1482          w = preferences_rec->by_name_and_icon;
1483       else if (preferences_rec->view_tree == BY_NAME_AND_SMALL_ICON)
1484          w = preferences_rec->by_name_and_small_icon;
1485       else
1486          w = preferences_rec->by_attributes;
1487
1488       showType = MULTIPLE_DIRECTORY;
1489       ToggleCallback (w, client_data, call_data);
1490    }
1491    else if (w == preferences_rec->tree_files_never)
1492    {
1493       XtSetValues (preferences_rec->tree_files_choose, false_args, 1);
1494       XtSetValues (preferences_rec->tree_files_always, false_args, 1);
1495       XtSetValues (preferences_rec->tree_files_never, true_args, 1);
1496    }
1497    else if (w == preferences_rec->tree_files_choose)
1498    {
1499       XtSetValues (preferences_rec->tree_files_never, false_args, 1);
1500       XtSetValues (preferences_rec->tree_files_always, false_args, 1);
1501       XtSetValues (preferences_rec->tree_files_choose, true_args, 1);
1502    }
1503    else if (w == preferences_rec->tree_files_always)
1504    {
1505       XtSetValues (preferences_rec->tree_files_never, false_args, 1);
1506       XtSetValues (preferences_rec->tree_files_choose, false_args, 1);
1507       XtSetValues (preferences_rec->tree_files_always, true_args, 1);
1508    }
1509    else if (w == preferences_rec->by_name)
1510    {
1511       if (showType == SINGLE_DIRECTORY)
1512          XtSetSensitive (XtParent (preferences_rec->random_on), True);
1513       XtSetValues (preferences_rec->by_name_and_icon, false_args, 1);
1514       XtSetValues (preferences_rec->by_name_and_small_icon, false_args, 1);
1515       XtSetValues (preferences_rec->by_attributes, false_args, 1);
1516       XtSetValues (preferences_rec->by_name, true_args, 1);
1517       *viewP = BY_NAME;
1518    }
1519    else if (w == preferences_rec->by_name_and_icon)
1520    {
1521       if (showType == SINGLE_DIRECTORY)
1522          XtSetSensitive (XtParent (preferences_rec->random_on), True);
1523       XtSetValues (preferences_rec->by_name, false_args, 1);
1524       XtSetValues (preferences_rec->by_name_and_small_icon, false_args, 1);
1525       XtSetValues (preferences_rec->by_attributes, false_args, 1);
1526       XtSetValues (preferences_rec->by_name_and_icon, true_args, 1);
1527       *viewP = BY_NAME_AND_ICON;
1528    }
1529    else if (w == preferences_rec->by_name_and_small_icon)
1530    {
1531       if (showType == SINGLE_DIRECTORY)
1532          XtSetSensitive (XtParent (preferences_rec->random_on), True);
1533       XtSetValues (preferences_rec->by_name, false_args, 1);
1534       XtSetValues (preferences_rec->by_attributes, false_args, 1);
1535       XtSetValues (preferences_rec->by_name_and_icon, false_args, 1);
1536       XtSetValues (preferences_rec->by_name_and_small_icon, true_args, 1);
1537       *viewP = BY_NAME_AND_SMALL_ICON;
1538    }
1539    else if (w == preferences_rec->by_attributes)
1540    {
1541       XtSetSensitive (XtParent (preferences_rec->random_on), False);
1542       XtSetValues (preferences_rec->by_name, false_args, 1);
1543       XtSetValues (preferences_rec->by_name_and_icon, false_args, 1);
1544       XtSetValues (preferences_rec->by_name_and_small_icon, false_args, 1);
1545       XtSetValues (preferences_rec->by_attributes, true_args, 1);
1546       *viewP = BY_ATTRIBUTES;
1547    }
1548    else if (w == preferences_rec->order_file_type)
1549    {
1550       XtSetValues (preferences_rec->order_alphabetical, false_args, 1);
1551       XtSetValues (preferences_rec->order_date, false_args, 1);
1552       XtSetValues (preferences_rec->order_size, false_args, 1);
1553       XtSetValues (preferences_rec->order_file_type, true_args, 1);
1554    }
1555    else if (w == preferences_rec->order_alphabetical)
1556    {
1557       XtSetValues (preferences_rec->order_file_type, false_args, 1);
1558       XtSetValues (preferences_rec->order_date, false_args, 1);
1559       XtSetValues (preferences_rec->order_size, false_args, 1);
1560       XtSetValues (preferences_rec->order_alphabetical, true_args, 1);
1561    }
1562    else if (w == preferences_rec->order_date)
1563    {
1564       XtSetValues (preferences_rec->order_file_type, false_args, 1);
1565       XtSetValues (preferences_rec->order_alphabetical, false_args, 1);
1566       XtSetValues (preferences_rec->order_size, false_args, 1);
1567       XtSetValues (preferences_rec->order_date, true_args, 1);
1568    }
1569    else if (w == preferences_rec->order_size)
1570    {
1571       XtSetValues (preferences_rec->order_file_type, false_args, 1);
1572       XtSetValues (preferences_rec->order_alphabetical, false_args, 1);
1573       XtSetValues (preferences_rec->order_date, false_args, 1);
1574       XtSetValues (preferences_rec->order_size, true_args, 1);
1575    }
1576    else if (w == preferences_rec->direction_ascending)
1577    {
1578       XtSetValues (preferences_rec->direction_descending, false_args, 1);
1579       XtSetValues (preferences_rec->direction_ascending, true_args, 1);
1580    }
1581    else if (w == preferences_rec->direction_descending)
1582    {
1583       XtSetValues (preferences_rec->direction_ascending, false_args, 1);
1584       XtSetValues (preferences_rec->direction_descending, true_args, 1);
1585    }
1586    else if (w == preferences_rec->random_on)
1587    {
1588       XtSetValues (preferences_rec->random_off, false_args, 1);
1589       XtSetValues (preferences_rec->random_on, true_args, 1);
1590    }
1591    else if (w == preferences_rec->random_off)
1592    {
1593       XtSetValues (preferences_rec->random_on, false_args, 1);
1594       XtSetValues (preferences_rec->random_off, true_args, 1);
1595    }
1596 }
1597
1598
1599 /************************************************************************
1600  *
1601  *  OkCallback
1602  *      This is a callback function called when the (Ok) button
1603  *      is pressed.  It saves the new preverences data itnernally and
1604  *      then calls the encapsulations callback function.
1605  *
1606  ************************************************************************/
1607
1608 static void
1609 OkCallback(
1610         Widget w,
1611         PreferencesApply *apply_data,
1612         XtPointer call_data )
1613 {
1614    PreferencesRec * preferences_rec;
1615    DialogData * dialog_data;
1616
1617    ApplyCallback( w, apply_data, call_data);
1618
1619    preferences_rec = (PreferencesRec *) apply_data->preferences_rec;
1620    dialog_data = _DtGetInstanceData ((XtPointer)preferences_rec);
1621
1622    XtCallCallbacks(preferences_rec->close, XmNactivateCallback,
1623                                                  (XtPointer)dialog_data);
1624 }
1625
1626
1627 /************************************************************************
1628  *
1629  *  ApplyCallback
1630  *      This is a callback function called when the (Apply) button
1631  *      is pressed.  It saves the new preverences data itnernally and
1632  *      then calls the encapsulations callback funtion.
1633  *
1634  ************************************************************************/
1635
1636 static void
1637 ApplyCallback(
1638         Widget w,
1639         PreferencesApply *apply_data,
1640         XtPointer call_data )
1641 {
1642    (*(apply_data->callback)) (w, apply_data->client_data, NULL);
1643 }
1644
1645
1646
1647
1648 /************************************************************************
1649  *
1650  *  GetPreferencesValues
1651  *      Update the current preferences values within the data structure
1652  *      from the current toggle button values.
1653  *
1654  ************************************************************************/
1655
1656 static void
1657 GetPreferencesValues(
1658         PreferencesRec *preferences_rec,
1659         PreferencesData *preferences_data )
1660 {
1661    Boolean set;
1662    Arg args[2];
1663
1664    XtSetArg (args[0], XmNset, &set);
1665
1666    XtGetValues (preferences_rec->show_single, args, 1);
1667    if (set) preferences_data->show_type = SINGLE_DIRECTORY;
1668    XtGetValues (preferences_rec->show_multiple, args, 1);
1669    if (set) preferences_data->show_type = MULTIPLE_DIRECTORY;
1670
1671    preferences_data->view_single = preferences_rec->view_single;
1672    preferences_data->view_tree = preferences_rec->view_tree;
1673
1674    XtGetValues (preferences_rec->tree_files_never, args, 1);
1675    if (set) preferences_data->tree_files = TREE_FILES_NEVER;
1676    XtGetValues (preferences_rec->tree_files_choose, args, 1);
1677    if (set) preferences_data->tree_files = TREE_FILES_CHOOSE;
1678    XtGetValues (preferences_rec->tree_files_always, args, 1);
1679    if (set) preferences_data->tree_files = TREE_FILES_ALWAYS;
1680
1681    XtGetValues (preferences_rec->order_file_type, args, 1);
1682    if (set) preferences_data->order = ORDER_BY_FILE_TYPE;
1683    XtGetValues (preferences_rec->order_alphabetical, args, 1);
1684    if (set) preferences_data->order = ORDER_BY_ALPHABETICAL;
1685    XtGetValues (preferences_rec->order_date, args, 1);
1686    if (set) preferences_data->order = ORDER_BY_DATE;
1687    XtGetValues (preferences_rec->order_size, args, 1);
1688    if (set) preferences_data->order = ORDER_BY_SIZE;
1689
1690    XtGetValues (preferences_rec->direction_ascending, args, 1);
1691    if (set) preferences_data->direction = DIRECTION_ASCENDING;
1692    XtGetValues (preferences_rec->direction_descending, args, 1);
1693    if (set) preferences_data->direction = DIRECTION_DESCENDING;
1694
1695    XtGetValues (preferences_rec->random_on, args, 1);
1696    if (set) preferences_data->positionEnabled = RANDOM_ON;
1697    XtGetValues (preferences_rec->random_off, args, 1);
1698    if (set) preferences_data->positionEnabled = RANDOM_OFF;
1699
1700    XtGetValues (preferences_rec->show_iconic_path, args, 1);
1701    preferences_data->show_iconic_path = set;
1702    XtGetValues (preferences_rec->show_current_dir, args, 1);
1703    preferences_data->show_current_dir = set;
1704    XtGetValues (preferences_rec->show_status_line, args, 1);
1705    preferences_data->show_status_line = set;
1706 }
1707
1708
1709
1710
1711 /************************************************************************
1712  *
1713  *  ShowTypeToString
1714  *      Convert the show type to a string and write it out.
1715  *
1716  ***********************************************************************/
1717
1718 void
1719 ShowTypeToString(
1720         int fd,
1721         unsigned char *value,
1722         char *out_buf )
1723 {
1724    char * buf;
1725
1726    if (*value == SINGLE_DIRECTORY)
1727       buf = Single_directory;
1728    else if (*value == MULTIPLE_DIRECTORY)
1729       buf = DirectoryTree;
1730
1731    _DtStringToString(fd, (char **)&buf, out_buf);
1732 }
1733
1734
1735
1736
1737 /************************************************************************
1738  *
1739  *  StringToShowType
1740  *      Convert string to a show type.
1741  *
1742  ************************************************************************/
1743
1744 void
1745 StringToShowType(
1746         XrmValuePtr args,
1747         Cardinal *num_args,
1748         XrmValue *from_val,
1749         XrmValue *to_val )
1750 {
1751    char * in_str = (char *)(from_val->addr);
1752    static unsigned char i;
1753
1754    to_val->size = sizeof (unsigned char);
1755    to_val->addr = (XtPointer) &i;
1756
1757    if (_DtStringsAreEquivalent (in_str, Single_directory))
1758       i = SINGLE_DIRECTORY;
1759    else if (_DtStringsAreEquivalent (in_str, DirectoryTree))
1760       i = MULTIPLE_DIRECTORY;
1761    else
1762    {
1763       to_val->size = 0;
1764       to_val->addr = NULL;
1765       XtStringConversionWarning ((char *)from_val->addr, SHOW_TYPE);
1766    }
1767 }
1768
1769
1770
1771
1772 /************************************************************************
1773  *
1774  *  TreeFilesToString
1775  *      Convert the tree-files option to a string and write it out.
1776  *
1777  ***********************************************************************/
1778
1779 void
1780 TreeFilesToString(
1781         int fd,
1782         unsigned char *value,
1783         char *out_buf )
1784 {
1785    char * buf;
1786
1787    if (*value == TREE_FILES_NEVER)
1788       buf = Tree_files_never;
1789    else if (*value == TREE_FILES_CHOOSE)
1790       buf = Tree_files_choose;
1791    else if (*value == TREE_FILES_ALWAYS)
1792       buf = Tree_files_always;
1793
1794    _DtStringToString(fd, (char **)&buf, out_buf);
1795 }
1796
1797
1798
1799
1800 /************************************************************************
1801  *
1802  *  StringToTreeFiles
1803  *      Convert string to a tree-files option.
1804  *
1805  ************************************************************************/
1806
1807 void
1808 StringToTreeFiles(
1809         XrmValuePtr args,
1810         Cardinal *num_args,
1811         XrmValue *from_val,
1812         XrmValue *to_val )
1813 {
1814    char * in_str = (char *)(from_val->addr);
1815    static unsigned char i;
1816
1817    to_val->size = sizeof (unsigned char);
1818    to_val->addr = (XtPointer) &i;
1819
1820    if (_DtStringsAreEquivalent (in_str, Tree_files_never))
1821       i = TREE_FILES_NEVER;
1822    else if (_DtStringsAreEquivalent (in_str, Tree_files_choose))
1823       i = TREE_FILES_CHOOSE;
1824    else if (_DtStringsAreEquivalent (in_str, Tree_files_always))
1825       i = TREE_FILES_ALWAYS;
1826    else
1827    {
1828       to_val->size = 0;
1829       to_val->addr = NULL;
1830       XtStringConversionWarning ((char *)from_val->addr, TREE_FILES);
1831    }
1832 }
1833
1834
1835
1836
1837 /************************************************************************
1838  *
1839  *  ViewToString
1840  *      Convert the view mode to a string and write it out.
1841  *
1842  ***********************************************************************/
1843
1844 void
1845 ViewToString(
1846         int fd,
1847         unsigned char *value,
1848         char *out_buf )
1849 {
1850    char * buf;
1851
1852    if (*value == BY_NAME)
1853       buf = By_name;
1854    else if (*value == BY_NAME_AND_ICON)
1855       buf = By_name_and_icon;
1856    else if (*value == BY_NAME_AND_SMALL_ICON)
1857       buf = By_name_and_small_icon;
1858    else if (*value == BY_ATTRIBUTES)
1859       buf = By_attributes;
1860
1861    _DtStringToString(fd, (char **)&buf, out_buf);
1862 }
1863
1864
1865
1866
1867 /************************************************************************
1868  *
1869  *  StringToView
1870  *      Convert string to a viewing mode.
1871  *
1872  ************************************************************************/
1873
1874 void
1875 StringToView(
1876         XrmValuePtr args,
1877         Cardinal *num_args,
1878         XrmValue *from_val,
1879         XrmValue *to_val )
1880 {
1881    char * in_str = (char *)(from_val->addr);
1882    static unsigned char i;
1883
1884    to_val->size = sizeof (unsigned char);
1885    to_val->addr = (XtPointer) &i;
1886
1887    if (_DtStringsAreEquivalent (in_str, By_name))
1888       i = BY_NAME;
1889    else if (_DtStringsAreEquivalent (in_str, By_name_and_icon))
1890       i = BY_NAME_AND_ICON;
1891    else if (_DtStringsAreEquivalent (in_str, By_name_and_small_icon))
1892       i = BY_NAME_AND_SMALL_ICON;
1893    else if (_DtStringsAreEquivalent (in_str, By_attributes))
1894       i = BY_ATTRIBUTES;
1895    else
1896    {
1897       to_val->size = 0;
1898       to_val->addr = NULL;
1899       XtStringConversionWarning ((char *)from_val->addr, VIEW);
1900    }
1901 }
1902
1903
1904
1905
1906
1907 /************************************************************************
1908  *
1909  *  OrderToString
1910  *      Convert the viewing order to a string and write it out.
1911  *
1912  ***********************************************************************/
1913
1914 void
1915 OrderToString(
1916         int fd,
1917         unsigned char *value,
1918         char *out_buf )
1919 {
1920    char * buf;
1921
1922    if (*value == ORDER_BY_FILE_TYPE)
1923       buf = Order_by_file_type;
1924    else if (*value == ORDER_BY_ALPHABETICAL)
1925       buf = Order_by_alphabetical;
1926    else if (*value == ORDER_BY_DATE)
1927       buf = Order_by_date;
1928    else if (*value == ORDER_BY_SIZE)
1929       buf = Order_by_size;
1930
1931    _DtStringToString(fd, (char **)&buf, out_buf);
1932 }
1933
1934
1935
1936
1937 /************************************************************************
1938  *
1939  *  StringToOrder
1940  *      Convert string to a view order.
1941  *
1942  ************************************************************************/
1943
1944 void
1945 StringToOrder(
1946         XrmValuePtr args,
1947         Cardinal *num_args,
1948         XrmValue *from_val,
1949         XrmValue *to_val )
1950 {
1951    char * in_str = (char *)(from_val->addr);
1952    static unsigned char i;
1953
1954    to_val->size = sizeof (unsigned char);
1955    to_val->addr = (XtPointer) &i;
1956
1957    if (_DtStringsAreEquivalent (in_str, Order_by_file_type))
1958       i = ORDER_BY_FILE_TYPE;
1959    else if (_DtStringsAreEquivalent (in_str, Order_by_alphabetical))
1960       i = ORDER_BY_ALPHABETICAL;
1961    else if (_DtStringsAreEquivalent (in_str, Order_by_date))
1962       i = ORDER_BY_DATE;
1963    else if (_DtStringsAreEquivalent (in_str, Order_by_size))
1964       i = ORDER_BY_SIZE;
1965    else
1966    {
1967       to_val->size = 0;
1968       to_val->addr = NULL;
1969       XtStringConversionWarning ((char *)from_val->addr, DIRECTION_RESRC);
1970    }
1971 }
1972
1973
1974
1975
1976 /************************************************************************
1977  *
1978  *  DirectionToString
1979  *      Convert the ordering direction to a string and write it out.
1980  *
1981  ***********************************************************************/
1982
1983 void
1984 DirectionToString(
1985         int fd,
1986         unsigned char *value,
1987         char *out_buf )
1988 {
1989    char * buf;
1990
1991    if (*value == DIRECTION_ASCENDING)
1992       buf = Direction_ascending;
1993    else if (*value == DIRECTION_DESCENDING)
1994       buf = Direction_descending;
1995
1996    _DtStringToString(fd, (char **)&buf, out_buf);
1997 }
1998
1999
2000 /************************************************************************
2001  *
2002  *  RandomToString
2003  *      Convert the random placement to a string and write it out.
2004  *
2005  ***********************************************************************/
2006
2007 void
2008 RandomToString(
2009         int fd,
2010         unsigned char *value,
2011         char *out_buf )
2012 {
2013    char * buf;
2014
2015    if (*value == RANDOM_ON)
2016       buf = Random_on;
2017    else if (*value == RANDOM_OFF)
2018       buf = Random_off;
2019
2020    _DtStringToString(fd, (char **)&buf, out_buf);
2021 }
2022
2023
2024 /************************************************************************
2025  *
2026  *  StringToDirection
2027  *      Convert string to a view ordering direction.
2028  *
2029  ************************************************************************/
2030
2031 void
2032 StringToDirection(
2033         XrmValuePtr args,
2034         Cardinal *num_args,
2035         XrmValue *from_val,
2036         XrmValue *to_val )
2037 {
2038    char * in_str = (char *)(from_val->addr);
2039    static unsigned char i;
2040
2041    to_val->size = sizeof (unsigned char);
2042    to_val->addr = (XtPointer) &i;
2043
2044    if (_DtStringsAreEquivalent (in_str, Direction_ascending))
2045       i = DIRECTION_ASCENDING;
2046    else if (_DtStringsAreEquivalent (in_str, Direction_descending))
2047       i = DIRECTION_DESCENDING;
2048    else
2049    {
2050       to_val->size = 0;
2051       to_val->addr = NULL;
2052       XtStringConversionWarning ((char *)from_val->addr, DIRECTION_RESRC);
2053    }
2054 }
2055
2056
2057 /************************************************************************
2058  *
2059  *  StringToRandom
2060  *      Convert string to either random placement on or off
2061  *
2062  ************************************************************************/
2063
2064 void
2065 StringToRandom(
2066         XrmValuePtr args,
2067         Cardinal *num_args,
2068         XrmValue *from_val,
2069         XrmValue *to_val )
2070 {
2071    char * in_str = (char *)(from_val->addr);
2072    static unsigned char i;
2073
2074    to_val->size = sizeof (unsigned char);
2075    to_val->addr = (XtPointer) &i;
2076
2077    if (_DtStringsAreEquivalent (in_str, Random_on))
2078       i = RANDOM_ON;
2079    else if (_DtStringsAreEquivalent (in_str, Random_off))
2080       i = RANDOM_OFF;
2081    else
2082    {
2083       to_val->size = 0;
2084       to_val->addr = NULL;
2085       XtStringConversionWarning ((char *)from_val->addr, RANDOM);
2086    }
2087 }