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