/[EmuXPortal]/branches/mono/EmuXPortal/Form1.cs
ViewVC logotype

Diff of /branches/mono/EmuXPortal/Form1.cs

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

revision 334 by william, Tue Dec 19 03:35:02 2017 UTC revision 355 by william, Tue Dec 19 20:15:02 2017 UTC
# Line 5  Line 5 
5    
6  #define DISABLE_RELEASE_MODE_KLOGLEVEL_DEBUG // when defined will turn off kLogLevel_Debug messages, in release mode  #define DISABLE_RELEASE_MODE_KLOGLEVEL_DEBUG // when defined will turn off kLogLevel_Debug messages, in release mode
7  //#define DISABLE_DEBUG_MODE_KLOGLEVEL_VERBOSE_DEBUG // when defined will turn off kLogLevel_VerboseDebug message, in debug mode  //#define DISABLE_DEBUG_MODE_KLOGLEVEL_VERBOSE_DEBUG // when defined will turn off kLogLevel_VerboseDebug message, in debug mode
8    
9  using System;  using System;
10  using System.Collections.Generic;  using System.Collections.Generic;
11  using System.ComponentModel;  using System.ComponentModel;
# Line 23  using System.IO; Line 24  using System.IO;
24  using Enterprise.CrossPlatform;  using Enterprise.CrossPlatform;
25    
26  namespace EmuXPortal  namespace EmuXPortal
27  {  {      
28      public partial class Form1 : Form      public partial class Form1 : Form
29      {      {
30                    static readonly System.Drawing.Color DEFAULT_TEXTFORECOLOR = System.Drawing.Color.Lime;
31                    static readonly System.Drawing.Color DEFAULT_TEXTFORECOLOR_ERROR = System.Drawing.Color.Yellow;
32                    static readonly System.Drawing.Color DEFAULT_TEXTFORECOLOR_LAUNCH = System.Drawing.Color.Blue;
33                    static readonly System.Drawing.Color DEFAULT_TEXTFORECOLOR_MISSING = System.Drawing.Color.Red;
34    
35    
36                    static bool bUserAbort =false;
37          static readonly Color SELECTED_CONTROL_BACKCOLOR = Color.SteelBlue;          static readonly Color SELECTED_CONTROL_BACKCOLOR = Color.SteelBlue;
38          const float PROGRESS_BAR_FONT_SIZE = 24;          const float PROGRESS_BAR_FONT_SIZE = 24;
39          private delegate Font Delegate_GetFormFont();          private delegate Font Delegate_GetFormFont();
# Line 35  namespace EmuXPortal Line 43  namespace EmuXPortal
43                  int SavedPlatformIndex= -1;                  int SavedPlatformIndex= -1;
44          GameControl CurrentGameControl = null;          GameControl CurrentGameControl = null;
45                  private CustomProgressBar progress_bar;                  private CustomProgressBar progress_bar;
46                    private IPlatformCache cache = null;
47    
48                    static bool OnAbort()
49            {
50                return bUserAbort;
51            }
52          #region unhandled exception support          #region unhandled exception support
53          static void Application_Unhandled_ThreadException(object sender, ThreadExceptionEventArgs e)          static void Application_Unhandled_ThreadException(object sender, ThreadExceptionEventArgs e)
54          {          {
# Line 108  namespace EmuXPortal Line 121  namespace EmuXPortal
121    
122              platform_flow.Dock = DockStyle.Fill;              platform_flow.Dock = DockStyle.Fill;
123              rom_flow.Dock = DockStyle.Fill;              rom_flow.Dock = DockStyle.Fill;
124    
125    //            this.PreviewKeyDown += Form1_PreviewKeyDown;
126    //            this.KeyPreview = true;
127                            //progress_bar.PreviewKeyDown += Progress_bar_PreviewKeyDown;
128                            this.KeyDown += Form1_KeyDown;
129                            
130            }
131    
132            void Form1_KeyDown (object sender, KeyEventArgs e)
133                    {
134                            if (e.KeyCode == Keys.Back || e.KeyCode == Keys.Escape) {                              
135                                    bAbortRomCopyToLocalCache = true; // this will cancel any copy operations
136                            }
137          }          }
138    
139                
# Line 124  namespace EmuXPortal Line 150  namespace EmuXPortal
150          }          }
151  #endregion  #endregion
152    
153                    private bool bCachedLoaded = false;
154                    private bool OnCacheLoaded() {
155                            return bCachedLoaded;
156                    }
157    
158          private void Form1_Load(object sender, EventArgs e)          private void Form1_Load(object sender, EventArgs e)
159          {          {
160              Config.LoadConfig();  
161                            SplashLoader loader = new SplashLoader(new AbortEvent(OnCacheLoaded));
162                            loader.Show();
163                            cache = PlatformCache.Create (new AbortEvent (OnAbort));
164                Config.LoadConfig(cache);
165              Config.InitializePresentationForm(this);              Config.InitializePresentationForm(this);
166                            bCachedLoaded = true;
167    
168          }          }
169          private void Form1_Shown(object sender, EventArgs e)          private void Form1_Shown(object sender, EventArgs e)
170          {          {
# Line 137  namespace EmuXPortal Line 174  namespace EmuXPortal
174  #else  #else
175              Cursor.Show();              Cursor.Show();
176  #endif  #endif
177                            
178          }          }
179                    private bool bAbortRomCopyToLocalCache = false;
180            private bool OnAbortRomCopyToLocalCache ()
181                    {
182                            return bAbortRomCopyToLocalCache;
183                    }
184    
185                    private void DeleteRomFromLocalCache (string rom_file, string rom_image)
186                    {                      
187                            progress_bar.Font = ResizeFont (GetFormFont (), PROGRESS_BAR_FONT_SIZE);
188                            #if DISABLE_PROGRESS_PERCENTAGE_MESSASGE
189                                    progress_bar.ShowPercentageLabel = false;
190                            #endif
191                            progress_bar.ProgressColor = Color.LimeGreen;
192                            progress_bar.Dock = DockStyle.Top;
193                            if (this.InvokeRequired) {
194                                    this.Invoke ((MethodInvoker)delegate() {
195                                            this.Controls.Add (progress_bar);
196                                    });
197                            } else {
198                                    this.Controls.Add (progress_bar);
199                            }
200                            progress_bar.Invoke (new MethodInvoker (delegate {
201                                    progress_bar.Margin = new System.Windows.Forms.Padding (0);
202                                    progress_bar.Size = new Size (GetFormWidth () - 25, 100);
203                            }));
204                            Application.DoEvents ();
205                            if (!string.IsNullOrEmpty (rom_image)) {
206                                    if (rom_image.ToLower ().Contains (Config.RomPath.ToLower ())) {
207                                            gLog.Warn.WriteLine("Not deleteing rom image in path: {0}", rom_image);
208                                            return;
209                                    }
210                                    progress_bar.Message = string.Format("Deleting local rom image: {0}", EmuXPortal.Api.Win32.CompactPath(rom_image));
211                                    File.Delete(rom_image);
212                                    progress_bar.Value = 50;
213    
214                            }
215                            if (!string.IsNullOrEmpty (rom_file)) {
216                                    if (rom_image.ToLower ().Contains (Config.RomPath.ToLower ())) {
217                                            gLog.Warn.WriteLine("Not deleteing rom file in path: {0}", rom_file);
218                                            return;
219                                    }
220                                    progress_bar.Message = string.Format("Deleting local rom file: {0}", EmuXPortal.Api.Win32.CompactPath(rom_file));
221                                    File.Delete(rom_file);
222                                    progress_bar.Value = 100;
223                            }
224                            if (this.InvokeRequired) {
225                                    this.Invoke ((MethodInvoker)delegate() {
226                                            this.Controls.Remove (progress_bar);
227                                    });
228                            } else {
229                                    this.Controls.Remove (progress_bar);
230                            }
231                            Application.DoEvents ();
232                    }
233            private void CopyRomToLocalCache (string src_rom_file, string dst_rom_file, string src_rom_image, string dst_rom_image)
234                    {
235                            bAbortRomCopyToLocalCache = false; // reset the copy abort flag
236                            progress_bar.Font = ResizeFont (GetFormFont (), PROGRESS_BAR_FONT_SIZE);
237                            #if DISABLE_PROGRESS_PERCENTAGE_MESSASGE
238                                    progress_bar.ShowPercentageLabel = false;
239                            #endif
240                            progress_bar.ProgressColor = Color.LimeGreen;
241                            progress_bar.Dock = DockStyle.Top;
242                            if (this.InvokeRequired) {
243                                    this.Invoke ((MethodInvoker)delegate() {
244                                            this.Controls.Add (progress_bar);
245                                    });
246                            } else {
247                                    this.Controls.Add (progress_bar);
248                            }
249                            progress_bar.Invoke (new MethodInvoker (delegate {
250                                    progress_bar.Margin = new System.Windows.Forms.Padding (0);
251                                    progress_bar.Size = new Size (GetFormWidth () - 25, 100);
252                            }));
253                            Application.DoEvents ();
254                            FileProgressCopier cp = null;
255                            if (!string.IsNullOrEmpty (src_rom_image) && !string.IsNullOrEmpty (dst_rom_image)) {
256                                    bAbortRomCopyToLocalCache = false;
257                                    cp = new FileProgressCopier (src_rom_image, dst_rom_image, new CopyProgressEvent (OnFileCopyProgress), new AbortEvent (OnAbortRomCopyToLocalCache));
258                                    cp.Start ();
259                                    while (!cp.CopyFinished) {
260                                            Application.DoEvents();
261                                    }
262                            }
263                            if (!string.IsNullOrEmpty (src_rom_file) && !string.IsNullOrEmpty (dst_rom_file)) {
264                                    bAbortRomCopyToLocalCache = false;
265                                    cp = new FileProgressCopier (src_rom_file, dst_rom_file, new CopyProgressEvent (OnFileCopyProgress), new AbortEvent (OnAbortRomCopyToLocalCache));
266                                    cp.Start ();
267                                    while (!cp.CopyFinished) {
268                                            Application.DoEvents();
269                                    }
270                            }
271                            if (this.InvokeRequired) {
272                                    this.Invoke ((MethodInvoker)delegate() {
273                                            this.Controls.Remove (progress_bar);
274                                    });
275                            } else {
276                                    this.Controls.Remove (progress_bar);
277                            }
278                            Application.DoEvents ();
279            }
280                    public void OnFileCopyProgress (object sender, int progress, string message)
281                    {
282                            //gLog.Debug.WriteLine("{0} [{1}%]", message, progress);
283    
284                            if (progress_bar.InvokeRequired) {
285                                            progress_bar.Invoke (new MethodInvoker (delegate {
286                                                    progress_bar.Message = message;
287                                                    progress_bar.Value = progress;
288                                                    progress_bar.Update ();
289                                                    Application.DoEvents();
290                                            }));
291                                    } else {
292                                            progress_bar.Message = message;
293                                            progress_bar.Value = progress;
294                                            progress_bar.Update ();
295                                            Application.DoEvents();
296                                    }
297                    }
298          void ReleasePlatformControlStreams ()          void ReleasePlatformControlStreams ()
299                  {                  {
300                          foreach (var c in platform_flow.Controls) {                          foreach (var c in platform_flow.Controls) {
# Line 182  namespace EmuXPortal Line 338  namespace EmuXPortal
338                                  CurrentPlatformControl = c;                                  CurrentPlatformControl = c;
339                          }                          }
340          }          }
341          void game_ctrl_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)  
342          {          void game_ctrl_PreviewKeyDown (object sender, PreviewKeyDownEventArgs e)
343                    {
344                          //gLog.Verbose.Debug.WriteLine ("game_ctrl_PreviewKeyDown() fired -- keycode [{0}]", e.KeyCode);                          //gLog.Verbose.Debug.WriteLine ("game_ctrl_PreviewKeyDown() fired -- keycode [{0}]", e.KeyCode);
345              GameControl c = sender as GameControl;                          GameControl c = sender as GameControl;
346    
347              int changeAmount = 0;                          int changeAmount = 0;
348              int currentPosition = 0;                          int currentPosition = 0;
349              if (e.KeyCode == Keys.F && (e.Modifiers & Keys.Control) == Keys.Control)                          IRomConfig config = null;
350              {                          if (e.KeyCode == Keys.C && (e.Modifiers & Keys.Control) == Keys.Control) {                              
351                  IRomConfig config = c.Tag as IRomConfig;                                  config = (c.Tag as IRomConfig);
352                  if (config == null)                                  if (config != null) {
353                  {                                          string platform_short = config.EmuConfig.PlatformNameShort;
354                      gLog.Error.WriteLine("Unable to add/remove from/to favorites (config is null): {0} [{1}]", config.RomTitle, config.RomFile);                                          string rom_file = config.RomFile;
355                  }                                          string rom_image = config.RomImage;
356                  else  
357                  {                                          string rom_filename = "";
358                      var isFavorite = RomFavorite.IsFavorite(config);                                          string rom_imagefilename = "";
359                      if (isFavorite)                                          FileInfo fi = null;
360                      {                                          try {
361                          // add to favorites                                                  fi = new FileInfo (rom_file);
362                          //gLog.Debug.WriteLine("Removing from favorites: {0} [{1}]", config.RomTitle, config.RomFile);                                                  rom_filename = fi.Name;
363                          if (!RomFavorite.RemoveFavorite(config))                                          } finally {
364                          {                                                  fi = null;
365                              gLog.Error.WriteLine("Failed to remove from favorites: {0} [{1}]", config.RomTitle, config.RomFile);                                          }
366                          }                                          try {
367                          else                                                  fi = new FileInfo (rom_image);
368                          {                                                  rom_imagefilename = fi.Name;
369                              gLog.Info.WriteLine("Removed from favorites: {0} [{1}]", config.RomTitle, config.RomFile);                                          } finally {
370                              if (config.Config.PlatformNameShort == "Favorites")                                                  fi = null;
371                              {                                          }
                                 var parent = c.Parent;  
                                 if (parent != null)  
                                 {  
                                     parent.Controls.Remove(c);  
                                     if (parent.Controls.Count > 0)  
                                     {  
                                         var next_ctrl = parent.Controls[0];  
                                         if (next_ctrl != null)  
                                         {  
                                             next_ctrl.Select();  
                                         }  
                                     }  
                                 }  
                             }                        
                         }  
                     }  
                     else  
                     {  
                         // add to favorites  
                         //gLog.Debug.WriteLine("Adding to favorites: {0} [{1}]", config.RomTitle, config.RomFile);  
                         if (!RomFavorite.AddFavorite(config))  
                         {  
                             gLog.Error.WriteLine("Failed to add to favorites: {0} [{1}]", config.RomTitle, config.RomFile);  
                         }  
                         else  
                         {  
                             gLog.Info.WriteLine("Added to favorites: {0} [{1}]", config.RomTitle, config.RomFile);  
                         }  
                     }  
                     //gLog.Debug.WriteLine("Updateing favorites");  
                     if (!RomFavorite.UpdateFavorites())  
                     {  
                         gLog.Error.WriteLine("Failed to update favorites");  
                     }  
                     else  
                     {  
                         gLog.Info.WriteLine("Updated favorites");  
                     }  
                 }  
                 return; // stop processing other keys  
372    
373              }                                          string local_path = Config.LocalRomPath.TrimEnd (new char[]{ '/' });
374                                            string local_rom_path = string.Format ("{0}/{1}", local_path, platform_short);
375                                            string local_romfile = OSInfo.FormatPath (string.Format ("{0}/{1}", local_rom_path, rom_filename));
376                                            string local_romimage = OSInfo.FormatPath (string.Format ("{0}/{1}", local_rom_path, rom_imagefilename));
377    
378                                            // create the local rom path for this platform
379                                            DirectoryInfo di = new DirectoryInfo (local_rom_path);
380                                            if (!di.Exists) {
381                                                    di.Create ();
382                                            }
383                                            this.Enabled = false;
384                                            CopyRomToLocalCache (rom_file, local_romfile, rom_image, local_romimage);
385                                            this.Enabled = true;
386                                    }
387                            }
388                            if (e.KeyCode == Keys.D && (e.Modifiers & Keys.Control) == Keys.Control) {                                                              
389                                    config = (c.Tag as IRomConfig);
390                                    if (config != null) {
391                                            string platform_short = config.EmuConfig.PlatformNameShort;
392                                            string rom_file = config.RomFile;
393                                            string rom_image = config.RomImage;
394    
395                                            string rom_filename = "";
396                                            string rom_imagefilename = "";
397                                            FileInfo fi = null;
398                                            try {
399                                                    fi = new FileInfo (rom_file);
400                                                    rom_filename = fi.Name;
401                                            } finally {
402                                                    fi = null;
403                                            }
404                                            try {
405                                                    fi = new FileInfo (rom_image);
406                                                    rom_imagefilename = fi.Name;
407                                            } finally {
408                                                    fi = null;
409                                            }
410                                            string local_path = Config.LocalRomPath.TrimEnd (new char[]{ '/' });
411                                            string local_rom_path = string.Format ("{0}/{1}", local_path, platform_short);
412                                            string local_romfile = OSInfo.FormatPath (string.Format ("{0}/{1}", local_rom_path, rom_filename));
413                                            string local_romimage = OSInfo.FormatPath (string.Format ("{0}/{1}", local_rom_path, rom_imagefilename));
414                                            this.Enabled = false;
415                                            DeleteRomFromLocalCache (local_romfile, local_romimage);
416                                            this.Enabled = true;
417                                    }
418                            }
419                            if (e.KeyCode == Keys.F && (e.Modifiers & Keys.Control) == Keys.Control) {
420                                    config = c.Tag as IRomConfig;
421                                    if (config == null) {
422                                            gLog.Error.WriteLine ("Unable to add/remove from/to favorites (config) is null");
423                                    } else {
424                                            var isFavorite = RomFavorite.IsFavorite (config);
425                                            if (isFavorite) {
426                                                    // add to favorites
427                                                    //gLog.Debug.WriteLine("Removing from favorites: {0} [{1}]", config.RomTitle, config.RomFile);
428                                                    if (!RomFavorite.RemoveFavorite (config)) {
429                                                            gLog.Error.WriteLine ("Failed to remove from favorites: {0} [{1}]", config.RomTitle, config.RomFile);
430                                                    } else {
431                                                            gLog.Info.WriteLine ("Removed from favorites: {0} [{1}]", config.RomTitle, config.RomFile);
432                                                            if (config.EmuConfig.PlatformNameShort == "Favorites") {
433                                                                    var parent = c.Parent;
434                                                                    if (parent != null) {
435                                                                            parent.Controls.Remove (c);
436                                                                            if (parent.Controls.Count > 0) {
437                                                                                    var next_ctrl = parent.Controls [0];
438                                                                                    if (next_ctrl != null) {
439                                                                                            next_ctrl.Select ();
440                                                                                    }
441                                                                            }
442                                                                    }
443                                                            }                      
444                                                    }
445                                            } else {
446                                                    // add to favorites
447                                                    //gLog.Debug.WriteLine("Adding to favorites: {0} [{1}]", config.RomTitle, config.RomFile);
448                                                    if (!RomFavorite.AddFavorite (config)) {
449                                                            gLog.Error.WriteLine ("Failed to add to favorites: {0} [{1}]", config.RomTitle, config.RomFile);
450                                                    } else {
451                                                            gLog.Info.WriteLine ("Added to favorites: {0} [{1}]", config.RomTitle, config.RomFile);
452                                                    }
453                                            }
454                                            //gLog.Debug.WriteLine("Updateing favorites");
455                                            if (!RomFavorite.UpdateFavorites (cache)) {
456                                                    gLog.Error.WriteLine ("Failed to update favorites");
457                                            } else {
458                                                    gLog.Info.WriteLine ("Updated favorites");
459                                            }
460                                    }
461                                    return; // stop processing other keys
462    
463                            }
464                          if (e.KeyCode == Keys.Up || e.KeyCode == Keys.Left) {                          if (e.KeyCode == Keys.Up || e.KeyCode == Keys.Left) {
465                                  if (OSInfo.OSIsUnix) {                                  if (OSInfo.OSIsUnix) {
466                                          rom_flow.SuspendLayout ();                                          rom_flow.SuspendLayout ();
# Line 270  namespace EmuXPortal Line 477  namespace EmuXPortal
477                                          rom_flow.ResumeLayout (false);                                          rom_flow.ResumeLayout (false);
478                                  }                                  }
479                          }                                        }              
480              if (e.KeyCode == Keys.Home)                          if (e.KeyCode == Keys.Home) {
481              {                                  rom_flow.SuspendLayout ();
482                  rom_flow.SuspendLayout();                                  rom_flow.Controls [0].Select ();
483                  rom_flow.Controls[0].Select();                                  rom_flow.ScrollControlIntoView (rom_flow.Controls [0]);
484                  rom_flow.ScrollControlIntoView(rom_flow.Controls[0]);                                  rom_flow.ResumeLayout (false);
485                  rom_flow.ResumeLayout(false);                          }
486              }                          if (e.KeyCode == Keys.End) {
487              if (e.KeyCode == Keys.End)                                  rom_flow.SuspendLayout ();
488              {                                  rom_flow.Controls [rom_flow.Controls.Count - 1].Select ();
489                  rom_flow.SuspendLayout();                                  rom_flow.ScrollControlIntoView (rom_flow.Controls [rom_flow.Controls.Count - 1]);
490                  rom_flow.Controls[rom_flow.Controls.Count - 1].Select();                                  rom_flow.ResumeLayout (false);
491                  rom_flow.ScrollControlIntoView(rom_flow.Controls[rom_flow.Controls.Count - 1]);                          }
492                  rom_flow.ResumeLayout(false);                          if (e.KeyCode == Keys.PageUp) {
493              }                                  rom_flow.SuspendLayout ();
494              if (e.KeyCode == Keys.PageUp)                                  changeAmount = rom_flow.VerticalScroll.LargeChange;
495              {                                  currentPosition = rom_flow.VerticalScroll.Value;
496                  rom_flow.SuspendLayout();                                  if ((currentPosition - changeAmount) > rom_flow.VerticalScroll.Minimum) {
497                  changeAmount = rom_flow.VerticalScroll.LargeChange;                                          try {
498                  currentPosition = rom_flow.VerticalScroll.Value;                                                  rom_flow.VerticalScroll.Value -= changeAmount;
499                  if ((currentPosition - changeAmount) > rom_flow.VerticalScroll.Minimum)                                          } catch {
500                  {                                                  rom_flow.Controls [0].Select ();
501                      try                                                  rom_flow.ScrollControlIntoView (rom_flow.Controls [0]);
502                      {                                                  rom_flow.PerformLayout ();
503                          rom_flow.VerticalScroll.Value -= changeAmount;                                                  return;
504                      }                                          }
505                      catch                                  } else {
506                      {                                          rom_flow.Controls [0].Select ();
507                          rom_flow.Controls[0].Select();                                          rom_flow.ScrollControlIntoView (rom_flow.Controls [0]);
508                          rom_flow.ScrollControlIntoView(rom_flow.Controls[0]);                                  }
509                          rom_flow.PerformLayout();                                  GameControl s = game_ctrl_get_last_visible ();
510                          return;                                  s.Select ();
511                      }                                  rom_flow.ScrollControlIntoView (s);
512                  }                                  rom_flow.ResumeLayout (false);
513                  else                          }
514                  {                          if (e.KeyCode == Keys.PageDown) {
515                      rom_flow.Controls[0].Select();                                  rom_flow.SuspendLayout ();
516                      rom_flow.ScrollControlIntoView(rom_flow.Controls[0]);                                  changeAmount = rom_flow.VerticalScroll.LargeChange;
517                  }                                  currentPosition = rom_flow.VerticalScroll.Value;
518                  GameControl s = game_ctrl_get_last_visible();                                  if ((currentPosition - changeAmount) < rom_flow.VerticalScroll.Maximum) {
519                  s.Select();                                          try {
520                  rom_flow.ScrollControlIntoView(s);                                                  rom_flow.VerticalScroll.Value += changeAmount;
521                  rom_flow.ResumeLayout(false);                                          } catch {
522              }                                                  rom_flow.Controls [0].Select ();
523              if (e.KeyCode == Keys.PageDown)                                                  rom_flow.ScrollControlIntoView (rom_flow.Controls [0]);
524              {                                                  rom_flow.PerformLayout ();
525                  rom_flow.SuspendLayout();                                                  return;
526                  changeAmount = rom_flow.VerticalScroll.LargeChange;                                          }
527                  currentPosition = rom_flow.VerticalScroll.Value;                                  } else {
528                  if ((currentPosition - changeAmount) < rom_flow.VerticalScroll.Maximum)                                          rom_flow.VerticalScroll.Value = rom_flow.VerticalScroll.Maximum;
529                  {                                  }
530                      try                                  GameControl s = game_ctrl_get_last_visible ();
531                      {                                  s.Select ();
532                          rom_flow.VerticalScroll.Value += changeAmount;                                  rom_flow.ScrollControlIntoView (s);
533                      }                                  rom_flow.ResumeLayout (false);
534                      catch                          }
                     {  
                         rom_flow.Controls[0].Select();  
                         rom_flow.ScrollControlIntoView(rom_flow.Controls[0]);  
                         rom_flow.PerformLayout();  
                         return;  
                     }  
                 }  
                 else  
                 {  
                     rom_flow.VerticalScroll.Value = rom_flow.VerticalScroll.Maximum;  
                 }  
                 GameControl s = game_ctrl_get_last_visible();  
                 s.Select();  
                 rom_flow.ScrollControlIntoView(s);  
                 rom_flow.ResumeLayout(false);  
             }  
   
             if (e.KeyCode == Keys.Enter)  
             {  
                                 ReleaseGameControlStreams();  
                 IRomConfig config = c.Tag as IRomConfig;  
   
                 Process p = new Process();  
   
                 p.StartInfo.FileName = config.Config.GameExe == "" ? config.Config.EmuPath : config.Config.GameExe;  
                 p.StartInfo.Arguments = config.Config.GameExeArgs == "" ? EmuConfigLoader.GetEMUOptions(config) : config.Config.GameExeArgs;  
535    
536                                  //gLog.Verbose.Debug.WriteLine ("Emulator: {0}", p.StartInfo.FileName);                          if (e.KeyCode == Keys.Enter) {                          
537                                  //gLog.Verbose.Debug.WriteLine ("Args: {0}", p.StartInfo.Arguments);                                  config = c.Tag as IRomConfig;
538                  p.Start();                                  if (config.RomExists) {
539                                            c.TextForeColor = DEFAULT_TEXTFORECOLOR_LAUNCH;
540                  // minimize EmuXPortal                                          string gamename = c.GameName;
541                  this.WindowState = FormWindowState.Minimized;                                          c.GameName = string.Format ("{0} (Loading...)", gamename);
542                  // wait for exit of game                                          bool game_launched = true;
543                  p.WaitForExit();                                          using (Process p = new Process ()) {
544                  // maximize EmuXPortal                                                  string binary = "";
545                  this.WindowState = FormWindowState.Maximized;                                                  string arguments = "";
546                                                    if (!string.IsNullOrEmpty (config.EmuConfig.EmuBinaryPath)) {
547                                                            binary = config.EmuConfig.EmuBinaryPath;
548                                                            arguments = EmuConfigLoader.GetEMUOptions (config);
549                                                    }
550                                                    if (!string.IsNullOrEmpty (config.EmuConfig.GameExe)) {
551                                                            binary = config.EmuConfig.GameExe;
552                                                            arguments = config.EmuConfig.GameExeArgs;
553                                                    }
554                                                    if (string.IsNullOrEmpty (binary)) {
555                                                            gLog.Warn.WriteLine ("Cannot launch this rom file -- missing arguments");
556                                                            game_launched = false;
557                                                    } else {
558                                                            p.StartInfo.FileName = binary;
559                                                            p.StartInfo.Arguments = arguments == null ? "" : arguments;
560                                                            p.Start ();
561                                                            // wait for exit of game
562                                                            p.WaitForExit ();
563                                                            c.TextForeColor = DEFAULT_TEXTFORECOLOR;
564                                                            c.GameName = gamename;
565                                                    }
566                                            }
567                                            if (!game_launched) {
568                                                    c.TextForeColor = DEFAULT_TEXTFORECOLOR_ERROR;
569                                                    c.GameName = string.Format ("{0} (Error While Loading...)", gamename);
570                                            }
571                                    } else {
572                                            c.TextForeColor = Color.Red;
573                                    }
574              }              }
575                          if (e.KeyCode == Keys.Back || e.KeyCode == Keys.Escape)                          if (e.KeyCode == Keys.Back || e.KeyCode == Keys.Escape)
576              {                                        {          
577                            
578                    bAbortRomCopyToLocalCache = true; // this will cancel any copy operations
579                                  ReleaseGameControlStreams();                                  ReleaseGameControlStreams();
580                                  SavedPlatformIndex = platform_flow.Controls.IndexOf (CurrentPlatformControl);                                  SavedPlatformIndex = platform_flow.Controls.IndexOf (CurrentPlatformControl);
581                  rom_flow.Visible = false;                  rom_flow.Visible = false;
# Line 503  namespace EmuXPortal Line 714  namespace EmuXPortal
714              }              }
715                          if (e.KeyCode == Keys.Back || e.KeyCode == Keys.Escape)                          if (e.KeyCode == Keys.Back || e.KeyCode == Keys.Escape)
716              {              {
717                    bAbortRomCopyToLocalCache = true;
718                                  ReleasePlatformControlStreams();                                  ReleasePlatformControlStreams();
719                  this.Close();                  this.Close();
720              }              }
# Line 747  namespace EmuXPortal Line 959  namespace EmuXPortal
959                  private void worker_progress_event (object event_source, ProgressEventArgs event_args)                  private void worker_progress_event (object event_source, ProgressEventArgs event_args)
960                  {                  {
961                          //gLog.Debug.WriteLine ("worker_progress_event called!");                          //gLog.Debug.WriteLine ("worker_progress_event called!");
   
962                          object user_object = event_args.GetUserObject ();                          object user_object = event_args.GetUserObject ();
963                          int progress = event_args.GetProgress();                          int progress = event_args.GetProgress();
964                          string message = event_args.GetUserMessage() == null ? "" : event_args.GetUserMessage();                          string message = event_args.GetUserMessage() == null ? "" : event_args.GetUserMessage();
# Line 797  namespace EmuXPortal Line 1008  namespace EmuXPortal
1008                          }));                          }));
1009    
1010                          HashSet<IRomConfig> roms = new HashSet<IRomConfig> ();                          HashSet<IRomConfig> roms = new HashSet<IRomConfig> ();
1011                          using (RomParser parser = new RomParser (CurrentSelectedRom, new ProgressEvent (worker_progress_event))) {                                                        using (RomParser parser = new RomParser (cache, CurrentSelectedRom, new ProgressEvent (worker_progress_event))) {                              
1012                                  foreach (var rom in parser.Roms) {                                  foreach (var rom in parser.Roms) {
1013                                          roms.Add(rom);                                          roms.Add (rom);
1014                                  }                                  }
1015                          }                          }
1016    
# Line 812  namespace EmuXPortal Line 1023  namespace EmuXPortal
1023                          }                          }
1024    
1025    
1026                          foreach (IRomConfig config in roms)                          foreach (IRomConfig config in roms) {
1027              {                                  progress_bar.Invoke (new MethodInvoker (delegate {
1028                  progress_bar.Invoke(new MethodInvoker(delegate { progress_bar.Value = (int)(100.0 * (count / total_count)); }));                                          progress_bar.Value = (int)(100.0 * (count / total_count));
1029                  GameControl game_ctrl = new GameControl();                                  }));
1030                  game_ctrl.Font = GetFormFont();                                  GameControl game_ctrl = new GameControl ();
1031                  game_ctrl.Dock = DockStyle.Top;                                  game_ctrl.Font = GetFormFont ();
1032                  game_ctrl.Width = this.Width - 10;                                  game_ctrl.Dock = DockStyle.Top;
1033                  game_ctrl.Tag = config;                                  game_ctrl.Width = this.Width - 10;
1034                  try                                  game_ctrl.Tag = config;
1035                  {                                  try {
1036                      lock (gameimage_lock)                                          lock (gameimage_lock) {
                     {  
1037                                                  //gLog.Debug.WriteLine ("handling rom: {0}", config.ToString ());                                                  //gLog.Debug.WriteLine ("handling rom: {0}", config.ToString ());
1038                                                  if(String.IsNullOrEmpty(config.RomImage)) {                                                  if (String.IsNullOrEmpty (config.RomImage)) {
1039                                                          game_ctrl.UpdateGameImage((Image)DefaultGameImage.Clone ());                                                          game_ctrl.UpdateGameImage ((Image)DefaultGameImage.Clone ());
1040                                                  }                                                  } else {
1041                                                  else {                                                          string path = config.isCachedLocally ? config.GetLocalRomImageOverride() : config.GetFullRomImage ();
1042                                                          string path = config.GetFullRomImage();                                                          if (File.Exists (path)) {
1043                                                          gLog.Debug.WriteLine("game_ctrl.ControlID = {0}", game_ctrl.ControlID);                                                                  game_ctrl.UpdateGameImage (path);
1044                                                          game_ctrl.UpdateGameImage(path);                                                          } else {
1045                                                                    game_ctrl.UpdateGameImage ((Image)DefaultGameImage.Clone ());
1046                                                            }
1047                                                  }                                                  }
1048                      }                                          }
1049                  }                                  } catch (Exception ex) {
                 catch (Exception ex)  
                 {  
1050                                          gLog.Error.WriteLine (ex.Message);                                          gLog.Error.WriteLine (ex.Message);
1051                                          gLog.Verbose.Error.WriteLine (ex.ToString());                                          gLog.Verbose.Error.WriteLine (ex.ToString ());
1052                      throw ex;                                          throw ex;
1053                  }                                  }
1054                  if (CurrentSelectedRom.PlatformNameShort == "Favorites")                                  if (CurrentSelectedRom.PlatformNameShort == "Favorites") {
1055                  {                                          //game_ctrl.GameName = config.RomTitle;
1056                      //game_ctrl.GameName = config.RomTitle;                                          var favorite = RomFavorite.GetFavoriteInfoFromRom (config);
1057                      game_ctrl.GameName = RomFavorite.GetRomTitleFromConfig(config);                                          game_ctrl.GameName = favorite.RomConfig.RomExists ? favorite.RomConfig.RomTitle : string.Format ("{0} - (unavailable)", favorite.RomConfig.RomTitle);
1058                                            //RomFavorite.GetRomTitleFromConfig(config);
1059                                            if (!favorite.RomConfig.RomExists) {
1060                                                    game_ctrl.TextForeColor = DEFAULT_TEXTFORECOLOR_MISSING;
1061                                            } else {
1062                                                    game_ctrl.TextForeColor = DEFAULT_TEXTFORECOLOR;
1063                                            }
1064                  }                  }
1065                  else                  else
1066                  {                  {
1067                      game_ctrl.GameName = config.RomTitle;                                          game_ctrl.GameName = config.RomExists ? config.RomTitle : string.Format("{0} - (unavailable)", config.RomTitle);
1068                                            if (!config.RomExists) {
1069                                                    game_ctrl.TextForeColor = DEFAULT_TEXTFORECOLOR_MISSING;
1070                                            } else {
1071                                                    game_ctrl.TextForeColor = DEFAULT_TEXTFORECOLOR;
1072                                            }
1073                  }                        }      
1074                  game_ctrl.PreviewKeyDown += new PreviewKeyDownEventHandler(game_ctrl_PreviewKeyDown);                  game_ctrl.PreviewKeyDown += new PreviewKeyDownEventHandler(game_ctrl_PreviewKeyDown);
1075                  game_ctrl.GotFocus += new EventHandler(game_ctrl_GotFocus);                  game_ctrl.GotFocus += new EventHandler(game_ctrl_GotFocus);
# Line 922  namespace EmuXPortal Line 1143  namespace EmuXPortal
1143                          }));                          }));
1144    
1145                          HashSet<IEmuConfig> platforms = new HashSet<IEmuConfig>();                          HashSet<IEmuConfig> platforms = new HashSet<IEmuConfig>();
1146                          using (PlatformParser parser = new PlatformParser (Config.RomPath, new ProgressEvent (worker_progress_event))) {                          using (PlatformParser parser = new PlatformParser (cache, Config.LocalRomPath, Config.RomPath, new ProgressEvent (worker_progress_event))) {
1147                                  foreach (var platform in parser.Platforms) {                                  foreach (var platform in parser.Platforms) {
1148                                          platforms.Add(platform);                                          platforms.Add(platform);
1149                                  }                                  }
# Line 954  namespace EmuXPortal Line 1175  namespace EmuXPortal
1175                                                  }                                                  }
1176                                                  else {                                                  else {
1177                                                          string path = config.GetFullPlatformImage();                                                          string path = config.GetFullPlatformImage();
1178                                                          gLog.Debug.WriteLine("platform_ctrl.ControlID = {0}", platform_ctrl.ControlID);                                                          if(File.Exists(path)) {
1179                                                          platform_ctrl.UpdatePlatformImage(path);                                                                  platform_ctrl.UpdatePlatformImage(path);
1180                                                            }
1181                                                            else {
1182                                                                    platform_ctrl.UpdatePlatformImage((Image)DefaultPlatformImage.Clone ());
1183                                                            }
1184                                                  }                                                  }
1185                                          }                                          }
1186                                  } catch (Exception ex) {                                  } catch (Exception ex) {

Legend:
Removed from v.334  
changed lines
  Added in v.355

  ViewVC Help
Powered by ViewVC 1.1.22