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

12 files changed, 390 insertions, 288 deletions

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)

             {

@@ -199,79 +249,21 @@ 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

             //