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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 244 - (hide 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 william 17 using System;
2     using System.Collections.Generic;
3     using System.Linq;
4     using System.Text;
5     using System.Drawing;
6     using System.IO;
7 william 20 using System.Xml;
8 william 199 using System.Diagnostics;
9 william 238 using Enterprise.Logging;
10 william 17
11     namespace EmuXPortal.Api
12     {
13 william 105 public interface IEmuConfig : IComparable<IEmuConfig>, IDisposable
14 william 17 {
15 william 175 bool IsFavorites { get; }
16 william 85 string ConfigPath { get; }
17 william 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 william 32 string ToString();
25 william 46
26 william 85 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 william 238 void RefreshConfig();
37 william 110 void ReleasePlatformImageResource();
38 william 175 }
39 william 17
40     public static class EmuConfigLoader
41     {
42 william 85 public static readonly IEmuConfig Empty = new EmuConfig();
43 william 17 private const string EMU_CONFIG = "emu.config"; // if this file signifies the emulator configuration
44 william 23 #region load
45 william 238 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 william 23 #endregion
48     #region parse emu options
49 william 238 public static string GetEMUOptions(IRomConfig config)
50 william 23 {
51 william 238 EMUOptions EMUOptions = new EMUOptions(config);
52 william 23 return EMUOptions.Options;
53     }
54     #endregion
55     #region private class EMUOptions
56     private class EMUOptions
57     {
58 william 24 #region Replaceable Constant Options
59     private const string ROM_FILE = "%ROM_FILE%";
60     private const string ROM_PATH = "%ROM_PATH%";
61     #endregion
62 william 23 private Dictionary<string, string> options_dict = new Dictionary<string, string>();
63 william 238 public EMUOptions(IRomConfig config)
64 william 23 {
65     init_dict(config);
66 william 238 config.Config.RefreshConfig();
67 william 23 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 william 24 options_dict.Add(ROM_FILE, config.RomFile);
75     options_dict.Add(ROM_PATH, config.Config.EmuRomPath);
76 william 23 }
77     public string Options { get; set; }
78     }
79     #endregion
80    
81 william 17 #region private class EmuConfig : IEmuConfig
82 william 199 internal class EmuConfig : IEmuConfig, IComparable<IEmuConfig>, IDisposable
83 william 17 {
84 william 238 public IEmuConfig Create(string rom_path) { return this.Create(string.Empty, rom_path); }
85     public IEmuConfig Create(string config_path, string rom_path)
86 william 46 {
87 william 200 IEmuConfig parent_rom = null;
88 william 170 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 william 200
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 william 238 parent_rom = EmuConfigLoader.Load(emu_config.FullName, EmuRomPath);
129 william 200 }
130    
131    
132     }
133    
134 william 46 // read the actual config emu.config
135     FileInfo fi = new FileInfo(config_path);
136     if (fi.Exists)
137     {
138 william 238 gLog.Debug.WriteLine("Found EMU Config File: {0}", config_path);
139     gLog.Debug.WriteLine("\tLoading Config: {0}", config_path);
140 william 85 this.ConfigPath = config_path;
141 william 46 //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 william 85 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 william 238 gLog.Debug.WriteLine("\t\tPLATFORMNAMESHORT={0}", PlatformNameShort);
162 william 85 }
163     break;
164     case "PLATFORMNAMELONG":
165     if (reader.IsStartElement())
166     {
167     value = reader.ReadElementContentAsString();
168     PlatformNameLong = (value == "") ? PlatformNameLong : value;
169 william 238 gLog.Debug.WriteLine("\t\tPLATFORMNAMELONG={0}", PlatformNameLong);
170 william 85 }
171     break;
172     case "PLATFORMIMAGE":
173     if (reader.IsStartElement())
174     {
175     string platform_image = reader.ReadElementContentAsString();
176 william 170 PlatformImage = (platform_image == "") ? null : Image.FromFile(string.Format(@"{0}\{1}", EmuRomPath, platform_image));
177 william 85 string str_platform_image = (platform_image == "") ? "DefaultPlatformImage" : platform_image;
178 william 238 gLog.Debug.WriteLine("\t\tPLATFORMIMAGE={0}", str_platform_image);
179 william 85 }
180     break;
181     case "EXTENSIONS":
182     if (reader.IsStartElement())
183     {
184     value = reader.ReadElementContentAsString();
185     Extenstions = (value == "") ? Extenstions : value;
186 william 238 gLog.Debug.WriteLine("\t\tEXTENSIONS={0}", Extenstions);
187 william 85 }
188     break;
189     case "EMULATORPATH":
190     if (reader.IsStartElement())
191     {
192     value = reader.ReadElementContentAsString();
193     EmuPath = (value == "") ? EmuPath : value;
194 william 238 gLog.Debug.WriteLine("\t\tEMULATORPATH={0}", EmuPath);
195 william 85 }
196     break;
197     case "EMULATOROPTIONS":
198     if (reader.IsStartElement())
199     {
200     value = reader.ReadElementContentAsString();
201     EmuOptions = (value == "") ? EmuOptions : value;
202 william 238 gLog.Debug.WriteLine("\tEMULATOROPTIONS={0}", EmuOptions);
203 william 85 }
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 william 238 gLog.Debug.WriteLine("\tGAMETITLE={0}", GameTitle);
213 william 85 }
214     break;
215     case "GAMEIMAGE":
216     if (reader.IsStartElement())
217     {
218     value = reader.ReadElementContentAsString();
219     string gameimage = (value == "") ? GameImage : value;
220     GameImage = gameimage;
221 william 238 gLog.Debug.WriteLine("\tGAMEIMAGE={0}", GameImage);
222 william 85 }
223     break;
224     case "GAMEEXE":
225     if (reader.IsStartElement())
226     {
227     value = reader.ReadElementContentAsString();
228     string gameexe = (value == "") ? GameExe : value;
229     GameExe = gameexe;
230 william 238 gLog.Debug.WriteLine("\tGAMEEXE={0}", GameExe);
231 william 85 }
232     break;
233     case "GAMEEXEARGS":
234     if (reader.IsStartElement())
235     {
236     value = reader.ReadElementContentAsString();
237     string gameexeargs = (value == "") ? GameExeArgs : value;
238     GameExeArgs = gameexeargs;
239 william 238 gLog.Debug.WriteLine("\tGAMEEXEARGS={0}", GameExeArgs);
240 william 85 }
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 william 238 gLog.Debug.WriteLine("\tEXTERNALCONFIGSPATH={0}", external_configs_path);
249 william 85 DirectoryInfo ext_path = new DirectoryInfo(external_configs_path);
250 william 170 string ext_rom_path = string.Format(@"{0}\{1}", EmuRomPath, external_configs_path);
251 william 85 // 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 william 238 IEmuConfig config = EmuConfigLoader.Load(file, EmuRomPath);
264 william 85 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 william 241 gLog.Warn.WriteLine("Warning: Unknown or Unrecognized config option: {0} in {1}", reader.Name, config_path);
276 william 85 break;
277     }
278     reader.Read();
279     }
280 william 46 }
281     }
282 william 241 gLog.Info.WriteLine("\tLoaded Config: {0}", config_path);
283 william 46 //loaded = true;
284     }
285     catch (Exception ex)
286     {
287 william 238 gLog.Error.WriteLine("\tFailed to Load Config: {0}", config_path);
288 william 241 gLog.Verbose.Error.WriteLine(ex.ToString());
289 william 46 }
290     }
291 william 241 else { gLog.Error.WriteLine("Could not find EMU Config File: {0}", config_path); }
292 william 46
293 william 200 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 william 46 return this;
311     }
312    
313 william 17 private const string Unknown_Platform = "Unknown Platform";
314 william 112 public EmuConfig() : this(null, "") { }
315 william 238 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 william 17 {
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 william 85 this.ExternalConfigs = new List<IEmuConfig>();
329     this.GameTitle = "";
330     this.GameImage = "";
331     this.GameExe = "";
332     this.GameExeArgs = "";
333 william 17 }
334     #region IEmuConfig members
335 william 175 public bool IsFavorites { get { return false; } }
336 william 85 public string ConfigPath { get; set; }
337 william 244 private string _PlatformNameShort = "";
338 william 17 public string PlatformNameShort
339     {
340     get
341     {
342     try
343     {
344 william 199 DirectoryInfo t = new DirectoryInfo(EmuRomPath);
345 william 17 return (_PlatformNameShort == "") ? string.Format("{0} (folder={1})", Unknown_Platform, t.Name) : _PlatformNameShort;
346 william 199
347 william 17 }
348 william 85 catch (Exception ex)
349 william 17 {
350 william 241 gLog.Error.WriteLine("Unable to retrieve property: PlatformNameShort");
351     gLog.Verbose.Error.WriteLine(ex.ToString());
352 william 17 return Unknown_Platform;
353     }
354     }
355 william 244 set { _PlatformNameShort = value == null ? "" : value; }
356 william 17 }
357 william 244 private string _PlatformNameLong = "";
358 william 17 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 william 241 gLog.Error.WriteLine("Unable to retrieve property: PlatformNameLong");
370     gLog.Verbose.Error.WriteLine(ex.ToString());
371 william 17 return Unknown_Platform;
372     }
373     }
374 william 244 set { _PlatformNameLong = value == null ? "" : value; }
375 william 17 }
376 william 20 public Image PlatformImage { get; set; }
377     public string Extenstions { get; set; }
378     public string EmuPath { get; set; }
379     public string EmuOptions { get; set; }
380 william 17 public string EmuRomPath { get; set; }
381 william 85 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 william 110
389     public void ReleasePlatformImageResource()
390     {
391     if (this.PlatformImage != null)
392     this.PlatformImage.Dispose();
393     }
394 william 85 #endregion
395    
396 william 32 public override string ToString()
397     {
398 william 85 return string.Format("{2} {0}{3}{1}", "{", "}", PlatformNameLong, PlatformNameShort);
399 william 32 }
400 william 31 #region IComparable Members
401    
402 william 104 public int CompareTo(IEmuConfig obj)
403 william 31 {
404 william 104 return this.PlatformNameLong.CompareTo(obj.PlatformNameLong);
405 william 31 }
406 william 238 public void RefreshConfig()
407 william 46 {
408 william 238 gLog.Debug.WriteLine("Refreshing config for: {0} from {1}", this.ToString(), string.Format(@"{0}\{1}", EmuRomPath, EMU_CONFIG));
409     this.Create(EmuRomPath);
410 william 46 }
411 william 31 #endregion
412 william 105
413     public void Dispose()
414     {
415     if (this.PlatformImage != null)
416     this.PlatformImage.Dispose();
417     }
418 william 17 }
419     #endregion
420    
421     }
422     }

  ViewVC Help
Powered by ViewVC 1.1.22