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