X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=win%2FC%23%2FfrmQueue.cs;h=2684772bbd8cfedbadf1b3a2d5ede9526ee010c6;hb=4560ade3c833f282f02d15a9473e233488617df9;hp=c7b280ef3d167b7590f55322b52ae0397e1ef88d;hpb=d646c74eab71ce803181537759b19c9b2726fc0a;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/win/C#/frmQueue.cs b/win/C#/frmQueue.cs
index c7b280ef..2684772b 100644
--- a/win/C#/frmQueue.cs
+++ b/win/C#/frmQueue.cs
@@ -1,54 +1,192 @@
 /*  frmQueue.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.ComponentModel;
-using System.Windows.Forms;
-using Handbrake.EncodeQueue;
+    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.Collections.ObjectModel;
+    using System.ComponentModel;
+    using System.IO;
+    using System.Windows.Forms;
+    using Functions;
+
+    using HandBrake.ApplicationServices.Model;
+    using HandBrake.ApplicationServices.Services;
+    using HandBrake.ApplicationServices.Services.Interfaces;
+
+    using Model;
+
+    /// <summary>
+    /// The Queue Window
+    /// </summary>
     public partial class frmQueue : Form
     {
+        /// <summary>
+        /// Update Handler Delegate
+        /// </summary>
         private delegate void UpdateHandler();
-        QueueHandler queue;
 
-        public frmQueue(QueueHandler q)
+        /// <summary>
+        /// An instance of the Queue service
+        /// </summary>
+        private readonly IQueue queue;
+
+        /// <summary>
+        /// A reference to the main application window
+        /// </summary>
+        private readonly frmMain mainWindow;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="frmQueue"/> class.
+        /// </summary>
+        /// <param name="q">
+        /// An instance of the queue service.
+        /// </param>
+        /// <param name="mw">
+        /// The main window.
+        /// </param>
+        public frmQueue(IQueue q, frmMain mw)
         {
             InitializeComponent();
 
+            this.mainWindow = mw;
+
             this.queue = q;
-            queue.OnEncodeStart += new EventHandler(queueOnEncodeStart);
-            queue.OnQueueFinished += new EventHandler(queueOnQueueFinished);
-            queue.OnPaused += new EventHandler(queueOnPaused);
+            queue.EncodeStarted += new EventHandler(QueueOnEncodeStart);
+            queue.QueueCompleted += new EventHandler(QueueOnQueueFinished);
+            queue.QueuePauseRequested += new EventHandler(QueueOnPaused);
+            queue.QueueListChanged += new EventHandler(queue_QueueListChanged);
+
+            queue.EncodeStarted += new EventHandler(queue_EncodeStarted);
+            queue.EncodeEnded += new EventHandler(queue_EncodeEnded);
+
+            drp_completeOption.Text = Properties.Settings.Default.CompletionOption;
+        }
+
+        /// <summary>
+        /// Queue Changed
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void queue_QueueListChanged(object sender, EventArgs e)
+        {
+            UpdateUiElementsOnQueueChange();
+        }
+
+        /// <summary>
+        /// Encode Ended
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void queue_EncodeEnded(object sender, EventArgs e)
+        {
+            queue.EncodeStatusChanged -= EncodeQueue_EncodeStatusChanged;
+            ResetEncodeText();
         }
-        void queueOnPaused(object sender, EventArgs e)
+
+        /// <summary>
+        /// Queue Started
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void queue_EncodeStarted(object sender, EventArgs e)
+        {
+            this.SetCurrentEncodeInformation();
+            queue.EncodeStatusChanged += EncodeQueue_EncodeStatusChanged;        
+        }
+
+        /// <summary>
+        /// Display the Encode Status
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void EncodeQueue_EncodeStatusChanged(object sender, HandBrake.ApplicationServices.EncodeProgressEventArgs e)
+        {
+            if (this.InvokeRequired)
+            {
+                this.BeginInvoke(new Encode.EncodeProgessStatus(EncodeQueue_EncodeStatusChanged), new[] { sender, e });
+                return;
+            }
+
+            lbl_encodeStatus.Text =
+                string.Format(
+                "Encoding: Pass {0} of {1}, {2:00.00}% Time Remaining: {3}",
+                e.Task,
+                e.TaskCount,
+                e.PercentComplete,
+                e.EstimatedTimeLeft);
+        }
+
+        /// <summary>
+        /// Handle the Queue Paused event
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The EventArgs.
+        /// </param>
+        private void QueueOnPaused(object sender, EventArgs e)
         {
-            setUIEncodeFinished();
-            updateUIElements();
+            SetUiEncodeFinished();
+            UpdateUiElementsOnQueueChange();
         }
-        void queueOnQueueFinished(object sender, EventArgs e)
+
+        /// <summary>
+        /// Handle the Queue Finished event.
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The EventArgs.
+        /// </param>
+        private void QueueOnQueueFinished(object sender, EventArgs e)
         {
-            setUIEncodeFinished();
-            resetQueue(); // Reset the Queue Window
+            SetUiEncodeFinished();
+            ResetQueue(); // Reset the Queue Window
         }
-        void queueOnEncodeStart(object sender, EventArgs e)
+
+        /// <summary>
+        /// Handle the Encode Started event
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void QueueOnEncodeStart(object sender, EventArgs e)
         {
-            setUIEncodeStarted(); // make sure the UI is set correctly
-            setCurrentEncodeInformation();
-            updateUIElements(); // Redraw the Queue, a new encode has started.
+            SetUiEncodeStarted(); // make sure the UI is set correctly
+            UpdateUiElementsOnQueueChange(); // Redraw the Queue, a new encode has started.
         }
 
         /// <summary>
         /// Initializes the Queue list with the Arraylist from the Queue class
         /// </summary>
-        public void setQueue()
+        public void SetQueue()
         {
-            updateUIElements();
+            UpdateUiElementsOnQueueChange();
         }
 
         /// <summary>
@@ -56,7 +194,7 @@ namespace Handbrake
         /// </summary>
         public new void Show()
         {
-           Show(true);
+            Show(true);
         }
 
         /// <summary>
@@ -65,114 +203,152 @@ namespace Handbrake
         /// <param name="doSetQueue">Indicates whether to call setQueue() before showing the window</param>
         public void Show(bool doSetQueue)
         {
-            if (doSetQueue) setQueue();
+            if (doSetQueue) SetQueue();
             base.Show();
-
-            //Activate();
         }
 
-        // Start and Stop Controls
-        private void btn_encode_Click(object sender, EventArgs e)
+        /// <summary>
+        /// Handle the Encode button Click event
+        /// </summary>
+        /// <param name="sender">The sender</param>
+        /// <param name="e">the EventArgs</param>
+        private void BtnEncodeClick(object sender, EventArgs e)
         {
-            if (queue.isPaused)
+            if (queue.Paused)
             {
-                setUIEncodeStarted();
-                MessageBox.Show("Encoding restarted", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
+                SetUiEncodeStarted();
             }
 
-            if (!queue.isEncodeStarted)
-                queue.startEncode();
-
+            lbl_encodeStatus.Text = "Encoding ...";
+            queue.Start();
         }
-        private void btn_pause_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Handle the Pause button click event.
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The EventArgs.
+        /// </param>
+        private void BtnPauseClick(object sender, EventArgs e)
         {
-            queue.pauseEncodeQueue();
-            setUIEncodeFinished();
-            resetQueue();
-            MessageBox.Show("No further items on the queue will start. The current encode process will continue until it is finished. \nClick 'Encode' when you wish to continue encoding the queue.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+            queue.Pause();
+            MessageBox.Show(
+                "No further items on the queue will start. The current encode process will continue until it is finished. \nClick 'Encode' when you wish to continue encoding the queue.",
+                "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
         }
 
-        // Window Display Management
-        private void setUIEncodeStarted()
+        // UI Work
+
+        /// <summary>
+        /// Setup the UI to show that an encode has started
+        /// </summary>
+        private void SetUiEncodeStarted()
         {
             if (InvokeRequired)
             {
-                BeginInvoke(new UpdateHandler(setUIEncodeStarted));
+                BeginInvoke(new UpdateHandler(SetUiEncodeStarted));
                 return;
             }
             btn_encode.Enabled = false;
             btn_pause.Visible = true;
         }
-        private void setUIEncodeFinished()
+
+        /// <summary>
+        /// Setup the UI to indicate that an encode has finished.
+        /// </summary>
+        private void SetUiEncodeFinished()
         {
             if (InvokeRequired)
             {
-                BeginInvoke(new UpdateHandler(setUIEncodeFinished));
+                BeginInvoke(new UpdateHandler(SetUiEncodeFinished));
                 return;
             }
             btn_pause.Visible = false;
             btn_encode.Enabled = true;
         }
-        private void resetQueue()
+
+        /// <summary>
+        /// Reset the Queue Window display
+        /// </summary>
+        private void ResetQueue()
         {
             if (InvokeRequired)
             {
-                BeginInvoke(new UpdateHandler(resetQueue));
+                BeginInvoke(new UpdateHandler(ResetQueue));
                 return;
             }
             btn_pause.Visible = false;
             btn_encode.Enabled = true;
 
+            ResetEncodeText();
+        }
+
+        /// <summary>
+        /// Reset the current job text
+        /// </summary>
+        private void ResetEncodeText()
+        {
+            if (InvokeRequired)
+            {
+                BeginInvoke(new UpdateHandler(ResetEncodeText));
+                return;
+            }
+            lbl_encodeStatus.Text = "Ready";
+
             lbl_source.Text = "-";
             lbl_dest.Text = "-";
-            lbl_vEnc.Text = "-";
-            lbl_aEnc.Text = "-";
-            lbl_title.Text = "-";
-            lbl_chapt.Text = "-";
+            lbl_encodeOptions.Text = "-";
 
             lbl_encodesPending.Text = list_queue.Items.Count + " encode(s) pending";
         }
-        private void redrawQueue()
+
+        /// <summary>
+        /// Redraw the Queue window with the latest information about HandBrakes status
+        /// </summary>
+        private void RedrawQueue()
         {
             if (InvokeRequired)
             {
-                BeginInvoke(new UpdateHandler(redrawQueue));
+                BeginInvoke(new UpdateHandler(RedrawQueue));
                 return;
             }
 
             list_queue.Items.Clear();
-            List<Job> theQueue = queue.getQueue();
-            foreach (Job queue_item in theQueue)
+            ReadOnlyCollection<Job> theQueue = queue.CurrentQueue;
+            foreach (Job queueItem in theQueue)
             {
-                string q_item = queue_item.Query;
-                Functions.QueryParser parsed = Functions.QueryParser.Parse(q_item);
+                string qItem = queueItem.Query;
+                QueryParser parsed = Functions.QueryParser.Parse(qItem);
 
                 // Get the DVD Title
-                string title = parsed.DVDTitle == 0 ? "Auto" : parsed.DVDTitle.ToString();
+                string title = parsed.Title == 0 ? "Auto" : parsed.Title.ToString();
 
                 // Get the DVD Chapters
                 string chapters;
-                if (parsed.DVDChapterStart == 0)
+                if (parsed.ChapterStart == 0)
                     chapters = "Auto";
                 else
                 {
-                    chapters = parsed.DVDChapterStart.ToString();
-                    if (parsed.DVDChapterFinish != 0)
-                        chapters = chapters + " - " + parsed.DVDChapterFinish;
+                    chapters = parsed.ChapterStart.ToString();
+                    if (parsed.ChapterFinish != 0)
+                        chapters = chapters + " - " + parsed.ChapterFinish;
                 }
 
                 ListViewItem item = new ListViewItem();
                 item.Text = title; // Title
                 item.SubItems.Add(chapters); // Chapters
-                item.SubItems.Add(queue_item.Source); // Source
-                item.SubItems.Add(queue_item.Destination); // Destination
+                item.SubItems.Add(queueItem.Source); // Source
+                item.SubItems.Add(queueItem.Destination); // Destination
                 item.SubItems.Add(parsed.VideoEncoder); // Video
 
                 // Display The Audio Track Information
                 string audio = string.Empty;
-                foreach (Functions.AudioTrack track in parsed.AudioInformation)
+                foreach (AudioTrack track in parsed.AudioInformation)
                 {
-                    if (audio != "")
+                    if (audio != string.Empty)
                         audio += ", " + track.Encoder;
                     else
                         audio = track.Encoder;
@@ -182,121 +358,165 @@ namespace Handbrake
                 list_queue.Items.Add(item);
             }
         }
-        private void updateUIElements()
+
+        /// <summary>
+        /// Update the UI elements
+        /// </summary>
+        private void UpdateUiElementsOnQueueChange()
         {
             if (InvokeRequired)
             {
-                BeginInvoke(new UpdateHandler(updateUIElements));
+                BeginInvoke(new UpdateHandler(UpdateUiElementsOnQueueChange));
                 return;
             }
 
-            redrawQueue();
+            RedrawQueue();
             lbl_encodesPending.Text = list_queue.Items.Count + " encode(s) pending";
         }
-        private void setCurrentEncodeInformation()
+
+        /// <summary>
+        /// Set the window up with the current encode information
+        /// </summary>
+        private void SetCurrentEncodeInformation()
         {
             try
             {
                 if (InvokeRequired)
                 {
-                    BeginInvoke(new UpdateHandler(setCurrentEncodeInformation));
+                    BeginInvoke(new UpdateHandler(SetCurrentEncodeInformation));
                 }
 
-                // found query is a global varible
-                Functions.QueryParser parsed = Functions.QueryParser.Parse(queue.lastQueueItem.Query);
-                lbl_source.Text = queue.lastQueueItem.Source;
-                lbl_dest.Text = queue.lastQueueItem.Destination;
-
-                lbl_title.Text = parsed.DVDTitle == 0 ? "Auto" : parsed.DVDTitle.ToString();
+                QueryParser parsed = QueryParser.Parse(queue.LastEncode.Query);
 
-                if (Equals(parsed.DVDChapterStart, 0))
-                    lbl_chapt.Text = "Auto";
+                // Get title and chapters
+                string title = parsed.Title == 0 ? "Auto" : parsed.Title.ToString();
+                string chapterlbl;
+                if (Equals(parsed.ChapterStart, 0))
+                    chapterlbl = "Auto";
                 else
                 {
-                    string chapters = parsed.DVDChapterStart.ToString();
-                    if (parsed.DVDChapterFinish != 0)
-                        chapters = chapters + " - " + parsed.DVDChapterFinish;
-                    lbl_chapt.Text = chapters;
+                    string chapters = parsed.ChapterStart.ToString();
+                    if (parsed.ChapterFinish != 0)
+                        chapters = chapters + " - " + parsed.ChapterFinish;
+                    chapterlbl = chapters;
                 }
 
-                lbl_vEnc.Text = parsed.VideoEncoder;
-
-                // Display The Audio Track Information
+                // Get audio information
                 string audio = string.Empty;
-                foreach (Functions.AudioTrack track in parsed.AudioInformation)
+                foreach (AudioTrack track in parsed.AudioInformation)
                 {
-                    if (audio != "")
+                    if (audio != string.Empty) 
                         audio += ", " + track.Encoder;
                     else
                         audio = track.Encoder;
                 }
-                lbl_aEnc.Text = audio;
-            }
+
+                // found query is a global varible        
+                lbl_encodeStatus.Text = "Encoding ...";
+                lbl_source.Text = queue.LastEncode.Source + "(Title: " + title + " Chapters: " + chapterlbl + ")";
+                lbl_dest.Text = queue.LastEncode.Destination;
+                lbl_encodeOptions.Text = "Video: " + parsed.VideoEncoder + " Audio: " + audio + Environment.NewLine +
+                                    "x264 Options: " + parsed.H264Query;
+               }
             catch (Exception)
             {
                 // Do Nothing
             }
         }
-        private void deleteSelectedItems()
-        {
-            // If there are selected items
-            if (list_queue.SelectedIndices.Count > 0)
-            {
-                // Save the selected indices to select them after the move
-                List<int> selectedIndices = new List<int>(list_queue.SelectedIndices.Count);
-                foreach (int selectedIndex in list_queue.SelectedIndices)
-                    selectedIndices.Add(selectedIndex);
 
-                int firstSelectedIndex = selectedIndices[0];
-
-                // Reverse the list to delete the items from last to first (preserves indices)
-                selectedIndices.Reverse();
-
-                // Remove each selected item
-                foreach (int selectedIndex in selectedIndices)
-                    queue.remove(selectedIndex);
-
-                updateUIElements();
-
-                // Select the item where the first deleted item was previously
-                if (firstSelectedIndex < list_queue.Items.Count)
-                    list_queue.Items[firstSelectedIndex].Selected = true;
-            }
-
-            list_queue.Select(); // Activate the control to show the selected items
-        }
+        /* Right Click Menu */
 
-        // Queue Management
-        private void mnu_up_Click(object sender, EventArgs e)
-        {
-            moveUp();
-        }
-        private void mnu_Down_Click(object sender, EventArgs e)
-        {
-            moveDown();
-        }
-        private void mnu_delete_Click(object sender, EventArgs e)
+        /// <summary>
+        /// Handle the Move Up Menu Item
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuUpClick(object sender, EventArgs e)
         {
-            deleteSelectedItems();
+            MoveUp();
         }
-        private void btn_up_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Handle the Move down Menu Item
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuDownClick(object sender, EventArgs e)
         {
-            moveUp();
+            MoveDown();
         }
-        private void btn_down_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Edit a job
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuEditClick(object sender, EventArgs e)
         {
-            moveDown();
+            if (list_queue.SelectedIndices != null && list_queue.SelectedIndices.Count != 0)
+            {
+                lock (queue)
+                {
+                    lock (list_queue)
+                    {
+                        int index = list_queue.SelectedIndices[0];
+                        mainWindow.RecievingJob(queue.GetJob(index));
+                        queue.Remove(index);
+                        RedrawQueue();
+                    }
+                }
+            }
         }
-        private void btn_delete_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Handle the delete Menu Item
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuDeleteClick(object sender, EventArgs e)
         {
-            deleteSelectedItems();
+            DeleteSelectedItems();
         }
-        private void list_queue_deleteKey(object sender, KeyEventArgs e)
+
+        /* Keyboard Shortcuts */
+
+        /// <summary>
+        /// Handle the delete keyboard press
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void ListQueueDeleteKey(object sender, KeyEventArgs e)
         {
-            if (e.KeyCode == Keys.Delete)
-                deleteSelectedItems();
+            if (e.KeyCode == Keys.Delete && e.Modifiers == Keys.None)
+                DeleteSelectedItems();
         }
-        private void moveUp()
+
+        /* Queue Management */
+
+        /// <summary>
+        /// Move items up in the queue
+        /// </summary>
+        private void MoveUp()
         {
             // If there are selected items and the first item is not selected
             if (list_queue.SelectedIndices.Count > 0 && !list_queue.SelectedIndices.Contains(0))
@@ -308,9 +528,7 @@ namespace Handbrake
 
                 // Move up each selected item
                 foreach (int selectedIndex in selectedIndices)
-                    queue.moveUp(selectedIndex);
-
-                updateUIElements();
+                    queue.MoveUp(selectedIndex);
 
                 // Keep the selected item(s) selected, now moved up one index
                 foreach (int selectedIndex in selectedIndices)
@@ -320,7 +538,11 @@ namespace Handbrake
 
             list_queue.Select(); // Activate the control to show the selected items
         }
-        private void moveDown()
+
+        /// <summary>
+        /// Move items down in the queue
+        /// </summary>
+        private void MoveDown()
         {
             // If there are selected items and the last item is not selected
             if (list_queue.SelectedIndices.Count > 0 &&
@@ -336,9 +558,7 @@ namespace Handbrake
 
                 // Move down each selected item
                 foreach (int selectedIndex in selectedIndices)
-                    queue.moveDown(selectedIndex);
-
-                updateUIElements();
+                    queue.MoveDown(selectedIndex);
 
                 // Keep the selected item(s) selected, now moved down one index
                 foreach (int selectedIndex in selectedIndices)
@@ -349,41 +569,121 @@ namespace Handbrake
             list_queue.Select(); // Activate the control to show the selected items
         }
 
-        // Queue Import/Export Features
-        private void mnu_batch_Click(object sender, EventArgs e)
+        /// <summary>
+        /// Delete the currently selected items on the queue
+        /// </summary>
+        private void DeleteSelectedItems()
         {
-            SaveFile.FileName = "";
+            // If there are selected items
+            if (list_queue.SelectedIndices.Count > 0)
+            {
+                // Save the selected indices to select them after the move
+                List<int> selectedIndices = new List<int>(list_queue.SelectedIndices.Count);
+                foreach (int selectedIndex in list_queue.SelectedIndices)
+                    selectedIndices.Add(selectedIndex);
+
+                int firstSelectedIndex = selectedIndices[0];
+
+                // Reverse the list to delete the items from last to first (preserves indices)
+                selectedIndices.Reverse();
+
+                // Remove each selected item
+                foreach (int selectedIndex in selectedIndices)
+                    queue.Remove(selectedIndex);
+
+                // Select the item where the first deleted item was previously
+                if (firstSelectedIndex < list_queue.Items.Count)
+                    list_queue.Items[firstSelectedIndex].Selected = true;
+            }
+
+            list_queue.Select(); // Activate the control to show the selected items
+        }
+
+        /* Queue Import / Export features */
+
+        /// <summary>
+        /// Create a batch script
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuBatchClick(object sender, EventArgs e)
+        {
+            SaveFile.FileName = string.Empty;
             SaveFile.Filter = "Batch|.bat";
             SaveFile.ShowDialog();
             if (SaveFile.FileName != String.Empty)
-                queue.writeBatchScript(SaveFile.FileName);
+                queue.WriteBatchScriptToFile(SaveFile.FileName);
         }
-        private void mnu_export_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Export Queue
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuExportClick(object sender, EventArgs e)
         {
-            SaveFile.FileName = "";
+            SaveFile.FileName = string.Empty;
             SaveFile.Filter = "HandBrake Queue|*.queue";
             SaveFile.ShowDialog();
             if (SaveFile.FileName != String.Empty)
-                queue.updateQueueRecoveryFile(SaveFile.FileName);
+                queue.WriteQueueStateToFile(SaveFile.FileName);
         }
-        private void mnu_import_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Import Queue
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuImportClick(object sender, EventArgs e)
         {
-            OpenFile.FileName = "";
+            OpenFile.FileName = string.Empty;
             OpenFile.ShowDialog();
             if (OpenFile.FileName != String.Empty)
-                queue.recoverQueue(OpenFile.FileName);
-            updateUIElements();
+                queue.LoadQueueFromFile(OpenFile.FileName);
         }
-        private void mnu_readd_Click(object sender, EventArgs e)
+
+        /// <summary>
+        /// Readd current job to queue
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The e.
+        /// </param>
+        private void MnuReaddClick(object sender, EventArgs e)
         {
-            if (queue.lastQueueItem != null)
+            if (queue.LastEncode != null && !queue.LastEncode.IsEmpty)
             {
-                queue.add(queue.lastQueueItem.Query, queue.lastQueueItem.Source, queue.lastQueueItem.Destination);
-                updateUIElements();
+                queue.Add(
+                    queue.LastEncode.Query, 
+                    queue.LastEncode.Title, 
+                    queue.LastEncode.Source,
+                    queue.LastEncode.Destination,
+                    queue.LastEncode.CustomQuery);
             }
         }
 
-        // Hide's the window when the user tries to "x" out of the window instead of closing it.
+        /* Overrides */
+
+        /// <summary>
+        /// Hide's the window when the user tries to "x" out of the window instead of closing it.
+        /// </summary>
+        /// <param name="e">
+        /// The e.
+        /// </param>
         protected override void OnClosing(CancelEventArgs e)
         {
             e.Cancel = true;
@@ -391,5 +691,20 @@ namespace Handbrake
             base.OnClosing(e);
         }
 
+        /// <summary>
+        /// Change the OnComplete option setting.
+        /// </summary>
+        /// <param name="sender">
+        /// The sender.
+        /// </param>
+        /// <param name="e">
+        /// The EventArgs.
+        /// </param>
+        private void CompleteOptionChanged(object sender, EventArgs e)
+        {
+            Properties.Settings.Default.CompletionOption = drp_completeOption.Text;
+            HandBrake.ApplicationServices.Init.CompletionOption = drp_completeOption.Text;
+            Properties.Settings.Default.Save();
+        }
     }
-}
+}
\ No newline at end of file