private void ExtractToFile(TreeEntry p_TreeEntry)
        {
            string packedPath      = p_TreeEntry.IndexData.FilePath;
            string defaultFilename = packedPath.Split('/').Last();

            SaveFileDialog saveFileDialog = new SaveFileDialog {
                FileName = defaultFilename
            };

            if (saveFileDialog.ShowDialog() == true)
            {
                try {
                    LoadedPackedFile.Extract(p_TreeEntry.IndexData.FilePath, saveFileDialog.FileName);
                } catch (Exception ex) {
                    Error(ex);
                }
            }
        }
        public void AddFileData(PackedFileIndexData p_File, string p_SubdirFilename = "")
        {
            string fileName;

            if (p_SubdirFilename.Length == 0)
            {
                fileName = p_File.FilePath;
            }
            else
            {
                fileName = p_SubdirFilename;
            }

            if (fileName.Contains('/'))
            {
                var       nextDir = fileName.Split("/")[0];
                TreeEntry subDir  = null;
                foreach (TreeEntry entry in Items)
                {
                    if (entry.Name.Equals(nextDir))
                    {
                        subDir = entry;
                        break;
                    }
                }
                if (subDir == null)
                {
                    subDir = new TreeEntry(this)
                    {
                        Name = nextDir
                    };
                    Items.Add(subDir);
                }
                subDir.AddFileData(p_File, fileName.Substring(nextDir.Length + 1));
            }
            else
            {
                Items.Add(new TreeEntry(this)
                {
                    Name = fileName, IndexData = p_File
                });
            }
        }
        public int CompareTo(object p_Other)
        {
            TreeEntry a = this;
            TreeEntry b = (TreeEntry)p_Other;

            if (a.IsDirectory == b.IsDirectory)
            {
                return(a.Name.CompareTo(b.Name));
            }
            else
            {
                if (a.IsDirectory)
                {
                    return(-1);
                }
                else
                {
                    return(1);
                }
            }
        }
        private void ExtractToFolder(IList p_SelectedItems)
        {
            // todo: CommonOpenFileDialog is from WindowsAPICodePack-Shell: analyse Nuget warnings
            CommonOpenFileDialog folderDialog = new CommonOpenFileDialog {
                IsFolderPicker = true
            };

            if (folderDialog.ShowDialog() == CommonFileDialogResult.Ok)
            {
                foreach (var item in p_SelectedItems)
                {
                    Debug.Assert(item is TreeEntry); // should always be the case
                    TreeEntry entry = item as TreeEntry;
                    try {
                        LoadedPackedFile.Extract(entry.GetItemPathString(), System.IO.Path.Combine(folderDialog.FileName, entry.Name));
                    } catch (Exception ex) {
                        Error(ex);
                    }
                }
            }
        }
        private void RefreshTreeView()
        {
            TreeEntry root = new TreeEntry(null)
            {
                Name = LoadedPackedFile.FileName
            };

            foreach (PackedFileIndexData file in LoadedPackedFile.GetFileIndexDataList())
            {
                root.AddFileData(file);
            }
            root.Sort();
            FileTree.Items.Clear();
            FileTree.Items.Add(root);

            TreeContent.Items.Clear();
            foreach (var item in root.Items)
            {
                TreeContent.Items.Add(item);
            }

            CurrentFolder = root;
        }
 public TreeEntry(TreeEntry p_Parent)
 {
     Items     = new ObservableCollection <TreeEntry>();
     IndexData = null;
     Parent    = p_Parent;
 }
 public TreeEntryAlias(TreeEntry p_Reference) : base(p_Reference.Parent)
 {
     ReferencedEntry = p_Reference;
     IndexData       = p_Reference.IndexData;
     Items           = p_Reference.Items;
 }
        private void TreeContent_SelectionChanged(object p_Sender, SelectionChangedEventArgs p_EventArgs)
        {
            ContentSelected = (TreeContent.SelectedItems.Count != 0);

            if (p_EventArgs.AddedItems.Count == 0)
            {
                return;
            }

            TreeEntry selectedItem = p_EventArgs.AddedItems[0] as TreeEntry;

            if (selectedItem is TreeEntryAlias /* && selectedItem.Name.Equals(NAVIGATE_UP_NAME) */)
            {
                (TreeContent.ItemContainerGenerator.ContainerFromItem(selectedItem) as ListViewItem).IsSelected = false;
                return;
            }

            List <TreeEntry> itemPath = selectedItem.GetItemPath();

            // Update Tree Selection
            _FileTreeSelectionUpdating = true;
            try {
                ItemsControl currentLevel = FileTree as ItemsControl;
                // foreach folder (pathLevel) expand the correct subfolder
                foreach (TreeEntry pathLevel in itemPath)
                {
                    TreeViewItem nextLevel      = null;
                    bool         doUpdateLayout = false;
                    // Check each subfolder if it is the wanted one and expand/collapse accordingly
                    foreach (TreeEntry treeItem in currentLevel.Items)
                    {
                        if (currentLevel.ItemContainerGenerator.ContainerFromItem(treeItem) is not TreeViewItem treeItemControl)
                        {
                            break;
                        }

                        var isNextPathLevel = treeItem.Equals(pathLevel);
                        // update IsExpanded and note if we need to update currentLevel layout
                        if (!doUpdateLayout && treeItemControl.IsExpanded != isNextPathLevel)
                        {
                            doUpdateLayout = true;
                        }
                        treeItemControl.IsExpanded = isNextPathLevel;
                        if (isNextPathLevel)
                        {
                            nextLevel = treeItemControl;
                        }
                    }
                    if (doUpdateLayout)
                    {
                        currentLevel.UpdateLayout();
                    }

                    if (nextLevel is null)
                    {
                        break;
                    }

                    currentLevel = nextLevel;
                }
                TreeContent_SelectTreeViewItem(currentLevel as TreeViewItem);
            } finally {
                _FileTreeSelectionUpdating = false;
            }
        }