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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 22 by william, Wed Apr 4 02:39:20 2012 UTC revision 200 by william, Mon Aug 4 12:39:13 2014 UTC
# Line 6  using System.Drawing; Line 6  using System.Drawing;
6  using System.IO;  using System.IO;
7  using EmuXPortal.Logging;  using EmuXPortal.Logging;
8  using System.Xml;  using System.Xml;
9    using System.Diagnostics;
10    
11  namespace EmuXPortal.Api  namespace EmuXPortal.Api
12  {  {
13      public interface IEmuConfig      public interface IEmuConfig : IComparable<IEmuConfig>, IDisposable
14      {      {
15            bool IsFavorites { get; }
16            string ConfigPath { get; }
17          string PlatformNameShort { get; }          string PlatformNameShort { get; }
18          string PlatformNameLong { get; }          string PlatformNameLong { get; }
19          Image PlatformImage { get; }          Image PlatformImage { get; }
# Line 18  namespace EmuXPortal.Api Line 21  namespace EmuXPortal.Api
21          string EmuPath { get; }          string EmuPath { get; }
22          string EmuOptions { get; }          string EmuOptions { get; }
23          string EmuRomPath { get; set; }          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(logger log);
37            void ReleasePlatformImageResource();
38        }    
39    
40      public static class EmuConfigLoader      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          private const string EMU_CONFIG = "emu.config"; // if this file signifies the emulator configuration
44          public static IEmuConfig Load(string rom_path) { return Load(string.Empty, rom_path); }          #region load
45          public static IEmuConfig Load(string config_path, string rom_path)          public static IEmuConfig Load(logger log,string rom_path) { return new EmuConfig().Create(log, rom_path); }
46            public static IEmuConfig Load(logger log,string config_path, string rom_path) { return new EmuConfig().Create(log, config_path, rom_path); }
47            #endregion
48            #region parse emu options
49            public static string GetEMUOptions(logger log, IRomConfig config)
50            {
51                EMUOptions EMUOptions = new EMUOptions(log, 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(logger log, IRomConfig config)
64                {
65                    init_dict(config);
66                    config.Config.RefreshConfig(log);
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              EmuConfig config = new EmuConfig();              public IEmuConfig Create(logger log, string rom_path) { return this.Create(log, string.Empty, rom_path); }
85              config.EmuRomPath = rom_path;              public IEmuConfig Create(logger log, string config_path, string rom_path)
86              if (config_path == "") { config_path = string.Format(@"{0}\{1}", rom_path, EMU_CONFIG); }              {
87                    IEmuConfig parent_rom = null;
88              // read the actual config emu.config                  if (rom_path == "")
89              FileInfo fi = new FileInfo(config_path);                  {
90              if (fi.Exists)                      if (config_path != "")
91              {                      {
92                  logger.WriteLine("Found EMU Config File: {0}", config_path);                          EmuRomPath = config_path.Replace(EMU_CONFIG, "").TrimEnd(new char[] { '\\' });
93                  logger.WriteLine("\tLoading Config: {0}", config_path);                      }
94                  //bool loaded = false;                      else
95                  try                      {
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(log, 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                      using (FileStream fs = new FileStream(config_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))                      log.WriteLine("Found EMU Config File: {0}", config_path);
139                        log.WriteLine("\tLoading Config: {0}", config_path);
140                        this.ConfigPath = config_path;
141                        //bool loaded = false;
142                        try
143                      {                      {
144                          using (XmlReader reader = XmlReader.Create(fs))                          using (FileStream fs = new FileStream(config_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
145                          {                          {
146                              string value = "";                              using (XmlReader reader = XmlReader.Create(fs))
147                              reader.ReadToFollowing("PLATFORMNAMESHORT");                              {
148                              value = reader.ReadElementContentAsString();                                  reader.Read();
149                              config.PlatformNameShort = (value == "") ? config.PlatformNameShort: value;                                  bool InConfigSection = false;
150                              logger.WriteLine("\t\tPLATFORMNAMESHORT={0}", config.PlatformNameShort);                                  while (!reader.EOF)
151                                    {
152                              reader.ReadToFollowing("PLATFORMNAMELONG");                                      string value = "";
153                              value = reader.ReadElementContentAsString();                                      switch (reader.Name.ToUpper())
154                              config.PlatformNameLong = (value == "") ? config.PlatformNameLong : value;                                      {
155                              logger.WriteLine("\t\tPLATFORMNAMELONG={0}", config.PlatformNameLong);                                          case "CONFIG": if (reader.IsStartElement()) { InConfigSection = true; } break;
156                                            case "PLATFORMNAMESHORT":
157                              reader.ReadToFollowing("PLATFORMIMAGE");                                              if (reader.IsStartElement())
158                              string platform_image = reader.ReadElementContentAsString();                                                                          {
159                              config.PlatformImage = (platform_image == "") ? Properties.Resources.DefaultPlatformImage : Image.FromFile(string.Format(@"{0}\{1}",rom_path,platform_image));                                                  value = reader.ReadElementContentAsString();
160                              string str_platform_image = (platform_image == "") ? "DefaultPlatformImage" : platform_image;                                                  PlatformNameShort = (value == "") ? PlatformNameShort : value;
161                              logger.WriteLine("\t\tPLATFORMIMAGE={0}", str_platform_image);                                                  log.WriteLine("\t\tPLATFORMNAMESHORT={0}", PlatformNameShort);
162                                                }
163                              reader.ReadToFollowing("EXTENSIONS");                                              break;
164                              value = reader.ReadElementContentAsString();                                          case "PLATFORMNAMELONG":
165                              config.Extenstions = (value == "") ? config.Extenstions : value;                                              if (reader.IsStartElement())
166                              logger.WriteLine("\t\tEXTENSIONS={0}", config.Extenstions);                                              {
167                                                    value = reader.ReadElementContentAsString();
168                              reader.ReadToFollowing("EMULATORPATH");                                                  PlatformNameLong = (value == "") ? PlatformNameLong : value;
169                              value = reader.ReadElementContentAsString();                                                  log.WriteLine("\t\tPLATFORMNAMELONG={0}", PlatformNameLong);
170                              config.EmuPath = (value == "") ? config.EmuPath : value;                                              }
171                              logger.WriteLine("\t\tEMULATORPATH={0}", config.EmuPath);                                              break;
172                                            case "PLATFORMIMAGE":
173                              reader.ReadToFollowing("EMULATOROPTIONS");                                              if (reader.IsStartElement())
174                              value = reader.ReadElementContentAsString();                                              {
175                              config.EmuOptions = (value == "") ? config.EmuOptions : value;                                                  string platform_image = reader.ReadElementContentAsString();
176                              logger.WriteLine("\tEMULATOROPTIONS={0}", config.EmuOptions);                                                  PlatformImage = (platform_image == "") ? null : Image.FromFile(string.Format(@"{0}\{1}", EmuRomPath, platform_image));
177                                                    string str_platform_image = (platform_image == "") ? "DefaultPlatformImage" : platform_image;
178                                                    log.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                                                    log.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                                                    log.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                                                    log.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                                                    log.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                                                    log.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                                                    log.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                                                    log.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                                                    log.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(log, 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                                                    log.WriteLine("Warning: Unknown or Unrecognized config option: {0} in {1}", reader.Name, config_path);
276                                                break;
277                                        }
278                                        reader.Read();
279                                    }
280                                }
281                          }                          }
282                            log.WriteLine("\tLoaded Config: {0}", config_path);
283                            //loaded = true;
284                        }
285                        catch (Exception ex)
286                        {
287                            log.WriteLine("\tFailed to Load Config: {0}", config_path);
288                            Console.WriteLine(ex.ToString());
289                            log.WriteLine("Error: {0}", ex.ToString());
290                            //loaded = false;
291                      }                      }
                     logger.WriteLine("\tLoaded Config: {0}", config_path);  
                     //loaded = true;  
292                  }                  }
293                  catch(Exception ex)                  else { log.WriteLine("Could not find EMU Config File: {0}", config_path); }
294    
295                    if (parent_rom != null)
296                  {                  {
297                      logger.WriteLine("\tFailed to Load Config: {0}", config_path);                      if (parent_rom.HasExternalConfigs)
298                      Console.WriteLine(ex.ToString());                      {
299                      logger.WriteLine("Error: {0}", ex.ToString());                          foreach (var rom in parent_rom.ExternalConfigs)
300                      //loaded = false;                          {
301                                if (rom.ConfigPath == config_path)
302                                {
303                                    this.PlatformNameShort = parent_rom.PlatformNameShort;
304                                    this.PlatformNameLong = parent_rom.PlatformNameLong;
305                                    break;
306                                }
307                            }
308                            
309                        }
310                  }                  }
311    
312                    return this;
313              }              }
314              else { logger.WriteLine("Could not find EMU Config File: {0}", config_path); }  
             return config;  
         }  
         #region private class EmuConfig : IEmuConfig  
         private class EmuConfig : IEmuConfig  
         {  
315              private const string Unknown_Platform = "Unknown Platform";              private const string Unknown_Platform = "Unknown Platform";
316              public EmuConfig() : this("") { }              private logger log;
317              public EmuConfig(string PlatformNameShort) : this(PlatformNameShort, PlatformNameShort) { }              public EmuConfig() : this(null, "") { }
318              public EmuConfig(string PlatformNameShort, string PlatformNameLong) : this(PlatformNameShort, PlatformNameLong, "") { }              public EmuConfig(logger log) : this(log,"") { }
319              public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage) : this(PlatformNameShort, PlatformNameLong, PlatformImage, "") { }              public EmuConfig(logger log, string PlatformNameShort) : this(log, PlatformNameShort, PlatformNameShort) { }
320              public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions) : this(PlatformNameShort, PlatformNameLong, PlatformImage, Extenstions, "") { }              public EmuConfig(logger log, string PlatformNameShort, string PlatformNameLong) : this(log, PlatformNameShort, PlatformNameLong, "") { }
321              public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions, string EmuPath) : this(PlatformNameShort, PlatformNameLong, PlatformImage, Extenstions, EmuPath, "") { }              public EmuConfig(logger log, string PlatformNameShort, string PlatformNameLong, string PlatformImage) : this(log, PlatformNameShort, PlatformNameLong, PlatformImage, "") { }
322              public EmuConfig(string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions, string EmuPath, string EmuOptions)              public EmuConfig(logger log, string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions) : this(log, PlatformNameShort, PlatformNameLong, PlatformImage, Extenstions, "") { }
323                public EmuConfig(logger log, string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions, string EmuPath) : this(log, PlatformNameShort, PlatformNameLong, PlatformImage, Extenstions, EmuPath, "") { }
324                public EmuConfig(logger log, string PlatformNameShort, string PlatformNameLong, string PlatformImage, string Extenstions, string EmuPath, string EmuOptions)
325              {              {
326                    
327                    
328    
329                  this.PlatformNameShort = PlatformNameShort;                  this.PlatformNameShort = PlatformNameShort;
330                  this.PlatformNameLong = PlatformNameLong;                  this.PlatformNameLong = PlatformNameLong;
331                  this.PlatformImage = (PlatformImage == "") ? Properties.Resources.DefaultPlatformImage : Image.FromFile(PlatformImage);                  this.PlatformImage = (PlatformImage == "") ? Properties.Resources.DefaultPlatformImage : Image.FromFile(PlatformImage);
332                  this.Extenstions = (Extenstions == "") ? "*.*" : Extenstions;                  this.Extenstions = (Extenstions == "") ? "*.*" : Extenstions;
333                  this.EmuPath = EmuPath;                  this.EmuPath = EmuPath;
334                  this.EmuOptions = EmuOptions;                  this.EmuOptions = EmuOptions;
335                    this.ExternalConfigs = new List<IEmuConfig>();
336                    this.GameTitle = "";
337                    this.GameImage = "";
338                    this.GameExe = "";
339                    this.GameExeArgs = "";
340                    this.log = log;
341              }              }
342              #region IEmuConfig members              #region IEmuConfig members
343                public bool IsFavorites { get { return false; } }
344                public string ConfigPath { get; set; }
345              private string _PlatformNameShort;              private string _PlatformNameShort;
346              public string PlatformNameShort              public string PlatformNameShort
347              {              {
# Line 118  namespace EmuXPortal.Api Line 349  namespace EmuXPortal.Api
349                  {                  {
350                      try                      try
351                      {                      {
352                          DirectoryInfo t = new DirectoryInfo(EmuRomPath);                          //if (string.IsNullOrEmpty(EmuRomPath))
353                            //{
354                            //    return "EmuRomPath null";
355                            //}
356                            DirectoryInfo t = new DirectoryInfo(EmuRomPath);                      
357                          return (_PlatformNameShort == "") ? string.Format("{0} (folder={1})", Unknown_Platform, t.Name) : _PlatformNameShort;                          return (_PlatformNameShort == "") ? string.Format("{0} (folder={1})", Unknown_Platform, t.Name) : _PlatformNameShort;
358                            
359                      }                      }
360                      catch(Exception ex)                      catch (Exception ex)
361                      {                      {
362                          logger.WriteLine("PlatformNameShort.get() Error: {0}",ex.ToString());                          log.WriteLine("PlatformNameShort.get() Error: {0}", ex.ToString());
363                          return Unknown_Platform;                          return Unknown_Platform;
364                      }                      }
365                  }                  }
# Line 141  namespace EmuXPortal.Api Line 377  namespace EmuXPortal.Api
377                      }                      }
378                      catch (Exception ex)                      catch (Exception ex)
379                      {                      {
380                          logger.WriteLine("PlatformNameLong.get() Error: {0}", ex.ToString());                          log.WriteLine("PlatformNameLong.get() Error: {0}", ex.ToString());
381                          return Unknown_Platform;                          return Unknown_Platform;
382                      }                      }
383                  }                  }
# Line 152  namespace EmuXPortal.Api Line 388  namespace EmuXPortal.Api
388              public string EmuPath { get; set; }              public string EmuPath { get; set; }
389              public string EmuOptions { get; set; }              public string EmuOptions { get; set; }
390              public string EmuRomPath { get; set; }              public string EmuRomPath { get; set; }
391              #endregion                    public bool HasExternalConfigs { get { return ExternalConfigs.Count > 0; } }
392                public List<IEmuConfig> ExternalConfigs { get; private set; }
393    
394                public string GameTitle { get; set; }
395                public string GameImage { get; set; }
396                public string GameExe { get; set; }
397                public string GameExeArgs { get; set; }
398    
399                public void ReleasePlatformImageResource()
400                {
401                    if (this.PlatformImage != null)
402                        this.PlatformImage.Dispose();
403                }
404                #endregion
405    
406                public override string ToString()
407                {
408                    return string.Format("{2} {0}{3}{1}", "{", "}", PlatformNameLong, PlatformNameShort);
409                }
410                #region IComparable Members
411    
412                public int CompareTo(IEmuConfig obj)
413                {
414                    return this.PlatformNameLong.CompareTo(obj.PlatformNameLong);
415                }
416                public void RefreshConfig(logger log)
417                {
418                    log.WriteLine("Refreshing config for: {0} from {1}", this.ToString(), string.Format(@"{0}\{1}", EmuRomPath, EMU_CONFIG));
419                    this.Create(log,EmuRomPath);
420                }
421                #endregion
422    
423                public void Dispose()
424                {
425                    if (this.PlatformImage != null)
426                        this.PlatformImage.Dispose();
427                }
428          }          }
429          #endregion          #endregion
430    

Legend:
Removed from v.22  
changed lines
  Added in v.200

  ViewVC Help
Powered by ViewVC 1.1.22