diff options
| author | sr55 <[email protected]> | 2009-05-23 14:58:01 +0000 |
|---|---|---|
| committer | sr55 <[email protected]> | 2009-05-23 14:58:01 +0000 |
| commit | adbb3094f0247a8e67f78ca01c6f9739f5d3336a (patch) | |
| tree | 67c7c52318d6a9cdcd93991a053b7e91d5e68cee /win/C#/EncodeQueue/QueueHandler.cs | |
| parent | ee294958088a96ca232a1334eea6542dd7e30d60 (diff) | |
WinGui:
- Renamed the Queue folder and moved the Encoding stuff into it.
- Moves encode process information into a class object.
git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@2445 b64f7644-9d1e-0410-96f1-a4d463321fa5
Diffstat (limited to 'win/C#/EncodeQueue/QueueHandler.cs')
| -rw-r--r-- | win/C#/EncodeQueue/QueueHandler.cs | 332 |
1 files changed, 332 insertions, 0 deletions
diff --git a/win/C#/EncodeQueue/QueueHandler.cs b/win/C#/EncodeQueue/QueueHandler.cs new file mode 100644 index 000000000..f34de0190 --- /dev/null +++ b/win/C#/EncodeQueue/QueueHandler.cs @@ -0,0 +1,332 @@ +/* QueueHandler.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.IO;
+using System.Windows.Forms;
+using System.Xml.Serialization;
+using System.Threading;
+using System.Diagnostics;
+
+namespace Handbrake.EncodeQueue
+{
+ public class QueueHandler
+ {
+ Encode encodeHandler = new Encode();
+ private static XmlSerializer ser = new XmlSerializer(typeof(List<QueueItem>));
+ List<QueueItem> queue = new List<QueueItem>();
+ int id; // Unique identifer number for each job
+
+ #region Queue Handling
+ public List<QueueItem> getQueue()
+ {
+ return queue;
+ }
+
+ /// <summary>
+ /// Get's the next CLI query for encoding
+ /// </summary>
+ /// <returns>String</returns>
+ private string getNextItemForEncoding()
+ {
+ QueueItem job = queue[0];
+ String query = job.Query;
+ lastQueueItem = job;
+ remove(0); // Remove the item which we are about to pass out.
+ return query;
+ }
+
+ /// <summary>
+ /// Get the last query that was returned by getNextItemForEncoding()
+ /// </summary>
+ /// <returns></returns>
+ public QueueItem lastQueueItem { get; set; }
+
+ /// <summary>
+ /// Add's a new item to the queue
+ /// </summary>
+ /// <param name="query">String</param>
+ /// <param name="source"></param>
+ /// <param name="destination"></param>
+ public void add(string query, string source, string destination)
+ {
+ QueueItem newJob = new QueueItem { Id = id, Query = query, Source = source, Destination = destination };
+ id++;
+
+ queue.Add(newJob);
+ }
+
+ /// <summary>
+ /// Check to see if a destination path is already on the queue
+ /// </summary>
+ /// <param name="destination">Destination path</param>
+ /// <returns>Boolean True/False. True = Path Exists</returns>
+ public Boolean checkDestinationPath(string destination)
+ {
+ foreach (QueueItem checkItem in queue)
+ {
+ if (checkItem.Destination.Contains(destination.Replace("\\\\", "\\")))
+ return true;
+ }
+ return false;
+ }
+
+ /// <summary>
+ /// Removes an item from the queue.
+ /// </summary>
+ /// <param name="index">Index</param>
+ /// <returns>Bolean true if successful</returns>
+ public void remove(int index)
+ {
+ queue.RemoveAt(index);
+ }
+
+ /// <summary>
+ /// Returns how many items are in the queue
+ /// </summary>
+ /// <returns>Int</returns>
+ public int count()
+ {
+ return queue.Count;
+ }
+
+ /// <summary>
+ /// Move an item with an index x, up in the queue
+ /// </summary>
+ /// <param name="index">Int</param>
+ public void moveUp(int index)
+ {
+ if (index > 0)
+ {
+ QueueItem item = queue[index];
+
+ queue.RemoveAt(index);
+ queue.Insert((index - 1), item);
+ }
+ }
+
+ /// <summary>
+ /// Move an item with an index x, down in the queue
+ /// </summary>
+ /// <param name="index">Int</param>
+ public void moveDown(int index)
+ {
+ if (index < queue.Count - 1)
+ {
+ QueueItem item = queue[index];
+
+ queue.RemoveAt(index);
+ queue.Insert((index + 1), item);
+ }
+ }
+
+ /// <summary>
+ /// Writes the current queue to disk. hb_queue_recovery.xml
+ /// This function is called after getNextItemForEncoding()
+ /// </summary>
+ public void write2disk(string file)
+ {
+ string tempPath = file == "hb_queue_recovery.xml" ? Path.Combine(Path.GetTempPath(), "hb_queue_recovery.xml") : file;
+
+ try
+ {
+ using (FileStream strm = new FileStream(tempPath, FileMode.Create, FileAccess.Write))
+ {
+ ser.Serialize(strm, queue);
+ strm.Close();
+ strm.Dispose();
+ }
+ }
+ catch (Exception)
+ {
+ // Any Errors will be out of diskspace/permissions problems.
+ // Don't report them as they'll annoy the user.
+ }
+ }
+
+ /// <summary>
+ /// Writes the current queue to disk to the location specified in file
+ /// </summary>
+ /// <param name="file"></param>
+ public void writeBatchScript(string file)
+ {
+ string queries = "";
+ foreach (QueueItem queue_item in queue)
+ {
+ string q_item = queue_item.Query;
+ string fullQuery = '"' + Application.StartupPath + "\\HandBrakeCLI.exe" + '"' + q_item;
+
+ if (queries == string.Empty)
+ queries = queries + fullQuery;
+ else
+ queries = queries + " && " + fullQuery;
+ }
+ string strCmdLine = queries;
+
+ if (file != "")
+ {
+ try
+ {
+ // Create a StreamWriter and open the file, Write the batch file query to the file and
+ // Close the stream
+ StreamWriter line = new StreamWriter(file);
+ line.WriteLine(strCmdLine);
+ line.Close();
+
+ MessageBox.Show("Your batch script has been sucessfully saved.", "Status", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
+ }
+ catch (Exception)
+ {
+ MessageBox.Show("Unable to write to the file. Please make sure that the location has the correct permissions for file writing.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
+ }
+
+ }
+ }
+
+ /// <summary>
+ /// Recover the queue from hb_queue_recovery.xml
+ /// </summary>
+ public void recoverQueue(string file)
+ {
+ string tempPath;
+ if (file == "hb_queue_recovery.xml")
+ tempPath = Path.Combine(Path.GetTempPath(), "hb_queue_recovery.xml");
+ else
+ tempPath = file;
+
+ if (File.Exists(tempPath))
+ {
+ using (FileStream strm = new FileStream(tempPath, FileMode.Open, FileAccess.Read))
+ {
+ if (strm.Length != 0)
+ {
+ List<QueueItem> list = ser.Deserialize(strm) as List<QueueItem>;
+
+ if (list != null)
+ foreach (QueueItem item in list)
+ queue.Add(item);
+
+ if (file != "hb_queue_recovery.xml")
+ write2disk("hb_queue_recovery.xml");
+ }
+ }
+ }
+ }
+ #endregion
+
+ #region Encoding
+
+ public Boolean isEncodeStarted { get; private set; }
+ public Boolean isPaused { get; private set; }
+ public Boolean isEncoding { get; private set; }
+ public EncodeProcess encodeProcess { get; set; }
+
+ public void startEncode()
+ {
+ Thread theQueue;
+ if (this.count() != 0)
+ {
+ if (isPaused)
+ isPaused = false;
+ else
+ {
+ isPaused = false;
+ try
+ {
+ theQueue = new Thread(startProc) { IsBackground = true };
+ theQueue.Start();
+ }
+ catch (Exception exc)
+ {
+ MessageBox.Show(exc.ToString());
+ }
+ }
+ }
+ }
+ public void pauseEncodeQueue()
+ {
+ isPaused = true;
+ EncodePaused(null);
+ }
+ public void endEncode()
+ {
+ encodeHandler.closeCLI(encodeProcess);
+ }
+
+ private void startProc(object state)
+ {
+ try
+ {
+ // Run through each item on the queue
+ while (this.count() != 0)
+ {
+ string query = getNextItemForEncoding();
+ write2disk("hb_queue_recovery.xml"); // Update the queue recovery file
+
+ encodeProcess = encodeHandler.runCli(query);
+ EncodeStarted(null);
+ encodeProcess.hbProcProcess.WaitForExit();
+
+ encodeHandler.addCLIQueryToLog(query);
+ encodeHandler.copyLog(lastQueueItem.Destination);
+
+ encodeProcess.hbProcProcess.Close();
+ encodeProcess.hbProcProcess.Dispose();
+ EncodeFinished(null);
+
+ while (isPaused) // Need to find a better way of doing this.
+ {
+ Thread.Sleep(10000);
+ }
+ }
+ EncodeQueueFinished(null);
+
+ // After the encode is done, we may want to shutdown, suspend etc.
+ encodeHandler.afterEncodeAction(encodeProcess);
+ }
+ catch (Exception exc)
+ {
+ throw new Exception(exc.ToString());
+ }
+ }
+ #endregion
+
+ #region Events
+ public event EventHandler OnEncodeStart;
+ public event EventHandler OnPaused;
+ public event EventHandler OnEncodeEnded;
+ public event EventHandler OnQueueFinished;
+
+ // Invoke the Changed event; called whenever encodestatus changes:
+ protected virtual void EncodeStarted(EventArgs e)
+ {
+ if (OnEncodeStart != null)
+ OnEncodeStart(this, e);
+
+ isEncoding = true;
+ }
+ protected virtual void EncodePaused(EventArgs e)
+ {
+ if (OnPaused != null)
+ OnPaused(this, e);
+ }
+ protected virtual void EncodeFinished(EventArgs e)
+ {
+ if (OnEncodeEnded != null)
+ OnEncodeEnded(this, e);
+
+ isEncoding = false;
+ }
+ protected virtual void EncodeQueueFinished(EventArgs e)
+ {
+ if (OnQueueFinished != null)
+ OnQueueFinished(this, e);
+ }
+ #endregion
+
+ }
+}
\ No newline at end of file |