1 /* $TOG: FileMgr.c /main/19 1998/01/27 12:19:54 mgreess $ */
2 /************************************<+>*************************************
3 ****************************************************************************
7 * COMPONENT_NAME: Desktop File Manager (dtfile)
9 * Description: Source file for the File Manager dialog.
11 * FUNCTIONS: BranchListToString
23 * DropOnPrimaryHotspot
26 * FileMgrBuildDirectories
27 * FileMgrPropagateSettings
28 * FileMgrRedisplayFiles
49 * PositioningEnabledInView
50 * ProcessDropOnFileWindow
56 * SelectionListToString
66 * StringToSelectionList
74 * (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
75 * (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
76 * (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
77 * (c) Copyright 1993, 1994, 1995 Novell, Inc.
79 ****************************************************************************
80 ************************************<+>*************************************/
83 #include <sys/types.h>
89 #include <Xm/CascadeB.h>
90 #include <Xm/DrawingA.h>
91 #include <Xm/DrawingAP.h>
92 #include <Xm/DrawnB.h>
95 #include <Xm/LabelG.h>
97 #include <Xm/PushBG.h>
98 #include <Xm/RowColumn.h>
99 #include <Xm/ScrolledW.h>
100 #include <Xm/SeparatoG.h>
102 #include <Xm/TextF.h>
103 #include <Xm/ToggleBG.h>
104 #include <Xm/VendorSEP.h>
106 #include <Dt/IconP.h>
107 #include <Dt/IconFile.h>
109 #include <X11/ShellP.h>
110 #include <X11/Shell.h>
111 #include <X11/Xatom.h>
112 #include <X11/keysymdef.h>
114 #include <Xm/Protocols.h>
116 #include <Dt/Action.h>
117 #include <Dt/DtP.h> /* required for DtDirPaths type */
118 #include <Dt/Connect.h> /* required for DtMakeConnect... */
119 #include <Dt/FileM.h>
120 #include <Dt/HourGlass.h>
121 #include <Dt/DtNlUtils.h>
124 #include <Xm/DragIcon.h>
125 #include <Xm/DragC.h>
131 #include "SharedProcs.h"
139 #include "ChangeDir.h"
142 #include "SharedMsgs.h"
143 #include "IconicPath.h"
146 /* Dialog classes installed by Main.c */
148 extern int file_mgr_dialog;
149 extern int change_dir_dialog;
150 extern int preferences_dialog;
151 extern int filter_dialog;
152 extern int find_dialog;
153 extern int mod_attr_dialog;
155 extern int ReadInFiletypes(
156 FilterData *filter_data) ;
158 /* global varibles used within this function when we have to
159 * put up a _DtMessage dialog
161 static int global_file_count;
162 static char **global_file_set;
163 static char **global_host_set;
164 static FileMgrData *fm;
165 static int view_type;
166 static FileViewData *fv;
167 static DesktopRec *dtWindow;
168 static unsigned int mod;
169 static DirectorySet *dd;
170 static Pixmap change_view_pixmap = XmUNSPECIFIED_PIXMAP;
172 /* Global variables used in Command.c, FileMgr.c and FileOp.c */
173 int G_dropx, G_dropy;
175 /******** Static Function Declarations ********/
177 static XmFontListEntry FontListDefaultEntry(
178 XmFontList font_list) ;
182 Widget *return_widget,
184 static XtPointer GetDefaultValues( void ) ;
185 static XtPointer GetResourceValues(
186 XrmDatabase data_base,
188 static void SetValues(
189 FileMgrRec *file_mgr_rec,
190 FileMgrData *file_mgr_data) ;
191 static void WriteResourceValues(
195 static void FreeValues(
196 FileMgrData *file_mgr_data) ;
198 XtPointer recordPtr) ;
199 static void GetSessionDir(
200 FileMgrData *file_mgr_data) ;
201 static void BranchListToString(
205 static void SelectionListToString(
207 FileViewData ***value,
209 static Boolean StringToBranchList(
215 XtPointer *converter_data );
216 static void StringToSelectionList(
221 static void GetFileData(
222 FileMgrData *file_mgr_data,
224 char ** branch_list) ;
225 static FileViewData * GetTopInfo(
226 FileMgrData *file_mgr_data,
228 char *directory_name,
229 char **branch_list) ;
230 static void CountDirectories(
233 static DirectorySet * NewDirectorySet(
236 FileMgrData *file_mgr_data) ;
237 static void MakeDirectorySets(
238 FileMgrData *file_mgr_data,
240 DirectorySet **directory_set,
242 static void ReadTreeDirectory(
245 char *directory_name,
246 FileMgrData *file_mgr_data,
248 DirectorySet ***directory_set,
249 int *directory_count) ;
250 static Bool IsShown( FileMgrData *fmd,
252 static void SetDisplayedRecur(
256 static void SelectVisible (
257 FileMgrData *file_mgr_data) ;
258 static void FreeDirectorySet(
259 DirectorySet ** directory_set,
260 int directory_count) ;
261 static void FreeDirectoryData(
262 FileMgrData *file_mgr_data) ;
263 static void SystemClose(
266 static void SetIconAttributes(
267 FileMgrRec *file_mgr_rec,
268 FileMgrData *file_mgr_data,
269 char *directory_name) ;
270 static void SetFocus (
271 FileMgrRec * file_mgr_rec,
272 FileMgrData * file_mgr_data) ;
273 static void MoveOkCB(
275 XtPointer client_data,
276 XtPointer call_data ) ;
277 static void MoveCancelCB(
279 XtPointer client_data,
280 XtPointer call_data ) ;
281 static void CreateFmPopup (
283 static void DoTheMove(
289 Cardinal *num_params );
290 static void ActivateClist(
294 Cardinal *num_params );
296 /******** End Static Function Declarations ********/
299 #define TREE_DASH_WIDTH 1
301 /* Resource read and write function */
303 static char * FILEMGR = "FileMgr";
306 /* Action for osfMenu */
307 static XtActionsRec FMAction[] =
308 { { "FMInput", FMInput},
309 { "ActivateClist", ActivateClist}
313 /* The resources set for the FileMgr dialog */
315 static DialogResource resources[] =
317 { "show_type", SHOW_TYPE, sizeof(unsigned char),
318 XtOffset(FileMgrDataPtr, show_type),
319 (XtPointer) SINGLE_DIRECTORY, ShowTypeToString },
321 { "tree_files", TREE_FILES, sizeof(unsigned char),
322 XtOffset(FileMgrDataPtr, tree_files),
323 (XtPointer) TREE_FILES_NEVER, TreeFilesToString },
325 { "view_single", VIEW, sizeof(unsigned char),
326 XtOffset(FileMgrDataPtr, view_single),
327 (XtPointer) BY_NAME_AND_ICON, ViewToString },
329 { "view_tree", VIEW, sizeof(unsigned char),
330 XtOffset(FileMgrDataPtr, view_tree),
331 (XtPointer) BY_NAME_AND_SMALL_ICON, ViewToString },
333 { "order", ORDER, sizeof(unsigned char),
334 XtOffset(FileMgrDataPtr, order),
335 (XtPointer) ORDER_BY_ALPHABETICAL, OrderToString },
337 { "direction", DIRECTION_RESRC, sizeof(unsigned char),
338 XtOffset(FileMgrDataPtr, direction),
339 (XtPointer) DIRECTION_ASCENDING, DirectionToString },
341 { "positionEnabled", RANDOM, sizeof(unsigned char),
342 XtOffset(FileMgrDataPtr, positionEnabled),
343 (XtPointer) RANDOM_OFF, RandomToString },
345 { "host", XmRString, sizeof(String),
346 XtOffset(FileMgrDataPtr, host), (XtPointer) NULL, _DtStringToString },
348 { "current_directory", XmRString, sizeof(String),
349 XtOffset(FileMgrDataPtr, current_directory),
350 (XtPointer) "~", _DtStringToString },
352 { "branch_list", BRANCH_LIST, sizeof(XtPointer),
353 XtOffset(FileMgrDataPtr, branch_list),
354 (XtPointer) NULL, BranchListToString },
356 { "restricted_directory", XmRString, sizeof(String),
357 XtOffset(FileMgrDataPtr, restricted_directory),
358 (XtPointer) NULL, _DtStringToString },
360 { "title", XmRString, sizeof(String),
361 XtOffset(FileMgrDataPtr, title),
362 (XtPointer) NULL, _DtStringToString },
364 { "helpVol", XmRString, sizeof(String),
365 XtOffset(FileMgrDataPtr, helpVol),
366 (XtPointer) NULL, _DtStringToString },
368 { "selection_list", SELECTION_LIST, sizeof(XtPointer),
369 XtOffset(FileMgrDataPtr, selection_list),
370 (XtPointer) NULL, SelectionListToString },
372 { "show_iconic_path", XmRBoolean, sizeof(Boolean),
373 XtOffset(FileMgrDataPtr, show_iconic_path),
374 (XtPointer) True, _DtBooleanToString },
376 { "show_current_directory", XmRBoolean, sizeof(Boolean),
377 XtOffset(FileMgrDataPtr, show_current_dir),
378 (XtPointer) False, _DtBooleanToString },
380 { "show_status_line", XmRBoolean, sizeof(Boolean),
381 XtOffset(FileMgrDataPtr, show_status_line),
382 (XtPointer) True, _DtBooleanToString },
384 { "fast_cd_enabled", XmRBoolean, sizeof(Boolean),
385 XtOffset(FileMgrDataPtr, fast_cd_enabled),
386 (XtPointer) False, _DtBooleanToString },
388 { "toolbox", XmRBoolean, sizeof(Boolean),
389 XtOffset(FileMgrDataPtr, toolbox),
390 (XtPointer) False, _DtBooleanToString },
392 { "show_hid_enabled", XmRBoolean, sizeof(Boolean),
393 XtOffset(FileMgrDataPtr, show_hid_enabled),
394 (XtPointer) False, _DtBooleanToString },
396 { "secondaryHelpDialogCount", XmRInt, sizeof(int),
397 XtOffset(FileMgrDataPtr, secondaryHelpDialogCount),
398 (XtPointer) 0, _DtIntToString },
400 { "attr_dialog_count", XmRInt, sizeof(int),
401 XtOffset(FileMgrDataPtr, attr_dialog_count),
402 (XtPointer) 0, _DtIntToString },
404 { "trashcan", XmRBoolean, sizeof(Boolean),
405 XtOffset(FileMgrDataPtr, IsTrashCan),
406 (XtPointer) False, _DtBooleanToString },
411 * The Dialog Class structure.
414 static DialogClass fileMgrClassRec =
419 (DialogInstallChangeProc) NULL,
420 (DialogInstallCloseProc) NULL,
422 (DialogGetValuesProc) NULL,
425 (DialogSetValuesProc) SetValues,
427 (DialogFreeValuesProc) FreeValues,
429 (DialogSetFocusProc) SetFocus,
432 DialogClass * fileMgrClass = (DialogClass *) &fileMgrClassRec;
434 #ifdef _CHECK_FOR_SPACES
435 char translations_sp_esc[] = "<Key>space:Space()\n\
436 <Key>osfCancel:EscapeFM()";
437 char translations_space[] = "<Key>space:Space()";
439 char translations_sp_esc[] = "Ctrl<Key>space:Space()\n\
440 <Key>osfCancel:EscapeFM()";
441 char translations_space[] = "Ctrl<Key>space:Space()";
443 char translations_escape[] = "<Key>osfCancel:EscapeFM()";
445 #define DOUBLE_CLICK_DRAG
446 #ifndef DOUBLE_CLICK_DRAG
447 char translations_da[] = "\
448 <Key>osfCancel:DrawingAreaInput() ManagerGadgetSelect()\n\
449 <Key>plus:DrawingAreaInput() ManagerGadgetSelect()\n\
450 <Key>minus:DrawingAreaInput() ManagerGadgetSelect()\n\
451 <Btn2Down>:DrawingAreaInput() ManagerGadgetArm()\n\
452 <Btn2Down>,<Btn2Up>:DrawingAreaInput() ManagerGadgetActivate()\n\
453 <Btn2Up>:DrawingAreaInput() ManagerGadgetActivate()\n\
454 <Btn2Down>(2+):DrawingAreaInput() ManagerGadgetMultiArm()\n\
455 <Btn2Up>(2+):DrawingAreaInput() ManagerGadgetMultiActivate()";
459 extern _XmConst char _XmDrawingA_traversalTranslations[];
461 char translations_da[] = "\
462 <BtnMotion>:ManagerGadgetButtonMotion()\n\
463 <Btn1Down>:DrawingAreaInput() ManagerGadgetArm()\n\
464 <Btn1Down>,<Btn1Up>:DrawingAreaInput() ManagerGadgetActivate()\n\
465 <Btn1Up>:DrawingAreaInput() ManagerGadgetActivate()\n\
466 <Btn1Down>(2+):DrawingAreaInput() ManagerGadgetMultiArm() \
467 ManagerGadgetMultiActivate()\n\
468 <Btn2Down>:DrawingAreaInput() ManagerGadgetArm()\n\
469 <Btn2Down>,<Btn2Up>:DrawingAreaInput() ManagerGadgetActivate()\n\
470 <Btn2Up>:DrawingAreaInput() ManagerGadgetActivate()\n\
471 <BtnDown>:DrawingAreaInput()\n\
472 <BtnUp>:DrawingAreaInput()\n\
473 :<Key>osfActivate:DrawingAreaInput() ManagerParentActivate()\n\
474 :<Key>osfCancel:DrawingAreaInput() ManagerGadgetSelect()\n\
475 :<Key>osfHelp:DrawingAreaInput() ManagerGadgetHelp()\n\
476 :<Key>osfSelect:DrawingAreaInput() ManagerGadgetSelect()\n\
477 :<Key>osfDelete:DrawingAreaInput() ManagerGadgetSelect()\n\
478 :<Key>osfMenu:FMInput(@)\n\
479 :<Key>osfEndLine:FMInput(@)\n\
480 <Key>osfBeginLine:FMInput(@)\n\
481 :<Key>osfPageDown:FMInput(@)\n\
482 :<Key>osfPageUp:FMInput(@)\n\
483 :<Key>F1:DrawingAreaInput() ManagerGadgetHelp()\n\
484 s c a <Key>c: ActivateClist(@)\n\
485 ~s ~m ~a <Key>Return:DrawingAreaInput() ManagerParentActivate()\n\
486 <Key>Return:DrawingAreaInput() ManagerGadgetSelect()\n\
487 <Key>space:DrawingAreaInput() ManagerGadgetSelect()\n\
488 :<Key>plus:DrawingAreaInput() ManagerGadgetSelect()\n\
489 :<Key>minus:DrawingAreaInput() ManagerGadgetSelect()\n\
490 <KeyDown>:DrawingAreaInput() ManagerGadgetKeyInput()\n\
491 <KeyUp>:DrawingAreaInput()";
492 #endif /* DOUBLE_CLICK_DRAG */
494 /************************************************************************
496 * FontListDefaultEntry
498 * Return the first entry in the font list with the tag
499 * XmFONTLIST_DEFAULT_TAG. If there isn't one, just return the
500 * first entry in the font list.
502 ************************************************************************/
504 static XmFontListEntry
505 FontListDefaultEntry(XmFontList font_list)
507 XmFontContext context;
508 XmFontListEntry first_entry, entry;
511 if (!XmFontListInitFontContext(&context, font_list))
514 entry = first_entry = XmFontListNextEntry(context);
516 tag = XmFontListEntryGetTag(entry);
517 if (!strcmp(XmFONTLIST_DEFAULT_TAG, tag)) {
523 entry = XmFontListNextEntry(context);
526 XmFontListFreeFontContext(context);
528 return entry ? entry : first_entry;
531 /************************************************************************
535 ************************************************************************/
541 Widget *return_widget,
544 static Boolean first = True;
545 FileMgrRec * file_mgr_rec;
550 Widget header_separator;
551 Widget iconic_path_da;
552 Widget current_directory_frame;
553 Widget current_directory_drop;
554 Widget current_directory_icon;
555 Widget directory_list_form;
558 Widget status_separator;
568 XmFontList font_list;
569 XtPointer entry_font;
571 XFontSetExtents *extents;
578 int icon_offset, cur_dir_offset;
579 Dimension shadow_thickness;
580 Dimension highlight_thickness;
581 XtTranslations trans_table, trans_table1;
584 /* Allocate the change directory dialog instance record. */
586 file_mgr_rec = (FileMgrRec *) XtMalloc (sizeof (FileMgrRec));
587 file_mgr_rec->action_pane_file_type = NULL;
589 /* set up translations in main edit widget */
590 trans_table = XtParseTranslationTable(translations_sp_esc);
592 char * resolvedTranslationString;
594 resolvedTranslationString = ResolveTranslationString( translations_da,
595 (char *)file_mgr_rec );
596 trans_table1 = XtParseTranslationTable( resolvedTranslationString );
597 XtFree( resolvedTranslationString );
598 resolvedTranslationString = NULL;
601 /* Create the shell and main window used for the view. */
603 XtSetArg (args[0], XmNallowShellResize, True);
604 if(!first && (special_view == True && special_title != NULL && !TrashView))
606 file_mgr_rec->shell = shell =
607 XtAppCreateShell (special_title, DTFILE_CLASS_NAME,
608 applicationShellWidgetClass, display, args, 1);
609 XtFree(special_title);
610 special_title = NULL;
613 file_mgr_rec->shell = shell =
614 XtAppCreateShell (application_name, DTFILE_CLASS_NAME,
615 applicationShellWidgetClass, display, args, 1);
617 special_view = False;
620 XtSetArg (args[n], XmNdeleteResponse, XmUNMAP); n++;
622 if (first == False || TrashView)
624 XtSetArg (args[n], XmNgeometry, NULL); n++;
629 /* Set the useAsyncGeo on the shell */
630 XtSetArg (args[n], XmNuseAsyncGeometry, True); n++;
631 XtSetValues (shell, args, n);
633 delete_window = XmInternAtom (XtDisplay (shell), "WM_DELETE_WINDOW", False);
634 XmAddWMProtocolCallback (shell, delete_window, (XtCallbackProc)SystemClose,
635 (XtPointer)file_mgr_rec);
637 file_mgr_rec->main = main = XmCreateMainWindow (shell, "main", args, 1);
638 XtManageChild (main);
639 XtAddCallback(main, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
640 HELP_FILE_MANAGER_VIEW_STR);
643 /* Get the select color */
645 XtSetArg (args[0], XmNbackground, &background);
646 XtSetArg (args[1], XmNcolormap, &colormap);
647 XtGetValues (main, args, 2);
649 XmGetColors (XtScreen (main), colormap, background,
650 &foreground, &top_shadow, &bottom_shadow, &select);
652 /* Create the menu. */
657 file_mgr_rec->menuStates = NULL;
658 file_mgr_rec->menu = menu = CreateTrashMenu (main, file_mgr_rec);
662 file_mgr_rec->menuStates = (RENAME | MOVE | DUPLICATE | LINK | TRASH |
663 MODIFY | CHANGEDIR | PREFERENCES | FILTER |
664 FIND | CREATE_DIR | CREATE_FILE | SETTINGS |
666 HOME | CHANGE_DIR | TERMINAL);
668 file_mgr_rec->menu = menu = CreateMenu (main, file_mgr_rec);
671 /* Create the work area frame. */
673 XtSetArg (args[0], XmNshadowThickness, 1);
674 XtSetArg (args[1], XmNshadowType, XmSHADOW_OUT);
675 XtSetArg (args[2], XmNmarginWidth, 5);
676 XtSetArg (args[3], XmNmarginHeight, 5);
677 work_frame = XmCreateFrame (main, "work_frame", args, 4);
678 XtManageChild (work_frame);
681 /* Create the current directory frame. */
684 XtSetArg (args[n], XmNshadowThickness, 1); n++;
685 XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT); n++;
686 XtSetArg (args[n], XmNmarginWidth, 1); n++;
687 XtSetArg (args[n], XmNmarginHeight, 1); n++;
688 XtSetArg (args[n], XmNtextTranslations, trans_table); n++;
689 file_mgr_rec->header_frame = header_frame =
690 XmCreateForm (main, "header_frame", args, n);
692 XtAddCallback(header_frame, XmNhelpCallback,
693 (XtCallbackProc)HelpRequestCB,
694 HELP_FILE_MANAGER_VIEW_STR);
696 /* Create the current directory line only if not in showFilesystem. */
697 if (showFilesystem && !TrashView)
699 /* Create the iconic path */
701 XtSetArg (args[n], DtNfileMgrRec, file_mgr_rec); n++;
702 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
703 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
704 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
705 file_mgr_rec->iconic_path_da = iconic_path_da =
706 _DtCreateIconicPath(header_frame, "iconic_path", args, n);
707 XtManageChild (iconic_path_da);
708 file_mgr_rec->iconic_path_width = 0;
710 /* Create the separator between iconic path and current directory */
712 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
713 XtSetArg (args[n], XmNtopWidget, iconic_path_da); n++;
714 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
715 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
716 file_mgr_rec->header_separator = header_separator =
717 XmCreateSeparatorGadget(header_frame, "header_separator", args, n);
718 XtManageChild (header_separator);
720 /* Create a form for the current directory */
722 XtSetArg (args[n], XmNtextTranslations, trans_table); n++;
723 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
724 XtSetArg (args[n], XmNtopWidget, header_separator); n++;
725 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
726 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
727 file_mgr_rec->current_directory_frame = current_directory_frame =
728 XmCreateForm (header_frame, "current_directory_frame", args, n);
729 XtManageChild (file_mgr_rec->current_directory_frame);
731 /* Event handler for detecting drag threshold surpassed */
732 XtAddEventHandler(current_directory_frame,
733 Button1MotionMask|Button2MotionMask,
734 False, (XtEventHandler)CurrentDirectoryIconMotion,
737 /* Create the change directory drop zone. */
740 if (change_view_pixmap == XmUNSPECIFIED_PIXMAP)
743 _DtGetPixmap(XtScreen(current_directory_frame),
744 CHANGE_VIEW_ICON_S, foreground, background);
747 XtSetArg (args[n], XmNstring, NULL); n++;
748 XtSetArg (args[n], XmNshadowThickness, 2); n++;
749 XtSetArg (args[n], XmNfillOnArm, False); n++;
750 XtSetArg (args[n], XmNhighlightThickness, 0); n++;
751 XtSetArg (args[n], XmNpixmap, change_view_pixmap); n++;
752 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
753 XtSetArg (args[n], XmNtopOffset, 2); n++;
754 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
755 XtSetArg (args[n], XmNleftOffset, 5); n++;
756 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
757 XtSetArg (args[n], XmNbottomOffset, 2); n++;
758 XtSetArg (args[n], XmNtraversalOn, False); n++;
759 XtSetArg (args[n], XmNdropSiteOperations,
760 XmDROP_MOVE | XmDROP_COPY | XmDROP_LINK); n++;
761 file_mgr_rec->current_directory_drop = current_directory_drop =
762 _DtCreateIcon (current_directory_frame, "drop_cd", args, n);
764 XtAddCallback (current_directory_drop, XmNdropCallback,
765 DropOnChangeView, (XtPointer) file_mgr_rec);
768 file_mgr_rec->current_directory_drop = current_directory_drop = NULL;
770 /* Create the current directory icon. */
772 XtSetArg (args[n], XmNstring, NULL); n++;
773 XtSetArg (args[n], XmNimageName, SMALL_DIRECTORY_ICON); n++;
774 XtSetArg (args[n], XmNshadowThickness, 0); n++;
775 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
778 XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
779 XtSetArg (args[n], XmNleftWidget, current_directory_drop); n++;
780 XtSetArg (args[n], XmNleftOffset, 0); n++;
784 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
785 XtSetArg (args[n], XmNleftOffset, 5); n++;
787 XtSetArg (args[n], XmNtraversalOn, False); n++;
788 file_mgr_rec->current_directory_icon = current_directory_icon =
789 _DtCreateIcon (current_directory_frame, "current_directory_icon",
792 /* Create the current directory line */
794 XtSetArg (args[n], XmNshadowThickness, 0); n++;
795 XtSetArg (args[n], XmNmarginWidth, 0); n++;
796 XtSetArg (args[n], XmNmarginHeight, 0); n++;
797 XtSetArg (args[n], XmNpushButtonEnabled, False); n++;
798 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
799 XtSetArg (args[n], XmNtopOffset, 1); n++;
800 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
801 XtSetArg (args[n], XmNleftOffset, 5); n++;
802 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
803 XtSetArg (args[n], XmNrightOffset, 1); n++;
804 XtSetArg (args[n], XmNtraversalOn, True); n++;
805 file_mgr_rec->current_directory =
806 XmCreateDrawnButton(current_directory_frame, "current_directory",
808 XtManageChild (file_mgr_rec->current_directory);
811 /* Create overlay text field, for typing in a new directory */
813 XtSetArg (args[n], XmNmarginHeight, 0); n++;
814 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
815 XtSetArg (args[n], XmNtopOffset, 1); n++;
816 XtSetArg (args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);n++;
817 XtSetArg (args[n], XmNleftWidget,
818 file_mgr_rec->current_directory); n++;
819 XtSetArg (args[n], XmNleftOffset, 0); n++;
820 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);n++;
821 XtSetArg (args[n], XmNbottomWidget,
822 file_mgr_rec->current_directory); n++;
823 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
824 XtSetArg (args[n], XmNrightOffset, 1); n++;
825 XtSetArg (args[n], XmNtraversalOn, True); n++;
826 file_mgr_rec->current_directory_text = XmCreateTextField(
827 current_directory_frame, FAST_RENAME, args, n);
830 * Make sure the font & highlight thickness of the text field is the
831 * same as the corresponding values for the current directory line.
833 XtSetArg (args[0], XmNhighlightThickness, &highlight_thickness);
834 XtSetArg (args[1], XmNfontList, &font_list);
835 XtGetValues (file_mgr_rec->current_directory, args, 2);
837 XtSetArg (args[0], XmNhighlightThickness, highlight_thickness);
838 XtSetArg (args[1], XmNfontList, font_list);
839 XtSetValues (file_mgr_rec->current_directory_text, args, 2);
842 * Calculate how high to make the current directory line by adding
843 * up the font height and the highlight and shadow thickness
845 XtSetArg (args[0], XmNshadowThickness, &shadow_thickness);
846 XtGetValues (file_mgr_rec->current_directory_text, args, 1);
848 entry_font = XmFontListEntryGetFont(FontListDefaultEntry(font_list), &type);
849 if(type == XmFONT_IS_FONTSET) {
850 extents = XExtentsOfFontSet((XFontSet)entry_font);
851 font_height = extents->max_logical_extent.height;
854 font_height = ((XFontStruct *)entry_font)->ascent +
855 ((XFontStruct *)entry_font)->descent;
857 curdir_height = font_height + 2*(highlight_thickness + shadow_thickness);
859 XtSetArg (args[0], XmNtopOffset, &cur_dir_offset);
860 XtGetValues (file_mgr_rec->current_directory, args, 1);
862 XtSetArg (args[0], XmNheight, curdir_height);
863 XtSetValues (file_mgr_rec->current_directory, args, 1);
865 XtSetArg (args[0], XmNheight, curdir_height + 2*cur_dir_offset);
866 XtSetValues (file_mgr_rec->current_directory_frame, args, 1);
868 XtAddCallback(file_mgr_rec->current_directory_text, XmNactivateCallback,
869 (XtCallbackProc)ChangeToNewDir, file_mgr_rec);
870 XtAddCallback(file_mgr_rec->current_directory_text, XmNhelpCallback,
871 (XtCallbackProc)HelpRequestCB,
872 HELP_FILE_MANAGER_VIEW_STR);
874 /* This code is here so the Text Path (used to be Fast Change Dir
875 text) will be checked if user is ever try to type on the portion
876 before his restricted path.
877 It's no longer needed because, there won't be anything since
878 I'm tryting to treat restrictMode the same way I treat restricted
879 directory (i.e. dtfile -restricted).
880 Why I want to treat them the same way? Because they are the
881 same sort of things and it, also, solves the iconic path problem.
882 Note that user can double click on one of the icon and to a directory
883 above the restricted directory.
887 /* add the callbacks to make sure the user isn't able to
888 go anywhere above their restricted directory */
889 XtAddCallback (file_mgr_rec->current_directory_text,
890 XmNmodifyVerifyCallback, (XtCallbackProc)TextChange,
892 XtAddCallback (file_mgr_rec->current_directory_text,
893 XmNmotionVerifyCallback, (XtCallbackProc)TextChange,
899 /* create the status line */
901 XtSetArg (args[n], XmNshadowThickness, 1); n++;
902 XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT); n++;
903 XtSetArg (args[n], XmNmarginWidth, 5); n++;
904 XtSetArg (args[n], XmNmarginHeight, 1); n++;
905 status_form = XmCreateForm (main, "status_form", args, n);
906 XtManageChild (status_form);
909 XtSetArg (args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
910 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
911 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
912 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
913 file_mgr_rec->status_line =
914 XmCreateLabelGadget (status_form, "status_line", args, n);
915 XtManageChild (file_mgr_rec->status_line);
917 /* Associate the menu and frames with the appropriate */
918 /* areas of the main windows. */
920 XmMainWindowSetAreas (main, menu, file_mgr_rec->header_frame,
921 NULL, NULL, work_frame);
922 XtSetArg (args[0], XmNmessageWindow, status_form);
923 XtSetValues(main, args, 1);
925 /* Create the Scrolled Window for the file display area and */
926 /* set the scrollbars colors correctly. */
929 XtSetArg (args[n], XmNspacing, 2); n++;
930 XtSetArg (args[n], XmNscrollingPolicy, XmAUTOMATIC); n++;
931 XtSetArg (args[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED); n++;
932 file_mgr_rec->scroll_window =
933 XmCreateScrolledWindow (work_frame, "scroll_window", args, n);
934 XtManageChild (file_mgr_rec->scroll_window);
936 XtAddCallback(file_mgr_rec->scroll_window, XmNhelpCallback,
937 (XtCallbackProc)HelpRequestCB,
938 HELP_TRASH_OVERVIEW_TOPIC_STR);
940 XtAddCallback(file_mgr_rec->scroll_window, XmNhelpCallback,
941 (XtCallbackProc)HelpRequestCB,
942 HELP_FILE_MANAGER_VIEW_STR);
944 /* Get the 2 scrollbars and reset their foreground to the proper color */
945 /* Also turn their traversal off and set the highlight thickness to 0. */
947 XtSetArg (args[0], XmNhorizontalScrollBar, &(file_mgr_rec->horizontal_scroll_bar));
948 XtSetArg (args[1], XmNverticalScrollBar, &(file_mgr_rec->vertical_scroll_bar));
949 XtGetValues (file_mgr_rec->scroll_window, args, 2);
951 XtSetArg (args[0], XmNforeground, background);
952 XtSetArg (args[1], XmNtraversalOn, True);
953 XtSetValues (file_mgr_rec->horizontal_scroll_bar, args, 2);
954 XtSetValues (file_mgr_rec->vertical_scroll_bar, args, 2);
957 /* Add an event handler to catch resizes occuring on the scrolled */
958 /* window, in order to force a relayout of the icons. */
960 XtAddEventHandler (file_mgr_rec->scroll_window, StructureNotifyMask,
961 False, (XtEventHandler)FileWindowResizeCallback,
963 XtAddEventHandler (shell, StructureNotifyMask,
964 False, (XtEventHandler)FileWindowMapCallback,
968 /* Create a drawing area as a child of the scrolled window */
971 XtSetArg (args[n], XmNmarginWidth, 0); n++;
972 XtSetArg (args[n], XmNmarginHeight, 0); n++;
973 XtSetArg (args[n], XmNresizePolicy, XmRESIZE_GROW); n++;
974 file_mgr_rec->file_window =
975 XmCreateDrawingArea (file_mgr_rec->scroll_window, "file_window", args, n);
976 XtAppAddActions( XtWidgetToApplicationContext(file_mgr_rec->file_window),
979 XtManageChild (file_mgr_rec->file_window);
981 XtManageChild (file_mgr_rec->header_frame);
983 XtSetArg (args[0], XmNbackground, select);
984 XtSetValues (file_mgr_rec->file_window, args, 1);
986 XtSetArg (args[0], XmNbackground, select);
987 XtSetValues (XtParent (file_mgr_rec->file_window), args, 1);
989 if(fileMgrPopup.menu == NULL)
990 CreateFmPopup(file_mgr_rec->file_window);
992 XmAddToPostFromList(fileMgrPopup.menu, file_mgr_rec->file_window);
994 /* set up translations in main edit widget */
995 #ifdef DOUBLE_CLICK_DRAG
996 XtUninstallTranslations(file_mgr_rec->file_window);
997 XtOverrideTranslations(file_mgr_rec->file_window,
999 ((XmManagerClassRec *)XtClass(file_mgr_rec->file_window))
1000 ->manager_class.translations);
1001 XtOverrideTranslations(file_mgr_rec->file_window, trans_table1);
1002 XtOverrideTranslations(file_mgr_rec->file_window,
1003 XtParseTranslationTable(_XmDrawingA_traversalTranslations));
1005 XtOverrideTranslations(file_mgr_rec->file_window, trans_table1);
1008 /* Add the callbacks for processing selections, exposures, */
1009 /* and geometry changes of the drawing area. */
1011 XtAddCallback (file_mgr_rec->file_window, XmNexposeCallback,
1012 FileWindowExposeCallback, file_mgr_rec);
1014 XtAddCallback (file_mgr_rec->file_window, XmNinputCallback,
1015 FileWindowInputCallback, file_mgr_rec);
1017 /* Event handler for detecting drag threshold surpassed */
1018 XtAddEventHandler(file_mgr_rec->file_window,
1019 Button1MotionMask|Button2MotionMask,
1020 False, (XtEventHandler)FileIconMotion,
1023 /* Arrange for initial focus to be inside the file window */
1024 file_mgr_rec->focus_widget = file_mgr_rec->file_window;
1026 /* Set the return values for the dialog widget and dialog instance. */
1028 *return_widget = (Widget) main;
1029 *dialog = (XtPointer) file_mgr_rec;
1033 /************************************************************************
1037 ************************************************************************/
1040 GetDefaultValues( void )
1042 FileMgrData * file_mgr_data;
1043 PreferencesData *preferences_data;
1044 unsigned char *viewP;
1047 /* Allocate and initialize the default change dir dialog data. */
1049 file_mgr_data = (FileMgrData *) XtMalloc (sizeof (FileMgrData));
1051 file_mgr_data->displayed = False;
1052 file_mgr_data->mapped = False;
1053 file_mgr_data->x = 0;
1054 file_mgr_data->y = 0;
1056 file_mgr_data->busy_status = not_busy;
1057 file_mgr_data->busy_detail = 0;
1059 file_mgr_data->num_objects = 0;
1060 file_mgr_data->object_positions = NULL;
1061 file_mgr_data->grid_height = 0;
1062 file_mgr_data->grid_width = 0;
1063 file_mgr_data->layout_data = NULL;
1065 file_mgr_data->special_msg = NULL;
1066 file_mgr_data->msg_timer_id = 0;
1068 file_mgr_data->show_type = SINGLE_DIRECTORY;
1069 file_mgr_data->tree_files = TREE_FILES_NEVER;
1070 file_mgr_data->view_single = BY_NAME_AND_ICON;
1071 file_mgr_data->view_tree = BY_NAME_AND_SMALL_ICON;
1072 file_mgr_data->tree_preread_level = 1;
1073 file_mgr_data->tree_show_level = 1;
1074 file_mgr_data->show_iconic_path = True;
1075 file_mgr_data->show_current_dir = True;
1076 file_mgr_data->show_status_line = True;
1078 file_mgr_data->scrollToThisFile = NULL;
1079 file_mgr_data->scrollToThisDirectory = NULL;
1081 file_mgr_data->renaming = NULL;
1083 if(special_view && !TrashView)
1085 if(special_title != NULL)
1087 file_mgr_data->title = XtNewString(special_title);
1090 file_mgr_data->title = NULL;
1092 if(special_helpVol != NULL)
1094 file_mgr_data->helpVol = XtNewString(special_helpVol);
1095 XtFree(special_helpVol);
1096 special_helpVol = NULL;
1099 file_mgr_data->helpVol = XtNewString(fileMgrHelpVol);
1101 if(special_restricted != NULL)
1102 file_mgr_data->restricted_directory = special_restricted;
1104 file_mgr_data->restricted_directory = NULL;
1106 if(special_treeType == UNSET_VALUE)
1107 file_mgr_data->show_type = SINGLE_DIRECTORY;
1109 file_mgr_data->show_type = special_treeType;
1111 if(special_treeFiles == UNSET_VALUE)
1112 file_mgr_data->tree_files = TREE_FILES_NEVER;
1114 file_mgr_data->tree_files = special_treeFiles;
1116 if(file_mgr_data->show_type == MULTIPLE_DIRECTORY)
1117 viewP = &file_mgr_data->view_tree;
1119 viewP = &file_mgr_data->view_single;
1120 if(special_viewType == UNSET_VALUE)
1121 file_mgr_data->view = *viewP;
1123 file_mgr_data->view = *viewP = special_viewType;
1125 if(special_orderType == UNSET_VALUE)
1126 file_mgr_data->order = ORDER_BY_ALPHABETICAL;
1128 file_mgr_data->order = special_orderType;
1130 if(special_directionType == UNSET_VALUE)
1131 file_mgr_data->direction = DIRECTION_ASCENDING;
1133 file_mgr_data->direction = special_directionType;
1135 if(special_randomType == UNSET_VALUE)
1136 file_mgr_data->positionEnabled = RANDOM_OFF;
1138 file_mgr_data->positionEnabled = special_randomType;
1143 if(fileMgrTitle == NULL)
1144 file_mgr_data->title = NULL;
1146 file_mgr_data->title = XtNewString(fileMgrTitle);
1148 file_mgr_data->helpVol = XtNewString(fileMgrHelpVol);
1150 if(treeType == UNSET_VALUE || TrashView)
1151 file_mgr_data->show_type = SINGLE_DIRECTORY;
1153 file_mgr_data->show_type = treeType;
1155 if(treeFiles == UNSET_VALUE)
1156 file_mgr_data->tree_files = TREE_FILES_NEVER;
1158 file_mgr_data->tree_files = treeFiles;
1160 if(file_mgr_data->show_type == MULTIPLE_DIRECTORY)
1161 viewP = &file_mgr_data->view_tree;
1163 viewP = &file_mgr_data->view_single;
1164 if(viewType == UNSET_VALUE)
1165 file_mgr_data->view = *viewP;
1167 file_mgr_data->view = *viewP = viewType;
1169 if(orderType == UNSET_VALUE)
1170 file_mgr_data->order = ORDER_BY_ALPHABETICAL;
1172 file_mgr_data->order = orderType;
1174 if(directionType == UNSET_VALUE)
1175 file_mgr_data->direction = DIRECTION_ASCENDING;
1177 file_mgr_data->direction = directionType;
1179 if(randomType == UNSET_VALUE)
1180 file_mgr_data->positionEnabled = RANDOM_OFF;
1182 file_mgr_data->positionEnabled = randomType;
1184 file_mgr_data->restricted_directory = NULL;
1187 file_mgr_data->restoreKind = NORMAL_RESTORE;
1189 file_mgr_data->host = NULL;
1190 file_mgr_data->current_directory = NULL;
1191 file_mgr_data->branch_list = NULL;
1193 file_mgr_data->toolbox = False;
1194 file_mgr_data->dropSite = False;
1196 file_mgr_data->newSize = True;
1198 file_mgr_data->directory_count = 0;
1199 file_mgr_data->directory_set = NULL;
1200 file_mgr_data->tree_root = NULL;
1202 file_mgr_data->selection_list =
1203 (FileViewData **) XtMalloc (sizeof (FileViewData *));
1204 file_mgr_data->selection_list[0] = NULL;
1206 file_mgr_data->selection_table = NULL;
1207 file_mgr_data->selected_file_count = 0;
1209 file_mgr_data->fast_cd_enabled = False;
1210 file_mgr_data->show_hid_enabled = False;
1212 file_mgr_data->cd_inited = False;
1213 file_mgr_data->cd_font = NULL;
1214 file_mgr_data->cd_fontset = NULL;
1215 file_mgr_data->cd_normal_gc = 0;
1216 file_mgr_data->cd_select_gc = 0;
1217 file_mgr_data->cd_select = NULL;
1219 file_mgr_data->tree_solid_thin_gc = 0;
1220 file_mgr_data->tree_solid_thick_gc = 0;
1221 file_mgr_data->tree_dash_thin_gc = 0;
1222 file_mgr_data->tree_dash_thick_gc = 0;
1224 file_mgr_data->file_mgr_rec = NULL;
1225 file_mgr_data->popup_menu_icon = NULL;
1226 file_mgr_data->drag_file_view_data = NULL;
1228 file_mgr_data->change_dir = _DtGetDefaultDialogData (change_dir_dialog);
1229 file_mgr_data->preferences = _DtGetDefaultDialogData (preferences_dialog);
1231 /* now set up the preferences the way they really are */
1232 preferences_data = (PreferencesData *)file_mgr_data->preferences->data;
1233 preferences_data->show_type = file_mgr_data->show_type;
1234 preferences_data->tree_files = file_mgr_data->tree_files;
1235 preferences_data->view_single = file_mgr_data->view_single;
1236 preferences_data->view_tree = file_mgr_data->view_tree;
1237 preferences_data->order = file_mgr_data->order;
1238 preferences_data->direction = file_mgr_data->direction;
1239 preferences_data->positionEnabled = file_mgr_data->positionEnabled;
1240 preferences_data->show_iconic_path = file_mgr_data->show_iconic_path;
1241 preferences_data->show_current_dir = file_mgr_data->show_current_dir;
1242 preferences_data->show_status_line = file_mgr_data->show_status_line;
1244 file_mgr_data->filter_edit = _DtGetDefaultDialogData (filter_dialog);
1245 file_mgr_data->filter_active = _DtGetDefaultDialogData (filter_dialog);
1246 file_mgr_data->find = _DtGetDefaultDialogData (find_dialog);
1247 file_mgr_data->attr_dialog_list = NULL;
1248 file_mgr_data->attr_dialog_count = 0;
1249 file_mgr_data->secondaryHelpDialogList = NULL;
1250 file_mgr_data->secondaryHelpDialogCount = 0;
1251 file_mgr_data->primaryHelpDialog = NULL;
1253 return ((XtPointer) file_mgr_data);
1257 /************************************************************************
1261 ************************************************************************/
1265 XrmDatabase data_base,
1268 static Boolean first = True;
1269 FileMgrData * file_mgr_data;
1270 PreferencesData *preferences_data;
1272 char * directory_name;
1273 char * new_name_list[20];
1274 int name_list_count;
1275 struct passwd * pwInfo;
1285 XtAppAddConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1286 SHOW_TYPE, StringToShowType, NULL, 0);
1287 XtAppAddConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1288 TREE_FILES, StringToTreeFiles, NULL, 0);
1289 XtAppAddConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1290 VIEW, StringToView, NULL, 0);
1291 XtAppAddConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1292 ORDER, StringToOrder, NULL, 0);
1293 XtAppAddConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1294 DIRECTION_RESRC, StringToDirection, NULL, 0);
1295 XtAppAddConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1296 RANDOM, StringToRandom, NULL, 0);
1297 XtAppSetTypeConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1298 BRANCH_LIST, (XtTypeConverter)StringToBranchList,
1299 NULL, 0, XtCacheNone, NULL);
1300 XtAppAddConverter (XtWidgetToApplicationContext (toplevel), XmRString,
1301 SELECTION_LIST, (XtConverter)StringToSelectionList,
1306 /* Allocate and get the resources for change dir dialog data. */
1308 file_mgr_data = (FileMgrData *) XtMalloc (sizeof (FileMgrData));
1310 file_mgr_data->busy_status = not_busy;
1311 file_mgr_data->busy_detail = 0;
1312 file_mgr_data->num_objects = 0;
1313 file_mgr_data->object_positions = NULL;
1314 file_mgr_data->grid_height = 0;
1315 file_mgr_data->grid_width = 0;
1316 file_mgr_data->layout_data = NULL;
1317 file_mgr_data->secondaryHelpDialogList = NULL;
1318 file_mgr_data->secondaryHelpDialogCount = 0;
1319 file_mgr_data->attr_dialog_count = 0;
1320 file_mgr_data->attr_dialog_list = NULL;
1321 file_mgr_data->primaryHelpDialog = NULL;
1322 file_mgr_data->popup_menu_icon = NULL;
1323 file_mgr_data->title = NULL;
1324 file_mgr_data->helpVol = NULL;
1325 file_mgr_data->restricted_directory = NULL;
1326 file_mgr_data->toolbox = False;
1327 file_mgr_data->dropSite = False;
1328 file_mgr_data->tree_preread_level = 1; /* @@@ make these resources? */
1329 file_mgr_data->tree_show_level = 1;
1330 file_mgr_data->tree_files = TREE_FILES_NEVER;
1331 file_mgr_data->special_msg = NULL;
1332 file_mgr_data->msg_timer_id = 0;
1333 file_mgr_data->show_iconic_path = True;
1334 file_mgr_data->show_current_dir = True;
1335 file_mgr_data->show_status_line = True;
1336 file_mgr_data->scrollToThisFile = NULL;
1337 file_mgr_data->scrollToThisDirectory = NULL;
1338 file_mgr_data->renaming = NULL;
1340 _DtDialogGetResources (data_base, name_list, FILEMGR, (char *)file_mgr_data,
1341 resources, fileMgrClass->resource_count);
1342 if (file_mgr_data->show_type == MULTIPLE_DIRECTORY)
1343 file_mgr_data->view = file_mgr_data->view_tree;
1345 file_mgr_data->view = file_mgr_data->view_single;
1347 /* Bases on the type of restore session we are doing we must
1348 * adjust the host, current_directory, and selections to the
1349 * proper values (e.g. restore session or restore settings)
1351 if (restoreType != NORMAL_RESTORE)
1353 GetSessionDir(file_mgr_data);
1355 /* Adjust the selected files to null */
1356 file_mgr_data->selection_list = NULL;
1358 /* Set the Displayed to false so we do not use the x and y
1359 values when we place the window in showDialog
1361 file_mgr_data->displayed = False;
1363 if(special_view && !TrashView)
1365 if(special_title != NULL)
1366 file_mgr_data->title = XtNewString(special_title);
1368 file_mgr_data->title = XtNewString(file_mgr_data->title);
1370 if(special_helpVol != NULL)
1371 file_mgr_data->helpVol = XtNewString(special_helpVol);
1373 file_mgr_data->helpVol = XtNewString(file_mgr_data->helpVol);
1375 if(special_treeType != UNSET_VALUE)
1376 file_mgr_data->show_type = special_treeType;
1378 if(special_treeFiles != UNSET_VALUE)
1379 file_mgr_data->tree_files = special_treeFiles;
1381 if(special_viewType != UNSET_VALUE)
1383 file_mgr_data->view = special_viewType;
1384 if(file_mgr_data->show_type == MULTIPLE_DIRECTORY)
1385 file_mgr_data->view_tree = special_viewType;
1387 file_mgr_data->view_single = special_viewType;
1390 if(special_orderType != UNSET_VALUE)
1391 file_mgr_data->order = special_orderType;
1393 if(special_directionType != UNSET_VALUE)
1394 file_mgr_data->direction = special_directionType;
1396 if(special_randomType != UNSET_VALUE)
1397 file_mgr_data->positionEnabled = special_randomType;
1401 file_mgr_data->title = XtNewString(file_mgr_data->title);
1402 file_mgr_data->helpVol = XtNewString(file_mgr_data->helpVol);
1407 GetSessionDir(file_mgr_data);
1409 file_mgr_data->title = XtNewString(file_mgr_data->title);
1410 file_mgr_data->helpVol = XtNewString(file_mgr_data->helpVol);
1413 /* The GetSessionDir() function depends on the hostname being set. */
1414 /* So, we'll do it earlier */
1415 if(file_mgr_data->host != NULL)
1416 file_mgr_data->host = XtNewString(file_mgr_data->host);
1418 file_mgr_data->host = XtNewString(home_host_name);
1420 file_mgr_data->restoreKind = NORMAL_RESTORE;
1422 file_mgr_data->directory_count = 0;
1423 file_mgr_data->directory_set = NULL;
1424 file_mgr_data->tree_root = NULL;
1426 file_mgr_data->selected_file_count = 0;
1427 file_mgr_data->selection_table = (char **) file_mgr_data->selection_list;
1428 file_mgr_data->selection_list =
1429 (FileViewData **) XtMalloc (sizeof (FileViewData *));
1430 file_mgr_data->selection_list[0] = NULL;
1432 file_mgr_data->cd_inited = False;
1433 file_mgr_data->cd_font = NULL;
1434 file_mgr_data->cd_fontset = NULL;
1435 file_mgr_data->cd_normal_gc = 0;
1436 file_mgr_data->cd_select_gc = 0;
1437 file_mgr_data->cd_select = NULL;
1439 file_mgr_data->popup_menu_icon = NULL;
1440 file_mgr_data->drag_file_view_data = NULL;
1442 file_mgr_data->tree_solid_thin_gc = 0;
1443 file_mgr_data->tree_solid_thick_gc = 0;
1444 file_mgr_data->tree_dash_thin_gc = 0;
1445 file_mgr_data->tree_dash_thick_gc = 0;
1447 host_name = XtNewString (file_mgr_data->host);
1448 directory_name = XtNewString (file_mgr_data->current_directory);
1450 FileMgrBuildDirectories (file_mgr_data, host_name, directory_name);
1452 XtFree ((char *) host_name);
1454 XtFree ((char *) directory_name);
1456 if (restoreType == NORMAL_RESTORE &&
1457 file_mgr_data->positionEnabled == RANDOM_ON)
1459 /* Restore the optional positional data */
1460 RestorePositionalData(data_base, name_list, file_mgr_data, FILEMGR);
1464 /* Get a copy of the name list to be used to build new name lists. */
1466 _DtDuplicateDialogNameList(name_list, new_name_list, 20, &name_list_count);
1468 /* Load sub-dialogs */
1470 /* Get secondary help dialogs */
1471 if(restoreType == NORMAL_RESTORE &&
1472 file_mgr_data->secondaryHelpDialogCount > 0)
1474 _DtLoadSubdialogArray(new_name_list, name_list_count,
1475 &(file_mgr_data->secondaryHelpDialogList),
1476 file_mgr_data->secondaryHelpDialogCount,
1477 help_dialog, data_base, 1);
1481 file_mgr_data->secondaryHelpDialogList = NULL;
1482 file_mgr_data->secondaryHelpDialogCount = 0;
1485 /* Get primary help dialog */
1486 new_name_list[name_list_count] = number;
1487 new_name_list[name_list_count + 1] = NULL;
1488 sprintf(number, "%d", 0);
1489 if (restoreType == NORMAL_RESTORE)
1491 file_mgr_data->primaryHelpDialog =
1492 _DtGetResourceDialogData(help_dialog, data_base, new_name_list);
1493 if(((DialogInstanceData *)
1494 (file_mgr_data->primaryHelpDialog->data))->displayed == False)
1496 _DtFreeDialogData( file_mgr_data->primaryHelpDialog );
1497 file_mgr_data->primaryHelpDialog = NULL;
1501 file_mgr_data->primaryHelpDialog = NULL;
1503 if (restoreType == NORMAL_RESTORE &&
1504 file_mgr_data->attr_dialog_count > 0)
1506 /* Get properties dialogs */
1507 _DtLoadSubdialogArray(new_name_list, name_list_count,
1508 &(file_mgr_data->attr_dialog_list),
1509 file_mgr_data->attr_dialog_count,
1510 mod_attr_dialog, data_base, 1);
1514 file_mgr_data->attr_dialog_list = NULL;
1515 file_mgr_data->attr_dialog_count = 0;
1517 new_name_list[name_list_count] = NULL;
1519 file_mgr_data->change_dir =
1520 _DtGetResourceDialogData (change_dir_dialog, data_base, name_list);
1522 file_mgr_data->preferences =
1523 _DtGetResourceDialogData (preferences_dialog, data_base, name_list);
1525 /* Set all dialogs displayed flag for change_dir, and preferences
1526 * to false if not NORMAL_RESTORE
1528 if (restoreType != NORMAL_RESTORE)
1530 ((DialogInstanceData *)
1531 (file_mgr_data->change_dir->data))->displayed = False;
1533 ((DialogInstanceData *)
1534 (file_mgr_data->preferences->data))->displayed = False;
1537 /* now set up the preferences the way they really are */
1538 preferences_data = (PreferencesData *)file_mgr_data->preferences->data;
1539 preferences_data->show_type = file_mgr_data->show_type;
1540 preferences_data->tree_files = file_mgr_data->tree_files;
1541 preferences_data->view_single = file_mgr_data->view_single;
1542 preferences_data->view_tree = file_mgr_data->view_tree;
1543 preferences_data->order = file_mgr_data->order;
1544 preferences_data->direction = file_mgr_data->direction;
1545 preferences_data->positionEnabled = file_mgr_data->positionEnabled;
1546 preferences_data->show_iconic_path = file_mgr_data->show_iconic_path;
1547 preferences_data->show_current_dir = file_mgr_data->show_current_dir;
1548 preferences_data->show_status_line = file_mgr_data->show_status_line;
1550 /* Build the name list for the file dialog that is displayed, */
1551 /* get resource data and perform and other initialization. */
1553 tmpStr = GetSharedMessage(FILTER_EDIT_ID_STRING);
1554 new_name_list[name_list_count] = XtNewString (tmpStr);
1555 new_name_list[name_list_count + 1] = NULL;
1557 file_mgr_data->filter_edit =
1558 _DtGetResourceDialogData (filter_dialog, data_base, new_name_list);
1560 XtFree ((char *) new_name_list[name_list_count]);
1561 new_name_list[name_list_count] = NULL;
1564 /* Build the name list for the filter dialog that is used for the */
1565 /* current processing values. Get the resource data and perform */
1566 /* and other initialization. */
1568 tmpStr = GetSharedMessage(FILTER_ACTIVE_ID_STRING);
1569 new_name_list[name_list_count] = XtNewString (tmpStr);
1570 new_name_list[name_list_count + 1] = NULL;
1572 file_mgr_data->filter_active =
1573 _DtGetResourceDialogData (filter_dialog, data_base, new_name_list);
1575 XtFree ((char *) new_name_list[name_list_count]);
1576 new_name_list[name_list_count] = NULL;
1578 /* Get the resource data for the find dialog and perform */
1579 /* additional initialization. */
1581 file_mgr_data->find =
1582 _DtGetResourceDialogData (find_dialog, data_base, name_list);
1585 /* Set the FilterDialog and Find dialog displayed flag to false if
1586 * not NORMAL_RESTORE
1589 if (restoreType != NORMAL_RESTORE)
1591 ((DialogInstanceData *)
1592 (file_mgr_data->filter_edit->data))->displayed = False;
1594 ((DialogInstanceData *)
1595 (file_mgr_data->find->data))->displayed = False;
1599 return ((XtPointer) file_mgr_data);
1602 /************************************************************************
1606 ************************************************************************/
1610 FileMgrRec *file_mgr_rec,
1611 FileMgrData *file_mgr_data )
1613 Widget cd = file_mgr_rec->current_directory;
1614 Widget cdi = file_mgr_rec->current_directory_icon;
1615 Widget cdd = file_mgr_rec->current_directory_drop;
1617 XmFontList font_list;
1618 XtPointer entry_font;
1622 XGCValues gc_values;
1624 ChangeDirData * change_dir_data;
1625 ModAttrRec *modAttr_rec;
1626 DialogData *attr_dialog;
1627 ModAttrData *attr_data;
1633 DirectorySet ** directory_set;
1634 FileViewData ** order_list;
1635 int directory_count;
1639 char *tmpStr, *tempStr;
1641 PixmapData *pixmapData;
1643 file_mgr_data->file_mgr_rec = (XtPointer) file_mgr_rec;
1645 /* this is what we did for the ultrix port to get the name of the
1646 Application dir right, BUT it has some bugs */
1647 if(file_mgr_data->title != NULL)
1649 XtSetArg (args[0], XmNtitle, file_mgr_data->title);
1650 XtSetValues(file_mgr_rec->shell, args, 1);
1653 /* Set up the callbacks for the current directory line only if
1654 not in showFilesystem. */
1656 if(showFilesystem && !TrashView)
1658 XtRemoveAllCallbacks (cd, XmNarmCallback);
1659 XtAddCallback (cd, XmNarmCallback, CurrentDirSelected, file_mgr_rec);
1661 XtRemoveAllCallbacks (cd, XmNexposeCallback);
1662 XtAddCallback (cd, XmNexposeCallback, CurrentDirExposed, file_mgr_rec);
1664 XtRemoveAllCallbacks (cdi, XmNcallback);
1665 XtAddCallback (cdi, XmNcallback, CurrentDirIconCallback, file_mgr_rec);
1669 XtRemoveAllCallbacks (cdd, XmNcallback);
1670 XtAddCallback (cdd, XmNcallback, CurrentDirDropCallback, file_mgr_rec);
1673 DtUpdateIconicPath(file_mgr_rec, file_mgr_data, False);
1677 * To help our menu callbacks get the file_mgr_rec when they are
1678 * activated, we will register the file_mgr_rec pointer as the
1679 * user_data for the menubar. That way, since the callbacks can
1680 * find out which menubar they were invoked from, they can easily
1681 * map this into the file_mgr_rec.
1683 XtSetArg(args[0], XmNuserData, file_mgr_rec);
1684 XtSetValues(file_mgr_rec->menu, args, 1);
1685 if(fileMgrPopup.menu != NULL)
1686 XtSetValues(fileMgrPopup.menu, args, 1);
1690 * Adjust some widgets, in case this is a recycled dialog, which
1691 * previously had been used as a desktop view, or vice-versa.
1694 XtManageChild(file_mgr_rec->header_frame);
1695 XtManageChild(file_mgr_rec->directoryBarBtn);
1698 if(showFilesystem && !TrashView)
1701 XtSetArg (args[0], XmNallowShellResize, False);
1702 XtSetValues(file_mgr_rec->shell, args, 1);
1705 widg = file_mgr_rec->directoryBarBtn;
1708 XtSetArg (args[0], XmNforeground, &foreground);
1709 XtSetArg (args[1], XmNbackground, &background);
1710 XtSetArg (args[2], XmNfontList, &font_list);
1711 XtGetValues (widg, args, 3);
1713 /* If the current_directory data has not been initialized */
1714 /* for this data record, do it now. */
1716 if (file_mgr_data->cd_inited == False)
1718 file_mgr_data->cd_inited = True;
1720 entry_font = XmFontListEntryGetFont(FontListDefaultEntry(font_list), &type);
1721 if(type == XmFONT_IS_FONTSET) {
1722 file_mgr_data->cd_fontset = (XFontSet)entry_font;
1723 file_mgr_data->cd_fonttype = XmFONT_IS_FONTSET;
1724 gc_mask = GCForeground | GCBackground;
1727 file_mgr_data->cd_font = (XFontStruct *)entry_font;
1728 file_mgr_data->cd_fonttype = XmFONT_IS_FONT;
1729 gc_values.font = ((XFontStruct *)entry_font)->fid;
1730 gc_mask = GCForeground | GCBackground | GCFont;
1733 gc_values.foreground = foreground;
1734 gc_values.background = background;
1735 file_mgr_data->cd_normal_gc = XtGetGC (widg, gc_mask, &gc_values);
1737 gc_values.foreground = background;
1738 gc_values.background = foreground;
1739 file_mgr_data->cd_select_gc = XtGetGC (widg, gc_mask, &gc_values);
1741 /* graphics contexts for drawing tree lines */
1742 gc_values.foreground = foreground;
1743 XtSetArg (args[0], XmNbackground, &gc_values.background);
1744 XtGetValues (file_mgr_rec->file_window, args, 1);
1745 gc_values.line_width = 2;
1746 gc_values.line_style = LineOnOffDash;
1747 gc_values.cap_style = CapNotLast;
1748 gc_values.dashes = TREE_DASH_WIDTH;
1750 gc_mask |= GCCapStyle;
1752 file_mgr_data->tree_solid_thin_gc =
1753 XtGetGC (widg, gc_mask, &gc_values);
1754 file_mgr_data->tree_solid_thick_gc =
1755 XtGetGC (widg, gc_mask | GCLineWidth, &gc_values);
1756 file_mgr_data->tree_dash_thin_gc =
1757 XtGetGC (widg, gc_mask | GCLineStyle | GCDashList, &gc_values);
1758 file_mgr_data->tree_dash_thick_gc =
1759 XtGetGC (widg, gc_mask | GCLineWidth |
1760 GCLineStyle | GCDashList, &gc_values);
1764 if(showFilesystem && !TrashView)
1766 /* Set the current directory icon to normal colors */
1767 SetToNormalColors (file_mgr_rec->current_directory_icon,
1768 file_mgr_rec->file_window, file_mgr_rec->main, NULL);
1771 /* Update the Change Directory host name */
1772 change_dir_data = (ChangeDirData *) file_mgr_data->change_dir->data;
1773 if (change_dir_data->host_name != NULL)
1774 XtFree ((char *) change_dir_data->host_name);
1775 change_dir_data->host_name = XtNewString (file_mgr_data->host);
1777 /* Display the correct small directory icon */
1778 pixmapData = GetPixmapData(file_mgr_rec,
1780 file_mgr_data->current_directory,
1783 XtSetArg (args[0], XmNimageName, pixmapData->iconFileName);
1785 XtSetArg (args[0], XmNimageName, NULL);
1786 XtSetValues(cdi, args, 1);
1788 _DtCheckAndFreePixmapData(
1789 GetDirectoryLogicalType(file_mgr_data,
1790 file_mgr_data->current_directory),
1791 file_mgr_rec->shell,
1795 if(file_mgr_data->restricted_directory == NULL)
1796 textString = XtNewString(file_mgr_data->current_directory);
1801 ptr = file_mgr_data->current_directory +
1802 strlen(file_mgr_data->restricted_directory);
1803 if(strcmp(ptr, "") == 0)
1804 textString = XtNewString( "/" );
1806 textString = XtNewString( ptr );
1808 XmTextFieldSetString(file_mgr_rec->current_directory_text, textString);
1810 /* Clear the change dir text field */
1811 if (file_mgr_data->fast_cd_enabled)
1812 XtManageChild(file_mgr_rec->current_directory_text);
1814 XtUnmanageChild(file_mgr_rec->current_directory_text);
1815 XtSetArg (args[0], XmNallowShellResize, True);
1816 XtSetValues(file_mgr_rec->shell, args, 1);
1821 /* Get the file set displayed */
1822 FileMgrRedisplayFiles (file_mgr_rec, file_mgr_data, True);
1825 /* Set the icon name for this view to the directory name. */
1826 SetIconAttributes ((FileMgrRec *)file_mgr_data->file_mgr_rec, file_mgr_data,
1827 file_mgr_data->current_directory);
1830 /* Process the selection table into a selection list */
1832 if (file_mgr_data->selection_table != NULL)
1834 DeselectAllFiles (file_mgr_data);
1836 directory_set = file_mgr_data->directory_set;
1838 if (file_mgr_data->show_type == SINGLE_DIRECTORY)
1839 directory_count = 1;
1841 directory_count = file_mgr_data->directory_count;
1844 while (file_mgr_data->selection_table[i] != NULL)
1846 for (j = 0; j < directory_count; j++)
1848 if (strncmp (directory_set[j]->name,
1849 file_mgr_data->selection_table[i],
1850 strlen (directory_set[j]->name)) == 0)
1852 file_name = strrchr(file_mgr_data->selection_table[i], '/') +1;
1853 order_list = directory_set[j]->order_list;
1855 for (k = 0; k < directory_set[j]->file_count; k++)
1857 if (strcmp (file_name,
1858 order_list[k]->file_data->file_name) == 0)
1860 if (order_list[k]->filtered == False)
1861 SelectFile (file_mgr_data, order_list[k]);
1871 file_mgr_data->selection_table = NULL;
1874 /* Initially, all menubuttons are sensitive */
1876 file_mgr_rec->menuStates = (RENAME | MOVE | DUPLICATE | LINK | TRASH |
1877 MODIFY | CHANGEDIR | PREFERENCES | FILTER |
1878 FIND | CREATE_DIR | CREATE_FILE | SETTINGS |
1879 CLEAN_UP | MOVE_UP |
1880 HOME | CHANGE_DIR | TERMINAL);
1882 if(file_mgr_data != trashFileMgrData
1883 && file_mgr_data != NULL )
1885 if (file_mgr_data->selected_file_count == 0)
1886 ActivateNoSelect (file_mgr_rec);
1887 else if (file_mgr_data->selected_file_count == 1)
1888 ActivateSingleSelect (file_mgr_rec,
1889 file_mgr_data->selection_list[0]->file_data->logical_type);
1891 ActivateMultipleSelect (file_mgr_rec);
1894 SensitizeTrashBtns();
1896 /* Display any dialogs that need to be displayed */
1897 if (((DialogInstanceData *)
1898 (file_mgr_data->change_dir->data))->displayed == True)
1900 ShowChangeDirDialog ((Widget)NULL, (XtPointer)file_mgr_rec,
1904 file_mgr_rec->menuStates |= CHANGEDIR;
1907 if (((DialogInstanceData *)
1908 (file_mgr_data->preferences->data))->displayed == True)
1910 ShowPreferencesDialog ((Widget)NULL, (XtPointer)file_mgr_rec,
1914 file_mgr_rec->menuStates |= PREFERENCES;
1916 if (((DialogInstanceData *)
1917 (file_mgr_data->find->data))->displayed == True)
1919 ShowFindDialog ((Widget)NULL, (XtPointer)file_mgr_rec, (XtPointer)NULL);
1922 file_mgr_rec->menuStates |= FIND;
1925 if (((DialogInstanceData *)
1926 (file_mgr_data->filter_edit->data))->displayed == True)
1928 ShowFilterDialog ((Widget)NULL, (XtPointer)file_mgr_rec, (XtPointer)NULL);
1931 file_mgr_rec->menuStates |= FILTER;
1933 /* Display any properties dialogs */
1934 for (i = 0; i < file_mgr_data->attr_dialog_count; i++)
1936 if (((DialogInstanceData *)
1937 (file_mgr_data->attr_dialog_list[i]->data))->displayed == False)
1943 attr_dialog = (DialogData *)file_mgr_data->attr_dialog_list[i];
1944 attr_data = (ModAttrData *) attr_dialog->data;
1946 loadOk = LoadFileAttributes(attr_data->host, attr_data->directory,
1947 attr_data->name, attr_data);
1952 /* We need the file_mgr_rec inside the create routine so
1953 * we attach it here for use later.
1955 ((ModAttrData *) (file_mgr_data->attr_dialog_list[i]->data))->
1956 main_widget = file_mgr_rec->main;
1958 _DtShowDialog (file_mgr_rec->shell, NULL, (XtPointer)file_mgr_rec,
1959 file_mgr_data->attr_dialog_list[i],
1960 ModAttrChange, (XtPointer)file_mgr_rec, ModAttrClose,
1961 (XtPointer)file_mgr_rec, NULL, False, False, NULL, NULL);
1963 modAttr_rec = (ModAttrRec *)_DtGetDialogInstance(
1964 file_mgr_data->attr_dialog_list[i]);
1966 if(file_mgr_data->title != NULL &&
1967 strcmp(file_mgr_data->helpVol, DTFILE_HELP_NAME) != 0)
1969 tmpStr = GETMESSAGE(21, 1, "File Permissions");
1970 tempStr = (char *)XtMalloc(strlen(tmpStr) +
1971 strlen(file_mgr_data->title) + 5);
1972 sprintf(tempStr, "%s - %s", file_mgr_data->title, tmpStr);
1976 tmpStr = (GETMESSAGE(21,34, "File Manager - Permissions"));
1977 tempStr = XtNewString(tmpStr);
1979 XtSetArg (args[0], XmNtitle, tempStr);
1980 XtSetValues (modAttr_rec->shell, args, 1);
1985 /* The object would have got deleted and hence we are not able to
1988 ModAttrFreeValues(attr_data);
1989 XtFree((char *)attr_dialog);
1990 file_mgr_data->attr_dialog_count--;
1991 if(file_mgr_data->attr_dialog_count >0)
1992 file_mgr_data->attr_dialog_list = (DialogData **) XtRealloc(
1993 (char *) file_mgr_data->attr_dialog_list,
1994 sizeof(DialogData *) * file_mgr_data->attr_dialog_count);
1997 XtFree((char *)file_mgr_data->attr_dialog_list);
1998 file_mgr_data->attr_dialog_list = NULL;
2003 /* Display any secondary help dialogs */
2004 for (i = 0; i < file_mgr_data->secondaryHelpDialogCount; i++)
2006 ShowHelpDialog(file_mgr_rec->shell, (XtPointer)file_mgr_rec,
2008 file_mgr_data->secondaryHelpDialogList[i], NULL, NULL,
2012 /* Display the primary help dialog, if active */
2013 if (file_mgr_data->primaryHelpDialog && ((DialogInstanceData *)
2014 (file_mgr_data->primaryHelpDialog->data))->displayed == True)
2016 ShowHelpDialog(file_mgr_rec->shell, (XtPointer)file_mgr_rec,
2018 file_mgr_data->primaryHelpDialog, NULL, NULL, NULL,
2027 /************************************************************************
2029 * WriteResourceValues
2031 ************************************************************************/
2034 WriteResourceValues(
2039 FileMgrData * file_mgr_data = (FileMgrData *) values->data;
2040 FileMgrRec * file_mgr_rec;
2041 char * new_name_list[20];
2042 int name_list_count;
2048 /* If the dialog is currently displayed, update the geometry */
2049 /* fields to their current values. */
2051 if (file_mgr_data->displayed == True)
2053 _DtGenericUpdateWindowPosition(values);
2054 file_mgr_rec = (FileMgrRec *) _DtGetDialogInstance (values);
2058 /* save FILEMGR resources */
2059 /* store netfile version of current directory name */
2061 if ( file_mgr_data->current_directory && file_mgr_data->toolbox )
2064 char *user_session_str = NULL;
2067 current_host = file_mgr_data->host;
2068 user_session_str = getenv("DTUSERSESSION");
2069 ptr = strstr(file_mgr_data->current_directory, user_session_str);
2073 file_mgr_data->host = XtNewString(file_mgr_data->current_directory);
2074 *ptr = user_session_str[0];
2078 file_mgr_data->host = XtNewString(file_mgr_data->current_directory);
2081 _DtDialogPutResources (fd, name_list, FILEMGR, values->data,
2082 resources, fileMgrClass->resource_count);
2084 XtFree(file_mgr_data->host);
2085 file_mgr_data->host = current_host;
2089 _DtDialogPutResources (fd, name_list, FILEMGR, values->data,
2090 resources, fileMgrClass->resource_count);
2094 /* Save the optional positional data if needed, if file_mgr_data->host
2095 is set to NULL, this is from a save settings, don't save the position
2098 SavePositionalData(fd, file_mgr_data, name_list, FILEMGR);
2101 /* Get a copy of the name list to be used to build new name lists */
2102 _DtDuplicateDialogNameList(name_list, new_name_list, 20, &name_list_count);
2104 /* Write out all of the dialogs */
2106 _DtWriteDialogData (file_mgr_data->change_dir, fd, name_list);
2107 _DtWriteDialogData (file_mgr_data->preferences, fd, name_list);
2110 /* Save any properties dialogs */
2111 _DtSaveSubdialogArray(new_name_list, name_list_count,
2112 file_mgr_data->attr_dialog_list,
2113 file_mgr_data->attr_dialog_count, fd, 1);
2115 /* Save any secondary help dialogs */
2116 _DtSaveSubdialogArray(new_name_list, name_list_count,
2117 file_mgr_data->secondaryHelpDialogList,
2118 file_mgr_data->secondaryHelpDialogCount, fd, 1);
2120 /* Save the primary help dialog, if active */
2121 if (file_mgr_data->primaryHelpDialog)
2123 new_name_list[name_list_count] = number;
2124 new_name_list[name_list_count + 1] = NULL;
2125 sprintf(number, "%d", 0);
2126 _DtWriteDialogData(file_mgr_data->primaryHelpDialog, fd, new_name_list);
2129 tmpStr = GetSharedMessage(FILTER_EDIT_ID_STRING);
2130 new_name_list[name_list_count] = XtNewString (tmpStr);
2131 new_name_list[name_list_count + 1] = NULL;
2132 _DtWriteDialogData (file_mgr_data->filter_edit, fd, new_name_list);
2133 XtFree ((char *) new_name_list[name_list_count]);
2134 new_name_list[name_list_count] = NULL;
2136 tmpStr = GetSharedMessage(FILTER_ACTIVE_ID_STRING);
2137 new_name_list[name_list_count] = XtNewString (tmpStr);
2138 new_name_list[name_list_count + 1] = NULL;
2139 _DtWriteDialogData (file_mgr_data->filter_active, fd, new_name_list);
2140 XtFree ((char *) new_name_list[name_list_count]);
2141 new_name_list[name_list_count] = NULL;
2143 _DtWriteDialogData (file_mgr_data->find, fd, name_list);
2149 /************************************************************************
2152 * Free up space allocated by the FileMgr dialog. This
2153 * includes sub directory information, and attached dialog data.
2155 * Note: this routine frees the FileMgrData, not the FileMgrRec
2156 * (the FileMgrRec data structure will be reused by the dialog
2157 * caching code for the next dtfile window the user might open)
2159 ************************************************************************/
2163 FileMgrData *file_mgr_data )
2167 FileMgrRec *file_mgr_rec;
2169 if (file_mgr_data == NULL)
2172 file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;
2174 FreeDirectoryData (file_mgr_data);
2176 if (file_mgr_data->branch_list != NULL)
2178 for (i = 0; file_mgr_data->branch_list[i]; i++)
2179 XtFree (file_mgr_data->branch_list[i]);
2180 XtFree ((char *) file_mgr_data->branch_list);
2181 file_mgr_data->branch_list = NULL;
2184 if (file_mgr_data->selection_list != NULL)
2186 XtFree ((char *) file_mgr_data->selection_list);
2187 file_mgr_data->selection_list = NULL;
2190 if (file_mgr_data->cd_select != NULL)
2192 XtFree ((char *) file_mgr_data->cd_select);
2193 file_mgr_data->cd_select = NULL;
2196 if (file_mgr_data->desktop_file != NULL)
2198 XtFree ((char *) file_mgr_data->desktop_file);
2199 file_mgr_data->desktop_file = NULL;
2203 XtFree(file_mgr_data->special_msg);
2204 file_mgr_data->special_msg = NULL;
2205 if (file_mgr_data->msg_timer_id)
2206 XtRemoveTimeOut(file_mgr_data->msg_timer_id);
2208 _DtDestroySubdialog(file_mgr_data->change_dir);
2209 _DtDestroySubdialog(file_mgr_data->preferences);
2210 _DtDestroySubdialog(file_mgr_data->filter_edit);
2211 _DtDestroySubdialog(file_mgr_data->filter_active);
2212 _DtDestroySubdialog(file_mgr_data->find);
2213 _DtDestroySubdialogArray(file_mgr_data->attr_dialog_list,
2214 file_mgr_data->attr_dialog_count);
2215 _DtDestroySubdialogArray(file_mgr_data->secondaryHelpDialogList,
2216 file_mgr_data->secondaryHelpDialogCount);
2217 _DtDestroySubdialog(file_mgr_data->primaryHelpDialog);
2220 && file_mgr_data != trashFileMgrData
2221 && file_mgr_data != NULL )
2223 /* Free up the GC's we got in SetValues */
2224 if(file_mgr_data->cd_normal_gc != NULL)
2225 XtReleaseGC(file_mgr_rec->current_directory,
2226 file_mgr_data->cd_normal_gc);
2227 if(file_mgr_data->cd_select_gc != NULL)
2228 XtReleaseGC(file_mgr_rec->current_directory_icon,
2229 file_mgr_data->cd_select_gc);
2231 if(file_mgr_data->tree_solid_thin_gc != NULL)
2232 XtReleaseGC(file_mgr_rec->current_directory_icon,
2233 file_mgr_data->tree_solid_thin_gc);
2234 if(file_mgr_data->tree_solid_thick_gc != NULL)
2235 XtReleaseGC(file_mgr_rec->current_directory_icon,
2236 file_mgr_data->tree_solid_thick_gc);
2237 if(file_mgr_data->tree_dash_thin_gc != NULL)
2238 XtReleaseGC(file_mgr_rec->current_directory_icon,
2239 file_mgr_data->tree_dash_thin_gc);
2240 if(file_mgr_data->tree_dash_thick_gc != NULL)
2241 XtReleaseGC(file_mgr_rec->current_directory_icon,
2242 file_mgr_data->tree_dash_thick_gc);
2245 FreeLayoutData(file_mgr_data->layout_data);
2247 { /* This block is added for rectifying memory leakages */
2248 XtFree(file_mgr_data->scrollToThisFile);
2249 XtFree(file_mgr_data->scrollToThisDirectory);
2252 XtFree ((char *) file_mgr_data);
2256 /************************************************************************
2259 * Destroy widgets and free up space allocated by the FileMgr dialog.
2260 * Called when the dialog is destroyed.
2262 ************************************************************************/
2266 XtPointer recordPtr )
2268 FileMgrRec *file_mgr_rec = (FileMgrRec *) recordPtr;
2270 XtDestroyWidget(file_mgr_rec->shell);
2272 XtFree(file_mgr_rec->action_pane_file_type);
2273 XtFree((char *)file_mgr_rec);
2282 Cardinal *num_params )
2284 XmDrawingAreaCallbackStruct cb ;
2285 FileMgrRec * fileMgrRec;
2287 Widget input_on_gadget ;
2289 if ((event->type == KeyPress)
2290 ||(event->type == KeyRelease))
2298 cb.reason = XmCR_INPUT;
2301 if( *(params[0]) != '@' )
2303 char * title = XtNewString( GETMESSAGE(12, 7, "File Manager") );
2304 char * tmp = "Gjmf Nbobhfs ufbn:\n\nTboez Bnjo\nEbo Ebp\nSbhiv Lspwwjej\nUfe Sbotpn\nMjoeb Sjfl\nGsbol Tdinvdl\nNvsbmj Tpnbspvuiv\n";
2306 int i, len = strlen( tmp );
2308 message = (char *)XtCalloc( 1, len + 1 );
2310 /* Not fancy, but serve the purpose */
2311 for( i = 0; i < len; ++i ){
2312 (( isalpha( tmp[i] ) ) ? (message[i] = (int)(tmp[i]) - 1) : (message[i] = tmp[i]));
2316 sscanf( params[0], "%lx", &fileMgrRec );
2318 sscanf( params[0], "%p", &fileMgrRec );
2320 _DtMessage(toplevel, title, message, NULL, HelpRequestCB);
2328 /************************************************************************
2329 ************************************************************************
2331 * Resource converters
2333 ************************************************************************
2334 ************************************************************************/
2337 /************************************************************************
2341 ************************************************************************/
2345 FileMgrData *file_mgr_data )
2347 if (restoreType == HOME_RESTORE) /* home settings restore */
2349 struct passwd * pwInfo;
2352 /* Set current_directory to the home dir */
2353 if ((homeDir = (char *)getenv("HOME")) == NULL)
2355 pwInfo = getpwuid (getuid());
2356 homeDir = pwInfo->pw_dir;
2359 file_mgr_data->current_directory = XtNewString(homeDir);
2361 file_mgr_data->current_directory =
2362 XtNewString(file_mgr_data->current_directory);
2364 if (file_mgr_data->restricted_directory)
2365 file_mgr_data->restricted_directory =
2366 XtNewString(file_mgr_data->restricted_directory);
2368 file_mgr_data->restricted_directory = NULL;
2370 else if (restoreType == TOOL_RESTORE) /* tool settings restore */
2372 file_mgr_data->current_directory =
2373 XtNewString(file_mgr_data->restricted_directory);
2375 if (file_mgr_data->restricted_directory)
2376 file_mgr_data->restricted_directory =
2377 XtNewString(file_mgr_data->restricted_directory);
2379 file_mgr_data->restricted_directory = NULL;
2381 else /* session restore */
2383 if ((file_mgr_data->current_directory) &&
2384 (file_mgr_data->toolbox) &&
2385 (file_mgr_data->host) &&
2386 (strcmp(file_mgr_data->host, file_mgr_data->current_directory) != 0))
2389 char *user_session_str;
2393 root_toolbox = (file_mgr_data->host);
2395 user_session_str = getenv("DTUSERSESSION");
2396 /* the restricted directory for any object is a parent of that *
2397 * object; the restricted directory for toolboxes is the root *
2398 * toolbox; the current toolbox dir is identified by the path *
2399 * information past the restricted dir/root toolbox */
2400 toolbox_dir = file_mgr_data->current_directory;
2401 toolbox_dir += strlen(file_mgr_data->restricted_directory);
2403 current_dir = XtMalloc(strlen(root_toolbox) +
2404 strlen(user_session_str) +
2405 strlen(toolbox_dir) + 1);
2406 sprintf(current_dir, "%s%s%s", root_toolbox,
2409 file_mgr_data->current_directory = current_dir;
2411 file_mgr_data->restricted_directory = XtMalloc(strlen(root_toolbox) +
2412 strlen(user_session_str) +
2414 sprintf(file_mgr_data->restricted_directory, "%s%s", root_toolbox,
2419 file_mgr_data->current_directory =
2420 XtNewString(file_mgr_data->current_directory);
2422 if (file_mgr_data->restricted_directory)
2423 file_mgr_data->restricted_directory =
2424 XtNewString(file_mgr_data->restricted_directory);
2426 file_mgr_data->restricted_directory = NULL;
2429 file_mgr_data->host = NULL;
2433 /************************************************************************
2436 * Given a file name get the right icon name for it.
2438 ************************************************************************/
2442 FileMgrRec *file_mgr_rec,
2443 FileMgrData *file_mgr_data,
2451 PixmapData * pixmapData;
2452 Tt_status tt_status;
2454 /* Display the correct small directory icon */
2455 ftype = GetDirectoryLogicalType(file_mgr_data, path);
2459 full_name = ResolveLocalPathName(file_mgr_data->host,
2464 if( TT_OK != tt_status )
2467 short_name = strrchr(full_name, '/');
2468 if (strcmp(short_name, "/.") == 0)
2470 if (short_name == full_name)
2473 short_name = strrchr(full_name, '/');
2475 if (strcmp(full_name, "/") == 0)
2476 short_name = full_name;
2478 *short_name++ = '\0';
2481 pixmapData = _DtRetrievePixmapData(ftype,
2484 file_mgr_rec->shell,
2487 pixmapData = _DtRetrievePixmapData(ftype,
2490 file_mgr_rec->shell,
2498 /************************************************************************
2500 * BranchListToString
2501 * Write out the array of strings to the file fd.
2503 ************************************************************************/
2512 Boolean first = True;
2517 (void) write (fd, out_buf, strlen (out_buf));
2520 branch_name = (*value)[i];
2522 while (branch_name != NULL)
2525 (void) write (fd, ", ", strlen (", "));
2529 (void) write (fd, branch_name, strlen (branch_name));
2532 branch_name = (*value)[i];
2535 (void) write (fd, "\n", strlen ("\n"));
2541 /************************************************************************
2543 * SelectionListToString
2544 * Write out the array of strings to the file fd.
2546 ************************************************************************/
2549 SelectionListToString(
2551 FileViewData ***value,
2555 Boolean first = True;
2556 FileViewData * file_view_data;
2557 DirectorySet * directory_set;
2561 (void) write (fd, out_buf, strlen (out_buf));
2564 file_view_data = (*value)[i];
2567 while (file_view_data != NULL)
2569 directory_set = (DirectorySet *) file_view_data->directory_set;
2572 (void) write (fd, ", ", strlen (", "));
2577 (void) write (fd, directory_set->name, strlen (directory_set->name));
2579 if (strcmp (directory_set->name, "/") != 0)
2580 (void) write (fd, "/", strlen ("/"));
2582 (void) write (fd, file_view_data->file_data->file_name,
2583 strlen (file_view_data->file_data->file_name));
2586 file_view_data = (*value)[i];
2589 (void) write (fd, "\n", strlen ("\n"));
2596 /************************************************************************
2598 * StringToBranchList
2599 * Convert a string to a string array.
2601 ************************************************************************/
2610 XtPointer *converter_data)
2612 static char ** table_ptr;
2615 char ** table = NULL;
2620 to_val->size = sizeof (char **);
2621 to_val->addr = (XtPointer) &table_ptr;
2623 if (from_val->addr == NULL)
2627 /* Loop through the string extracting branch names */
2628 /* and placing them into an array of strings. */
2630 current = start = (char *) from_val->addr;
2632 while (start != NULL)
2634 current = DtStrchr (start, ',');
2635 if (current != NULL)
2642 table = (char **) XtRealloc ((char *)table,
2643 sizeof (char *) * (table_size + 1));
2644 table[table_size] = NULL;
2646 table[table_size - 1] = XtNewString (start);
2652 to_val->addr = (XtPointer ) &table_ptr;
2653 to_val->size = sizeof(XtPointer);
2658 /************************************************************************
2660 * StringToSelectionList
2661 * Convert a string to a string array.
2663 ************************************************************************/
2666 StringToSelectionList(
2672 static char ** table_ptr;
2675 char ** table = NULL;
2680 to_val->size = sizeof (char **);
2681 to_val->addr = (XtPointer) &table_ptr;
2683 if (from_val->addr == NULL)
2687 /* Loop through the string extracting file specifications */
2688 /* and placing them into an array of strings. */
2690 current = start = (char *) from_val->addr;
2692 while (start != NULL)
2694 current = DtStrchr (start, ',');
2695 if (current != NULL)
2702 table = (char **) XtRealloc ((char *)table,
2703 sizeof (char *) * (table_size + 1));
2704 table[table_size] = NULL;
2706 table[table_size - 1] = XtNewString (start);
2712 to_val->addr = (XtPointer ) &table_ptr;
2713 to_val->size = sizeof(XtPointer);
2719 /************************************************************************
2720 ************************************************************************
2722 File Mgr file and directory processing functions.
2724 ************************************************************************
2725 ************************************************************************/
2728 /************************************************************************
2731 * Update the iconic path and current directory line.
2733 ************************************************************************/
2737 * Update the status line label widget to show the right text.
2741 FileMgrRec *file_mgr_rec,
2742 FileMgrData *file_mgr_data)
2744 char buf[21+MAX_PATH];
2745 XmString label_string;
2748 if (file_mgr_data->special_msg &&
2749 (file_mgr_data->busy_status == initiating_readdir ||
2750 file_mgr_data->busy_status == busy_readdir))
2752 SetSpecialMsg( file_mgr_rec, file_mgr_data, NULL );
2755 if (file_mgr_data->special_msg)
2757 label_string = XmStringCreateLocalized(file_mgr_data->special_msg);
2761 GetStatusMsg(file_mgr_data, buf);
2762 label_string = XmStringCreateLocalized(buf);
2764 XtSetArg (args[0], XmNlabelString, label_string);
2765 XtSetValues(file_mgr_rec->status_line, args, 1);
2766 XmStringFree (label_string);
2772 * Timeout routine that resets the status line after a
2773 * special message was shown (see also SetSpecialMsg).
2777 FileMgrData *file_mgr_data,
2780 FileMgrRec *file_mgr_rec;
2782 if (*id != file_mgr_data->msg_timer_id)
2785 file_mgr_data->msg_timer_id = 0;
2787 if (file_mgr_data->special_msg)
2789 XtFree(file_mgr_data->special_msg);
2790 file_mgr_data->special_msg = NULL;
2791 if (file_mgr_data->show_status_line)
2793 file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;
2794 UpdateStatusLine(file_mgr_rec, file_mgr_data);
2802 * Arrange for a special message to be shown in the status line.
2803 * After 4 seconds the status line will revert back to the usual
2804 * "x Files, y Hidden" message.
2808 FileMgrRec *file_mgr_rec,
2809 FileMgrData *file_mgr_data,
2812 if (file_mgr_data->special_msg)
2814 XtFree(file_mgr_data->special_msg);
2815 file_mgr_data->special_msg = NULL;
2817 if (file_mgr_data->msg_timer_id)
2818 XtRemoveTimeOut(file_mgr_data->msg_timer_id);
2822 file_mgr_data->special_msg = XtNewString(msg);
2823 file_mgr_data->msg_timer_id =
2824 XtAppAddTimeOut (XtWidgetToApplicationContext (file_mgr_rec->shell),
2825 4000, (XtTimerCallbackProc) MsgTimerEvent,
2826 (XtPointer) file_mgr_data);
2830 file_mgr_data->special_msg = NULL;
2831 file_mgr_data->msg_timer_id = 0;
2838 * Update the iconic path, current directory, and status lines.
2842 FileMgrRec *file_mgr_rec,
2843 FileMgrData *file_mgr_data,
2844 Boolean icons_changed)
2848 Widget cur_dir_manage[4];
2849 int cur_dir_nmanage;
2852 PixmapData *pixmapData;
2855 * No headers on the trash can.
2857 if (!showFilesystem)
2859 if(file_mgr_data->show_status_line)
2860 UpdateStatusLine(file_mgr_rec, file_mgr_data);
2863 else if(file_mgr_data == trashFileMgrData
2866 UpdateStatusLine(file_mgr_rec, file_mgr_data);
2871 * Make sure the iconic path & current directory widgets are
2872 * correctly managed & attached.
2874 if ((file_mgr_data->show_iconic_path == 0) !=
2875 (XtIsManaged(file_mgr_rec->iconic_path_da) == 0) ||
2876 (file_mgr_data->show_current_dir == 0) !=
2877 (XtIsManaged(file_mgr_rec->current_directory_frame) == 0))
2879 icons_changed = True;
2882 "UpdateHeaders: iconic_path %d, current_dir %d, status_line %d\n",
2883 file_mgr_data->show_iconic_path,
2884 file_mgr_data->show_current_dir,
2885 file_mgr_data->show_status_line));
2887 if (!file_mgr_data->show_iconic_path && !file_mgr_data->show_current_dir)
2888 XtUnmanageChild(file_mgr_rec->header_frame);
2891 ((XmManagerWidget)file_mgr_rec->header_frame)->composite.children,
2892 ((XmManagerWidget)file_mgr_rec->header_frame)->composite.num_children);
2894 ((XmManagerWidget)file_mgr_rec->current_directory_frame)->
2896 ((XmManagerWidget)file_mgr_rec->current_directory_frame)->
2897 composite.num_children);
2900 /* attach the iconic path */
2901 if (file_mgr_data->show_iconic_path)
2904 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
2905 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2906 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
2907 if (file_mgr_data->show_current_dir)
2909 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
2913 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
2915 XtSetValues(file_mgr_rec->iconic_path_da, args, n);
2916 manage[nmanage++] = file_mgr_rec->iconic_path_da;
2919 /* attach the separator */
2920 if (file_mgr_data->show_iconic_path && file_mgr_data->show_current_dir)
2923 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
2924 XtSetArg (args[n], XmNtopWidget,
2925 file_mgr_rec->iconic_path_da); n++;
2926 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2927 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
2928 XtSetValues(file_mgr_rec->header_separator, args, n);
2929 manage[nmanage++] = file_mgr_rec->header_separator;
2932 /* attach the current directory line */
2933 if (file_mgr_data->show_current_dir)
2936 if (file_mgr_data->show_iconic_path)
2938 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
2939 XtSetArg (args[n], XmNtopWidget,
2940 file_mgr_rec->header_separator); n++;
2944 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
2946 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2947 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
2949 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
2951 XtSetValues(file_mgr_rec->current_directory_frame, args, n);
2952 manage[nmanage++] = file_mgr_rec->current_directory_frame;
2955 * If the iconic path is shown, show only the current directory on
2956 * the current directory line;
2957 * if the iconic path is not shown, also show the drop target and
2958 * the icon representing the current directory.
2960 cur_dir_nmanage = 1;
2961 cur_dir_manage[0] = file_mgr_rec->current_directory;
2963 if (file_mgr_data->show_iconic_path)
2966 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2967 XtSetArg (args[n], XmNleftOffset, 5); n++;
2968 XtSetValues(file_mgr_rec->current_directory, args, n);
2975 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2976 XtSetArg (args[n], XmNleftOffset, 5); n++;
2977 XtSetValues(file_mgr_rec->current_directory_drop, args, n);
2978 cur_dir_manage[cur_dir_nmanage++] =
2979 file_mgr_rec->current_directory_drop;
2982 XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
2983 XtSetArg (args[n], XmNleftWidget,
2984 file_mgr_rec->current_directory_drop); n++;
2985 XtSetArg (args[n], XmNleftOffset, 0); n++;
2990 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
2991 XtSetArg (args[n], XmNleftOffset, 10); n++;
2993 XtSetValues(file_mgr_rec->current_directory_icon, args, n);
2994 cur_dir_manage[cur_dir_nmanage++] =
2995 file_mgr_rec->current_directory_icon;
2998 XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
2999 XtSetArg (args[n], XmNleftWidget,
3000 file_mgr_rec->current_directory_icon);n++;
3001 XtSetArg (args[n], XmNleftOffset, 0); n++;
3002 XtSetValues(file_mgr_rec->current_directory, args, n);
3007 if (file_mgr_data->show_iconic_path || file_mgr_data->show_current_dir)
3009 if (file_mgr_data->show_current_dir)
3010 XtManageChildren(cur_dir_manage, cur_dir_nmanage);
3011 XtManageChildren(manage, nmanage);
3012 if (!XtIsManaged(file_mgr_rec->header_frame))
3013 XtManageChild(file_mgr_rec->header_frame);
3016 XtSetArg (args[0], XmNallowShellResize, True);
3017 XtSetValues(file_mgr_rec->shell, args, 1);
3021 * Make sure the status line is correctly managed.
3023 if (file_mgr_data->show_status_line &&
3024 !XtIsManaged(XtParent(file_mgr_rec->status_line)))
3026 XtManageChild(XtParent(file_mgr_rec->status_line));
3028 else if (!file_mgr_data->show_status_line &&
3029 XtIsManaged(XtParent(file_mgr_rec->status_line)))
3031 XtUnmanageChild(XtParent(file_mgr_rec->status_line));
3034 if (file_mgr_data->show_iconic_path)
3035 DtUpdateIconicPath(file_mgr_rec, file_mgr_data, icons_changed);
3037 if (file_mgr_data->show_current_dir)
3041 /* Display the correct small directory icon */
3042 pixmapData = GetPixmapData(file_mgr_rec,
3044 file_mgr_data->current_directory,
3046 XtSetArg (args[0], XmNallowShellResize, False);
3047 XtSetValues(file_mgr_rec->shell, args, 1);
3050 XtSetArg (args[0], XmNimageName, pixmapData->iconFileName);
3052 XtSetArg (args[0], XmNimageName, NULL);
3053 XtSetValues(file_mgr_rec->current_directory_icon, args, 1);
3054 _DtCheckAndFreePixmapData(
3055 GetDirectoryLogicalType(file_mgr_data,
3056 file_mgr_data->current_directory),
3057 file_mgr_rec->shell,
3058 (DtIconGadget) file_mgr_rec->current_directory_icon,
3061 XtSetArg (args[0], XmNallowShellResize, True);
3062 XtSetValues(file_mgr_rec->shell, args, 1);
3064 if(XtIsRealized(file_mgr_rec->main))
3065 DrawCurrentDirectory (file_mgr_rec->current_directory,
3066 file_mgr_rec, file_mgr_data);
3069 if (file_mgr_data->show_status_line)
3070 UpdateStatusLine(file_mgr_rec, file_mgr_data);
3074 /************************************************************************
3076 * FileMgrRedisplayFiles
3077 * Reprocess and redisplay the files of a view.
3079 ************************************************************************/
3082 FileMgrRedisplayFiles(
3083 FileMgrRec *file_mgr_rec,
3084 FileMgrData *file_mgr_data,
3085 Boolean new_directory)
3087 _DtTurnOnHourGlass (file_mgr_rec->shell);
3088 GetFileData (file_mgr_data, True, file_mgr_data->branch_list);
3089 XmDropSiteStartUpdate(file_mgr_rec->file_window);
3090 UpdateFileIcons(file_mgr_rec, file_mgr_data, new_directory);
3091 UpdateHeaders (file_mgr_rec, file_mgr_data, False);
3092 LayoutFileIcons(file_mgr_rec, file_mgr_data, False, False);
3093 XmDropSiteEndUpdate(file_mgr_rec->file_window);
3094 _DtTurnOffHourGlass (file_mgr_rec->shell);
3100 /************************************************************************
3103 * Update the view to the new directory.
3105 ************************************************************************/
3109 FileMgrData *file_mgr_data,
3111 char *directory_name )
3113 FileMgrRec * file_mgr_rec;
3115 char tmp_directory_name[MAX_PATH];
3121 tmp_type = DtDtsDataToDataType(directory_name, NULL, 0, NULL, NULL,
3123 if (( (strcmp(tmp_type, LT_AGROUP) == 0) ||
3124 (strstr(tmp_type, LT_AGROUP_SUBDIR)) )
3126 ( !(file_mgr_data->toolbox) ))
3128 DtActionArg *action_args;
3131 action_args = (DtActionArg *) XtCalloc(1, sizeof(DtActionArg));
3134 action_args[0].argClass = DtACTION_FILE;
3135 action_args[0].u.file.name = directory_name;
3138 pwd_dir = XtNewString(file_mgr_data->current_directory);
3139 DtActionInvoke(((FileMgrRec *) file_mgr_data->file_mgr_rec)->shell,
3140 "OpenAppGroup", action_args, 1,
3141 NULL, NULL, pwd_dir, True, NULL, NULL);
3142 DtDtsFreeDataType(tmp_type);
3146 else if (strcmp(tmp_type, LT_TRASH) == 0)
3148 DtActionArg *action_args;
3151 pwd_dir = XtNewString(file_mgr_data->current_directory);
3152 DtActionInvoke(((FileMgrRec *) file_mgr_data->file_mgr_rec)->shell,
3154 NULL, NULL, pwd_dir, True, NULL, NULL);
3155 DtDtsFreeDataType(tmp_type);
3159 DtDtsFreeDataType(tmp_type);
3161 if (openDirType == NEW)
3163 DialogData *dialog_data;
3164 FileMgrData *fileMgrData;
3166 fileMgrData = CheckOpenDir(directory_name, host_name);
3167 if(fileMgrData != NULL)
3169 dialog_data = _DtGetInstanceData(fileMgrData->file_mgr_rec);
3170 CloseView(dialog_data);
3172 ForceMyIconClosed(file_mgr_data->host, file_mgr_data->current_directory);
3175 file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;
3177 /* Set the icon name for this view to the directory name. */
3179 SetIconAttributes ((FileMgrRec *)file_mgr_data->file_mgr_rec, file_mgr_data,
3182 _DtTurnOnHourGlass (file_mgr_rec->shell);
3184 DeselectAllFiles (file_mgr_data);
3185 ActivateNoSelect (file_mgr_rec);
3187 /* When leaving a directory, save any positional information */
3188 if(file_mgr_data->object_positions)
3190 SavePositionInfo(file_mgr_data);
3191 FreePositionInfo(file_mgr_data);
3194 /* save the current branch list */
3195 branch_list = file_mgr_data->branch_list;
3196 file_mgr_data->branch_list = NULL;
3198 FileMgrBuildDirectories (file_mgr_data, host_name, directory_name);
3200 GetFileData (file_mgr_data, True, branch_list);
3202 if (branch_list != NULL)
3204 for (i = 0; branch_list[i]; i++)
3205 XtFree (branch_list[i]);
3206 XtFree ((char *) branch_list);
3209 UpdateCachedDirectories (view_set, view_count);
3211 /* Inherit, or load positional data for this directory */
3212 XmDropSiteStartUpdate(file_mgr_rec->file_window);
3213 LoadPositionInfo(file_mgr_data);
3214 UpdateFileIcons(file_mgr_rec, file_mgr_data, True);
3216 if (showFilesystem && file_mgr_data != trashFileMgrData)
3217 UpdateHeaders (file_mgr_rec, file_mgr_data, True);
3218 else if(file_mgr_data == trashFileMgrData
3219 && file_mgr_data != NULL )
3220 UpdateStatusLine(file_mgr_rec, file_mgr_data);
3222 /* change the title */
3223 title = _DtBuildFMTitle(file_mgr_data);
3224 XtSetArg (args[0], XmNtitle, title);
3225 XtSetValues (file_mgr_rec->shell, args, 1);
3228 if (file_mgr_data->show_type == SINGLE_DIRECTORY)
3229 LayoutFileIcons(file_mgr_rec, file_mgr_data, True, True);
3231 LayoutFileIcons(file_mgr_rec, file_mgr_data, False, True);
3233 if (openDirType == NEW)
3234 ForceMyIconOpen (file_mgr_data->host, NULL);
3235 XmDropSiteEndUpdate(file_mgr_rec->file_window);
3241 /************************************************************************
3244 * This function causes a rescan of the directory for the view
3245 * and a full redisplay of the file icons.
3247 ************************************************************************/
3251 FileMgrRec *file_mgr_rec )
3253 DialogData * dialog_data;
3254 FileMgrData * file_mgr_data;
3255 DirectorySet ** directory_set;
3259 dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
3260 file_mgr_data = (FileMgrData *) dialog_data->data;
3262 _DtTurnOnHourGlass (file_mgr_rec->shell);
3264 directory_set = file_mgr_data->directory_set;
3266 for (i = 0; i < file_mgr_data->directory_count; i++)
3267 RereadDirectory (file_mgr_rec->shell, file_mgr_data->host,
3268 directory_set[i]->name);
3270 GetFileData (file_mgr_data, False, file_mgr_data->branch_list);
3271 XmDropSiteStartUpdate(file_mgr_rec->file_window);
3272 UpdateFileIcons(file_mgr_rec, file_mgr_data, False);
3273 UpdateHeaders (file_mgr_rec, file_mgr_data, False);
3274 LayoutFileIcons(file_mgr_rec, file_mgr_data, False, True);
3275 XmDropSiteEndUpdate(file_mgr_rec->file_window);
3276 /* _DtTurnOffHourGlass (file_mgr_rec->shell); */
3281 /************************************************************************
3283 * FileMgrBuildDirectories
3284 * Given a directory name, setup the directory set structure
3285 * contained in the file mgr data stucture.
3287 ************************************************************************/
3290 FileMgrBuildDirectories(
3291 FileMgrData *file_mgr_data,
3293 char *directory_name )
3295 char current_directory[MAX_PATH];
3296 DirectorySet ** directory_set;
3298 /* Inform Main that the directory is being changed and */
3299 /* free up the data contained in the current directory set. */
3301 if (file_mgr_data->current_directory != NULL)
3303 DirectoryChanged ((XtPointer)file_mgr_data, file_mgr_data->host, host_name,
3304 file_mgr_data->current_directory, directory_name);
3305 FreeDirectoryData (file_mgr_data);
3308 file_mgr_data->current_directory = (char *) XtNewString(directory_name);
3309 (void) strcpy (current_directory, file_mgr_data->current_directory);
3311 /* This code will solve the path problem if user has
3312 Dtfile*restrictMode resource set to True and
3313 also invoke dtfile with -restricted option
3316 && file_mgr_data->toolbox == False
3317 && file_mgr_data->restricted_directory
3318 && strncmp( file_mgr_data->restricted_directory, directory_name,
3319 strlen( file_mgr_data->restricted_directory ) ) != 0
3322 XtFree( file_mgr_data->restricted_directory );
3323 file_mgr_data->restricted_directory = XtNewString( directory_name );
3326 if (file_mgr_data->host != NULL)
3327 XtFree ((char *) file_mgr_data->host);
3329 file_mgr_data->host = (char *) XtNewString (host_name);
3332 /* Allocate the data for one initial directory set */
3334 file_mgr_data->directory_set = directory_set =
3335 ((DirectorySet **) XtMalloc (2 * sizeof(DirectorySet *))) + 1;
3336 file_mgr_data->directory_count = 1;
3338 directory_set[-1] = NULL;
3340 directory_set[0] = (DirectorySet *) XtMalloc (sizeof (DirectorySet));
3341 directory_set[0]->name = (char *) XtNewString (current_directory);
3342 directory_set[0]->sub_root = NULL;
3343 directory_set[0]->file_count = 0;
3344 directory_set[0]->file_view_data = NULL;
3345 directory_set[0]->order_list = NULL;
3346 directory_set[0]->filtered_file_count = 0;
3347 directory_set[0]->invisible_file_count = 0;
3348 directory_set[0]->file_mgr_data = (XtPointer) file_mgr_data;
3354 FileMgrData * file_mgr_data,
3359 static Region r = NULL;
3360 unsigned char flags;
3361 XRectangle pRect, lRect;
3363 if ((file_mgr_data->show_type != SINGLE_DIRECTORY) ||
3364 (file_mgr_data->view == BY_ATTRIBUTES))
3368 && x < (Position)(w->core.x + w->core.width)
3369 && y < (Position)(w->core.y + w->core.height)
3378 r = XCreateRegion();
3380 XSubtractRegion(r, r, r);
3382 _DtIconGetIconRects((DtIconGadget)w, &flags, &pRect, &lRect);
3384 if (flags & XmPIXMAP_RECT)
3385 XUnionRectWithRegion(&pRect, r, r);
3387 if (flags & XmLABEL_RECT)
3388 XUnionRectWithRegion(&lRect, r, r);
3390 if (XPointInRegion(r, x, y))
3399 * Check to see if the drop occurred within one of the primary hotspots.
3400 * If this is the desktop, then we need to check the hotspots according
3401 * to their stacking order; all other views have their hotspots checked
3402 * according to the order the files were loaded, since overlapping hotspots
3407 DropOnPrimaryHotspot (
3408 FileMgrData * file_mgr_data,
3411 DirectorySet ** directory_data)
3413 int directory_count;
3415 FileViewData * file_view_data;
3416 DirectorySet * dir_data;
3419 if (PositioningEnabledInView(file_mgr_data))
3421 top = GetTopOfStack(file_mgr_data);
3425 file_view_data = top->file_view_data;
3427 if(file_view_data == NULL)
3433 if (file_view_data->displayed &&
3434 DropOnGadget(file_mgr_data, file_view_data->widget, drop_x, drop_y))
3436 *directory_data = file_mgr_data->directory_set[0];
3437 return(file_view_data);
3445 if (file_mgr_data->show_type == MULTIPLE_DIRECTORY) {
3447 directory_count = file_mgr_data->directory_count;
3451 directory_count = 1;
3454 for (; i < directory_count; i++)
3456 dir_data = file_mgr_data->directory_set[i];
3458 for (j = 0; j < dir_data->file_count; j++)
3460 file_view_data = dir_data->file_view_data[j];
3462 if (!file_view_data->displayed)
3465 if (DropOnGadget(file_mgr_data, file_view_data->widget, drop_x,
3468 *directory_data = dir_data;
3469 return(file_view_data);
3475 *directory_data = NULL;
3481 /************************************************************************
3483 * ProcessDropOnFileWindow
3485 ************************************************************************/
3487 ProcessDropOnFileWindow (
3489 DtDndDropCallbackStruct *dropInfo,
3490 FileMgrData *file_mgr_data)
3492 char *command = NULL;
3495 /******************/
3496 /* transfer phase */
3497 /******************/
3498 if(dropInfo->reason != DtCR_DND_DROP_ANIMATE)
3502 XmDragContext drag_context;
3504 /* Initiating view not valid when another client initiates drag */
3506 initiating_view = NULL;
3508 /* reject the drop if the Protocol is buffer and it was
3509 dropped on the Trash Can
3511 if (dropInfo->dropData->protocol == DtDND_BUFFER_TRANSFER)
3513 if (file_mgr_data == trashFileMgrData
3514 && file_mgr_data != NULL )
3516 dropInfo->status = DtDND_FAILURE;
3517 DPRINTF (("ProcessDropOnFileWindow: Rejecting buffer drop on Trash Can\n"));
3523 /* if placement is 'As Placed', set blend model to BLEND_NONE */
3524 /* @@@...Need to check if this will work correctly for BUFFERS */
3525 if (PositioningEnabledInView(file_mgr_data))
3527 drag_context = (XmDragContext)dropInfo->dragContext;
3531 XtSetArg(args[0], XmNblendModel, XmBLEND_NONE);
3532 XtSetValues((Widget)drag_context, args, 1);
3535 /* if placement is 'Grid' */
3538 /* if initiating view is current view, set status
3541 if (initiating_view)
3543 if ((((FileMgrData *)initiating_view)->current_directory ==
3544 file_mgr_data->current_directory) &&
3545 (dropInfo->dropData->protocol == DtDND_FILENAME_TRANSFER))
3547 /* we actually want to allow a copy or a link to the same directory
3548 * but not a move. If it's a copy or link, we want the initiating
3549 * view to be NULL so that later we don't error out when it checks
3550 * to see if they are from the same view. We will fail out if the
3551 * operation is a MOVE (causing the zoom back).
3553 fileType = GetDirectoryLogicalType(file_mgr_data,
3554 file_mgr_data->current_directory);
3556 command = TypeToAction(dropInfo->operation, fileType);
3559 if (strcmp(command, "FILESYSTEM_MOVE") == 0)
3560 dropInfo->status = DtDND_FAILURE;
3562 initiating_view = NULL;
3568 /* set the complete move flag to False since the animate
3569 callback handles the deletion of the original file on the move
3572 DPRINTF(("DropOnFileWindow: Transfer Callback - Setting Complete move flag to False\n"));
3574 if(dropInfo->dropData->protocol == DtDND_BUFFER_TRANSFER)
3575 dropInfo->completeMove = True;
3577 /* set the complete move flag to False since we will be handling */
3578 /* the deletion of the original file */
3580 dropInfo->completeMove = False;
3583 /*****************************/
3584 /* animate phase, run action */
3585 /*****************************/
3588 char *command = NULL;
3591 DPRINTF(("DropOnFileWindow - Animate Callback."));
3593 fileType = GetDirectoryLogicalType(file_mgr_data,
3594 file_mgr_data->current_directory);
3596 command = TypeToAction(dropInfo->operation, fileType);
3600 DirectorySet *directory_set;
3603 /* retrieve the fileViewData for the current directory */
3604 directory_set = file_mgr_data->directory_set[0];
3605 for( i = 0; i < directory_set->file_count; ++i )
3607 if( strcmp(directory_set->order_list[i]->file_data->file_name, "." )
3610 RunCommand( command,
3612 directory_set->order_list[i],
3619 DtDtsFreeAttributeValue( command );
3625 /************************************************************************
3629 ************************************************************************/
3634 XtPointer client_data,
3635 XtPointer call_data)
3637 FileMgrData * file_mgr_data = (FileMgrData *)client_data;
3638 DtDndDropCallbackStruct *dropInfo = (DtDndDropCallbackStruct *)call_data;
3640 switch (dropInfo->dropData->protocol)
3642 case DtDND_FILENAME_TRANSFER:
3644 DPRINTF(("DropOnFileWindow: Number of Files dropped are %d\n",
3645 dropInfo->dropData->numItems));
3646 ProcessDropOnFileWindow (w, dropInfo, file_mgr_data);
3648 case DtDND_BUFFER_TRANSFER:
3649 DPRINTF (("DropOnFileWindow: Number of Buffers dropped are %d\n",
3650 dropInfo->dropData->numItems));
3651 ProcessDropOnFileWindow (w, dropInfo, file_mgr_data);
3654 dropInfo->status = DtDND_FAILURE;
3659 /************************************************************************
3661 * ProcessDropOnObject
3663 ************************************************************************/
3665 ProcessDropOnObject(
3667 DtDndDropCallbackStruct *dropInfo,
3668 FileViewData *file_view_data)
3672 DirectorySet *directory_data =
3673 (DirectorySet *) file_view_data->directory_set;
3674 FileMgrData *file_mgr_data = (FileMgrData *) directory_data->file_mgr_data;
3675 char *command = NULL;
3677 /******************/
3678 /* transfer phase */
3679 /******************/
3680 if (dropInfo->reason != DtCR_DND_DROP_ANIMATE)
3682 DPRINTF(("DropOnObject: Transfer Callback\n"));
3684 /* Initiating view not valid when another client initiates drag */
3686 initiating_view = NULL;
3688 /* check for invalid trash drop */
3689 if (FileFromTrash(dropInfo->dropData->data.files[0]))
3691 if (InvalidTrashDragDrop(dropInfo->operation,
3693 ((FileMgrRec *)file_mgr_data->file_mgr_rec)->file_window))
3695 dropInfo->status = DtDND_FAILURE;
3699 command = TypeToAction(dropInfo->operation,
3700 file_view_data->file_data->logical_type);
3702 (strncmp("FILESYSTEM_", command, strlen("FILESYSTEM_")) != 0) &&
3703 dropInfo->dropData->protocol == DtDND_BUFFER_TRANSFER)
3704 dropInfo->completeMove = True;
3706 /* set the complete move flag to False since we will be handling */
3707 /* the deletion of the original file */
3708 dropInfo->completeMove = False;
3711 /******************************************/
3712 /* animate phase, retrieve action and run */
3713 /******************************************/
3716 command = TypeToAction(dropInfo->operation,
3717 file_view_data->file_data->logical_type);
3720 RunCommand (command,
3727 DtDtsFreeAttributeValue(command);
3733 /************************************************************************
3737 ************************************************************************/
3742 XtPointer client_data,
3743 XtPointer call_data)
3745 DtDndDropCallbackStruct *dropInfo = (DtDndDropCallbackStruct *)call_data;
3747 switch (dropInfo->dropData->protocol)
3749 case DtDND_FILENAME_TRANSFER:
3750 case DtDND_BUFFER_TRANSFER:
3751 ProcessDropOnObject(w, dropInfo, (FileViewData *) client_data);
3754 dropInfo->status = DtDND_FAILURE;
3759 /************************************************************************
3761 * FileMgrPropagateSettings
3762 * Set a new (dst_data) file manager view settings to an
3763 * old (src_data) settings.
3765 ************************************************************************/
3768 FileMgrPropagateSettings(
3769 FileMgrData *src_data,
3770 FileMgrData *dst_data )
3773 PreferencesData * src_preferences_data;
3774 PreferencesData * dst_preferences_data;
3776 FilterData * src_filter_active_data;
3777 FilterData * dst_filter_active_data;
3778 FilterData * src_filter_edit_data;
3779 FilterData * dst_filter_edit_data;
3782 Dimension src_width;
3783 Dimension src_height;
3785 /* Copy the preferences data from src to dst data */
3787 src_preferences_data = (PreferencesData *) src_data->preferences->data;
3788 dst_preferences_data = (PreferencesData *) dst_data->preferences->data;
3790 dst_data->show_type = dst_preferences_data->show_type = src_data->show_type;
3791 dst_data->tree_files = dst_preferences_data->tree_files =
3792 src_data->tree_files;
3793 dst_data->view = src_data->view;
3794 dst_data->view_single = dst_preferences_data->view_single =
3795 src_data->view_single;
3796 dst_data->view_tree = dst_preferences_data->view_tree =
3797 src_data->view_tree;
3798 dst_data->order = dst_preferences_data->order = src_data->order;
3799 dst_data->direction = dst_preferences_data->direction = src_data->direction;
3800 dst_data->positionEnabled = dst_preferences_data->positionEnabled =
3801 src_data->positionEnabled;
3802 dst_data->show_iconic_path = dst_preferences_data->show_iconic_path =
3803 src_data->show_iconic_path;
3804 dst_data->show_current_dir = dst_preferences_data->show_current_dir =
3805 src_data->show_current_dir;
3806 dst_data->show_status_line = dst_preferences_data->show_status_line =
3807 src_data->show_status_line;
3810 /* Copy the Filter active info from src to dest data */
3811 src_filter_active_data = (FilterData *) src_data->filter_active->data;
3812 dst_filter_active_data = (FilterData *) dst_data->filter_active->data;
3814 dst_filter_active_data->match_flag = src_filter_active_data->match_flag;
3815 dst_filter_active_data->filter = XtNewString(src_filter_active_data->filter);
3816 dst_filter_active_data->show_hidden = src_filter_active_data->show_hidden;
3817 dst_filter_active_data->filetypesFilteredCount =
3818 src_filter_active_data->filetypesFilteredCount;
3819 XtFree(dst_filter_active_data->filetypesFiltered);
3820 dst_filter_active_data->filetypesFiltered =
3821 XtNewString(src_filter_active_data->filetypesFiltered);
3822 dst_filter_active_data->count = ReadInFiletypes(dst_filter_active_data);
3824 /* Copy the Filter edit info from src to dest data */
3825 src_filter_edit_data = (FilterData *) src_data->filter_edit->data;
3826 dst_filter_edit_data = (FilterData *) dst_data->filter_edit->data;
3828 dst_filter_edit_data->match_flag = src_filter_edit_data->match_flag;
3829 dst_filter_edit_data->filter = XtNewString(src_filter_edit_data->filter);
3830 dst_filter_edit_data->show_hidden = src_filter_edit_data->show_hidden;
3831 dst_filter_edit_data->filetypesFilteredCount =
3832 src_filter_edit_data->filetypesFilteredCount;
3833 XtFree(dst_filter_edit_data->filetypesFiltered);
3834 dst_filter_edit_data->filetypesFiltered =
3835 XtNewString(src_filter_edit_data->filetypesFiltered);
3836 dst_filter_edit_data->count = ReadInFiletypes(dst_filter_edit_data);
3838 /* Get the size info (e.g. X, Y) form src to dest data */
3839 XtSetArg (args[0], XmNwidth, &src_width);
3840 XtSetArg (args[1], XmNheight, &src_height);
3841 XtGetValues (((FileMgrRec *) src_data->file_mgr_rec)->shell, args, 2);
3843 dst_data->height = src_height;
3844 dst_data->width = src_width;
3846 /* need to propagate whether its a toolbox or not */
3847 dst_data->toolbox = src_data->toolbox;
3851 /************************************************************************
3854 * Update the list of open tree branches
3856 ************************************************************************/
3860 FileMgrData *file_mgr_data,
3861 DirectorySet *directory_set)
3864 char ** table = NULL;
3869 /* check if the given directory set is already in the table */
3870 if (directory_set && file_mgr_data->branch_list) {
3871 for (i = 0; file_mgr_data->branch_list[i]; i++)
3872 if (strcmp(file_mgr_data->branch_list[i] + 2, directory_set->name) == 0)
3874 /* just update the TreeShow value for this branch and return */
3875 file_mgr_data->branch_list[i][0] = '0' + directory_set->sub_root->ts;
3880 /* free old branch_list, if any */
3881 if (file_mgr_data->branch_list) {
3882 for (i = 0; file_mgr_data->branch_list[i]; i++)
3883 XtFree (file_mgr_data->branch_list[i]);
3884 XtFree((char *)file_mgr_data->branch_list);
3885 file_mgr_data->branch_list = NULL;
3888 /* create new brach list */
3889 for (i = 0; i < file_mgr_data->directory_count; i++) {
3891 if (file_mgr_data->directory_set[i]->sub_root->ts < tsNotRead)
3894 /* get the name of the tree branch */
3895 branch_name = file_mgr_data->directory_set[i]->name;
3897 /* generate table entry */
3898 branch_entry = (char *)XtMalloc(2 + strlen(branch_name) + 1);
3899 branch_entry[0] = '0' + file_mgr_data->directory_set[i]->sub_root->ts;
3900 branch_entry[1] = ':';
3901 strcpy(branch_entry + 2, branch_name);
3903 /* add entry to the table */
3905 table = (char **)XtRealloc((char *)table,
3906 sizeof(char *) * (table_size + 1));
3907 table[table_size - 1] = branch_entry;
3908 table[table_size] = NULL;
3911 file_mgr_data->branch_list = table;
3915 /************************************************************************
3918 * Read the directory contained in host: current_directory and
3919 * build the file data list and reset any related information
3921 ************************************************************************/
3925 FileMgrData *file_mgr_data,
3929 FileMgrRec *file_mgr_rec;
3930 int directory_count;
3931 DirectorySet ** directory_set;
3932 DirectorySet ** new_dir_set;
3933 FileViewData ** new_view_data;
3934 FileViewData *new_renaming,*new_popup_menu_icon=NULL;
3935 FileViewData *file_view_data,*new_drag_file_view_data=NULL;
3938 ObjectPtr position_info;
3945 file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;
3946 directory_count = file_mgr_data->directory_count;
3947 directory_set = file_mgr_data->directory_set;
3950 * Read the directory and subdirectories given by branch_list.
3951 * Note: if any directory we need isn't yet in the cache,
3952 * ReadTreeDirectory will just kick off a background process
3953 * to read the directory and return with
3954 * file_mgr_data->busy_status set to busy_readdir.
3956 ReadTreeDirectory (file_mgr_rec->shell, file_mgr_data->host,
3957 file_mgr_data->current_directory,
3958 file_mgr_data, branch_list,
3959 &new_dir_set, &new_dir_count);
3961 /* if directories not ready yet, don't do anything */
3962 if (file_mgr_data->busy_status != not_busy)
3968 * Try to preserve the 'widget' and 'position_info' fields in the
3969 * file_view_data structure, for each file. This will allow us to
3970 * re-use the same Icon widget, to reduce flashing.
3971 * Also preserve ndir & nfile counts (used in FilterFiles to decide
3972 * whether to expand or collapse a tree branch if ndir or nfile
3976 /* loop through the old directory set */
3977 new_renaming = NULL;
3978 for (i = 0; i < directory_count; i++)
3980 /* find a directory with same name in the new directory set */
3981 for (j = 0; j < new_dir_count; j++)
3982 if (strcmp(directory_set[i]->name, new_dir_set[j]->name) == 0)
3985 /* if we couldn't find this directory, continue to the next one */
3986 if (j == new_dir_count)
3989 new_view_data = new_dir_set[j]->file_view_data;
3990 new_file_count = new_dir_set[j]->file_count;
3992 /* loop throught the old file list */
3993 for (j = 0; j < directory_set[i]->file_count; j++)
3995 file_view_data = directory_set[i]->file_view_data[j];
3996 position_info = file_view_data->position_info;
3999 * Find a file by the same name in the new file list.
4001 for (k = 0; k < new_file_count; k++)
4003 if (new_view_data[k]->file_data == file_view_data->file_data)
4005 /* Fix for defect 5029 */
4006 if(file_mgr_data->popup_menu_icon && file_view_data->file_data==
4007 file_mgr_data->popup_menu_icon->file_data)
4008 new_popup_menu_icon = new_view_data[k];
4010 /* Fix for defect 5703 */
4011 if ( file_mgr_data->drag_file_view_data &&
4012 file_mgr_data->drag_file_view_data->file_data ==
4013 file_view_data->file_data)
4014 new_drag_file_view_data = new_view_data[k];
4016 if (file_view_data == file_mgr_data->renaming)
4017 new_renaming = new_view_data[k];
4019 /* re-use the old widgets */
4020 new_view_data[k]->widget = file_view_data->widget;
4021 new_view_data[k]->treebtn = file_view_data->treebtn;
4022 new_view_data[k]->registered = file_view_data->registered;
4024 /* preserve ndir, nfile counts */
4025 new_view_data[k]->ndir = file_view_data->ndir;
4026 new_view_data[k]->nfile = file_view_data->nfile;
4028 /* preserve the position info */
4031 new_view_data[k]->position_info = position_info;
4032 position_info->file_view_data = new_view_data[k];
4035 /* preserve icon_mtime */
4036 new_view_data[k]->icon_mtime = file_view_data->icon_mtime;
4042 /* if no file by the same name was found in the new file list,
4043 the file must have gone away ... lets eliminate the
4044 position infomation */
4045 if (position_info && k == new_file_count)
4047 for (k = 0; k < file_mgr_data->num_objects; k++)
4049 if (file_mgr_data->object_positions[k] == position_info)
4051 /* @@@ what does this do? */
4052 position_info->late_bind = True;
4053 position_info->y += (file_view_data->widget->core.height / 2);
4060 /* replace the old directory set */
4061 file_mgr_data->directory_set = new_dir_set;
4062 file_mgr_data->directory_count = new_dir_count;
4063 file_mgr_data->renaming = new_renaming;
4064 file_mgr_data->popup_menu_icon = new_popup_menu_icon;
4065 file_mgr_data->drag_file_view_data = new_drag_file_view_data;
4067 /* Get the file types and the files sorted and filtered */
4068 for (i = 0; i < new_dir_count; i++)
4070 OrderFiles (file_mgr_data, new_dir_set[i]);
4071 FilterFiles (file_mgr_data, new_dir_set[i]);
4072 file_mgr_data->tree_root->filtered =
4073 file_mgr_data->show_type != MULTIPLE_DIRECTORY;
4075 SelectVisible(file_mgr_data);
4077 /* update the branch_list */
4078 UpdateBranchList(file_mgr_data, NULL);
4080 /* Update the selection list */
4082 while (j < file_mgr_data->selected_file_count)
4084 file_view_data = file_mgr_data->selection_list[j];
4086 /* See if the selected file is still around */
4088 for (i = 0; !match && i < new_dir_count; i++)
4090 for (k = 0; k < new_dir_set[i]->file_count; k++)
4092 if (file_view_data->file_data ==
4093 new_dir_set[i]->file_view_data[k]->file_data)
4097 file_mgr_data->selection_list[j] =
4098 new_dir_set[i]->file_view_data[k];
4103 /* Keep the file selected only if it was found in the new
4104 * directory set and if it is not filtered */
4105 if (match && !file_view_data->filtered)
4108 DeselectFile (file_mgr_data, file_view_data, False);
4111 /* free the old directory set */
4112 FreeLayoutData(file_mgr_data->layout_data);
4113 file_mgr_data->layout_data = NULL;
4114 FreeDirectorySet(directory_set, directory_count);
4116 /* Set the menu activation to reflect and changes in the selection. */
4118 if(file_mgr_data != trashFileMgrData
4119 && file_mgr_data != NULL )
4121 if (file_mgr_data->selected_file_count == 0)
4122 ActivateNoSelect ((FileMgrRec *) file_mgr_data->file_mgr_rec);
4123 else if (file_mgr_data->selected_file_count == 1)
4124 ActivateSingleSelect ((FileMgrRec *) file_mgr_data->file_mgr_rec,
4125 file_mgr_data->selection_list[0]->file_data->logical_type);
4127 ActivateMultipleSelect ((FileMgrRec *) file_mgr_data->file_mgr_rec);
4130 SensitizeTrashBtns();
4132 /* load positional data for this directory */
4133 if ( (file_mgr_data->positionEnabled == RANDOM_ON)
4134 && ( (file_mgr_rec->menuStates & CLEAN_UP_OP) == 0)
4136 LoadPositionInfo(file_mgr_data);
4141 /************************************************************************
4144 * Search for a directory in branch list.
4146 ************************************************************************/
4150 FileMgrData *file_mgr_data,
4152 char *directory_name,
4158 if (branch_list == NULL)
4161 for (i = 0; branch_list[i]; i++)
4162 if (strcmp(branch_list[i] + 2, directory_name) == 0) {
4163 ts = branch_list[i][0] - '0';
4164 if (ts == tsNotRead)
4167 if (ts == tsAll && file_mgr_data->tree_files == TREE_FILES_NEVER)
4169 else if (ts == tsDirs && file_mgr_data->tree_files == TREE_FILES_ALWAYS)
4181 /************************************************************************
4184 * Read a directory and sub directories.
4186 ************************************************************************/
4188 static FileViewData *
4190 FileMgrData *file_mgr_data,
4192 char *directory_name,
4200 /* allocate new FileData */
4201 fp = (FileData *) XtMalloc(sizeof(FileData));
4202 memset(fp, 0, sizeof(FileData));
4205 if (strcmp(directory_name, "/") == 0)
4206 fp->file_name = XtNewString("/");
4209 p = strrchr(directory_name, '/');
4211 fp->file_name = XtNewString(p + 1);
4213 fp->file_name = XtNewString(directory_name);
4216 /* assume it's a directory for now ... */
4217 fp->is_subdir = True;
4219 /* @@@ do a readlink here ... */
4221 /* allocate FileViewData */
4222 ip = (FileViewData *)XtMalloc(sizeof(FileViewData));
4223 memset(ip, 0, sizeof(FileViewData));
4226 if (QueryBranchList(file_mgr_data, branch_list, directory_name, &ts) &&
4231 else if (file_mgr_data->tree_files == TREE_FILES_ALWAYS)
4245 * Recursively count the number of subdirectores we have read.
4250 if (ip->file_data->is_subdir && ip->ts != tsNotRead)
4253 for (dp = ip->desc; dp; dp = dp->next)
4254 CountDirectories(dp, np);
4258 static DirectorySet *
4262 FileMgrData *file_mgr_data)
4268 /* allocate a new directory set entry */
4269 ds = (DirectorySet *)XtMalloc(sizeof(DirectorySet));
4271 /* initialize the directory set entry */
4272 ds->name = XtNewString(name);
4275 for (dp = ip->desc; dp; dp = dp->next)
4277 if (ds->file_count != 0)
4278 ds->file_view_data =
4279 (FileViewData **)XtMalloc(ds->file_count*sizeof(FileViewData *));
4281 ds->file_view_data = NULL;
4283 for (dp = ip->desc, i = 0; dp; dp = dp->next, i++) {
4284 ds->file_view_data[i] = dp;
4285 dp->directory_set = (XtPointer)ds;
4287 ds->order_list = NULL;
4288 ds->filtered_file_count = 0;
4289 ds->invisible_file_count = 0;
4290 ds->file_mgr_data = (XtPointer)file_mgr_data;
4298 FileMgrData *file_mgr_data,
4300 DirectorySet **directory_set,
4303 * Recursively add directores to the directory set array.
4306 char fullname[MAX_PATH];
4309 if (ip->file_data->is_subdir && ip->ts != tsNotRead)
4311 /* add a new entry to the directory set array */
4312 GetFullName(file_mgr_data, ip, fullname);
4313 directory_set[*index] = NewDirectorySet(fullname, ip, file_mgr_data);
4317 for (dp = ip->desc; dp; dp = dp->next)
4318 MakeDirectorySets(file_mgr_data, dp, directory_set, index);
4326 char *directory_name,
4327 FileMgrData *file_mgr_data,
4329 DirectorySet ***directory_set,
4330 int *directory_count)
4332 FileViewData *ip, *dp;
4335 /* eliminate "/." */
4336 if (strcmp(directory_name, "/.") == 0)
4337 directory_name = "/";
4339 /* if not in tree mode, clear branch_list (@@@ really?) */
4340 if (file_mgr_data->show_type != MULTIPLE_DIRECTORY)
4343 /* get a FileViewData for the tree root */
4344 file_mgr_data->tree_root = ip =
4345 GetTopInfo(file_mgr_data, host_name, directory_name, branch_list);
4347 /* read the directory tree */
4348 rc = ReadDir(w, file_mgr_data, host_name, directory_name, ip,
4349 0, file_mgr_data->tree_preread_level, branch_list);
4350 if (file_mgr_data->busy_status != not_busy)
4352 /* No point in continuing any further, free up all 'ip' and return */
4353 XtFree(ip->file_data->file_name);
4354 XtFree((char *)ip->file_data);
4356 file_mgr_data->tree_root = NULL;
4362 /* update root FileData from "." */
4363 for (dp = ip->desc; dp; dp = dp->next)
4364 if (strcmp(dp->file_data->file_name, ".") == 0) {
4365 ip->file_data->physical_type = dp->file_data->physical_type;
4366 ip->file_data->logical_type =
4367 GetDirectoryLogicalType(file_mgr_data, directory_name);
4368 ip->file_data->errnum = dp->file_data->errnum;
4369 ip->file_data->stat = dp->file_data->stat;
4370 ip->file_data->is_broken = dp->file_data->is_broken;
4374 *directory_count = 0;
4375 CountDirectories(ip, directory_count);
4377 /* allocate array of directory set pointers */
4379 (DirectorySet **) XtMalloc ((*directory_count + 1)*sizeof(DirectorySet *));
4381 /* make a fake directory set for the tree root */
4383 char fullname[MAX_PATH];
4387 ds = (DirectorySet *)XtMalloc(sizeof(DirectorySet));
4388 ip->directory_set = (XtPointer)ds;
4390 strcpy(fullname, directory_name);
4391 p = strrchr(fullname, '/');
4394 ds->name = XtNewString(fullname);
4395 ds->sub_root = NULL;
4397 ds->file_view_data =
4398 (FileViewData **)XtMalloc(sizeof(FileViewData *));
4399 ds->file_view_data[0] = ip;
4401 (FileViewData **)XtMalloc(sizeof(FileViewData *));
4402 ds->order_list[0] = ip;
4403 ds->filtered_file_count = 1;
4404 ds->file_mgr_data = (XtPointer)file_mgr_data;
4406 (*directory_set)[0] = ds;
4410 /* make directory sets for the current dir and subdirs */
4412 MakeDirectorySets(file_mgr_data, ip, *directory_set, &i);
4416 /*--------------------------------------------------------------------
4418 *------------------------------------------------------------------*/
4425 * Decide if entry is currently displayed.
4430 /* filtered files are not shown */
4434 /* in flat mode all un-filtered files are shown */
4435 if (fmd->show_type == SINGLE_DIRECTORY)
4438 /* in tree mode an entry is shown only if user chooses to */
4439 ts = ip->parent? ip->parent->ts: tsDirs;
4442 else if (ts == tsDirs)
4443 return ip->file_data->is_subdir;
4452 FileViewData *dp, /* directory entry being searched */
4453 int level) /* tree depth level of this entry */
4455 * Recursively determine the display position of a given entry
4456 * Return false if the entry not currently displayed
4461 /* skip entries that are not displayed */
4462 if (level > 0 && !IsShown(fmd, dp))
4465 /* this entry is displayed */
4466 dp->displayed = True;
4468 /* traverse subtree */
4471 for (ip = dp->desc; ip; ip = ip->next)
4472 SetDisplayedRecur(fmd, ip, level);
4479 SelectVisible (FileMgrData *file_mgr_data)
4483 /* assume nothing displayed */
4484 for (i = 0; i < file_mgr_data->directory_count; i++)
4485 for (j = 0; j < file_mgr_data->directory_set[i]->file_count; j++)
4486 file_mgr_data->directory_set[i]->file_view_data[j]->displayed = False;
4488 /* set the displayed flag for all entries that are actually shown */
4489 SetDisplayedRecur(file_mgr_data, file_mgr_data->tree_root, 0);
4490 if (file_mgr_data->show_type == SINGLE_DIRECTORY)
4491 file_mgr_data->tree_root->displayed = False;
4495 /*--------------------------------------------------------------------
4496 * expand tree branches
4497 *------------------------------------------------------------------*/
4500 * UpdateBranchState:
4501 * Determine new tree brach expansion state after a subdirectory has
4502 * been re-read (op == BRANCH_UPDATE), or after the user has requested
4503 * to expand (op == BRANCH_EXPAND) or collapse (op == BRANCH_COLLAPSE)
4508 FileMgrData *file_mgr_data,
4513 TreeShow old_ts = ip->ts;
4515 if (ip->ts == tsReading && op == BRANCH_UPDATE)
4523 /* this is a new branch that's currently being read */
4527 else if (ip->ts == tsError)
4529 /* can't expand or collaps this branch */
4533 else if (op == BRANCH_UPDATE) /* update */
4537 else if (op == BRANCH_EXPAND) /* show more */
4539 if (file_mgr_data->tree_files == TREE_FILES_NEVER)
4541 if (ip->ts == tsNone || !showEmptySet && ip->ndir == 0)
4549 if (ip->ndir == 0 && ip->nfile == 0)
4551 /* the subdir is empty */
4554 else if (ip->ts == tsNone)
4559 else if (ip->ts == tsAll)
4561 else if (ip->ts == tsNone &&
4562 ip->ndir > 0 && ip->nfile > 0 &&
4563 file_mgr_data->tree_files == TREE_FILES_CHOOSE)
4571 (ip->nfile == 0 || file_mgr_data->tree_files == TREE_FILES_NEVER) &&
4574 DirectorySet *directory_set = (DirectorySet *)ip->directory_set;
4575 FileMgrData *file_mgr_data = (FileMgrData *)directory_set->file_mgr_data;
4576 FileMgrRec *file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;
4581 msg = GETMESSAGE(12,18, "The folder %s is empty.");
4583 msg = GETMESSAGE(12,19, "The folder %s contains no subdirectories.");
4585 sprintf(buf, msg, ip->file_data->file_name);
4586 SetSpecialMsg( file_mgr_rec, file_mgr_data, buf );
4590 else if (op == BRANCH_COLLAPSE) /* show less */
4594 if (file_mgr_data->tree_files == TREE_FILES_NEVER)
4596 if (ip->ts == tsNone || !showEmptySet && ip->ndir == 0)
4603 if (ip->ndir == 0 && ip->nfile == 0)
4605 /* the subdir is empty */
4608 else if (ip->ts == tsNone)
4613 else if (ip->ts == tsNone)
4615 else if (ip->ts == tsAll &&
4616 ip->ndir > 0 && ip->nfile > 0 &&
4617 file_mgr_data->tree_files == TREE_FILES_CHOOSE)
4628 * Expand (expand == True) or collpase (expand == False) a tree branch.
4632 FileMgrData *file_mgr_data,
4636 FileMgrRec *file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;
4637 DirectorySet *directory_set;
4638 int level, i, n, old_count, rc;
4644 GetAncestorInfo(file_mgr_data, ip, &level, path, NULL);
4645 SetSpecialMsg( file_mgr_rec, file_mgr_data, NULL );
4650 new_branch = (ip->ts == tsNotRead || ip->ts == tsError);
4653 /* we need to read the sub directory */
4654 _DtTurnOnHourGlass (file_mgr_rec->shell);
4655 if (ip->ts == tsError)
4657 if (file_mgr_data->busy_status == not_busy)
4659 file_mgr_data->busy_detail = 0;
4660 file_mgr_data->busy_status = initiating_readdir;
4662 RereadDirectory (file_mgr_rec->shell, file_mgr_data->host, path);
4663 if (file_mgr_data->busy_status == initiating_readdir)
4664 file_mgr_data->busy_status = not_busy;
4666 rc = ReadDir(file_mgr_rec->shell, file_mgr_data,
4667 file_mgr_data->host, path, ip,
4668 level, level, NULL);
4670 /* create new directory set entry */
4671 directory_set = NewDirectorySet(path, ip, file_mgr_data);
4673 /* if this is a new entry, add it to the directory set */
4674 if (ip->ts == tsNotRead)
4676 file_mgr_data->directory_set =
4678 XtRealloc((char *)(file_mgr_data->directory_set - 1),
4679 (file_mgr_data->directory_count + 2)*sizeof(DirectorySet *))) + 1;
4680 file_mgr_data->directory_set[file_mgr_data->directory_count] =
4682 file_mgr_data->directory_count++;
4686 /* otherwise, replace the existing entry */
4687 for (i = 0; i < file_mgr_data->directory_count; i++)
4688 if (strcmp(file_mgr_data->directory_set[i]->name, path) == 0)
4690 XtFree(file_mgr_data->directory_set[i]->name);
4691 file_mgr_data->directory_set[i]->name = NULL;
4692 if (file_mgr_data->directory_set[i]->file_view_data != NULL)
4693 XtFree((char *)file_mgr_data->directory_set[i]->file_view_data);
4694 file_mgr_data->directory_set[i]->file_view_data = NULL;
4695 XtFree((char *)file_mgr_data->directory_set[i]);
4696 file_mgr_data->directory_set[i] = directory_set;
4700 ip->ts == tsError && file_mgr_data->busy_status == busy_readdir)
4705 if (file_mgr_data->busy_status != busy_readdir)
4707 OrderFiles (file_mgr_data, directory_set);
4708 FilterFiles (file_mgr_data, directory_set);
4709 file_mgr_data->newSize = True;
4710 AddFileIcons(file_mgr_rec, file_mgr_data, directory_set);
4714 /* expand the branch */
4715 UpdateBranchState(file_mgr_data, ip, BRANCH_EXPAND,
4716 new_branch && file_mgr_data->busy_status == busy_readdir);
4720 /* collaps the branch */
4721 UpdateBranchState(file_mgr_data, ip, BRANCH_COLLAPSE, False);
4724 /* change tree button */
4725 if (file_mgr_data->busy_status != busy_readdir)
4727 px = GetTreebtnPixmap(file_mgr_data, ip);
4728 XtSetArg(args[0], XmNlabelPixmap, px);
4729 XtSetValues (ip->treebtn, args, 1);
4732 for (i = 0; i < file_mgr_data->directory_count; i++)
4733 if (strcmp(file_mgr_data->directory_set[i]->name, path) == 0)
4736 SelectVisible(file_mgr_data);
4737 UpdateBranchList(file_mgr_data, file_mgr_data->directory_set[i]);
4739 UnmanageFileIcons(file_mgr_rec, file_mgr_data, ip);
4740 EraseTreeLines(file_mgr_rec, file_mgr_data, ip);
4742 /* update the "Hidden" count */
4743 UpdateHeaders(file_mgr_rec, file_mgr_data, False);
4747 /************************************************************************
4750 * Free up the directory set data.
4752 ************************************************************************/
4756 DirectorySet ** directory_set,
4757 int directory_count)
4764 for (i = -1; i < directory_count; i++)
4766 if (directory_set[i] == NULL)
4769 XtFree ((char *) directory_set[i]->name);
4770 for (j = 0; j < directory_set[i]->file_count; j++)
4772 if( (char *) directory_set[i]->file_view_data[j]->label)
4774 XtFree ((char *) directory_set[i]->file_view_data[j]->label);
4775 directory_set[i]->file_view_data[j]->label = NULL;
4777 XtFree ((char *) directory_set[i]->file_view_data[j]);
4778 directory_set[i]->file_view_data[j] = NULL;
4780 if (directory_set[i]->file_view_data != NULL)
4781 XtFree ((char *) directory_set[i]->file_view_data);
4782 XtFree ((char *) directory_set[i]->order_list);
4783 XtFree ((char *) directory_set[i]);
4786 XtFree ((char *) (directory_set - 1));
4790 /************************************************************************
4793 * Free up the current directory and the directory set data.
4795 ************************************************************************/
4799 FileMgrData *file_mgr_data )
4801 if(file_mgr_data->object_positions)
4802 FreePositionInfo(file_mgr_data);
4804 if (file_mgr_data->current_directory != NULL)
4805 XtFree ((char *) file_mgr_data->current_directory);
4806 file_mgr_data->current_directory = NULL;
4808 if (file_mgr_data->host != NULL)
4809 XtFree ((char *) file_mgr_data->host);
4810 file_mgr_data->host = NULL;
4812 FreeLayoutData(file_mgr_data->layout_data);
4813 file_mgr_data->layout_data = NULL;
4814 FreeDirectorySet(file_mgr_data->directory_set,
4815 file_mgr_data->directory_count);
4816 file_mgr_data->directory_set = NULL;
4822 /************************************************************************
4825 * Close (destroy) the file browser view. This callback is issued
4826 * from both the Close menu item and the Close system menu.
4828 ************************************************************************/
4833 XtPointer client_data,
4834 XtPointer call_data )
4836 FileMgrRec * file_mgr_rec;
4837 DialogData * dialog_data;
4839 Widget mbar = XmGetPostedFromWidget(XtParent(w));
4842 XmUpdateDisplay (w);
4844 XtSetArg(args[0], XmNuserData, &file_mgr_rec);
4845 XtGetValues(mbar, args, 1);
4846 /* Ignore accelerator received after we're unposted */
4847 if ((dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec)) == NULL)
4850 CloseView (dialog_data);
4856 /************************************************************************
4859 * Function called from a close on the system menu.
4861 ************************************************************************/
4868 FileMgrRec * file_mgr_rec;
4869 DialogData * dialog_data;
4872 file_mgr_rec = (FileMgrRec *) data;
4873 dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
4875 CloseView (dialog_data);
4880 /************************************************************************
4883 * Set the icon name and icon to be used for a file manager view.
4885 ************************************************************************/
4889 FileMgrRec *file_mgr_rec,
4890 FileMgrData *file_mgr_data,
4891 char *directory_name )
4893 static Pixmap tool_icon = XmUNSPECIFIED_PIXMAP;
4894 static Pixmap dir_icon = XmUNSPECIFIED_PIXMAP;
4895 static Pixmap tool_mask = XmUNSPECIFIED_PIXMAP;
4896 static Pixmap dir_mask = XmUNSPECIFIED_PIXMAP;
4897 char * new_directory_name;
4898 Pixel background, foreground, top_shadow, bottom_shadow, select;
4901 unsigned int height;
4904 Boolean havePixmap = False;
4905 Boolean haveMask = False;
4906 Boolean root = False;
4908 char *ptr, *fileLabel, *fileName;
4910 if (tool_icon == XmUNSPECIFIED_PIXMAP)
4912 XtSetArg (args[0], XmNbackground, &background);
4913 XtSetArg (args[1], XmNcolormap, &colormap);
4914 XtGetValues (file_mgr_rec->main, args, 2);
4916 XmGetColors (XtScreen (file_mgr_rec->main), colormap, background,
4917 &foreground, &top_shadow, &bottom_shadow, &select);
4919 /* first get the File Manager's Icon */
4920 pixmap = XmGetPixmap (XtScreen (file_mgr_rec->main), fileMgrIcon,
4921 foreground, background);
4922 if( pixmap != XmUNSPECIFIED_PIXMAP)
4925 /* now let's get the mask for the File Manager */
4926 pixmap = _DtGetMask (XtScreen (file_mgr_rec->main), fileMgrIcon);
4927 if( pixmap != XmUNSPECIFIED_PIXMAP)
4930 /* Let's get the Application Manager's Icon */
4931 pixmap = XmGetPixmap (XtScreen (file_mgr_rec->main), appMgrIcon,
4932 foreground, background);
4933 if( pixmap != XmUNSPECIFIED_PIXMAP)
4936 /* now let's get the mask for the Application Manager */
4937 pixmap = _DtGetMask (XtScreen (file_mgr_rec->main), appMgrIcon);
4938 if( pixmap != XmUNSPECIFIED_PIXMAP)
4944 if (fileLabel = DtDtsFileToAttributeValue(directory_name, DtDTS_DA_LABEL))
4946 else if (fileName = strrchr(directory_name, '/'))
4951 if(file_mgr_data->title)
4953 if(file_mgr_data->toolbox)
4955 if(strcmp(directory_name, file_mgr_data->restricted_directory) == 0)
4957 new_directory_name =
4958 (char *)XtMalloc(strlen(file_mgr_data->title) + 1);
4959 strcpy( new_directory_name, file_mgr_data->title );
4963 new_directory_name = (char *)XtMalloc( strlen(ptr) + 1 );
4964 sprintf(new_directory_name, "%s", ptr);
4969 new_directory_name = (char *)XtMalloc( strlen(ptr) + 1);
4970 sprintf(new_directory_name, "%s", ptr);
4976 if (strcmp (directory_name, "/") == 0 && !fileLabel)
4978 new_directory_name = (char *)XtMalloc(strlen(file_mgr_data->host) +
4979 strlen(root_title) + 3);
4980 sprintf( new_directory_name, "%s:%s", file_mgr_data->host, root_title );
4984 new_directory_name = ptr;
4987 XtSetArg (args[0], XmNiconName, new_directory_name);
4989 if(file_mgr_data->toolbox && tool_icon != XmUNSPECIFIED_PIXMAP)
4992 XtSetArg (args[1], XmNiconPixmap, tool_icon);
4993 if( tool_mask != XmUNSPECIFIED_PIXMAP)
4996 XtSetArg (args[2], XmNiconMask, tool_mask);
4999 else if (dir_icon != XmUNSPECIFIED_PIXMAP)
5002 XtSetArg (args[1], XmNiconPixmap, dir_icon);
5003 if( dir_mask != XmUNSPECIFIED_PIXMAP)
5006 XtSetArg (args[2], XmNiconMask, dir_mask);
5013 XtSetValues (file_mgr_rec->shell, args, 3);
5015 XtSetValues (file_mgr_rec->shell, args, 2);
5018 XtSetValues (file_mgr_rec->shell, args, 1);
5021 DtDtsFreeAttributeValue(fileLabel);
5023 XtFree(new_directory_name);
5029 * Menu callback for the fast change directory toggle. Toggles the text
5030 * field up and down.
5033 ShowChangeDirField (
5035 XtPointer client_data,
5038 FileMgrRec * file_mgr_rec;
5039 DialogData * dialog_data;
5040 FileMgrData * file_mgr_data;
5046 /* Set the menu item to insensitive to prevent multiple */
5047 /* dialogs from being posted and get the area under the */
5048 /* menu pane redrawn. */
5052 if((int)client_data == FM_POPUP)
5055 mbar = XmGetPostedFromWidget(XtParent(w));
5056 XmUpdateDisplay (w);
5057 XtSetArg(args[0], XmNuserData, &file_mgr_rec);
5058 XtGetValues(mbar, args, 1);
5062 /* Done only during a restore session */
5063 file_mgr_rec = (FileMgrRec *)client_data;
5066 /* Got an accelerator after we were unposted */
5067 if ((dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec)) == NULL)
5069 file_mgr_data = (FileMgrData *) dialog_data->data;
5071 /* Toggle the state of the text field */
5072 if (XtIsManaged(file_mgr_rec->current_directory_text))
5074 XtSetArg (args[0], XmNallowShellResize, False);
5075 XtSetValues(file_mgr_rec->shell, args, 1);
5076 XtUnmanageChild(file_mgr_rec->current_directory_text);
5077 XtSetArg (args[0], XmNallowShellResize, True);
5078 XtSetValues(file_mgr_rec->shell, args, 1);
5079 file_mgr_data->fast_cd_enabled = False;
5082 ShowFastChangeDir(file_mgr_rec, file_mgr_data);
5088 * Class function for forcing the focus to the text field, if visible, each
5089 * time the FileMgr dialog is posted.
5094 FileMgrRec * file_mgr_rec,
5095 FileMgrData * file_mgr_data)
5097 /* Force the focus to the text field */
5098 if (file_mgr_data->fast_cd_enabled)
5100 XRaiseWindow(XtDisplay(file_mgr_rec->current_directory_text),
5101 XtWindow(file_mgr_rec->current_directory_text));
5102 XmProcessTraversal(file_mgr_rec->current_directory_text,
5103 XmTRAVERSE_CURRENT);
5109 * This function free up any position information associated with the
5110 * dtfile view, and nulls out the associated data fields.
5115 FileMgrData * file_mgr_data)
5118 FileViewData **file_view_data;
5120 /* free object positions */
5121 for (i = 0; i < file_mgr_data->num_objects; i++)
5123 XtFree(file_mgr_data->object_positions[i]->name);
5124 XtFree((char *)file_mgr_data->object_positions[i]);
5125 file_mgr_data->object_positions[i] = NULL;
5128 XtFree((char *)file_mgr_data->object_positions);
5130 file_mgr_data->object_positions = NULL;
5131 file_mgr_data->num_objects = 0;
5133 /* clear references to object positions in file_view_data */
5134 for (i = 0; i < file_mgr_data->directory_count; i++)
5136 file_view_data = file_mgr_data->directory_set[i]->file_view_data;
5137 for (j = 0; j < file_mgr_data->directory_set[i]->file_count; j++)
5138 file_view_data[j]->position_info = NULL;
5144 * This function determines whether random positioning is currently enabled
5145 * for this view. The decision is based upon they type of the view, and
5146 * the current preferences settings.
5150 PositioningEnabledInView (
5151 FileMgrData * file_mgr_data)
5154 if ((file_mgr_data->show_type == SINGLE_DIRECTORY) &&
5155 (file_mgr_data->view != BY_ATTRIBUTES) &&
5156 (file_mgr_data->positionEnabled == RANDOM_ON))
5166 * This function is similar to the above function, but is less restrictive;
5167 * this function does not require that the view currently have positioning
5168 * enabled; it simply returns whether the view has positioning info.
5173 FileMgrData * file_mgr_data)
5176 if ((file_mgr_data->object_positions) &&
5177 (file_mgr_data->positionEnabled == RANDOM_ON))
5187 * When a new view of a directory is spun off of an existing view of that
5188 * directory, we want the new view to inherit the positioning information
5189 * associated with the original view. This function takes care of that.
5193 InheritPositionInfo (
5194 FileMgrData * src_file_mgr_data,
5195 FileMgrData * dest_file_mgr_data)
5198 ObjectPosition *ptr;
5199 ObjectPosition **temp_stack;
5201 if (!PositionFlagSet(src_file_mgr_data))
5203 /* Nothing to inherit */
5204 dest_file_mgr_data->num_objects = 0;
5205 dest_file_mgr_data->object_positions = NULL;
5209 dest_file_mgr_data->num_objects = src_file_mgr_data->num_objects;
5210 dest_file_mgr_data->object_positions = (ObjectPosition **) XtMalloc(
5211 sizeof(ObjectPosition *) * dest_file_mgr_data->num_objects);
5213 temp_stack = (ObjectPosition **) XtMalloc(
5214 sizeof(ObjectPosition *) * dest_file_mgr_data->num_objects);
5216 for (i = 0; i < dest_file_mgr_data->num_objects; i++)
5218 ptr = dest_file_mgr_data->object_positions[i] = (ObjectPosition *)
5219 XtMalloc(sizeof(ObjectPosition));
5221 *ptr = *(src_file_mgr_data->object_positions[i]);
5222 ptr->name = XtNewString(ptr->name);
5223 ptr->file_view_data = NULL;
5227 temp_stack[ptr->stacking_order - 1] = ptr;
5230 for(i = 0; i < dest_file_mgr_data->num_objects; i++)
5232 if(dest_file_mgr_data->object_positions[i]->stacking_order == 1)
5234 dest_file_mgr_data->object_positions[i]->next =
5235 temp_stack[dest_file_mgr_data->object_positions[i]->stacking_order];
5238 else if(dest_file_mgr_data->object_positions[i]->stacking_order ==
5239 dest_file_mgr_data->num_objects)
5241 dest_file_mgr_data->object_positions[i]->prev =
5242 temp_stack[dest_file_mgr_data->object_positions[i]->
5243 stacking_order - 2];
5247 dest_file_mgr_data->object_positions[i]->prev =
5248 temp_stack[dest_file_mgr_data->object_positions[i]->
5249 stacking_order - 2];
5250 dest_file_mgr_data->object_positions[i]->next =
5251 temp_stack[dest_file_mgr_data->object_positions[i]->stacking_order];
5255 XtFree((char *)temp_stack);
5260 * This function saves the current position information (if any) in the
5261 * associated directory; if there is no positional data, then any old
5262 * position files in this directory are removed. The entries are written
5263 * according to their position (left to right, top to bottom), not according
5264 * to their relative stacking order.
5269 FileMgrData * file_mgr_data)
5272 PositionInfo *position_info;
5273 ObjectPosition * ptr;
5276 /* Copy object positions into position info array */
5277 if (file_mgr_data->num_objects <= 0)
5278 position_info = NULL;
5281 position_info = (PositionInfo *)
5282 XtMalloc(file_mgr_data->num_objects * sizeof(PositionInfo));
5283 for (i = 0; i < file_mgr_data->num_objects; i++)
5285 ptr = file_mgr_data->object_positions[i];
5287 position_info[i].name = ptr->name;
5288 position_info[i].x = ptr->x;
5289 position_info[i].y = ptr->y;
5290 position_info[i].stacking_order = ptr->stacking_order;
5294 SetDirectoryPositionInfo(file_mgr_data->host,
5295 file_mgr_data->current_directory,
5296 file_mgr_data->num_objects, position_info);
5298 XtFree((char *)position_info);
5303 * This function will attempt to load any positional data associated with
5304 * the directory to be viewed. Within the positioning file, the entries
5305 * are order in left-to-right, top-to-bottom order, not according to the
5311 FileMgrData * file_mgr_data)
5313 PositionInfo *position_info;
5314 ObjectPosition * ptr;
5318 /* don't do anything if we already have position information */
5319 if (file_mgr_data->object_positions != NULL)
5322 /* Load the number of entries */
5323 numObjects = GetDirectoryPositionInfo(file_mgr_data->host,
5324 file_mgr_data->current_directory, &position_info);
5326 if (numObjects <= 0)
5328 file_mgr_data->object_positions = NULL;
5329 file_mgr_data->num_objects = 0;
5335 /* Proceed with the loading */
5336 file_mgr_data->object_positions = (ObjectPosition **)XtMalloc(
5337 sizeof(ObjectPosition *) * numObjects);
5339 for (i = 0; i < numObjects; i++)
5341 ptr = file_mgr_data->object_positions[i] = (ObjectPosition *)
5342 XtMalloc(sizeof(ObjectPosition));
5343 ptr->name = XtNewString(position_info[i].name);
5344 ptr->x = position_info[i].x;
5345 ptr->y = position_info[i].y;
5346 ptr->in_use = False;
5347 ptr->late_bind = False;
5348 ptr->stacking_order = position_info[i].stacking_order;
5349 ptr->file_view_data = NULL;
5354 /* Repair all of the next and prev pointers */
5355 file_mgr_data->num_objects = i;
5356 RepairStackingPointers(file_mgr_data);
5357 /* OrderChildrenList(file_mgr_data); */
5363 /************************************************************************
5365 * MoveOkCB - the user wishes to actually do the move even though its
5366 * not the desktop object that is actually getting moved.
5367 * This function calls the routines which do the moves. It
5368 * depends on the view type to determine how it does it.
5370 * DESKTOP - the drop happened on a Desktop object
5371 * and the object was a directory
5372 * NOT_DESKTOP_DIR - the drop happened on a directory
5373 * but it wasn't a directory on the desktop.
5374 * NOT_DESKTOP - drop happened in a FileManager view
5375 * and not on a directory.
5378 ************************************************************************/
5382 XtPointer client_data,
5383 XtPointer call_data )
5385 XtUnmanageChild((Widget)client_data);
5386 XmUpdateDisplay((Widget)client_data);
5387 XtDestroyWidget((Widget)client_data);
5392 /************************************************************************
5394 * MoveCancelCB - function called when the user cancels out of the
5395 * Move file question dialog. Just deleted the dialog.
5397 ************************************************************************/
5401 XtPointer client_data,
5402 XtPointer call_data )
5404 FileMgrRec *file_mgr_rec;
5406 XtUnmanageChild((Widget)client_data);
5407 XmUpdateDisplay((Widget)client_data);
5408 XtDestroyWidget((Widget)client_data);
5410 if(view_type == NOT_DESKTOP)
5412 file_mgr_rec = (FileMgrRec *)fm->file_mgr_rec;
5413 LayoutFileIcons(file_mgr_rec, fm, False, True);
5418 RemoveIconInWorkspace(
5420 char * workspaceName )
5422 DesktopRec *desktopWin;
5424 char iconName[MAX_PATH];
5427 for(i = 0; i < desktop_data->numIconsUsed; i++)
5429 desktopWin = desktop_data->desktopWindows[i];
5431 if( strcmp( desktopWin->dir_linked_to, "/" ) == 0 )
5432 sprintf( iconName, "/%s", desktopWin->file_name );
5434 sprintf( iconName, "%s/%s", desktopWin->dir_linked_to, desktopWin->file_name );
5436 DtEliminateDots( iconName );
5438 if( strcmp( fileName, iconName ) == 0
5439 && strcmp( workspaceName, desktopWin->workspace_name ) == 0 )
5441 RemoveDT( desktopWin->shell, (XtPointer) desktopWin,
5448 /*************************************************************************
5450 * CheckMoveType - function used to determine:
5451 * 1) is the file being moved have a reference to a
5453 * 2) if yes: is the file being moved dragged from
5454 * the Desktop (check widget_dragged)?
5455 * 2a) if yes: set up global varibles used by message
5457 * 2b) if no: execute the move, then if one of the objects
5458 * is on the Desktop, move the link to the
5460 * 3) question 1 answer is no: just exectute the move
5462 * Other information:
5464 * DESKTOP - the drop happened on a Desktop object
5465 * and the object was a directory
5466 * NOT_DESKTOP_DIR - the drop happened on a directory
5467 * but it wasn't a directory on the desktop.
5468 * NOT_DESKTOP - drop happened in a FileManager view
5469 * and not on a directory.
5472 **************************************************************************/
5475 FileMgrData *file_mgr_data,
5476 FileViewData *file_view_data,
5477 DirectorySet * directory_data,
5478 DesktopRec * desktopWindow,
5481 unsigned int modifiers,
5492 char directory[MAX_PATH];
5495 Screen *currentScreen;
5497 char * workspace_name;
5501 #ifdef _CHECK_FOR_SPACES
5502 if (_DtSpacesInFileNames(file_set, file_count))
5504 char * tmpStr = (GETMESSAGE(27,94, "The File Manager does not support objects\nwith spaces in their names, so we cannot delete them.\nTo delete these objects:\n - select 'Open Terminal' from the File Manager menu\n - then issue the remove command to delete them."));
5505 char * msg = XtNewString(tmpStr);
5506 FileOperationError (toplevel, msg, NULL);
5512 display = XtDisplay(toplevel);
5513 screen = XDefaultScreen(display);
5514 currentScreen = XScreenOfDisplay(display, screen);
5515 rootWindow = RootWindowOfScreen(currentScreen);
5517 if( DtWsmGetCurrentWorkspace(display,rootWindow,&pCurrent) == Success )
5519 workspace_name = XGetAtomName (display, pCurrent);
5520 CleanUpWSName(workspace_name);
5523 /* Fix for the case, when you drop an object from App. Manager on to desktop
5524 and try to move it to File Manager. It must copied for this operation
5525 (modifers == ControlMask). */
5529 Str = (char *)IsAFileOnDesktop2(file_set, file_count, &number,&IsToolBox);
5531 modifiers = ControlMask;
5535 * If number is comes back greater than 0 then at least one of the files
5536 * dropped has a reference to a Desktop object
5538 * If widget_dragged is != NULL then the files dragged are from the
5539 * desktop; in this case set up globals, and post a confirmation dialog.
5541 modifiers &= ~Button2Mask;
5542 modifiers &= ~Button1Mask;
5544 modifiers != ControlMask && modifiers != ShiftMask &&
5545 widget_dragged != NULL)
5547 char *message = NULL;
5549 char *from, *to, *filename;
5551 global_file_count = file_count;
5552 _DtCopyDroppedFileInfo(file_count, file_set, host_set,
5553 &global_file_set, &global_host_set);
5556 fv = file_view_data;
5562 /* desktop object dropped on a desktop directory */
5563 dtWindow = desktopWindow;
5564 fm = (FileMgrData *)NULL;
5565 dd = (DirectorySet *)NULL;
5566 to = (char *)XtMalloc(strlen(directory_data->name) +
5567 strlen(fv->file_data->file_name)+ 2);
5568 sprintf(to, "%s/%s", directory_data->name,
5569 fv->file_data->file_name );
5570 DtEliminateDots(to);
5572 case NOT_DESKTOP_DIR:
5573 /* desktop object dropped on a file view directory icon */
5574 dtWindow = (DesktopRec *)NULL;
5576 dd = directory_data;
5577 to = (char *)XtMalloc(strlen(dd->name) +
5578 strlen(fv->file_data->file_name) + 2);
5579 sprintf( to, "%s/%s",dd->name , fv->file_data->file_name );
5580 (void) DtEliminateDots(to);
5582 default:/* view == NOT_DESKTOP */
5583 /* desktop object dropped in a file manager view */
5584 dtWindow = (DesktopRec *)NULL;
5586 dd = (DirectorySet *)NULL;
5587 to = (char *)XtMalloc(strlen(file_mgr_data->current_directory)
5589 strcpy(to, file_mgr_data->current_directory);
5593 for(i=0; i<file_count; i++)
5595 if(strcmp(file_set[i], to) == 0)
5598 FileMgrRec *file_mgr_rec;
5600 GETMESSAGE(11,16,"A folder cannot be moved into itself.\n%s");
5601 msg = XtNewString(tmpStr);
5602 if(file_view_data == NULL)
5604 file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;
5605 FileOperationError(file_mgr_rec->shell, msg, file_set[i]);
5609 FileOperationError(file_view_data->widget, msg, file_set[i]);
5614 XtFree(workspace_name);
5619 tmpStr = (GETMESSAGE(12,3, "Move File(s)"));
5620 title = XtNewString(tmpStr);
5623 int len = strlen(to);
5627 && file_mgr_data->toolbox )
5629 ptr = strrchr(file_set[0], '/');
5630 ptr1 = (char *)XtMalloc(strlen(to) + strlen(ptr) + 1);
5631 sprintf(ptr1, "%s%s", to, ptr);
5632 ptr1 = _DtResolveAppManPath( ptr1,
5633 file_mgr_data->restricted_directory);
5635 if (strncmp(ptr1, file_set[0], len) == 0)
5644 from = XtNewString( file_set[0] );
5645 ptr = strrchr( from, '/' );
5647 filename = XtNewString("");
5651 ptr = strrchr(file_set[0], '/');
5655 from = (char *)XtMalloc(strlen(file_set[0]) + 1);
5656 strcpy(from, file_set[0]);
5659 filename = (char *)XtMalloc(strlen(ptr) + 1);
5660 strcpy(filename, ptr);
5664 from = (char *)XtMalloc(strlen(ptr) + 1);
5666 filename = XtNewString("");
5670 if( strcmp( from, to ) == 0 )
5672 RemoveIconInWorkspace( file_set[0], workspace_name );
5676 XtFree(workspace_name);
5680 #ifdef sun /* This format statement core dumps on SunOS 4.0.3 and 4.1 */
5681 tmpStr = (GETMESSAGE(12,4, "The object %s is currently in folder %s.\nYou are moving the object to folder %s.\nIs this what you want to do?"));
5683 tmpStr = (GETMESSAGE(12,5, "The object %1$s is currently in folder %2$s.\nYou are moving the object to folder %3$s.\nIs this what you want to do?"));
5685 message = (char *)XtMalloc(strlen(tmpStr) + strlen(filename) +
5686 strlen(to) + strlen(from) + 1);
5688 sprintf(message, tmpStr, filename, from, to);
5695 int len = strlen(to);
5699 for( i = 0; i < desktop_data->numWorkspaces; ++i )
5701 if( strcmp( workspace_name, desktop_data->workspaceData[i]->name) == 0 )
5703 workspace_num = desktop_data->workspaceData[i]->number;
5708 DeselectAllDTFiles( desktop_data->workspaceData[workspace_num -1] );
5714 && file_mgr_data->toolbox)
5716 to = _DtResolveAppManPath( to,
5717 file_mgr_data->restricted_directory );
5718 for( i = 0; i < number; ++i )
5722 from = (char *)XtNewString( file_set[i] );
5723 ptr = strrchr( from, '/' );
5725 from = _DtResolveAppManPath( from,
5726 file_mgr_data->restricted_directory );
5729 if( strcmp( from, to ) == 0 )
5730 RemoveIconInWorkspace( file_set[i], workspace_name );
5738 for( i = 0; i < number; ++i )
5740 ptr = strrchr(file_set[i], '/');
5744 from = (char *)XtMalloc(strlen(file_set[i]) + 1);
5745 strcpy(from, file_set[i]);
5750 from = (char *)XtMalloc(strlen(ptr) + 1);
5754 if( strcmp( to, from ) == 0 )
5756 RemoveIconInWorkspace( file_set[i], workspace_name );
5769 tmpStr = (GETMESSAGE(12,6, "At least one of the files you dropped is from a different\nfolder. You are moving all these files to %s.\nIs this what you want to do?"));
5770 message = (char *)XtMalloc(strlen(tmpStr) + strlen(to) + 1);
5772 sprintf(message, tmpStr, to);
5782 _DtMessageDialog(toplevel, title, message, NULL, TRUE,
5783 MoveCancelCB, MoveOkCB, NULL, HelpRequestCB, False,
5790 XtFree(workspace_name);
5794 XtFree(Str); /* No longer used, so free it up */
5795 XtFree(workspace_name);
5797 * Files are not dragged from the desktop.
5799 * Just execute the operation. The target directory dependings on
5800 * the view type (i.e. DESKTOP, NOT_DESKTOP, or NOT_DESKTOP_DIR).
5805 target_host = desktopWindow->host;
5806 sprintf( directory, "%s/%s", directory_data->name,
5807 file_view_data->file_data->file_name );
5808 DtEliminateDots(directory);
5809 value = FileMoveCopyDesktop (file_view_data, directory,
5810 host_set, file_set, file_count,
5811 modifiers, desktopWindow,
5815 case NOT_DESKTOP_DIR:
5816 target_host = file_mgr_data->host;
5817 sprintf( directory, "%s/%s", directory_data->name,
5818 file_view_data->file_data->file_name );
5819 DtEliminateDots(directory);
5820 value = FileMoveCopy (file_mgr_data,
5821 NULL, directory, target_host,
5822 host_set, file_set, file_count,
5823 modifiers, NULL, NULL);
5826 default:/* view == NOT_DESKTOP */
5827 target_host = file_mgr_data->host;
5828 strcpy(directory, file_mgr_data->current_directory);
5832 RepositionIcons(file_mgr_data, file_set, file_count, drop_x,
5835 value = FileMoveCopy(file_mgr_data,
5836 NULL, directory, target_host,
5837 host_set, file_set, file_count,
5838 modifiers, NULL, NULL);
5845 * If this was a move and any of the files is referenced by a
5846 * Desktop object we need to change the reference to the new
5847 * location that the file moved to.
5849 * @@@ This should really be done in the pipe callback!
5853 modifiers != ControlMask && modifiers != ShiftMask)
5855 Tt_status tt_status;
5857 for(j = 0; j < file_count; j++)
5860 DesktopRec *desktopWin;
5863 * loop through each desktop object to see if the file
5864 * being operated on has a reference to a desktop object.
5865 * If it does change the reference in the desktop object
5867 * NOTE: if we find a desktop object the file references,
5868 * after we've changed the DT object we can't break
5869 * because there might be more than one DT object which
5872 for(i = 0; i < desktop_data->numIconsUsed; i++)
5874 desktopWin = desktop_data->desktopWindows[i];
5875 fileName = ResolveLocalPathName( desktopWin->host, desktopWin->dir_linked_to,
5876 desktopWin->file_name, home_host_name, &tt_status);
5877 if( TT_OK == tt_status && strcmp(fileName, file_set[j]) == 0 )
5880 * if fileName == file_set[j] then the file is on the
5881 * Desktop so change the dir_linked to reference. What the
5882 * new reference is depends on which view type is being
5885 XtFree(desktopWin->host);
5886 desktopWin->host = XtNewString(target_host);
5888 XtFree(desktopWin->dir_linked_to);
5889 desktopWin->dir_linked_to = XtNewString(directory);
5891 XtFree(desktopWin->restricted_directory);
5892 if(file_mgr_data->restricted_directory != NULL)
5893 desktopWin->restricted_directory =
5894 XtNewString(file_mgr_data->restricted_directory);
5896 desktopWin->restricted_directory = NULL;
5898 XtFree(desktopWin->title);
5899 if(file_mgr_data->title != NULL)
5900 desktopWin->title = XtNewString(file_mgr_data->title);
5902 desktopWin->title = NULL;
5904 XtFree(desktopWin->helpVol);
5905 if(file_mgr_data->helpVol != NULL)
5906 desktopWin->helpVol = XtNewString(file_mgr_data->helpVol);
5908 desktopWin->helpVol = NULL;
5910 desktopWin->toolbox = file_mgr_data->toolbox;
5913 } /* for ( i = 0 ...) */
5914 } /* for (j = 0 ...) */
5916 /* since at least one of the file has been moved lets update
5917 the !dtdesktop file */
5918 SaveDesktopInfo(NORMAL_RESTORE);
5925 * This function returns the current working directory settings, used when
5926 * invoking an action. The caller passes in the current directory for the
5927 * command, and we will simply copy it and return new pointers, unless the
5928 * path specifies a directory which is part of the tool/apps area; in this
5929 * case, the cwd is set to the user's home directory.
5931 * The application must free up these two return pointers.
5943 if ((strcmp(home_host_name, viewHost) == 0) && type != NULL)
5947 /* Force app dir and any of its subdirs to use $HOME */
5948 if(strcmp(users_home_dir, "/") != 0)
5950 ptr = strrchr(users_home_dir, '/');
5952 *pwdDirRet = XtNewString(users_home_dir);
5956 *pwdDirRet = XtNewString(users_home_dir);
5957 *pwdHostRet = XtNewString(home_host_name);
5961 /* Simply use the passed in cwd */
5962 *pwdHostRet = XtNewString(viewHost);
5963 *pwdDirRet = XtNewString(viewDir);
5968 CreateFmPopup (Widget w)
5970 Widget popupBtns[FM_POPUP_CHILDREN];
5971 XmString label_string;
5978 /* Create file manager popup menu */
5980 XtSetArg(args[n],XmNmenuAccelerator," "); n++;
5981 XtSetArg(args[n],XmNwhichButton, bMenuButton); n++;
5982 fileMgrPopup.menu = XmCreatePopupMenu(w, "FMPopup", args, n);
5983 XtAddCallback(fileMgrPopup.menu, XmNhelpCallback,
5984 (XtCallbackProc)HelpRequestCB,
5985 HELP_POPUP_MENU_STR);
5988 /* Create file manager title */
5989 fileMgrPopup.title = popupBtns[i] =
5990 (Widget)XmCreateLabelGadget(fileMgrPopup.menu, "fmtitle", NULL, 0);
5994 /* Create title separators */
5995 popupBtns[i++] = XmCreateSeparatorGadget(fileMgrPopup.menu, "sep2",
5999 /* Create 'Properties' option - white space popup */
6000 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 150, "Change Permissions...")));
6001 XtSetArg (args[0], XmNlabelString, label_string);
6002 mnemonic = ((char *)GETMESSAGE(20, 17, "P"));
6003 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6005 fileMgrPopup.wsPopup[BTN_PROPERTIES] = popupBtns[i] =
6006 XmCreatePushButtonGadget (fileMgrPopup.menu, "permissions", args, 2);
6007 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6008 (XtCallbackProc)HelpRequestCB,
6009 HELP_POPUP_MENU_STR);
6011 XmStringFree (label_string);
6014 /* Create 'Find' option -- white space popup */
6015 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 18, "Find...")));
6016 XtSetArg (args[0], XmNlabelString, label_string);
6017 mnemonic = ((char *)GETMESSAGE(20, 19, "F"));
6018 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6020 fileMgrPopup.wsPopup[BTN_FIND] = popupBtns[i] =
6021 XmCreatePushButtonGadget (fileMgrPopup.menu, "find", args, 2);
6022 XtAddCallback (popupBtns[i], XmNactivateCallback,
6023 ShowFindDialog, (XtPointer) FM_POPUP);
6024 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6025 (XtCallbackProc)HelpRequestCB,
6026 HELP_FILE_MENU_STR);
6028 XmStringFree (label_string);
6031 /* Create 'Clean Up' option -- white space popup */
6032 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 99, "Clean Up")));
6033 XtSetArg (args[0], XmNlabelString, label_string);
6034 mnemonic = ((char *)GETMESSAGE(20, 100, "C"));
6035 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6037 fileMgrPopup.wsPopup[BTN_CLEANUP] = popupBtns[i] =
6038 XmCreatePushButtonGadget (fileMgrPopup.menu, "cleanUp", args, 2);
6039 XtAddCallback (popupBtns[i], XmNactivateCallback,
6040 CleanUp, (XtPointer) FM_POPUP);
6041 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6042 (XtCallbackProc)HelpRequestCB,
6043 HELP_CLEAN_UP_COMMAND_STR);
6045 XmStringFree (label_string);
6048 /* Create 'Select All' option -- white space popup */
6049 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 48, "Select All")));
6050 XtSetArg (args[0], XmNlabelString, label_string);
6051 mnemonic = ((char *)GETMESSAGE(20, 51, "S"));
6052 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6054 fileMgrPopup.wsPopup[BTN_SELECTALL] = popupBtns[i] =
6055 XmCreatePushButtonGadget (fileMgrPopup.menu, "selectAll", args, 2);
6056 XtAddCallback (popupBtns[i], XmNactivateCallback,
6057 SelectAll, (XtPointer) FM_POPUP);
6058 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6059 (XtCallbackProc)HelpRequestCB,
6060 HELP_SELECT_ALL_COMMAND_STR);
6062 XmStringFree (label_string);
6065 /* Create 'Unselect All' option -- white space popup */
6066 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 52, "Deselect All")));
6067 XtSetArg (args[0], XmNlabelString, label_string);
6068 mnemonic = ((char *)GETMESSAGE(20, 55, "D"));
6069 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6071 fileMgrPopup.wsPopup[BTN_UNSELECTALL] = popupBtns[i] =
6072 XmCreatePushButtonGadget (fileMgrPopup.menu, "deselectAll", args, 2);
6073 XtAddCallback (popupBtns[i], XmNactivateCallback,
6074 UnselectAll, (XtPointer) FM_POPUP);
6075 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6076 (XtCallbackProc)HelpRequestCB,
6077 HELP_UNSELECT_ALL_COMMAND_STR);
6079 XmStringFree (label_string);
6082 /* Create 'Show Hidden Files' option -- white space popup */
6083 label_string = XmStringCreateLocalized((GETMESSAGE(20, 156, "Show Hidden Objects")));
6084 XtSetArg (args[0], XmNlabelString, label_string);
6085 mnemonic = ((char *)GETMESSAGE(20, 102, "H"));
6086 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6088 fileMgrPopup.wsPopup[BTN_SHOWHIDDEN] = popupBtns[i] =
6089 XmCreateToggleButtonGadget (fileMgrPopup.menu, "showHiddenObjects", args, 2);
6090 XtAddCallback (popupBtns[i], XmNvalueChangedCallback,
6091 ShowHiddenFiles, (XtPointer) FM_POPUP);
6092 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6093 (XtCallbackProc)HelpRequestCB,
6094 HELP_SHOW_HIDDEN_COMMAND_STR);
6096 XmStringFree (label_string);
6099 /* Manage white space popup buttons -- since XmNadjustMargin defaults */
6100 /* to true, we manage these buttons now so that they will be aligned */
6101 /* according to the 'ShowHiddenFiles' toggle button */
6102 XtManageChildren(fileMgrPopup.wsPopup, WS_BTNS);
6105 /* Adjust XmNadjustMargin such that the rest of the popup buttons will */
6106 /* NOT be forced to align with the 'ShowHiddenFiles' toggle button */
6107 XtSetArg(args[0], XmNadjustMargin, False);
6108 XtSetValues(fileMgrPopup.menu, args, 1);
6111 /* Create 'Properties' option - object popup */
6112 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 150, "Change Permissions...")));
6113 XtSetArg (args[0], XmNlabelString, label_string);
6114 mnemonic = ((char *)GETMESSAGE(20, 17, "P"));
6115 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6117 fileMgrPopup.objPopup[BTN_PROPERTIES] = popupBtns[i] =
6118 XmCreatePushButtonGadget (fileMgrPopup.menu, "permissions", args, 2);
6119 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6120 (XtCallbackProc)HelpRequestCB,
6121 HELP_POPUP_MENU_STR);
6123 XmStringFree (label_string);
6126 /* Create 'Put In Workspace' option -- object popup */
6127 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 84, "Put in Workspace")));
6128 XtSetArg (args[0], XmNlabelString, label_string);
6129 mnemonic = ((char *)GETMESSAGE(20, 85, "W"));
6130 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6132 fileMgrPopup.objPopup[BTN_PUTON] = popupBtns[i] =
6133 XmCreatePushButtonGadget (fileMgrPopup.menu, "putInWorkspace", args, 2);
6134 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6135 (XtCallbackProc)HelpRequestCB,
6136 HELP_POPUP_MENU_STR);
6138 XmStringFree (label_string);
6141 /* Create 'Delete To Trash' option -- object popup */
6142 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 151, "Put in Trash")));
6143 XtSetArg (args[0], XmNlabelString, label_string);
6144 mnemonic = ((char *)GETMESSAGE(20, 91, "T"));
6145 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6147 fileMgrPopup.objPopup[BTN_TRASH] = popupBtns[i] =
6148 XmCreatePushButtonGadget (fileMgrPopup.menu, "trash", args, 2);
6149 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6150 (XtCallbackProc)HelpRequestCB,
6151 HELP_POPUP_MENU_STR);
6153 XmStringFree (label_string);
6155 /* Create 'Help' option -- object popup */
6156 label_string = XmStringCreateLocalized ((GETMESSAGE(20, 123, "Help")));
6157 XtSetArg (args[0], XmNlabelString, label_string);
6158 mnemonic = ((char *)GETMESSAGE(20, 102, "H"));
6159 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6161 fileMgrPopup.objPopup[BTN_HELP] = popupBtns[i] =
6162 XmCreatePushButtonGadget (fileMgrPopup.menu, "popupHelp", args, 2);
6163 XtAddCallback (popupBtns[i++], XmNhelpCallback,
6164 (XtCallbackProc)HelpRequestCB,
6165 HELP_HELP_MENU_STR);
6167 XmStringFree (label_string);
6169 /* Create 'Restore' option -- trash popup */
6170 label_string = XmStringCreateLocalized ((GETMESSAGE(27, 24, "Put back")));
6171 XtSetArg (args[0], XmNlabelString, label_string);
6172 mnemonic = ((char *)GETMESSAGE(27, 26, "P"));
6173 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6174 fileMgrPopup.trash_objPopup[BTN_RESTORE] = popupBtns[i] =
6175 XmCreatePushButtonGadget (fileMgrPopup.menu, "putBack", args, 2);
6176 XtAddCallback(popupBtns[i++], XmNhelpCallback,
6177 (XtCallbackProc)HelpRequestCB,
6178 HELP_TRASH_DIALOG_STR);
6179 XmStringFree (label_string);
6182 /* Create 'Remove' option -- trash popup */
6183 label_string = XmStringCreateLocalized ((GETMESSAGE(27, 28, "Shred")));
6184 XtSetArg (args[0], XmNlabelString, label_string);
6185 mnemonic = ((char *)GETMESSAGE(27, 30, "h"));
6186 XtSetArg (args[1], XmNmnemonic, mnemonic[0]);
6187 fileMgrPopup.trash_objPopup[BTN_REMOVE] = popupBtns[i] =
6188 XmCreatePushButtonGadget (fileMgrPopup.menu, "shred", args, 2);
6189 XtAddCallback(popupBtns[i++], XmNhelpCallback,
6190 (XtCallbackProc)HelpRequestCB,
6191 HELP_TRASH_DIALOG_STR);
6192 XmStringFree (label_string);
6195 /* Create separator -- white space popup and object popup */
6196 fileMgrPopup.action_separator = popupBtns[i++] =
6197 XmCreateSeparatorGadget(fileMgrPopup.menu, "sep2", NULL, 0);
6200 /* Manage popup buttons */
6201 XtManageChildren(popupBtns, i);
6206 /************************************************************************
6208 * DoTheMove - the user wishes to actually do the move even though its
6209 * not the desktop object that is actually getting moved.
6210 * This function calls the routines which do the moves. It
6211 * depends on the view type to determine how it does it.
6213 * DESKTOP - the drop happened on a Desktop object
6214 * and the object was a directory
6215 * NOT_DESKTOP_DIR - the drop happened on a directory
6216 * but it wasn't a directory on the desktop.
6217 * NOT_DESKTOP - drop happened in a FileManager view
6218 * and not on a directory.
6220 * if the type passed in is DESKTOP, then remove the corresponding
6223 ************************************************************************/
6232 char *file, *next, *end;
6233 char directory[MAX_PATH];
6234 Boolean result = True;
6236 file_count = global_file_count;
6237 file_set = global_file_set;
6238 host_set = global_host_set;
6244 RepositionIcons(fm, file_set, file_count, dx, dy, True);
6246 result = FileMoveCopy(fm,
6247 NULL, fm->current_directory, fm->host,
6248 host_set, file_set, file_count,
6249 (unsigned int)0, NULL, NULL);
6254 for(j = 0; j < file_count; j++)
6256 /* remove the Desktop object which corresponds to this move */
6257 for(i = 0; i < desktop_data->numIconsUsed; i++)
6260 DesktopRec *desktopWin;
6262 desktopWin = desktop_data->desktopWindows[i];
6263 if (strcmp(desktopWin->host, host_set[j]) != 0)
6266 fileName = (char *)XtMalloc(strlen(desktopWin->dir_linked_to)+
6267 strlen(desktopWin->file_name) + 3);
6268 sprintf( fileName, "%s/%s", desktopWin->dir_linked_to,
6269 desktopWin->file_name );
6271 * if fileName == file_set[j] then the file is on the
6272 * Desktop so change the dir_linked to reference. What the
6273 * new reference is depends on which view type is being
6276 if(strcmp(fileName, file_set[j]) == 0)
6280 Screen *currentScreen;
6282 char *workspace_name;
6284 screen = XDefaultScreen(XtDisplay(desktopWin->shell));
6286 XScreenOfDisplay(XtDisplay(desktopWin->shell), screen);
6287 rootWindow = RootWindowOfScreen(currentScreen);
6289 if(DtWsmGetCurrentWorkspace(XtDisplay(desktopWin->shell),
6290 rootWindow, &pCurrent) == Success)
6292 XGetAtomName (XtDisplay(desktopWin->shell), pCurrent);
6294 workspace_name = XtNewString("One");
6295 if (strcmp(workspace_name, desktopWin->workspace_name) == 0)
6297 RemoveDT (desktopWin->shell, (XtPointer) desktopWin,
6299 XtFree(workspace_name);
6300 workspace_name = NULL;
6303 XtFree(workspace_name);
6304 workspace_name = NULL;
6312 case NOT_DESKTOP_DIR:
6313 sprintf( directory, "%s/%s", dd->name, fv->file_data->file_name );
6315 result = FileMoveCopy (fm,
6316 NULL, directory, fm->host,
6317 host_set, file_set, file_count,
6318 (unsigned int) 0, NULL, NULL);
6325 DirectorySet * directory_data = (DirectorySet *)fv->directory_set;
6327 sprintf( directory, "%s/%s", directory_data->name,
6328 fv->file_data->file_name );
6330 result = FileMoveCopyDesktop (fv, directory, host_set, file_set,
6331 file_count, mod, dtWindow,
6337 _DtFreeDroppedFileInfo(file_count, file_set, host_set);
6345 Cardinal *num_params )
6347 XmDrawingAreaCallbackStruct cb ;
6348 FileMgrRec * fileMgrRec;
6350 Widget input_on_gadget ;
6352 if ((event->type == KeyPress)
6353 ||(event->type == KeyRelease))
6361 cb.reason = XmCR_INPUT ;
6364 if( *(params[0]) != '@' )
6367 sscanf( params[0], "%lx", &fileMgrRec );
6369 sscanf( params[0], "%p", &fileMgrRec );
6371 FileWindowInputCallback( wid, (XtPointer)fileMgrRec, (XtPointer)&cb );