public void Expand(FileListViewModel _rootModel, ExModel dirModel)
        {
            if (_rootModel != null)
            {
                if (EmbeddedModel is DirectoryModel)
                //////{ }
                    _rootModel.CurrentDirectory = (EmbeddedModel as DirectoryModel).EmbeddedDirectoryEntry;
                else
                {
                    try
                    {
                        FileSystemInfoEx entry = EmbeddedModel.EmbeddedEntry;
                        if (PathEx.GetExtension(entry.Name).ToLower() == ".lnk")
                            using (ShellLink sl = new ShellLink(entry.FullName))
                            {
                                string linkPath = sl.Target;
                                if (DirectoryEx.Exists(linkPath) && sl.Arguments == "")
                                    _rootModel.CurrentDirectory = FileSystemInfoEx.FromString(linkPath) as DirectoryInfoEx;
                                else Run(linkPath, sl.Arguments);
                            }
                        else
                            Run(entry.FullName, "");
                    }
                    catch (IOException ex)
                    {
                        MessageBox.Show(ex.Message, "Expand Failed");
                    }
                }

            }

        }
        public FileListCommands(FileList flist, FileListViewModel rootModel)
        {
            Func<ExModel[]> getSelectionFunc = new Func<ExModel[]>(() =>
            { return (from vm in rootModel.CurrentDirectoryModel.SelectedViewModels select vm.EmbeddedModel).ToArray(); });
            Func<DirectoryModel> getCurrentFunc = new Func<DirectoryModel>(() => { return rootModel.CurrentDirectoryModel.EmbeddedDirectoryModel; });
            Func<System.Drawing.Point> getMousePositionFunc = new Func<System.Drawing.Point>(() =>
            { Point pt = flist.PointToScreen(Mouse.GetPosition(flist)); return new System.Drawing.Point((int)pt.X, (int)pt.Y); });

            SetupCommands(getSelectionFunc, getCurrentFunc, getMousePositionFunc);
            SetupCommands(flist, rootModel);

            SimpleRoutedCommand.Register(typeof(FileList), RefreshCommand);
            SimpleRoutedCommand.Register(typeof(FileList), ContextMenuCommand);
            SimpleRoutedCommand.Register(typeof(FileList), NewFolderCommand);
            SimpleRoutedCommand.Register(typeof(FileList), OpenCommand, new KeyGesture(Key.Enter));
            SimpleRoutedCommand.Register(typeof(FileList), CopyCommand);
            SimpleRoutedCommand.Register(typeof(FileList), PasteCommand);
            SimpleRoutedCommand.Register(typeof(FileList), SelectAllCommand, new KeyGesture(Key.A, ModifierKeys.Control));
            SimpleRoutedCommand.Register(typeof(FileList), DeleteCommand, new KeyGesture(Key.Delete));
            SimpleRoutedCommand.Register(typeof(FileList), PropertiesCommand);
            SimpleRoutedCommand.Register(typeof(FileList), RenameCommand, new KeyGesture(Key.F2));
            SimpleRoutedCommand.Register(typeof(FileList), FindCommand, new KeyGesture(Key.F, ModifierKeys.Control));

            flist.AddHandler(TreeViewItem.MouseRightButtonUpEvent, new MouseButtonEventHandler(
                (MouseButtonEventHandler)delegate(object sender, MouseButtonEventArgs args)
                {
                    ApplicationCommands.ContextMenu.Execute(null, flist);
                }));
        }
        public FileListViewItemViewModel(FileListViewModel rootModel, Model.ExModel model)
            : base(rootModel, model)
        {
            _rootModel = rootModel;

            _expandCommand = new SimpleCommand
            {
                CanExecuteDelegate = x => true,
                ExecuteDelegate    = x => Expand(_rootModel, (ExModel)x)
            };
        }
        public FileListViewItemViewModel(FileListViewModel rootModel, Model.ExModel model)
            : base(rootModel, model)
        {
            _rootModel = rootModel;

            _expandCommand = new SimpleCommand
            {
                CanExecuteDelegate = x => true,
                ExecuteDelegate = x => Expand(_rootModel, (ExModel)x)
            };
        }
        public void Expand(FileListViewModel _rootModel, ExModel dirModel)
        {
            if (_rootModel != null)
            {
                EmbeddedModel = dirModel;
                if (EmbeddedModel is DirectoryModel)
                {
                    _rootModel.CurrentDirectory = (EmbeddedModel as DirectoryModel).EmbeddedDirectoryEntry;
                }
                else
                {
                    try
                    {
#if true
                        FileSystemInfoEx entry = EmbeddedModel.EmbeddedEntry;
#else
                        FileSystemInfoEx entry = EmbeddedModel.EmbeddedEntry;
#endif

                        if (PathEx.GetExtension(entry.Name).ToLower() == ".lnk")
                        {
                            using (ShellLink sl = new ShellLink(entry.FullName))
                            {
                                string linkPath = sl.Target;
                                if (DirectoryEx.Exists(linkPath) && sl.Arguments == "")
                                {
                                    _rootModel.CurrentDirectory = FileSystemInfoEx.FromString(linkPath) as DirectoryInfoEx;
                                }
                                else
                                {
                                    Run(linkPath, sl.Arguments);
                                }
                            }
                        }
                        else
                        {
                            Run(entry.FullName, "");
                        }
                    }
                    catch (IOException ex)
                    {
                        MessageBox.Show(ex.Message, "Expand Failed");
                    }
                }
            }
        }
        public CurrentDirectoryViewModel(FileListViewModel rootModel, Model.DirectoryModel model)
            : base(rootModel, model)
        {
            IsLoaded   = false;
            _rootModel = rootModel;

            _subEntries        = new CollectionViewSource();
            _subEntries.Source = SubEntriesInternal;
            _subEntries.SortDescriptions.Add(new SortDescription("IsDirectory", ListSortDirection.Descending));
            _subEntries.SortDescriptions.Add(new SortDescription("FullName", ListSortDirection.Ascending));

            _refreshCommand = new SimpleCommand
            {
                CanExecuteDelegate = x => true,
                ExecuteDelegate    = x => Refresh()
            };


            #region FileSystemWatcher
            _watcher = new FileSystemWatcherEx(model.EmbeddedDirectoryEntry);

            var handler = (FileSystemEventHandlerEx) delegate(object sender, FileSystemEventArgsEx args)
            {
                if (args.FullPath.Equals(model.FullName))
                {
                    Refresh();
                }
            };
            var renameHandler = (RenameEventHandlerEx) delegate(object sender, RenameEventArgsEx args)
            {
                if (args.OldFullPath.Equals(model.FullName))
                {
                    Refresh();
                }
            };

            _watcher.OnChanged += handler;
            _watcher.OnCreated += handler;
            _watcher.OnDeleted += handler;
            _watcher.OnRenamed += renameHandler;
            #endregion
        }
        public CurrentDirectoryViewModel(FileListViewModel rootModel, Model.DirectoryModel model)
            : base(rootModel, model)
        {
            IsLoaded = false;
            _rootModel = rootModel;

            _subEntries = new CollectionViewSource();
            _subEntries.Source = SubEntriesInternal;
            _subEntries.SortDescriptions.Add(new SortDescription("IsDirectory", ListSortDirection.Descending));
            _subEntries.SortDescriptions.Add(new SortDescription("FullName", ListSortDirection.Ascending));

            _refreshCommand = new SimpleCommand
            {
                CanExecuteDelegate = x => true,
                ExecuteDelegate = x => Refresh()
            };

            #region FileSystemWatcher
            _watcher = new FileSystemWatcherEx(model.EmbeddedDirectoryEntry);

            var handler = (FileSystemEventHandlerEx)delegate(object sender, FileSystemEventArgsEx args)
            {
                if (args.FullPath.Equals(model.FullName))
                    Refresh();
            };
            var renameHandler = (RenameEventHandlerEx)delegate(object sender, RenameEventArgsEx args)
            {
                if (args.OldFullPath.Equals(model.FullName))
                    Refresh();
            };

            _watcher.OnChanged += handler;
            _watcher.OnCreated += handler;
            _watcher.OnDeleted += handler;
            _watcher.OnRenamed += renameHandler;
            #endregion
        }
        public void SetupCommands(FileList flist, FileListViewModel rootModel)
        {
            #region IndividualItemCommand - Open, Rename
            OpenCommand = new SimpleRoutedCommand(ApplicationCommands.Open)
            {
                CanExecuteDelegate = x =>
                {
                    return rootModel.CurrentDirectoryModel != null && rootModel.CurrentDirectoryModel.SelectedCount == 1;
                },
                ExecuteDelegate = x =>
                {
                    rootModel.CurrentDirectoryModel.SelectedViewModels[0].Expand(rootModel,
                        rootModel.CurrentDirectoryModel.SelectedViewModels[0].EmbeddedModel);
                }
            };

            RenameCommand = new SimpleRoutedCommand(ApplicationCommands.SaveAs)
            {
                CanExecuteDelegate = x =>
                {
                    return rootModel.CurrentDirectoryModel != null && rootModel.CurrentDirectoryModel.SelectedCount == 1;
                },
                ExecuteDelegate = x =>
                {
                    rootModel.CurrentDirectoryModel.IsEditing = !rootModel.CurrentDirectoryModel.IsEditing;
                }
            };

            #endregion

            #region NewFolderCommand
            NewFolderCommand = new SimpleRoutedCommand(FileListCommands.NewFolder)
            {
                CanExecuteDelegate = x =>
                {
                    if ((rootModel.CurrentDirectoryModel.EmbeddedDirectoryModel.EmbeddedDirectoryEntry.Attributes & FileAttributes.ReadOnly) != 0)
                        return false;

                    if (x == null)
                        return true;

                    if (x is string)
                    {
                        string type = (string)x;
                        switch (type.ToLower())
                        {
                            case "zip":
                            case "7z": return true;
                        }
                    }

                    return false;
                },
                ExecuteDelegate = x =>
                {
                    string type = x as string;
                    if (x != null) type = type.ToLower();
                    rootModel.CurrentDirectoryModel.NewFolder();
                }
            };
            #endregion

            #region SelectAllCommand
            SelectAllCommand = new SimpleRoutedCommand(ApplicationCommands.SelectAll)
            {
                CanExecuteDelegate = x =>
                {
                    return rootModel.CurrentDirectoryModel != null && rootModel.CurrentDirectoryModel.HasSubEntries;
                },
                ExecuteDelegate = x =>
                {
                    if (rootModel.CurrentDirectoryModel.SelectedCount == rootModel.CurrentDirectoryModel.SubEntriesInternal.Count)
                        rootModel.CurrentDirectoryModel.UnselectAll();
                    else rootModel.CurrentDirectoryModel.SelectAll();
                }

            };
            #endregion

            #region RefreshCommand
            RefreshCommand = new SimpleRoutedCommand(NavigationCommands.Refresh)
            {
                CanExecuteDelegate = x => true,
                ExecuteDelegate = x => rootModel.CurrentDirectoryModel.Refresh()
            };
            #endregion

            #region FindCommand

            FindCommand = new SimpleRoutedCommand(ApplicationCommands.Find)
            {
                CanExecuteDelegate = x =>
                {
                    return rootModel.CurrentDirectoryModel != null && !rootModel.CurrentDirectoryModel.IsEditing;
                },
                ExecuteDelegate = x =>
                {
                    flist.LookupAdorner.UpdateVisibilty(true);
                    FocusManager.SetFocusedElement(flist, flist.LookupAdorner);
                }
            };

            #endregion
        }
Beispiel #9
0
        public FileList()
        {
            ModelToExConverter = new ModelToExConverter();
            ExModelToIconConverter = new ExModelToIconConverter();
            DataContext = RootModel = new FileListViewModel();
            Commands = new FileListCommands(this, RootModel);

            InitializeComponent();

            //0.2
            Binding isLoadingBinding = new Binding("IsLoading");
            isLoadingBinding.Source = RootModel;
            this.SetBinding(IsLoadingProperty, isLoadingBinding);

            Binding sortByBinding = new Binding("SortBy");
            sortByBinding.Source = RootModel;
            sortByBinding.Mode = BindingMode.TwoWay;
            this.SetBinding(SortByProperty, sortByBinding);

            Binding sortDirectionBinding = new Binding("SortDirection");
            sortDirectionBinding.Source = RootModel;
            sortDirectionBinding.Mode = BindingMode.TwoWay;
            this.SetBinding(SortDirectionProperty, sortDirectionBinding);
            UpdateCollumnHeader();

            RootModel.OnProgress += (ProgressEventHandler)delegate(object sender, ProgressEventArgs e)
            {
                RaiseEvent(new ProgressRoutedEventArgs(ProgressEvent, e));
            };

            this.AddHandler(ListView.KeyDownEvent, (KeyEventHandler)delegate(object sender, KeyEventArgs args)
            {
                if ((args as RoutedEventArgs).OriginalSource == this)
                {
                    if ((int)args.Key >= (int)Key.A && (int)args.Key <= (int)Key.Z)
                    {
                        _lookupAdorner.UpdateVisibilty(true);
                        //_lookupAdorner.Focus();
                        Keyboard.Focus(_lookupAdorner);

                        //_lookupAdorner.Text = args.Key.ToString().ToLower();
                    }

                    if (args.Key == Key.Escape)
                        _lookupAdorner.UpdateVisibilty(false);

                }
                //if (args.Key == Key.F3)
                //    _lookupAdorner.UpdateVisibilty(true);

            });

            //0.2
            this.AddHandler(GridViewColumnHeader.ClickEvent, (RoutedEventHandler)delegate(object sender, RoutedEventArgs args)
            {
                if (args.OriginalSource is GridViewColumnHeader)
                {
                    GridViewColumnHeader header = (GridViewColumnHeader)args.OriginalSource;
                    ExComparer.SortCriteria columnName = GetSortPropertyName(header.Column);

                    //if (string.IsNullOrEmpty(columnName))
                    //    return;

                    if (RootModel.SortBy != columnName)
                        RootModel.SortBy = columnName;
                    else
                        if (RootModel.SortDirection == ListSortDirection.Ascending)
                            RootModel.SortDirection = ListSortDirection.Descending;
                        else RootModel.SortDirection = ListSortDirection.Ascending;

                    UpdateCollumnHeader();
                }

            });

            this.AddHandler(ListView.SelectionChangedEvent, (SelectionChangedEventHandler)delegate(object sender, SelectionChangedEventArgs args)
            {
                List<FileSystemInfoEx> selectedList = new List<FileSystemInfoEx>(SelectedEntries);

                foreach (FileListViewItemViewModel removeItem in args.RemovedItems)
                    selectedList.Remove(removeItem.EmbeddedModel.EmbeddedEntry);

                foreach (FileListViewItemViewModel addItem in args.AddedItems)
                    selectedList.Add(addItem.EmbeddedModel.EmbeddedEntry);

                SelectedEntries = selectedList;

                //The following does not work because of virtual items.
                //SelectedEntries = RootModel.CurrentDirectoryModel.SelectedEntries;
            });

            RootModel.PropertyChanged += (PropertyChangedEventHandler)delegate(object sender, PropertyChangedEventArgs args)
            {
                if (args.PropertyName == "CurrentDirectory")
                {
                    CurrentDirectory = RootModel.CurrentDirectory;
                    ScrollViewer scrollViewer = UITools.FindVisualChild<ScrollViewer>(this);
                    if (scrollViewer != null)
                        scrollViewer.ScrollToHome();

                    ExToIconConverter ati = this.TryFindResource("ati") as ExToIconConverter;
                    if (ati.IconCount > 500)
                        ati.ClearInstanceCache();
                }

            };

            //#region ExpandHandler
            //this.AddHandler(ListViewItem.MouseDoubleClickEvent, (RoutedEventHandler)delegate(object sender, RoutedEventArgs e)
            //{
            //    DependencyObject lvItem = getListViewItem(e.OriginalSource as DependencyObject);
            //    if (lvItem != null)
            //    {
            //        FileListViewItemViewModel model =
            //            (FileListViewItemViewModel)ItemContainerGenerator.ItemFromContainer(lvItem);
            //        if (model != null)
            //        {
            //            model.Expand();
            //        }
            //    }
            //});
            //#endregion

            #region ContextMenuWrapper - Obsoluted
            //_cmw = new ContextMenuWrapper();

            //this.AddHandler(TreeViewItem.MouseRightButtonUpEvent, new MouseButtonEventHandler(
            //    (MouseButtonEventHandler)delegate(object sender, MouseButtonEventArgs args)
            //    {
            //        if (SelectedValue is FileListViewItemViewModel)
            //        {
            //            var selectedItems = (from FileListViewItemViewModel model in SelectedItems
            //                                 select model.EmbeddedModel.EmbeddedEntry).ToArray();
            //            Point pt = this.PointToScreen(args.GetPosition(this));

            //            string command = _cmw.Popup(selectedItems, new System.Drawing.Point((int)pt.X, (int)pt.Y));
            //            switch (command)
            //            {
            //                case "rename":
            //                    if (this.SelectedValue != null)
            //                    {
            //                        SetIsEditing(ItemContainerGenerator.ContainerFromItem(this.SelectedValue), true);
            //                    }
            //                    break;
            //                case "refresh":
            //                    RootModel.CurrentDirectoryModel.Refresh();
            //                    break;
            //            }
            //        }
            //    }));
            #endregion
        }
 public CurrentDirectoryViewModel Create(FileListViewModel rootModel, Model.DirectoryModel model)
 { return new CurrentDirectoryViewModel(rootModel, model); ; }