Cool_Tools/ImHex
1
0
Fork 0
mirror of synced 2024-11-28 09:30:51 +01:00
Code Releases Wiki Activity

build: Remove all static variables from headers to hopefully fix plugins

Browse Source
This commit is contained in:
WerWolv 2023-07-26 13:50:51 +02:00
parent 866c87b2bf
commit 27c8e19c14
31 changed files with 236 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
lib/libimhex/include/hex/api/event.hpp
View File

@ -82,7 +82,8 @@ namespace hex {
*/ */
template<typename E> template<typename E>
static EventList::iterator subscribe(typename E::Callback function) { static EventList::iterator subscribe(typename E::Callback function) {
return s_events.insert(s_events.end(), std::make_pair(E::Id, std::make_unique<E>(function))); auto &events = getEvents();
return events.insert(events.end(), std::make_pair(E::Id, std::make_unique<E>(function)));
} }
/** /**
@ -93,7 +94,7 @@ namespace hex {
*/ */
template<typename E> template<typename E>
static void subscribe(void *token, typename E::Callback function) { static void subscribe(void *token, typename E::Callback function) {
s_tokenStore.insert(std::make_pair(token, subscribe<E>(function))); getTokenStore().insert(std::make_pair(token, subscribe<E>(function)));
} }
/** /**
@ -101,7 +102,7 @@ namespace hex {
* @param token Token returned by subscribe * @param token Token returned by subscribe
*/ */
static void unsubscribe(const EventList::iterator &token) noexcept { static void unsubscribe(const EventList::iterator &token) noexcept {
s_events.erase(token); getEvents().erase(token);
} }
/** /**
@ -111,13 +112,14 @@ namespace hex {
*/ */
template<typename E> template<typename E>
static void unsubscribe(void *token) noexcept { static void unsubscribe(void *token) noexcept {
auto iter = std::find_if(s_tokenStore.begin(), s_tokenStore.end(), [&](auto &item) { auto &tokenStore = getTokenStore();
auto iter = std::find_if(tokenStore.begin(), tokenStore.end(), [&](auto &item) {
return item.first == token && item.second->first == E::Id; return item.first == token && item.second->first == E::Id;
}); });
if (iter != s_tokenStore.end()) { if (iter != tokenStore.end()) {
s_events.remove(*iter->second); getEvents().remove(*iter->second);
s_tokenStore.erase(iter); tokenStore.erase(iter);
} }
} }
@ -129,7 +131,7 @@ namespace hex {
*/ */
template<typename E> template<typename E>
static void post(auto &&...args) noexcept { static void post(auto &&...args) noexcept {
for (const auto &[id, event] : s_events) { for (const auto &[id, event] : getEvents()) {
if (id == E::Id) { if (id == E::Id) {
(*static_cast<E *const>(event.get()))(std::forward<decltype(args)>(args)...); (*static_cast<E *const>(event.get()))(std::forward<decltype(args)>(args)...);
} }
@ -145,13 +147,13 @@ namespace hex {
* @brief Unsubscribe all subscribers from all events * @brief Unsubscribe all subscribers from all events
*/ */
static void clear() noexcept { static void clear() noexcept {
s_events.clear(); getEvents().clear();
s_tokenStore.clear(); getTokenStore().clear();
} }
private: private:
static std::map<void *, EventList::iterator> s_tokenStore; static std::map<void *, EventList::iterator>& getTokenStore();
static EventList s_events; static EventList& getEvents();
}; };
/* Default Events */ /* Default Events */

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

@ -413,9 +413,6 @@ namespace hex {
* @brief Clear all shortcuts * @brief Clear all shortcuts
*/ */
static void clearShortcuts(); static void clearShortcuts();
private:
static std::map<Shortcut, std::function<void()>> s_globalShortcuts;
}; };
} }

4
lib/libimhex/include/hex/api/layout_manager.hpp
View File

@ -30,10 +30,6 @@ namespace hex {
private: private:
LayoutManager() = default; LayoutManager() = default;
static std::optional<std::fs::path> s_layoutPathToLoad;
static std::optional<std::string> s_layoutStringToLoad;
static std::vector<Layout> s_layouts;
}; };
} }

4
lib/libimhex/include/hex/api/localization.hpp
View File

@ -43,10 +43,6 @@ namespace hex {
private: private:
std::string m_unlocalizedString; std::string m_unlocalizedString;
static std::string s_fallbackLanguage;
static std::string s_selectedLanguage;
static std::map<std::string, std::string> s_currStrings;
}; };
std::string operator+(const std::string &&left, const LangEntry &&right); std::string operator+(const std::string &&left, const LangEntry &&right);

8
lib/libimhex/include/hex/api/plugin_manager.hpp
View File

@ -90,13 +90,7 @@ namespace hex {
static void unload(); static void unload();
static void reload(); static void reload();
static const auto &getPlugins() { static const std::vector<Plugin> &getPlugins();
return PluginManager::s_plugins;
}
private:
static std::fs::path s_pluginFolder;
static std::vector<Plugin> s_plugins;
}; };
} }

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

@ -116,27 +116,16 @@ namespace hex {
* @brief Get the list of registered handlers * @brief Get the list of registered handlers
* @return List of registered handlers * @return List of registered handlers
*/ */
static std::vector<Handler>& getHandlers() { static std::vector<Handler>& getHandlers();
return s_handlers;
}
/** /**
* @brief Get the list of registered per-provider handlers * @brief Get the list of registered per-provider handlers
* @return List of registered per-provider handlers * @return List of registered per-provider handlers
*/ */
static std::vector<ProviderHandler>& getProviderHandlers() { static std::vector<ProviderHandler>& getProviderHandlers();
return s_providerHandlers;
}
private: private:
ProjectFile() = default; ProjectFile() = default;
static std::function<bool(const std::fs::path&)> s_loadProjectFunction;
static std::function<bool(std::optional<std::fs::path>, bool)> s_storeProjectFunction;
static std::fs::path s_currProjectPath;
static std::vector<Handler> s_handlers;
static std::vector<ProviderHandler> s_providerHandlers;
}; };
} }

11
lib/libimhex/include/hex/api/task.hpp
View File

@ -167,17 +167,6 @@ namespace hex {
static void runDeferredCalls(); static void runDeferredCalls();
private: private:
static std::mutex s_deferredCallsMutex, s_tasksFinishedMutex;
static std::list<std::shared_ptr<Task>> s_tasks;
static std::list<std::shared_ptr<Task>> s_taskQueue;
static std::list<std::function<void()>> s_deferredCalls;
static std::list<std::function<void()>> s_tasksFinishedCallbacks;
static std::mutex s_queueMutex;
static std::condition_variable s_jobCondVar;
static std::vector<std::jthread> s_workers;
static void runner(const std::stop_token &stopToken); static void runner(const std::stop_token &stopToken);
}; };

11
lib/libimhex/include/hex/api/theme_manager.hpp
View File

@ -78,18 +78,11 @@ namespace hex {
StyleMap styleMap; StyleMap styleMap;
}; };
static std::map<std::string, ThemeHandler>& getThemeHandlers() { return s_themeHandlers; } static std::map<std::string, ThemeHandler>& getThemeHandlers();
static std::map<std::string, StyleHandler>& getStyleHandlers() { return s_styleHandlers; } static std::map<std::string, StyleHandler>& getStyleHandlers();
private: private:
ThemeManager() = default; ThemeManager() = default;
static std::map<std::string, nlohmann::json> s_themes;
static std::map<std::string, ThemeHandler> s_themeHandlers;
static std::map<std::string, StyleHandler> s_styleHandlers;
static std::string s_imageTheme;
static std::string s_currTheme;
}; };
} }

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

@ -51,10 +51,7 @@ namespace hex::dp {
[[nodiscard]] std::vector<u8>& getDefaultData() { return this->m_defaultData; } [[nodiscard]] std::vector<u8>& getDefaultData() { return this->m_defaultData; }
static void setIdCounter(int id) { static void setIdCounter(int id);
if (id > Attribute::s_idCounter)
Attribute::s_idCounter = id;
}
private: private:
int m_id; int m_id;
@ -69,8 +66,6 @@ namespace hex::dp {
friend class Node; friend class Node;
void setParentNode(Node *node) { this->m_parentNode = node; } void setParentNode(Node *node) { this->m_parentNode = node; }
static int s_idCounter;
}; };
} }

7
lib/libimhex/include/hex/data_processor/link.hpp
View File

@ -14,16 +14,11 @@ namespace hex::dp {
[[nodiscard]] int getFromId() const { return this->m_from; } [[nodiscard]] int getFromId() const { return this->m_from; }
[[nodiscard]] int getToId() const { return this->m_to; } [[nodiscard]] int getToId() const { return this->m_to; }
static void setIdCounter(int id) { static void setIdCounter(int id);
if (id > Link::s_idCounter)
Link::s_idCounter = id;
}
private: private:
int m_id; int m_id;
int m_from, m_to; int m_from, m_to;
static int s_idCounter;
}; };
} }

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

@ -69,10 +69,7 @@ namespace hex::dp {
return this->m_position; return this->m_position;
} }
static void setIdCounter(int id) { static void setIdCounter(int id);
if (id > Node::s_idCounter)
Node::s_idCounter = id;
}
const std::vector<u8>& getBufferOnInput(u32 index); const std::vector<u8>& getBufferOnInput(u32 index);
const i128& getIntegerOnInput(u32 index); const i128& getIntegerOnInput(u32 index);
@ -90,8 +87,6 @@ namespace hex::dp {
prv::Overlay *m_overlay = nullptr; prv::Overlay *m_overlay = nullptr;
ImVec2 m_position; ImVec2 m_position;
static int s_idCounter;
Attribute& getAttribute(u32 index) { Attribute& getAttribute(u32 index) {
if (index >= this->getAttributes().size()) if (index >= this->getAttributes().size())
throw std::runtime_error("Attribute index out of bounds!"); throw std::runtime_error("Attribute index out of bounds!");

17
lib/libimhex/include/hex/helpers/http_requests.hpp
View File

@ -93,13 +93,7 @@ namespace hex {
return *this; return *this;
} }
static void setCACert(std::string data) { static void setProxy(std::string proxy);
HttpRequest::s_caCertData = std::move(data);
}
static void setProxy(std::string proxy) {
HttpRequest::s_proxyUrl = std::move(proxy);
}
void setMethod(std::string method) { void setMethod(std::string method) {
this->m_method = std::move(method); this->m_method = std::move(method);
@ -286,9 +280,7 @@ namespace hex {
char *url = nullptr; char *url = nullptr;
curl_easy_getinfo(this->m_curl, CURLINFO_EFFECTIVE_URL, &url); curl_easy_getinfo(this->m_curl, CURLINFO_EFFECTIVE_URL, &url);
log::error("Http request '{0} {1}' failed with error {2}: '{3}'", this->m_method, url, u32(result), curl_easy_strerror(result)); log::error("Http request '{0} {1}' failed with error {2}: '{3}'", this->m_method, url, u32(result), curl_easy_strerror(result));
if (!HttpRequest::s_proxyUrl.empty()){ checkProxyErrors();
log::info("A custom proxy '{0}' is in use. Is it working correctly?", HttpRequest::s_proxyUrl);
}
return { }; return { };
} }
@ -300,11 +292,13 @@ namespace hex {
return Result<T>(statusCode, { data.begin(), data.end() }); return Result<T>(statusCode, { data.begin(), data.end() });
} }
[[maybe_unused]] static CURLcode sslCtxFunction(CURL *ctx, void *sslctx, void *userData);
static size_t writeToVector(void *contents, size_t size, size_t nmemb, void *userdata); static size_t writeToVector(void *contents, size_t size, size_t nmemb, void *userdata);
static size_t writeToFile(void *contents, size_t size, size_t nmemb, void *userdata); static size_t writeToFile(void *contents, size_t size, size_t nmemb, void *userdata);
static int progressCallback(void *contents, curl_off_t dlTotal, curl_off_t dlNow, curl_off_t ulTotal, curl_off_t ulNow); static int progressCallback(void *contents, curl_off_t dlTotal, curl_off_t dlNow, curl_off_t ulTotal, curl_off_t ulNow);
private:
static void checkProxyErrors();
private: private:
CURL *m_curl; CURL *m_curl;
@ -320,7 +314,6 @@ namespace hex {
std::atomic<bool> m_canceled = false; std::atomic<bool> m_canceled = false;
[[maybe_unused]] std::unique_ptr<mbedtls_x509_crt> m_caCert; [[maybe_unused]] std::unique_ptr<mbedtls_x509_crt> m_caCert;
static std::string s_caCertData, s_proxyUrl;
}; };
} }

3
lib/libimhex/include/hex/providers/provider.hpp
View File

@ -206,9 +206,6 @@ namespace hex::prv {
std::string m_errorMessage; std::string m_errorMessage;
size_t m_pageSize = MaxPageSize; size_t m_pageSize = MaxPageSize;
private:
static u32 s_idCounter;
}; };
} }

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

@ -34,9 +34,7 @@ namespace hex {
return { 0, 0 }; return { 0, 0 };
} }
[[nodiscard]] static std::vector<std::unique_ptr<PopupBase>> &getOpenPopups() { [[nodiscard]] static std::vector<std::unique_ptr<PopupBase>> &getOpenPopups();
return s_openPopups;
}
[[nodiscard]] const std::string &getUnlocalizedName() const { [[nodiscard]] const std::string &getUnlocalizedName() const {
return this->m_unlocalizedName; return this->m_unlocalizedName;
@ -58,9 +56,6 @@ namespace hex {
return this->m_close; return this->m_close;
} }
protected:
static std::vector<std::unique_ptr<PopupBase>> s_openPopups;
private: private:
std::string m_unlocalizedName; std::string m_unlocalizedName;
@ -84,7 +79,7 @@ namespace hex {
auto popup = std::make_unique<T>(std::forward<Args>(args)...); auto popup = std::make_unique<T>(std::forward<Args>(args)...);
s_openPopups.emplace_back(std::move(popup)); getOpenPopups().emplace_back(std::move(popup));
} }
}; };

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

@ -51,20 +51,17 @@ namespace hex {
return LangEntry(unlocalizedName) + "###" + unlocalizedName; return LangEntry(unlocalizedName) + "###" + unlocalizedName;
} }
static ImFontAtlas *getFontAtlas() { return View::s_fontAtlas; } static ImFontAtlas *getFontAtlas();
static void setFontAtlas(ImFontAtlas *atlas) { View::s_fontAtlas = atlas; } static void setFontAtlas(ImFontAtlas *atlas);
static ImFontConfig getFontConfig() { return View::s_fontConfig; } static ImFontConfig getFontConfig();
static void setFontConfig(ImFontConfig config) { View::s_fontConfig = config; } static void setFontConfig(ImFontConfig config);
private: private:
std::string m_unlocalizedViewName; std::string m_unlocalizedViewName;
bool m_windowOpen = false; bool m_windowOpen = false;
std::map<Shortcut, std::function<void()>> m_shortcuts; std::map<Shortcut, std::function<void()>> m_shortcuts;
static ImFontAtlas *s_fontAtlas;
static ImFontConfig s_fontConfig;
friend class ShortcutManager; friend class ShortcutManager;
}; };

14
lib/libimhex/source/api/event.cpp
View File

@ -2,7 +2,17 @@
namespace hex { namespace hex {
EventManager::EventList EventManager::s_events; std::map<void *, EventManager::EventList::iterator>& EventManager::getTokenStore() {
std::map<void *, EventManager::EventList::iterator> EventManager::s_tokenStore; static std::map<void *, EventManager::EventList::iterator> tokenStore;
return tokenStore;
}
EventManager::EventList& EventManager::getEvents() {
static EventManager::EventList events;
return events;
}
} }

19
lib/libimhex/source/api/keybinding.cpp
View File

@ -5,10 +5,15 @@
namespace hex { namespace hex {
std::map<Shortcut, std::function<void()>> ShortcutManager::s_globalShortcuts; namespace {
std::map<Shortcut, std::function<void()>> s_globalShortcuts;
}
void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const std::function<void()> &callback) { void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const std::function<void()> &callback) {
ShortcutManager::s_globalShortcuts.insert({ shortcut, callback }); s_globalShortcuts.insert({ shortcut, callback });
} }
void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const std::function<void()> &callback) { void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const std::function<void()> &callback) {
@ -48,16 +53,16 @@ namespace hex {
void ShortcutManager::processGlobals(bool ctrl, bool alt, bool shift, bool super, u32 keyCode) { void ShortcutManager::processGlobals(bool ctrl, bool alt, bool shift, bool super, u32 keyCode) {
Shortcut pressedShortcut = getShortcut(ctrl, alt, shift, super, false, keyCode); Shortcut pressedShortcut = getShortcut(ctrl, alt, shift, super, false, keyCode);
if (ShortcutManager::s_globalShortcuts.contains(pressedShortcut + AllowWhileTyping)) { if (s_globalShortcuts.contains(pressedShortcut + AllowWhileTyping)) {
ShortcutManager::s_globalShortcuts[pressedShortcut + AllowWhileTyping](); s_globalShortcuts[pressedShortcut + AllowWhileTyping]();
} else if (ShortcutManager::s_globalShortcuts.contains(pressedShortcut)) { } else if (s_globalShortcuts.contains(pressedShortcut)) {
if (!ImGui::GetIO().WantTextInput) if (!ImGui::GetIO().WantTextInput)
ShortcutManager::s_globalShortcuts[pressedShortcut](); s_globalShortcuts[pressedShortcut]();
} }
} }
void ShortcutManager::clearShortcuts() { void ShortcutManager::clearShortcuts() {
ShortcutManager::s_globalShortcuts.clear(); s_globalShortcuts.clear();
} }
} }

11
lib/libimhex/source/api/layout_manager.cpp
View File

@ -9,9 +9,14 @@
namespace hex { namespace hex {
std::optional<std::fs::path> LayoutManager::s_layoutPathToLoad; namespace {
std::optional<std::string> LayoutManager::s_layoutStringToLoad;
std::vector<LayoutManager::Layout> LayoutManager::s_layouts; std::optional<std::fs::path> s_layoutPathToLoad;
std::optional<std::string> s_layoutStringToLoad;
std::vector<LayoutManager::Layout> s_layouts;
}
void LayoutManager::load(const std::fs::path &path) { void LayoutManager::load(const std::fs::path &path) {
s_layoutPathToLoad = path; s_layoutPathToLoad = path;

31
lib/libimhex/source/api/localization.cpp
View File

@ -4,9 +4,14 @@
namespace hex { namespace hex {
std::string LangEntry::s_fallbackLanguage; namespace {
std::string LangEntry::s_selectedLanguage;
std::map<std::string, std::string> LangEntry::s_currStrings; std::string s_fallbackLanguage;
std::string s_selectedLanguage;
std::map<std::string, std::string> s_currStrings;
}
LanguageDefinition::LanguageDefinition(std::map<std::string, std::string> &&entries) { LanguageDefinition::LanguageDefinition(std::map<std::string, std::string> &&entries) {
for (const auto &[key, value] : entries) { for (const auto &[key, value] : entries) {
@ -67,7 +72,7 @@ namespace hex {
} }
const std::string &LangEntry::get() const { const std::string &LangEntry::get() const {
auto &lang = LangEntry::s_currStrings; auto &lang = s_currStrings;
if (lang.contains(this->m_unlocalizedString)) if (lang.contains(this->m_unlocalizedString))
return lang[this->m_unlocalizedString]; return lang[this->m_unlocalizedString];
else else
@ -75,7 +80,7 @@ namespace hex {
} }
void LangEntry::loadLanguage(const std::string &language) { void LangEntry::loadLanguage(const std::string &language) {
LangEntry::s_currStrings.clear(); s_currStrings.clear();
auto &definitions = ContentRegistry::Language::impl::getLanguageDefinitions(); auto &definitions = ContentRegistry::Language::impl::getLanguageDefinitions();
@ -83,15 +88,15 @@ namespace hex {
return; return;
for (auto &definition : definitions[language]) for (auto &definition : definitions[language])
LangEntry::s_currStrings.insert(definition.getEntries().begin(), definition.getEntries().end()); s_currStrings.insert(definition.getEntries().begin(), definition.getEntries().end());
const auto fallbackLanguage = LangEntry::getFallbackLanguage(); const auto fallbackLanguage = LangEntry::getFallbackLanguage();
if (language != fallbackLanguage) { if (language != fallbackLanguage) {
for (auto &definition : definitions[fallbackLanguage]) for (auto &definition : definitions[fallbackLanguage])
LangEntry::s_currStrings.insert(definition.getEntries().begin(), definition.getEntries().end()); s_currStrings.insert(definition.getEntries().begin(), definition.getEntries().end());
} }
LangEntry::s_selectedLanguage = language; s_selectedLanguage = language;
} }
const std::map<std::string, std::string> &LangEntry::getSupportedLanguages() { const std::map<std::string, std::string> &LangEntry::getSupportedLanguages() {
@ -99,20 +104,20 @@ namespace hex {
} }
void LangEntry::setFallbackLanguage(const std::string &language) { void LangEntry::setFallbackLanguage(const std::string &language) {
LangEntry::s_fallbackLanguage = language; s_fallbackLanguage = language;
} }
const std::string &LangEntry::getFallbackLanguage() { const std::string &LangEntry::getFallbackLanguage() {
return LangEntry::s_fallbackLanguage; return s_fallbackLanguage;
} }
void LangEntry::resetLanguageStrings() { void LangEntry::resetLanguageStrings() {
LangEntry::s_currStrings.clear(); s_currStrings.clear();
LangEntry::s_selectedLanguage.clear(); s_selectedLanguage.clear();
} }
const std::string &LangEntry::getSelectedLanguage() { const std::string &LangEntry::getSelectedLanguage() {
return LangEntry::s_selectedLanguage; return s_selectedLanguage;
} }
} }

24
lib/libimhex/source/api/plugin_manager.cpp
View File

@ -170,34 +170,42 @@ namespace hex {
} }
std::fs::path PluginManager::s_pluginFolder; namespace {
std::vector<Plugin> PluginManager::s_plugins;
std::fs::path s_pluginFolder;
std::vector<Plugin> s_plugins;
}
bool PluginManager::load(const std::fs::path &pluginFolder) { bool PluginManager::load(const std::fs::path &pluginFolder) {
if (!wolv::io::fs::exists(pluginFolder)) if (!wolv::io::fs::exists(pluginFolder))
return false; return false;
PluginManager::s_pluginFolder = pluginFolder; s_pluginFolder = pluginFolder;
for (auto &pluginPath : std::fs::directory_iterator(pluginFolder)) { for (auto &pluginPath : std::fs::directory_iterator(pluginFolder)) {
if (pluginPath.is_regular_file() && pluginPath.path().extension() == ".hexplug") if (pluginPath.is_regular_file() && pluginPath.path().extension() == ".hexplug")
PluginManager::s_plugins.emplace_back(pluginPath.path()); s_plugins.emplace_back(pluginPath.path());
} }
if (PluginManager::s_plugins.empty()) if (s_plugins.empty())
return false; return false;
return true; return true;
} }
void PluginManager::unload() { void PluginManager::unload() {
PluginManager::s_plugins.clear(); s_plugins.clear();
PluginManager::s_pluginFolder.clear(); s_pluginFolder.clear();
} }
void PluginManager::reload() { void PluginManager::reload() {
PluginManager::unload(); PluginManager::unload();
PluginManager::load(PluginManager::s_pluginFolder); PluginManager::load(s_pluginFolder);
}
const std::vector<Plugin> &PluginManager::getPlugins() {
return s_plugins;
} }
} }

35
lib/libimhex/source/api/project_file_manager.cpp
View File

@ -11,20 +11,25 @@
namespace hex { namespace hex {
std::vector<ProjectFile::Handler> ProjectFile::s_handlers; namespace {
std::vector<ProjectFile::ProviderHandler> ProjectFile::s_providerHandlers;
std::fs::path ProjectFile::s_currProjectPath; std::vector<ProjectFile::Handler> s_handlers;
std::vector<ProjectFile::ProviderHandler> s_providerHandlers;
std::fs::path s_currProjectPath;
std::function<bool(const std::fs::path&)> s_loadProjectFunction;
std::function<bool(std::optional<std::fs::path>, bool)> s_storeProjectFunction;
}
std::function<bool(const std::fs::path&)> ProjectFile::s_loadProjectFunction;
std::function<bool(std::optional<std::fs::path>, bool)> ProjectFile::s_storeProjectFunction;
void ProjectFile::setProjectFunctions( void ProjectFile::setProjectFunctions(
const std::function<bool(const std::fs::path&)> &loadFun, const std::function<bool(const std::fs::path&)> &loadFun,
const std::function<bool(std::optional<std::fs::path>, bool)> &storeFun const std::function<bool(std::optional<std::fs::path>, bool)> &storeFun
) { ) {
ProjectFile::s_loadProjectFunction = loadFun; s_loadProjectFunction = loadFun;
ProjectFile::s_storeProjectFunction = storeFun; s_storeProjectFunction = storeFun;
} }
bool ProjectFile::load(const std::fs::path &filePath) { bool ProjectFile::load(const std::fs::path &filePath) {
@ -36,19 +41,27 @@ namespace hex {
} }
bool ProjectFile::hasPath() { bool ProjectFile::hasPath() {
return !ProjectFile::s_currProjectPath.empty(); return !s_currProjectPath.empty();
} }
void ProjectFile::clearPath() { void ProjectFile::clearPath() {
ProjectFile::s_currProjectPath.clear(); s_currProjectPath.clear();
} }
std::fs::path ProjectFile::getPath() { std::fs::path ProjectFile::getPath() {
return ProjectFile::s_currProjectPath; return s_currProjectPath;
} }
void ProjectFile::setPath(const std::fs::path &path) { void ProjectFile::setPath(const std::fs::path &path) {
ProjectFile::s_currProjectPath = path; s_currProjectPath = path;
}
std::vector<ProjectFile::Handler> &ProjectFile::getHandlers() {
return s_handlers;
}
std::vector<ProjectFile::ProviderHandler> &ProjectFile::getProviderHandlers() {
return s_providerHandlers;
} }
} }

27
lib/libimhex/source/api/task.cpp
View File

@ -14,15 +14,20 @@
namespace hex { namespace hex {
std::mutex TaskManager::s_deferredCallsMutex, TaskManager::s_tasksFinishedMutex; namespace {
std::list<std::shared_ptr<Task>> TaskManager::s_tasks, TaskManager::s_taskQueue; std::mutex s_deferredCallsMutex, s_tasksFinishedMutex;
std::list<std::function<void()>> TaskManager::s_deferredCalls;
std::list<std::function<void()>> TaskManager::s_tasksFinishedCallbacks; std::list<std::shared_ptr<Task>> s_tasks, s_taskQueue;
std::list<std::function<void()>> s_deferredCalls;
std::list<std::function<void()>> s_tasksFinishedCallbacks;
std::mutex s_queueMutex;
std::condition_variable s_jobCondVar;
std::vector<std::jthread> s_workers;
}
std::mutex TaskManager::s_queueMutex;
std::condition_variable TaskManager::s_jobCondVar;
std::vector<std::jthread> TaskManager::s_workers;
static void setThreadName(const std::string &name) { static void setThreadName(const std::string &name) {
#if defined(OS_WINDOWS) #if defined(OS_WINDOWS)
@ -210,19 +215,19 @@ namespace hex {
log::debug("Initializing task manager thread pool with {} workers.", threadCount); log::debug("Initializing task manager thread pool with {} workers.", threadCount);
for (u32 i = 0; i < threadCount; i++) for (u32 i = 0; i < threadCount; i++)
TaskManager::s_workers.emplace_back(TaskManager::runner); s_workers.emplace_back(TaskManager::runner);
} }
void TaskManager::exit() { void TaskManager::exit() {
for (auto &task : TaskManager::s_tasks) for (auto &task : s_tasks)
task->interrupt(); task->interrupt();
for (auto &thread : TaskManager::s_workers) for (auto &thread : s_workers)
thread.request_stop(); thread.request_stop();
s_jobCondVar.notify_all(); s_jobCondVar.notify_all();
TaskManager::s_workers.clear(); s_workers.clear();
} }
void TaskManager::runner(const std::stop_token &stopToken) { void TaskManager::runner(const std::stop_token &stopToken) {

34
lib/libimhex/source/api/theme_manager.cpp
View File

@ -9,11 +9,16 @@
namespace hex { namespace hex {
std::map<std::string, nlohmann::json> ThemeManager::s_themes; namespace {
std::map<std::string, ThemeManager::ThemeHandler> ThemeManager::s_themeHandlers;
std::map<std::string, ThemeManager::StyleHandler> ThemeManager::s_styleHandlers; std::map<std::string, nlohmann::json> s_themes;
std::string ThemeManager::s_imageTheme; std::map<std::string, ThemeManager::ThemeHandler> s_themeHandlers;
std::string ThemeManager::s_currTheme; std::map<std::string, ThemeManager::StyleHandler> s_styleHandlers;
std::string s_imageTheme;
std::string s_currTheme;
}
void ThemeManager::addThemeHandler(const std::string &name, const ColorMap &colorMap, const std::function<ImColor(u32)> &getFunction, const std::function<void(u32, ImColor)> &setFunction) { void ThemeManager::addThemeHandler(const std::string &name, const ColorMap &colorMap, const std::function<ImColor(u32)> &getFunction, const std::function<void(u32, ImColor)> &setFunction) {
s_themeHandlers[name] = { colorMap, getFunction, setFunction }; s_themeHandlers[name] = { colorMap, getFunction, setFunction };
@ -201,11 +206,20 @@ namespace hex {
} }
void ThemeManager::reset() { void ThemeManager::reset() {
ThemeManager::s_themes.clear(); s_themes.clear();
ThemeManager::s_styleHandlers.clear(); s_styleHandlers.clear();
ThemeManager::s_themeHandlers.clear(); s_themeHandlers.clear();
ThemeManager::s_imageTheme.clear(); s_imageTheme.clear();
ThemeManager::s_currTheme.clear(); s_currTheme.clear();
}
std::map<std::string, ThemeManager::ThemeHandler> &ThemeManager::getThemeHandlers() {
return s_themeHandlers;
}
std::map<std::string, ThemeManager::StyleHandler> &ThemeManager::getStyleHandlers() {
return s_styleHandlers;
} }
} }

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

@ -3,9 +3,14 @@
namespace hex::dp { namespace hex::dp {
int Attribute::s_idCounter = 1; namespace {
Attribute::Attribute(IOType ioType, Type type, std::string unlocalizedName) : m_id(Attribute::s_idCounter++), m_ioType(ioType), m_type(type), m_unlocalizedName(std::move(unlocalizedName)) { int 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() { Attribute::~Attribute() {
@ -13,4 +18,9 @@ namespace hex::dp {
attr->removeConnectedAttribute(linkId); attr->removeConnectedAttribute(linkId);
} }
void Attribute::setIdCounter(int id) {
if (id > s_idCounter)
s_idCounter = id;
}
} }

11
lib/libimhex/source/data_processor/link.cpp
View File

@ -3,9 +3,16 @@
namespace hex::dp { namespace hex::dp {
int Link::s_idCounter = 1; namespace {
Link::Link(int from, int to) : m_id(Link::s_idCounter++), m_from(from), m_to(to) { } int s_idCounter = 1;
}
Link::Link(int from, int to) : m_id(s_idCounter++), m_from(from), m_to(to) { }
void Link::setIdCounter(int id) {
if (id > s_idCounter)
s_idCounter = id;
}
} }

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

@ -7,9 +7,13 @@
namespace hex::dp { namespace hex::dp {
int Node::s_idCounter = 1; namespace {
Node::Node(std::string unlocalizedTitle, std::vector<Attribute> attributes) : m_id(Node::s_idCounter++), m_unlocalizedTitle(std::move(unlocalizedTitle)), m_attributes(std::move(attributes)) { int 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)) {
for (auto &attr : this->m_attributes) for (auto &attr : this->m_attributes)
attr.setParentNode(this); attr.setParentNode(this);
} }
@ -136,4 +140,9 @@ namespace hex::dp {
this->m_overlay->getData() = data; this->m_overlay->getData() = data;
} }
void Node::setIdCounter(int id) {
if (id > s_idCounter)
s_idCounter = id;
}
} }

33
lib/libimhex/source/helpers/http_requests.cpp
View File

@ -2,8 +2,12 @@
namespace hex { namespace hex {
std::string HttpRequest::s_caCertData; namespace {
std::string HttpRequest::s_proxyUrl;
std::string s_proxyUrl;
}
HttpRequest::HttpRequest(std::string method, std::string url) : m_method(std::move(method)), m_url(std::move(url)) { HttpRequest::HttpRequest(std::string method, std::string url) : m_method(std::move(method)), m_url(std::move(url)) {
AT_FIRST_TIME { AT_FIRST_TIME {
@ -38,21 +42,6 @@ namespace hex {
curl_easy_setopt(this->m_curl, CURLOPT_PROXY, s_proxyUrl.c_str()); curl_easy_setopt(this->m_curl, CURLOPT_PROXY, s_proxyUrl.c_str());
} }
CURLcode HttpRequest::sslCtxFunction(CURL *ctx, void *sslctx, void *userData) {
hex::unused(ctx, userData);
auto *cfg = static_cast<mbedtls_ssl_config *>(sslctx);
auto crt = static_cast<mbedtls_x509_crt*>(userData);
mbedtls_x509_crt_init(crt);
mbedtls_x509_crt_parse(crt, reinterpret_cast<const u8 *>(HttpRequest::s_caCertData.data()), HttpRequest::s_caCertData.size());
mbedtls_ssl_conf_ca_chain(cfg, crt, nullptr);
return CURLE_OK;
}
size_t HttpRequest::writeToVector(void *contents, size_t size, size_t nmemb, void *userdata) { size_t HttpRequest::writeToVector(void *contents, size_t size, size_t nmemb, void *userdata) {
auto &response = *reinterpret_cast<std::vector<u8>*>(userdata); auto &response = *reinterpret_cast<std::vector<u8>*>(userdata);
auto startSize = response.size(); auto startSize = response.size();
@ -84,4 +73,14 @@ namespace hex {
return request.m_canceled ? CURLE_ABORTED_BY_CALLBACK : CURLE_OK; return request.m_canceled ? CURLE_ABORTED_BY_CALLBACK : CURLE_OK;
} }
void HttpRequest::setProxy(std::string proxy) {
s_proxyUrl = std::move(proxy);
}
void HttpRequest::checkProxyErrors() {
if (!s_proxyUrl.empty()){
log::info("A custom proxy '{0}' is in use. Is it working correctly?", s_proxyUrl);
}
}
} }

7
lib/libimhex/source/providers/provider.cpp
View File

@ -13,7 +13,12 @@
namespace hex::prv { namespace hex::prv {
u32 Provider::s_idCounter = 0; namespace {
u32 s_idCounter = 0;
}
Provider::Provider() : m_id(s_idCounter++) { Provider::Provider() : m_id(s_idCounter++) {
this->m_patches.emplace_back(); this->m_patches.emplace_back();

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

@ -2,6 +2,12 @@
namespace hex::impl { namespace hex::impl {
std::vector<std::unique_ptr<PopupBase>> PopupBase::s_openPopups;
[[nodiscard]] std::vector<std::unique_ptr<PopupBase>> &PopupBase::getOpenPopups() {
static std::vector<std::unique_ptr<PopupBase>> openPopups;
return openPopups;
}
} }

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

@ -8,8 +8,12 @@
namespace hex { namespace hex {
ImFontAtlas *View::s_fontAtlas; namespace {
ImFontConfig View::s_fontConfig;
ImFontAtlas *s_fontAtlas;
ImFontConfig s_fontConfig;
}
View::View(std::string unlocalizedName) : m_unlocalizedViewName(std::move(unlocalizedName)) { } View::View(std::string unlocalizedName) : m_unlocalizedViewName(std::move(unlocalizedName)) { }
@ -62,4 +66,10 @@ namespace hex {
rightButtonFn(); rightButtonFn();
} }
ImFontAtlas *View::getFontAtlas() { return s_fontAtlas; }
void View::setFontAtlas(ImFontAtlas *atlas) { s_fontAtlas = atlas; }
ImFontConfig View::getFontConfig() { return s_fontConfig; }
void View::setFontConfig(ImFontConfig config) { s_fontConfig = config; }
} }

23
main/source/init/tasks.cpp
View File

@ -108,29 +108,6 @@ namespace hex::init {
bool setupEnvironment() { bool setupEnvironment() {
hex::log::debug("Using romfs: '{}'", romfs::name()); hex::log::debug("Using romfs: '{}'", romfs::name());
// Load the SSL certificate
constexpr static auto CaCertFileName = "cacert.pem";
// Look for a custom certificate in the config folder
std::fs::path caCertPath;
for (const auto &folder : fs::getDefaultPaths(fs::ImHexPath::Config)) {
for (const auto &file : std::fs::directory_iterator(folder)) {
if (file.path().filename() == CaCertFileName) {
caCertPath = file.path();
break;
}
}
}
// If a custom certificate was found, use it, otherwise use the one from the romfs
std::string caCertData;
if (!caCertPath.empty())
caCertData = wolv::io::File(caCertPath, wolv::io::File::Mode::Read).readString();
else
caCertData = std::string(romfs::get(CaCertFileName).string());
HttpRequest::setCACert(caCertData);
return true; return true;
} }