X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=win%2FC%23%2FfrmActivityWindow.cs;h=5f41c799bd50d4fcd7a31ef6d986c90bf888aa7a;hb=a524194964cbed535f17b1b729fec7847539c94e;hp=dc8b7a642a0933384077f0c2c87cffda32b449ad;hpb=76a5e6eea6cce52113a35f84634d41fc2a642b1e;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/win/C#/frmActivityWindow.cs b/win/C#/frmActivityWindow.cs
index dc8b7a64..5f41c799 100644
--- a/win/C#/frmActivityWindow.cs
+++ b/win/C#/frmActivityWindow.cs
@@ -1,82 +1,329 @@
 /*  frmActivityWindow.cs $
  	
  	   This file is part of the HandBrake source code.
- 	   Homepage: <http://handbrake.m0k.org/>.
+ 	   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.Data;
-using System.Drawing;
 using System.Text;
 using System.Windows.Forms;
 using System.IO;
+using System.Threading;
+using Handbrake.Functions;
+using Microsoft.Win32;
 
 
 namespace Handbrake
 {
     public partial class frmActivityWindow : Form
     {
-        /// <summary>
-        /// This window should be used to display the RAW output of the handbrake CLI which is produced during an encode.
-        /// </summary>
-        public frmActivityWindow()
-        {
-            InitializeComponent();
-            this.rtf_actLog.Text = string.Empty;     
-        }
+        private delegate void setTextCallback(StringBuilder text);
+        private delegate void setTextClearCallback();
+        private static int _position;
+        private static string _lastMode;
+        private static string _currentMode;
+        private Thread _monitor;
+        private Boolean _kilLThread;
 
-        private void btn_close_Click(object sender, EventArgs e)
+        public frmActivityWindow(string mode)
         {
-             this.Hide();
-        }
+            _kilLThread = false;
+            _position = 0;
+            if (mode == "scan")
+                SetScanMode();
+            else
+                SetEncodeMode();
 
-        private void frmActivityWindow_Load(object sender, EventArgs e)
+            InitializeComponent();
+        }
+        private void NewActivityWindow_Load(object sender, EventArgs e)
         {
-            this.rtf_actLog.Text = string.Empty;
-            readFile();
+            _monitor = new Thread(LogMonitor);
+            
+            try
+            {
+                _monitor.Start();
+            }
+            catch (Exception exc)
+            {
+                MessageBox.Show("Unable to monitor HandBrakes log files. Please report this error. If the problem presists, try rebooting your computer.\n\n Debug Informaton:\n" + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+            }
         }
 
-        private void readFile()
+        private void LogMonitor()
         {
-            try
+            while (true)
             {
-                string dvdInfoPath = Path.Combine(Path.GetTempPath(), "hb_encode_log.dat");
-                FileStream f = System.IO.File.Open(dvdInfoPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+                if (!IsHandleCreated || _kilLThread) // break out the thread if the window has been disposed.
+                    break;
+
+                // Perform a reset if require.
+                // If we have switched to a different log file, we want to start from the beginning.
+                if (SetLogFile != _lastMode)
+                    Reset();
 
-                StreamReader sr = new StreamReader(f);
+                // Perform the window update
+                switch (SetLogFile)
+                {
+                    case "last_scan_log.txt":
+                        AppendWindowText(ReadFile("last_scan_log.txt"));
+                        _lastMode = "last_scan_log.txt";
+                        break;
+                    case "last_encode_log.txt":
+                        AppendWindowText(ReadFile("last_encode_log.txt"));
+                        _lastMode = "last_encode_log.txt";
+                        break;
+                }
 
+                try
+                {
+                    Thread.Sleep(1000);
+                }
+                catch (ThreadInterruptedException)
+                {
+                    // Do Nothnig.
+                }
 
+            }
+        }
+        private StringBuilder ReadFile(string file)
+        {
+            StringBuilder appendText = new StringBuilder();
 
-                string line = sr.ReadLine();
+            // last_encode_log.txt is the primary log file. Since .NET can't read this file whilst the CLI is outputing to it (Not even in read only mode),
+            // we'll need to make a copy of it.
+            string logDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs";
+            string logFile = Path.Combine(logDir, file);
+            string logFile2 = Path.Combine(logDir, "tmp_appReadable_log.txt");
 
-                while (line != null)
+            try
+            {
+                // 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.
+                if (File.Exists(logFile))
+                    File.Copy(logFile, logFile2, true);
+                else
+                {
+                    appendText.AppendFormat("Waiting for the log file to be generated ...\n");
+                    _position = 0;
+                    ClearWindowText();
+                    PrintLogHeader();
+                    return appendText;
+                }
+
+                // Start the Reader
+                // Only use text which continues on from the last read line
+                StreamReader sr = new StreamReader(logFile2);
+                string line;
+                int i = 1;
+                while ((line = sr.ReadLine()) != null)
                 {
-                    this.rtf_actLog.AppendText(line + System.Environment.NewLine);
-                    line = sr.ReadLine();
+                    if (i > _position)
+                    {
+                        appendText.AppendLine(line);
+                        _position++;
+                    }
+                    i++;
                 }
                 sr.Close();
+                sr.Dispose();
+
+            }
+            catch (Exception exc)
+            {
+                appendText.AppendFormat("\n The Log file could not be read. You may need to restart HandBrake! " + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                _position = 0;
+                ClearWindowText();
+            }
+            return appendText;
+        }
+        private void AppendWindowText(StringBuilder text)
+        {
+            try
+            {
+                if (IsHandleCreated)
+                {
+                    if (rtf_actLog.InvokeRequired)
+                    {
+                        IAsyncResult invoked = BeginInvoke(new setTextCallback(AppendWindowText), new object[] { text });
+                        EndInvoke(invoked);
+                    }
+                    else
+                        rtf_actLog.AppendText(text.ToString());
+                }
+            } catch(ThreadInterruptedException)
+            {
+                // Do Nothing
+            }
+            catch (Exception exc)
+            {
+                MessageBox.Show("Unless you are having problems, you can probably ignore this error. It would not hurt to report this error!\n\nSetWindowText(): Exception: \n" + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
+            }
+        }
+        private void ClearWindowText()
+        {
+            try
+            {
+                if (IsHandleCreated)
+                {
+                    if (rtf_actLog.InvokeRequired)
+                    {
+                        IAsyncResult invoked = BeginInvoke(new setTextClearCallback(ClearWindowText));
+                        EndInvoke(invoked);
+                    }
+                    else
+                        rtf_actLog.Clear();
+                }
+            }
+            catch (Exception exc)
+            {
+                MessageBox.Show("Unless you are having problems, you can probably ignore this error. It would not hurt to report this error!\n\nClearWindowText(): Exception: \n" + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
+            }
+        }
+        private void PrintLogHeader()
+        {
+            try
+            {
+                if (IsHandleCreated)
+                {
+                    if (rtf_actLog.InvokeRequired)
+                    {
+                        IAsyncResult invoked = BeginInvoke(new setTextClearCallback(PrintLogHeader));
+                        EndInvoke(invoked);
+                    }
+                    else
+                    {
+                        // Print the log header. This function will be re-implimented later. Do not delete.
+                        rtf_actLog.AppendText(String.Format("### Windows GUI {1} {0} \n", Properties.Settings.Default.hb_build, Properties.Settings.Default.hb_version));
+                        rtf_actLog.AppendText(String.Format("### Running: {0} \n###\n", Environment.OSVersion));
+                        rtf_actLog.AppendText(String.Format("### CPU: {0} \n", getCpuCount()));
+                        rtf_actLog.AppendText(String.Format("### Ram: {0} MB \n", TotalPhysicalMemory()));
+                        rtf_actLog.AppendText(String.Format("### Screen: {0}x{1} \n", screenBounds().Bounds.Width, screenBounds().Bounds.Height));
+                        rtf_actLog.AppendText(String.Format("### Temp Dir: {0} \n", Path.GetTempPath()));
+                        rtf_actLog.AppendText(String.Format("### Install Dir: {0} \n", Application.StartupPath));
+                        rtf_actLog.AppendText(String.Format("### Data Dir: {0} \n", Application.UserAppDataPath));
+                        rtf_actLog.AppendText("#########################################\n\n");
+                    }
+                }
             }
-            catch (Exception)
+            catch (Exception exc)
             {
-                rtf_actLog.Clear();
-                rtf_actLog.Text = "Please wait until the encode has finished to view the log.";
+                MessageBox.Show("Unless you are having problems, you can probably ignore this error. It would not hurt to report this error!\n\nPrintLogHeader(): Exception: \n" + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
             }
+
+        }
+        private void Reset()
+        {
+            _position = 0;
+            ClearWindowText();
+            PrintLogHeader();
+        }
+
+        #region Public
+
+        public string SetLogFile
+        {
+            get { return string.IsNullOrEmpty(_currentMode) ? "" : _currentMode; }
+            set { _currentMode = value; }
+        }
+        public void SetScanMode()
+        {
+            Reset();
+            SetLogFile = "last_scan_log.txt";
+            this.Text = "Activity Window (Scan Log)";
         }
+        public void SetEncodeMode()
+        {
+            Reset();
+            SetLogFile = "last_encode_log.txt";
+            this.Text = "Activity Window (Enocde Log)";
+        }
+
+        #endregion
 
+        #region User Interface
+        private void mnu_copy_log_Click(object sender, EventArgs e)
+        {
+            if (rtf_actLog.SelectedText != "")
+                Clipboard.SetDataObject(rtf_actLog.SelectedText, true);
+            else
+                Clipboard.SetDataObject(rtf_actLog.Text, true);
+        }
+        private void mnu_openLogFolder_Click(object sender, EventArgs e)
+        {
+            string logDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\logs";
+            string windir = Environment.GetEnvironmentVariable("WINDIR");
+            System.Diagnostics.Process prc = new System.Diagnostics.Process();
+            prc.StartInfo.FileName = windir + @"\explorer.exe";
+            prc.StartInfo.Arguments = logDir;
+            prc.Start();
+        }
         private void btn_copy_Click(object sender, EventArgs e)
         {
-            if (rtf_actLog.Text != "")
-                Clipboard.SetText(rtf_actLog.Text, TextDataFormat.Text);
+            if (rtf_actLog.SelectedText != "")
+                Clipboard.SetDataObject(rtf_actLog.SelectedText, true);
+            else
+                Clipboard.SetDataObject(rtf_actLog.Text, true);
+        }
+        private void btn_scan_log_Click(object sender, EventArgs e)
+        {
+            SetScanMode();
         }
+        private void btn_encode_log_Click(object sender, EventArgs e)
+        {
+            SetEncodeMode();
+        }
+        #endregion
 
-        private void btn_refresh_Click(object sender, EventArgs e)
+        #region System Information
+        /// <summary>
+        /// Returns the total physical ram in a system
+        /// </summary>
+        /// <returns></returns>
+        public uint TotalPhysicalMemory()
         {
-            rtf_actLog.Clear();
-            readFile();
+            Win32.MEMORYSTATUS memStatus = new Win32.MEMORYSTATUS();
+            Win32.GlobalMemoryStatus(ref memStatus);
+
+            uint MemoryInfo = memStatus.dwTotalPhys;
+            MemoryInfo = MemoryInfo / 1024 / 1024;
+
+            return MemoryInfo;
         }
 
+        /// <summary>
+        /// Get the number of CPU Cores
+        /// </summary>
+        /// <returns>Object</returns>
+        public Object getCpuCount()
+        {
+            RegistryKey RegKey = Registry.LocalMachine;
+            RegKey = RegKey.OpenSubKey("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0");
+            return RegKey.GetValue("ProcessorNameString");
+        }
 
+        /// <summary>
+        /// Get the System screen size information.
+        /// </summary>
+        /// <returns>System.Windows.Forms.Scree</returns>
+        public Screen screenBounds()
+        {
+            return Screen.PrimaryScreen;
+        }
+        #endregion
+
+        protected override void OnClosing(CancelEventArgs e)
+        {
+            _kilLThread = true;
+            _monitor.Interrupt();
+            _monitor.Join();
+            e.Cancel = true;
+            this.Dispose();
+            base.OnClosing(e);
+        }
     }
 }
\ No newline at end of file