Cool_Tools/ImHex
1
0
Fork 0
mirror of synced 2024-11-24 07:40:17 +01:00
Code Releases Wiki Activity

refactor: Make sure unlocalized strings are always actually unlocalized

Browse Source
This commit is contained in:
WerWolv 2023-12-19 12:22:28 +01:00
parent 8fe490ed03
commit dd4be3b772
40 changed files with 249 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
lib/libimhex/include/hex/api/achievement_manager.hpp
View File

@ -13,6 +13,7 @@
#include <imgui.h>
#include <hex/ui/imgui_imhex_extensions.h>
#include <hex/api/localization_manager.hpp>
namespace hex {
@ -20,13 +21,13 @@ namespace hex {
class Achievement {
public:
explicit Achievement(std::string unlocalizedCategory, std::string unlocalizedName) : m_unlocalizedCategory(std::move(unlocalizedCategory)), m_unlocalizedName(std::move(unlocalizedName)) { }
explicit Achievement(UnlocalizedString unlocalizedCategory, UnlocalizedString unlocalizedName) : m_unlocalizedCategory(std::move(unlocalizedCategory)), m_unlocalizedName(std::move(unlocalizedName)) { }
/**
* @brief Returns the unlocalized name of the achievement
* @return Unlocalized name of the achievement
*/
[[nodiscard]] const std::string &getUnlocalizedName() const {
[[nodiscard]] const UnlocalizedString &getUnlocalizedName() const {
return this->m_unlocalizedName;
}
@ -34,7 +35,7 @@ namespace hex {
* @brief Returns the unlocalized category of the achievement
* @return Unlocalized category of the achievement
*/
[[nodiscard]] const std::string &getUnlocalizedCategory() const {
[[nodiscard]] const UnlocalizedString &getUnlocalizedCategory() const {
return this->m_unlocalizedCategory;
}
@ -135,7 +136,7 @@ namespace hex {
* @brief Returns the unlocalized description of the achievement
* @return Unlocalized description of the achievement
*/
[[nodiscard]] const std::string &getUnlocalizedDescription() const {
[[nodiscard]] const UnlocalizedString &getUnlocalizedDescription() const {
return this->m_unlocalizedDescription;
}
@ -273,8 +274,8 @@ namespace hex {
}
private:
std::string m_unlocalizedCategory, m_unlocalizedName;
std::string m_unlocalizedDescription;
UnlocalizedString m_unlocalizedCategory, m_unlocalizedName;
UnlocalizedString m_unlocalizedDescription;
bool m_blacked = false;
bool m_invisible = false;
@ -364,7 +365,7 @@ namespace hex {
* @param unlocalizedCategory Unlocalized category of the achievement
* @param unlocalizedName Unlocalized name of the achievement
*/
static void unlockAchievement(const std::string &unlocalizedCategory, const std::string &unlocalizedName);
static void unlockAchievement(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName);
/**
* @brief Returns all registered achievements

87
lib/libimhex/include/hex/api/content_registry.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include <hex.hpp>
#include <hex/api/localization_manager.hpp>
#include <hex/helpers/concepts.hpp>
#include <pl/pattern_language.hpp>
@ -254,18 +255,18 @@ namespace hex {
namespace impl {
struct Entry {
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
std::unique_ptr<Widgets::Widget> widget;
};
struct SubCategory {
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
std::vector<Entry> entries;
};
struct Category {
std::string unlocalizedName;
std::string unlocalizedDescription;
UnlocalizedString unlocalizedName;
UnlocalizedString unlocalizedDescription;
std::vector<SubCategory> subCategories;
};
@ -274,14 +275,14 @@ namespace hex {
void clear();
std::vector<Category> &getSettings();
nlohmann::json& getSetting(const std::string &unlocalizedCategory, const std::string &unlocalizedName, const nlohmann::json &defaultValue);
nlohmann::json& getSetting(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &defaultValue);
nlohmann::json &getSettingsData();
Widgets::Widget* add(const std::string &unlocalizedCategory, const std::string &unlocalizedSubCategory, const std::string &unlocalizedName, std::unique_ptr<Widgets::Widget> &&widget);
Widgets::Widget* add(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedSubCategory, const UnlocalizedString &unlocalizedName, std::unique_ptr<Widgets::Widget> &&widget);
}
template<std::derived_from<Widgets::Widget> T>
Widgets::Widget::Interface& add(const std::string &unlocalizedCategory, const std::string &unlocalizedSubCategory, const std::string &unlocalizedName, auto && ... args) {
Widgets::Widget::Interface& add(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedSubCategory, const UnlocalizedString &unlocalizedName, auto && ... args) {
return impl::add(
unlocalizedCategory,
unlocalizedSubCategory,
@ -290,10 +291,10 @@ namespace hex {
)->getInterface();
}
void setCategoryDescription(const std::string &unlocalizedCategory, const std::string &unlocalizedDescription);
void setCategoryDescription(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedDescription);
[[nodiscard]] nlohmann::json read(const std::string &unlocalizedCategory, const std::string &unlocalizedName, const nlohmann::json &defaultValue);
void write(const std::string &unlocalizedCategory, const std::string &unlocalizedName, const nlohmann::json &value);
[[nodiscard]] nlohmann::json read(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &defaultValue);
void write(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &value);
}
/* Command Palette Command Registry. Allows adding of new commands to the command palette */
@ -318,7 +319,7 @@ namespace hex {
struct Entry {
Type type;
std::string command;
std::string unlocalizedDescription;
UnlocalizedString unlocalizedDescription;
DisplayCallback displayCallback;
ExecuteCallback executeCallback;
};
@ -346,7 +347,7 @@ namespace hex {
void add(
Type type,
const std::string &command,
const std::string &unlocalizedDescription,
const UnlocalizedString &unlocalizedDescription,
const impl::DisplayCallback &displayCallback,
const impl::ExecuteCallback &executeCallback = [](auto) {});
@ -484,7 +485,7 @@ namespace hex {
* @param unlocalizedName The unlocalized name of the view
* @return The view if it exists, nullptr otherwise
*/
View* getViewByName(const std::string &unlocalizedName);
View* getViewByName(const UnlocalizedString &unlocalizedName);
}
/* Tools Registry. Allows adding new entries to the tools window */
@ -509,7 +510,7 @@ namespace hex {
* @param unlocalizedName The unlocalized name of the tool
* @param function The function that will be called to draw the tool
*/
void add(const std::string &unlocalizedName, const impl::Callback &function);
void add(const UnlocalizedString &unlocalizedName, const impl::Callback &function);
}
/* Data Inspector Registry. Allows adding of new types to the data inspector */
@ -529,7 +530,7 @@ namespace hex {
using GeneratorFunction = std::function<DisplayFunction(const std::vector<u8> &, std::endian, NumberDisplayStyle)>;
struct Entry {
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
size_t requiredSize;
size_t maxSize;
GeneratorFunction generatorFunction;
@ -547,7 +548,7 @@ namespace hex {
* @param displayGeneratorFunction The function that will be called to generate the display function
* @param editingFunction The function that will be called to edit the data
*/
void add(const std::string &unlocalizedName, size_t requiredSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction = std::nullopt);
void add(const UnlocalizedString &unlocalizedName, size_t requiredSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction = std::nullopt);
/**
* @brief Adds a new entry to the data inspector
@ -557,7 +558,7 @@ namespace hex {
* @param displayGeneratorFunction The function that will be called to generate the display function
* @param editingFunction The function that will be called to edit the data
*/
void add(const std::string &unlocalizedName, size_t requiredSize, size_t maxSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction = std::nullopt);
void add(const UnlocalizedString &unlocalizedName, size_t requiredSize, size_t maxSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction = std::nullopt);
}
/* Data Processor Node Registry. Allows adding new processor nodes to be used in the data processor */
@ -568,8 +569,8 @@ namespace hex {
using CreatorFunction = std::function<std::unique_ptr<dp::Node>()>;
struct Entry {
std::string category;
std::string name;
UnlocalizedString unlocalizedCategory;
UnlocalizedString unlocalizedName;
CreatorFunction creatorFunction;
};
@ -588,10 +589,10 @@ namespace hex {
* @param args Arguments passed to the constructor of the node
*/
template<std::derived_from<dp::Node> T, typename... Args>
void add(const std::string &unlocalizedCategory, const std::string &unlocalizedName, Args &&...args) {
void add(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, Args &&...args) {
add(impl::Entry {
unlocalizedCategory.c_str(),
unlocalizedName.c_str(),
unlocalizedCategory,
unlocalizedName,
[=, ...args = std::forward<Args>(args)] mutable {
auto node = std::make_unique<T>(std::forward<Args>(args)...);
node->setUnlocalizedName(unlocalizedName);
@ -636,11 +637,11 @@ namespace hex {
using ClickCallback = std::function<void()>;
struct MainMenuItem {
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
};
struct MenuItem {
std::vector<std::string> unlocalizedNames;
std::vector<UnlocalizedString> unlocalizedNames;
std::unique_ptr<Shortcut> shortcut;
View *view;
MenuCallback callback;
@ -655,7 +656,7 @@ namespace hex {
struct TitleBarButton {
std::string icon;
std::string unlocalizedTooltip;
UnlocalizedString unlocalizedTooltip;
ClickCallback callback;
};
@ -678,7 +679,7 @@ namespace hex {
* @param unlocalizedName The unlocalized name of the entry
* @param priority The priority of the entry. Lower values are displayed first
*/
void registerMainMenuItem(const std::string &unlocalizedName, u32 priority);
void registerMainMenuItem(const UnlocalizedString &unlocalizedName, u32 priority);
/**
* @brief Adds a new main menu entry
@ -689,7 +690,7 @@ namespace hex {
* @param enabledCallback The function to call to determine if the entry is enabled
* @param view The view to use for the entry. If nullptr, the shortcut will work globally
*/
void addMenuItem(const std::vector<std::string> &unlocalizedMainMenuNames, u32 priority, const Shortcut &shortcut, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback = []{ return true; }, View *view = nullptr);
void addMenuItem(const std::vector<UnlocalizedString> &unlocalizedMainMenuNames, u32 priority, const Shortcut &shortcut, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback = []{ return true; }, View *view = nullptr);
/**
* @brief Adds a new main menu sub-menu entry
@ -698,14 +699,14 @@ namespace hex {
* @param function The function to call when the entry is clicked
* @param enabledCallback The function to call to determine if the entry is enabled
*/
void addMenuItemSubMenu(std::vector<std::string> unlocalizedMainMenuNames, u32 priority, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback = []{ return true; });
void addMenuItemSubMenu(std::vector<UnlocalizedString> unlocalizedMainMenuNames, u32 priority, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback = []{ return true; });
/**
* @brief Adds a new main menu separator
* @param unlocalizedMainMenuNames The unlocalized names of the main menu entries
* @param priority The priority of the entry. Lower values are displayed first
*/
void addMenuItemSeparator(std::vector<std::string> unlocalizedMainMenuNames, u32 priority);
void addMenuItemSeparator(std::vector<UnlocalizedString> unlocalizedMainMenuNames, u32 priority);
/**
@ -740,7 +741,7 @@ namespace hex {
* @param unlocalizedTooltip The unlocalized tooltip to use for the button
* @param function The function to call when the button is clicked
*/
void addTitleBarButton(const std::string &icon, const std::string &unlocalizedTooltip, const impl::ClickCallback &function);
void addTitleBarButton(const std::string &icon, const UnlocalizedString &unlocalizedTooltip, const impl::ClickCallback &function);
}
@ -749,7 +750,7 @@ namespace hex {
namespace impl {
void addProviderName(const std::string &unlocalizedName);
void addProviderName(const UnlocalizedString &unlocalizedName);
using ProviderCreationFunction = prv::Provider*(*)();
void add(const std::string &typeName, ProviderCreationFunction creationFunction);
@ -784,7 +785,7 @@ namespace hex {
using Callback = std::function<std::string(prv::Provider *provider, u64 address, size_t size)>;
struct Entry {
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
Callback callback;
};
@ -798,7 +799,7 @@ namespace hex {
* @param unlocalizedName The unlocalized name of the formatter
* @param callback The function to call to format the data
*/
void add(const std::string &unlocalizedName, const impl::Callback &callback);
void add(const UnlocalizedString &unlocalizedName, const impl::Callback &callback);
}
@ -831,7 +832,7 @@ namespace hex {
class DataVisualizer {
public:
DataVisualizer(std::string unlocalizedName, u16 bytesPerCell, u16 maxCharsPerCell)
DataVisualizer(UnlocalizedString unlocalizedName, u16 bytesPerCell, u16 maxCharsPerCell)
: m_unlocalizedName(std::move(unlocalizedName)),
m_bytesPerCell(bytesPerCell),
m_maxCharsPerCell(maxCharsPerCell) { }
@ -844,7 +845,7 @@ namespace hex {
[[nodiscard]] u16 getBytesPerCell() const { return this->m_bytesPerCell; }
[[nodiscard]] u16 getMaxCharsPerCell() const { return this->m_maxCharsPerCell; }
[[nodiscard]] const std::string& getUnlocalizedName() const { return this->m_unlocalizedName; }
[[nodiscard]] const UnlocalizedString& getUnlocalizedName() const { return this->m_unlocalizedName; }
protected:
const static int TextInputFlags;
@ -853,7 +854,7 @@ namespace hex {
bool drawDefaultTextEditingTextBox(u64 address, std::string &data, ImGuiInputTextFlags flags) const;
private:
std::string m_unlocalizedName;
UnlocalizedString m_unlocalizedName;
u16 m_bytesPerCell;
u16 m_maxCharsPerCell;
};
@ -881,7 +882,7 @@ namespace hex {
* @param unlocalizedName Unlocalized name of the data visualizer
* @return The data visualizer, or nullptr if it doesn't exist
*/
std::shared_ptr<DataVisualizer> getVisualizerByName(const std::string &unlocalizedName);
std::shared_ptr<DataVisualizer> getVisualizerByName(const UnlocalizedString &unlocalizedName);
}
@ -890,7 +891,7 @@ namespace hex {
class Hash {
public:
explicit Hash(std::string unlocalizedName) : m_unlocalizedName(std::move(unlocalizedName)) {}
explicit Hash(UnlocalizedString unlocalizedName) : m_unlocalizedName(std::move(unlocalizedName)) {}
virtual ~Hash() = default;
class Function {
@ -932,7 +933,7 @@ namespace hex {
[[nodiscard]] virtual nlohmann::json store() const = 0;
virtual void load(const nlohmann::json &json) = 0;
[[nodiscard]] const std::string &getUnlocalizedName() const {
[[nodiscard]] const UnlocalizedString &getUnlocalizedName() const {
return this->m_unlocalizedName;
}
@ -942,7 +943,7 @@ namespace hex {
}
private:
std::string m_unlocalizedName;
UnlocalizedString m_unlocalizedName;
};
namespace impl {
@ -980,7 +981,7 @@ namespace hex {
void stopServices();
}
void registerService(const std::string &unlocalizedName, const impl::Callback &callback);
void registerService(const UnlocalizedString &unlocalizedName, const impl::Callback &callback);
}
/* Network Communication Interface Registry. Allows adding new communication interface endpoints */
@ -1002,14 +1003,14 @@ namespace hex {
namespace impl {
struct Experiment {
std::string unlocalizedName, unlocalizedDescription;
UnlocalizedString unlocalizedName, unlocalizedDescription;
bool enabled;
};
std::map<std::string, Experiment> &getExperiments();
}
void addExperiment(const std::string &experimentName, const std::string &unlocalizedName, const std::string &unlocalizedDescription = "");
void addExperiment(const std::string &experimentName, const UnlocalizedString &unlocalizedName, const UnlocalizedString &unlocalizedDescription = "");
void enableExperiement(const std::string &experimentName, bool enabled);
[[nodiscard]] bool isExperimentEnabled(const std::string &experimentName);

3
lib/libimhex/include/hex/api/imhex_api.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include <hex.hpp>
#include <hex/api/localization_manager.hpp>
#include <optional>
#include <span>
@ -338,7 +339,7 @@ namespace hex {
* @param skipLoadInterface Whether to skip the provider's loading interface (see property documentation)
* @param select Whether to select the provider after adding it
*/
prv::Provider* createProvider(const std::string &unlocalizedName, bool skipLoadInterface = false, bool select = true);
prv::Provider* createProvider(const UnlocalizedString &unlocalizedName, bool skipLoadInterface = false, bool select = true);
}

42
lib/libimhex/include/hex/api/localization_manager.hpp
View File

@ -32,10 +32,13 @@ namespace hex {
[[nodiscard]] const std::string &getSelectedLanguage();
}
struct UnlocalizedString;
class Lang {
public:
explicit Lang(const char *unlocalizedString);
explicit Lang(std::string unlocalizedString);
explicit Lang(const std::string &unlocalizedString);
explicit Lang(const UnlocalizedString &unlocalizedString);
explicit Lang(std::string_view unlocalizedString);
[[nodiscard]] operator std::string() const;
@ -60,6 +63,43 @@ namespace hex {
return Lang(string);
}
struct UnlocalizedString {
public:
UnlocalizedString() = default;
UnlocalizedString(auto && arg) : m_unlocalizedString(std::forward<decltype(arg)>(arg)) {
static_assert(!std::same_as<std::remove_cvref_t<decltype(arg)>, Lang>, "Expected a unlocalized name, got a localized one!");
}
[[nodiscard]] operator std::string() const {
return m_unlocalizedString;
}
[[nodiscard]] operator std::string_view() const {
return m_unlocalizedString;
}
[[nodiscard]] operator const char *() const {
return m_unlocalizedString.c_str();
}
[[nodiscard]] const std::string &get() const {
return m_unlocalizedString;
}
[[nodiscard]] bool empty() const {
return m_unlocalizedString.empty();
}
auto operator<=>(const UnlocalizedString &) const = default;
auto operator<=>(const std::string &other) const {
return m_unlocalizedString <=> other;
}
private:
std::string m_unlocalizedString;
};
}
template<>

10
lib/libimhex/include/hex/api/shortcut_manager.hpp
View File

@ -1,7 +1,7 @@
#pragma once
#include <hex.hpp>
#include <GLFW/glfw3.h>
#include <hex/api/localization_manager.hpp>
#include <functional>
#include <memory>
@ -9,6 +9,8 @@
#include <set>
#include <string>
#include <GLFW/glfw3.h>
struct ImGuiWindow;
namespace hex {
@ -391,7 +393,7 @@ namespace hex {
using Callback = std::function<void()>;
struct ShortcutEntry {
Shortcut shortcut;
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
Callback callback;
};
@ -401,7 +403,7 @@ namespace hex {
* @param unlocalizedName The unlocalized name of the shortcut
* @param callback The callback to call when the shortcut is triggered.
*/
static void addGlobalShortcut(const Shortcut &shortcut, const std::string &unlocalizedName, const Callback &callback);
static void addGlobalShortcut(const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const Callback &callback);
/**
* @brief Add a view-specific shortcut. View-specific shortcuts can only be triggered when the specified view is focused.
@ -410,7 +412,7 @@ namespace hex {
* @param unlocalizedName The unlocalized name of the shortcut
* @param callback The callback to call when the shortcut is triggered.
*/
static void addShortcut(View *view, const Shortcut &shortcut, const std::string &unlocalizedName, const Callback &callback);
static void addShortcut(View *view, const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const Callback &callback);
/**

7
lib/libimhex/include/hex/api/task_manager.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include <hex.hpp>
#include <hex/api/localization_manager.hpp>
#include <cstdio>
#include <thread>
@ -23,7 +24,7 @@ namespace hex {
class Task {
public:
Task() = default;
Task(std::string unlocalizedName, u64 maxValue, bool background, std::function<void(Task &)> function);
Task(UnlocalizedString unlocalizedName, u64 maxValue, bool background, std::function<void(Task &)> function);
Task(const Task&) = delete;
Task(Task &&other) noexcept;
@ -64,7 +65,7 @@ namespace hex {
void clearException();
[[nodiscard]] std::string getExceptionMessage() const;
[[nodiscard]] const std::string &getUnlocalizedName();
[[nodiscard]] const UnlocalizedString &getUnlocalizedName();
[[nodiscard]] u64 getValue() const;
[[nodiscard]] u64 getMaxValue() const;
@ -76,7 +77,7 @@ namespace hex {
private:
mutable std::mutex m_mutex;
std::string m_unlocalizedName;
UnlocalizedString m_unlocalizedName;
std::atomic<u64> m_currValue = 0, m_maxValue = 0;
std::function<void()> m_interruptCallback;
std::function<void(Task &)> m_function;

24
lib/libimhex/include/hex/api/tutorial_manager.hpp
View File

@ -24,7 +24,7 @@ namespace hex {
struct Tutorial {
Tutorial() = delete;
Tutorial(const std::string &unlocalizedName, const std::string &unlocalizedDescription) :
Tutorial(const UnlocalizedString &unlocalizedName, const UnlocalizedString &unlocalizedDescription) :
m_unlocalizedName(unlocalizedName),
m_unlocalizedDescription(unlocalizedDescription) { }
@ -37,7 +37,7 @@ namespace hex {
* @param ids ID of the element to highlight
* @return Current step
*/
Step& addHighlight(const std::string &unlocalizedText, std::initializer_list<std::variant<Lang, std::string, int>> &&ids);
Step& addHighlight(const UnlocalizedString &unlocalizedText, std::initializer_list<std::variant<Lang, std::string, int>> &&ids);
/**
* @brief Adds a highlighting to a specific element
@ -53,7 +53,7 @@ namespace hex {
* @param position Position of the message box
* @return Current step
*/
Step& setMessage(const std::string &unlocalizedTitle, const std::string &unlocalizedMessage, Position position = Position::None);
Step& setMessage(const UnlocalizedString &unlocalizedTitle, const UnlocalizedString &unlocalizedMessage, Position position = Position::None);
/**
* @brief Allows this step to be skipped by clicking on the advance button
@ -78,14 +78,14 @@ namespace hex {
private:
struct Highlight {
std::string unlocalizedText;
UnlocalizedString unlocalizedText;
std::vector<std::variant<Lang, std::string, int>> highlightIds;
};
struct Message {
Position position;
std::string unlocalizedTitle;
std::string unlocalizedMessage;
UnlocalizedString unlocalizedTitle;
UnlocalizedString unlocalizedMessage;
bool allowSkip;
};
@ -105,16 +105,16 @@ namespace hex {
Step& addStep();
const std::string& getUnlocalizedName() const { return this->m_unlocalizedName; }
const std::string& getUnlocalizedDescription() const { return this->m_unlocalizedDescription; }
const UnlocalizedString& getUnlocalizedName() const { return this->m_unlocalizedName; }
const UnlocalizedString& getUnlocalizedDescription() const { return this->m_unlocalizedDescription; }
private:
friend class TutorialManager;
void start();
std::string m_unlocalizedName;
std::string m_unlocalizedDescription;
UnlocalizedString m_unlocalizedName;
UnlocalizedString m_unlocalizedDescription;
std::list<Step> m_steps;
decltype(m_steps)::iterator m_currentStep, m_latestStep;
};
@ -137,13 +137,13 @@ namespace hex {
* @param unlocalizedDescription
* @return Reference to created tutorial
*/
static Tutorial& createTutorial(const std::string &unlocalizedName, const std::string &unlocalizedDescription);
static Tutorial& createTutorial(const UnlocalizedString &unlocalizedName, const UnlocalizedString &unlocalizedDescription);
/**
* @brief Starts the tutorial with the given name
* @param unlocalizedName Name of tutorial to start
*/
static void startTutorial(const std::string &unlocalizedName);
static void startTutorial(const UnlocalizedString &unlocalizedName);
/**

8
lib/libimhex/include/hex/data_processor/attribute.hpp
View File

@ -1,5 +1,7 @@
#pragma once
#include <hex.hpp>
#include <hex/api/localization_manager.hpp>
#include <string>
#include <string_view>
@ -23,7 +25,7 @@ namespace hex::dp {
Out
};
Attribute(IOType ioType, Type type, std::string unlocalizedName);
Attribute(IOType ioType, Type type, UnlocalizedString unlocalizedName);
~Attribute();
[[nodiscard]] int getId() const { return this->m_id; }
@ -31,7 +33,7 @@ namespace hex::dp {
[[nodiscard]] IOType getIOType() const { return this->m_ioType; }
[[nodiscard]] Type getType() const { return this->m_type; }
[[nodiscard]] const std::string &getUnlocalizedName() const { return this->m_unlocalizedName; }
[[nodiscard]] const UnlocalizedString &getUnlocalizedName() const { return this->m_unlocalizedName; }
void addConnectedAttribute(int linkId, Attribute *to) { this->m_connectedAttributes.insert({ linkId, to }); }
void removeConnectedAttribute(int linkId) { this->m_connectedAttributes.erase(linkId); }
@ -56,7 +58,7 @@ namespace hex::dp {
int m_id;
IOType m_ioType;
Type m_type;
std::string m_unlocalizedName;
UnlocalizedString m_unlocalizedName;
std::map<int, Attribute *> m_connectedAttributes;
Node *m_parentNode = nullptr;

11
lib/libimhex/include/hex/data_processor/node.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include <hex.hpp>
#include <hex/api/localization_manager.hpp>
#include <hex/helpers/intrinsics.hpp>
#include <hex/data_processor/attribute.hpp>
@ -21,17 +22,17 @@ namespace hex::dp {
class Node {
public:
Node(std::string unlocalizedTitle, std::vector<Attribute> attributes);
Node(UnlocalizedString unlocalizedTitle, std::vector<Attribute> attributes);
virtual ~Node() = default;
[[nodiscard]] int getId() const { return this->m_id; }
void setId(int id) { this->m_id = id; }
[[nodiscard]] const std::string &getUnlocalizedName() const { return this->m_unlocalizedName; }
void setUnlocalizedName(const std::string &unlocalizedName) { this->m_unlocalizedName = unlocalizedName; }
[[nodiscard]] const UnlocalizedString &getUnlocalizedName() const { return this->m_unlocalizedName; }
void setUnlocalizedName(const UnlocalizedString &unlocalizedName) { this->m_unlocalizedName = unlocalizedName; }
[[nodiscard]] const std::string &getUnlocalizedTitle() const { return this->m_unlocalizedTitle; }
[[nodiscard]] const UnlocalizedString &getUnlocalizedTitle() const { return this->m_unlocalizedTitle; }
void setUnlocalizedTitle(std::string title) { this->m_unlocalizedTitle = std::move(title); }
[[nodiscard]] std::vector<Attribute> &getAttributes() { return this->m_attributes; }
@ -81,7 +82,7 @@ namespace hex::dp {
private:
int m_id;
std::string m_unlocalizedTitle, m_unlocalizedName;
UnlocalizedString m_unlocalizedTitle, m_unlocalizedName;
std::vector<Attribute> m_attributes;
std::set<u32> m_processedInputs;
prv::Overlay *m_overlay = nullptr;

4
lib/libimhex/include/hex/providers/undo_redo/operations/operation_group.hpp
View File

@ -10,7 +10,7 @@ namespace hex::prv::undo {
class OperationGroup : public Operation {
public:
explicit OperationGroup(std::string unlocalizedName) : m_unlocalizedName(std::move(unlocalizedName)) {}
explicit OperationGroup(UnlocalizedString unlocalizedName) : m_unlocalizedName(std::move(unlocalizedName)) {}
OperationGroup(const OperationGroup &other) {
for (const auto &operation : other.m_operations)
@ -59,7 +59,7 @@ namespace hex::prv::undo {
}
private:
std::string m_unlocalizedName;
UnlocalizedString m_unlocalizedName;
std::vector<std::unique_ptr<Operation>> m_operations;
u64 m_startAddress = std::numeric_limits<u64>::max();

5
lib/libimhex/include/hex/providers/undo_redo/stack.hpp
View File

@ -1,9 +1,10 @@
#pragma once
#include <hex.hpp>
#include <hex/api/localization_manager.hpp>
#include <hex/providers/undo_redo/operations/operation.hpp>
#include <atomic>
#include <map>
#include <memory>
#include <mutex>
@ -24,7 +25,7 @@ namespace hex::prv::undo {
void undo(u32 count = 1);
void redo(u32 count = 1);
void groupOperations(u32 count, const std::string &unlocalizedName);
void groupOperations(u32 count, const UnlocalizedString &unlocalizedName);
void apply(const Stack &otherStack);
[[nodiscard]] bool canUndo() const;

9
lib/libimhex/include/hex/ui/popup.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include <hex.hpp>
#include <hex/api/localization_manager.hpp>
#include <memory>
#include <string>
@ -17,7 +18,7 @@ namespace hex {
class PopupBase {
public:
explicit PopupBase(std::string unlocalizedName, bool closeButton, bool modal)
explicit PopupBase(UnlocalizedString unlocalizedName, bool closeButton, bool modal)
: m_unlocalizedName(std::move(unlocalizedName)), m_closeButton(closeButton), m_modal(modal) { }
virtual ~PopupBase() = default;
@ -35,7 +36,7 @@ namespace hex {
[[nodiscard]] static std::vector<std::unique_ptr<PopupBase>> &getOpenPopups();
[[nodiscard]] const std::string &getUnlocalizedName() const {
[[nodiscard]] const UnlocalizedString &getUnlocalizedName() const {
return this->m_unlocalizedName;
}
@ -57,7 +58,7 @@ namespace hex {
private:
std::string m_unlocalizedName;
UnlocalizedString m_unlocalizedName;
bool m_closeButton, m_modal;
std::atomic<bool> m_close = false;
};
@ -68,7 +69,7 @@ namespace hex {
template<typename T>
class Popup : public impl::PopupBase {
protected:
explicit Popup(std::string unlocalizedName, bool closeButton = true, bool modal = true) : PopupBase(std::move(unlocalizedName), closeButton, modal) { }
explicit Popup(UnlocalizedString unlocalizedName, bool closeButton = true, bool modal = true) : PopupBase(std::move(unlocalizedName), closeButton, modal) { }
public:
template<typename ...Args>

19
lib/libimhex/include/hex/ui/view.hpp
View File

@ -11,11 +11,12 @@
#include <hex/api/imhex_api.hpp>
#include <hex/api/shortcut_manager.hpp>
#include <hex/api/event_manager.hpp>
#include <hex/api/localization_manager.hpp>
#include <hex/providers/provider.hpp>
#include <hex/providers/provider_data.hpp>
#include <hex/helpers/utils.hpp>
#include <hex/api/localization_manager.hpp>
#include <map>
#include <string>
@ -23,7 +24,7 @@
namespace hex {
class View {
explicit View(std::string unlocalizedName);
explicit View(UnlocalizedString unlocalizedName);
public:
virtual ~View() = default;
@ -86,7 +87,7 @@ namespace hex {
[[nodiscard]] bool &getWindowOpenState();
[[nodiscard]] const bool &getWindowOpenState() const;
[[nodiscard]] const std::string &getUnlocalizedName() const;
[[nodiscard]] const UnlocalizedString &getUnlocalizedName() const;
[[nodiscard]] std::string getName() const;
[[nodiscard]] bool didWindowJustOpen();
@ -96,7 +97,7 @@ namespace hex {
static void discardNavigationRequests();
[[nodiscard]] static std::string toWindowName(const std::string &unlocalizedName);
[[nodiscard]] static std::string toWindowName(const UnlocalizedString &unlocalizedName);
public:
class Window;
@ -105,7 +106,7 @@ namespace hex {
class Modal;
private:
std::string m_unlocalizedViewName;
UnlocalizedString m_unlocalizedViewName;
bool m_windowOpen = false, m_prevWindowOpen = false;
std::map<Shortcut, ShortcutManager::ShortcutEntry> m_shortcuts;
bool m_windowJustOpened = false;
@ -119,7 +120,7 @@ namespace hex {
*/
class View::Window : public View {
public:
explicit Window(std::string unlocalizedName) : View(std::move(unlocalizedName)) {}
explicit Window(UnlocalizedString unlocalizedName) : View(std::move(unlocalizedName)) {}
void draw() final {
if (this->shouldDraw()) {
@ -138,7 +139,7 @@ namespace hex {
*/
class View::Special : public View {
public:
explicit Special(std::string unlocalizedName) : View(std::move(unlocalizedName)) {}
explicit Special(UnlocalizedString unlocalizedName) : View(std::move(unlocalizedName)) {}
void draw() final {
if (this->shouldDraw()) {
@ -153,7 +154,7 @@ namespace hex {
*/
class View::Floating : public View::Window {
public:
explicit Floating(std::string unlocalizedName) : Window(std::move(unlocalizedName)) {}
explicit Floating(UnlocalizedString unlocalizedName) : Window(std::move(unlocalizedName)) {}
[[nodiscard]] ImGuiWindowFlags getWindowFlags() const override { return ImGuiWindowFlags_NoDocking; }
};
@ -163,7 +164,7 @@ namespace hex {
*/
class View::Modal : public View {
public:
explicit Modal(std::string unlocalizedName) : View(std::move(unlocalizedName)) {}
explicit Modal(UnlocalizedString unlocalizedName) : View(std::move(unlocalizedName)) {}
void draw() final {
if (this->shouldDraw()) {

2
lib/libimhex/source/api/achievement_manager.cpp
View File

@ -87,7 +87,7 @@ namespace hex {
return startNodes;
}
void AchievementManager::unlockAchievement(const std::string &unlocalizedCategory, const std::string &unlocalizedName) {
void AchievementManager::unlockAchievement(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName) {
auto &categories = getAchievements();
auto categoryIter = categories.find(unlocalizedCategory);

64
lib/libimhex/source/api/content_registry.cpp
View File

@ -28,7 +28,7 @@ namespace hex {
namespace impl {
nlohmann::json& getSetting(const std::string &unlocalizedCategory, const std::string &unlocalizedName, const nlohmann::json &defaultValue) {
nlohmann::json& getSetting(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &defaultValue) {
auto &settings = getSettingsData();
if (!settings.contains(unlocalizedCategory))
@ -113,7 +113,7 @@ namespace hex {
#endif
template<typename T>
static T* insertOrGetEntry(std::vector<T> &vector, const std::string &unlocalizedName) {
static T* insertOrGetEntry(std::vector<T> &vector, const UnlocalizedString &unlocalizedName) {
T *foundEntry = nullptr;
for (auto &entry : vector) {
if (entry.unlocalizedName == unlocalizedName) {
@ -138,7 +138,7 @@ namespace hex {
return categories;
}
Widgets::Widget* add(const std::string &unlocalizedCategory, const std::string &unlocalizedSubCategory, const std::string &unlocalizedName, std::unique_ptr<Widgets::Widget> &&widget) {
Widgets::Widget* add(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedSubCategory, const UnlocalizedString &unlocalizedName, std::unique_ptr<Widgets::Widget> &&widget) {
const auto category = insertOrGetEntry(getSettings(), unlocalizedCategory);
const auto subCategory = insertOrGetEntry(category->subCategories, unlocalizedSubCategory);
const auto entry = insertOrGetEntry(subCategory->entries, unlocalizedName);
@ -152,13 +152,13 @@ namespace hex {
}
void setCategoryDescription(const std::string &unlocalizedCategory, const std::string &unlocalizedDescription) {
void setCategoryDescription(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedDescription) {
const auto category = insertOrGetEntry(impl::getSettings(), unlocalizedCategory);
category->unlocalizedDescription = unlocalizedDescription;
}
nlohmann::json read(const std::string &unlocalizedCategory, const std::string &unlocalizedName, const nlohmann::json &defaultValue) {
nlohmann::json read(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &defaultValue) {
auto setting = impl::getSetting(unlocalizedCategory, unlocalizedName, defaultValue);
if (setting.is_number() && defaultValue.is_boolean())
@ -169,7 +169,7 @@ namespace hex {
return setting;
}
void write(const std::string &unlocalizedCategory, const std::string &unlocalizedName, const nlohmann::json &value) {
void write(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &value) {
impl::getSetting(unlocalizedCategory, unlocalizedName, value) = value;
}
@ -391,7 +391,7 @@ namespace hex {
namespace ContentRegistry::CommandPaletteCommands {
void add(Type type, const std::string &command, const std::string &unlocalizedDescription, const impl::DisplayCallback &displayCallback, const impl::ExecuteCallback &executeCallback) {
void add(Type type, const std::string &command, const UnlocalizedString &unlocalizedDescription, const impl::DisplayCallback &displayCallback, const impl::ExecuteCallback &executeCallback) {
log::debug("Registered new command palette command: {}", command);
impl::getEntries().push_back(impl::Entry { type, command, unlocalizedDescription, displayCallback, executeCallback });
@ -561,12 +561,12 @@ namespace hex {
}
void impl::add(std::unique_ptr<View> &&view) {
log::debug("Registered new view: {}", view->getUnlocalizedName());
log::debug("Registered new view: {}", view->getUnlocalizedName().get());
getEntries().insert({ view->getUnlocalizedName(), std::move(view) });
}
View* getViewByName(const std::string &unlocalizedName) {
View* getViewByName(const UnlocalizedString &unlocalizedName) {
auto &views = impl::getEntries();
if (views.contains(unlocalizedName))
@ -579,8 +579,8 @@ namespace hex {
namespace ContentRegistry::Tools {
void add(const std::string &unlocalizedName, const impl::Callback &function) {
log::debug("Registered new tool: {}", unlocalizedName);
void add(const UnlocalizedString &unlocalizedName, const impl::Callback &function) {
log::debug("Registered new tool: {}", unlocalizedName.get());
impl::getEntries().emplace_back(impl::Entry { unlocalizedName, function, false });
}
@ -599,14 +599,14 @@ namespace hex {
namespace ContentRegistry::DataInspector {
void add(const std::string &unlocalizedName, size_t requiredSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction) {
log::debug("Registered new data inspector format: {}", unlocalizedName);
void add(const UnlocalizedString &unlocalizedName, size_t requiredSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction) {
log::debug("Registered new data inspector format: {}", unlocalizedName.get());
impl::getEntries().push_back({ unlocalizedName, requiredSize, requiredSize, std::move(displayGeneratorFunction), std::move(editingFunction) });
}
void add(const std::string &unlocalizedName, size_t requiredSize, size_t maxSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction) {
log::debug("Registered new data inspector format: {}", unlocalizedName);
void add(const UnlocalizedString &unlocalizedName, size_t requiredSize, size_t maxSize, impl::GeneratorFunction displayGeneratorFunction, std::optional<impl::EditingFunction> editingFunction) {
log::debug("Registered new data inspector format: {}", unlocalizedName.get());
impl::getEntries().push_back({ unlocalizedName, requiredSize, maxSize, std::move(displayGeneratorFunction), std::move(editingFunction) });
}
@ -627,7 +627,7 @@ namespace hex {
namespace ContentRegistry::DataProcessorNode {
void impl::add(const Entry &entry) {
log::debug("Registered new data processor node type: [{}]: {}", entry.category, entry.name);
log::debug("Registered new data processor node type: [{}]: {}", entry.unlocalizedCategory.get(), entry.unlocalizedName.get());
getEntries().push_back(entry);
}
@ -712,14 +712,14 @@ namespace hex {
namespace ContentRegistry::Interface {
void registerMainMenuItem(const std::string &unlocalizedName, u32 priority) {
log::debug("Registered new main menu item: {}", unlocalizedName);
void registerMainMenuItem(const UnlocalizedString &unlocalizedName, u32 priority) {
log::debug("Registered new main menu item: {}", unlocalizedName.get());
impl::getMainMenuItems().insert({ priority, { unlocalizedName } });
}
void addMenuItem(const std::vector<std::string> &unlocalizedMainMenuNames, u32 priority, const Shortcut &shortcut, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback, View *view) {
log::debug("Added new menu item to menu {} with priority {}", wolv::util::combineStrings(unlocalizedMainMenuNames, " -> "), priority);
void addMenuItem(const std::vector<UnlocalizedString> &unlocalizedMainMenuNames, u32 priority, const Shortcut &shortcut, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback, View *view) {
log::debug("Added new menu item to menu {} with priority {}", unlocalizedMainMenuNames[0].get(), priority);
impl::getMenuItems().insert({
priority, impl::MenuItem { unlocalizedMainMenuNames, std::make_unique<Shortcut>(shortcut), view, function, enabledCallback }
@ -733,8 +733,8 @@ namespace hex {
}
}
void addMenuItemSubMenu(std::vector<std::string> unlocalizedMainMenuNames, u32 priority, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback) {
log::debug("Added new menu item sub menu to menu {} with priority {}", wolv::util::combineStrings(unlocalizedMainMenuNames, " -> "), priority);
void addMenuItemSubMenu(std::vector<UnlocalizedString> unlocalizedMainMenuNames, u32 priority, const impl::MenuCallback &function, const impl::EnabledCallback& enabledCallback) {
log::debug("Added new menu item sub menu to menu {} with priority {}", unlocalizedMainMenuNames[0].get(), priority);
unlocalizedMainMenuNames.emplace_back(impl::SubMenuValue);
impl::getMenuItems().insert({
@ -742,7 +742,7 @@ namespace hex {
});
}
void addMenuItemSeparator(std::vector<std::string> unlocalizedMainMenuNames, u32 priority) {
void addMenuItemSeparator(std::vector<UnlocalizedString> unlocalizedMainMenuNames, u32 priority) {
unlocalizedMainMenuNames.emplace_back(impl::SeparatorValue);
impl::getMenuItems().insert({
priority, impl::MenuItem { unlocalizedMainMenuNames, std::make_unique<Shortcut>(), nullptr, []{}, []{ return true; } }
@ -765,7 +765,7 @@ namespace hex {
impl::getSidebarItems().push_back({ icon, function, enabledCallback });
}
void addTitleBarButton(const std::string &icon, const std::string &unlocalizedTooltip, const impl::ClickCallback &function) {
void addTitleBarButton(const std::string &icon, const UnlocalizedString &unlocalizedTooltip, const impl::ClickCallback &function) {
impl::getTitleBarButtons().push_back({ icon, unlocalizedTooltip, function });
}
@ -835,8 +835,8 @@ namespace hex {
return providerNames;
}
void addProviderName(const std::string &unlocalizedName) {
log::debug("Registered new provider: {}", unlocalizedName);
void addProviderName(const UnlocalizedString &unlocalizedName) {
log::debug("Registered new provider: {}", unlocalizedName.get());
getEntries().push_back(unlocalizedName);
}
@ -848,8 +848,8 @@ namespace hex {
namespace ContentRegistry::DataFormatter {
void add(const std::string &unlocalizedName, const impl::Callback &callback) {
log::debug("Registered new data formatter: {}", unlocalizedName);
void add(const UnlocalizedString &unlocalizedName, const impl::Callback &callback) {
log::debug("Registered new data formatter: {}", unlocalizedName.get());
impl::getEntries().push_back({ unlocalizedName, callback });
}
@ -966,7 +966,7 @@ namespace hex {
}
std::shared_ptr<DataVisualizer> getVisualizerByName(const std::string &unlocalizedName) {
std::shared_ptr<DataVisualizer> getVisualizerByName(const UnlocalizedString &unlocalizedName) {
for (const auto &visualizer : impl::getVisualizers()) {
if (visualizer->getUnlocalizedName() == unlocalizedName)
return visualizer;
@ -1019,8 +1019,8 @@ namespace hex {
}
void registerService(const std::string &unlocalizedName, const impl::Callback &callback) {
log::debug("Registered new background service: {}", unlocalizedName);
void registerService(const UnlocalizedString &unlocalizedName, const impl::Callback &callback) {
log::debug("Registered new background service: {}", unlocalizedName.get());
impl::getServices().push_back(impl::Service {
unlocalizedName,
@ -1067,7 +1067,7 @@ namespace hex {
}
void addExperiment(const std::string &experimentName, const std::string &unlocalizedName, const std::string &unlocalizedDescription) {
void addExperiment(const std::string &experimentName, const UnlocalizedString &unlocalizedName, const UnlocalizedString &unlocalizedDescription) {
auto &experiments = impl::getExperiments();
if (experiments.contains(experimentName)) {

2
lib/libimhex/source/api/imhex_api.cpp
View File

@ -365,7 +365,7 @@ namespace hex {
});
}
prv::Provider* createProvider(const std::string &unlocalizedName, bool skipLoadInterface, bool select) {
prv::Provider* createProvider(const UnlocalizedString &unlocalizedName, bool skipLoadInterface, bool select) {
prv::Provider* result = nullptr;
RequestCreateProvider::post(unlocalizedName, skipLoadInterface, select, &result);

3
lib/libimhex/source/api/localization_manager.cpp
View File

@ -75,7 +75,8 @@ namespace hex {
}
Lang::Lang(const char *unlocalizedString) : m_unlocalizedString(unlocalizedString) { }
Lang::Lang(std::string unlocalizedString) : m_unlocalizedString(std::move(unlocalizedString)) { }
Lang::Lang(const std::string &unlocalizedString) : m_unlocalizedString(unlocalizedString) { }
Lang::Lang(const UnlocalizedString &unlocalizedString) : m_unlocalizedString(unlocalizedString.get()) { }
Lang::Lang(std::string_view unlocalizedString) : m_unlocalizedString(unlocalizedString) { }
Lang::operator std::string() const {

4
lib/libimhex/source/api/shortcut_manager.cpp
View File

@ -15,11 +15,11 @@ namespace hex {
}
void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const std::string &unlocalizedName, const std::function<void()> &callback) {
void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback) {
s_globalShortcuts.insert({ shortcut, { shortcut, unlocalizedName, callback } });
}
void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const std::string &unlocalizedName, const std::function<void()> &callback) {
void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback) {
view->m_shortcuts.insert({ shortcut + CurrentView, { shortcut, unlocalizedName, callback } });
}

10
lib/libimhex/source/api/task_manager.cpp
View File

@ -55,7 +55,7 @@ namespace hex {
#endif
}
Task::Task(std::string unlocalizedName, u64 maxValue, bool background, std::function<void(Task &)> function)
Task::Task(UnlocalizedString unlocalizedName, u64 maxValue, bool background, std::function<void(Task &)> function)
: m_unlocalizedName(std::move(unlocalizedName)), m_maxValue(maxValue), m_function(std::move(function)), m_background(background) { }
Task::Task(hex::Task &&other) noexcept {
@ -138,7 +138,7 @@ namespace hex {
return this->m_exceptionMessage;
}
const std::string &Task::getUnlocalizedName() {
const UnlocalizedString &Task::getUnlocalizedName() {
return this->m_unlocalizedName;
}
@ -281,17 +281,17 @@ namespace hex {
// Execute the task
task->m_function(*task);
log::debug("Task '{}' finished", task->m_unlocalizedName);
log::debug("Task '{}' finished", task->m_unlocalizedName.get());
} catch (const Task::TaskInterruptor &) {
// Handle the task being interrupted by user request
task->interruption();
} catch (const std::exception &e) {
log::error("Exception in task '{}': {}", task->m_unlocalizedName, e.what());
log::error("Exception in task '{}': {}", task->m_unlocalizedName.get(), e.what());
// Handle the task throwing an uncaught exception
task->exception(e.what());
} catch (...) {
log::error("Exception in task '{}'", task->m_unlocalizedName);
log::error("Exception in task '{}'", task->m_unlocalizedName.get());
// Handle the task throwing an uncaught exception of unknown type
task->exception("Unknown Exception");

12
lib/libimhex/source/api/tutorial_manager.cpp
View File

@ -66,11 +66,11 @@ namespace hex {
}
TutorialManager::Tutorial& TutorialManager::createTutorial(const std::string& unlocalizedName, const std::string& unlocalizedDescription) {
TutorialManager::Tutorial& TutorialManager::createTutorial(const UnlocalizedString &unlocalizedName, const UnlocalizedString &unlocalizedDescription) {
return s_tutorials.try_emplace(unlocalizedName, Tutorial(unlocalizedName, unlocalizedDescription)).first->second;
}
void TutorialManager::startTutorial(const std::string& unlocalizedName) {
void TutorialManager::startTutorial(const UnlocalizedString &unlocalizedName) {
s_currentTutorial = s_tutorials.find(unlocalizedName);
if (s_currentTutorial == s_tutorials.end())
return;
@ -251,7 +251,7 @@ namespace hex {
}, id);
}
s_highlights.emplace(idStack.get(), text.c_str());
s_highlights.emplace(idStack.get(), text);
}
}
@ -288,7 +288,7 @@ namespace hex {
}
TutorialManager::Tutorial::Step& TutorialManager::Tutorial::Step::addHighlight(const std::string& unlocalizedText, std::initializer_list<std::variant<Lang, std::string, int>>&& ids) {
TutorialManager::Tutorial::Step& TutorialManager::Tutorial::Step::addHighlight(const UnlocalizedString &unlocalizedText, std::initializer_list<std::variant<Lang, std::string, int>>&& ids) {
this->m_highlights.emplace_back(
unlocalizedText,
ids
@ -298,12 +298,12 @@ namespace hex {
}
TutorialManager::Tutorial::Step& TutorialManager::Tutorial::Step::addHighlight(std::initializer_list<std::variant<Lang, std::string, int>>&& ids) {
return this->addHighlight("", std::move(ids));
return this->addHighlight("", std::forward<decltype(ids)>(ids));
}
TutorialManager::Tutorial::Step& TutorialManager::Tutorial::Step::setMessage(const std::string& unlocalizedTitle, const std::string& unlocalizedMessage, Position position) {
TutorialManager::Tutorial::Step& TutorialManager::Tutorial::Step::setMessage(const UnlocalizedString &unlocalizedTitle, const UnlocalizedString &unlocalizedMessage, Position position) {
this->m_message = Message {
position,
unlocalizedTitle,

2
lib/libimhex/source/data_processor/attribute.cpp
View File

@ -6,7 +6,7 @@ namespace hex::dp {
int Attribute::s_idCounter = 1;
Attribute::Attribute(IOType ioType, Type type, std::string unlocalizedName) : m_id(s_idCounter++), m_ioType(ioType), m_type(type), m_unlocalizedName(std::move(unlocalizedName)) {
Attribute::Attribute(IOType ioType, Type type, UnlocalizedString unlocalizedName) : m_id(s_idCounter++), m_ioType(ioType), m_type(type), m_unlocalizedName(std::move(unlocalizedName)) {
}
Attribute::~Attribute() {

2
lib/libimhex/source/data_processor/node.cpp
View File

@ -9,7 +9,7 @@ namespace hex::dp {
int Node::s_idCounter = 1;
Node::Node(std::string unlocalizedTitle, std::vector<Attribute> attributes) : m_id(s_idCounter++), m_unlocalizedTitle(std::move(unlocalizedTitle)), m_attributes(std::move(attributes)) {
Node::Node(UnlocalizedString unlocalizedTitle, std::vector<Attribute> attributes) : m_id(s_idCounter++), m_unlocalizedTitle(std::move(unlocalizedTitle)), m_attributes(std::move(attributes)) {
for (auto &attr : this->m_attributes)
attr.setParentNode(this);
}

5
lib/libimhex/source/providers/undo/stack.cpp
View File

@ -5,12 +5,13 @@
#include <wolv/utils/guards.hpp>
#include <atomic>
namespace hex::prv::undo {
namespace {
std::atomic_bool s_locked;
std::atomic<bool> s_locked;
std::mutex s_mutex;
}
@ -66,7 +67,7 @@ namespace hex::prv::undo {
}
}
void Stack::groupOperations(u32 count, const std::string &unlocalizedName) {
void Stack::groupOperations(u32 count, const UnlocalizedString &unlocalizedName) {
if (count <= 1)
return;

8
lib/libimhex/source/ui/view.cpp
View File

@ -7,7 +7,7 @@
namespace hex {
View::View(std::string unlocalizedName) : m_unlocalizedViewName(std::move(unlocalizedName)) { }
View::View(UnlocalizedString unlocalizedName) : m_unlocalizedViewName(std::move(unlocalizedName)) { }
bool View::shouldDraw() const {
return ImHexApi::Provider::isValid() && ImHexApi::Provider::get()->isAvailable();
@ -43,7 +43,7 @@ namespace hex {
return this->m_windowOpen;
}
const std::string &View::getUnlocalizedName() const {
const UnlocalizedString &View::getUnlocalizedName() const {
return this->m_unlocalizedViewName;
}
@ -71,8 +71,8 @@ namespace hex {
ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NavEnableKeyboard;
}
std::string View::toWindowName(const std::string &unlocalizedName) {
return Lang(unlocalizedName) + "###" + unlocalizedName;
std::string View::toWindowName(const UnlocalizedString &unlocalizedName) {
return Lang(unlocalizedName) + "###" + unlocalizedName.get();
}
}

12
main/gui/source/window/window.cpp
View File

@ -231,21 +231,21 @@ namespace hex {
}
}
static void createNestedMenu(std::span<const std::string> menuItems, const Shortcut &shortcut, const std::function<void()> &callback, const std::function<bool()> &enabledCallback) {
static void createNestedMenu(std::span<const UnlocalizedString> menuItems, const Shortcut &shortcut, const std::function<void()> &callback, const std::function<bool()> &enabledCallback) {
const auto &name = menuItems.front();
if (name == ContentRegistry::Interface::impl::SeparatorValue) {
if (name.get() == ContentRegistry::Interface::impl::SeparatorValue) {
ImGui::Separator();
return;
}
if (name == ContentRegistry::Interface::impl::SubMenuValue) {
if (name.get() == ContentRegistry::Interface::impl::SubMenuValue) {
callback();
} else if (menuItems.size() == 1) {
if (ImGui::MenuItem(Lang(name), shortcut.toString().c_str(), false, enabledCallback()))
callback();
} else {
bool isSubmenu = *(menuItems.begin() + 1) == ContentRegistry::Interface::impl::SubMenuValue;
bool isSubmenu = (menuItems.begin() + 1)->get() == ContentRegistry::Interface::impl::SubMenuValue;
if (ImGui::BeginMenu(Lang(name), isSubmenu ? enabledCallback() : true)) {
createNestedMenu({ menuItems.begin() + 1, menuItems.end() }, shortcut, callback, enabledCallback);
@ -760,7 +760,7 @@ namespace hex {
for (auto &[priority, menuItem] : ContentRegistry::Interface::impl::getMenuItems()) {
const auto &[unlocalizedNames, shortcut, view, callback, enabledCallback] = menuItem;
if (ImGui::BeginPopup(unlocalizedNames.front().c_str())) {
if (ImGui::BeginPopup(unlocalizedNames.front().get().c_str())) {
createNestedMenu({ unlocalizedNames.begin() + 1, unlocalizedNames.end() }, *shortcut, callback, enabledCallback);
ImGui::EndPopup();
}
@ -1178,7 +1178,7 @@ namespace hex {
Window* window = static_cast<Window*>(handler->UserData);
for (auto &[name, view] : ContentRegistry::Views::impl::getEntries()) {
std::string format = view->getUnlocalizedName() + "=%d";
std::string format = view->getUnlocalizedName().get() + "=%d";
sscanf(line, format.c_str(), &view->getWindowOpenState());
}
for (auto &[name, function, detached] : ContentRegistry::Tools::impl::getEntries()) {

2
plugins/builtin/include/content/popups/popup_notification.hpp
View File

@ -15,7 +15,7 @@ namespace hex::plugin::builtin {
template<typename T>
class PopupNotification : public Popup<T> {
public:
PopupNotification(std::string unlocalizedName, std::string message, std::function<void()> function)
PopupNotification(UnlocalizedString unlocalizedName, std::string message, std::function<void()> function)
: hex::Popup<T>(std::move(unlocalizedName), false),
m_message(std::move(message)), m_function(std::move(function)) { }

6
plugins/builtin/include/content/popups/popup_text_input.hpp
View File

@ -14,12 +14,12 @@ namespace hex::plugin::builtin {
class PopupTextInput : public Popup<PopupTextInput> {
public:
PopupTextInput(std::string unlocalizedName, std::string message, std::function<void(std::string)> function)
PopupTextInput(UnlocalizedString unlocalizedName, UnlocalizedString message, std::function<void(std::string)> function)
: hex::Popup<PopupTextInput>(std::move(unlocalizedName), false),
m_message(std::move(message)), m_function(std::move(function)) { }
void drawContent() override {
ImGuiExt::TextFormattedWrapped("{}", this->m_message.c_str());
ImGuiExt::TextFormattedWrapped("{}", Lang(this->m_message));
ImGui::NewLine();
ImGui::PushItemWidth(-1);
@ -65,7 +65,7 @@ namespace hex::plugin::builtin {
private:
std::string m_input;
std::string m_message;
UnlocalizedString m_message;
std::function<void(std::string)> m_function;
bool m_justOpened = true;
};

2
plugins/builtin/include/content/views/view_data_inspector.hpp
View File

@ -20,7 +20,7 @@ namespace hex::plugin::builtin {
private:
struct InspectorCacheEntry {
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
ContentRegistry::DataInspector::impl::DisplayFunction displayFunction;
std::optional<ContentRegistry::DataInspector::impl::EditingFunction> editingFunction;
bool editing;

4
plugins/builtin/include/content/views/view_store.hpp
View File

@ -38,7 +38,7 @@ namespace hex::plugin::builtin {
};
struct StoreCategory {
std::string unlocalizedName;
UnlocalizedString unlocalizedName;
std::string requestName;
fs::ImHexPath path;
std::vector<StoreEntry> entries;
@ -76,7 +76,7 @@ namespace hex::plugin::builtin {
void refresh();
void parseResponse();
void addCategory(const std::string &unlocalizedName, const std::string &requestName, fs::ImHexPath path, std::function<void()> downloadCallback = []{});
void addCategory(const UnlocalizedString &unlocalizedName, const std::string &requestName, fs::ImHexPath path, std::function<void()> downloadCallback = []{});
bool download(fs::ImHexPath pathType, const std::string &fileName, const std::string &url, bool update);
bool remove(fs::ImHexPath pathType, const std::string &fileName);

12
plugins/builtin/source/content/achievements.cpp
View File

@ -16,32 +16,32 @@ namespace hex::plugin::builtin {
class AchievementStartingOut : public Achievement {
public:
explicit AchievementStartingOut(std::string unlocalizedName) : Achievement("hex.builtin.achievement.starting_out", std::move(unlocalizedName)) { }
explicit AchievementStartingOut(UnlocalizedString unlocalizedName) : Achievement("hex.builtin.achievement.starting_out", std::move(unlocalizedName)) { }
};
class AchievementHexEditor : public Achievement {
public:
explicit AchievementHexEditor(std::string unlocalizedName) : Achievement("hex.builtin.achievement.hex_editor", std::move(unlocalizedName)) { }
explicit AchievementHexEditor(UnlocalizedString unlocalizedName) : Achievement("hex.builtin.achievement.hex_editor", std::move(unlocalizedName)) { }
};
class AchievementPatterns : public Achievement {
public:
explicit AchievementPatterns(std::string unlocalizedName) : Achievement("hex.builtin.achievement.patterns", std::move(unlocalizedName)) { }
explicit AchievementPatterns(UnlocalizedString unlocalizedName) : Achievement("hex.builtin.achievement.patterns", std::move(unlocalizedName)) { }
};
class AchievementDataProcessor : public Achievement {
public:
explicit AchievementDataProcessor(std::string unlocalizedName) : Achievement("hex.builtin.achievement.data_processor", std::move(unlocalizedName)) { }
explicit AchievementDataProcessor(UnlocalizedString unlocalizedName) : Achievement("hex.builtin.achievement.data_processor", std::move(unlocalizedName)) { }
};
class AchievementFind : public Achievement {
public:
explicit AchievementFind(std::string unlocalizedName) : Achievement("hex.builtin.achievement.find", std::move(unlocalizedName)) { }
explicit AchievementFind(UnlocalizedString unlocalizedName) : Achievement("hex.builtin.achievement.find", std::move(unlocalizedName)) { }
};
class AchievementMisc : public Achievement {
public:
explicit AchievementMisc(std::string unlocalizedName) : Achievement("hex.builtin.achievement.misc", std::move(unlocalizedName)) { }
explicit AchievementMisc(UnlocalizedString unlocalizedName) : Achievement("hex.builtin.achievement.misc", std::move(unlocalizedName)) { }
};
void registerGettingStartedAchievements() {

4
plugins/builtin/source/content/background_services.cpp
View File

@ -91,8 +91,8 @@ namespace hex::plugin::builtin {
autoBackupTime = ContentRegistry::Settings::read("hex.builtin.setting.general", "hex.builtin.setting.general.auto_backup_time", 0).get<int>() * 30;
});
ContentRegistry::BackgroundServices::registerService("hex.builtin.background_service.network_interface"_lang, handleNetworkInterfaceService);
ContentRegistry::BackgroundServices::registerService("hex.builtin.background_service.auto_backup"_lang, handleAutoBackup);
ContentRegistry::BackgroundServices::registerService("hex.builtin.background_service.network_interface", handleNetworkInterfaceService);
ContentRegistry::BackgroundServices::registerService("hex.builtin.background_service.auto_backup", handleAutoBackup);
}
}

6
plugins/builtin/source/content/main_menu_items.cpp
View File

@ -542,14 +542,14 @@ namespace hex::plugin::builtin {
ContentRegistry::Interface::registerMainMenuItem("hex.builtin.menu.workspace", 4000);
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.workspace", "hex.builtin.menu.workspace.layout", "hex.builtin.menu.workspace.layout.save" }, 1100, Shortcut::None, [] {
PopupTextInput::open("hex.builtin.popup.save_layout.title"_lang, "hex.builtin.popup.save_layout.desc"_lang, [](const std::string &name) {
PopupTextInput::open("hex.builtin.popup.save_layout.title", "hex.builtin.popup.save_layout.desc", [](const std::string &name) {
LayoutManager::save(name);
});
}, ImHexApi::Provider::isValid);
ContentRegistry::Interface::addMenuItemSubMenu({ "hex.builtin.menu.workspace", "hex.builtin.menu.workspace.layout" }, 1150, [] {
bool locked = LayoutManager::isLayoutLocked();
if (ImGui::MenuItem("hex.builtin.menu.workspace.layout.lock"_lang, nullptr, &locked, ImHexApi::Provider::isValid())) {
if (ImGui::MenuItem("hex.builtin.menu.workspace.layout.lock", nullptr, &locked, ImHexApi::Provider::isValid())) {
LayoutManager::lockLayout(locked);
ContentRegistry::Settings::write("hex.builtin.setting.interface", "hex.builtin.setting.interface.layout_locked", locked);
}
@ -584,7 +584,7 @@ namespace hex::plugin::builtin {
ContentRegistry::Interface::addMenuItemSeparator({ "hex.builtin.menu.workspace" }, 3000);
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.workspace", "hex.builtin.menu.workspace.create" }, 3100, Shortcut::None, [] {
PopupTextInput::open("hex.builtin.popup.create_workspace.title"_lang, "hex.builtin.popup.create_workspace.desc"_lang, [](const std::string &name) {
PopupTextInput::open("hex.builtin.popup.create_workspace.title", "hex.builtin.popup.create_workspace.desc", [](const std::string &name) {
WorkspaceManager::createWorkspace(name);
});
}, ImHexApi::Provider::isValid);

2
plugins/builtin/source/content/providers/memory_file_provider.cpp
View File

@ -146,7 +146,7 @@ namespace hex::plugin::builtin {
}
void MemoryFileProvider::renameFile() {
PopupTextInput::open("hex.builtin.provider.mem_file.rename"_lang, "hex.builtin.provider.mem_file.rename.desc"_lang, [this](const std::string &name) {
PopupTextInput::open("hex.builtin.provider.mem_file.rename", "hex.builtin.provider.mem_file.rename.desc", [this](const std::string &name) {
this->m_name = name;
RequestUpdateWindowTitle::post();
});

2
plugins/builtin/source/content/recent.cpp
View File

@ -37,7 +37,7 @@ namespace hex::plugin::builtin::recent {
std::fs::path path;
};
public:
PopupAutoBackups() : Popup("hex.builtin.welcome.start.recent.auto_backups"_lang, true, true) {
PopupAutoBackups() : Popup("hex.builtin.welcome.start.recent.auto_backups", true, true) {
for (const auto &backupPath : fs::getDefaultPaths(fs::ImHexPath::Backups)) {
for (const auto &entry : std::fs::directory_iterator(backupPath)) {
if (entry.is_regular_file() && entry.path().extension() == ".hexproj") {

2
plugins/builtin/source/content/tutorials/introduction.cpp
View File

@ -92,7 +92,7 @@ namespace hex::plugin::builtin {
})
.onAppear([&step] {
EventViewOpened::subscribe([&step](View *view){
if (view->getUnlocalizedName() == "hex.builtin.view.tutorials.name")
if (view->getUnlocalizedName() == UnlocalizedString("hex.builtin.view.tutorials.name"))
step.complete();
});
})

4
plugins/builtin/source/content/views/view_data_processor.cpp
View File

@ -579,7 +579,7 @@ namespace hex::plugin::builtin {
nlohmann::json nodeJson = nlohmann::json::parse(file.readString());
// Add the loaded node to the list of custom nodes
this->m_customNodes.push_back(CustomNode { Lang(nodeJson.at("name")), nodeJson });
this->m_customNodes.push_back(CustomNode { Lang(nodeJson.at("name").get<std::string>()), nodeJson });
} catch (nlohmann::json::exception &e) {
log::warn("Failed to load custom node '{}': {}", entry.path().string(), e.what());
}
@ -1077,7 +1077,7 @@ namespace hex::plugin::builtin {
std::unique_ptr<dp::Node> newNode;
for (auto &entry : nodeEntries) {
if (data.contains("name") && entry.name == data["type"].get<std::string>())
if (data.contains("name") && entry.unlocalizedName == data["type"].get<std::string>())
newNode = entry.creatorFunction();
}

2
plugins/builtin/source/content/views/view_hashes.cpp
View File

@ -19,7 +19,7 @@ namespace hex::plugin::builtin {
m_hash(hash) { }
void drawContent() override {
ImGuiExt::Header(this->getUnlocalizedName().c_str(), true);
ImGuiExt::Header(this->getUnlocalizedName(), true);
ImGui::PushItemWidth(-1);
if (ImGui::InputTextMultiline("##input", this->m_input)) {

4
plugins/builtin/source/content/views/view_hex_editor.cpp
View File

@ -1044,7 +1044,7 @@ namespace hex::plugin::builtin {
ContentRegistry::Interface::addMenuItemSeparator({ "hex.builtin.menu.file" }, 1300);
/* Save */
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.file", "hex.builtin.view.hex_editor.menu.file.save"_lang }, 1350,
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.file", "hex.builtin.view.hex_editor.menu.file.save" }, 1350,
CTRLCMD + Keys::S,
save,
[] {
@ -1055,7 +1055,7 @@ namespace hex::plugin::builtin {
});
/* Save As */
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.file", "hex.builtin.view.hex_editor.menu.file.save_as"_lang }, 1375,
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.file", "hex.builtin.view.hex_editor.menu.file.save_as" }, 1375,
CTRLCMD + SHIFT + Keys::S,
saveAs,
[] {

4
plugins/builtin/source/content/views/view_settings.cpp
View File

@ -21,7 +21,7 @@ namespace hex::plugin::builtin {
// Add the settings menu item to the Extras menu
ContentRegistry::Interface::addMenuItemSeparator({ "hex.builtin.menu.extras" }, 3000);
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.extras", "hex.builtin.view.settings.name"_lang }, 4000, Shortcut::None, [&, this] {
ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.extras", "hex.builtin.view.settings.name" }, 4000, Shortcut::None, [&, this] {
this->getWindowOpenState() = true;
});
}
@ -80,7 +80,7 @@ namespace hex::plugin::builtin {
ContentRegistry::Settings::write(category.unlocalizedName, setting.unlocalizedName, newValue);
// Print a debug message
log::debug("Setting [{} / {}]: Value was changed to {}", category.unlocalizedName, setting.unlocalizedName, nlohmann::to_string(newValue));
log::debug("Setting [{} / {}]: Value was changed to {}", category.unlocalizedName.get(), setting.unlocalizedName.get(), nlohmann::to_string(newValue));
// Signal that the setting was changed
EventSettingsChanged::post();

18
plugins/builtin/source/content/views/view_store.cpp
View File

@ -37,20 +37,20 @@ namespace hex::plugin::builtin {
this->m_httpRequest.setTimeout(30'0000);
addCategory("hex.builtin.view.store.tab.patterns"_lang, "patterns", fs::ImHexPath::Patterns);
addCategory("hex.builtin.view.store.tab.includes"_lang, "includes", fs::ImHexPath::PatternsInclude);
addCategory("hex.builtin.view.store.tab.magic"_lang, "magic", fs::ImHexPath::Magic, []{
addCategory("hex.builtin.view.store.tab.patterns", "patterns", fs::ImHexPath::Patterns);
addCategory("hex.builtin.view.store.tab.includes", "includes", fs::ImHexPath::PatternsInclude);
addCategory("hex.builtin.view.store.tab.magic", "magic", fs::ImHexPath::Magic, []{
magic::compile();
});
addCategory("hex.builtin.view.store.tab.nodes"_lang, "nodes", fs::ImHexPath::Nodes);
addCategory("hex.builtin.view.store.tab.encodings"_lang, "encodings", fs::ImHexPath::Encodings);
addCategory("hex.builtin.view.store.tab.constants"_lang, "constants", fs::ImHexPath::Constants);
addCategory("hex.builtin.view.store.tab.themes"_lang, "themes", fs::ImHexPath::Themes, [this]{
addCategory("hex.builtin.view.store.tab.nodes", "nodes", fs::ImHexPath::Nodes);
addCategory("hex.builtin.view.store.tab.encodings", "encodings", fs::ImHexPath::Encodings);
addCategory("hex.builtin.view.store.tab.constants", "constants", fs::ImHexPath::Constants);
addCategory("hex.builtin.view.store.tab.themes", "themes", fs::ImHexPath::Themes, [this]{
auto themeFile = wolv::io::File(this->m_downloadPath, wolv::io::File::Mode::Read);
ThemeManager::addTheme(themeFile.readString());
});
addCategory("hex.builtin.view.store.tab.yara"_lang, "yara", fs::ImHexPath::Yara);
addCategory("hex.builtin.view.store.tab.yara", "yara", fs::ImHexPath::Yara);
}
@ -333,7 +333,7 @@ namespace hex::plugin::builtin {
return removed;
}
void ViewStore::addCategory(const std::string &unlocalizedName, const std::string &requestName, fs::ImHexPath path, std::function<void()> downloadCallback) {
void ViewStore::addCategory(const UnlocalizedString &unlocalizedName, const std::string &requestName, fs::ImHexPath path, std::function<void()> downloadCallback) {
this->m_categories.push_back({ unlocalizedName, requestName, path, { }, std::move(downloadCallback) });
}