/[EmuXPortal]/trunk/EmuXPortal/Api/EmuConfig.cs
ViewVC logotype

Contents of /trunk/EmuXPortal/Api/EmuConfig.cs

Parent Directory Parent Directory | Revision Log Revision Log


Revision 244 - (show annotations) (download)
Tue Aug 5 05:58:51 2014 UTC (6 years, 2 months ago) by william
File size: 22972 byte(s)
PlatformNameShort/PlatformNameLong : if these are set with a null value, set them to an empty string :: also set the default value to an empty string

1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Drawing;
6 using System.IO;
7 using System.Xml;
8 using System.Diagnostics;
9 using Enterprise.Logging;
10
11 namespace EmuXPortal.Api
12 {
13 public interface IEmuConfig : IComparable<IEmuConfig>, IDisposable
14 {
15 bool IsFavorites { get; }
16 string ConfigPath { get; }
17 string PlatformNameShort { get; }
18 string PlatformNameLong { get; }
19 Image PlatformImage { get; }
20 string Extenstions { get; }
21 string EmuPath { get; }
22 string EmuOptions { get; }
23 string EmuRomPath { get; set; }
24 string ToString();
25
26 bool HasExternalConfigs { get; }
27 List<IEmuConfig> ExternalConfigs { get; }
28
29
30 string GameTitle { get; }
31 string GameImage { get; }
32 string GameExe { get; }
33 string GameExeArgs { get; }
34
35
36 void RefreshConfig();
37 void ReleasePlatformImageResource();
38 }
39
40 public static class EmuConfigLoader
41 {
42 public static readonly IEmuConfig Empty = new EmuConfig();
43 private const string EMU_CONFIG = "emu.config"; // if this file signifies the emulator configuration
44 #region load
45 public static IEmuConfig Load(string rom_path) { return new EmuConfig().Create(rom_path); }
46 public static IEmuConfig Load(string config_path, string rom_path) { return new EmuConfig().Create(config_path, rom_path); }
47 #endregion
48 #region parse emu options
49 public static string GetEMUOptions(IRomConfig config)
50 {
51 EMUOptions EMUOptions = new EMUOptions(config);
52 return EMUOptions.Options;
53 }
54 #endregion
55 #region private class EMUOptions
56 private class EMUOptions
57 {
58 #region Replaceable Constant Options
59 private const string ROM_FILE = "%ROM_FILE%";
60 private const string ROM_PATH = "%ROM_PATH%";
61 #endregion
62 private Dictionary<string, string> options_dict = new Dictionary<string, string>();
63 public EMUOptions(IRomConfig config)
64 {
65 init_dict(config);
66 config.Config.RefreshConfig();
67 string options = config.Config.EmuOptions;
68 string real_options = options;
69 foreach (KeyValuePair<string, string> pair in options_dict) { if (options.ToLower().Contains(pair.Key.ToLower())) { real_options = real_options.ToLower().Replace(pair.Key.ToLower(), pair.Value); } }
70 Options = real_options;
71 }
72 private void init_dict(IRomConfig config)
73 {
74 options_dict.Add(ROM_FILE, config.RomFile);
75 options_dict.Add(ROM_PATH, config.Config.EmuRomPath);
76 }
77 public string Options { get; set; }
78 }
79 #endregion
80
81 #region private class EmuConfig : IEmuConfig
82 internal class EmuConfig : IEmuConfig, IComparable<IEmuConfig>, IDisposable
83 {
84 public IEmuConfig Create(string rom_path) { return this.Create(string.Empty, rom_path); }
85 public IEmuConfig Create(string config_path, string rom_path)
86 {
87 IEmuConfig parent_rom = null;
88 if (rom_path == "")
89 {
90 if (config_path != "")
91 {
92 EmuRomPath = config_path.Replace(EMU_CONFIG, "").TrimEnd(new char[] { '\\' });
93 }
94 else
95 {
96 EmuRomPath = Config.RomPath;
97 }
98 }
99 else { EmuRomPath = rom_path; }
100 if (config_path == "")
101 {
102 config_path = string.Format(@"{0}\{1}", EmuRomPath, EMU_CONFIG);
103 }
104
105
106 if (rom_path == "")
107 {
108 FileInfo emu_config = new FileInfo(string.Format(@"{0}\{1}", new FileInfo(config_path).Directory, EMU_CONFIG));
109 //if (emu_config.Exists)
110 //{
111 // EmuRomPath = emu_config.Directory.FullName;
112 //}
113 while (!emu_config.Exists)
114 {
115 try
116 {
117 emu_config = new FileInfo(string.Format(@"{0}\{1}", emu_config.Directory.Parent.FullName, EMU_CONFIG));
118 }
119 catch (Exception)
120 {
121 break;
122 }
123 }
124 if (emu_config.Exists)
125 {
126 EmuRomPath = emu_config.Directory.FullName;
127 // load the rom config
128 parent_rom = EmuConfigLoader.Load(emu_config.FullName, EmuRomPath);
129 }
130
131
132 }
133
134 // read the actual config emu.config
135 FileInfo fi = new FileInfo(config_path);
136 if (fi.Exists)
137 {
138 gLog.Debug.WriteLine("Found EMU Config File: {0}", config_path);
139 gLog.Debug.WriteLine("\tLoading Config: {0}", config_path);
140 this.ConfigPath = config_path;
141 //bool loaded = false;
142 try
143 {
144 using (FileStream fs = new FileStream(config_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
145 {
146 using (XmlReader reader = XmlReader.Create(fs))
147 {
148 reader.Read();
149 bool InConfigSection = false;
150 while (!reader.EOF)
151 {
152 string value = "";
153 switch (reader.Name.ToUpper())
154 {
155 case "CONFIG": if (reader.IsStartElement()) { InConfigSection = true; } break;
156 case "PLATFORMNAMESHORT":
157 if (reader.IsStartElement())
158 {
159 value = reader.ReadElementContentAsString();
160 PlatformNameShort = (value == "") ? PlatformNameShort : value;
161 gLog.Debug.WriteLine("\t\tPLATFORMNAMESHORT={0}", PlatformNameShort);
162 }
163 break;
164 case "PLATFORMNAMELONG":
165 if (reader.IsStartElement())
166 {
167 value = reader.ReadElementContentAsString();
168 PlatformNameLong = (value == "") ? PlatformNameLong : value;
169 gLog.Debug.WriteLine("\t\tPLATFORMNAMELONG={0}", PlatformNameLong);
170 }
171 break;
172 case "PLATFORMIMAGE":
173 if (reader.IsStartElement())
174 {
175 string platform_image = reader.ReadElementContentAsString();
176 PlatformImage = (platform_image == "") ? null : Image.FromFile(string.Format(@"{0}\{1}", EmuRomPath, platform_image));
177 string str_platform_image = (platform_image == "") ? "DefaultPlatformImage" : platform_image;
178 gLog.Debug.WriteLine("\t\tPLATFORMIMAGE={0}", str_platform_image);
179 }
180 break;
181 case "EXTENSIONS":
182 if (reader.IsStartElement())
183 {
184 value = reader.ReadElementContentAsString();
185 Extenstions = (value == "") ? Extenstions : value;
186 gLog.Debug.WriteLine("\t\tEXTENSIONS={0}", Extenstions);
187 }
188 break;
189 case "EMULATORPATH":
190 if (reader.IsStartElement())
191 {
192 value = reader.ReadElementContentAsString();
193 EmuPath = (value == "") ? EmuPath : value;
194 gLog.Debug.WriteLine("\t\tEMULATORPATH={0}", EmuPath);
195 }
196 break;
197 case "EMULATOROPTIONS":
198 if (reader.IsStartElement())
199 {
200 value = reader.ReadElementContentAsString();
201 EmuOptions = (value == "") ? EmuOptions : value;
202 gLog.Debug.WriteLine("\tEMULATOROPTIONS={0}", EmuOptions);
203 }
204 break;
205 #region External Non-Emulator Rom Support
206 case "GAMETITLE":
207 if (reader.IsStartElement())
208 {
209 value = reader.ReadElementContentAsString();
210 string gametitle = (value == "") ? GameTitle : value;
211 GameTitle = gametitle;
212 gLog.Debug.WriteLine("\tGAMETITLE={0}", GameTitle);
213 }
214 break;
215 case "GAMEIMAGE":
216 if (reader.IsStartElement())
217 {
218 value = reader.ReadElementContentAsString();
219 string gameimage = (value == "") ? GameImage : value;
220 GameImage = gameimage;
221 gLog.Debug.WriteLine("\tGAMEIMAGE={0}", GameImage);
222 }
223 break;
224 case "GAMEEXE":
225 if (reader.IsStartElement())
226 {
227 value = reader.ReadElementContentAsString();
228 string gameexe = (value == "") ? GameExe : value;
229 GameExe = gameexe;
230 gLog.Debug.WriteLine("\tGAMEEXE={0}", GameExe);
231 }
232 break;
233 case "GAMEEXEARGS":
234 if (reader.IsStartElement())
235 {
236 value = reader.ReadElementContentAsString();
237 string gameexeargs = (value == "") ? GameExeArgs : value;
238 GameExeArgs = gameexeargs;
239 gLog.Debug.WriteLine("\tGAMEEXEARGS={0}", GameExeArgs);
240 }
241 break;
242 case "EXTERNALCONFIGSPATH":
243 if (reader.IsStartElement())
244 {
245 string searchPattern = "*.config";
246 string external_configs_path = reader.ReadElementContentAsString();
247 //EmuOptions = (external_configs_path == "") ? EmuOptions : value;
248 gLog.Debug.WriteLine("\tEXTERNALCONFIGSPATH={0}", external_configs_path);
249 DirectoryInfo ext_path = new DirectoryInfo(external_configs_path);
250 string ext_rom_path = string.Format(@"{0}\{1}", EmuRomPath, external_configs_path);
251 // try the path in romroot
252 if (!ext_path.Exists) { ext_path = new DirectoryInfo(ext_rom_path); }
253 if (ext_path.Exists)
254 {
255 List<IEmuConfig> externalconfigs = new List<IEmuConfig>();
256 List<string> external_config_files = (searchPattern == "*.*")
257 ? new List<string>(Directory.GetFiles(ext_path.FullName, "*.*", SearchOption.TopDirectoryOnly))
258 : new List<string>(Directory.GetFiles(ext_path.FullName, "*.*", SearchOption.TopDirectoryOnly).Where(s => searchPattern.Contains(Path.GetExtension(s).ToLower())));
259 if (external_config_files.Count > 0)
260 external_config_files.Sort(); // sort the files (they should already be sorted alphabetically by GetFiles())
261 foreach (string file in external_config_files)
262 {
263 IEmuConfig config = EmuConfigLoader.Load(file, EmuRomPath);
264 if (config != null)
265 externalconfigs.Add(config);
266 }
267 if (externalconfigs.Count > 0)
268 ExternalConfigs = externalconfigs;
269 }
270 }
271 break;
272 #endregion
273 default:
274 if (InConfigSection && (reader.Name != string.Empty) && reader.IsStartElement())
275 gLog.Warn.WriteLine("Warning: Unknown or Unrecognized config option: {0} in {1}", reader.Name, config_path);
276 break;
277 }
278 reader.Read();
279 }
280 }
281 }
282 gLog.Info.WriteLine("\tLoaded Config: {0}", config_path);
283 //loaded = true;
284 }
285 catch (Exception ex)
286 {
287 gLog.Error.WriteLine("\tFailed to Load Config: {0}", config_path);
288 gLog.Verbose.Error.WriteLine(ex.ToString());
289 }
290 }
291 else { gLog.Error.WriteLine("Could not find EMU Config File: {0}", config_path); }
292
293 if (parent_rom != null)
294 {
295 if (parent_rom.HasExternalConfigs)
296 {
297 foreach (var rom in parent_rom.ExternalConfigs)
298 {
299 if (rom.ConfigPath == config_path)
300 {
301 this.PlatformNameShort = parent_rom.PlatformNameShort;
302 this.PlatformNameLong = parent_rom.PlatformNameLong;
303 break;
304 }
305 }
306
307 }
308 }
309
310 return this;
311 }
312
313 private const string Unknown_Platform = "Unknown Platform";
314 public EmuConfig() : this(null, "") { }
315 public EmuConfig(string PlatformNameShort) : this(PlatformNameShort, PlatformNameShort) { }
316 public EmuConfig(string PlatformNameShort, string PlatformNameLong) : this(PlatformNameShort, PlatformNameLong, "") { }
317 public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage) : this(PlatformNameShort, PlatformNameLong, PlatformImage, "") { }
318 public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions) : this(PlatformNameShort, PlatformNameLong, PlatformImage, Extenstions, "") { }
319 public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions, string EmuPath) : this(PlatformNameShort, PlatformNameLong, PlatformImage, Extenstions, EmuPath, "") { }
320 public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions, string EmuPath, string EmuOptions)
321 {
322 this.PlatformNameShort = PlatformNameShort;
323 this.PlatformNameLong = PlatformNameLong;
324 this.PlatformImage = (PlatformImage == "") ? Properties.Resources.DefaultPlatformImage : Image.FromFile(PlatformImage);
325 this.Extenstions = (Extenstions == "") ? "*.*" : Extenstions;
326 this.EmuPath = EmuPath;
327 this.EmuOptions = EmuOptions;
328 this.ExternalConfigs = new List<IEmuConfig>();
329 this.GameTitle = "";
330 this.GameImage = "";
331 this.GameExe = "";
332 this.GameExeArgs = "";
333 }
334 #region IEmuConfig members
335 public bool IsFavorites { get { return false; } }
336 public string ConfigPath { get; set; }
337 private string _PlatformNameShort = "";
338 public string PlatformNameShort
339 {
340 get
341 {
342 try
343 {
344 DirectoryInfo t = new DirectoryInfo(EmuRomPath);
345 return (_PlatformNameShort == "") ? string.Format("{0} (folder={1})", Unknown_Platform, t.Name) : _PlatformNameShort;
346
347 }
348 catch (Exception ex)
349 {
350 gLog.Error.WriteLine("Unable to retrieve property: PlatformNameShort");
351 gLog.Verbose.Error.WriteLine(ex.ToString());
352 return Unknown_Platform;
353 }
354 }
355 set { _PlatformNameShort = value == null ? "" : value; }
356 }
357 private string _PlatformNameLong = "";
358 public string PlatformNameLong
359 {
360 get
361 {
362 try
363 {
364 DirectoryInfo t = new DirectoryInfo(EmuRomPath);
365 return (_PlatformNameLong == "") ? string.Format("{0} (folder={1})", Unknown_Platform, t.Name) : _PlatformNameLong;
366 }
367 catch (Exception ex)
368 {
369 gLog.Error.WriteLine("Unable to retrieve property: PlatformNameLong");
370 gLog.Verbose.Error.WriteLine(ex.ToString());
371 return Unknown_Platform;
372 }
373 }
374 set { _PlatformNameLong = value == null ? "" : value; }
375 }
376 public Image PlatformImage { get; set; }
377 public string Extenstions { get; set; }
378 public string EmuPath { get; set; }
379 public string EmuOptions { get; set; }
380 public string EmuRomPath { get; set; }
381 public bool HasExternalConfigs { get { return ExternalConfigs.Count > 0; } }
382 public List<IEmuConfig> ExternalConfigs { get; private set; }
383
384 public string GameTitle { get; set; }
385 public string GameImage { get; set; }
386 public string GameExe { get; set; }
387 public string GameExeArgs { get; set; }
388
389 public void ReleasePlatformImageResource()
390 {
391 if (this.PlatformImage != null)
392 this.PlatformImage.Dispose();
393 }
394 #endregion
395
396 public override string ToString()
397 {
398 return string.Format("{2} {0}{3}{1}", "{", "}", PlatformNameLong, PlatformNameShort);
399 }
400 #region IComparable Members
401
402 public int CompareTo(IEmuConfig obj)
403 {
404 return this.PlatformNameLong.CompareTo(obj.PlatformNameLong);
405 }
406 public void RefreshConfig()
407 {
408 gLog.Debug.WriteLine("Refreshing config for: {0} from {1}", this.ToString(), string.Format(@"{0}\{1}", EmuRomPath, EMU_CONFIG));
409 this.Create(EmuRomPath);
410 }
411 #endregion
412
413 public void Dispose()
414 {
415 if (this.PlatformImage != null)
416 this.PlatformImage.Dispose();
417 }
418 }
419 #endregion
420
421 }
422 }

  ViewVC Help
Powered by ViewVC 1.1.22