Cool_Tools/ImHex
1
0
Fork 0
mirror of synced 2024-11-24 15:50:16 +01:00
Code Releases Wiki Activity

patterns: Move pattern drawer into builtin plugin (#482)

Browse Source 
Co-authored-by: Dmitry Polshakov <dmitry.polshakov@dsr-corporation.com>
This commit is contained in:
Polshakov Dmitry 2022-04-08 17:08:02 +03:00 committed by GitHub
parent 299c69686e
commit 4928c044af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 552 additions and 479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

477
lib/libimhex/include/hex/pattern_language/pattern_drawer.hpp
View File

@ -1,477 +0,0 @@
#pragma once
#include <hex/pattern_language/patterns/pattern_array_dynamic.hpp>
#include <hex/pattern_language/patterns/pattern_array_static.hpp>
#include <hex/pattern_language/patterns/pattern_bitfield.hpp>
#include <hex/pattern_language/patterns/pattern_boolean.hpp>
#include <hex/pattern_language/patterns/pattern_character.hpp>
#include <hex/pattern_language/patterns/pattern_enum.hpp>
#include <hex/pattern_language/patterns/pattern_float.hpp>
#include <hex/pattern_language/patterns/pattern_padding.hpp>
#include <hex/pattern_language/patterns/pattern_pointer.hpp>
#include <hex/pattern_language/patterns/pattern_signed.hpp>
#include <hex/pattern_language/patterns/pattern_string.hpp>
#include <hex/pattern_language/patterns/pattern_struct.hpp>
#include <hex/pattern_language/patterns/pattern_union.hpp>
#include <hex/pattern_language/patterns/pattern_unsigned.hpp>
#include <hex/pattern_language/patterns/pattern_wide_character.hpp>
#include <hex/pattern_language/patterns/pattern_wide_string.hpp>
#include <nlohmann/json.hpp>
namespace {
constexpr auto DisplayEndDefault = 50u;
constexpr auto DisplayEndStep = 50u;
template<typename T>
concept ArrayPattern = requires(T pattern, std::function<void(int, hex::pl::Pattern&)> fn) {
{ pattern.forEachArrayEntry(fn) } -> std::same_as<void>;
};
};
namespace hex::pl {
class PatternDrawer : public PatternVisitor
{
public:
PatternDrawer()
: m_provider{nullptr}
{ }
void setProvider(prv::Provider *provider) {
m_provider = provider;
}
void visit(PatternArrayDynamic& pattern) override {
this->drawArray(pattern);
}
void visit(PatternArrayStatic& pattern) override {
this->drawArray(pattern);
}
void visit(PatternBitfieldField& pattern) override {
ImGui::TableNextRow();
ImGui::TableNextColumn();
drawNameColumn(pattern);
makeSelectable(pattern);
drawColorColumn(pattern);
auto byteAddr = pattern.getOffset() + pattern.getBitOffset() / 8;
auto firstBitIdx = pattern.getBitOffset() % 8;
auto lastBitIdx = firstBitIdx + (pattern.getBitSize() - 1) % 8;
if (firstBitIdx == lastBitIdx)
ImGui::TextFormatted("0x{0:08X} bit {1}", byteAddr, firstBitIdx);
else
ImGui::TextFormatted("0x{0:08X} bits {1} - {2}", byteAddr, firstBitIdx, lastBitIdx);
ImGui::TableNextColumn();
if (pattern.getBitSize() == 1)
ImGui::TextFormatted("{0} bit", pattern.getBitSize());
else
ImGui::TextFormatted("{0} bits", pattern.getBitSize());
ImGui::TableNextColumn();
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "bits");
ImGui::TableNextColumn();
u64 extractedValue = pattern.getValue(m_provider);
ImGui::TextFormatted("{}", pattern.formatDisplayValue(hex::format("{0} (0x{1:X})", extractedValue, extractedValue), &pattern));
}
void visit(PatternBitfield& pattern) override {
std::vector<u8> value = pattern.getValue(m_provider);
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "bitfield");
std::string valueString = "{ ";
for (auto i : value)
valueString += hex::format("{0:02X} ", i);
valueString += "}";
ImGui::TextFormatted("{}", pattern.formatDisplayValue(valueString, &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.forEachMember([&] (auto &field) {
this->draw(field);
});
ImGui::TreePop();
}
}
void visit(PatternBoolean& pattern) override {
u8 boolean = pattern.getValue(m_provider);
if (boolean == 0)
this->createDefaultEntry(pattern, "false", false);
else if (boolean == 1)
this->createDefaultEntry(pattern, "true", true);
else
this->createDefaultEntry(pattern, "true*", true);
}
void visit(PatternCharacter& pattern) override {
char character = pattern.getValue(m_provider);
this->createDefaultEntry(pattern, hex::format("'{0}'", character), character);
}
void visit(PatternEnum& pattern) override {
u64 value = pattern.getValue(m_provider);
std::string valueString = pattern.getTypeName() + "::";
bool foundValue = false;
for (auto &[entryValueLiteral, entryName] : pattern.getEnumValues()) {
auto visitor = overloaded {
[&, name = entryName](auto &entryValue) {
if (static_cast<decltype(entryValue)>(value) == entryValue) {
valueString += name;
foundValue = true;
return true;
}
return false;
},
[](const std::string &) { return false; },
[](Pattern *) { return false; },
};
bool matches = std::visit(visitor, entryValueLiteral);
if (matches)
break;
}
if (!foundValue)
valueString += "???";
ImGui::TableNextRow();
createLeafNode(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
ImGui::SameLine();
drawNameColumn(pattern);
drawColorColumn(pattern);
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "enum");
ImGui::TextFormatted("{}", pattern.formatDisplayValue(hex::format("{} (0x{:0{}X})", valueString.c_str(), value, pattern.getSize() * 2), &pattern));
}
void visit(PatternFloat& pattern) override {
if (pattern.getSize() == 4) {
float f32 = static_cast<float>(pattern.getValue(m_provider));
u32 integerResult = 0;
std::memcpy(&integerResult, &f32, sizeof(float));
this->createDefaultEntry(pattern, hex::format("{:e} (0x{:0{}X})", f32, integerResult, pattern.getSize() * 2), f32);
} else if (pattern.getSize() == 8) {
double f64 = pattern.getValue(m_provider);
u64 integerResult = 0;
std::memcpy(&integerResult, &f64, sizeof(double));
this->createDefaultEntry(pattern, hex::format("{:e} (0x{:0{}X})", f64, integerResult, pattern.getSize() * 2), f64);
}
}
void visit(PatternPadding& pattern) override {
// Do nothing
hex::unused(pattern);
}
void visit(PatternPointer& pattern) override {
u64 data = pattern.getValue(m_provider);
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::SameLine(0, 0);
drawColorColumn(pattern);
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "{}", pattern.getFormattedName());
ImGui::TableNextColumn();
ImGui::TextFormatted("{}", pattern.formatDisplayValue(hex::format("*(0x{0:X})", data), u128(data)));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.getPointedAtPattern()->accept(*this);
ImGui::TreePop();
}
}
void visit(PatternSigned& pattern) override {
i128 data = pattern.getValue(m_provider);
this->createDefaultEntry(pattern, hex::format("{:d} (0x{:0{}X})", data, data, 1 * 2), data);
}
void visit(PatternString& pattern) override {
auto size = std::min<size_t>(pattern.getSize(), 0x7F);
if (size == 0)
return;
std::string displayString = pattern.getValue(m_provider, size);
this->createDefaultEntry(pattern, hex::format("\"{0}\" {1}", displayString, size > pattern.getSize() ? "(truncated)" : ""), displayString);
}
void visit(PatternStruct& pattern) override {
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "struct");
ImGui::TextFormatted("{}", pattern.formatDisplayValue("{ ... }", &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.forEachMember([&](auto &member){
this->draw(member);
});
ImGui::TreePop();
}
}
void visit(PatternUnion& pattern) override {
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "union");
ImGui::TextFormatted("{}", pattern.formatDisplayValue("{ ... }", &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.forEachMember([&](auto &member) {
this->draw(member);
});
ImGui::TreePop();
}
}
void visit(PatternUnsigned& pattern) override {
u128 data = pattern.getValue(m_provider);
this->createDefaultEntry(pattern, hex::format("{:d} (0x{:0{}X})", data, data, pattern.getSize() * 2), data);
}
void visit(PatternWideCharacter& pattern) override {
char16_t character = pattern.getValue(m_provider);
u128 literal = character;
auto str = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.to_bytes(character);
this->createDefaultEntry(pattern, hex::format("'{0}'", str), literal);
}
void visit(PatternWideString& pattern) override {
auto size = std::min<size_t>(pattern.getSize(), 0x100);
if (size == 0)
return;
std::string utf8String = pattern.getValue(m_provider, size);
this->createDefaultEntry(pattern, hex::format("\"{0}\" {1}", utf8String, size > pattern.getSize() ? "(truncated)" : ""), utf8String);
}
private:
void createDefaultEntry(const Pattern &pattern, const std::string &value, Token::Literal &&literal) const {
ImGui::TableNextRow();
createLeafNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::SameLine();
drawNameColumn(pattern);
drawColorColumn(pattern);
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "{}", pattern.getTypeName().empty() ? pattern.getFormattedName() : pattern.getTypeName());
ImGui::TableNextColumn();
ImGui::TextFormatted("{}", pattern.formatDisplayValue(value, literal));
}
static void makeSelectable(const Pattern &pattern) {
ImGui::PushID(static_cast<int>(pattern.getOffset()));
ImGui::PushID(pattern.getVariableName().c_str());
if (ImGui::Selectable("##PatternLine", false, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowItemOverlap)) {
ImHexApi::HexEditor::setSelection(pattern.getOffset(), pattern.getSize());
}
ImGui::SameLine();
ImGui::PopID();
ImGui::PopID();
}
static void drawCommentTooltip(const Pattern &pattern) {
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem) && pattern.getComment().has_value()) {
ImGui::BeginTooltip();
ImGui::TextUnformatted(pattern.getComment()->c_str());
ImGui::EndTooltip();
}
}
void draw(Pattern& pattern) {
if (pattern.isHidden())
return;
pattern.accept(*this);
}
template<ArrayPattern T>
void drawArray(T& pattern) {
if (pattern.getEntryCount() == 0)
return;
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "{0}", pattern.getTypeName());
ImGui::SameLine(0, 0);
ImGui::TextUnformatted("[");
ImGui::SameLine(0, 0);
ImGui::TextFormattedColored(ImColor(0xFF00FF00), "{0}", pattern.getEntryCount());
ImGui::SameLine(0, 0);
ImGui::TextUnformatted("]");
ImGui::TableNextColumn();
ImGui::TextFormatted("{}", pattern.formatDisplayValue("{ ... }", &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
auto& displayEnd = this->getDisplayEnd(pattern);
if (open) {
pattern.forEachArrayEntry([&] (u64 idx, auto &entry){
u64 lastVisible = displayEnd - 1;
ImGui::PushID(entry.getOffset());
if (idx < lastVisible) {
this->draw(entry);
} else if (idx == lastVisible) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
ImGui::Selectable("... (Double-click to see more items)", false, ImGuiSelectableFlags_SpanAllColumns);
if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
displayEnd += DisplayEndStep;
}
ImGui::PopID();
});
ImGui::TreePop();
} else {
displayEnd = DisplayEndDefault;
}
}
static void createLeafNode(const Pattern& pattern) {
ImGui::TreeNodeEx(pattern.getDisplayName().c_str(), ImGuiTreeNodeFlags_Leaf |
ImGuiTreeNodeFlags_NoTreePushOnOpen |
ImGuiTreeNodeFlags_SpanFullWidth |
ImGuiTreeNodeFlags_AllowItemOverlap);
}
static bool createTreeNode(const Pattern& pattern) {
return ImGui::TreeNodeEx(pattern.getDisplayName().c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
}
static void drawTypenameColumn(const Pattern& pattern, const std::string& pattern_name) {
ImGui::TextFormattedColored(ImColor(0xFFD69C56), pattern_name);
ImGui::SameLine();
ImGui::TextUnformatted(pattern.getTypeName().c_str());
ImGui::TableNextColumn();
}
static void drawNameColumn(const Pattern& pattern) {
ImGui::TextUnformatted(pattern.getDisplayName().c_str());
ImGui::TableNextColumn();
}
static void drawColorColumn(const Pattern& pattern) {
ImGui::ColorButton("color", ImColor(pattern.getColor()), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetColumnWidth(), ImGui::GetTextLineHeight()));
ImGui::TableNextColumn();
}
static void drawOffsetColumn(const Pattern& pattern) {
ImGui::TextFormatted("0x{0:08X} : 0x{1:08X}", pattern.getOffset(), pattern.getOffset() + pattern.getSize() - (pattern.getSize() == 0 ? 0 : 1));
ImGui::TableNextColumn();
}
static void drawSizeColumn(const Pattern& pattern) {
ImGui::TextFormatted("0x{0:04X}", pattern.getSize());
ImGui::TableNextColumn();
}
u64& getDisplayEnd(const Pattern& pattern) {
auto it = m_displayEnd.find(&pattern);
if (it != m_displayEnd.end()) {
return it->second;
}
auto [inserted, success] = m_displayEnd.emplace(&pattern, DisplayEndDefault);
return inserted->second;
}
private:
prv::Provider *m_provider;
std::map<const Pattern*, u64> m_displayEnd;
};
};

1
plugins/builtin/CMakeLists.txt
View File

@ -47,6 +47,7 @@ add_library(${PROJECT_NAME} SHARED
source/math_evaluator.cpp
source/pattern_drawer.cpp
source/lang/en_US.cpp
source/lang/de_DE.cpp

5
plugins/builtin/include/content/views/view_pattern_data.hpp
View File

@ -1,9 +1,10 @@
#pragma once
#include "pattern_drawer.hpp"
#include <hex.hpp>
#include <imgui.h>
#include <hex/pattern_language/pattern_drawer.hpp>
#include <hex/ui/view.hpp>
#include <vector>
@ -21,7 +22,7 @@ namespace hex::plugin::builtin {
private:
std::map<prv::Provider *, std::vector<std::shared_ptr<pl::Pattern>>> m_sortedPatterns;
hex::pl::PatternDrawer m_drawer;
hex::PatternDrawer m_drawer;
};
}

79
plugins/builtin/include/pattern_drawer.hpp Normal file
View File

@ -0,0 +1,79 @@
#pragma once
#include <hex/pattern_language/patterns/pattern.hpp>
#include <hex/pattern_language/pattern_visitor.hpp>
#include <hex/providers/provider.hpp>
namespace hex {
template<typename T>
concept ArrayPattern = requires(T pattern, std::function<void(int, pl::Pattern&)> fn) {
{ pattern.forEachArrayEntry(fn) } -> std::same_as<void>;
};
class PatternDrawer : public pl::PatternVisitor
{
public:
PatternDrawer();
void setProvider(prv::Provider *provider);
void visit(pl::PatternArrayDynamic& pattern) override;
void visit(pl::PatternArrayStatic& pattern) override;
void visit(pl::PatternBitfieldField& pattern) override;
void visit(pl::PatternBitfield& pattern) override;
void visit(pl::PatternBoolean& pattern) override;
void visit(pl::PatternCharacter& pattern) override;
void visit(pl::PatternEnum& pattern) override;
void visit(pl::PatternFloat& pattern) override;
void visit(pl::PatternPadding& pattern) override;
void visit(pl::PatternPointer& pattern) override;
void visit(pl::PatternSigned& pattern) override;
void visit(pl::PatternString& pattern) override;
void visit(pl::PatternStruct& pattern) override;
void visit(pl::PatternUnion& pattern) override;
void visit(pl::PatternUnsigned& pattern) override;
void visit(pl::PatternWideCharacter& pattern) override;
void visit(pl::PatternWideString& pattern) override;
private:
void createDefaultEntry(const pl::Pattern &pattern, const std::string &value, pl::Token::Literal &&literal) const;
void createLeafNode(const pl::Pattern& pattern) const;
bool createTreeNode(const pl::Pattern& pattern) const;
void makeSelectable(const pl::Pattern &pattern) const;
void draw(pl::Pattern& pattern);
template<ArrayPattern T>
void drawArray(T& pattern) {
bool opened = this->drawArrayRoot(pattern, pattern.getEntryCount(), pattern.isInlined());
if (opened) {
auto& displayEnd = this->getDisplayEnd(pattern);
pattern.forEachArrayEntry([&] (u64 idx, auto &entry){
this->drawArrayNode(idx, displayEnd, entry);
});
}
this->drawArrayEnd(pattern, opened);
}
bool drawArrayRoot(pl::Pattern& pattern, size_t entryCount, bool isInlined);
void drawArrayNode(u64 idx, u64 displayEnd, pl::Pattern& pattern);
void drawArrayEnd(pl::Pattern& pattern, bool opened);
void drawCommentTooltip(const pl::Pattern &pattern) const;
void drawTypenameColumn(const pl::Pattern& pattern, const std::string& pattern_name) const;
void drawNameColumn(const pl::Pattern& pattern) const;
void drawColorColumn(const pl::Pattern& pattern) const;
void drawOffsetColumn(const pl::Pattern& pattern) const;
void drawSizeColumn(const pl::Pattern& pattern) const;
u64& getDisplayEnd(const pl::Pattern& pattern);
private:
prv::Provider *m_provider;
std::map<const pl::Pattern*, u64> m_displayEnd;
};
};

469
plugins/builtin/source/pattern_drawer.cpp Normal file
View File

@ -0,0 +1,469 @@
#include "pattern_drawer.hpp"
#include <hex/pattern_language/patterns/pattern_array_dynamic.hpp>
#include <hex/pattern_language/patterns/pattern_array_static.hpp>
#include <hex/pattern_language/patterns/pattern_bitfield.hpp>
#include <hex/pattern_language/patterns/pattern_boolean.hpp>
#include <hex/pattern_language/patterns/pattern_character.hpp>
#include <hex/pattern_language/patterns/pattern_enum.hpp>
#include <hex/pattern_language/patterns/pattern_float.hpp>
#include <hex/pattern_language/patterns/pattern_padding.hpp>
#include <hex/pattern_language/patterns/pattern_pointer.hpp>
#include <hex/pattern_language/patterns/pattern_signed.hpp>
#include <hex/pattern_language/patterns/pattern_string.hpp>
#include <hex/pattern_language/patterns/pattern_struct.hpp>
#include <hex/pattern_language/patterns/pattern_union.hpp>
#include <hex/pattern_language/patterns/pattern_unsigned.hpp>
#include <hex/pattern_language/patterns/pattern_wide_character.hpp>
#include <hex/pattern_language/patterns/pattern_wide_string.hpp>
#include <string>
namespace {
constexpr static auto DisplayEndDefault = 50u;
constexpr static auto DisplayEndStep = 50u;
using namespace ::std::literals::string_literals;
};
namespace hex {
PatternDrawer::PatternDrawer()
: m_provider{nullptr}
{ }
void PatternDrawer::setProvider(prv::Provider *provider) {
m_provider = provider;
}
void PatternDrawer::visit(pl::PatternArrayDynamic& pattern) {
this->drawArray(pattern);
}
void PatternDrawer::visit(pl::PatternArrayStatic& pattern) {
this->drawArray(pattern);
}
void PatternDrawer::visit(pl::PatternBitfieldField& pattern) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
drawNameColumn(pattern);
makeSelectable(pattern);
drawColorColumn(pattern);
auto byteAddr = pattern.getOffset() + pattern.getBitOffset() / 8;
auto firstBitIdx = pattern.getBitOffset() % 8;
auto lastBitIdx = firstBitIdx + (pattern.getBitSize() - 1) % 8;
if (firstBitIdx == lastBitIdx)
ImGui::TextFormatted("0x{0:08X} bit {1}", byteAddr, firstBitIdx);
else
ImGui::TextFormatted("0x{0:08X} bits {1} - {2}", byteAddr, firstBitIdx, lastBitIdx);
ImGui::TableNextColumn();
if (pattern.getBitSize() == 1)
ImGui::TextFormatted("{0} bit", pattern.getBitSize());
else
ImGui::TextFormatted("{0} bits", pattern.getBitSize());
ImGui::TableNextColumn();
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "bits");
ImGui::TableNextColumn();
u64 extractedValue = pattern.getValue(m_provider);
ImGui::TextFormatted("{}", pattern.formatDisplayValue(hex::format("{0} (0x{1:X})", extractedValue, extractedValue), &pattern));
}
void PatternDrawer::visit(pl::PatternBitfield& pattern) {
std::vector<u8> value = pattern.getValue(m_provider);
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "bitfield");
std::string valueString = "{ ";
for (auto i : value)
valueString += hex::format("{0:02X} ", i);
valueString += "}";
ImGui::TextFormatted("{}", pattern.formatDisplayValue(valueString, &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.forEachMember([&] (auto &field) {
this->draw(field);
});
ImGui::TreePop();
}
}
void PatternDrawer::visit(pl::PatternBoolean& pattern) {
u8 boolean = pattern.getValue(m_provider);
if (boolean == 0)
this->createDefaultEntry(pattern, "false", false);
else if (boolean == 1)
this->createDefaultEntry(pattern, "true", true);
else
this->createDefaultEntry(pattern, "true*", true);
}
void PatternDrawer::visit(pl::PatternCharacter& pattern) {
char character = pattern.getValue(m_provider);
this->createDefaultEntry(pattern, hex::format("'{0}'", character), character);
}
void PatternDrawer::visit(pl::PatternEnum& pattern) {
u64 value = pattern.getValue(m_provider);
std::string valueString = pattern.getTypeName() + "::";
bool foundValue = false;
for (auto &[entryValueLiteral, entryName] : pattern.getEnumValues()) {
auto visitor = overloaded {
[&, name = entryName](auto &entryValue) {
if (static_cast<decltype(entryValue)>(value) == entryValue) {
valueString += name;
foundValue = true;
return true;
}
return false;
},
[](const std::string &) { return false; },
[](pl::Pattern *) { return false; },
};
bool matches = std::visit(visitor, entryValueLiteral);
if (matches)
break;
}
if (!foundValue)
valueString += "???";
ImGui::TableNextRow();
createLeafNode(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
ImGui::SameLine();
drawNameColumn(pattern);
drawColorColumn(pattern);
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "enum");
ImGui::TextFormatted("{}", pattern.formatDisplayValue(hex::format("{} (0x{:0{}X})", valueString.c_str(), value, pattern.getSize() * 2), &pattern));
}
void PatternDrawer::visit(pl::PatternFloat& pattern) {
if (pattern.getSize() == 4) {
float f32 = static_cast<float>(pattern.getValue(m_provider));
u32 integerResult = 0;
std::memcpy(&integerResult, &f32, sizeof(float));
this->createDefaultEntry(pattern, hex::format("{:e} (0x{:0{}X})", f32, integerResult, pattern.getSize() * 2), f32);
} else if (pattern.getSize() == 8) {
double f64 = pattern.getValue(m_provider);
u64 integerResult = 0;
std::memcpy(&integerResult, &f64, sizeof(double));
this->createDefaultEntry(pattern, hex::format("{:e} (0x{:0{}X})", f64, integerResult, pattern.getSize() * 2), f64);
}
}
void PatternDrawer::visit(pl::PatternPadding& pattern) {
// Do nothing
hex::unused(pattern);
}
void PatternDrawer::visit(pl::PatternPointer& pattern) {
u64 data = pattern.getValue(m_provider);
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::SameLine(0, 0);
drawColorColumn(pattern);
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "{}", pattern.getFormattedName());
ImGui::TableNextColumn();
ImGui::TextFormatted("{}", pattern.formatDisplayValue(hex::format("*(0x{0:X})", data), u128(data)));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.getPointedAtPattern()->accept(*this);
ImGui::TreePop();
}
}
void PatternDrawer::visit(pl::PatternSigned& pattern) {
i128 data = pattern.getValue(m_provider);
this->createDefaultEntry(pattern, hex::format("{:d} (0x{:0{}X})", data, data, 1 * 2), data);
}
void PatternDrawer::visit(pl::PatternString& pattern) {
auto size = std::min<size_t>(pattern.getSize(), 0x7F);
if (size == 0)
return;
std::string displayString = pattern.getValue(m_provider, size);
this->createDefaultEntry(pattern, hex::format("\"{0}\" {1}", displayString, size > pattern.getSize() ? "(truncated)" : ""), displayString);
}
void PatternDrawer::visit(pl::PatternStruct& pattern) {
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "struct");
ImGui::TextFormatted("{}", pattern.formatDisplayValue("{ ... }", &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.forEachMember([&](auto &member){
this->draw(member);
});
ImGui::TreePop();
}
}
void PatternDrawer::visit(pl::PatternUnion& pattern) {
bool open = true;
if (!pattern.isInlined()) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
drawTypenameColumn(pattern, "union");
ImGui::TextFormatted("{}", pattern.formatDisplayValue("{ ... }", &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
if (open) {
pattern.forEachMember([&](auto &member) {
this->draw(member);
});
ImGui::TreePop();
}
}
void PatternDrawer::visit(pl::PatternUnsigned& pattern) {
u128 data = pattern.getValue(m_provider);
this->createDefaultEntry(pattern, hex::format("{:d} (0x{:0{}X})", data, data, pattern.getSize() * 2), data);
}
void PatternDrawer::visit(pl::PatternWideCharacter& pattern) {
char16_t character = pattern.getValue(m_provider);
u128 literal = character;
auto str = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.to_bytes(character);
this->createDefaultEntry(pattern, hex::format("'{0}'", str), literal);
}
void PatternDrawer::visit(pl::PatternWideString& pattern) {
auto size = std::min<size_t>(pattern.getSize(), 0x100);
if (size == 0)
return;
std::string utf8String = pattern.getValue(m_provider, size);
this->createDefaultEntry(pattern, hex::format("\"{0}\" {1}", utf8String, size > pattern.getSize() ? "(truncated)" : ""), utf8String);
}
void PatternDrawer::createDefaultEntry(const pl::Pattern &pattern, const std::string &value, pl::Token::Literal &&literal) const {
ImGui::TableNextRow();
createLeafNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::SameLine();
drawNameColumn(pattern);
drawColorColumn(pattern);
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "{}", pattern.getTypeName().empty() ? pattern.getFormattedName() : pattern.getTypeName());
ImGui::TableNextColumn();
ImGui::TextFormatted("{}", pattern.formatDisplayValue(value, literal));
}
void PatternDrawer::makeSelectable(const pl::Pattern &pattern) const {
ImGui::PushID(static_cast<int>(pattern.getOffset()));
ImGui::PushID(pattern.getVariableName().c_str());
if (ImGui::Selectable("##PatternLine", false, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowItemOverlap)) {
ImHexApi::HexEditor::setSelection(pattern.getOffset(), pattern.getSize());
}
ImGui::SameLine();
ImGui::PopID();
ImGui::PopID();
}
void PatternDrawer::drawCommentTooltip(const pl::Pattern &pattern) const {
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem) && pattern.getComment().has_value()) {
ImGui::BeginTooltip();
ImGui::TextUnformatted(pattern.getComment()->c_str());
ImGui::EndTooltip();
}
}
void PatternDrawer::draw(pl::Pattern& pattern) {
if (pattern.isHidden())
return;
pattern.accept(*this);
}
bool PatternDrawer::drawArrayRoot(pl::Pattern& pattern, size_t entryCount, bool isInlined) {
if (entryCount == 0)
return false;
bool open = true;
if (!isInlined) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
open = createTreeNode(pattern);
ImGui::TableNextColumn();
makeSelectable(pattern);
drawCommentTooltip(pattern);
ImGui::TableNextColumn();
drawOffsetColumn(pattern);
drawSizeColumn(pattern);
ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "{0}", pattern.getTypeName());
ImGui::SameLine(0, 0);
ImGui::TextUnformatted("[");
ImGui::SameLine(0, 0);
ImGui::TextFormattedColored(ImColor(0xFF00FF00), "{0}", entryCount);
ImGui::SameLine(0, 0);
ImGui::TextUnformatted("]");
ImGui::TableNextColumn();
ImGui::TextFormatted("{}", pattern.formatDisplayValue("{ ... }", &pattern));
} else {
ImGui::SameLine();
ImGui::TreeNodeEx("", ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf);
}
return open;
}
void PatternDrawer::drawArrayNode(u64 idx, u64 displayEnd, pl::Pattern& pattern) {
u64 lastVisible = displayEnd - 1;
ImGui::PushID(pattern.getOffset());
if (idx < lastVisible) {
this->draw(pattern);
} else if (idx == lastVisible) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
ImGui::Selectable("... (Double-click to see more items)", false, ImGuiSelectableFlags_SpanAllColumns);
if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
displayEnd += DisplayEndStep;
}
ImGui::PopID();
}
void PatternDrawer::drawArrayEnd(pl::Pattern& pattern, bool opened) {
if (opened) {
ImGui::TreePop();
} else {
auto& displayEnd = this->getDisplayEnd(pattern);
displayEnd = DisplayEndDefault;
}
}
void PatternDrawer::createLeafNode(const pl::Pattern& pattern) const {
ImGui::TreeNodeEx(pattern.getDisplayName().c_str(), ImGuiTreeNodeFlags_Leaf |
ImGuiTreeNodeFlags_NoTreePushOnOpen |
ImGuiTreeNodeFlags_SpanFullWidth |
ImGuiTreeNodeFlags_AllowItemOverlap);
}
bool PatternDrawer::createTreeNode(const pl::Pattern& pattern) const {
return ImGui::TreeNodeEx(pattern.getDisplayName().c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
}
void PatternDrawer::drawTypenameColumn(const pl::Pattern& pattern, const std::string& pattern_name) const {
ImGui::TextFormattedColored(ImColor(0xFFD69C56), pattern_name);
ImGui::SameLine();
ImGui::TextUnformatted(pattern.getTypeName().c_str());
ImGui::TableNextColumn();
}
void PatternDrawer::drawNameColumn(const pl::Pattern& pattern) const {
ImGui::TextUnformatted(pattern.getDisplayName().c_str());
ImGui::TableNextColumn();
}
void PatternDrawer::drawColorColumn(const pl::Pattern& pattern) const {
ImGui::ColorButton("color", ImColor(pattern.getColor()), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetColumnWidth(), ImGui::GetTextLineHeight()));
ImGui::TableNextColumn();
}
void PatternDrawer::drawOffsetColumn(const pl::Pattern& pattern) const {
ImGui::TextFormatted("0x{0:08X} : 0x{1:08X}", pattern.getOffset(), pattern.getOffset() + pattern.getSize() - (pattern.getSize() == 0 ? 0 : 1));
ImGui::TableNextColumn();
}
void PatternDrawer::drawSizeColumn(const pl::Pattern& pattern) const {
ImGui::TextFormatted("0x{0:04X}", pattern.getSize());
ImGui::TableNextColumn();
}
u64& PatternDrawer::getDisplayEnd(const pl::Pattern& pattern) {
auto it = m_displayEnd.find(&pattern);
if (it != m_displayEnd.end()) {
return it->second;
}
auto [inserted, success] = m_displayEnd.emplace(&pattern, DisplayEndDefault);
return inserted->second;
}
};