Add all the files

src/gui/MemorySearcherTool.h

@@ -0,0 +1,262 @@
+#pragma once
+
+#include <mutex>
+#include <thread>
+#include <atomic>
+
+#include "Cafe/HW/MMU/MMU.h"
+#include "util/helpers/helpers.h"
+#include "gui/helpers/wxCustomEvents.h"
+
+enum SearchDataType
+{
+	SearchDataType_None,
+	SearchDataType_String,
+	SearchDataType_Float,
+	SearchDataType_Double,
+	SearchDataType_Int8,
+	SearchDataType_Int16,
+	SearchDataType_Int32,
+	SearchDataType_Int64,
+};
+
+struct TableEntry_t
+{
+	uint32 address;
+	const char description[32];
+	SearchDataType type;
+	bool freeze;
+	uint16 dataLen;
+	uint8* data;
+};
+
+class MemorySearcherTool : public wxFrame
+{
+public:
+	MemorySearcherTool(wxFrame* parent);
+	virtual ~MemorySearcherTool();
+
+	void OnTimerTick(wxTimerEvent& event);
+	void OnClose(wxCloseEvent&);
+	void OnSearch(wxCommandEvent&);
+	void OnSearchFinished(wxCommandEvent& event);
+	void OnUpdateGauge(wxSetGaugeValue& event);
+	void OnFilter(wxCommandEvent& event);
+	void OnResultListClick(wxMouseEvent& event);
+	void OnEntryListRightClick(wxDataViewEvent& event);
+	//void OnEntryListRightClick2(wxContextMenuEvent& event);
+	void OnPopupClick(wxCommandEvent& event);
+
+	void OnItemEdited(wxDataViewEvent& event);
+
+private:
+	void Reset();
+	bool VerifySearchValue() const;
+	void FillResultList();
+	void RefreshResultList();
+	void RefreshStashList();
+	void SetSearchDataType();
+	std::string GetSearchTypeName() const;
+	void CreateRightClickPopupMenu();
+
+	void Load();
+	void Save();
+
+	static bool IsAddressValid(uint32 addr);
+
+	template <typename T>
+	bool ConvertStringToType(const char* inValue, T& outValue) const
+	{
+		std::istringstream iss(inValue);
+		iss >> std::noskipws >> outValue;
+		return iss && iss.eof();
+	}
+	
+	template <>
+	bool ConvertStringToType(const char* inValue, sint8& outValue) const;
+
+	using ListType_t = std::vector<MEMPTR<void>>;
+	ListType_t SearchValues(SearchDataType type, void* ptr, uint32 size)
+	{
+		/*if (type == SearchDataType_String)
+			return SearchValues((const char* )ptr, size);
+		else */if (type == SearchDataType_Float)
+			return SearchValues((float*)ptr, size);
+		else if (type == SearchDataType_Double)
+			return SearchValues((double*)ptr, size);
+		else if (type == SearchDataType_Int8)
+			return SearchValues((sint8*)ptr, size);
+		else if (type == SearchDataType_Int16)
+			return SearchValues((sint16*)ptr, size);
+		else if (type == SearchDataType_Int32)
+			return SearchValues((sint32*)ptr, size);
+		else if (type == SearchDataType_Int64)
+			return SearchValues((sint64*)ptr, size);
+		return {};
+	}
+	
+	ListType_t FilterValues(SearchDataType type)
+	{
+		/*if (type == SearchDataType_String)
+			return FilterValues<const char*>();
+		else */if (type == SearchDataType_Float)
+			return FilterValues<float>();
+		else if (type == SearchDataType_Double)
+			return FilterValues<double>();
+		else if (type == SearchDataType_Int8)
+			return FilterValues<sint8>();
+		else if (type == SearchDataType_Int16)
+			return FilterValues<sint16>();
+		else if (type == SearchDataType_Int32)
+			return FilterValues<sint32>();
+		else if (type == SearchDataType_Int64)
+			return FilterValues<sint64>();
+		return {};
+	}
+
+	constexpr static int kGaugeStep = 0x10000;
+
+	template <typename T>
+	ListType_t SearchValues(T* ptr, uint32 size)
+	{
+		const auto value = m_textValue->GetValue();
+		const auto* string_value = value.c_str().AsChar();
+		const auto search_value = ConvertString<T>(string_value);
+
+		const auto* end = (T*)((uint8*)ptr + size - sizeof(T));
+
+		uint32 counter = 0;
+		std::vector<MEMPTR<void>> result;
+		for (; ptr < end; ++ptr)
+		{
+			if (!m_running)
+				return result;
+
+			const auto tmp = (betype<T>*)ptr;
+			if (equals(search_value, tmp->value()))
+				result.emplace_back(ptr);
+
+			counter += sizeof(T);
+			if(counter >= kGaugeStep)
+			{
+				wxQueueEvent(this, new wxSetGaugeValue(1, m_gauge));
+				counter -= kGaugeStep;
+			}
+		}
+
+		return result;
+	}
+
+	template <typename T>
+	ListType_t FilterValues()
+	{
+		const auto value = m_textValue->GetValue();
+		const auto* string_value = value.c_str().AsChar();
+		const auto search_value = ConvertString<T>(string_value);
+
+		ListType_t newSearchBuffer;
+		newSearchBuffer.reserve(m_searchBuffer.size());
+
+		for (const auto& it : m_searchBuffer)
+		{
+			if (!m_running)
+				return newSearchBuffer;
+
+			const auto tmp = (betype<T>*)it.GetPtr();
+			if (equals(search_value , tmp->value()))
+				newSearchBuffer.emplace_back(it);
+			
+			wxQueueEvent(this, new wxSetGaugeValue(1, m_gauge));
+		}
+
+		return newSearchBuffer;
+	}
+
+wxDECLARE_EVENT_TABLE();
+
+	SearchDataType m_searchDataType = SearchDataType_None;
+	wxComboBox* m_cbDataType;
+	wxTextCtrl* m_textValue;
+	wxButton *m_buttonStart, *m_buttonFilter;
+	wxListCtrl* m_listResults;
+	wxDataViewListCtrl* m_listEntryTable;
+	wxStaticText* m_textEntryTable;
+	wxGauge* m_gauge;
+	wxTimer* m_refresh_timer;
+
+	ListType_t m_searchBuffer;
+	std::vector<TableEntry_t> m_tableEntries;
+	
+	std::mutex m_mutex;
+	std::thread m_worker;
+
+	std::atomic_bool m_running = true;
+	std::atomic_bool m_search_running = false;
+	std::vector<std::future<ListType_t>> m_search_jobs;
+
+	bool m_clear_state = false;
+};
+
+
+
+
+//
+//template <typename T>
+//void MemorySearcherTool::FilterValues()
+//{
+//	auto s1 = m_textValue->GetValue();
+//	auto s2 = s1.c_str();
+//	auto stringValue = s2.AsChar();
+//
+//	T filterValue;
+//	ConvertStringToType(stringValue, filterValue);
+//
+//	std::vector<uint32> newSearchBuffer;
+//	newSearchBuffer.reserve(m_searchBuffer.size());
+//
+//	uint32 gaugeValue = 0;
+//	uint32 count = m_searchBuffer.size();
+//	uint32 counter = 0;
+//
+//	for (auto it = m_searchBuffer.begin(); it != m_searchBuffer.end(); ++it)
+//	{
+//		if (m_running)
+//			return;
+//
+//		T value = memory_read<T>(*it);
+//		if constexpr (std::is_same<T, float>::value)
+//		{
+//			//float value1 = filterValue * 0.95f;
+//			float diff = filterValue - value;
+//			diff = fabs(diff);
+//			if(diff < value*0.05f)
+//			{
+//				newSearchBuffer.push_back(*it);
+//			}
+//
+//		}
+//		else
+//		{
+//			if (value == filterValue)
+//			{
+//				newSearchBuffer.push_back(*it);
+//			}
+//		}
+//
+//		++counter;
+//		uint32 newValue = counter * 100 / count;
+//		if (newValue > gaugeValue + GAUGE_STEP_SIZE)
+//		{
+//			gaugeValue = newValue;
+//			m_gaugeValue = newValue;
+//		}
+//	}
+//
+//	m_mutex.lock();
+//	m_searchBuffer = newSearchBuffer;
+//	m_gaugeValue = 100;
+//	m_mutex.unlock();
+//	m_isSearchFinished = true;
+//}
+//
+