cde/programs/dtfile/Prefs.c

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