imports/imhex
1
0
Fork 0
mirror of https://github.com/WerWolv/ImHex.git synced 2026-04-02 05:27:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

chore: apply more light lints (#2575)

Browse Source 
<!--
Please provide as much information as possible about what your PR aims
to do.
PRs with no description will most likely be closed until more
information is provided.
If you're planing on changing fundamental behaviour or add big new
features, please open a GitHub Issue first before starting to work on
it.
If it's not something big and you still want to contact us about it,
feel free to do so !
-->

### Problem description
<!-- Describe the bug that you fixed/feature request that you
implemented, or link to an existing issue describing it -->

### Implementation description
<!-- Explain what you did to correct the problem -->

### Screenshots
<!-- If your change is visual, take a screenshot showing it. Ideally,
make before/after sceenshots -->

### Additional things
<!-- Anything else you would like to say -->
This commit is contained in:
iTrooz
2025-12-20 15:59:48 +01:00
committed by GitHub
parent a1711ccfa6
commit 17c2dfcbd0
54 changed files with 444 additions and 457 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -630,22 +630,22 @@ namespace hex {
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::s_entries->push_back(impl::Entry { type, command, unlocalizedDescription, displayCallback, executeCallback });
impl::s_entries->push_back(impl::Entry { .type=type, .command=command, .unlocalizedDescription=unlocalizedDescription, .displayCallback=displayCallback, .executeCallback=executeCallback });
}
void addHandler(Type type, const std::string &command, const impl::QueryCallback &queryCallback, const impl::DisplayCallback &displayCallback) {
log::debug("Registered new command palette command handler: {}", command);
impl::s_handlers->push_back(impl::Handler { type, command, queryCallback, displayCallback });
impl::s_handlers->push_back(impl::Handler { .type=type, .command=command, .queryCallback=queryCallback, .displayCallback=displayCallback });
}
void setDisplayedContent(const impl::ContentDisplayCallback &displayCallback) {
impl::s_displayedContent = impl::ContentDisplay { true, displayCallback };
impl::s_displayedContent = impl::ContentDisplay { .showSearchBox=true, .callback=displayCallback };
}
void openWithContent(const impl::ContentDisplayCallback &displayCallback) {
RequestOpenCommandPalette::post();
impl::s_displayedContent = impl::ContentDisplay { false, displayCallback };
impl::s_displayedContent = impl::ContentDisplay { .showSearchBox=false, .callback=displayCallback };
}
}
@@ -783,12 +783,12 @@ namespace hex {
void addVisualizer(const std::string &name, const impl::VisualizerFunctionCallback &function, pl::api::FunctionParameterCount parameterCount) {
log::debug("Registered new pattern visualizer function: {}", name);
(*impl::s_visualizers)[name] = impl::Visualizer { parameterCount, function };
(*impl::s_visualizers)[name] = impl::Visualizer { .parameterCount=parameterCount, .callback=function };
}
void addInlineVisualizer(const std::string &name, const impl::VisualizerFunctionCallback &function, pl::api::FunctionParameterCount parameterCount) {
log::debug("Registered new inline pattern visualizer function: {}", name);
(*impl::s_inlineVisualizers)[name] = impl::Visualizer { parameterCount, function };
(*impl::s_inlineVisualizers)[name] = impl::Visualizer { .parameterCount=parameterCount, .callback=function };
}
}
@@ -854,7 +854,7 @@ namespace hex {
void add(const UnlocalizedString &unlocalizedName, const char *icon, const impl::Callback &function) {
log::debug("Registered new tool: {}", unlocalizedName.get());
impl::s_tools->emplace_back(impl::Entry { unlocalizedName, icon, function });
impl::s_tools->emplace_back(impl::Entry { .unlocalizedName=unlocalizedName, .icon=icon, .function=function });
}
}
@@ -1009,7 +1009,7 @@ namespace hex {
coloredIcon.color = ImGuiCustomCol_ToolbarGray;
impl::s_menuItems->insert({
priority, impl::MenuItem { unlocalizedMainMenuNames, coloredIcon, shortcut, view, function, enabledCallback, selectedCallback, -1 }
priority, impl::MenuItem { .unlocalizedNames=unlocalizedMainMenuNames, .icon=coloredIcon, .shortcut=shortcut, .view=view, .callback=function, .enabledCallback=enabledCallback, .selectedCallback=selectedCallback, .toolbarIndex=-1 }
});
if (shortcut != Shortcut::None) {
@@ -1033,14 +1033,14 @@ namespace hex {
unlocalizedMainMenuNames.emplace_back(impl::SubMenuValue);
impl::s_menuItems->insert({
priority, impl::MenuItem { unlocalizedMainMenuNames, icon, showOnWelcomeScreen ? Shortcut({ ShowOnWelcomeScreen }) : Shortcut::None, view, function, enabledCallback, []{ return false; }, -1 }
priority, impl::MenuItem { .unlocalizedNames=unlocalizedMainMenuNames, .icon=icon, .shortcut=showOnWelcomeScreen ? Shortcut({ ShowOnWelcomeScreen }) : Shortcut::None, .view=view, .callback=function, .enabledCallback=enabledCallback, .selectedCallback=[]{ return false; }, .toolbarIndex=-1 }
});
}
void addMenuItemSeparator(std::vector<UnlocalizedString> unlocalizedMainMenuNames, u32 priority, View *view) {
unlocalizedMainMenuNames.emplace_back(impl::SeparatorValue);
impl::s_menuItems->insert({
priority, impl::MenuItem { unlocalizedMainMenuNames, "", Shortcut::None, view, []{}, []{ return true; }, []{ return false; }, -1 }
priority, impl::MenuItem { .unlocalizedNames=unlocalizedMainMenuNames, .icon="", .shortcut=Shortcut::None, .view=view, .callback=[]{}, .enabledCallback=[]{ return true; }, .selectedCallback=[]{ return false; }, .toolbarIndex=-1 }
});
}
@@ -1114,9 +1114,9 @@ namespace hex {
}
namespace ContentRegistry::Provider {
namespace impl {
namespace ContentRegistry::Provider::impl {
void add(const std::string &typeName, ProviderCreationFunction creationFunction) {
(void)RequestCreateProvider::subscribe([expectedName = typeName, creationFunction](const std::string &name, bool skipLoadInterface, bool selectProvider, std::shared_ptr<prv::Provider> *provider) {
@@ -1145,7 +1145,7 @@ namespace hex {
}
}
namespace ContentRegistry::DataFormatter {
@@ -1301,40 +1301,35 @@ namespace hex {
}
namespace ContentRegistry::Diffing {
namespace impl {
namespace ContentRegistry::Diffing::impl {
static AutoReset<std::vector<std::unique_ptr<Algorithm>>> s_algorithms;
const std::vector<std::unique_ptr<Algorithm>>& getAlgorithms() {
return *s_algorithms;
}
void addAlgorithm(std::unique_ptr<Algorithm> &&hash) {
s_algorithms->emplace_back(std::move(hash));
}
static AutoReset<std::vector<std::unique_ptr<Algorithm>>> s_algorithms;
const std::vector<std::unique_ptr<Algorithm>>& getAlgorithms() {
return *s_algorithms;
}
void addAlgorithm(std::unique_ptr<Algorithm> &&hash) {
s_algorithms->emplace_back(std::move(hash));
}
}
namespace ContentRegistry::Hashes {
namespace impl {
namespace ContentRegistry::Hashes::impl {
static AutoReset<std::vector<std::unique_ptr<Hash>>> s_hashes;
const std::vector<std::unique_ptr<Hash>>& getHashes() {
return *s_hashes;
}
void add(std::unique_ptr<Hash> &&hash) {
s_hashes->emplace_back(std::move(hash));
}
static AutoReset<std::vector<std::unique_ptr<Hash>>> s_hashes;
const std::vector<std::unique_ptr<Hash>>& getHashes() {
return *s_hashes;
}
void add(std::unique_ptr<Hash> &&hash) {
s_hashes->emplace_back(std::move(hash));
}
}
namespace ContentRegistry::BackgroundServices {
namespace impl {
@@ -1540,22 +1535,19 @@ namespace hex {
}
}
namespace ContentRegistry::Disassemblers {
namespace ContentRegistry::Disassemblers::impl {
namespace impl {
static AutoReset<std::map<std::string, impl::CreatorFunction>> s_architectures;
static AutoReset<std::map<std::string, impl::CreatorFunction>> s_architectures;
void addArchitectureCreator(impl::CreatorFunction function) {
const auto arch = function();
(*s_architectures)[arch->getName()] = std::move(function);
}
const std::map<std::string, impl::CreatorFunction>& getArchitectures() {
return *s_architectures;
}
void addArchitectureCreator(impl::CreatorFunction function) {
const auto arch = function();
(*s_architectures)[arch->getName()] = std::move(function);
}
const std::map<std::string, impl::CreatorFunction>& getArchitectures() {
return *s_architectures;
}
}

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

@@ -261,7 +261,7 @@ namespace hex {
}
void setSelection(u64 address, size_t size, prv::Provider *provider) {
setSelection({ { address, size }, provider == nullptr ? Provider::get() : provider });
setSelection({ { .address=address, .size=size }, provider == nullptr ? Provider::get() : provider });
}
void addVirtualFile(const std::string &path, std::vector<u8> data, Region region) {
@@ -285,7 +285,7 @@ namespace hex {
}
u64 add(u64 address, size_t size, const std::string &name, const std::string &comment, u32 color) {
return add(Region { address, size }, name, comment, color);
return add(Region { .address=address, .size=size }, name, comment, color);
}
void remove(u64 id) {
@@ -904,7 +904,7 @@ namespace hex {
}
}
return { { name, version } };
return { { .name=name, .version=version } };
}
const SemanticVersion& getImHexVersion() {
@@ -1224,7 +1224,7 @@ namespace hex {
if (it == impl::s_fontDefinitions->end()) {
const auto defaultFont = ImGui::GetDefaultFont();
return { defaultFont, defaultFont, defaultFont };
return { .regular=defaultFont, .bold=defaultFont, .italic=defaultFont };
} else
return it->second;
}

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

@@ -56,7 +56,7 @@ namespace hex {
const auto path = item["path"].get<std::string>();
definition.languageFilePaths.emplace_back(PathEntry{ path, callback });
definition.languageFilePaths.emplace_back(PathEntry{ .path=path, .callback=callback });
}
}

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

@@ -281,25 +281,25 @@ namespace hex {
void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
log::debug("Adding global shortcut {} for {}", shortcut.toString(), unlocalizedName.back().get());
auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { shortcut, unlocalizedName, callback, enabledCallback } });
auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { .shortcut=shortcut, .unlocalizedName=unlocalizedName, .callback=callback, .enabledCallback=enabledCallback } });
if (!inserted) log::error("Failed to add shortcut!");
}
void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
log::debug("Adding global shortcut {} for {}", shortcut.toString(), unlocalizedName.get());
auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { shortcut, { unlocalizedName }, callback, enabledCallback } });
auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { .shortcut=shortcut, .unlocalizedName={ unlocalizedName }, .callback=callback, .enabledCallback=enabledCallback } });
if (!inserted) log::error("Failed to add shortcut!");
}
void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
log::debug("Adding shortcut {} for {}", shortcut.toString(), unlocalizedName.back().get());
auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { shortcut, unlocalizedName, callback, enabledCallback } });
auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { .shortcut=shortcut, .unlocalizedName=unlocalizedName, .callback=callback, .enabledCallback=enabledCallback } });
if (!inserted) log::error("Failed to add shortcut!");
}
void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
log::debug("Adding shortcut {} for {}", shortcut.toString(), unlocalizedName.get());
auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { shortcut, { unlocalizedName }, callback, enabledCallback } });
auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { .shortcut=shortcut, .unlocalizedName={ unlocalizedName }, .callback=callback, .enabledCallback=enabledCallback } });
if (!inserted) log::error("Failed to add shortcut!");
}

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

@@ -31,7 +31,7 @@ namespace hex {
void ThemeManager::addThemeHandler(const std::string &name, const ColorMap &colorMap, const std::function<ImColor(u32)> &getFunction, const std::function<void(u32, ImColor)> &setFunction) {
std::unique_lock lock(s_themeMutex);
(*s_themeHandlers)[name] = { colorMap, getFunction, setFunction };
(*s_themeHandlers)[name] = { .colorMap=colorMap, .getFunction=getFunction, .setFunction=setFunction };
}
void ThemeManager::addStyleHandler(const std::string &name, const StyleMap &styleMap) {

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

@@ -320,10 +320,10 @@ namespace hex {
if (!message.has_value()) {
message = Tutorial::Step::Message {
Position::None,
"",
"",
false
.position=Position::None,
.unlocalizedTitle="",
.unlocalizedMessage="",
.allowSkip=false
};
}
@@ -483,10 +483,10 @@ namespace hex {
TutorialManager::Tutorial::Step& TutorialManager::Tutorial::Step::setMessage(const UnlocalizedString &unlocalizedTitle, const UnlocalizedString &unlocalizedMessage, Position position) {
m_message = Message {
position,
unlocalizedTitle,
unlocalizedMessage,
false
.position=position,
.unlocalizedTitle=unlocalizedTitle,
.unlocalizedMessage=unlocalizedMessage,
.allowSkip=false
};
return *this;
@@ -497,10 +497,10 @@ namespace hex {
m_message->allowSkip = true;
} else {
m_message = Message {
Position::Bottom | Position::Right,
"",
"",
true
.position=Position::Bottom | Position::Right,
.unlocalizedTitle="",
.unlocalizedMessage="",
.allowSkip=true
};
}