X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=win%2FC%23%2FfrmActivityWindow.cs;h=613a1a4c2c31a912d16abb5fa1f0940996703642;hb=4f0019f03c2e85e8634150ff0c9a31bee6d35ce5;hp=ebee0ea4258226208385c6bc28469886873b7885;hpb=1bd547ad1105e88e30c65bf625b88b3d14794b1c;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/win/C#/frmActivityWindow.cs b/win/C#/frmActivityWindow.cs index ebee0ea4..613a1a4c 100644 --- a/win/C#/frmActivityWindow.cs +++ b/win/C#/frmActivityWindow.cs @@ -1,105 +1,502 @@ /* frmActivityWindow.cs $ - - This file is part of the HandBrake source code. - Homepage: . - It may be used under the terms of the GNU General Public License. */ - -using System; -using System.Collections.Generic; -using System.ComponentModel; -using System.Data; -using System.Drawing; -using System.Text; -using System.Windows.Forms; -using System.IO; -using System.Threading; - + This file is part of the HandBrake source code. + Homepage: . + It may be used under the terms of the GNU General Public License. */ namespace Handbrake { + using System; + using System.ComponentModel; + using System.Diagnostics; + using System.IO; + using System.Text; + using System.Threading; + using System.Windows.Forms; + using Functions; + using Model; + using Services; + using Timer = System.Threading.Timer; + + /// + /// The Activity Log Window + /// public partial class frmActivityWindow : Form { + /* Private Variables */ + + /// + /// The current position in the log file + /// + private int position; + + /// + /// A Timer for this window + /// + private Timer windowTimer; + + /// + /// The Encode Object + /// + private Encode encode; + + /// + /// The Scan Object + /// + private ScanService scan; + /// - /// This window should be used to display the RAW output of the handbrake CLI which is produced during an encode. + /// The Type of log that the window is currently dealing with /// - /// - Thread monitorFile; - String read_file; - public frmActivityWindow(string file) + private ActivityLogMode mode; + + /* Constructor */ + + /// + /// Initializes a new instance of the class. + /// + /// + /// The encode. + /// + /// + /// The scan. + /// + public frmActivityWindow(Encode encode, ScanService scan) { InitializeComponent(); - this.rtf_actLog.Text = string.Empty; - monitorFile = new Thread(autoUpdate); - read_file = file; + this.encode = encode; + this.scan = scan; + this.position = 0; + + // Listen for Scan and Encode Starting Events + scan.ScanStared += scan_ScanStared; + encode.EncodeStarted += encode_EncodeStarted; + } + + /* Delegates */ + + /// + /// A callback function for updating the ui + /// + /// + /// The text. + /// + private delegate void SetTextCallback(StringBuilder text); + + /// + /// Clear text callback + /// + private delegate void SetTextClearCallback(); + + /// + /// Set mode callback + /// + /// + /// The set mode. + /// + private delegate void SetModeCallback(ActivityLogMode setMode); + + /* Private Methods */ + + /// + /// Set the window to scan mode + /// + /// + /// The set Mode. + /// + private void SetMode(ActivityLogMode setMode) + { + if (IsHandleCreated) + { + if (rtf_actLog.InvokeRequired) + { + IAsyncResult invoked = BeginInvoke(new SetModeCallback(SetMode), new object[] {setMode}); + EndInvoke(invoked); + } + else + { + Reset(); + this.mode = setMode; + + Array values = Enum.GetValues(typeof(ActivityLogMode)); + Properties.Settings.Default.ActivityWindowLastMode = (int) values.GetValue(Convert.ToInt32(setMode)); + Properties.Settings.Default.Save(); + + this.Text = mode == ActivityLogMode.Scan + ? "Activity Window (Scan Log)" + : "Activity Window (Encode Log)"; + + if (mode == ActivityLogMode.Scan) + { + scan.ScanCompleted += stopWindowRefresh; + encode.EncodeEnded -= stopWindowRefresh; + } + else + { + scan.ScanCompleted -= stopWindowRefresh; + encode.EncodeEnded += stopWindowRefresh; + } + + // Start a fresh window timer + windowTimer = new Timer(new TimerCallback(LogMonitor), null, 1000, 1000); + } + } + } + + /// + /// On Window load, start a new timer + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void NewActivityWindow_Load(object sender, EventArgs e) + { + ActivityLogMode activitLogMode = (ActivityLogMode) Enum.ToObject(typeof(ActivityLogMode), Properties.Settings.Default.ActivityWindowLastMode); + SetMode(activitLogMode); + } + + /// + /// Set the Log window to encode mode when an encode starts. + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void encode_EncodeStarted(object sender, EventArgs e) + { + SetMode(ActivityLogMode.Encode); } - private void frmActivityWindow_Load(object sender, EventArgs e) + /// + /// Set the log widow to scan mode when a scan starts + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void scan_ScanStared(object sender, EventArgs e) { - this.rtf_actLog.Text = string.Empty; - rtf_actLog.Text = readFile(); - - monitorFile.Start(); + SetMode(ActivityLogMode.Scan); + } + + /// + /// Stop refreshing the window when no scanning or encoding is happening. + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void stopWindowRefresh(object sender, EventArgs e) + { + windowTimer.Dispose(); + LogMonitor(null); + } + + /// + /// Append new text to the window + /// + /// + /// The n. + /// + private void LogMonitor(object n) + { + AppendWindowText(GetLog()); + } + + /// + /// New Code for getting the Activity log from the Services rather than reading a file. + /// + /// + /// The StringBuilder containing a log + /// + private StringBuilder GetLog() + { + StringBuilder appendText = new StringBuilder(); + + if (this.mode == ActivityLogMode.Scan) + { + if (scan == null || scan.ActivityLog == string.Empty) + { + appendText.AppendFormat("Waiting for the log to be generated ...\n"); + position = 0; + ClearWindowText(); + PrintLogHeader(); + return appendText; + } + + using (StringReader reader = new StringReader(scan.ActivityLog)) + { + LogReader(reader, appendText); + } + } + else + { + if (encode == null || encode.ActivityLog == string.Empty) + { + appendText.AppendFormat("Waiting for the log to be generated ...\n"); + position = 0; + ClearWindowText(); + PrintLogHeader(); + return appendText; + } + + using (StringReader reader = new StringReader(encode.ActivityLog)) + { + LogReader(reader, appendText); + } + } + return appendText; } - private void autoUpdate(object state) + /// + /// Reads the log data from a Scan or Encode object + /// + /// + /// The reader. + /// + /// + /// The append text. + /// + private void LogReader(StringReader reader, StringBuilder appendText) { - while (true) + string line; + int i = 1; + while ((line = reader.ReadLine()) != null) { - updateTextFromThread(); - Thread.Sleep(3000); + if (i > position) + { + appendText.AppendLine(line); + position++; + } + i++; } } - - private delegate void UpdateUIHandler(); - private void updateTextFromThread() + + /// + /// Append text to the RTF box + /// + /// + /// The text. + /// + private void AppendWindowText(StringBuilder text) { - if (this.InvokeRequired) + try + { + if (IsHandleCreated) + { + if (rtf_actLog.InvokeRequired) + { + IAsyncResult invoked = BeginInvoke(new SetTextCallback(AppendWindowText), new object[] { text }); + EndInvoke(invoked); + } + else + lock (rtf_actLog) + rtf_actLog.AppendText(text.ToString()); + + // Stop the refresh process if log has finished. + if (text.ToString().Contains("HandBrake has Exited")) + { + windowTimer.Dispose(); + } + } + } + catch (Exception) { - this.BeginInvoke(new UpdateUIHandler(updateTextFromThread)); return; } - rtf_actLog.Text = readFile(); - this.rtf_actLog.SelectionStart = this.rtf_actLog.Text.Length -1; - this.rtf_actLog.ScrollToCaret(); + } - if (rtf_actLog.Text.Contains("HandBrake has exited.")) - monitorFile.Abort(); + /// + /// Clear the contents of the log window + /// + private void ClearWindowText() + { + try + { + if (IsHandleCreated) + { + if (rtf_actLog.InvokeRequired) + { + IAsyncResult invoked = BeginInvoke(new SetTextClearCallback(ClearWindowText)); + EndInvoke(invoked); + } + else + lock (rtf_actLog) + rtf_actLog.Clear(); + } + } + catch (Exception) + { + return; + } } - private string readFile() + /// + /// Display the log header + /// + private void PrintLogHeader() { - string log = ""; try { - // hb_encode_log.dat is the primary log file. Since .NET can't read this file whilst the CLI is outputing to it, - // we'll need to make a copy of it. - string logFile = Path.Combine(Path.GetTempPath(), read_file); - string logFile2 = Path.Combine(Path.GetTempPath(), "hb_encode_log_AppReadable.dat"); - - // Make sure the application readable log file does not already exist. FileCopy fill fail if it does. - if (File.Exists(logFile2)) - File.Delete(logFile2); - - // Copy the log file. - File.Copy(logFile, logFile2); - - // Begin processing the log file. - StreamReader sr = new StreamReader(logFile2); - string line = sr.ReadLine(); - while (line != null) + if (IsHandleCreated) { - log = log + (line + System.Environment.NewLine); - line = sr.ReadLine(); + if (rtf_actLog.InvokeRequired) + { + IAsyncResult invoked = BeginInvoke(new SetTextClearCallback(PrintLogHeader)); + EndInvoke(invoked); + } + else + { + lock (rtf_actLog) + { + // Print the log header. This function will be re-implimented later. Do not delete. + StringBuilder header = new StringBuilder(); + + header.Append(String.Format("### Windows GUI {1} {0} \n", Properties.Settings.Default.hb_build, Properties.Settings.Default.hb_version)); + header.Append(String.Format("### Running: {0} \n###\n", Environment.OSVersion)); + header.Append(String.Format("### CPU: {0} \n", SystemInfo.GetCpuCount)); + header.Append(String.Format("### Ram: {0} MB \n", SystemInfo.TotalPhysicalMemory)); + header.Append(String.Format("### Screen: {0}x{1} \n", SystemInfo.ScreenBounds.Bounds.Width, SystemInfo.ScreenBounds.Bounds.Height)); + header.Append(String.Format("### Temp Dir: {0} \n", Path.GetTempPath())); + header.Append(String.Format("### Install Dir: {0} \n", Application.StartupPath)); + header.Append(String.Format("### Data Dir: {0} \n", Application.UserAppDataPath)); + header.Append("#########################################\n\n"); + + rtf_actLog.AppendText(header.ToString()); + } + } } - sr.Close(); } - catch (Exception exc) + catch (Exception) { - MessageBox.Show("An Error has occured! \n\n" + exc.ToString(), "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; } + } + + /// + /// Reset Everything + /// + private void Reset() + { + if (windowTimer != null) + windowTimer.Dispose(); + position = 0; + ClearWindowText(); + PrintLogHeader(); + windowTimer = new Timer(new TimerCallback(LogMonitor), null, 1000, 1000); + } + + /* Menus and Buttons */ + + /// + /// Copy log to clipboard + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void MnuCopyLogClick(object sender, EventArgs e) + { + Clipboard.SetDataObject(rtf_actLog.SelectedText != string.Empty ? rtf_actLog.SelectedText : rtf_actLog.Text, true); + } + + /// + /// Open the log folder + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void MnuOpenLogFolderClick(object sender, EventArgs e) + { + string logDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs"; + string windir = Environment.GetEnvironmentVariable("WINDIR"); + Process prc = new Process + { + StartInfo = + { + FileName = windir + @"\explorer.exe", + Arguments = logDir + } + }; + prc.Start(); + } + + /// + /// Copy the log + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void BtnCopyClick(object sender, EventArgs e) + { + Clipboard.SetDataObject(rtf_actLog.SelectedText != string.Empty ? rtf_actLog.SelectedText : rtf_actLog.Text, true); + } + + /// + /// Set scan mode + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void BtnScanLogClick(object sender, EventArgs e) + { + SetMode(ActivityLogMode.Scan); + } + + /// + /// Set the encode mode + /// + /// + /// The sender. + /// + /// + /// The e. + /// + private void BtnEncodeLogClick(object sender, EventArgs e) + { + SetMode(ActivityLogMode.Encode); + } + + /* Overrides */ + + /// + /// override onclosing + /// + /// + /// The e. + /// + protected override void OnClosing(CancelEventArgs e) + { + scan.ScanStared -= scan_ScanStared; + encode.EncodeStarted -= encode_EncodeStarted; + + scan.ScanCompleted -= stopWindowRefresh; + encode.EncodeEnded -= stopWindowRefresh; - return log; + windowTimer.Dispose(); + e.Cancel = true; + this.Dispose(); + base.OnClosing(e); } } } \ No newline at end of file