コード例 #1
0
        //public override void DragDrop(ITreeNode draggingNode)
        //{
        //    if (draggingNode is FileTreeNodeBase || draggingNode is VirtualFileTreeNodeBase)
        //    {
        //        ContextMenuStripEx menu = new ContextMenuStripEx();
        //        var copy = menu.Items.Add(Texts.Get("s_copy_here"));
        //        copy.Click += (sender, ev) => DragDropFile(draggingNode, CopyFileMode.Copy);
        //        var move = menu.Items.Add(Texts.Get("s_move_here"));
        //        move.Click += (sender, ev) => DragDropFile(draggingNode, CopyFileMode.Move);
        //        menu.ShowOnCursor();
        //    }
        //}

        private void DoGetChildren()
        {
            var loaded = new Dictionary <string, ITreeNode>();
            List <ITreeNode> result = new List <ITreeNode>();
            var files = m_folder.LoadFiles();

            HTree.CallFilterFolderFiles(files);
            files.Sort((a, b) => a.FullPath.Length - b.FullPath.Length);
            foreach (IVirtualFile file in files)
            {
                if (PrefixTest(loaded, file))
                {
                    continue;
                }

                ITreeNode node = null;
                if (file.DiskPath != null)
                {
                    if (DeletedFileRegistrer.DeletedInvisible.Contains(file.DiskPath.ToLower()))
                    {
                        continue;
                    }
                    if (DeletedFileRegistrer.DeletedVisible.Contains(file.DiskPath.ToLower()))
                    {
                        node = new DeletedPathNode(this, file.DiskPath);
                    }
                }

                try
                {
                    if (node == null)
                    {
                        node = NodeFactory.FromFile(this, file);
                    }
                }
                catch
                {
                    node = new UnknownVirtualFileNode(this, new UnknownFileHandler {
                        FileObject = file
                    });
                }
                //if (node == null) node = new UnknownVirtualFileNode(this, file);

                if (node != null)
                {
                    result.Add(node);
                }
                if (node is VirtualFileTreeNodeBase)
                {
                    loaded[file.Name] = (VirtualFileTreeNodeBase)node;
                }
            }

            var dirs = m_folder.LoadFolders();

            dirs.Sort((a, b) => a.FullPath.Length - b.FullPath.Length);

            foreach (var dir in dirs)
            {
                //if (System.IO.Path.GetFileName(dir).ToLower().StartsWith(".private")) continue;
                if (dir.DiskPath != null && IOTool.IsVersioningDirectory(dir.DiskPath))
                {
                    continue;
                }
                if (PrefixTest(loaded, dir))
                {
                    continue;
                }

                ITreeNode node = null;
                if (dir.DiskPath != null)
                {
                    if (DeletedFileRegistrer.DeletedInvisible.Contains(dir.DiskPath.ToLower()))
                    {
                        continue;
                    }
                    if (DeletedFileRegistrer.DeletedVisible.Contains(dir.DiskPath.ToLower()))
                    {
                        node = new DeletedPathNode(this, dir.DiskPath);
                    }
                }

                if (node == null)
                {
                    var newnode = new VirtualFolderTreeNode(this, dir, dir.Name);
                    loaded[dir.Name] = newnode;
                    node             = newnode;
                }
                result.Add(node);
            }

            result.Sort(CompareNodes);
            PostprocessChildren(result);
            m_children = result.ToArray();
        }