Docking/UI/UIMemoryViewer.cs

//#define DISABLE_GETFIRSTNONZEROBYTE_ONUPDATE_ACCEPTEDPROCESS // when defined will not call GetFirstNonZeroByte() when AcceptedProcess is updated and is not null
#define DISABLE_GETFIRSTNONZERO_BYTE // when defined will make GetFirstNonZeroByte() an empty void method
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Be.Windows.Forms;
using RomCheater.Logging;
using RomCheater.PluginFramework.Interfaces;
using System.Diagnostics;
using Sojaner.MemoryScanner.MemoryProviers;
using System.Runtime.InteropServices;
using RomCheater.PluginFramework.Events;
using Sojaner.MemoryScanner;

namespace RomCheater.Docking.UI
{
    public partial class UIMemoryViewer : UserControl, 
        IAcceptsPlugin<IConfigPlugin>,
        IAcceptsProcess<Process>,
        IAcceptsProcessAndConfig,
        IAcceptsMemoryRange,
        IBrowseMemoryRegion,
        IAcceptPEData
    {
        public UIMemoryViewer()
        {
            InitializeComponent();
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.DoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.ResizeRedraw, true);
            //this.OnPCSX2ProcessCallback = new UIEvents.PCSX2ProcessCallback(this.PCSX2ProcessCallback);
            //if (this.OnPCSX2ProcessCallback != null) { this.OnPCSX2ProcessCallback.Invoke(out procdata); }
            this.UpdateEnabled = false;
            txtData.BytesPerLine = (int)max_address_width;
            txtData.UseFixedBytesPerLine = true;
            txtData.StringViewVisible = true;
            ramScroll.Minimum = (int)MemoryRangeStart;
            for (int i = MemoryRangeStart; i < (MemoryRangeStart + max_ram_view); i += max_address_width) { ramScroll.Maximum += (int)max_address_width; }
            ramScroll.Value = ramScroll.Minimum;
            this.CanChangeUpdateInterval = false;


            lblAddressMarker.Text = "";
            for (uint i = 0; i < max_address_width; i++)
            {
                lblAddressMarker.Text = lblAddressMarker.Text + string.Format("{0:X2} ", i);
            }
            this.AcceptedPlugin = null; this.AcceptedProcess = null;

            txtAddresses.MouseWheel += new MouseEventHandler(txtAddresses_MouseWheel);
            txtData.MouseWheel += new MouseEventHandler(txtData_MouseWheel);
        }

        private void GetFirstNonZeroByte()
        {
#if !DISABLE_GETFIRSTNONZERO_BYTE
            if (!DesignMode)
            {
                GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
                provider.OpenProvider();
                int addr = 0;
                provider.ReadFirstNonZeroByte(MemoryRangeStart, MemoryRangeSize, out addr);
                provider.CloseProvider();
                GotoAddress(addr);
            }
#else
            this.GotoImageBase();    
#endif
        }
        #region IBrowseMemoryRegion
        public bool BrowseMemoryRegion(int MemoryRegion)
        {
            try
            {
                if (!((MemoryRangeStart <= MemoryRegion) && (MemoryRegion <= (MemoryRangeStart + MemoryRangeSize)))) { return false; }
                GotoAddress(MemoryRegion);
                return true;
            }
            catch(Exception ex)
            {
                logger.Error.WriteLine("UIMemoryViewer.BrowseMemoryRegion(int MemoryRegion): Failed to Browse Memory Region: 0x{0:x8}", MemoryRegion);
                logger.Error.WriteLine(ex.ToString());
                return false;
            }
        }
        #endregion
        #region  IAcceptsProcess<Process> Members
        private Process _AcceptedProcess;
        public Process AcceptedProcess
        {
            get { return _AcceptedProcess; }
            set
            {
                _AcceptedProcess = value;
                update_timer.Enabled = (value != null);
                UpdateEnabled = update_timer.Enabled;
#if !DISABLE_GETFIRSTNONZEROBYTE_ONUPDATE_ACCEPTEDPROCESS
                if (value != null)
                    GetFirstNonZeroByte();
#endif
            }
        }
        #endregion
        #region IAcceptsPlugin<IConfigPlugin> Members
        public IConfigPlugin AcceptedPlugin { get; set; }
        #endregion
        #region IAcceptsMemoryRange members
        public int MemoryRangeStart { get { return MemorySizeConstants.MinimumAddress; } set { } }
        public uint MemoryRangeSize { get { if (MemoryRangeStart > 0) { return (uint)(MemorySizeConstants.MaximumAddress - MemoryRangeStart); } return MemorySizeConstants.MaximumAddress; } set { } }
        #endregion
        #region IAcceptPEData members
        private IPEDData peData { get; set; }
        public void SetPEViewerData(IPEDData peData) { this.peData = peData; }
        #endregion
        public void GotoTop() { this.CURRENT_TOP_ADDR = 0; }
        public void GotoBottom() { uint size = (uint)MemoryRangeSize; this.CURRENT_TOP_ADDR = (int)((size - 1) - max_ram_view); }
        public void GotoAddress(int addr) {
            logger.VerboseDebug.WriteLine("UIMemoryViewer::GotoAddress(0x{0:x8})", addr);
            this.CURRENT_TOP_ADDR = (int)(addr & 0xFFFFFFF0); }
        private bool _UpdateEnabled;
        public bool UpdateEnabled
        {
            get { return _UpdateEnabled; }
            set
            {
                _UpdateEnabled = value;
                if (value) { this.update_timer.Enabled = true; }
                else { this.update_timer.Enabled = false; }
            }
        }
        private bool _CanChangeUpdateInterval;
        public bool CanChangeUpdateInterval
        {
            get { return _CanChangeUpdateInterval; }
            set { _CanChangeUpdateInterval = value; }
        }

        public int UpdateInterval
        {
            get { return this.update_timer.Interval; }
            set { if (CanChangeUpdateInterval) this.update_timer.Interval = value; }
        }
        private string AddressList = "";
        private string AsciiData = "";
        private byte[] RamData = new byte[] { };

        const int max_address_width = 16;
        static int max_ram_view = max_address_width * 27;

        static int small_scroll_change = max_address_width * 1; // scrolls one line (when you clikc the up or down arrows)
        static int medium_scroll_change = max_ram_view / 2; // scrolls half a page
        static int large_scroll_change = max_ram_view; // scrolls a full page
        private int _CURRENT_TOP_ADDR;
        int CURRENT_TOP_ADDR
        {
            get { return _CURRENT_TOP_ADDR; }
            set { txthexGoto.Value = _CURRENT_TOP_ADDR = value; }
        }
        //uint CURRENT_BOITTOM_ADDR() { return CURRENT_TOP_ADDR + max_ram_view; }
        private void UpdateMaxRamView()
        {
            if (this.IsDisposed) return;
            Graphics g = this.CreateGraphics();
            Size size = g.MeasureString("00", txtData.Font).ToSize();
            int ByteHeight = size.Height;
            int TotalHeight = txtData.Height;
            int NumberOfBytes = (int)((TotalHeight / ByteHeight) * max_address_width);
            int byte_width = (max_address_width * 2);
            max_ram_view = NumberOfBytes + (byte_width);
        }
        private void btnGotoAddress_Click(object sender, EventArgs e)
        {
            logger.VerboseDebug.WriteLine("UIMemoryViewer::btnGotoAddress_Click(0x{0:x8})", txthexGoto.ToInt32());
            this.GotoAddress(txthexGoto.ToInt32());
        }

        private void btnEditBytes_Click(object sender, EventArgs e)
        {
            byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();
            logger.Info.WriteLine("UIMemoryViewer :: editing {0} bytes", data.Length);
            bool reenable = false;
            if (this.UpdateEnabled) reenable = true;
            this.UpdateEnabled = false;
            ByteEditor editor = new ByteEditor(data, this.CURRENT_TOP_ADDR);
            editor.ShowDialog();
            int changed_byte_count = 0;
            if (editor.BytesEdited)
            {

                if (editor.AsBytes.Length == data.Length)
                {
                    
                    for (int i = 0; i < data.Length; i++)
                    {
                        if (data[i] != editor.AsBytes[i])
                            changed_byte_count++;
                    }                    
                }
                //DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(editor.AsBytes);
                //txtData.ByteProvider = _DynamicByteProvider;
                //_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
                this.WriteCurrentBytes(this.CURRENT_TOP_ADDR, editor.AsBytes);
            }
            logger.Info.WriteLine("UIMemoryViewer :: changed {0} bytes", changed_byte_count);
            this.UpdateEnabled = reenable;
        }
        private bool ForceUpdate = false;
        private bool ShouldUpdateResults()
        {
            //if (ResultsUpdateWorkerThread.IsBusy) { return false; }
            if (ForceUpdate) return true;
            //else if (TextIsBeingSelected) return false;
            //else if (NonHandledKeysAreBeingPressed) return false;
            else if (this.UpdateEnabled) return true;
            else { return false; }
        }
        private void UpdateGui(bool force)
        {
            if (AcceptedProcess == null) { return; }
            if (AcceptedPlugin == null) { return; }
            
            if (!this.ShouldUpdateResults()) { return; }// this.Logger.LogDebugMessage(string.Format("ShouldUpdateResults() -> returning false")); return; }
            this.UpdateMaxRamView();
            //if (!force)
            //{
            if (!ResultsUpdateWorkerThread.IsBusy)
                ResultsUpdateWorkerThread.RunWorkerAsync();
            //}
            //else
            //{
            //    while (!ResultsUpdateWorkerThread.IsBusy) { ResultsUpdateWorkerThread.CancelAsync(); Application.DoEvents(); }
            //    ResultsUpdateWorkerThread.RunWorkerAsync();
            //}
        }
        private void UpdateGui()
        {
            this.UpdateGui(false);
        }
        private byte[] GetMemory()
        {
            byte[] data = new byte[max_ram_view];
            try
            {
                GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
                provider.OpenProvider();
                int bytesReadSize;
                provider.ReadProcessMemory(CURRENT_TOP_ADDR, (uint)max_ram_view, out bytesReadSize, out data);
                try
                {
                    provider.CloseProvider();
                }
                catch (SEHException ex)
                {
                    logger.Error.WriteLine("UIMemoryViewer.GetMemory(): SEHException: (0x{0:x8} {1}", ex.ErrorCode, ex.Message);
                    logger.Error.WriteLine(ex.ToString());
                }
                catch (Exception ex)
                {
                    logger.Error.WriteLine("UIMemoryViewer.GetMemory(): Exception: {0}", ex.Message);
                    logger.Error.WriteLine(ex.ToString());
                }
            }
            catch (Exception ex)
            {
                logger.Error.WriteLine("{0}.GetMemory():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
            }
            finally
            {
                if (data.Length == 0)
                {
                    data = new byte[max_ram_view];
                    for (int i = 0; i < data.Length; i++) { data[i] = 0x0; }
                }
            }
            return data;
        }
        private void UpdateMemroyView() { this.UpdateMemroyView(this.CURRENT_TOP_ADDR); }
        private void UpdateMemroyView(int address)
        {
            try
            {
                if (AcceptedProcess == null) { return; }
                if (AcceptedPlugin == null) { return; }

                byte[] data = GetMemory();
                try
                {
                    RamData = data;


                    AddressList = "";
                    AsciiData = "";
                    // write the addreses out
                    for (int i = address; i < (address + max_ram_view); i += max_address_width)
                    {
                        AddressList = AddressList + string.Format("{0:X8}:\n", i);
                    }
                    //// write out the ascii data
                    StringBuilder builder = new StringBuilder();
                    for (int i = address; i < (address + max_ram_view); i += max_address_width)
                    {
                        try
                        {
                            for (int j = 0; j < max_address_width; j++)
                            {
                                int current_addr = i + j;
                                if (current_addr >= MemoryRangeSize) break;
                                byte ascii_value_raw = data[j];
                                char ascii_value = (char)data[j];
                                if (ascii_value_raw >= 0x20 && ascii_value_raw <= 0x7e)
                                {
                                    builder.Append(ascii_value.ToString());
                                }
                                else
                                {
                                    builder.Append(".");
                                }
                            }
                            builder.AppendLine();
                        }
                        catch (Exception ex)
                        {
                            logger.Error.WriteLine("{0}.UpdateMemroyView().BuildingAsciiString:{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
                            return;
                        }
                    }
                    AsciiData = builder.ToString();


                }
                catch (Exception ex)
                {
                    logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
                    return;
                }
            }
            catch (Exception ex) { logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
        }
        //private void HexResourceViewerBytes_Changed(object sender, System.EventArgs e)
        //{
        //    this.WriteCurrentBytes();
        //}
        private void WriteCurrentBytes(int start_address, byte[] data)
        {
            try
            {
                if (AcceptedProcess == null) { return; }
                if (AcceptedPlugin == null) { return; }
                // Byte changed
                //byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();
                GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
                provider.OpenProvider();
                int bytesReadSize;

                provider.WriteProcessMemory(start_address, data, out bytesReadSize);
                //for (int i = 0; i < data.Length; i ++)
                //{
                //    int addr = (int)(start_address + i);
                //    byte data_to_write = data[i];
                    
                //}
                provider.CloseProvider();
            }
            catch (Exception ex) { logger.Error.WriteLine("{0}.WriteCurrentBytes():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
        }

        private void update_timer_Tick(object sender, EventArgs e) { this.UpdateGui(); }
        private void ResultsUpdateWorkerThread_DoWork(object sender, DoWorkEventArgs e) { try { this.UpdateMemroyView(); } catch (Exception ex) { logger.Error.WriteLine("{0}.ResultsUpdateWorkerThread_DoWork():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); } }
        private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            try
            {
                txtAddresses.Clear(); txtAddresses.Text = AddressList;
                //txtAscii.Clear(); txtAscii.Text = AsciiData;
                //this.Logger.LogDebugMessage(string.Format("RunWorkerCompeleted() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", RamData.Length));
                DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(RamData);
                txtData.ByteProvider = _DynamicByteProvider;
                //_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
            }
            catch (ObjectDisposedException) { } // ignore errors aobut disposed objects (usually only happens when the parent closes)
            catch (Exception ex) { logger.Error.WriteLine("{0}.ResultsUpdateWorkerThread_RunWorkerCompleted():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
        }
        private void Handle_KeyDown(object sender, KeyEventArgs e)
        {
            //isScrolling = false;
            //bool reenable = false;
            //if (this.UpdateEnabled) reenable = true;
            //this.UpdateEnabled = false;

            this.UpdateMaxRamView();
            int ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;

            ////if (e.Type == ScrollEventType.EndScroll) return;
            //uint size = max_ram_view;

            bool haveModifier = false;
            switch (e.Modifiers)
            {
                case Keys.Control:
                    switch (e.KeyCode)
                    {
                        case Keys.Home:
                            this.CURRENT_TOP_ADDR = 0; //NonHandledKeysAreBeingPressed = false; 
                            break;
                        case Keys.End:
                            this.CURRENT_TOP_ADDR = (int)((MemoryRangeSize - 1) - max_ram_view); //NonHandledKeysAreBeingPressed = false;
                            break;
                        default:
                            //NonHandledKeysAreBeingPressed = true;
                            break;
                    }
                    break;
            }

            if (!haveModifier)
            {
                switch (e.KeyCode)
                {
                    case Keys.Up:
                        if (this.CURRENT_TOP_ADDR == 0 && (this.CURRENT_TOP_ADDR - small_scroll_change > this.CURRENT_TOP_ADDR))
                        {
                            this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
                        }
                        else
                        {
                            this.CURRENT_TOP_ADDR -= (int)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
                        }
                        break;
                    case Keys.Down:
                        this.CURRENT_TOP_ADDR += (int)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
                        break;
                    case Keys.PageUp:
                        if (this.CURRENT_TOP_ADDR == 0 && (this.CURRENT_TOP_ADDR - large_scroll_change > this.CURRENT_TOP_ADDR))
                        {
                            this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
                        }
                        else
                        {
                            this.CURRENT_TOP_ADDR -= (int)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
                        }
                        break;
                    case Keys.PageDown:
                        this.CURRENT_TOP_ADDR += (int)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
                        break;
                    default:
                        //NonHandledKeysAreBeingPressed = true;
                        break;
                }
            }
            if (this.CURRENT_TOP_ADDR < MemoryRangeStart) this.CURRENT_TOP_ADDR = MemoryRangeStart;
            //if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;
            if (this.CURRENT_TOP_ADDR + max_ram_view >= MemoryRangeSize) this.CURRENT_TOP_ADDR = (int)(MemoryRangeSize - max_ram_view);
            
            //this.UpdateEnabled = reenable;
        }

        private void UIMemoryViewer_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
        private void txtAddresses_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
        private void txtData_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }

        private void ramScroll_Scroll(object sender, ScrollEventArgs e) { this.Handle_Scroll(sender, e); }

        private ScrollEventArgs GetMouseWheelScrollChange(int WheelDelta)
        {
            ScrollEventArgs args = new ScrollEventArgs(ScrollEventType.SmallIncrement,1);
            if (WheelDelta < 0)
            {
                //// negative: scroll down
                //// SmallDecrement -or- LargeDecrement
                //if (WheelDelta <= small_scroll_change)
                //{
                //    args = new ScrollEventArgs(ScrollEventType.SmallDecrement,(int)small_scroll_change);
                //}
                //if (WheelDelta > small_scroll_change && WheelDelta <= large_scroll_change)
                //{
                //    args = new ScrollEventArgs(ScrollEventType.LargeDecrement, (int)large_scroll_change);
                //}
                args = new ScrollEventArgs(ScrollEventType.SmallIncrement, 1);
            }
            else
            {
                //// positive: scroll up
                //// SmallIncrement  -or- LargeIncrement
                //if (WheelDelta <= small_scroll_change)
                //{
                //    args = new ScrollEventArgs(ScrollEventType.SmallIncrement, (int)small_scroll_change);
                //}
                //if (WheelDelta > small_scroll_change && WheelDelta <= large_scroll_change)
                //{
                //    args = new ScrollEventArgs(ScrollEventType.LargeIncrement, (int)large_scroll_change);
                //}
                args = new ScrollEventArgs(ScrollEventType.SmallDecrement, 1);
            }
            return args;
        }

        void txtAddresses_MouseWheel(object sender, MouseEventArgs e) { this.Handle_Scroll(sender, GetMouseWheelScrollChange(e.Delta)); }
        void txtData_MouseWheel(object sender, MouseEventArgs e) { this.Handle_Scroll(sender, GetMouseWheelScrollChange(e.Delta)); }
       

        private void Handle_Scroll(object sender, ScrollEventArgs e)
        {
            //isScrolling = true;
            //bool reenable = false;
            //if (this.UpdateEnabled) reenable = true;
            //this.UpdateEnabled = false;

            this.UpdateMaxRamView();
            int ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;
            //uint size = MemorySize;
            if (e.Type == ScrollEventType.EndScroll) return;

            switch (e.Type)
            {
                case ScrollEventType.SmallDecrement:
                    if (this.CURRENT_TOP_ADDR == 0 && ((this.CURRENT_TOP_ADDR - small_scroll_change) > this.CURRENT_TOP_ADDR))
                    {
                        this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
                    }
                    else
                    {
                        this.CURRENT_TOP_ADDR -= (small_scroll_change);
                    }
                    break;
                case ScrollEventType.SmallIncrement:
                    this.CURRENT_TOP_ADDR += (small_scroll_change);
                    break;

                case ScrollEventType.LargeDecrement:
                    if (this.CURRENT_TOP_ADDR == 0 && ((this.CURRENT_TOP_ADDR - large_scroll_change) > this.CURRENT_TOP_ADDR))
                    {
                        this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
                    }
                    else
                    {
                        this.CURRENT_TOP_ADDR -= (large_scroll_change);
                    }
                    break;
                case ScrollEventType.LargeIncrement:
                    this.CURRENT_TOP_ADDR += (large_scroll_change);
                    break;
                case ScrollEventType.ThumbPosition:
                //this.CURRENT_TOP_ADDR = (uint)e.NewValue;
                //break;
                default:
                    this.CURRENT_TOP_ADDR = (int)(e.NewValue & 0xFFFFFFF0);
                    break;
            }
            if (this.CURRENT_TOP_ADDR < 0) this.CURRENT_TOP_ADDR = 0;
            //if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = VTLB_VADDR_SIZE - max_ram_view;
            //if (this.CURRENT_TOP_ADDR < 0 || this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
            if (this.CURRENT_TOP_ADDR + max_ram_view >= MemoryRangeSize) this.CURRENT_TOP_ADDR = (int)(MemoryRangeSize - max_ram_view);
            //this.UpdateEnabled = reenable;
            //isScrolling = false;
        }
        private void GotoImageBase()
        {            
            if (this.peData == null) return;
            object ImageBase = 0;
            bool x86 = this.peData.Is32bitAssembly();            
            if (x86)
            {
                ImageBase = this.peData.NTHeader.OptionalHeader32._ImageBase;
                uint ib = Convert.ToUInt32(ImageBase);
                logger.VerboseDebug.WriteLine("UIMemoryViewer::GotoImageBase(0x{0:x8})", ib);
                txthexGoto.Value = ib;
            }
            else
            {
                ImageBase = this.peData.NTHeader.OptionalHeader64._ImageBase;
                ulong ib = Convert.ToUInt64(ImageBase);
                logger.VerboseDebug.WriteLine("UIMemoryViewer::GotoImageBase(0x{0:x16})", ib);
                txthexGoto.Value = (long)ib;
            }
            
            this.GotoAddress(txthexGoto.ToInt32());
        }
        private void btnGotoImageBase_Click(object sender, EventArgs e)
        {
            
            this.GotoImageBase();
        }

    }
}
Revision:	360
Committed:	Sun Jun 10 01:24:25 2012 UTC (11 years, 5 months ago) by william
File size:	27001 byte(s)
Log Message:
#	Content
1	//#define DISABLE_GETFIRSTNONZEROBYTE_ONUPDATE_ACCEPTEDPROCESS // when defined will not call GetFirstNonZeroByte() when AcceptedProcess is updated and is not null
2	#define DISABLE_GETFIRSTNONZERO_BYTE // when defined will make GetFirstNonZeroByte() an empty void method
3	using System;
4	using System.Collections.Generic;
5	using System.ComponentModel;
6	using System.Drawing;
7	using System.Data;
8	using System.Linq;
9	using System.Text;
10	using System.Windows.Forms;
11	using Be.Windows.Forms;
12	using RomCheater.Logging;
13	using RomCheater.PluginFramework.Interfaces;
14	using System.Diagnostics;
15	using Sojaner.MemoryScanner.MemoryProviers;
16	using System.Runtime.InteropServices;
17	using RomCheater.PluginFramework.Events;
18	using Sojaner.MemoryScanner;
19
20	namespace RomCheater.Docking.UI
21	{
22	public partial class UIMemoryViewer : UserControl,
23	IAcceptsPlugin<IConfigPlugin>,
24	IAcceptsProcess<Process>,
25	IAcceptsProcessAndConfig,
26	IAcceptsMemoryRange,
27	IBrowseMemoryRegion,
28	IAcceptPEData
29	{
30	public UIMemoryViewer()
31	{
32	InitializeComponent();
33	SetStyle(ControlStyles.UserPaint, true);
34	SetStyle(ControlStyles.DoubleBuffer, true);
35	SetStyle(ControlStyles.AllPaintingInWmPaint, true);
36	SetStyle(ControlStyles.ResizeRedraw, true);
37	//this.OnPCSX2ProcessCallback = new UIEvents.PCSX2ProcessCallback(this.PCSX2ProcessCallback);
38	//if (this.OnPCSX2ProcessCallback != null) { this.OnPCSX2ProcessCallback.Invoke(out procdata); }
39	this.UpdateEnabled = false;
40	txtData.BytesPerLine = (int)max_address_width;
41	txtData.UseFixedBytesPerLine = true;
42	txtData.StringViewVisible = true;
43	ramScroll.Minimum = (int)MemoryRangeStart;
44	for (int i = MemoryRangeStart; i < (MemoryRangeStart + max_ram_view); i += max_address_width) { ramScroll.Maximum += (int)max_address_width; }
45	ramScroll.Value = ramScroll.Minimum;
46	this.CanChangeUpdateInterval = false;
47
48
49	lblAddressMarker.Text = "";
50	for (uint i = 0; i < max_address_width; i++)
51	{
52	lblAddressMarker.Text = lblAddressMarker.Text + string.Format("{0:X2} ", i);
53	}
54	this.AcceptedPlugin = null; this.AcceptedProcess = null;
55
56	txtAddresses.MouseWheel += new MouseEventHandler(txtAddresses_MouseWheel);
57	txtData.MouseWheel += new MouseEventHandler(txtData_MouseWheel);
58	}
59
60	private void GetFirstNonZeroByte()
61	{
62	#if !DISABLE_GETFIRSTNONZERO_BYTE
63	if (!DesignMode)
64	{
65	GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
66	provider.OpenProvider();
67	int addr = 0;
68	provider.ReadFirstNonZeroByte(MemoryRangeStart, MemoryRangeSize, out addr);
69	provider.CloseProvider();
70	GotoAddress(addr);
71	}
72	#else
73	this.GotoImageBase();
74	#endif
75	}
76	#region IBrowseMemoryRegion
77	public bool BrowseMemoryRegion(int MemoryRegion)
78	{
79	try
80	{
81	if (!((MemoryRangeStart <= MemoryRegion) && (MemoryRegion <= (MemoryRangeStart + MemoryRangeSize)))) { return false; }
82	GotoAddress(MemoryRegion);
83	return true;
84	}
85	catch(Exception ex)
86	{
87	logger.Error.WriteLine("UIMemoryViewer.BrowseMemoryRegion(int MemoryRegion): Failed to Browse Memory Region: 0x{0:x8}", MemoryRegion);
88	logger.Error.WriteLine(ex.ToString());
89	return false;
90	}
91	}
92	#endregion
93	#region IAcceptsProcess<Process> Members
94	private Process _AcceptedProcess;
95	public Process AcceptedProcess
96	{
97	get { return _AcceptedProcess; }
98	set
99	{
100	_AcceptedProcess = value;
101	update_timer.Enabled = (value != null);
102	UpdateEnabled = update_timer.Enabled;
103	#if !DISABLE_GETFIRSTNONZEROBYTE_ONUPDATE_ACCEPTEDPROCESS
104	if (value != null)
105	GetFirstNonZeroByte();
106	#endif
107	}
108	}
109	#endregion
110	#region IAcceptsPlugin<IConfigPlugin> Members
111	public IConfigPlugin AcceptedPlugin { get; set; }
112	#endregion
113	#region IAcceptsMemoryRange members
114	public int MemoryRangeStart { get { return MemorySizeConstants.MinimumAddress; } set { } }
115	public uint MemoryRangeSize { get { if (MemoryRangeStart > 0) { return (uint)(MemorySizeConstants.MaximumAddress - MemoryRangeStart); } return MemorySizeConstants.MaximumAddress; } set { } }
116	#endregion
117	#region IAcceptPEData members
118	private IPEDData peData { get; set; }
119	public void SetPEViewerData(IPEDData peData) { this.peData = peData; }
120	#endregion
121	public void GotoTop() { this.CURRENT_TOP_ADDR = 0; }
122	public void GotoBottom() { uint size = (uint)MemoryRangeSize; this.CURRENT_TOP_ADDR = (int)((size - 1) - max_ram_view); }
123	public void GotoAddress(int addr) {
124	logger.VerboseDebug.WriteLine("UIMemoryViewer::GotoAddress(0x{0:x8})", addr);
125	this.CURRENT_TOP_ADDR = (int)(addr & 0xFFFFFFF0); }
126	private bool _UpdateEnabled;
127	public bool UpdateEnabled
128	{
129	get { return _UpdateEnabled; }
130	set
131	{
132	_UpdateEnabled = value;
133	if (value) { this.update_timer.Enabled = true; }
134	else { this.update_timer.Enabled = false; }
135	}
136	}
137	private bool _CanChangeUpdateInterval;
138	public bool CanChangeUpdateInterval
139	{
140	get { return _CanChangeUpdateInterval; }
141	set { _CanChangeUpdateInterval = value; }
142	}
143
144	public int UpdateInterval
145	{
146	get { return this.update_timer.Interval; }
147	set { if (CanChangeUpdateInterval) this.update_timer.Interval = value; }
148	}
149	private string AddressList = "";
150	private string AsciiData = "";
151	private byte[] RamData = new byte[] { };
152
153	const int max_address_width = 16;
154	static int max_ram_view = max_address_width * 27;
155
156	static int small_scroll_change = max_address_width * 1; // scrolls one line (when you clikc the up or down arrows)
157	static int medium_scroll_change = max_ram_view / 2; // scrolls half a page
158	static int large_scroll_change = max_ram_view; // scrolls a full page
159	private int _CURRENT_TOP_ADDR;
160	int CURRENT_TOP_ADDR
161	{
162	get { return _CURRENT_TOP_ADDR; }
163	set { txthexGoto.Value = _CURRENT_TOP_ADDR = value; }
164	}
165	//uint CURRENT_BOITTOM_ADDR() { return CURRENT_TOP_ADDR + max_ram_view; }
166	private void UpdateMaxRamView()
167	{
168	if (this.IsDisposed) return;
169	Graphics g = this.CreateGraphics();
170	Size size = g.MeasureString("00", txtData.Font).ToSize();
171	int ByteHeight = size.Height;
172	int TotalHeight = txtData.Height;
173	int NumberOfBytes = (int)((TotalHeight / ByteHeight) * max_address_width);
174	int byte_width = (max_address_width * 2);
175	max_ram_view = NumberOfBytes + (byte_width);
176	}
177	private void btnGotoAddress_Click(object sender, EventArgs e)
178	{
179	logger.VerboseDebug.WriteLine("UIMemoryViewer::btnGotoAddress_Click(0x{0:x8})", txthexGoto.ToInt32());
180	this.GotoAddress(txthexGoto.ToInt32());
181	}
182
183	private void btnEditBytes_Click(object sender, EventArgs e)
184	{
185	byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();
186	logger.Info.WriteLine("UIMemoryViewer :: editing {0} bytes", data.Length);
187	bool reenable = false;
188	if (this.UpdateEnabled) reenable = true;
189	this.UpdateEnabled = false;
190	ByteEditor editor = new ByteEditor(data, this.CURRENT_TOP_ADDR);
191	editor.ShowDialog();
192	int changed_byte_count = 0;
193	if (editor.BytesEdited)
194	{
195
196	if (editor.AsBytes.Length == data.Length)
197	{
198
199	for (int i = 0; i < data.Length; i++)
200	{
201	if (data[i] != editor.AsBytes[i])
202	changed_byte_count++;
203	}
204	}
205	//DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(editor.AsBytes);
206	//txtData.ByteProvider = _DynamicByteProvider;
207	//_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
208	this.WriteCurrentBytes(this.CURRENT_TOP_ADDR, editor.AsBytes);
209	}
210	logger.Info.WriteLine("UIMemoryViewer :: changed {0} bytes", changed_byte_count);
211	this.UpdateEnabled = reenable;
212	}
213	private bool ForceUpdate = false;
214	private bool ShouldUpdateResults()
215	{
216	//if (ResultsUpdateWorkerThread.IsBusy) { return false; }
217	if (ForceUpdate) return true;
218	//else if (TextIsBeingSelected) return false;
219	//else if (NonHandledKeysAreBeingPressed) return false;
220	else if (this.UpdateEnabled) return true;
221	else { return false; }
222	}
223	private void UpdateGui(bool force)
224	{
225	if (AcceptedProcess == null) { return; }
226	if (AcceptedPlugin == null) { return; }
227
228	if (!this.ShouldUpdateResults()) { return; }// this.Logger.LogDebugMessage(string.Format("ShouldUpdateResults() -> returning false")); return; }
229	this.UpdateMaxRamView();
230	//if (!force)
231	//{
232	if (!ResultsUpdateWorkerThread.IsBusy)
233	ResultsUpdateWorkerThread.RunWorkerAsync();
234	//}
235	//else
236	//{
237	// while (!ResultsUpdateWorkerThread.IsBusy) { ResultsUpdateWorkerThread.CancelAsync(); Application.DoEvents(); }
238	// ResultsUpdateWorkerThread.RunWorkerAsync();
239	//}
240	}
241	private void UpdateGui()
242	{
243	this.UpdateGui(false);
244	}
245	private byte[] GetMemory()
246	{
247	byte[] data = new byte[max_ram_view];
248	try
249	{
250	GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
251	provider.OpenProvider();
252	int bytesReadSize;
253	provider.ReadProcessMemory(CURRENT_TOP_ADDR, (uint)max_ram_view, out bytesReadSize, out data);
254	try
255	{
256	provider.CloseProvider();
257	}
258	catch (SEHException ex)
259	{
260	logger.Error.WriteLine("UIMemoryViewer.GetMemory(): SEHException: (0x{0:x8} {1}", ex.ErrorCode, ex.Message);
261	logger.Error.WriteLine(ex.ToString());
262	}
263	catch (Exception ex)
264	{
265	logger.Error.WriteLine("UIMemoryViewer.GetMemory(): Exception: {0}", ex.Message);
266	logger.Error.WriteLine(ex.ToString());
267	}
268	}
269	catch (Exception ex)
270	{
271	logger.Error.WriteLine("{0}.GetMemory():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
272	}
273	finally
274	{
275	if (data.Length == 0)
276	{
277	data = new byte[max_ram_view];
278	for (int i = 0; i < data.Length; i++) { data[i] = 0x0; }
279	}
280	}
281	return data;
282	}
283	private void UpdateMemroyView() { this.UpdateMemroyView(this.CURRENT_TOP_ADDR); }
284	private void UpdateMemroyView(int address)
285	{
286	try
287	{
288	if (AcceptedProcess == null) { return; }
289	if (AcceptedPlugin == null) { return; }
290
291	byte[] data = GetMemory();
292	try
293	{
294	RamData = data;
295
296
297	AddressList = "";
298	AsciiData = "";
299	// write the addreses out
300	for (int i = address; i < (address + max_ram_view); i += max_address_width)
301	{
302	AddressList = AddressList + string.Format("{0:X8}:\n", i);
303	}
304	//// write out the ascii data
305	StringBuilder builder = new StringBuilder();
306	for (int i = address; i < (address + max_ram_view); i += max_address_width)
307	{
308	try
309	{
310	for (int j = 0; j < max_address_width; j++)
311	{
312	int current_addr = i + j;
313	if (current_addr >= MemoryRangeSize) break;
314	byte ascii_value_raw = data[j];
315	char ascii_value = (char)data[j];
316	if (ascii_value_raw >= 0x20 && ascii_value_raw <= 0x7e)
317	{
318	builder.Append(ascii_value.ToString());
319	}
320	else
321	{
322	builder.Append(".");
323	}
324	}
325	builder.AppendLine();
326	}
327	catch (Exception ex)
328	{
329	logger.Error.WriteLine("{0}.UpdateMemroyView().BuildingAsciiString:{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
330	return;
331	}
332	}
333	AsciiData = builder.ToString();
334
335
336	}
337	catch (Exception ex)
338	{
339	logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
340	return;
341	}
342	}
343	catch (Exception ex) { logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
344	}
345	//private void HexResourceViewerBytes_Changed(object sender, System.EventArgs e)
346	//{
347	// this.WriteCurrentBytes();
348	//}
349	private void WriteCurrentBytes(int start_address, byte[] data)
350	{
351	try
352	{
353	if (AcceptedProcess == null) { return; }
354	if (AcceptedPlugin == null) { return; }
355	// Byte changed
356	//byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();
357	GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
358	provider.OpenProvider();
359	int bytesReadSize;
360
361	provider.WriteProcessMemory(start_address, data, out bytesReadSize);
362	//for (int i = 0; i < data.Length; i ++)
363	//{
364	// int addr = (int)(start_address + i);
365	// byte data_to_write = data[i];
366
367	//}
368	provider.CloseProvider();
369	}
370	catch (Exception ex) { logger.Error.WriteLine("{0}.WriteCurrentBytes():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
371	}
372
373	private void update_timer_Tick(object sender, EventArgs e) { this.UpdateGui(); }
374	private void ResultsUpdateWorkerThread_DoWork(object sender, DoWorkEventArgs e) { try { this.UpdateMemroyView(); } catch (Exception ex) { logger.Error.WriteLine("{0}.ResultsUpdateWorkerThread_DoWork():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); } }
375	private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
376	{
377	try
378	{
379	txtAddresses.Clear(); txtAddresses.Text = AddressList;
380	//txtAscii.Clear(); txtAscii.Text = AsciiData;
381	//this.Logger.LogDebugMessage(string.Format("RunWorkerCompeleted() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", RamData.Length));
382	DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(RamData);
383	txtData.ByteProvider = _DynamicByteProvider;
384	//_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
385	}
386	catch (ObjectDisposedException) { } // ignore errors aobut disposed objects (usually only happens when the parent closes)
387	catch (Exception ex) { logger.Error.WriteLine("{0}.ResultsUpdateWorkerThread_RunWorkerCompleted():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
388	}
389	private void Handle_KeyDown(object sender, KeyEventArgs e)
390	{
391	//isScrolling = false;
392	//bool reenable = false;
393	//if (this.UpdateEnabled) reenable = true;
394	//this.UpdateEnabled = false;
395
396	this.UpdateMaxRamView();
397	int ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;
398
399	////if (e.Type == ScrollEventType.EndScroll) return;
400	//uint size = max_ram_view;
401
402	bool haveModifier = false;
403	switch (e.Modifiers)
404	{
405	case Keys.Control:
406	switch (e.KeyCode)
407	{
408	case Keys.Home:
409	this.CURRENT_TOP_ADDR = 0; //NonHandledKeysAreBeingPressed = false;
410	break;
411	case Keys.End:
412	this.CURRENT_TOP_ADDR = (int)((MemoryRangeSize - 1) - max_ram_view); //NonHandledKeysAreBeingPressed = false;
413	break;
414	default:
415	//NonHandledKeysAreBeingPressed = true;
416	break;
417	}
418	break;
419	}
420
421	if (!haveModifier)
422	{
423	switch (e.KeyCode)
424	{
425	case Keys.Up:
426	if (this.CURRENT_TOP_ADDR == 0 && (this.CURRENT_TOP_ADDR - small_scroll_change > this.CURRENT_TOP_ADDR))
427	{
428	this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
429	}
430	else
431	{
432	this.CURRENT_TOP_ADDR -= (int)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
433	}
434	break;
435	case Keys.Down:
436	this.CURRENT_TOP_ADDR += (int)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
437	break;
438	case Keys.PageUp:
439	if (this.CURRENT_TOP_ADDR == 0 && (this.CURRENT_TOP_ADDR - large_scroll_change > this.CURRENT_TOP_ADDR))
440	{
441	this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
442	}
443	else
444	{
445	this.CURRENT_TOP_ADDR -= (int)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
446	}
447	break;
448	case Keys.PageDown:
449	this.CURRENT_TOP_ADDR += (int)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
450	break;
451	default:
452	//NonHandledKeysAreBeingPressed = true;
453	break;
454	}
455	}
456	if (this.CURRENT_TOP_ADDR < MemoryRangeStart) this.CURRENT_TOP_ADDR = MemoryRangeStart;
457	//if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;
458	if (this.CURRENT_TOP_ADDR + max_ram_view >= MemoryRangeSize) this.CURRENT_TOP_ADDR = (int)(MemoryRangeSize - max_ram_view);
459
460	//this.UpdateEnabled = reenable;
461	}
462
463	private void UIMemoryViewer_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
464	private void txtAddresses_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
465	private void txtData_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
466
467	private void ramScroll_Scroll(object sender, ScrollEventArgs e) { this.Handle_Scroll(sender, e); }
468
469	private ScrollEventArgs GetMouseWheelScrollChange(int WheelDelta)
470	{
471	ScrollEventArgs args = new ScrollEventArgs(ScrollEventType.SmallIncrement,1);
472	if (WheelDelta < 0)
473	{
474	//// negative: scroll down
475	//// SmallDecrement -or- LargeDecrement
476	//if (WheelDelta <= small_scroll_change)
477	//{
478	// args = new ScrollEventArgs(ScrollEventType.SmallDecrement,(int)small_scroll_change);
479	//}
480	//if (WheelDelta > small_scroll_change && WheelDelta <= large_scroll_change)
481	//{
482	// args = new ScrollEventArgs(ScrollEventType.LargeDecrement, (int)large_scroll_change);
483	//}
484	args = new ScrollEventArgs(ScrollEventType.SmallIncrement, 1);
485	}
486	else
487	{
488	//// positive: scroll up
489	//// SmallIncrement -or- LargeIncrement
490	//if (WheelDelta <= small_scroll_change)
491	//{
492	// args = new ScrollEventArgs(ScrollEventType.SmallIncrement, (int)small_scroll_change);
493	//}
494	//if (WheelDelta > small_scroll_change && WheelDelta <= large_scroll_change)
495	//{
496	// args = new ScrollEventArgs(ScrollEventType.LargeIncrement, (int)large_scroll_change);
497	//}
498	args = new ScrollEventArgs(ScrollEventType.SmallDecrement, 1);
499	}
500	return args;
501	}
502
503	void txtAddresses_MouseWheel(object sender, MouseEventArgs e) { this.Handle_Scroll(sender, GetMouseWheelScrollChange(e.Delta)); }
504	void txtData_MouseWheel(object sender, MouseEventArgs e) { this.Handle_Scroll(sender, GetMouseWheelScrollChange(e.Delta)); }
505
506
507	private void Handle_Scroll(object sender, ScrollEventArgs e)
508	{
509	//isScrolling = true;
510	//bool reenable = false;
511	//if (this.UpdateEnabled) reenable = true;
512	//this.UpdateEnabled = false;
513
514	this.UpdateMaxRamView();
515	int ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;
516	//uint size = MemorySize;
517	if (e.Type == ScrollEventType.EndScroll) return;
518
519	switch (e.Type)
520	{
521	case ScrollEventType.SmallDecrement:
522	if (this.CURRENT_TOP_ADDR == 0 && ((this.CURRENT_TOP_ADDR - small_scroll_change) > this.CURRENT_TOP_ADDR))
523	{
524	this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
525	}
526	else
527	{
528	this.CURRENT_TOP_ADDR -= (small_scroll_change);
529	}
530	break;
531	case ScrollEventType.SmallIncrement:
532	this.CURRENT_TOP_ADDR += (small_scroll_change);
533	break;
534
535	case ScrollEventType.LargeDecrement:
536	if (this.CURRENT_TOP_ADDR == 0 && ((this.CURRENT_TOP_ADDR - large_scroll_change) > this.CURRENT_TOP_ADDR))
537	{
538	this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
539	}
540	else
541	{
542	this.CURRENT_TOP_ADDR -= (large_scroll_change);
543	}
544	break;
545	case ScrollEventType.LargeIncrement:
546	this.CURRENT_TOP_ADDR += (large_scroll_change);
547	break;
548	case ScrollEventType.ThumbPosition:
549	//this.CURRENT_TOP_ADDR = (uint)e.NewValue;
550	//break;
551	default:
552	this.CURRENT_TOP_ADDR = (int)(e.NewValue & 0xFFFFFFF0);
553	break;
554	}
555	if (this.CURRENT_TOP_ADDR < 0) this.CURRENT_TOP_ADDR = 0;
556	//if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = VTLB_VADDR_SIZE - max_ram_view;
557	//if (this.CURRENT_TOP_ADDR < 0 \|\| this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
558	if (this.CURRENT_TOP_ADDR + max_ram_view >= MemoryRangeSize) this.CURRENT_TOP_ADDR = (int)(MemoryRangeSize - max_ram_view);
559	//this.UpdateEnabled = reenable;
560	//isScrolling = false;
561	}
562	private void GotoImageBase()
563	{
564	if (this.peData == null) return;
565	object ImageBase = 0;
566	bool x86 = this.peData.Is32bitAssembly();
567	if (x86)
568	{
569	ImageBase = this.peData.NTHeader.OptionalHeader32._ImageBase;
570	uint ib = Convert.ToUInt32(ImageBase);
571	logger.VerboseDebug.WriteLine("UIMemoryViewer::GotoImageBase(0x{0:x8})", ib);
572	txthexGoto.Value = ib;
573	}
574	else
575	{
576	ImageBase = this.peData.NTHeader.OptionalHeader64._ImageBase;
577	ulong ib = Convert.ToUInt64(ImageBase);
578	logger.VerboseDebug.WriteLine("UIMemoryViewer::GotoImageBase(0x{0:x16})", ib);
579	txthexGoto.Value = (long)ib;
580	}
581
582	this.GotoAddress(txthexGoto.ToInt32());
583	}
584	private void btnGotoImageBase_Click(object sender, EventArgs e)
585	{
586
587	this.GotoImageBase();
588	}
589
590	}
591	}