X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=win%2FC%23%2FfrmMain.cs;h=184af65a6413f6cc138321c0230796f727955fe9;hb=01adcc9f552746e1c6b4503c78d4c27891d68f68;hp=822e8a734d3ba9fd91aa0f8287bc1665fbc8e8da;hpb=7aae4579f0684036317f2cebfe2b50f8364ed554;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/win/C#/frmMain.cs b/win/C#/frmMain.cs
index 822e8a73..184af65a 100644
--- a/win/C#/frmMain.cs
+++ b/win/C#/frmMain.cs
@@ -1,144 +1,209 @@
 /*  frmMain.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.Drawing;
-using System.Globalization;
-using System.Windows.Forms;
-using System.IO;
-using System.Diagnostics;
-using System.Threading;
-using Handbrake.EncodeQueue;
-using Handbrake.Functions;
-using Handbrake.Presets;
-using Handbrake.Parsing;
+    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
 {
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Diagnostics;
+    using System.Drawing;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Threading;
+    using System.Windows.Forms;
+
+    using DevExpress.Utils.Menu;
+
+    using Functions;
+
+    using HandBrake.ApplicationServices.EventArgs;
+    using HandBrake.ApplicationServices.Utilities;
+    using HandBrake.Framework.Model;
+    using HandBrake.Framework.Services;
+    using HandBrake.Framework.Views;
+    using HandBrake.ApplicationServices.Functions;
+    using HandBrake.ApplicationServices.Model;
+    using HandBrake.ApplicationServices.Parsing;
+    using HandBrake.ApplicationServices.Services;
+    using HandBrake.ApplicationServices.Services.Interfaces;
+
+    using Handbrake.ToolWindows;
+
+    using Model;
+    using Properties;
+
+    using Main = Handbrake.Functions.Main;
+
+    /// <summary>
+    /// The Main Window
+    /// </summary>
     public partial class frmMain : Form
     {
         // Objects which may be used by one or more other objects *************
-        Queue encodeQueue = new Queue();
-        PresetsHandler presetHandler = new PresetsHandler();
-        QueryGenerator queryGen = new QueryGenerator();
+        private IQueueProcessor queueProcessor = new QueueProcessor(Program.InstanceId);
+        private PresetService presetHandler = new PresetService();
 
-        // Globals: Mainly used for tracking. *********************************
-        public Title selectedTitle;
+        // Windows ************************************************************
         private frmQueue queueWindow;
         private frmPreview qtpreview;
-        private frmActivityWindow ActivityWindow;
-        private Form splash;
+        private frmActivityWindow activityWindow;
+
+        // Globals: Mainly used for tracking. *********************************
+        public Title selectedTitle;
         public string sourcePath;
-        private string lastAction;
         private SourceType selectedSourceType;
         private string dvdDrivePath;
         private string dvdDriveLabel;
-        private Preset CurrentlySelectedPreset;
-        private DVD currentSource;
+        private Preset currentlySelectedPreset;
+        private Source currentSource;
+
+        private IScan SourceScan;
+        private List<DriveInformation> drives;
+        private QueueTask queueEdit;
 
         // Delegates **********************************************************
         private delegate void UpdateWindowHandler();
 
         // Applicaiton Startup ************************************************
 
-        #region Application Startup
-        public frmMain()
+        #region Properties
+
+        /// <summary>
+        /// Gets SourceName.
+        /// </summary>
+        public string SourceName
         {
-            // Load and setup the splash screen in this thread
-            splash = new frmSplashScreen();
-            splash.Show(this);
-            Label lblStatus = new Label { Size = new Size(150, 20), Location = new Point(182, 102) };
-            splash.Controls.Add(lblStatus);
+            get
+            {
+                if (this.selectedSourceType == SourceType.DvdDrive)
+                {
+                    return this.dvdDriveLabel;
+                }
+
+                if (selectedTitle != null && !string.IsNullOrEmpty(selectedTitle.SourceName))
+                {
+                    return Path.GetFileName(selectedTitle.SourceName);
+                }
 
+                // We have a drive, selected as a folder.
+                if (this.sourcePath.EndsWith("\\"))
+                {
+                    drives = UtilityService.GetDrives();
+                    foreach (DriveInformation item in drives)
+                    {
+                        if (item.RootDirectory.Contains(this.sourcePath))
+                        {
+                            return item.VolumeLabel;
+                        }
+                    }
+                }
+
+                if (Path.GetFileNameWithoutExtension(this.sourcePath) != "VIDEO_TS")
+                    return Path.GetFileNameWithoutExtension(this.sourcePath);
+
+                return Path.GetFileNameWithoutExtension(Path.GetDirectoryName(this.sourcePath));
+            }
+        }
+
+        #endregion
+
+        #region Application Startup
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="frmMain"/> class.
+        /// </summary>
+        /// <param name="args">
+        /// The arguments passed in on application startup.
+        /// </param>
+        public frmMain(string[] args)
+        {
             InitializeComponent();
+            this.presetsToolStrip.Renderer = new ToolStripRenderOverride();
+
+            // We can use LibHB, if the library hb.dll exists.
+            this.SourceScan = File.Exists("hb.dll") ? (IScan)new LibScan() : new ScanService();
 
             // Update the users config file with the CLI version data.
-            lblStatus.Text = "Setting Version Data ...";
-            Application.DoEvents();
             Main.SetCliVersionData();
 
-            // Show the form, but leave disabled until preloading is complete then show the main form
-            this.Enabled = false;
-            this.Show();
-            Application.DoEvents(); // Forces frmMain to draw
+            if (Settings.Default.hb_version.Contains("svn"))
+            {
+                this.Text += " " + Settings.Default.hb_version;
+            }
 
             // Check for new versions, if update checking is enabled
-            if (Properties.Settings.Default.updateStatus)
+            if (Settings.Default.updateStatus)
             {
-                DateTime now = DateTime.Now;
-                DateTime lastCheck = Properties.Settings.Default.lastUpdateCheckDate;
-                TimeSpan elapsed = now.Subtract(lastCheck);
-                if (elapsed.TotalDays > Properties.Settings.Default.daysBetweenUpdateCheck)
+                if (DateTime.Now.Subtract(Settings.Default.lastUpdateCheckDate).TotalDays > Properties.Settings.Default.daysBetweenUpdateCheck)
                 {
-                    lblStatus.Text = "Checking for updates ...";
-                    Application.DoEvents();
-
-                    Main.BeginCheckForUpdates(new AsyncCallback(UpdateCheckDone), false);
+                    // Set when the last update was
+                    Settings.Default.lastUpdateCheckDate = DateTime.Now;
+                    Settings.Default.Save();
+                    string url = Settings.Default.hb_build.ToString().EndsWith("1")
+                                                  ? Settings.Default.appcast_unstable
+                                                  : Settings.Default.appcast;
+                    UpdateService.BeginCheckForUpdates(new AsyncCallback(UpdateCheckDone), false, url, Settings.Default.hb_build, Settings.Default.skipversion, Settings.Default.hb_version);
                 }
             }
 
+            // Clear the log files in the background
+            if (Settings.Default.clearOldLogs)
+            {
+                Thread clearLog = new Thread(() => UtilityService.ClearLogFiles(30));
+                clearLog.Start();
+            }
+
             // Setup the GUI components
-            lblStatus.Text = "Setting up the GUI ...";
-            Application.DoEvents();
-            loadPresetPanel();                       // Load the Preset Panel
+            LoadPresetPanel(); // Load the Preset Panel
             treeView_presets.ExpandAll();
-            lbl_encode.Text = "";
+            lbl_encode.Text = string.Empty;
             drop_mode.SelectedIndex = 0;
-            queueWindow = new frmQueue(encodeQueue);        // Prepare the Queue
-            if (!Properties.Settings.Default.QueryEditorTab)
+            queueWindow = new frmQueue(this.queueProcessor, this); // Prepare the Queue
+            if (!Settings.Default.QueryEditorTab)
                 tabs_panel.TabPages.RemoveAt(7); // Remove the query editor tab if the user does not want it enabled.
+            if (Settings.Default.tooltipEnable)
+                ToolTip.Active = true;
 
             // Load the user's default settings or Normal Preset
-            if (Properties.Settings.Default.defaultPreset != "")
+            if (Settings.Default.defaultPreset != string.Empty && presetHandler.GetPreset(Properties.Settings.Default.defaultPreset) != null)
             {
-                if (presetHandler.GetPreset(Properties.Settings.Default.defaultPreset) != null)
+                string query = presetHandler.GetPreset(Settings.Default.defaultPreset).Query;
+                if (query != null)
                 {
-                    string query = presetHandler.GetPreset(Properties.Settings.Default.defaultPreset).Query;
-                    Boolean loadPictureSettings = presetHandler.GetPreset(Properties.Settings.Default.defaultPreset).PictureSettings;
-
-                    if (query != null)
-                    {
-                        //Ok, Reset all the H264 widgets before changing the preset
-                        x264Panel.reset2Defaults();
+                    x264Panel.Reset2Defaults();
 
-                        // Send the query from the file to the Query Parser class, then load the preset
-                        QueryParser presetQuery = QueryParser.Parse(query);
-                        PresetLoader.presetLoader(this, presetQuery, Properties.Settings.Default.defaultPreset, loadPictureSettings);
+                    EncodeTask presetQuery = QueryParserUtility.Parse(query);
+                    PresetLoader.LoadPreset(this, presetQuery, Settings.Default.defaultPreset);
 
-                        // The x264 widgets will need updated, so do this now:
-                        x264Panel.X264_StandardizeOptString();
-                        x264Panel.X264_SetCurrentSettingsInPanel();
-                    }
+                    x264Panel.StandardizeOptString();
+                    x264Panel.SetCurrentSettingsInPanel();
                 }
-                else
-                    loadNormalPreset();
             }
             else
                 loadNormalPreset();
 
-            // Enabled GUI tooltip's if Required
-            if (Properties.Settings.Default.tooltipEnable)
-                ToolTip.Active = true;
-
             // Register with Growl (if not using Growl for the encoding completion action, this wont hurt anything)
             GrowlCommunicator.Register();
 
-            //Finished Loading
-            lblStatus.Text = "Loading Complete!";
-            Application.DoEvents();
-            splash.Close();
-            splash.Dispose();
-            this.Enabled = true;
-
             // Event Handlers and Queue Recovery
             events();
-            queueRecovery();
+            Main.RecoverQueue(this.queueProcessor);
+
+            // If have a file passed in via command arguemtents, check it's a file and try scanning it.
+            if (args.Length >= 1 && (File.Exists(args[0]) || Directory.Exists(args[0])))
+            {
+                this.StartScan(args[0], 0);
+            }
         }
 
+        /// <summary>
+        /// When the update check is done, process the results.
+        /// </summary>
+        /// <param name="result">IAsyncResult result</param>
         private void UpdateCheckDone(IAsyncResult result)
         {
             if (InvokeRequired)
@@ -147,64 +212,27 @@ namespace Handbrake
                 return;
             }
 
-            UpdateCheckInformation info;
-
             try
             {
-                info = Main.EndCheckForUpdates(result);
+                UpdateCheckInformation info = UpdateService.EndCheckForUpdates(result);
 
                 if (info.NewVersionAvailable)
                 {
-                    frmUpdater updateWindow = new frmUpdater(info.BuildInformation);
+                    UpdateInfo updateWindow = new UpdateInfo(info.BuildInformation, Settings.Default.hb_version, Settings.Default.hb_build.ToString());
                     updateWindow.ShowDialog();
                 }
             }
             catch (Exception ex)
             {
                 if ((bool)result.AsyncState)
-                    MessageBox.Show("Unable to check for updates, Please try again later.\n\nDetailed Error Information:\n" + ex, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                    Main.ShowExceptiowWindow("Unable to check for updates, Please try again later.", ex.ToString());
             }
         }
 
-        // Startup Functions   
-        private void queueRecovery()
-        {
-            if (Main.CheckQueueRecovery())
-            {
-                DialogResult result = MessageBox.Show("HandBrake has detected unfinished items on the queue from the last time the application was launched. Would you like to recover these?", "Queue Recovery Possible", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
-
-                if (result == DialogResult.Yes)
-                    encodeQueue.LoadQueueFromFile("hb_queue_recovery.xml"); // Start Recovery
-                else
-                {
-                    // Remove the Queue recovery file if the user doesn't want to recovery the last queue.
-                    string queuePath = Path.Combine(Path.GetTempPath(), "hb_queue_recovery.xml");
-                    if (File.Exists(queuePath))
-                        File.Delete(queuePath);
-                }
-            }
-        }
-        #endregion
-
-        #region Properties
-        public string SourceName
-        {
-            get
-            {
-                if (this.selectedSourceType == SourceType.DvdDrive)
-                {
-                    return this.dvdDriveLabel;
-                }
-
-                if (Path.GetFileNameWithoutExtension(this.sourcePath) != "VIDEO_TS")
-                    return Path.GetFileNameWithoutExtension(this.sourcePath);
-
-                return Path.GetFileNameWithoutExtension(Path.GetDirectoryName(this.sourcePath));
-            }
-        }
         #endregion
 
         #region Events
+
         // Encoding Events for setting up the GUI
         private void events()
         {
@@ -212,80 +240,83 @@ namespace Handbrake
             RegisterPresetEventHandler();
 
             // Handle Window Resize
-            if (Properties.Settings.Default.MainWindowMinimize)
-                this.Resize += new EventHandler(frmMain_Resize);
+            if (Settings.Default.MainWindowMinimize)
+                this.Resize += this.frmMain_Resize;
 
             // Handle Encode Start / Finish / Pause
-            encodeQueue.CurrentJobCompleted += new EventHandler(encodeEnded);
-            encodeQueue.QueuePauseRequested += new EventHandler(encodePaused);
-            encodeQueue.NewJobStarted += new EventHandler(encodeStarted);
+            this.queueProcessor.EncodeService.EncodeStarted += this.encodeStarted;
+            this.queueProcessor.EncodeService.EncodeCompleted += encodeEnded;
+
+            // Scan Started and Completed Events
+            SourceScan.ScanStatusChanged += this.SourceScanScanStatusChanged;
+            SourceScan.ScanCompleted += this.SourceScanScanCompleted;
 
             // Handle a file being draged onto the GUI.
-            this.DragEnter += new DragEventHandler(frmMain_DragEnter);
-            this.DragDrop += new DragEventHandler(frmMain_DragDrop);
+            this.DragEnter += frmMain_DragEnter;
+            this.DragDrop += this.frmMain_DragDrop;
         }
 
         // Change the preset label to custom when a user changes a setting. Don't want to give the impression that users can change settings and still be using a preset
         private void RegisterPresetEventHandler()
         {
             // Output Settings
-            drop_format.SelectedIndexChanged += new EventHandler(changePresetLabel);
-            check_largeFile.CheckedChanged += new EventHandler(changePresetLabel);
-            check_iPodAtom.CheckedChanged += new EventHandler(changePresetLabel);
-            check_optimiseMP4.CheckedChanged += new EventHandler(changePresetLabel);
+            drop_format.SelectedIndexChanged += this.changePresetLabel;
+            check_largeFile.CheckedChanged += this.changePresetLabel;
+            check_iPodAtom.CheckedChanged += this.changePresetLabel;
+            check_optimiseMP4.CheckedChanged += this.changePresetLabel;
 
             // Picture Settings
-            //PictureSettings.PictureSettingsChanged += new EventHandler(changePresetLabel);
+            PictureSettings.PictureSettingsChanged += this.changePresetLabel;
 
             // Filter Settings
-            Filters.FilterSettingsChanged += new EventHandler(changePresetLabel);
+            Filters.FilterSettingsChanged += this.changePresetLabel;
 
             // Video Tab
-            drp_videoEncoder.SelectedIndexChanged += new EventHandler(changePresetLabel);
-            check_2PassEncode.CheckedChanged += new EventHandler(changePresetLabel);
-            check_turbo.CheckedChanged += new EventHandler(changePresetLabel);
-            text_filesize.TextChanged += new EventHandler(changePresetLabel);
-            text_bitrate.TextChanged += new EventHandler(changePresetLabel);
-            slider_videoQuality.ValueChanged += new EventHandler(changePresetLabel);
+            drp_videoEncoder.SelectedIndexChanged += this.changePresetLabel;
+            check_2PassEncode.CheckedChanged += this.changePresetLabel;
+            check_turbo.CheckedChanged += this.changePresetLabel;
+            text_bitrate.TextChanged += this.changePresetLabel;
+            slider_videoQuality.ValueChanged += this.changePresetLabel;
 
             // Audio Panel
-            AudioSettings.AudioListChanged += new EventHandler(changePresetLabel);
+            AudioSettings.AudioListChanged += this.changePresetLabel;
 
             // Advanced Tab
-            x264Panel.rtf_x264Query.TextChanged += new EventHandler(changePresetLabel);
+            x264Panel.rtf_x264Query.TextChanged += this.changePresetLabel;
         }
+
         private void UnRegisterPresetEventHandler()
         {
             // Output Settings 
-            drop_format.SelectedIndexChanged -= new EventHandler(changePresetLabel);
-            check_largeFile.CheckedChanged -= new EventHandler(changePresetLabel);
-            check_iPodAtom.CheckedChanged -= new EventHandler(changePresetLabel);
-            check_optimiseMP4.CheckedChanged -= new EventHandler(changePresetLabel);
+            drop_format.SelectedIndexChanged -= this.changePresetLabel;
+            check_largeFile.CheckedChanged -= this.changePresetLabel;
+            check_iPodAtom.CheckedChanged -= this.changePresetLabel;
+            check_optimiseMP4.CheckedChanged -= this.changePresetLabel;
 
             // Picture Settings
-            //PictureSettings.PictureSettingsChanged -= new EventHandler(changePresetLabel);
+            PictureSettings.PictureSettingsChanged -= this.changePresetLabel;
 
             // Filter Settings
-            Filters.FilterSettingsChanged -= new EventHandler(changePresetLabel);
+            Filters.FilterSettingsChanged -= this.changePresetLabel;
 
             // Video Tab
-            drp_videoEncoder.SelectedIndexChanged -= new EventHandler(changePresetLabel);
-            check_2PassEncode.CheckedChanged -= new EventHandler(changePresetLabel);
-            check_turbo.CheckedChanged -= new EventHandler(changePresetLabel);
-            text_filesize.TextChanged -= new EventHandler(changePresetLabel);
-            text_bitrate.TextChanged -= new EventHandler(changePresetLabel);
-            slider_videoQuality.ValueChanged -= new EventHandler(changePresetLabel);
+            drp_videoEncoder.SelectedIndexChanged -= this.changePresetLabel;
+            check_2PassEncode.CheckedChanged -= this.changePresetLabel;
+            check_turbo.CheckedChanged -= this.changePresetLabel;
+            text_bitrate.TextChanged -= this.changePresetLabel;
+            slider_videoQuality.ValueChanged -= this.changePresetLabel;
 
             // Audio Panel
-            AudioSettings.AudioListChanged -= new EventHandler(changePresetLabel);
+            AudioSettings.AudioListChanged -= this.changePresetLabel;
 
             // Advanced Tab
-            x264Panel.rtf_x264Query.TextChanged -= new EventHandler(changePresetLabel);
+            x264Panel.rtf_x264Query.TextChanged -= this.changePresetLabel;
         }
+
         private void changePresetLabel(object sender, EventArgs e)
         {
             labelPreset.Text = "Output Settings (Preset: Custom)";
-            CurrentlySelectedPreset = null;
+            this.currentlySelectedPreset = null;
         }
 
         private static void frmMain_DragEnter(object sender, DragEventArgs e)
@@ -293,6 +324,7 @@ namespace Handbrake
             if (e.Data.GetDataPresent(DataFormats.FileDrop, false))
                 e.Effect = DragDropEffects.All;
         }
+
         private void frmMain_DragDrop(object sender, DragEventArgs e)
         {
             string[] fileList = e.Data.GetData(DataFormats.FileDrop) as string[];
@@ -300,7 +332,7 @@ namespace Handbrake
 
             if (fileList != null)
             {
-                if (fileList[0] != "")
+                if (!string.IsNullOrEmpty(fileList[0]))
                 {
                     this.selectedSourceType = SourceType.VideoFile;
                     StartScan(fileList[0], 0);
@@ -311,211 +343,292 @@ namespace Handbrake
             else
                 UpdateSourceLabel();
         }
+
         private void encodeStarted(object sender, EventArgs e)
         {
-            lastAction = "encode";
-            setEncodeStarted();
-
-            // Experimental HBProc Process Monitoring.
-            if (Properties.Settings.Default.enocdeStatusInGui)
-            {
-                Thread encodeMon = new Thread(encodeMonitorThread);
-                encodeMon.Start();
-            }
+            SetEncodeStarted();
+            this.queueProcessor.EncodeService.EncodeStatusChanged += EncodeQueue_EncodeStatusChanged;
         }
+
         private void encodeEnded(object sender, EventArgs e)
         {
-            setEncodeFinished();
-        }
-        private void encodePaused(object sender, EventArgs e)
-        {
-            setEncodeFinished();
+            this.queueProcessor.EncodeService.EncodeStatusChanged -= EncodeQueue_EncodeStatusChanged;
+            SetEncodeFinished();
         }
         #endregion
 
         // User Interface Menus / Tool Strips *********************************
 
         #region File Menu
+
+        /// <summary>
+        /// Kill The scan menu Item
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void mnu_killCLI_Click(object sender, EventArgs e)
         {
             KillScan();
         }
+
+        /// <summary>
+        /// Exit the Application Menu Item
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void mnu_exit_Click(object sender, EventArgs e)
         {
             Application.Exit();
         }
+
         #endregion
 
         #region Tools Menu
+
+        /// <summary>
+        /// Menu - Start Button
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void mnu_encode_Click(object sender, EventArgs e)
         {
             queueWindow.Show();
         }
+
+        /// <summary>
+        /// Menu - Display the Log Window
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void mnu_encodeLog_Click(object sender, EventArgs e)
         {
-            frmActivityWindow dvdInfoWindow = new frmActivityWindow(lastAction);
-            dvdInfoWindow.Show();
+            this.btn_ActivityWindow_Click(this, null);
         }
+
+        /// <summary>
+        /// Menu - Display the Options Window
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void mnu_options_Click(object sender, EventArgs e)
         {
             Form options = new frmOptions(this);
             options.ShowDialog();
         }
-        #endregion
 
-        #region Presets Menu
-        private void mnu_presetReset_Click(object sender, EventArgs e)
-        {
-            presetHandler.UpdateBuiltInPresets();
-            loadPresetPanel();
-            if (treeView_presets.Nodes.Count == 0)
-                MessageBox.Show("Unable to load the presets.xml file. Please select \"Update Built-in Presets\" from the Presets Menu. \nMake sure you are running the program in Admin mode if running on Vista. See Windows FAQ for details!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
-            else
-                MessageBox.Show("Presets have been updated!", "Alert", MessageBoxButtons.OK, MessageBoxIcon.Information);
-
-            treeView_presets.ExpandAll();
-        }
-        private void mnu_delete_preset_Click(object sender, EventArgs e)
-        {
-            presetHandler.RemoveBuiltInPresets();
-            loadPresetPanel(); // Reload the preset panel
-        }
-        private void mnu_SelectDefault_Click(object sender, EventArgs e)
-        {
-            loadNormalPreset();
-        }
-        private void mnu_importMacPreset_Click(object sender, EventArgs e)
-        {
-            importPreset();
-        }
-        private void btn_new_preset_Click(object sender, EventArgs e)
-        {
-            Form preset = new frmAddPreset(this, queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), presetHandler);
-            preset.ShowDialog();
-        }
         #endregion
 
-        #region Help Menu
-        private void mnu_user_guide_Click(object sender, EventArgs e)
+        #region Help Menu (Toolbar)
+
+        /// <summary>
+        ///  Menu - Display the User Guide Web Page
+        /// </summary>
+        /// <param name="sender">The Sender</param>
+        /// <param name="e">The EventArgs</param>
+        private void MnuUserGuide_Click(object sender, EventArgs e)
         {
             Process.Start("http://trac.handbrake.fr/wiki/HandBrakeGuide");
         }
-        private void mnu_handbrake_home_Click(object sender, EventArgs e)
-        {
-            Process.Start("http://handbrake.fr");
-        }
-        private void mnu_UpdateCheck_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Check for Updates
+        /// </summary>
+        /// <param name="sender">The Sender</param>
+        /// <param name="e">The EventArgs</param>
+        private void MnuCheckForUpdates_Click(object sender, EventArgs e)
         {
             lbl_updateCheck.Visible = true;
-            Main.BeginCheckForUpdates(new AsyncCallback(updateCheckDoneMenu), false);
+            Settings.Default.lastUpdateCheckDate = DateTime.Now;
+            Settings.Default.Save();
+            string url = Settings.Default.hb_build.ToString().EndsWith("1")
+                                                  ? Settings.Default.appcast_unstable
+                                                  : Settings.Default.appcast;
+            UpdateService.BeginCheckForUpdates(new AsyncCallback(UpdateCheckDoneMenu), false, url, Settings.Default.hb_build, Settings.Default.skipversion, Settings.Default.hb_version);
         }
-        private void updateCheckDoneMenu(IAsyncResult result)
-        {
-            // Make sure it's running on the calling thread
-            if (InvokeRequired)
-            {
-                Invoke(new MethodInvoker(() => updateCheckDoneMenu(result)));
-                return;
-            }
-            UpdateCheckInformation info;
-            try
-            {
-                // Get the information about the new build, if any, and close the window
-                info = Main.EndCheckForUpdates(result);
 
-                if (info.NewVersionAvailable && info.BuildInformation != null)
-                {
-                    frmUpdater updateWindow = new frmUpdater(info.BuildInformation);
-                    updateWindow.ShowDialog();
-                }
-                else
-                    MessageBox.Show("There are no new updates at this time.", "Update Check", MessageBoxButtons.OK, MessageBoxIcon.Information);
-                lbl_updateCheck.Visible = false;
-                return;
-            }
-            catch (Exception ex)
-            {
-                if ((bool)result.AsyncState)
-                    MessageBox.Show("Unable to check for updates, Please try again later.\n\nDetailed Error Information:\n" + ex, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
-            }
-        }
-        private void mnu_about_Click(object sender, EventArgs e)
+        /// <summary>
+        /// Menu - Display the About Window
+        /// </summary>
+        /// <param name="sender">The Sender</param>
+        /// <param name="e">The EventArgs</param>
+        private void MnuAboutHandBrake_Click(object sender, EventArgs e)
         {
             using (frmAbout About = new frmAbout())
             {
                 About.ShowDialog();
             }
         }
+
         #endregion
 
         #region Preset Bar
-        // Right Click Menu Code
+
+        /// <summary>
+        /// RMenu - Expand All
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void pmnu_expandAll_Click(object sender, EventArgs e)
         {
             treeView_presets.ExpandAll();
         }
+
+        /// <summary>
+        /// RMenu - Collaspe All
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void pmnu_collapse_Click(object sender, EventArgs e)
         {
             treeView_presets.CollapseAll();
         }
+
+        /// <summary>
+        /// Menu - Import Preset
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void pmnu_import_Click(object sender, EventArgs e)
         {
-            importPreset();
+            ImportPreset();
         }
+
+        /// <summary>
+        /// RMenu - Save Changes to Preset
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void pmnu_saveChanges_Click(object sender, EventArgs e)
         {
-            DialogResult result = MessageBox.Show("Do you wish to include picture settings when updating the preset: " + treeView_presets.SelectedNode.Text, "Update Preset", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
-            if (result == DialogResult.Yes)
-                presetHandler.Update(treeView_presets.SelectedNode.Text, QueryGenerator.GenerateTabbedComponentsQuery(this), true);
-            else if (result == DialogResult.No)
-                presetHandler.Update(treeView_presets.SelectedNode.Text, QueryGenerator.GenerateTabbedComponentsQuery(this), false);
+            DialogResult result =
+                MessageBox.Show(
+                    "Do you wish to include picture settings when updating the preset: " +
+                    treeView_presets.SelectedNode.Text, "Update Preset", MessageBoxButtons.YesNoCancel,
+                    MessageBoxIcon.Question);
+
+            Preset preset = new Preset
+                {
+                    Name = this.treeView_presets.SelectedNode.Text,
+                    Query =
+                        QueryGenerator.GenerateQueryForPreset(this, QueryPictureSettingsMode.SourceMaximum, true, 0, 0),
+                    CropSettings = (result == DialogResult.Yes)
+                };
+
+            presetHandler.Update(preset);
         }
+
+        /// <summary>
+        /// RMenu - Delete Preset
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void pmnu_delete_click(object sender, EventArgs e)
         {
             if (treeView_presets.SelectedNode != null)
             {
-                presetHandler.Remove(treeView_presets.SelectedNode.Text);
+                presetHandler.Remove((Preset)treeView_presets.SelectedNode.Tag);
                 treeView_presets.Nodes.Remove(treeView_presets.SelectedNode);
             }
             treeView_presets.Select();
         }
-        private void presets_menu_Opening(object sender, System.ComponentModel.CancelEventArgs e)
+
+        /// <summary>
+        /// Preset Menu Is Opening. Setup the Menu
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void presets_menu_Opening(object sender, CancelEventArgs e)
         {
             // Make sure that the save menu is always disabled by default
             pmnu_saveChanges.Enabled = false;
 
             // Now enable the save menu if the selected preset is a user preset
             if (treeView_presets.SelectedNode != null)
-                if (presetHandler.CheckIfUserPresetExists(treeView_presets.SelectedNode.Text))
+                if (presetHandler.CheckIfPresetExists(treeView_presets.SelectedNode.Text))
                     pmnu_saveChanges.Enabled = true;
 
             treeView_presets.Select();
         }
 
         // Presets Management
-        private void btn_addPreset_Click(object sender, EventArgs e)
+
+        private void BtnAddPreset_Click(object sender, EventArgs e)
         {
-            Form preset = new frmAddPreset(this, QueryGenerator.GenerateTabbedComponentsQuery(this), presetHandler);
-            preset.ShowDialog();
+            Form preset = new frmAddPreset(this, presetHandler);
+            if (preset.ShowDialog() == DialogResult.OK)
+            {
+                TreeNode presetTreeview = new TreeNode(presetHandler.LastPresetAdded.Name) { ForeColor = Color.Black };
+                treeView_presets.Nodes.Add(presetTreeview);
+                presetHandler.LastPresetAdded = null;
+            }
         }
-        private void btn_removePreset_Click(object sender, EventArgs e)
+
+        private void BtnRemovePreset_Click(object sender, EventArgs e)
         {
-            DialogResult result = MessageBox.Show("Are you sure you wish to delete the selected preset?", "Preset", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
+            DialogResult result = MessageBox.Show("Are you sure you wish to delete the selected preset?", "Preset",
+                                                  MessageBoxButtons.YesNo, MessageBoxIcon.Question);
             if (result == DialogResult.Yes)
             {
                 if (treeView_presets.SelectedNode != null)
                 {
-                    presetHandler.Remove(treeView_presets.SelectedNode.Text);
+                    presetHandler.Remove((Preset)treeView_presets.SelectedNode.Tag);
                     treeView_presets.Nodes.Remove(treeView_presets.SelectedNode);
                 }
             }
             treeView_presets.Select();
         }
-        private void btn_setDefault_Click(object sender, EventArgs e)
+
+
+        private void MnuSetDefaultPreset_Click(object sender, EventArgs e)
         {
             if (treeView_presets.SelectedNode != null)
             {
-                DialogResult result = MessageBox.Show("Are you sure you wish to set this preset as the default?", "Preset", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
+                DialogResult result = MessageBox.Show("Are you sure you wish to set this preset as the default?",
+                                                      "Preset", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                 if (result == DialogResult.Yes)
                 {
                     Properties.Settings.Default.defaultPreset = treeView_presets.SelectedNode.Text;
@@ -526,6 +639,40 @@ namespace Handbrake
             else
                 MessageBox.Show("Please select a preset first.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
         }
+
+        private void MnuImportPreset_Click(object sender, EventArgs e)
+        {
+            this.ImportPreset();
+        }
+
+        private void MnuExportPreset_Click(object sender, EventArgs e)
+        {
+            this.ExportPreset();
+        }
+
+        private void MnuResetBuiltInPresets_Click(object sender, EventArgs e)
+        {
+            presetHandler.UpdateBuiltInPresets(string.Empty);
+            LoadPresetPanel();
+            if (treeView_presets.Nodes.Count == 0)
+                MessageBox.Show(
+                    "Unable to load the presets.xml file. Please select \"Update Built-in Presets\" from the Presets Menu. \nMake sure you are running the program in Admin mode if running on Vista. See Windows FAQ for details!",
+                    "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+            else
+                MessageBox.Show("Presets have been updated!", "Alert", MessageBoxButtons.OK, MessageBoxIcon.Information);
+
+            treeView_presets.ExpandAll();
+        }
+
+        /// <summary>
+        /// PresetBar Mouse Down event
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void treeview_presets_mouseUp(object sender, MouseEventArgs e)
         {
             if (e.Button == MouseButtons.Right)
@@ -541,27 +688,71 @@ namespace Handbrake
 
             treeView_presets.Select();
         }
+
+        /// <summary>
+        /// Preset Bar after selecting the preset
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void treeView_presets_AfterSelect(object sender, TreeViewEventArgs e)
         {
             selectPreset();
         }
+
+        /// <summary>
+        /// When the mouse moves, display a preset
+        /// </summary>
+        /// <param name="sender">The Sender</param>
+        /// <param name="e">the MouseEventArgs</param>
+        private void TreeViewPresetsMouseMove(object sender, MouseEventArgs e)
+        {
+            TreeNode theNode = this.treeView_presets.GetNodeAt(e.X, e.Y);
+
+            if ((theNode != null))
+            {
+                // Change the ToolTip only if the pointer moved to a new node.
+                if (theNode.ToolTipText != this.ToolTip.GetToolTip(this.treeView_presets))
+                {
+                    this.ToolTip.SetToolTip(this.treeView_presets, theNode.ToolTipText);
+                }
+            }
+            else     // Pointer is not over a node so clear the ToolTip.
+            {
+                this.ToolTip.SetToolTip(this.treeView_presets, string.Empty);
+            }
+        }
+
+        /// <summary>
+        /// Preset Bar - Handle the Delete Key
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void treeView_presets_deleteKey(object sender, KeyEventArgs e)
         {
             if (e.KeyCode == Keys.Delete)
             {
-                DialogResult result = MessageBox.Show("Are you sure you wish to delete the selected preset?", "Preset", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
+                DialogResult result = MessageBox.Show("Are you sure you wish to delete the selected preset?", "Preset",
+                                                      MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                 if (result == DialogResult.Yes)
                 {
                     if (treeView_presets.SelectedNode != null)
-                        presetHandler.Remove(treeView_presets.SelectedNode.Text);
+                        presetHandler.Remove((Preset)treeView_presets.SelectedNode.Tag);
 
                     // Remember each nodes expanded status so we can reload it
-                    List<Boolean> nodeStatus = new List<Boolean>();
+                    List<bool> nodeStatus = new List<bool>();
                     foreach (TreeNode node in treeView_presets.Nodes)
                         nodeStatus.Add(node.IsExpanded);
 
                     // Now reload the preset panel
-                    loadPresetPanel();
+                    LoadPresetPanel();
 
                     // And finally, re-expand any of the nodes if required
                     int i = 0;
@@ -575,6 +766,10 @@ namespace Handbrake
                 }
             }
         }
+
+        /// <summary>
+        /// Select the selected preset and setup the GUI
+        /// </summary>
         private void selectPreset()
         {
             if (treeView_presets.SelectedNode != null)
@@ -585,30 +780,33 @@ namespace Handbrake
                 if (preset != null)
                 {
                     string query = presetHandler.GetPreset(presetName).Query;
-                    Boolean loadPictureSettings = presetHandler.GetPreset(presetName).PictureSettings;
 
                     if (query != null)
                     {
-                        //Ok, Reset all the H264 widgets before changing the preset
-                        x264Panel.reset2Defaults();
+                        // Ok, Reset all the H264 widgets before changing the preset
+                        x264Panel.Reset2Defaults();
 
                         // Send the query from the file to the Query Parser class
-                        QueryParser presetQuery = QueryParser.Parse(query);
+                        EncodeTask presetQuery = QueryParserUtility.Parse(query);
 
                         // Now load the preset
-                        PresetLoader.presetLoader(this, presetQuery, presetName, loadPictureSettings);
+                        PresetLoader.LoadPreset(this, presetQuery, presetName);
 
                         // The x264 widgets will need updated, so do this now:
-                        x264Panel.X264_StandardizeOptString();
-                        x264Panel.X264_SetCurrentSettingsInPanel();
+                        x264Panel.StandardizeOptString();
+                        x264Panel.SetCurrentSettingsInPanel();
 
                         // Finally, let this window have a copy of the preset settings.
-                        CurrentlySelectedPreset = preset;
+                        this.currentlySelectedPreset = preset;
                         PictureSettings.SetPresetCropWarningLabel(preset);
                     }
                 }
             }
         }
+
+        /// <summary>
+        /// Load the Normal Preset
+        /// </summary>
         private void loadNormalPreset()
         {
             foreach (TreeNode treenode in treeView_presets.Nodes)
@@ -620,83 +818,174 @@ namespace Handbrake
                 }
             }
         }
-        private void importPreset()
+
+        /// <summary>
+        /// Import a plist preset
+        /// </summary>
+        private void ImportPreset()
         {
-            Import imp = new Import();
             if (openPreset.ShowDialog() == DialogResult.OK)
             {
-                QueryParser parsed = imp.importMacPreset(openPreset.FileName);
-                if (presetHandler.CheckIfUserPresetExists(parsed.PresetName + " (Imported)"))
+                EncodeTask parsed = PlistPresetHandler.Import(openPreset.FileName);
+                if (presetHandler.CheckIfPresetExists(parsed.PresetName + " (Imported)"))
                 {
-                    DialogResult result = MessageBox.Show("This preset appears to already exist. Would you like to overwrite it?", "Overwrite preset?",
-                                                           MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
+                    DialogResult result =
+                        MessageBox.Show("This preset appears to already exist. Would you like to overwrite it?",
+                                        "Overwrite preset?",
+                                        MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                     if (result == DialogResult.Yes)
                     {
-                        PresetLoader.presetLoader(this, parsed, parsed.PresetName, parsed.UsesPictureSettings);
-                        presetHandler.Update(parsed.PresetName + " (Imported)", queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null),
-                                                   parsed.UsesPictureSettings);
+                        PresetLoader.LoadPreset(this, parsed, parsed.PresetName);
+
+                        Preset preset = new Preset
+                            {
+                                Name = parsed.PresetName + " (Imported)",
+                                Query = QueryGenerator.GenerateFullQuery(this),
+                                CropSettings = parsed.UsesPictureSettings
+                            };
+
+                        presetHandler.Update(preset);
                     }
                 }
                 else
                 {
-                    PresetLoader.presetLoader(this, parsed, parsed.PresetName, parsed.UsesPictureSettings);
-                    presetHandler.Add(parsed.PresetName, queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), parsed.UsesPictureSettings);
+                    PresetLoader.LoadPreset(this, parsed, parsed.PresetName);
+
+                    Preset preset = new Preset
+                    {
+                        Name = parsed.PresetName + " (Imported)",
+                        Query = QueryGenerator.GenerateFullQuery(this),
+                        CropSettings = parsed.UsesPictureSettings
+                    };
 
-                    if (presetHandler.Add(parsed.PresetName + " (Imported)", queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), parsed.UsesPictureSettings))
+                    if (presetHandler.Add(preset))
                     {
-                        TreeNode preset_treeview = new TreeNode(parsed.PresetName + " (Imported)") { ForeColor = Color.Black };
+                        TreeNode preset_treeview = new TreeNode(parsed.PresetName + " (Imported)")
+                                                       {
+                                                           ForeColor = Color.Black
+                                                       };
                         treeView_presets.Nodes.Add(preset_treeview);
                     }
                 }
             }
         }
+
+        /// <summary>
+        /// Export a plist Preset
+        /// </summary>
+        private void ExportPreset()
+        {
+            SaveFileDialog savefiledialog = new SaveFileDialog { Filter = "plist|*.plist" };
+
+            if (treeView_presets.SelectedNode != null)
+            {
+                if (savefiledialog.ShowDialog() == DialogResult.OK)
+                {
+                    Preset preset = presetHandler.GetPreset(treeView_presets.SelectedNode.Text);
+                    PlistPresetHandler.Export(savefiledialog.FileName, preset);
+                }
+            }
+        }
+
         #endregion
 
         #region ToolStrip
+
+        /// <summary>
+        /// Toolbar - When the Source button is clicked, Clear any DVD drives and add any available DVD drives that can be used as a source.
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void btn_source_Click(object sender, EventArgs e)
         {
-            mnu_dvd_drive.Visible = true;
-            Thread driveInfoThread = new Thread(getDriveInfoThread);
+            // Remove old Drive Menu Items.
+            List<ToolStripMenuItem> itemsToRemove = new List<ToolStripMenuItem>();
+            foreach (var item in btn_source.DropDownItems)
+            {
+                if (item.GetType() == typeof(ToolStripMenuItem))
+                {
+                    ToolStripMenuItem menuItem = (ToolStripMenuItem)item;
+                    if (menuItem.Name.StartsWith("Drive"))
+                    {
+                        itemsToRemove.Add(menuItem);
+                    }
+                }
+            }
+
+            foreach (ToolStripMenuItem item in itemsToRemove)
+                btn_source.DropDownItems.Remove(item);
+
+            Thread driveInfoThread = new Thread(SetDriveSelectionMenuItem);
             driveInfoThread.Start();
         }
+
+        /// <summary>
+        /// Toolbar - Start The Encode
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void btn_start_Click(object sender, EventArgs e)
         {
             if (btn_start.Text == "Stop")
             {
-                DialogResult result = MessageBox.Show("Are you sure you wish to cancel the encode?", "Cancel Encode?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
+                DialogResult result = !Properties.Settings.Default.showCliForInGuiEncodeStatus
+                             ? MessageBox.Show(
+                                 "Are you sure you wish to cancel the encode?\n\nPlease note: Stopping this encode will render the file unplayable. ",
+                                 "Cancel Encode?",
+                                 MessageBoxButtons.YesNo,
+                                 MessageBoxIcon.Question)
+                             : MessageBox.Show(
+                                 "Are you sure you wish to cancel the encode?",
+                                 "Cancel Encode?",
+                                 MessageBoxButtons.YesNo,
+                                 MessageBoxIcon.Question);
 
                 if (result == DialogResult.Yes)
                 {
                     // Pause The Queue
-                    encodeQueue.Pause();
-
-                    // Allow the CLI to exit cleanly
-                    Win32.SetForegroundWindow((int)encodeQueue.ProcessHandle);
-                    SendKeys.Send("^C");
+                    this.queueProcessor.Pause();
 
-                    // Update the GUI
-                    setEncodeFinished();
+                    if (Settings.Default.showCliForInGuiEncodeStatus)
+                        this.queueProcessor.EncodeService.SafelyStop();
+                    else
+                        this.queueProcessor.EncodeService.Stop();
                 }
             }
             else
             {
-                if (encodeQueue.Count != 0 || (!string.IsNullOrEmpty(sourcePath) && !string.IsNullOrEmpty(text_destination.Text)))
+                // If we have a custom query, then we'll want to figure out what the new source and destination is, otherwise we'll just use the gui components.
+                string jobSourcePath = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetSourceFromQuery(rtf_query.Text) : sourcePath;
+                string jobDestination = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetDestinationFromQuery(rtf_query.Text) : text_destination.Text;
+
+                if (this.queueProcessor.QueueManager.Count != 0 || (!string.IsNullOrEmpty(jobSourcePath) && !string.IsNullOrEmpty(jobDestination)))
                 {
-                    string generatedQuery = queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
-                    string specifiedQuery = rtf_query.Text != "" ? rtf_query.Text : queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
+                    string generatedQuery = QueryGenerator.GenerateFullQuery(this);
+                    string specifiedQuery = rtf_query.Text != string.Empty
+                                                ? rtf_query.Text
+                                                : QueryGenerator.GenerateFullQuery(this);
                     string query = string.Empty;
 
                     // Check to make sure the generated query matches the GUI settings
-                    if (Properties.Settings.Default.PromptOnUnmatchingQueries && !string.IsNullOrEmpty(specifiedQuery) && generatedQuery != specifiedQuery)
+                    if (Properties.Settings.Default.PromptOnUnmatchingQueries && !string.IsNullOrEmpty(specifiedQuery) &&
+                        generatedQuery != specifiedQuery)
                     {
                         DialogResult result = MessageBox.Show("The query under the \"Query Editor\" tab " +
-                            "does not match the current GUI settings.\n\nBecause the manual query takes " +
-                            "priority over the GUI, your recently updated settings will not be taken " +
-                            "into account when encoding this job." + Environment.NewLine + Environment.NewLine +
-                            "Do you want to replace the manual query with the updated GUI-generated query?",
-                            "Manual Query does not Match GUI",
-                            MessageBoxButtons.YesNoCancel, MessageBoxIcon.Asterisk,
-                            MessageBoxDefaultButton.Button3);
+                                                              "does not match the current GUI settings.\n\nBecause the manual query takes " +
+                                                              "priority over the GUI, your recently updated settings will not be taken " +
+                                                              "into account when encoding this job." +
+                                                              Environment.NewLine + Environment.NewLine +
+                                                              "Do you want to replace the manual query with the updated GUI-generated query?",
+                                                              "Manual Query does not Match GUI",
+                                                              MessageBoxButtons.YesNoCancel, MessageBoxIcon.Asterisk,
+                                                              MessageBoxDefaultButton.Button3);
 
                         switch (result)
                         {
@@ -720,67 +1009,204 @@ namespace Handbrake
                     }
 
                     DialogResult overwrite = DialogResult.Yes;
-                    if (text_destination.Text != "")
-                        if (File.Exists(text_destination.Text))
-                            overwrite = MessageBox.Show("The destination file already exists. Are you sure you want to overwrite it?", "Overwrite File?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
+                    if (!string.IsNullOrEmpty(jobDestination) && File.Exists(jobDestination))
+                    {
+                        overwrite = MessageBox.Show(
+                                "The destination file already exists. Are you sure you want to overwrite it?",
+                                "Overwrite File?",
+                                MessageBoxButtons.YesNo,
+                                MessageBoxIcon.Question);
+                    }
 
                     if (overwrite == DialogResult.Yes)
                     {
-                        if (encodeQueue.Count == 0)
-                            encodeQueue.Add(query, sourcePath, text_destination.Text, (rtf_query.Text != ""));
+                        QueueTask task = new QueueTask(query)
+                            {
+                                Title = this.GetTitle(),
+                                Source = jobSourcePath,
+                                Destination = jobDestination,
+                                CustomQuery = (this.rtf_query.Text != string.Empty)
+                            };
+
+                        if (this.queueProcessor.QueueManager.Count == 0)
+                            this.queueProcessor.QueueManager.Add(task);
 
                         queueWindow.SetQueue();
-                        if (encodeQueue.Count > 1)
+                        if (this.queueProcessor.QueueManager.Count > 1)
                             queueWindow.Show(false);
 
-                        setEncodeStarted(); // Encode is running, so setup the GUI appropriately
-                        encodeQueue.Start(); // Start The Queue Encoding Process
-                        lastAction = "encode";   // Set the last action to encode - Used for activity window.
+                        SetEncodeStarted(); // Encode is running, so setup the GUI appropriately
+                        this.queueProcessor.Start(); // Start The Queue Encoding Process
                     }
-                    if (ActivityWindow != null)
-                        ActivityWindow.SetEncodeMode();
 
                     this.Focus();
                 }
                 else if (string.IsNullOrEmpty(sourcePath) || string.IsNullOrEmpty(text_destination.Text))
-                    MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                    MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK,
+                                    MessageBoxIcon.Warning);
             }
         }
+
+        /// <summary>
+        /// Toolbar - Add the current job to the Queue
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void btn_add2Queue_Click(object sender, EventArgs e)
         {
-            if (string.IsNullOrEmpty(sourcePath) || string.IsNullOrEmpty(text_destination.Text))
-                MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-            else
+            // Add the item to the queue.
+            AddItemToQueue(true);
+            queueWindow.Show();
+        }
+
+        /// <summary>
+        /// Add Multiple Items to the Queue at once.
+        /// </summary>
+        /// <param name="sender">The Sender</param>
+        /// <param name="e">The EventArgs</param>
+        private void MnuAddMultiToQueueClick(object sender, EventArgs e)
+        {
+            if (!Settings.Default.autoNaming)
+            {
+                MessageBox.Show("Destination Auto Naming must be enabled in preferences for this feature to work.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                return;
+            }
+
+            if (this.SourceScan.SouceData == null)
+            {
+                MessageBox.Show("You must first scan a source or collection of source to use this feature.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                return;
+            }
+
+            BatchAdd batchAdd = new BatchAdd();
+            if (batchAdd.ShowDialog() == DialogResult.OK)
             {
-                String query = queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
-                if (rtf_query.Text != "")
-                    query = rtf_query.Text;
+                int min = batchAdd.Min;
+                int max = batchAdd.Max;
+                bool errors = false;
 
-                if (encodeQueue.CheckForDestinationDuplicate(text_destination.Text))
+                foreach (Title title in this.SourceScan.SouceData.Titles)
                 {
-                    DialogResult result = MessageBox.Show("There is already a queue item for this destination path. \n\n If you continue, the encode will be overwritten. Do you wish to continue?",
-                  "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
-                    if (result == DialogResult.Yes)
-                        encodeQueue.Add(query, sourcePath, text_destination.Text, (rtf_query.Text != ""));
+                    if (title.Duration.TotalMinutes > min && title.Duration.TotalMinutes < max)
+                    {
+                        // Add to Queue
+                        this.drp_dvdtitle.SelectedItem = title;
 
+                        if (!this.AddItemToQueue(false))
+                        {
+                            errors = true;
+                        }
+                    }
                 }
-                else
-                    encodeQueue.Add(query, sourcePath, text_destination.Text, (rtf_query.Text != ""));
 
-                lbl_encode.Text = encodeQueue.Count + " encode(s) pending in the queue";
+                if (errors)
+                {
+                    MessageBox.Show(
+                        "One or more items could not be added to the queue. You should check your queue and manually add any missing jobs.",
+                        "Warning",
+                        MessageBoxButtons.OK,
+                        MessageBoxIcon.Warning);
+                }
+            }
+        }
+
+        private bool AddItemToQueue(bool showError)
+        {
+            string query = QueryGenerator.GenerateFullQuery(this);
+            if (!string.IsNullOrEmpty(rtf_query.Text))
+                query = rtf_query.Text;
+
+            // If we have a custom query, then we'll want to figure out what the new source and destination is, otherwise we'll just use the gui components.
+            string jobSourcePath = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetSourceFromQuery(rtf_query.Text) : sourcePath;
+            string jobDestination = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetDestinationFromQuery(rtf_query.Text) : text_destination.Text;
 
-                queueWindow.Show();
+            // Make sure we have a Source and Destination.
+            if (string.IsNullOrEmpty(jobSourcePath) || string.IsNullOrEmpty(jobDestination))
+            {
+                if (showError)
+                    MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                return false;
             }
+
+            // Make sure the destination path exists.
+            if (!Directory.Exists(Path.GetDirectoryName(jobDestination)))
+            {
+                if (showError)
+                    MessageBox.Show(string.Format("Destination Path does not exist.\nPath: {0}\n\nThis item was not added to the Queue.", Path.GetDirectoryName(jobDestination)), "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                return false;
+            }
+
+            // Make sure we don't have a duplciate on the queue.
+            if (this.queueProcessor.QueueManager.CheckForDestinationPathDuplicates(jobDestination))
+            {
+                if (showError)
+                {
+                    DialogResult result;
+                    result =
+                        MessageBox.Show(
+                            string.Format(
+                                "There is already a queue item for this destination path.\nDestination Path: {0} \n\nIf you continue, the encode will be overwritten. Do you wish to continue?",
+                                jobDestination),
+                            "Warning",
+                            MessageBoxButtons.YesNo,
+                            MessageBoxIcon.Warning);
+
+                    if (result != DialogResult.Yes) return false;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            // Add the job.
+            QueueTask task = new QueueTask(query)
+            {
+                Title = this.GetTitle(),
+                Source = jobSourcePath,
+                Destination = jobDestination,
+                CustomQuery = (this.rtf_query.Text != string.Empty)
+            };
+            this.queueProcessor.QueueManager.Add(task);
+
+            lbl_encode.Text = this.queueProcessor.QueueManager.Count + " encode(s) pending in the queue";
+
+            return true;
         }
+
+        /// <summary>
+        /// Toolbar - Show the Queue
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void btn_showQueue_Click(object sender, EventArgs e)
         {
             queueWindow.Show();
             queueWindow.Activate();
         }
+
+        /// <summary>
+        /// Toolbar - Show the Preview Window
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void tb_preview_Click(object sender, EventArgs e)
         {
             if (string.IsNullOrEmpty(sourcePath) || string.IsNullOrEmpty(text_destination.Text))
-                MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK,
+                                MessageBoxIcon.Warning);
             else
             {
                 if (qtpreview == null)
@@ -794,33 +1220,42 @@ namespace Handbrake
                     qtpreview.Show();
                 }
                 else
-                    MessageBox.Show(qtpreview, "The preview window is already open!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                    MessageBox.Show(qtpreview, "The preview window is already open!", "Warning", MessageBoxButtons.OK,
+                                    MessageBoxIcon.Warning);
             }
         }
+
+        /// <summary>
+        /// Toolbar - Show the Activity log Window
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void btn_ActivityWindow_Click(object sender, EventArgs e)
         {
-            if (ActivityWindow == null || !ActivityWindow.IsHandleCreated)
-                ActivityWindow = new frmActivityWindow(lastAction);
-            else
-                switch (lastAction)
-                {
-                    case "scan":
-                        ActivityWindow.SetScanMode();
-                        break;
-                    case "encode":
-                        ActivityWindow.SetEncodeMode();
-                        break;
-                    default:
-                        ActivityWindow.SetEncodeMode();
-                        break;
-                }
+            if (this.activityWindow == null || !this.activityWindow.IsHandleCreated)
+                this.activityWindow = new frmActivityWindow(this.queueProcessor.EncodeService, SourceScan);
 
-            ActivityWindow.Show();
-            ActivityWindow.Activate();
+            this.activityWindow.Show();
+            this.activityWindow.Activate();
         }
+
         #endregion
 
         #region System Tray Icon
+
+        /// <summary>
+        /// Handle Resizing of the main window when deaing with the Notify Icon
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void frmMain_Resize(object sender, EventArgs e)
         {
             if (FormWindowState.Minimized == this.WindowState)
@@ -831,6 +1266,16 @@ namespace Handbrake
             else if (FormWindowState.Normal == this.WindowState)
                 notifyIcon.Visible = false;
         }
+
+        /// <summary>
+        /// Double Click the Tray Icon
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void notifyIcon_MouseDoubleClick(object sender, MouseEventArgs e)
         {
             this.Visible = true;
@@ -838,6 +1283,16 @@ namespace Handbrake
             this.WindowState = FormWindowState.Normal;
             notifyIcon.Visible = false;
         }
+
+        /// <summary>
+        /// Tray Icon - Restore Menu Item - Resture the Window
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         private void btn_restore_Click(object sender, EventArgs e)
         {
             this.Visible = true;
@@ -845,41 +1300,96 @@ namespace Handbrake
             this.WindowState = FormWindowState.Normal;
             notifyIcon.Visible = false;
         }
+
         #endregion
 
-        #region Tab Control
+        #region Main Window and Tab Control
 
-        //Source
-        private void btn_dvd_source_Click(object sender, EventArgs e)
+        // Source
+        private void BtnFolderScanClicked(object sender, EventArgs e)
         {
+            this.btn_source.HideDropDown();
             if (DVD_Open.ShowDialog() == DialogResult.OK)
             {
                 this.selectedSourceType = SourceType.Folder;
-                SelectSource(DVD_Open.SelectedPath);
+                SelectSource(DVD_Open.SelectedPath, 0);
+            }
+            else
+                UpdateSourceLabel();
+        }
+
+        private void BtnFileScanClicked(object sender, EventArgs e)
+        {
+            this.btn_source.HideDropDown();
+            if (ISO_Open.ShowDialog() == DialogResult.OK)
+            {
+                this.selectedSourceType = SourceType.VideoFile;
+                SelectSource(ISO_Open.FileName, 0);
             }
             else
                 UpdateSourceLabel();
         }
-        private void btn_file_source_Click(object sender, EventArgs e)
+
+        private void MnuDvdDriveClick(object sender, EventArgs e)
+        {
+            ToolStripMenuItem item = sender as ToolStripMenuItem;
+            if (item != null)
+            {
+                string driveId = item.Name.Replace("Drive", string.Empty);
+                int id;
+                if (int.TryParse(driveId, out id))
+                {
+                    this.dvdDrivePath = drives[id].RootDirectory;
+                    this.dvdDriveLabel = drives[id].VolumeLabel;
+
+                    if (this.dvdDrivePath == null) return;
+                    this.selectedSourceType = SourceType.DvdDrive;
+                    SelectSource(this.dvdDrivePath, 0);
+                }
+            }
+        }
+
+        private void VideoTitleSpecificScanClick(object sender, EventArgs e)
         {
+            this.btn_source.HideDropDown();
             if (ISO_Open.ShowDialog() == DialogResult.OK)
             {
                 this.selectedSourceType = SourceType.VideoFile;
-                SelectSource(ISO_Open.FileName);
+
+                int sourceTitle = 0;
+                TitleSpecificScan title = new TitleSpecificScan();
+                if (title.ShowDialog() == DialogResult.OK)
+                {
+                    sourceTitle = title.Title;
+                    SelectSource(ISO_Open.FileName, sourceTitle);
+                }
+            }
+            else
+                UpdateSourceLabel();
+        }
+
+        private void FolderTitleSpecificScanClick(object sender, EventArgs e)
+        {
+            this.btn_source.HideDropDown();
+            if (DVD_Open.ShowDialog() == DialogResult.OK)
+            {
+                this.selectedSourceType = SourceType.Folder;
+
+                int sourceTitle = 0;
+                TitleSpecificScan title = new TitleSpecificScan();
+                if (title.ShowDialog() == DialogResult.OK)
+                {
+                    sourceTitle = title.Title;
+                    SelectSource(DVD_Open.SelectedPath, sourceTitle);
+                }
             }
             else
                 UpdateSourceLabel();
         }
-        private void mnu_dvd_drive_Click(object sender, EventArgs e)
-        {
-            if (this.dvdDrivePath == null) return;
-            this.selectedSourceType = SourceType.DvdDrive;
-            SelectSource(this.dvdDrivePath);
-        }
-        private void SelectSource(string file)
+
+        private void SelectSource(string file, int titleSpecific)
         {
             Check_ChapterMarkers.Enabled = true;
-            lastAction = "scan";
             sourcePath = string.Empty;
 
             if (file == string.Empty) // Must have a file or path
@@ -889,30 +1399,33 @@ namespace Handbrake
             }
 
             sourcePath = Path.GetFileName(file);
-            StartScan(file, 0);
+            StartScan(file, titleSpecific);
         }
+
         private void drp_dvdtitle_Click(object sender, EventArgs e)
         {
             if ((drp_dvdtitle.Items.Count == 1) && (drp_dvdtitle.Items[0].ToString() == "Automatic"))
-                MessageBox.Show("There are no titles to select. Please load a source file by clicking the 'Source' button above before trying to select a title.", "Alert", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
+                MessageBox.Show(
+                    "There are no titles to select. Please load a source file by clicking the 'Source' button above before trying to select a title.",
+                    "Alert", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
         }
+
         private void drp_dvdtitle_SelectedIndexChanged(object sender, EventArgs e)
         {
             UnRegisterPresetEventHandler();
             drop_mode.SelectedIndex = 0;
 
-            PictureSettings.lbl_Aspect.Text = "Select a Title"; // Reset some values on the form
             drop_chapterStart.Items.Clear();
             drop_chapterFinish.Items.Clear();
 
             // If the dropdown is set to automatic nothing else needs to be done.
-            // Otheriwse if its not, title data has to be loased from parsing.
+            // Otheriwse if its not, title data has to be loaded from parsing.
             if (drp_dvdtitle.Text != "Automatic")
             {
                 selectedTitle = drp_dvdtitle.SelectedItem as Title;
                 lbl_duration.Text = selectedTitle.Duration.ToString();
-                PictureSettings.CurrentlySelectedPreset = CurrentlySelectedPreset;
-                PictureSettings.Source = selectedTitle;  // Setup Picture Settings Tab Control
+                PictureSettings.CurrentlySelectedPreset = this.currentlySelectedPreset;
+                PictureSettings.Source = selectedTitle; // Setup Picture Settings Tab Control
 
                 // Populate the Angles dropdown
                 drop_angle.Items.Clear();
@@ -920,7 +1433,16 @@ namespace Handbrake
                 {
                     drop_angle.Visible = true;
                     lbl_angle.Visible = true;
-                    drop_angle.Items.AddRange(selectedTitle.Angles.ToArray());
+
+                    for (int i = 1; i <= selectedTitle.AngleCount; i++)
+                        drop_angle.Items.Add(i.ToString());
+
+                    if (drop_angle.Items.Count == 0)
+                    {
+                        drop_angle.Visible = false;
+                        lbl_angle.Visible = false;
+                    }
+
                     if (drop_angle.Items.Count != 0)
                         drop_angle.SelectedIndex = 0;
                 }
@@ -943,7 +1465,7 @@ namespace Handbrake
                     drop_chapterFinish.Text = drop_chapterFinish.Items[drop_chapterFinish.Items.Count - 1].ToString();
 
                 // Populate the Audio Channels Dropdown
-                AudioSettings.SetTrackList(selectedTitle);
+                AudioSettings.SetTrackListFromPreset(selectedTitle, this.currentlySelectedPreset);
 
                 // Populate the Subtitles dropdown
                 Subtitles.SetSubtitleTrackAuto(selectedTitle.Subtitles.ToArray());
@@ -951,7 +1473,7 @@ namespace Handbrake
             // Update the source label if we have multiple streams
             if (selectedTitle != null)
                 if (!string.IsNullOrEmpty(selectedTitle.SourceName))
-                    labelSource.Text = labelSource.Text = Path.GetFileName(selectedTitle.SourceName);
+                    labelSource.Text = Path.GetFileName(selectedTitle.SourceName);
 
             // Run the AutoName & ChapterNaming functions
             if (Properties.Settings.Default.autoNaming)
@@ -960,13 +1482,15 @@ namespace Handbrake
                 if (autoPath != null)
                     text_destination.Text = autoPath;
                 else
-                    MessageBox.Show("You currently have \"Automatically name output files\" enabled for the destination file box, but you do not have a default directory set.\n\nYou should set a \"Default Path\" in HandBrakes preferences. (See 'Tools' menu -> 'Options' -> 'General' Tab -> 'Default Path')", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                    MessageBox.Show(
+                        "You currently have \"Automatically name output files\" enabled for the destination file box, but you do not have a valid default directory set.\n\nYou should set a \"Default Path\" in HandBrakes preferences. (See 'Tools' menu -> 'Options' -> 'General' Tab -> 'Default Path')",
+                        "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
             }
 
             data_chpt.Rows.Clear();
             if (selectedTitle.Chapters.Count != 1)
             {
-                DataGridView chapterGridView = Main.ChapterNaming(data_chpt, drop_chapterFinish.Text);
+                DataGridView chapterGridView = Main.ChapterNaming(selectedTitle, data_chpt, drop_chapterFinish.Text);
                 if (chapterGridView != null)
                     data_chpt = chapterGridView;
             }
@@ -982,6 +1506,7 @@ namespace Handbrake
 
             RegisterPresetEventHandler();
         }
+
         private void chapersChanged(object sender, EventArgs e)
         {
             if (drop_mode.SelectedIndex != 0) // Function is not used if we are not in chapters mode.
@@ -1030,7 +1555,9 @@ namespace Handbrake
             }
 
             // Update the Duration
-            lbl_duration.Text = Main.CalculateDuration(drop_chapterStart.SelectedIndex, drop_chapterFinish.SelectedIndex, selectedTitle).ToString();
+            lbl_duration.Text =
+                Main.CalculateDuration(drop_chapterStart.SelectedIndex, drop_chapterFinish.SelectedIndex, selectedTitle)
+                    .ToString();
 
             // Run the Autonaming function
             if (Properties.Settings.Default.autoNaming)
@@ -1053,6 +1580,7 @@ namespace Handbrake
                 }
             }
         }
+
         private void SecondsOrFramesChanged(object sender, EventArgs e)
         {
             int start, end;
@@ -1077,11 +1605,12 @@ namespace Handbrake
                     return;
             }
         }
+
         private void drop_mode_SelectedIndexChanged(object sender, EventArgs e)
         {
             // Reset
-            this.drop_chapterFinish.TextChanged -= new System.EventHandler(this.SecondsOrFramesChanged);
-            this.drop_chapterStart.TextChanged -= new System.EventHandler(this.SecondsOrFramesChanged);
+            this.drop_chapterFinish.TextChanged -= new EventHandler(this.SecondsOrFramesChanged);
+            this.drop_chapterStart.TextChanged -= new EventHandler(this.SecondsOrFramesChanged);
 
             // Do Work
             switch (drop_mode.SelectedIndex)
@@ -1098,8 +1627,8 @@ namespace Handbrake
                         lbl_duration.Text = "--:--:--";
                     return;
                 case 1:
-                    this.drop_chapterStart.TextChanged += new System.EventHandler(this.SecondsOrFramesChanged);
-                    this.drop_chapterFinish.TextChanged += new System.EventHandler(this.SecondsOrFramesChanged);
+                    this.drop_chapterStart.TextChanged += new EventHandler(this.SecondsOrFramesChanged);
+                    this.drop_chapterFinish.TextChanged += new EventHandler(this.SecondsOrFramesChanged);
                     drop_chapterStart.DropDownStyle = ComboBoxStyle.Simple;
                     drop_chapterFinish.DropDownStyle = ComboBoxStyle.Simple;
                     if (selectedTitle != null)
@@ -1109,8 +1638,8 @@ namespace Handbrake
                     }
                     return;
                 case 2:
-                    this.drop_chapterStart.TextChanged += new System.EventHandler(this.SecondsOrFramesChanged);
-                    this.drop_chapterFinish.TextChanged += new System.EventHandler(this.SecondsOrFramesChanged);
+                    this.drop_chapterStart.TextChanged += new EventHandler(this.SecondsOrFramesChanged);
+                    this.drop_chapterFinish.TextChanged += new EventHandler(this.SecondsOrFramesChanged);
                     drop_chapterStart.DropDownStyle = ComboBoxStyle.Simple;
                     drop_chapterFinish.DropDownStyle = ComboBoxStyle.Simple;
                     if (selectedTitle != null)
@@ -1122,7 +1651,7 @@ namespace Handbrake
             }
         }
 
-        //Destination
+        // Destination
         private void btn_destBrowse_Click(object sender, EventArgs e)
         {
             // This removes the file extension from the filename box on the save file dialog.
@@ -1145,7 +1674,7 @@ namespace Handbrake
                 {
                     case 1:
                         if (!Path.GetExtension(DVD_Save.FileName).Equals(".mp4", StringComparison.InvariantCultureIgnoreCase))
-                            if (Properties.Settings.Default.useM4v)
+                            if (Properties.Settings.Default.useM4v == 2 || Properties.Settings.Default.useM4v == 0)
                                 DVD_Save.FileName = DVD_Save.FileName.Replace(".mp4", ".m4v").Replace(".mkv", ".m4v");
                             else
                                 DVD_Save.FileName = DVD_Save.FileName.Replace(".m4v", ".mp4").Replace(".mkv", ".mp4");
@@ -1155,7 +1684,7 @@ namespace Handbrake
                             DVD_Save.FileName = DVD_Save.FileName.Replace(".mp4", ".mkv").Replace(".m4v", ".mkv");
                         break;
                     default:
-                        //do nothing  
+                        // do nothing  
                         break;
                 }
                 text_destination.Text = DVD_Save.FileName;
@@ -1165,6 +1694,7 @@ namespace Handbrake
                     SetExtension(".m4v");
             }
         }
+
         private void text_destination_TextChanged(object sender, EventArgs e)
         {
             string path = text_destination.Text;
@@ -1180,10 +1710,7 @@ namespace Handbrake
             switch (drop_format.SelectedIndex)
             {
                 case 0:
-                    if (Properties.Settings.Default.useM4v || Check_ChapterMarkers.Checked || AudioSettings.RequiresM4V() || Subtitles.RequiresM4V())
-                        SetExtension(".m4v");
-                    else
-                        SetExtension(".mp4");
+                    SetExtension(".mp4");
                     break;
                 case 1:
                     SetExtension(".mkv");
@@ -1191,7 +1718,6 @@ namespace Handbrake
             }
 
             AudioSettings.SetContainer(drop_format.Text);
-            Subtitles.SetContainer(drop_format.SelectedIndex);
 
             if (drop_format.Text.Contains("MP4"))
             {
@@ -1204,11 +1730,12 @@ namespace Handbrake
             else if (drop_format.Text.Contains("MKV"))
                 drp_videoEncoder.Items.Add("VP3 (Theora)");
         }
+
         public void SetExtension(string newExtension)
         {
             if (newExtension == ".mp4" || newExtension == ".m4v")
-                if (Properties.Settings.Default.useM4v || Check_ChapterMarkers.Checked || AudioSettings.RequiresM4V() || Subtitles.RequiresM4V())
-                    newExtension = ".m4v";
+                if (Check_ChapterMarkers.Checked || AudioSettings.RequiresM4V() || Subtitles.RequiresM4V() || Properties.Settings.Default.useM4v == 2) 
+                    newExtension = Properties.Settings.Default.useM4v == 1 ? ".mp4" : ".m4v";
                 else
                     newExtension = ".mp4";
 
@@ -1216,12 +1743,12 @@ namespace Handbrake
                 text_destination.Text = Path.ChangeExtension(text_destination.Text, newExtension);
         }
 
-        //Video Tab
+        // Video Tab
         private void drp_videoEncoder_SelectedIndexChanged(object sender, EventArgs e)
         {
             setContainerOpts();
 
-            //Turn off some options which are H.264 only when the user selects a non h.264 encoder
+            // Turn off some options which are H.264 only when the user selects a non h.264 encoder
             if (drp_videoEncoder.Text.Contains("H.264"))
             {
                 if (check_2PassEncode.CheckState == CheckState.Checked)
@@ -1238,7 +1765,7 @@ namespace Handbrake
                 check_turbo.CheckState = CheckState.Unchecked;
                 check_turbo.Enabled = false;
                 tab_advanced.Enabled = false;
-                x264Panel.x264Query = "";
+                x264Panel.X264Query = string.Empty;
                 check_iPodAtom.Enabled = false;
                 check_iPodAtom.Checked = false;
             }
@@ -1248,7 +1775,7 @@ namespace Handbrake
             {
                 case "MPEG-4 (FFmpeg)":
                     if (slider_videoQuality.Value > 31)
-                        slider_videoQuality.Value = 20;   // Just reset to 70% QP 10 on encode change.
+                        slider_videoQuality.Value = 20; // Just reset to 70% QP 10 on encode change.
                     slider_videoQuality.Minimum = 1;
                     slider_videoQuality.Maximum = 31;
                     break;
@@ -1261,36 +1788,43 @@ namespace Handbrake
                     double multiplier = 1.0 / cqStep;
                     double value = slider_videoQuality.Value * multiplier;
 
-                    switch (Properties.Settings.Default.x264cqstep.ToString(culture))
-                    {
-                        case "0.2":
-                            slider_videoQuality.Maximum = 255;
-                            break;
-                        case "0.25":
-                            slider_videoQuality.Maximum = 204;
-                            break;
-                        case "0.5":
-                            slider_videoQuality.Maximum = 102;
-                            break;
-                        case "1":
-                            slider_videoQuality.Maximum = 51;
-                            break;
-                        default:
-                            slider_videoQuality.Maximum = 51;
-                            break;
-                    }
+                    slider_videoQuality.Maximum = (int)(51 / Properties.Settings.Default.x264cqstep);
+
                     if (value < slider_videoQuality.Maximum)
                         slider_videoQuality.Value = slider_videoQuality.Maximum - (int)value;
 
                     break;
                 case "VP3 (Theora)":
                     if (slider_videoQuality.Value > 63)
-                        slider_videoQuality.Value = 45;  // Just reset to 70% QP 45 on encode change.
+                        slider_videoQuality.Value = 45; // Just reset to 70% QP 45 on encode change.
                     slider_videoQuality.Minimum = 0;
                     slider_videoQuality.Maximum = 63;
                     break;
             }
         }
+
+        /// <summary>
+        /// When the FrameRate is not Same As Source, show the Max/Constant Mode dropdown
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void drp_videoFramerate_SelectedIndexChanged(object sender, EventArgs e)
+        {
+            if (this.drp_videoFramerate.SelectedIndex == 0)
+            {
+                this.checkMaximumFramerate.Visible = false;
+                this.checkMaximumFramerate.CheckState = CheckState.Unchecked;
+            }
+            else
+            {
+                this.checkMaximumFramerate.Visible = true;
+            }
+        }
+
         /// <summary>
         /// Set the container format options
         /// </summary>
@@ -1312,35 +1846,20 @@ namespace Handbrake
                 check_iPodAtom.Checked = false;
             }
         }
-        private double _cachedCqStep = Properties.Settings.Default.x264cqstep;
+
+        private double cachedCqStep = Properties.Settings.Default.x264cqstep;
+
         /// <summary>
         /// Update the CQ slider for x264 for a new CQ step. This is set from option
         /// </summary>
         public void setQualityFromSlider()
         {
             // Work out the current RF value.
-            double cqStep = _cachedCqStep;
+            double cqStep = this.cachedCqStep;
             double rfValue = 51.0 - slider_videoQuality.Value * cqStep;
 
             // Change the maximum value for the slider
-            switch (Properties.Settings.Default.x264cqstep.ToString(new CultureInfo("en-US")))
-            {
-                case "0.2":
-                    slider_videoQuality.Maximum = 255;
-                    break;
-                case "0.25":
-                    slider_videoQuality.Maximum = 204;
-                    break;
-                case "0.5":
-                    slider_videoQuality.Maximum = 102;
-                    break;
-                case "1":
-                    slider_videoQuality.Maximum = 51;
-                    break;
-                default:
-                    slider_videoQuality.Maximum = 51;
-                    break;
-            }
+            slider_videoQuality.Maximum = (int)(51 / Properties.Settings.Default.x264cqstep);
 
             // Reset the CQ slider to RF0
             slider_videoQuality.Value = slider_videoQuality.Maximum;
@@ -1355,63 +1874,46 @@ namespace Handbrake
             }
 
             // Cache the CQ step for the next calculation
-            _cachedCqStep = Properties.Settings.Default.x264cqstep;
+            this.cachedCqStep = Properties.Settings.Default.x264cqstep;
         }
+
         private void slider_videoQuality_Scroll(object sender, EventArgs e)
         {
             double cqStep = Properties.Settings.Default.x264cqstep;
             switch (drp_videoEncoder.Text)
             {
                 case "MPEG-4 (FFmpeg)":
-                    double rfValue = 31 - (slider_videoQuality.Value - 1);
-                    double max = slider_videoQuality.Maximum;
-                    double min = slider_videoQuality.Minimum;
-                    double val = ((max - min) - (rfValue - min)) / (max - min);
                     lbl_SliderValue.Text = "QP:" + (32 - slider_videoQuality.Value);
-                    lbl_qualityValue.Text = Math.Round((val * 100), 2).ToString(new CultureInfo("en-US")) + "%";
                     break;
                 case "H.264 (x264)":
-                    rfValue = 51.0 - slider_videoQuality.Value * cqStep;
-                    max = slider_videoQuality.Maximum * cqStep;
-                    min = slider_videoQuality.Minimum;
-                    val = ((max - min) - (rfValue - min)) / (max - min);
+                    double rfValue = 51.0 - slider_videoQuality.Value * cqStep;
                     rfValue = Math.Round(rfValue, 2);
                     lbl_SliderValue.Text = "RF:" + rfValue.ToString(new CultureInfo("en-US"));
-                    lbl_qualityValue.Text = Math.Round((val * 100), 2).ToString(new CultureInfo("en-US")) + "%";
+                    this.lbl_rfwarn.Visible = rfValue == 0;
                     break;
                 case "VP3 (Theora)":
-                    rfValue = slider_videoQuality.Value;
-                    double value = rfValue / 63;
                     lbl_SliderValue.Text = "QP:" + slider_videoQuality.Value;
-                    lbl_qualityValue.Text = Math.Round((value * 100), 2).ToString(new CultureInfo("en-US")) + "%";
                     break;
             }
         }
-        private void radio_targetFilesize_CheckedChanged(object sender, EventArgs e)
-        {
-            text_bitrate.Enabled = false;
-            text_filesize.Enabled = true;
-            slider_videoQuality.Enabled = false;
 
-            check_2PassEncode.Enabled = true;
-        }
         private void radio_avgBitrate_CheckedChanged(object sender, EventArgs e)
         {
             text_bitrate.Enabled = true;
-            text_filesize.Enabled = false;
             slider_videoQuality.Enabled = false;
 
             check_2PassEncode.Enabled = true;
         }
+
         private void radio_cq_CheckedChanged(object sender, EventArgs e)
         {
             text_bitrate.Enabled = false;
-            text_filesize.Enabled = false;
             slider_videoQuality.Enabled = true;
 
             check_2PassEncode.Enabled = false;
             check_2PassEncode.CheckState = CheckState.Unchecked;
         }
+
         private void check_2PassEncode_CheckedChanged(object sender, EventArgs e)
         {
             if (check_2PassEncode.CheckState.ToString() == "Checked")
@@ -1438,26 +1940,41 @@ namespace Handbrake
             }
             else
             {
-                if (drop_format.SelectedIndex != 1 && !Properties.Settings.Default.useM4v)
+                if (drop_format.SelectedIndex != 1)
                     SetExtension(".mp4");
                 data_chpt.Enabled = false;
                 btn_importChapters.Enabled = false;
             }
         }
+
         private void btn_importChapters_Click(object sender, EventArgs e)
         {
             if (File_ChapterImport.ShowDialog() == DialogResult.OK)
             {
-                String filename = File_ChapterImport.FileName;
+                string filename = File_ChapterImport.FileName;
                 DataGridView imported = Main.ImportChapterNames(data_chpt, filename);
                 if (imported != null)
                     data_chpt = imported;
             }
         }
+
+        private void btn_export_Click(object sender, EventArgs e)
+        {
+            SaveFileDialog saveFileDialog = new SaveFileDialog();
+            saveFileDialog.Filter = "Csv File|*.csv";
+            saveFileDialog.DefaultExt = "csv";
+            if (saveFileDialog.ShowDialog() == DialogResult.OK)
+            {
+                string filename = saveFileDialog.FileName;
+
+                Main.SaveChapterMarkersToCsv(this, filename);
+            }
+        }
+
         private void mnu_resetChapters_Click(object sender, EventArgs e)
         {
             data_chpt.Rows.Clear();
-            DataGridView chapterGridView = Main.ChapterNaming(data_chpt, drop_chapterFinish.Text);
+            DataGridView chapterGridView = Main.ChapterNaming(selectedTitle, data_chpt, drop_chapterFinish.Text);
             if (chapterGridView != null)
             {
                 data_chpt = chapterGridView;
@@ -1467,48 +1984,40 @@ namespace Handbrake
         // Query Editor Tab
         private void btn_generate_Query_Click(object sender, EventArgs e)
         {
-            rtf_query.Text = queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
+            rtf_query.Text = QueryGenerator.GenerateFullQuery(this);
         }
+
         private void btn_clear_Click(object sender, EventArgs e)
         {
             rtf_query.Clear();
         }
+
         #endregion
 
         // MainWindow Components, Actions and Functions ***********************
 
         #region Source Scan
-        public Boolean isScanning { get; set; }
-        private Scan SourceScan;
 
-        private void StartScan(String filename, int title)
+        /// <summary>
+        /// Start the Scan Process
+        /// </summary>
+        /// <param name="filename">
+        /// The filename.
+        /// </param>
+        /// <param name="title">
+        /// The title.
+        /// </param>
+        private void StartScan(string filename, int title)
         {
             // Setup the GUI components for the scan.
             sourcePath = filename;
-            foreach (Control ctrl in Controls)
-                if (!(ctrl is StatusStrip || ctrl is MenuStrip || ctrl is ToolStrip))
-                    ctrl.Enabled = false;
-
-            lbl_encode.Visible = true;
-            lbl_encode.Text = "Scanning ...";
-            btn_source.Enabled = false;
-            btn_start.Enabled = false;
-            btn_showQueue.Enabled = false;
-            btn_add2Queue.Enabled = false;
-            tb_preview.Enabled = false;
-            mnu_killCLI.Visible = true;
 
-            if (ActivityWindow != null)
-                ActivityWindow.SetScanMode();
+            this.DisableGUI();
 
             // Start the Scan
             try
             {
-                isScanning = true;
-                SourceScan = new Scan();
-                SourceScan.ScanSource(sourcePath, title);
-                SourceScan.ScanStatusChanged += new EventHandler(SourceScan_ScanStatusChanged);
-                SourceScan.ScanCompleted += new EventHandler(SourceScan_ScanCompleted);
+                SourceScan.Scan(sourcePath, title);
             }
             catch (Exception exc)
             {
@@ -1516,53 +2025,78 @@ namespace Handbrake
             }
         }
 
-        void SourceScan_ScanStatusChanged(object sender, EventArgs e)
-        {
-            UpdateScanStatusLabel();
-        }
-        void SourceScan_ScanCompleted(object sender, EventArgs e)
-        {
-            UpdateGuiAfterScan();
-        }
-
-        private void UpdateScanStatusLabel()
+        /// <summary>
+        /// Update the Status label for the scan
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void SourceScanScanStatusChanged(object sender, ScanProgressEventArgs e)
         {
-            if (InvokeRequired)
+            if (this.InvokeRequired)
             {
-                BeginInvoke(new UpdateWindowHandler(UpdateScanStatusLabel));
+                this.BeginInvoke(new ScanProgessStatus(this.SourceScanScanStatusChanged), new[] { sender, e });
                 return;
             }
-            lbl_encode.Text = SourceScan.ScanStatus();
+
+            labelSource.Text = string.Format("Processing Title: {0} of {1}", e.CurrentTitle, e.Titles);
         }
-        private void UpdateGuiAfterScan()
+
+        /// <summary>
+        /// Update the UI after the scan has completed
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void SourceScanScanCompleted(object sender, EventArgs e)
         {
-            if (InvokeRequired)
+            if (this.InvokeRequired)
             {
-                BeginInvoke(new UpdateWindowHandler(UpdateGuiAfterScan));
+                this.BeginInvoke(new ScanCompletedStatus(this.SourceScanScanCompleted), new[] { sender, e });
                 return;
             }
 
             try
             {
-                currentSource = SourceScan.SouceData();
+                currentSource = SourceScan.SouceData;
 
                 // Setup some GUI components
                 drp_dvdtitle.Items.Clear();
                 if (currentSource.Titles.Count != 0)
                     drp_dvdtitle.Items.AddRange(currentSource.Titles.ToArray());
 
-                // Now select the longest title
-                if (currentSource.Titles.Count != 0)
-                    drp_dvdtitle.SelectedItem = Main.SelectLongestTitle(currentSource);
+                foreach (Title title in currentSource.Titles)
+                {
+                    if (title.MainTitle)
+                    {
+                        drp_dvdtitle.SelectedItem = title;
+                    }
+                }
 
-                // Enable the creation of chapter markers if the file is an image of a dvd.
-                if (sourcePath.ToLower().Contains(".iso") || sourcePath.Contains("VIDEO_TS") || Directory.Exists(Path.Combine(sourcePath, "VIDEO_TS")))
-                    Check_ChapterMarkers.Enabled = true;
-                else
+                if (drp_dvdtitle.SelectedItem == null && drp_dvdtitle.Items.Count > 0)
+                {
+                    drp_dvdtitle.SelectedIndex = 0;
+                }
+
+                // Enable the creation of chapter markers if the file is an image of a dvd
+                if (drop_chapterStart.Items.Count > 0)
                 {
-                    Check_ChapterMarkers.Enabled = false;
-                    Check_ChapterMarkers.Checked = false;
-                    data_chpt.Rows.Clear();
+                    int start, end;
+                    int.TryParse(drop_chapterStart.Items[0].ToString(), out start);
+                    int.TryParse(drop_chapterFinish.Items[drop_chapterFinish.Items.Count - 1].ToString(), out end);
+                    if (end > start) Check_ChapterMarkers.Enabled = true;
+                    else
+                    {
+                        Check_ChapterMarkers.Enabled = false;
+                        Check_ChapterMarkers.Checked = false;
+                        data_chpt.Rows.Clear();
+                    }
                 }
 
                 // If no titles were found, Display an error message
@@ -1575,23 +2109,54 @@ namespace Handbrake
                 }
                 UpdateSourceLabel();
 
+                // This is a bit of a hack to fix the queue editing.
+                // If afte the scan, we find a job sitting in queueEdit, then the user has rescaned the source from the queue by clicking edit.
+                // When this occures, we want to repopulate their old settings.
+                if (queueEdit != null)
+                {
+                    // Setup UI
+                    if (queueEdit.Query != null)
+                    {
+                        // Send the query from the file to the Query Parser class
+                        EncodeTask presetQuery = QueryParserUtility.Parse(queueEdit.Query);
+
+                        // Now load the preset
+                        PresetLoader.LoadPreset(this, presetQuery, "Load Back From Queue");
+
+                        // Set the destination path
+                        this.text_destination.Text = queueEdit.Destination;
+
+                        // The x264 widgets will need updated, so do this now:
+                        x264Panel.StandardizeOptString();
+                        x264Panel.SetCurrentSettingsInPanel();
+
+                        // Set the crop label
+                        PictureSettings.SetPresetCropWarningLabel(null);
+                    }
+
+                    queueEdit = null;
+                }
+
                 // Enable the GUI components and enable any disabled components
                 EnableGUI();
             }
             catch (Exception exc)
             {
-                MessageBox.Show("frmMain.cs - updateUIafterScan " + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                MessageBox.Show("frmMain.cs - updateUIafterScan " + exc, "Error", MessageBoxButtons.OK,
+                                MessageBoxIcon.Error);
                 EnableGUI();
             }
         }
 
+        /// <summary>
+        /// Enable the GUI
+        /// </summary>
         private void EnableGUI()
         {
             try
             {
                 if (InvokeRequired)
                     BeginInvoke(new UpdateWindowHandler(EnableGUI));
-                lbl_encode.Text = "Scan Completed";
                 foreach (Control ctrl in Controls)
                     ctrl.Enabled = true;
                 btn_start.Enabled = true;
@@ -1606,24 +2171,44 @@ namespace Handbrake
                 MessageBox.Show("frmMain.cs - EnableGUI() " + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
             }
         }
+
+        /// <summary>
+        /// Disable the GUI
+        /// </summary>
+        private void DisableGUI()
+        {
+            foreach (Control ctrl in Controls)
+                if (!(ctrl is StatusStrip || ctrl is MenuStrip || ctrl is ToolStrip))
+                    ctrl.Enabled = false;
+
+            labelSource.Enabled = true;
+            labelStaticSource.Enabled = true;
+            SourceLayoutPanel.Enabled = true;
+            btn_source.Enabled = false;
+            btn_start.Enabled = false;
+            btn_showQueue.Enabled = false;
+            btn_add2Queue.Enabled = false;
+            tb_preview.Enabled = false;
+            mnu_killCLI.Visible = true;
+        }
+
+        /// <summary>
+        /// Kill the Scan
+        /// </summary>
         private void KillScan()
         {
-            try
-            {
-                SourceScan.ScanCompleted -= new EventHandler(SourceScan_ScanCompleted);
-                EnableGUI();
-                ResetGUI();
+            SourceScan.ScanCompleted -= this.SourceScanScanCompleted;
+            EnableGUI();
+            ResetGUI();
 
-                if (SourceScan.ScanProcess() != null)
-                    SourceScan.ScanProcess().Kill();
+            SourceScan.Stop();
 
-                lbl_encode.Text = "Scan Cancelled!";
-            }
-            catch (Exception ex)
-            {
-                MessageBox.Show("Unable to kill HandBrakeCLI.exe \nYou may need to manually kill HandBrakeCLI.exe using the Windows Task Manager if it does not close automatically within the next few minutes. \n\nError Information: \n" + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
-            }
+            labelSource.Text = "Scan Cancelled";
         }
+
+        /// <summary>
+        /// Reset the GUI
+        /// </summary>
         private void ResetGUI()
         {
             drp_dvdtitle.Items.Clear();
@@ -1631,37 +2216,55 @@ namespace Handbrake
             drop_chapterFinish.Items.Clear();
             lbl_duration.Text = "Select a Title";
             PictureSettings.lbl_src_res.Text = "Select a Title";
-            PictureSettings.lbl_Aspect.Text = "Select a Title";
             sourcePath = String.Empty;
             text_destination.Text = String.Empty;
             selectedTitle = null;
-            isScanning = false;
         }
+
+        /// <summary>
+        /// Update the Source Label
+        /// </summary>
         private void UpdateSourceLabel()
         {
             labelSource.Text = string.IsNullOrEmpty(sourcePath) ? "Select \"Source\" to continue." : this.SourceName;
+        }
 
-            if (selectedTitle != null)
-                if (!string.IsNullOrEmpty(selectedTitle.SourceName)) // If it's one of multiple source files, make sure we don't use the folder name
-                    labelSource.Text = Path.GetFileName(selectedTitle.SourceName);
+        /// <summary>
+        /// Take a job from the Queue, rescan it, and reload the GUI for that job.
+        /// </summary>
+        /// <param name="job">
+        /// The job.
+        /// </param>
+        public void RecievingJob(QueueTask job)
+        {
+            // Reset
+            this.currentlySelectedPreset = null;
+            x264Panel.Reset2Defaults();
+
+            // Scan
+            queueEdit = job; // Nasty but will do for now. TODO
+            StartScan(job.Source, job.Title);
         }
+
         #endregion
 
-        #region GUI
+        #region GUI Functions and Actions
+
         /// <summary>
         /// Set the GUI to it's finished encoding state.
         /// </summary>
-        private void setEncodeFinished()
+        private void SetEncodeFinished()
         {
             try
             {
                 if (InvokeRequired)
                 {
-                    BeginInvoke(new UpdateWindowHandler(setEncodeFinished));
+                    BeginInvoke(new UpdateWindowHandler(SetEncodeFinished));
                     return;
                 }
 
                 lbl_encode.Text = "Encoding Finished";
+                ProgressBarStatus.Visible = false;
                 btn_start.Text = "Start";
                 btn_start.ToolTipText = "Start the encoding process";
                 btn_start.Image = Properties.Resources.Play;
@@ -1683,18 +2286,19 @@ namespace Handbrake
         /// <summary>
         /// Set the GUI to it's started encoding state.
         /// </summary>
-        private void setEncodeStarted()
+        private void SetEncodeStarted()
         {
             try
             {
                 if (InvokeRequired)
                 {
-                    BeginInvoke(new UpdateWindowHandler(setEncodeStarted));
+                    BeginInvoke(new UpdateWindowHandler(SetEncodeStarted));
                     return;
                 }
-
                 lbl_encode.Visible = true;
-                lbl_encode.Text = "Encoding with " + encodeQueue.Count + " encode(s) pending";
+                ProgressBarStatus.Value = 0;
+                ProgressBarStatus.Visible = true;
+                lbl_encode.Text = "Encoding with " + this.queueProcessor.QueueManager.Count + " encode(s) pending";
                 btn_start.Text = "Stop";
                 btn_start.ToolTipText = "Stop the encoding process.";
                 btn_start.Image = Properties.Resources.stop;
@@ -1704,117 +2308,255 @@ namespace Handbrake
                 MessageBox.Show(exc.ToString());
             }
         }
-        #endregion
 
-        #region DVD Drive Detection
-        private void getDriveInfoThread()
+        /// <summary>
+        /// Display the Encode Status
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void EncodeQueue_EncodeStatusChanged(object sender, EncodeProgressEventArgs e)
+        {
+            if (this.InvokeRequired)
+            {
+                this.BeginInvoke(new EncodeProgessStatus(EncodeQueue_EncodeStatusChanged), new[] { sender, e });
+                return;
+            }
+
+            lbl_encode.Text =
+                string.Format(
+                "{0:00.00}%,  FPS: {1:000.0},  Avg FPS: {2:000.0},  Time Remaining: {3},  Encode(s) Pending {4}",
+                e.PercentComplete,
+                e.CurrentFrameRate,
+                e.AverageFrameRate,
+                e.EstimatedTimeLeft,
+                this.queueProcessor.QueueManager.Count);
+
+            ProgressBarStatus.Value = (int)Math.Round(e.PercentComplete);
+        }
+
+        /// <summary>
+        /// Set the DVD Drive selection in the "Source" Menu
+        /// </summary>
+        private void SetDriveSelectionMenuItem()
         {
             try
             {
                 if (InvokeRequired)
                 {
-                    BeginInvoke(new UpdateWindowHandler(getDriveInfoThread));
+                    BeginInvoke(new UpdateWindowHandler(SetDriveSelectionMenuItem));
                     return;
                 }
 
-                Boolean foundDrive = false;
-                DriveInfo[] theCollectionOfDrives = DriveInfo.GetDrives();
-                foreach (DriveInfo curDrive in theCollectionOfDrives)
+                drives = UtilityService.GetDrives();
+
+                List<ToolStripMenuItem> menuItems = new List<ToolStripMenuItem>();
+                foreach (DriveInformation drive in drives)
                 {
-                    if (curDrive.DriveType == DriveType.CDRom && curDrive.IsReady)
-                    {
-                        if (File.Exists(curDrive.RootDirectory + "VIDEO_TS\\VIDEO_TS.IFO"))
+                    ToolStripMenuItem menuItem = new ToolStripMenuItem
                         {
-                            this.dvdDrivePath = curDrive.RootDirectory + "VIDEO_TS";
-                            this.dvdDriveLabel = curDrive.VolumeLabel;
-                            mnu_dvd_drive.Text = this.dvdDrivePath + " (" + this.dvdDriveLabel + ")";
-                            foundDrive = true;
-                            break;
-                        }
-                    }
+                            Name = drive.ToString(),
+                            Text = drive.RootDirectory + " (" + drive.VolumeLabel + ")",
+                            Image = Resources.disc_small
+                        };
+                    menuItem.Click += new EventHandler(MnuDvdDriveClick);
+                    menuItems.Add(menuItem);
                 }
 
-                if (foundDrive == false)
-                    mnu_dvd_drive.Text = "[No DVD Drive Ready]";
+                foreach (ToolStripMenuItem item in menuItems)
+                    btn_source.DropDownItems.Add(item);
             }
-            catch (Exception)
+            catch (Exception exc)
             {
-                mnu_dvd_drive.Text = "[No DVD Drive Ready / Found]";
+                MessageBox.Show("Error in SetDriveSelectionMenuItem" + exc);
             }
         }
-        #endregion
 
-        #region Public Methods
         /// <summary>
         /// Access the preset Handler and setup the preset panel.
         /// </summary>
-        public void loadPresetPanel()
+        private void LoadPresetPanel()
         {
             if (presetHandler.CheckIfPresetsAreOutOfDate())
-                if (!Properties.Settings.Default.presetNotification)
-                    MessageBox.Show(splash,
-                    "HandBrake has determined your built-in presets are out of date... These presets will now be updated.",
-                    "Preset Update", MessageBoxButtons.OK, MessageBoxIcon.Information);
+                if (!Settings.Default.presetNotification)
+                    MessageBox.Show(this,
+                                    "HandBrake has determined your built-in presets are out of date... These presets will now be updated.",
+                                    "Preset Update", MessageBoxButtons.OK, MessageBoxIcon.Information);
+
+            // Clear the old presets
+            treeView_presets.Nodes.Clear();
+
+
+            string category = string.Empty; // The category we are currnetly processing
+            TreeNode rootNode = null;
+            foreach (Preset preset in this.presetHandler.Presets.Where(p => p.IsBuildIn))
+            {
+                // If the category of this preset doesn't match the current category we are processing
+                // Then we need to create a new root node.
+                if (preset.Category != category)
+                {
+                    rootNode = new TreeNode(preset.Category) { ForeColor = Color.DarkBlue };
+                    treeView_presets.Nodes.Add(rootNode);
+                    category = preset.Category;
+                }
+
+                if (preset.Category == category && rootNode != null)
+                    rootNode.Nodes.Add(new TreeNode(preset.Name) { ToolTipText = preset.Description, ForeColor = Color.DarkBlue });
+            }
+
+            rootNode = null;
+            category = null;
+            foreach (Preset preset in this.presetHandler.Presets.Where(p => !p.IsBuildIn)) // User Presets
+            {
+                if (preset.Category != category && preset.Category != string.Empty)
+                {
+                    rootNode = new TreeNode(preset.Category) { ForeColor = Color.Black };
+                    treeView_presets.Nodes.Add(rootNode);
+                    category = preset.Category;
+                }
+
+                if (preset.Category == category && rootNode != null)
+                    rootNode.Nodes.Add(new TreeNode(preset.Name) { ForeColor = Color.Black, ToolTipText = preset.Description });
+                else
+                    treeView_presets.Nodes.Add(new TreeNode(preset.Name) { ForeColor = Color.Black, ToolTipText = preset.Description });
+            }
 
-            presetHandler.GetPresetPanel(ref treeView_presets);
             treeView_presets.Update();
         }
-        #endregion
 
-        #region Overrides
         /// <summary>
-        /// If the queue is being processed, prompt the user to confirm application close.
+        /// Get the title from the selected item in the title dropdown.
         /// </summary>
-        /// <param name="e"></param>
-        protected override void OnFormClosing(FormClosingEventArgs e)
+        /// <returns>
+        /// The title.
+        /// </returns>
+        private int GetTitle()
         {
-            // If currently encoding, the queue isn't paused, and there are queue items to process, prompt to confirm close.
-            if ((encodeQueue.IsEncoding) && (!encodeQueue.PauseRequested) && (encodeQueue.Count > 0))
+            int title = 0;
+            if (drp_dvdtitle.SelectedItem != null)
             {
-                DialogResult result = MessageBox.Show("HandBrake has queue items to process. Closing HandBrake will not stop the current encoding, but will stop processing the queue.\n\nDo you want to close HandBrake?",
-                    "Close HandBrake?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
-                if (result == DialogResult.No)
-                    e.Cancel = true;
+                string[] titleInfo = drp_dvdtitle.SelectedItem.ToString().Split(' ');
+                int.TryParse(titleInfo[0], out title);
             }
-            base.OnFormClosing(e);
+
+            return title;
         }
-        #endregion
 
-        #region In-GUI Encode Status (Experimental)
-        private void encodeMonitorThread()
+        /// <summary>
+        /// Handle the Update Check Finishing.
+        /// </summary>
+        /// <param name="result">
+        /// The result.
+        /// </param>
+        private void UpdateCheckDoneMenu(IAsyncResult result)
         {
+            // Make sure it's running on the calling thread
+            if (InvokeRequired)
+            {
+                Invoke(new MethodInvoker(() => this.UpdateCheckDoneMenu(result)));
+                return;
+            }
+            UpdateCheckInformation info;
             try
             {
-                Parser encode = new Parser(encodeQueue.HbProcess.StandardOutput.BaseStream);
-                encode.OnEncodeProgress += encodeOnEncodeProgress;
-                while (!encode.EndOfStream)
-                    encode.readEncodeStatus();
+                // Get the information about the new build, if any, and close the window
+                info = UpdateService.EndCheckForUpdates(result);
+
+                if (info.NewVersionAvailable && info.BuildInformation != null)
+                {
+                    UpdateInfo updateWindow = new UpdateInfo(info.BuildInformation, Settings.Default.hb_version, Settings.Default.hb_build.ToString());
+                    updateWindow.ShowDialog();
+                }
+                else
+                    MessageBox.Show("There are no new updates at this time.", "Update Check", MessageBoxButtons.OK,
+                                    MessageBoxIcon.Information);
+                lbl_updateCheck.Visible = false;
+                return;
             }
-            catch (Exception exc)
+            catch (Exception ex)
             {
-                MessageBox.Show(exc.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                if ((bool)result.AsyncState)
+                    MessageBox.Show(
+                        "Unable to check for updates, Please try again later.\n\nDetailed Error Information:\n" + ex,
+                        "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
             }
         }
-        private void encodeOnEncodeProgress(object Sender, int CurrentTask, int TaskCount, float PercentComplete, float CurrentFps, float AverageFps, TimeSpan TimeRemaining)
+
+        #endregion
+
+        #region Overrides
+
+        /// <summary>
+        /// Handle GUI shortcuts
+        /// </summary>
+        /// <param name="msg">Message</param>
+        /// <param name="keyData">Keys</param>
+        /// <returns>Bool</returns>
+        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
         {
-            if (this.InvokeRequired)
+            if (keyData == (Keys.Control | Keys.S))
             {
-                this.BeginInvoke(new EncodeProgressEventHandler(encodeOnEncodeProgress),
-                    new object[] { Sender, CurrentTask, TaskCount, PercentComplete, CurrentFps, AverageFps, TimeRemaining });
-                return;
+                btn_start_Click(this, new EventArgs());
+                return true;
+            }
+
+            if (keyData == (Keys.Control | Keys.Shift | Keys.A))
+            {
+                btn_add2Queue_Click(this, new EventArgs());
+                return true;
             }
-            lbl_encode.Text = string.Format("Encode Progress: {0}%,       FPS: {1},       Avg FPS: {2},       Time Remaining: {3} ", PercentComplete, CurrentFps, AverageFps, TimeRemaining);
+            return base.ProcessCmdKey(ref msg, keyData);
         }
-        #endregion
 
-        #region enum
-        private enum SourceType
+        /// <summary>
+        /// If the queue is being processed, prompt the user to confirm application close.
+        /// </summary>
+        /// <param name="e">FormClosingEventArgs</param>
+        protected override void OnFormClosing(FormClosingEventArgs e)
         {
-            None = 0,
-            Folder,
-            DvdDrive,
-            VideoFile
+            try
+            {
+                // If currently encoding, the queue isn't paused, and there are queue items to process, prompt to confirm close.
+                if (this.queueProcessor.EncodeService.IsEncoding)
+                {
+                    DialogResult result =
+                        MessageBox.Show(
+                            "HandBrake is currently encoding. Closing HandBrake will stop the current encode and will result in an unplayable file.\n\nDo you want to close HandBrake?",
+                            "Close HandBrake?",
+                            MessageBoxButtons.YesNo,
+                            MessageBoxIcon.Question);
+
+                    if (result == DialogResult.No)
+                    {
+                        e.Cancel = true;
+                        return;
+                    }
+
+                    this.queueProcessor.Pause();
+                    this.queueProcessor.EncodeService.Stop();
+                }
+
+                if (SourceScan.IsScanning)
+                {
+                    SourceScan.Stop();
+                }
+
+                SourceScan.ScanCompleted -= this.SourceScanScanCompleted;
+                SourceScan.ScanStatusChanged -= this.SourceScanScanStatusChanged;
+            }
+            catch (Exception exc)
+            {
+                Main.ShowExceptiowWindow("HandBrake was not able to shutdown properly. You may need to forcefully quit HandBrake CLI from TaskManager if it's still running.", exc.ToString());
+            }
+            finally
+            {
+                base.OnFormClosing(e);
+            }
         }
+
         #endregion
 
         // This is the END of the road ****************************************