ed/Cog
1
0
Fork 0
mirror of https://github.com/Ed94/Cog.git synced 2026-06-13 08:02:23 -07:00
Code Issues Packages Projects Releases Wiki Activity

CogCommonUI: Add a new plugin to fix CommonUI blocking cog shortcuts (F1, F2, ...)

Browse Source 
Reference this plugin where other cog modules are added.
This plugin uses a CommonUI ActionRouter to let Cog receives the shortcuts it needs.
If you already have an Action Router, you can call FCogImguiInputHelper::IsTopPriorityKey to know if the key event to should handled or not.
This commit is contained in:
Arnaud Jamin
2025-01-25 21:50:19 -05:00
parent c345235e96
commit c9918da4f1
16 changed files with 293 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Plugins/Cog/Source/CogEngine/Private/CogEngineWindow_CommandBindings.cpp
+1 -1
View File
@@ -54,7 +54,7 @@ void FCogEngineWindow_CommandBindings::RenderContent()
"Disable the existing Unreal command shortcuts mapped to same shortcuts Cog is using. Typically, if the F1 shortcut is used to toggle Inputs, the Unreal wireframe command will get disabled."
))
{
GetOwner()->DisableConflictingCommands();
GetOwner()->OnShortcutsDefined();
}
for (FKeyBind& KeyBind : PlayerInput->DebugExecBindings)
Plugins/Cog/Source/CogImgui/Private/CogImguiInputHelper.cpp
+73 -57
View File
@@ -1,5 +1,7 @@
#include "CogImguiInputHelper.h"
#include <ThirdParty/SPIRV-Reflect/SPIRV-Reflect/spirv_reflect.h>
#include "CogImguiKeyInfo.h"
#include "Engine/World.h"
#include "Framework/Application/SlateApplication.h"
@@ -16,6 +18,9 @@
#include "Kismet2/DebuggerCommands.h"
#endif //WITH_EDITOR
//--------------------------------------------------------------------------------------------------------------------------
TArray<FCogImGuiKeyInfo> FCogImguiInputHelper::CogShortcuts;
//--------------------------------------------------------------------------------------------------------------------------
APlayerController* FCogImguiInputHelper::GetFirstLocalPlayerController(const UWorld& World)
{
@@ -45,23 +50,35 @@ UPlayerInput* FCogImguiInputHelper::GetPlayerInput(const UWorld& World)
}
//--------------------------------------------------------------------------------------------------------------------------
bool FCogImguiInputHelper::IsKeyEventHandled(UWorld* World, const FKeyEvent& KeyEvent)
bool FCogImguiInputHelper::IsTopPriorityKey(UWorld* InWorld, const FKey& InKey)
{
FKeyEvent KeyEvent(InKey, FModifierKeysState(), 0, false, 0, 0);
return IsTopPriorityKeyEvent(InWorld, KeyEvent);
}
//--------------------------------------------------------------------------------------------------------------------------
bool FCogImguiInputHelper::IsTopPriorityKeyEvent(UWorld* InWorld, const FKeyEvent& InKeyEvent)
{
//------------------------------------------------------------------------------------------------
// We want the user to be able to use Cog shortcuts when imgui has the input.
//------------------------------------------------------------------------------------------------
for (const FCogImGuiKeyInfo& KeyInfo : CogShortcuts)
{
if (IsKeyEventMatchingKeyInfo(InKeyEvent, KeyInfo))
{ return true; }
}
//------------------------------------------------------------------------------------------------
// We want the user to be able to open the console command when imgui has the input.
//------------------------------------------------------------------------------------------------
if (IsConsoleEvent(KeyEvent))
{
return false;
}
if (IsConsoleEvent(InKeyEvent))
{ return true; }
//------------------------------------------------------------------------------------------------
// We want the user to be able to stop its session by pressing Esc, even when imgui has the input
//------------------------------------------------------------------------------------------------
if (IsStopPlaySessionEvent(KeyEvent))
{
return false;
}
if (IsStopPlaySessionEvent(InKeyEvent))
{ return true; }
//------------------------------------------------------------------------------------------------
// If we receive a key modifier, we want to let others systems know about it.
@@ -71,22 +88,16 @@ bool FCogImguiInputHelper::IsKeyEventHandled(UWorld* World, const FKeyEvent& Key
// and not the Key+Modifier event.
// We update ImGui modifier keys in SCogImguiWidget::TickKeyModifiers().
//------------------------------------------------------------------------------------------------
if (KeyEvent.GetKey().IsModifierKey())
{
return false;
}
if (InKeyEvent.GetKey().IsModifierKey())
{ return true; }
//------------------------------------------------------------------------------------------------
// We want the user to be able to use command bindings, even when imgui has the input.
// We actually use a console command to toggle the input from the game to imgui, and other
// windows command such as LoadLayout.
//------------------------------------------------------------------------------------------------
if (IsKeyBoundToCommand(World, KeyEvent))
{
return false;
}
if (IsKeyBoundToCommand(InWorld, InKeyEvent))
{ return true; }
return true;
return false;
}
//--------------------------------------------------------------------------------------------------------------------------
@@ -97,7 +108,7 @@ bool FCogImguiInputHelper::IsCheckBoxStateMatchingValue(ECheckBoxState CheckBoxS
}
//--------------------------------------------------------------------------------------------------------------------------
bool FCogImguiInputHelper::IsCheckBoxStateMatchingKeybindModifier(ECheckBoxState InCheckBoxState, bool InRequireModifier, bool InIgnoreModifier)
bool FCogImguiInputHelper::IsCheckBoxStateMatchingKeyBindModifier(ECheckBoxState InCheckBoxState, bool InRequireModifier, bool InIgnoreModifier)
{
switch (InCheckBoxState)
{
@@ -109,13 +120,13 @@ bool FCogImguiInputHelper::IsCheckBoxStateMatchingKeybindModifier(ECheckBoxState
}
//--------------------------------------------------------------------------------------------------------------------------
bool FCogImguiInputHelper::IsKeyEventMatchingKeyInfo(const FKeyEvent& KeyEvent, const FCogImGuiKeyInfo& KeyInfo)
bool FCogImguiInputHelper::IsKeyEventMatchingKeyInfo(const FKeyEvent& InKeyEvent, const FCogImGuiKeyInfo& InKeyInfo)
{
const bool Result = (KeyInfo.Key == KeyEvent.GetKey())
&& IsCheckBoxStateMatchingValue(KeyInfo.Shift, KeyEvent.IsShiftDown())
&& IsCheckBoxStateMatchingValue(KeyInfo.Ctrl, KeyEvent.IsControlDown())
&& IsCheckBoxStateMatchingValue(KeyInfo.Alt, KeyEvent.IsAltDown())
&& IsCheckBoxStateMatchingValue(KeyInfo.Cmd, KeyEvent.IsCommandDown());
const bool Result = (InKeyInfo.Key == InKeyEvent.GetKey())
&& IsCheckBoxStateMatchingValue(InKeyInfo.Shift, InKeyEvent.IsShiftDown())
&& IsCheckBoxStateMatchingValue(InKeyInfo.Ctrl, InKeyEvent.IsControlDown())
&& IsCheckBoxStateMatchingValue(InKeyInfo.Alt, InKeyEvent.IsAltDown())
&& IsCheckBoxStateMatchingValue(InKeyInfo.Cmd, InKeyEvent.IsCommandDown());
return Result;
}
@@ -182,10 +193,10 @@ void FCogImguiInputHelper::KeyInfoToKeyBind(const FCogImGuiKeyInfo& KeyInfo, FKe
bool FCogImguiInputHelper::IsKeyBindMatchingKeyInfo(const FKeyBind& InKeyBind, const FCogImGuiKeyInfo& InKeyInfo)
{
const bool Result = (InKeyInfo.Key == InKeyBind.Key)
&& IsCheckBoxStateMatchingKeybindModifier(InKeyInfo.Shift, InKeyBind.Shift, InKeyBind.bIgnoreShift)
&& IsCheckBoxStateMatchingKeybindModifier(InKeyInfo.Ctrl, InKeyBind.Control, InKeyBind.bIgnoreCtrl)
&& IsCheckBoxStateMatchingKeybindModifier(InKeyInfo.Alt, InKeyBind.Alt, InKeyBind.bIgnoreAlt)
&& IsCheckBoxStateMatchingKeybindModifier(InKeyInfo.Cmd, InKeyBind.Cmd, InKeyBind.bIgnoreCmd);
&& IsCheckBoxStateMatchingKeyBindModifier(InKeyInfo.Shift, InKeyBind.Shift, InKeyBind.bIgnoreShift)
&& IsCheckBoxStateMatchingKeyBindModifier(InKeyInfo.Ctrl, InKeyBind.Control, InKeyBind.bIgnoreCtrl)
&& IsCheckBoxStateMatchingKeyBindModifier(InKeyInfo.Alt, InKeyBind.Alt, InKeyBind.bIgnoreAlt)
&& IsCheckBoxStateMatchingKeyBindModifier(InKeyInfo.Cmd, InKeyBind.Cmd, InKeyBind.bIgnoreCmd);
return Result;
}
@@ -326,33 +337,11 @@ FString FCogImguiInputHelper::CommandToString(const UPlayerInput* PlayerInput, c
}
//--------------------------------------------------------------------------------------------------------------------------
FString FCogImguiInputHelper::KeyBindToString(const FKeyBind& KeyBind)
FString FCogImguiInputHelper::KeyBindToString(const FKeyBind& InKeyBind)
{
FString Result = "[";
if (KeyBind.Alt)
{
Result += FString("Alt ");
}
if (KeyBind.Shift)
{
Result += FString("Shift ");
}
if (KeyBind.Control)
{
Result += FString("Ctrl ");
}
if (KeyBind.Cmd)
{
Result += FString("Cmd ");
}
Result += KeyBind.Key.ToString();
Result += FString("]");
return Result;
FCogImGuiKeyInfo KeyInfo;
KeyBindToKeyInfo(InKeyBind, KeyInfo);
return KeyInfoToString(KeyInfo);
}
//--------------------------------------------------------------------------------------------------------------------------
@@ -471,6 +460,32 @@ bool FCogImguiInputHelper::IsMouseInsideMainViewport()
return false;
}
//--------------------------------------------------------------------------------------------------------------------------
void FCogImguiInputHelper::SetShortcuts(const UWorld& World, const TArray<FCogImGuiKeyInfo>& InShortcuts, bool InDisableCommandsConflictingWithShortcuts)
{
CogShortcuts = InShortcuts;
if (InDisableCommandsConflictingWithShortcuts == false )
{ return; }
UPlayerInput* PlayerInput = FCogImguiInputHelper::GetPlayerInput(World);
if (PlayerInput == nullptr)
{ return; }
for (const FCogImGuiKeyInfo& Shortcut : CogShortcuts)
{
for (FKeyBind& KeyBind : PlayerInput->DebugExecBindings)
{
if (IsKeyBindMatchingKeyInfo(KeyBind, Shortcut))
{
KeyBind.bDisabled = true;
}
}
}
PlayerInput->SaveConfig();
}
//--------------------------------------------------------------------------------------------------------------------------
ImGuiKey FCogImguiInputHelper::ToImKey(const FKey& Key)
{
@@ -615,3 +630,4 @@ ImGuiKey FCogImguiInputHelper::ToImKey(const FKey& Key)
const ImGuiKey* Result = LookupMap.Find(Key);
return (Result != nullptr) ? *Result : ImGuiKey_None;
}
Plugins/Cog/Source/CogImgui/Private/CogImguiWidget.cpp
+5 -5
View File
@@ -152,7 +152,7 @@ FReply SCogImguiWidget::HandleKeyEvent(const FKeyEvent& KeyEvent, bool Down)
return FReply::Unhandled();
}
if (FCogImguiInputHelper::IsKeyEventHandled(Context->GetGameViewport()->GetWorld(), KeyEvent) == false)
if (FCogImguiInputHelper::IsTopPriorityKeyEvent(Context->GetGameViewport()->GetWorld(), KeyEvent))
{
return FReply::Unhandled();
}
@@ -169,10 +169,10 @@ FReply SCogImguiWidget::HandleKeyEvent(const FKeyEvent& KeyEvent, bool Down)
return FReply::Unhandled();
}
if (IO.WantTextInput == false)
{
return FReply::Unhandled();
}
// if (IO.WantTextInput == false)
// {
// return FReply::Unhandled();
// }
return FReply::Handled();
}
Plugins/Cog/Source/CogImgui/Public/CogImguiInputHelper.h
+11 -4
View File
@@ -22,15 +22,17 @@ public:
static UPlayerInput* GetPlayerInput(const UWorld& World);
static bool IsKeyEventHandled(UWorld* World, const FKeyEvent& KeyEvent);
static bool IsTopPriorityKey(UWorld* InWorld, const FKey& InKey);
static bool IsTopPriorityKeyEvent(UWorld* InWorld, const FKeyEvent& InKeyEvent);
static bool WasKeyInfoJustPressed(APlayerController& PlayerController, const FCogImGuiKeyInfo& KeyInfo);
static bool IsCheckBoxStateMatchingValue(ECheckBoxState CheckBoxState, bool bValue);
static bool IsCheckBoxStateMatchingKeybindModifier(ECheckBoxState InCheckBoxState, bool InRequireModifier, bool InIgnoreModifier);
static bool IsCheckBoxStateMatchingKeyBindModifier(ECheckBoxState InCheckBoxState, bool InRequireModifier, bool InIgnoreModifier);
static bool IsKeyEventMatchingKeyInfo(const FKeyEvent& KeyEvent, const FCogImGuiKeyInfo& InputChord);
static bool IsKeyEventMatchingKeyInfo(const FKeyEvent& InKeyEvent, const FCogImGuiKeyInfo& InKeyInfo);
static bool IsKeyBindMatchingKeyInfo(const FKeyBind& InKeyBind, const FCogImGuiKeyInfo& InKeyInfo);
@@ -60,7 +62,7 @@ public:
static FString CommandToString(const UPlayerInput* PlayerInput, const FString& Command);
static FString KeyBindToString(const FKeyBind& KeyBind);
static FString KeyBindToString(const FKeyBind& InKeyBind);
static FString KeyInfoToString(const FCogImGuiKeyInfo& InKeyInfo);
@@ -68,9 +70,14 @@ public:
static bool IsKeyBoundToCommand(const UPlayerInput* InPlayerInput, const FKeyEvent& KeyEvent);
static void SetShortcuts(const UWorld& World, const TArray<FCogImGuiKeyInfo>& InShortcuts, bool InDisableCommandsConflictingWithShortcuts);
template<typename T, std::enable_if_t<(sizeof(T) <= sizeof(ImWchar)), T>* = nullptr>
static ImWchar CastInputChar(T Char)
{
return static_cast<ImWchar>(Char);
}
private:
static TArray<FCogImGuiKeyInfo> CogShortcuts;
};
Plugins/Cog/Source/CogWindow/Private/CogWindowManager.cpp
+8 -38
View File
@@ -51,10 +51,7 @@ void UCogWindowManager::InitializeInternal()
SpaceWindows.Add(AddWindow<FCogWindow_Spacing>("Spacing 4", false));
Settings = GetConfig<UCogWindowConfig_Settings>();
if (Settings->bResolveShortcutsConflicts)
{
DisableConflictingCommands();
}
OnShortcutsDefined();
LayoutsWindow = AddWindow<FCogWindow_Layouts>("Window.Layouts", false);
SettingsWindow = AddWindow<FCogWindow_Settings>("Window.Settings", false);
@@ -843,10 +840,10 @@ void UCogWindowManager::HandleInputs()
if (PlayerInput == nullptr)
{ return; }
if (ImGui::GetIO().WantTextInput)
if (Settings->bDisableShortcutsWhenImGuiWantTextInput && ImGui::GetIO().WantTextInput)
{ return; }
if (FCogImguiInputHelper::IsKeyInfoPressed(PlayerInput, Settings->ToggleImguiInputShortcut))
if (FCogImguiInputHelper::IsKeyInfoPressed(PlayerInput, Settings->ToggleImGuiInputShortcut))
{
ToggleInputMode();
}
@@ -888,42 +885,15 @@ bool UCogWindowManager::GetActivateSelectionMode() const
}
//--------------------------------------------------------------------------------------------------------------------------
void UCogWindowManager::DisableConflictingCommands() const
void UCogWindowManager::OnShortcutsDefined() const
{
if (GetWorld() == nullptr)
{ return; }
UPlayerInput* PlayerInput = FCogImguiInputHelper::GetPlayerInput(*GetWorld());
if (PlayerInput == nullptr)
{ return; }
DisableConflictingCommand(PlayerInput, Settings->ToggleImguiInputShortcut);
DisableConflictingCommand(PlayerInput, Settings->ToggleSelectionShortcut);
TArray Shortcuts = { Settings->ToggleImGuiInputShortcut, Settings->ToggleSelectionShortcut };
Shortcuts.Append(Settings->LoadLayoutShortcuts);
Shortcuts.Append(Settings->SaveLayoutShortcuts);
for (int32 i = 0; i < Settings->LoadLayoutShortcuts.Num(); ++i)
{
DisableConflictingCommand(PlayerInput, Settings->LoadLayoutShortcuts[i]);
}
for (int32 i = 0; i < Settings->SaveLayoutShortcuts.Num(); ++i)
{
DisableConflictingCommand(PlayerInput, Settings->SaveLayoutShortcuts[i]);
}
PlayerInput->SaveConfig();
FCogImguiInputHelper::SetShortcuts(*GetWorld(), Shortcuts, Settings->bDisableConflictingCommands);
}
//--------------------------------------------------------------------------------------------------------------------------
void UCogWindowManager::DisableConflictingCommand(UPlayerInput* InPlayerInput, const FCogImGuiKeyInfo& InShortcut)
{
if (InPlayerInput == nullptr)
{ return; }
for (FKeyBind& KeyBind :InPlayerInput->DebugExecBindings)
{
if (FCogImguiInputHelper::IsKeyBindMatchingKeyInfo(KeyBind, InShortcut))
{
KeyBind.bDisabled = true;
}
}
}
Plugins/Cog/Source/CogWindow/Private/CogWindowWidgets.cpp
+12
View File
@@ -40,6 +40,18 @@ void FCogWindowWidgets::EndTableTooltip()
ImGui::PopStyleVar(2);
}
//--------------------------------------------------------------------------------------------------------------------------
void FCogWindowWidgets::ItemTooltipWrappedText(const char* InText)
{
if (ImGui::BeginItemTooltip())
{
ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
ImGui::TextUnformatted(InText);
ImGui::PopTextWrapPos();
ImGui::EndTooltip();
}
}
//--------------------------------------------------------------------------------------------------------------------------
bool FCogWindowWidgets::BeginItemTableTooltip()
{
Plugins/Cog/Source/CogWindow/Private/CogWindow_Settings.cpp
+21 -18
View File
@@ -77,8 +77,8 @@ void FCogWindow_Settings::RenderContent()
{
Context.SetEnableInput(bEnableInput);
}
ImGui::SetItemTooltip("Enable ImGui inputs. When enabled the ImGui menu is shown and inputs are forwarded to ImGui.");
FCogWindowWidgets::MenuItemShortcut("EnableInputShortcut", FCogImguiInputHelper::KeyInfoToString(Config->ToggleImguiInputShortcut));
FCogWindowWidgets::ItemTooltipWrappedText("Enable ImGui inputs. When enabled the ImGui menu is shown and inputs are forwarded to ImGui.");
FCogWindowWidgets::MenuItemShortcut("EnableInputShortcut", FCogImguiInputHelper::KeyInfoToString(Config->ToggleImGuiInputShortcut));
//-------------------------------------------------------------------------------------------
bool bShareKeyboard = Context.GetShareKeyboard();
@@ -86,7 +86,7 @@ void FCogWindow_Settings::RenderContent()
{
Context.SetShareKeyboard(bShareKeyboard);
}
ImGui::SetItemTooltip("Forward the keyboard inputs to the game when ImGui does not need them.");
FCogWindowWidgets::ItemTooltipWrappedText("Forward the keyboard inputs to the game when ImGui does not need them.");
//-------------------------------------------------------------------------------------------
bool bShareMouse = Context.GetShareMouse();
@@ -94,7 +94,7 @@ void FCogWindow_Settings::RenderContent()
{
Context.SetShareMouse(bShareMouse);
}
ImGui::SetItemTooltip("Forward mouse inputs to the game when ImGui does not need them.");
FCogWindowWidgets::ItemTooltipWrappedText("Forward mouse inputs to the game when ImGui does not need them.");
//-------------------------------------------------------------------------------------------
if (bShareMouse == false)
@@ -107,7 +107,7 @@ void FCogWindow_Settings::RenderContent()
{
Context.SetShareMouseWithGameplay(bShareMouseWithGameplay);
}
ImGui::SetItemTooltip("When disabled, mouse inputs are only forwarded to game menus. "
FCogWindowWidgets::ItemTooltipWrappedText("When disabled, mouse inputs are only forwarded to game menus. "
"When enabled, mouse inputs are also forwarded to the gameplay. Note that this mode: \n"
" - Force the cursor to be visible.\n"
" - Prevent the interaction of Cog's transform gizmos.\n"
@@ -120,15 +120,21 @@ void FCogWindow_Settings::RenderContent()
//-------------------------------------------------------------------------------------------
ImGui::CheckboxFlags("Keyboard Navigation", &IO.ConfigFlags, ImGuiConfigFlags_NavEnableKeyboard);
ImGui::SetItemTooltip("Use the keyboard to navigate in ImGui windows with the following keys : Tab, Directional Arrows, Space, Enter.");
FCogWindowWidgets::ItemTooltipWrappedText("Use the keyboard to navigate in ImGui windows with the following keys : Tab, Directional Arrows, Space, Enter.");
//-------------------------------------------------------------------------------------------
//ImGui::CheckboxFlags("Gamepad Navigation", &IO.ConfigFlags, ImGuiConfigFlags_NavEnableGamepad);
//ImGui::SetItemTooltip("Use the gamepad to navigate in ImGui windows.");
//FCogWindowWidgets::ItemTooltipWrappedText("Use the gamepad to navigate in ImGui windows.");
//-------------------------------------------------------------------------------------------
ImGui::Checkbox("Disable Conflicting Commands", &Config->bResolveShortcutsConflicts);
ImGui::SetItemTooltip("Disable the existing Unreal command shortcuts mapped to same shortcuts Cog is using. Typically, if the F1 shortcut is used to toggle Inputs, the Unreal wireframe command will get disabled.");
ImGui::Checkbox("Disable Conflicting Commands", &Config->bDisableConflictingCommands);
FCogWindowWidgets::ItemTooltipWrappedText("Disable the existing Unreal command shortcuts mapped to same shortcuts Cog is using. Typically, if the F1 shortcut is used to toggle Inputs, the Unreal wireframe command will get disabled.");
//-------------------------------------------------------------------------------------------
ImGui::Checkbox("Disable shortcuts when ImGui want text input", &Config->bDisableShortcutsWhenImGuiWantTextInput);
FCogWindowWidgets::ItemTooltipWrappedText("Disable Cog's shortcuts (ToggleInput, ToggleSelectionMode, LoadLayout, ...) when ImGui want text input."
" This can be required if the shortcuts are mapped by keys generating a text input (letters, or Backspace for example)."
" This is not required if the shortcuts are set to keys such as F1 or F2.");
}
//-------------------------------------------------------------------------------------------
@@ -138,19 +144,19 @@ void FCogWindow_Settings::RenderContent()
{
FCogImguiHelper::SetFlags(IO.ConfigFlags, ImGuiConfigFlags_ViewportsEnable, Config->bEnableViewports);
}
ImGui::SetItemTooltip("Enable moving ImGui windows outside of the main viewport.");
FCogWindowWidgets::ItemTooltipWrappedText("Enable moving ImGui windows outside of the main viewport.");
//-------------------------------------------------------------------------------------------
ImGui::Checkbox("Compact Mode", &Config->bCompactMode);
ImGui::SetItemTooltip("Enable compact mode.");
FCogWindowWidgets::ItemTooltipWrappedText("Enable compact mode.");
//-------------------------------------------------------------------------------------------
ImGui::Checkbox("Show Windows In Main Menu", &Config->bShowWindowsInMainMenu);
ImGui::SetItemTooltip("Show the content of the windows when hovering the window menu item.");
FCogWindowWidgets::ItemTooltipWrappedText("Show the content of the windows when hovering the window menu item.");
//-------------------------------------------------------------------------------------------
ImGui::Checkbox("Show Help", &Config->bShowHelp);
ImGui::SetItemTooltip("Show windows help on the window menu items.");
FCogWindowWidgets::ItemTooltipWrappedText("Show windows help on the window menu items.");
//-------------------------------------------------------------------------------------------
FCogWindowWidgets::SetNextItemToShortWidth();
@@ -170,7 +176,7 @@ void FCogWindow_Settings::RenderContent()
//-------------------------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Shortcuts", ImGuiTreeNodeFlags_DefaultOpen))
{
RenderShortcut("Toggle ImGui Input", Config->ToggleImguiInputShortcut);
RenderShortcut("Toggle ImGui Input", Config->ToggleImGuiInputShortcut);
RenderShortcut("Toggle Selection", Config->ToggleSelectionShortcut);
ImGui::Separator();
@@ -232,9 +238,6 @@ void FCogWindow_Settings::RenderShortcut(const char* Label, FCogImGuiKeyInfo& Ke
{
if (FCogWindowWidgets::InputKey(Label, KeyInfo))
{
if (Config->bResolveShortcutsConflicts)
{
GetOwner()->DisableConflictingCommands();
}
GetOwner()->OnShortcutsDefined();
}
}
Plugins/Cog/Source/CogWindow/Public/CogWindowManager.h
+1 -1
View File
@@ -79,7 +79,7 @@ public:
static void SortCommands(UPlayerInput* PlayerInput);
void DisableConflictingCommands() const;
void OnShortcutsDefined() const;
protected:
Plugins/Cog/Source/CogWindow/Public/CogWindowWidgets.h
+2
View File
@@ -27,6 +27,8 @@ public:
static void EndTableTooltip();
static void ItemTooltipWrappedText(const char* InText);
static bool BeginItemTableTooltip();
static void EndItemTableTooltip();
Plugins/Cog/Source/CogWindow/Public/CogWindow_Settings.h
+10 -4
View File
@@ -80,10 +80,13 @@ public:
bool bNavEnableKeyboard = false;
UPROPERTY(Config)
bool bResolveShortcutsConflicts = true;
bool bDisableConflictingCommands = true;
UPROPERTY(Config)
FCogImGuiKeyInfo ToggleImguiInputShortcut = FCogImGuiKeyInfo(EKeys::F1);
bool bDisableShortcutsWhenImGuiWantTextInput = false;
UPROPERTY(Config)
FCogImGuiKeyInfo ToggleImGuiInputShortcut = FCogImGuiKeyInfo(EKeys::F1);
UPROPERTY(Config)
FCogImGuiKeyInfo ToggleSelectionShortcut = FCogImGuiKeyInfo(EKeys::F5);
@@ -114,10 +117,13 @@ public:
bShareMouse = false;
bShareKeyboard = false;
bNavEnableKeyboard = false;
bDisableConflictingCommands = true;
bDisableShortcutsWhenImGuiWantTextInput = false;
//bNavEnableGamepad = false;
//bNavNoCaptureInput = true;
ToggleImguiInputShortcut = FCogImGuiKeyInfo(EKeys::F1);
ToggleImGuiInputShortcut = FCogImGuiKeyInfo(EKeys::F1);
ToggleSelectionShortcut = FCogImGuiKeyInfo(EKeys::F5);
LoadLayoutShortcuts = { FCogImGuiKeyInfo(EKeys::F2), FCogImGuiKeyInfo(EKeys::F3), FCogImGuiKeyInfo(EKeys::F4), FCogImGuiKeyInfo()};
SaveLayoutShortcuts = { FCogImGuiKeyInfo(), FCogImGuiKeyInfo(), FCogImGuiKeyInfo(), FCogImGuiKeyInfo()};
Plugins/CogCommonUI/CogCommonUI.uplugin
+34
View File
@@ -0,0 +1,34 @@
{
"FileVersion": 1,
"Version": 1,
"VersionName": "1.0",
"FriendlyName": "CogCommonUI",
"Description": "",
"Category": "Other",
"CreatedBy": "Arnaud Jamin",
"CreatedByURL": "",
"DocsURL": "",
"MarketplaceURL": "",
"SupportURL": "",
"CanContainContent": false,
"IsBetaVersion": false,
"IsExperimentalVersion": false,
"Installed": false,
"Modules": [
{
"Name": "CogCommonUI",
"Type": "Runtime",
"LoadingPhase": "Default"
}
],
"Plugins": [
{
"Name": "Cog",
"Enabled": true
},
{
"Name": "CommonUI",
"Enabled": true
}
]
}
Plugins/CogCommonUI/Source/CogCommonUI/CogCommonUI.Build.cs
+50
View File
@@ -0,0 +1,50 @@
using UnrealBuildTool;
public class CogCommonUI : ModuleRules
{
public CogCommonUI(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CogCommon",
"CogImgui",
"CogDebug",
"CogWindow",
"CommonUI",
"InputCore",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
}
}
Plugins/CogCommonUI/Source/CogCommonUI/Private/CogCommonUIModule.cpp
+17
View File
@@ -0,0 +1,17 @@
#include "CogCommonUIModule.h"
#define LOCTEXT_NAMESPACE "FCogCommonUIModule"
//--------------------------------------------------------------------------------------------------------------------------
void FCogCommonUIModule::StartupModule()
{
}
//--------------------------------------------------------------------------------------------------------------------------
void FCogCommonUIModule::ShutdownModule()
{
}
#undef LOCTEXT_NAMESPACE
IMPLEMENT_MODULE(FCogCommonUIModule, CogCommonUI)
Plugins/CogCommonUI/Source/CogCommonUI/Private/CogCommonUI_ActionRouter.cpp
+15
View File
@@ -0,0 +1,15 @@
#include "CogCommonUI_ActionRouter.h"
#include "CogImguiInputHelper.h"
ERouteUIInputResult UCogCommonUI_ActionRouter::ProcessInput(FKey Key, EInputEvent InputEvent) const
{
UWorld* World = GetWorld();
if (FCogImguiInputHelper::IsTopPriorityKey(World, Key))
{
return ERouteUIInputResult::Unhandled;
}
return UCommonUIActionRouterBase::ProcessInput(Key, InputEvent);
}
Plugins/CogCommonUI/Source/CogCommonUI/Public/CogCommonUIModule.h
+20
View File
@@ -0,0 +1,20 @@
#pragma once
#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"
class COGCOMMONUI_API FCogCommonUIModule : public IModuleInterface
{
public:
static inline FCogCommonUIModule& Get()
{
return FModuleManager::LoadModuleChecked<FCogCommonUIModule>("CogCommonUI");
}
/** IModuleInterface implementation */
virtual void StartupModule() override;
virtual void ShutdownModule() override;
private:
};
Plugins/CogCommonUI/Source/CogCommonUI/Public/CogCommonUI_ActionRouter.h
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "CoreMinimal.h"
#include "Input/CommonUIActionRouterBase.h"
#include "CogCommonUI_ActionRouter.generated.h"
UCLASS()
class COGCOMMONUI_API UCogCommonUI_ActionRouter : public UCommonUIActionRouterBase
{
GENERATED_BODY()
virtual ERouteUIInputResult ProcessInput(FKey Key, EInputEvent InputEvent) const override;
};