ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/EmuXPortal/branches/mono/EmuXPortal/Form1.cs
(Generate patch)

Comparing branches/mono/EmuXPortal/Form1.cs (file contents):
Revision 611 by william, Fri Apr 22 01:21:20 2022 UTC vs.
Revision 612 by william, Fri Apr 22 21:30:03 2022 UTC

# Line 1 | Line 1
1 < //#define DEV_DEBUG
2 <
3 < #if DEV_DEBUG
4 < #define USE_WINDOWED_MODE // when defined will use windowed mode instead of fullscreen
1 > //#define DEV_DEBUG
2 >
3 >
4 > #if DEV_DEBUG
5 > #define FORCE_CACHE_REBULD // when defined will force rebuilding of cache
6   #endif
7 < //#define DISABLE_PLUGINS // when defined plugin loading an their use will be disabled
8 <
9 < //#define HAVE_X11_BORDERSTYLE_ERROR // indicates that there is an error with Control.set_InternalBorderStyle resulting in an X11 Error BadWindow (invalid Window parameter)
10 <
11 < //#define DISABLE_WORKER_PROGRESS_EVENT // when defined will disable worker progress events
12 < //#define DISAGLE_LOAD_SPLASH // when defined will not display a splash at loading (e.g. during cache building)
7 > //#define DISABLE_PLUGINS // when defined plugin loading an their use will be disabled
8 >
9 > //#define HAVE_X11_BORDERSTYLE_ERROR // indicates that there is an error with Control.set_InternalBorderStyle resulting in an X11 Error BadWindow (invalid Window parameter)
10 >
11 > //#define DISABLE_WORKER_PROGRESS_EVENT // when defined will disable worker progress events
12 > //#define DISABLE_SPLASH // when defined will not show a splash (e.g. during cache building)
13  
14   //#define DISABLE_CURSOR_HIDE // when this is present, the cursor will not be hidden
15   //#define DISABLE_PROGRESS_PERCENTAGE_MESSASGE // when this is present, no progress percent message will be shown on any progressbar
16  
17 <
17 >
18   #if DEV_DEBUG
19   #warning DEV_DEBUG is enabled
20   #endif
# Line 49 | Line 50 | namespace EmuXPortal {
50                  //const string irexec = "/usr/bin/irexec";
51                  const string irexec = "irexec";
52                  const string irexec_lircrc = "emuxportal.lircrc";
52                static int irexec_pid = 0;
53  
54                  Thread irexec_thread_monitor = null;
55  
# Line 57 | Line 57 | namespace EmuXPortal {
57  
58                  private const int WINDOW_MODE_WIDTH = 900;
59                  private const int WINDOW_MODE_HEIGHT = 500;
60 <                private const int INPUT_POLLING_FREQUENCY = 100;
61 <                
62 <
63 <                private bool bRebuildCache = false;
60 >                private const int INPUT_POLLING_FREQUENCY = 100;
61 >
62 >
63 > #if DEV_DEBUG && FORCE_CACHE_REBULD
64 >                private const bool bRebuildCache = false;
65 > #else
66 >                private bool bRebuildCache = false;
67 > #endif
68 >
69                  private CustomProgressBar progress_bar;
70                  private IPlatformCache cache = null;
71                  private bool bConfigLoaded = false;
# Line 72 | Line 77 | namespace EmuXPortal {
77  
78                  private Queue<KeyArrayArgs> event_queue;
79                  private readonly object event_queue_lock = new object ();
80 +
81  
82                  private void do_irexec_monitor ()
83                  {
# Line 93 | Line 99 | namespace EmuXPortal {
99  
100                  private void HookIRExec ()
101                  {
96                        //if (!OSInfo.OSIsUnix) { return; }
97                        //KillDanglingIRExecProcesses ();
98                        //gLog.Info.WriteLine ("Hooking Irexec...");
99                        //using (Process p = new Process ()) {
100                        //      p.StartInfo.FileName = irexec;
101                        //      p.StartInfo.Arguments = Enterprise.CrossPlatform.OSInfo.FormatPath (string.Format ("{0}/{1}", Application.StartupPath, irexec_lircrc));
102                        //      p.Start ();
103                        //      irexec_pid = p.Id;
104                        //      gLog.Info.WriteLine ("Irexec Hooked [pid=0x{0:x8}]", irexec_pid);
105                        //}
102                          irexec_thread_monitor = new Thread (new ThreadStart (do_irexec_monitor));
103                          irexec_thread_monitor.SetApartmentState (ApartmentState.STA);
104                          irexec_thread_monitor.Start ();
105                  }
106                  private void UnHookIRExec ()
107                  {
112                        //if (!OSInfo.OSIsUnix) { return; }
113                        //if (irexec_pid != 0) {
114                        //      gLog.Info.WriteLine ("UnHooking Irexec [pid=0x{0:x8}]", irexec_pid);
115                        //      try {
116                        //              using (Process p = Process.GetProcessById (irexec_pid)) {
117                        //                      p.Kill ();
118                        //                      gLog.Info.WriteLine ("UnHooked Irexec...");
119                        //              }
120                        //      } catch {
121                        //              gLog.Error.WriteLine ("Failed to UnHook Irexec...");
122                        //      }
123                        //}
108                          if (irexec_thread_monitor != null && irexec_thread_monitor.IsAlive) {
109                                  irexec_thread_monitor.Abort ();
110                                  irexec_thread_monitor = null;
# Line 159 | Line 143 | namespace EmuXPortal {
143                  public Form1 ()
144                  {
145                          InitializeComponent ();
162                        this.BackColor = Color.Black;
163                        this.ForeColor = Color.LimeGreen;
146                          this.progress_bar = new CustomProgressBar ();
165                        this.KeyPreview = true;
147  
148                          #region logging support
149                          string log_path = Application.StartupPath;
# Line 208 | Line 189 | namespace EmuXPortal {
189                          if (bInputQueueDisabled) {
190                                  return;
191                          }
211                        //gLog.Verbose.Debug.WriteLine ("Input_Queue_Handler_Tick -- running");
192                          if (bInputQueuHandlerRunning) { return; }
193                          if (event_queue.Count > 0) {
194                                  bInputQueuHandlerRunning = true;
# Line 219 | Line 199 | namespace EmuXPortal {
199                                  var keys = key_event.GetKeys ();
200                                  string key_string = KeyConverter.getSendKeysString (keys);
201                                  StringBuilder sb = new StringBuilder ();
202 <                                keys.ToList ().ForEach ((Keys obj) => sb.AppendFormat (" {0}", obj));
223 <                                //gLog.Verbose.Debug.WriteLine ("Sending keys: {0}", sb.ToString());
202 >                                keys.ToList ().ForEach ((Keys obj) => sb.AppendFormat (" {0}", obj));
203                                  SendKeys.Send (key_string);
225                                // process key_event
204                                  bInputQueuHandlerRunning = false;
205                          }
206                  }
# Line 230 | Line 208 | namespace EmuXPortal {
208  
209                  void Handle_InputPoll (object sender, KeyArrayArgs e)
210                  {
233                        /*if (bInputQueueDisabled) {
234                                // drop this input event
235                                var keys = e.GetKeys ();
236                                StringBuilder sb = new StringBuilder ();
237                                if (keys.Length > 0) {
238                                        sb.AppendFormat ("{0}", keys [0]);
239                                }
240                                for (int i = 1; i < keys.Length; i++) {
241                                        sb.AppendFormat (", {0}", keys [i]);
242                                }
243                                gLog.Verbose.Warn.WriteLine ("Input Queue temporairly disabled....dropped key event ({0})!", sb.ToString());
244                                return;
245                        }
246                        lock (event_queue_lock) {
247                                event_queue.Enqueue (e);                                
248                        }*/
211                          if (!bInputQueueDisabled) {
212                                  lock (event_queue_lock) {
213                                          event_queue.Enqueue (e);
# Line 281 | Line 243 | namespace EmuXPortal {
243                  {
244                          var cargs = new List<String> (System.Environment.GetCommandLineArgs ());
245                          if (cargs.Contains ("--rebuild")) {
246 + #if !DEV_DEBUG
247                                  bRebuildCache = true;
248 + #endif
249                          }
250                  }
251  
252  
253                  private void Form1_Load (object sender, EventArgs e)
254                  {
255 <                        HandleCommandLine ();
256 <                        Config.InitializePresentationForm (this);
257 <                        this.Show ();
294 <
295 <                }
296 <
297 <                private void Form1_Shown (object sender, EventArgs e)
298 <                {
299 <                        this.Activated += Handle_Activated;
255 >                        HandleCommandLine ();
256 >                        Config.InitializePresentationForm (this);
257 >                        this.Activated += Handle_Activated;
258  
259                  }
260  
# Line 304 | Line 262 | namespace EmuXPortal {
262                  void Handle_Activated (object sender, EventArgs e)
263                  {
264                          this.Activated -= Handle_Activated;
265 <
308 < #if DEV_DEBUG && USE_WINDOWED_MODE
309 <                        this.Width = WINDOW_MODE_WIDTH;
310 <                        this.Height = WINDOW_MODE_HEIGHT;
311 <                        this.FormBorderStyle = FormBorderStyle.Sizable;
312 < #endif
313 <
314 < #if !DISAGLE_LOAD_SPLASH
315 <                        SplashLoader loader = new SplashLoader (new AbortEvent (OnCacheLoaded));
316 <                        loader.Show (this);
317 < #endif
318 <                        Stopwatch t = new Stopwatch ();
319 <                        t.Start ();
320 <                        try {
321 <                                cache = PlatformCache.Create (new AbortEvent (OnAbort), bRebuildCache);
322 <                                bCachedLoaded = true;
323 <                        } catch (Exception ex) {
324 <                                gLog.Error.WriteLine (ex.ToString ());
325 <                        }
326 <                        t.Stop ();
327 <                        gLog.Profiler.WriteLine ("Cache generate/load took: {0}", TimeUtils.getTimeString (t));
328 <
329 <                        t = new Stopwatch ();
330 <                        t.Start ();
331 <                        bConfigLoaded = Config.LoadConfig (cache);
332 <                        t.Stop ();
333 <                        gLog.Profiler.WriteLine ("Config load took: {0}", TimeUtils.getTimeString (t));
334 <
335 <                        if (!bConfigLoaded) {
336 <                                input_queue_handler.Stop ();
337 <                                input_queue_handler.Enabled = false;
338 <                                return;
339 <                        }
340 <
341 <                        /* initialize the container controls */                
342 <                        platform_flow.setCache (cache);
343 <                        rom_flow.setCache (cache);
344 <
345 <
346 <
347 <                        platform_flow.Font = this.Font;
348 <                        rom_flow.Font = this.Font;
349 <
350 <                        //platform_flow.setDefaultPlatformImage ((Bitmap)Properties.Resources.DefaultPlatformImage);
351 <                        //rom_flow.setDefaultGameImage ((Bitmap)Properties.Resources.DefaultGameImage);
352 <
353 <                        platform_flow.BackColor = this.BackColor;
354 <                        platform_flow.ForeColor = this.ForeColor;
355 <
356 <                        rom_flow.BackColor = this.BackColor;
357 <                        rom_flow.ForeColor = this.ForeColor;
358 <
359 <
360 <                        platform_flow.controlsRendered += ControlsRendered;
361 <                        rom_flow.controlsRendered += ControlsRendered;
362 <
363 <                        platform_flow.switchControls += SwitchControls;
364 <                        rom_flow.switchControls += SwitchControls;
365 <
366 <                        platform_flow.Parent = this;
367 <                        rom_flow.Parent = this;
368 <
369 <
370 <                        platform_flow.Width = this.Width - 10;
371 <                        rom_flow.Width = this.Width - 10;
372 <
373 <                        rom_flow.RomLaunched += Rom_Flow_RomLaunched;
374 <
375 <
376 <                        if (!bConfigLoaded) {
377 <                                gLog.Warn.WriteLine ("Terminating application...");
378 <                                Application.Exit ();
379 <                                return;
380 <                        }
381 <                        platform_flow.Visible = true;
382 < #if !DISABLE_CURSOR_HIDE
383 <                        Cursor.Hide ();
384 < #else
385 <            Cursor.Show();
386 < #endif
387 <
388 < #if !DISABLE_PLUGINS
389 <                        PluginLoader.StartInputPolling (bInputQueueDisabled, Handle_InputPoll);
390 < #endif
391 <
265 >                        this.cache_worker.RunWorkerAsync ();
266                  }
267  
268                  void Rom_Flow_RomLaunched (object sender, RomLaunchArgs e)
# Line 444 | Line 318 | namespace EmuXPortal {
318                          }
319                  }
320  
447                
448
321                  private void platform_flow_VisibleChanged (object sender, EventArgs e)
322                  {
323                          if (!platform_flow.Visible) return;
324 <                        
324 >                        platform_flow.Width = this.Width - 10;
325                          platform_flow.renderControls ();
326                  }
327  
456
457
328                  private void rom_flow_VisibleChanged (object sender, EventArgs e)
329                  {
330 <                        if (!rom_flow.Visible) return;
330 >                        if (!rom_flow.Visible) return;
331 >                        rom_flow.Width = this.Width - 10;
332                  }
333  
334  
# Line 469 | Line 340 | namespace EmuXPortal {
340                  {
341                          Cursor.Show ();
342                          PluginLoader.EndInputPolling ();
343 +                }
344 +
345 +                private void Cache_Worker_DoWork (object sender, DoWorkEventArgs e)
346 +                {
347 +
348 + #if !DISABLE_SPLASH
349 +                        this.Controls.Add (splash);
350 +                        this.splash.Width = this.Width;
351 + #endif
352 +                        Stopwatch t = new Stopwatch ();
353 +                        t.Start ();
354 +                        try {
355 +                                cache = PlatformCache.Create (new AbortEvent (OnAbort), bRebuildCache);
356 +                                bCachedLoaded = true;
357 +                        } catch (Exception ex) {
358 +                                gLog.Error.WriteLine (ex.ToString ());
359 +                        }
360 +                        t.Stop ();
361 +
362 +                        if (bCachedLoaded) {
363 +                                gLog.Profiler.WriteLine ("Cache generate/load took: {0}", TimeUtils.getTimeString (t));
364 +                        }
365 +                }
366 +                private void Cache_Worker_RunWorkerCompleted (object sender, RunWorkerCompletedEventArgs e)
367 +                {
368 +                        if (!bCachedLoaded) {
369 +                                gLog.Warn.WriteLine ("Failed to generate cache...");
370 +                                Application.Exit ();
371 +                                return;
372 +                        }
373 + #if !DISABLE_SPLASH
374 +                        this.Controls.Remove (splash);
375 + #endif
376 +                        config_worker.RunWorkerAsync ();
377 +                }
378 +                private void Config_Worker_DoWork (object sender, DoWorkEventArgs e)
379 +                {
380 +                        Stopwatch t = new Stopwatch ();
381 +                        t.Start ();
382 +                        try {
383 +                                bConfigLoaded = Config.LoadConfig (cache);
384 +                        } catch (Exception ex) {
385 +                                bConfigLoaded = false;
386 +                                gLog.Error.WriteLine (ex.ToString ());
387 +                                return;
388 +                        }
389 +                        t.Stop ();
390 +                        gLog.Profiler.WriteLine ("Config load took: {0}", TimeUtils.getTimeString (t));
391 +
392 +
393 +
394 +                }
395 +                private void Config_Worker_RunWorkerCompleted (object sender, RunWorkerCompletedEventArgs e)
396 +                {
397 +                        if (!bConfigLoaded) {
398 +                                gLog.Warn.WriteLine ("Failed to load config...");
399 +                                Application.Exit ();
400 +                                return;
401 +                        }
402 +                        /* set the container control's cache */
403 +                        platform_flow.setCache (cache);
404 +                        rom_flow.setCache (cache);
405 +                        platform_flow.Visible = true;
406 +                        platform_flow.Focus ();
407 + #if !DISABLE_CURSOR_HIDE
408 +                        Cursor.Hide ();
409 + #else
410 +            Cursor.Show();
411 + #endif
412 +
413 + #if !DISABLE_PLUGINS
414 +                        PluginLoader.StartInputPolling (bInputQueueDisabled, Handle_InputPoll);
415 + #endif
416                  }
417          }
418   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines