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

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

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

revision 509 by william, Tue Jun 4 21:25:01 2013 UTC revision 511 by william, Tue Jun 4 22:38:40 2013 UTC
# Line 40  using System.Reflection; Line 40  using System.Reflection;
40  using Sojaner.MemoryScanner;  using Sojaner.MemoryScanner;
41  using System.Collections;  using System.Collections;
42  using RomCheater.Serialization;  using RomCheater.Serialization;
43    using RomCheater.Core;
44    
45  namespace RomCheater.Docking  namespace RomCheater.Docking
46  {  {
# Line 65  namespace RomCheater.Docking Line 66  namespace RomCheater.Docking
66          public FloatingMemorySearcher(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }          public FloatingMemorySearcher(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
67    
68          //new Action<int, string>(UpdateProgress) to use this as a delegate          //new Action<int, string>(UpdateProgress) to use this as a delegate
69          private void UpdateProgress(int value, string message)  
70            private void thread_UpdateProgress(object o)
71          {          {
72              //string stacktrace = string.Empty;              IProgressMessage pm = (o as IProgressMessage);
73              //if (value == 0 && message == string.Empty)              if (pm == null) { return; }
74              //{              resultsprogress.Value = pm.Progress;
75              //    stacktrace = System.Environment.StackTrace;              resultsprogress.Message = pm.Message;          
76              //}          }
77              resultsprogress.Value = value;  
78              resultsprogress.Message = message;          private void UpdateProgress(int progress, string message)
79            {
80                // detach the progress update from execution within the current thread (so it does not block a cpu-intensive or long running sequence)
81                Thread t = new Thread(new ParameterizedThreadStart(thread_UpdateProgress));
82                t.SetApartmentState(ApartmentState.MTA);
83                t.Start(new ProgressMessage(progress, message));
84          }          }
85    
86          #region IAcceptsProcess<Process> Members          #region IAcceptsProcess<Process> Members
# Line 1056  namespace RomCheater.Docking Line 1063  namespace RomCheater.Docking
1063                  Debug.WriteLine(ex.ToString());                  Debug.WriteLine(ex.ToString());
1064              }              }
1065          }          }
         private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)  
         {  
             if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }  
             SearchDataTypes sdt = SearchArgs.DataType;  
             bool unsigned = SearchArgs.IsUnsignedDataType;  
             //int Last_Whole_Percent_Done = 0;  
             uint CurrentIndex = e.CurrentIndex;  
             if (e.UserState != null)  
             {  
                 SearchResultWriter writer = (e.UserState as SearchResultWriter);  
                 if (writer == null)  
                     throw new InvalidOperationException("writer cannot be null");  
                 using (MemoryStream ms = new MemoryStream(e.Data))  
                 {  
                     using (BinaryReader br = new BinaryReader(ms))  
                     {  
                         while (br.BaseStream.Position < br.BaseStream.Length)  
                         {  
                             try  
                             {  
                                 switch (sdt)  
                                 {  
                                     case SearchDataTypes._8bits:  
                                         if (unsigned)  
                                         {  
                                             #region 8bits - unsigned  
                                             var Value = br.ReadByte();  
                                             using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 byte value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToByte(Value), value))  
                                                 {  
                                                     writer.WriteResult<byte>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         }  
                                         else  
                                         {  
                                             #region 8bits - signed  
                                             var Value = br.ReadSByte();  
                                             using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 sbyte value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToSByte(Value), value))  
                                                 {  
                                                     writer.WriteResult<sbyte>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         } break;  
                                     case SearchDataTypes._16bits:  
                                         if (unsigned)  
                                         {  
                                             #region 16bits - unsigned  
                                             var Value = br.ReadUInt16();  
                                             using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 ushort value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToUInt16(Value), value))  
                                                 {  
                                                     writer.WriteResult<ushort>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         }  
                                         else  
                                         {  
                                             #region 16bits - signed  
                                             var Value = br.ReadInt16();  
                                             using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 short value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToSByte(Value), value))  
                                                 {  
                                                     writer.WriteResult<short>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         } break;  
                                     case SearchDataTypes._32bits:  
                                         if (unsigned)  
                                         {  
                                             #region 32bits - unsigned  
                                             var Value = br.ReadUInt32();  
                                             using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 uint value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToUInt32(Value), value))  
                                                 {  
                                                     writer.WriteResult<uint>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         }  
                                         else  
                                         {  
                                             #region 32bits - signed  
                                             var Value = br.ReadInt32();  
                                             using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 int value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToInt32(Value), value))  
                                                 {  
                                                     writer.WriteResult<int>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         } break;  
                                     case SearchDataTypes._64bits:  
                                         if (unsigned)  
                                         {  
                                             #region 64bits - unsigned  
                                             var Value = br.ReadUInt64();  
                                             using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 ulong value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToUInt64(Value), value))  
                                                 {  
                                                     writer.WriteResult<ulong>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         }  
                                         else  
                                         {  
                                             #region 64bits - signed  
                                             var Value = br.ReadInt64();  
                                             using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))  
                                             {  
                                                 long value = 0;  
                                                 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                 {  
                                                     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                     {  
                                                         try  
                                                         {  
                                                             gmp.OpenProvider();  
                                                             gmp.ReadMemory(CurrentIndex, out value);  
                                                             gmp.CloseProvider();  
                                                         }  
                                                         catch (Exception ex)  
                                                         {  
                                                             logger.VerboseError.WriteLine(ex.ToString());  
                                                         }  
                                                     }  
                                                     comparer.Value = value;  
                                                 }  
                                                 else  
                                                 {  
                                                     value = Convert.ToInt64(SearchArgs.CompareStartValue);  
                                                     comparer.Value = value;  
                                                 }  
                                                 if (comparer.Compare(Convert.ToInt64(Value), value))  
                                                 {  
                                                     writer.WriteResult<long>(comparer.Address, comparer.Value);  
                                                 }  
                                             }  
                                             #endregion  
                                         } break;  
                                 }  
                                 if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }  
                             }  
                             catch (EndOfStreamException) { }  
                             if (e.ReportProgress)  
                             {  
                                 double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);  
                                 int int_percent_done = (int)double_percent_done;  
                                 //if (CurrentIndex % 10 == 0)  
                                 //{  
                                 //    if (int_percent_done <= 100)  
                                 //    {  
                                 new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Index: 0x{0:x8} of 0x{1:x8}", CurrentIndex, e.TotalCount));  
                                 //    }  
                                 //    if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }  
                                 //}  
                             }  
                             //switch (sdt)  
                             //{  
                             //    case SearchDataTypes._8bits:  
                             //        CurrentIndex += sizeof(byte);  
                             //        break;  
                             //    case SearchDataTypes._16bits:  
                             //        CurrentIndex += sizeof(ushort);  
                             //        break;  
                             //    case SearchDataTypes._32bits:  
                             //        CurrentIndex += sizeof(uint);  
                             //        break;  
                             //    case SearchDataTypes._64bits:  
                             //        CurrentIndex += sizeof(ulong);  
                             //        break;  
                             //}  
                         }  
1066    
1067                      }          #region old-code: private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)
1068                  }          //private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)
1069              }          //{
1070              if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }          //    if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1071          }          //    SearchDataTypes sdt = SearchArgs.DataType;
1072            //    bool unsigned = SearchArgs.IsUnsignedDataType;
1073            //    //int Last_Whole_Percent_Done = 0;
1074            //    uint CurrentIndex = e.CurrentIndex;
1075            //    if (e.UserState != null)
1076            //    {
1077            //        SearchResultWriter writer = (e.UserState as SearchResultWriter);
1078            //        if (writer == null)
1079            //            throw new InvalidOperationException("writer cannot be null");
1080            //        using (MemoryStream ms = new MemoryStream(e.Data))
1081            //        {
1082            //            using (BinaryReader br = new BinaryReader(ms))
1083            //            {
1084            //                while (br.BaseStream.Position < br.BaseStream.Length)
1085            //                {
1086            //                    try
1087            //                    {
1088            //                        switch (sdt)
1089            //                        {
1090            //                            case SearchDataTypes._8bits:
1091            //                                if (unsigned)
1092            //                                {
1093            //                                    #region 8bits - unsigned
1094            //                                    var Value = br.ReadByte();
1095            //                                    using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1096            //                                    {
1097            //                                        byte value = 0;
1098            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1099            //                                        {
1100            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1101            //                                            {
1102            //                                                try
1103            //                                                {
1104            //                                                    gmp.OpenProvider();
1105            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1106            //                                                    gmp.CloseProvider();
1107            //                                                }
1108            //                                                catch (Exception ex)
1109            //                                                {
1110            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1111            //                                                }
1112            //                                            }
1113            //                                            comparer.Value = value;
1114            //                                        }
1115            //                                        else
1116            //                                        {
1117            //                                            value = Convert.ToByte(SearchArgs.CompareStartValue);
1118            //                                            comparer.Value = value;
1119            //                                        }
1120            //                                        if (comparer.Compare(Convert.ToByte(Value), value))
1121            //                                        {
1122            //                                            writer.WriteResult<byte>(comparer.Address, comparer.Value);
1123            //                                        }
1124            //                                    }
1125            //                                    #endregion
1126            //                                }
1127            //                                else
1128            //                                {
1129            //                                    #region 8bits - signed
1130            //                                    var Value = br.ReadSByte();
1131            //                                    using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1132            //                                    {
1133            //                                        sbyte value = 0;
1134            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1135            //                                        {
1136            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1137            //                                            {
1138            //                                                try
1139            //                                                {
1140            //                                                    gmp.OpenProvider();
1141            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1142            //                                                    gmp.CloseProvider();
1143            //                                                }
1144            //                                                catch (Exception ex)
1145            //                                                {
1146            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1147            //                                                }
1148            //                                            }
1149            //                                            comparer.Value = value;
1150            //                                        }
1151            //                                        else
1152            //                                        {
1153            //                                            value = Convert.ToSByte(SearchArgs.CompareStartValue);
1154            //                                            comparer.Value = value;
1155            //                                        }
1156            //                                        if (comparer.Compare(Convert.ToSByte(Value), value))
1157            //                                        {
1158            //                                            writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1159            //                                        }
1160            //                                    }
1161            //                                    #endregion
1162            //                                } break;
1163            //                            case SearchDataTypes._16bits:
1164            //                                if (unsigned)
1165            //                                {
1166            //                                    #region 16bits - unsigned
1167            //                                    var Value = br.ReadUInt16();
1168            //                                    using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1169            //                                    {
1170            //                                        ushort value = 0;
1171            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1172            //                                        {
1173            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1174            //                                            {
1175            //                                                try
1176            //                                                {
1177            //                                                    gmp.OpenProvider();
1178            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1179            //                                                    gmp.CloseProvider();
1180            //                                                }
1181            //                                                catch (Exception ex)
1182            //                                                {
1183            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1184            //                                                }
1185            //                                            }
1186            //                                            comparer.Value = value;
1187            //                                        }
1188            //                                        else
1189            //                                        {
1190            //                                            value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1191            //                                            comparer.Value = value;
1192            //                                        }
1193            //                                        if (comparer.Compare(Convert.ToUInt16(Value), value))
1194            //                                        {
1195            //                                            writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1196            //                                        }
1197            //                                    }
1198            //                                    #endregion
1199            //                                }
1200            //                                else
1201            //                                {
1202            //                                    #region 16bits - signed
1203            //                                    var Value = br.ReadInt16();
1204            //                                    using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1205            //                                    {
1206            //                                        short value = 0;
1207            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1208            //                                        {
1209            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1210            //                                            {
1211            //                                                try
1212            //                                                {
1213            //                                                    gmp.OpenProvider();
1214            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1215            //                                                    gmp.CloseProvider();
1216            //                                                }
1217            //                                                catch (Exception ex)
1218            //                                                {
1219            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1220            //                                                }
1221            //                                            }
1222            //                                            comparer.Value = value;
1223            //                                        }
1224            //                                        else
1225            //                                        {
1226            //                                            value = Convert.ToInt16(SearchArgs.CompareStartValue);
1227            //                                            comparer.Value = value;
1228            //                                        }
1229            //                                        if (comparer.Compare(Convert.ToSByte(Value), value))
1230            //                                        {
1231            //                                            writer.WriteResult<short>(comparer.Address, comparer.Value);
1232            //                                        }
1233            //                                    }
1234            //                                    #endregion
1235            //                                } break;
1236            //                            case SearchDataTypes._32bits:
1237            //                                if (unsigned)
1238            //                                {
1239            //                                    #region 32bits - unsigned
1240            //                                    var Value = br.ReadUInt32();
1241            //                                    using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1242            //                                    {
1243            //                                        uint value = 0;
1244            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1245            //                                        {
1246            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1247            //                                            {
1248            //                                                try
1249            //                                                {
1250            //                                                    gmp.OpenProvider();
1251            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1252            //                                                    gmp.CloseProvider();
1253            //                                                }
1254            //                                                catch (Exception ex)
1255            //                                                {
1256            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1257            //                                                }
1258            //                                            }
1259            //                                            comparer.Value = value;
1260            //                                        }
1261            //                                        else
1262            //                                        {
1263            //                                            value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1264            //                                            comparer.Value = value;
1265            //                                        }
1266            //                                        if (comparer.Compare(Convert.ToUInt32(Value), value))
1267            //                                        {
1268            //                                            writer.WriteResult<uint>(comparer.Address, comparer.Value);
1269            //                                        }
1270            //                                    }
1271            //                                    #endregion
1272            //                                }
1273            //                                else
1274            //                                {
1275            //                                    #region 32bits - signed
1276            //                                    var Value = br.ReadInt32();
1277            //                                    using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1278            //                                    {
1279            //                                        int value = 0;
1280            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1281            //                                        {
1282            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1283            //                                            {
1284            //                                                try
1285            //                                                {
1286            //                                                    gmp.OpenProvider();
1287            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1288            //                                                    gmp.CloseProvider();
1289            //                                                }
1290            //                                                catch (Exception ex)
1291            //                                                {
1292            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1293            //                                                }
1294            //                                            }
1295            //                                            comparer.Value = value;
1296            //                                        }
1297            //                                        else
1298            //                                        {
1299            //                                            value = Convert.ToInt32(SearchArgs.CompareStartValue);
1300            //                                            comparer.Value = value;
1301            //                                        }
1302            //                                        if (comparer.Compare(Convert.ToInt32(Value), value))
1303            //                                        {
1304            //                                            writer.WriteResult<int>(comparer.Address, comparer.Value);
1305            //                                        }
1306            //                                    }
1307            //                                    #endregion
1308            //                                } break;
1309            //                            case SearchDataTypes._64bits:
1310            //                                if (unsigned)
1311            //                                {
1312            //                                    #region 64bits - unsigned
1313            //                                    var Value = br.ReadUInt64();
1314            //                                    using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1315            //                                    {
1316            //                                        ulong value = 0;
1317            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1318            //                                        {
1319            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1320            //                                            {
1321            //                                                try
1322            //                                                {
1323            //                                                    gmp.OpenProvider();
1324            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1325            //                                                    gmp.CloseProvider();
1326            //                                                }
1327            //                                                catch (Exception ex)
1328            //                                                {
1329            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1330            //                                                }
1331            //                                            }
1332            //                                            comparer.Value = value;
1333            //                                        }
1334            //                                        else
1335            //                                        {
1336            //                                            value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1337            //                                            comparer.Value = value;
1338            //                                        }
1339            //                                        if (comparer.Compare(Convert.ToUInt64(Value), value))
1340            //                                        {
1341            //                                            writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1342            //                                        }
1343            //                                    }
1344            //                                    #endregion
1345            //                                }
1346            //                                else
1347            //                                {
1348            //                                    #region 64bits - signed
1349            //                                    var Value = br.ReadInt64();
1350            //                                    using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1351            //                                    {
1352            //                                        long value = 0;
1353            //                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1354            //                                        {
1355            //                                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1356            //                                            {
1357            //                                                try
1358            //                                                {
1359            //                                                    gmp.OpenProvider();
1360            //                                                    gmp.ReadMemory(CurrentIndex, out value);
1361            //                                                    gmp.CloseProvider();
1362            //                                                }
1363            //                                                catch (Exception ex)
1364            //                                                {
1365            //                                                    logger.VerboseError.WriteLine(ex.ToString());
1366            //                                                }
1367            //                                            }
1368            //                                            comparer.Value = value;
1369            //                                        }
1370            //                                        else
1371            //                                        {
1372            //                                            value = Convert.ToInt64(SearchArgs.CompareStartValue);
1373            //                                            comparer.Value = value;
1374            //                                        }
1375            //                                        if (comparer.Compare(Convert.ToInt64(Value), value))
1376            //                                        {
1377            //                                            writer.WriteResult<long>(comparer.Address, comparer.Value);
1378            //                                        }
1379            //                                    }
1380            //                                    #endregion
1381            //                                } break;
1382            //                        }
1383            //                        if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1384            //                    }
1385            //                    catch (EndOfStreamException) { }
1386            //                    if (e.ReportProgress)
1387            //                    {
1388            //                        double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1389            //                        int int_percent_done = (int)double_percent_done;
1390            //                        //if (CurrentIndex % 10 == 0)
1391            //                        //{
1392            //                        //    if (int_percent_done <= 100)
1393            //                        //    {
1394            //                        new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Index: 0x{0:x8} of 0x{1:x8}", CurrentIndex, e.TotalCount));
1395            //                        //    }
1396            //                        //    if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1397            //                        //}
1398            //                    }
1399            //                    //switch (sdt)
1400            //                    //{
1401            //                    //    case SearchDataTypes._8bits:
1402            //                    //        CurrentIndex += sizeof(byte);
1403            //                    //        break;
1404            //                    //    case SearchDataTypes._16bits:
1405            //                    //        CurrentIndex += sizeof(ushort);
1406            //                    //        break;
1407            //                    //    case SearchDataTypes._32bits:
1408            //                    //        CurrentIndex += sizeof(uint);
1409            //                    //        break;
1410            //                    //    case SearchDataTypes._64bits:
1411            //                    //        CurrentIndex += sizeof(ulong);
1412            //                    //        break;
1413            //                    //}
1414            //                }
1415            //            }
1416            //        }
1417            //    }
1418            //    if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1419            //}
1420            #endregion
1421    
1422          private void search_provider_OnBytesRead(OnBytesReadEventArgs e)          private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1423          {          {
1424              if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }              if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
# Line 1731  namespace RomCheater.Docking Line 1741  namespace RomCheater.Docking
1741                              {                              {
1742                                  double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);                                  double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1743                                  int int_percent_done = (int)double_percent_done;                                  int int_percent_done = (int)double_percent_done;
1744                                  if (int_percent_done != Last_Whole_Percent_Done && CurrentIndex % 100000 == 0)  
1745                                  {                                  //int align_base = 1000;
1746                                      if (int_percent_done <= 100)                                  //int align_magnitude = 1;
1747                                      {                                  //int alignment = align_base * align_magnitude;
1748                                          new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart)));                                  //if (int_percent_done != Last_Whole_Percent_Done && (CurrentIndex % alignment) == 0)
1749                                          Last_Whole_Percent_Done = int_percent_done;                                  //{
1750                                      }                                  //    if (int_percent_done <= 100)
1751                                      if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }                                  //    {
1752                                  }                                  new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart)));
1753                                    //        Last_Whole_Percent_Done = int_percent_done;
1754                                    //    }
1755                                    //    if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1756                                    //}
1757                              }                              }
1758                              uint size = 0;                              uint size = 0;
1759                              BitTools.SizeOf(sdt, out size);                              BitTools.SizeOf(sdt, out size);

Legend:
Removed from v.509  
changed lines
  Added in v.511

  ViewVC Help
Powered by ViewVC 1.1.22