From b59b7b8733533aed4b97da6679e455df63049e23 Mon Sep 17 00:00:00 2001
From: sr55 <sr55.hb@outlook.com>
Date: Sat, 20 Feb 2010 21:59:23 +0000
Subject: WinGui: - Some tweaks to the StyleCop Settings File. - Some
 abbreviations added to the ReSharper config file. - Some more warnings
 cleaned up.

git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@3130 b64f7644-9d1e-0410-96f1-a4d463321fa5
---
 win/C#/EncodeQueue/Encode.cs     | 320 +++++++++++++++++++++------------------
 win/C#/EncodeQueue/Job.cs        |  24 +--
 win/C#/EncodeQueue/Queue.cs      | 152 +++++++++++--------
 win/C#/Functions/Win32.cs        |  30 ++++
 win/C#/HandBrakeCS.5.0.ReSharper |   2 +
 win/C#/Model/AudioTrack.cs       |  32 ++--
 win/C#/Model/DriveInformation.cs |  14 +-
 win/C#/Model/SourceType.cs       |  10 +-
 win/C#/Model/Subtitle.cs         |  53 +++----
 win/C#/Program.cs                |  27 ++--
 win/C#/Settings.StyleCop         |  12 ++
 win/C#/frmMain.Designer.cs       |   2 +-
 12 files changed, 390 insertions(+), 288 deletions(-)

(limited to 'win')

diff --git a/win/C#/EncodeQueue/Encode.cs b/win/C#/EncodeQueue/Encode.cs
index 28ef3ae46..60f460a54 100644
--- a/win/C#/EncodeQueue/Encode.cs
+++ b/win/C#/EncodeQueue/Encode.cs
@@ -1,103 +1,146 @@
 /*  Encode.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. */
-
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Windows.Forms;
-using Handbrake.Functions;
+    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.EncodeQueue
 {
+    using System;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Windows.Forms;
+    using Functions;
+    using Properties;
+
     /// <summary>
     /// Class which handles the CLI
     /// </summary>
     public class Encode
     {
         /// <summary>
-        /// Process ID
+        /// Fires when a new CLI Job starts
         /// </summary>
-        private int ProcessID { get; set; }
+        public event EventHandler EncodeStarted;
 
         /// <summary>
-        /// The HB Process
+        /// Fires when a CLI job finishes.
         /// </summary>
-        public Process HbProcess { get; set; }
-        
+        public event EventHandler EncodeEnded;
+
         /// <summary>
-        /// The Process Handle
+        /// Gets or sets The HB Process
         /// </summary>
-        public IntPtr ProcessHandle { get; set; }
-        
+        public Process HbProcess { get; set; }
+
         /// <summary>
-        /// Returns true of HandBrakeCLI.exe is running
+        /// Gets or sets The Process Handle
         /// </summary>
-        public Boolean IsEncoding { get; set; }     
+        public IntPtr ProcessHandle { get; set; }
 
         /// <summary>
-        /// Fires when a new CLI Job starts
+        /// Gets or sets a value indicating whether HandBrakeCLI.exe is running
         /// </summary>
-        public event EventHandler EncodeStarted;
+        public bool IsEncoding { get; set; }
 
         /// <summary>
-        /// Fires when a CLI job finishes.
+        /// Gets or sets the Process ID
         /// </summary>
-        public event EventHandler EncodeEnded;
+        private int ProcessID { get; set; }
 
         /// <summary>
         /// Create a preview sample video
         /// </summary>
-        /// <param name="query"></param>
+        /// <param name="query">
+        /// The CLI Query
+        /// </param>
         public void CreatePreviewSample(string query)
         {
-            Run(query);
+            this.Run(query);
+        }
+
+        /// <summary>
+        /// Kill the CLI process
+        /// </summary>
+        public void Stop()
+        {
+            if (this.HbProcess != null)
+                this.HbProcess.Kill();
+
+            Process[] list = Process.GetProcessesByName("HandBrakeCLI");
+            foreach (Process process in list)
+                process.Kill();
+
+            this.IsEncoding = false;
+
+            if (this.EncodeEnded != null)
+                this.EncodeEnded(this, new EventArgs());
+        }
+
+        /// <summary>
+        /// Attempt to Safely kill a DirectRun() CLI
+        /// NOTE: This will not work with a MinGW CLI
+        /// Note: http://www.cygwin.com/ml/cygwin/2006-03/msg00330.html
+        /// </summary>
+        public void SafelyClose()
+        {
+            if ((int)this.ProcessHandle == 0)
+                return;
+
+            // Allow the CLI to exit cleanly
+            Win32.SetForegroundWindow((int)this.ProcessHandle);
+            SendKeys.Send("^C");
+
+            // HbProcess.StandardInput.AutoFlush = true;
+            // HbProcess.StandardInput.WriteLine("^C");
         }
 
         /// <summary>
         /// Execute a HandBrakeCLI process.
         /// </summary>
-        /// <param name="query">The CLI Query</param>
+        /// <param name="query">
+        /// The CLI Query
+        /// </param>
         protected void Run(string query)
         {
             try
             {
-                if (EncodeStarted != null)
-                    EncodeStarted(this, new EventArgs());
+                if (this.EncodeStarted != null)
+                    this.EncodeStarted(this, new EventArgs());
 
-                IsEncoding = true;
+                this.IsEncoding = true;
 
                 string handbrakeCLIPath = Path.Combine(Application.StartupPath, "HandBrakeCLI.exe");
-                string logPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs", "last_encode_log.txt");
+                string logPath =
+                    Path.Combine(
+                        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs", 
+                        "last_encode_log.txt");
                 string strCmdLine = String.Format(@" /C """"{0}"" {1} 2>""{2}"" """, handbrakeCLIPath, query, logPath);
-                ProcessStartInfo cliStart = new ProcessStartInfo("CMD.exe", strCmdLine);
+                var cliStart = new ProcessStartInfo("CMD.exe", strCmdLine);
 
-                if (Properties.Settings.Default.enocdeStatusInGui)
+                if (Settings.Default.enocdeStatusInGui)
                 {
                     cliStart.RedirectStandardOutput = true;
                     cliStart.UseShellExecute = false;
-                    if (!Properties.Settings.Default.showCliForInGuiEncodeStatus)
+                    if (!Settings.Default.showCliForInGuiEncodeStatus)
                         cliStart.CreateNoWindow = true;
                 }
-                if (Properties.Settings.Default.cli_minimized)
+                if (Settings.Default.cli_minimized)
                     cliStart.WindowStyle = ProcessWindowStyle.Minimized;
 
                 Process[] before = Process.GetProcesses(); // Get a list of running processes before starting.
-                HbProcess = Process.Start(cliStart);
-                ProcessID = Main.GetCliProcess(before);
+                this.HbProcess = Process.Start(cliStart);
+                this.ProcessID = Main.GetCliProcess(before);
 
-                if (HbProcess != null)
-                    ProcessHandle = HbProcess.MainWindowHandle; // Set the process Handle
+                if (this.HbProcess != null)
+                    this.ProcessHandle = this.HbProcess.MainWindowHandle; // Set the process Handle
 
                 // Set the process Priority
                 Process hbCliProcess = null;
-                if (ProcessID != -1)
-                    hbCliProcess = Process.GetProcessById(ProcessID);
+                if (this.ProcessID != -1)
+                    hbCliProcess = Process.GetProcessById(this.ProcessID);
 
                 if (hbCliProcess != null)
-                    switch (Properties.Settings.Default.processPriority)
+                    switch (Settings.Default.processPriority)
                     {
                         case "Realtime":
                             hbCliProcess.PriorityClass = ProcessPriorityClass.RealTime;
@@ -121,7 +164,12 @@ namespace Handbrake.EncodeQueue
             }
             catch (Exception exc)
             {
-                MessageBox.Show("It would appear that HandBrakeCLI has not started correctly. You should take a look at the Activity log as it may indicate the reason why.\n\n   Detailed Error Information: error occured in runCli()\n\n" + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                MessageBox.Show(
+                    "It would appear that HandBrakeCLI has not started correctly. You should take a look at the Activity log as it may indicate the reason why.\n\nDetailed Error Information: error occured in runCli()\n\n" +
+                    exc,
+                    "Error", 
+                    MessageBoxButtons.OK, 
+                    MessageBoxIcon.Error);
             }
         }
 
@@ -130,31 +178,34 @@ namespace Handbrake.EncodeQueue
         /// TODO: Code to handle the Log data has yet to be written.
         /// TODO: Code to handle the % / ETA info has to be written.
         /// </summary>
+        /// <param name="query">
+        /// The query.
+        /// </param>
         protected void DirectRun(string query)
         {
             try
             {
-                if (EncodeStarted != null)
-                    EncodeStarted(this, new EventArgs());
+                if (this.EncodeStarted != null)
+                    this.EncodeStarted(this, new EventArgs());
 
-                IsEncoding = true;
+                this.IsEncoding = true;
 
                 // Setup the job
                 string handbrakeCLIPath = Path.Combine(Environment.CurrentDirectory, "HandBrakeCLI.exe");
-                Process hbProc = new Process
-                {
-                    StartInfo =
-                    {
-                        FileName = handbrakeCLIPath,
-                        Arguments = query,
-                        UseShellExecute = false,
-                        RedirectStandardOutput = true,
-                        RedirectStandardError = true,
-                        RedirectStandardInput = true,
-                        CreateNoWindow = false,
-                        WindowStyle = ProcessWindowStyle.Minimized
-                    }
-                };
+                var hbProc = new Process
+                                 {
+                                     StartInfo =
+                                         {
+                                             FileName = handbrakeCLIPath, 
+                                             Arguments = query, 
+                                             UseShellExecute = false, 
+                                             RedirectStandardOutput = true, 
+                                             RedirectStandardError = true, 
+                                             RedirectStandardInput = true, 
+                                             CreateNoWindow = false, 
+                                             WindowStyle = ProcessWindowStyle.Minimized
+                                         }
+                                 };
 
                 // Setup the redirects
                 hbProc.ErrorDataReceived += new DataReceivedEventHandler(HbProcErrorDataReceived);
@@ -164,7 +215,7 @@ namespace Handbrake.EncodeQueue
                 hbProc.Start();
 
                 // Set the Process Priority
-                switch (Properties.Settings.Default.processPriority)
+                switch (Settings.Default.processPriority)
                 {
                     case "Realtime":
                         hbProc.PriorityClass = ProcessPriorityClass.RealTime;
@@ -187,10 +238,9 @@ namespace Handbrake.EncodeQueue
                 }
 
                 // Set the class items
-                HbProcess = hbProc;
-                ProcessID = hbProc.Id;
-                ProcessHandle = hbProc.Handle;
-
+                this.HbProcess = hbProc;
+                this.ProcessID = hbProc.Id;
+                this.ProcessHandle = hbProc.Handle;
             }
             catch (Exception exc)
             {
@@ -198,80 +248,22 @@ namespace Handbrake.EncodeQueue
             }
         }
 
-        /// <summary>
-        /// Kill the CLI process
-        /// </summary>
-        public void Stop()
-        {
-            if (HbProcess != null)
-                HbProcess.Kill();
-
-            Process[] list = Process.GetProcessesByName("HandBrakeCLI");
-            foreach (Process process in list)
-                    process.Kill();
-
-            IsEncoding = false;
-
-            if (EncodeEnded != null)
-                EncodeEnded(this, new EventArgs());
-        }
-
-        /// <summary>
-        /// Attempt to Safely kill a DirectRun() CLI
-        /// NOTE: This will not work with a MinGW CLI
-        /// Note: http://www.cygwin.com/ml/cygwin/2006-03/msg00330.html
-        /// </summary>
-        public void SafelyClose()
-        {
-            if ((int)ProcessHandle == 0)
-                return;
-
-            // Allow the CLI to exit cleanly
-            Win32.SetForegroundWindow((int)ProcessHandle);
-            SendKeys.Send("^C");
-
-            // HbProcess.StandardInput.AutoFlush = true;
-            // HbProcess.StandardInput.WriteLine("^C");
-        }
-
-        /// <summary>
-        /// Recieve the Standard Error information and process it
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        private static void HbProcErrorDataReceived(object sender, DataReceivedEventArgs e)
-        {
-            // TODO: Recieve the Log data and process it
-            throw new NotImplementedException();
-        }
-
-        /// <summary>
-        /// Standard Input Data Recieved from the CLI
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        private static void HbProcOutputDataReceived(object sender, DataReceivedEventArgs e)
-        {
-            // TODO: Recieve the %, ETA, FPS etc and process it
-            throw new NotImplementedException();
-        }
-
         /// <summary>
         /// Perform an action after an encode. e.g a shutdown, standby, restart etc.
         /// </summary>
         protected void Finish()
         {
-            if (EncodeEnded != null)
-                EncodeEnded(this, new EventArgs());
+            if (this.EncodeEnded != null)
+                this.EncodeEnded(this, new EventArgs());
 
-            IsEncoding = false;
+            this.IsEncoding = false;
 
-            //Growl
-            if (Properties.Settings.Default.growlQueue)
+            // Growl
+            if (Settings.Default.growlQueue)
                 GrowlCommunicator.Notify("Queue Completed", "Put down that cocktail...\nyour Handbrake queue is done.");
 
             // Do something whent he encode ends.
-            switch (Properties.Settings.Default.CompletionOption)
+            switch (Settings.Default.CompletionOption)
             {
                 case "Shutdown":
                     Process.Start("Shutdown", "-s -t 60");
@@ -299,7 +291,9 @@ namespace Handbrake.EncodeQueue
         /// <summary>
         /// Add the CLI Query to the Log File.
         /// </summary>
-        /// <param name="encJob"></param>
+        /// <param name="encJob">
+        /// The Encode Job Object
+        /// </param>
         protected void AddCLIQueryToLog(Job encJob)
         {
             try
@@ -308,12 +302,12 @@ namespace Handbrake.EncodeQueue
                                 "\\HandBrake\\logs";
                 string logPath = Path.Combine(logDir, "last_encode_log.txt");
 
-                StreamReader reader =
+                var reader =
                     new StreamReader(File.Open(logPath, FileMode.Open, FileAccess.Read, FileShare.Read));
-                String log = reader.ReadToEnd();
+                string log = reader.ReadToEnd();
                 reader.Close();
 
-                StreamWriter writer = new StreamWriter(File.Create(logPath));
+                var writer = new StreamWriter(File.Create(logPath));
 
                 writer.Write("### CLI Query: " + encJob.Query + "\n\n");
                 writer.Write("### User Query: " + encJob.CustomQuery + "\n\n");
@@ -321,7 +315,8 @@ namespace Handbrake.EncodeQueue
                 writer.WriteLine(log);
                 writer.Flush();
                 writer.Close();
-            } catch (Exception)
+            }
+            catch (Exception)
             {
                 return;
             }
@@ -331,17 +326,21 @@ namespace Handbrake.EncodeQueue
         /// Save a copy of the log to the users desired location or a default location
         /// if this feature is enabled in options.
         /// </summary>
-        /// <param name="destination"></param>
+        /// <param name="destination">
+        /// The Destination File Path
+        /// </param>
         protected void CopyLog(string destination)
         {
             try
             {
-                string logDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs";
+                string logDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) +
+                                "\\HandBrake\\logs";
                 string tempLogFile = Path.Combine(logDir, "last_encode_log.txt");
 
                 string encodeDestinationPath = Path.GetDirectoryName(destination);
-                String destinationFile = Path.GetFileName(destination);
-                string encodeLogFile = destinationFile + " " + DateTime.Now.ToString().Replace("/", "-").Replace(":", "-") + ".txt";
+                string destinationFile = Path.GetFileName(destination);
+                string encodeLogFile = destinationFile + " " +
+                                       DateTime.Now.ToString().Replace("/", "-").Replace(":", "-") + ".txt";
 
                 // Make sure the log directory exists.
                 if (!Directory.Exists(logDir))
@@ -351,19 +350,52 @@ namespace Handbrake.EncodeQueue
                 File.Copy(tempLogFile, Path.Combine(logDir, encodeLogFile));
 
                 // Save a copy of the log file in the same location as the enocde.
-                if (Properties.Settings.Default.saveLogWithVideo)
+                if (Settings.Default.saveLogWithVideo)
                     File.Copy(tempLogFile, Path.Combine(encodeDestinationPath, encodeLogFile));
 
                 // Save a copy of the log file to a user specified location
-                if (Directory.Exists(Properties.Settings.Default.saveLogPath))
-                    if (Properties.Settings.Default.saveLogPath != String.Empty && Properties.Settings.Default.saveLogToSpecifiedPath)
-                        File.Copy(tempLogFile, Path.Combine(Properties.Settings.Default.saveLogPath, encodeLogFile));
+                if (Directory.Exists(Settings.Default.saveLogPath))
+                    if (Settings.Default.saveLogPath != String.Empty && Settings.Default.saveLogToSpecifiedPath)
+                        File.Copy(tempLogFile, Path.Combine(Settings.Default.saveLogPath, encodeLogFile));
             }
             catch (Exception exc)
             {
-                MessageBox.Show("Something went a bit wrong trying to copy your log file.\nError Information:\n\n" + exc, "Error",
-                                MessageBoxButtons.OK, MessageBoxIcon.Error);
+                MessageBox.Show(
+                    "Something went a bit wrong trying to copy your log file.\nError Information:\n\n" + exc,
+                    "Error",
+                    MessageBoxButtons.OK,
+                    MessageBoxIcon.Error);
             }
         }
+
+        /// <summary>
+        /// Recieve the Standard Error information and process it
+        /// </summary>
+        /// <param name="sender">
+        /// The Sender Object
+        /// </param>
+        /// <param name="e">
+        /// DataReceived EventArgs
+        /// </param>
+        private static void HbProcErrorDataReceived(object sender, DataReceivedEventArgs e)
+        {
+            // TODO: Recieve the Log data and process it
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Standard Input Data Recieved from the CLI
+        /// </summary>
+        /// <param name="sender">
+        /// The Sender Object
+        /// </param>
+        /// <param name="e">
+        /// DataReceived EventArgs
+        /// </param>
+        private static void HbProcOutputDataReceived(object sender, DataReceivedEventArgs e)
+        {
+            // TODO: Recieve the %, ETA, FPS etc and process it
+            throw new NotImplementedException();
+        }
     }
 }
\ No newline at end of file
diff --git a/win/C#/EncodeQueue/Job.cs b/win/C#/EncodeQueue/Job.cs
index 7dfe7e518..6c87cd606 100644
--- a/win/C#/EncodeQueue/Job.cs
+++ b/win/C#/EncodeQueue/Job.cs
@@ -1,13 +1,13 @@
 /*  QueueItem.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. */
-
-using System;
+    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.EncodeQueue
 {
+    /// <summary>
+    /// The job.
+    /// </summary>
     public struct Job
     {
         /// <summary>
@@ -21,9 +21,9 @@ namespace Handbrake.EncodeQueue
         public string Query { get; set; }
 
         /// <summary>
-        /// record if this is a user or GUI generated query
+        /// Gets or sets a value indicating whether if this is a user or GUI generated query
         /// </summary>
-        public Boolean CustomQuery { get; set; }
+        public bool CustomQuery { get; set; }
 
         /// <summary>
         /// Gets or sets the source file of encoding.
@@ -36,11 +36,15 @@ namespace Handbrake.EncodeQueue
         public string Destination { get; set; }
 
         /// <summary>
-        /// Gets whether or not this instance is empty.
+        /// Gets a value indicating whether or not this instance is empty.
         /// </summary>
         public bool IsEmpty
         {
-            get { return Id == 0 && string.IsNullOrEmpty(Query) && string.IsNullOrEmpty(Source) && string.IsNullOrEmpty(Destination); }
+            get
+            {
+                return this.Id == 0 && string.IsNullOrEmpty(this.Query) && string.IsNullOrEmpty(this.Source) &&
+                       string.IsNullOrEmpty(this.Destination);
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/win/C#/EncodeQueue/Queue.cs b/win/C#/EncodeQueue/Queue.cs
index da9b78658..891c2de2c 100644
--- a/win/C#/EncodeQueue/Queue.cs
+++ b/win/C#/EncodeQueue/Queue.cs
@@ -1,25 +1,38 @@
 /*  Queue.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. */
-
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.IO;
-using System.Threading;
-using System.Windows.Forms;
-using System.Xml.Serialization;
-using Handbrake.Functions;
+    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.EncodeQueue
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.IO;
+    using System.Threading;
+    using System.Windows.Forms;
+    using System.Xml.Serialization;
+    using Functions;
+
+    /// <summary>
+    /// The HandBrake Queue
+    /// </summary>
     public class Queue : Encode
     {
+        /// <summary>
+        /// An XML Serializer
+        /// </summary>
         private static XmlSerializer serializer;
+
+        /// <summary>
+        /// The Queue Job List
+        /// </summary>
         private readonly List<Job> queue = new List<Job>();
-        private int NextJobId;
+
+        /// <summary>
+        /// The Next Job ID
+        /// </summary>
+        private int nextJobId;
 
         /// <summary>
         /// Fires when a pause to the encode queue has been requested.
@@ -38,11 +51,11 @@ namespace Handbrake.EncodeQueue
         /// <returns>The job that was removed from the queue.</returns>
         private Job GetNextJob()
         {
-            Job job = queue[0];
-            LastEncode = job;
-            Remove(0); // Remove the item which we are about to pass out.
+            Job job = this.queue[0];
+            this.LastEncode = job;
+            this.Remove(0); // Remove the item which we are about to pass out.
 
-            WriteQueueStateToFile("hb_queue_recovery.xml");
+            this.WriteQueueStateToFile("hb_queue_recovery.xml");
 
             return job;
         }
@@ -52,7 +65,7 @@ namespace Handbrake.EncodeQueue
         /// </summary>
         public ReadOnlyCollection<Job> CurrentQueue
         {
-            get { return queue.AsReadOnly(); }
+            get { return this.queue.AsReadOnly(); }
         }
 
         /// <summary>
@@ -60,23 +73,30 @@ namespace Handbrake.EncodeQueue
         /// </summary>
         public int Count
         {
-            get { return queue.Count; }
+            get { return this.queue.Count; }
         }
 
         /// <summary>
         /// Adds an item to the queue.
         /// </summary>
-        /// <param name="query">The query that will be passed to the HandBrake CLI.</param>
-        /// <param name="source">The location of the source video.</param>
-        /// <param name="destination">The location where the encoded video will be.</param>
-        /// <param name="customJob">Custom job</param>
-        /// <param name="scanInfo">The Scan</param>
+        /// <param name="query">
+        /// The query that will be passed to the HandBrake CLI.
+        /// </param>
+        /// <param name="source">
+        /// The location of the source video.
+        /// </param>
+        /// <param name="destination">
+        /// The location where the encoded video will be.
+        /// </param>
+        /// <param name="customJob">
+        /// Custom job
+        /// </param>
         public void Add(string query, string source, string destination, bool customJob)
         {
-            Job newJob = new Job { Id = NextJobId++, Query = query, Source = source, Destination = destination, CustomQuery = customJob };
+            Job newJob = new Job { Id = this.nextJobId++, Query = query, Source = source, Destination = destination, CustomQuery = customJob };
 
-            queue.Add(newJob);
-            WriteQueueStateToFile("hb_queue_recovery.xml");
+            this.queue.Add(newJob);
+            this.WriteQueueStateToFile("hb_queue_recovery.xml");
         }
 
         /// <summary>
@@ -85,19 +105,19 @@ namespace Handbrake.EncodeQueue
         /// <param name="index">The zero-based location of the job in the queue.</param>
         public void Remove(int index)
         {
-            queue.RemoveAt(index);
-            WriteQueueStateToFile("hb_queue_recovery.xml");
+            this.queue.RemoveAt(index);
+            this.WriteQueueStateToFile("hb_queue_recovery.xml");
         }
 
         /// <summary>
         /// Retrieve a job from the queue
         /// </summary>
-        /// <param name="index"></param>
-        /// <returns></returns>
+        /// <param name="index">the job id</param>
+        /// <returns>A job for the given index or blank job object</returns>
         public Job GetJob(int index)
         {
-            if (queue.Count >= (index +1))
-                return queue[index];
+            if (this.queue.Count >= (index + 1))
+                return this.queue[index];
 
             return new Job();
         }
@@ -125,15 +145,15 @@ namespace Handbrake.EncodeQueue
         /// <param name="index">The zero-based location of the job in the queue.</param>
         public void MoveDown(int index)
         {
-            if (index < queue.Count - 1)
+            if (index < this.queue.Count - 1)
             {
-                Job item = queue[index];
+                Job item = this.queue[index];
 
-                queue.RemoveAt(index);
-                queue.Insert((index + 1), item);
+                this.queue.RemoveAt(index);
+                this.queue.Insert((index + 1), item);
             }
 
-            WriteQueueStateToFile("hb_queue_recovery.xml"); // Update the queue recovery file
+            this.WriteQueueStateToFile("hb_queue_recovery.xml"); // Update the queue recovery file
         }
 
         /// <summary>
@@ -168,11 +188,11 @@ namespace Handbrake.EncodeQueue
         /// <param name="file">The location of the file to write the batch file to.</param>
         public void WriteBatchScriptToFile(string file)
         {
-            string queries = "";
-            foreach (Job queue_item in queue)
+            string queries = string.Empty;
+            foreach (Job queueItem in this.queue)
             {
-                string q_item = queue_item.Query;
-                string fullQuery = '"' + Application.StartupPath + "\\HandBrakeCLI.exe" + '"' + q_item;
+                string qItem = queueItem.Query;
+                string fullQuery = '"' + Application.StartupPath + "\\HandBrakeCLI.exe" + '"' + qItem;
 
                 if (queries == string.Empty)
                     queries = queries + fullQuery;
@@ -181,7 +201,7 @@ namespace Handbrake.EncodeQueue
             }
             string strCmdLine = queries;
 
-            if (file != "")
+            if (file != string.Empty)
             {
                 try
                 {
@@ -224,10 +244,10 @@ namespace Handbrake.EncodeQueue
 
                         if (list != null)
                             foreach (Job item in list)
-                                queue.Add(item);
+                                this.queue.Add(item);
 
                         if (file != "hb_queue_recovery.xml")
-                            WriteQueueStateToFile("hb_queue_recovery.xml");
+                            this.WriteQueueStateToFile("hb_queue_recovery.xml");
                     }
                 }
             }
@@ -240,7 +260,7 @@ namespace Handbrake.EncodeQueue
         /// <returns>Whether or not the supplied destination is already in the queue.</returns>
         public bool CheckForDestinationDuplicate(string destination)
         {
-            foreach (Job checkItem in queue)
+            foreach (Job checkItem in this.queue)
             {
                 if (checkItem.Destination.Contains(destination.Replace("\\\\", "\\")))
                     return true;
@@ -254,15 +274,15 @@ namespace Handbrake.EncodeQueue
         #region Encoding
 
         /// <summary>
-        /// Gets the last encode that was processed.
+        /// Gets or sets the last encode that was processed.
         /// </summary>
         /// <returns></returns> 
         public Job LastEncode { get; set; }
 
         /// <summary>
-        /// Request Pause
+        /// Gets a value indicating whether Request Pause
         /// </summary>
-        public Boolean PauseRequested { get; private set; }
+        public bool PauseRequested { get; private set; }
 
         /// <summary>
         /// Starts encoding the first job in the queue and continues encoding until all jobs
@@ -272,14 +292,14 @@ namespace Handbrake.EncodeQueue
         {
             if (this.Count != 0)
             {
-                if (PauseRequested)
-                    PauseRequested = false;
+                if (this.PauseRequested)
+                    this.PauseRequested = false;
                 else
                 {
-                    PauseRequested = false;
+                    this.PauseRequested = false;
                     try
                     {
-                        Thread theQueue = new Thread(StartQueue) { IsBackground = true };
+                        Thread theQueue = new Thread(this.StartQueue) {IsBackground = true};
                         theQueue.Start();
                     }
                     catch (Exception exc)
@@ -295,50 +315,50 @@ namespace Handbrake.EncodeQueue
         /// </summary>
         public void Pause()
         {
-            PauseRequested = true;
+            this.PauseRequested = true;
 
-            if (QueuePauseRequested != null)
-                QueuePauseRequested(this, new EventArgs());
+            if (this.QueuePauseRequested != null)
+                this.QueuePauseRequested(this, new EventArgs());
         }
 
         /// <summary>
         /// Run through all the jobs on the queue.
         /// </summary>
-        /// <param name="state"></param>
+        /// <param name="state">Object State</param>
         private void StartQueue(object state)
         {
             // Run through each item on the queue
             while (this.Count != 0)
             {
-                Job encJob = GetNextJob();
+                Job encJob = this.GetNextJob();
                 string query = encJob.Query;
-                WriteQueueStateToFile("hb_queue_recovery.xml"); // Update the queue recovery file
+                this.WriteQueueStateToFile("hb_queue_recovery.xml"); // Update the queue recovery file
 
                 Run(query);
 
                 HbProcess.WaitForExit();
 
                 AddCLIQueryToLog(encJob);
-                CopyLog(LastEncode.Destination);
+                this.CopyLog(this.LastEncode.Destination);
 
                 HbProcess.Close();
                 HbProcess.Dispose();
 
                 IsEncoding = false;
 
-                //Growl
+                // Growl
                 if (Properties.Settings.Default.growlEncode)
                     GrowlCommunicator.Notify("Encode Completed", "Put down that cocktail...\nyour Handbrake encode is done.");
 
-                while (PauseRequested) // Need to find a better way of doing this.
+                while (this.PauseRequested) // Need to find a better way of doing this.
                 {
                     Thread.Sleep(2000);
                 }
             }
-            LastEncode = new Job();
+            this.LastEncode = new Job();
 
-            if (QueueCompleted != null)
-                QueueCompleted(this, new EventArgs());
+            if (this.QueueCompleted != null)
+                this.QueueCompleted(this, new EventArgs());
 
             // After the encode is done, we may want to shutdown, suspend etc.
             Finish();
diff --git a/win/C#/Functions/Win32.cs b/win/C#/Functions/Win32.cs
index b5ca77c06..4b3501782 100644
--- a/win/C#/Functions/Win32.cs
+++ b/win/C#/Functions/Win32.cs
@@ -52,13 +52,43 @@ namespace Handbrake.Functions
         /// </summary>
         public struct MEMORYSTATUS // Unused var's are required here.
         {
+            /// <summary>
+            /// Unknown
+            /// </summary>
             public UInt32 dwLength;
+
+            /// <summary>
+            /// Memory Load
+            /// </summary>
             public UInt32 dwMemoryLoad;
+
+            /// <summary>
+            /// </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;
         }
 
diff --git a/win/C#/HandBrakeCS.5.0.ReSharper b/win/C#/HandBrakeCS.5.0.ReSharper
index 8565476d6..780744878 100644
--- a/win/C#/HandBrakeCS.5.0.ReSharper
+++ b/win/C#/HandBrakeCS.5.0.ReSharper
@@ -104,6 +104,8 @@
       <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="EnumMember" />
       <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="Other" />
       <Abbreviation Text="CLI" />
+      <Abbreviation Text="DRC" />
+      <Abbreviation Text="ID" />
     </Naming2>
   </CodeStyleSettings>
 </Configuration>
\ No newline at end of file
diff --git a/win/C#/Model/AudioTrack.cs b/win/C#/Model/AudioTrack.cs
index 822488b8e..410cfa59e 100644
--- a/win/C#/Model/AudioTrack.cs
+++ b/win/C#/Model/AudioTrack.cs
@@ -1,8 +1,7 @@
 /*  AudioTrack.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. */
+    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.Model
 {
@@ -12,46 +11,47 @@ namespace Handbrake.Model
     public class AudioTrack
     {
         /// <summary>
+        /// Initializes a new instance of the <see cref="AudioTrack"/> class. 
         /// Audio Track instance
         /// </summary>
         public AudioTrack()
         {
             // Default Values
-            Track = "Automatic";
-            MixDown = "Automatic";
-            SampleRate = "Auto";
-            Bitrate = "Auto";
-            DRC = "1";
+            this.Track = "Automatic";
+            this.MixDown = "Automatic";
+            this.SampleRate = "Auto";
+            this.Bitrate = "Auto";
+            this.DRC = "1";
         }
 
         /// <summary>
-        /// Audio Track Name
+        /// Gets or sets Audio Track Name
         /// </summary>
         public string Track { get; set; }
 
         /// <summary>
-        /// Audio Mixdown
+        /// Gets or sets Audio Mixdown
         /// </summary>
         public string MixDown { get; set; }
 
         /// <summary>
-        /// Audio Encoder
+        /// Gets or sets Audio Encoder
         /// </summary>
         public string Encoder { get; set; }
 
         /// <summary>
-        /// Audio Bitrate
+        /// Gets or sets Audio Bitrate
         /// </summary>
         public string Bitrate { get; set; }
 
         /// <summary>
-        /// Audio SampleRate
+        /// Gets or sets Audio SampleRate
         /// </summary>
         public string SampleRate { get; set; }
 
         /// <summary>
-        /// Dynamic Range Compression
+        /// Gets or sets Dynamic Range Compression
         /// </summary>
         public string DRC { get; set; }
     }
-}
+}
\ No newline at end of file
diff --git a/win/C#/Model/DriveInformation.cs b/win/C#/Model/DriveInformation.cs
index 9367e7e50..8db3ed8f8 100644
--- a/win/C#/Model/DriveInformation.cs
+++ b/win/C#/Model/DriveInformation.cs
@@ -1,20 +1,22 @@
 /*  DriveInformation.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. */
+    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.Model
 {
+    /// <summary>
+    /// Information about a DVD drive
+    /// </summary>
     public class DriveInformation
     {
         /// <summary>
-        /// The Drive Volume Name
+        /// Gets or sets The Drive Volume Name
         /// </summary>
         public string VolumeLabel { get; set; }
 
         /// <summary>
-        /// The Root Directory
+        /// Gets or sets The Root Directory
         /// </summary>
         public string RootDirectory { get; set; }
     }
diff --git a/win/C#/Model/SourceType.cs b/win/C#/Model/SourceType.cs
index c5a1bf417..4cc8b416d 100644
--- a/win/C#/Model/SourceType.cs
+++ b/win/C#/Model/SourceType.cs
@@ -1,11 +1,13 @@
 /*  SourceType.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. */
+    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.Model
 {
+    /// <summary>
+    /// The Type of source that the user has scanned
+    /// </summary>
     public enum SourceType
     {
         /// <summary>
diff --git a/win/C#/Model/Subtitle.cs b/win/C#/Model/Subtitle.cs
index 0eead5908..9254ab438 100644
--- a/win/C#/Model/Subtitle.cs
+++ b/win/C#/Model/Subtitle.cs
@@ -1,89 +1,86 @@
 /*  Subtitle.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. */
-using System.Windows.Forms;
+    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.Model
 {
+    using System.Windows.Forms;
+
     /// <summary>
     /// Subtitle Information
     /// </summary>
     public class SubtitleInfo
     {
         /// <summary>
-        /// Subtitle Track
+        /// Gets or sets the Subtitle Track
         /// </summary>
         public string Track { get; set; }
 
         /// <summary>
-        /// Forced Subtitle
+        /// Gets or sets the Forced Subtitle
         /// </summary>
         public string Forced { get; set; }
 
         /// <summary>
-        /// Burned In Subtitle
+        /// Gets or sets the Burned In Subtitle
         /// </summary>
         public string Burned { get; set; }
 
         /// <summary>
-        /// Default Subtitle Track
+        /// Gets or sets the Default Subtitle Track
         /// </summary>
         public string Default { get; set; }
 
         /// <summary>
-        /// SRT Language
+        /// Gets or sets the SRT Language
         /// </summary>
         public string SrtLang { get; set; }
 
         /// <summary>
-        /// SRT Character Code
+        /// Gets or sets the SRT Character Code
         /// </summary>
         public string SrtCharCode { get; set; }
 
         /// <summary>
-        /// SRT Offset
+        /// Gets or sets the SRT Offset
         /// </summary>
         public int SrtOffset { get; set; }
 
         /// <summary>
-        /// Path to the SRT file
+        /// Gets or sets the Path to the SRT file
         /// </summary>
         public string SrtPath { get; set; }
 
         /// <summary>
-        /// SRT Filename
+        /// Gets or sets the SRT Filename
         /// </summary>
         public string SrtFileName { get; set; }
 
         /// <summary>
-        /// Returns if this is an SRT subtitle.
+        /// Gets a value indicating whether this is an SRT subtitle.
         /// </summary>
         public bool IsSrtSubtitle
         {
-            get
-            {
-                return SrtFileName != "-";
-            }
+            get { return this.SrtFileName != "-"; }
         }
 
         /// <summary>
-        /// A ListViewItem Containing information about this subitlte
+        /// Gets A ListViewItem Containing information about this subitlte
         /// </summary>
         public ListViewItem ListView
         {
             get
             {
-                ListViewItem listTrack = new ListViewItem(Track);
-                listTrack.SubItems.Add(Forced);
-                listTrack.SubItems.Add(Burned);
-                listTrack.SubItems.Add(Default);
-                listTrack.SubItems.Add(SrtLang);
-                listTrack.SubItems.Add(SrtCharCode);
-                listTrack.SubItems.Add(SrtOffset.ToString());
+                var listTrack = new ListViewItem(this.Track);
+                listTrack.SubItems.Add(this.Forced);
+                listTrack.SubItems.Add(this.Burned);
+                listTrack.SubItems.Add(this.Default);
+                listTrack.SubItems.Add(this.SrtLang);
+                listTrack.SubItems.Add(this.SrtCharCode);
+                listTrack.SubItems.Add(this.SrtOffset.ToString());
                 return listTrack;
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/win/C#/Program.cs b/win/C#/Program.cs
index 282f9f528..805d339af 100644
--- a/win/C#/Program.cs
+++ b/win/C#/Program.cs
@@ -1,23 +1,25 @@
-/*  Program.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. */
-
-using System;
-using System.Windows.Forms;
-using System.IO;
-using Handbrake.Presets;
+/*  Program.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
 {
-    static class Program
+    using System;
+    using System.IO;
+    using System.Windows.Forms;
+    using Presets;
+
+    /// <summary>
+    /// HandBrake Starts Here
+    /// </summary>
+    public static class Program
     {
         /// <summary>
         /// The main entry point for the application.
         /// </summary>
         [STAThread]
-        static void Main()
+        public static void Main()
         {
             Screen scr = Screen.PrimaryScreen;
             if ((scr.Bounds.Width < 1024) || (scr.Bounds.Height < 620))
@@ -40,5 +42,4 @@ namespace Handbrake
             }
         }
     }
-
 }
\ No newline at end of file
diff --git a/win/C#/Settings.StyleCop b/win/C#/Settings.StyleCop
index e6b8a0684..5b5f06b1c 100644
--- a/win/C#/Settings.StyleCop
+++ b/win/C#/Settings.StyleCop
@@ -2,6 +2,13 @@
   <GlobalSettings>
     <StringProperty Name="MergeSettingsFiles">NoMerge</StringProperty>
   </GlobalSettings>
+  <Parsers>
+    <Parser ParserId="Microsoft.StyleCop.CSharp.CsParser">
+      <ParserSettings>
+        <BooleanProperty Name="AnalyzeDesignerFiles">False</BooleanProperty>
+      </ParserSettings>
+    </Parser>
+  </Parsers>
   <Analyzers>
     <Analyzer AnalyzerId="Microsoft.StyleCop.CSharp.DocumentationRules">
       <Rules>
@@ -45,6 +52,11 @@
             <BooleanProperty Name="Enabled">False</BooleanProperty>
           </RuleSettings>
         </Rule>
+        <Rule Name="DocumentationTextMustContainWhitespace">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
       </Rules>
       <AnalyzerSettings>
         <StringProperty Name="CompanyName">HandBrake Project</StringProperty>
diff --git a/win/C#/frmMain.Designer.cs b/win/C#/frmMain.Designer.cs
index e40022c24..dad2201f2 100644
--- a/win/C#/frmMain.Designer.cs
+++ b/win/C#/frmMain.Designer.cs
@@ -1077,7 +1077,7 @@ namespace Handbrake
             this.x264Panel.Name = "x264Panel";
             this.x264Panel.Size = new System.Drawing.Size(720, 306);
             this.x264Panel.TabIndex = 0;
-            this.x264Panel.X264Query = "";
+            this.x264Panel.X264Query = " -x ";
             // 
             // tab_query
             // 
-- 
cgit v1.2.3