From e208029dd329178a81924334b9f2331bb8578391 Mon Sep 17 00:00:00 2001 From: Poddav Date: Mon, 21 Jul 2014 23:26:28 +0400 Subject: [PATCH] Initial commit. --- .gitignore | 6 + AboutBox.xaml | 100 ++ AboutBox.xaml.cs | 213 ++++ App.config | 73 ++ App.xaml | 9 + App.xaml.cs | 174 ++++ ArcFormats/ArcAMI.cs | 284 +++++ ArcFormats/ArcFormats.csproj | 149 +++ ArcFormats/ArcINT.cs | 288 ++++++ ArcFormats/ArcNPA.cs | 376 +++++++ ArcFormats/ArcXFL.cs | 212 ++++ ArcFormats/ArcXP3.cs | 626 +++++++++++ ArcFormats/ArcYPF.cs | 193 ++++ ArcFormats/Blowfish.cs | 677 ++++++++++++ ArcFormats/ImageHG3.cs | 342 ++++++ ArcFormats/ImageTLG.cs | 1006 ++++++++++++++++++ ArcFormats/ImageWCG.cs | 477 +++++++++ ArcFormats/Properties/AssemblyInfo.cs | 36 + ArcFormats/Properties/Settings.Designer.cs | 73 ++ ArcFormats/Properties/Settings.settings | 18 + ArcFormats/Settings.cs | 36 + ArcFormats/Strings/arcStrings.Designer.cs | 139 +++ ArcFormats/Strings/arcStrings.resx | 148 +++ ArcFormats/Strings/arcStrings.ru-RU.resx | 148 +++ ArcFormats/WidgetINT.xaml | 57 + ArcFormats/WidgetINT.xaml.cs | 126 +++ ArcFormats/WidgetNPA.xaml | 6 + ArcFormats/WidgetNPA.xaml.cs | 23 + ArcFormats/WidgetXP3.xaml | 6 + ArcFormats/WidgetXP3.xaml.cs | 24 + ArcFormats/WidgetYPF.xaml | 12 + ArcFormats/WidgetYPF.xaml.cs | 29 + ArcFormats/app.config | 21 + ArcFormats/packages.config | 4 + ArcParameters.xaml | 24 + ArcParameters.xaml.cs | 22 + Console/App.config | 6 + Console/ConsoleBrowser.cs | 137 +++ Console/GARbro.Console.csproj | 101 ++ Console/GARbro.Console.csproj.user | 16 + Console/Properties/AssemblyInfo.cs | 36 + DragScroll.cs | 166 +++ ExtractArchive.xaml | 37 + ExtractArchive.xaml.cs | 80 ++ ExtractDialog.cs | 83 ++ ExtractFile.xaml | 34 + ExtractFile.xaml.cs | 83 ++ GARbro.GUI.csproj | 305 ++++++ GARbro.GUI.csproj.user | 17 + GARbro.sln | 59 ++ GameRes/ArcFile.cs | 245 +++++ GameRes/ArcView.cs | 470 +++++++++ GameRes/GameRes.cs | 347 +++++++ GameRes/GameRes.csproj | 89 ++ GameRes/Image.cs | 100 ++ GameRes/ImageBMP.cs | 81 ++ GameRes/ImageJPEG.cs | 79 ++ GameRes/ImagePNG.cs | 195 ++++ GameRes/ImageTGA.cs | 204 ++++ GameRes/ImageTIFF.cs | 363 +++++++ GameRes/MultiDict.cs | 162 +++ GameRes/Properties/AssemblyInfo.cs | 36 + GameRes/ScriptText.cs | 36 + GameRes/Strings/garStrings.Designer.cs | 90 ++ GameRes/Strings/garStrings.resx | 129 +++ GameRes/Strings/garStrings.ru-RU.resx | 129 +++ GameRes/Utility.cs | 235 +++++ HistoryStack.cs | 109 ++ Image.Convert/App.config | 6 + Image.Convert/Image.Convert.csproj | 70 ++ Image.Convert/Image.Convert.csproj.user | 6 + Image.Convert/Program.cs | 174 ++++ Image.Convert/Properties/AssemblyInfo.cs | 36 + ImagePreview.cs | 205 ++++ Images/32x32/back button.png | Bin 0 -> 4843 bytes Images/32x32/forward button.png | Bin 0 -> 4773 bytes Images/32x32/help.png | Bin 0 -> 2427 bytes Images/64x64/info.png | Bin 0 -> 9247 bytes Images/search4files.ico | Bin 0 -> 22486 bytes MainWindow.xaml | 258 +++++ MainWindow.xaml.cs | 1094 ++++++++++++++++++++ Makefile | 20 + ModalWindow.cs | 88 ++ Properties/AssemblyInfo.cs | 55 + Properties/Resources.Designer.cs | 63 ++ Properties/Resources.resx | 117 +++ Properties/Settings.Designer.cs | 230 ++++ Properties/Settings.settings | 57 + Properties/app.manifest | 54 + Settings.cs | 43 + Shell.cs | 182 ++++ Strings/guiStrings.Designer.cs | 594 +++++++++++ Strings/guiStrings.resx | 297 ++++++ Strings/guiStrings.ru-RU.resx | 300 ++++++ Utility.cs | 117 +++ ViewModel.cs | 296 ++++++ packages.config | 6 + zlib/changes.txt | 25 + zlib/zlib32.dll | Bin 0 -> 142848 bytes zlib/zlib64.dll | Bin 0 -> 165376 bytes zlib/zlibnet.chm | Bin 0 -> 49950 bytes zlib/zlibnet.dll | Bin 0 -> 41472 bytes 102 files changed, 14809 insertions(+) create mode 100644 .gitignore create mode 100644 AboutBox.xaml create mode 100644 AboutBox.xaml.cs create mode 100644 App.config create mode 100644 App.xaml create mode 100644 App.xaml.cs create mode 100644 ArcFormats/ArcAMI.cs create mode 100644 ArcFormats/ArcFormats.csproj create mode 100644 ArcFormats/ArcINT.cs create mode 100644 ArcFormats/ArcNPA.cs create mode 100644 ArcFormats/ArcXFL.cs create mode 100644 ArcFormats/ArcXP3.cs create mode 100644 ArcFormats/ArcYPF.cs create mode 100644 ArcFormats/Blowfish.cs create mode 100644 ArcFormats/ImageHG3.cs create mode 100644 ArcFormats/ImageTLG.cs create mode 100644 ArcFormats/ImageWCG.cs create mode 100644 ArcFormats/Properties/AssemblyInfo.cs create mode 100644 ArcFormats/Properties/Settings.Designer.cs create mode 100644 ArcFormats/Properties/Settings.settings create mode 100644 ArcFormats/Settings.cs create mode 100644 ArcFormats/Strings/arcStrings.Designer.cs create mode 100644 ArcFormats/Strings/arcStrings.resx create mode 100644 ArcFormats/Strings/arcStrings.ru-RU.resx create mode 100644 ArcFormats/WidgetINT.xaml create mode 100644 ArcFormats/WidgetINT.xaml.cs create mode 100644 ArcFormats/WidgetNPA.xaml create mode 100644 ArcFormats/WidgetNPA.xaml.cs create mode 100644 ArcFormats/WidgetXP3.xaml create mode 100644 ArcFormats/WidgetXP3.xaml.cs create mode 100644 ArcFormats/WidgetYPF.xaml create mode 100644 ArcFormats/WidgetYPF.xaml.cs create mode 100644 ArcFormats/app.config create mode 100644 ArcFormats/packages.config create mode 100644 ArcParameters.xaml create mode 100644 ArcParameters.xaml.cs create mode 100644 Console/App.config create mode 100644 Console/ConsoleBrowser.cs create mode 100644 Console/GARbro.Console.csproj create mode 100644 Console/GARbro.Console.csproj.user create mode 100644 Console/Properties/AssemblyInfo.cs create mode 100644 DragScroll.cs create mode 100644 ExtractArchive.xaml create mode 100644 ExtractArchive.xaml.cs create mode 100644 ExtractDialog.cs create mode 100644 ExtractFile.xaml create mode 100644 ExtractFile.xaml.cs create mode 100644 GARbro.GUI.csproj create mode 100644 GARbro.GUI.csproj.user create mode 100644 GARbro.sln create mode 100644 GameRes/ArcFile.cs create mode 100644 GameRes/ArcView.cs create mode 100644 GameRes/GameRes.cs create mode 100644 GameRes/GameRes.csproj create mode 100644 GameRes/Image.cs create mode 100644 GameRes/ImageBMP.cs create mode 100644 GameRes/ImageJPEG.cs create mode 100644 GameRes/ImagePNG.cs create mode 100644 GameRes/ImageTGA.cs create mode 100644 GameRes/ImageTIFF.cs create mode 100644 GameRes/MultiDict.cs create mode 100644 GameRes/Properties/AssemblyInfo.cs create mode 100644 GameRes/ScriptText.cs create mode 100644 GameRes/Strings/garStrings.Designer.cs create mode 100644 GameRes/Strings/garStrings.resx create mode 100644 GameRes/Strings/garStrings.ru-RU.resx create mode 100644 GameRes/Utility.cs create mode 100644 HistoryStack.cs create mode 100644 Image.Convert/App.config create mode 100644 Image.Convert/Image.Convert.csproj create mode 100644 Image.Convert/Image.Convert.csproj.user create mode 100644 Image.Convert/Program.cs create mode 100644 Image.Convert/Properties/AssemblyInfo.cs create mode 100644 ImagePreview.cs create mode 100644 Images/32x32/back button.png create mode 100644 Images/32x32/forward button.png create mode 100644 Images/32x32/help.png create mode 100644 Images/64x64/info.png create mode 100644 Images/search4files.ico create mode 100644 MainWindow.xaml create mode 100644 MainWindow.xaml.cs create mode 100644 Makefile create mode 100644 ModalWindow.cs create mode 100644 Properties/AssemblyInfo.cs create mode 100644 Properties/Resources.Designer.cs create mode 100644 Properties/Resources.resx create mode 100644 Properties/Settings.Designer.cs create mode 100644 Properties/Settings.settings create mode 100644 Properties/app.manifest create mode 100644 Settings.cs create mode 100644 Shell.cs create mode 100644 Strings/guiStrings.Designer.cs create mode 100644 Strings/guiStrings.resx create mode 100644 Strings/guiStrings.ru-RU.resx create mode 100644 Utility.cs create mode 100644 ViewModel.cs create mode 100644 packages.config create mode 100644 zlib/changes.txt create mode 100644 zlib/zlib32.dll create mode 100644 zlib/zlib64.dll create mode 100644 zlib/zlibnet.chm create mode 100644 zlib/zlibnet.dll diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..df26e2db --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +bin +obj +tags +*.exe +*.suo +*;* diff --git a/AboutBox.xaml b/AboutBox.xaml new file mode 100644 index 00000000..0becb3d6 --- /dev/null +++ b/AboutBox.xaml @@ -0,0 +1,100 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs new file mode 100644 index 00000000..1b0cc98f --- /dev/null +++ b/MainWindow.xaml.cs @@ -0,0 +1,1094 @@ +// Game Resource Browser +// +// Copyright (C) 2014 by morkt +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +// + +using System; +using System.IO; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Text; +using System.Diagnostics; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Threading; +using System.Threading; +using Microsoft.VisualBasic.FileIO; +using Ookii.Dialogs.Wpf; +using GARbro.GUI.Properties; +using GARbro.GUI.Strings; +using GameRes; +using Rnd.Windows; + +namespace GARbro.GUI +{ + /// + /// Interaction logic for MainWindow.xaml + /// + public partial class MainWindow : Window + { + private App m_app; + + const StringComparison StringIgnoreCase = StringComparison.CurrentCultureIgnoreCase; + + public MainWindow() + { + m_app = Application.Current as App; + InitializeComponent(); + InitDirectoryChangesWatcher(); + InitPreviewPane(); + + FormatCatalog.Instance.ParametersRequest += OnParametersRequest; + + CurrentDirectory.SizeChanged += (s, e) => { + if (e.WidthChanged) + { + pathLine.MinWidth = e.NewSize.Width-79; + this.MinWidth = e.NewSize.Width+65; + } + }; + pathLine.EnterKeyDown += acb_OnKeyDown; + } + + void WindowLoaded (object sender, RoutedEventArgs e) + { + lv_SetSortMode (Settings.Default.lvSortColumn, Settings.Default.lvSortDirection); + Dispatcher.InvokeAsync (WindowRendered, DispatcherPriority.ContextIdle); + } + + void WindowRendered () + { + ViewModel = CreateViewModel (m_app.InitPath); + lv_SelectItem (0); + SetStatusText (guiStrings.MsgReady); + } + + /// + /// Save settings when main window is about to close + /// + protected override void OnClosing (CancelEventArgs e) + { + SaveSettings(); + base.OnClosing (e); + } + + /// + /// Manually save settings that are not automatically saved by bindings. + /// + private void SaveSettings() + { + if (null != m_lvSortByColumn) + { + Settings.Default.lvSortColumn = m_lvSortByColumn.Tag.ToString(); + Settings.Default.lvSortDirection = m_lvSortDirection; + } + else + Settings.Default.lvSortColumn = ""; + } + + /// + /// Set status line text. Could be called from any thread. + /// + public void SetStatusText (string text) + { + Dispatcher.Invoke (() => { appStatusText.Text = text; }); + } + + /// + /// Popup error message box. Could be called from any thread. + /// + public void PopupError (string message, string title) + { + Dispatcher.Invoke (() => MessageBox.Show (this, message, title, MessageBoxButton.OK, MessageBoxImage.Error)); + } + + /// + /// Set data context of the ListView. + /// + + private DirectoryViewModel ViewModel + { + get + { + var source = CurrentDirectory.ItemsSource as CollectionView; + if (null == source) + return null; + return source.SourceCollection as DirectoryViewModel; + } + set + { + StopWatchDirectoryChanges(); + var cvs = this.Resources["ListViewSource"] as CollectionViewSource; + cvs.Source = value; + pathLine.Text = value.Path; + if (m_lvSortByColumn != null) + lv_Sort (m_lvSortByColumn.Tag.ToString(), m_lvSortDirection); + else + lv_Sort (null, m_lvSortDirection); + if (!value.IsArchive && !string.IsNullOrEmpty (value.Path)) + { + Directory.SetCurrentDirectory (value.Path); + WatchDirectoryChanges (value.Path); + } + CurrentDirectory.UpdateLayout(); + } + } + + DirectoryViewModel GetNewViewModel (string path) + { + SetBusyState(); + path = Path.GetFullPath (path); + if (Directory.Exists (path)) + return new DirectoryViewModel (path, m_app.GetDirectoryList (path)); + else + return new ArchiveViewModel (path, m_app.GetArchive (path)); + } + + public void SetBusyState() + { + Mouse.OverrideCursor = Cursors.Wait; + Dispatcher.InvokeAsync (() => { + Mouse.OverrideCursor = null; + }, DispatcherPriority.ApplicationIdle); + } + + /// + /// Create view model corresponding to . Returns null on error. + /// + DirectoryViewModel TryCreateViewModel (string path) + { + try + { + return GetNewViewModel (path); + } + catch (Exception X) + { + SetStatusText (string.Format ("{0}: {1}", Path.GetFileName (path), X.Message)); + return null; + } + } + + /// + /// Create view model corresponding to or empty view model if there was + /// an error accessing path. + /// + DirectoryViewModel CreateViewModel (string path) + { + try + { + return GetNewViewModel (path); + } + catch (Exception X) + { + PopupError (X.Message, guiStrings.MsgErrorOpening); + return new DirectoryViewModel ("", new Entry[0]); + } + } + + #region Refresh view on filesystem changes + + private FileSystemWatcher m_watcher = new FileSystemWatcher(); + + void InitDirectoryChangesWatcher () + { + m_watcher.NotifyFilter = NotifyFilters.Size | NotifyFilters.FileName | NotifyFilters.DirectoryName; + m_watcher.Changed += InvokeRefreshView; + m_watcher.Created += InvokeRefreshView; + m_watcher.Deleted += InvokeRefreshView; + m_watcher.Renamed += InvokeRefreshView; + } + + void WatchDirectoryChanges (string path) + { + m_watcher.Path = path; + m_watcher.EnableRaisingEvents = true; + } + + void StopWatchDirectoryChanges() + { + m_watcher.EnableRaisingEvents = false; + } + + private void InvokeRefreshView (object source, FileSystemEventArgs e) + { + var watcher = source as FileSystemWatcher; + if (watcher.Path == ViewModel.Path) + { + watcher.EnableRaisingEvents = false; + Dispatcher.Invoke (RefreshView, DispatcherPriority.Send, CancellationToken.None, + TimeSpan.FromMilliseconds (100)); + } + } + #endregion + + /// + /// Select specified item within CurrentDirectory and bring it into a view. + /// + + void lv_SelectItem (EntryViewModel item) + { + if (item != null) + { + CurrentDirectory.SelectedItem = item; + CurrentDirectory.ScrollIntoView (item); + var lvi = (ListViewItem)CurrentDirectory.ItemContainerGenerator.ContainerFromItem (item); + if (lvi != null) + lvi.Focus(); + } + } + + void lv_SelectItem (int index) + { + CurrentDirectory.SelectedIndex = index; + CurrentDirectory.ScrollIntoView (CurrentDirectory.SelectedItem); + var lvi = (ListViewItem)CurrentDirectory.ItemContainerGenerator.ContainerFromIndex (index); + if (lvi != null) + lvi.Focus(); + } + + void lv_SelectItem (string name) + { + if (!string.IsNullOrEmpty (name)) + lv_SelectItem (ViewModel.Find (name)); + } + + private void lv_Focus () + { + if (CurrentDirectory.SelectedIndex != -1) + { + var item = CurrentDirectory.SelectedItem; + var lvi = CurrentDirectory.ItemContainerGenerator.ContainerFromItem (item) as ListViewItem; + if (lvi != null) + { + lvi.Focus(); + return; + } + } + CurrentDirectory.Focus(); + } + + void lvi_Selected (object sender, RoutedEventArgs args) + { + var lvi = sender as ListViewItem; + if (lvi == null) + return; + var entry = lvi.Content as EntryViewModel; + if (entry == null) + return; + PreviewEntry (entry.Source); + } + + void lvi_DoubleClick (object sender, MouseButtonEventArgs args) + { + var lvi = sender as ListViewItem; + if (Commands.OpenItem.CanExecute (null, lvi)) + { + Commands.OpenItem.Execute (null, lvi); + args.Handled = true; + } + } + + /// + /// Get currently selected item from ListView widget. + /// + private ListViewItem lv_GetCurrentContainer () + { + int current = CurrentDirectory.SelectedIndex; + if (-1 == current) + return null; + + return CurrentDirectory.ItemContainerGenerator.ContainerFromIndex (current) as ListViewItem; + } + + GridViewColumnHeader m_lvSortByColumn = null; + ListSortDirection m_lvSortDirection = ListSortDirection.Ascending; + + public bool IsSortByName { + get { return m_lvSortByColumn != null && "Name".Equals (m_lvSortByColumn.Tag); } + } + public bool IsSortByType { + get { return m_lvSortByColumn != null && "Type".Equals (m_lvSortByColumn.Tag); } + } + public bool IsSortBySize { + get { return m_lvSortByColumn != null && "Size".Equals (m_lvSortByColumn.Tag); } + } + public bool IsUnsorted { get { return m_lvSortByColumn == null; } } + + void lv_SetSortMode (string sortBy, ListSortDirection direction) + { + m_lvSortByColumn = null; + GridView view = CurrentDirectory.View as GridView; + foreach (var column in view.Columns) + { + var header = column.Header as GridViewColumnHeader; + if (null != header && !string.IsNullOrEmpty (sortBy) && sortBy.Equals (header.Tag)) + { + if (ListSortDirection.Ascending == direction) + column.HeaderTemplate = Resources["SortArrowUp"] as DataTemplate; + else + column.HeaderTemplate = Resources["SortArrowDown"] as DataTemplate; + m_lvSortByColumn = header; + m_lvSortDirection = direction; + } + else + { + column.HeaderTemplate = Resources["SortArrowNone"] as DataTemplate; + } + } + } + + private void lv_Sort (string sortBy, ListSortDirection direction) + { + var dataView = CollectionViewSource.GetDefaultView (CurrentDirectory.ItemsSource) as ListCollectionView; + dataView.CustomSort = new FileSystemComparer (sortBy, direction); + /* + using (dataView.DeferRefresh()) + { + dataView.SortDescriptions.Clear(); + dataView.SortDescriptions.Add (new SortDescription ("Priority", ListSortDirection.Ascending)); + if (!string.IsNullOrEmpty (sortBy)) + { + dataView.SortDescriptions.Add (new SortDescription (sortBy, direction)); + if (sortBy != "Name") + dataView.SortDescriptions.Add (new SortDescription ("Name", ListSortDirection.Ascending)); + } + } + */ + } + + /// + /// Sort Listview by columns + /// + void lv_ColumnHeaderClicked (object sender, RoutedEventArgs e) + { + var headerClicked = e.OriginalSource as GridViewColumnHeader; + + if (null == headerClicked) + return; + if (headerClicked.Role == GridViewColumnHeaderRole.Padding) + return; + + ListSortDirection direction; + if (headerClicked != m_lvSortByColumn) + direction = ListSortDirection.Ascending; + else if (m_lvSortDirection == ListSortDirection.Ascending) + direction = ListSortDirection.Descending; + else + direction = ListSortDirection.Ascending; + + string sortBy = headerClicked.Tag.ToString(); + lv_Sort (sortBy, direction); + + // Remove arrow from previously sorted header + if (m_lvSortByColumn != null && m_lvSortByColumn != headerClicked) + { + m_lvSortByColumn.Column.HeaderTemplate = Resources["SortArrowNone"] as DataTemplate; + } + + if (ListSortDirection.Ascending == direction) + { + headerClicked.Column.HeaderTemplate = Resources["SortArrowUp"] as DataTemplate; + } + else + { + headerClicked.Column.HeaderTemplate = Resources["SortArrowDown"] as DataTemplate; + } + m_lvSortByColumn = headerClicked; + m_lvSortDirection = direction; + } + + /// + /// Handle "Sort By" commands. + /// + + private void SortByExec (object sender, ExecutedRoutedEventArgs e) + { + string sort_by = e.Parameter as string; + lv_Sort (sort_by, ListSortDirection.Ascending); + lv_SetSortMode (sort_by, ListSortDirection.Ascending); + } + + /// + /// Event handler for keys pressed in the right pane + /// + + private void lv_TextInput (object sender, TextCompositionEventArgs e) + { + LookupItem (e.Text); + e.Handled = true; + } + + /// + /// Lookup item in listview pane by first letter. + /// + + private void LookupItem (string key) + { + if (string.IsNullOrEmpty (key)) + return; + var source = CurrentDirectory.ItemsSource as CollectionView; + if (source == null) + return; + + var current = CurrentDirectory.SelectedItem as EntryViewModel; + int index = 0; + if (current != null && current.Name.StartsWith (key, StringIgnoreCase)) + index = CurrentDirectory.SelectedIndex+1; + + for (int i = index, count = source.Count; i < count; ++i) + { + var entry = source.GetItemAt (i) as EntryViewModel; + if (entry != null && entry.Name.StartsWith (key, StringIgnoreCase)) + { + lv_SelectItem (entry); + break; + } + } + } + + private void acb_OnKeyDown (object sender, KeyEventArgs e) + { + if (e.Key != Key.Return) + return; + string path = (sender as AutoCompleteBox).Text; + if (string.IsNullOrEmpty (path)) + return; + try + { + ViewModel = GetNewViewModel (path); + lv_Focus(); + } + catch (Exception X) + { + PopupError (X.Message, guiStrings.MsgErrorOpening); + } + } + + #region Navigation history implementation + + private string CurrentPath { get { return ViewModel.Path; } } + + HistoryStack m_history = new HistoryStack(); + + DirectoryPosition GetCurrentPosition () + { + var evm = CurrentDirectory.SelectedItem as EntryViewModel; + return new DirectoryPosition (ViewModel, evm); + } + + bool SetCurrentPosition (DirectoryPosition pos) + { + var vm = TryCreateViewModel (pos.Path); + if (null == vm) + return false; + try + { + vm.SetPosition (pos); + ViewModel = vm; + if (null != pos.Item) + lv_SelectItem (pos.Item.Name); + return true; + } + catch (Exception X) + { + SetStatusText (X.Message); + return false; + } + } + + private void SaveCurrentPosition () + { + m_history.Push (GetCurrentPosition()); + } + + private void GoBackExec (object sender, ExecutedRoutedEventArgs e) + { + DirectoryPosition current = m_history.Undo (GetCurrentPosition()); + if (current != null) + SetCurrentPosition (current); + } + + private void GoForwardExec (object sender, ExecutedRoutedEventArgs e) + { + DirectoryPosition current = m_history.Redo (GetCurrentPosition()); + if (current != null) + SetCurrentPosition (current); + } + + private void CanExecuteGoBack (object sender, CanExecuteRoutedEventArgs e) + { + e.CanExecute = m_history.CanUndo(); + } + + private void CanExecuteGoForward (object sender, CanExecuteRoutedEventArgs e) + { + e.CanExecute = m_history.CanRedo(); + } + #endregion + + /// + /// Open file/directory. + /// + private void OpenItemExec (object control, ExecutedRoutedEventArgs e) + { + EntryViewModel entry = CurrentDirectory.SelectedItem as EntryViewModel; + if (null == entry) + { + var lvi = e.OriginalSource as ListViewItem; + if (lvi != null) + entry = lvi.Content as EntryViewModel; + } + if (null == entry) + return; + + var vm = ViewModel; + if (null == vm) + return; + if (vm.IsArchive) // tried to open file inside archive + { + var arc_vm = vm as ArchiveViewModel; + if (!("" == arc_vm.SubDir && ".." == entry.Name)) + { + OpenArchiveEntry (arc_vm, entry); + return; + } + } + OpenDirectoryEntry (vm, entry); + } + + private void OpenDirectoryEntry (DirectoryViewModel vm, EntryViewModel entry) + { + string old_dir = vm.Path; + string new_dir = Path.Combine (old_dir, entry.Name); + Trace.WriteLine (new_dir, "OpenDirectoryEntry"); + vm = TryCreateViewModel (new_dir); + if (null == vm) + { + if (entry.Type != "archive") + SystemOpen (new_dir); + return; + } + SaveCurrentPosition(); + ViewModel = vm; + if (vm.IsArchive && null != m_app.CurrentArchive) + SetStatusText (m_app.CurrentArchive.Description); + else + SetStatusText (""); + var old_parent = Directory.GetParent (old_dir); + if (null != old_parent && vm.Path == old_parent.FullName) + { + lv_SelectItem (Path.GetFileName (old_dir)); + } + else + { + lv_SelectItem (0); + } + } + + private void OpenArchiveEntry (ArchiveViewModel vm, EntryViewModel entry) + { + if (entry.IsDirectory) + { + SaveCurrentPosition(); + var old_dir = vm.SubDir; + try + { + vm.ChDir (entry.Name); + if (".." == entry.Name) + lv_SelectItem (Path.GetFileName (old_dir)); + else + lv_SelectItem (0); + SetStatusText (""); + } + catch (Exception X) + { + SetStatusText (X.Message); + } + } + } + + /// + /// Launch specified file. + /// + private void SystemOpen (string file) + { + try + { + Process.Start (file); + } + catch (Exception X) + { + SetStatusText (X.Message); + } + } + + /// + /// Refresh current view. + /// + private void RefreshExec (object sender, ExecutedRoutedEventArgs e) + { + RefreshView(); + } + + private void RefreshView () + { + m_app.ResetCache(); + var pos = GetCurrentPosition(); + SetCurrentPosition (pos); + } + + /// + /// Open current file in Explorer. + /// + + private void ExploreItemExec (object sender, ExecutedRoutedEventArgs e) + { + var entry = CurrentDirectory.SelectedItem as EntryViewModel; + if (entry != null && !ViewModel.IsArchive) + { + try + { + string name = Path.Combine (CurrentPath, entry.Name); + Process.Start ("explorer.exe", "/select,"+name); + } + catch (Exception X) + { + // ignore + Trace.WriteLine (X.Message, "explorer.exe"); + } + } + } + + /// + /// Delete item from both media library and disk drive. + /// + private void DeleteItemExec (object sender, ExecutedRoutedEventArgs e) + { + var entry = CurrentDirectory.SelectedItem as EntryViewModel; + if (entry == null) + return; + + this.IsEnabled = false; + try + { + m_app.ResetCache(); + string item_name = Path.Combine (CurrentPath, entry.Name); + Trace.WriteLine (item_name, "DeleteItemExec"); + FileSystem.DeleteFile (item_name, UIOption.AllDialogs, RecycleOption.SendToRecycleBin); + DeleteItem (lv_GetCurrentContainer()); + SetStatusText (string.Format(guiStrings.MsgDeletedItem, item_name)); + } + catch (OperationCanceledException) + { + } + catch (Exception X) + { + SetStatusText (X.Message); + } + finally + { + this.IsEnabled = true; + } + } + + /// + /// Delete item at the specified position within ListView, correctly adjusting current + /// position. + /// + private void DeleteItem (ListViewItem item) + { + int i = CurrentDirectory.SelectedIndex; + int next = -1; + if (i+1 < CurrentDirectory.Items.Count) + next = i + 1; + else if (i > 0) + next = i - 1; + + if (next != -1) + CurrentDirectory.SelectedIndex = next; + + var entry = item.Content as EntryViewModel; + if (entry != null) + { + ViewModel.Remove (entry); + } + } + + /// + /// Rename selected item. + /// + private void RenameItemExec(object sender, ExecutedRoutedEventArgs e) + { + RenameElement (lv_GetCurrentContainer()); + } + + /// + /// Rename item contained within specified framework control. + /// + void RenameElement (ListViewItem item) + { + if (item == null) + return; +/* + TextBlock block = FindByName (item, "item_Text") as TextBlock; + TextBox box = FindSibling (block, "item_Input") as TextBox; + + if (block == null || box == null) + return; + + IsRenameActive = true; + + block.Visibility = Visibility.Collapsed; + box.Text = block.Text; + box.Visibility = Visibility.Visible; + box.Select (0, box.Text.Length); + box.Focus(); +*/ + } + + /// + /// Handle "Extract item" command. + /// + private void ExtractItemExec (object sender, ExecutedRoutedEventArgs e) + { + var entry = CurrentDirectory.SelectedItem as EntryViewModel; + if (null == entry) + return; + try + { + if (!ViewModel.IsArchive) + { + if (!entry.IsDirectory) + { + var arc_dir = CurrentPath; + var source = Path.Combine (arc_dir, entry.Name); + string destination = arc_dir; + // extract into directory named after archive + if (!string.IsNullOrEmpty (Path.GetExtension (entry.Name))) + destination = Path.GetFileNameWithoutExtension (source); + ExtractArchive (source, destination); + } + } + else if (null != m_app.CurrentArchive) + { + var vm = ViewModel as ArchiveViewModel; + string destination = Path.GetDirectoryName (vm.Path); + string arc_name = Path.GetFileName (vm.Path); + if (entry.Name == ".." && vm.SubDir == "") // root entry + { + ExtractArchive (m_app.CurrentArchive, arc_name, destination); + } + else + { + ExtractFileFromArchive (entry, destination); + } + } + } + catch (Exception X) + { + PopupError (X.Message, guiStrings.MsgErrorExtracting); + } + } + + private void ExtractArchive (string path, string destination) + { + string arc_name = Path.GetFileName (path); + FormatCatalog.Instance.LastError = null; + var arc = ArcFile.TryOpen (path); + if (null != arc) + { + ExtractArchive (arc, arc_name, destination); + } + else + { + string error_message; + if (FormatCatalog.Instance.LastError != null) + error_message = FormatCatalog.Instance.LastError.Message; + else + error_message = guiStrings.MsgUnknownFormat; + SetStatusText (string.Format ("{1}: {0}", error_message, arc_name)); + } + } + + private void ExtractArchive (ArcFile arc, string arc_name, string destination) + { + if (0 == arc.Dir.Count) + { + SetStatusText (string.Format ("{1}: {0}", guiStrings.MsgEmptyArchive, arc_name)); + return; + } + var extractDialog = new ExtractArchiveDialog (arc_name, destination); + extractDialog.Owner = this; + var result = extractDialog.ShowDialog(); + if (!result.Value) + return; + + destination = extractDialog.DestinationDir.Text; + if (!string.IsNullOrEmpty (destination)) + { + destination = Path.GetFullPath (destination); + Trace.WriteLine (destination, "Extract destination"); + StopWatchDirectoryChanges(); + try + { + Directory.CreateDirectory (destination); + Directory.SetCurrentDirectory (destination); + } + finally + { + m_watcher.EnableRaisingEvents = true; + } + } + IEnumerable file_list = arc.Dir; + bool skip_images = !extractDialog.ExtractImages.IsChecked.Value; + bool skip_script = !extractDialog.ExtractText.IsChecked.Value; + if (skip_images || skip_script) + file_list = file_list.Where (f => !(skip_images && f.Type == "image") && !(skip_script && f.Type == "script")); + + if (!file_list.Any()) + { + SetStatusText (string.Format ("{1}: {0}", guiStrings.MsgNoFiles, arc_name)); + return; + } + ImageFormat image_format = null; + if (!skip_images) + image_format = extractDialog.GetImageFormat (extractDialog.ImageConversionFormat); + + SetStatusText (string.Format(guiStrings.MsgExtractingTo, arc_name, destination)); + ExtractFilesFromArchive (string.Format (guiStrings.MsgExtractingArchive, arc_name), + arc, file_list, image_format); + } + + private void ExtractFileFromArchive (EntryViewModel entry, string destination) + { + var extractDialog = new ExtractFile (entry, destination); + extractDialog.Owner = this; + var result = extractDialog.ShowDialog(); + if (!result.Value) + return; + + var file_list = (ViewModel as ArchiveViewModel).GetFiles (entry); + + destination = extractDialog.DestinationDir.Text; + if (!string.IsNullOrEmpty (destination)) + { + destination = Path.GetFullPath (destination); + Directory.CreateDirectory (destination); + Directory.SetCurrentDirectory (destination); + } + ImageFormat format = null; + if (entry.Type == "image") + format = extractDialog.GetImageFormat (extractDialog.ImageConversionFormat); + + string arc_name = Path.GetFileName (CurrentPath); + ExtractFilesFromArchive (string.Format (guiStrings.MsgExtractingFile, arc_name), + m_app.CurrentArchive, file_list, format); + } + + private void ExtractFilesFromArchive (string text, ArcFile arc, IEnumerable file_list, + ImageFormat image_format = null) + { + file_list = file_list.OrderBy (e => e.Offset); + var extractProgressDialog = new ProgressDialog () + { + WindowTitle = guiStrings.TextTitle, + Text = text, + Description = "", + MinimizeBox = true, + }; + if (1 == file_list.Count()) + { + extractProgressDialog.Description = file_list.First().Name; + extractProgressDialog.ProgressBarStyle = ProgressBarStyle.MarqueeProgressBar; + } + extractProgressDialog.DoWork += (s, e) => + { + try + { + int total = file_list.Count(); + int i = 0; + foreach (var entry in file_list) + { + if (extractProgressDialog.CancellationPending) + break; + if (total > 1) + extractProgressDialog.ReportProgress (i*100/total, null, entry.Name); + if (null != image_format && entry.Type == "image") + ExtractImage (arc, entry, image_format); + else + arc.Extract (entry); + ++i; + } + SetStatusText (string.Format (guiStrings.MsgExtractCompletePlural, i, + Localization.Plural (i, "file"))); + } + catch (Exception X) + { + SetStatusText (X.Message); + } + }; + extractProgressDialog.RunWorkerCompleted += (s, e) => { + extractProgressDialog.Dispose(); + if (!ViewModel.IsArchive) + { + arc.Dispose(); + Dispatcher.Invoke (RefreshView); + } + }; + extractProgressDialog.ShowDialog (this); + } + + /// + /// Handle "Exit" command. + /// + void ExitExec (object sender, ExecutedRoutedEventArgs e) + { + Application.Current.Shutdown(); + } + + private void MenuAbout_Click (object sender, RoutedEventArgs e) + { + var about = new AboutBox(); + about.Owner = this; + about.ShowDialog(); + } + + private void CanExecuteAlways (object sender, CanExecuteRoutedEventArgs e) + { + e.CanExecute = true; + } + + private void CanExecuteControlCommand (object sender, CanExecuteRoutedEventArgs e) + { + Control target = e.Source as Control; + e.CanExecute = target != null; + } + + private void CanExecuteOnSelected (object sender, CanExecuteRoutedEventArgs e) + { + e.CanExecute = CurrentDirectory.SelectedIndex != -1; + } + + private void CanExecuteInArchive (object sender, CanExecuteRoutedEventArgs e) + { + e.CanExecute = ViewModel.IsArchive && CurrentDirectory.SelectedIndex != -1; + } + + private void CanExecuteInDirectory (object sender, CanExecuteRoutedEventArgs e) + { + e.CanExecute = !ViewModel.IsArchive; + } + + private void CanExecuteDelete (object sender, CanExecuteRoutedEventArgs e) + { + if (!ViewModel.IsArchive && CurrentDirectory.SelectedIndex != -1) + { + var entry = CurrentDirectory.SelectedItem as EntryViewModel; + if (entry != null && !entry.IsDirectory) + { + e.CanExecute = true; + return; + } + } + e.CanExecute = false; + } + + private void OnParametersRequest (object sender, ParametersRequestEventArgs e) + { + var control = e.InputWidget as UIElement; + if (null != control) + { + var param_dialog = new ArcParametersDialog (control, e.Notice); + param_dialog.Owner = this; + e.InputResult = param_dialog.ShowDialog() ?? false; + } + } + } + + /// + /// TextBox that uses filesystem as source for autocomplete. + /// + public class ExtAutoCompleteBox : AutoCompleteBox + { + public delegate void EnterKeyDownEvent (object sender, KeyEventArgs e); + public event EnterKeyDownEvent EnterKeyDown; + /* + public event EnterKeyDownEvent EnterKeyDown + { + add { AddHandler (KeyEvent, value); } + remove { RemoveHandler (KeyEvent, value); } + } + public static readonly RoutedEvent EnterKeyEvent = EventManager.RegisterRoutedEvent( + "EnterKeyDown", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(ExtAutoCompleteBox)); + */ + + protected override void OnKeyDown (KeyEventArgs e) + { + base.OnKeyDown (e); + if (e.Key == Key.Enter) + RaiseEnterKeyDownEvent (e); + } + + private void RaiseEnterKeyDownEvent (KeyEventArgs e) + { + if (EnterKeyDown != null) + EnterKeyDown (this, e); + +// var event_args = new RoutedEventArgs (ExtCompleteBox.EnterKeyEvent); +// RaiseEvent (event_args); + } + + protected override void OnPopulating (PopulatingEventArgs e) + { + var candidates = new List(); + string dirname = Path.GetDirectoryName (this.Text); + if (!string.IsNullOrEmpty (this.Text) && Directory.Exists (dirname)) + { + foreach (var dir in Directory.GetDirectories (dirname)) + { + if (dir.StartsWith (dirname, StringComparison.CurrentCultureIgnoreCase)) + candidates.Add (dir); + } + } + this.ItemsSource = candidates; + base.OnPopulating (e); + } + } + + public static class Commands + { + public static readonly RoutedCommand OpenItem = new RoutedCommand(); + public static readonly RoutedCommand ExtractItem = new RoutedCommand(); + public static readonly RoutedCommand SortBy = new RoutedCommand(); + public static readonly RoutedCommand Exit = new RoutedCommand(); + public static readonly RoutedCommand GoBack = new RoutedCommand(); + public static readonly RoutedCommand GoForward = new RoutedCommand(); + public static readonly RoutedCommand DeleteItem = new RoutedCommand(); + public static readonly RoutedCommand RenameItem = new RoutedCommand(); + public static readonly RoutedCommand ExploreItem = new RoutedCommand(); + public static readonly RoutedCommand Refresh = new RoutedCommand(); + public static readonly RoutedCommand Browse = new RoutedCommand(); + } +} diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..15ee9a22 --- /dev/null +++ b/Makefile @@ -0,0 +1,20 @@ +MSCS = D:/WINDOWS/Microsoft.NET/Framework/v4.0.30319/csc //nologo + +.SUFFIXES: .cs .exe + +all: GARbro + +adler32: adler32.cs + $(MSCS) $(MSCSFLAGS) //out:$@.exe $^ + +inflate: inflate.cs + $(MSCS) $(MSCSFLAGS) //out:$@.exe $^ //r:zlib\\zlibnet.dll + +deflate: deflate.cs + $(MSCS) $(MSCSFLAGS) //out:$@.exe $^ //r:zlib\\zlibnet.dll + +GARbro: Program.cs GameRes.cs ArcXFL.cs + $(MSCS) $(MSCSFLAGS) //out:$@.exe $^ //r:System.ComponentModel.Composition.dll //r:System.ComponentModel.DataAnnotations.dll + +tags: + ctags *.cs diff --git a/ModalWindow.cs b/ModalWindow.cs new file mode 100644 index 00000000..6b1aa5cc --- /dev/null +++ b/ModalWindow.cs @@ -0,0 +1,88 @@ +//! \file ModalWindow.cs +//! \date Tue Aug 02 10:20:50 2011 +//! \brief Window without an icon. +// +// Copyright (C) 2011 by poddav +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +// + +using System; +using System.Windows; +using System.Windows.Interop; +using System.Runtime.InteropServices; + +namespace Rnd.Windows +{ + /// + /// Window without an icon. + /// + public class ModalWindow : Window + { + protected override void OnSourceInitialized(EventArgs e) + { + base.OnSourceInitialized(e); + + HideIcon (this); + } + + internal class NativeMethods + { + [DllImport ("user32.dll")] + internal static extern int GetWindowLong (IntPtr hwnd, int index); + + [DllImport ("user32.dll")] + internal static extern int SetWindowLong (IntPtr hwnd, int index, int newStyle); + + [DllImport ("user32.dll")] + internal static extern bool SetWindowPos (IntPtr hwnd, IntPtr hwndInsertAfter, int x, int y, int width, int height, uint flags); + + [DllImport ("user32.dll")] + internal static extern IntPtr SendMessage (IntPtr hwnd, uint msg, IntPtr wParam, IntPtr lParam); + } + + const int GWL_EXSTYLE = -20; + const int WS_EX_DLGMODALFRAME = 0x0001; + + const int SWP_NOSIZE = 0x0001; + const int SWP_NOMOVE = 0x0002; + const int SWP_NOZORDER = 0x0004; + const int SWP_FRAMECHANGED = 0x0020; + const uint WM_SETICON = 0x0080; + + /// + /// Win32 mumbo-jumbo to hide window icon and its menu. + /// + + public static void HideIcon (Window window) + { + // Get this window's handle + IntPtr hwnd = new WindowInteropHelper (window).Handle; + + // Change the extended window style to not show a window icon + int extendedStyle = NativeMethods.GetWindowLong (hwnd, GWL_EXSTYLE); + NativeMethods.SetWindowLong (hwnd, GWL_EXSTYLE, extendedStyle | WS_EX_DLGMODALFRAME); + NativeMethods.SendMessage (hwnd, WM_SETICON, IntPtr.Zero, IntPtr.Zero); + NativeMethods.SendMessage (hwnd, WM_SETICON, new IntPtr (1), IntPtr.Zero); + + // Update the window's non-client area to reflect the changes + NativeMethods.SetWindowPos (hwnd, IntPtr.Zero, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED); + } + } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..18975dae --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,55 @@ +using System.Reflection; +using System.Resources; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Windows; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Game Resource browser")] +[assembly: AssemblyDescription("Game Resource browser")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("GARbro.GUI")] +[assembly: AssemblyCopyright("Copyright © 2014 mørkt")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +//In order to begin building localizable applications, set +//CultureYouAreCodingWith in your .csproj file +//inside a . For example, if you are using US english +//in your source files, set the to en-US. Then uncomment +//the NeutralResourceLanguage attribute below. Update the "en-US" in +//the line below to match the UICulture setting in the project file. + +//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)] + + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] + + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 00000000..836235e8 --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18444 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace GARbro.GUI.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("GARbro.GUI.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/Properties/Resources.resx b/Properties/Resources.resx new file mode 100644 index 00000000..ffecec85 --- /dev/null +++ b/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Properties/Settings.Designer.cs b/Properties/Settings.Designer.cs new file mode 100644 index 00000000..6b052f5d --- /dev/null +++ b/Properties/Settings.Designer.cs @@ -0,0 +1,230 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18444 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace GARbro.GUI.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "12.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool UpgradeRequired { + get { + return ((bool)(this["UpgradeRequired"])); + } + set { + this["UpgradeRequired"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("NaN")] + public double winTop { + get { + return ((double)(this["winTop"])); + } + set { + this["winTop"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("NaN")] + public double winLeft { + get { + return ((double)(this["winLeft"])); + } + set { + this["winLeft"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("1024")] + public double winWidth { + get { + return ((double)(this["winWidth"])); + } + set { + this["winWidth"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("560")] + public double winHeight { + get { + return ((double)(this["winHeight"])); + } + set { + this["winHeight"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Normal")] + public global::System.Windows.WindowState winState { + get { + return ((global::System.Windows.WindowState)(this["winState"])); + } + set { + this["winState"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("265")] + public double lvNameColumnWidth { + get { + return ((double)(this["lvNameColumnWidth"])); + } + set { + this["lvNameColumnWidth"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("75")] + public double lvTypeColumnWidth { + get { + return ((double)(this["lvTypeColumnWidth"])); + } + set { + this["lvTypeColumnWidth"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("75")] + public double lvSizeColumnWidth { + get { + return ((double)(this["lvSizeColumnWidth"])); + } + set { + this["lvSizeColumnWidth"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Name")] + public string lvSortColumn { + get { + return ((string)(this["lvSortColumn"])); + } + set { + this["lvSortColumn"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("Ascending")] + public global::System.ComponentModel.ListSortDirection lvSortDirection { + get { + return ((global::System.ComponentModel.ListSortDirection)(this["lvSortDirection"])); + } + set { + this["lvSortDirection"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("448")] + public global::System.Windows.GridLength lvPanelWidth { + get { + return ((global::System.Windows.GridLength)(this["lvPanelWidth"])); + } + set { + this["lvPanelWidth"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool appExtractImages { + get { + return ((bool)(this["appExtractImages"])); + } + set { + this["appExtractImages"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool appExtractText { + get { + return ((bool)(this["appExtractText"])); + } + set { + this["appExtractText"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + public string appImageFormat { + get { + return ((string)(this["appImageFormat"])); + } + set { + this["appImageFormat"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("UTF-8")] + public string appTextEncoding { + get { + return ((string)(this["appTextEncoding"])); + } + set { + this["appTextEncoding"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + public string appLastDirectory { + get { + return ((string)(this["appLastDirectory"])); + } + set { + this["appLastDirectory"] = value; + } + } + } +} diff --git a/Properties/Settings.settings b/Properties/Settings.settings new file mode 100644 index 00000000..e3fcc508 --- /dev/null +++ b/Properties/Settings.settings @@ -0,0 +1,57 @@ + + + + + + True + + + NaN + + + NaN + + + 1024 + + + 560 + + + Normal + + + 265 + + + 75 + + + 75 + + + Name + + + Ascending + + + 448 + + + True + + + True + + + + + + UTF-8 + + + + + + \ No newline at end of file diff --git a/Properties/app.manifest b/Properties/app.manifest new file mode 100644 index 00000000..14d77941 --- /dev/null +++ b/Properties/app.manifest @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Settings.cs b/Settings.cs new file mode 100644 index 00000000..e755fd00 --- /dev/null +++ b/Settings.cs @@ -0,0 +1,43 @@ +namespace GARbro.GUI.Properties { + + + // This class allows you to handle specific events on the settings class: + // The SettingChanging event is raised before a setting's value is changed. + // The PropertyChanged event is raised after a setting's value is changed. + // The SettingsLoaded event is raised after the setting values are loaded. + // The SettingsSaving event is raised before the setting values are saved. + internal sealed partial class Settings { + + public Settings() { + // // To add event handlers for saving and changing settings, uncomment the lines below: + // + // this.SettingChanging += this.SettingChangingEventHandler; + // + // this.SettingsSaving += this.SettingsSavingEventHandler; + // + this.SettingsLoaded += OnSettingsLoadedHandler; + } + + void OnSettingsLoadedHandler (object sender, System.Configuration.SettingsLoadedEventArgs e) + { + if (Settings.Default.UpgradeRequired) + { + Settings.Default.Upgrade(); + Settings.Default.UpgradeRequired = false; + Settings.Default.Save(); + + // do not restore in minimized state + if (Settings.Default.winState == System.Windows.WindowState.Minimized) + Settings.Default.winState = System.Windows.WindowState.Normal; + } + } + + private void SettingChangingEventHandler(object sender, System.Configuration.SettingChangingEventArgs e) { + // Add code to handle the SettingChangingEvent event here. + } + + private void SettingsSavingEventHandler(object sender, System.ComponentModel.CancelEventArgs e) { + // Add code to handle the SettingsSaving event here. + } + } +} diff --git a/Shell.cs b/Shell.cs new file mode 100644 index 00000000..e50c6dc2 --- /dev/null +++ b/Shell.cs @@ -0,0 +1,182 @@ +//! \file Shell.cs +//! \date Tue Aug 02 13:48:55 2011 +//! \brief Win32 shell functions. +// +// Copyright (C) 2011 by poddav +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +// + +using System; +using System.Text; +using System.Runtime.InteropServices; + +namespace Rnd.Shell +{ + /// + /// Wrapper around PathCreateFromUrl WINAPI call. + /// + class PathConverter + { + [DllImport("shlwapi.dll", EntryPoint="PathCreateFromUrlW", CharSet=CharSet.Unicode, SetLastError=true)] + private static extern Int32 PathCreateFromUrl( + string url, StringBuilder path, + ref Int32 size, UInt32 flags); + + private StringBuilder buf; + private Int32 size; + + public PathConverter (int capacity = 260) + { + buf = new StringBuilder (capacity); + } + public string UrlToPath (string url) + { + size = buf.Capacity; + Int32 rc = PathCreateFromUrl (url, buf, ref size, 0); + return rc == 0 ? buf.ToString (0, size) : ""; + } + } + + /// + /// Wrapper around SHGetFileInfo WINAPI call. + /// + class FileInfo + { + [DllImport("shell32.dll", CharSet=CharSet.Auto)] + public static extern IntPtr SHGetFileInfo( + string pszPath, Int32 dwFileAttributes, + ref SHFILEINFO psfi, int cbFileInfo, int uFlags); + + [DllImport("User32.dll")] + public static extern int DestroyIcon(IntPtr hIcon); + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)] + public struct SHFILEINFO + { + public IntPtr hIcon; + public int iIcon; + public uint dwAttributes; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] + public string szDisplayName; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)] + public string szTypeName; + + public SHFILEINFO(bool b) + { + hIcon = IntPtr.Zero; + iIcon = 0; + dwAttributes = 0; + szDisplayName = ""; + szTypeName = ""; + } + }; + + [Flags] + public enum SHGFI : uint + { + /// get icon + Icon = 0x000000100, + /// get display name + DisplayName = 0x000000200, + /// get type name + TypeName = 0x000000400, + /// get attributes + Attributes = 0x000000800, + /// get icon location + IconLocation = 0x000001000, + /// return exe type + ExeType = 0x000002000, + /// get system icon index + SysIconIndex = 0x000004000, + /// put a link overlay on icon + LinkOverlay = 0x000008000, + /// show icon in selected state + Selected = 0x000010000, + /// get only specified attributes + Attr_Specified = 0x000020000, + /// get large icon + LargeIcon = 0x000000000, + /// get small icon + SmallIcon = 0x000000001, + /// get open icon + OpenIcon = 0x000000002, + /// get shell size icon + ShellIconSize = 0x000000004, + /// pszPath is a pidl + PIDL = 0x000000008, + /// use passed dwFileAttribute + UseFileAttributes= 0x000000010, + /// apply the appropriate overlays + AddOverlays = 0x000000020, + /// Get the index of the overlay in the upper 8 bits of the iIcon + OverlayIndex = 0x000000040, + } + + public static string GetTypeName (string filename) + { + SHFILEINFO info = new SHFILEINFO(true); + int szInfo = Marshal.SizeOf (info); + int result = (int)SHGetFileInfo (filename, 0, ref info, szInfo, (int)SHGFI.TypeName); + + // If uFlags does not contain SHGFI_EXETYPE or SHGFI_SYSICONINDEX, + // the return value is nonzero if successful, or zero otherwise. + if (result != 0) + return info.szTypeName; + else + return string.Empty; + } + + public static SHFILEINFO? GetInfo (string filename, SHGFI flags) + { + SHFILEINFO info = new SHFILEINFO(true); + int szInfo = Marshal.SizeOf (info); + int result = (int)SHGetFileInfo (filename, 0, ref info, szInfo, (int)flags); + + return result != 0? new Nullable (info): null; + } + } + + /// + /// Wrapper around MoveFileEx WINAPI call. + /// + class File + { + [DllImport("kernel32.dll", EntryPoint="MoveFileExW", SetLastError=true, CharSet=CharSet.Unicode)] + public static extern bool MoveFileEx (string lpExistingFileName, string lpNewFileName, MoveFileFlags dwFlags); + + [Flags] + public enum MoveFileFlags : uint + { + ReplaceExisting = 0x00000001, + CopyAllowed = 0x00000002, + DelayUntilReboot = 0x00000004, + WriteThrough = 0x00000008, + CreateHardlink = 0x00000010, + FailIfNotTrackable = 0x00000020 + } + + public static bool Rename (string szFrom, string szTo) + { + return MoveFileEx (szFrom, szTo, MoveFileFlags.ReplaceExisting); + } + } +} diff --git a/Strings/guiStrings.Designer.cs b/Strings/guiStrings.Designer.cs new file mode 100644 index 00000000..8b79e6b7 --- /dev/null +++ b/Strings/guiStrings.Designer.cs @@ -0,0 +1,594 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18444 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace GARbro.GUI.Strings { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + public class guiStrings { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal guiStrings() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + public static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("GARbro.GUI.Strings.guiStrings", typeof(guiStrings).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + public static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to Cancel. + /// + public static string ButtonCancel { + get { + return ResourceManager.GetString("ButtonCancel", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extract. + /// + public static string ButtonExtract { + get { + return ResourceManager.GetString("ButtonExtract", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to OK. + /// + public static string ButtonOK { + get { + return ResourceManager.GetString("ButtonOK", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to _Close. + /// + public static string CtxMenuClose { + get { + return ResourceManager.GetString("CtxMenuClose", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Copy. + /// + public static string CtxMenuCopy { + get { + return ResourceManager.GetString("CtxMenuCopy", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Cut. + /// + public static string CtxMenuCut { + get { + return ResourceManager.GetString("CtxMenuCut", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to _Delete. + /// + public static string CtxMenuDelete { + get { + return ResourceManager.GetString("CtxMenuDelete", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Browse in _Explorer. + /// + public static string CtxMenuExplorer { + get { + return ResourceManager.GetString("CtxMenuExplorer", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extract. + /// + public static string CtxMenuExtract { + get { + return ResourceManager.GetString("CtxMenuExtract", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Open. + /// + public static string CtxMenuOpen { + get { + return ResourceManager.GetString("CtxMenuOpen", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Paste. + /// + public static string CtxMenuPaste { + get { + return ResourceManager.GetString("CtxMenuPaste", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Refresh. + /// + public static string CtxMenuRefresh { + get { + return ResourceManager.GetString("CtxMenuRefresh", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to _Rename. + /// + public static string CtxMenuRename { + get { + return ResourceManager.GetString("CtxMenuRename", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sort by. + /// + public static string CtxMenuSortBy { + get { + return ResourceManager.GetString("CtxMenuSortBy", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Name. + /// + public static string CtxMenuSortByName { + get { + return ResourceManager.GetString("CtxMenuSortByName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Size. + /// + public static string CtxMenuSortBySize { + get { + return ResourceManager.GetString("CtxMenuSortBySize", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Type. + /// + public static string CtxMenuSortByType { + get { + return ResourceManager.GetString("CtxMenuSortByType", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Unsorted. + /// + public static string CtxMenuUnsorted { + get { + return ResourceManager.GetString("CtxMenuUnsorted", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Name. + /// + public static string HeaderName { + get { + return ResourceManager.GetString("HeaderName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Size. + /// + public static string HeaderSize { + get { + return ResourceManager.GetString("HeaderSize", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Type. + /// + public static string HeaderType { + get { + return ResourceManager.GetString("HeaderType", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to file. + /// + public static string LPfile1 { + get { + return ResourceManager.GetString("LPfile1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to files. + /// + public static string LPfile2 { + get { + return ResourceManager.GetString("LPfile2", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to About. + /// + public static string MenuAbout { + get { + return ResourceManager.GetString("MenuAbout", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Deleted {0}. + /// + public static string MsgDeletedItem { + get { + return ResourceManager.GetString("MsgDeletedItem", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to directory not found. + /// + public static string MsgDirectoryNotFound { + get { + return ResourceManager.GetString("MsgDirectoryNotFound", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to archive is empty. + /// + public static string MsgEmptyArchive { + get { + return ResourceManager.GetString("MsgEmptyArchive", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Error extracting file. + /// + public static string MsgErrorExtracting { + get { + return ResourceManager.GetString("MsgErrorExtracting", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Error opening file. + /// + public static string MsgErrorOpening { + get { + return ResourceManager.GetString("MsgErrorOpening", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extracted {0} into {1}. + /// + public static string MsgExtractComplete { + get { + return ResourceManager.GetString("MsgExtractComplete", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extracted {0} {1}. + /// + public static string MsgExtractCompletePlural { + get { + return ResourceManager.GetString("MsgExtractCompletePlural", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extracting files from {0}. + /// + public static string MsgExtractingArchive { + get { + return ResourceManager.GetString("MsgExtractingArchive", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extracting file from {0}. + /// + public static string MsgExtractingFile { + get { + return ResourceManager.GetString("MsgExtractingFile", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extracting files from {0} to {1}. + /// + public static string MsgExtractingTo { + get { + return ResourceManager.GetString("MsgExtractingTo", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Image {0} x {1} pixels. + /// + public static string MsgImageSize { + get { + return ResourceManager.GetString("MsgImageSize", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to no files to extract. + /// + public static string MsgNoFiles { + get { + return ResourceManager.GetString("MsgNoFiles", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ready. + /// + public static string MsgReady { + get { + return ResourceManager.GetString("MsgReady", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to unable to interpret image format. + /// + public static string MsgUnableInterpret { + get { + return ResourceManager.GetString("MsgUnableInterpret", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to file could not be opened as resource archive. + /// + public static string MsgUnknownFormat { + get { + return ResourceManager.GetString("MsgUnknownFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Version {0}. + /// + public static string MsgVersion { + get { + return ResourceManager.GetString("MsgVersion", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to [builtin]. + /// + public static string TextAboutBuiltin { + get { + return ResourceManager.GetString("TextAboutBuiltin", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Supported archives:. + /// + public static string TextAboutSupportedArchives { + get { + return ResourceManager.GetString("TextAboutSupportedArchives", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Supported image formats:. + /// + public static string TextAboutSupportedImages { + get { + return ResourceManager.GetString("TextAboutSupportedImages", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to About Game Resource browser. + /// + public static string TextAboutTitle { + get { + return ResourceManager.GetString("TextAboutTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to as is. + /// + public static string TextAsIs { + get { + return ResourceManager.GetString("TextAsIs", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Choose destination directory. + /// + public static string TextChooseDestDir { + get { + return ResourceManager.GetString("TextChooseDestDir", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to <DIR>. + /// + public static string TextDirType { + get { + return ResourceManager.GetString("TextDirType", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Text encoding. + /// + public static string TextEncoding { + get { + return ResourceManager.GetString("TextEncoding", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extract all files from {0} to. + /// + public static string TextExtractAllTo { + get { + return ResourceManager.GetString("TextExtractAllTo", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extract {0} to. + /// + public static string TextExtractFileTo { + get { + return ResourceManager.GetString("TextExtractFileTo", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extract images. + /// + public static string TextExtractImages { + get { + return ResourceManager.GetString("TextExtractImages", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extract text. + /// + public static string TextExtractText { + get { + return ResourceManager.GetString("TextExtractText", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Extract from archive. + /// + public static string TextExtractTitle { + get { + return ResourceManager.GetString("TextExtractTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Archive parameters. + /// + public static string TextParametersTitle { + get { + return ResourceManager.GetString("TextParametersTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Save as. + /// + public static string TextSaveAs { + get { + return ResourceManager.GetString("TextSaveAs", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Save images as. + /// + public static string TextSaveImagesAs { + get { + return ResourceManager.GetString("TextSaveImagesAs", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Game Resource browser. + /// + public static string TextTitle { + get { + return ResourceManager.GetString("TextTitle", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Back. + /// + public static string TooltipBack { + get { + return ResourceManager.GetString("TooltipBack", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Forward. + /// + public static string TooltipForward { + get { + return ResourceManager.GetString("TooltipForward", resourceCulture); + } + } + } +} diff --git a/Strings/guiStrings.resx b/Strings/guiStrings.resx new file mode 100644 index 00000000..db4ca19e --- /dev/null +++ b/Strings/guiStrings.resx @@ -0,0 +1,297 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Cancel + + + Extract + + + OK + + + _Close + + + Copy + + + Cut + + + _Delete + + + Browse in _Explorer + + + Extract + + + Open + + + Paste + + + Refresh + + + _Rename + + + Sort by + + + Name + + + Size + + + Type + + + Unsorted + + + Name + + + Size + + + Type + + + file + + + files + + + About + + + Deleted {0} + + + directory not found + + + archive is empty + + + Error extracting file + + + Error opening file + + + Extracted {0} into {1} + + + Extracted {0} {1} + + + Extracting files from {0} + + + Extracting file from {0} + + + Extracting files from {0} to {1} + + + Image {0} x {1} pixels + + + no files to extract + + + Ready + + + unable to interpret image format + + + file could not be opened as resource archive + + + Version {0} + + + [builtin] + + + Supported archives: + + + Supported image formats: + + + About Game Resource browser + + + as is + + + Choose destination directory + + + <DIR> + + + Text encoding + + + Extract all files from {0} to + + + Extract {0} to + + + Extract images + + + Extract text + + + Extract from archive + + + Archive parameters + + + Save as + + + Save images as + + + Game Resource browser + + + Back + + + Forward + + \ No newline at end of file diff --git a/Strings/guiStrings.ru-RU.resx b/Strings/guiStrings.ru-RU.resx new file mode 100644 index 00000000..76f309c4 --- /dev/null +++ b/Strings/guiStrings.ru-RU.resx @@ -0,0 +1,300 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Отмена + + + Извлечь + + + _Закрыть + + + Копировать + + + Вырезать + + + Удалить + + + Просмотр в Explorer + + + Извлечь + + + Открыть + + + Вставить + + + Обновить + + + Переименовать + + + Сортировка + + + по имени + + + по размеру + + + по типу + + + не сортировать + + + Имя + + + Размер + + + Тип + + + файл + + + файла + + + файлов + + + О программе + + + Удалён файл {0} + + + каталог не найден + + + архив пуст + + + Ошибка извлечения файла + + + Ошибка открытия файла + + + {0} извлечён в {1} + + + Извлечено {0} {1} + + + Извлекаются файлы из {0} + + + Файл извлекается из {0} + + + Извлекаются файлы из {0} в {1} + + + Изображение {0} x {1} пикселей + + + отсутствуют файлы, удовлетворяющие выбранным критериям + + + Готов + + + не удалось интерпретировать формат изображения + + + файл не может быть открыт как архив ресурсов + + + Версия {0} + + + [встроен] + + + Поддерживаемые архивы: + + + Поддерживаемые форматы изображений: + + + Об обозревателе игровых ресурсов + + + исходном + + + Выберите место извлечения + + + <DIR> + + + Кодировка текста + + + Извлечь все файлы из {0} в + + + Извлечь {0} в + + + Извлекать изображения + + + Извлекать текст + + + Извлечь из архива + + + OK + + + Параметры архива + + + Сохранить в формате + + + Сохранить в формате + + + Обозреватель игровых ресурсов + + + Назад + + + Вперёд + + \ No newline at end of file diff --git a/Utility.cs b/Utility.cs new file mode 100644 index 00000000..a9272457 --- /dev/null +++ b/Utility.cs @@ -0,0 +1,117 @@ +//! \file Utility.cs +//! \date Sun Jul 06 07:40:34 2014 +//! \brief utility classes. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Globalization; +using System.Runtime.InteropServices; +using System.Windows.Input; +using GARbro.GUI.Strings; + +namespace GARbro.GUI +{ + internal class NativeMethods + { + [DllImport ("shlwapi.dll", CharSet = CharSet.Unicode)] + internal static extern int StrCmpLogicalW (string psz1, string psz2); + + [DllImport ("gdi32.dll")] + internal static extern int GetDeviceCaps (IntPtr hDc, int nIndex); + + [DllImport ("user32.dll")] + internal static extern IntPtr GetDC (IntPtr hWnd); + + [DllImport ("user32.dll")] + internal static extern int ReleaseDC (IntPtr hWnd, IntPtr hDc); + } + + public static class Desktop + { + public static int DpiX { get { return dpi_x; } } + public static int DpiY { get { return dpi_y; } } + + public const int LOGPIXELSX = 88; + public const int LOGPIXELSY = 90; + + private static int dpi_x = GetCaps (LOGPIXELSX); + private static int dpi_y = GetCaps (LOGPIXELSY); + + public static int GetCaps (int cap) + { + IntPtr hdc = NativeMethods.GetDC (IntPtr.Zero); + if (hdc == IntPtr.Zero) + return 96; + int dpi = NativeMethods.GetDeviceCaps (hdc, cap); + NativeMethods.ReleaseDC (IntPtr.Zero, hdc); + return dpi; + } + } + + public sealed class NumericStringComparer : IComparer + { + public int Compare (string a, string b) + { + return NativeMethods.StrCmpLogicalW (a, b); + } + } + + public class WaitCursor : IDisposable + { + private Cursor m_previousCursor; + + public WaitCursor() + { + m_previousCursor = Mouse.OverrideCursor; + Mouse.OverrideCursor = Cursors.Wait; + } + + #region IDisposable Members + bool disposed = false; + public void Dispose() + { + Dispose (true); + GC.SuppressFinalize (this); + } + + protected virtual void Dispose (bool disposing) + { + if (!disposed) + { + Mouse.OverrideCursor = m_previousCursor; + disposed = true; + } + } + #endregion + } + + public static class Localization + { + public static string Plural (int n, string en_singular) + { + string suffix; + if (CultureInfo.CurrentUICulture.Name == "ru-RU") + { + suffix = (n%10==1 && n%100!=11 ? "1" : n%10>=2 && n% 10<=4 && (n%100<10 || n%100>=20) ? "2" : "3"); + } + else // assume en-EN + { + suffix = 1 == n ? "1" : "2"; + } + try + { + var res = guiStrings.ResourceManager.GetString ("LP"+en_singular+suffix); + return res ?? en_singular; + } + catch + { + return en_singular; + } + } + + // Localization.Format ("{0:file:files} copied", count); +// public static string Format (string format, params object[] args); + } +} diff --git a/ViewModel.cs b/ViewModel.cs new file mode 100644 index 00000000..6ec735d3 --- /dev/null +++ b/ViewModel.cs @@ -0,0 +1,296 @@ +//! \file ViewModel.cs +//! \date Wed Jul 02 07:29:11 2014 +//! \brief GARbro directory list. +// + +using System; +using System.IO; +using System.Linq; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Text.RegularExpressions; +using System.Globalization; +using GameRes; +using GARbro.GUI.Strings; + +namespace GARbro.GUI +{ + public class SubDirEntry : GameRes.Entry + { + public override string Type { get { return guiStrings.TextDirType; } } + + public SubDirEntry (string name) + { + Name = name; + Size = 0; + } + } + + public class DirectoryViewModel : ObservableCollection + { + public string Path { get; private set; } + public ICollection Source { get; private set; } + public virtual bool IsArchive { get { return false; } } + + public DirectoryViewModel (string path, ICollection filelist) + { + Path = path; + Source = filelist; + ImportFromSource(); + } + + protected virtual void ImportFromSource () + { + if (!string.IsNullOrEmpty (Path) && null != Directory.GetParent (Path)) + { + Add (new EntryViewModel (new SubDirEntry (".."), -2)); + } + foreach (var entry in Source) + { + int prio = null == entry as SubDirEntry ? 0 : -1; + Add (new EntryViewModel (entry, prio)); + } + } + + public EntryViewModel Find (string name) + { + return this.FirstOrDefault (e => e.Name.Equals (name, System.StringComparison.OrdinalIgnoreCase)); + } + + public virtual void SetPosition (DirectoryPosition pos) + { + } + } + + public class ArchiveViewModel : DirectoryViewModel + { + public override bool IsArchive { get { return true; } } + public string SubDir { get; protected set; } + + public ArchiveViewModel (string path, ArcFile arc) + : base (path, arc.Dir) + { + } + + protected override void ImportFromSource () + { + UpdateModel (""); + } + + private string m_delimiter = "/"; + private static readonly char[] m_path_delimiters = { '/', '\\' }; + + public void ChDir (string subdir) + { + string new_path; + if (".." == subdir) + { + if (0 == SubDir.Length) + return; + var path = SubDir.Split (m_path_delimiters); + if (path.Length > 1) + new_path = string.Join (m_delimiter, path, 0, path.Length-1); + else + new_path = ""; + } + else + { + var entry = this.FirstOrDefault (e => e.Name.Equals (subdir, StringComparison.OrdinalIgnoreCase)); + if (null == entry) + throw new DirectoryNotFoundException (string.Format ("{1}: {0}", guiStrings.MsgDirectoryNotFound, subdir)); + if (SubDir.Length > 0) + new_path = SubDir + m_delimiter + entry.Name; + else + new_path = entry.Name; + } + UpdateModel (new_path); + } + + static readonly Regex path_re = new Regex (@"\G[/\\]?([^/\\]+)([/\\])"); + + private void UpdateModel (string root_path) + { + IEnumerable dir = Source; + if (!string.IsNullOrEmpty (root_path)) + dir = from entry in dir + where entry.Name.StartsWith (root_path+m_delimiter) + select entry; + if (!dir.Any()) + { + throw new DirectoryNotFoundException (string.Format ("{1}: {0}", guiStrings.MsgDirectoryNotFound, root_path)); + } + m_suppress_notification = true; + try + { + this.Clear(); + SubDir = root_path; + Add (new EntryViewModel (new SubDirEntry (".."), -2)); + var subdirs = new HashSet(); + foreach (var entry in dir) + { + var match = path_re.Match (entry.Name, root_path.Length); + if (match.Success) + { + string name = match.Groups[1].Value; + if (subdirs.Add (name)) + { + m_delimiter = match.Groups[2].Value; + Add (new EntryViewModel (new SubDirEntry (name), -1)); + } + } + else + { + Add (new EntryViewModel (entry, 0)); + } + } + } + finally + { + m_suppress_notification = false; + OnCollectionChanged (new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); + } + } + + public override void SetPosition (DirectoryPosition pos) + { + UpdateModel (pos.ArchivePath); + } + + public IEnumerable GetFiles (EntryViewModel entry) + { + if (!entry.IsDirectory) + return new Entry[] { entry.Source }; + + string path = GetPath (entry.Name); + return from file in Source + where file.Name.StartsWith (path) + select file; + } + + string GetPath (string dir) + { + if (SubDir.Length > 0) + return SubDir + m_delimiter + dir + m_delimiter; + else + return dir + m_delimiter; + } + + private bool m_suppress_notification = false; + + protected override void OnCollectionChanged (NotifyCollectionChangedEventArgs e) + { + if (!m_suppress_notification) + base.OnCollectionChanged(e); + } + } + + public class EntryViewModel + { + public EntryViewModel (Entry entry, int priority) + { + Source = entry; + Name = Path.GetFileName (entry.Name); + Priority = priority; + } + + public Entry Source { get; private set; } + + public string Name { get; private set; } + public string Type { get { return Source.Type; } } + public uint Size { get { return Source.Size; } } + public int Priority { get; private set; } + public bool IsDirectory { get { return Priority < 0; } } + } + + public sealed class FileSystemComparer : IComparer + { + private string m_property; + private int m_direction; + private static Comparer s_default_comparer = new Comparer (CultureInfo.CurrentUICulture); + + public FileSystemComparer (string property, ListSortDirection direction) + { + m_property = property; + m_direction = direction == ListSortDirection.Ascending ? 1 : -1; + } + + public int Compare (object a, object b) + { + var v_a = a as EntryViewModel; + var v_b = b as EntryViewModel; + if (null == v_a || null == v_b) + return s_default_comparer.Compare (a, b) * m_direction; + + if (v_a.Priority < v_b.Priority) + return -1; + if (v_a.Priority > v_b.Priority) + return 1; + if (string.IsNullOrEmpty (m_property)) + return 0; + int order; + if (m_property != "Name") + { + if ("Type" == m_property) + { + // empty strings placed in the end + if (string.IsNullOrEmpty (v_a.Type)) + order = string.IsNullOrEmpty (v_b.Type) ? 0 : m_direction; + else if (string.IsNullOrEmpty (v_b.Type)) + order = -m_direction; + else + order = string.Compare (v_a.Type, v_b.Type, true) * m_direction; + } + else + { + var prop_a = a.GetType ().GetProperty (m_property).GetValue (a); + var prop_b = b.GetType ().GetProperty (m_property).GetValue (b); + order = s_default_comparer.Compare (prop_a, prop_b) * m_direction; + } + if (0 == order) + order = NativeMethods.StrCmpLogicalW (v_a.Name, v_b.Name); + } + else + order = NativeMethods.StrCmpLogicalW (v_a.Name, v_b.Name) * m_direction; + return order; + } + } + + /// + /// Image format model for formats drop-down list widgets. + /// + public class ImageFormatModel + { + public ImageFormat Source { get; private set; } + public string Tag { + get { return null != Source ? Source.Tag : guiStrings.TextAsIs; } + } + + public ImageFormatModel (ImageFormat impl = null) + { + Source = impl; + } + } + + /// + /// Stores current position within directory view model. + /// + public class DirectoryPosition + { + public string Path { get; set; } + public string ArchivePath { get; set; } + public EntryViewModel Item { get; set; } + + public DirectoryPosition (DirectoryViewModel vm, EntryViewModel item) + { + Path = vm.Path; + Item = item; + if (vm.IsArchive) + ArchivePath = (vm as ArchiveViewModel).SubDir; + else + ArchivePath = ""; + } + } +} diff --git a/packages.config b/packages.config new file mode 100644 index 00000000..316816f4 --- /dev/null +++ b/packages.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/zlib/changes.txt b/zlib/changes.txt new file mode 100644 index 00000000..2a9c0c11 --- /dev/null +++ b/zlib/changes.txt @@ -0,0 +1,25 @@ +v1.3 june 2013 +Upgrade zlib to 1.2.8 +Make custom build v1.2.8.1 where 1 bugs fixed: Incorrect move method was sent to SetFilePointer. +Fix bug where utf8 flag was not set correctly. +Change UTF8Encoding to default true. +Support unicode in filename of zip itself. + +v1.2 6.may 2012 +-Upgrade zlib to 1.2.7 +-Change Zip64 option to enum (Yes,No,Auto) where Auto now is default (was No) + +v1.1 6.jan 2011 +Fixed bug: If Unzipper.ItemList had more than one entry, unzip would not work (exctracted files would try to overwrite themself) + +Update zlib dlls to custom build v1.2.5.1 where 2 bugs fixed: +-Adding over 64k number of entries in zip with total size below 4GB created invalid zip +-Writing entries over 4GB with zip64=false did not fail but created invalid zip + +Misc: +Convert unsafe code to safe code. +Wrap CloseCurrentEntry in try/finally block: we must always CloseFile, even if CloseCurrentEntry fails. +Zip64 zipping works now. + +v1.0 +Initial release diff --git a/zlib/zlib32.dll b/zlib/zlib32.dll new file mode 100644 index 0000000000000000000000000000000000000000..ae69a87a035e9cbe3d05db3053612277638a9d1b GIT binary patch literal 142848 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

O_ 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�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 WAOe911RxNBKm-C12tXhMfgt`AI(4N0 literal 0 HcmV?d00001 diff --git a/zlib/zlibnet.dll b/zlib/zlibnet.dll new file mode 100644 index 0000000000000000000000000000000000000000..84a100fce9ece7951926120f45c6610eaa5ccff2 GIT binary patch literal 41472 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 literal 0 HcmV?d00001