/[RomCheater]/trunk/RomCheater/Docking/UI/UIMemoryViewer.cs
ViewVC logotype

Diff of /trunk/RomCheater/Docking/UI/UIMemoryViewer.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 200 by william, Thu May 31 07:29:44 2012 UTC revision 282 by william, Tue Jun 5 01:19:54 2012 UTC
# Line 1  Line 1 
1  ´╗┐using System;  ´╗┐//#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;  using System.Collections.Generic;
5  using System.ComponentModel;  using System.ComponentModel;
6  using System.Drawing;  using System.Drawing;
# Line 10  using Be.Windows.Forms; Line 12  using Be.Windows.Forms;
12  using RomCheater.Logging;  using RomCheater.Logging;
13  using RomCheater.PluginFramework.Interfaces;  using RomCheater.PluginFramework.Interfaces;
14  using System.Diagnostics;  using System.Diagnostics;
15    using Sojaner.MemoryScanner.MemoryProviers;
16    
17  namespace RomCheater.Docking.UI  namespace RomCheater.Docking.UI
18  {  {
19      public partial class UIMemoryViewer : UserControl, IProcessConfig, IAcceptsPlugin<IConfigPlugin>//, IAcceptsMemoryRange      public partial class UIMemoryViewer : UserControl,
20            IAcceptsPlugin<IConfigPlugin>,
21            IAcceptsProcess<Process>,
22            IAcceptsProcessAndConfig
23      {      {
24          public UIMemoryViewer()          public UIMemoryViewer()
25          {          {
# Line 29  namespace RomCheater.Docking.UI Line 35  namespace RomCheater.Docking.UI
35              txtData.UseFixedBytesPerLine = true;              txtData.UseFixedBytesPerLine = true;
36              txtData.StringViewVisible = true;              txtData.StringViewVisible = true;
37              ramScroll.Minimum = (int)MemoryStart;              ramScroll.Minimum = (int)MemoryStart;
38              for (uint i = MemoryStart; i < (MemoryStart + MemorySize); i += max_address_width) { ramScroll.Maximum += (int)max_address_width; }              for (int i = MemoryStart; i < (MemoryStart + max_ram_view); i += max_address_width) { ramScroll.Maximum += (int)max_address_width; }
39              ramScroll.Value = ramScroll.Minimum;              ramScroll.Value = ramScroll.Minimum;
40              this.CanChangeUpdateInterval = false;              this.CanChangeUpdateInterval = false;
41    
# Line 40  namespace RomCheater.Docking.UI Line 46  namespace RomCheater.Docking.UI
46                  lblAddressMarker.Text = lblAddressMarker.Text + string.Format("{0:X2} ", i);                  lblAddressMarker.Text = lblAddressMarker.Text + string.Format("{0:X2} ", i);
47              }              }
48              this.AcceptedPlugin = null; this.AcceptedProcess = null;              this.AcceptedPlugin = null; this.AcceptedProcess = null;
49    
50                txtAddresses.MouseWheel += new MouseEventHandler(txtAddresses_MouseWheel);
51                txtData.MouseWheel += new MouseEventHandler(txtData_MouseWheel);
52          }          }
53          #region IProcessConfig Members  
54            private void GetFirstNonZeroByte()
55            {
56    #if !DISABLE_GETFIRSTNONZERO_BYTE
57                if (!DesignMode)
58                {
59                    GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
60                    provider.OpenProvider();
61                    int addr = 0;
62                    provider.ReadFirstNonZeroByte(MemoryStart, MemorySize, out addr);
63                    provider.CloseProvider();
64                    GotoAddress(addr);
65                }
66    #endif
67            }
68    
69            #region  IAcceptsProcess<Process> Members
70          private Process _AcceptedProcess;          private Process _AcceptedProcess;
71          public Process AcceptedProcess          public Process AcceptedProcess
72          {          {
# Line 51  namespace RomCheater.Docking.UI Line 76  namespace RomCheater.Docking.UI
76                  _AcceptedProcess = value;                  _AcceptedProcess = value;
77                  update_timer.Enabled = (value != null);                  update_timer.Enabled = (value != null);
78                  UpdateEnabled = update_timer.Enabled;                  UpdateEnabled = update_timer.Enabled;
79    #if !DISABLE_GETFIRSTNONZEROBYTE_ONUPDATE_ACCEPTEDPROCESS
80                    if (value != null)
81                        GetFirstNonZeroByte();
82    #endif
83              }              }
84          }          }
85          #endregion          #endregion
# Line 58  namespace RomCheater.Docking.UI Line 87  namespace RomCheater.Docking.UI
87          public IConfigPlugin AcceptedPlugin { get; set; }          public IConfigPlugin AcceptedPlugin { get; set; }
88          #endregion          #endregion
89          #region IAcceptsMemoryRange members          #region IAcceptsMemoryRange members
90          public uint MemoryStart { get; set; }          public int MemoryStart { get { return MemorySizeConstants.MinimumAddress; } }
91          public uint MemorySize { get; set; }          public uint MemorySize { get { return MemorySizeConstants.MaximumAddress; } }
92          #endregion          #endregion
93          public void GotoTop() { this.CURRENT_TOP_ADDR = 0; }          public void GotoTop() { this.CURRENT_TOP_ADDR = 0; }
94          public void GotoBottom() { uint size = MemorySize; this.CURRENT_TOP_ADDR = (uint)((size - 1) - max_ram_view); }          public void GotoBottom() { uint size = (uint)MemorySize; this.CURRENT_TOP_ADDR = (int)((size - 1) - max_ram_view); }
95          public void GotoAddress(uint addr) { this.CURRENT_TOP_ADDR = (uint)addr & 0xFFFFFFF0; }          public void GotoAddress(int addr) { this.CURRENT_TOP_ADDR = (int)(addr & 0xFFFFFFF0); }
96          private bool _UpdateEnabled;          private bool _UpdateEnabled;
97          public bool UpdateEnabled          public bool UpdateEnabled
98          {          {
# Line 91  namespace RomCheater.Docking.UI Line 120  namespace RomCheater.Docking.UI
120          private string AsciiData = "";          private string AsciiData = "";
121          private byte[] RamData = new byte[] { };          private byte[] RamData = new byte[] { };
122    
123          const uint max_address_width = 16;          const int max_address_width = 16;
124          static uint max_ram_view = max_address_width * 27;          static int max_ram_view = max_address_width * 27;
125    
126          static uint small_scroll_change = max_address_width * 1; // scrolls one line (when you clikc the up or down arrows)          static int small_scroll_change = max_address_width * 1; // scrolls one line (when you clikc the up or down arrows)
127          static uint medium_scroll_change = max_ram_view / 2; // scrolls half a page          static int medium_scroll_change = max_ram_view / 2; // scrolls half a page
128          static uint large_scroll_change = max_ram_view; // scrolls a full page          static int large_scroll_change = max_ram_view; // scrolls a full page
129          private uint _CURRENT_TOP_ADDR;          private int _CURRENT_TOP_ADDR;
130          uint CURRENT_TOP_ADDR          int CURRENT_TOP_ADDR
131          {          {
132              get { return _CURRENT_TOP_ADDR; }              get { return _CURRENT_TOP_ADDR; }
133              set { _CURRENT_TOP_ADDR = value; }              set { txthexGoto.Value = _CURRENT_TOP_ADDR = value; }
134          }          }
135          //uint CURRENT_BOITTOM_ADDR() { return CURRENT_TOP_ADDR + max_ram_view; }          //uint CURRENT_BOITTOM_ADDR() { return CURRENT_TOP_ADDR + max_ram_view; }
136          private void UpdateMaxRamView()          private void UpdateMaxRamView()
# Line 110  namespace RomCheater.Docking.UI Line 139  namespace RomCheater.Docking.UI
139              Size size = g.MeasureString("00", txtData.Font).ToSize();              Size size = g.MeasureString("00", txtData.Font).ToSize();
140              int ByteHeight = size.Height;              int ByteHeight = size.Height;
141              int TotalHeight = txtData.Height;              int TotalHeight = txtData.Height;
142              uint NumberOfBytes = (uint)((TotalHeight / ByteHeight) * max_address_width);              int NumberOfBytes = (int)((TotalHeight / ByteHeight) * max_address_width);
143              uint byte_width = (max_address_width * 2);              int byte_width = (max_address_width * 2);
144              max_ram_view = NumberOfBytes + (byte_width - 1);              max_ram_view = NumberOfBytes + (byte_width);
145          }          }
146          private void btnGotoAddress_Click(object sender, EventArgs e)          private void btnGotoAddress_Click(object sender, EventArgs e)
147          {          {
148              this.GotoAddress(txthexGoto.ToUInt32());              this.GotoAddress(txthexGoto.ToInt32());
149          }          }
150    
151          private void btnEditBytes_Click(object sender, EventArgs e)          private void btnEditBytes_Click(object sender, EventArgs e)
# Line 128  namespace RomCheater.Docking.UI Line 157  namespace RomCheater.Docking.UI
157              editor.ShowDialog();              editor.ShowDialog();
158              if (editor.BytesEdited)              if (editor.BytesEdited)
159              {              {
160                  DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(editor.AsBytes);                  //DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(editor.AsBytes);
161                  txtData.ByteProvider = _DynamicByteProvider;                  //txtData.ByteProvider = _DynamicByteProvider;
162                  _DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);                  //_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
163                  this.WriteCurrentBytes();                  this.WriteCurrentBytes(this.CURRENT_TOP_ADDR, editor.AsBytes);
164              }              }
165              this.UpdateEnabled = reenable;              this.UpdateEnabled = reenable;
166          }          }
# Line 169  namespace RomCheater.Docking.UI Line 198  namespace RomCheater.Docking.UI
198          }          }
199          private byte[] GetMemory()          private byte[] GetMemory()
200          {          {
201                byte[] data = new byte[] { };
202              try              try
203              {              {
204                  Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();                  GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
205                  reader.ReadProcess = this.AcceptedProcess;                  provider.OpenProvider();
                 reader.OpenProcess();  
206                  int bytesReadSize;                  int bytesReadSize;
207                  byte[] data = reader.ReadProcessMemory(CURRENT_TOP_ADDR, max_ram_view, out bytesReadSize);                  provider.ReadProcessMemory(CURRENT_TOP_ADDR, (uint)max_ram_view, out bytesReadSize, out data);
208                  //this.Logger.LogDebugMessage(string.Format("GetMemory() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", data.Length));                  provider.CloseProvider();
209                  return data;  
210              }              }
211              catch (Exception ex)              catch (Exception ex)
212              {              {
213                  logger.Error.WriteLine("{0}.GetMemory():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());                  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;  
214              }              }
215                finally
216                {
217                    if (data.Length == 0)
218                    {
219                        data = new byte[max_ram_view];
220                        for (int i = 0; i < data.Length; i++) { data[i] = 0x0; }
221                    }
222                }
223                return data;
224          }          }
225          private void UpdateMemroyView() { this.UpdateMemroyView(this.CURRENT_TOP_ADDR); }          private void UpdateMemroyView() { this.UpdateMemroyView(this.CURRENT_TOP_ADDR); }
226          private void UpdateMemroyView(uint address)          private void UpdateMemroyView(int address)
227          {          {
228              try              try
229              {              {
# Line 196  namespace RomCheater.Docking.UI Line 231  namespace RomCheater.Docking.UI
231                  if (AcceptedPlugin == null) { return; }                  if (AcceptedPlugin == null) { return; }
232    
233                  byte[] data = GetMemory();                  byte[] data = GetMemory();
   
                 List<byte> ByteData = new List<byte>((int)(address + (max_ram_view - 0)));  
   
234                  try                  try
235                  {                  {
236                      AddressList = "";                      RamData = data;
                     AsciiData = "";  
237    
                     // create a byte array holding only the bytes that we need  
                     for (uint i = address; i < (address + (max_ram_view + 1)); i += 1) { ByteData.Add(data[i]); }  
238    
239                        AddressList = "";
240                        AsciiData = "";
241                      // write the addreses out                      // write the addreses out
242                      for (uint i = address; i < (address + max_ram_view); i += max_address_width)                      for (int i = address; i < (address + max_ram_view); i += max_address_width)
243                      {                      {
244                          AddressList = AddressList + string.Format("{0:X8}:\n", i);                          AddressList = AddressList + string.Format("{0:X8}:\n", i);
245                      }                      }
246                      // write out the ascii data                      //// write out the ascii data
247                      StringBuilder builder = new StringBuilder();                      StringBuilder builder = new StringBuilder();
248                      for (uint i = address; i < (address + max_ram_view); i += max_address_width)                      for (int i = address; i < (address + max_ram_view); i += max_address_width)
249                      {                      {
250                          for (uint j = 0; j < max_address_width; j++)                          try
251                          {                          {
252                              uint current_addr = i + j;                              for (int j = 0; j < max_address_width; j++)
                             if (current_addr >= MemorySize) break;  
                             byte ascii_value_raw = data[current_addr];  
                             char ascii_value = (char)data[current_addr];  
                             if (ascii_value_raw >= 0x20 && ascii_value_raw <= 0x7e)  
253                              {                              {
254                                  builder.Append(ascii_value.ToString());                                  int current_addr = i + j;
255                              }                                  if (current_addr >= MemorySize) break;
256                              else                                  byte ascii_value_raw = data[j];
257                              {                                  char ascii_value = (char)data[j];
258                                  builder.Append(".");                                  if (ascii_value_raw >= 0x20 && ascii_value_raw <= 0x7e)
259                                    {
260                                        builder.Append(ascii_value.ToString());
261                                    }
262                                    else
263                                    {
264                                        builder.Append(".");
265                                    }
266                              }                              }
267                                builder.AppendLine();
268                            }
269                            catch (Exception ex)
270                            {
271                                logger.Error.WriteLine("{0}.UpdateMemroyView().BuildingAsciiString:{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString());
272                                return;
273                          }                          }
                         builder.AppendLine();  
274                      }                      }
275                      AsciiData = builder.ToString();                      AsciiData = builder.ToString();
                     // write out the bytes  
                     RamData = ByteData.ToArray();  
276    
277    
278                  }                  }
# Line 247  namespace RomCheater.Docking.UI Line 284  namespace RomCheater.Docking.UI
284              }              }
285              catch (Exception ex) { logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }              catch (Exception ex) { logger.Error.WriteLine("{0}.UpdateMemroyView():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
286          }          }
287          private void HexResourceViewerBytes_Changed(object sender, System.EventArgs e)          //private void HexResourceViewerBytes_Changed(object sender, System.EventArgs e)
288          {          //{
289              this.WriteCurrentBytes();          //    this.WriteCurrentBytes();
290          }          //}
291          private void WriteCurrentBytes()          private void WriteCurrentBytes(int start_address, byte[] data)
292          {          {
293              try              try
294              {              {
295                  if (AcceptedProcess == null) { return; }                  if (AcceptedProcess == null) { return; }
296                  if (AcceptedPlugin == null) { return; }                  if (AcceptedPlugin == null) { return; }
297                  // Byte changed                  // Byte changed
298                  byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();                  //byte[] data = (txtData.ByteProvider as DynamicByteProvider).Bytes.ToArray();
299                                    GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
300                    provider.OpenProvider();
                 Sojaner.MemoryScanner.ProcessMemoryReader reader = new Sojaner.MemoryScanner.ProcessMemoryReader();  
                 reader.ReadProcess = this.AcceptedProcess;  
                 reader.OpenProcess();  
301                  int bytesReadSize;                  int bytesReadSize;
302    
303                  for (int i = 0; i < data.Length; i += sizeof(uint))                  for (int i = 0; i < data.Length; i ++)
304                  {                  {
305                      uint addr = (uint)(this.CURRENT_TOP_ADDR + i);                      int addr = (int)(start_address + i);
306                      uint data_to_write = BitConverter.ToUInt32(data, i);                      byte data_to_write = data[i];
307                      reader.WriteProcessMemory((UIntPtr)addr, data, out bytesReadSize);                      provider.WriteProcessMemory(addr, data_to_write, out bytesReadSize);
308                  }                  }
309                    provider.CloseProvider();
310              }              }
311              catch (Exception ex) { logger.Error.WriteLine("{0}.WriteCurrentBytes():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }              catch (Exception ex) { logger.Error.WriteLine("{0}.WriteCurrentBytes():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
312          }          }
# Line 287  namespace RomCheater.Docking.UI Line 322  namespace RomCheater.Docking.UI
322                  //this.Logger.LogDebugMessage(string.Format("RunWorkerCompeleted() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", RamData.Length));                  //this.Logger.LogDebugMessage(string.Format("RunWorkerCompeleted() -> Memory Size: {0}0x{2:X8}{1}", "{", "}", RamData.Length));
323                  DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(RamData);                  DynamicByteProvider _DynamicByteProvider = new DynamicByteProvider(RamData);
324                  txtData.ByteProvider = _DynamicByteProvider;                  txtData.ByteProvider = _DynamicByteProvider;
325                  _DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);                  //_DynamicByteProvider.Changed += new EventHandler(HexResourceViewerBytes_Changed);
326              }              }
327              catch (ObjectDisposedException) { } // ignore errors aobut disposed objects (usually only happens when the parent closes)              catch (ObjectDisposedException) { } // ignore errors aobut disposed objects (usually only happens when the parent closes)
328              catch (Exception ex) { logger.Error.WriteLine("{0}.ResultsUpdateWorkerThread_RunWorkerCompleted():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }              catch (Exception ex) { logger.Error.WriteLine("{0}.ResultsUpdateWorkerThread_RunWorkerCompleted():{1}{2}", this.GetType().Name, System.Environment.NewLine, ex.ToString()); }
# Line 300  namespace RomCheater.Docking.UI Line 335  namespace RomCheater.Docking.UI
335              //this.UpdateEnabled = false;              //this.UpdateEnabled = false;
336    
337              this.UpdateMaxRamView();              this.UpdateMaxRamView();
338              uint ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;              int ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;
339    
340              ////if (e.Type == ScrollEventType.EndScroll) return;              ////if (e.Type == ScrollEventType.EndScroll) return;
341              uint size = MemorySize;              //uint size = max_ram_view;
342    
343              bool haveModifier = false;              bool haveModifier = false;
344              switch (e.Modifiers)              switch (e.Modifiers)
# Line 315  namespace RomCheater.Docking.UI Line 350  namespace RomCheater.Docking.UI
350                              this.CURRENT_TOP_ADDR = 0; //NonHandledKeysAreBeingPressed = false;                              this.CURRENT_TOP_ADDR = 0; //NonHandledKeysAreBeingPressed = false;
351                              break;                              break;
352                          case Keys.End:                          case Keys.End:
353                              this.CURRENT_TOP_ADDR = (uint)((size - 1) - max_ram_view); //NonHandledKeysAreBeingPressed = false;                              this.CURRENT_TOP_ADDR = (int)((MemorySize - 1) - max_ram_view); //NonHandledKeysAreBeingPressed = false;
354                              break;                              break;
355                          default:                          default:
356                              //NonHandledKeysAreBeingPressed = true;                              //NonHandledKeysAreBeingPressed = true;
# Line 329  namespace RomCheater.Docking.UI Line 364  namespace RomCheater.Docking.UI
364                  switch (e.KeyCode)                  switch (e.KeyCode)
365                  {                  {
366                      case Keys.Up:                      case Keys.Up:
367                          this.CURRENT_TOP_ADDR -= (uint)small_scroll_change; //NonHandledKeysAreBeingPressed = false;                          if (this.CURRENT_TOP_ADDR == 0 && (this.CURRENT_TOP_ADDR - small_scroll_change > this.CURRENT_TOP_ADDR))
368                            {
369                                this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
370                            }
371                            else
372                            {
373                                this.CURRENT_TOP_ADDR -= (int)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
374                            }
375                          break;                          break;
376                      case Keys.Down:                      case Keys.Down:
377                          this.CURRENT_TOP_ADDR += (uint)small_scroll_change; //NonHandledKeysAreBeingPressed = false;                          this.CURRENT_TOP_ADDR += (int)small_scroll_change; //NonHandledKeysAreBeingPressed = false;
378                          break;                          break;
379                      case Keys.PageUp:                      case Keys.PageUp:
380                          this.CURRENT_TOP_ADDR -= (uint)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;                          if (this.CURRENT_TOP_ADDR == 0 && (this.CURRENT_TOP_ADDR - large_scroll_change > this.CURRENT_TOP_ADDR))
381                            {
382                                this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
383                            }
384                            else
385                            {
386                                this.CURRENT_TOP_ADDR -= (int)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
387                            }
388                          break;                          break;
389                      case Keys.PageDown:                      case Keys.PageDown:
390                          this.CURRENT_TOP_ADDR += (uint)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;                          this.CURRENT_TOP_ADDR += (int)(large_scroll_change); //NonHandledKeysAreBeingPressed = false;
391                          break;                          break;
392                      default:                      default:
393                          //NonHandledKeysAreBeingPressed = true;                          //NonHandledKeysAreBeingPressed = true;
# Line 347  namespace RomCheater.Docking.UI Line 396  namespace RomCheater.Docking.UI
396              }              }
397              if (this.CURRENT_TOP_ADDR < MemoryStart) this.CURRENT_TOP_ADDR = MemoryStart;              if (this.CURRENT_TOP_ADDR < MemoryStart) this.CURRENT_TOP_ADDR = MemoryStart;
398              //if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;              //if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;
399              if (this.CURRENT_TOP_ADDR + max_ram_view >= MemoryStart) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;              if (this.CURRENT_TOP_ADDR + max_ram_view >= MemorySize) this.CURRENT_TOP_ADDR = (int)(MemorySize - max_ram_view);
400                
401              //this.UpdateEnabled = reenable;              //this.UpdateEnabled = reenable;
402          }          }
403    
# Line 357  namespace RomCheater.Docking.UI Line 406  namespace RomCheater.Docking.UI
406          private void txtData_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }          private void txtData_KeyDown(object sender, KeyEventArgs e) { this.Handle_KeyDown(sender, e); }
407    
408          private void ramScroll_Scroll(object sender, ScrollEventArgs e) { this.Handle_Scroll(sender, e); }          private void ramScroll_Scroll(object sender, ScrollEventArgs e) { this.Handle_Scroll(sender, e); }
409    
410            private ScrollEventArgs GetMouseWheelScrollChange(int WheelDelta)
411            {
412                ScrollEventArgs args = new ScrollEventArgs(ScrollEventType.SmallIncrement,1);
413                if (WheelDelta < 0)
414                {
415                    //// negative: scroll down
416                    //// SmallDecrement -or- LargeDecrement
417                    //if (WheelDelta <= small_scroll_change)
418                    //{
419                    //    args = new ScrollEventArgs(ScrollEventType.SmallDecrement,(int)small_scroll_change);
420                    //}
421                    //if (WheelDelta > small_scroll_change && WheelDelta <= large_scroll_change)
422                    //{
423                    //    args = new ScrollEventArgs(ScrollEventType.LargeDecrement, (int)large_scroll_change);
424                    //}
425                    args = new ScrollEventArgs(ScrollEventType.SmallIncrement, 1);
426                }
427                else
428                {
429                    //// positive: scroll up
430                    //// SmallIncrement  -or- LargeIncrement
431                    //if (WheelDelta <= small_scroll_change)
432                    //{
433                    //    args = new ScrollEventArgs(ScrollEventType.SmallIncrement, (int)small_scroll_change);
434                    //}
435                    //if (WheelDelta > small_scroll_change && WheelDelta <= large_scroll_change)
436                    //{
437                    //    args = new ScrollEventArgs(ScrollEventType.LargeIncrement, (int)large_scroll_change);
438                    //}
439                    args = new ScrollEventArgs(ScrollEventType.SmallDecrement, 1);
440                }
441                return args;
442            }
443    
444            void txtAddresses_MouseWheel(object sender, MouseEventArgs e) { this.Handle_Scroll(sender, GetMouseWheelScrollChange(e.Delta)); }
445            void txtData_MouseWheel(object sender, MouseEventArgs e) { this.Handle_Scroll(sender, GetMouseWheelScrollChange(e.Delta)); }
446          
447    
448          private void Handle_Scroll(object sender, ScrollEventArgs e)          private void Handle_Scroll(object sender, ScrollEventArgs e)
449          {          {
450              //isScrolling = true;              //isScrolling = true;
# Line 365  namespace RomCheater.Docking.UI Line 453  namespace RomCheater.Docking.UI
453              //this.UpdateEnabled = false;              //this.UpdateEnabled = false;
454    
455              this.UpdateMaxRamView();              this.UpdateMaxRamView();
456              uint ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;              int ORIGINAL_ADDR = this.CURRENT_TOP_ADDR;
457              uint size = MemorySize;              //uint size = MemorySize;
458              if (e.Type == ScrollEventType.EndScroll) return;              if (e.Type == ScrollEventType.EndScroll) return;
459    
460              switch (e.Type)              switch (e.Type)
461              {              {
462                  case ScrollEventType.SmallDecrement:                  case ScrollEventType.SmallDecrement:
463                      this.CURRENT_TOP_ADDR -= (small_scroll_change);                      if (this.CURRENT_TOP_ADDR == 0 && ((this.CURRENT_TOP_ADDR - small_scroll_change) > this.CURRENT_TOP_ADDR))
464                        {
465                            this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
466                        }
467                        else
468                        {
469                            this.CURRENT_TOP_ADDR -= (small_scroll_change);
470                        }
471                      break;                      break;
472                  case ScrollEventType.SmallIncrement:                  case ScrollEventType.SmallIncrement:
473                      this.CURRENT_TOP_ADDR += (small_scroll_change);                      this.CURRENT_TOP_ADDR += (small_scroll_change);
474                      break;                      break;
475    
476                  case ScrollEventType.LargeDecrement:                  case ScrollEventType.LargeDecrement:
477                      this.CURRENT_TOP_ADDR -= (large_scroll_change);                      if (this.CURRENT_TOP_ADDR == 0 && ((this.CURRENT_TOP_ADDR - large_scroll_change) > this.CURRENT_TOP_ADDR))
478                        {
479                            this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
480                        }
481                        else
482                        {
483                            this.CURRENT_TOP_ADDR -= (large_scroll_change);
484                        }
485                      break;                      break;
486                  case ScrollEventType.LargeIncrement:                  case ScrollEventType.LargeIncrement:
487                      this.CURRENT_TOP_ADDR += (large_scroll_change);                      this.CURRENT_TOP_ADDR += (large_scroll_change);
# Line 388  namespace RomCheater.Docking.UI Line 490  namespace RomCheater.Docking.UI
490                  //this.CURRENT_TOP_ADDR = (uint)e.NewValue;                  //this.CURRENT_TOP_ADDR = (uint)e.NewValue;
491                  //break;                  //break;
492                  default:                  default:
493                      this.CURRENT_TOP_ADDR = (uint)((uint)e.NewValue & 0xFFFFFFF0);                      this.CURRENT_TOP_ADDR = (int)(e.NewValue & 0xFFFFFFF0);
494                      break;                      break;
495              }              }
496              if (this.CURRENT_TOP_ADDR < 0) this.CURRENT_TOP_ADDR = 0;              if (this.CURRENT_TOP_ADDR < 0) this.CURRENT_TOP_ADDR = 0;
497              //if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = VTLB_VADDR_SIZE - max_ram_view;              //if (this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = VTLB_VADDR_SIZE - max_ram_view;
498              //if (this.CURRENT_TOP_ADDR < 0 || this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;              //if (this.CURRENT_TOP_ADDR < 0 || this.CURRENT_TOP_ADDR >= VTLB_VADDR_SIZE) this.CURRENT_TOP_ADDR = ORIGINAL_ADDR;
499              if (this.CURRENT_TOP_ADDR + max_ram_view >= MemorySize) this.CURRENT_TOP_ADDR = (size - 1) - max_ram_view;              if (this.CURRENT_TOP_ADDR + max_ram_view >= MemorySize) this.CURRENT_TOP_ADDR = (int)(MemorySize - max_ram_view);
500              //this.UpdateEnabled = reenable;              //this.UpdateEnabled = reenable;
501              //isScrolling = false;              //isScrolling = false;
502          }          }
503    
504      }      }
505  }  }

Legend:
Removed from v.200  
changed lines
  Added in v.282

  ViewVC Help
Powered by ViewVC 1.1.22