#define FORCE_DISABLE_PROFILER_LOGLEVEL // when define will forcibly disable the profiler loglevel
//#region Logging Defines
//// include this any class or method that required logging, and comment-out what is not needed

//#region Enabled logging levels
//#define LOGGING_ENABLE_INFO
//#define LOGGING_ENABLE_WARN
//#define LOGGING_ENABLE_DEBUG
//#define LOGGING_ENABLE_VERBOSEDEBUG
//#define LOGGING_ENABLE_ERROR
//#define LOGGING_ENABLE_VERBOSEERROR
//#define LOGGING_ENABLE_PROFILER
//#endregion
//#endregion
//#define FORCE_ALL_LOGGING_FLAGS // when defined will force logging flags to ALL
#define SHOW_DEBUG_MENU // when defined will show the debug menu or else it will be hidden
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using RomCheater.Logging;
using RomCheater.Properties;
using RomCheater.UserSettingsSupport;
using RomCheater.PluginFramework.Core;
using System.Diagnostics;

using WeifenLuo.WinFormsUI.Docking;
using RomCheater.Core.Docking;
using System.IO;
using Sojaner.MemoryScanner;
using Sojaner.MemoryScanner.Events;
using RomCheater.Serialization;
using RomCheater.Interfaces;
using Enterprise.Logging;

namespace RomCheater
{
    public partial class Main : Form
    {
        //private ushort Logger_flags = 0;
        private LogLevel logging_level = LogLevel.kLogLevel_All;
        const string DockPanelConfig = "RomCheater-DockPanel.conf";
        private SettingSubscriber SettingsSubscriber;
        private bool m_bSaveLayout = true;
        private Process SelectedProcess = null;        
        private DeserializeDockContent m_deserializeDockContent;
        private FloatingLogWindow m_LogWindow = new FloatingLogWindow();
        private FloatingAboutBox m_AboutBox = new FloatingAboutBox();
        private FloatingRamDumperDialog m_RamDump = new FloatingRamDumperDialog();
        private FloatingPIDSelector m_PIDSelector = new FloatingPIDSelector();
        private FloatingMemoryView m_memoryview = new FloatingMemoryView();
        private FloatingDataTypeConverter m_typeconverter = new FloatingDataTypeConverter();
        private FloatingMemorySearcher m_memsearcher = new FloatingMemorySearcher();
        private FloatingPEViewer m_peviewer = new FloatingPEViewer();
        private FloatingRVACalculator m_rvacalc = new FloatingRVACalculator();

        private FloatingMemorySectionViewer m_msv = new FloatingMemorySectionViewer();

        private FloatingUserControlDock m_ucd = new FloatingUserControlDock();

        private FloatingWebBrowser m_wb = new FloatingWebBrowser();

        //private bool log_window_expanded = false;
        //private double log_window_splitter_default_position = 1.4045;
        PluginLoader loader = null;
        IConfigPlugin ConfigPlugin = null;
        IInputPlugin InputPlugin = null;
        IWindowPlugin WindowPlugin = null;
        List<IUserControlPlugin> UserControlPlugins = null;
        //static Main() { SettingSubscriber.AddSubscriber(new Main(), Settings.Default); }
        //private const string t = "RomCheater";
        #region LogWriterSupport
        static LogWriter _LoggerInstance;
        static LogWriter LoggerInstance
        {
            get { return _LoggerInstance; }
            set { _LoggerInstance = value; }
        }
        #endregion


        public IWebBrowserProvider WebBrowserProvider
        {
            get { return new WebBrowserProvider(m_wb); }
        }

        private void OnProcessChanged(ProcessChangedEventArgs e)
        {
            ConfigPlugin.WebBrowserProvider = this.WebBrowserProvider;
            if (m_memsearcher.SearchInProgess)
            {
                DialogResult result = MessageBox.Show("Do you want to start a new search with the selected process?", "A memory search is currently in progress", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button3);
                if (result != DialogResult.Yes || result != DialogResult.OK) { return; }
                m_memsearcher = null; //free memory used by the memory searcher
                m_memsearcher = new FloatingMemorySearcher();
            }
            SelectedProcess = Process.GetProcessById(e.ProcessID);
            m_RamDump.AcceptedPlugin = this.ConfigPlugin;
            m_RamDump.AcceptedProcess = SelectedProcess;

            m_peviewer.AcceptedPlugin = this.ConfigPlugin;
            m_peviewer.AcceptedProcess = SelectedProcess;
            m_peviewer.OnPEDataUpdated += new BaseEventHandler<PEViewerDataUpdatedEventArgs>(OnPEDataUpdated);

            m_memoryview.AcceptedPlugin = this.ConfigPlugin;
            m_memoryview.AcceptedProcess = SelectedProcess;

            m_memsearcher.AcceptedPlugin = this.ConfigPlugin;
            m_memsearcher.AcceptedProcess = SelectedProcess;
            m_memsearcher.OnBrowseMemoryRegion += new BaseEventHandler<BrowseMemoryRegionEvent>(OnBrowseMemoryRegion);

            m_msv.AcceptedPlugin = this.ConfigPlugin;
            m_msv.AcceptedProcess = SelectedProcess;
            m_msv.OnBrowseMemoryRegion += new BaseEventHandler<BrowseMemoryRegionEvent>(OnBrowseMemoryRegion);


            AcceptedProcessAndConfig iapc = new AcceptedProcessAndConfig(this.ConfigPlugin, SelectedProcess);

            this.ConfigPlugin.SetAcceptedProcessAndConfig(iapc);
            this.WindowPlugin.SetAcceptedProcessAndConfig(iapc);
            this.InputPlugin.SetAcceptedProcessAndConfig(iapc);
            for (int i = 0; i < UserControlPlugins.Count; i++)
            {
                UserControlPlugins[i].SetAcceptedProcessAndConfig(iapc);
            }
        }

        void OnPEDataUpdated(PEViewerDataUpdatedEventArgs e)
        {            
                m_memoryview.SetPEViewerData(e.peData);            
                m_memsearcher.SetPEViewerData(e.peData);
                m_rvacalc.SetPEViewerData(e.peData);
                m_RamDump.SetPEViewerData(e.peData);
                m_msv.SetPEViewerData(e.peData);

                ConfigPlugin.SetPEViewerData(e.peData);
                WindowPlugin.SetPEViewerData(e.peData);
                InputPlugin.SetPEViewerData(e.peData);

                for (int i = 0; i < UserControlPlugins.Count; i++)
                {
                    UserControlPlugins[i].SetPEViewerData(e.peData);
                }

        }
        private void OnBrowseMemoryRegion(BrowseMemoryRegionEvent e)
        {
            m_memoryview.BrowseMemoryRegion(e.MemoryRegion);
        }

        #region Dock Support
        void AddDockToWindowList(object sender, EventArgs e)
        {
            DockContent dc;
            TypeBinder.Bind(sender, out dc);
            ToolStripMenuItem tsmi = new ToolStripMenuItem(dc.Text);
            tsmi.Name = dc.Name;
            tsmi.Tag = dc;
            tsmi.Click += new EventHandler(tsmi_Click);            
            mnuWindows.DropDownItems.Add(tsmi);
        }
        void tsmi_Click(object sender, EventArgs e)
        {
            ToolStripMenuItem tsmi;
            TypeBinder.Bind(sender, out tsmi);
            DockContent dc;
            TypeBinder.Bind(tsmi.Tag, out dc);
            dc.Activate();
        }
        void RemoveDockFromWindowList(object sender, FormClosedEventArgs e)
        {
            DockContent dc;
            TypeBinder.Bind(sender, out dc);
             mnuWindows.DropDownItems.RemoveByKey(dc.Name);
        }
        private IDockContent GetContentFromPersistString(string persistString)
        {
            if (persistString == typeof(FloatingLogWindow).ToString()) { return m_LogWindow; }
            if (persistString == typeof(FloatingRamDumperDialog).ToString()) { return m_RamDump; }
            if (persistString == typeof(FloatingPIDSelector).ToString()) { return m_PIDSelector; }
            if (persistString == typeof(FloatingMemoryView).ToString()) { return m_memoryview; }
            if (persistString == typeof(FloatingDataTypeConverter).ToString()) { return m_typeconverter; }
            if (persistString == typeof(FloatingMemorySearcher).ToString()) { return m_memsearcher; }
            if (persistString == typeof(FloatingPEViewer).ToString()) { return m_peviewer; }
            if (persistString == typeof(FloatingRVACalculator).ToString()) { return m_rvacalc; }            
            if (persistString == typeof(FloatingMemorySectionViewer).ToString()) { return m_msv; }
            if (persistString == typeof(FloatingUserControlDock).ToString()) { return m_ucd; }
            if (persistString == typeof(FloatingWebBrowser).ToString()) { return m_wb; }
            else { return null; }
        }
        private void SetDockIcon(DockContent c)
        {
            if (c == null)
            {
                throw new NullReferenceException("");
            }
            c.ShowIcon = true;
            //c.DockHandler.CloseButton = false;
            //c.DockHandler.CloseButtonVisible = false;
            //c.DockHandler.AllowEndUserDocking = false;
            //c.Icon = (Icon)Core.Properties.Resources.romcheater_icon.Clone();
            c.Icon = Core.Properties.Resources.romcheater_icon;
            //c.Activate();
        }
        private void SetDockIcons()
        {
            SetDockIcon(m_LogWindow);
            SetDockIcon(m_RamDump);
            SetDockIcon(m_PIDSelector);
            SetDockIcon(m_memoryview);
            SetDockIcon(m_typeconverter);
            SetDockIcon(m_memsearcher);
            SetDockIcon(m_peviewer);
            SetDockIcon(m_rvacalc);
            SetDockIcon(m_ucd);
            SetDockIcon(m_msv);
            SetDockIcon(m_wb);
        }
        public void SetupDocks()
        {
            m_LogWindow = new FloatingLogWindow();
            LoggerInstance = m_LogWindow.Logwriter;
            m_AboutBox = new FloatingAboutBox();
            m_RamDump = new FloatingRamDumperDialog();
            m_PIDSelector = new FloatingPIDSelector();
            m_PIDSelector.OnSelectedProcessChanged += new BaseEventHandler<ProcessChangedEventArgs>(OnProcessChanged);
            m_memoryview = new FloatingMemoryView();
            m_typeconverter = new FloatingDataTypeConverter();
            m_memsearcher = new FloatingMemorySearcher();
            m_memsearcher.OnBrowseMemoryRegion += new BaseEventHandler<BrowseMemoryRegionEvent>(OnBrowseMemoryRegion);
            m_peviewer = new FloatingPEViewer();
            m_peviewer.OnPEDataUpdated += new BaseEventHandler<PEViewerDataUpdatedEventArgs>(OnPEDataUpdated);
            m_rvacalc = new FloatingRVACalculator();
            m_ucd = new FloatingUserControlDock();
            m_msv = new FloatingMemorySectionViewer();
            m_deserializeDockContent = new DeserializeDockContent(GetContentFromPersistString);
            m_wb = new FloatingWebBrowser();            
        }
        #region SetupDockWindowHandler support
        public void SetupDockWindowHandler()
        {
            SetupLogWindowHandler();
            SetupRamDumpWindowHandler();
            SetupMemoryViewWindowHandler();
            SetupPIDSelectorWindowHandler();
            SetupDataTypeConverterWindowHandler();
            SetupMemorySearchWindowHandler();
            SetupPEViewerWindowHandler();
            SetupRVACalculatorWindowHandler();            
            SetupMemorySectionViewerWindowHandler();
            SetupUserControlDockWindowHandler();
            SetupWebBrowserWindowHandler();            
        }
        private void SetupLogWindowHandler()
        {
            if (m_LogWindow == null) return;
            m_LogWindow.Shown += new EventHandler(AddDockToWindowList);
            m_LogWindow.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);            
            //m_LogWindow.Activate();
        }
        private void SetupRamDumpWindowHandler()
        {
            if (m_RamDump == null) return;
            m_RamDump.Shown += new EventHandler(AddDockToWindowList);
            m_RamDump.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            m_RamDump.AcceptedPlugin = ConfigPlugin;
            //m_RamDump.Activate();
        }
        private void SetupMemoryViewWindowHandler()
        {
            if (m_memoryview == null) return;
            m_memoryview.Shown += new EventHandler(AddDockToWindowList);
            m_memoryview.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            m_memoryview.AcceptedPlugin = ConfigPlugin;
            //m_memoryview.Activate();
        }
        private void SetupPIDSelectorWindowHandler()
        {
            if (m_PIDSelector == null) return;
            m_PIDSelector.Shown += new EventHandler(AddDockToWindowList);
            m_PIDSelector.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            m_PIDSelector.AcceptedPlugin = ConfigPlugin;
            //m_PIDSelector.Activate();
        }
        private void SetupDataTypeConverterWindowHandler()
        {
            if (m_typeconverter == null) return;
            m_typeconverter.Shown += new EventHandler(AddDockToWindowList);
            m_typeconverter.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            //m_typeconverter.Activate();
        }
        private void SetupMemorySearchWindowHandler()
        {
            if (m_memsearcher == null) return;
            m_memsearcher.Shown += new EventHandler(AddDockToWindowList);
            m_memsearcher.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            //m_memsearcher.Activate();
        }
        private void SetupPEViewerWindowHandler()
        {
            if (m_peviewer == null) return;
            m_peviewer.Shown += new EventHandler(AddDockToWindowList);
            m_peviewer.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            m_PIDSelector.AcceptedPlugin = ConfigPlugin;
            //m_peviewer.Activate();
        }
        private void SetupRVACalculatorWindowHandler()
        {
            if (m_rvacalc == null) return;
            m_rvacalc.Shown += new EventHandler(AddDockToWindowList);
            m_rvacalc.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            m_rvacalc.AcceptedPlugin = ConfigPlugin;
            //m_rvacalc.Activate();
        }
        private void SetupUserControlDockWindowHandler()
        {
            if (m_ucd == null) return;
            m_ucd.Shown += new EventHandler(AddDockToWindowList);
            m_ucd.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            //m_ucd.Activate();
        }
        private void SetupMemorySectionViewerWindowHandler()
        {
            if (m_msv == null) return;
            m_msv.Shown += new EventHandler(AddDockToWindowList);
            m_msv.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            m_msv.AcceptedPlugin = ConfigPlugin;
            //m_msv.Activate();
        }
        private void SetupWebBrowserWindowHandler()
        {
            if (m_wb == null) return;
            m_wb.Shown += new EventHandler(AddDockToWindowList);
            m_wb.FormClosed += new FormClosedEventHandler(RemoveDockFromWindowList);
            //m_wb.Activate();
        }
        #endregion
        public void ShowDocks()
        {
            ShowLogWindow();
            SetupLogWindowHandler();
            //ShowAboutBox();
            ShowRamDump();
            SetupRamDumpWindowHandler();
            ShowMemoryView();
            SetupMemoryViewWindowHandler();
            ShowPidSelector();
            SetupPIDSelectorWindowHandler();
            ShowDataTypeConverter();
            SetupDataTypeConverterWindowHandler();

            ShowRVACalculator();
            SetupRVACalculatorWindowHandler();

            ShowMemorySectionViewer();
            SetupMemorySectionViewerWindowHandler();



            ShowUserControlDock();
            SetupUserControlDockWindowHandler();          

            ShowMemorySearch();
            SetupMemorySearchWindowHandler();
            ShowPEViewer();
            SetupPEViewerWindowHandler();
            
            ShowWebBrowser();
            SetupWebBrowserWindowHandler();          
        }
        public void ShowLogWindow()
        {
            if (m_LogWindow == null || m_LogWindow.IsDisposed) { m_LogWindow = new FloatingLogWindow(); }
            LoggerInstance = m_LogWindow.Logwriter;
            //LoggerInstance.CreateNewLog(false);
            m_LogWindow.Show(dockPanel, DockState.DockBottom);       
        }
        public void ShowAboutBox()
        {
            if (m_AboutBox == null || m_AboutBox.IsDisposed) { m_AboutBox = new FloatingAboutBox(); }
            m_AboutBox.ShowDialog();
        }
        public void ShowRamDump()
        {
            //load_plugins_silent();
            m_RamDump = new FloatingRamDumperDialog(ConfigPlugin);
            m_RamDump.AcceptedProcess = SelectedProcess;
            m_RamDump.Show(dockPanel);
        }       
        public void ShowMemoryView()
        {
            //load_plugins_silent();
            m_memoryview = new FloatingMemoryView(ConfigPlugin);
            m_memoryview.AcceptedProcess = SelectedProcess;
            m_memoryview.Show(dockPanel);
        }
        public void ShowPidSelector()
        {
            //load_plugins_silent();
            //List<Process> procs = ConfigPlugin.ValidProcessesForPlugin;
            m_PIDSelector = new FloatingPIDSelector(ConfigPlugin);
            m_PIDSelector.OnSelectedProcessChanged += new BaseEventHandler<ProcessChangedEventArgs>(OnProcessChanged);
            m_PIDSelector.Show(dockPanel);
        }
        public void ShowDataTypeConverter()
        {
            if (m_typeconverter == null || m_typeconverter.IsDisposed) { m_typeconverter = new FloatingDataTypeConverter(); }
            m_typeconverter.Show(dockPanel, DockState.DockRightAutoHide);            
        }
        public void ShowMemorySearch()
        {
            //load_plugins_silent();
            m_memsearcher = new FloatingMemorySearcher(ConfigPlugin);
            m_memsearcher.AcceptedProcess = SelectedProcess;
            m_memsearcher.OnBrowseMemoryRegion += new BaseEventHandler<BrowseMemoryRegionEvent>(OnBrowseMemoryRegion);
            m_memsearcher.Show(dockPanel);
        }
        public void ShowPEViewer()
        {
            //load_plugins_silent();
            m_peviewer = new FloatingPEViewer(ConfigPlugin);
            m_peviewer.AcceptedProcess = SelectedProcess;
            m_peviewer.OnPEDataUpdated += new BaseEventHandler<PEViewerDataUpdatedEventArgs>(OnPEDataUpdated);
            m_peviewer.Show(dockPanel);
        }
        public void ShowRVACalculator()
        {
            //load_plugins_silent();
            m_rvacalc = new FloatingRVACalculator(ConfigPlugin);
            m_rvacalc.AcceptedProcess = SelectedProcess;
            m_rvacalc.Show(dockPanel, DockState.DockRightAutoHide);
        }
        public void ShowMemorySectionViewer()
        {
            //load_plugins_silent();
            m_msv = new FloatingMemorySectionViewer(ConfigPlugin);
            m_msv.AcceptedProcess = SelectedProcess;
            m_msv.Show(dockPanel);
        }
        public void ShowUserControlDock()
        {
            //load_plugins_silent();
            if (m_ucd == null)
            {
                m_ucd = new FloatingUserControlDock();
            }
            if (this.UserControlPlugins.Count > 0)
            {
                m_ucd.UserPlugins = this.UserControlPlugins;
            }
            m_ucd.Show(dockPanel, DockState.DockRightAutoHide);
        }
        public void ShowWebBrowser()
        {
            //load_plugins_silent();
            m_wb = new FloatingWebBrowser();
            m_wb.Show(dockPanel);
        }
        #endregion


        public Main() : this(false) { }
        public Main(bool no_console_redirect)
        {
            InitializeComponent();            
#if SHOW_DEBUG_MENU
            mnuDebug.Visible = true;
#else
            mnuDebug.Visible = false;
#endif
            SettingsSubscriber = new SettingSubscriber();
            SettingsSubscriber.AddSubscriber(this, Settings.Default);            
            SetupDocks();
            LoggerInstance = m_LogWindow.Logwriter;
            load_loggerflags();
            load_plugins();      
        }
        private void load_loggerflags()
        {
            bool upgraded_flags = Logging.Properties.Settings.Default.UpgradedLogLevel;
            if (!upgraded_flags)
            {
                logging_level = new LoggingFlagsConverter(Logging.Properties.Settings.Default.LoggingFlags).ConvertFlags();
                Logging.Properties.Settings.Default.UpgradedLogLevel = true;
                Logging.Properties.Settings.Default.gLogLoggingFlags = (uint)logging_level;
                Logging.Properties.Settings.Default.Save();
            }
             logging_level = (LogLevel)Logging.Properties.Settings.Default.gLogLoggingFlags;
#if FORCE_ALL_LOGGING_FLAGS
      logging_level = LogLevel.kLogLevel_All;
#endif
#if FORCE_DISABLE_PROFILER_LOGLEVEL
             logging_level = logging_level & ~LogLevel.kLogLevel_Profiler;
             logging_level = logging_level & ~LogLevel.kLogLevel_VerboseProfiler;
#endif
             gLog.CreateLog(LoggingConstants.AppFullLogPath, true, logging_level, new EventHandler<LoggerOnFlushEventArgs>(Log_OnFlush), LoggerInstance.Log);
        }

        private void Log_OnFlush(object sender, LoggerOnFlushEventArgs e)
        {           
        }
        private void load_plugins() { load_plugins(false); }
        private void load_plugins_silent() { load_plugins(true); }
        private void load_plugins(bool silent)
        {
            loader = new PluginLoader();
            loader.LoadPlugins(silent);

            ConfigPlugin = loader.GetConfigPlugin(RomCheater.Properties.Settings.Default.LastConfigPlugin);
            if (ConfigPlugin != null && !silent)
                gLog.Info.WriteLine("Loaded Config Plugin: {0}", ConfigPlugin.ToString());
            InputPlugin = loader.GetInputPlugin(RomCheater.Properties.Settings.Default.LastInputPlugin);
            if (InputPlugin != null && !silent)
                gLog.Info.WriteLine("Loaded Input Plugin: {0}", InputPlugin.ToString());
            WindowPlugin = loader.GetWindowPlugin(RomCheater.Properties.Settings.Default.LastWindowPlugin);
            if (WindowPlugin != null && !silent)
                gLog.Info.WriteLine("Loaded Window Plugin: {0}", WindowPlugin.ToString());


            UserControlPlugins = new List<IUserControlPlugin>(loader.LoadedUserControlPlugins);
            if (UserControlPlugins != null)
            {
                foreach (var t in UserControlPlugins)
                {
                    if (!silent)
                        gLog.Info.WriteLine("Loaded UserControl Plugin: {0}", t.ToString());
                }

                string stacktrace = System.Environment.StackTrace;

                if (UserControlPlugins.Count > 0)
                {
                    m_ucd.UserPlugins = UserControlPlugins;                    
                }
            }

            ConfigPlugin.WebBrowserProvider = this.WebBrowserProvider;


            m_PIDSelector.AcceptedPlugin = ConfigPlugin;
            m_RamDump.AcceptedPlugin = ConfigPlugin;
            m_memoryview.AcceptedPlugin = ConfigPlugin;
            m_memsearcher.AcceptedPlugin = ConfigPlugin;
            m_PIDSelector.AcceptedPlugin = ConfigPlugin;
            if (this.SelectedProcess != null)
            {
                m_RamDump.AcceptedProcess = SelectedProcess;
                 m_memoryview.AcceptedProcess = SelectedProcess;
                 m_memsearcher.AcceptedProcess = SelectedProcess;
            }


        }

        private void mnuItemExit_Click(object sender, EventArgs e)
        {
            this.Close();
        }


        private void Main_Load(object sender, EventArgs e)
        {
            SettingsSubscriber.SaveSettings();
        }

        private void mnuItemConfig_Click(object sender, EventArgs e)
        {
            RomCheaterConfigDialog dlg = new RomCheaterConfigDialog(loader);
            dlg.ShowDialog();
            //logger.ForceLog.Info.WriteLine("LoggingFlags = 0x{0:x4} ({1})", logger.GetLoggingFlags().Value, logger.GetLoggingFlags().Name);
            // reload plugins
            load_plugins(true);
        }

        private void mnuItemOpenProcess_Click(object sender, EventArgs e)
        {
            ////List<Process> procs = ConfigPlugin.ValidProcessesForPlugin;
            //PIDSelector selector = new PIDSelector(ConfigPlugin);
            //selector.ShowDialog();
        }

        private void Main_Shown(object sender, EventArgs e)
        {
            dockPanel.SuspendLayout(true);
            //ShowDocks();
            string configFile = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), DockPanelConfig);
            if (File.Exists(configFile))
            {
                try
                {
                    dockPanel.LoadFromXml(configFile, m_deserializeDockContent);
                    SetupDockWindowHandler();
                    SetDockIcons();
                }
                catch (Exception)
                {
                    ShowDocks();
                    SetDockIcons();
                }
            }
            else
            {
               ShowDocks();
               SetDockIcons();
            }

            if(m_PIDSelector != null)
                m_PIDSelector.Activate();
            dockPanel.ResumeLayout(true, true);
        }

        private void mnuItemShowLogWindow_Click(object sender, EventArgs e)
        {
            ShowLogWindow();
        }

        private void mnuItemHelpAbout_Click(object sender, EventArgs e)
        {
            ShowAboutBox();
        }

        private void mnuItemShowRamDumpDialog_Click(object sender, EventArgs e)
        {
            ShowRamDump();
        }

        private void mnuItemShowPIDSelector_Click(object sender, EventArgs e)
        {
            ShowPidSelector();
        }
        private void mnuItemShowMemoryView_Click(object sender, EventArgs e)
        {
            ShowMemoryView();
        }
        private void Main_FormClosing(object sender, FormClosingEventArgs e)
        {
            SettingsSubscriber.SaveSettings();
            string configFile = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), DockPanelConfig);
            if (m_bSaveLayout)
                dockPanel.SaveAsXml(configFile);
            else if (File.Exists(configFile))
                File.Delete(configFile);

            SearchResultWriter.CleanupTemporarySearchResultFiles();


            // notify any docked windows of formclosing

            foreach (var t in this.dockPanel.Contents)
            {
                t.OnDeactivate<FormClosingEventArgs>(e);               
            }

        }

        private void mnuTestExeParse_Click(object sender, EventArgs e)
        {
          IPEDData peData =  new PEData((IAcceptsProcessAndConfig)this);
        }

        private void mnuItemFindMaxNonNegativeHexValue_Click(object sender, EventArgs e)
        {

            //uint start = 0xf0000000;
            uint end = uint.MaxValue;
            //for (uint i = start; i < end; i++)
            //{
            ulong value = Convert.ToUInt64(end.ToString(), 16);
            //}
        }

        private void mnuItemShowDataTypeConverter_Click(object sender, EventArgs e)
        {
            ShowDataTypeConverter();
        }

        private void mnuItemShowMemorySearch_Click(object sender, EventArgs e)
        {
            ShowMemorySearch();
        }

        private void mnuItemDateShift_Click(object sender, EventArgs e)
        {
            DateTime t = DateTime.Now;
            int year = Convert.ToInt32(t.ToString("yy"));
            int y = year << 9;
            int m = t.Month << 5;
            int d = t.Day;

            ushort v1 = (ushort)(y | m | d);

            t = t.AddDays(1);
            year = Convert.ToInt32(t.ToString("yy"));
            y = year << 9;
            m = t.Month << 5;
            d = t.Day;
            ushort v2 = (ushort)(y | m | d);

            t = t.AddDays(1);
            year = Convert.ToInt32(t.ToString("yy"));
            y = year << 9;
            m = t.Month << 5;
            d = t.Day;
            ushort v3 = (ushort)(y | m | d);

            t = new DateTime(9999,12,31);
            year = Convert.ToInt32(t.ToString("yy"));
            y = year << 9;
            m = t.Month << 5;
            d = t.Day;
            ushort v4 = (ushort)(y | m | d);
        }

        private void mnuItemShowPEViewer_Click(object sender, EventArgs e)
        {
            ShowPEViewer();
        }

        private void mnuItemShowRVACalculator_Click(object sender, EventArgs e)
        {
            ShowRVACalculator();
        }

        private void mnuItemShowUserControlDock_Click(object sender, EventArgs e)
        {
            ShowUserControlDock();
        }

        private void mnuItemShowMemorySectionViewer_Click(object sender, EventArgs e)
        {
            ShowMemorySectionViewer();
        }

        private void mnuItemShowWebBrowser_Click(object sender, EventArgs e)
        {
            ShowWebBrowser();
        }        
    }
}