From 0c9a71f626e0e552cf670103b8dad8e61de1fb69 Mon Sep 17 00:00:00 2001
From: sr55 <sr55.hb@outlook.com>
Date: Sun, 6 Jun 2010 18:22:39 +0000
Subject: WinGui: - Moved all the services that handle parsing, scanning,
 encodes and the queue out into a separate library.

git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@3362 b64f7644-9d1e-0410-96f1-a4d463321fa5
---
 .../Functions/GrowlCommunicator.cs                 | 119 +++++++++++++++++
 .../Functions/Main.cs                              |  83 ++++++++++++
 .../Functions/Win32.cs                             | 143 +++++++++++++++++++++
 3 files changed, 345 insertions(+)
 create mode 100644 win/C#/HandBrake.ApplicationServices/Functions/GrowlCommunicator.cs
 create mode 100644 win/C#/HandBrake.ApplicationServices/Functions/Main.cs
 create mode 100644 win/C#/HandBrake.ApplicationServices/Functions/Win32.cs

(limited to 'win/C#/HandBrake.ApplicationServices/Functions')

diff --git a/win/C#/HandBrake.ApplicationServices/Functions/GrowlCommunicator.cs b/win/C#/HandBrake.ApplicationServices/Functions/GrowlCommunicator.cs
new file mode 100644
index 000000000..579b92a46
--- /dev/null
+++ b/win/C#/HandBrake.ApplicationServices/Functions/GrowlCommunicator.cs
@@ -0,0 +1,119 @@
+/*  GrowlCommunicator.cs $
+    This file is part of the HandBrake source code.
+    Homepage: <http://handbrake.fr>.
+    It may be used under the terms of the GNU General Public License. */
+
+namespace HandBrake.ApplicationServices.Functions
+{
+    using System;
+
+    using Growl.Connector;
+
+    /// <summary>
+    /// Provides all functionality for communicating with Growl for Windows.
+    /// </summary>
+    /// <remarks>
+    /// This class is implemented as a static class because:
+    ///     1. It allows nearly all of the Growl-related code to be in one place
+    ///     2. It prevents the main form, queue handler, and any other part of Handbrake from having to declare
+    ///        or track any new instance variables
+    /// </remarks>
+    public static class GrowlCommunicator
+    {
+        /// <summary>
+        /// The <see cref="GrowlConnector"/> that actually talks to Growl
+        /// </summary>
+        private static GrowlConnector growl;
+
+        /// <summary>
+        /// The Handbrake application instance that is registered with Growl
+        /// </summary>
+        private static Application application;
+
+        /// <summary>
+        /// Notification shown upon completion of encoding
+        /// </summary>
+        private static NotificationType encodeOrQueueCompleted = new NotificationType("EncodeOrQueue", "HandBrake Status");
+
+        /// <summary>
+        /// Checks to see if Growl is currently running on the local machine.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if Growl is running;
+        /// <c>false</c> otherwise
+        /// </returns>
+        public static bool IsRunning()
+        {
+            Initialize();
+
+            return growl.IsGrowlRunning();
+        }
+
+        /// <summary>
+        /// Registers Handbrake with the local Growl instance
+        /// </summary>
+        /// <remarks>
+        /// This should usually be called at application start-up
+        /// </remarks>
+        public static void Register()
+        {
+            Initialize();
+            growl.Register(application, new[] {encodeOrQueueCompleted});
+        }
+
+        /// <summary>
+        /// Sends a notification to Growl. (Since Handbrake currently only supports one type of notification with
+        /// static text, this is a shortcut method).
+        /// </summary>
+        /// <param name="title">
+        /// The title.
+        /// </param>
+        /// <param name="text">
+        /// The text to display.
+        /// </param>
+        public static void Notify(string title, string text)
+        {
+            Notification notification = new Notification(application.Name, encodeOrQueueCompleted.Name, String.Empty, 
+                                                         title, text);
+            growl.Notify(notification);
+        }
+
+        /// <summary>
+        /// Sends a notification to Growl. (This is the more generic version that could be used in the future if 
+        /// more notification types are implemented)
+        /// </summary>
+        /// <param name="notificationType">The <see cref="NotificationType">type</see> of notification to send</param>
+        /// <param name="title">The notification title</param>
+        /// <param name="text">The notification text</param>
+        /// <param name="imageUrl">The notification image as a url</param>
+        public static void Notify(NotificationType notificationType, string title, string text, string imageUrl)
+        {
+            Notification notification = new Notification(application.Name, notificationType.Name, String.Empty, title, 
+                                                         text)
+                                            {
+                                                Icon = imageUrl
+                                            };
+
+            growl.Notify(notification);
+        }
+
+        /// <summary>
+        /// Initializes the GrowlCommunicator
+        /// </summary>
+        private static void Initialize()
+        {
+            if (growl == null)
+            {
+                growl = new GrowlConnector
+                            {
+                                EncryptionAlgorithm = Cryptography.SymmetricAlgorithmType.PlainText
+                            };
+
+                application = new Application("Handbrake")
+                                  {
+                                      Icon = Properties.Resources.logo64
+                                  };
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/win/C#/HandBrake.ApplicationServices/Functions/Main.cs b/win/C#/HandBrake.ApplicationServices/Functions/Main.cs
new file mode 100644
index 000000000..0696101c1
--- /dev/null
+++ b/win/C#/HandBrake.ApplicationServices/Functions/Main.cs
@@ -0,0 +1,83 @@
+/*  Main.cs $
+    This file is part of the HandBrake source code.
+    Homepage: <http://handbrake.fr>.
+    It may be used under the terms of the GNU General Public License. */
+
+namespace HandBrake.ApplicationServices.Functions
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+
+    /// <summary>
+    /// Useful functions which various screens can use.
+    /// </summary>
+    public static class Main
+    {
+        /// <summary>
+        /// Get the Process ID of HandBrakeCLI for the current instance.
+        /// </summary>
+        /// <param name="before">List of processes before the new process was started</param>
+        /// <returns>Int - Process ID</returns>
+        public static int GetCliProcess(Process[] before)
+        {
+            // This is a bit of a cludge. Maybe someone has a better idea on how to impliment this.
+            // Since we used CMD to start HandBrakeCLI, we don't get the process ID from hbProc.
+            // Instead we take the processes before and after, and get the ID of HandBrakeCLI.exe
+            // avoiding any previous instances of HandBrakeCLI.exe in before.
+            // Kill the current process.
+
+            DateTime startTime = DateTime.Now;
+            TimeSpan duration;
+
+            Process[] hbProcesses = Process.GetProcessesByName("HandBrakeCLI");
+            while (hbProcesses.Length == 0)
+            {
+                hbProcesses = Process.GetProcessesByName("HandBrakeCLI");
+                duration = DateTime.Now - startTime;
+                if (duration.Seconds > 5 && hbProcesses.Length == 0)
+                    // Make sure we don't wait forever if the process doesn't start
+                    return -1;
+            }
+
+            Process hbProcess = null;
+            foreach (Process process in hbProcesses)
+            {
+                bool found = false;
+                // Check if the current CLI instance was running before we started the current one
+                foreach (Process bprocess in before)
+                {
+                    if (process.Id == bprocess.Id)
+                        found = true;
+                }
+
+                // If it wasn't running before, we found the process we want.
+                if (!found)
+                {
+                    hbProcess = process;
+                    break;
+                }
+            }
+            if (hbProcess != null)
+                return hbProcess.Id;
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Show the Exception Window
+        /// </summary>
+        /// <param name="shortError">
+        /// The short error.
+        /// </param>
+        /// <param name="longError">
+        /// The long error.
+        /// </param>
+        public static void ShowExceptiowWindow(string shortError, string longError)
+        {
+            frmExceptionWindow exceptionWindow = new frmExceptionWindow();
+            exceptionWindow.Setup(shortError, longError);
+            exceptionWindow.Show();
+        }
+    }
+}
\ No newline at end of file
diff --git a/win/C#/HandBrake.ApplicationServices/Functions/Win32.cs b/win/C#/HandBrake.ApplicationServices/Functions/Win32.cs
new file mode 100644
index 000000000..a3caf38ab
--- /dev/null
+++ b/win/C#/HandBrake.ApplicationServices/Functions/Win32.cs
@@ -0,0 +1,143 @@
+/*  win32.cs $
+    This file is part of the HandBrake source code.
+    Homepage: <http://handbrake.fr>.
+    It may be used under the terms of the GNU General Public License. */
+
+namespace HandBrake.ApplicationServices.Functions
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Win32 API calls
+    /// </summary>
+    public class Win32
+    {
+        /// <summary>
+        /// Set the Forground Window
+        /// </summary>
+        /// <param name="hWnd">
+        /// The h wnd.
+        /// </param>
+        /// <returns>
+        /// A Boolean true when complete.
+        /// </returns>
+        [DllImport("user32.dll")]
+        public static extern bool SetForegroundWindow(int hWnd);
+
+        /// <summary>
+        /// Lock the workstation
+        /// </summary>
+        [DllImport("user32.dll")]
+        public static extern void LockWorkStation();
+
+        /// <summary>
+        /// Exit Windows
+        /// </summary>
+        /// <param name="uFlags">
+        /// The u flags.
+        /// </param>
+        /// <param name="dwReason">
+        /// The dw reason.
+        /// </param>
+        /// <returns>
+        /// an integer
+        /// </returns>
+        [DllImport("user32.dll")]
+        public static extern int ExitWindowsEx(int uFlags, int dwReason);
+
+        /// <summary>
+        /// System Memory Status
+        /// </summary>
+        public struct MEMORYSTATUS // Unused var's are required here.
+        {
+            /// <summary>
+            /// Unknown
+            /// </summary>
+            public UInt32 dwLength;
+
+            /// <summary>
+            /// Memory Load
+            /// </summary>
+            public UInt32 dwMemoryLoad;
+
+            /// <summary>
+            /// Total Physical Memory
+            /// </summary>
+            public UInt32 dwTotalPhys; // Used
+
+            /// <summary>
+            /// Available Physical Memory
+            /// </summary>
+            public UInt32 dwAvailPhys;
+
+            /// <summary>
+            /// Total Page File
+            /// </summary>
+            public UInt32 dwTotalPageFile;
+
+            /// <summary>
+            /// Available Page File
+            /// </summary>
+            public UInt32 dwAvailPageFile;
+
+            /// <summary>
+            /// Total Virtual Memory
+            /// </summary>
+            public UInt32 dwTotalVirtual;
+
+            /// <summary>
+            /// Available Virtual Memory
+            /// </summary>
+            public UInt32 dwAvailVirtual;
+        }
+
+        /// <summary>
+        /// Global Memory Status
+        /// </summary>
+        /// <param name="lpBuffer">
+        /// The lp buffer.
+        /// </param>
+        [DllImport("kernel32.dll")]
+        public static extern void GlobalMemoryStatus
+        (
+            ref MEMORYSTATUS lpBuffer
+        );
+
+        /// <summary>
+        /// Generate a Console Ctrl Event
+        /// </summary>
+        /// <param name="sigevent">
+        /// The sigevent.
+        /// </param>
+        /// <param name="dwProcessGroupId">
+        /// The dw process group id.
+        /// </param>
+        /// <returns>
+        /// Bool true is sucess
+        /// </returns>
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool GenerateConsoleCtrlEvent(ConsoleCtrlEvent sigevent, int dwProcessGroupId);
+
+        /// <summary>
+        /// Console Ctrl Event
+        /// </summary>
+        public enum ConsoleCtrlEvent
+        {
+            /// <summary>
+            /// Ctrl - C
+            /// </summary>
+            CTRL_C = 0,
+
+            /// <summary>
+            /// Ctrl - Break
+            /// </summary>
+            CTRL_BREAK = 1,
+
+            /// <summary>
+            /// Ctrl - Close
+            /// </summary>
+            CTRL_CLOSE = 2,
+        }
+    }
+}
-- 
cgit v1.2.3