├── Mapcache Editor.sln
├── Mapcache Editor
    ├── App.xaml
    ├── App.xaml.cs
    ├── ApplicationConfiguration
    │   ├── MapcacheConfiguration.cs
    │   └── PathRequest.cs
    ├── Core
    │   ├── Commands
    │   │   ├── AddMapCommand.cs
    │   │   ├── CommandsHolder.cs
    │   │   ├── DeleteMapCommand.cs
    │   │   ├── IMapcacheCommand.cs
    │   │   └── MapcacheGroupCommand.cs
    │   ├── Extensions.cs
    │   ├── MapInfo.cs
    │   ├── Mapcache.cs
    │   ├── MapcacheDialog.xaml
    │   └── MapcacheDialog.xaml.cs
    ├── Files
    │   ├── ActImaging.dll
    │   ├── Encryption.dll
    │   ├── ErrorManager.dll
    │   ├── GRF.dll
    │   ├── Gif.Components.dll
    │   ├── GrfToWpfBridge.dll
    │   ├── TokeiLibrary.dll
    │   ├── Utilities.dll
    │   └── zlib.net.dll
    ├── Main.cs
    ├── Mapcache Editor.csproj
    ├── Properties
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   ├── Resources.resx
    │   ├── Settings.Designer.cs
    │   └── Settings.settings
    ├── Resources
    │   ├── add.png
    │   ├── app.ico
    │   ├── arrowdown.png
    │   ├── cache.png
    │   ├── convert.png
    │   ├── delete.png
    │   ├── empty.png
    │   ├── help.png
    │   ├── newFile.png
    │   ├── redo.png
    │   ├── save.png
    │   ├── smallArrow.png
    │   └── undo.png
    ├── WPF
    │   └── Styles
    │   │   └── GRFEditorStyles.xaml
    ├── app.config
    ├── app.ico
    └── app.manifest
└── README.md


/Mapcache Editor.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 11.00
 3 | # Visual Studio 2010
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mapcache Editor", "Mapcache Editor\Mapcache Editor.csproj", "{5DBC2907-9F05-453C-91B3-7ABD1616EDE0}"
 5 | EndProject
 6 | Global
 7 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 8 | 		Debug|x86 = Debug|x86
 9 | 		Release|x86 = Release|x86
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{5DBC2907-9F05-453C-91B3-7ABD1616EDE0}.Debug|x86.ActiveCfg = Debug|x86
13 | 		{5DBC2907-9F05-453C-91B3-7ABD1616EDE0}.Debug|x86.Build.0 = Debug|x86
14 | 		{5DBC2907-9F05-453C-91B3-7ABD1616EDE0}.Release|x86.ActiveCfg = Release|x86
15 | 		{5DBC2907-9F05-453C-91B3-7ABD1616EDE0}.Release|x86.Build.0 = Release|x86
16 | 	EndGlobalSection
17 | 	GlobalSection(SolutionProperties) = preSolution
18 | 		HideSolutionNode = FALSE
19 | 	EndGlobalSection
20 | EndGlobal
21 | 


--------------------------------------------------------------------------------
/Mapcache Editor/App.xaml:
--------------------------------------------------------------------------------
1 | <Application x:Class="Mapcache_Editor.App"
2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4 |              StartupUri="MainWindow.xaml">
5 |     <Application.Resources>
6 |          
7 |     </Application.Resources>
8 | </Application>
9 | 


--------------------------------------------------------------------------------
/Mapcache Editor/App.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Diagnostics;
  3 | using System.IO;
  4 | using System.Reflection;
  5 | using System.Windows;
  6 | using ErrorManager;
  7 | using GRF.Image;
  8 | using GRF.IO;
  9 | using GRF.System;
 10 | using GRF.Threading;
 11 | using GrfToWpfBridge.Application;
 12 | using Mapcache_Editor.ApplicationConfiguration;
 13 | using TokeiLibrary;
 14 | using Utilities;
 15 | 
 16 | namespace Mapcache_Editor {
 17 | 	/// <summary>
 18 | 	/// Interaction logic for App.xaml
 19 | 	/// </summary>
 20 | 	public partial class App : Application {
 21 | 		public App() {
 22 | 			Configuration.ConfigAsker = MapcacheConfiguration.ConfigAsker;
 23 | 			Settings.TempPath = GrfPath.Combine(MapcacheConfiguration.ProgramDataPath, "~tmp\\" + MapcacheConfiguration.ProcessId);
 24 | 			ErrorHandler.SetErrorHandler(new DefaultErrorHandler());
 25 | 
 26 | 			if (!Directory.Exists(Settings.TempPath)) {
 27 | 				try {
 28 | 					GrfPath.CreateDirectoryFromFile(Settings.TempPath);
 29 | 				}
 30 | 				catch {
 31 | 				}
 32 | 			}
 33 | 
 34 | 			ClearTemporaryFiles();
 35 | 		}
 36 | 
 37 | 		/// <summary>
 38 | 		/// Clears the temporary files, this method is different than GRFE's (and it is better).
 39 | 		/// </summary>
 40 | 		public static void ClearTemporaryFiles() {
 41 | 			GrfThread.Start(delegate {
 42 | 				int errorCount = 0;
 43 | 
 44 | 				// Clear root files only
 45 | 				foreach (string file in Directory.GetFiles(GrfPath.Combine(MapcacheConfiguration.ProgramDataPath, "~tmp"), "*", SearchOption.TopDirectoryOnly)) {
 46 | 					if (!GrfPath.Delete(file)) {
 47 | 						errorCount++;
 48 | 					}
 49 | 
 50 | 					if (errorCount > 20)
 51 | 						break;
 52 | 				}
 53 | 
 54 | 				// There will be no files in the temporary folder anymore
 55 | 				foreach (var directory in Directory.GetDirectories(GrfPath.Combine(MapcacheConfiguration.ProgramDataPath, "~tmp"), "*")) {
 56 | 					string folderName = Path.GetFileName(directory);
 57 | 					int processId;
 58 | 
 59 | 					if (Int32.TryParse(folderName, out processId)) {
 60 | 						try {
 61 | 							Process.GetProcessById(processId);
 62 | 							// Do not bother if the process exists, even if it's not SDE
 63 | 						}
 64 | 						catch (ArgumentException) {
 65 | 							// The process is not running
 66 | 							try {
 67 | 								Directory.Delete(directory, true);
 68 | 							}
 69 | 							catch { }
 70 | 						}
 71 | 						catch {
 72 | 							// Do nothing
 73 | 						}
 74 | 					}
 75 | 				}
 76 | 			}, "GRF - TemporaryFilesManager cleanup");
 77 | 		}
 78 | 
 79 | 		protected override void OnStartup(StartupEventArgs e) {
 80 | 			ApplicationManager.CrashReportEnabled = true;
 81 | 			ImageConverterManager.AddConverter(new DefaultImageConverter());
 82 | 			Configuration.SetImageRendering(Resources);
 83 | 
 84 | 			Resources.MergedDictionaries.Add(new ResourceDictionary { Source = new Uri("pack://application:,,,/" + Assembly.GetEntryAssembly().GetName().Name.Replace(" ", "%20") + ";component/WPF/Styles/GRFEditorStyles.xaml", UriKind.RelativeOrAbsolute) });
 85 | 
 86 | 			if (!Methods.IsWinVistaOrHigher() && Methods.IsWinXPOrHigher()) {
 87 | 				// We are on Windows XP, force the style.
 88 | 				_installTheme();
 89 | 			}
 90 | 
 91 | 			base.OnStartup(e);
 92 | 		}
 93 | 
 94 | 		private bool _installTheme() {
 95 | 			try {
 96 | 				Uri uri = new Uri("PresentationFramework.Aero;V3.0.0.0;31bf3856ad364e35;component\\themes/aero.normalcolor.xaml", UriKind.Relative);
 97 | 				Resources.MergedDictionaries.Add(LoadComponent(uri) as ResourceDictionary);
 98 | 				return true;
 99 | 			}
100 | 			catch {
101 | 				return false;
102 | 			}
103 | 		}
104 | 	}
105 | }
106 | 


--------------------------------------------------------------------------------
/Mapcache Editor/ApplicationConfiguration/MapcacheConfiguration.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Diagnostics;
 3 | using System.Globalization;
 4 | using System.Reflection;
 5 | using System.Text;
 6 | using ErrorManager;
 7 | using GRF.IO;
 8 | using GRF.System;
 9 | using TokeiLibrary;
10 | using Utilities;
11 | 
12 | namespace Mapcache_Editor.ApplicationConfiguration {
13 | 	/// <summary>
14 | 	/// Program's configuration (stored in config.txt)
15 | 	/// </summary>
16 | 	public static class MapcacheConfiguration {
17 | 		private static ConfigAsker _configAsker;
18 | 
19 | 		public static ConfigAsker ConfigAsker {
20 | 			get { return _configAsker ?? (_configAsker = new ConfigAsker(GrfPath.Combine(Configuration.ApplicationDataPath, ProgramName, "config.txt"))); }
21 | 			set { _configAsker = value; }
22 | 		}
23 | 
24 | 		public static string AppLastPath {
25 | 			get { return ConfigAsker["[Mapcache - Application latest file name]", Configuration.ApplicationPath]; }
26 | 			set { ConfigAsker["[Mapcache - Application latest file name]"] = value; }
27 | 		}
28 | 
29 | 		public static string MapCachePath {
30 | 			get { return ConfigAsker["[Mapcache - MapCachePath]", Configuration.ApplicationPath]; }
31 | 			set { ConfigAsker["[Mapcache - MapCachePath]"] = value; }
32 | 		}
33 | 		
34 | 		#region Program's configuration and information
35 | 
36 | 		public static string PublicVersion {
37 | 			get { return "1.0.1"; }
38 | 		}
39 | 
40 | 		public static string Author {
41 | 			get { return "Tokeiburu"; }
42 | 		}
43 | 
44 | 		public static string ProgramName {
45 | 			get { return "Mapcache Editor"; }
46 | 		}
47 | 
48 | 		public static string RealVersion {
49 | 			get { return Assembly.GetEntryAssembly().GetName().Version.ToString(); }
50 | 		}
51 | 
52 | 		#endregion
53 | 
54 | 		private static int _processId = 0;
55 | 
56 | 		public static int ProcessId {
57 | 			get {
58 | 				if (_processId == 0)
59 | 					_processId = Process.GetCurrentProcess().Id;
60 | 
61 | 				return _processId;
62 | 			}
63 | 		}
64 | 
65 | 		public static string TempPath {
66 | 			get { return Settings.TempPath; }
67 | 		}
68 | 
69 | 		public static bool AttemptingCustomDllLoad {
70 | 			get { return Boolean.Parse(ConfigAsker["[GRFEditor - Loading custom DLL state]", false.ToString()]); }
71 | 			set { ConfigAsker["[GRFEditor - Loading custom DLL state]"] = value.ToString(); }
72 | 		}
73 | 
74 | 		public static int CompressionMethod {
75 | 			get { return Int32.Parse(ConfigAsker["[GRFEditor - Compression method index]", "0"]); }
76 | 			set { ConfigAsker["[GRFEditor - Compression method index]"] = value.ToString(CultureInfo.InvariantCulture); }
77 | 		}
78 | 
79 | 		public static string CustomCompressionMethod {
80 | 			get { return ConfigAsker["[GRFEditor - Custom compression library]", ""]; }
81 | 			set { ConfigAsker["[GRFEditor - Custom compression library]"] = value; }
82 | 		}
83 | 
84 | 		public static string ProgramDataPath {
85 | 			get { return GrfPath.Combine(Configuration.ApplicationDataPath, ProgramName); }
86 | 		}
87 | 
88 | 		public static ErrorLevel WarningLevel {
89 | 			get { return (ErrorLevel) Int32.Parse(ConfigAsker["[Server database editor - Warning level]", "0"]); }
90 | 			set { ConfigAsker["[Server database editor - Warning level]"] = ((int) value).ToString(CultureInfo.InvariantCulture); }
91 | 		}
92 | 	}
93 | }


--------------------------------------------------------------------------------
/Mapcache Editor/ApplicationConfiguration/PathRequest.cs:
--------------------------------------------------------------------------------
 1 | using TokeiLibrary.Paths;
 2 | using Utilities;
 3 | 
 4 | namespace Mapcache_Editor.ApplicationConfiguration {
 5 | 	/// <summary>
 6 | 	/// Copied from GRF Editor
 7 | 	/// This class is Used when requesting paths; it saves the latest automatically
 8 | 	/// </summary>
 9 | 	public static class PathRequest {
10 | 		public static Setting ExtractSetting {
11 | 			get { return new Setting(null, typeof (MapcacheConfiguration).GetProperty("AppLastPath")); }
12 | 		}
13 | 
14 | 		public static string SaveFileMapcache(params string[] extra) {
15 | 			return TkPathRequest.SaveFile(new Setting(null, typeof(MapcacheConfiguration).GetProperty("MapCachePath")), extra);
16 | 		}
17 | 
18 | 		public static string OpenFileMapcache(params string[] extra) {
19 | 			return TkPathRequest.OpenFile(new Setting(null, typeof(MapcacheConfiguration).GetProperty("MapCachePath")), extra);
20 | 		}
21 | 
22 | 		public static string[] OpenFilesCde(params string[] extra) {
23 | 			return TkPathRequest.OpenFiles(new Setting(null, typeof (MapcacheConfiguration).GetProperty("AppLastPath")), extra);
24 | 		}
25 | 	}
26 | }


--------------------------------------------------------------------------------
/Mapcache Editor/Core/Commands/AddMapCommand.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using GRF.Core;
 3 | 
 4 | namespace Mapcache_Editor.Core.Commands {
 5 | 	public class AddMapCommand : IMapcacheCommand {
 6 | 		private readonly string _name;
 7 | 		private byte[] _gat;
 8 | 		private byte[] _rsw;
 9 | 		private MapInfo _map;
10 | 		private MapInfo _conflictMap;
11 | 
12 | 		public AddMapCommand(string name, byte[] gat, byte[] rsw) {
13 | 			_name = name.ToLowerInvariant();
14 | 			_gat = gat;
15 | 			_rsw = rsw;
16 | 
17 | 			// Execute now to reduce the memory usage
18 | 			_setupMap();
19 | 		}
20 | 
21 | 		public AddMapCommand(string name, MapInfo map) {
22 | 			_name = name.ToLowerInvariant();
23 | 			_map = map;
24 | 			_map.Added = true;
25 | 		}
26 | 
27 | 		private void _setupMap() {
28 | 			if (_map == null) {
29 | 				bool hasWater = _rsw != null;
30 | 				int waterHeight = _rsw != null ? (int)BitConverter.ToSingle(_rsw, 166) : -1;
31 | 
32 | 				_map = new MapInfo(_name);
33 | 				_map.Xs = BitConverter.ToUInt16(_gat, 6);
34 | 				_map.Ys = BitConverter.ToUInt16(_gat, 10);
35 | 				_map.Data = new byte[_map.Xs * _map.Ys];
36 | 
37 | 				int offset = 14;
38 | 
39 | 				for (int i = 0; i < _map.Len; i++) {
40 | 					float height = BitConverter.ToSingle(_gat, offset);
41 | 					int cellType = BitConverter.ToInt32(_gat, offset + 16);
42 | 					offset += 20;
43 | 
44 | 					if (hasWater && cellType == 0 && height > waterHeight)
45 | 						cellType = 3;
46 | 
47 | 					_map.Data[i] = (byte)cellType;
48 | 				}
49 | 
50 | 				_map.Data = Compression.CompressZlib(_map.Data);
51 | 				_map.Added = true;
52 | 				_gat = null;
53 | 				_rsw = null;
54 | 			}
55 | 		}
56 | 
57 | 		public void Execute(Mapcache mapcache) {
58 | 			_setupMap();
59 | 			
60 | 			int index = mapcache.GetMapIndex(_name);
61 | 			
62 | 			if (index > -1) {
63 | 				_conflictMap = mapcache.Maps[index];
64 | 				mapcache.Maps[index] = _map;
65 | 			}
66 | 			else {
67 | 				mapcache.Maps.Add(_map);
68 | 			}
69 | 		}
70 | 
71 | 		public void Undo(Mapcache mapcache) {
72 | 			if (_conflictMap == null)
73 | 				mapcache.Maps.Remove(_map);
74 | 			else
75 | 				mapcache.Maps[mapcache.GetMapIndex(_name)] = _conflictMap;
76 | 		}
77 | 
78 | 		public string CommandDescription {
79 | 			get { return "Added map '" + _name + "'"; }
80 | 		}
81 | 	}
82 | }
83 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/Commands/CommandsHolder.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Linq;
  5 | using Utilities.Commands;
  6 | using Utilities.Extension;
  7 | 
  8 | namespace Mapcache_Editor.Core.Commands {
  9 | 	public class CommandsHolder : AbstractCommand<IMapcacheCommand> {
 10 | 		private readonly Mapcache _mapcache;
 11 | 
 12 | 		public CommandsHolder(Mapcache mapcache) {
 13 | 			_mapcache = mapcache;
 14 | 		}
 15 | 
 16 | 		protected override void _execute(IMapcacheCommand command) {
 17 | 			command.Execute(_mapcache);
 18 | 		}
 19 | 
 20 | 		protected override void _undo(IMapcacheCommand command) {
 21 | 			command.Undo(_mapcache);
 22 | 		}
 23 | 
 24 | 		protected override void _redo(IMapcacheCommand command) {
 25 | 			command.Execute(_mapcache);
 26 | 		}
 27 | 
 28 | 		/// <summary>
 29 | 		/// Begins the commands stack grouping.
 30 | 		/// </summary>
 31 | 		public void Begin() {
 32 | 			_mapcache.Commands.BeginEdit(new MapcacheGroupCommand(_mapcache, false));
 33 | 		}
 34 | 
 35 | 		/// <summary>
 36 | 		/// Begins the commands stack grouping and apply commands as soon as they're received.
 37 | 		/// </summary>
 38 | 		public void BeginNoDelay() {
 39 | 			_mapcache.Commands.BeginEdit(new MapcacheGroupCommand(_mapcache, true));
 40 | 		}
 41 | 
 42 | 		/// <summary>
 43 | 		/// Ends the commands stack grouping.
 44 | 		/// </summary>
 45 | 		public void End() {
 46 | 			_mapcache.Commands.EndEdit();
 47 | 		}
 48 | 
 49 | 		public void AddMap(string gatfile) {
 50 | 			if (!gatfile.IsExtension(".gat"))
 51 | 				throw new Exception("Unknown extension, expected a .gat file.");
 52 | 
 53 | 			string rswfile = gatfile.ReplaceExtension(".rsw");
 54 | 
 55 | 			if (!File.Exists(gatfile))
 56 | 				throw new FileNotFoundException(String.Format("File not found: {0}.", gatfile), gatfile);
 57 | 
 58 | 			if (!File.Exists(rswfile))
 59 | 				throw new FileNotFoundException(String.Format("File not found: {0}.", rswfile), rswfile);
 60 | 
 61 | 			_mapcache.Commands.StoreAndExecute(new AddMapCommand(Path.GetFileNameWithoutExtension(gatfile), File.ReadAllBytes(gatfile), File.ReadAllBytes(rswfile)));
 62 | 		}
 63 | 
 64 | 		public void AddMapRaw(string name, MapInfo map) {
 65 | 			_mapcache.Commands.StoreAndExecute(new AddMapCommand(name, map));
 66 | 		}
 67 | 		
 68 | 		public void AddMap(string name, byte[] gatdata, byte[] rswdata) {
 69 | 			_mapcache.Commands.StoreAndExecute(new AddMapCommand(name, gatdata, rswdata));
 70 | 		}
 71 | 
 72 | 		public void DeleteMap(string name) {
 73 | 			_mapcache.Commands.StoreAndExecute(new DeleteMapCommand(name));
 74 | 		}
 75 | 
 76 | 		public void DeleteMaps(List<string> names) {
 77 | 			if (names.Count == 0)
 78 | 				return;
 79 | 
 80 | 			if (names.Count == 1) {
 81 | 				DeleteMap(names[0]);
 82 | 				return;
 83 | 			}
 84 | 
 85 | 			Begin();
 86 | 
 87 | 			foreach (var map in names) {
 88 | 				DeleteMap(map);
 89 | 			}
 90 | 
 91 | 			End();
 92 | 		}
 93 | 
 94 | 		public void AddMaps(List<string> names) {
 95 | 			HashSet<string> files = new HashSet<string>();
 96 | 
 97 | 			foreach (var file in names.Where(p => p.IsExtension(".gat", ".rsw", ".gnd"))) {
 98 | 				files.Add(file.ReplaceExtension(".gat"));
 99 | 			}
100 | 
101 | 			names = files.ToList();
102 | 
103 | 			if (names.Count == 0)
104 | 				return;
105 | 
106 | 			if (names.Count == 1) {
107 | 				AddMap(names[0]);
108 | 				return;
109 | 			}
110 | 
111 | 			Begin();
112 | 
113 | 			foreach (var map in names) {
114 | 				AddMap(map);
115 | 			}
116 | 
117 | 			End();
118 | 		}
119 | 	}
120 | }
121 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/Commands/DeleteMapCommand.cs:
--------------------------------------------------------------------------------
 1 | namespace Mapcache_Editor.Core.Commands {
 2 | 	public class DeleteMapCommand : IMapcacheCommand {
 3 | 		private readonly string _name;
 4 | 		private MapInfo _conflict;
 5 | 		private int _index;
 6 | 
 7 | 		public DeleteMapCommand(string name) {
 8 | 			_name = name;
 9 | 		}
10 | 
11 | 		public void Execute(Mapcache mapcache) {
12 | 			_index = mapcache.GetMapIndex(_name);
13 | 			_conflict = mapcache.Maps[_index];
14 | 			mapcache.Maps.RemoveAt(_index);
15 | 		}
16 | 
17 | 		public void Undo(Mapcache mapcache) {
18 | 			mapcache.Maps.Insert(_index, _conflict);
19 | 		}
20 | 
21 | 		public string CommandDescription {
22 | 			get { return "Deleted map '" + _name + "'"; }
23 | 		}
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/Commands/IMapcacheCommand.cs:
--------------------------------------------------------------------------------
1 | namespace Mapcache_Editor.Core.Commands {
2 | 	public interface IMapcacheCommand {
3 | 		void Execute(Mapcache mapcache);
4 | 		void Undo(Mapcache mapcache);
5 | 		string CommandDescription { get; }
6 | 	}
7 | }
8 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/Commands/MapcacheGroupCommand.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using Utilities.Commands;
 3 | 
 4 | namespace Mapcache_Editor.Core.Commands {
 5 | 	public class MapcacheGroupCommand : IGroupCommand<IMapcacheCommand>, IMapcacheCommand {
 6 | 		private readonly bool _executeCommandsOnStore;
 7 | 		private readonly Mapcache _mapcache;
 8 | 		private readonly List<IMapcacheCommand> _commands = new List<IMapcacheCommand>();
 9 | 		private bool _firstTimeExecuted;
10 | 
11 | 		public List<IMapcacheCommand> Commands {
12 | 			get { return _commands; }
13 | 		}
14 | 
15 | 		public MapcacheGroupCommand(Mapcache mapcache, bool executeCommandsOnStore = false) {
16 | 			_mapcache = mapcache;
17 | 			_executeCommandsOnStore = executeCommandsOnStore;
18 | 		}
19 | 
20 | 		public void Add(IMapcacheCommand command) {
21 | 			_commands.Add(command);
22 | 		}
23 | 
24 | 		public void Processing(IMapcacheCommand command) {
25 | 			if (_executeCommandsOnStore)
26 | 				command.Execute(_mapcache);
27 | 		}
28 | 
29 | 		public void AddRange(List<IMapcacheCommand> commands) {
30 | 			_commands.AddRange(commands);
31 | 		}
32 | 
33 | 		public void Close() {
34 | 		}
35 | 
36 | 		public void Execute(Mapcache mapcache) {
37 | 			if (_executeCommandsOnStore) {
38 | 				if (_firstTimeExecuted) {
39 | 					_firstTimeExecuted = false;
40 | 					return;
41 | 				}
42 | 			}
43 | 
44 | 			for (int index = 0; index < _commands.Count; index++) {
45 | 				var command = _commands[index];
46 | 				try {
47 | 					command.Execute(mapcache);
48 | 				}
49 | 				catch (AbstractCommandException) {
50 | 					_commands.RemoveAt(index);
51 | 					index--;
52 | 				}
53 | 			}
54 | 		}
55 | 
56 | 		public void Undo(Mapcache mapcache) {
57 | 			for (int index = _commands.Count - 1; index >= 0; index--) {
58 | 				_commands[index].Undo(mapcache);
59 | 			}
60 | 		}
61 | 
62 | 		public string CommandDescription {
63 | 			get {
64 | 				if (_commands.Count == 1) {
65 | 					return _commands[0].CommandDescription;
66 | 				}
67 | 
68 | 				const int DisplayLimit = 2;
69 | 
70 | 				string result = string.Format("Group command ({0}) :\r\n", _commands.Count);
71 | 
72 | 				for (int i = 0; i < DisplayLimit && i < _commands.Count; i++) {
73 | 					result += "    " + _commands[i].CommandDescription.Replace("\r\n", "\\r\\n").Replace("\n", "\\n") + "\r\n";
74 | 				}
75 | 
76 | 				result = result.Trim(new char[] { '\r', '\n' });
77 | 
78 | 				if (_commands.Count > DisplayLimit) {
79 | 					result += "...";
80 | 				}
81 | 
82 | 				return result;
83 | 			}
84 | 		}
85 | 	}
86 | }
87 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/Extensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Windows;
 6 | using System.Windows.Controls;
 7 | using ErrorManager;
 8 | using TokeiLibrary.WPF.Styles.ListView;
 9 | 
10 | namespace Mapcache_Editor.Core {
11 | 	public static class Extensions {
12 | 		public static void GenerateListViewTemplate(ListView list, ListViewDataTemplateHelper.GeneralColumnInfo[] columnInfos, ListViewCustomComparer sorter, IList<string> triggers, params string[] extraCommands) {
13 | 			Gen1(list);
14 | 			ListViewDataTemplateHelper.GenerateListViewTemplateNew(list, columnInfos, sorter, triggers, extraCommands);
15 | 		}
16 | 
17 | 		public static void Gen1(ListView list) {
18 | 			try {
19 | 				Style style = new Style();
20 | 				style.TargetType = typeof(ListViewItem);
21 | 
22 | 				style.Setters.Add(new Setter(
23 | 					FrameworkElement.HorizontalAlignmentProperty,
24 | 					HorizontalAlignment.Left
25 | 					));
26 | 				style.Setters.Add(new Setter(
27 | 					Control.HorizontalContentAlignmentProperty,
28 | 					HorizontalAlignment.Stretch
29 | 					));
30 | 
31 | 				list.ItemContainerStyle = style;
32 | 			}
33 | 			catch (Exception err) {
34 | 				ErrorHandler.HandleException(err);
35 | 			}
36 | 		}
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/MapInfo.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.ComponentModel;
 3 | using System.IO;
 4 | using GRF.IO;
 5 | using Utilities;
 6 | using Utilities.Services;
 7 | 
 8 | namespace Mapcache_Editor.Core {
 9 | 	public class MapInfo : INotifyPropertyChanged {
10 | 		public string MapName { get; set; }
11 | 		public int Xs { get; set; }
12 | 		public int Ys { get; set; }
13 | 		public byte[] Data { get; set; }
14 | 
15 | 		public int Len {
16 | 			get { return Data.Length; }
17 | 		}
18 | 
19 | 		#region INotifyPropertyChanged Members
20 | 		public event PropertyChangedEventHandler PropertyChanged;
21 | 		#endregion
22 | 
23 | 		public bool Normal {
24 | 			get { return true; }
25 | 		}
26 | 
27 | 		public bool Added { get; set; }
28 | 
29 | 		public string DisplaySize {
30 | 			get { return Methods.FileSizeToString(Len); }
31 | 		}
32 | 
33 | 		public MapInfo(string name) {
34 | 			if (name.Length > 11)
35 | 				name = name.Substring(0, 11);
36 | 			MapName = name;
37 | 		}
38 | 
39 | 		public MapInfo(ByteReader reader) {
40 | 			MapName = reader.String(12, '\0');
41 | 			MapName = MapName.ToLowerInvariant();
42 | 			Xs = reader.UInt16();
43 | 			Ys = reader.UInt16();
44 | 			int len = reader.Int32();
45 | 			Data = reader.Bytes(len);
46 | 		}
47 | 
48 | 		public void Write(BinaryWriter writer) {
49 | 			byte[] mapName = EncodingService.Ansi.GetBytes(MapName);
50 | 			writer.Write(mapName, 0, mapName.Length);
51 | 			if (mapName.Length < 12) {
52 | 				writer.Write(new byte[12 - mapName.Length]);
53 | 			}
54 | 			writer.Write((UInt16)Xs);
55 | 			writer.Write((UInt16)Ys);
56 | 			writer.Write(Data.Length);
57 | 			writer.Write(Data);
58 | 		}
59 | 
60 | 		public virtual void OnPropertyChanged() {
61 | 			PropertyChangedEventHandler handler = PropertyChanged;
62 | 			if (handler != null) handler(this, new PropertyChangedEventArgs(""));
63 | 		}
64 | 	}
65 | }


--------------------------------------------------------------------------------
/Mapcache Editor/Core/Mapcache.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.IO;
  5 | using System.Linq;
  6 | using GRF;
  7 | using GRF.IO;
  8 | using GRF.System;
  9 | using GRF.Threading;
 10 | using Mapcache_Editor.Core.Commands;
 11 | using TokeiLibrary.WPF;
 12 | 
 13 | namespace Mapcache_Editor.Core {
 14 | 	public class Mapcache : IProgress {
 15 | 		static Mapcache() {
 16 | 			TemporaryFilesManager.UniquePattern(Process.GetCurrentProcess().Id + "_mapcache_{0:0000}.dat");
 17 | 		}
 18 | 
 19 | 		public CommandsHolder Commands { get; private set; }
 20 | 
 21 | 		public string LoadedPath { get; set; }
 22 | 		private List<MapInfo> _maps = new List<MapInfo>();
 23 | 
 24 | 		public UInt32 FileSize {
 25 | 			get { return (uint)(8 + Maps.Sum(p => p.Len) + Maps.Count * 20); }
 26 | 		}
 27 | 
 28 | 		public UInt16 MapCount {
 29 | 			get { return (ushort)Maps.Count; }
 30 | 		}
 31 | 
 32 | 		public List<MapInfo> Maps {
 33 | 			get { return _maps; }
 34 | 			set { _maps = value; }
 35 | 		}
 36 | 
 37 | 		public RangeObservableCollection<MapInfo> ViewMaps {
 38 | 			get { return new RangeObservableCollection<MapInfo>(Maps); }
 39 | 		}
 40 | 
 41 | 		public Mapcache(MultiType data) : this(new ByteReader(data.Data)) {
 42 | 			LoadedPath = data.Path;
 43 | 		}
 44 | 
 45 | 		public Mapcache() {
 46 | 			Commands = new CommandsHolder(this);
 47 | 		}
 48 | 
 49 | 		private Mapcache(ByteReader reader) {
 50 | 			Commands = new CommandsHolder(this);
 51 | 
 52 | 			_load(reader);
 53 | 		}
 54 | 
 55 | 		private void _load(ByteReader reader) {
 56 | 			reader.UInt32(); // file size
 57 | 			reader.UInt16(); // map count
 58 | 			reader.UInt16(); // the header structure is 8 bytes
 59 | 
 60 | 			while (reader.CanRead) {
 61 | 				Maps.Add(new MapInfo(reader));
 62 | 			}
 63 | 		}
 64 | 
 65 | 		public int GetMapIndex(string name) {
 66 | 			var map = Maps.FirstOrDefault(p => p.MapName == name);
 67 | 
 68 | 			if (map == null)
 69 | 				return -1;
 70 | 
 71 | 			return Maps.IndexOf(map);
 72 | 		}
 73 | 
 74 | 		public void Save() {
 75 | 			Save(LoadedPath);
 76 | 		}
 77 | 
 78 | 		public void Save(string filename) {
 79 | 			if (!File.Exists(filename)) {
 80 | 				GrfPath.CreateDirectoryFromFile(filename);
 81 | 
 82 | 				using (var writer = File.Create(filename)) {
 83 | 					Save(writer);
 84 | 				}
 85 | 
 86 | 				return;
 87 | 			}
 88 | 
 89 | 			string tempFile = TemporaryFilesManager.GetTemporaryFilePath(Process.GetCurrentProcess().Id + "_mapcache_{0:0000}.dat");
 90 | 
 91 | 			using (var writer = File.Create(tempFile)) {
 92 | 				Save(writer);
 93 | 			}
 94 | 
 95 | 			GrfPath.CreateDirectoryFromFile(filename);
 96 | 			GrfPath.Delete(filename);
 97 | 			File.Copy(tempFile, filename);
 98 | 			GrfPath.Delete(tempFile);
 99 | 		}
100 | 
101 | 		public void Save(Stream stream) {
102 | 			BinaryWriter writer = new BinaryWriter(stream);
103 | 			writer.Write(FileSize);
104 | 			writer.Write(MapCount);
105 | 			writer.Write((UInt16)0);
106 | 
107 | 			foreach (var map in Maps) {
108 | 				map.Write(writer);
109 | 			}
110 | 		}
111 | 
112 | 		public void Load(string file) {
113 | 			Maps.Clear();
114 | 			_load(new ByteReader(File.ReadAllBytes(file)));
115 | 			LoadedPath = file;
116 | 			Commands.ClearCommands();
117 | 		}
118 | 
119 | 		public void Reset() {
120 | 			Maps.Clear();
121 | 			LoadedPath = null;
122 | 			Commands.ClearCommands();
123 | 		}
124 | 
125 | 		public float Progress { get; set; }
126 | 		public bool IsCancelling { get; set; }
127 | 		public bool IsCancelled { get; set; }
128 | 	}
129 | }
130 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/MapcacheDialog.xaml:
--------------------------------------------------------------------------------
 1 | <Styles:TkWindow x:Class="Mapcache_Editor.Core.MapcacheDialog"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |               xmlns:Styles="clr-namespace:TokeiLibrary.WPF.Styles;assembly=TokeiLibrary"
 5 |                  xmlns:ListView="clr-namespace:TokeiLibrary.WPF.Styles.ListView;assembly=TokeiLibrary"
 6 |                  xmlns:wpfBugFix="clr-namespace:TokeiLibrary.WpfBugFix;assembly=TokeiLibrary"
 7 |                  Width="530" Height="450">
 8 |     <Grid>
 9 |         <Grid.RowDefinitions>
10 |             <RowDefinition />
11 |             <RowDefinition Height="auto" />
12 |         </Grid.RowDefinitions>
13 |         <Grid Name="_jobGrid">
14 |             <Grid>
15 |                 <Grid.RowDefinitions>
16 |                     <RowDefinition Height="auto" />
17 |                     <RowDefinition />
18 |                     <RowDefinition Height="auto" />
19 |                 </Grid.RowDefinitions>
20 |                 <Menu Height="30" AllowDrop="True">
21 |                     <MenuItem Margin="0 0 0 0">
22 |                         <MenuItem.Header>
23 |                             <Label Content="File" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="-5 0 -5 0" />
24 |                         </MenuItem.Header>
25 |                         <MenuItem Name="_menuItemNew" ListView:WpfUtils.ImagePath="empty.png" Header="New" InputGestureText="Ctrl-N" Click="_menuItemNew_Click" />
26 |                         <Separator />
27 |                         <MenuItem Name="_menuItemOpenFrom" ListView:WpfUtils.ImagePath="newFile.png" Header="Open..." InputGestureText="Ctrl-O" Click="_menuItemOpenFrom_Click" />
28 |                         <MenuItem Name="_menuItemRecentFiles" ListView:WpfUtils.ImagePath="empty.png" Header="Open recent" />
29 |                         <Separator />
30 |                         <MenuItem Name="_menuItemSave" ListView:WpfUtils.ImagePath="save.png" Header="Save" InputGestureText="Ctrl-S" Click="_menuItemSave_Click" />
31 |                         <MenuItem Name="_menuItemSaveAs" ListView:WpfUtils.ImagePath="empty.png" Header="Save as..." Click="_menuItemSaveAs_Click" />
32 |                         <Separator />
33 |                         <MenuItem Name="_menuItemCloseGrf" ListView:WpfUtils.ImagePath="empty.png" Header="Close mapcache" Click="_menuItemCloseGrf_Click" />
34 |                         <Separator />
35 |                         <MenuItem Name="_menuItemSelect" ListView:WpfUtils.ImagePath="arrowdown.png" Header="Select" Click="_menuItemSelect_Click" />
36 |                         <Separator />
37 |                         <MenuItem Name="_menuItemAbout" ListView:WpfUtils.ImagePath="help.png" Header="About..." Click="_menuItemAbout_Click" />
38 |                         <MenuItem Name="_menuItemQuit" ListView:WpfUtils.ImagePath="empty.png" Header="Quit" Click="_menuItemQuit_Click" />
39 |                     </MenuItem>
40 |                     <MenuItem VerticalAlignment="Center" Visibility="Visible">
41 |                         <MenuItem.Header>
42 |                             <Label Content="Edit" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="-5 0 -5 0" />
43 |                         </MenuItem.Header>
44 |                         <MenuItem Name="_buttonUndo" ListView:WpfUtils.ImagePath="undo.png" IsEnabled="false" Header="Undo" InputGestureText="Ctrl-Z" Click="_buttonUndo_Click" />
45 |                         <MenuItem Name="_buttonRedo" ListView:WpfUtils.ImagePath="redo.png" IsEnabled="false" Header="Redo" InputGestureText="Ctrl-Y" Click="_buttonRedo_Click" />
46 |                         <Separator />
47 |                         <MenuItem Name="_menuItemMerge" ListView:WpfUtils.ImagePath="convert.png" Header="Merge..." InputGestureText="Ctrl-M" Click="_menuItemMerge_Click" />
48 |                         <Separator />
49 |                         <MenuItem Name="_menuItemAdd" ListView:WpfUtils.ImagePath="add.png" Header="Add maps..." Click="_menuItemAdd_Click" />
50 |                         <MenuItem Name="_menuItemDelete" ListView:WpfUtils.ImagePath="delete.png" Header="Remove selected maps" Click="_menuItemDelete_Click" />
51 |                     </MenuItem>
52 |                 </Menu>
53 |                 <DockPanel Grid.Row="0" HorizontalAlignment="Left" Margin="75 0 0 0">
54 |                     <wpfBugFix:ToggleMemoryButton x:Name="_tmbUndo" IsEnabled="false" PrimaryButtonImagePath="undo.png" DisplayFormat="Undo {0} action" />
55 |                     <wpfBugFix:ToggleMemoryButton x:Name="_tmbRedo" IsEnabled="false" PrimaryButtonImagePath="redo.png" DisplayFormat="Redo {0} action" />
56 |                 </DockPanel>
57 |                 <Styles:TkProgressBar Grid.Row="0" Name="_progressBar" Width="300" HorizontalAlignment="Right" Margin="0 0 3 0"  />
58 |                 <Border Grid.Row="1" BorderBrush="#909090" BorderThickness="0 1 0 0" MouseDown="Border_MouseDown">
59 |                     <wpfBugFix:RangeListView DragEnter="_listView_DragEnter" Foreground="Black" Drop="_listView_Drop" TextSearch.TextPath="MapName" 
60 |                                              SelectionMode="Extended" AllowDrop="True" ListView:WpfUtils.IsGridSortable="True" FocusVisualStyle="{x:Null}" 
61 |                                              BorderThickness="0" Name="_listView" VirtualizingStackPanel.IsVirtualizing="True" ScrollViewer.HorizontalScrollBarVisibility="Disabled">
62 |                         <wpfBugFix:RangeListView.ContextMenu>
63 |                             <ContextMenu>
64 |                                 <MenuItem Name="_miDelete" Click="_miDelete_Click" Header="Delete" ListView:WpfUtils.ImagePath="delete.png" />
65 |                             </ContextMenu>
66 |                         </wpfBugFix:RangeListView.ContextMenu>
67 |                     </wpfBugFix:RangeListView>
68 |                 </Border>
69 |                 <Border Grid.Row="2" BorderBrush="#909090" BorderThickness="0 1 0 0" MouseDown="Border_MouseDown">
70 |                     <Grid Background="#EFEFEF">
71 |                         <DockPanel MinWidth="450" HorizontalAlignment="Left">
72 |                             <Label Name="_labelMapCount" Content="Map count: 0" Width="120" Margin="3" Padding="0" HorizontalAlignment="Left" />
73 |                             <Label Name="_labelMapAdded" Content="Added: 0" Width="120" Margin="3" Padding="0" HorizontalAlignment="Left" />
74 |                             <Label Name="_labelSize" Content="File size: 0 B" Width="150" Margin="3" Padding="0" HorizontalAlignment="Left" />
75 |                         </DockPanel>
76 |                     </Grid>
77 |                 </Border>
78 |             </Grid>
79 |         </Grid>
80 |     </Grid>
81 | </Styles:TkWindow>
82 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Core/MapcacheDialog.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.ComponentModel;
  4 | using System.IO;
  5 | using System.Linq;
  6 | using System.Windows;
  7 | using System.Windows.Input;
  8 | using ErrorManager;
  9 | using GRF.Core;
 10 | using GRF.Threading;
 11 | using GrfToWpfBridge.Application;
 12 | using Mapcache_Editor.ApplicationConfiguration;
 13 | using Mapcache_Editor.Core.Commands;
 14 | using TokeiLibrary;
 15 | using TokeiLibrary.Shortcuts;
 16 | using TokeiLibrary.WPF;
 17 | using TokeiLibrary.WPF.Styles;
 18 | using TokeiLibrary.WPF.Styles.ListView;
 19 | using Utilities;
 20 | using Utilities.Extension;
 21 | using Utilities.Services;
 22 | using AsyncOperation = GrfToWpfBridge.Application.AsyncOperation;
 23 | 
 24 | namespace Mapcache_Editor.Core {
 25 | 	/// <summary>
 26 | 	/// Interaction logic for ScriptEditDialog.xaml
 27 | 	/// </summary>
 28 | 	public partial class MapcacheDialog : TkWindow {
 29 | 		private readonly Mapcache _cache;
 30 | 		private readonly WpfRecentFiles _recentFilesManager;
 31 | 		private readonly AsyncOperation _asyncOperation;
 32 | 
 33 | 		public MapcacheDialog()
 34 | 			: base("Mapcache", "cache.png", SizeToContent.Manual, ResizeMode.CanResize) {
 35 | 			
 36 | 			InitializeComponent();
 37 | 
 38 | 			ShowInTaskbar = true;
 39 | 			WindowStartupLocation = WindowStartupLocation.CenterOwner;
 40 | 
 41 | 			_cache = new Mapcache();
 42 | 			_cache.Commands.ModifiedStateChanged += _commands_ModifiedStateChanged;
 43 | 			_asyncOperation = new AsyncOperation(_progressBar);
 44 | 
 45 | 			Extensions.GenerateListViewTemplate(_listView, new ListViewDataTemplateHelper.GeneralColumnInfo[] {
 46 | 				new ListViewDataTemplateHelper.GeneralColumnInfo { Header = "Name", DisplayExpression = "MapName", SearchGetAccessor = "MapName", ToolTipBinding = "MapName", TextWrapping = TextWrapping.Wrap, TextAlignment = TextAlignment.Center, FixedWidth = 140 },
 47 | 				new ListViewDataTemplateHelper.GeneralColumnInfo { Header = "Width", DisplayExpression = "Xs", SearchGetAccessor = "Xs", ToolTipBinding = "Xs", TextAlignment = TextAlignment.Center, FixedWidth = 80 },
 48 | 				new ListViewDataTemplateHelper.GeneralColumnInfo { Header = "Height", DisplayExpression = "Ys", SearchGetAccessor = "Ys", ToolTipBinding = "Ys", TextAlignment = TextAlignment.Center, FixedWidth = 80 },
 49 | 				new ListViewDataTemplateHelper.GeneralColumnInfo { Header = "Size", DisplayExpression = "DisplaySize", SearchGetAccessor = "Len", ToolTipBinding = "DisplaySize", TextAlignment = TextAlignment.Center, FixedWidth = 150 },
 50 | 			}, new DefaultListViewComparer<MapInfo>(), new string[] { "Added", "Blue" });
 51 | 
 52 | 			_tmbUndo.SetUndo(_cache.Commands);
 53 | 			_tmbRedo.SetRedo(_cache.Commands);
 54 | 			_commands_ModifiedStateChanged(null, null);
 55 | 			_listView.ItemsSource = _cache.ViewMaps;
 56 | 
 57 | 			ApplicationShortcut.Link(ApplicationShortcut.Save, () => _menuItemSave_Click(null, null), this);
 58 | 			ApplicationShortcut.Link(ApplicationShortcut.Undo, () => _cache.Commands.Undo(), this);
 59 | 			ApplicationShortcut.Link(ApplicationShortcut.Redo, () => _cache.Commands.Redo(), this);
 60 | 			ApplicationShortcut.Link(ApplicationShortcut.New, () => _menuItemNew_Click(null, null), this);
 61 | 			ApplicationShortcut.Link(ApplicationShortcut.Open, () => _menuItemOpenFrom_Click(null, null), this);
 62 | 			ApplicationShortcut.Link(ApplicationShortcut.Delete, () => _miDelete_Click(null, null), this);
 63 | 
 64 | 			_recentFilesManager = new WpfRecentFiles(Configuration.ConfigAsker, 6, _menuItemRecentFiles, "Mapcache");
 65 | 			_recentFilesManager.FileClicked += _recentFilesManager_FileClicked;
 66 | 
 67 | 			if (_recentFilesManager.Files.Count > 0 && File.Exists(_recentFilesManager.Files[0])) {
 68 | 				_load(_recentFilesManager.Files[0]);
 69 | 			}
 70 | 		}
 71 | 
 72 | 		private void _commands_ModifiedStateChanged(object sender, IMapcacheCommand command) {
 73 | 			this.Dispatch(delegate {
 74 | 				if (_cache.LoadedPath != null) {
 75 | 					this.Title = "Mapcache - " + Methods.CutFileName(_cache.LoadedPath, 50) + (_cache.Commands.IsModified ? " *" : "");
 76 | 				}
 77 | 				else {
 78 | 					this.Title = "Mapcache - map_cache.dat *";
 79 | 				}
 80 | 
 81 | 				_labelMapCount.Content = "Map count: " + _cache.MapCount;
 82 | 				_labelMapAdded.Content = "Added: " + _cache.Maps.Count(p => p.Added);
 83 | 				_labelSize.Content = "File Size: " + _cache.FileSize + " (" + Methods.FileSizeToString(_cache.FileSize) + ")";
 84 | 				_listView.ItemsSource = _cache.ViewMaps;
 85 | 			});
 86 | 		}
 87 | 
 88 | 		private void _miDelete_Click(object sender, RoutedEventArgs e) {
 89 | 			try {
 90 | 				if (!_validateState())
 91 | 					return;
 92 | 				_cache.Commands.DeleteMaps(_listView.SelectedItems.OfType<MapInfo>().Select(p => p.MapName).ToList());
 93 | 			}
 94 | 			catch (Exception err) {
 95 | 				ErrorHandler.HandleException(err);
 96 | 			}
 97 | 		}
 98 | 
 99 | 		private bool _validateState() {
100 | 			if (_asyncOperation.IsRunning) {
101 | 				ErrorHandler.HandleException("An operation is currently running, wait for it to finish or cancel it.", ErrorLevel.NotSpecified);
102 | 				return false;
103 | 			}
104 | 
105 | 			return true;
106 | 		}
107 | 
108 | 		private void _menuItemSave_Click(object sender, RoutedEventArgs e) {
109 | 			if (!_validateState())
110 | 				return;
111 | 
112 | 			if (_cache.LoadedPath == null) {
113 | 				_menuItemSaveAs_Click(sender, e);
114 | 				return;
115 | 			}
116 | 
117 | 			_cache.Save(_cache.LoadedPath);
118 | 			_cache.LoadedPath = _cache.LoadedPath;
119 | 			_cache.Commands.SaveCommandIndex();
120 | 			_fakeProgress(0);
121 | 		}
122 | 
123 | 		private void _menuItemSaveAs_Click(object sender, RoutedEventArgs e) {
124 | 			if (!_validateState())
125 | 				return;
126 | 
127 | 			try {
128 | 				string file = PathRequest.SaveFileMapcache("filter", "Dat Files (*.dat)|*.dat", "fileName", Path.GetFileName(_cache.LoadedPath ?? "map_cache.dat"));
129 | 
130 | 				if (file != null) {
131 | 					_cache.Save(file);
132 | 					_cache.LoadedPath = file;
133 | 					_cache.Commands.SaveCommandIndex();
134 | 					_fakeProgress(0);
135 | 				}
136 | 			}
137 | 			catch (Exception err) {
138 | 				ErrorHandler.HandleException(err);
139 | 			}
140 | 		}
141 | 
142 | 		private void _fakeProgress(int mode) {
143 | 			if (mode == 1) {
144 | 				_asyncOperation.SetAndRunOperation(new GrfThread(_dull, _cache, 200), delegate {
145 | 					_progressBar.SetSpecialState(TkProgressBar.ProgressStatus.FileLoaded);
146 | 				});
147 | 			}
148 | 			else
149 | 				_asyncOperation.SetAndRunOperation(new GrfThread(_dull, _cache, 200));
150 | 		}
151 | 
152 | 		private void _dull() {
153 | 			AProgress.Finalize(_cache);
154 | 		}
155 | 
156 | 		private void _menuItemAbout_Click(object sender, RoutedEventArgs e) {
157 | 			WindowProvider.ShowWindow(new AboutDialog(MapcacheConfiguration.PublicVersion, MapcacheConfiguration.RealVersion, MapcacheConfiguration.Author, MapcacheConfiguration.ProgramName), this);
158 | 		}
159 | 
160 | 		private void _menuItemQuit_Click(object sender, RoutedEventArgs e) {
161 | 			Close();
162 | 		}
163 | 
164 | 		protected override void OnClosing(CancelEventArgs e) {
165 | 			try {
166 | 				if (_cache != null && _cache.Commands.IsModified) {
167 | 					MessageBoxResult res = WindowProvider.ShowDialog("The map cache has been modified, do you want to save it first?", "Modified map cache", MessageBoxButton.YesNoCancel);
168 | 
169 | 					if (res == MessageBoxResult.Yes) {
170 | 						_menuItemSaveAs_Click(null, null);
171 | 						e.Cancel = true;
172 | 						return;
173 | 					}
174 | 
175 | 					if (res == MessageBoxResult.Cancel) {
176 | 						e.Cancel = true;
177 | 						return;
178 | 					}
179 | 				}
180 | 
181 | 				ApplicationManager.Shutdown();
182 | 				base.OnClosing(e);
183 | 			}
184 | 			catch (Exception err) {
185 | 				try {
186 | 					ErrorHandler.HandleException("The application hasn't ended properly. Please report this issue.", err);
187 | 				}
188 | 				catch {
189 | 				}
190 | 			}
191 | 		}
192 | 
193 | 		private void _menuItemOpenFrom_Click(object sender, RoutedEventArgs e) {
194 | 			try {
195 | 				string file = PathRequest.OpenFileMapcache("filter", "Dat Files (*.dat)|*.dat");
196 | 
197 | 				if (file != null) {
198 | 					if (File.Exists(file)) {
199 | 						_load(file);
200 | 						_recentFilesManager.AddRecentFile(file);
201 | 					}
202 | 				}
203 | 			}
204 | 			catch (Exception err) {
205 | 				ErrorHandler.HandleException(err);
206 | 			}
207 | 		}
208 | 
209 | 		private void _load(string file) {
210 | 			if (file.IsExtension(".dat")) {
211 | 				if (_validateNewContainer()) {
212 | 					_cache.Load(file);
213 | 					_commands_ModifiedStateChanged(null, null);
214 | 					_fakeProgress(1);
215 | 				}
216 | 			}
217 | 		}
218 | 
219 | 		private bool _validateNewContainer() {
220 | 			try {
221 | 				if (!_validateState())
222 | 					return false;
223 | 
224 | 				if (_cache.Commands.IsModified) {
225 | 					MessageBoxResult res = WindowProvider.ShowDialog("The map cache has been modified, do you want to save it first?", "Modified map cache", MessageBoxButton.YesNoCancel);
226 | 
227 | 					if (res == MessageBoxResult.Yes) {
228 | 						_menuItemSaveAs_Click(null, null);
229 | 						return false;
230 | 					}
231 | 
232 | 					if (res == MessageBoxResult.Cancel) {
233 | 						return false;
234 | 					}
235 | 				}
236 | 			}
237 | 			catch {
238 | 				return true;
239 | 			}
240 | 
241 | 			return true;
242 | 		}
243 | 
244 | 		private void _recentFilesManager_FileClicked(string fileName) {
245 | 			try {
246 | 				if (File.Exists(fileName)) {
247 | 					_load(fileName);
248 | 				}
249 | 				else {
250 | 					ErrorHandler.HandleException("File not found : " + fileName, ErrorLevel.Low);
251 | 					_recentFilesManager.RemoveRecentFile(fileName);
252 | 				}
253 | 			}
254 | 			catch (Exception err) {
255 | 				ErrorHandler.HandleException(err);
256 | 			}
257 | 		}
258 | 
259 | 		private void _menuItemCloseGrf_Click(object sender, RoutedEventArgs e) {
260 | 			try {
261 | 				if (_validateNewContainer()) {
262 | 					_cache.Reset();
263 | 					_progressBar.Progress = 0;
264 | 					_commands_ModifiedStateChanged(null, null);
265 | 				}
266 | 			}
267 | 			catch (Exception err) {
268 | 				ErrorHandler.HandleException(err);
269 | 			}
270 | 		}
271 | 
272 | 		private void _menuItemSelect_Click(object sender, RoutedEventArgs e) {
273 | 			try {
274 | 				if (_cache.LoadedPath == null)
275 | 					throw new Exception("No file has been loaded.");
276 | 
277 | 				OpeningService.FileOrFolder(_cache.LoadedPath);
278 | 			}
279 | 			catch (Exception err) {
280 | 				ErrorHandler.HandleException(err);
281 | 			}
282 | 		}
283 | 
284 | 		private void _menuItemNew_Click(object sender, RoutedEventArgs e) {
285 | 			_menuItemCloseGrf_Click(null, null);
286 | 		}
287 | 
288 | 		private void _listView_DragEnter(object sender, DragEventArgs e) {
289 | 			e.Effects = DragDropEffects.Copy;
290 | 		}
291 | 
292 | 		private void _listView_Drop(object sender, DragEventArgs e) {
293 | 			try {
294 | 				if (!_validateState())
295 | 					return;
296 | 
297 | 				if (e.Data.GetDataPresent(DataFormats.FileDrop, true)) {
298 | 					string[] files = e.Data.GetData(DataFormats.FileDrop, true) as string[];
299 | 
300 | 					if (files == null)
301 | 						return;
302 | 
303 | 					if (files.Length == 1 && files[0].IsExtension(".dat")) {
304 | 						_load(files[0]);
305 | 						_recentFilesManager.AddRecentFile(files[0]);
306 | 					}
307 | 					else {
308 | 						_cache.Commands.AddMaps(files.ToList());
309 | 					}
310 | 				}
311 | 			}
312 | 			catch (Exception err) {
313 | 				ErrorHandler.HandleException(err);
314 | 			}
315 | 		}
316 | 
317 | 		private void _menuItemAdd_Click(object sender, RoutedEventArgs e) {
318 | 			try {
319 | 				string[] files = PathRequest.OpenFilesCde("filter", "Gat Files (*.gat)|*.gat");
320 | 
321 | 				if (files != null) {
322 | 					_cache.Commands.AddMaps(files.ToList());
323 | 				}
324 | 			}
325 | 			catch (Exception err) {
326 | 				ErrorHandler.HandleException(err);
327 | 			}
328 | 		}
329 | 
330 | 		private void _menuItemDelete_Click(object sender, RoutedEventArgs e) {
331 | 			_miDelete_Click(null, null);
332 | 		}
333 | 
334 | 		private void _buttonUndo_Click(object sender, RoutedEventArgs e) {
335 | 			if (!_validateState())
336 | 				return;
337 | 			_cache.Commands.Undo();
338 | 		}
339 | 
340 | 		private void _buttonRedo_Click(object sender, RoutedEventArgs e) {
341 | 			if (!_validateState())
342 | 				return;
343 | 			_cache.Commands.Redo();
344 | 		}
345 | 
346 | 		private void Border_MouseDown(object sender, MouseButtonEventArgs e) {
347 | 			if (e.ChangedButton == MouseButton.Left)
348 | 				this.DragMove();
349 | 		}
350 | 
351 | 		private void _menuItemMerge_Click(object sender, RoutedEventArgs e) {
352 | 			try {
353 | 				if (!_validateState())
354 | 					return;
355 | 
356 | 				string file = PathRequest.OpenFileMapcache("filter", "Grf and Dat Files (*.grf, *.dat)|*.grf;*.dat");
357 | 
358 | 				if (file != null) {
359 | 					if (file.IsExtension(".grf")) {
360 | 						_asyncOperation.SetAndRunOperation(new GrfThread(delegate {
361 | 							AProgress.Init(_cache);
362 | 
363 | 							try {
364 | 								_cache.Commands.Begin();
365 | 
366 | 								List<FileEntry> files = new List<FileEntry>();
367 | 								int count = 0;
368 | 
369 | 								using (GrfHolder grf = new GrfHolder(file, GrfLoadOptions.Normal)) {
370 | 									files.AddRange(grf.FileTable.EntriesInDirectory("data\\", SearchOption.TopDirectoryOnly).Where(entry => entry.RelativePath.IsExtension(".gat")));
371 | 
372 | 									foreach (var entry in files) {
373 | 										count++;
374 | 										AProgress.IsCancelling(_cache);
375 | 										FileEntry rswEntry = grf.FileTable.TryGet(entry.RelativePath.ReplaceExtension(".rsw"));
376 | 
377 | 										if (rswEntry == null)
378 | 											continue;
379 | 
380 | 										_cache.Progress = (float)count / files.Count * 100f;
381 | 										_cache.Commands.AddMap(Path.GetFileNameWithoutExtension(entry.DisplayRelativePath), entry.GetDecompressedData(), rswEntry.GetDecompressedData());
382 | 									}
383 | 								}
384 | 							}
385 | 							catch (OperationCanceledException) {
386 | 								_cache.IsCancelled = true;
387 | 								_cache.Commands.CancelEdit();
388 | 							}
389 | 							catch (Exception err) {
390 | 								_cache.Commands.CancelEdit();
391 | 								ErrorHandler.HandleException(err);
392 | 							}
393 | 							finally {
394 | 								_cache.Commands.End();
395 | 								AProgress.Finalize(_cache);
396 | 							}
397 | 						}, _cache, 200));
398 | 					}
399 | 					else if (file.IsExtension(".dat")) {
400 | 						Mapcache cache = new Mapcache(file);
401 | 
402 | 						try {
403 | 							_cache.Commands.Begin();
404 | 
405 | 							foreach (var map in cache.Maps) {
406 | 								_cache.Commands.AddMapRaw(map.MapName, map);
407 | 							}
408 | 						}
409 | 						catch {
410 | 							_cache.Commands.CancelEdit();
411 | 							throw;
412 | 						}
413 | 						finally {
414 | 							_cache.Commands.End();
415 | 						}
416 | 					}
417 | 					else {
418 | 						throw new Exception("Unreognized file format.");
419 | 					}
420 | 				}
421 | 			}
422 | 			catch (Exception err) {
423 | 				ErrorHandler.HandleException(err);
424 | 			}
425 | 		}
426 | 	}
427 | }
428 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Files/ActImaging.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/ActImaging.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/Encryption.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/Encryption.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/ErrorManager.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/ErrorManager.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/GRF.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/GRF.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/Gif.Components.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/Gif.Components.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/GrfToWpfBridge.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/GrfToWpfBridge.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/TokeiLibrary.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/TokeiLibrary.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/Utilities.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/Utilities.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Files/zlib.net.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Files/zlib.net.dll


--------------------------------------------------------------------------------
/Mapcache Editor/Main.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Diagnostics;
  3 | using System.IO;
  4 | using System.IO.Compression;
  5 | using System.Linq;
  6 | using System.Reflection;
  7 | using System.Windows;
  8 | using Mapcache_Editor;
  9 | 
 10 | namespace SDE {
 11 | 	public class GRFEditorMain {
 12 | 		private static readonly string[] _registeredAssemblies = new string[] {
 13 | 			"ErrorManager",
 14 | 			"ICSharpCode.AvalonEdit",
 15 | 			"GRF",
 16 | 			"TokeiLibrary",
 17 | 			"PaletteRecolorer",
 18 | 			"Be.Windows.Forms.HexBox",
 19 | 			"zlib.net",
 20 | 			"Utilities",
 21 | 			"cps",
 22 | 			"Encryption",
 23 | 			"Gif.Components",
 24 | 			"ColorPicker",
 25 | 			"GrfMenuHandler64",
 26 | 			"GrfMenuHandler32",
 27 | 			"msvcp100",
 28 | 			"msvcr100",
 29 | 			"ActImaging",
 30 | 			"Database",
 31 | 			"Lua",
 32 | 			"XDMessaging",
 33 | 			"ErrorManager",
 34 | 			"GrfToWpfBridge",
 35 | 			"System.Threading",
 36 | 		};
 37 | 
 38 | 		[STAThread]
 39 | 		public static void Main(string[] args) {
 40 | 			AppDomain.CurrentDomain.AssemblyResolve += (sender, arguments) => {
 41 | 				AssemblyName assemblyName = new AssemblyName(arguments.Name);
 42 | 
 43 | 				if (assemblyName.Name.EndsWith(".resources"))
 44 | 					return null;
 45 | 
 46 | 				string resourceName = "Mapcache_Editor.Files." + assemblyName.Name + ".dll";
 47 | 
 48 | 				using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName)) {
 49 | 					if (stream != null) {
 50 | 						byte[] assemblyData = new Byte[stream.Length];
 51 | 						stream.Read(assemblyData, 0, assemblyData.Length);
 52 | 						return Assembly.Load(assemblyData);
 53 | 					}
 54 | 				}
 55 | 
 56 | 				string compressedResourceName = "Mapcache_Editor.Files.Compressed." + new AssemblyName(arguments.Name).Name + ".dll";
 57 | 
 58 | 				using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(compressedResourceName)) {
 59 | 					if (stream != null) {
 60 | 						byte[] assemblyData = new Byte[stream.Length];
 61 | 						stream.Read(assemblyData, 0, assemblyData.Length);
 62 | 						return Assembly.Load(Decompress(assemblyData));
 63 | 					}
 64 | 				}
 65 | 
 66 | 				if (_registeredAssemblies.ToList().Contains(assemblyName.Name)) {
 67 | 					MessageBox.Show("Failed to load assembly : " + resourceName + "\r\n\r\nThe application will now shutdown.", "Assembly loader");
 68 | 					Process.GetCurrentProcess().Kill();
 69 | 				}
 70 | 
 71 | 				return null;
 72 | 			};
 73 | 
 74 | 			Directory.SetCurrentDirectory(Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName));
 75 | 
 76 | 			var app = new App();
 77 | 			app.StartupUri = new Uri("Core\\MapcacheDialog.xaml", UriKind.Relative);
 78 | 			app.Run();
 79 | 		}
 80 | 
 81 | 		public static byte[] Decompress(byte[] data) {
 82 | 			using (MemoryStream memStream = new MemoryStream(data))
 83 | 			using (GZipStream stream = new GZipStream(memStream, CompressionMode.Decompress)) {
 84 | 				const int size = 4096;
 85 | 				byte[] buffer = new byte[size];
 86 | 				using (MemoryStream memory = new MemoryStream()) {
 87 | 					int count;
 88 | 					do {
 89 | 						count = stream.Read(buffer, 0, size);
 90 | 						if (count > 0) {
 91 | 							memory.Write(buffer, 0, count);
 92 | 						}
 93 | 					}
 94 | 					while (count > 0);
 95 | 					return memory.ToArray();
 96 | 				}
 97 | 			}
 98 | 		}
 99 | 
100 | 		public static byte[] Compress(byte[] data) {
101 | 			using (MemoryStream memory = new MemoryStream()) {
102 | 				using (GZipStream gzip = new GZipStream(memory, CompressionMode.Compress, true)) {
103 | 					gzip.Write(data, 0, data.Length);
104 | 				}
105 | 				return memory.ToArray();
106 | 			}
107 | 		}
108 | 	}
109 | }
110 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Mapcache Editor.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  5 |     <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
  6 |     <ProductVersion>8.0.30703</ProductVersion>
  7 |     <SchemaVersion>2.0</SchemaVersion>
  8 |     <ProjectGuid>{5DBC2907-9F05-453C-91B3-7ABD1616EDE0}</ProjectGuid>
  9 |     <OutputType>WinExe</OutputType>
 10 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 11 |     <RootNamespace>Mapcache_Editor</RootNamespace>
 12 |     <AssemblyName>Mapcache Editor</AssemblyName>
 13 |     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
 14 |     <FileAlignment>512</FileAlignment>
 15 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 16 |     <WarningLevel>4</WarningLevel>
 17 |     <TargetFrameworkProfile>Client</TargetFrameworkProfile>
 18 |   </PropertyGroup>
 19 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
 20 |     <PlatformTarget>x86</PlatformTarget>
 21 |     <DebugSymbols>true</DebugSymbols>
 22 |     <DebugType>full</DebugType>
 23 |     <Optimize>false</Optimize>
 24 |     <OutputPath>bin\Debug\</OutputPath>
 25 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 26 |     <ErrorReport>prompt</ErrorReport>
 27 |     <WarningLevel>4</WarningLevel>
 28 |   </PropertyGroup>
 29 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
 30 |     <PlatformTarget>x86</PlatformTarget>
 31 |     <DebugType>pdbonly</DebugType>
 32 |     <Optimize>true</Optimize>
 33 |     <OutputPath>bin\Release\</OutputPath>
 34 |     <DefineConstants>TRACE</DefineConstants>
 35 |     <ErrorReport>prompt</ErrorReport>
 36 |     <WarningLevel>4</WarningLevel>
 37 |   </PropertyGroup>
 38 |   <PropertyGroup>
 39 |     <ApplicationManifest>app.manifest</ApplicationManifest>
 40 |   </PropertyGroup>
 41 |   <PropertyGroup>
 42 |     <StartupObject>SDE.GRFEditorMain</StartupObject>
 43 |   </PropertyGroup>
 44 |   <PropertyGroup>
 45 |     <ApplicationIcon>app.ico</ApplicationIcon>
 46 |   </PropertyGroup>
 47 |   <ItemGroup>
 48 |     <Reference Include="ErrorManager">
 49 |       <HintPath>..\..\..\..\..\..\..\tktoolsuite\Librairies\ErrorManager.dll</HintPath>
 50 |     </Reference>
 51 |     <Reference Include="GRF">
 52 |       <HintPath>..\..\..\..\..\..\..\tktoolsuite\Librairies\GRF.dll</HintPath>
 53 |     </Reference>
 54 |     <Reference Include="GrfToWpfBridge">
 55 |       <HintPath>..\..\..\..\..\..\..\tktoolsuite\Librairies\GrfToWpfBridge.dll</HintPath>
 56 |     </Reference>
 57 |     <Reference Include="System" />
 58 |     <Reference Include="System.Data" />
 59 |     <Reference Include="System.Xml" />
 60 |     <Reference Include="System.Core" />
 61 |     <Reference Include="System.Xml.Linq" />
 62 |     <Reference Include="System.Data.DataSetExtensions" />
 63 |     <Reference Include="TokeiLibrary">
 64 |       <HintPath>..\..\..\..\..\..\..\tktoolsuite\Librairies\TokeiLibrary.dll</HintPath>
 65 |     </Reference>
 66 |     <Reference Include="Utilities">
 67 |       <HintPath>..\..\..\..\..\..\..\tktoolsuite\Librairies\Utilities.dll</HintPath>
 68 |     </Reference>
 69 |     <Reference Include="WindowsBase" />
 70 |     <Reference Include="PresentationCore" />
 71 |     <Reference Include="PresentationFramework" />
 72 |   </ItemGroup>
 73 |   <ItemGroup>
 74 |     <ApplicationDefinition Include="App.xaml">
 75 |       <Generator>MSBuild:Compile</Generator>
 76 |       <SubType>Designer</SubType>
 77 |     </ApplicationDefinition>
 78 |     <Page Include="Core\MapcacheDialog.xaml">
 79 |       <Generator>MSBuild:Compile</Generator>
 80 |       <SubType>Designer</SubType>
 81 |     </Page>
 82 |     <Compile Include="App.xaml.cs">
 83 |       <DependentUpon>App.xaml</DependentUpon>
 84 |       <SubType>Code</SubType>
 85 |     </Compile>
 86 |     <Compile Include="ApplicationConfiguration\PathRequest.cs" />
 87 |     <Compile Include="ApplicationConfiguration\MapcacheConfiguration.cs" />
 88 |     <Compile Include="Core\Commands\AddMapCommand.cs" />
 89 |     <Compile Include="Core\Commands\CommandsHolder.cs" />
 90 |     <Compile Include="Core\Commands\DeleteMapCommand.cs" />
 91 |     <Compile Include="Core\Commands\IMapcacheCommand.cs" />
 92 |     <Compile Include="Core\Commands\MapcacheGroupCommand.cs" />
 93 |     <Compile Include="Core\Extensions.cs" />
 94 |     <Compile Include="Core\Mapcache.cs" />
 95 |     <Compile Include="Core\MapcacheDialog.xaml.cs">
 96 |       <DependentUpon>MapcacheDialog.xaml</DependentUpon>
 97 |     </Compile>
 98 |     <Compile Include="Core\MapInfo.cs" />
 99 |     <Compile Include="Main.cs" />
100 |     <Page Include="WPF\Styles\GRFEditorStyles.xaml">
101 |       <Generator>MSBuild:Compile</Generator>
102 |       <SubType>Designer</SubType>
103 |     </Page>
104 |   </ItemGroup>
105 |   <ItemGroup>
106 |     <Compile Include="Properties\AssemblyInfo.cs">
107 |       <SubType>Code</SubType>
108 |     </Compile>
109 |     <Compile Include="Properties\Resources.Designer.cs">
110 |       <AutoGen>True</AutoGen>
111 |       <DesignTime>True</DesignTime>
112 |       <DependentUpon>Resources.resx</DependentUpon>
113 |     </Compile>
114 |     <Compile Include="Properties\Settings.Designer.cs">
115 |       <AutoGen>True</AutoGen>
116 |       <DependentUpon>Settings.settings</DependentUpon>
117 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
118 |     </Compile>
119 |     <EmbeddedResource Include="Properties\Resources.resx">
120 |       <Generator>ResXFileCodeGenerator</Generator>
121 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
122 |     </EmbeddedResource>
123 |     <None Include="app.config" />
124 |     <None Include="app.manifest" />
125 |     <None Include="Properties\Settings.settings">
126 |       <Generator>SettingsSingleFileGenerator</Generator>
127 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
128 |     </None>
129 |     <AppDesigner Include="Properties\" />
130 |   </ItemGroup>
131 |   <ItemGroup>
132 |     <EmbeddedResource Include="Resources\redo.png" />
133 |     <EmbeddedResource Include="Resources\undo.png" />
134 |   </ItemGroup>
135 |   <ItemGroup>
136 |     <EmbeddedResource Include="Resources\arrowdown.png" />
137 |     <EmbeddedResource Include="Resources\cache.png" />
138 |     <EmbeddedResource Include="Resources\save.png" />
139 |   </ItemGroup>
140 |   <ItemGroup>
141 |     <EmbeddedResource Include="Resources\add.png" />
142 |     <EmbeddedResource Include="Resources\convert.png" />
143 |     <EmbeddedResource Include="Resources\delete.png" />
144 |   </ItemGroup>
145 |   <ItemGroup>
146 |     <EmbeddedResource Include="Resources\empty.png" />
147 |   </ItemGroup>
148 |   <ItemGroup>
149 |     <EmbeddedResource Include="Resources\newFile.png" />
150 |   </ItemGroup>
151 |   <ItemGroup>
152 |     <EmbeddedResource Include="Resources\help.png" />
153 |   </ItemGroup>
154 |   <ItemGroup>
155 |     <EmbeddedResource Include="Resources\smallArrow.png" />
156 |   </ItemGroup>
157 |   <ItemGroup>
158 |     <Resource Include="app.ico" />
159 |   </ItemGroup>
160 |   <ItemGroup>
161 |     <EmbeddedResource Include="Files\ActImaging.dll" />
162 |     <EmbeddedResource Include="Files\Encryption.dll" />
163 |     <EmbeddedResource Include="Files\ErrorManager.dll" />
164 |     <EmbeddedResource Include="Files\Gif.Components.dll" />
165 |     <EmbeddedResource Include="Files\GRF.dll" />
166 |     <EmbeddedResource Include="Files\GrfToWpfBridge.dll" />
167 |     <EmbeddedResource Include="Files\TokeiLibrary.dll" />
168 |     <EmbeddedResource Include="Files\Utilities.dll" />
169 |     <EmbeddedResource Include="Files\zlib.net.dll" />
170 |   </ItemGroup>
171 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
172 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
173 |        Other similar extension points exist, see Microsoft.Common.targets.
174 |   <Target Name="BeforeBuild">
175 |   </Target>
176 |   <Target Name="AfterBuild">
177 |   </Target>
178 |   -->
179 | </Project>


--------------------------------------------------------------------------------
/Mapcache Editor/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following 
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTitle("Mapcache Editor")]
11 | [assembly: AssemblyDescription("Mapcache Editor")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("Tokei")]
14 | [assembly: AssemblyProduct("Mapcache Editor")]
15 | [assembly: AssemblyCopyright("Copyright ©  2018")]
16 | [assembly: AssemblyTrademark("")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Setting ComVisible to false makes the types in this assembly not visible 
20 | // to COM components.  If you need to access a type in this assembly from 
21 | // COM, set the ComVisible attribute to true on that type.
22 | [assembly: ComVisible(false)]
23 | 
24 | //In order to begin building localizable applications, set 
25 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
26 | //inside a <PropertyGroup>.  For example, if you are using US english
27 | //in your source files, set the <UICulture> to en-US.  Then uncomment
28 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
29 | //the line below to match the UICulture setting in the project file.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 | 	ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
36 | 	//(used if a resource is not found in the page, 
37 | 	// or application resource dictionaries)
38 | 	ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
39 | 	//(used if a resource is not found in the page, 
40 | 	// app, or any theme specific resource dictionaries)
41 | )]
42 | 
43 | 
44 | // Version information for an assembly consists of the following four values:
45 | //
46 | //      Major Version
47 | //      Minor Version 
48 | //      Build Number
49 | //      Revision
50 | //
51 | // You can specify all the values or you can default the Build and Revision Numbers 
52 | // by using the '*' as shown below:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("1.0.0.0")]
55 | [assembly: AssemblyFileVersion("1.0.0.0")]
56 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace Mapcache_Editor.Properties {
12 |     using System;
13 |     
14 |     
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     internal class Resources {
26 |         
27 |         private static global::System.Resources.ResourceManager resourceMan;
28 |         
29 |         private static global::System.Globalization.CultureInfo resourceCulture;
30 |         
31 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 |         internal Resources() {
33 |         }
34 |         
35 |         /// <summary>
36 |         ///   Returns the cached ResourceManager instance used by this class.
37 |         /// </summary>
38 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 |         internal static global::System.Resources.ResourceManager ResourceManager {
40 |             get {
41 |                 if (object.ReferenceEquals(resourceMan, null)) {
42 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Mapcache_Editor.Properties.Resources", typeof(Resources).Assembly);
43 |                     resourceMan = temp;
44 |                 }
45 |                 return resourceMan;
46 |             }
47 |         }
48 |         
49 |         /// <summary>
50 |         ///   Overrides the current thread's CurrentUICulture property for all
51 |         ///   resource lookups using this strongly typed resource class.
52 |         /// </summary>
53 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 |         internal static global::System.Globalization.CultureInfo Culture {
55 |             get {
56 |                 return resourceCulture;
57 |             }
58 |             set {
59 |                 resourceCulture = value;
60 |             }
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/Mapcache Editor/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace Mapcache_Editor.Properties {
12 |     
13 |     
14 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
15 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
16 |     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
17 |         
18 |         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
19 |         
20 |         public static Settings Default {
21 |             get {
22 |                 return defaultInstance;
23 |             }
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/Mapcache Editor/Properties/Settings.settings:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='utf-8'?>
2 | <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
3 |   <Profiles>
4 |     <Profile Name="(Default)" />
5 |   </Profiles>
6 |   <Settings />
7 | </SettingsFile>


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/add.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/add.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/app.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/app.ico


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/arrowdown.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/arrowdown.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/cache.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/cache.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/convert.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/convert.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/delete.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/delete.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/empty.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/empty.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/help.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/help.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/newFile.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/newFile.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/redo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/redo.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/save.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/save.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/smallArrow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/smallArrow.png


--------------------------------------------------------------------------------
/Mapcache Editor/Resources/undo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/Resources/undo.png


--------------------------------------------------------------------------------
/Mapcache Editor/WPF/Styles/GRFEditorStyles.xaml:
--------------------------------------------------------------------------------
  1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  2 |                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  3 |     <Style TargetType="{x:Type ComboBox}">
  4 |         <Setter Property="FocusVisualStyle" Value="{x:Null}" />
  5 |     </Style>
  6 |     <Style TargetType="{x:Type TabControl}">
  7 |         <Setter Property="FocusVisualStyle" Value="{x:Null}" />
  8 |     </Style>
  9 |     <Style TargetType="{x:Type TabItem}">
 10 |         <Setter Property="FocusVisualStyle" Value="{x:Null}" />
 11 |     </Style>
 12 | 
 13 |     <Style x:Key="ButtonStyledXP" TargetType="{x:Type Button}" BasedOn="{x:Null}">
 14 |         <Setter Property="Padding" Value="3"/>
 15 |         <Setter Property="SnapsToDevicePixels" Value="True" />
 16 |         <Setter Property="Template" Value="{DynamicResource ButtonTemplateXP}" />
 17 |     </Style>
 18 | 
 19 |     <Style x:Key="ButtonStyled" TargetType="{x:Type Button}" BasedOn="{x:Null}">
 20 |         <Setter Property="Padding" Value="3"/>
 21 |         <Setter Property="SnapsToDevicePixels" Value="True" />
 22 |         <Setter Property="Template" Value="{DynamicResource ButtonTemplate}" />
 23 |     </Style>
 24 | 
 25 |     <LinearGradientBrush x:Key="MouseOverBrush" EndPoint="0.5,1" StartPoint="0.5,0">
 26 |         <GradientStop Color="#E8F5FC" Offset="0" />
 27 |         <GradientStop Color="#E0F2FB" Offset="0.318" />
 28 |         <GradientStop Color="#D8EFFB" Offset="0.488" />
 29 |         <GradientStop Color="#BDE5FC" Offset="0.502" />
 30 |         <GradientStop Color="#AFDDF7" Offset="0.834" />
 31 |         <GradientStop Color="#A7D9F4" Offset="1" />
 32 |     </LinearGradientBrush>
 33 |     <LinearGradientBrush x:Key="MouseOverBorderBrush" EndPoint="0.5,1" StartPoint="0.5,0">
 34 |         <GradientStop Color="#3C7EB0" Offset="0" />
 35 |         <GradientStop Color="#3C7EB0" Offset="0.536" />
 36 |         <GradientStop Color="#3C7EB0" Offset="1" />
 37 |     </LinearGradientBrush>
 38 |     <LinearGradientBrush x:Key="MouseOverHighlightBrush" EndPoint="0.5,1" StartPoint="0.5,0">
 39 |         <GradientStop Color="#FDFEFE" Offset="0" />
 40 |         <GradientStop Color="#D4ECF9" Offset="1" />
 41 |     </LinearGradientBrush>
 42 |     <LinearGradientBrush x:Key="PressedBrush" EndPoint="0.5,1" StartPoint="0.5,0">
 43 |         <GradientStop Color="#AFCCDC" Offset="0" />
 44 |         <GradientStop Color="#C1E3F5" Offset="0.046" />
 45 |         <GradientStop Color="#C1E3F5" Offset="0.488" />
 46 |         <GradientStop Color="#AAD9F2" Offset="0.502" />
 47 |         <GradientStop Color="#9CD1EE" Offset="0.724" />
 48 |         <GradientStop Color="#8FCAEA" Offset="1" />
 49 |     </LinearGradientBrush>
 50 |     <LinearGradientBrush x:Key="PressedBorderBrush" EndPoint="0.5,1" StartPoint="0.5,0">
 51 |         <GradientStop Color="#2C628A" Offset="0" />
 52 |         <GradientStop Color="#2C628A" Offset="1" />
 53 |     </LinearGradientBrush>
 54 |     <LinearGradientBrush x:Key="ButtonBorderBrush" EndPoint="0.5,1" StartPoint="0.5,0">
 55 |         <GradientStop Color="#B0B0B0" Offset="0" />
 56 |         <GradientStop Color="#8C8C8C" Offset="1" />
 57 |     </LinearGradientBrush>
 58 |     <LinearGradientBrush x:Key="PressedHighlightBrush" EndPoint="0.5,1" StartPoint="0.5,0">
 59 |         <GradientStop Color="#556974" Offset="0" />
 60 |         <GradientStop Color="#556974" Offset="0.665" />
 61 |     </LinearGradientBrush>
 62 |     <SolidColorBrush x:Key="DisabledBackgroundBrush" Color="#A5FFFFFF"/>
 63 |     <SolidColorBrush x:Key="DisabledBorderBrush" Color="#66FFFFFF"/>
 64 |     <SolidColorBrush x:Key="FocusBrush" Color="#06CCFE"/>
 65 | 
 66 |     <ControlTemplate x:Key="ButtonTemplate" TargetType="{x:Type Button}">
 67 |         <ControlTemplate.Resources>
 68 |             <Storyboard x:Key="HoverOn">
 69 |                 <DoubleAnimation Duration="00:00:00.1000000" Storyboard.TargetName="BackgroundOver" Storyboard.TargetProperty="Opacity" To="1" />
 70 |                 <DoubleAnimation Duration="00:00:00.1000000" Storyboard.TargetName="BackgroundOver_Highlight" Storyboard.TargetProperty="Opacity" To="0.65" />
 71 |             </Storyboard>
 72 |             <Storyboard x:Key="HoverOff">
 73 |                 <DoubleAnimation Duration="00:00:00.4000000" Storyboard.TargetName="BackgroundOver" Storyboard.TargetProperty="Opacity" To="0" />
 74 |                 <DoubleAnimation Duration="00:00:00.4000000" Storyboard.TargetName="BackgroundOver_Highlight" Storyboard.TargetProperty="Opacity" To="0" />
 75 |             </Storyboard>
 76 |             <Storyboard x:Key="PressedOn">
 77 |                 <DoubleAnimation Duration="00:00:00.1000000" Storyboard.TargetName="BackgroundPressed" Storyboard.TargetProperty="Opacity" To="0.84" />
 78 |                 <DoubleAnimation Duration="00:00:00.1000000" Storyboard.TargetName="BackgoundPressed_Highlight" Storyboard.TargetProperty="Opacity" To="0.65" />
 79 |             </Storyboard>
 80 |             <Storyboard x:Key="PressedOff">
 81 |                 <DoubleAnimation Duration="00:00:00.4000000" Storyboard.TargetName="BackgroundPressed" Storyboard.TargetProperty="Opacity" To="0" />
 82 |                 <DoubleAnimation Duration="00:00:00.4000000" Storyboard.TargetName="BackgoundPressed_Highlight" Storyboard.TargetProperty="Opacity" To="0" />
 83 |             </Storyboard>
 84 | 
 85 |             <Storyboard x:Key="FocusedOn">
 86 |                 <DoubleAnimation Duration="00:00:01.5000000" AutoReverse="True" RepeatBehavior="Forever" Storyboard.TargetName="BackgroundOver" Storyboard.TargetProperty="Opacity" To="0.84" />
 87 |                 <DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="FocusVisualElement" Storyboard.TargetProperty="(UIElement.Opacity)">
 88 |                     <SplineDoubleKeyFrame KeyTime="00:00:00.1000000" Value="1" />
 89 |                 </DoubleAnimationUsingKeyFrames>
 90 |             </Storyboard>
 91 |             <Storyboard x:Key="FocusedOn2">
 92 |                 <DoubleAnimation Duration="00:00:01.5000000" AutoReverse="True" RepeatBehavior="Forever" Storyboard.TargetName="BackgroundOver2" Storyboard.TargetProperty="Opacity" To="0.84" />
 93 |                 <DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="FocusVisualElement2" Storyboard.TargetProperty="(UIElement.Opacity)">
 94 |                     <SplineDoubleKeyFrame KeyTime="00:00:00.1000000" Value="1" />
 95 |                 </DoubleAnimationUsingKeyFrames>
 96 |             </Storyboard>
 97 | 
 98 |             <Storyboard x:Key="FocusedOff">
 99 |                 <DoubleAnimation Duration="00:00:00.1000000" Storyboard.TargetName="BackgroundOver" Storyboard.TargetProperty="Opacity" To="0" />
100 |                 <DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="FocusVisualElement" Storyboard.TargetProperty="(UIElement.Opacity)">
101 |                     <SplineDoubleKeyFrame KeyTime="00:00:00.1000000" Value="0" />
102 |                 </DoubleAnimationUsingKeyFrames>
103 |             </Storyboard>
104 |             <Storyboard x:Key="FocusedOff2">
105 |                 <DoubleAnimation Duration="00:00:00.1000000" Storyboard.TargetName="BackgroundOver2" Storyboard.TargetProperty="Opacity" To="0" />
106 |                 <DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="FocusVisualElement2" Storyboard.TargetProperty="(UIElement.Opacity)">
107 |                     <SplineDoubleKeyFrame KeyTime="00:00:00.1000000" Value="0" />
108 |                 </DoubleAnimationUsingKeyFrames>
109 |             </Storyboard>
110 |         </ControlTemplate.Resources>
111 |         <Grid x:Name="Grid">
112 |             <Border x:Name="BackgroundNorm" BorderThickness="1" CornerRadius="0 3 3 0" Background="{TemplateBinding Background}" BorderBrush="{DynamicResource ButtonBorderBrush}"/>
113 |             <Border x:Name="BackgroundNorm_highlight" Margin="1" BorderBrush="White" BorderThickness="1" CornerRadius="0 3 3 0" Opacity="0.65" />
114 |             <Border x:Name="BackgroundOver" BorderThickness="1" CornerRadius="0 3 3 0" Opacity="0" Background="{DynamicResource MouseOverBrush}" BorderBrush="{DynamicResource MouseOverBorderBrush}"/>
115 |             <Border x:Name="BackgroundOver_Highlight" Margin="1" BorderThickness="1" CornerRadius="0 3 3 0" Opacity="0" BorderBrush="{DynamicResource MouseOverHighlightBrush}"/>
116 |             <Border x:Name="BackgroundOver2" BorderThickness="1" CornerRadius="0 3 3 0" Opacity="0" Background="{DynamicResource MouseOverBrush}" BorderBrush="{DynamicResource MouseOverBorderBrush}"/>
117 |             <Border x:Name="BackgroundOver_Highlight2" Margin="1" BorderThickness="1" CornerRadius="0 3 3 0" Opacity="0" BorderBrush="{DynamicResource MouseOverHighlightBrush}"/>
118 |             <Border x:Name="BackgroundPressed" BorderThickness="1" CornerRadius="0 3 3 0" Opacity="0" Background="{DynamicResource PressedBrush}" BorderBrush="{DynamicResource PressedBorderBrush}"/>
119 |             <Border x:Name="DisabledVisualElement" IsHitTestVisible="false" Background="{DynamicResource DisabledBackgroundBrush}" BorderBrush="{DynamicResource DisabledBorderBrush}" BorderThickness="1" Opacity="0" />
120 | 
121 |             <TextBlock Panel.ZIndex="1" x:Name="DisabledOverlay" Text="{TemplateBinding Content}" Foreground="#FF8E96A2" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" Margin="{TemplateBinding Padding}" Visibility="Collapsed" />
122 |             <Border x:Name="FocusVisualElement" Margin="1" BorderBrush="{DynamicResource FocusBrush}" BorderThickness="1" CornerRadius="0 2 2 0" IsHitTestVisible="false" Opacity="0" />
123 |             <Border x:Name="FocusVisualElement2" Margin="1" BorderBrush="{DynamicResource FocusBrush}" BorderThickness="1" CornerRadius="0 2 2 0" IsHitTestVisible="false" Opacity="0" />
124 |             <Border x:Name="BackgoundPressed_Highlight" Margin="1" BorderThickness="1.5,1.5,0,0" CornerRadius="0 3 3 0" Opacity="0" BorderBrush="{DynamicResource PressedHighlightBrush}"/>
125 |             <Border x:Name="DefaultBorder" Margin="-1" BorderBrush="Black" BorderThickness="1" CornerRadius="0 3 3 0" IsHitTestVisible="false" Opacity="0" />
126 |             <ContentPresenter x:Name="contentPresenter" ContentTemplate="{TemplateBinding ContentTemplate}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}" Content="{TemplateBinding Content}"  />
127 |         </Grid>
128 | 
129 |         <ControlTemplate.Triggers>
130 |             <Trigger Property="IsDefault" Value="True">
131 |                 <Setter Property="Opacity" TargetName="DefaultBorder" Value="1" />
132 |             </Trigger>
133 |             <!--<Trigger Property="IsFocused" Value="True">
134 |                 <Trigger.EnterActions>
135 |                     <BeginStoryboard x:Name="FocusedOn_BeginStoryboard" Storyboard="{StaticResource FocusedOn2}" />
136 |                 </Trigger.EnterActions>
137 |                 <Trigger.ExitActions>
138 |                     <BeginStoryboard x:Name="FocusedOff_BeginStoryboard" Storyboard="{StaticResource FocusedOff2}" />
139 |                     <StopStoryboard BeginStoryboardName="FocusedOn_BeginStoryboard" />
140 |                 </Trigger.ExitActions>
141 |             </Trigger>
142 |             <Trigger Property="IsKeyboardFocused" Value="true">
143 | 
144 |                 <Trigger.ExitActions>
145 |                     <BeginStoryboard x:Name="FocusedOff_BeginStoryboard1" Storyboard="{StaticResource FocusedOff}" />
146 |                 </Trigger.ExitActions>
147 |                 <Trigger.EnterActions>
148 |                     <BeginStoryboard x:Name="FocusedOn_BeginStoryboard1" Storyboard="{StaticResource FocusedOn}" />
149 |                     <StopStoryboard BeginStoryboardName="FocusedOn_BeginStoryboard1" />
150 |                 </Trigger.EnterActions>
151 | 
152 |             </Trigger>-->
153 |             <Trigger Property="IsMouseOver" Value="true">
154 |                 <Trigger.ExitActions>
155 |                     <BeginStoryboard Storyboard="{StaticResource HoverOff}" x:Name="HoverOff_BeginStoryboard" />
156 |                 </Trigger.ExitActions>
157 |                 <Trigger.EnterActions>
158 |                     <BeginStoryboard Storyboard="{StaticResource HoverOn}" />
159 |                 </Trigger.EnterActions>
160 | 
161 |             </Trigger>
162 |             <Trigger Property="IsPressed" Value="true">
163 |                 <Trigger.ExitActions>
164 |                     <BeginStoryboard Storyboard="{StaticResource PressedOff}" />
165 |                 </Trigger.ExitActions>
166 |                 <Trigger.EnterActions>
167 |                     <BeginStoryboard Storyboard="{StaticResource PressedOn}" />
168 |                 </Trigger.EnterActions>
169 |             </Trigger>
170 | 
171 |             <Trigger Property="IsEnabled" Value="false">
172 |                 <Setter Property="Foreground" Value="{DynamicResource DisabledForegroundBrush_Button}" />
173 |             </Trigger>
174 |         </ControlTemplate.Triggers>
175 |     </ControlTemplate>
176 | 
177 |     <ControlTemplate x:Key="ButtonTemplateXP" TargetType="{x:Type Button}">
178 |         <Grid x:Name="Grid">
179 |             <Border x:Name="BackgroundNorm" BorderThickness="1" CornerRadius="0 3 3 0" Background="{TemplateBinding Background}" BorderBrush="{DynamicResource ButtonBorderBrush}"/>
180 |             <Border x:Name="BackgroundNorm_highlight" Margin="1" BorderBrush="White" BorderThickness="1" CornerRadius="0 3 3 0" Opacity="0.65" />
181 | 
182 |             <ContentPresenter x:Name="contentPresenter"  VerticalAlignment="{TemplateBinding VerticalContentAlignment}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}" Content="{TemplateBinding Content}"  />
183 |         </Grid>
184 | 
185 |         <ControlTemplate.Triggers>
186 |             <Trigger Property="IsMouseOver" Value="True">
187 |                 <Setter TargetName="BackgroundNorm" Property="Background" Value="{DynamicResource MouseOverBrush}" />
188 |                 <Setter TargetName="BackgroundNorm_highlight" Property="BorderBrush" Value="{DynamicResource MouseOverBorderBrush}" />
189 |             </Trigger>
190 |             <Trigger Property="IsPressed" Value="True">
191 |                 <Setter TargetName="BackgroundNorm" Property="Background" Value="{DynamicResource PressedBrush}" />
192 |                 <Setter TargetName="BackgroundNorm_highlight" Property="BorderBrush" Value="{DynamicResource PressedBorderBrush}" />
193 |             </Trigger>
194 |         </ControlTemplate.Triggers>
195 |     </ControlTemplate>
196 | 
197 |     <Style x:Key="TabControlStyled" TargetType="{x:Type TabControl}">
198 |         <Setter Property="Background" Value="{DynamicResource TabItemBackground}" />
199 |         <Setter Property="BorderThickness" Value="1,0,0,0" />
200 |         <Setter Property="BorderBrush" Value="{DynamicResource TabControlBorder}" />
201 |         <Setter Property="Padding" Value="4 0 0 0" />
202 |         <Setter Property="TabStripPlacement" Value="Left" />
203 |     </Style>
204 | 
205 |     <Style x:Key="TabItemStyled" TargetType="{x:Type TabItem}">
206 |         <Setter Property="Background" Value="{DynamicResource TabItemBackground}" />
207 |         <!--<Setter Property="ListView:WpfUtils.IsMouseEffectOn" Value="True" />-->
208 |         <Setter Property="Template">
209 |             <Setter.Value>
210 |                 <ControlTemplate TargetType="{x:Type TabItem}">
211 |                     <Grid>
212 |                         <Border x:Name="Border" Margin="0,0,0,0" BorderBrush="Transparent" BorderThickness="1,1,0,1">
213 |                             <Border Name="SubBorder" Margin="5">
214 |                                 <ContentPresenter x:Name="ContentSite" TextElement.FontSize="13" VerticalAlignment="Center" ContentSource="Header" Margin="5 6 15 6" RecognizesAccessKey="False">
215 |                                 </ContentPresenter>
216 |                             </Border>
217 |                         </Border>
218 |                         <Canvas Name="Canva" HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0 0 10.5 0">
219 |                             <Path Stroke="{DynamicResource TabControlBorder}" StrokeThickness="1" Data="M 0,0 12,12 12,-12 0,0 12,12" Fill="{DynamicResource TabItemBackground}" />
220 |                             <Path Stroke="{DynamicResource TabItemBackground}" StrokeThickness="1" Data="M 12,16 12,-16" Fill="{DynamicResource TabItemBackground}" />
221 |                         </Canvas>
222 |                     </Grid>
223 |                     <ControlTemplate.Triggers>
224 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="False">
225 |                             <Setter Property="Cursor" Value="Arrow" />
226 |                         </Trigger>
227 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="True">
228 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemMouseOverBackground}" />
229 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemMouseOverBorder}" />
230 |                             <Setter Property="Cursor" Value="Hand" />
231 |                         </Trigger>
232 |                         <Trigger Property="IsSelected" Value="True">
233 |                             <Setter Property="Panel.ZIndex" Value="100" />
234 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemSelectedBackground}" />
235 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemSelectedBorder}" />
236 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextSelectedForeground}" />
237 |                             <Setter TargetName="Canva" Property="Visibility" Value="Visible" />
238 |                         </Trigger>
239 |                         <Trigger Property="IsSelected" Value="False">
240 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextNormalForeground}" />
241 |                             <Setter TargetName="Canva" Property="Visibility" Value="Hidden" />
242 |                         </Trigger>
243 |                     </ControlTemplate.Triggers>
244 |                 </ControlTemplate>
245 |             </Setter.Value>
246 |         </Setter>
247 |     </Style>
248 | 
249 |     <Style x:Key="TabItemStyledLess" TargetType="{x:Type TabItem}">
250 |         <Setter Property="Background" Value="{DynamicResource TabItemBackground}" />
251 |         <Setter Property="Template">
252 |             <Setter.Value>
253 |                 <ControlTemplate TargetType="{x:Type TabItem}">
254 |                     <Grid>
255 |                         <Border x:Name="Border" Margin="0,0,0,0" BorderBrush="Transparent" BorderThickness="1,1,0,1">
256 |                             <Border Name="SubBorder" Margin="5">
257 |                                 <ContentPresenter x:Name="ContentSite" TextElement.FontSize="13" VerticalAlignment="Center" ContentSource="Header" Margin="5 0 15 0" RecognizesAccessKey="False">
258 |                                 </ContentPresenter>
259 |                             </Border>
260 |                         </Border>
261 |                         <Canvas Name="Canva" HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0 0 10.5 0">
262 |                             <Path Stroke="{DynamicResource TabControlBorder}" StrokeThickness="1" Data="M 0,0 12,12 12,-12 0,0 12,12" Fill="{DynamicResource TabItemBackground}" />
263 |                             <Path Stroke="{DynamicResource TabItemBackground}" StrokeThickness="1" Data="M 12,16 12,-16" Fill="{DynamicResource TabItemBackground}" />
264 |                         </Canvas>
265 |                         <TextBox Name="Dummy" Visibility="Collapsed" />
266 |                     </Grid>
267 |                     <ControlTemplate.Triggers>
268 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="False">
269 |                             <Setter Property="Cursor" Value="Arrow" />
270 |                         </Trigger>
271 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="True">
272 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemMouseOverBackground}" />
273 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemMouseOverBorder}" />
274 |                             <Setter Property="Cursor" Value="Hand" />
275 |                         </Trigger>
276 |                         <Trigger Property="IsSelected" Value="True">
277 |                             <Setter Property="Panel.ZIndex" Value="100" />
278 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemSelectedBackground}" />
279 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemSelectedBorder}" />
280 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextSelectedForeground}" />
281 |                             <Setter TargetName="Canva" Property="Visibility" Value="Visible" />
282 |                             <Setter TargetName="Dummy" Property="Text" Value="Visible" />
283 |                         </Trigger>
284 |                         <Trigger Property="IsSelected" Value="False">
285 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextNormalForeground}" />
286 |                             <Setter TargetName="Canva" Property="Visibility" Value="Hidden" />
287 |                             <Setter TargetName="Dummy" Property="Text" Value="Hidden" />
288 |                         </Trigger>
289 |                     </ControlTemplate.Triggers>
290 |                 </ControlTemplate>
291 |             </Setter.Value>
292 |         </Setter>
293 |     </Style>
294 | 
295 |     <Style x:Key="TabItemStyledLess1" TargetType="{x:Type TabItem}">
296 |         <Setter Property="Background" Value="{DynamicResource TabItemBackground}" />
297 |         <Setter Property="Template">
298 |             <Setter.Value>
299 |                 <ControlTemplate TargetType="{x:Type TabItem}">
300 |                     <Grid>
301 |                         <Border x:Name="Border" Margin="0,0,51,0" Background="Transparent" BorderBrush="Transparent" BorderThickness="1,1,1,1">
302 |                             <Border Name="SubBorder" Margin="5 5 0 5">
303 |                                 <ContentPresenter x:Name="ContentSite" TextElement.FontSize="13" VerticalAlignment="Center" ContentSource="Header" Margin="5 0 3 0" RecognizesAccessKey="False">
304 |                                 </ContentPresenter>
305 |                             </Border>
306 |                         </Border>
307 |                         <Canvas Name="Canva" HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0 0 10.5 0">
308 |                             <Path Stroke="{DynamicResource TabControlBorder}" StrokeThickness="1" Data="M 0,0 12,12 12,-12 0,0 12,12" Fill="{DynamicResource TabItemBackground}" />
309 |                             <Path Stroke="{DynamicResource TabItemBackground}" StrokeThickness="1" Data="M 12,16 12,-16" Fill="{DynamicResource TabItemBackground}" />
310 |                         </Canvas>
311 |                         <TextBox Name="Dummy" Visibility="Collapsed" />
312 |                         <Border x:Name="OutterBorder" BorderBrush="Transparent" BorderThickness="1,1,0,1" IsHitTestVisible="False" />
313 |                     </Grid>
314 |                     <ControlTemplate.Triggers>
315 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="False">
316 |                             <Setter Property="Cursor" Value="Arrow" />
317 |                         </Trigger>
318 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="True">
319 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemMouseOverBackground}" />
320 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemMouseOverBorder}" />
321 |                             <Setter TargetName="OutterBorder" Property="BorderBrush" Value="{DynamicResource TabItemMouseOverBorder}" />
322 |                             <Setter Property="Cursor" Value="Hand" />
323 |                         </Trigger>
324 |                         <Trigger Property="IsSelected" Value="True">
325 |                             <Setter Property="Panel.ZIndex" Value="100" />
326 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemSelectedBackground}" />
327 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemSelectedBorder}" />
328 |                             <Setter TargetName="OutterBorder" Property="BorderBrush" Value="{DynamicResource TabItemSelectedBorder}" />
329 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextSelectedForeground}" />
330 |                             <Setter TargetName="Canva" Property="Visibility" Value="Visible" />
331 |                             <Setter TargetName="Dummy" Property="Text" Value="Visible" />
332 |                         </Trigger>
333 |                         <Trigger Property="IsSelected" Value="False">
334 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextNormalForeground}" />
335 |                             <Setter TargetName="Canva" Property="Visibility" Value="Hidden" />
336 |                             <Setter TargetName="Dummy" Property="Text" Value="Hidden" />
337 |                         </Trigger>
338 |                     </ControlTemplate.Triggers>
339 |                 </ControlTemplate>
340 |             </Setter.Value>
341 |         </Setter>
342 |     </Style>
343 |     
344 |     <Style x:Key="TabItemStyledLess2" TargetType="{x:Type TabItem}">
345 |         <Setter Property="Background" Value="{DynamicResource TabItemBackground}" />
346 |         <Setter Property="Template">
347 |             <Setter.Value>
348 |                 <ControlTemplate TargetType="{x:Type TabItem}">
349 |                     <Grid Margin="0 -20 0 0">
350 |                         <Grid HorizontalAlignment="Right">
351 |                             <Border Width="52" x:Name="Border" Margin="0,0,0,0" BorderBrush="Transparent" BorderThickness="1,1,0,1">
352 |                                 <Border Name="SubBorder" Margin="5 5 0 5">
353 |                                     <ContentPresenter x:Name="ContentSite" TextElement.FontSize="13" VerticalAlignment="Center" ContentSource="Header" Margin="5 0 15 0" RecognizesAccessKey="False">
354 |                                     </ContentPresenter>
355 |                                 </Border>
356 |                             </Border>
357 |                             <Canvas Name="Canva" HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0 0 10.5 0">
358 |                                 <Path Stroke="{DynamicResource TabControlBorder}" StrokeThickness="1" Data="M 0,0 12,12 12,-12 0,0 12,12" Fill="{DynamicResource TabItemBackground}" />
359 |                                 <Path Stroke="{DynamicResource TabItemBackground}" StrokeThickness="1" Data="M 12,16 12,-16" Fill="{DynamicResource TabItemBackground}" />
360 |                             </Canvas>
361 |                             <TextBox Name="Dummy" Visibility="Collapsed" />
362 |                         </Grid>
363 |                         <Border x:Name="OutterBorder" BorderBrush="Transparent" BorderThickness="1,1,0,1" IsHitTestVisible="False" />
364 |                     </Grid>
365 |                     <ControlTemplate.Triggers>
366 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="False">
367 |                             <Setter Property="Cursor" Value="Arrow" />
368 |                         </Trigger>
369 |                         <Trigger SourceName="Border" Property="IsMouseOver" Value="True">
370 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemMouseOverBackground}" />
371 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemMouseOverBorder}" />
372 |                             <Setter TargetName="OutterBorder" Property="BorderBrush" Value="{DynamicResource TabItemMouseOverBorder}" />
373 |                             <Setter Property="Cursor" Value="Hand" />
374 |                         </Trigger>
375 |                         <Trigger Property="IsSelected" Value="True">
376 |                             <Setter Property="Panel.ZIndex" Value="100" />
377 |                             <Setter TargetName="Border" Property="Background" Value="{DynamicResource TabItemSelectedBackground}" />
378 |                             <Setter TargetName="Border" Property="BorderBrush" Value="{DynamicResource TabItemSelectedBorder}" />
379 |                             <Setter TargetName="OutterBorder" Property="BorderBrush" Value="{DynamicResource TabItemSelectedBorder}" />
380 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextSelectedForeground}" />
381 |                             <Setter TargetName="Canva" Property="Visibility" Value="Visible" />
382 |                             <Setter TargetName="Dummy" Property="Text" Value="Visible" />
383 |                         </Trigger>
384 |                         <Trigger Property="IsSelected" Value="False">
385 |                             <Setter TargetName="ContentSite" Property="TextElement.Foreground" Value="{DynamicResource TabItemTextNormalForeground}" />
386 |                             <Setter TargetName="Canva" Property="Visibility" Value="Hidden" />
387 |                             <Setter TargetName="Dummy" Property="Text" Value="Hidden" />
388 |                         </Trigger>
389 |                     </ControlTemplate.Triggers>
390 |                 </ControlTemplate>
391 |             </Setter.Value>
392 |         </Setter>
393 |     </Style>
394 | 
395 |     <SolidColorBrush x:Key="TabControlBackground" Color="#F7F9FD"/>
396 |     <SolidColorBrush x:Key="TabControlBorder" Color="#CED6E3"/>
397 |     <SolidColorBrush x:Key="TabItemBackground" Color="White"/>
398 |     <SolidColorBrush x:Key="TabItemMouseOverBackground" Color="#F3F5F8"/>
399 |     <SolidColorBrush x:Key="TabItemMouseOverBorder" Color="#CED6E3"/>
400 |     <SolidColorBrush x:Key="TabItemSelectedBackground" Color="#E9ECF2"/>
401 |     <SolidColorBrush x:Key="TabItemSelectedBorder" Color="#CED6E3"/>
402 |     <SolidColorBrush x:Key="TabItemTextSelectedForeground" Color="Black"/>
403 |     <SolidColorBrush x:Key="TabItemTextNormalForeground" Color="#626262"/>
404 |     <SolidColorBrush x:Key="SeperatorBrush" Color="#E3E9F1"/>
405 | 
406 | 
407 |     <SolidColorBrush x:Key="TextForeground" Color="Black"/>
408 |     <SolidColorBrush x:Key="FancyButtonHeaderForeground" Color="#0577C1"/>
409 |     <SolidColorBrush x:Key="FancyButtonDisabledBackgroundBrush" Color="#81F3F3F3"/>
410 |     <SolidColorBrush x:Key="FancyButtonDisabledBorderBrush" Color="#81F3F3F3"/>
411 | 
412 |     <SolidColorBrush x:Key="FancyButtonMouseOverBackgroundBrush" Color="#F3F6FB"/>
413 |     <SolidColorBrush x:Key="FancyButtonMouseOverBorderBrush" Color="#DDE4EE"/>
414 | 
415 |     <SolidColorBrush x:Key="FancyButtonPressedBackgroundBrush" Color="#E3EAF6"/>
416 |     <SolidColorBrush x:Key="FancyButtonPressedBorderBrush" Color="#C9D5E5"/>
417 | 
418 |     <SolidColorBrush x:Key="UIDialogBackground" Color="#FFF0F0F0"/>
419 | </ResourceDictionary>


--------------------------------------------------------------------------------
/Mapcache Editor/app.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <configuration>
 3 |   <startup useLegacyV2RuntimeActivationPolicy="true">
 4 |     <supportedRuntime version="v4.0"/>
 5 |     <supportedRuntime version="v4.0" sku="Client"/>
 6 |     <supportedRuntime version="v2.0.50727"/>
 7 |     <supportedRuntime version="v2.0.50727" sku="Client"/>
 8 |   </startup>
 9 | </configuration>
10 | 


--------------------------------------------------------------------------------
/Mapcache Editor/app.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tokeiburu/Mapcache-Editor/df03764544f3fb0595a41da93e1466b517e04649/Mapcache Editor/app.ico


--------------------------------------------------------------------------------
/Mapcache Editor/app.manifest:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <asmv1:assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" xmlns:asmv2="urn:schemas-microsoft-com:asm.v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 3 |   <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
 4 |   <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
 5 |     <security>
 6 |       <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
 7 |         <!-- UAC Manifest Options
 8 |             If you want to change the Windows User Account Control level replace the 
 9 |             requestedExecutionLevel node with one of the following.
10 | 
11 |         <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
12 |         <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
13 |         <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
14 | 
15 |             Specifying requestedExecutionLevel node will disable file and registry virtualization.
16 |             If you want to utilize File and Registry Virtualization for backward 
17 |             compatibility then delete the requestedExecutionLevel node.
18 |         -->
19 |         <requestedExecutionLevel level="asInvoker" uiAccess="false" />
20 |       </requestedPrivileges>
21 |     </security>
22 |   </trustInfo>
23 | 
24 |   <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
25 |     <application>
26 |     </application>
27 |   </compatibility>
28 |   <dependency>
29 |     <dependentAssembly>
30 |       <assemblyIdentity
31 |           type="win32"
32 |           name="Microsoft.Windows.Common-Controls"
33 |           version="6.0.0.0"
34 |           processorArchitecture="*"
35 |           publicKeyToken="6595b64144ccf1df"
36 |           language="*"
37 |         />
38 |     </dependentAssembly>
39 |   </dependency>
40 | 
41 | </asmv1:assembly>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Mapcache-Editor
2 | A Mapcache Editor for rAthena.
3 | 


--------------------------------------------------------------------------------