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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 //#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 #if !USE_AUTOMATIC_MEMORY_SEARCH_RANGE
3 #define FORCE_USE_OF_MEMORYSIZECONSTANTS // when defined wil force the use of the constants defined in MemorySizeConstants for memory search range
4 #endif
5 //#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 using System;
9 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 using RomCheater.Docking.MemorySearch;
20 using libWin32.Win32.Threading;
21 using System.Threading;
22 using RomCheater.Logging;
23 using System.IO;
24 using Sojaner.MemoryScanner.MemoryProviers;
25 using RomCheater.PluginFramework.Events;
26 using System.Reflection;
27 using Sojaner.MemoryScanner;
28 using System.Collections;
29 using RomCheater.Serialization;
30
31 namespace RomCheater.Docking
32 {
33 public partial class FloatingMemorySearcher : DockContent,
34 IAcceptsPlugin<IConfigPlugin>,
35 IAcceptsProcess<Process>,
36 IAcceptsProcessAndConfig,
37 ISearchInProgress,
38 IAcceptsBrowseMemoryRegion,
39 IAcceptsMemoryRange
40 {
41 #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 private bool DefaultUnsignedState = true; // set unsigned to true
48 public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; OnBrowseMemoryRegion = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }
49 public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
50 public FloatingMemorySearcher(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
51
52 #region IAcceptsProcess<Process> Members
53 private Process _AcceptedProcess;
54 public Process AcceptedProcess { get { return _AcceptedProcess; } set { _AcceptedProcess = value; UpdateAcceptedProcess(value); } }
55 #endregion
56 #region IAcceptsPlugin<IConfigPlugin> Members
57 private IConfigPlugin _AcceptedPlugin;
58 public IConfigPlugin AcceptedPlugin { get { return _AcceptedPlugin; } set { _AcceptedPlugin = value; UpdateAcceptedPlugin(value); } }
59 #endregion
60 #region IAcceptsBrowseMemoryRegion members
61 public event BaseEventHandler<BrowseMemoryRegionEvent> OnBrowseMemoryRegion;
62 #endregion
63
64 private void UpdateAcceptedPlugin(IConfigPlugin config)
65 {
66 this.lstResults.AcceptedPlugin = config;
67 this.lstPatchList.AcceptedPlugin = config;
68 if (config != null)
69 {
70 MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
71 MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
72 }
73 }
74 private void UpdateAcceptedProcess(Process process)
75 {
76 this.lstResults.AcceptedProcess = process;
77 this.lstPatchList.AcceptedProcess = process;
78 #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 #endif
83 #if FORCE_USE_OF_MEMORYSIZECONSTANTS
84 // force use of MemorySizeConstants
85 txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
86 txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
87 #endif
88 #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && !FORCE_USE_OF_MEMORYSIZECONSTANTS
89 ////// 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 //txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
99 //txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
100 //}
101 if (AcceptedPlugin != null)
102 {
103 MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
104 MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
105 }
106
107 #endif
108
109 }
110 #region ISearchInProgress members
111 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 #endregion
123
124 #region IAcceptsMemoryRange
125 #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
126 private uint _MemoryRangeStart;
127 private uint _MemoryRangeSize;
128 #endif
129 public uint MemoryRangeStart
130 {
131 get
132 {
133 #if FORCE_USE_OF_MEMORYSIZECONSTANTS
134 return MemorySizeConstants.MinimumSearchAddress;
135 #else
136 return _MemoryRangeStart;
137 #endif
138 }
139 set
140 {
141 #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
142 _MemoryRangeStart = value;
143 txtMemoryRangeStart.Value = value;
144 #endif
145 }
146 }
147 public uint MemoryRangeSize
148 {
149 get
150 {
151 #if FORCE_USE_OF_MEMORYSIZECONSTANTS
152 return MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
153 #else
154 return _MemoryRangeSize;
155 #endif
156 }
157 set
158 {
159 #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
160 _MemoryRangeSize = value;
161 txtMemoryRangeSize.Value = value;
162 #endif
163 }
164 }
165 #endregion
166
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 chkRefreshResults.Checked = true;
174 }
175 public enum eListViewResults
176 {
177 SEARCH_RESULTS_LIST = 0x3000,
178 PATCH_RESULTS_LIST = 0x3001,
179 UKNOWN_RESULTS_LIST = 0x3001
180 }
181 bool IsFirstSearch = true;
182 SearchType SearchArgs;
183 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 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 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 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 private void ResultsUpdateWorkerThread_DoWork(object sender, DoWorkEventArgs e)
405 {
406 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
417 #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 int Address = 0;
443 ResultDataType _result = (ResultDataType)ResultItems[i].Tag;
444
445 Address = Convert.ToInt32(ResultItems[i].SubItems[col_Found_Address].Text, 16);
446 //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);
447 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
448 {
449 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 }
497 //Application.DoEvents();
498 }
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 int Address = 0;
527 ResultDataType _result = (ResultDataType)AddedItems[i].Tag;
528 Address = Convert.ToInt32(AddedItems[i].SubItems[col_Added_Address].Text, 16);
529 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
530 {
531 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 }
579 //Application.DoEvents();
580 }
581 #endregion
582
583
584 }
585
586 private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
587 {
588 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
598 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 }
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 //this.IsResultsUpdateFrozen = false;
659 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 PatchAdder adder = new PatchAdder((IAcceptsProcessAndConfig)this);
720 adder.ShowDialog();
721 if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
722 }
723
724 private void btnAddAddressRange_Click(object sender, EventArgs e)
725 {
726 PatchRangeAdder adder = new PatchRangeAdder((IAcceptsProcessAndConfig)this);
727 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 ResultItemState state = new ResultItemState(address, bitsize, IsUnsigned, (IAcceptsProcessAndConfig)this);
780 ResultItem item = new ResultItem(state.Address, state.Value, state.Frozen, state.ValueType, state.IsUnsigned);
781 this.AddToPatchList(item);
782 }
783
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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
861 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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
872 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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
885 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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
896 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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
909 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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
920 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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
933 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 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
944 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 SearchRangePatcher rangePatcher = new SearchRangePatcher((IAcceptsProcessAndConfig)this, patch_list);
966 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 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 private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)
1081 {
1082 Stopwatch st = new Stopwatch();
1083 st.Start();
1084
1085 Stopwatch st_first_search = new Stopwatch();
1086 Stopwatch st_nonrange_search = new Stopwatch();
1087 Stopwatch st_ranged_search = new Stopwatch();
1088
1089 e.Result = st;
1090 //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
1091 List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();
1092 //const int ElementsBeforeDisplay = 100;
1093 SearchArgs.LogSearchOptions();
1094 uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
1095
1096 bool unsigned = SearchArgs.IsUnsignedDataType;
1097 SearchDataTypes sdt = SearchArgs.DataType;
1098 //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 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1106 {
1107 provider.OpenProvider();
1108 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 provider.CloseProvider();
1113 writer.Dispose();
1114 }
1115 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 {
1205 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 {
1213 #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 try
1218 {
1219 using (SearchResultReader reader = new SearchResultReader())
1220 {
1221 for (int i = 0; i < reader.ResultCount; i += 1)
1222 {
1223 object result_value = 0;
1224 uint address = 0;
1225 #region switch (SearchArgs.DataType)
1226 switch (SearchArgs.DataType)
1227 {
1228 case SearchDataTypes._8bits: if (unsigned)
1229 {
1230 using (ResultType<byte> result = reader.GetNextResult<byte>())
1231 {
1232 address = result.Address;
1233 result_value = result.Value;
1234 }
1235 }
1236 else
1237 {
1238 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 {
1246 using (ResultType<ushort> result = reader.GetNextResult<ushort>())
1247 {
1248 address = result.Address;
1249 result_value = result.Value;
1250 }
1251 }
1252 else
1253 {
1254 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 {
1262 using (ResultType<uint> result = reader.GetNextResult<uint>())
1263 {
1264 address = result.Address;
1265 result_value = result.Value;
1266 }
1267 }
1268 else
1269 {
1270 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 {
1278 using (ResultType<ulong> result = reader.GetNextResult<ulong>())
1279 {
1280 address = result.Address;
1281 result_value = result.Value;
1282 }
1283 }
1284 else
1285 {
1286 using (ResultType<long> result = reader.GetNextResult<long>())
1287 {
1288 address = result.Address;
1289 result_value = result.Value;
1290 }
1291 } break;
1292 }
1293 #endregion
1294 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 {
1310 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 }
1333 else
1334 {
1335 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 }
1356 break;
1357 #endregion
1358 #region case SearchDataTypes._16bits:
1359 case SearchDataTypes._16bits:
1360 if (SearchArgs.IsUnsignedDataType)
1361 {
1362 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 }
1385 else
1386 {
1387 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 }
1408 break;
1409 #endregion
1410 #region case SearchDataTypes._32bits:
1411 case SearchDataTypes._32bits:
1412 if (SearchArgs.IsUnsignedDataType)
1413 {
1414 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 }
1447 else
1448 {
1449 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 }
1470 break;
1471 #endregion
1472 #region case SearchDataTypes._64bits:
1473 case SearchDataTypes._64bits:
1474 if (SearchArgs.IsUnsignedDataType)
1475 {
1476 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 }
1499 else
1500 {
1501 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 }
1522 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 {
1537 int local_k = 0;
1538 }
1539 }
1540 }
1541 }
1542 }
1543 }
1544 catch (Exception ex)
1545 {
1546 throw;
1547 }
1548 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 #endregion
1552 }
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 {
1564 for (int i = 0; i < reader.ResultCount; i += 1)
1565 {
1566 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 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1582 //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1583 if (SearchArgs.CompareType == SearchCompareTypes.Between)
1584 {
1585 InRangeComparer comparer = new InRangeComparer(address, 0);
1586 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
1587 {
1588 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1589 {
1590 second_tmp_Results.Add(_tmp_result);
1591 }
1592 }
1593 comparer = null;
1594 }
1595 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 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1601 {
1602 second_tmp_Results.Add(_tmp_result);
1603 }
1604 }
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 if (int_percent_done == 11)
1622 {
1623 int local_k = 0;
1624 }
1625 }
1626 }
1627 }
1628 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
1634 }
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 }
1662 second_tmp_Results = null; // free memory
1663 }
1664 }
1665
1666
1667
1668 private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)
1669 {
1670 //if (SearchArgs.ProgressLogger != null)
1671 //{
1672 // resultsprogress.Value = e.ProgressPercentage;
1673 // //Application.DoEvents();
1674 //}
1675 }
1676
1677 private void SearchWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
1678 {
1679 if (!e.Cancelled)
1680 {
1681 Stopwatch st = (e.Result as Stopwatch);
1682 st.Stop();
1683 logger.Profiler.WriteLine("Search took {0} seconds, overall, to complete.", st.Elapsed.TotalSeconds);
1684 }
1685
1686 resultsprogress.Value = 100;
1687 bool unsigned = SearchArgs.IsUnsignedDataType;
1688 using (SearchResultReader reader = new SearchResultReader())
1689 {
1690
1691 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 logger.Debug.WriteLine(string.Format("Results Count -> 0x{0:x8}", reader.ResultCount));
1764
1765
1766 if (reader.ResultCount == 1) // debug message for 1 result using 32bit unsigned
1767 logger.Debug.WriteLine(string.Format("Debug: Found 1 result -> Address: 0x{0:x8} Value: 0x{1:x16}", address, result_value));
1768
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 {
1773 lstResults.Items.Clear();
1774 List<ResultItem> items = new List<ResultItem>();
1775 for (int i = 0; i < reader.ResultCount; i++)
1776 {
1777 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
1783 case SearchDataTypes._8bits:
1784 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 break;
1787 case SearchDataTypes._16bits:
1788 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 break;
1791 case SearchDataTypes._32bits:
1792 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 break;
1795 case SearchDataTypes._64bits:
1796 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 break;
1799 }
1800
1801 if (!items.Contains(item))
1802 items.Add(item);
1803 }
1804 lstResults.Items.AddRange(items.ToArray());
1805 }
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 }
1814 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
1820 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 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 #region Search Button
1857 private void btnSearch_Click(object sender, EventArgs e)
1858 {
1859 this.SearchInProgess = true;
1860 //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 //args.Results = SearchArgs.Results;
1969 }
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 btnReset.Enabled = false;
1981 btnSearch.Enabled = false;
1982 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 }
1990 #endregion
1991 private void btnReset_Click(object sender, EventArgs e)
1992 {
1993 this.SearchInProgess = false;
1994 //btnSearch.Enabled = true;
1995 //btnCancel.Enabled = false;
1996 this.DoResetSpecific();
1997 lstResults.Items.Clear();
1998 //try { SearchArgs.Results = new List<ResultType<object>>(); }
1999 //catch { }
2000 }
2001
2002 private void btnCancel_Click(object sender, EventArgs e)
2003 {
2004 this.SearchInProgess = false;
2005 //btnCancel.Enabled = false;
2006 //btnSearch.Enabled = true;
2007 //btnReset.Enabled = true;
2008 this.DoCancelSpecific();
2009 }
2010
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 OnBrowseMemoryRegion(new BrowseMemoryRegionEvent(this, rdt.Address));
2042 }
2043
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
2072 private void chkMemoryRangeExpertMode_CheckedChanged(object sender, EventArgs e)
2073 {
2074 txtMemoryRangeStart.ReadOnly = !chkMemoryRangeExpertMode.Checked;
2075 txtMemoryRangeSize.ReadOnly = !chkMemoryRangeExpertMode.Checked;
2076 }
2077
2078 private void txtMemoryRangeStart_ValueChanged(object sender, ValueChangedEventArgs e) { this.MemoryRangeStart = Convert.ToUInt32(e.NewValue); }
2079 private void txtMemoryRangeSize_ValueChanged(object sender, ValueChangedEventArgs e) { this.MemoryRangeSize = Convert.ToUInt32(e.NewValue); }
2080
2081 }
2082 }

  ViewVC Help
Powered by ViewVC 1.1.22