/[RomCheater]/trunk/RomCheater/Docking/FloatingMemorySearcher.cs
ViewVC logotype

Annotation of /trunk/RomCheater/Docking/FloatingMemorySearcher.cs

Parent Directory Parent Directory | Revision Log Revision Log


Revision 409 - (hide annotations) (download)
Thu Jun 21 20:02:40 2012 UTC (8 years, 4 months ago) by william
File size: 109240 byte(s)

1 william 395 //#define USE_AUTOMATIC_MEMORY_SEARCH_RANGE // when defined will automatically choose the best starting address and size for memory search otherwise it will use the constants defined in MemorySizeConstants
2 william 289 #if !USE_AUTOMATIC_MEMORY_SEARCH_RANGE
3 william 287 #define FORCE_USE_OF_MEMORYSIZECONSTANTS // when defined wil force the use of the constants defined in MemorySizeConstants for memory search range
4 william 289 #endif
5 william 280 //#define DONOT_HAVE_RANGED_SEARCH_SUPPORT // when defined, indicates that ranged searches have not been implemented
6     #define INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY // when defined will set MIN RESULTS to 0x2701 otherwise 0x03e8
7     //#define DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE // when defined will not freeze/resume thread on freeze
8 william 229 using System;
9 william 227 using System.Collections.Generic;
10     using System.ComponentModel;
11     using System.Data;
12     using System.Drawing;
13     using System.Linq;
14     using System.Text;
15     using System.Windows.Forms;
16     using WeifenLuo.WinFormsUI.Docking;
17     using RomCheater.PluginFramework.Interfaces;
18     using System.Diagnostics;
19 william 229 using RomCheater.Docking.MemorySearch;
20     using libWin32.Win32.Threading;
21 william 230 using System.Threading;
22     using RomCheater.Logging;
23     using System.IO;
24 william 242 using Sojaner.MemoryScanner.MemoryProviers;
25 william 275 using RomCheater.PluginFramework.Events;
26 william 287 using System.Reflection;
27 william 292 using Sojaner.MemoryScanner;
28 william 399 using System.Collections;
29 william 401 using RomCheater.Serialization;
30 william 227
31     namespace RomCheater.Docking
32     {
33 william 228 public partial class FloatingMemorySearcher : DockContent,
34 william 243 IAcceptsPlugin<IConfigPlugin>,
35     IAcceptsProcess<Process>,
36     IAcceptsProcessAndConfig,
37 william 275 ISearchInProgress,
38 william 287 IAcceptsBrowseMemoryRegion,
39     IAcceptsMemoryRange
40 william 227 {
41 william 280 #if INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY
42     const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x2701; // 10,000 results
43     #else
44     const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x03e8; // 1,000 results
45     #endif
46    
47 william 229 private bool DefaultUnsignedState = true; // set unsigned to true
48 william 287 public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; OnBrowseMemoryRegion = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }
49 william 227 public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
50     public FloatingMemorySearcher(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
51    
52 william 237 #region IAcceptsProcess<Process> Members
53 william 243 private Process _AcceptedProcess;
54 william 305 public Process AcceptedProcess { get { return _AcceptedProcess; } set { _AcceptedProcess = value; UpdateAcceptedProcess(value); } }
55 william 227 #endregion
56     #region IAcceptsPlugin<IConfigPlugin> Members
57 william 243 private IConfigPlugin _AcceptedPlugin;
58 william 305 public IConfigPlugin AcceptedPlugin { get { return _AcceptedPlugin; } set { _AcceptedPlugin = value; UpdateAcceptedPlugin(value); } }
59 william 227 #endregion
60 william 275 #region IAcceptsBrowseMemoryRegion members
61 william 287 public event BaseEventHandler<BrowseMemoryRegionEvent> OnBrowseMemoryRegion;
62 william 275 #endregion
63    
64 william 305 private void UpdateAcceptedPlugin(IConfigPlugin config)
65 william 243 {
66     this.lstResults.AcceptedPlugin = config;
67     this.lstPatchList.AcceptedPlugin = config;
68 william 389 if (config != null)
69     {
70     MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
71     MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
72     }
73 william 305 }
74     private void UpdateAcceptedProcess(Process process)
75     {
76     this.lstResults.AcceptedProcess = process;
77 william 243 this.lstPatchList.AcceptedProcess = process;
78 william 287 #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && FORCE_USE_OF_MEMORYSIZECONSTANTS
79     logger.Warn.WriteLine("FloatingMemorySearcher.UpdateAcceptedProcessAndConfig(IConfigPlugin config, Process process):");
80     logger.Warn.WriteLine("Both USE_AUTOMATIC_MEMORY_SEARCH_RANGE and FORCE_USE_OF_MEMORYSIZECONSTANTS are defined");
81     logger.Warn.WriteLine("FORCE_USE_OF_MEMORYSIZECONSTANTS will take precedence and will ignore the values supplied in the memeory search range");
82 william 289 #endif
83     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
84     // force use of MemorySizeConstants
85 william 349 txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
86 william 401 txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
87 william 287 #endif
88     #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && !FORCE_USE_OF_MEMORYSIZECONSTANTS
89 william 318 ////// code to automatically choose the best starting memory address and size
90     //if (process != null)
91     //{
92     // string filename = process.MainModule.FileName;
93     // //string filename = @"c:\Windows\notepad.exe";
94     // PEReader peReader = new PEReader(filename);
95     //}
96     //else
97     //{
98 william 389 //txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
99     //txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
100 william 318 //}
101 william 389 if (AcceptedPlugin != null)
102     {
103     MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
104     MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
105     }
106    
107 william 287 #endif
108    
109 william 243 }
110 william 228 #region ISearchInProgress members
111 william 399 private bool _SearchInProgess;
112     public bool SearchInProgess
113     {
114     get { return _SearchInProgess; }
115     private set
116     {
117     _SearchInProgess = value;
118     if (this.AcceptedPlugin != null)
119     this.AcceptedPlugin.SetMemorySearchReference(this);
120     }
121     }
122 william 228 #endregion
123 william 229
124 william 287 #region IAcceptsMemoryRange
125     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
126 william 389 private uint _MemoryRangeStart;
127 william 287 private uint _MemoryRangeSize;
128     #endif
129 william 378 public uint MemoryRangeStart
130 william 287 {
131     get
132     {
133     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
134 william 349 return MemorySizeConstants.MinimumSearchAddress;
135 william 287 #else
136     return _MemoryRangeStart;
137     #endif
138     }
139     set
140     {
141     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
142     _MemoryRangeStart = value;
143 william 389 txtMemoryRangeStart.Value = value;
144 william 287 #endif
145     }
146     }
147     public uint MemoryRangeSize
148     {
149     get
150     {
151     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
152 william 401 return MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
153 william 287 #else
154     return _MemoryRangeSize;
155     #endif
156     }
157     set
158     {
159     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
160     _MemoryRangeSize = value;
161 william 389 txtMemoryRangeSize.Value = value;
162 william 287 #endif
163     }
164     }
165     #endregion
166 william 229
167     public void Reload()
168     {
169     chkUnsigned.Checked = DefaultUnsignedState;
170     radio_8bits.Checked = true;
171     radiocompare_equal.Checked = true;
172     radio_oldvalue.Checked = true;
173 william 230 chkRefreshResults.Checked = true;
174 william 229 }
175 william 230 public enum eListViewResults
176     {
177     SEARCH_RESULTS_LIST = 0x3000,
178     PATCH_RESULTS_LIST = 0x3001,
179     UKNOWN_RESULTS_LIST = 0x3001
180     }
181 william 280 bool IsFirstSearch = true;
182 william 277 SearchType SearchArgs;
183 william 272 static int col_Found_Address = 1;
184     static int col_Found_Value = 2;
185     static int col_Found_Frozen = 3;
186     static int col_Added_Address = 1;
187     static int col_Added_Value = 2;
188     static int col_Added_Frozen = 3;
189 william 230 List<ListViewItem> ResultItems = new List<ListViewItem>();
190     List<ListViewItem> AddedItems = new List<ListViewItem>();
191     private bool _PatchedValue_NeedsUpdate;
192     bool PatchedValue_NeedsUpdate
193     {
194     get { if (_PatchedValue_NeedsUpdate) this.ThawResultsUpdate(); return _PatchedValue_NeedsUpdate; }
195     set { _PatchedValue_NeedsUpdate = value; if (value) this.ThawResultsUpdate(); }
196     }
197     private delegate ListViewItem ThreadSafe_GetResultItem(int index, int lv_type);
198     private ListViewItem GetResultItem(int index, int lv_type)
199     {
200     try
201     {
202     AddressValuePairList lv = null;
203     switch (lv_type)
204     {
205     case (int)eListViewResults.SEARCH_RESULTS_LIST: lv = lstResults; break;
206     case (int)eListViewResults.PATCH_RESULTS_LIST: lv = lstPatchList; break;
207     default: throw new IndexOutOfRangeException("Detected: " + Enum.GetName(typeof(eListViewResults), eListViewResults.UKNOWN_RESULTS_LIST) + " with value: " + lv_type.ToString("x4"));
208     }
209     ListViewItem item = new ListViewItem();
210     item = (ListViewItem)lv.Items[index].Clone();
211     return item;
212     }
213     catch (Exception)
214     {
215     return null;
216     }
217     }
218 william 229 private void radiocompare_equal_CheckedChanged(object sender, EventArgs e)
219     {
220     //if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
221     //{
222     if (radio_oldvalue.Checked)
223     {
224     txtStartAddr.ReadOnly = true;
225     txtEndAddr.ReadOnly = true;
226     }
227     if (radio_specificvalue.Checked)
228     {
229     txtStartAddr.ReadOnly = false;
230     txtEndAddr.ReadOnly = true;
231     }
232     //}
233     }
234    
235     private void radiocompare_between_CheckedChanged(object sender, EventArgs e)
236     {
237     if (!radiocompare_equal.Checked &&
238     !radiocompare_greaterthan.Checked &&
239     !radiocompare_greaterthan.Checked &&
240     !radiocompare_lessthan.Checked &&
241     !radiocompare_greaterthan_orequal.Checked &&
242     !radiocompare_lessthan_orequal.Checked &&
243     !radiocompare_notequal.Checked)
244     if (radiocompare_between.Checked)
245     {
246     txtStartAddr.ReadOnly = false;
247     txtEndAddr.ReadOnly = false;
248     return;
249     }
250     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
251     {
252     if (radio_oldvalue.Checked)
253     {
254     txtStartAddr.ReadOnly = true;
255     txtEndAddr.ReadOnly = true;
256     }
257     if (radio_specificvalue.Checked)
258     {
259     txtStartAddr.ReadOnly = false;
260     txtEndAddr.ReadOnly = true;
261     }
262     }
263     }
264    
265     private void radiocompare_notbetween_CheckedChanged(object sender, EventArgs e)
266     {
267     if (!radiocompare_equal.Checked &&
268     !radiocompare_greaterthan.Checked &&
269     !radiocompare_greaterthan.Checked &&
270     !radiocompare_lessthan.Checked &&
271     !radiocompare_greaterthan_orequal.Checked &&
272     !radiocompare_lessthan_orequal.Checked &&
273     !radiocompare_notequal.Checked)
274     if (radiocompare_notbetween.Checked)
275     {
276     txtStartAddr.ReadOnly = false;
277     txtEndAddr.ReadOnly = false;
278     return;
279     }
280     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
281     {
282     if (radio_oldvalue.Checked)
283     {
284     txtStartAddr.ReadOnly = true;
285     txtEndAddr.ReadOnly = true;
286     }
287     if (radio_specificvalue.Checked)
288     {
289     txtStartAddr.ReadOnly = false;
290     txtEndAddr.ReadOnly = true;
291     }
292     }
293     }
294    
295     private void radio_8bits_CheckedChanged(object sender, EventArgs e)
296     {
297     if (chkUnsigned.Checked)
298     {
299     txtStartAddr.CreateTypeSize<byte>();
300     txtEndAddr.CreateTypeSize<byte>();
301     }
302     else
303     {
304     txtStartAddr.CreateTypeSize<sbyte>();
305     txtEndAddr.CreateTypeSize<sbyte>();
306     }
307     }
308    
309     private void radio_16bits_CheckedChanged(object sender, EventArgs e)
310     {
311     if (chkUnsigned.Checked)
312     {
313     txtStartAddr.CreateTypeSize<ushort>();
314     txtEndAddr.CreateTypeSize<ushort>();
315     }
316     else
317     {
318     txtStartAddr.CreateTypeSize<short>();
319     txtEndAddr.CreateTypeSize<short>();
320     }
321     }
322    
323     private void radio_32bits_CheckedChanged(object sender, EventArgs e)
324     {
325    
326     if (chkUnsigned.Checked)
327     {
328     txtStartAddr.CreateTypeSize<uint>();
329     txtEndAddr.CreateTypeSize<uint>();
330     }
331     else
332     {
333     txtStartAddr.CreateTypeSize<int>();
334     txtEndAddr.CreateTypeSize<int>();
335     }
336     }
337    
338     private void radio_64bits_CheckedChanged(object sender, EventArgs e)
339     {
340    
341     if (chkUnsigned.Checked)
342     {
343     txtStartAddr.CreateTypeSize<ulong>();
344     txtEndAddr.CreateTypeSize<ulong>();
345     }
346     else
347     {
348     txtStartAddr.CreateTypeSize<long>();
349     txtEndAddr.CreateTypeSize<long>();
350     }
351     }
352    
353     private void radio_oldvalue_CheckedChanged(object sender, EventArgs e)
354     {
355     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
356     {
357     txtStartAddr.ReadOnly = true;
358     txtEndAddr.ReadOnly = true;
359     }
360     }
361    
362     private void radio_specificvalue_CheckedChanged(object sender, EventArgs e)
363     {
364     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
365     {
366     txtStartAddr.ReadOnly = false;
367     txtEndAddr.ReadOnly = true;
368     }
369     }
370    
371     private void chkRefreshResults_CheckedChanged(object sender, EventArgs e)
372     {
373     if (chkRefreshResults.Checked)
374     {
375     timer_update_results.Enabled = true;
376     }
377     else
378     {
379     timer_update_results.Enabled = false;
380     ResultsUpdateWorkerThread.CancelAsync();
381     }
382     }
383    
384     private void timer_update_results_Tick(object sender, EventArgs e)
385     {
386     if (chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
387     {
388     ResultsUpdateWorkerThread.RunWorkerAsync();
389     }
390     }
391 william 230 private bool ShouldUpdateResults()
392     {
393     if (this.AcceptedProcess == null) return false;
394     if (SearchWorkerThread.IsBusy) return false;
395     //if (JokerSearchWorker.IsBusy) return false;
396     if (this.IsResultsUpdateFrozen) return false;
397     if (mnuAddedResults.Visible) return false;
398     if (mnuResults.Visible) return false;
399     if (Process.GetProcessById(this.AcceptedProcess.Id) == null) return false;
400     if (lstResults.Items.Count > 0) return true;
401     if (lstPatchList.Items.Count > 0) return true;
402     return false;
403     }
404 william 229 private void ResultsUpdateWorkerThread_DoWork(object sender, DoWorkEventArgs e)
405     {
406 william 230 Thread.Sleep(250); // keep thread from blocking
407     if (!this.ShouldUpdateResults()) return;
408     ////if (SearchArgs == null) return;
409     ////if (this.IsResultsUpdateFrozen) return;
410     ////// put thread to sleep for 500ms
411     ////System.Threading.Thread.Sleep(500);
412     //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
413     //byte[] buffered_mem = provider.GetMemory();
414     //MemoryStream ms = new MemoryStream(buffered_mem);
415     //BinaryReader r_ms = new BinaryReader(ms);
416 william 229
417 william 230 #region Update Results List
418     ResultItems = new List<ListViewItem>();
419     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
420     for (int i = 0; i < lstResults.Items.Count; i++)
421     {
422     if (this.lstResults.InvokeRequired)
423     {
424     ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
425     object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.SEARCH_RESULTS_LIST });
426     if (item != null)
427     ResultItems.Add((ListViewItem)item);
428     }
429     else
430     {
431     ResultItems.Add(lstResults.Items[i]);
432     }
433    
434     }
435     for (int i = 0; i < ResultItems.Count; i++)
436     {
437     if (ResultsUpdateWorkerThread.CancellationPending == true)
438     {
439     e.Cancel = true;
440     return;
441     }
442 william 249 int Address = 0;
443 william 230 ResultDataType _result = (ResultDataType)ResultItems[i].Tag;
444    
445 william 249 Address = Convert.ToInt32(ResultItems[i].SubItems[col_Found_Address].Text, 16);
446 william 242 //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);
447 william 398 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
448 william 230 {
449 william 398 provider.OpenProvider();
450     int bytesReadSize;
451     byte[] data;
452     uint bytesToRead = 0;
453     switch (_result.ValueType)
454     {
455     case SearchDataTypes._8bits:
456     bytesToRead = 1;
457     break;
458     case SearchDataTypes._16bits:
459     bytesToRead = 2;
460     break;
461     case SearchDataTypes._32bits:
462     bytesToRead = 4;
463     break;
464     case SearchDataTypes._64bits:
465     bytesToRead = 8;
466     break;
467     }
468     provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
469     using (MemoryStream ms = new MemoryStream(data))
470     {
471     using (BinaryReader r_ms = new BinaryReader(ms))
472     {
473     switch (_result.ValueType)
474     {
475     case SearchDataTypes._8bits:
476     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
477     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
478     break;
479     case SearchDataTypes._16bits:
480     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
481     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
482     break;
483     case SearchDataTypes._32bits:
484     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
485     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
486     break;
487     case SearchDataTypes._64bits:
488     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
489     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
490     break;
491     }
492     r_ms.Close();
493     }
494     }
495     provider.CloseProvider();
496 william 230 }
497 william 398 //Application.DoEvents();
498 william 230 }
499     #endregion
500    
501     #region Update Added Results List
502     AddedItems = new List<ListViewItem>();
503     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
504     for (int i = 0; i < lstPatchList.Items.Count; i++)
505     {
506     if (this.lstResults.InvokeRequired)
507     {
508     ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
509     object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.PATCH_RESULTS_LIST });
510     if (item != null)
511     AddedItems.Add((ListViewItem)item);
512     }
513     else
514     {
515     AddedItems.Add(lstPatchList.Items[i]);
516     }
517    
518     }
519     for (int i = 0; i < AddedItems.Count; i++)
520     {
521     if (ResultsUpdateWorkerThread.CancellationPending == true)
522     {
523     e.Cancel = true;
524     return;
525     }
526 william 249 int Address = 0;
527 william 230 ResultDataType _result = (ResultDataType)AddedItems[i].Tag;
528 william 249 Address = Convert.ToInt32(AddedItems[i].SubItems[col_Added_Address].Text, 16);
529 william 398 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
530 william 230 {
531 william 398 provider.OpenProvider();
532     int bytesReadSize;
533     byte[] data;
534     uint bytesToRead = 0;
535     switch (_result.ValueType)
536     {
537     case SearchDataTypes._8bits:
538     bytesToRead = 1;
539     break;
540     case SearchDataTypes._16bits:
541     bytesToRead = 2;
542     break;
543     case SearchDataTypes._32bits:
544     bytesToRead = 4;
545     break;
546     case SearchDataTypes._64bits:
547     bytesToRead = 8;
548     break;
549     }
550     provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
551     provider.CloseProvider();
552     using (MemoryStream ms = new MemoryStream(data))
553     {
554     using (BinaryReader r_ms = new BinaryReader(ms))
555     {
556     switch (_result.ValueType)
557     {
558     case SearchDataTypes._8bits:
559     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
560     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
561     break;
562     case SearchDataTypes._16bits:
563     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
564     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
565     break;
566     case SearchDataTypes._32bits:
567     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
568     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
569     break;
570     case SearchDataTypes._64bits:
571     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
572     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
573     break;
574     }
575     r_ms.Close();
576     }
577     }
578 william 230 }
579 william 398 //Application.DoEvents();
580 william 230 }
581     #endregion
582    
583    
584 william 229 }
585    
586     private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
587     {
588 william 230 try
589     {
590     //if ((lstResults.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate ) return;
591     //if ((lstPatchList.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate) return;
592     if (!this.ShouldUpdateResults()) return;
593     if (ResultItems.Count > 0)
594     {
595     //lstResults.Items.Clear();
596     //lstResults.Items.AddRange(ResultItems.ToArray());
597 william 229
598 william 230 for (int i = 0; i < ResultItems.Count; i++)
599     {
600     lstResults.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
601     ResultItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
602     }
603    
604     }
605     if (AddedItems.Count > 0)
606     {
607     //lstPatchList.Items.Clear();
608     //lstPatchList.Items.AddRange(AddedItems.ToArray());
609    
610     for (int i = 0; i < AddedItems.Count; i++)
611     {
612     lstPatchList.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
613     AddedItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
614     }
615    
616     }
617     PatchedValue_NeedsUpdate = false;
618     }
619     catch { }
620 william 229 }
621    
622     private void btnImportFile_Click(object sender, EventArgs e)
623     {
624     this.FreezeResultsUpdate();
625     if (!lstPatchList.ImportFromFile())
626     {
627     MessageBox.Show("Failed to Import Patch List from File.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
628     this.ThawResultsUpdate();
629     return;
630     }
631     else
632     {
633     MessageBox.Show("Succesfully Imported Patch List from File.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
634     this.ThawResultsUpdate();
635     return;
636     }
637     }
638     bool g_isFrozen = false;
639     private bool IsResultsUpdateFrozen
640     {
641     get { return g_isFrozen; }
642     set { g_isFrozen = value; }
643     }
644     private void ThawResultsUpdate()
645     {
646     this.IsResultsUpdateFrozen = false;
647     if (this.AcceptedProcess != null)
648     {
649     #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
650     ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
651     #endif
652     }
653     }
654    
655     private void FreezeResultsUpdate()
656     {
657     this.IsResultsUpdateFrozen = true;
658 william 285 //this.IsResultsUpdateFrozen = false;
659 william 229 if (this.AcceptedProcess != null)
660     {
661     #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
662     ThreadControl.SuspendProcess(this.AcceptedProcess.Id);
663     #endif
664     }
665     }
666    
667     private void btnExportFile_Click(object sender, EventArgs e)
668     {
669     this.FreezeResultsUpdate();
670     if (!lstPatchList.ExportToFile())
671     {
672     MessageBox.Show("Failed to Export Patch List to File.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
673     this.ThawResultsUpdate();
674     return;
675     }
676     else
677     {
678     MessageBox.Show("Succesfully Exported Patch List to File.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
679     this.ThawResultsUpdate();
680     return;
681     }
682     }
683    
684     private void btnImportClipboard_Click(object sender, EventArgs e)
685     {
686     this.FreezeResultsUpdate();
687     if (!lstPatchList.ImportFromClipboard())
688     {
689     MessageBox.Show("Failed to Import Patch List from Clipboard.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
690     this.ThawResultsUpdate();
691     return;
692     }
693     else
694     {
695     MessageBox.Show("Succesfully Import Patch List from Clipboard.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
696     this.ThawResultsUpdate();
697     }
698     }
699    
700     private void btnExportClipboard_Click(object sender, EventArgs e)
701     {
702     this.FreezeResultsUpdate();
703     if (!lstPatchList.ExportToClipboard())
704     {
705     MessageBox.Show("Failed to Export Patch List to Clipboard.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
706     this.ThawResultsUpdate();
707     return;
708     }
709     else
710     {
711     MessageBox.Show("Succesfully Exported Patch List to Clipboard.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
712     this.ThawResultsUpdate();
713     return;
714     }
715     }
716    
717     private void btnAddPatchAddress_Click(object sender, EventArgs e)
718     {
719 william 245 PatchAdder adder = new PatchAdder((IAcceptsProcessAndConfig)this);
720 william 229 adder.ShowDialog();
721     if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
722     }
723    
724     private void btnAddAddressRange_Click(object sender, EventArgs e)
725     {
726 william 245 PatchRangeAdder adder = new PatchRangeAdder((IAcceptsProcessAndConfig)this);
727 william 229 adder.ShowDialog();
728     if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
729     }
730     private void AddToPatchList(List<ResultDataType> item) { foreach (ResultDataType data in item) { AddToPatchList(data); } }
731     private void AddToPatchList(ResultDataType item)
732     {
733     ResultItem item2 = null;
734     switch (item.ValueType)
735     {
736     case SearchDataTypes._8bits:
737     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToByte(item.Value)); }
738     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToSByte(item.Value)); }
739     break;
740     case SearchDataTypes._16bits:
741     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt16(item.Value)); }
742     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt16(item.Value)); }
743     break;
744     case SearchDataTypes._32bits:
745     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt32(item.Value)); }
746     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt32(item.Value)); }
747     break;
748     case SearchDataTypes._64bits:
749     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt64(item.Value)); }
750     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt64(item.Value)); }
751     break;
752     }
753     this.AddToPatchList(item2);
754     }
755     private void AddToPatchList(ListViewItem item)
756     {
757     try
758     {
759     ResultDataType _result = (ResultDataType)item.Tag;
760     this.AddToPatchList(_result);
761     }
762     catch (InvalidCastException ex)
763     {
764     // unable to cast
765     MessageBox.Show(ex.Message, "Invalid Cast Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
766     }
767     catch (Exception ex)
768     {
769     // other exception
770     MessageBox.Show(ex.Message, "Unhandled Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
771     }
772     }
773     private void AddToPatchList(ResultItem item)
774     {
775     if (!lstPatchList.Items.Contains(item)) lstPatchList.Items.Add(item);
776     }
777     private void AddToPatchList(string address, SearchDataTypes bitsize, bool IsUnsigned)
778     {
779 william 245 ResultItemState state = new ResultItemState(address, bitsize, IsUnsigned, (IAcceptsProcessAndConfig)this);
780 william 229 ResultItem item = new ResultItem(state.Address, state.Value, state.Frozen, state.ValueType, state.IsUnsigned);
781     this.AddToPatchList(item);
782     }
783 william 230
784     private void mnuItemAddToPatchList_Click(object sender, EventArgs e)
785     {
786     if (!(lstResults.SelectedItems.Count > 0)) return;
787     //if (SearchArgs == null) return;
788    
789     try
790     {
791     for (int i = 0; i < lstResults.SelectedIndices.Count; i++)
792     {
793     //ResultDataType result = (ResultDataType)lstResults.Items[selected_index].Tag;
794     ListViewItem item = lstResults.Items[lstResults.SelectedIndices[i]];
795     this.AddToPatchList(item);
796     }
797     }
798     catch (Exception ex)
799     {
800     logger.Error.WriteLine(ex.ToString());
801     }
802     }
803    
804     private void mnuItemRemoveResult_Click(object sender, EventArgs e)
805     {
806     if (!(lstPatchList.SelectedItems.Count > 0)) return;
807     //if (SearchArgs == null) return;
808     try
809     {
810     this.FreezeResultsUpdate();
811     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
812     {
813     //lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
814     lstPatchList.Items[lstPatchList.SelectedIndices[i]].Remove();
815     }
816     this.ThawResultsUpdate();
817     }
818     catch (Exception ex)
819     {
820     Debug.WriteLine(ex.ToString());
821     }
822     }
823     private void PatchRange(bool SingleEntry)
824     {
825     //if (SearchArgs == null) return;
826     #region Patch Selected Address
827     // stop ResultsUpdate Thread
828     ResultsUpdateWorkerThread.CancelAsync();
829    
830     List<ResultDataType> patch_list = new List<ResultDataType>();
831     List<int> SelectedIndexes = new List<int>();
832    
833     if (SingleEntry)
834     {
835     SelectedIndexes.Add(lstPatchList.SelectedIndices[0]);
836     }
837     else
838     {
839     foreach (int index in lstPatchList.SelectedIndices)
840     {
841     SelectedIndexes.Add(index);
842     }
843     }
844     //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
845     foreach (int index in SelectedIndexes)
846     {
847     if (SingleEntry)
848     {
849     SearchPatcher patcher = null;
850     uint Address = 0;
851     ListViewItem item = lstPatchList.Items[index];
852     ResultDataType _result = (ResultDataType)item.Tag;
853     Address = Convert.ToUInt32(item.SubItems[col_Found_Address].Text, 16);
854     switch (_result.ValueType)
855     {
856     case SearchDataTypes._8bits:
857     if (_result.IsUnsigned)
858     {
859     byte value = Convert.ToByte(item.SubItems[col_Found_Value].Text, 16);
860 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
861 william 230 timer_update_results.Enabled = false;
862     patcher.ShowDialog();
863     timer_update_results.Enabled = true;
864     PatchedValue_NeedsUpdate = true;
865     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
866     ResultsUpdateWorkerThread.RunWorkerAsync();
867     }
868     else
869     {
870     sbyte value = Convert.ToSByte(item.SubItems[col_Found_Value].Text, 16);
871 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
872 william 230 timer_update_results.Enabled = false;
873     patcher.ShowDialog();
874     timer_update_results.Enabled = true;
875     PatchedValue_NeedsUpdate = true;
876     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
877     ResultsUpdateWorkerThread.RunWorkerAsync();
878     }
879     break;
880     case SearchDataTypes._16bits:
881     if (_result.IsUnsigned)
882     {
883     ushort value = Convert.ToUInt16(item.SubItems[col_Found_Value].Text, 16);
884 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
885 william 230 timer_update_results.Enabled = false;
886     patcher.ShowDialog();
887     timer_update_results.Enabled = true;
888     PatchedValue_NeedsUpdate = true;
889     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
890     ResultsUpdateWorkerThread.RunWorkerAsync();
891     }
892     else
893     {
894     short value = Convert.ToInt16(item.SubItems[col_Found_Value].Text, 16);
895 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
896 william 230 timer_update_results.Enabled = false;
897     patcher.ShowDialog();
898     timer_update_results.Enabled = true;
899     PatchedValue_NeedsUpdate = true;
900     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
901     ResultsUpdateWorkerThread.RunWorkerAsync();
902     }
903     break;
904     case SearchDataTypes._32bits:
905     if (_result.IsUnsigned)
906     {
907     uint value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
908 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
909 william 230 timer_update_results.Enabled = false;
910     patcher.ShowDialog();
911     timer_update_results.Enabled = true;
912     PatchedValue_NeedsUpdate = true;
913     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
914     ResultsUpdateWorkerThread.RunWorkerAsync();
915     }
916     else
917     {
918     int value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
919 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
920 william 230 timer_update_results.Enabled = false;
921     patcher.ShowDialog();
922     timer_update_results.Enabled = true;
923     PatchedValue_NeedsUpdate = true;
924     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
925     ResultsUpdateWorkerThread.RunWorkerAsync();
926     }
927     break;
928     case SearchDataTypes._64bits:
929     if (_result.IsUnsigned)
930     {
931     ulong value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
932 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
933 william 230 timer_update_results.Enabled = false;
934     patcher.ShowDialog();
935     timer_update_results.Enabled = true;
936     PatchedValue_NeedsUpdate = true;
937     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
938     ResultsUpdateWorkerThread.RunWorkerAsync();
939     }
940     else
941     {
942     long value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
943 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
944 william 230 timer_update_results.Enabled = false;
945     patcher.ShowDialog();
946     timer_update_results.Enabled = true;
947     PatchedValue_NeedsUpdate = true;
948     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
949     ResultsUpdateWorkerThread.RunWorkerAsync();
950     }
951     break;
952     }
953     }
954     else
955     {
956    
957     ListViewItem item = lstPatchList.Items[index];
958     ResultDataType _result = (ResultDataType)item.Tag;
959     patch_list.Add(_result);
960     }
961     }
962    
963     if (patch_list.Count > 0)
964     {
965 william 243 SearchRangePatcher rangePatcher = new SearchRangePatcher((IAcceptsProcessAndConfig)this, patch_list);
966 william 230 rangePatcher.ShowDialog();
967     }
968    
969     #endregion
970     }
971     private void mnuItemPatchSelectedEntry_Click(object sender, EventArgs e)
972     {
973     if (!(lstPatchList.SelectedItems.Count == 1)) return;
974     PatchRange(true);
975     }
976    
977     private void mnuItemPatchSelectedRange_Click(object sender, EventArgs e)
978     {
979     if (!(lstPatchList.SelectedItems.Count >= 1)) return;
980     PatchRange(false);
981     }
982    
983     private void mnuItemFreezeSelectedPatches_Click(object sender, EventArgs e)
984     {
985     if (!(lstPatchList.SelectedItems.Count > 0)) return;
986     //if (SearchArgs == null) return;
987     try
988     {
989     lstPatchList.ProcessID = this.AcceptedProcess.Id;
990     this.FreezeResultsUpdate();
991     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
992     {
993     lstPatchList.FreezeItem(lstPatchList.SelectedIndices[i]);
994     }
995     // force thaw and update
996     this.ThawResultsUpdate();
997     this.Update();
998     }
999     catch (Exception ex)
1000     {
1001     Debug.WriteLine(ex.ToString());
1002     }
1003     }
1004    
1005     private void mnuItemThawSelectedPatches_Click(object sender, EventArgs e)
1006     {
1007     if (!(lstPatchList.SelectedItems.Count > 0)) return;
1008     //if (SearchArgs == null) return;
1009     try
1010     {
1011     lstPatchList.ProcessID = this.AcceptedProcess.Id;
1012     this.FreezeResultsUpdate();
1013     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
1014     {
1015     lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
1016     }
1017     // force thaw and update
1018     this.ThawResultsUpdate();
1019     this.Update();
1020     }
1021     catch (Exception ex)
1022     {
1023     Debug.WriteLine(ex.ToString());
1024     }
1025     }
1026 william 408 private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1027     {
1028     SearchDataTypes sdt = SearchArgs.DataType;
1029     bool unsigned = SearchArgs.IsUnsignedDataType;
1030     int Last_Whole_Percent_Done = 0;
1031     uint CurrentIndex = e.CurrentIndex;
1032     if (e.UserState != null)
1033     {
1034     SearchResultWriter writer = (e.UserState as SearchResultWriter);
1035     if (writer == null)
1036     throw new InvalidOperationException("writer cannot be null");
1037     using (MemoryStream ms = new MemoryStream(e.Data))
1038     {
1039     using (BinaryReader br = new BinaryReader(ms))
1040     {
1041     while (br.BaseStream.Position < br.BaseStream.Length)
1042     {
1043     try
1044     {
1045     switch (sdt)
1046     {
1047     case SearchDataTypes._8bits:
1048     if (unsigned) { writer.WriteResult<Byte>((uint)br.BaseStream.Position, br.ReadByte()); }
1049     else { writer.WriteResult<SByte>((uint)br.BaseStream.Position, br.ReadSByte()); } break;
1050     case SearchDataTypes._16bits:
1051     if (unsigned) { writer.WriteResult<UInt16>((uint)br.BaseStream.Position, br.ReadUInt16()); }
1052     else { writer.WriteResult<Int16>((uint)br.BaseStream.Position, br.ReadInt16()); } break;
1053     case SearchDataTypes._32bits:
1054     if (unsigned) { writer.WriteResult<UInt32>((uint)br.BaseStream.Position, br.ReadUInt32()); }
1055     else { writer.WriteResult<Int32>((uint)br.BaseStream.Position, br.ReadInt32()); } break;
1056     case SearchDataTypes._64bits:
1057     if (unsigned) { writer.WriteResult<UInt64>((uint)br.BaseStream.Position, br.ReadUInt64()); }
1058     else { writer.WriteResult<Int64>((uint)br.BaseStream.Position, br.ReadInt64()); } break;
1059     }
1060     }
1061     catch (EndOfStreamException) { }
1062     double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1063     int int_percent_done = (int)double_percent_done;
1064     if (int_percent_done != Last_Whole_Percent_Done && (((double)Last_Whole_Percent_Done / 2.0) == (int)((double)Last_Whole_Percent_Done / 2.0)))
1065     {
1066     if (int_percent_done <= 100)
1067     {
1068     resultsprogress.Value = int_percent_done;
1069     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart));
1070     Last_Whole_Percent_Done = int_percent_done;
1071     }
1072     }
1073     CurrentIndex++;
1074     }
1075    
1076     }
1077     }
1078     }
1079     }
1080 william 230 private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)
1081     {
1082 william 286 Stopwatch st = new Stopwatch();
1083     st.Start();
1084 william 392
1085     Stopwatch st_first_search = new Stopwatch();
1086     Stopwatch st_nonrange_search = new Stopwatch();
1087     Stopwatch st_ranged_search = new Stopwatch();
1088    
1089 william 286 e.Result = st;
1090 william 280 //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
1091     List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();
1092 william 402 //const int ElementsBeforeDisplay = 100;
1093 william 280 SearchArgs.LogSearchOptions();
1094 william 398 uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
1095 william 399
1096     bool unsigned = SearchArgs.IsUnsignedDataType;
1097     SearchDataTypes sdt = SearchArgs.DataType;
1098 william 408 //byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G
1099     logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", MemoryRangeSize - MemoryRangeStart));
1100     resultsprogress.Value = 0;
1101     resultsprogress.Message = string.Format("Search is Warming Up...Please Wait...");
1102    
1103     Stopwatch provider_st = new Stopwatch();
1104     provider_st.Start();
1105 william 398 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1106     {
1107     provider.OpenProvider();
1108 william 408 int count = (int)(MemoryRangeSize - MemoryRangeStart) / (int)STEP_SIZE;
1109     SearchResultWriter writer = new SearchResultWriter(count);
1110     provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);
1111     provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);
1112 william 398 provider.CloseProvider();
1113 william 408 writer.Dispose();
1114 william 398 }
1115 william 408 provider_st.Stop();
1116     logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);
1117     //if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }
1118     int Last_Whole_Percent_Done = 0;
1119    
1120     #region First Search
1121     //if (SearchArgs.IsFirstSearch)
1122     //{
1123     // st_first_search.Start();
1124     // //SearchArgs.Results.Clear();
1125     // r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
1126     // int count = (int)buffered_mem.Length / (int)STEP_SIZE;
1127     // #region using (SearchResultWriter writer = new SearchResultWriter(count))
1128     // using (SearchResultWriter writer = new SearchResultWriter(count))
1129     // {
1130     // //List<ResultType<object>> results_list = new List<ResultType<object>>();
1131     // //for (uint i = 0; i < buffered_mem.Length; i += STEP_SIZE)
1132     // //{
1133     // #region while (r_ms.BaseStream.Position < r_ms.BaseStream.Length)
1134     // while (r_ms.BaseStream.Position < r_ms.BaseStream.Length)
1135     // {
1136     // //using (ResultType<object> _tmp_result = new ResultType<object>())
1137     // //{
1138     // try
1139     // {
1140     // switch (sdt)
1141     // {
1142     // case SearchDataTypes._8bits:
1143     // if (unsigned) { writer.WriteResult<Byte>((uint)r_ms.BaseStream.Position, r_ms.ReadByte()); }
1144     // else { writer.WriteResult<SByte>((uint)r_ms.BaseStream.Position, r_ms.ReadSByte()); } break;
1145     // case SearchDataTypes._16bits:
1146     // if (unsigned) { writer.WriteResult<UInt16>((uint)r_ms.BaseStream.Position, r_ms.ReadUInt16()); }
1147     // else { writer.WriteResult<Int16>((uint)r_ms.BaseStream.Position, r_ms.ReadInt16()); } break;
1148     // case SearchDataTypes._32bits:
1149     // if (unsigned) { writer.WriteResult<UInt32>((uint)r_ms.BaseStream.Position, r_ms.ReadUInt32()); }
1150     // else { writer.WriteResult<Int32>((uint)r_ms.BaseStream.Position, r_ms.ReadInt32()); } break;
1151     // case SearchDataTypes._64bits:
1152     // if (unsigned) { writer.WriteResult<UInt64>((uint)r_ms.BaseStream.Position, r_ms.ReadUInt64()); }
1153     // else { writer.WriteResult<Int64>((uint)r_ms.BaseStream.Position, r_ms.ReadInt64()); } break;
1154     // }
1155     // }
1156     // catch (EndOfStreamException)
1157     // {
1158     // //logger.VerboseError.WriteLine(ex.ToString());
1159     // break;
1160     // }
1161     // //results_list.Add(_tmp_result);
1162     // //SearchArgs.Results.Add(_tmp_result);
1163     // double double_percent_done = 100.0 * (double)((double)r_ms.BaseStream.Position / (double)r_ms.BaseStream.Length);
1164     // int int_percent_done = (int)double_percent_done;
1165     // if (int_percent_done != Last_Whole_Percent_Done)
1166     // {
1167     // if (int_percent_done <= 100)
1168     // {
1169     // resultsprogress.Value = int_percent_done;
1170     // resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", (r_ms.BaseStream.Position + MemoryRangeStart));
1171     // Last_Whole_Percent_Done = int_percent_done;
1172     // }
1173     // }
1174     // }
1175     // if (SearchWorkerThread.CancellationPending == true)
1176     // {
1177     // e.Cancel = true;
1178     // return;
1179     // }
1180     // #endregion
1181     // }
1182     // #endregion
1183     // //}
1184     // //SearchArgs.Results.AddRange(results_list);
1185     // //results_list = null;
1186     // resultsprogress.Value = 100;
1187     // resultsprogress.Message = "";
1188     // //Application.DoEvents();
1189     // st_first_search.Stop();
1190     // logger.Profiler.WriteLine("First search took a total of {0} seconds to complete.", st_first_search.Elapsed.TotalSeconds);
1191     // Last_Whole_Percent_Done = 0;
1192     //}
1193     #endregion
1194    
1195     #region Subsequent Searches
1196     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
1197    
1198    
1199     // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
1200     bool NeedToCompare = true;
1201     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
1202     SearchArgs.CompareType == SearchCompareTypes.Equal &&
1203     SearchArgs.IsFirstSearch)
1204 william 280 {
1205 william 408 NeedToCompare = false;
1206     //second_tmp_Results = null; // Free Memory
1207     }
1208    
1209     if (NeedToCompare)
1210     {
1211     if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)
1212 william 280 {
1213 william 408 #region Non-Range Searches
1214     st_nonrange_search.Start();
1215     //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
1216     ////second_tmp_Results.c
1217 william 409 try
1218 william 280 {
1219 william 409 using (SearchResultReader reader = new SearchResultReader())
1220 william 398 {
1221 william 409 for (int i = 0; i < reader.ResultCount; i += 1)
1222 william 398 {
1223 william 409 object result_value = 0;
1224     uint address = 0;
1225     #region switch (SearchArgs.DataType)
1226     switch (SearchArgs.DataType)
1227 william 398 {
1228 william 409 case SearchDataTypes._8bits: if (unsigned)
1229 william 403 {
1230 william 409 using (ResultType<byte> result = reader.GetNextResult<byte>())
1231     {
1232     address = result.Address;
1233     result_value = result.Value;
1234     }
1235 william 403 }
1236 william 408 else
1237     {
1238 william 409 using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())
1239     {
1240     address = result.Address;
1241     result_value = result.Value;
1242     }
1243     } break;
1244     case SearchDataTypes._16bits: if (unsigned)
1245 william 408 {
1246 william 409 using (ResultType<ushort> result = reader.GetNextResult<ushort>())
1247     {
1248     address = result.Address;
1249     result_value = result.Value;
1250     }
1251 william 408 }
1252     else
1253     {
1254 william 409 using (ResultType<short> result = reader.GetNextResult<short>())
1255     {
1256     address = result.Address;
1257     result_value = result.Value;
1258     }
1259     } break;
1260     case SearchDataTypes._32bits: if (unsigned)
1261 william 408 {
1262 william 409 using (ResultType<uint> result = reader.GetNextResult<uint>())
1263     {
1264     address = result.Address;
1265     result_value = result.Value;
1266     }
1267 william 408 }
1268     else
1269     {
1270 william 409 using (ResultType<int> result = reader.GetNextResult<int>())
1271     {
1272     address = result.Address;
1273     result_value = result.Value;
1274     }
1275     } break;
1276     case SearchDataTypes._64bits: if (unsigned)
1277 william 408 {
1278 william 409 using (ResultType<ulong> result = reader.GetNextResult<ulong>())
1279     {
1280     address = result.Address;
1281     result_value = result.Value;
1282     }
1283 william 408 }
1284     else
1285     {
1286 william 409 using (ResultType<long> result = reader.GetNextResult<long>())
1287     {
1288     address = result.Address;
1289     result_value = result.Value;
1290     }
1291     } break;
1292     }
1293 william 408 #endregion
1294 william 409 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1295     try
1296     {
1297     //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1298     }
1299     catch (Exception)
1300     {
1301     throw;
1302     }
1303     switch (SearchArgs.DataType)
1304     {
1305     #region Comparer Support
1306     #region case SearchDataTypes._8bits:
1307     case SearchDataTypes._8bits:
1308     if (SearchArgs.IsUnsignedDataType)
1309 william 405 {
1310 william 409 byte lookup_value = 0;
1311     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1312     _8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address);
1313     byte value = 0;
1314     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1315     {
1316     value = Convert.ToByte(result_value);
1317     comparer.Value = value;
1318     }
1319     else
1320     {
1321     value = Convert.ToByte(SearchArgs.CompareStartValue);
1322     comparer.Value = value;
1323     }
1324     if (comparer.Compare(lookup_value, value))
1325     {
1326     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1327     {
1328     second_tmp_Results.Add(_tmp_result);
1329     }
1330     }
1331     comparer = null; // free memory
1332 william 405 }
1333 william 408 else
1334     {
1335 william 409 sbyte lookup_value = 0;
1336     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1337     _8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address);
1338     sbyte value = 0;
1339     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1340     {
1341     value = Convert.ToSByte(result_value);
1342     }
1343     else
1344     {
1345     value = Convert.ToSByte(SearchArgs.CompareStartValue);
1346     }
1347     if (comparer.Compare(lookup_value, value))
1348     {
1349     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1350     {
1351     second_tmp_Results.Add(_tmp_result);
1352     }
1353     }
1354     comparer = null; // free memory
1355 william 408 }
1356 william 409 break;
1357     #endregion
1358     #region case SearchDataTypes._16bits:
1359     case SearchDataTypes._16bits:
1360     if (SearchArgs.IsUnsignedDataType)
1361 william 408 {
1362 william 409 ushort lookup_value = 0;
1363     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1364     _16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address);
1365     ushort value = 0;
1366     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1367     {
1368     value = Convert.ToUInt16(result_value);
1369     comparer.Value = value;
1370     }
1371     else
1372     {
1373     value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1374     comparer.Value = value;
1375     }
1376     if (comparer.Compare(lookup_value, value))
1377     {
1378     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1379     {
1380     second_tmp_Results.Add(_tmp_result);
1381     }
1382     }
1383     comparer = null; // free memory
1384 william 408 }
1385     else
1386     {
1387 william 409 short lookup_value = 0;
1388     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1389     _16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address);
1390     short value = 0;
1391     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1392     {
1393     value = Convert.ToInt16(result_value);
1394     }
1395     else
1396     {
1397     value = Convert.ToInt16(SearchArgs.CompareStartValue);
1398     }
1399     if (comparer.Compare(lookup_value, value))
1400     {
1401     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1402     {
1403     second_tmp_Results.Add(_tmp_result);
1404     }
1405     }
1406     comparer = null; // free memory
1407 william 408 }
1408 william 409 break;
1409     #endregion
1410     #region case SearchDataTypes._32bits:
1411     case SearchDataTypes._32bits:
1412     if (SearchArgs.IsUnsignedDataType)
1413 william 408 {
1414 william 409 uint lookup_value = 0;
1415     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1416     {
1417     try
1418     {
1419     gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider();
1420     }
1421     catch (Exception ex)
1422     {
1423     throw;
1424     }
1425     }
1426     _32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address);
1427     uint value = 0;
1428     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1429     {
1430     value = Convert.ToUInt32(result_value);
1431     comparer.Value = value;
1432     }
1433     else
1434     {
1435     value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1436     comparer.Value = value;
1437     }
1438     if (comparer.Compare(lookup_value, value))
1439     {
1440     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1441     {
1442     second_tmp_Results.Add(_tmp_result);
1443     }
1444     }
1445     comparer = null; // free memory
1446 william 402 }
1447 william 408 else
1448     {
1449 william 409 int lookup_value = 0;
1450     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1451     _32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address);
1452     int value = 0;
1453     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1454     {
1455     value = Convert.ToInt32(result_value);
1456     }
1457     else
1458     {
1459     value = Convert.ToInt32(SearchArgs.CompareStartValue);
1460     }
1461     if (comparer.Compare(lookup_value, value))
1462     {
1463     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1464     {
1465     second_tmp_Results.Add(_tmp_result);
1466     }
1467     }
1468     comparer = null; // free memory
1469 william 408 }
1470 william 409 break;
1471     #endregion
1472     #region case SearchDataTypes._64bits:
1473     case SearchDataTypes._64bits:
1474     if (SearchArgs.IsUnsignedDataType)
1475 william 408 {
1476 william 409 ulong lookup_value = 0;
1477     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1478     _64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address);
1479     ulong value = 0;
1480     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1481     {
1482     value = Convert.ToUInt64(result_value);
1483     comparer.Value = value;
1484     }
1485     else
1486     {
1487     value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1488     comparer.Value = value;
1489     }
1490     if (comparer.Compare(lookup_value, value))
1491     {
1492     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1493     {
1494     second_tmp_Results.Add(_tmp_result);
1495     }
1496     }
1497     comparer = null; // free memory
1498 william 402 }
1499 william 408 else
1500     {
1501 william 409 long lookup_value = 0;
1502     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1503     _64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address);
1504     long value = 0;
1505     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1506     {
1507     value = Convert.ToInt64(result_value);
1508     }
1509     else
1510     {
1511     value = Convert.ToInt64(SearchArgs.CompareStartValue);
1512     }
1513     if (comparer.Compare(lookup_value, value))
1514     {
1515     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1516     {
1517     second_tmp_Results.Add(_tmp_result);
1518     }
1519     }
1520     comparer = null; // free memory
1521 william 408 }
1522 william 409 break;
1523     #endregion
1524     #endregion
1525     }
1526     double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1527     int int_percent_done = (int)double_percent_done;
1528     if (int_percent_done != Last_Whole_Percent_Done && i % 100000 == 0)
1529     {
1530     if (int_percent_done <= 100)
1531     {
1532     resultsprogress.Value = int_percent_done;
1533     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1534     Last_Whole_Percent_Done = int_percent_done;
1535     if (int_percent_done == 11)
1536 william 408 {
1537 william 409 int local_k = 0;
1538 william 408 }
1539 william 402 }
1540 william 280 }
1541 william 398 }
1542 william 280 }
1543     }
1544 william 409 catch (Exception ex)
1545     {
1546     throw;
1547     }
1548 william 408 st_nonrange_search.Stop();
1549     logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);
1550     Last_Whole_Percent_Done = 0;
1551 william 280 #endregion
1552 william 408 }
1553     #region Ranged Searches
1554     #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT
1555     if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1556     {
1557     st_ranged_search.Start();
1558     object start, end;
1559    
1560     start = SearchArgs.CompareStartValue;
1561     end = SearchArgs.CompareEndValue;
1562     using (SearchResultReader reader = new SearchResultReader())
1563 william 280 {
1564 william 408 for (int i = 0; i < reader.ResultCount; i += 1)
1565 william 402 {
1566 william 409 uint address = 0;
1567     #region switch (SearchArgs.DataType)
1568     switch (SearchArgs.DataType)
1569     {
1570     case SearchDataTypes._8bits: if (unsigned) { using (ResultType<byte> result = reader.GetNextResult<byte>()) { address = result.Address; } }
1571     else { using (ResultType<sbyte> result = reader.GetNextResult<sbyte>()) { address = result.Address; } } break;
1572     case SearchDataTypes._16bits: if (unsigned) { using (ResultType<ushort> result = reader.GetNextResult<ushort>()) { address = result.Address; } }
1573     else { using (ResultType<short> result = reader.GetNextResult<short>()) { address = result.Address; } } break;
1574     case SearchDataTypes._32bits: if (unsigned) { using (ResultType<uint> result = reader.GetNextResult<uint>()) { address = result.Address; } }
1575     else { using (ResultType<int> result = reader.GetNextResult<int>()) { address = result.Address; } } break;
1576     case SearchDataTypes._64bits: if (unsigned) { using (ResultType<ulong> result = reader.GetNextResult<ulong>()) { address = result.Address; } }
1577     else { using (ResultType<long> result = reader.GetNextResult<long>()) { address = result.Address; } } break;
1578     }
1579     #endregion
1580    
1581 william 408 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1582     //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1583     if (SearchArgs.CompareType == SearchCompareTypes.Between)
1584 william 402 {
1585 william 408 InRangeComparer comparer = new InRangeComparer(address, 0);
1586     if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
1587 william 402 {
1588 william 409 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1589     {
1590     second_tmp_Results.Add(_tmp_result);
1591     }
1592 william 402 }
1593 william 408 comparer = null;
1594 william 402 }
1595 william 408 else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1596     {
1597     NotInRangeComparer comparer = new NotInRangeComparer(address, 0);
1598     if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
1599     {
1600 william 409 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1601     {
1602     second_tmp_Results.Add(_tmp_result);
1603     }
1604 william 408 }
1605     comparer = null;
1606     }
1607     else
1608     {
1609     throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
1610     }
1611     double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1612     int int_percent_done = (int)double_percent_done;
1613     if (int_percent_done != Last_Whole_Percent_Done)
1614     {
1615     if (int_percent_done <= 100)
1616     {
1617     resultsprogress.Value = int_percent_done;
1618     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1619     Last_Whole_Percent_Done = int_percent_done;
1620     }
1621 william 409 if (int_percent_done == 11)
1622     {
1623     int local_k = 0;
1624     }
1625 william 408 }
1626     }
1627 william 280 }
1628 william 408 st_ranged_search.Stop();
1629     logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);
1630     }
1631     #endif
1632     #endregion
1633 william 398
1634 william 408 }
1635     #endregion
1636     // leave SearchArgs.Results alone, if false
1637     if (NeedToCompare)
1638     {
1639     // fix addresses when memory start is not zero
1640     if (MemoryRangeStart > 0 && SearchArgs.IsFirstSearch) { for (int i = 0; i < second_tmp_Results.Count; i++) { second_tmp_Results[i].Address = second_tmp_Results[i].Address + MemoryRangeStart; } }
1641     using (SearchResultWriter writer = new SearchResultWriter(second_tmp_Results.Count))
1642     {
1643     for (int i = 0; i < second_tmp_Results.Count; i++)
1644     {
1645     switch (sdt)
1646     {
1647     case SearchDataTypes._8bits:
1648     if (unsigned) { writer.WriteResult<Byte>(second_tmp_Results[i].Address, Convert.ToByte(second_tmp_Results[i].Value)); }
1649     else { writer.WriteResult<SByte>(second_tmp_Results[i].Address, Convert.ToSByte(second_tmp_Results[i].Value)); } break;
1650     case SearchDataTypes._16bits:
1651     if (unsigned) { writer.WriteResult<UInt16>(second_tmp_Results[i].Address, Convert.ToUInt16(second_tmp_Results[i].Value)); }
1652     else { writer.WriteResult<Int16>(second_tmp_Results[i].Address, Convert.ToInt16(second_tmp_Results[i].Value)); } break;
1653     case SearchDataTypes._32bits:
1654     if (unsigned) { writer.WriteResult<UInt32>(second_tmp_Results[i].Address, Convert.ToUInt32(second_tmp_Results[i].Value)); }
1655     else { writer.WriteResult<Int32>(second_tmp_Results[i].Address, Convert.ToInt32(second_tmp_Results[i].Value)); } break;
1656     case SearchDataTypes._64bits:
1657     if (unsigned) { writer.WriteResult<UInt64>(second_tmp_Results[i].Address, Convert.ToUInt64(second_tmp_Results[i].Value)); }
1658     else { writer.WriteResult<Int64>(second_tmp_Results[i].Address, Convert.ToInt64(second_tmp_Results[i].Value)); } break;
1659     }
1660     }
1661 william 280 }
1662 william 408 second_tmp_Results = null; // free memory
1663 william 280 }
1664 william 230 }
1665    
1666 william 408
1667    
1668 william 230 private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)
1669     {
1670 william 280 //if (SearchArgs.ProgressLogger != null)
1671     //{
1672     // resultsprogress.Value = e.ProgressPercentage;
1673     // //Application.DoEvents();
1674     //}
1675 william 230 }
1676    
1677     private void SearchWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
1678     {
1679 william 286 if (!e.Cancelled)
1680     {
1681     Stopwatch st = (e.Result as Stopwatch);
1682     st.Stop();
1683 william 392 logger.Profiler.WriteLine("Search took {0} seconds, overall, to complete.", st.Elapsed.TotalSeconds);
1684 william 286 }
1685    
1686 william 280 resultsprogress.Value = 100;
1687 william 409 bool unsigned = SearchArgs.IsUnsignedDataType;
1688 william 402 using (SearchResultReader reader = new SearchResultReader())
1689     {
1690 william 280
1691 william 409 object result_value = 0;
1692     uint address = 0;
1693     switch (SearchArgs.DataType)
1694     {
1695     case SearchDataTypes._8bits: if (unsigned)
1696     {
1697     using (ResultType<byte> result = reader.GetNextResult<byte>())
1698     {
1699     address = result.Address;
1700     result_value = result.Value;
1701     }
1702     }
1703     else
1704     {
1705     using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())
1706     {
1707     address = result.Address;
1708     result_value = result.Value;
1709     }
1710     } break;
1711     case SearchDataTypes._16bits: if (unsigned)
1712     {
1713     using (ResultType<ushort> result = reader.GetNextResult<ushort>())
1714     {
1715     address = result.Address;
1716     result_value = result.Value;
1717     }
1718     }
1719     else
1720     {
1721     using (ResultType<short> result = reader.GetNextResult<short>())
1722     {
1723     address = result.Address;
1724     result_value = result.Value;
1725     }
1726     } break;
1727     case SearchDataTypes._32bits: if (unsigned)
1728     {
1729     using (ResultType<uint> result = reader.GetNextResult<uint>())
1730     {
1731     address = result.Address;
1732     result_value = result.Value;
1733     }
1734     }
1735     else
1736     {
1737     using (ResultType<int> result = reader.GetNextResult<int>())
1738     {
1739     address = result.Address;
1740     result_value = result.Value;
1741     }
1742     } break;
1743     case SearchDataTypes._64bits: if (unsigned)
1744     {
1745     using (ResultType<ulong> result = reader.GetNextResult<ulong>())
1746     {
1747     address = result.Address;
1748     result_value = result.Value;
1749     }
1750     }
1751     else
1752     {
1753     using (ResultType<long> result = reader.GetNextResult<long>())
1754     {
1755     address = result.Address;
1756     result_value = result.Value;
1757     }
1758     } break;
1759     }
1760    
1761    
1762    
1763 william 402 logger.Debug.WriteLine(string.Format("Results Count -> 0x{0:x8}", reader.ResultCount));
1764 william 280
1765 william 402
1766     if (reader.ResultCount == 1) // debug message for 1 result using 32bit unsigned
1767 william 409 logger.Debug.WriteLine(string.Format("Debug: Found 1 result -> Address: 0x{0:x8} Value: 0x{1:x16}", address, result_value));
1768 william 402
1769     logger.Info.WriteLine(string.Format("Found 0x{0:x8} results", reader.ResultCount));
1770    
1771     if (reader.ResultCount <= MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY)
1772 william 280 {
1773 william 402 lstResults.Items.Clear();
1774     List<ResultItem> items = new List<ResultItem>();
1775     for (int i = 0; i < reader.ResultCount; i++)
1776 william 280 {
1777 william 402 ResultItem item = new ResultItem(0, false);
1778     //item.Text = string.Format("0x{0:x8}", SearchArgs.Results[i].Address);
1779     //item.SubItems.Add(string.Format("0x{0:x8}", SearchArgs.Results[i].Address));
1780     switch (SearchArgs.DataType)
1781     {
1782 william 280
1783 william 402 case SearchDataTypes._8bits:
1784 william 409 if (SearchArgs.IsUnsignedDataType) { ResultType<byte> result = reader.GetNextResult<byte>(); item = new ResultItem(result.Address, false, result.Value); }
1785     else { ResultType<sbyte> result = reader.GetNextResult<sbyte>(); item = new ResultItem(result.Address, false, result.Value); }
1786 william 402 break;
1787     case SearchDataTypes._16bits:
1788 william 409 if (SearchArgs.IsUnsignedDataType) { ResultType<ushort> result = reader.GetNextResult<ushort>(); item = new ResultItem(result.Address, false, result.Value); }
1789     else { ResultType<short> result = reader.GetNextResult<short>(); item = new ResultItem(result.Address, false, result.Value); }
1790 william 402 break;
1791     case SearchDataTypes._32bits:
1792 william 409 if (SearchArgs.IsUnsignedDataType) { ResultType<uint> result = reader.GetNextResult<uint>(); item = new ResultItem(result.Address, false, result.Value); }
1793     else { ResultType<int> result = reader.GetNextResult<int>(); item = new ResultItem(result.Address, false, result.Value); }
1794 william 402 break;
1795     case SearchDataTypes._64bits:
1796 william 409 if (SearchArgs.IsUnsignedDataType) { ResultType<ulong> result = reader.GetNextResult<ulong>(); item = new ResultItem(result.Address, false, result.Value); }
1797     else { ResultType<long> result = reader.GetNextResult<long>(); item = new ResultItem(result.Address, false, result.Value); }
1798 william 402 break;
1799     }
1800    
1801     if (!items.Contains(item))
1802     items.Add(item);
1803 william 280 }
1804 william 402 lstResults.Items.AddRange(items.ToArray());
1805 william 280 }
1806     }
1807    
1808     this.DoSearchDoneSpecific();
1809     //System.Threading.Thread.Sleep(100);
1810     //if (_SEARCH_MODE != SearchMode.SEARCH_MODE_NORMAL_WITH_JOKER)
1811     this.ThawResultsUpdate();
1812     Application.DoEvents();
1813 william 230 }
1814 william 280 private void DoSearchDoneSpecific()
1815     {
1816     SearchWorkerThread.CancelAsync();
1817     if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
1818     else { timer_update_results.Enabled = false; }
1819 william 230
1820 william 280 search_progress_updater.Enabled = false;
1821    
1822     btnCancel.Enabled = false;
1823     btnReset.Enabled = true;
1824     btnSearch.Enabled = true;
1825     grpCompareType.Enabled = true;
1826     grpCompareValue.Enabled = true;
1827     resultsprogress.Value = 0;
1828     resultsprogress.Message = "";
1829     grpDataType.Enabled = false;
1830     // resume process on reset, incase it was suspended
1831     ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
1832     //Application.DoEvents();
1833     this.Refresh();
1834     }
1835    
1836     private void DoCancelSpecific()
1837     {
1838     this.DoSearchDoneSpecific();
1839     }
1840     private void DoResetSpecific()
1841     {
1842     this.DoCancelSpecific();
1843     IsFirstSearch = true;
1844     grpDataType.Enabled = true;
1845     }
1846 william 230 private void search_progress_updater_Tick(object sender, EventArgs e)
1847     {
1848     if ((this.AcceptedProcess ==null) || Process.GetProcessById(this.AcceptedProcess.Id) == null)
1849     {
1850     SearchWorkerThread.CancelAsync();
1851     //JokerSearchWorker.CancelAsync();
1852     ResultsUpdateWorkerThread.CancelAsync();
1853     }
1854     }
1855    
1856 william 280 #region Search Button
1857 william 230 private void btnSearch_Click(object sender, EventArgs e)
1858     {
1859 william 271 this.SearchInProgess = true;
1860 william 280 //btnCancel.Enabled = true;
1861     //btnReset.Enabled = false;
1862     //btnSearch.Enabled = false;
1863     this.FreezeResultsUpdate();
1864     this.handle_btnSearch_Click();
1865     }
1866     private void handle_btnSearch_Click()
1867     {
1868     //this.FreezeResultsUpdate();
1869     lstResults.Items.Clear();
1870    
1871     if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
1872     else { timer_update_results.Enabled = false; }
1873    
1874    
1875     resultsprogress.Value = 0;
1876     bool _is_unsigned = chkUnsigned.Checked;
1877     SearchType search_type = new SearchType();
1878     SearchDataTypes _data_type = new SearchDataTypes();
1879     SearchCompareTypes _compare_type = new SearchCompareTypes();
1880     CompareValueTypes _compare_value_type = new CompareValueTypes();
1881     object start_value = 0;
1882     object end_value = 0;
1883     // get datatype
1884     if (radio_8bits.Checked) { _data_type = SearchDataTypes._8bits; }
1885     else if (radio_16bits.Checked) { _data_type = SearchDataTypes._16bits; }
1886     else if (radio_32bits.Checked) { _data_type = SearchDataTypes._32bits; }
1887     else if (radio_64bits.Checked) { _data_type = SearchDataTypes._64bits; }
1888     else { logger.Error.WriteLine("Could not determine search data type bit size. (was not 8/16/32/or 64bits)"); }
1889     // get compare type
1890     if (radiocompare_equal.Checked) { _compare_type = SearchCompareTypes.Equal; }
1891     else if (radiocompare_greaterthan.Checked) { _compare_type = SearchCompareTypes.GreaterThan; }
1892     else if (radiocompare_lessthan.Checked) { _compare_type = SearchCompareTypes.LessThan; }
1893     else if (radiocompare_greaterthan_orequal.Checked) { _compare_type = SearchCompareTypes.GreaterThanOrEqual; }
1894     else if (radiocompare_lessthan_orequal.Checked) { _compare_type = SearchCompareTypes.LessThanOrEqual; }
1895     else if (radiocompare_notequal.Checked) { _compare_type = SearchCompareTypes.NotEqual; }
1896     else if (radiocompare_between.Checked) { _compare_type = SearchCompareTypes.Between; }
1897     else if (radiocompare_notbetween.Checked) { _compare_type = SearchCompareTypes.NotBetween; }
1898     else { logger.Error.WriteLine("Could not determine search comparison type. (was not == > < >= <= != <> or !<>)"); }
1899     // get compare valure type
1900     if (radio_oldvalue.Checked) { _compare_value_type = CompareValueTypes.OldValue; }
1901     else if (radio_specificvalue.Checked) { _compare_value_type = CompareValueTypes.SpecificValue; }
1902     else { logger.Error.WriteLine("Could not determine search comparison type. (was not old or specific value"); }
1903    
1904     if (_compare_value_type == CompareValueTypes.SpecificValue || (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween))
1905     {
1906    
1907     switch (_data_type)
1908     {
1909     case SearchDataTypes._8bits:
1910     if (_is_unsigned) { start_value = txtStartAddr.ToByte(); }
1911     else { start_value = txtStartAddr.ToSByte(); }
1912     break;
1913     case SearchDataTypes._16bits:
1914     if (_is_unsigned) { start_value = txtStartAddr.ToUInt16(); }
1915     else { start_value = txtStartAddr.ToInt16(); }
1916     break;
1917     case SearchDataTypes._32bits:
1918     if (_is_unsigned) { start_value = txtStartAddr.ToUInt32(); }
1919     else { start_value = txtStartAddr.ToInt32(); }
1920     break;
1921     case SearchDataTypes._64bits:
1922     if (_is_unsigned) { start_value = txtStartAddr.ToUInt64(); }
1923     else { start_value = txtStartAddr.ToInt64(); }
1924     break;
1925     default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
1926     }
1927     }
1928     if (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween)
1929     {
1930     switch (_data_type)
1931     {
1932     case SearchDataTypes._8bits:
1933     if (_is_unsigned) { end_value = txtEndAddr.ToByte(); }
1934     else { end_value = txtEndAddr.ToSByte(); }
1935     break;
1936     case SearchDataTypes._16bits:
1937     if (_is_unsigned) { end_value = txtEndAddr.ToUInt16(); }
1938     else { end_value = txtEndAddr.ToInt16(); }
1939     break;
1940     case SearchDataTypes._32bits:
1941     if (_is_unsigned) { end_value = txtEndAddr.ToUInt32(); }
1942     else { end_value = txtEndAddr.ToInt32(); }
1943     break;
1944     case SearchDataTypes._64bits:
1945     if (_is_unsigned) { end_value = txtEndAddr.ToUInt64(); }
1946     else { end_value = txtEndAddr.ToInt64(); }
1947     break;
1948     default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
1949     }
1950     }
1951    
1952     search_type = new SearchType(_data_type, _is_unsigned, _compare_type, _compare_value_type, start_value, end_value, resultsprogress);
1953    
1954     //search_type.LogSearchOptions();
1955    
1956     search_type.IsFirstSearch = IsFirstSearch;
1957    
1958    
1959    
1960     DoSearch(search_type);
1961     IsFirstSearch = false;
1962     }
1963     private void DoSearch(SearchType args)
1964     {
1965     if (!args.IsFirstSearch && SearchArgs != null)
1966     {
1967     //args.Results.AddRange(SearchArgs.Results.ToArray());
1968 william 402 //args.Results = SearchArgs.Results;
1969 william 280 }
1970     SearchArgs = args;
1971     #if DONOT_HAVE_RANGED_SEARCH_SUPPORT
1972     if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1973     {
1974     throw new NotImplementedException("Between and Not Between Range searches have not been implemented.");
1975     }
1976     #endif
1977     search_progress_updater.Enabled = true;
1978     //padPluginSelector.Enabled = false;
1979     //gsPluginSelector.Enabled = false;
1980 william 271 btnReset.Enabled = false;
1981     btnSearch.Enabled = false;
1982 william 280 btnCancel.Enabled = true;
1983     grpDataType.Enabled = false;
1984     grpCompareType.Enabled = false;
1985     grpCompareValue.Enabled = false;
1986     this.Refresh();
1987     Application.DoEvents();
1988     SearchWorkerThread.RunWorkerAsync();
1989 william 230 }
1990 william 280 #endregion
1991 william 271 private void btnReset_Click(object sender, EventArgs e)
1992     {
1993     this.SearchInProgess = false;
1994 william 280 //btnSearch.Enabled = true;
1995     //btnCancel.Enabled = false;
1996     this.DoResetSpecific();
1997     lstResults.Items.Clear();
1998 william 402 //try { SearchArgs.Results = new List<ResultType<object>>(); }
1999     //catch { }
2000 william 271 }
2001    
2002     private void btnCancel_Click(object sender, EventArgs e)
2003     {
2004     this.SearchInProgess = false;
2005 william 280 //btnCancel.Enabled = false;
2006     //btnSearch.Enabled = true;
2007     //btnReset.Enabled = true;
2008     this.DoCancelSpecific();
2009 william 271 }
2010 william 275
2011     private void mnuItemPatchListViewMemoryRegion_Click(object sender, EventArgs e)
2012     {
2013     List<ResultDataType> patch_list = new List<ResultDataType>();
2014     List<int> SelectedIndexes = new List<int>();
2015     foreach (int index in lstPatchList.SelectedIndices) { SelectedIndexes.Add(index); }
2016     foreach (int index in SelectedIndexes)
2017     {
2018     ListViewItem item = lstPatchList.Items[index];
2019     ResultDataType rdt = (ResultDataType)item.Tag;
2020     ViewMemoryRegion(rdt);
2021     break; // only get the fist item
2022     }
2023     }
2024    
2025     private void mnuItemResultsListViewMemoryRegion_Click(object sender, EventArgs e)
2026     {
2027     List<ResultDataType> patch_list = new List<ResultDataType>();
2028     List<int> SelectedIndexes = new List<int>();
2029     foreach (int index in lstResults.SelectedIndices) { SelectedIndexes.Add(index); }
2030     foreach (int index in SelectedIndexes)
2031     {
2032     ListViewItem item = lstResults.Items[index];
2033     ResultDataType rdt = (ResultDataType)item.Tag;
2034     ViewMemoryRegion(rdt);
2035     break; // only get the fist item
2036     }
2037     }
2038     private void ViewMemoryRegion(ResultDataType rdt)
2039     {
2040     if (OnBrowseMemoryRegion != null)
2041 william 323 OnBrowseMemoryRegion(new BrowseMemoryRegionEvent(this, rdt.Address));
2042 william 275 }
2043 william 277
2044     private void mnuAddedResults_Opening(object sender, CancelEventArgs e)
2045     {
2046     if (!(lstPatchList.Items.Count > 0)) { mnuItemRemoveResult.Visible = false; e.Cancel = true; }
2047     if (!(lstPatchList.Items.Count > 0)) { mnuItemPatchSelectedEntry.Visible = false; e.Cancel = true; }
2048     if (e.Cancel) return;
2049     if (lstPatchList.Items.Count > 0) mnuItemRemoveResult.Visible = true;
2050     if (lstPatchList.Items.Count > 0) mnuItemPatchSelectedEntry.Visible = true;
2051    
2052     if (!(lstPatchList.Items.Count > 0)) { mnuItemFreezeSelectedPatches.Visible = false; e.Cancel = true; }
2053     if (!(lstPatchList.Items.Count > 0)) { mnuItemThawSelectedPatches.Visible = false; e.Cancel = true; }
2054     if (e.Cancel) return;
2055    
2056     if (lstPatchList.Items.Count > 0) mnuItemFreezeSelectedPatches.Visible = true;
2057     if (lstPatchList.Items.Count > 0) mnuItemThawSelectedPatches.Visible = true;
2058    
2059     if (lstPatchList.SelectedItems.Count == 0) e.Cancel = true;
2060     if (e.Cancel) return;
2061    
2062     }
2063    
2064     private void mnuResults_Opening(object sender, CancelEventArgs e)
2065     {
2066     if (!(lstResults.Items.Count > 0)) e.Cancel = true;
2067     if (lstResults.SelectedItems.Count == 0) e.Cancel = true;
2068     if (SearchArgs == null) e.Cancel = true;
2069     if (e.Cancel) return;
2070     }
2071 william 287
2072     private void chkMemoryRangeExpertMode_CheckedChanged(object sender, EventArgs e)
2073     {
2074 william 288 txtMemoryRangeStart.ReadOnly = !chkMemoryRangeExpertMode.Checked;
2075     txtMemoryRangeSize.ReadOnly = !chkMemoryRangeExpertMode.Checked;
2076 william 287 }
2077    
2078 william 378 private void txtMemoryRangeStart_ValueChanged(object sender, ValueChangedEventArgs e) { this.MemoryRangeStart = Convert.ToUInt32(e.NewValue); }
2079 william 288 private void txtMemoryRangeSize_ValueChanged(object sender, ValueChangedEventArgs e) { this.MemoryRangeSize = Convert.ToUInt32(e.NewValue); }
2080 william 287
2081 william 227 }
2082     }

  ViewVC Help
Powered by ViewVC 1.1.22