/[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 277 by william, Sun Jun 3 22:30:23 2012 UTC revision 280 by william, Tue Jun 5 00:13:29 2012 UTC
# Line 1  Line 1 
1  //#define DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE // when defined will not freeze/resume thread on freeze  #define USE_FORCED_LOGGING_CONTROL // when defined, will override and force an internal logging control
2    //#define DONOT_HAVE_RANGED_SEARCH_SUPPORT // when defined, indicates that ranged searches have not been implemented
3    
4    #define INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY // when defined will set MIN RESULTS to 0x2701 otherwise 0x03e8
5    
6    //#define DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE // when defined will not freeze/resume thread on freeze
7  using System;  using System;
8  using System.Collections.Generic;  using System.Collections.Generic;
9  using System.ComponentModel;  using System.ComponentModel;
# Line 27  namespace RomCheater.Docking Line 32  namespace RomCheater.Docking
32          ISearchInProgress,          ISearchInProgress,
33          IAcceptsBrowseMemoryRegion          IAcceptsBrowseMemoryRegion
34      {      {
35    #if INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY
36            const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x2701; // 10,000 results
37    #else
38            const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x03e8; // 1,000 results
39    #endif
40    
41          private bool DefaultUnsignedState = true; // set unsigned to true          private bool DefaultUnsignedState = true; // set unsigned to true
42          public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }          public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }
43          public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }          public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
# Line 70  namespace RomCheater.Docking Line 81  namespace RomCheater.Docking
81              PATCH_RESULTS_LIST = 0x3001,              PATCH_RESULTS_LIST = 0x3001,
82              UKNOWN_RESULTS_LIST = 0x3001              UKNOWN_RESULTS_LIST = 0x3001
83          }          }
84            bool IsFirstSearch = true;
85          SearchType SearchArgs;          SearchType SearchArgs;
86          static int col_Found_Address = 1;          static int col_Found_Address = 1;
87          static int col_Found_Value = 2;          static int col_Found_Value = 2;
# Line 905  namespace RomCheater.Docking Line 917  namespace RomCheater.Docking
917    
918          private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)          private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)
919          {          {
920                //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
921                List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();
922                const double _UPDATE_DELAY = 1024.0;
923                int UPDATE_DELAY = (int)(_UPDATE_DELAY / 1000);
924                //tmp_Results = SearchArgs.Results.GetRange(0,SearchArgs.Results.Count);
925                //SearchArgs.Results = null;
926                //SearchArgs.Results.Clear();
927                // log options
928                SearchArgs.LogSearchOptions();
929                int STEP_SIZE = (int)SearchArgs.DataType / 8;
930    
931                GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this);
932                provider.OpenProvider();
933                int bytes_read = 0;
934                byte[] buffered_mem = new byte[int.MaxValue];
935                provider.ReadProcessMemory(0, int.MaxValue, out bytes_read, out buffered_mem);
936                provider.CloseProvider();
937                if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }
938                MemoryStream ms = new MemoryStream(buffered_mem);
939                BinaryReader r_ms = new BinaryReader(ms);
940                logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", r_ms.BaseStream.Length));
941                int Last_Whole_Percent_Done = 0;
942    
943                #region First Search
944                if (SearchArgs.IsFirstSearch)
945                {
946                    SearchArgs.Results.Clear();
947                    r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
948                    for (int i = 0; i < r_ms.BaseStream.Length; i += STEP_SIZE)
949                    {
950                        ResultType<object> _tmp_result = new ResultType<object>();
951    
952    
953                        switch (SearchArgs.DataType)
954                        {
955                            case SearchDataTypes._8bits:
956                                if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>((int)i, r_ms.ReadByte()); }
957                                else { _tmp_result = new ResultType<object>((int)i, r_ms.ReadSByte()); } break;
958                            case SearchDataTypes._16bits:
959                                if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>((int)i, r_ms.ReadUInt16()); }
960                                else { _tmp_result = new ResultType<object>((int)i, r_ms.ReadInt16()); } break;
961                            case SearchDataTypes._32bits:
962                                if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>((int)i, r_ms.ReadUInt32()); }
963                                else { _tmp_result = new ResultType<object>((int)i, r_ms.ReadInt32()); } break;
964                            case SearchDataTypes._64bits:
965                                if (SearchArgs.IsUnsignedDataType) { _tmp_result = new ResultType<object>((int)i, r_ms.ReadUInt64()); }
966                                else { _tmp_result = new ResultType<object>((int)i, r_ms.ReadInt64()); } break;
967                        }
968                        SearchArgs.Results.Add(_tmp_result);
969                        double double_percent_done = 100.0 * (double)((double)i / (double)r_ms.BaseStream.Length);
970                        int int_percent_done = (int)double_percent_done;
971                        if ((i / UPDATE_DELAY) == (int)(i / UPDATE_DELAY) && int_percent_done != Last_Whole_Percent_Done)
972                        {
973                            resultsprogress.Value = int_percent_done;
974                            resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);
975                            Last_Whole_Percent_Done = int_percent_done;
976                            Application.DoEvents();
977                        }
978    
979                        if (SearchWorkerThread.CancellationPending == true)
980                        {
981                            e.Cancel = true;
982                            return;
983                        }
984    
985                    }
986                    resultsprogress.Value = 100;
987                    resultsprogress.Message = "";
988                    Application.DoEvents();
989    
990                }
991                #endregion
992    
993                #region Subsequent Searches
994                r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
995    
996    
997                // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
998                bool NeedToCompare = true;
999                if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
1000                    SearchArgs.CompareType == SearchCompareTypes.Equal &&
1001                    SearchArgs.IsFirstSearch)
1002                {
1003                    NeedToCompare = false;
1004                    second_tmp_Results = null; // Free Memory
1005                }
1006    
1007                if (NeedToCompare)
1008                {
1009                    if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)
1010                    {
1011                        #region Non-Range Searches
1012                        //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
1013                        ////second_tmp_Results.c
1014                        for (int i = 0; i < SearchArgs.Results.Count; i += 1)
1015                        {
1016                            r_ms.BaseStream.Seek(SearchArgs.Results[i].Address, SeekOrigin.Begin);
1017    
1018                            switch (SearchArgs.DataType)
1019                            {
1020                                #region Comparer Support
1021                                case SearchDataTypes._8bits:
1022                                    if (SearchArgs.IsUnsignedDataType)
1023                                    {
1024                                        byte lookup_value = r_ms.ReadByte();
1025                                        _8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1026                                        byte value = 0;
1027                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1028                                        {
1029                                            value = Convert.ToByte(SearchArgs.Results[i].Value);
1030                                            comparer.Value = value;
1031                                        }
1032                                        else
1033                                        {
1034                                            value = Convert.ToByte(SearchArgs.CompareStartValue);
1035                                            comparer.Value = value;
1036                                        }
1037                                        if (comparer.Compare(lookup_value, value))
1038                                        {
1039                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1040                                            //second_tmp_Results.Add(_tmp_result);
1041                                            //_tmp_result = null; // free memory
1042                                            //SearchArgs.Results.RemoveAt(i);
1043                                            SearchArgs.Results[i].Value = comparer.Value;
1044                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1045                                        }
1046                                        comparer = null; // free memory
1047                                    }
1048                                    else
1049                                    {
1050                                        sbyte lookup_value = r_ms.ReadSByte();
1051                                        _8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1052                                        sbyte value = 0;
1053                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1054                                        {
1055                                            value = Convert.ToSByte(SearchArgs.Results[i].Value);
1056                                        }
1057                                        else
1058                                        {
1059                                            value = Convert.ToSByte(SearchArgs.CompareStartValue);
1060                                        }
1061                                        if (comparer.Compare(lookup_value, value))
1062                                        {
1063                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1064                                            //second_tmp_Results.Add(_tmp_result);
1065                                            //_tmp_result = null; // free memory
1066                                            //SearchArgs.Results.RemoveAt(i);
1067                                            SearchArgs.Results[i].Value = comparer.Value;
1068                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1069                                        }
1070                                        comparer = null; // free memory
1071                                    }
1072                                    break;
1073                                case SearchDataTypes._16bits:
1074                                    if (SearchArgs.IsUnsignedDataType)
1075                                    {
1076                                        ushort lookup_value = r_ms.ReadUInt16();
1077                                        _16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1078                                        ushort value = 0;
1079                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1080                                        {
1081                                            value = Convert.ToUInt16(SearchArgs.Results[i].Value);
1082                                            comparer.Value = value;
1083                                        }
1084                                        else
1085                                        {
1086                                            value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1087                                            comparer.Value = value;
1088                                        }
1089                                        if (comparer.Compare(lookup_value, value))
1090                                        {
1091                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1092                                            //second_tmp_Results.Add(_tmp_result);
1093                                            //_tmp_result = null; // free memory
1094                                            //SearchArgs.Results.RemoveAt(i);
1095                                            SearchArgs.Results[i].Value = comparer.Value;
1096                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1097                                        }
1098                                        comparer = null; // free memory
1099                                    }
1100                                    else
1101                                    {
1102                                        short lookup_value = r_ms.ReadInt16();
1103                                        _16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1104                                        short value = 0;
1105                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1106                                        {
1107                                            value = Convert.ToInt16(SearchArgs.Results[i].Value);
1108                                        }
1109                                        else
1110                                        {
1111                                            value = Convert.ToInt16(SearchArgs.CompareStartValue);
1112                                        }
1113                                        if (comparer.Compare(lookup_value, value))
1114                                        {
1115                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1116                                            //second_tmp_Results.Add(_tmp_result);
1117                                            //_tmp_result = null; // free memory
1118                                            //SearchArgs.Results.RemoveAt(i);
1119                                            SearchArgs.Results[i].Value = comparer.Value;
1120                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1121                                        }
1122                                        comparer = null; // free memory
1123                                    }
1124                                    break;
1125                                case SearchDataTypes._32bits:
1126                                    if (SearchArgs.IsUnsignedDataType)
1127                                    {
1128                                        uint lookup_value = r_ms.ReadUInt32();
1129                                        _32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1130                                        uint value = 0;
1131                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1132                                        {
1133                                            value = Convert.ToUInt32(SearchArgs.Results[i].Value);
1134                                            comparer.Value = value;
1135                                        }
1136                                        else
1137                                        {
1138                                            value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1139                                            comparer.Value = value;
1140                                        }
1141                                        if (comparer.Compare(lookup_value, value))
1142                                        {
1143                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1144                                            //second_tmp_Results.Add(_tmp_result);
1145                                            //_tmp_result = null; // free memory
1146                                            //SearchArgs.Results.RemoveAt(i);
1147                                            SearchArgs.Results[i].Value = comparer.Value;
1148                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1149                                        }
1150                                        comparer = null; // free memory
1151                                    }
1152                                    else
1153                                    {
1154                                        int lookup_value = r_ms.ReadInt32();
1155                                        _32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1156                                        int value = 0;
1157                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1158                                        {
1159                                            value = Convert.ToInt32(SearchArgs.Results[i].Value);
1160                                        }
1161                                        else
1162                                        {
1163                                            value = Convert.ToInt32(SearchArgs.CompareStartValue);
1164                                        }
1165                                        if (comparer.Compare(lookup_value, value))
1166                                        {
1167                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1168                                            //second_tmp_Results.Add(_tmp_result);
1169                                            //_tmp_result = null; // free memory
1170                                            //SearchArgs.Results.RemoveAt(i);
1171                                            SearchArgs.Results[i].Value = comparer.Value;
1172                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1173                                        }
1174                                        comparer = null; // free memory
1175                                    }
1176                                    break;
1177                                case SearchDataTypes._64bits:
1178                                    if (SearchArgs.IsUnsignedDataType)
1179                                    {
1180                                        ulong lookup_value = r_ms.ReadUInt64();
1181                                        _64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1182                                        ulong value = 0;
1183                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1184                                        {
1185                                            value = Convert.ToUInt64(SearchArgs.Results[i].Value);
1186                                            comparer.Value = value;
1187                                        }
1188                                        else
1189                                        {
1190                                            value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1191                                            comparer.Value = value;
1192                                        }
1193                                        if (comparer.Compare(lookup_value, value))
1194                                        {
1195                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1196                                            //second_tmp_Results.Add(_tmp_result);
1197                                            //_tmp_result = null; // free memory
1198                                            //SearchArgs.Results.RemoveAt(i);
1199                                            SearchArgs.Results[i].Value = comparer.Value;
1200                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1201                                        }
1202                                        comparer = null; // free memory
1203                                    }
1204                                    else
1205                                    {
1206                                        long lookup_value = r_ms.ReadInt64();
1207                                        _64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, SearchArgs.Results[i].Address);
1208                                        long value = 0;
1209                                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1210                                        {
1211                                            value = Convert.ToInt64(SearchArgs.Results[i].Value);
1212                                        }
1213                                        else
1214                                        {
1215                                            value = Convert.ToInt64(SearchArgs.CompareStartValue);
1216                                        }
1217                                        if (comparer.Compare(lookup_value, value))
1218                                        {
1219                                            //ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value);                                    
1220                                            //second_tmp_Results.Add(_tmp_result);
1221                                            //_tmp_result = null; // free memory
1222                                            //SearchArgs.Results.RemoveAt(i);
1223                                            SearchArgs.Results[i].Value = comparer.Value;
1224                                            second_tmp_Results.Add(SearchArgs.Results[i]);
1225                                        }
1226                                        comparer = null; // free memory
1227                                    }
1228                                    break;
1229                                #endregion
1230                            }
1231    
1232                            double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);
1233                            int int_percent_done = (int)double_percent_done;
1234                            if ((i / UPDATE_DELAY) == (int)(i / UPDATE_DELAY) && int_percent_done != Last_Whole_Percent_Done)
1235                            {
1236                                resultsprogress.Value = int_percent_done;
1237                                resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);
1238                                Last_Whole_Percent_Done = int_percent_done;
1239                                Application.DoEvents();
1240                            }
1241    
1242                        }
1243                        #endregion
1244                    }
1245                    #region Ranged Searches
1246    #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT
1247                    if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1248                    {
1249                        object start, end;
1250    
1251                        start = SearchArgs.CompareStartValue;
1252                        end = SearchArgs.CompareEndValue;
1253                        for (int i = 0; i < SearchArgs.Results.Count; i += 1)
1254                        {
1255                            //r_ms.BaseStream.Seek(SearchArgs.Results[i].Address, SeekOrigin.Begin);
1256                            if (SearchArgs.CompareType == SearchCompareTypes.Between)
1257                            {
1258                                InRangeComparer comparer = new InRangeComparer(SearchArgs.Results[i].Address, 0);
1259                                if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))
1260                                {
1261                                    SearchArgs.Results[i].Value = comparer.Value;
1262                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1263                                }
1264                                comparer = null;
1265                            }
1266                            else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1267                            {
1268                                NotInRangeComparer comparer = new NotInRangeComparer(SearchArgs.Results[i].Address, 0);
1269                                if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, r_ms))
1270                                {
1271                                    SearchArgs.Results[i].Value = comparer.Value;
1272                                    second_tmp_Results.Add(SearchArgs.Results[i]);
1273                                }
1274                                comparer = null;
1275                            }
1276                            else
1277                            {
1278                                throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
1279                            }
1280                            double double_percent_done = 100.0 * (double)((double)i / (double)SearchArgs.Results.Count);
1281                            int int_percent_done = (int)double_percent_done;
1282                            if ((i / UPDATE_DELAY) == (int)(i / UPDATE_DELAY) && int_percent_done != Last_Whole_Percent_Done)
1283                            {
1284                                resultsprogress.Value = int_percent_done;
1285                                resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i);
1286                                Last_Whole_Percent_Done = int_percent_done;
1287                                Application.DoEvents();
1288                            }
1289                        }
1290                    }
1291    #endif
1292                    #endregion
1293    
1294                }
1295                #endregion
1296                // leave SearchArgs.Results alone, if false
1297                if (NeedToCompare)
1298                {
1299                    SearchArgs.Results = second_tmp_Results.GetRange(0, second_tmp_Results.Count);
1300                    second_tmp_Results = null; // free memory
1301                }
1302    
1303                r_ms.Close();
1304          }          }
1305    
1306          private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)          private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)
1307          {          {
1308                //if (SearchArgs.ProgressLogger != null)
1309                //{
1310                //    resultsprogress.Value = e.ProgressPercentage;
1311                //    //Application.DoEvents();
1312                //}
1313          }          }
1314    
1315          private void SearchWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)          private void SearchWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
1316          {          {
1317                resultsprogress.Value = 100;
1318                logger.Debug.WriteLine(string.Format("\nResults Count -> 0x{0:x8}", SearchArgs.Results.Count));
1319    
1320                if (SearchArgs.Results.Count == 1) // debug message for 1 result using 32bit unsigned
1321                    logger.Debug.WriteLine(string.Format("\nDebug: Found 1 result -> Address: 0x{0:x8} Value: 0x{1:x8}", SearchArgs.Results[0].Address, SearchArgs.Results[0].Value));
1322    
1323               logger.Info.WriteLine(string.Format("\nFound 0x{0:x8} results", SearchArgs.Results.Count));
1324    
1325                if (SearchArgs.Results.Count <= MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY)
1326                {
1327                    lstResults.Items.Clear();
1328                    List<ResultItem> items = new List<ResultItem>();
1329                    for (int i = 0; i < SearchArgs.Results.Count; i++)
1330                    {
1331                        ResultItem item = new ResultItem(0, false);
1332                        //item.Text = string.Format("0x{0:x8}", SearchArgs.Results[i].Address);
1333                        //item.SubItems.Add(string.Format("0x{0:x8}", SearchArgs.Results[i].Address));
1334                        switch (SearchArgs.DataType)
1335                        {
1336    
1337                            case SearchDataTypes._8bits:
1338                                if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToByte(SearchArgs.Results[i].Value)); }
1339                                else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToSByte(SearchArgs.Results[i].Value)); }
1340                                break;
1341                            case SearchDataTypes._16bits:
1342                                if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToUInt16(SearchArgs.Results[i].Value)); }
1343                                else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToInt16(SearchArgs.Results[i].Value)); }
1344                                break;
1345                            case SearchDataTypes._32bits:
1346                                if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToUInt32(SearchArgs.Results[i].Value)); }
1347                                else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToInt32(SearchArgs.Results[i].Value)); }
1348                                break;
1349                            case SearchDataTypes._64bits:
1350                                if (SearchArgs.IsUnsignedDataType) { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToUInt64(SearchArgs.Results[i].Value)); }
1351                                else { item = new ResultItem(SearchArgs.Results[i].Address, false, Convert.ToInt64(SearchArgs.Results[i].Value)); }
1352                                break;
1353                        }
1354    
1355                        if (!items.Contains(item))
1356                            items.Add(item);
1357                    }
1358                    lstResults.Items.AddRange(items.ToArray());
1359                }
1360    
1361                this.DoSearchDoneSpecific();
1362                //System.Threading.Thread.Sleep(100);
1363                //if (_SEARCH_MODE != SearchMode.SEARCH_MODE_NORMAL_WITH_JOKER)
1364                this.ThawResultsUpdate();
1365                Application.DoEvents();
1366          }          }
1367            private void DoSearchDoneSpecific()
1368            {
1369                SearchWorkerThread.CancelAsync();
1370                if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
1371                else { timer_update_results.Enabled = false; }
1372    
1373                search_progress_updater.Enabled = false;
1374    
1375                btnCancel.Enabled = false;
1376                btnReset.Enabled = true;
1377                btnSearch.Enabled = true;
1378                grpCompareType.Enabled = true;
1379                grpCompareValue.Enabled = true;
1380                resultsprogress.Value = 0;
1381                resultsprogress.Message = "";
1382                grpDataType.Enabled = false;
1383                // resume process on reset, incase it was suspended
1384                ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
1385                //Application.DoEvents();
1386                this.Refresh();
1387            }
1388    
1389            private void DoCancelSpecific()
1390            {
1391                this.DoSearchDoneSpecific();
1392            }
1393            private void DoResetSpecific()
1394            {
1395                this.DoCancelSpecific();
1396                IsFirstSearch = true;
1397                grpDataType.Enabled = true;
1398            }
1399          private void search_progress_updater_Tick(object sender, EventArgs e)          private void search_progress_updater_Tick(object sender, EventArgs e)
1400          {          {
1401              if ((this.AcceptedProcess ==null) || Process.GetProcessById(this.AcceptedProcess.Id) == null)              if ((this.AcceptedProcess ==null) || Process.GetProcessById(this.AcceptedProcess.Id) == null)
# Line 928  namespace RomCheater.Docking Line 1406  namespace RomCheater.Docking
1406              }              }
1407          }          }
1408    
1409            #region Search Button
1410          private void btnSearch_Click(object sender, EventArgs e)          private void btnSearch_Click(object sender, EventArgs e)
1411          {          {
1412              this.SearchInProgess = true;              this.SearchInProgess = true;
1413              btnCancel.Enabled = true;              //btnCancel.Enabled = true;
1414              btnReset.Enabled = false;              //btnReset.Enabled = false;
1415              btnSearch.Enabled = false;              //btnSearch.Enabled = false;
1416              this.FreezeResultsUpdate();              this.FreezeResultsUpdate();
1417                this.handle_btnSearch_Click();
1418          }          }
1419            private void handle_btnSearch_Click()
1420            {
1421                //this.FreezeResultsUpdate();
1422                lstResults.Items.Clear();
1423    
1424                if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
1425                else { timer_update_results.Enabled = false; }
1426    
1427    
1428                resultsprogress.Value = 0;
1429                bool _is_unsigned = chkUnsigned.Checked;
1430                SearchType search_type = new SearchType();
1431                SearchDataTypes _data_type = new SearchDataTypes();
1432                SearchCompareTypes _compare_type = new SearchCompareTypes();
1433                CompareValueTypes _compare_value_type = new CompareValueTypes();
1434                object start_value = 0;
1435                object end_value = 0;
1436                // get datatype
1437                if (radio_8bits.Checked) { _data_type = SearchDataTypes._8bits; }
1438                else if (radio_16bits.Checked) { _data_type = SearchDataTypes._16bits; }
1439                else if (radio_32bits.Checked) { _data_type = SearchDataTypes._32bits; }
1440                else if (radio_64bits.Checked) { _data_type = SearchDataTypes._64bits; }
1441                else { logger.Error.WriteLine("Could not determine search data type bit size. (was not 8/16/32/or 64bits)"); }
1442                // get compare type
1443                if (radiocompare_equal.Checked) { _compare_type = SearchCompareTypes.Equal; }
1444                else if (radiocompare_greaterthan.Checked) { _compare_type = SearchCompareTypes.GreaterThan; }
1445                else if (radiocompare_lessthan.Checked) { _compare_type = SearchCompareTypes.LessThan; }
1446                else if (radiocompare_greaterthan_orequal.Checked) { _compare_type = SearchCompareTypes.GreaterThanOrEqual; }
1447                else if (radiocompare_lessthan_orequal.Checked) { _compare_type = SearchCompareTypes.LessThanOrEqual; }
1448                else if (radiocompare_notequal.Checked) { _compare_type = SearchCompareTypes.NotEqual; }
1449                else if (radiocompare_between.Checked) { _compare_type = SearchCompareTypes.Between; }
1450                else if (radiocompare_notbetween.Checked) { _compare_type = SearchCompareTypes.NotBetween; }
1451                else { logger.Error.WriteLine("Could not determine search comparison type. (was not == > < >= <= != <> or !<>)"); }
1452                // get compare valure type
1453                if (radio_oldvalue.Checked) { _compare_value_type = CompareValueTypes.OldValue; }
1454                else if (radio_specificvalue.Checked) { _compare_value_type = CompareValueTypes.SpecificValue; }
1455                else { logger.Error.WriteLine("Could not determine search comparison type. (was not old or specific value"); }
1456    
1457                if (_compare_value_type == CompareValueTypes.SpecificValue || (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween))
1458                {
1459    
1460                    switch (_data_type)
1461                    {
1462                        case SearchDataTypes._8bits:
1463                            if (_is_unsigned) { start_value = txtStartAddr.ToByte(); }
1464                            else { start_value = txtStartAddr.ToSByte(); }
1465                            break;
1466                        case SearchDataTypes._16bits:
1467                            if (_is_unsigned) { start_value = txtStartAddr.ToUInt16(); }
1468                            else { start_value = txtStartAddr.ToInt16(); }
1469                            break;
1470                        case SearchDataTypes._32bits:
1471                            if (_is_unsigned) { start_value = txtStartAddr.ToUInt32(); }
1472                            else { start_value = txtStartAddr.ToInt32(); }
1473                            break;
1474                        case SearchDataTypes._64bits:
1475                            if (_is_unsigned) { start_value = txtStartAddr.ToUInt64(); }
1476                            else { start_value = txtStartAddr.ToInt64(); }
1477                            break;
1478                        default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
1479                    }
1480                }
1481                if (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween)
1482                {
1483                    switch (_data_type)
1484                    {
1485                        case SearchDataTypes._8bits:
1486                            if (_is_unsigned) { end_value = txtEndAddr.ToByte(); }
1487                            else { end_value = txtEndAddr.ToSByte(); }
1488                            break;
1489                        case SearchDataTypes._16bits:
1490                            if (_is_unsigned) { end_value = txtEndAddr.ToUInt16(); }
1491                            else { end_value = txtEndAddr.ToInt16(); }
1492                            break;
1493                        case SearchDataTypes._32bits:
1494                            if (_is_unsigned) { end_value = txtEndAddr.ToUInt32(); }
1495                            else { end_value = txtEndAddr.ToInt32(); }
1496                            break;
1497                        case SearchDataTypes._64bits:
1498                            if (_is_unsigned) { end_value = txtEndAddr.ToUInt64(); }
1499                            else { end_value = txtEndAddr.ToInt64(); }
1500                            break;
1501                        default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
1502                    }
1503                }
1504    
1505                search_type = new SearchType(_data_type, _is_unsigned, _compare_type, _compare_value_type, start_value, end_value, resultsprogress);
1506    
1507                //search_type.LogSearchOptions();
1508    
1509                search_type.IsFirstSearch = IsFirstSearch;
1510    
1511    
1512    
1513                DoSearch(search_type);
1514                IsFirstSearch = false;
1515            }
1516            private void DoSearch(SearchType args)
1517            {
1518                if (!args.IsFirstSearch && SearchArgs != null)
1519                {
1520                    //args.Results.AddRange(SearchArgs.Results.ToArray());
1521                    args.Results = SearchArgs.Results;
1522                }
1523                SearchArgs = args;
1524    #if DONOT_HAVE_RANGED_SEARCH_SUPPORT
1525                if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1526                {
1527                    throw new NotImplementedException("Between and Not Between Range searches have not been implemented.");
1528                }
1529    #endif
1530                search_progress_updater.Enabled = true;
1531                //padPluginSelector.Enabled = false;
1532                //gsPluginSelector.Enabled = false;
1533                btnReset.Enabled = false;
1534                btnSearch.Enabled = false;
1535                btnCancel.Enabled = true;
1536                grpDataType.Enabled = false;
1537                grpCompareType.Enabled = false;
1538                grpCompareValue.Enabled = false;
1539                this.Refresh();
1540                Application.DoEvents();
1541                SearchWorkerThread.RunWorkerAsync();
1542            }
1543            #endregion
1544          private void btnReset_Click(object sender, EventArgs e)          private void btnReset_Click(object sender, EventArgs e)
1545          {          {
1546              this.SearchInProgess = false;              this.SearchInProgess = false;
1547              btnSearch.Enabled = true;              //btnSearch.Enabled = true;
1548              btnCancel.Enabled = false;              //btnCancel.Enabled = false;
1549                this.DoResetSpecific();
1550                lstResults.Items.Clear();
1551                try { SearchArgs.Results = new List<ResultType<object>>(); }
1552                catch { }
1553          }          }
1554    
1555          private void btnCancel_Click(object sender, EventArgs e)          private void btnCancel_Click(object sender, EventArgs e)
1556          {          {
1557              this.SearchInProgess = false;              this.SearchInProgess = false;
1558              btnCancel.Enabled = false;              //btnCancel.Enabled = false;
1559              btnSearch.Enabled = true;              //btnSearch.Enabled = true;
1560              btnReset.Enabled = true;              //btnReset.Enabled = true;
1561                this.DoCancelSpecific();
1562          }          }
1563    
1564          private void mnuItemPatchListViewMemoryRegion_Click(object sender, EventArgs e)          private void mnuItemPatchListViewMemoryRegion_Click(object sender, EventArgs e)

Legend:
Removed from v.277  
changed lines
  Added in v.280

  ViewVC Help
Powered by ViewVC 1.1.22