Docking/UI/UIMemoryViewer.cs

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;

namespace RomCheater.Docking.UI
{
    public partial class UIMemoryViewer : UserControl, IProcessConfig, IAcceptsPlugin<IConfigPlugin>//, IAcceptsMemoryRange
    {
        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)MemoryStart;
            for (uint i = MemoryStart; i < (MemoryStart + 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;
        }
        #region IProcessConfig Members
        private Process _AcceptedProcess;
        public Process AcceptedProcess
        {
            get { return _AcceptedProcess; }
            set
            {
                _AcceptedProcess = value;
                update_timer.Enabled = (value != null);
                UpdateEnabled = update_timer.Enabled;
            }
        }
        #endregion
        #region IAcceptsPlugin<IConfigPlugin> Members
        public IConfigPlugin AcceptedPlugin { get; set; }
        #endregion
        #region IAcceptsMemoryRange members
        private uint MemoryStart { get { return 0; } }
        private uint MemorySize { get { return int.MaxValue; } }
        #endregion
        public void GotoTop() { this.CURRENT_TOP_ADDR = 0; }
        public void GotoBottom() { uint size = MemorySize; this.CURRENT_TOP_ADDR = (uint)((size - 1) - max_ram_view); }
        public void GotoAddress(uint addr) { this.CURRENT_TOP_ADDR = (uint)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 uint max_address_width = 16;
        static uint max_ram_view = max_address_width * 27;

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

        private void btnEditBytes_Click(object sender, EventArgs e)
        {
            bool reenable = false;
            if (this.UpdateEnabled) reenable = true;
            this.UpdateEnabled = false;
            ByteEditor editor = new ByteEditor((txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray(), this.CURRENT_TOP_ADDR);
            editor.ShowDialog();
            if (editor.BytesEdited)
            {
                DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(editor.AsBytes);
                txtData.ByteProvider = _DynamicByteProvider;
                _DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
                this.WriteCurrentBytes();
            }
            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()
        {
            try
            {
                Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
                reader.ReadProcess = this.AcceptedProcess;
                reader.OpenProcess();
                int bytesReadSize;
                byte[] data = reader.ReadProcessMemory(CURRENT_TOP_ADDR, max_ram_view, out bytesReadSize);
                //this.Logger.LogDebugMessage(string.Format("GetMemory() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", data.Length));
                return data;
            }
            catch (Exception ex)
            {
                logger.Error.WriteLine("{0}.GetMemory():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
                byte[] 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(uint address)
        {
            try
            {
                if (AcceptedProcess == null) { return; }
                if (AcceptedPlugin == null) { return; }

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


                    AddressList = "";
                    AsciiData = "";
                    // write the addreses out
                    for (uint 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 (uint i = address; i < (address + max_ram_view); i += max_address_width)
                    {
                        try
                        {
                            for (uint j = 0; j < max_address_width; j++)
                            {
                                uint current_addr = i + j;
                                if (current_addr >= MemorySize) 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()
        {
            try
            {
                if (AcceptedProcess == null) { return; }
                if (AcceptedPlugin == null) { return; }
                // Byte changed
                byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();
                

                Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
                reader.ReadProcess = this.AcceptedProcess;
                reader.OpenProcess();
                int bytesReadSize;

                for (int i = 0; i < data.Length; i += sizeof(uint))
                {
                    uint addr = (uint)(this.CURRENT_TOP_ADDR + i);
                    uint data_to_write = BitConverter.ToUInt32(data, i);
                    reader.WriteProcessMemory((UIntPtr)addr, data, out bytesReadSize);
                }
            }
            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();
            uint 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 = (uint)((size - 1) - max_ram_view); //NonHandledKeysAreBeingPressed = false;
                            break;
                        default:
                            //NonHandledKeysAreBeingPressed = true;
                            break;
                    }
                    break;
            }

            if (!haveModifier)
            {
                switch (e.KeyCode)
                {
                    case Keys.Up:
                        this.CURRENT_TOP_ADDR -= (uint)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
                        break;
                    case Keys.Down:
                        this.CURRENT_TOP_ADDR += (uint)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
                        break;
                    case Keys.PageUp:
                        this.CURRENT_TOP_ADDR -= (uint)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
                        break;
                    case Keys.PageDown:
                        this.CURRENT_TOP_ADDR += (uint)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
                        break;
                    default:
                        //NonHandledKeysAreBeingPressed = true;
                        break;
                }
            }
            if (this.CURRENT_TOP_ADDR < MemoryStart) this.CURRENT_TOP_ADDR = MemoryStart;
            //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 >= MemorySize) this.CURRENT_TOP_ADDR = (size - 1);

            //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 void Handle_Scroll(object sender, ScrollEventArgs e)
        {
            //isScrolling = true;
            //bool reenable = false;
            //if (this.UpdateEnabled) reenable = true;
            //this.UpdateEnabled = false;

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

            switch (e.Type)
            {
                case ScrollEventType.SmallDecrement:
                    this.CURRENT_TOP_ADDR -= (small_scroll_change);
                    break;
                case ScrollEventType.SmallIncrement:
                    this.CURRENT_TOP_ADDR += (small_scroll_change);
                    break;

                case ScrollEventType.LargeDecrement:
                    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 = (uint)((uint)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 >= MemorySize) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;
            //this.UpdateEnabled = reenable;
            //isScrolling = false;
        }
    }
}
1	william	198	using System;
2			using System.Collections.Generic;
3			using System.ComponentModel;
4			using System.Drawing;
5			using System.Data;
6			using System.Linq;
7			using System.Text;
8			using System.Windows.Forms;
9			using Be.Windows.Forms;
10			using RomCheater.Logging;
11			using RomCheater.PluginFramework.Interfaces;
12			using System.Diagnostics;
13
14			namespace RomCheater.Docking.UI
15			{
16	william	200	public partial class UIMemoryViewer : UserControl, IProcessConfig, IAcceptsPlugin<IConfigPlugin>//, IAcceptsMemoryRange
17	william	198	{
18			public UIMemoryViewer()
19			{
20			InitializeComponent();
21			SetStyle(ControlStyles.UserPaint, true);
22			SetStyle(ControlStyles.DoubleBuffer, true);
23			SetStyle(ControlStyles.AllPaintingInWmPaint, true);
24			SetStyle(ControlStyles.ResizeRedraw, true);
25			//this.OnPCSX2ProcessCallback = new UIEvents.PCSX2ProcessCallback(this.PCSX2ProcessCallback);
26			//if (this.OnPCSX2ProcessCallback != null) { this.OnPCSX2ProcessCallback.Invoke(out procdata); }
27			this.UpdateEnabled = false;
28			txtData.BytesPerLine = (int)max_address_width;
29			txtData.UseFixedBytesPerLine = true;
30			txtData.StringViewVisible = true;
31			ramScroll.Minimum = (int)MemoryStart;
32	william	201	for (uint i = MemoryStart; i < (MemoryStart + max_ram_view); i += max_address_width) { ramScroll.Maximum += (int)max_address_width; }
33	william	198	ramScroll.Value = ramScroll.Minimum;
34			this.CanChangeUpdateInterval = false;
35
36
37			lblAddressMarker.Text = "";
38			for (uint i = 0; i < max_address_width; i++)
39			{
40			lblAddressMarker.Text = lblAddressMarker.Text + string.Format("{0:X2} ", i);
41			}
42			this.AcceptedPlugin = null; this.AcceptedProcess = null;
43			}
44			#region IProcessConfig Members
45	william	199	private Process _AcceptedProcess;
46			public Process AcceptedProcess
47			{
48			get { return _AcceptedProcess; }
49			set
50			{
51			_AcceptedProcess = value;
52			update_timer.Enabled = (value != null);
53			UpdateEnabled = update_timer.Enabled;
54			}
55			}
56	william	198	#endregion
57			#region IAcceptsPlugin<IConfigPlugin> Members
58			public IConfigPlugin AcceptedPlugin { get; set; }
59			#endregion
60	william	200	#region IAcceptsMemoryRange members
61	william	201	private uint MemoryStart { get { return 0; } }
62			private uint MemorySize { get { return int.MaxValue; } }
63	william	200	#endregion
64	william	198	public void GotoTop() { this.CURRENT_TOP_ADDR = 0; }
65			public void GotoBottom() { uint size = MemorySize; this.CURRENT_TOP_ADDR = (uint)((size - 1) - max_ram_view); }
66			public void GotoAddress(uint addr) { this.CURRENT_TOP_ADDR = (uint)addr & 0xFFFFFFF0; }
67			private bool _UpdateEnabled;
68			public bool UpdateEnabled
69			{
70			get { return _UpdateEnabled; }
71			set
72			{
73			_UpdateEnabled = value;
74			if (value) { this.update_timer.Enabled = true; }
75			else { this.update_timer.Enabled = false; }
76			}
77			}
78			private bool _CanChangeUpdateInterval;
79			public bool CanChangeUpdateInterval
80			{
81			get { return _CanChangeUpdateInterval; }
82			set { _CanChangeUpdateInterval = value; }
83			}
84
85			public int UpdateInterval
86			{
87			get { return this.update_timer.Interval; }
88			set { if (CanChangeUpdateInterval) this.update_timer.Interval = value; }
89			}
90			private string AddressList = "";
91			private string AsciiData = "";
92			private byte[] RamData = new byte[] { };
93
94			const uint max_address_width = 16;
95			static uint max_ram_view = max_address_width * 27;
96
97			static uint small_scroll_change = max_address_width * 1; // scrolls one line (when you clikc the up or down arrows)
98			static uint medium_scroll_change = max_ram_view / 2; // scrolls half a page
99			static uint large_scroll_change = max_ram_view; // scrolls a full page
100			private uint _CURRENT_TOP_ADDR;
101			uint CURRENT_TOP_ADDR
102			{
103			get { return _CURRENT_TOP_ADDR; }
104			set { _CURRENT_TOP_ADDR = value; }
105			}
106			//uint CURRENT_BOITTOM_ADDR() { return CURRENT_TOP_ADDR + max_ram_view; }
107			private void UpdateMaxRamView()
108			{
109			Graphics g = this.CreateGraphics();
110			Size size = g.MeasureString("00", txtData.Font).ToSize();
111			int ByteHeight = size.Height;
112			int TotalHeight = txtData.Height;
113			uint NumberOfBytes = (uint)((TotalHeight / ByteHeight) * max_address_width);
114			uint byte_width = (max_address_width * 2);
115			max_ram_view = NumberOfBytes + (byte_width - 1);
116			}
117			private void btnGotoAddress_Click(object sender, EventArgs e)
118			{
119			this.GotoAddress(txthexGoto.ToUInt32());
120			}
121
122			private void btnEditBytes_Click(object sender, EventArgs e)
123			{
124			bool reenable = false;
125			if (this.UpdateEnabled) reenable = true;
126			this.UpdateEnabled = false;
127			ByteEditor editor = new ByteEditor((txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray(), this.CURRENT_TOP_ADDR);
128			editor.ShowDialog();
129			if (editor.BytesEdited)
130			{
131			DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(editor.AsBytes);
132			txtData.ByteProvider = _DynamicByteProvider;
133			_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
134			this.WriteCurrentBytes();
135			}
136			this.UpdateEnabled = reenable;
137			}
138			private bool ForceUpdate = false;
139			private bool ShouldUpdateResults()
140			{
141			//if (ResultsUpdateWorkerThread.IsBusy) { return false; }
142			if (ForceUpdate) return true;
143			//else if (TextIsBeingSelected) return false;
144			//else if (NonHandledKeysAreBeingPressed) return false;
145			else if (this.UpdateEnabled) return true;
146			else { return false; }
147			}
148			private void UpdateGui(bool force)
149			{
150			if (AcceptedProcess == null) { return; }
151			if (AcceptedPlugin == null) { return; }
152
153			if (!this.ShouldUpdateResults()) { return; }// this.Logger.LogDebugMessage(string.Format("ShouldUpdateResults() -> returning false")); return; }
154			this.UpdateMaxRamView();
155			//if (!force)
156			//{
157			if (!ResultsUpdateWorkerThread.IsBusy)
158			ResultsUpdateWorkerThread.RunWorkerAsync();
159			//}
160			//else
161			//{
162			// while (!ResultsUpdateWorkerThread.IsBusy) { ResultsUpdateWorkerThread.CancelAsync(); Application.DoEvents(); }
163			// ResultsUpdateWorkerThread.RunWorkerAsync();
164			//}
165			}
166			private void UpdateGui()
167			{
168			this.UpdateGui(false);
169			}
170			private byte[] GetMemory()
171			{
172			try
173			{
174			Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
175			reader.ReadProcess = this.AcceptedProcess;
176			reader.OpenProcess();
177			int bytesReadSize;
178	william	200	byte[] data = reader.ReadProcessMemory(CURRENT_TOP_ADDR, max_ram_view, out bytesReadSize);
179	william	198	//this.Logger.LogDebugMessage(string.Format("GetMemory() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", data.Length));
180			return data;
181			}
182			catch (Exception ex)
183			{
184			logger.Error.WriteLine("{0}.GetMemory():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
185	william	200	byte[] data = new byte[max_ram_view];
186	william	198	for (int i = 0; i < data.Length; i++) { data[i] = 0x0; }
187			return data;
188			}
189			}
190			private void UpdateMemroyView() { this.UpdateMemroyView(this.CURRENT_TOP_ADDR); }
191			private void UpdateMemroyView(uint address)
192			{
193			try
194			{
195			if (AcceptedProcess == null) { return; }
196			if (AcceptedPlugin == null) { return; }
197
198			byte[] data = GetMemory();
199	william	201	try
200			{
201			RamData = data;
202	william	198
203
204			AddressList = "";
205			AsciiData = "";
206			// write the addreses out
207			for (uint i = address; i < (address + max_ram_view); i += max_address_width)
208			{
209			AddressList = AddressList + string.Format("{0:X8}:\n", i);
210			}
211	william	201	//// write out the ascii data
212	william	198	StringBuilder builder = new StringBuilder();
213			for (uint i = address; i < (address + max_ram_view); i += max_address_width)
214			{
215	william	201	try
216	william	198	{
217	william	201	for (uint j = 0; j < max_address_width; j++)
218	william	198	{
219	william	201	uint current_addr = i + j;
220			if (current_addr >= MemorySize) break;
221			byte ascii_value_raw = data[j];
222			char ascii_value = (char)data[j];
223			if (ascii_value_raw >= 0x20 && ascii_value_raw <= 0x7e)
224			{
225			builder.Append(ascii_value.ToString());
226			}
227			else
228			{
229			builder.Append(".");
230			}
231	william	198	}
232	william	201	builder.AppendLine();
233	william	198	}
234	william	201	catch (Exception ex)
235			{
236			logger.Error.WriteLine("{0}.UpdateMemroyView().BuildingAsciiString:{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
237			return;
238			}
239	william	198	}
240			AsciiData = builder.ToString();
241
242
243			}
244			catch (Exception ex)
245			{
246			logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
247			return;
248			}
249			}
250			catch (Exception ex) { logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
251			}
252			private void HexResourceViewerBytes_Changed(object sender, System.EventArgs e)
253			{
254			this.WriteCurrentBytes();
255			}
256			private void WriteCurrentBytes()
257			{
258			try
259			{
260			if (AcceptedProcess == null) { return; }
261			if (AcceptedPlugin == null) { return; }
262			// Byte changed
263			byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();
264
265
266			Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();
267			reader.ReadProcess = this.AcceptedProcess;
268			reader.OpenProcess();
269			int bytesReadSize;
270
271			for (int i = 0; i < data.Length; i += sizeof(uint))
272			{
273			uint addr = (uint)(this.CURRENT_TOP_ADDR + i);
274			uint data_to_write = BitConverter.ToUInt32(data, i);
275			reader.WriteProcessMemory((UIntPtr)addr, data, out bytesReadSize);
276			}
277			}
278			catch (Exception ex) { logger.Error.WriteLine("{0}.WriteCurrentBytes():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
279			}
280
281			private void update_timer_Tick(object sender, EventArgs e) { this.UpdateGui(); }
282			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()); } }
283			private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
284			{
285			try
286			{
287			txtAddresses.Clear(); txtAddresses.Text = AddressList;
288			//txtAscii.Clear(); txtAscii.Text = AsciiData;
289			//this.Logger.LogDebugMessage(string.Format("RunWorkerCompeleted() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", RamData.Length));
290			DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(RamData);
291			txtData.ByteProvider = _DynamicByteProvider;
292			_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
293			}
294			catch (ObjectDisposedException) { } // ignore errors aobut disposed objects (usually only happens when the parent closes)
295			catch (Exception ex) { logger.Error.WriteLine("{0}.ResultsUpdateWorkerThread_RunWorkerCompleted():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
296			}
297			private void Handle_KeyDown(object sender, KeyEventArgs e)
298			{
299			//isScrolling = false;
300			//bool reenable = false;
301			//if (this.UpdateEnabled) reenable = true;
302			//this.UpdateEnabled = false;
303
304			this.UpdateMaxRamView();
305			uint ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;
306
307			////if (e.Type == ScrollEventType.EndScroll) return;
308	william	201	uint size = max_ram_view;
309	william	198
310			bool haveModifier = false;
311			switch (e.Modifiers)
312			{
313			case Keys.Control:
314			switch (e.KeyCode)
315			{
316			case Keys.Home:
317			this.CURRENT_TOP_ADDR = 0; //NonHandledKeysAreBeingPressed = false;
318			break;
319			case Keys.End:
320			this.CURRENT_TOP_ADDR = (uint)((size - 1) - max_ram_view); //NonHandledKeysAreBeingPressed = false;
321			break;
322			default:
323			//NonHandledKeysAreBeingPressed = true;
324			break;
325			}
326			break;
327			}
328
329			if (!haveModifier)
330			{
331			switch (e.KeyCode)
332			{
333			case Keys.Up:
334			this.CURRENT_TOP_ADDR -= (uint)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
335			break;
336			case Keys.Down:
337			this.CURRENT_TOP_ADDR += (uint)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
338			break;
339			case Keys.PageUp:
340			this.CURRENT_TOP_ADDR -= (uint)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
341			break;
342			case Keys.PageDown:
343			this.CURRENT_TOP_ADDR += (uint)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
344			break;
345			default:
346			//NonHandledKeysAreBeingPressed = true;
347			break;
348			}
349			}
350			if (this.CURRENT_TOP_ADDR < MemoryStart) this.CURRENT_TOP_ADDR = MemoryStart;
351			//if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;
352	william	201	if (this.CURRENT_TOP_ADDR + max_ram_view >= MemorySize) this.CURRENT_TOP_ADDR = (size - 1);
353	william	198
354			//this.UpdateEnabled = reenable;
355			}
356
357			private void UIMemoryViewer_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
358			private void txtAddresses_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
359			private void txtData_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
360
361			private void ramScroll_Scroll(object sender, ScrollEventArgs e) { this.Handle_Scroll(sender, e); }
362			private void Handle_Scroll(object sender, ScrollEventArgs e)
363			{
364			//isScrolling = true;
365			//bool reenable = false;
366			//if (this.UpdateEnabled) reenable = true;
367			//this.UpdateEnabled = false;
368
369			this.UpdateMaxRamView();
370			uint ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;
371			uint size = MemorySize;
372			if (e.Type == ScrollEventType.EndScroll) return;
373
374			switch (e.Type)
375			{
376			case ScrollEventType.SmallDecrement:
377			this.CURRENT_TOP_ADDR -= (small_scroll_change);
378			break;
379			case ScrollEventType.SmallIncrement:
380			this.CURRENT_TOP_ADDR += (small_scroll_change);
381			break;
382
383			case ScrollEventType.LargeDecrement:
384			this.CURRENT_TOP_ADDR -= (large_scroll_change);
385			break;
386			case ScrollEventType.LargeIncrement:
387			this.CURRENT_TOP_ADDR += (large_scroll_change);
388			break;
389			case ScrollEventType.ThumbPosition:
390			//this.CURRENT_TOP_ADDR = (uint)e.NewValue;
391			//break;
392			default:
393			this.CURRENT_TOP_ADDR = (uint)((uint)e.NewValue & 0xFFFFFFF0);
394			break;
395			}
396			if (this.CURRENT_TOP_ADDR < 0) this.CURRENT_TOP_ADDR = 0;
397			//if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = VTLB_VADDR_SIZE - max_ram_view;
398			//if (this.CURRENT_TOP_ADDR < 0 \|\| this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
399			if (this.CURRENT_TOP_ADDR + max_ram_view >= MemorySize) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;
400			//this.UpdateEnabled = reenable;
401			//isScrolling = false;
402			}
403			}
404			}