cde/programs/dtfile/Filter.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: Filter.c /main/8 1996/10/30 11:10:48 drk $ */
  24 /************************************<+>*************************************
  25  ****************************************************************************
  26  *
  27  *   FILE:           Filter.c
  28  *
  29  *   COMPONENT_NAME: Desktop File Manager (dtfile)
  30  *
  31  *   Description:    Source file for the file filter dialog.
  32  *
  33  *   FUNCTIONS: ApplyCallback
  34  *              Create
  35  *              DefaultCallback
  36  *              DeselectAllFilter
  37  *              Destroy
  38  *              FileTypeAscending
  39  *              FreeValues
  40  *              GetDefaultValues
  41  *              GetFilterValues
  42  *              GetResourceValues
  43  *              GetValues
  44  *              InstallChange
  45  *              InstallClose
  46  *              OkCallback
  47  *              ReadInFiletypes
  48  *              SelectAllFilter
  49  *              SetValues
  50  *              ShowHiddenFiles
  51  *              UpdateFilterAfterDBReread
  52  *              WriteResourceValues
  53  *              filterTypeChanged
  54  *
  55  *   (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
  56  *   (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
  57  *   (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
  58  *   (c) Copyright 1993, 1994, 1995 Novell, Inc.
  59  *
  60  ****************************************************************************
  61  ************************************<+>*************************************/
  62
  63
  64 #include <stdio.h>
  65 #include <time.h>
  66 #include <stdlib.h>
  67
  68 #include <Xm/XmP.h>
  69 #include <Xm/Xm.h>
  70 #include <Xm/DialogS.h>
  71 #include <Xm/DrawingA.h>
  72 #include <Xm/Form.h>
  73 #include <Xm/LabelG.h>
  74 #include <Xm/List.h>
  75 #include <Xm/MessageB.h>
  76 #include <Xm/PushBG.h>
  77 #include <Xm/RowColumn.h>
  78 #include <Xm/TextF.h>
  79 #include <Xm/ToggleBG.h>
  80 #include <Xm/ScrollBar.h>
  81 #include <Xm/ScrolledW.h>
  82 #include <Xm/SeparatoG.h>
  83 #include <Xm/VendorSEP.h>
  84 #include <Xm/MwmUtil.h>
  85 #include <Xm/Protocols.h>
  86
  87 #include <Dt/TitleBox.h>
  88 #include <Dt/Icon.h>
  89 #include <Dt/IconP.h>
  90 #include <Dt/IconFile.h>
  91
  92 #include <X11/ShellP.h>
  93 #include <X11/Shell.h>
  94 #include <X11/Xatom.h>
  95
  96 #include <Dt/DtP.h>
  97 #include <Dt/DtNlUtils.h>
  98 #include <Dt/Dts.h>
  99 #include <Dt/SharedProcs.h>
 100
 101 #include "Encaps.h"
 102 #include "SharedProcs.h"
 103
 104 #include "FileMgr.h"
 105 #include "Desktop.h"
 106 #include "Main.h"
 107 #include "Common.h"
 108 #include "Filter.h"
 109 #include "Help.h"
 110
 111 char **DtDtsDataTypeNames(void);
 112
 113 static char * FILE_FILTER = "FileFilter";
 114
 115
 116 static DialogResource resources[] =
 117 {
 118    { "matchFilter", XmRBoolean, sizeof(Boolean),
 119      XtOffset(FilterDataPtr, match_flag),
 120      (XtPointer) True, _DtBooleanToString },
 121
 122    { "name", XmRString, sizeof(String),
 123      XtOffset(FilterDataPtr, filter),
 124      (XtPointer) "", _DtStringToString },
 125
 126    { "showHidden", XmRBoolean, sizeof(Boolean),
 127      XtOffset(FilterDataPtr, show_hidden),
 128      (XtPointer) False, _DtBooleanToString },
 129
 130    { "filetypesFilteredCount", XmRInt, sizeof(int),
 131      XtOffset(FilterDataPtr, filetypesFilteredCount),
 132      (XtPointer) 3, _DtIntToString },
 133
 134    { "filetypesFiltered", XmRString, sizeof(String),
 135      XtOffset(FilterDataPtr, filetypesFiltered),
 136      (XtPointer) DEFAULT_FILTER, _DtStringToString },
 137 };
 138
 139
 140 #define FM_TYPE_LABEL  "TYPE_LABEL"
 141
 142 /********    Forward Function Declaration    ********/
 143 int ReadInFiletypes(FilterData *filter_data);
 144
 145 /********    Static Function Declarations    ********/
 146
 147 static void Create(
 148                         Display *display,
 149                         Widget parent,
 150                         Widget *return_widget,
 151                         XtPointer *dialog) ;
 152 static void InstallChange(
 153                         FilterRec *filter_rec,
 154                         XtCallbackProc callback,
 155                         XtPointer client_data) ;
 156 static void InstallClose(
 157                         FilterRec *filter_rec,
 158                         XtCallbackProc callback,
 159                         XtPointer client_data) ;
 160 static void Destroy(
 161                         FilterRec *filter_rec) ;
 162 static XtPointer GetValues(
 163                         FilterRec *filter_rec) ;
 164 static XtPointer GetDefaultValues( void ) ;
 165 static XtPointer GetResourceValues(
 166                         XrmDatabase data_base,
 167                         char **name_list) ;
 168 static void SetValues(
 169                         FilterRec *filter_rec,
 170                         FilterData *filter_data) ;
 171 static void WriteResourceValues(
 172                         DialogData *values,
 173                         int fd,
 174                         char **name_list) ;
 175 static void FreeValues(
 176                         FilterData *filter_data) ;
 177 static void DefaultCallback(
 178                         Widget w,
 179                         XtPointer client_data,
 180                         XtPointer call_data) ;
 181 static void CancelCallback(
 182                         Widget w,
 183                         XtPointer client_data,
 184                         XtPointer call_data) ;
 185 static void OkCallback(
 186                         Widget w,
 187                         XtPointer client_data,
 188                         XtPointer call_data) ;
 189 static void ApplyCallback(
 190                         Widget w,
 191                         XtPointer client_data,
 192                         XtPointer call_data) ;
 193 static Boolean GetFilterValues(
 194                         FilterRec *filter_rec,
 195                         FilterData *filter_data) ;
 196 static void filterTypeChanged(
 197                         Widget w,
 198                         XtPointer client_data,
 199                         XtPointer call_data ) ;
 200 static int FileTypeAscending(
 201                        FTData **t1,
 202                        FTData **t2 );
 203 static void SelectAllFilter(
 204                        Widget w,
 205                        XEvent *event,
 206                        String *params,
 207                        Cardinal *num_params );
 208 static void DeselectAllFilter(
 209                        Widget w,
 210                        XEvent *event,
 211                        String *params,
 212                        Cardinal *num_params );
 213 /********    End Static Function Declarations    ********/
 214
 215
 216
 217
 218 static DialogClass filterClassRec =
 219 {
 220    resources,
 221    XtNumber(resources),
 222    Create,
 223    (DialogInstallChangeProc) InstallChange,
 224    (DialogInstallCloseProc) InstallClose,
 225    (DialogDestroyProc) Destroy,
 226    (DialogGetValuesProc) GetValues,
 227    GetDefaultValues,
 228    GetResourceValues,
 229    (DialogSetValuesProc) SetValues,
 230    WriteResourceValues,
 231    (DialogFreeValuesProc) FreeValues,
 232    (DialogMapWindowProc) _DtGenericMapWindow,
 233    NULL,
 234 };
 235
 236 DialogClass * filterClass = (DialogClass *) &filterClassRec;
 237
 238 static XtActionsRec FilterAction[] = {
 239 { "SelectAllFilter", SelectAllFilter },
 240 { "DeselectAllFilter", DeselectAllFilter }
 241 };
 242
 243 static char FilterTranslationString[] = "\
 244 Ctrl<Key>slash:SelectAllFilter(@)\n\
 245 Ctrl<Key>backslash:DeselectAllFilter(@)";
 246
 247 /************************************************************************
 248  *
 249  *  Create
 250  *
 251  ************************************************************************/
 252
 253 static void
 254 Create(
 255         Display *display,
 256         Widget parent,
 257         Widget *return_widget,
 258         XtPointer *dialog )
 259 {
 260    FilterRec * filter_rec;
 261    Widget shell, form, fileNameFilter;
 262    Widget tog_frame, tog_form, fileTypeScrollWin, file_window;
 263    Widget labelPt2, hidden, separator, sel_form;
 264    Widget ok, apply, reset, close, help;
 265    Widget selectAll, unselectAll;
 266    Widget hiddenPulldown;
 267    XmString label_string;
 268    XtTranslations filterTranslationTable;
 269    int flag=FLAG_RESET;
 270
 271    Arg args[20];
 272    int n;
 273    char * tmpStr, * resolvedFilterTranslationString;
 274
 275    /*  Allocate the file filter dialog instance record.  */
 276    filter_rec = (FilterRec *) XtMalloc (sizeof (FilterRec));
 277
 278    /*  Create the shell and form used for the dialog.  */
 279    n = 0;
 280    XtSetArg (args[n], XmNmwmFunctions, MWM_FUNC_MOVE |
 281              MWM_FUNC_CLOSE);                                           ++n;
 282    XtSetArg (args[n], XmNmwmDecorations, MWM_DECOR_BORDER |
 283              MWM_DECOR_TITLE);                                          ++n;
 284    XtSetArg (args[n], XmNallowShellResize, True);                       ++n;
 285    shell = XmCreateDialogShell (parent, "filter_files", args, n);
 286
 287    /* Set the useAsyncGeo on the shell */
 288    XtSetArg (args[0], XmNuseAsyncGeometry, True);
 289    XtSetValues (XtParent(shell), args, 1);
 290
 291    n = 0;
 292    XtSetArg (args[n], XmNmarginWidth, 1);                               n++;
 293    XtSetArg (args[n], XmNmarginHeight, 1);                              n++;
 294    XtSetArg (args[n], XmNshadowThickness, 1);                           n++;
 295    XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);                     n++;
 296    XtSetArg (args[n], XmNautoUnmanage, False);                          n++;
 297    form = XmCreateForm (shell, "form", args, n);
 298    XtAddCallback(form, XmNhelpCallback, HelpRequestCB,
 299                  HELP_FILTER_DIALOG_STR);
 300
 301    XtAppAddActions( XtWidgetToApplicationContext(form),
 302                     FilterAction,
 303                     XtNumber(FilterAction));
 304    resolvedFilterTranslationString = ResolveTranslationString(
 305                                FilterTranslationString,
 306                                (char *)filter_rec );
 307    filterTranslationTable = XtParseTranslationTable(
 308                                resolvedFilterTranslationString );
 309    XtFree( resolvedFilterTranslationString );
 310     resolvedFilterTranslationString  = NULL;
 311    XtOverrideTranslations(form, filterTranslationTable);
 312
 313    hiddenPulldown = XmCreatePulldownMenu(form, "hiddenPD", args, 0);
 314
 315    label_string = XmStringCreateLocalized ((GETMESSAGE(13,27, "Shown")));
 316    XtSetArg(args[0], XmNmarginHeight, 1);
 317    XtSetArg(args[1], XmNmarginWidth, 1);
 318    XtSetArg(args[2], XmNlabelString, label_string);
 319    XtSetArg(args[3], XmNuserData, SHOWN);
 320    filter_rec->hidArray[SHOWN] =
 321                 XmCreatePushButtonGadget(hiddenPulldown, "shown", args, 4);
 322    XmStringFree(label_string);
 323    XtAddCallback(filter_rec->hidArray[SHOWN], XmNactivateCallback,
 324                                     filterTypeChanged, (XtPointer) filter_rec);
 325
 326    label_string = XmStringCreateLocalized ((GETMESSAGE(13,28, "Hidden")));
 327    XtSetArg(args[2], XmNlabelString, label_string);
 328    XtSetArg(args[3], XmNuserData, HIDDEN);
 329    filter_rec->hidArray[HIDDEN] =
 330                 XmCreatePushButtonGadget(hiddenPulldown, "hidden", args, 4);
 331    XmStringFree(label_string);
 332    XtAddCallback(filter_rec->hidArray[HIDDEN], XmNactivateCallback,
 333                                     filterTypeChanged, (XtPointer) filter_rec);
 334    XtManageChildren(filter_rec->hidArray, 2);
 335
 336    /* create the Option Menu and attach it to the Pulldown MenuPane */
 337    label_string = XmStringCreateLocalized ((GETMESSAGE(13,31,
 338                           "Select Datatypes to be:")));
 339    n = 0;
 340    XtSetArg (args[n], XmNlabelString, label_string);                  n++;
 341    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);              n++;
 342    XtSetArg (args[n], XmNleftOffset, 5);                              n++;
 343    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);               n++;
 344    XtSetArg (args[n], XmNtopOffset, 10);                              n++;
 345    XtSetArg (args[n], XmNsubMenuId, hiddenPulldown);                  n++;
 346    XtSetArg (args[n], XmNmenuHistory, filter_rec->hidArray[HIDDEN]);  n++;
 347    hidden = XmCreateOptionMenu(form, "file_name_label", args, n);
 348    XtManageChild (hidden);
 349    XmStringFree (label_string);
 350    XtAddCallback(hidden, XmNhelpCallback, HelpRequestCB,
 351                  HELP_FILTER_DIALOG_STR);
 352
 353    /* Create the Scrolled Window For the filetype display area   */
 354    /* and set the scrollbars colors correctly                    */
 355    n = 0;
 356    XtSetArg (args[n], XmNspacing, 2);                                   n++;
 357    XtSetArg (args[n], XmNscrollingPolicy, XmAUTOMATIC);                 n++;
 358    XtSetArg (args[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED);          n++;
 359    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);                n++;
 360    XtSetArg (args[n], XmNleftOffset, 10);                               n++;
 361    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);               n++;
 362    XtSetArg (args[n], XmNrightOffset, 10);                              n++;
 363    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 364    XtSetArg (args[n], XmNtopWidget, hidden);                            n++;
 365    XtSetArg (args[n], XmNtopOffset, 5);                                 n++;
 366    fileTypeScrollWin = XmCreateScrolledWindow(form, "filetypeSWin", args, n);
 367    XtManageChild (fileTypeScrollWin);
 368    XtAddCallback(fileTypeScrollWin, XmNhelpCallback, HelpRequestCB,
 369                  HELP_FILTER_DIALOG_STR);
 370
 371    /*  Create a drawing area as a child of the scrolled window  */
 372
 373    n = 0;
 374    XtSetArg (args[n], XmNmarginWidth, 4);                               n++;
 375    XtSetArg (args[n], XmNmarginHeight, 4);                              n++;
 376    XtSetArg (args[n], XmNresizePolicy, XmRESIZE_ANY);                   n++;
 377    file_window = XmCreateDrawingArea (fileTypeScrollWin, "file_window",
 378                                                                      args, n);
 379    XtManageChild (file_window);
 380
 381    n = 0;
 382    XtSetArg (args[n], XmNmarginWidth, 1);                               n++;
 383    XtSetArg (args[n], XmNmarginHeight, 1);                              n++;
 384    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 385    XtSetArg (args[n], XmNautoUnmanage, False);                          n++;
 386    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);                n++;
 387    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);               n++;
 388    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 389    XtSetArg (args[n], XmNtopWidget, fileTypeScrollWin);                 n++;
 390    XtSetArg (args[n], XmNtopOffset, 10);                                n++;
 391    sel_form = XmCreateForm (form, "sel_form", args, n);
 392    XtManageChild(sel_form);
 393
 394    label_string = XmStringCreateLocalized ((GETMESSAGE(13,21, "Select All")));
 395    n = 0;
 396    XtSetArg (args[n], XmNlabelString, label_string);                 n++;
 397    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);         n++;
 398    XtSetArg (args[n], XmNleftPosition, 15);                          n++;
 399    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);              n++;
 400    XtSetArg (args[n], XmNtopOffset, 5);                              n++;
 401    XtSetArg (args[n], XmNmarginHeight, 4);                           n++;
 402    XtSetArg (args[n], XmNmarginWidth, 10);                           n++;
 403    selectAll = XmCreatePushButtonGadget (sel_form, "selectAll", args, n);
 404    XtManageChild (selectAll);
 405    XtAddCallback (selectAll, XmNactivateCallback, SelectAllFileTypes,
 406                                                  (XtPointer) filter_rec);
 407    XtAddCallback(selectAll, XmNhelpCallback, HelpRequestCB,
 408                  HELP_FILTER_DIALOG_STR);
 409    XmStringFree (label_string);
 410    XtSetArg (args[0], XmNdefaultButton, selectAll);
 411    XtSetValues (sel_form, args, 1);
 412
 413    label_string = XmStringCreateLocalized ((GETMESSAGE(13,22, "Deselect All")));
 414    n = 0;
 415    XtSetArg (args[n], XmNlabelString, label_string);                    n++;
 416    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 417    XtSetArg (args[n], XmNleftPosition, 55);                             n++;
 418    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);                 n++;
 419    XtSetArg (args[n], XmNtopOffset, 5);                                 n++;
 420    XtSetArg (args[n], XmNmarginHeight, 4);                              n++;
 421    XtSetArg (args[n], XmNmarginWidth, 10);                              n++;
 422    unselectAll = XmCreatePushButtonGadget (sel_form, "deselectAll", args, n);
 423    XtManageChild (unselectAll);
 424    XtAddCallback (unselectAll, XmNactivateCallback, UnselectAllFileTypes,
 425                                                  (XtPointer) filter_rec);
 426    XtAddCallback(unselectAll, XmNhelpCallback, HelpRequestCB,
 427                  HELP_FILTER_DIALOG_STR);
 428    XmStringFree (label_string);
 429
 430    /*  Create the file name filter label and text fields.  */
 431    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(13,26,
 432                     "Also hide (Optional): ")));
 433    n = 0;
 434    XtSetArg (args[n], XmNlabelString, label_string);                    n++;
 435    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);                n++;
 436    XtSetArg (args[n], XmNleftOffset, 5);                                n++;
 437    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 438    XtSetArg (args[n], XmNtopWidget, sel_form);                          n++;
 439    XtSetArg (args[n], XmNtopOffset, 18);                                n++;
 440    XtSetArg (args[n], XmNtraversalOn, False);                           n++;
 441    labelPt2 = XmCreateLabelGadget (form, "file_name_label", args, n);
 442    XtManageChild (labelPt2);
 443    XmStringFree (label_string);
 444    XtAddCallback(labelPt2, XmNhelpCallback, HelpRequestCB,
 445                  HELP_FILTER_DIALOG_STR);
 446
 447
 448    n = 0;
 449    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);              n++;
 450    XtSetArg (args[n], XmNleftWidget, labelPt2);                         n++;
 451    XtSetArg (args[n], XmNleftOffset, 0);                                n++;
 452    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 453    XtSetArg (args[n], XmNtopWidget, sel_form);                          n++;
 454    XtSetArg (args[n], XmNtopOffset, 10);                                n++;
 455    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);               n++;
 456    XtSetArg (args[n], XmNrightOffset, 10);                              n++;
 457    fileNameFilter = XmCreateTextField (form, "file_name_text", args, n);
 458    XtManageChild (fileNameFilter);
 459    XtAddCallback(fileNameFilter, XmNhelpCallback, HelpRequestCB,
 460                  HELP_FILTER_DIALOG_STR);
 461
 462    /*  Create a separator between the buttons  */
 463
 464    n = 0;
 465    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);                n++;
 466    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);               n++;
 467    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 468    XtSetArg (args[n], XmNtopWidget, fileNameFilter);                    n++;
 469    XtSetArg (args[n], XmNtopOffset, 10);                                n++;
 470    separator =  XmCreateSeparatorGadget (form, "separator", args, n);
 471    XtManageChild (separator);
 472
 473
 474    /*  Create the ok, apply, reset, cancel and help buttons  */
 475
 476    n = 0;
 477    XtSetArg (args[n], XmNlabelString, okXmString);                      n++;
 478    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 479    XtSetArg (args[n], XmNleftPosition, 1);                              n++;
 480    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);           n++;
 481    XtSetArg (args[n], XmNrightPosition, 19);                            n++;
 482    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 483    XtSetArg (args[n], XmNtopWidget, separator);                         n++;
 484    XtSetArg (args[n], XmNtopOffset, 5);                                 n++;
 485    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);              n++;
 486    XtSetArg (args[n], XmNbottomOffset, 5);                              n++;
 487    XtSetArg (args[n], XmNmarginWidth, 4);                               n++;
 488    XtSetArg (args[n], XmNmarginHeight, 4);                              n++;
 489    XtSetArg (args[n], XmNmultiClick, XmMULTICLICK_DISCARD);             n++;
 490    XtSetArg (args[n], XmNuserData, flag);                        n++;
 491    ok = XmCreatePushButtonGadget (form, "ok", args, n);
 492    XtManageChild (ok);
 493    XtAddCallback(ok, XmNhelpCallback, HelpRequestCB,
 494                  HELP_FILTER_DIALOG_STR);
 495
 496    n = 0;
 497    XtSetArg (args[n], XmNlabelString, applyXmString);                   n++;
 498    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 499    XtSetArg (args[n], XmNleftPosition, 21);                             n++;
 500    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);           n++;
 501    XtSetArg (args[n], XmNrightPosition, 39);                            n++;
 502    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 503    XtSetArg (args[n], XmNtopWidget, separator);                         n++;
 504    XtSetArg (args[n], XmNtopOffset, 5);                                 n++;
 505    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);              n++;
 506    XtSetArg (args[n], XmNbottomOffset, 5);                              n++;
 507    XtSetArg (args[n], XmNmarginWidth, 4);                               n++;
 508    XtSetArg (args[n], XmNmarginHeight, 4);                              n++;
 509    apply = XmCreatePushButtonGadget (form, "apply", args, n);
 510    XtManageChild (apply);
 511    XtAddCallback(apply, XmNhelpCallback, HelpRequestCB,
 512                  HELP_FILTER_DIALOG_STR);
 513
 514    XtSetArg (args[0], XmNdefaultButton, apply);
 515    XtSetValues (form, args, 1);
 516
 517    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(13, 11, "Defaults")));
 518    n = 0;
 519    XtSetArg (args[n], XmNlabelString, label_string);                    n++;
 520    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 521    XtSetArg (args[n], XmNleftPosition, 41);                             n++;
 522    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);           n++;
 523    XtSetArg (args[n], XmNrightPosition, 59);                            n++;
 524    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 525    XtSetArg (args[n], XmNtopWidget, separator);                         n++;
 526    XtSetArg (args[n], XmNtopOffset, 5);                                 n++;
 527    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);              n++;
 528    XtSetArg (args[n], XmNbottomOffset, 5);                              n++;
 529    XtSetArg (args[n], XmNmarginWidth, 4);                               n++;
 530    XtSetArg (args[n], XmNmarginHeight, 4);                              n++;
 531    reset = XmCreatePushButtonGadget (form, "reset", args, n);
 532    XtManageChild (reset);
 533    XtAddCallback (reset, XmNactivateCallback, DefaultCallback, (XtPointer) filter_rec);
 534    XtAddCallback(reset, XmNhelpCallback, HelpRequestCB,
 535                  HELP_FILTER_DIALOG_STR);
 536    XmStringFree (label_string);
 537
 538
 539    n = 0;
 540    XtSetArg (args[n], XmNlabelString, cancelXmString);                  n++;
 541    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 542    XtSetArg (args[n], XmNleftPosition, 61);                             n++;
 543    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);           n++;
 544    XtSetArg (args[n], XmNrightPosition, 79);                            n++;
 545    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 546    XtSetArg (args[n], XmNtopWidget, separator);                         n++;
 547    XtSetArg (args[n], XmNtopOffset, 5);                                 n++;
 548    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);              n++;
 549    XtSetArg (args[n], XmNbottomOffset, 5);                              n++;
 550    XtSetArg (args[n], XmNmarginWidth, 4);                               n++;
 551    XtSetArg (args[n], XmNmarginHeight, 4);                              n++;
 552    XtSetArg (args[n], XmNmultiClick, XmMULTICLICK_DISCARD);             n++;
 553    XtSetArg (args[n], XmNuserData, flag );                              n++;
 554    close = XmCreatePushButtonGadget (form, "close", args, n);
 555    XtAddCallback (close, XmNactivateCallback, CancelCallback, (XtPointer) filter_rec);
 556    XtManageChild (close);
 557    XtAddCallback(close, XmNhelpCallback, HelpRequestCB,
 558                  HELP_FILTER_DIALOG_STR);
 559
 560
 561    n = 0;
 562    XtSetArg (args[n], XmNlabelString, helpXmString);                    n++;
 563    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 564    XtSetArg (args[n], XmNleftPosition, 81);                             n++;
 565    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);           n++;
 566    XtSetArg (args[n], XmNrightPosition, 99);                            n++;
 567    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 568    XtSetArg (args[n], XmNtopWidget, separator);                         n++;
 569    XtSetArg (args[n], XmNtopOffset, 5);                                 n++;
 570    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);              n++;
 571    XtSetArg (args[n], XmNbottomOffset, 5);                              n++;
 572    XtSetArg (args[n], XmNmarginWidth, 4);                               n++;
 573    XtSetArg (args[n], XmNmarginHeight, 4);                              n++;
 574    help = XmCreatePushButtonGadget (form, "help", args, n);
 575    XtManageChild (help);
 576    XtAddCallback(help, XmNactivateCallback, HelpRequestCB,
 577                  HELP_FILTER_DIALOG_STR);
 578    XtAddCallback(help, XmNhelpCallback, HelpRequestCB,
 579                  HELP_FILTER_DIALOG_STR);
 580
 581
 582    XtSetArg (args[0], XmNcancelButton, close);
 583    XtSetValues (form, args, 1);
 584
 585    /* Fill in our instance structure */
 586
 587    filter_rec->shell = shell;
 588    filter_rec->form = form;
 589    filter_rec->fileNameFilter = fileNameFilter;
 590    filter_rec->hidden = hidden;
 591    filter_rec->scrolled_window = fileTypeScrollWin;
 592    filter_rec->file_window = file_window;
 593    filter_rec->select_all = selectAll;
 594    filter_rec->unselect_all = unselectAll;
 595    filter_rec->label = labelPt2;
 596    filter_rec->cancel = 0x0;
 597    filter_rec->previous_filter_data = NULL;
 598
 599    filter_rec->ok = ok;
 600    filter_rec->apply = apply;
 601    filter_rec->reset = reset;
 602    filter_rec->close = close;
 603    filter_rec->help = help;
 604
 605    /*  Set the return values for the dialog widget and dialog instance.  */
 606
 607    *return_widget = form;
 608    *dialog = (XtPointer) filter_rec;
 609 }
 610
 611
 612
 613
 614 /************************************************************************
 615  *
 616  *  InstallChange
 617  *
 618  ************************************************************************/
 619
 620 static void
 621 InstallChange(
 622         FilterRec *filter_rec,
 623         XtCallbackProc callback,
 624         XtPointer client_data )
 625 {
 626    FilterApply * apply_data;
 627
 628
 629    /*  Setup the callback data to be sent to the Ok callback.   */
 630    /*  This contains the encapsulation callback to invoke upon  */
 631    /*  the data within the dialog being changed.                */
 632
 633    apply_data = (FilterApply *) XtMalloc (sizeof (FilterApply));
 634    apply_data->callback = callback;
 635    apply_data->client_data = client_data;
 636    apply_data->filter_rec = (XtPointer) filter_rec;
 637    filter_rec->apply_data = apply_data;
 638
 639
 640    XtAddCallback (filter_rec->apply, XmNactivateCallback,
 641                   ApplyCallback, (XtPointer) apply_data);
 642
 643    XtAddCallback (filter_rec->ok, XmNactivateCallback,
 644                   OkCallback, (XtPointer) apply_data);
 645 }
 646
 647
 648
 649
 650 /************************************************************************
 651  *
 652  *  InstallClose
 653  *
 654  ************************************************************************/
 655
 656 static void
 657 InstallClose(
 658         FilterRec *filter_rec,
 659         XtCallbackProc callback,
 660         XtPointer client_data )
 661 {
 662    Atom delete_window_atom;
 663
 664    XtAddCallback(filter_rec->close, XmNactivateCallback, callback, client_data);
 665
 666    delete_window_atom = XmInternAtom (XtDisplay(filter_rec->shell), "WM_DELETE_WINDOW", True);
 667    XmRemoveWMProtocols( filter_rec->shell, &delete_window_atom, 1 );
 668    XmAddWMProtocolCallback( filter_rec->shell, delete_window_atom, callback,
 669                             (XtPointer) client_data );
 670 }
 671
 672
 673
 674
 675 /************************************************************************
 676  *
 677  *  Destroy
 678  *
 679  ************************************************************************/
 680
 681 static void
 682 Destroy(
 683         FilterRec *filter_rec )
 684 {
 685    XtDestroyWidget (filter_rec->shell);
 686    XtFree ((char *) filter_rec->apply_data);
 687    XtFree ((char *) filter_rec);
 688 }
 689
 690
 691
 692
 693 /************************************************************************
 694  *
 695  *  GetValues
 696  *
 697  ************************************************************************/
 698
 699 static XtPointer
 700 GetValues(
 701         FilterRec *filter_rec )
 702 {
 703    FilterData * filter_data;
 704
 705   if( filter_rec->cancel
 706       && filter_rec->previous_filter_data )
 707   {
 708
 709     filter_data = filter_rec->previous_filter_data;
 710     filter_rec->previous_filter_data = NULL;
 711   }
 712   else
 713   {
 714     Arg args[4];
 715
 716     /*  Allocate and initialize the file filter dialog data.  */
 717
 718     filter_data = (FilterData *) XtMalloc (sizeof (FilterData));
 719
 720     filter_data->displayed = True;
 721
 722     XtSetArg (args[0], XmNx, &filter_data->x);
 723     XtSetArg (args[1], XmNy, &filter_data->y);
 724     XtSetArg (args[2], XmNwidth, &filter_data->width);
 725     XtSetArg (args[3], XmNheight, &filter_data->height);
 726     XtGetValues (filter_rec->shell, args, 4);
 727
 728     (void) GetFilterValues (filter_rec, filter_data);
 729   }
 730
 731   filter_rec->cancel = 0x0;
 732
 733   return ((XtPointer) filter_data);
 734 }
 735
 736
 737
 738
 739 /************************************************************************
 740  *
 741  *  GetDefaultValues
 742  *
 743  ************************************************************************/
 744
 745 static XtPointer
 746 GetDefaultValues( void )
 747 {
 748    FilterData * filter_data;
 749
 750    /*  Allocate and initialize the default file filter dialog data.  */
 751
 752    filter_data = (FilterData *) XtMalloc (sizeof (FilterData));
 753
 754    filter_data->displayed = False;
 755    filter_data->x = 0;
 756    filter_data->y = 0;
 757    filter_data->height = 0;
 758    filter_data->width = 0;
 759    filter_data->match_flag = True;
 760    filter_data->filter = XtNewString(".*");
 761    filter_data->show_hidden = False;
 762    filter_data->filetypesFilteredCount = 3;
 763    filter_data->filetypesFiltered = XtNewString(DEFAULT_FILTER);
 764    filter_data->user_data = NULL;
 765    filter_data->count = ReadInFiletypes(filter_data);
 766
 767    return ((XtPointer) filter_data);
 768 }
 769
 770
 771
 772
 773 /************************************************************************
 774  *
 775  *  GetResourceValues
 776  *
 777  ************************************************************************/
 778
 779 static XtPointer
 780 GetResourceValues(
 781         XrmDatabase data_base,
 782         char **name_list )
 783 {
 784    FilterData * filter_data;
 785    static Boolean convertersAdded = False;
 786
 787
 788    /*  Allocate and get the resources for file filter dialog data.  */
 789
 790    filter_data = (FilterData *) XtMalloc (sizeof (FilterData));
 791    filter_data->user_data = NULL;
 792
 793    _DtDialogGetResources (data_base, name_list, FILE_FILTER, (char *)filter_data,
 794                        resources, filterClass->resource_count);
 795
 796
 797    /* Create new strings for any string value we read in from our
 798     * resourceDB.
 799     */
 800
 801    filter_data->filter = XtNewString(filter_data->filter);
 802    filter_data->filetypesFiltered = XtNewString(filter_data->filetypesFiltered);
 803
 804    filter_data->count = ReadInFiletypes(filter_data);
 805
 806    return ((XtPointer) filter_data);
 807 }
 808
 809
 810 static FilterData *
 811 CopyFilterData(
 812         FilterData *filter_data )
 813 {
 814   FilterData * CopiedFilterData;
 815   int i;
 816
 817   CopiedFilterData = (FilterData *) XtMalloc (sizeof (FilterData));
 818   CopiedFilterData->displayed = filter_data->displayed;
 819   CopiedFilterData->show_hidden = filter_data->show_hidden;
 820   CopiedFilterData->match_flag = filter_data->match_flag;
 821   CopiedFilterData->filter = XtNewString( filter_data->filter );
 822   CopiedFilterData->filetypesFilteredCount = filter_data->filetypesFilteredCount;
 823   CopiedFilterData->filetypesFiltered = XtNewString( filter_data->filetypesFiltered );
 824   CopiedFilterData->count = filter_data->count;
 825   CopiedFilterData->user_data = (FTData **) XtMalloc(sizeof(FTData *) *
 826                                                        filter_data->count);
 827   for( i = 0; i < filter_data->count; ++i )
 828   {
 829     CopiedFilterData->user_data[i] = (FTData *)XtMalloc(sizeof(FTData));
 830     CopiedFilterData->user_data[i]->filetype =
 831       XtNewString( filter_data->user_data[i]->filetype );
 832     CopiedFilterData->user_data[i]->index =
 833       filter_data->user_data[i]->index;
 834     CopiedFilterData->user_data[i]->selected =
 835       filter_data->user_data[i]->selected;
 836   }
 837   return CopiedFilterData;
 838 }
 839
 840 /************************************************************************
 841  *
 842  *  SetValues
 843  *
 844  ************************************************************************/
 845
 846 static void
 847 SetValues(
 848         FilterRec *filter_rec,
 849         FilterData *filter_data )
 850 {
 851    Arg args[20];
 852    int n, i, count;
 853    XmManagerWidget mgr = (XmManagerWidget)filter_rec->file_window;
 854    int num_children = mgr->composite.num_children;
 855    Pixel  background_color;
 856    Pixel  foreground_color;
 857    Pixel  pixmap_background;
 858    Pixel  pixmap_foreground;
 859
 860    XmString icon_label;
 861    Widget icon_widget;
 862    Position x;
 863    Dimension max = 0;
 864    XtWidgetGeometry  desired, preferred;
 865    FTData *user_data;
 866    PixmapData *pixmapData;
 867
 868    filter_rec->cancel = 0x0;
 869    if( filter_rec->previous_filter_data )
 870      FreeValues( filter_rec->previous_filter_data );
 871    filter_rec->previous_filter_data = CopyFilterData( filter_data );
 872
 873    XmTextFieldSetString (filter_rec->fileNameFilter, filter_data->filter);
 874
 875    if(XmToggleButtonGadgetGetState (*showHiddenMenu))
 876       filter_data->show_hidden = True;
 877    else
 878       filter_data->show_hidden = False;
 879
 880    if(filter_data->match_flag)
 881       XtSetArg (args[0], XmNmenuHistory, filter_rec->hidArray[HIDDEN]);
 882    else
 883       XtSetArg (args[0], XmNmenuHistory, filter_rec->hidArray[SHOWN]);
 884    XtSetValues(filter_rec->hidden, args, 1);
 885
 886    XtSetArg (args[0], XmNbackground, &background_color);
 887    XtSetArg (args[1], XmNforeground, &foreground_color);
 888    XtSetArg (args[2], XmNtopShadowColor, &pixmap_background);
 889    XtSetArg (args[3], XmNbottomShadowColor, &pixmap_foreground);
 890    XtGetValues((Widget)mgr, args, 4);
 891
 892    for (i = 0, x = 5, count = 0; i < filter_data->count; i++)
 893    {
 894       char *ptr;
 895
 896       user_data = filter_data->user_data[i];
 897
 898       if (ptr = (char *)DtDtsDataTypeToAttributeValue(user_data->filetype,
 899                                                       FM_TYPE_LABEL,
 900                                                       NULL))
 901       {
 902          icon_label = XmStringCreateLocalized(ptr);
 903          DtDtsFreeAttributeValue(ptr);
 904       }
 905       else
 906       {
 907          icon_label = XmStringCreateLocalized(user_data->filetype);
 908       }
 909
 910       pixmapData = _DtRetrievePixmapData(user_data->filetype,
 911                                          NULL,
 912                                          NULL,
 913                                          filter_rec->file_window,
 914                                          LARGE);
 915
 916       n = 0;
 917       XtSetArg (args[n], XmNstring, icon_label);                        n++;
 918       if (pixmapData)
 919         XtSetArg (args[n], XmNimageName, pixmapData->iconFileName);
 920       else
 921         XtSetArg (args[n], XmNimageName, NULL);                         n++;
 922       XtSetArg (args[n], XmNunderline, False);                          n++;
 923
 924       XtSetArg (args[n], XmNpixmapPosition, XmPIXMAP_TOP);              n++;
 925       XtSetArg (args[n], XmNbehavior, XmICON_BUTTON);                   n++;
 926       XtSetArg (args[n], XmNfillMode, XmFILL_PARENT);              n++;
 927
 928       XtSetArg (args[n], XmNforeground, foreground_color);           n++;
 929       XtSetArg (args[n], XmNarmColor, white_pixel);                  n++;
 930       if (background_color == white_pixel)
 931       {
 932          XtSetArg (args[n], XmNbackground, white_pixel);             n++;
 933          XtSetArg (args[n], XmNpixmapBackground, white_pixel);       n++;
 934          XtSetArg (args[n], XmNpixmapForeground, black_pixel);       n++;
 935       }
 936       else if (background_color == black_pixel)
 937       {
 938          XtSetArg (args[n], XmNbackground, black_pixel);             n++;
 939          XtSetArg (args[n], XmNpixmapBackground, white_pixel);       n++;
 940          XtSetArg (args[n], XmNpixmapForeground, black_pixel);       n++;
 941       }
 942       else
 943       {
 944          XtSetArg (args[n], XmNbackground, background_color);        n++;
 945          XtSetArg (args[n], XmNpixmapBackground, pixmap_background); n++;
 946          XtSetArg (args[n], XmNpixmapForeground, pixmap_foreground); n++;
 947       }
 948
 949       if (i - count < num_children)
 950       {
 951          icon_widget = mgr->composite.children[i - count];
 952          XtSetArg (args[n], XmNx, x);                                   n++;
 953          XtSetArg (args[n], XmNy, 5);                                   n++;
 954          XtSetArg (args[n], XmNuserData, user_data);                    n++;
 955          XtSetValues(icon_widget, args, n);
 956          XtRemoveAllCallbacks (icon_widget, XmNcallback);
 957
 958       }
 959       else
 960       {
 961          XtSetArg (args[n], XmNx, x);                                   n++;
 962          XtSetArg (args[n], XmNy, 5);                                   n++;
 963          XtSetArg (args[n], XmNshadowThickness, 2);                     n++;
 964          XtSetArg (args[n], XmNfontList, user_font);                    n++;
 965          if(keybdFocusPolicy == XmEXPLICIT)
 966          {
 967             XtSetArg (args[n], XmNtraversalOn, True);                   n++;
 968          }
 969          else
 970          {
 971             XtSetArg (args[n], XmNtraversalOn, False);                  n++;
 972             XtSetArg (args[n], XmNhighlightThickness, 0);               n++;
 973          }
 974          XtSetArg (args[n], XmNborderType, DtNON_RECTANGLE);           n++;
 975          if (mgr->composite.num_children == 0)
 976          {
 977             XtSetArg (args[n], XmNuserData, user_data);                 n++;
 978             icon_widget= _DtCreateIcon ((Widget)mgr, "icon", args, n);
 979          }
 980          else
 981          {
 982             icon_widget = _DtDuplicateIcon((Widget)mgr,
 983                           mgr->composite.children[0],
 984                           (XmString)args[0].value, (String)args[1].value,
 985                           (XtPointer)user_data, (Boolean)args[2].value);
 986             n = 0;
 987             XtSetArg (args[n], XmNx, x);                                n++;
 988             XtSetArg (args[n], XmNy, 5);                                n++;
 989             XtSetValues(icon_widget, args, n);
 990          }
 991          XtAddCallback(icon_widget, XmNhelpCallback,
 992                        (XtCallbackProc)HelpRequestCB, NULL);
 993       }
 994       XtAddCallback (icon_widget, XmNcallback, NewFileTypeSelected,
 995                                                     (XtPointer)filter_rec);
 996
 997       _DtCheckAndFreePixmapData(user_data->filetype,
 998                                 filter_rec->file_window,
 999                                 (DtIconGadget) icon_widget,
1000                                 pixmapData);
1001
1002       XtManageChild(icon_widget);
1003       x += 5 + icon_widget->core.width;
1004       if (icon_widget->core.height > max)
1005          max = icon_widget->core.height;
1006
1007       XmStringFree(icon_label);
1008    }
1009
1010    for (i = 0, count = 0; i < filter_data->count; i++)
1011    {
1012
1013       user_data = filter_data->user_data[i];
1014
1015       icon_widget = mgr->composite.children[i - count];
1016
1017       if(filter_data->user_data[i]->selected == True)
1018       {
1019          n = 0;
1020          /* Draw the selected icon as selected */
1021          if (background_color == white_pixel)
1022          {
1023             XtSetArg (args[n], XmNbackground, black_pixel);             n++;
1024             XtSetArg (args[n], XmNforeground, white_pixel);             n++;
1025          }
1026          else
1027          {
1028             XtSetArg (args[n], XmNbackground, white_pixel);             n++;
1029             XtSetArg (args[n], XmNforeground, black_pixel);             n++;
1030          }
1031
1032          XtSetArg (args[n], XmNpixmapBackground, white_pixel);          n++;
1033          XtSetArg (args[n], XmNpixmapForeground, black_pixel);          n++;
1034          XtSetArg (args[n], XmNarmColor, white_pixel);                  n++;
1035          XtSetValues(icon_widget, args, n);
1036       }
1037    }
1038
1039    i -= count;
1040    /* Unmanage any icons left over */
1041    while (i < num_children)
1042    {
1043       XtUnmanageChild(mgr->composite.children[i]);
1044       i++;
1045    }
1046
1047    /* Line up the titles in all of the icons */
1048    num_children = mgr->composite.num_children;
1049    for (i = 0; i < num_children; i++)
1050    {
1051       if (XtIsManaged(mgr->composite.children[i]))
1052       {
1053          if (mgr->composite.children[i]->core.height != max)
1054          {
1055             n = 0;
1056             XtSetArg(args[n], XmNy,
1057                      5 + (max - mgr->composite.children[i]->core.height)); n++;
1058             XtSetValues(mgr->composite.children[i], args, n);
1059          }
1060       }
1061    }
1062
1063    /* Set the height of the scrolled window */
1064    desired.x = filter_rec->scrolled_window->core.x;
1065    desired.y = filter_rec->scrolled_window->core.y;
1066    desired.width = filter_rec->scrolled_window->core.width;
1067    desired.request_mode = (CWWidth);
1068    XtQueryGeometry(filter_rec->scrolled_window, &desired, &preferred);
1069    n = 0;
1070    if (preferred.request_mode & CWWidth)
1071    {
1072        XtSetArg(args[n], XmNwidth, (XtArgVal) preferred.width);
1073        n++;
1074    }
1075    if (preferred.request_mode & CWHeight)
1076    {
1077        XtSetArg(args[n], XmNheight, (XtArgVal) preferred.height);
1078        n++;
1079    }
1080    XtSetValues(filter_rec->scrolled_window, args, n);
1081
1082 }
1083
1084
1085
1086
1087 /************************************************************************
1088  *
1089  *  WriteResourceValues
1090  *
1091  ************************************************************************/
1092
1093 static void
1094 WriteResourceValues(
1095         DialogData *values,
1096         int fd,
1097         char **name_list )
1098 {
1099    FilterData * filter_data = (FilterData *) values->data;
1100    FilterRec  * filter_rec;
1101    Arg args[2];
1102
1103
1104    /*  If the dialog is currently displayed, update the geometry  */
1105    /*  fields to their current values.                            */
1106
1107    if (filter_data->displayed == True)
1108    {
1109       _DtGenericUpdateWindowPosition(values);
1110       filter_rec = (FilterRec *) _DtGetDialogInstance (values);
1111    }
1112
1113    _DtDialogPutResources (fd, name_list, FILE_FILTER, values->data,
1114                        resources, filterClass->resource_count);
1115 }
1116
1117
1118
1119
1120 /************************************************************************
1121  *
1122  *  FreeValues
1123  *
1124  ************************************************************************/
1125
1126 static void
1127 FreeValues(
1128         FilterData *filter_data )
1129 {
1130    int i;
1131
1132    for( i = 0; i < filter_data->count; i++)
1133    {
1134       if(filter_data->user_data[i]->filetype)
1135         XtFree ((char *)filter_data->user_data[i]->filetype);
1136       XtFree ((char *)filter_data->user_data[i]);
1137    }
1138    XtFree ((char *)filter_data->user_data);
1139    XtFree ((char *) filter_data->filter);
1140    XtFree ((char *) filter_data->filetypesFiltered);
1141    XtFree ((char *) filter_data);
1142 }
1143
1144
1145
1146 /************************************************************************
1147  *
1148  *  DefaultCallback
1149  *
1150  ************************************************************************/
1151
1152 static void
1153 DefaultCallback(
1154         Widget w,
1155         XtPointer client_data,
1156         XtPointer call_data )
1157 {
1158    FilterRec * filter_rec = (FilterRec *) client_data;
1159    DialogData * dialog_data;
1160    FilterData * filter_data;
1161    int i;
1162    Arg args[1];
1163
1164
1165    /*  Get the instance and data for the dialog  */
1166
1167    dialog_data = _DtGetInstanceData ((XtPointer)filter_rec);
1168    filter_data = (FilterData *) dialog_data->data;
1169
1170    filter_data->show_hidden = False;
1171
1172    XtSetArg (args[0], XmNmenuHistory, filter_rec->hidArray[HIDDEN]);
1173    XtSetValues(filter_rec->hidden, args, 1);
1174    filter_data->match_flag = True;
1175
1176    XmToggleButtonGadgetSetState(*showHiddenMenu, False, False);
1177
1178    XtFree( filter_data->filter );
1179    filter_data->filter = XtNewString(".*");
1180
1181    filter_data->filetypesFilteredCount = 3;
1182    XtFree( filter_data->filetypesFiltered );
1183    filter_data->filetypesFiltered = XtNewString( DEFAULT_FILTER );
1184
1185    filter_data->count = ReadInFiletypes(filter_data);
1186
1187    /* Display the new type  */
1188    SetValues (filter_rec, filter_data);
1189 }
1190
1191 /************************************************************************
1192  *
1193  *  CancelCallback
1194  *
1195  ************************************************************************/
1196
1197 static void
1198 CancelCallback(
1199         Widget w,
1200         XtPointer client_data,
1201         XtPointer call_data )
1202 {
1203   FilterRec * filter_rec = (FilterRec *) client_data;
1204
1205   filter_rec->cancel = 0x1;
1206 }
1207
1208 /************************************************************************
1209  *
1210  *  OkCallback
1211  *      This is a callback function called when the (Ok) button
1212  *      is pressed.  It saves the new file filter data internally and
1213  *      then calls the encapsulations callback function. It then closes
1214  *      the dialog.
1215  *
1216  ************************************************************************/
1217
1218 static void
1219 OkCallback(
1220         Widget w,
1221         XtPointer client_data,
1222         XtPointer call_data )
1223 {
1224    FilterRec  * filter_rec = (FilterRec *) ((FilterApply *)client_data)->filter_rec;
1225    DialogData * dialog_data;
1226    Widget close = filter_rec->close;
1227
1228    if(RecheckFlag(NULL,w))
1229      return;
1230    else if(RecheckFlag(NULL,close))
1231      return;
1232
1233    ApplyCallback(w, client_data, call_data);
1234    dialog_data = _DtGetInstanceData ((XtPointer)filter_rec);
1235    ResetFlag(NULL,close);
1236    XtCallCallbacks(filter_rec->close, XmNactivateCallback,
1237                                                  (XtPointer)dialog_data);
1238 }
1239
1240
1241 /************************************************************************
1242  *
1243  *  ApplyCallback
1244  *      This is a callback function called when the (Apply) button
1245  *      is pressed.  It saves the new file filter data internally and
1246  *      then calls the encapsulations callback function.
1247  *
1248  ************************************************************************/
1249
1250 static void
1251 ApplyCallback(
1252         Widget w,
1253         XtPointer client_data,
1254         XtPointer call_data )
1255 {
1256    FilterRec  * filter_rec;
1257    DialogData * dialog_data;
1258    FilterData * filter_data;
1259    FilterData * new_filter_data;
1260    XmManagerWidget mgr;
1261    int num_children;
1262    int i, count;
1263    Arg args[2];
1264
1265
1266    filter_rec = (FilterRec *) ((FilterApply *) client_data)->filter_rec;
1267    dialog_data = _DtGetInstanceData ((XtPointer)filter_rec);
1268    filter_data = (FilterData *) dialog_data->data;
1269    new_filter_data = (FilterData *) XtMalloc (sizeof (FilterData));
1270    mgr = (XmManagerWidget)filter_rec->file_window;
1271    num_children = mgr->composite.num_children;
1272
1273    GetFilterValues (filter_rec, new_filter_data);
1274    FreeValues (filter_data);
1275    dialog_data->data = (XtPointer) new_filter_data;
1276
1277    if( filter_rec->previous_filter_data )
1278      FreeValues( filter_rec->previous_filter_data );
1279    filter_rec->previous_filter_data = CopyFilterData( new_filter_data );
1280
1281    /* Need to update 'userData' for each of the icons */
1282    for (i = 0, count = 0; i < num_children &&
1283                           i + count < new_filter_data->count; i++)
1284    {
1285       XtSetArg (args[0], XmNuserData, new_filter_data->user_data[i + count]);
1286       XtSetValues(mgr->composite.children[i], args, 1);
1287    }
1288    (*(((FilterApply *)client_data)->callback)) (w, ((FilterApply *)client_data)->client_data, NULL);
1289 }
1290
1291
1292
1293 /************************************************************************
1294  *
1295  *  GetFilterValues
1296  *      Update the current file filter values within the data structure
1297  *      from the current toggle button values.
1298  *
1299  ************************************************************************/
1300
1301 static Boolean
1302 GetFilterValues(
1303         FilterRec *filter_rec,
1304         FilterData *filter_data )
1305 {
1306    int i;
1307    Widget menuHistory;
1308    Arg args[2];
1309    DialogData * dialog_data;
1310    FilterData * old_filter_data;
1311
1312    filter_data->displayed = True;
1313
1314    filter_data->filter = XmTextFieldGetString (filter_rec->fileNameFilter);
1315
1316    XmToggleButtonGadgetSetState(*showHiddenMenu, False, False);
1317    filter_data->show_hidden = False;
1318
1319    XtSetArg (args[0], XmNmenuHistory, &menuHistory);
1320    XtGetValues (filter_rec->hidden, args, 1);
1321
1322    if(menuHistory == filter_rec->hidArray[HIDDEN])
1323       filter_data->match_flag = True;
1324    else
1325       filter_data->match_flag = False;
1326
1327    filter_data->filetypesFiltered = NULL;
1328    filter_data->filetypesFilteredCount = 0;
1329    dialog_data = _DtGetInstanceData ((XtPointer)filter_rec);
1330    if(dialog_data != NULL)
1331    {
1332       old_filter_data = (FilterData *) dialog_data->data;
1333       filter_data->count = old_filter_data->count;
1334       filter_data->user_data = (FTData **) XtMalloc(sizeof(FTData *) *
1335                                                        filter_data->count);
1336
1337       for( i = 0; i < filter_data->count; i++)
1338       {
1339          /* Copy current value from the old dialog values */
1340          filter_data->user_data[i] = (FTData *)XtMalloc(sizeof(FTData));
1341          filter_data->user_data[i]->filetype =
1342               XtNewString(old_filter_data->user_data[i]->filetype);
1343          filter_data->user_data[i]->index =
1344               old_filter_data->user_data[i]->index;
1345          filter_data->user_data[i]->selected =
1346               old_filter_data->user_data[i]->selected;
1347
1348          if((filter_data->user_data[i]->selected == True &&
1349                                                 filter_data->match_flag) ||
1350             (filter_data->user_data[i]->selected == False &&
1351                                                 !filter_data->match_flag))
1352          {
1353            if(filter_data->filetypesFiltered == NULL)
1354            {
1355               filter_data->filetypesFiltered =
1356                 XtNewString(filter_data->user_data[i]->filetype);
1357            }
1358            else
1359            {
1360               filter_data->filetypesFiltered = (char *)XtRealloc(
1361                                (char *)filter_data->filetypesFiltered,
1362                                strlen(filter_data->filetypesFiltered) +
1363                                strlen(filter_data->user_data[i]->filetype) + 2);
1364
1365               strcat(filter_data->filetypesFiltered, ",");
1366               strcat(filter_data->filetypesFiltered,
1367                      filter_data->user_data[i]->filetype);
1368            }
1369            filter_data->filetypesFilteredCount++;
1370         }
1371       }
1372
1373       return (True);
1374     }
1375     return(False);
1376 }
1377
1378
1379 void
1380 ShowHiddenFiles (
1381    Widget  w,
1382    XtPointer client_data,
1383    XtPointer callback)
1384
1385 {
1386    FilterData *filter_data;
1387    FileMgrData *file_mgr_data;
1388    FileMgrRec *file_mgr_rec;
1389    FilterRec *filter_rec;
1390    DialogData *dialog_data;
1391    Widget mbar;
1392    Arg args[1];
1393
1394    if ((XtArgVal)client_data == FM_POPUP)
1395      mbar = XtParent(w);
1396    else
1397      mbar = (Widget)XmGetPostedFromWidget(XtParent(w));
1398    XmUpdateDisplay (w);
1399
1400    XtSetArg(args[0], XmNuserData, &file_mgr_rec);
1401    XtGetValues(mbar, args, 1);
1402
1403    dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
1404    file_mgr_data = (FileMgrData *) dialog_data->data;
1405
1406    filter_data = (FilterData *)(file_mgr_data->filter_active->data);
1407    if (file_mgr_data->show_hid_enabled)
1408    {
1409       filter_data->show_hidden = False;
1410       file_mgr_data->show_hid_enabled = False;
1411    }
1412    else
1413    {
1414       filter_data->show_hidden = True;
1415       file_mgr_data->show_hid_enabled = True;
1416    }
1417
1418    filter_rec = (FilterRec *)_DtGetDialogInstance( file_mgr_data->filter_edit );
1419
1420    /* Refilter the contents of the current directory */
1421
1422    FileMgrRedisplayFiles (file_mgr_rec, file_mgr_data, False);
1423
1424 }
1425
1426
1427 int
1428 ReadInFiletypes(
1429      FilterData *filter_data)
1430 {
1431    char **file_types;
1432    int i;
1433    int count = 0;
1434    int count_size = 0;
1435    FTData *user_data;
1436    char *filtered_types, *file_type;
1437    int j;
1438
1439    if (filter_data->user_data)
1440    {
1441       for(i=0; i<filter_data->count; i++)
1442       {
1443          XtFree(filter_data->user_data[i]->filetype);
1444          XtFree((char *)filter_data->user_data[i]);
1445       }
1446       XtFree((char *)filter_data->user_data);
1447       filter_data->user_data = NULL;
1448       filter_data->count = 0;
1449    }
1450
1451    file_types = (char **) DtDtsDataTypeNames();
1452    i = 0;
1453    while(file_types[i])
1454    {
1455       /* filter out invisible types and actions */
1456       if((_DtCheckForDataTypeProperty(file_types[i], "invisible")) ||
1457          (DtDtsDataTypeIsAction(file_types[i])))
1458       {
1459          i++;
1460          continue;
1461       }
1462
1463       if (count == count_size)
1464       {
1465          count_size += 10;
1466
1467          filter_data->user_data =
1468             (FTData **) XtRealloc ((char *)filter_data->user_data,
1469                                         sizeof (FTData *) * count_size);
1470       }
1471
1472       user_data = (FTData *)XtMalloc(sizeof(FTData));
1473       user_data->index = count;
1474       user_data->selected = False;
1475       user_data->filetype = XtNewString(file_types[i]);
1476
1477       filter_data->user_data[count] = user_data;
1478       count++;
1479       i++;
1480    }
1481
1482    DtDtsFreeDataTypeNames(file_types);
1483
1484    qsort( filter_data->user_data, count, sizeof( FTData *), (int (*)())FileTypeAscending );
1485
1486    filtered_types = filter_data->filetypesFiltered;
1487    for(i = 0; i < filter_data->filetypesFilteredCount; i++)
1488    {
1489       file_type = filtered_types;
1490       filtered_types = DtStrchr(filtered_types, ',');
1491
1492       if(filter_data->filetypesFilteredCount - 1 != i)
1493          *filtered_types = '\0';
1494
1495       for(j = 0; j < count; j++)
1496       {
1497           if(strcmp(file_type, filter_data->user_data[j]->filetype) == 0)
1498           {
1499              filter_data->user_data[j]->selected = True;
1500              break;
1501           }
1502       }
1503
1504       if(filter_data->filetypesFilteredCount - 1 != i)
1505       {
1506          *filtered_types = ',';
1507          filtered_types++;
1508       }
1509    }
1510    if(!filter_data->match_flag)
1511    {
1512       for(j = 0; j < count; j++)
1513       {
1514           if(filter_data->user_data[j]->selected == True)
1515              filter_data->user_data[j]->selected = False;
1516           else
1517              filter_data->user_data[j]->selected = True;
1518       }
1519    }
1520
1521    return(count);
1522 }
1523
1524
1525 /*
1526  * Whenever the database files are reread, we must update the filter
1527  * values, since the indices of the filetypes may have changed.
1528  */
1529
1530 void
1531 UpdateFilterAfterDBReread (
1532    DialogData * dialog_data )
1533
1534 {
1535    int i, count;
1536    int num_children;
1537    XmManagerWidget mgr;
1538    Arg args[2];
1539    FilterData * new_filter_data;
1540    FilterData * filter_data;
1541    FilterRec * filter_rec;
1542    Boolean result;
1543
1544    filter_data = (FilterData *) dialog_data->data;
1545    new_filter_data = (FilterData *) XtMalloc (sizeof (FilterData));
1546
1547    if (filter_rec = (FilterRec *) _DtGetDialogInstance(dialog_data))
1548    {
1549       /* Dialog is posted */
1550       result = GetFilterValues (filter_rec, new_filter_data);
1551       if( result )
1552       {
1553          XtFree(new_filter_data->filetypesFiltered);
1554          new_filter_data->filetypesFiltered =
1555                   XtNewString(filter_data->filetypesFiltered);
1556          new_filter_data->filetypesFilteredCount =
1557                   filter_data->filetypesFilteredCount;
1558          FreeValues (filter_data);
1559          dialog_data->data = (XtPointer) new_filter_data;
1560          filter_data = new_filter_data;
1561       }
1562    }
1563
1564    /* Reload the filetype information */
1565    filter_data->count = ReadInFiletypes(filter_data);
1566
1567    if (filter_rec && result)
1568    {
1569       /* Need to update 'userData' for each of the icons */
1570       mgr = (XmManagerWidget)filter_rec->file_window;
1571       num_children = mgr->composite.num_children;
1572       for (i = 0, count = 0; i < num_children &&
1573                              i + count < filter_data->count; i++)
1574       {
1575          XtSetArg (args[0], XmNuserData, new_filter_data->user_data[i]);
1576          XtSetValues(mgr->composite.children[i], args, 1);
1577       }
1578       /* Display the new type  */
1579       SetValues (filter_rec, filter_data);
1580    }
1581 }
1582
1583 static void
1584 filterTypeChanged(
1585         Widget w,
1586         XtPointer client_data,
1587         XtPointer call_data )
1588 {
1589    Widget menuHistory;
1590    FilterRec * filter_rec = (FilterRec *) client_data;
1591    DialogData * dialog_data;
1592    FilterData * filter_data;
1593    Arg args[2];
1594    XmString label_string;
1595
1596    /*  Get the instance and data for the dialog  */
1597    dialog_data = _DtGetInstanceData ((XtPointer)filter_rec);
1598    filter_data = (FilterData *) dialog_data->data;
1599
1600    XtSetArg (args[0], XmNmenuHistory, &menuHistory);
1601    XtGetValues (filter_rec->hidden, args, 1);
1602
1603    if(menuHistory == filter_rec->hidArray[HIDDEN])
1604    {
1605       filter_data->match_flag = True;
1606       label_string = XmStringCreateLocalized (((char *)GETMESSAGE(13,26,
1607                                          "Also hide (Optional): ")));
1608    }
1609    else
1610    {
1611       filter_data->match_flag = False;
1612       label_string = XmStringCreateLocalized (((char *)GETMESSAGE(13,29,
1613                                          "Also show (Optional): ")));
1614    }
1615    XtSetArg (args[0], XmNlabelString, label_string);
1616    XtSetValues( filter_rec->label, args, 1 );
1617
1618    XmStringFree( label_string );
1619    XmUpdateDisplay( filter_rec->label );
1620 }
1621
1622 static int
1623 FileTypeAscending(
1624         FTData **t1,
1625         FTData **t2 )
1626 {
1627   return strcmp( (*t1)->filetype, (*t2)->filetype );
1628 }
1629
1630 static void
1631 SelectAllFilter(
1632         Widget w,
1633         XEvent *event,
1634         String *params,
1635         Cardinal *num_params )
1636 {
1637   FilterRec * filterRec;
1638
1639   sscanf( params[0], "%p", (void **) &filterRec );
1640   SelectAllFileTypes( w, (XtPointer)filterRec, NULL );
1641   return ;
1642 }
1643
1644 static void
1645 DeselectAllFilter(
1646         Widget w,
1647         XEvent *event,
1648         String *params,
1649         Cardinal *num_params )
1650 {
1651   FilterRec * filterRec;
1652
1653   sscanf( params[0], "%p", (void **) &filterRec );
1654   UnselectAllFileTypes( w, (XtPointer)filterRec, NULL );
1655   return ;
1656 }