mirror of
https://github.com/NohamR/Reclass.git
synced 2026-05-10 19:59:21 +00:00
feat: scanner panel with signature/value search, rescan, address delegate
- Signature mode (IDA-style patterns with wildcards) and value mode (typed exact match) - Async scan engine with progress, cancel support - Re-scan updates all results with unified progress (single-pass read + table build) - Previous value column appears after first re-scan - WinDbg backtick address format with dimmed leading zeros (AddressDelegate) - Inline editing: address expressions navigate, value edits write to provider - Right-click context menu: Copy Address, Copy Value, Go to Address - Auto-sized columns, themed buttons with icons, dynamic combo width - 49 UI tests covering scan, rescan, editing, theming, progress completion
This commit is contained in:
IChooseYou
@@ -57,5 +57,8 @@
|
||||
<file alias="remote.svg">vsicons/remote.svg</file>
|
||||
<file alias="plug.svg">vsicons/plug.svg</file>
|
||||
<file alias="clear-all.svg">vsicons/clear-all.svg</file>
|
||||
<file alias="search.svg">vsicons/search.svg</file>
|
||||
<file alias="regex.svg">vsicons/regex.svg</file>
|
||||
<file alias="refresh.svg">vsicons/refresh.svg</file>
|
||||
</qresource>
|
||||
</RCC>
|
||||
|
||||
507
src/scanner.cpp
Normal file
507
src/scanner.cpp
Normal file
@@ -0,0 +1,507 @@
|
||||
#include "scanner.h"
|
||||
#include <QtConcurrent>
|
||||
#include <QMetaObject>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
|
||||
namespace rcx {
|
||||
|
||||
// ── Pattern parsing ──
|
||||
|
||||
static int hexVal(QChar c) {
|
||||
ushort u = c.unicode();
|
||||
if (u >= '0' && u <= '9') return u - '0';
|
||||
if (u >= 'a' && u <= 'f') return u - 'a' + 10;
|
||||
if (u >= 'A' && u <= 'F') return u - 'A' + 10;
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool parseSignature(const QString& input, QByteArray& pattern, QByteArray& mask,
|
||||
QString* errorMsg)
|
||||
{
|
||||
pattern.clear();
|
||||
mask.clear();
|
||||
|
||||
QString trimmed = input.trimmed();
|
||||
if (trimmed.isEmpty()) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Empty pattern");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check for C-style: \xAB\xCD
|
||||
if (trimmed.startsWith(QStringLiteral("\\x"))) {
|
||||
QStringList parts = trimmed.split(QStringLiteral("\\x"), Qt::SkipEmptyParts);
|
||||
for (const QString& part : parts) {
|
||||
if (part.size() != 2) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid C-style byte: \\x%1").arg(part);
|
||||
return false;
|
||||
}
|
||||
int hi = hexVal(part[0]);
|
||||
int lo = hexVal(part[1]);
|
||||
if (hi < 0 || lo < 0) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid hex char in: \\x%1").arg(part);
|
||||
return false;
|
||||
}
|
||||
pattern.append(char((hi << 4) | lo));
|
||||
mask.append(char(0xFF));
|
||||
}
|
||||
return !pattern.isEmpty();
|
||||
}
|
||||
|
||||
// Space-separated or packed hex
|
||||
bool hasSpaces = trimmed.contains(' ');
|
||||
|
||||
if (hasSpaces) {
|
||||
QStringList tokens = trimmed.split(' ', Qt::SkipEmptyParts);
|
||||
for (const QString& tok : tokens) {
|
||||
if (tok == QStringLiteral("??") || tok == QStringLiteral("?")) {
|
||||
pattern.append(char(0));
|
||||
mask.append(char(0));
|
||||
} else if (tok.size() == 2) {
|
||||
int hi = hexVal(tok[0]);
|
||||
int lo = hexVal(tok[1]);
|
||||
if (hi < 0 || lo < 0) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid hex byte: %1").arg(tok);
|
||||
return false;
|
||||
}
|
||||
pattern.append(char((hi << 4) | lo));
|
||||
mask.append(char(0xFF));
|
||||
} else {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid token: %1 (expected 2 hex chars or wildcards)").arg(tok);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Packed: "488B??05"
|
||||
if (trimmed.size() % 2 != 0) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Odd number of characters in packed pattern");
|
||||
return false;
|
||||
}
|
||||
for (int i = 0; i < trimmed.size(); i += 2) {
|
||||
QChar c0 = trimmed[i], c1 = trimmed[i + 1];
|
||||
if ((c0 == '?' && c1 == '?')) {
|
||||
pattern.append(char(0));
|
||||
mask.append(char(0));
|
||||
} else {
|
||||
int hi = hexVal(c0);
|
||||
int lo = hexVal(c1);
|
||||
if (hi < 0 || lo < 0) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid hex chars at position %1: %2%3")
|
||||
.arg(i).arg(c0).arg(c1);
|
||||
return false;
|
||||
}
|
||||
pattern.append(char((hi << 4) | lo));
|
||||
mask.append(char(0xFF));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pattern.isEmpty()) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Empty pattern after parsing");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// ── Value serialization ──
|
||||
|
||||
template<typename T>
|
||||
static void appendLE(QByteArray& out, T val) {
|
||||
out.append(reinterpret_cast<const char*>(&val), sizeof(T));
|
||||
}
|
||||
|
||||
bool serializeValue(ValueType type, const QString& input,
|
||||
QByteArray& pattern, QByteArray& mask,
|
||||
QString* errorMsg)
|
||||
{
|
||||
pattern.clear();
|
||||
mask.clear();
|
||||
|
||||
QString trimmed = input.trimmed();
|
||||
if (trimmed.isEmpty()) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Empty value");
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ok = false;
|
||||
|
||||
switch (type) {
|
||||
case ValueType::Int8: {
|
||||
int v = trimmed.toInt(&ok);
|
||||
if (!ok || v < -128 || v > 127) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid int8 value");
|
||||
return false;
|
||||
}
|
||||
appendLE<int8_t>(pattern, (int8_t)v);
|
||||
break;
|
||||
}
|
||||
case ValueType::Int16: {
|
||||
int v = trimmed.toInt(&ok);
|
||||
if (!ok || v < -32768 || v > 32767) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid int16 value");
|
||||
return false;
|
||||
}
|
||||
appendLE<int16_t>(pattern, (int16_t)v);
|
||||
break;
|
||||
}
|
||||
case ValueType::Int32: {
|
||||
int v = trimmed.toInt(&ok);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid int32 value");
|
||||
return false;
|
||||
}
|
||||
appendLE<int32_t>(pattern, (int32_t)v);
|
||||
break;
|
||||
}
|
||||
case ValueType::Int64: {
|
||||
qlonglong v = trimmed.toLongLong(&ok);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid int64 value");
|
||||
return false;
|
||||
}
|
||||
appendLE<int64_t>(pattern, (int64_t)v);
|
||||
break;
|
||||
}
|
||||
case ValueType::UInt8: {
|
||||
uint v = trimmed.toUInt(&ok);
|
||||
if (!ok || v > 255) {
|
||||
// Try hex
|
||||
if (trimmed.startsWith("0x", Qt::CaseInsensitive))
|
||||
v = trimmed.toUInt(&ok, 16);
|
||||
if (!ok || v > 255) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid uint8 value");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
appendLE<uint8_t>(pattern, (uint8_t)v);
|
||||
break;
|
||||
}
|
||||
case ValueType::UInt16: {
|
||||
uint v = trimmed.toUInt(&ok);
|
||||
if (!ok || v > 65535) {
|
||||
if (trimmed.startsWith("0x", Qt::CaseInsensitive))
|
||||
v = trimmed.toUInt(&ok, 16);
|
||||
if (!ok || v > 65535) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid uint16 value");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
appendLE<uint16_t>(pattern, (uint16_t)v);
|
||||
break;
|
||||
}
|
||||
case ValueType::UInt32: {
|
||||
quint32 v = trimmed.toULong(&ok);
|
||||
if (!ok) {
|
||||
if (trimmed.startsWith("0x", Qt::CaseInsensitive))
|
||||
v = trimmed.toULong(&ok, 16);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid uint32 value");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
appendLE<uint32_t>(pattern, v);
|
||||
break;
|
||||
}
|
||||
case ValueType::UInt64: {
|
||||
quint64 v = trimmed.toULongLong(&ok);
|
||||
if (!ok) {
|
||||
if (trimmed.startsWith("0x", Qt::CaseInsensitive))
|
||||
v = trimmed.toULongLong(&ok, 16);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid uint64 value");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
appendLE<uint64_t>(pattern, v);
|
||||
break;
|
||||
}
|
||||
case ValueType::Float: {
|
||||
float v = trimmed.toFloat(&ok);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid float value");
|
||||
return false;
|
||||
}
|
||||
appendLE<float>(pattern, v);
|
||||
break;
|
||||
}
|
||||
case ValueType::Double: {
|
||||
double v = trimmed.toDouble(&ok);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid double value");
|
||||
return false;
|
||||
}
|
||||
appendLE<double>(pattern, v);
|
||||
break;
|
||||
}
|
||||
case ValueType::Vec2: {
|
||||
QStringList parts = trimmed.split(QRegularExpression("\\s+"), Qt::SkipEmptyParts);
|
||||
if (parts.size() != 2) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Vec2 requires 2 space-separated floats");
|
||||
return false;
|
||||
}
|
||||
for (const QString& p : parts) {
|
||||
float v = p.toFloat(&ok);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid float in vec2: %1").arg(p);
|
||||
return false;
|
||||
}
|
||||
appendLE<float>(pattern, v);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ValueType::Vec3: {
|
||||
QStringList parts = trimmed.split(QRegularExpression("\\s+"), Qt::SkipEmptyParts);
|
||||
if (parts.size() != 3) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Vec3 requires 3 space-separated floats");
|
||||
return false;
|
||||
}
|
||||
for (const QString& p : parts) {
|
||||
float v = p.toFloat(&ok);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid float in vec3: %1").arg(p);
|
||||
return false;
|
||||
}
|
||||
appendLE<float>(pattern, v);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ValueType::Vec4: {
|
||||
QStringList parts = trimmed.split(QRegularExpression("\\s+"), Qt::SkipEmptyParts);
|
||||
if (parts.size() != 4) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Vec4 requires 4 space-separated floats");
|
||||
return false;
|
||||
}
|
||||
for (const QString& p : parts) {
|
||||
float v = p.toFloat(&ok);
|
||||
if (!ok) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Invalid float in vec4: %1").arg(p);
|
||||
return false;
|
||||
}
|
||||
appendLE<float>(pattern, v);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ValueType::UTF8: {
|
||||
QByteArray encoded = trimmed.toUtf8();
|
||||
if (encoded.isEmpty()) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Empty UTF-8 string");
|
||||
return false;
|
||||
}
|
||||
pattern = encoded;
|
||||
break;
|
||||
}
|
||||
case ValueType::UTF16: {
|
||||
// UTF-16LE encoding
|
||||
for (int i = 0; i < trimmed.size(); i++) {
|
||||
ushort u = trimmed[i].unicode();
|
||||
appendLE<uint16_t>(pattern, u);
|
||||
}
|
||||
if (pattern.isEmpty()) {
|
||||
if (errorMsg) *errorMsg = QStringLiteral("Empty UTF-16 string");
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ValueType::HexBytes: {
|
||||
// Parse hex bytes (like signature but no wildcards)
|
||||
QByteArray dummyMask;
|
||||
if (!parseSignature(trimmed, pattern, dummyMask, errorMsg))
|
||||
return false;
|
||||
// HexBytes = exact match, no wildcards
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Set mask to all 0xFF (exact match) for value scans
|
||||
mask.fill(char(0xFF), pattern.size());
|
||||
return true;
|
||||
}
|
||||
|
||||
int naturalAlignment(ValueType type) {
|
||||
switch (type) {
|
||||
case ValueType::Int8:
|
||||
case ValueType::UInt8:
|
||||
case ValueType::UTF8:
|
||||
case ValueType::HexBytes:
|
||||
return 1;
|
||||
case ValueType::Int16:
|
||||
case ValueType::UInt16:
|
||||
case ValueType::UTF16:
|
||||
return 2;
|
||||
case ValueType::Int32:
|
||||
case ValueType::UInt32:
|
||||
case ValueType::Float:
|
||||
case ValueType::Vec2:
|
||||
case ValueType::Vec3:
|
||||
case ValueType::Vec4:
|
||||
return 4;
|
||||
case ValueType::Int64:
|
||||
case ValueType::UInt64:
|
||||
case ValueType::Double:
|
||||
return 8;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
// ── Scan engine ──
|
||||
|
||||
ScanEngine::ScanEngine(QObject* parent)
|
||||
: QObject(parent)
|
||||
{
|
||||
qRegisterMetaType<QVector<ScanResult>>("QVector<rcx::ScanResult>");
|
||||
}
|
||||
|
||||
bool ScanEngine::isRunning() const {
|
||||
return m_watcher && m_watcher->isRunning();
|
||||
}
|
||||
|
||||
void ScanEngine::abort() {
|
||||
m_abort.store(true);
|
||||
}
|
||||
|
||||
void ScanEngine::start(std::shared_ptr<Provider> provider, const ScanRequest& req) {
|
||||
if (isRunning()) return;
|
||||
|
||||
if (req.pattern.isEmpty()) {
|
||||
emit error(QStringLiteral("Empty pattern"));
|
||||
return;
|
||||
}
|
||||
if (req.pattern.size() != req.mask.size()) {
|
||||
emit error(QStringLiteral("Pattern and mask size mismatch"));
|
||||
return;
|
||||
}
|
||||
|
||||
m_abort.store(false);
|
||||
|
||||
auto* watcher = new QFutureWatcher<QVector<ScanResult>>(this);
|
||||
m_watcher = watcher;
|
||||
|
||||
connect(watcher, &QFutureWatcher<QVector<ScanResult>>::finished, this, [this, watcher]() {
|
||||
auto results = watcher->result();
|
||||
watcher->deleteLater();
|
||||
if (m_watcher == watcher)
|
||||
m_watcher = nullptr;
|
||||
emit finished(results);
|
||||
});
|
||||
|
||||
watcher->setFuture(QtConcurrent::run([this, provider, req]() {
|
||||
return runScan(provider, req);
|
||||
}));
|
||||
}
|
||||
|
||||
QVector<ScanResult> ScanEngine::runScan(std::shared_ptr<Provider> prov,
|
||||
const ScanRequest& req)
|
||||
{
|
||||
QVector<ScanResult> results;
|
||||
|
||||
if (!prov || req.pattern.isEmpty())
|
||||
return results;
|
||||
|
||||
auto regions = prov->enumerateRegions();
|
||||
|
||||
// Fallback for providers that don't enumerate regions (file/buffer)
|
||||
if (regions.isEmpty()) {
|
||||
MemoryRegion fallback;
|
||||
fallback.base = 0;
|
||||
fallback.size = (uint64_t)prov->size();
|
||||
fallback.readable = true;
|
||||
fallback.writable = true;
|
||||
fallback.executable = false;
|
||||
regions.append(fallback);
|
||||
}
|
||||
|
||||
const int patternLen = req.pattern.size();
|
||||
const char* pat = req.pattern.constData();
|
||||
const char* msk = req.mask.constData();
|
||||
const int alignment = qMax(1, req.alignment);
|
||||
|
||||
// Pre-compute total bytes for progress
|
||||
uint64_t totalBytes = 0;
|
||||
for (const auto& r : regions) {
|
||||
if (req.filterExecutable && !r.executable) continue;
|
||||
if (req.filterWritable && !r.writable) continue;
|
||||
totalBytes += r.size;
|
||||
}
|
||||
|
||||
if (totalBytes == 0) return results;
|
||||
|
||||
uint64_t scannedBytes = 0;
|
||||
int lastPct = -1;
|
||||
|
||||
constexpr int kChunk = 256 * 1024;
|
||||
|
||||
for (const auto& region : regions) {
|
||||
if (m_abort.load()) break;
|
||||
|
||||
if (req.filterExecutable && !region.executable) continue;
|
||||
if (req.filterWritable && !region.writable) continue;
|
||||
|
||||
if ((uint64_t)patternLen > region.size) {
|
||||
scannedBytes += region.size;
|
||||
continue;
|
||||
}
|
||||
|
||||
const int overlap = patternLen - 1;
|
||||
QByteArray chunk(qMin((uint64_t)kChunk, region.size), Qt::Uninitialized);
|
||||
|
||||
for (uint64_t off = 0; off < region.size; ) {
|
||||
if (m_abort.load()) break;
|
||||
|
||||
uint64_t remaining = region.size - off;
|
||||
int readLen = (int)qMin((uint64_t)chunk.size(), remaining);
|
||||
|
||||
if (!prov->read(region.base + off, chunk.data(), readLen)) {
|
||||
// Skip unreadable chunk
|
||||
off += readLen;
|
||||
scannedBytes += readLen;
|
||||
continue;
|
||||
}
|
||||
|
||||
int scanEnd = readLen - patternLen;
|
||||
const char* data = chunk.constData();
|
||||
|
||||
for (int i = 0; i <= scanEnd; i += alignment) {
|
||||
bool match = true;
|
||||
for (int j = 0; j < patternLen; j++) {
|
||||
if ((data[i + j] & msk[j]) != (pat[j] & msk[j])) {
|
||||
match = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (match) {
|
||||
ScanResult r;
|
||||
r.address = region.base + off + (uint64_t)i;
|
||||
r.regionModule = region.moduleName;
|
||||
results.append(r);
|
||||
|
||||
if (results.size() >= req.maxResults)
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
// Advance with overlap to catch patterns that straddle chunks
|
||||
uint64_t advance;
|
||||
if (readLen > overlap)
|
||||
advance = (uint64_t)(readLen - overlap);
|
||||
else
|
||||
advance = 1; // prevent infinite loop on tiny regions
|
||||
scannedBytes += advance;
|
||||
off += advance;
|
||||
|
||||
// Throttled progress
|
||||
int pct = (int)(scannedBytes * 100 / totalBytes);
|
||||
if (pct > 100) pct = 100;
|
||||
if (pct != lastPct) {
|
||||
lastPct = pct;
|
||||
QMetaObject::invokeMethod(this, "progress",
|
||||
Qt::QueuedConnection, Q_ARG(int, pct));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
return results;
|
||||
}
|
||||
|
||||
} // namespace rcx
|
||||
85
src/scanner.h
Normal file
85
src/scanner.h
Normal file
@@ -0,0 +1,85 @@
|
||||
#pragma once
|
||||
#include "providers/provider.h"
|
||||
#include <QObject>
|
||||
#include <QByteArray>
|
||||
#include <QString>
|
||||
#include <QVector>
|
||||
#include <QFutureWatcher>
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
|
||||
namespace rcx {
|
||||
|
||||
// ── Scan request / result ──
|
||||
|
||||
struct ScanRequest {
|
||||
QByteArray pattern; // literal bytes to match
|
||||
QByteArray mask; // 0xFF = must match, 0x00 = wildcard
|
||||
|
||||
bool filterExecutable = false; // only scan +x regions
|
||||
bool filterWritable = false; // only scan +w regions
|
||||
|
||||
int alignment = 1; // 1 = every byte, 4 = dword, 8 = qword
|
||||
int maxResults = 50000;
|
||||
};
|
||||
|
||||
struct ScanResult {
|
||||
uint64_t address;
|
||||
QString regionModule;
|
||||
QByteArray scanValue; // cached bytes at scan/update time
|
||||
QByteArray previousValue; // value before last update
|
||||
};
|
||||
|
||||
// ── Value scan types ──
|
||||
|
||||
enum class ValueType {
|
||||
Int8, Int16, Int32, Int64,
|
||||
UInt8, UInt16, UInt32, UInt64,
|
||||
Float, Double,
|
||||
Vec2, Vec3, Vec4,
|
||||
UTF8, UTF16,
|
||||
HexBytes
|
||||
};
|
||||
|
||||
// ── Pattern parsing ──
|
||||
|
||||
// Parse IDA-style signature string ("48 8B ?? 05") into pattern + mask.
|
||||
// Returns true on success. On failure, sets errorMsg.
|
||||
bool parseSignature(const QString& input, QByteArray& pattern, QByteArray& mask,
|
||||
QString* errorMsg = nullptr);
|
||||
|
||||
// Serialize a typed value into raw bytes for exact-match scanning.
|
||||
// Returns true on success. On failure, sets errorMsg.
|
||||
bool serializeValue(ValueType type, const QString& input,
|
||||
QByteArray& pattern, QByteArray& mask,
|
||||
QString* errorMsg = nullptr);
|
||||
|
||||
// Natural alignment for a value type (used as default alignment for value scans).
|
||||
int naturalAlignment(ValueType type);
|
||||
|
||||
// ── Scan engine ──
|
||||
|
||||
class ScanEngine : public QObject {
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit ScanEngine(QObject* parent = nullptr);
|
||||
|
||||
void start(std::shared_ptr<Provider> provider, const ScanRequest& req);
|
||||
void abort();
|
||||
bool isRunning() const;
|
||||
|
||||
signals:
|
||||
void progress(int percent);
|
||||
void finished(QVector<ScanResult> results);
|
||||
void error(QString message);
|
||||
|
||||
private:
|
||||
QVector<ScanResult> runScan(std::shared_ptr<Provider> prov, const ScanRequest& req);
|
||||
|
||||
std::atomic<bool> m_abort{false};
|
||||
QFutureWatcher<QVector<ScanResult>>* m_watcher = nullptr;
|
||||
};
|
||||
|
||||
} // namespace rcx
|
||||
|
||||
Q_DECLARE_METATYPE(QVector<rcx::ScanResult>)
|
||||
726
src/scannerpanel.cpp
Normal file
726
src/scannerpanel.cpp
Normal file
@@ -0,0 +1,726 @@
|
||||
#include "scannerpanel.h"
|
||||
#include "addressparser.h"
|
||||
#include <cstring>
|
||||
#include <QVBoxLayout>
|
||||
#include <QHBoxLayout>
|
||||
#include <QHeaderView>
|
||||
#include <QClipboard>
|
||||
#include <QApplication>
|
||||
#include <QMenu>
|
||||
#include <QPainter>
|
||||
|
||||
namespace rcx {
|
||||
|
||||
void AddressDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
|
||||
const QModelIndex& index) const {
|
||||
// Draw background (selection/hover handled by style)
|
||||
QStyleOptionViewItem opt = option;
|
||||
initStyleOption(&opt, index);
|
||||
opt.text.clear();
|
||||
QApplication::style()->drawControl(QStyle::CE_ItemViewItem, &opt, painter);
|
||||
|
||||
QString text = index.data(Qt::DisplayRole).toString();
|
||||
if (text.isEmpty()) return;
|
||||
|
||||
// Find first non-zero hex digit (skip backtick)
|
||||
int dimEnd = 0;
|
||||
for (int i = 0; i < text.size(); i++) {
|
||||
QChar c = text[i];
|
||||
if (c == '`') { dimEnd = i + 1; continue; }
|
||||
if (c != '0') break;
|
||||
dimEnd = i + 1;
|
||||
}
|
||||
|
||||
QRect textRect = opt.rect.adjusted(7, 0, -4, 0); // match item padding
|
||||
painter->setFont(opt.font);
|
||||
|
||||
if (dimEnd > 0) {
|
||||
painter->setPen(dimColor);
|
||||
painter->drawText(textRect, Qt::AlignLeft | Qt::AlignVCenter, text.left(dimEnd));
|
||||
// Advance past dim prefix
|
||||
int dimWidth = painter->fontMetrics().horizontalAdvance(text.left(dimEnd));
|
||||
textRect.setLeft(textRect.left() + dimWidth);
|
||||
}
|
||||
painter->setPen(brightColor);
|
||||
painter->drawText(textRect, Qt::AlignLeft | Qt::AlignVCenter, text.mid(dimEnd));
|
||||
}
|
||||
|
||||
ScannerPanel::ScannerPanel(QWidget* parent)
|
||||
: QWidget(parent)
|
||||
, m_engine(new ScanEngine(this))
|
||||
{
|
||||
auto* mainLayout = new QVBoxLayout(this);
|
||||
mainLayout->setContentsMargins(6, 6, 6, 6);
|
||||
mainLayout->setSpacing(4);
|
||||
|
||||
// ── Row 1: Mode + pattern/value input ──
|
||||
auto* inputRow = new QHBoxLayout;
|
||||
inputRow->setSpacing(6);
|
||||
|
||||
m_modeCombo = new QComboBox(this);
|
||||
m_modeCombo->addItem(QIcon(QStringLiteral(":/vsicons/regex.svg")),
|
||||
QStringLiteral("Signature"));
|
||||
m_modeCombo->addItem(QIcon(QStringLiteral(":/vsicons/symbol-variable.svg")),
|
||||
QStringLiteral("Value"));
|
||||
updateComboWidth();
|
||||
inputRow->addWidget(m_modeCombo);
|
||||
|
||||
// Signature input
|
||||
m_patternLabel = new QLabel(QStringLiteral("Pattern:"), this);
|
||||
inputRow->addWidget(m_patternLabel);
|
||||
|
||||
m_patternEdit = new QLineEdit(this);
|
||||
m_patternEdit->setPlaceholderText(QStringLiteral("48 8B ?? 05 ?? ?? ?? ?? CC"));
|
||||
inputRow->addWidget(m_patternEdit, 1);
|
||||
|
||||
// Value input (hidden initially)
|
||||
m_typeLabel = new QLabel(QStringLiteral("Type:"), this);
|
||||
inputRow->addWidget(m_typeLabel);
|
||||
|
||||
m_typeCombo = new QComboBox(this);
|
||||
m_typeCombo->addItem(QStringLiteral("int8"), (int)ValueType::Int8);
|
||||
m_typeCombo->addItem(QStringLiteral("int16"), (int)ValueType::Int16);
|
||||
m_typeCombo->addItem(QStringLiteral("int32"), (int)ValueType::Int32);
|
||||
m_typeCombo->addItem(QStringLiteral("int64"), (int)ValueType::Int64);
|
||||
m_typeCombo->addItem(QStringLiteral("uint8"), (int)ValueType::UInt8);
|
||||
m_typeCombo->addItem(QStringLiteral("uint16"), (int)ValueType::UInt16);
|
||||
m_typeCombo->addItem(QStringLiteral("uint32"), (int)ValueType::UInt32);
|
||||
m_typeCombo->addItem(QStringLiteral("uint64"), (int)ValueType::UInt64);
|
||||
m_typeCombo->addItem(QStringLiteral("float"), (int)ValueType::Float);
|
||||
m_typeCombo->addItem(QStringLiteral("double"), (int)ValueType::Double);
|
||||
m_typeCombo->setCurrentIndex(2); // default: int32
|
||||
inputRow->addWidget(m_typeCombo);
|
||||
|
||||
m_valueLabel = new QLabel(QStringLiteral("Value:"), this);
|
||||
inputRow->addWidget(m_valueLabel);
|
||||
|
||||
m_valueEdit = new QLineEdit(this);
|
||||
m_valueEdit->setPlaceholderText(QStringLiteral("12345"));
|
||||
inputRow->addWidget(m_valueEdit, 1);
|
||||
|
||||
mainLayout->addLayout(inputRow);
|
||||
|
||||
// ── Row 2: Filters + scan button + progress ──
|
||||
auto* filterRow = new QHBoxLayout;
|
||||
filterRow->setSpacing(6);
|
||||
|
||||
m_execCheck = new QCheckBox(QStringLiteral("Executable"), this);
|
||||
filterRow->addWidget(m_execCheck);
|
||||
|
||||
m_writeCheck = new QCheckBox(QStringLiteral("Writable"), this);
|
||||
filterRow->addWidget(m_writeCheck);
|
||||
|
||||
filterRow->addStretch();
|
||||
|
||||
m_scanBtn = new QPushButton(QIcon(QStringLiteral(":/vsicons/search.svg")),
|
||||
QStringLiteral("Scan"), this);
|
||||
filterRow->addWidget(m_scanBtn);
|
||||
|
||||
m_updateBtn = new QPushButton(QIcon(QStringLiteral(":/vsicons/refresh.svg")),
|
||||
QStringLiteral("Re-scan"), this);
|
||||
m_updateBtn->setEnabled(false);
|
||||
filterRow->addWidget(m_updateBtn);
|
||||
|
||||
m_progressBar = new QProgressBar(this);
|
||||
m_progressBar->setRange(0, 100);
|
||||
m_progressBar->setTextVisible(true);
|
||||
m_progressBar->setFixedWidth(150);
|
||||
m_progressBar->hide();
|
||||
filterRow->addWidget(m_progressBar);
|
||||
|
||||
mainLayout->addLayout(filterRow);
|
||||
|
||||
// ── Results table ──
|
||||
m_resultTable = new QTableWidget(this);
|
||||
m_resultTable->setColumnCount(2);
|
||||
m_resultTable->horizontalHeader()->hide();
|
||||
m_resultTable->verticalHeader()->hide();
|
||||
m_resultTable->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
|
||||
m_resultTable->horizontalHeader()->setStretchLastSection(false);
|
||||
m_resultTable->setSelectionBehavior(QAbstractItemView::SelectRows);
|
||||
m_resultTable->setSelectionMode(QAbstractItemView::SingleSelection);
|
||||
m_resultTable->setEditTriggers(QAbstractItemView::DoubleClicked);
|
||||
m_resultTable->setShowGrid(false);
|
||||
m_resultTable->setMouseTracking(true);
|
||||
m_resultTable->setFocusPolicy(Qt::StrongFocus);
|
||||
m_resultTable->setContextMenuPolicy(Qt::CustomContextMenu);
|
||||
|
||||
// Address column delegate for dimmed leading zeros
|
||||
m_addrDelegate = new AddressDelegate(this);
|
||||
m_resultTable->setItemDelegateForColumn(0, m_addrDelegate);
|
||||
mainLayout->addWidget(m_resultTable, 1);
|
||||
|
||||
// ── Row 3: Status + action buttons ──
|
||||
auto* actionRow = new QHBoxLayout;
|
||||
actionRow->setSpacing(6);
|
||||
|
||||
m_statusLabel = new QLabel(QStringLiteral("Ready"), this);
|
||||
actionRow->addWidget(m_statusLabel, 1);
|
||||
|
||||
m_gotoBtn = new QPushButton(QIcon(QStringLiteral(":/vsicons/arrow-right.svg")),
|
||||
QStringLiteral("Go to Address"), this);
|
||||
m_gotoBtn->setEnabled(false);
|
||||
actionRow->addWidget(m_gotoBtn);
|
||||
|
||||
m_copyBtn = new QPushButton(QIcon(QStringLiteral(":/vsicons/clippy.svg")),
|
||||
QStringLiteral("Copy Address"), this);
|
||||
m_copyBtn->setEnabled(false);
|
||||
actionRow->addWidget(m_copyBtn);
|
||||
|
||||
mainLayout->addLayout(actionRow);
|
||||
|
||||
// ── Initial visibility: signature mode ──
|
||||
m_typeLabel->hide();
|
||||
m_typeCombo->hide();
|
||||
m_valueLabel->hide();
|
||||
m_valueEdit->hide();
|
||||
|
||||
// ── Connections ──
|
||||
connect(m_modeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
|
||||
this, &ScannerPanel::onModeChanged);
|
||||
connect(m_scanBtn, &QPushButton::clicked,
|
||||
this, &ScannerPanel::onScanClicked);
|
||||
connect(m_updateBtn, &QPushButton::clicked,
|
||||
this, &ScannerPanel::onUpdateClicked);
|
||||
connect(m_gotoBtn, &QPushButton::clicked,
|
||||
this, &ScannerPanel::onGoToAddress);
|
||||
connect(m_copyBtn, &QPushButton::clicked,
|
||||
this, &ScannerPanel::onCopyAddress);
|
||||
connect(m_resultTable, &QTableWidget::cellDoubleClicked,
|
||||
this, &ScannerPanel::onResultDoubleClicked);
|
||||
connect(m_resultTable, &QTableWidget::cellChanged,
|
||||
this, &ScannerPanel::onCellEdited);
|
||||
connect(m_resultTable, &QTableWidget::itemSelectionChanged, this, [this]() {
|
||||
bool hasSel = !m_resultTable->selectedItems().isEmpty();
|
||||
m_gotoBtn->setEnabled(hasSel);
|
||||
m_copyBtn->setEnabled(hasSel);
|
||||
});
|
||||
|
||||
connect(m_resultTable, &QWidget::customContextMenuRequested, this, [this](const QPoint& pos) {
|
||||
int row = m_resultTable->rowAt(pos.y());
|
||||
if (row < 0 || row >= m_results.size()) return;
|
||||
QMenu menu;
|
||||
auto* copyAddr = menu.addAction(QIcon(QStringLiteral(":/vsicons/clippy.svg")),
|
||||
QStringLiteral("Copy Address"));
|
||||
auto* copyVal = menu.addAction(QIcon(QStringLiteral(":/vsicons/clippy.svg")),
|
||||
QStringLiteral("Copy Value"));
|
||||
auto* goTo = menu.addAction(QIcon(QStringLiteral(":/vsicons/arrow-right.svg")),
|
||||
QStringLiteral("Go to Address"));
|
||||
auto* chosen = menu.exec(m_resultTable->viewport()->mapToGlobal(pos));
|
||||
if (chosen == copyAddr) {
|
||||
QString addr = QStringLiteral("0x%1")
|
||||
.arg(m_results[row].address, 0, 16, QLatin1Char('0')).toUpper();
|
||||
QApplication::clipboard()->setText(addr);
|
||||
m_statusLabel->setText(QStringLiteral("Copied: %1").arg(addr));
|
||||
} else if (chosen == copyVal) {
|
||||
QApplication::clipboard()->setText(formatValue(m_results[row].scanValue));
|
||||
m_statusLabel->setText(QStringLiteral("Copied value"));
|
||||
} else if (chosen == goTo) {
|
||||
emit goToAddress(m_results[row].address);
|
||||
}
|
||||
});
|
||||
|
||||
connect(m_engine, &ScanEngine::progress, this, [this](int pct) {
|
||||
m_progressBar->setValue(pct);
|
||||
});
|
||||
connect(m_engine, &ScanEngine::finished,
|
||||
this, &ScannerPanel::onScanFinished);
|
||||
connect(m_engine, &ScanEngine::error, this, [this](const QString& msg) {
|
||||
m_statusLabel->setText(QStringLiteral("Error: %1").arg(msg));
|
||||
m_scanBtn->setText(QStringLiteral("Scan"));
|
||||
m_progressBar->hide();
|
||||
});
|
||||
}
|
||||
|
||||
void ScannerPanel::setProviderGetter(ProviderGetter getter) {
|
||||
m_providerGetter = std::move(getter);
|
||||
}
|
||||
|
||||
void ScannerPanel::setEditorFont(const QFont& font) {
|
||||
m_resultTable->setFont(font);
|
||||
QFontMetrics fm(font);
|
||||
m_resultTable->verticalHeader()->setDefaultSectionSize(fm.height() + 6);
|
||||
m_patternEdit->setFont(font);
|
||||
m_valueEdit->setFont(font);
|
||||
m_modeCombo->setFont(font);
|
||||
m_typeCombo->setFont(font);
|
||||
m_statusLabel->setFont(font);
|
||||
m_scanBtn->setFont(font);
|
||||
m_gotoBtn->setFont(font);
|
||||
m_copyBtn->setFont(font);
|
||||
m_patternLabel->setFont(font);
|
||||
m_typeLabel->setFont(font);
|
||||
m_valueLabel->setFont(font);
|
||||
m_execCheck->setFont(font);
|
||||
m_writeCheck->setFont(font);
|
||||
m_updateBtn->setFont(font);
|
||||
updateComboWidth();
|
||||
}
|
||||
|
||||
void ScannerPanel::updateComboWidth() {
|
||||
QFontMetrics fm(m_modeCombo->font());
|
||||
int maxW = 0;
|
||||
for (int i = 0; i < m_modeCombo->count(); i++)
|
||||
maxW = qMax(maxW, fm.horizontalAdvance(m_modeCombo->itemText(i)));
|
||||
m_modeCombo->setFixedWidth(maxW + 50); // icon + dropdown arrow + padding
|
||||
}
|
||||
|
||||
void ScannerPanel::onModeChanged(int index) {
|
||||
bool isSig = (index == 0);
|
||||
|
||||
m_patternLabel->setVisible(isSig);
|
||||
m_patternEdit->setVisible(isSig);
|
||||
|
||||
m_typeLabel->setVisible(!isSig);
|
||||
m_typeCombo->setVisible(!isSig);
|
||||
m_valueLabel->setVisible(!isSig);
|
||||
m_valueEdit->setVisible(!isSig);
|
||||
}
|
||||
|
||||
void ScannerPanel::onScanClicked() {
|
||||
if (m_engine->isRunning()) {
|
||||
m_engine->abort();
|
||||
m_scanBtn->setText(QStringLiteral("Scan"));
|
||||
m_progressBar->hide();
|
||||
m_statusLabel->setText(QStringLiteral("Scan cancelled"));
|
||||
return;
|
||||
}
|
||||
|
||||
// Get provider
|
||||
std::shared_ptr<Provider> provider;
|
||||
if (m_providerGetter)
|
||||
provider = m_providerGetter();
|
||||
|
||||
if (!provider) {
|
||||
m_statusLabel->setText(QStringLiteral("No source attached"));
|
||||
return;
|
||||
}
|
||||
|
||||
// Build request
|
||||
ScanRequest req = buildRequest();
|
||||
if (req.pattern.isEmpty())
|
||||
return; // error already shown by buildRequest
|
||||
|
||||
m_lastScanMode = m_modeCombo->currentIndex();
|
||||
if (m_lastScanMode == 1)
|
||||
m_lastValueType = (ValueType)m_typeCombo->currentData().toInt();
|
||||
m_lastPattern = req.pattern;
|
||||
|
||||
m_scanBtn->setText(QStringLiteral("Cancel"));
|
||||
m_progressBar->setValue(0);
|
||||
m_progressBar->show();
|
||||
m_statusLabel->setText(QStringLiteral("Scanning..."));
|
||||
|
||||
m_engine->start(provider, req);
|
||||
}
|
||||
|
||||
ScanRequest ScannerPanel::buildRequest() {
|
||||
ScanRequest req;
|
||||
QString err;
|
||||
|
||||
if (m_modeCombo->currentIndex() == 0) {
|
||||
// Signature mode
|
||||
if (!parseSignature(m_patternEdit->text(), req.pattern, req.mask, &err)) {
|
||||
m_statusLabel->setText(QStringLiteral("Pattern error: %1").arg(err));
|
||||
return {};
|
||||
}
|
||||
req.alignment = 1;
|
||||
} else {
|
||||
// Value mode
|
||||
auto vt = (ValueType)m_typeCombo->currentData().toInt();
|
||||
if (!serializeValue(vt, m_valueEdit->text(), req.pattern, req.mask, &err)) {
|
||||
m_statusLabel->setText(QStringLiteral("Value error: %1").arg(err));
|
||||
return {};
|
||||
}
|
||||
req.alignment = naturalAlignment(vt);
|
||||
}
|
||||
|
||||
req.filterExecutable = m_execCheck->isChecked();
|
||||
req.filterWritable = m_writeCheck->isChecked();
|
||||
|
||||
return req;
|
||||
}
|
||||
|
||||
void ScannerPanel::onScanFinished(QVector<ScanResult> results) {
|
||||
m_scanBtn->setText(QStringLiteral("Scan"));
|
||||
m_progressBar->hide();
|
||||
m_results = results;
|
||||
|
||||
// Cache scan-time bytes
|
||||
if (m_lastScanMode == 1) {
|
||||
// Value mode — every result matched the same value, no re-read needed
|
||||
for (auto& r : m_results) {
|
||||
r.previousValue.clear();
|
||||
r.scanValue = m_lastPattern;
|
||||
}
|
||||
} else {
|
||||
// Signature mode — wildcards mean each match may differ, read actual bytes
|
||||
std::shared_ptr<Provider> prov;
|
||||
if (m_providerGetter)
|
||||
prov = m_providerGetter();
|
||||
for (auto& r : m_results) {
|
||||
r.previousValue.clear();
|
||||
r.scanValue = prov ? prov->readBytes(r.address, 16) : QByteArray();
|
||||
}
|
||||
}
|
||||
|
||||
m_updateBtn->setEnabled(!m_results.isEmpty());
|
||||
populateTable(false);
|
||||
|
||||
m_statusLabel->setText(QStringLiteral("%1 result%2")
|
||||
.arg(m_results.size())
|
||||
.arg(m_results.size() == 1 ? "" : "s"));
|
||||
}
|
||||
|
||||
void ScannerPanel::populateTable(bool showPrevious) {
|
||||
m_resultTable->blockSignals(true);
|
||||
int cols = showPrevious ? 3 : 2;
|
||||
m_resultTable->setColumnCount(cols);
|
||||
m_resultTable->setRowCount(m_results.size());
|
||||
|
||||
for (int i = 0; i < m_results.size(); i++) {
|
||||
const auto& r = m_results[i];
|
||||
|
||||
// Address column — WinDbg backtick format: 00000000`00000000
|
||||
QString hexPart = QStringLiteral("%1").arg(r.address, 16, 16, QLatin1Char('0')).toUpper();
|
||||
hexPart.insert(8, '`');
|
||||
auto* addrItem = new QTableWidgetItem(hexPart);
|
||||
addrItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
|
||||
m_resultTable->setItem(i, 0, addrItem);
|
||||
|
||||
// Value column
|
||||
auto* valItem = new QTableWidgetItem(formatValue(r.scanValue));
|
||||
valItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
|
||||
m_resultTable->setItem(i, 1, valItem);
|
||||
|
||||
// Previous column
|
||||
if (showPrevious) {
|
||||
auto* prevItem = new QTableWidgetItem(
|
||||
r.previousValue.isEmpty() ? QString() : formatValue(r.previousValue));
|
||||
prevItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
|
||||
m_resultTable->setItem(i, 2, prevItem);
|
||||
}
|
||||
}
|
||||
|
||||
m_resultTable->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
|
||||
m_resultTable->horizontalHeader()->setStretchLastSection(false);
|
||||
m_resultTable->blockSignals(false);
|
||||
}
|
||||
|
||||
void ScannerPanel::onUpdateClicked() {
|
||||
if (m_results.isEmpty()) return;
|
||||
|
||||
std::shared_ptr<Provider> prov;
|
||||
if (m_providerGetter)
|
||||
prov = m_providerGetter();
|
||||
if (!prov) {
|
||||
m_statusLabel->setText(QStringLiteral("No source attached"));
|
||||
return;
|
||||
}
|
||||
|
||||
m_updateBtn->setEnabled(false);
|
||||
m_scanBtn->setEnabled(false);
|
||||
m_statusLabel->setText(QStringLiteral("Re-scanning..."));
|
||||
m_progressBar->setValue(0);
|
||||
m_progressBar->show();
|
||||
|
||||
int readSize = (m_lastScanMode == 1) ? valueSize() : 16;
|
||||
int total = m_results.size();
|
||||
|
||||
// Single pass: read new values + build table rows
|
||||
m_resultTable->blockSignals(true);
|
||||
m_resultTable->setColumnCount(3);
|
||||
m_resultTable->setRowCount(total);
|
||||
|
||||
for (int i = 0; i < total; i++) {
|
||||
auto& r = m_results[i];
|
||||
r.previousValue = r.scanValue;
|
||||
r.scanValue = prov->readBytes(r.address, readSize);
|
||||
|
||||
QString hexPart = QStringLiteral("%1").arg(r.address, 16, 16, QLatin1Char('0')).toUpper();
|
||||
hexPart.insert(8, '`');
|
||||
auto* addrItem = new QTableWidgetItem(hexPart);
|
||||
addrItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
|
||||
m_resultTable->setItem(i, 0, addrItem);
|
||||
|
||||
auto* valItem = new QTableWidgetItem(formatValue(r.scanValue));
|
||||
valItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
|
||||
m_resultTable->setItem(i, 1, valItem);
|
||||
|
||||
auto* prevItem = new QTableWidgetItem(formatValue(r.previousValue));
|
||||
prevItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
|
||||
m_resultTable->setItem(i, 2, prevItem);
|
||||
|
||||
if ((i & 0xFF) == 0) {
|
||||
m_progressBar->setValue(i * 100 / total);
|
||||
QApplication::processEvents();
|
||||
}
|
||||
}
|
||||
|
||||
m_resultTable->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
|
||||
m_resultTable->horizontalHeader()->setStretchLastSection(false);
|
||||
m_resultTable->blockSignals(false);
|
||||
|
||||
m_progressBar->setValue(100);
|
||||
m_progressBar->hide();
|
||||
m_scanBtn->setEnabled(true);
|
||||
m_updateBtn->setEnabled(true);
|
||||
m_statusLabel->setText(QStringLiteral("Updated %1 result%2")
|
||||
.arg(total).arg(total == 1 ? "" : "s"));
|
||||
}
|
||||
|
||||
void ScannerPanel::onGoToAddress() {
|
||||
int row = m_resultTable->currentRow();
|
||||
if (row < 0 || row >= m_results.size()) return;
|
||||
emit goToAddress(m_results[row].address);
|
||||
}
|
||||
|
||||
void ScannerPanel::onCopyAddress() {
|
||||
int row = m_resultTable->currentRow();
|
||||
if (row < 0 || row >= m_results.size()) return;
|
||||
|
||||
QString addr = QStringLiteral("0x%1")
|
||||
.arg(m_results[row].address, 0, 16, QLatin1Char('0')).toUpper();
|
||||
QApplication::clipboard()->setText(addr);
|
||||
m_statusLabel->setText(QStringLiteral("Copied: %1").arg(addr));
|
||||
}
|
||||
|
||||
void ScannerPanel::onResultDoubleClicked(int row, int col) {
|
||||
// Double-click on address column navigates (editing also starts via edit trigger)
|
||||
// Double-click on preview column only starts inline editing
|
||||
Q_UNUSED(col);
|
||||
Q_UNUSED(row);
|
||||
// Navigation is handled by Go to Address button or onCellEdited for address expressions
|
||||
}
|
||||
|
||||
void ScannerPanel::onCellEdited(int row, int col) {
|
||||
if (row < 0 || row >= m_results.size()) return;
|
||||
|
||||
auto* item = m_resultTable->item(row, col);
|
||||
if (!item) return;
|
||||
QString text = item->text().trimmed();
|
||||
|
||||
if (col == 0) {
|
||||
// Address column — evaluate expression via AddressParser
|
||||
AddressParserCallbacks cbs;
|
||||
std::shared_ptr<Provider> prov;
|
||||
if (m_providerGetter)
|
||||
prov = m_providerGetter();
|
||||
if (prov) {
|
||||
auto* p = prov.get();
|
||||
cbs.resolveModule = [p](const QString& name, bool* ok) -> uint64_t {
|
||||
uint64_t base = p->symbolToAddress(name);
|
||||
*ok = (base != 0);
|
||||
return base;
|
||||
};
|
||||
cbs.readPointer = [p](uint64_t addr, bool* ok) -> uint64_t {
|
||||
uint64_t val = 0;
|
||||
*ok = p->read(addr, &val, 8);
|
||||
return val;
|
||||
};
|
||||
}
|
||||
auto result = AddressParser::evaluate(text, 8, &cbs);
|
||||
if (result.ok) {
|
||||
m_results[row].address = result.value;
|
||||
emit goToAddress(result.value);
|
||||
// Reformat the address cell
|
||||
m_resultTable->blockSignals(true);
|
||||
QString hexPart = QStringLiteral("%1").arg(result.value, 16, 16, QLatin1Char('0')).toUpper();
|
||||
hexPart.insert(8, '`');
|
||||
item->setText(hexPart);
|
||||
// Re-read preview at new address and update cache
|
||||
if (prov) {
|
||||
int readSize = (m_lastScanMode == 1) ? valueSize() : 16;
|
||||
m_results[row].scanValue = prov->readBytes(result.value, readSize);
|
||||
if (auto* prevItem = m_resultTable->item(row, 1))
|
||||
prevItem->setText(formatValue(m_results[row].scanValue));
|
||||
}
|
||||
m_resultTable->blockSignals(false);
|
||||
} else {
|
||||
m_statusLabel->setText(QStringLiteral("Expression error: %1").arg(result.error));
|
||||
// Restore original address
|
||||
m_resultTable->blockSignals(true);
|
||||
QString hexPart = QStringLiteral("%1").arg(m_results[row].address, 16, 16, QLatin1Char('0')).toUpper();
|
||||
hexPart.insert(8, '`');
|
||||
item->setText(hexPart);
|
||||
m_resultTable->blockSignals(false);
|
||||
}
|
||||
} else if (col == 1) {
|
||||
// Preview column — parse hex bytes and write to provider
|
||||
std::shared_ptr<Provider> prov;
|
||||
if (m_providerGetter)
|
||||
prov = m_providerGetter();
|
||||
if (!prov || !prov->isWritable()) {
|
||||
m_statusLabel->setText(QStringLiteral("Provider is read-only"));
|
||||
return;
|
||||
}
|
||||
QByteArray bytes;
|
||||
uint64_t addr = m_results[row].address;
|
||||
|
||||
if (m_lastScanMode == 0) {
|
||||
// Signature mode — parse space-separated hex bytes
|
||||
QStringList tokens = text.split(' ', Qt::SkipEmptyParts);
|
||||
for (const QString& tok : tokens) {
|
||||
bool ok;
|
||||
uint val = tok.toUInt(&ok, 16);
|
||||
if (!ok || val > 0xFF) {
|
||||
m_statusLabel->setText(QStringLiteral("Invalid hex byte: %1").arg(tok));
|
||||
return;
|
||||
}
|
||||
bytes.append(char(val));
|
||||
}
|
||||
} else {
|
||||
// Value mode — parse native type
|
||||
bool ok = false;
|
||||
bytes.resize(valueSize());
|
||||
char* d = bytes.data();
|
||||
switch (m_lastValueType) {
|
||||
case ValueType::Int8: { auto v = (int8_t)text.toInt(&ok); if (ok) memcpy(d, &v, 1); break; }
|
||||
case ValueType::UInt8: { auto v = (uint8_t)text.toUInt(&ok); if (ok) memcpy(d, &v, 1); break; }
|
||||
case ValueType::Int16: { auto v = (int16_t)text.toShort(&ok); if (ok) memcpy(d, &v, 2); break; }
|
||||
case ValueType::UInt16: { auto v = text.toUShort(&ok); if (ok) memcpy(d, &v, 2); break; }
|
||||
case ValueType::Int32: { auto v = text.toInt(&ok); if (ok) memcpy(d, &v, 4); break; }
|
||||
case ValueType::UInt32: { auto v = text.toUInt(&ok); if (ok) memcpy(d, &v, 4); break; }
|
||||
case ValueType::Int64: { auto v = text.toLongLong(&ok); if (ok) memcpy(d, &v, 8); break; }
|
||||
case ValueType::UInt64: { auto v = text.toULongLong(&ok); if (ok) memcpy(d, &v, 8); break; }
|
||||
case ValueType::Float: { auto v = text.toFloat(&ok); if (ok) memcpy(d, &v, 4); break; }
|
||||
case ValueType::Double: { auto v = text.toDouble(&ok); if (ok) memcpy(d, &v, 8); break; }
|
||||
default: break;
|
||||
}
|
||||
if (!ok) {
|
||||
m_statusLabel->setText(QStringLiteral("Invalid value"));
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (bytes.isEmpty()) return;
|
||||
|
||||
if (prov->writeBytes(addr, bytes)) {
|
||||
m_statusLabel->setText(QStringLiteral("Wrote %1 byte%2 to 0x%3")
|
||||
.arg(bytes.size())
|
||||
.arg(bytes.size() == 1 ? "" : "s")
|
||||
.arg(addr, 0, 16, QLatin1Char('0')).toUpper());
|
||||
// Re-read and update cache
|
||||
m_resultTable->blockSignals(true);
|
||||
int readSize = (m_lastScanMode == 1) ? valueSize() : 16;
|
||||
m_results[row].scanValue = prov->readBytes(addr, readSize);
|
||||
item->setText(formatValue(m_results[row].scanValue));
|
||||
m_resultTable->blockSignals(false);
|
||||
} else {
|
||||
m_statusLabel->setText(QStringLiteral("Write failed"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ScannerPanel::applyTheme(const Theme& theme) {
|
||||
// Address delegate colors
|
||||
m_addrDelegate->dimColor = theme.textFaint;
|
||||
m_addrDelegate->brightColor = theme.text;
|
||||
|
||||
// Results table — editor-matching style
|
||||
m_resultTable->setStyleSheet(QStringLiteral(
|
||||
"QTableWidget { background: %1; color: %2; border: none; }"
|
||||
"QTableWidget::item { padding: 2px 6px; border: none; }"
|
||||
"QTableWidget::item:hover { background: %3; padding: 2px 6px; border: none; }"
|
||||
"QTableWidget::item:selected { background: %3; color: %2; padding: 2px 6px; border: none; }"
|
||||
"QTableWidget QLineEdit { background: %1; color: %2; border: 1px solid %4;"
|
||||
" padding: 1px 4px; selection-background-color: %5; }")
|
||||
.arg(theme.background.name(), theme.text.name(), theme.hover.name(),
|
||||
theme.borderFocused.name(), theme.selection.name()));
|
||||
|
||||
// Input fields
|
||||
QString lineEditStyle = QStringLiteral(
|
||||
"QLineEdit { background: %1; color: %2; border: 1px solid %3; padding: 2px 4px; }"
|
||||
"QLineEdit:focus { border-color: %4; }")
|
||||
.arg(theme.background.name(), theme.text.name(),
|
||||
theme.border.name(), theme.borderFocused.name());
|
||||
m_patternEdit->setStyleSheet(lineEditStyle);
|
||||
m_valueEdit->setStyleSheet(lineEditStyle);
|
||||
|
||||
// Combo boxes
|
||||
QString comboStyle = QStringLiteral(
|
||||
"QComboBox { background: %1; color: %2; border: 1px solid %3; padding: 2px 4px 2px 4px; }"
|
||||
"QComboBox::drop-down { subcontrol-origin: padding; subcontrol-position: top right;"
|
||||
" width: 16px; border-left: 1px solid %3; }"
|
||||
"QComboBox::down-arrow { image: url(:/vsicons/chevron-down.svg); width: 10px; height: 10px; }"
|
||||
"QComboBox QAbstractItemView { background: %1; color: %2; selection-background-color: %4; }")
|
||||
.arg(theme.background.name(), theme.text.name(),
|
||||
theme.border.name(), theme.hover.name());
|
||||
m_modeCombo->setStyleSheet(comboStyle);
|
||||
m_typeCombo->setStyleSheet(comboStyle);
|
||||
|
||||
// Labels
|
||||
QPalette lp;
|
||||
lp.setColor(QPalette::WindowText, theme.textDim);
|
||||
m_patternLabel->setPalette(lp);
|
||||
m_typeLabel->setPalette(lp);
|
||||
m_valueLabel->setPalette(lp);
|
||||
m_statusLabel->setPalette(lp);
|
||||
|
||||
// Checkboxes
|
||||
QPalette cp;
|
||||
cp.setColor(QPalette::WindowText, theme.textDim);
|
||||
m_execCheck->setPalette(cp);
|
||||
m_writeCheck->setPalette(cp);
|
||||
|
||||
// Buttons
|
||||
QString btnStyle = QStringLiteral(
|
||||
"QPushButton { background: %1; color: %2; border: 1px solid %3; padding: 4px 12px; }"
|
||||
"QPushButton:hover { background: %4; }"
|
||||
"QPushButton:pressed { background: %5; }"
|
||||
"QPushButton:disabled { color: %6; }")
|
||||
.arg(theme.button.name(), theme.text.name(), theme.border.name(),
|
||||
theme.hover.name(), theme.hover.darker(130).name(),
|
||||
theme.textMuted.name());
|
||||
m_scanBtn->setStyleSheet(btnStyle);
|
||||
m_updateBtn->setStyleSheet(btnStyle);
|
||||
m_gotoBtn->setStyleSheet(btnStyle);
|
||||
m_copyBtn->setStyleSheet(btnStyle);
|
||||
|
||||
// Progress bar
|
||||
m_progressBar->setStyleSheet(QStringLiteral(
|
||||
"QProgressBar { background: %1; border: 1px solid %2; text-align: center; color: %3; }"
|
||||
"QProgressBar::chunk { background: %4; }")
|
||||
.arg(theme.background.name(), theme.border.name(),
|
||||
theme.textDim.name(), theme.indHoverSpan.name()));
|
||||
}
|
||||
|
||||
int ScannerPanel::valueSize() const {
|
||||
switch (m_lastValueType) {
|
||||
case ValueType::Int8: case ValueType::UInt8: return 1;
|
||||
case ValueType::Int16: case ValueType::UInt16: return 2;
|
||||
case ValueType::Int32: case ValueType::UInt32: case ValueType::Float: return 4;
|
||||
case ValueType::Int64: case ValueType::UInt64: case ValueType::Double: return 8;
|
||||
default: return 16;
|
||||
}
|
||||
}
|
||||
|
||||
QString ScannerPanel::formatValue(const QByteArray& bytes) const {
|
||||
if (m_lastScanMode == 0) {
|
||||
// Signature mode — hex bytes
|
||||
QString s;
|
||||
for (int j = 0; j < bytes.size(); j++) {
|
||||
if (j > 0) s += ' ';
|
||||
s += QStringLiteral("%1").arg((uint8_t)bytes[j], 2, 16, QLatin1Char('0')).toUpper();
|
||||
}
|
||||
return s;
|
||||
}
|
||||
// Value mode — native type
|
||||
const char* d = bytes.constData();
|
||||
int sz = bytes.size();
|
||||
switch (m_lastValueType) {
|
||||
case ValueType::Int8: if (sz >= 1) return QString::number((int8_t)d[0]); break;
|
||||
case ValueType::UInt8: if (sz >= 1) return QString::number((uint8_t)d[0]); break;
|
||||
case ValueType::Int16: if (sz >= 2) { int16_t v; memcpy(&v, d, 2); return QString::number(v); } break;
|
||||
case ValueType::UInt16: if (sz >= 2) { uint16_t v; memcpy(&v, d, 2); return QString::number(v); } break;
|
||||
case ValueType::Int32: if (sz >= 4) { int32_t v; memcpy(&v, d, 4); return QString::number(v); } break;
|
||||
case ValueType::UInt32: if (sz >= 4) { uint32_t v; memcpy(&v, d, 4); return QString::number(v); } break;
|
||||
case ValueType::Int64: if (sz >= 8) { int64_t v; memcpy(&v, d, 8); return QString::number(v); } break;
|
||||
case ValueType::UInt64: if (sz >= 8) { uint64_t v; memcpy(&v, d, 8); return QString::number(v); } break;
|
||||
case ValueType::Float: if (sz >= 4) { float v; memcpy(&v, d, 4); return QString::number(v, 'g', 9); } break;
|
||||
case ValueType::Double: if (sz >= 8) { double v; memcpy(&v, d, 8); return QString::number(v, 'g', 17); } break;
|
||||
default: break;
|
||||
}
|
||||
return QStringLiteral("??");
|
||||
}
|
||||
|
||||
} // namespace rcx
|
||||
111
src/scannerpanel.h
Normal file
111
src/scannerpanel.h
Normal file
@@ -0,0 +1,111 @@
|
||||
#pragma once
|
||||
#include "scanner.h"
|
||||
#include "themes/theme.h"
|
||||
#include <QWidget>
|
||||
#include <QComboBox>
|
||||
#include <QLineEdit>
|
||||
#include <QCheckBox>
|
||||
#include <QPushButton>
|
||||
#include <QProgressBar>
|
||||
#include <QTableWidget>
|
||||
#include <QStyledItemDelegate>
|
||||
#include <QLabel>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
|
||||
namespace rcx {
|
||||
|
||||
// Delegate that paints address with dimmed high-bytes prefix
|
||||
class AddressDelegate : public QStyledItemDelegate {
|
||||
Q_OBJECT
|
||||
public:
|
||||
using QStyledItemDelegate::QStyledItemDelegate;
|
||||
QColor dimColor;
|
||||
QColor brightColor;
|
||||
void paint(QPainter* painter, const QStyleOptionViewItem& option,
|
||||
const QModelIndex& index) const override;
|
||||
};
|
||||
|
||||
class ScannerPanel : public QWidget {
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit ScannerPanel(QWidget* parent = nullptr);
|
||||
|
||||
using ProviderGetter = std::function<std::shared_ptr<Provider>()>;
|
||||
void setProviderGetter(ProviderGetter getter);
|
||||
|
||||
void setEditorFont(const QFont& font);
|
||||
void applyTheme(const Theme& theme);
|
||||
|
||||
// Test accessors
|
||||
QComboBox* modeCombo() const { return m_modeCombo; }
|
||||
QLineEdit* patternEdit() const { return m_patternEdit; }
|
||||
QComboBox* typeCombo() const { return m_typeCombo; }
|
||||
QLineEdit* valueEdit() const { return m_valueEdit; }
|
||||
QCheckBox* execCheck() const { return m_execCheck; }
|
||||
QCheckBox* writeCheck() const { return m_writeCheck; }
|
||||
QPushButton* scanButton() const { return m_scanBtn; }
|
||||
QPushButton* updateButton() const { return m_updateBtn; }
|
||||
QProgressBar* progressBar() const { return m_progressBar; }
|
||||
QTableWidget* resultsTable() const { return m_resultTable; }
|
||||
QLabel* statusLabel() const { return m_statusLabel; }
|
||||
QPushButton* gotoButton() const { return m_gotoBtn; }
|
||||
QPushButton* copyButton() const { return m_copyBtn; }
|
||||
ScanEngine* engine() const { return m_engine; }
|
||||
|
||||
signals:
|
||||
void goToAddress(uint64_t address);
|
||||
|
||||
private slots:
|
||||
void onModeChanged(int index);
|
||||
void onScanClicked();
|
||||
void onScanFinished(QVector<ScanResult> results);
|
||||
void onGoToAddress();
|
||||
void onCopyAddress();
|
||||
void onResultDoubleClicked(int row, int col);
|
||||
void onCellEdited(int row, int col);
|
||||
void onUpdateClicked();
|
||||
|
||||
private:
|
||||
ScanRequest buildRequest();
|
||||
void populateTable(bool showPrevious);
|
||||
void updateComboWidth();
|
||||
|
||||
// Input widgets
|
||||
QComboBox* m_modeCombo; // Signature / Value
|
||||
QLineEdit* m_patternEdit; // Signature pattern input
|
||||
QComboBox* m_typeCombo; // Value type dropdown
|
||||
QLineEdit* m_valueEdit; // Value input
|
||||
QLabel* m_patternLabel;
|
||||
QLabel* m_typeLabel;
|
||||
QLabel* m_valueLabel;
|
||||
|
||||
// Filters
|
||||
QCheckBox* m_execCheck;
|
||||
QCheckBox* m_writeCheck;
|
||||
|
||||
// Actions
|
||||
QPushButton* m_scanBtn;
|
||||
QPushButton* m_updateBtn;
|
||||
QProgressBar* m_progressBar;
|
||||
|
||||
// Results
|
||||
QTableWidget* m_resultTable;
|
||||
AddressDelegate* m_addrDelegate;
|
||||
QLabel* m_statusLabel;
|
||||
QPushButton* m_gotoBtn;
|
||||
QPushButton* m_copyBtn;
|
||||
|
||||
// Engine
|
||||
ScanEngine* m_engine;
|
||||
ProviderGetter m_providerGetter;
|
||||
QVector<ScanResult> m_results;
|
||||
int m_lastScanMode = 0; // 0=signature, 1=value
|
||||
ValueType m_lastValueType = ValueType::Int32;
|
||||
QByteArray m_lastPattern; // serialized search value
|
||||
|
||||
QString formatValue(const QByteArray& bytes) const;
|
||||
int valueSize() const;
|
||||
};
|
||||
|
||||
} // namespace rcx
|
||||
Reference in New Issue
Block a user