1491 lines
49 KiB
C++
1491 lines
49 KiB
C++
// Menu Clavier. Voir LPKeyboardSubsystem.h.
|
||
|
||
#include "LPKeyboardSubsystem.h"
|
||
|
||
#include "Components/Button.h"
|
||
#include "Components/ScrollBox.h"
|
||
#include "Components/ScrollBoxSlot.h"
|
||
#include "Components/TextBlock.h"
|
||
#include "Engine/GameInstance.h"
|
||
#include "Engine/GameViewportClient.h"
|
||
#include "Engine/World.h"
|
||
#include "Framework/Application/IInputProcessor.h"
|
||
#include "Framework/Application/SlateApplication.h"
|
||
#include "GameFramework/InputSettings.h"
|
||
#include "GameFramework/PlayerController.h"
|
||
#include "GameFramework/PlayerInput.h"
|
||
#include "HAL/FileManager.h"
|
||
#include "LifePlay.h"
|
||
#include "Misc/ConfigCacheIni.h"
|
||
#include "Misc/FileHelper.h"
|
||
#include "Misc/Paths.h"
|
||
#include "Styling/CoreStyle.h"
|
||
#include "Widgets/Input/SButton.h"
|
||
#include "Widgets/Input/SComboBox.h"
|
||
#include "Widgets/Layout/SBorder.h"
|
||
#include "Widgets/Layout/SBox.h"
|
||
#include "Widgets/Layout/SScrollBox.h"
|
||
#include "Widgets/SBoxPanel.h"
|
||
#include "Widgets/Text/STextBlock.h"
|
||
|
||
namespace
|
||
{
|
||
const FName ButtonName(TEXT("LPKeyboardRow"));
|
||
const TCHAR* InputSection = TEXT("/Script/Engine.InputSettings");
|
||
|
||
// KEY2 (KEY2-SPEC-01 § 4, § 5) : section [LPKeyboard] de LPKeyboard.ini et prereglages de disposition.
|
||
const TCHAR* KbSection = TEXT("LPKeyboard");
|
||
const TCHAR* KbLayoutQwerty = TEXT("QWERTY");
|
||
const TCHAR* KbLayoutAzerty = TEXT("AZERTY");
|
||
const TCHAR* KbLayoutCustom = TEXT("Custom");
|
||
const int32 KbVersion = 2;
|
||
const FName KbMoveForward(TEXT("MoveForward"));
|
||
const FName KbMoveRight(TEXT("MoveRight"));
|
||
const FName KbActionPanel(TEXT("ActionPanel"));
|
||
const FName KbCameraHeight(TEXT("CameraHeight"));
|
||
const FName KbCoupleMoveY(TEXT("CoupleMoveY"));
|
||
// KEY2-SPEC-02 : rangs des sections Map & World et Couple (scene) ; l'option « Move couple with » ouvre Couple.
|
||
const int32 KbMapOrder = 3;
|
||
const int32 KbCoupleOrder = 4;
|
||
|
||
bool KbIsMoveGroup(FName Name)
|
||
{
|
||
return Name == KbMoveForward || Name == KbMoveRight;
|
||
}
|
||
|
||
// Prereglage exclusif (§ 4) : QWERTY = W S A D et ActionPanel Q ; AZERTY = Z S Q D et ActionPanel A.
|
||
void KbLayoutPreset(bool bAzerty, TArray<FInputAxisKeyMapping>& Axes, FInputActionKeyMapping& Action)
|
||
{
|
||
Axes.Reset();
|
||
Axes.Add(FInputAxisKeyMapping(KbMoveForward, bAzerty ? EKeys::Z : EKeys::W, 1.f));
|
||
Axes.Add(FInputAxisKeyMapping(KbMoveForward, EKeys::S, -1.f));
|
||
Axes.Add(FInputAxisKeyMapping(KbMoveRight, bAzerty ? EKeys::Q : EKeys::A, -1.f));
|
||
Axes.Add(FInputAxisKeyMapping(KbMoveRight, EKeys::D, 1.f));
|
||
Action = FInputActionKeyMapping(KbActionPanel, bAzerty ? EKeys::A : EKeys::Q);
|
||
}
|
||
|
||
// Touches lues en dur par PC (KEY1-CART-01 § 12.2) : acceptees, avec un avertissement (§ 7, 5).
|
||
bool KbGameReadKey(const FKey& Key)
|
||
{
|
||
return Key == EKeys::LeftShift || Key == EKeys::RightShift || Key == EKeys::LeftControl || Key == EKeys::RightControl
|
||
|| Key == EKeys::F12 || Key == EKeys::PageDown || Key == EKeys::Y || Key == EKeys::N
|
||
|| Key == EKeys::LeftMouseButton || Key == EKeys::RightMouseButton;
|
||
}
|
||
|
||
FString KeyboardIniPath()
|
||
{
|
||
return FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("Config/Windows/LPKeyboard.ini"));
|
||
}
|
||
|
||
FString ExportAction(const FInputActionKeyMapping& Map)
|
||
{
|
||
FString Text;
|
||
FInputActionKeyMapping::StaticStruct()->ExportText(Text, &Map, nullptr, nullptr, PPF_None, nullptr);
|
||
return Text;
|
||
}
|
||
|
||
FString ExportAxis(const FInputAxisKeyMapping& Map)
|
||
{
|
||
FString Text;
|
||
FInputAxisKeyMapping::StaticStruct()->ExportText(Text, &Map, nullptr, nullptr, PPF_None, nullptr);
|
||
return Text;
|
||
}
|
||
|
||
struct FBindRow
|
||
{
|
||
FName Name;
|
||
FString Label;
|
||
bool bAxis = false;
|
||
float Scale = 0.f;
|
||
FKey Key;
|
||
bool bShift = false;
|
||
bool bCtrl = false;
|
||
bool bAlt = false;
|
||
bool bCmd = false;
|
||
// KEY2-SPEC-02 : section d'affichage (une fleche apparait dans Map & World et dans Couple, meme liaison).
|
||
int32 Section = 0;
|
||
};
|
||
|
||
struct FLiveKeyboard
|
||
{
|
||
TWeakObjectPtr<ULPKeyboardSubsystem> Owner;
|
||
TSharedPtr<class SLPKeyboardMenu> Menu;
|
||
TSharedPtr<IInputProcessor> Processor;
|
||
bool bEmbedded = false;
|
||
};
|
||
|
||
bool IsRemappable(const FKey& Key)
|
||
{
|
||
return Key.IsValid() && !Key.IsAnalog() && !Key.IsAxis1D() && !Key.IsGamepadKey();
|
||
}
|
||
|
||
FString ActionLabel(FName Name)
|
||
{
|
||
static const TCHAR* Known[][2] = {
|
||
{TEXT("Pause"), TEXT("Pause")},
|
||
{TEXT("Journal"), TEXT("Journal")},
|
||
{TEXT("Inventory"), TEXT("Inventory")},
|
||
{TEXT("MainMenu"), TEXT("Main Menu")},
|
||
{TEXT("CharacterMenu"), TEXT("Character Menu")},
|
||
{TEXT("ModuleMenu"), TEXT("Modules")},
|
||
{TEXT("CityMenu"), TEXT("City")},
|
||
{TEXT("StatMenu"), TEXT("Statistics")},
|
||
{TEXT("ContactsMenu"), TEXT("Contacts")},
|
||
{TEXT("RotateCamera"), TEXT("Rotate Camera")},
|
||
{TEXT("ManualAnimating"), TEXT("Manual Animation")},
|
||
{TEXT("SpeedUp"), TEXT("Speed Up")},
|
||
{TEXT("SpeedDown"), TEXT("Slow Down")},
|
||
{TEXT("SwapRoles"), TEXT("Swap Roles")},
|
||
{TEXT("SwitchCamera"), TEXT("Switch Camera")},
|
||
{TEXT("NextBuilding"), TEXT("Next Building")},
|
||
{TEXT("PreviousBuilding"), TEXT("Previous Building")},
|
||
{TEXT("TestScenes"), TEXT("Test Scenes")},
|
||
{TEXT("Recommended"), TEXT("Recommended")},
|
||
{TEXT("QuickSave"), TEXT("Quick Save")},
|
||
{TEXT("Quickload"), TEXT("Quick Load")},
|
||
{TEXT("SearchBarToggle"), TEXT("Search")},
|
||
{TEXT("Interact"), TEXT("Interact")},
|
||
{TEXT("ActionPanel"), TEXT("Action Panel (also Alt / middle click)")},
|
||
};
|
||
const FString Raw = Name.ToString();
|
||
for (int32 Index = 0; Index < UE_ARRAY_COUNT(Known); ++Index)
|
||
{
|
||
if (Raw == Known[Index][0])
|
||
{
|
||
return Known[Index][1];
|
||
}
|
||
}
|
||
if (Raw.StartsWith(TEXT("Favorite")))
|
||
{
|
||
return TEXT("Favorite ") + Raw.RightChop(8);
|
||
}
|
||
return Raw;
|
||
}
|
||
|
||
FString AxisLabel(FName Name, float Scale)
|
||
{
|
||
const bool bPositive = Scale >= 0.f;
|
||
// KEY2-SUITE-LB (CAM2-SPEC-02 § 7) : hors scene, la vue de dessus ; en scene, le couple.
|
||
if (Name == TEXT("LeftRight"))
|
||
{
|
||
return bPositive ? TEXT("Right (map view / couple)") : TEXT("Left (map view / couple)");
|
||
}
|
||
if (Name == TEXT("DownUp"))
|
||
{
|
||
return bPositive ? TEXT("Forward (map view / couple)") : TEXT("Back (map view / couple)");
|
||
}
|
||
if (Name == TEXT("MoveForward"))
|
||
{
|
||
return bPositive ? TEXT("Walk Forward") : TEXT("Walk Back");
|
||
}
|
||
if (Name == TEXT("MoveRight"))
|
||
{
|
||
return bPositive ? TEXT("Walk Right") : TEXT("Walk Left");
|
||
}
|
||
if (Name == TEXT("PenisRotation"))
|
||
{
|
||
return bPositive ? TEXT("Rotation +") : TEXT("Rotation −");
|
||
}
|
||
if (Name == KbCameraHeight)
|
||
{
|
||
return bPositive ? TEXT("Camera Height Up (scene)") : TEXT("Camera Height Down (scene)");
|
||
}
|
||
if (Name == KbCoupleMoveY)
|
||
{
|
||
// KEY2-SUITE-LB (option N1) : V / X montent et baissent le couple ; le nom interne CoupleMoveY est garde.
|
||
return bPositive ? TEXT("Couple Up") : TEXT("Couple Down");
|
||
}
|
||
return Name.ToString() + (bPositive ? TEXT(" +") : TEXT(" −"));
|
||
}
|
||
|
||
struct FBindGroup
|
||
{
|
||
int32 Order = 9;
|
||
const TCHAR* Title = TEXT("Other");
|
||
};
|
||
|
||
FBindGroup GroupFor(FName Name)
|
||
{
|
||
// KEY2-SPEC-02 (decision « regroupement des touches ok ») : 9 sections par fonctionnalite. Les fleches (LeftRight,
|
||
// DownUp) sont rangees dans Couple ; Rebuild en ajoute une copie dans Map & World (meme liaison).
|
||
const FString Raw = Name.ToString();
|
||
if (Name == KbMoveForward || Name == KbMoveRight)
|
||
{
|
||
return {1, TEXT("Movement")};
|
||
}
|
||
if (Name == TEXT("SwitchCamera") || Name == TEXT("RotateCamera") || Name == TEXT("ScrollDownUp") || Name == KbCameraHeight)
|
||
{
|
||
return {2, TEXT("Camera")};
|
||
}
|
||
if (Name == TEXT("NextBuilding") || Name == TEXT("PreviousBuilding"))
|
||
{
|
||
return {KbMapOrder, TEXT("Map & World")};
|
||
}
|
||
if (Name == KbCoupleMoveY || Name == TEXT("LeftRight") || Name == TEXT("DownUp") || Name == TEXT("ManualAnimating")
|
||
|| Name == TEXT("PenisRotation"))
|
||
{
|
||
return {KbCoupleOrder, TEXT("Couple (scene)")};
|
||
}
|
||
if (Name == TEXT("Interact") || Name == KbActionPanel || Name == TEXT("SwapRoles") || Name == TEXT("Recommended"))
|
||
{
|
||
return {5, TEXT("Actions & Interaction")};
|
||
}
|
||
if (Name == TEXT("Journal") || Name == TEXT("Inventory") || Name == TEXT("MainMenu") || Name == TEXT("CharacterMenu")
|
||
|| Name == TEXT("ModuleMenu") || Name == TEXT("CityMenu") || Name == TEXT("StatMenu") || Name == TEXT("ContactsMenu")
|
||
|| Name == TEXT("SearchBarToggle"))
|
||
{
|
||
return {6, TEXT("Menus")};
|
||
}
|
||
if (Name == TEXT("Pause") || Name == TEXT("SpeedUp") || Name == TEXT("SpeedDown"))
|
||
{
|
||
return {7, TEXT("Time")};
|
||
}
|
||
if (Raw.StartsWith(TEXT("Favorite")))
|
||
{
|
||
return {8, TEXT("Favorites")};
|
||
}
|
||
if (Name == TEXT("QuickSave") || Name == TEXT("Quickload") || Name == TEXT("TestScenes"))
|
||
{
|
||
return {9, TEXT("System")};
|
||
}
|
||
return {10, TEXT("Other")};
|
||
}
|
||
|
||
// KEY2-SPEC-02 (option A) : libelle d'une fleche selon sa section, vue de dessus ou couple.
|
||
FString KbArrowLabel(FName Name, float Scale, bool bMap)
|
||
{
|
||
const bool bPositive = Scale >= 0.f;
|
||
const FString Prefix = bMap ? TEXT("Map ") : TEXT("Couple ");
|
||
if (Name == TEXT("LeftRight"))
|
||
{
|
||
return Prefix + (bPositive ? TEXT("Right") : TEXT("Left"));
|
||
}
|
||
return Prefix + (bPositive ? TEXT("Forward") : TEXT("Back"));
|
||
}
|
||
|
||
FString ChordText(const FKey& Key, bool bShift, bool bCtrl, bool bAlt, bool bCmd)
|
||
{
|
||
FString Text;
|
||
if (bCtrl)
|
||
{
|
||
Text += TEXT("Ctrl+");
|
||
}
|
||
if (bShift)
|
||
{
|
||
Text += TEXT("Shift+");
|
||
}
|
||
if (bAlt)
|
||
{
|
||
Text += TEXT("Alt+");
|
||
}
|
||
if (bCmd)
|
||
{
|
||
Text += TEXT("Cmd+");
|
||
}
|
||
Text += Key.GetDisplayName().ToString();
|
||
return Text;
|
||
}
|
||
|
||
// KEY2 : ligne sans touche (avec Add) si l'action, ou l'axe de ce signe, n'a aucune liaison affichee.
|
||
void KbAddMissing(TArray<FBindRow>& Binds, FName Name, bool bAxis, float Scale)
|
||
{
|
||
for (const FBindRow& Existing : Binds)
|
||
{
|
||
if (Existing.Name == Name && Existing.bAxis == bAxis && (!bAxis || (Existing.Scale >= 0.f) == (Scale >= 0.f)))
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
FBindRow Missing;
|
||
Missing.Name = Name;
|
||
Missing.Label = bAxis ? AxisLabel(Name, Scale) : ActionLabel(Name);
|
||
Missing.bAxis = bAxis;
|
||
Missing.Scale = Scale;
|
||
Binds.Add(Missing);
|
||
}
|
||
|
||
TSharedRef<STextBlock> MakeText(const FString& Value, int32 Size, const FLinearColor& Color)
|
||
{
|
||
FSlateFontInfo Font = FCoreStyle::GetDefaultFontStyle("Regular", Size);
|
||
Font.OutlineSettings.OutlineSize = 2;
|
||
Font.OutlineSettings.bApplyOutlineToDropShadows = true;
|
||
Font.OutlineSettings.OutlineColor = FLinearColor(0.f, 0.f, 0.f, 0.8f);
|
||
return SNew(STextBlock)
|
||
.Text(FText::FromString(Value))
|
||
.Font(Font)
|
||
.ColorAndOpacity(FSlateColor(Color));
|
||
}
|
||
|
||
class SLPKeyboardMenu : public SCompoundWidget
|
||
{
|
||
public:
|
||
SLATE_BEGIN_ARGS(SLPKeyboardMenu) {}
|
||
SLATE_ARGUMENT(bool, bEmbedded)
|
||
SLATE_END_ARGS()
|
||
|
||
void Construct(const FArguments& InArgs, ULPKeyboardSubsystem* InOwner)
|
||
{
|
||
Owner = InOwner;
|
||
bEmbedded = InArgs._bEmbedded;
|
||
// KEY2 (§ 4) : liste des dispositions, la disposition enregistree choisie au depart.
|
||
LayoutOptions.Add(MakeShared<FString>(KbLayoutQwerty));
|
||
LayoutOptions.Add(MakeShared<FString>(KbLayoutAzerty));
|
||
SelectedLayout = (InOwner && InOwner->GetLayout() == KbLayoutAzerty) ? LayoutOptions[1] : LayoutOptions[0];
|
||
ChildSlot
|
||
[
|
||
SNew(SBox)
|
||
.HAlign(bEmbedded ? HAlign_Fill : HAlign_Center)
|
||
.VAlign(bEmbedded ? VAlign_Fill : VAlign_Center)
|
||
[
|
||
SNew(SBorder)
|
||
.BorderImage(bEmbedded ? FCoreStyle::Get().GetBrush("NoBrush") : FCoreStyle::Get().GetBrush("ToolPanel.GroupBorder"))
|
||
.Padding(bEmbedded ? 0.f : 16.f)
|
||
[
|
||
SNew(SBox)
|
||
.WidthOverride(bEmbedded ? FOptionalSize() : FOptionalSize(560.f))
|
||
.HeightOverride(bEmbedded ? FOptionalSize() : FOptionalSize(640.f))
|
||
[
|
||
SNew(SVerticalBox)
|
||
+ SVerticalBox::Slot().AutoHeight().Padding(0.f, 0.f, 0.f, 8.f)
|
||
[
|
||
SNew(STextBlock)
|
||
.Text(FText::FromString(TEXT("Change a key, add one, or remove one. Escape cancels the capture. Saved for this version of the game.")))
|
||
.AutoWrapText(true)
|
||
.Font(MakeText(TEXT(""), 16, FLinearColor::White)->GetFont())
|
||
.ColorAndOpacity(FSlateColor(FLinearColor(1.f, 1.f, 1.f, 0.95f)))
|
||
]
|
||
// KEY2 (§ 4) : disposition (QWERTY, AZERTY), bouton Apply et disposition en cours.
|
||
+ SVerticalBox::Slot().AutoHeight().Padding(0.f, 0.f, 0.f, 8.f)
|
||
[
|
||
SNew(SHorizontalBox)
|
||
+ SHorizontalBox::Slot().AutoWidth().VAlign(VAlign_Center).Padding(0.f, 0.f, 8.f, 0.f)
|
||
[
|
||
SNew(SComboBox<TSharedPtr<FString>>)
|
||
.OptionsSource(&LayoutOptions)
|
||
.InitiallySelectedItem(SelectedLayout)
|
||
.OnGenerateWidget_Lambda([](TSharedPtr<FString> Item) -> TSharedRef<SWidget>
|
||
{
|
||
return MakeText(Item.IsValid() ? *Item : FString(), 16, FLinearColor::White);
|
||
})
|
||
.OnSelectionChanged_Lambda([this](TSharedPtr<FString> Item, ESelectInfo::Type)
|
||
{
|
||
if (Item.IsValid())
|
||
{
|
||
SelectedLayout = Item;
|
||
}
|
||
})
|
||
[
|
||
SNew(STextBlock)
|
||
.Text_Lambda([this]() { return FText::FromString(SelectedLayout.IsValid() ? *SelectedLayout : FString()); })
|
||
.Font(MakeText(TEXT(""), 16, FLinearColor::White)->GetFont())
|
||
]
|
||
]
|
||
+ SHorizontalBox::Slot().AutoWidth().VAlign(VAlign_Center).Padding(0.f, 0.f, 8.f, 0.f)
|
||
[
|
||
SNew(SButton)
|
||
.OnClicked(this, &SLPKeyboardMenu::OnApplyLayout)
|
||
[
|
||
MakeText(TEXT("Apply"), 16, FLinearColor::White)
|
||
]
|
||
]
|
||
+ SHorizontalBox::Slot().FillWidth(1.f).VAlign(VAlign_Center)
|
||
[
|
||
SAssignNew(LayoutBlock, STextBlock)
|
||
.Font(MakeText(TEXT(""), 16, FLinearColor::White)->GetFont())
|
||
.ColorAndOpacity(FSlateColor(FLinearColor(0.85f, 0.9f, 1.f)))
|
||
]
|
||
]
|
||
+ SVerticalBox::Slot().FillHeight(1.f)
|
||
[
|
||
SNew(SScrollBox)
|
||
+ SScrollBox::Slot()
|
||
[
|
||
SAssignNew(Rows, SVerticalBox)
|
||
]
|
||
]
|
||
+ SVerticalBox::Slot().AutoHeight().Padding(0.f, 8.f, 0.f, 8.f)
|
||
[
|
||
SAssignNew(StatusBlock, STextBlock)
|
||
.AutoWrapText(true)
|
||
.Font(MakeText(TEXT(""), 16, FLinearColor::White)->GetFont())
|
||
.ColorAndOpacity(FSlateColor(FLinearColor(0.95f, 0.85f, 0.4f)))
|
||
]
|
||
+ SVerticalBox::Slot().AutoHeight()
|
||
[
|
||
SNew(SHorizontalBox)
|
||
+ SHorizontalBox::Slot().FillWidth(1.f).Padding(0.f, 0.f, 8.f, 0.f)
|
||
[
|
||
SNew(SButton)
|
||
.OnClicked(this, &SLPKeyboardMenu::OnReset)
|
||
[
|
||
MakeText(TEXT("Reset"), 20, FLinearColor::White)
|
||
]
|
||
]
|
||
+ SHorizontalBox::Slot().FillWidth(1.f)
|
||
[
|
||
SNew(SButton)
|
||
.Visibility(bEmbedded ? EVisibility::Collapsed : EVisibility::Visible)
|
||
.OnClicked(this, &SLPKeyboardMenu::OnClose)
|
||
[
|
||
MakeText(TEXT("Close"), 20, FLinearColor::White)
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
];
|
||
Rebuild();
|
||
}
|
||
|
||
void Rebuild()
|
||
{
|
||
if (!Rows.IsValid())
|
||
{
|
||
return;
|
||
}
|
||
Rows->ClearChildren();
|
||
ULPKeyboardSubsystem* Sub = Owner.Get();
|
||
const UInputSettings* Settings = UInputSettings::GetInputSettings();
|
||
if (!Sub || !Settings)
|
||
{
|
||
return;
|
||
}
|
||
TArray<FBindRow> Binds;
|
||
for (const FInputActionKeyMapping& Map : Settings->GetActionMappings())
|
||
{
|
||
if (!IsRemappable(Map.Key))
|
||
{
|
||
continue;
|
||
}
|
||
FBindRow Row;
|
||
Row.Name = Map.ActionName;
|
||
Row.Label = ActionLabel(Map.ActionName);
|
||
Row.Key = Map.Key;
|
||
Row.bShift = Map.bShift;
|
||
Row.bCtrl = Map.bCtrl;
|
||
Row.bAlt = Map.bAlt;
|
||
Row.bCmd = Map.bCmd;
|
||
Binds.Add(Row);
|
||
}
|
||
for (const FInputAxisKeyMapping& Map : Settings->GetAxisMappings())
|
||
{
|
||
if (!IsRemappable(Map.Key))
|
||
{
|
||
continue;
|
||
}
|
||
FBindRow Row;
|
||
Row.Name = Map.AxisName;
|
||
Row.Label = AxisLabel(Map.AxisName, Map.Scale);
|
||
Row.bAxis = true;
|
||
Row.Scale = Map.Scale;
|
||
Row.Key = Map.Key;
|
||
Binds.Add(Row);
|
||
}
|
||
// KEY2 : entrees de la section Scene sans touche (fichier d'avant KEY2) : ligne vide avec Add.
|
||
KbAddMissing(Binds, KbActionPanel, false, 0.f);
|
||
KbAddMissing(Binds, KbCameraHeight, true, 1.f);
|
||
KbAddMissing(Binds, KbCameraHeight, true, -1.f);
|
||
KbAddMissing(Binds, KbCoupleMoveY, true, 1.f);
|
||
KbAddMissing(Binds, KbCoupleMoveY, true, -1.f);
|
||
// KEY2-SPEC-02 (option A) : section de chaque ligne ; une fleche apparait aussi dans Map & World (meme liaison :
|
||
// Change ou Remove dans l'une agit sur l'autre, le menu se redessine depuis les reglages).
|
||
TArray<FBindRow> MapRows;
|
||
for (FBindRow& Row : Binds)
|
||
{
|
||
Row.Section = GroupFor(Row.Name).Order;
|
||
if (Row.bAxis && (Row.Name == TEXT("LeftRight") || Row.Name == TEXT("DownUp")))
|
||
{
|
||
Row.Label = KbArrowLabel(Row.Name, Row.Scale, false);
|
||
FBindRow MapRow = Row;
|
||
MapRow.Section = KbMapOrder;
|
||
MapRow.Label = KbArrowLabel(Row.Name, Row.Scale, true);
|
||
MapRows.Add(MapRow);
|
||
}
|
||
}
|
||
Binds.Append(MapRows);
|
||
Binds.Sort([](const FBindRow& A, const FBindRow& B)
|
||
{
|
||
if (A.Section != B.Section)
|
||
{
|
||
return A.Section < B.Section;
|
||
}
|
||
if (A.Label != B.Label)
|
||
{
|
||
return A.Label < B.Label;
|
||
}
|
||
return A.Key.GetDisplayName().ToString() < B.Key.GetDisplayName().ToString();
|
||
});
|
||
|
||
int32 PreviousGroup = INDEX_NONE;
|
||
FString Previous;
|
||
for (const FBindRow& Row : Binds)
|
||
{
|
||
if (Row.Section != PreviousGroup)
|
||
{
|
||
PreviousGroup = Row.Section;
|
||
Previous.Reset();
|
||
const FBindGroup Section = Row.Section == KbMapOrder ? FBindGroup{KbMapOrder, TEXT("Map & World")} : GroupFor(Row.Name);
|
||
Rows->AddSlot().AutoHeight().Padding(0.f, 12.f, 0.f, 4.f)
|
||
[
|
||
MakeText(Section.Title, 20, FLinearColor(1.f, 0.92f, 0.45f))
|
||
];
|
||
// KEY2-SPEC-02 : l'option « Move couple with » ouvre la section Couple (scene).
|
||
if (Row.Section == KbCoupleOrder)
|
||
{
|
||
AddCoupleDragRow(Sub);
|
||
}
|
||
}
|
||
if (Row.Label != Previous)
|
||
{
|
||
Previous = Row.Label;
|
||
const FBindRow Group = Row;
|
||
Rows->AddSlot().AutoHeight().Padding(0.f, 10.f, 0.f, 2.f)
|
||
[
|
||
SNew(SHorizontalBox)
|
||
+ SHorizontalBox::Slot().FillWidth(1.f).VAlign(VAlign_Center)
|
||
[
|
||
MakeText(Row.Label, 20, FLinearColor(1.f, 1.f, 1.f, 0.95f))
|
||
]
|
||
+ SHorizontalBox::Slot().AutoWidth()
|
||
[
|
||
SNew(SButton)
|
||
.OnClicked_Lambda([this, Group]()
|
||
{
|
||
if (ULPKeyboardSubsystem* Sub = Owner.Get())
|
||
{
|
||
Sub->BeginWait(Group.Name, Group.bAxis, Group.Scale, EKeys::Invalid, false, false, false, false, true);
|
||
Sub->RefreshMenu();
|
||
}
|
||
return FReply::Handled();
|
||
})
|
||
[
|
||
MakeText(TEXT("Add"), 16, FLinearColor::White)
|
||
]
|
||
]
|
||
];
|
||
}
|
||
if (!Row.Key.IsValid())
|
||
{
|
||
// KEY2 : entree sans touche (KbAddMissing) : seul Add est propose.
|
||
Rows->AddSlot().AutoHeight().Padding(12.f, 2.f, 0.f, 2.f)
|
||
[
|
||
MakeText(TEXT("(no key)"), 16, FLinearColor(0.85f, 0.9f, 1.f, 0.6f))
|
||
];
|
||
continue;
|
||
}
|
||
const FBindRow Current = Row;
|
||
Rows->AddSlot().AutoHeight().Padding(12.f, 2.f, 0.f, 2.f)
|
||
[
|
||
SNew(SHorizontalBox)
|
||
+ SHorizontalBox::Slot().FillWidth(1.f).VAlign(VAlign_Center)
|
||
[
|
||
MakeText(ChordText(Current.Key, Current.bShift, Current.bCtrl, Current.bAlt, Current.bCmd), 16, FLinearColor(0.85f, 0.9f, 1.f))
|
||
]
|
||
+ SHorizontalBox::Slot().AutoWidth().Padding(4.f, 0.f)
|
||
[
|
||
SNew(SButton)
|
||
.OnClicked_Lambda([this, Current]()
|
||
{
|
||
if (ULPKeyboardSubsystem* Sub = Owner.Get())
|
||
{
|
||
Sub->BeginWait(Current.Name, Current.bAxis, Current.Scale, Current.Key, Current.bShift, Current.bCtrl, Current.bAlt, Current.bCmd, false);
|
||
Sub->RefreshMenu();
|
||
}
|
||
return FReply::Handled();
|
||
})
|
||
[
|
||
MakeText(TEXT("Change"), 16, FLinearColor::White)
|
||
]
|
||
]
|
||
+ SHorizontalBox::Slot().AutoWidth()
|
||
[
|
||
SNew(SButton)
|
||
.OnClicked_Lambda([this, Current]()
|
||
{
|
||
if (ULPKeyboardSubsystem* Sub = Owner.Get())
|
||
{
|
||
Sub->RemoveBinding(Current.Name, Current.bAxis, Current.Scale, Current.Key, Current.bShift, Current.bCtrl, Current.bAlt, Current.bCmd);
|
||
}
|
||
return FReply::Handled();
|
||
})
|
||
[
|
||
MakeText(TEXT("Remove"), 16, FLinearColor::White)
|
||
]
|
||
]
|
||
];
|
||
}
|
||
if (LayoutBlock.IsValid() && Sub)
|
||
{
|
||
// KEY2 (§ 4) : « Layout: QWERTY », « Layout: AZERTY » ou « Layout: custom ».
|
||
const FString ShownLayout = Sub->GetLayout() == KbLayoutAzerty ? FString(TEXT("AZERTY"))
|
||
: Sub->GetLayout() == KbLayoutQwerty ? FString(TEXT("QWERTY")) : FString(TEXT("custom"));
|
||
LayoutBlock->SetText(FText::FromString(TEXT("Layout: ") + ShownLayout));
|
||
}
|
||
if (StatusBlock.IsValid() && Sub)
|
||
{
|
||
StatusBlock->SetText(FText::FromString(Sub->GetStatus()));
|
||
}
|
||
}
|
||
|
||
private:
|
||
FReply OnReset()
|
||
{
|
||
if (ULPKeyboardSubsystem* Sub = Owner.Get())
|
||
{
|
||
Sub->ResetToDefault();
|
||
}
|
||
return FReply::Handled();
|
||
}
|
||
|
||
FReply OnApplyLayout()
|
||
{
|
||
if (ULPKeyboardSubsystem* Sub = Owner.Get())
|
||
{
|
||
Sub->ApplyLayout(SelectedLayout.IsValid() ? *SelectedLayout : FString(KbLayoutQwerty));
|
||
}
|
||
return FReply::Handled();
|
||
}
|
||
|
||
// KEY2 (§ 8b) : option « Move couple with » (Mouse and arrows, Arrows only), en tete du bloc des personnages.
|
||
void AddCoupleDragRow(const ULPKeyboardSubsystem* Keys)
|
||
{
|
||
Rows->AddSlot().AutoHeight().Padding(0.f, 10.f, 0.f, 2.f)
|
||
[
|
||
SNew(SHorizontalBox)
|
||
+ SHorizontalBox::Slot().FillWidth(1.f).VAlign(VAlign_Center)
|
||
[
|
||
MakeText(TEXT("Move couple with"), 20, FLinearColor(1.f, 1.f, 1.f, 0.95f))
|
||
]
|
||
+ SHorizontalBox::Slot().AutoWidth()
|
||
[
|
||
SNew(SButton)
|
||
.OnClicked_Lambda([this]()
|
||
{
|
||
if (ULPKeyboardSubsystem* Owned = Owner.Get())
|
||
{
|
||
Owned->SetCoupleDragByKeys(!Owned->IsCoupleDragByKeys());
|
||
}
|
||
return FReply::Handled();
|
||
})
|
||
[
|
||
MakeText(Keys && Keys->IsCoupleDragByKeys() ? TEXT("Arrows only") : TEXT("Mouse and arrows"), 16, FLinearColor::White)
|
||
]
|
||
]
|
||
];
|
||
}
|
||
|
||
FReply OnClose()
|
||
{
|
||
if (ULPKeyboardSubsystem* Sub = Owner.Get())
|
||
{
|
||
Sub->CloseKeyboardMenu();
|
||
}
|
||
return FReply::Handled();
|
||
}
|
||
|
||
TWeakObjectPtr<ULPKeyboardSubsystem> Owner;
|
||
TSharedPtr<SVerticalBox> Rows;
|
||
TSharedPtr<STextBlock> StatusBlock;
|
||
bool bEmbedded = false;
|
||
/** KEY2 (§ 4) : options de la liste (QWERTY, AZERTY), choix en cours, texte de la disposition enregistree. */
|
||
TArray<TSharedPtr<FString>> LayoutOptions;
|
||
TSharedPtr<FString> SelectedLayout;
|
||
TSharedPtr<STextBlock> LayoutBlock;
|
||
};
|
||
|
||
FLiveKeyboard& Live()
|
||
{
|
||
static FLiveKeyboard State;
|
||
return State;
|
||
}
|
||
|
||
class FKeyboardProcessor : public IInputProcessor
|
||
{
|
||
public:
|
||
virtual void Tick(const float, FSlateApplication&, TSharedRef<ICursor>) override {}
|
||
|
||
virtual bool HandleKeyDownEvent(FSlateApplication&, const FKeyEvent& Event) override
|
||
{
|
||
ULPKeyboardSubsystem* Sub = Live().Owner.Get();
|
||
if (!Sub || !Live().Menu.IsValid())
|
||
{
|
||
return false;
|
||
}
|
||
const FKey Key = Event.GetKey();
|
||
if (Sub->IsWaiting())
|
||
{
|
||
if (Key == EKeys::Escape)
|
||
{
|
||
PendingModifier = EKeys::Invalid;
|
||
Sub->CancelWait();
|
||
}
|
||
else if (!Key.IsModifierKey())
|
||
{
|
||
PendingModifier = EKeys::Invalid;
|
||
Sub->CommitKey(Key, Event.IsShiftDown(), Event.IsControlDown(), Event.IsAltDown(), Event.IsCommandDown());
|
||
}
|
||
else if (!Event.IsRepeat())
|
||
{
|
||
// KEY2 (§ 7, 3) : modificateur seul, enregistre au relachement si rien d'autre n'est presse entre-temps.
|
||
bModifierAlone = !PendingModifier.IsValid();
|
||
PendingModifier = Key;
|
||
}
|
||
return true;
|
||
}
|
||
if (Live().bEmbedded)
|
||
{
|
||
return false;
|
||
}
|
||
if (Key == EKeys::Escape)
|
||
{
|
||
Sub->CloseKeyboardMenu();
|
||
return true;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
virtual bool HandleKeyUpEvent(FSlateApplication&, const FKeyEvent& Event) override
|
||
{
|
||
const FKey Key = Event.GetKey();
|
||
const bool bReleased = PendingModifier.IsValid() && Key == PendingModifier;
|
||
if (bReleased)
|
||
{
|
||
PendingModifier = EKeys::Invalid;
|
||
}
|
||
ULPKeyboardSubsystem* Sub = Live().Owner.Get();
|
||
if (!bReleased || !bModifierAlone || !Sub || !Live().Menu.IsValid() || !Sub->IsWaiting())
|
||
{
|
||
return false;
|
||
}
|
||
// KEY2 (§ 7, 3) : modificateur seul (ex. LeftControl de ManualAnimating), sans modificateur en plus.
|
||
Sub->CommitKey(Key, false, false, false, false);
|
||
return true;
|
||
}
|
||
|
||
virtual bool HandleMouseButtonDownEvent(FSlateApplication&, const FPointerEvent& Event) override
|
||
{
|
||
ULPKeyboardSubsystem* Sub = Live().Owner.Get();
|
||
if (!Sub || !Live().Menu.IsValid() || !Sub->IsWaiting())
|
||
{
|
||
return false;
|
||
}
|
||
// KEY2 (§ 7, 1) : boutons de souris pendant une capture ; clic gauche seulement avec un modificateur.
|
||
bModifierAlone = false;
|
||
const FKey Button = Event.GetEffectingButton();
|
||
const bool bModifier = Event.IsShiftDown() || Event.IsControlDown() || Event.IsAltDown() || Event.IsCommandDown();
|
||
if (Button == EKeys::LeftMouseButton && !bModifier)
|
||
{
|
||
Sub->RefuseLeftClick();
|
||
}
|
||
else if (Button == EKeys::LeftMouseButton || Button == EKeys::RightMouseButton || Button == EKeys::MiddleMouseButton
|
||
|| Button == EKeys::ThumbMouseButton || Button == EKeys::ThumbMouseButton2)
|
||
{
|
||
PendingModifier = EKeys::Invalid;
|
||
Sub->CommitKey(Button, Event.IsShiftDown(), Event.IsControlDown(), Event.IsAltDown(), Event.IsCommandDown());
|
||
}
|
||
return true;
|
||
}
|
||
|
||
virtual bool HandleMouseWheelOrGestureEvent(FSlateApplication&, const FPointerEvent& InWheelEvent, const FPointerEvent* InGestureEvent) override
|
||
{
|
||
ULPKeyboardSubsystem* Sub = Live().Owner.Get();
|
||
if (!Sub || !Live().Menu.IsValid() || !Sub->IsWaiting() || InGestureEvent || FMath::IsNearlyZero(InWheelEvent.GetWheelDelta()))
|
||
{
|
||
return false;
|
||
}
|
||
// KEY2 (§ 7, 2) : molette pour les actions seulement (les axes gardent MouseWheelAxis).
|
||
bModifierAlone = false;
|
||
PendingModifier = EKeys::Invalid;
|
||
Sub->CommitWheel(InWheelEvent.GetWheelDelta() > 0.f, InWheelEvent.IsShiftDown(), InWheelEvent.IsControlDown(),
|
||
InWheelEvent.IsAltDown(), InWheelEvent.IsCommandDown());
|
||
return true;
|
||
}
|
||
|
||
private:
|
||
/** KEY2 : modificateur tenu pendant la capture ; vrai tant qu'aucune autre touche ni bouton n'a ete presse. */
|
||
FKey PendingModifier;
|
||
bool bModifierAlone = false;
|
||
};
|
||
}
|
||
|
||
bool ULPKeyboardSubsystem::IsMenuOpen() const
|
||
{
|
||
// KEY2-DIAG-01 (COMMUN-15) : la page integree aux reglages reste valide apres leur fermeture ; elle ne compte comme
|
||
// menu que pendant une capture. Les reglages ouverts sont deja vus comme menu (MainMenu_C, MenuOnScreen).
|
||
return Live().Menu.IsValid() && Live().Owner.Get() == this && (!Live().bEmbedded || bWaiting);
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::Initialize(FSubsystemCollectionBase& Collection)
|
||
{
|
||
Super::Initialize(Collection);
|
||
if (!LoadSaved())
|
||
{
|
||
SaveSaved();
|
||
}
|
||
TickHandle = FTSTicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateUObject(this, &ULPKeyboardSubsystem::Tick), 0.5f);
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::Deinitialize()
|
||
{
|
||
if (Live().Owner.Get() == this)
|
||
{
|
||
CloseKeyboardMenu();
|
||
}
|
||
FTSTicker::GetCoreTicker().RemoveTicker(TickHandle);
|
||
Super::Deinitialize();
|
||
}
|
||
|
||
bool ULPKeyboardSubsystem::Tick(float DeltaTime)
|
||
{
|
||
(void)DeltaTime;
|
||
UGameInstance* GI = GetGameInstance();
|
||
bool bFound = false;
|
||
for (TObjectIterator<UScrollBox> It; It; ++It)
|
||
{
|
||
UScrollBox* Scroll = *It;
|
||
if (!Scroll || Scroll->GetFName() != TEXT("SettingsScrollBox") || Scroll->HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject))
|
||
{
|
||
continue;
|
||
}
|
||
const UUserWidget* Owner = Scroll->GetTypedOuter<UUserWidget>();
|
||
if (!Owner || Owner->HasAnyFlags(RF_ClassDefaultObject) || Owner->GetGameInstance() != GI)
|
||
{
|
||
continue;
|
||
}
|
||
bFound = true;
|
||
}
|
||
if (!bFound && !bLoggedMissing)
|
||
{
|
||
bLoggedMissing = true;
|
||
UE_LOG(LogLifePlay, Display, TEXT("Clavier : liste des reglages pas encore ouverte"));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::AttachButton(UScrollBox* Scroll)
|
||
{
|
||
for (int32 Index = 0; Index < Scroll->GetChildrenCount(); ++Index)
|
||
{
|
||
if (Scroll->GetChildAt(Index) && Scroll->GetChildAt(Index)->GetFName() == ButtonName)
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
UButton* Button = NewObject<UButton>(Scroll, ButtonName);
|
||
UTextBlock* Label = NewObject<UTextBlock>(Button, TEXT("LPKeyboardLabel"));
|
||
Label->SetText(FText::FromString(TEXT("Keyboard")));
|
||
Label->SetColorAndOpacity(FSlateColor(FLinearColor::White));
|
||
FSlateFontInfo Font = FCoreStyle::GetDefaultFontStyle("Regular", 16);
|
||
Label->SetFont(Font);
|
||
Button->SetContent(Label);
|
||
if (UScrollBoxSlot* Slot = Cast<UScrollBoxSlot>(Scroll->AddChild(Button)))
|
||
{
|
||
Slot->SetPadding(FMargin(0.f, 12.f, 0.f, 4.f));
|
||
Slot->SetHorizontalAlignment(HAlign_Fill);
|
||
}
|
||
Button->OnClicked.AddDynamic(this, &ULPKeyboardSubsystem::OpenKeyboardMenu);
|
||
UE_LOG(LogLifePlay, Display, TEXT("Clavier : bouton ajoute dans les reglages"));
|
||
}
|
||
|
||
TSharedRef<SWidget> ULPKeyboardSubsystem::TakeEmbeddedPage()
|
||
{
|
||
if (Live().Menu.IsValid() && Live().Owner.Get() == this)
|
||
{
|
||
return Live().Menu.ToSharedRef();
|
||
}
|
||
Status = IdleStatus();
|
||
bWaiting = false;
|
||
Live().bEmbedded = true;
|
||
TSharedRef<SLPKeyboardMenu> Panel = SNew(SLPKeyboardMenu, this).bEmbedded(true);
|
||
Live().Owner = this;
|
||
Live().Menu = Panel;
|
||
if (!Live().Processor.IsValid())
|
||
{
|
||
Live().Processor = MakeShared<FKeyboardProcessor>();
|
||
FSlateApplication::Get().RegisterInputPreProcessor(Live().Processor.ToSharedRef(), 0);
|
||
}
|
||
return Panel;
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::OpenKeyboardMenu()
|
||
{
|
||
if (Live().Menu.IsValid() || !FSlateApplication::IsInitialized() || !GEngine || !GEngine->GameViewport)
|
||
{
|
||
return;
|
||
}
|
||
Status = IdleStatus();
|
||
bWaiting = false;
|
||
Live().bEmbedded = false;
|
||
TSharedRef<SLPKeyboardMenu> Panel = SNew(SLPKeyboardMenu, this).bEmbedded(false);
|
||
Live().Owner = this;
|
||
Live().Menu = Panel;
|
||
Live().Processor = MakeShared<FKeyboardProcessor>();
|
||
GEngine->GameViewport->AddViewportWidgetContent(Panel, 200);
|
||
FSlateApplication::Get().RegisterInputPreProcessor(Live().Processor.ToSharedRef(), 0);
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::CloseKeyboardMenu()
|
||
{
|
||
if (Live().Owner.Get() != this && Live().Owner.IsValid())
|
||
{
|
||
return;
|
||
}
|
||
bWaiting = false;
|
||
if (Live().Processor.IsValid() && FSlateApplication::IsInitialized())
|
||
{
|
||
FSlateApplication::Get().UnregisterInputPreProcessor(Live().Processor.ToSharedRef());
|
||
}
|
||
if (Live().Menu.IsValid() && GEngine && GEngine->GameViewport)
|
||
{
|
||
GEngine->GameViewport->RemoveViewportWidgetContent(Live().Menu.ToSharedRef());
|
||
}
|
||
Live().Menu.Reset();
|
||
Live().Processor.Reset();
|
||
Live().Owner.Reset();
|
||
Live().bEmbedded = false;
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::BeginWait(FName Name, bool bAxis, float Scale, FKey OldKey, bool bShift, bool bCtrl, bool bAlt, bool bCmd, bool bAdd)
|
||
{
|
||
bWaiting = true;
|
||
bWaitAdd = bAdd;
|
||
bWaitAxis = bAxis;
|
||
WaitScale = Scale;
|
||
WaitName = Name;
|
||
WaitOldKey = OldKey;
|
||
bWaitShift = bShift;
|
||
bWaitCtrl = bCtrl;
|
||
bWaitAlt = bAlt;
|
||
bWaitCmd = bCmd;
|
||
Status = bAdd
|
||
? FString::Printf(TEXT("New key for %s. Escape cancels."), bAxis ? *AxisLabel(Name, Scale) : *ActionLabel(Name))
|
||
: FString::Printf(TEXT("Replaces %s. Escape cancels."), *OldKey.GetDisplayName().ToString());
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::CancelWait()
|
||
{
|
||
bWaiting = false;
|
||
Status = TEXT("Capture cancelled.");
|
||
RefreshMenu();
|
||
}
|
||
|
||
bool ULPKeyboardSubsystem::CommitKey(const FKey& Key, bool bShift, bool bCtrl, bool bAlt, bool bCmd)
|
||
{
|
||
bWaiting = false;
|
||
if (!IsRemappable(Key))
|
||
{
|
||
Status = TEXT("This key cannot be assigned.");
|
||
RefreshMenu();
|
||
return false;
|
||
}
|
||
UInputSettings* Settings = UInputSettings::GetInputSettings();
|
||
if (!Settings)
|
||
{
|
||
return false;
|
||
}
|
||
TArray<FString> Cleared;
|
||
if (!bWaitAdd && WaitOldKey.IsValid())
|
||
{
|
||
if (bWaitAxis)
|
||
{
|
||
Settings->RemoveAxisMapping(FInputAxisKeyMapping(WaitName, WaitOldKey, WaitScale), false);
|
||
}
|
||
else
|
||
{
|
||
Settings->RemoveActionMapping(FInputActionKeyMapping(WaitName, WaitOldKey, bWaitShift, bWaitCtrl, bWaitAlt, bWaitCmd), false);
|
||
}
|
||
}
|
||
const TArray<FInputActionKeyMapping> Actions = Settings->GetActionMappings();
|
||
for (const FInputActionKeyMapping& Map : Actions)
|
||
{
|
||
if (Map.Key == Key && Map.bShift == bShift && Map.bCtrl == bCtrl && Map.bAlt == bAlt && Map.bCmd == bCmd)
|
||
{
|
||
Settings->RemoveActionMapping(Map, false);
|
||
Cleared.Add(ActionLabel(Map.ActionName));
|
||
}
|
||
}
|
||
// KEY2 (§ 4) : toute modification manuelle du groupe de deplacement passe la disposition en Custom.
|
||
bool bMoveTouched = bWaitAxis && KbIsMoveGroup(WaitName);
|
||
TArray<FInputAxisKeyMapping> Axes = Settings->GetAxisMappings();
|
||
for (const FInputAxisKeyMapping& Map : Axes)
|
||
{
|
||
if (Map.Key == Key && !bShift && !bCtrl && !bAlt && !bCmd)
|
||
{
|
||
Settings->RemoveAxisMapping(Map, false);
|
||
Cleared.Add(AxisLabel(Map.AxisName, Map.Scale));
|
||
if (KbIsMoveGroup(Map.AxisName))
|
||
{
|
||
bMoveTouched = true;
|
||
}
|
||
}
|
||
}
|
||
if (bWaitAxis)
|
||
{
|
||
Settings->AddAxisMapping(FInputAxisKeyMapping(WaitName, Key, WaitScale), false);
|
||
}
|
||
else
|
||
{
|
||
Settings->AddActionMapping(FInputActionKeyMapping(WaitName, Key, bShift, bCtrl, bAlt, bCmd), false);
|
||
}
|
||
if (bMoveTouched)
|
||
{
|
||
Layout = KbLayoutCustom;
|
||
}
|
||
ApplyToPlayer();
|
||
Status = Cleared.Num() > 0
|
||
? FString::Printf(TEXT("%s saved. Removed from: %s."), *Key.GetDisplayName().ToString(), *FString::Join(Cleared, TEXT(", ")))
|
||
: FString::Printf(TEXT("%s saved."), *Key.GetDisplayName().ToString());
|
||
if (KbGameReadKey(Key))
|
||
{
|
||
// KEY2 (§ 7, 5) : touche lue en dur par le jeu, acceptee avec un avertissement.
|
||
Status += FString::Printf(TEXT(" Also used by the game: %s."), *Key.GetDisplayName().ToString());
|
||
}
|
||
RefreshMenu();
|
||
return true;
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::RemoveBinding(FName Name, bool bAxis, float Scale, FKey Key, bool bShift, bool bCtrl, bool bAlt, bool bCmd)
|
||
{
|
||
bWaiting = false;
|
||
UInputSettings* Settings = UInputSettings::GetInputSettings();
|
||
if (!Settings)
|
||
{
|
||
return;
|
||
}
|
||
if (bAxis)
|
||
{
|
||
Settings->RemoveAxisMapping(FInputAxisKeyMapping(Name, Key, Scale), false);
|
||
}
|
||
else
|
||
{
|
||
Settings->RemoveActionMapping(FInputActionKeyMapping(Name, Key, bShift, bCtrl, bAlt, bCmd), false);
|
||
}
|
||
if (bAxis && KbIsMoveGroup(Name))
|
||
{
|
||
// KEY2 (§ 4) : modification manuelle du groupe de deplacement.
|
||
Layout = KbLayoutCustom;
|
||
}
|
||
ApplyToPlayer();
|
||
Status = FString::Printf(TEXT("%s removed."), *Key.GetDisplayName().ToString());
|
||
RefreshMenu();
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::ApplyPreset(bool bAzerty, TArray<FString>& Cleared)
|
||
{
|
||
UInputSettings* Settings = UInputSettings::GetInputSettings();
|
||
if (!Settings)
|
||
{
|
||
return;
|
||
}
|
||
TArray<FInputAxisKeyMapping> PresetAxes;
|
||
FInputActionKeyMapping PresetAction;
|
||
KbLayoutPreset(bAzerty, PresetAxes, PresetAction);
|
||
// 1. Toutes les liaisons de MoveForward, MoveRight et ActionPanel.
|
||
const TArray<FInputAxisKeyMapping> GroupAxes = Settings->GetAxisMappings();
|
||
for (const FInputAxisKeyMapping& Map : GroupAxes)
|
||
{
|
||
if (KbIsMoveGroup(Map.AxisName))
|
||
{
|
||
Settings->RemoveAxisMapping(Map, false);
|
||
}
|
||
}
|
||
const TArray<FInputActionKeyMapping> GroupActions = Settings->GetActionMappings();
|
||
for (const FInputActionKeyMapping& Map : GroupActions)
|
||
{
|
||
if (Map.ActionName == KbActionPanel)
|
||
{
|
||
Settings->RemoveActionMapping(Map, false);
|
||
}
|
||
}
|
||
// 2. La meme touche, sans modificateur, retiree des autres actions et axes (regle de CommitKey), avec annonce.
|
||
TArray<FKey> PresetKeys;
|
||
for (const FInputAxisKeyMapping& Map : PresetAxes)
|
||
{
|
||
PresetKeys.AddUnique(Map.Key);
|
||
}
|
||
PresetKeys.AddUnique(PresetAction.Key);
|
||
const TArray<FInputActionKeyMapping> OtherActions = Settings->GetActionMappings();
|
||
for (const FInputActionKeyMapping& Map : OtherActions)
|
||
{
|
||
if (PresetKeys.Contains(Map.Key) && !Map.bShift && !Map.bCtrl && !Map.bAlt && !Map.bCmd)
|
||
{
|
||
Settings->RemoveActionMapping(Map, false);
|
||
Cleared.Add(FString::Printf(TEXT("%s (%s)"), *ActionLabel(Map.ActionName), *Map.Key.GetDisplayName().ToString()));
|
||
}
|
||
}
|
||
const TArray<FInputAxisKeyMapping> OtherAxes = Settings->GetAxisMappings();
|
||
for (const FInputAxisKeyMapping& Map : OtherAxes)
|
||
{
|
||
if (PresetKeys.Contains(Map.Key))
|
||
{
|
||
Settings->RemoveAxisMapping(Map, false);
|
||
Cleared.Add(FString::Printf(TEXT("%s (%s)"), *AxisLabel(Map.AxisName, Map.Scale), *Map.Key.GetDisplayName().ToString()));
|
||
}
|
||
}
|
||
// 3. Les 5 liaisons du prereglage (ApplyToPlayer par l'appelant).
|
||
for (const FInputAxisKeyMapping& Map : PresetAxes)
|
||
{
|
||
Settings->AddAxisMapping(Map, false);
|
||
}
|
||
Settings->AddActionMapping(PresetAction, false);
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::ApplyLayout(const FString& LayoutName)
|
||
{
|
||
bWaiting = false;
|
||
if (!UInputSettings::GetInputSettings())
|
||
{
|
||
return;
|
||
}
|
||
const bool bAzerty = LayoutName == KbLayoutAzerty;
|
||
TArray<FString> Cleared;
|
||
ApplyPreset(bAzerty, Cleared);
|
||
Layout = bAzerty ? KbLayoutAzerty : KbLayoutQwerty;
|
||
ApplyToPlayer();
|
||
Status = Cleared.Num() > 0
|
||
? FString::Printf(TEXT("Layout %s applied. Removed from: %s."), *Layout, *FString::Join(Cleared, TEXT(", ")))
|
||
: FString::Printf(TEXT("Layout %s applied."), *Layout);
|
||
UE_LOG(LogLifePlay, Display, TEXT("Clavier : disposition %s appliquee, %d liaisons retirees ailleurs"), *Layout, Cleared.Num());
|
||
RefreshMenu();
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::RefuseLeftClick()
|
||
{
|
||
Status = TEXT("Left click needs Shift, Ctrl, Alt or Cmd. Escape cancels.");
|
||
RefreshMenu();
|
||
}
|
||
|
||
bool ULPKeyboardSubsystem::CommitWheel(bool bUp, bool bShift, bool bCtrl, bool bAlt, bool bCmd)
|
||
{
|
||
if (bWaitAxis)
|
||
{
|
||
Status = TEXT("The mouse wheel can only be assigned to an action. Press a key, or Escape.");
|
||
RefreshMenu();
|
||
return false;
|
||
}
|
||
return CommitKey(bUp ? EKeys::MouseScrollUp : EKeys::MouseScrollDown, bShift, bCtrl, bAlt, bCmd);
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::SetCoupleDragByKeys(bool bKeys)
|
||
{
|
||
bWaiting = false;
|
||
bCoupleDragKeys = bKeys;
|
||
SaveSaved();
|
||
Status = bKeys
|
||
? TEXT("Couple moved with the arrows only: the left click no longer drags it.")
|
||
: TEXT("Couple moved with the mouse and the arrows.");
|
||
RefreshMenu();
|
||
}
|
||
|
||
FString ULPKeyboardSubsystem::IdleStatus() const
|
||
{
|
||
if (const UInputSettings* Settings = UInputSettings::GetInputSettings())
|
||
{
|
||
for (const FInputActionKeyMapping& Map : Settings->GetActionMappings())
|
||
{
|
||
if (Map.ActionName == KbActionPanel && Map.Key.IsValid())
|
||
{
|
||
return TEXT("Choose Change or Add, then press a key.");
|
||
}
|
||
}
|
||
}
|
||
return TEXT("Action Panel has no key: choose a layout and press Apply, or use Add.");
|
||
}
|
||
|
||
bool ULPKeyboardSubsystem::LoadDefaults(TArray<FInputActionKeyMapping>& Actions, TArray<FInputAxisKeyMapping>& Axes) const
|
||
{
|
||
const FString Path = FPaths::Combine(FPaths::ProjectConfigDir(), TEXT("DefaultInput.ini"));
|
||
TArray<FString> Lines;
|
||
if (!FFileHelper::LoadFileToStringArray(Lines, *Path))
|
||
{
|
||
return false;
|
||
}
|
||
for (FString Line : Lines)
|
||
{
|
||
Line.TrimStartAndEndInline();
|
||
if (Line.StartsWith(TEXT("+ActionMappings=")))
|
||
{
|
||
FInputActionKeyMapping Map;
|
||
const FString Inner = Line.Mid(16);
|
||
if (FInputActionKeyMapping::StaticStruct()->ImportText(*Inner, &Map, nullptr, PPF_None, nullptr, TEXT("ActionMappings")) && Map.Key.IsValid())
|
||
{
|
||
Actions.Add(Map);
|
||
}
|
||
}
|
||
else if (Line.StartsWith(TEXT("+AxisMappings=")))
|
||
{
|
||
FInputAxisKeyMapping Map;
|
||
const FString Inner = Line.Mid(14);
|
||
if (FInputAxisKeyMapping::StaticStruct()->ImportText(*Inner, &Map, nullptr, PPF_None, nullptr, TEXT("AxisMappings")) && Map.Key.IsValid())
|
||
{
|
||
Axes.Add(Map);
|
||
}
|
||
}
|
||
}
|
||
return Actions.Num() > 0 || Axes.Num() > 0;
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::ResetToDefault()
|
||
{
|
||
bWaiting = false;
|
||
TArray<FInputActionKeyMapping> Actions;
|
||
TArray<FInputAxisKeyMapping> Axes;
|
||
UInputSettings* Settings = UInputSettings::GetInputSettings();
|
||
if (!Settings || !LoadDefaults(Actions, Axes))
|
||
{
|
||
Status = TEXT("The original keys could not be found.");
|
||
RefreshMenu();
|
||
return;
|
||
}
|
||
const TArray<FInputActionKeyMapping> CurrentActions = Settings->GetActionMappings();
|
||
for (const FInputActionKeyMapping& Map : CurrentActions)
|
||
{
|
||
Settings->RemoveActionMapping(Map, false);
|
||
}
|
||
const TArray<FInputAxisKeyMapping> CurrentAxes = Settings->GetAxisMappings();
|
||
for (const FInputAxisKeyMapping& Map : CurrentAxes)
|
||
{
|
||
Settings->RemoveAxisMapping(Map, false);
|
||
}
|
||
for (const FInputActionKeyMapping& Map : Actions)
|
||
{
|
||
Settings->AddActionMapping(Map, false);
|
||
}
|
||
for (const FInputAxisKeyMapping& Map : Axes)
|
||
{
|
||
Settings->AddAxisMapping(Map, false);
|
||
}
|
||
// KEY2 (§ 4, decision 12) : un joueur en AZERTY le reste ; les autres reviennent au QWERTY de DefaultInput.ini.
|
||
const bool bKeepAzerty = Layout == KbLayoutAzerty;
|
||
if (bKeepAzerty)
|
||
{
|
||
TArray<FString> Cleared;
|
||
ApplyPreset(true, Cleared);
|
||
}
|
||
else
|
||
{
|
||
Layout = KbLayoutQwerty;
|
||
}
|
||
ApplyToPlayer();
|
||
Status = bKeepAzerty ? TEXT("Original keys restored, AZERTY layout kept.") : TEXT("Original keys restored.");
|
||
RefreshMenu();
|
||
}
|
||
|
||
bool ULPKeyboardSubsystem::LoadSaved()
|
||
{
|
||
const FString Path = KeyboardIniPath();
|
||
if (!FPaths::FileExists(Path))
|
||
{
|
||
UE_LOG(LogLifePlay, Display, TEXT("Clavier : %s absent, creation avec les touches actuelles"), *Path);
|
||
return false;
|
||
}
|
||
FConfigFile File;
|
||
File.Read(Path);
|
||
TArray<FString> ActionLines;
|
||
TArray<FString> AxisLines;
|
||
// KEY2-DIAG-01 : FConfigFile::Read ne traite pas les commandes '+' (FillFileFromDisk, bHandleSymbolCommands faux) :
|
||
// les cles ecrites par SaveSaved se relisent sous leur nom avec '+'. Le nom sans '+' reste lu pour un fichier edite a la main.
|
||
File.GetArray(InputSection, TEXT("+ActionMappings"), ActionLines);
|
||
File.GetArray(InputSection, TEXT("+AxisMappings"), AxisLines);
|
||
TArray<FString> PlainLines;
|
||
File.GetArray(InputSection, TEXT("ActionMappings"), PlainLines);
|
||
ActionLines.Append(PlainLines);
|
||
PlainLines.Reset();
|
||
File.GetArray(InputSection, TEXT("AxisMappings"), PlainLines);
|
||
AxisLines.Append(PlainLines);
|
||
TArray<FInputActionKeyMapping> Actions;
|
||
TArray<FInputAxisKeyMapping> Axes;
|
||
for (const FString& Line : ActionLines)
|
||
{
|
||
FInputActionKeyMapping Map;
|
||
if (FInputActionKeyMapping::StaticStruct()->ImportText(*Line, &Map, nullptr, PPF_None, nullptr, TEXT("ActionMappings")) && Map.Key.IsValid())
|
||
{
|
||
Actions.Add(Map);
|
||
}
|
||
}
|
||
for (const FString& Line : AxisLines)
|
||
{
|
||
FInputAxisKeyMapping Map;
|
||
if (FInputAxisKeyMapping::StaticStruct()->ImportText(*Line, &Map, nullptr, PPF_None, nullptr, TEXT("AxisMappings")) && Map.Key.IsValid())
|
||
{
|
||
Axes.Add(Map);
|
||
}
|
||
}
|
||
UInputSettings* Settings = UInputSettings::GetInputSettings();
|
||
if (!Settings || (Actions.Num() == 0 && Axes.Num() == 0))
|
||
{
|
||
UE_LOG(LogLifePlay, Warning, TEXT("Clavier : %s illisible, les touches du jeu sont gardees"), *Path);
|
||
return false;
|
||
}
|
||
// KEY2 (KEY2-SPEC-01 § 4, § 5, § 5b) : section [LPKeyboard]. Un fichier d'avant la version 2 perd les liaisons
|
||
// retirees du jeu (exactes, sans modificateur), recoit ActionPanel sur Q, CameraHeight sur G / B et CoupleMoveY sur
|
||
// V / X quand l'action manque et que la touche n'est liee a rien (arbitrage de Big Boss), passe en Custom.
|
||
FString SavedLayout;
|
||
if (File.GetString(KbSection, TEXT("Layout"), SavedLayout))
|
||
{
|
||
Layout = SavedLayout == KbLayoutAzerty ? KbLayoutAzerty : SavedLayout == KbLayoutQwerty ? KbLayoutQwerty : KbLayoutCustom;
|
||
}
|
||
FString SavedDrag;
|
||
bCoupleDragKeys = File.GetString(KbSection, TEXT("CoupleDrag"), SavedDrag) && SavedDrag == TEXT("Keys");
|
||
int32 SavedVersion = 0;
|
||
File.GetInt(KbSection, TEXT("Version"), SavedVersion);
|
||
const bool bMigrate = SavedVersion < KbVersion;
|
||
if (bMigrate)
|
||
{
|
||
struct FRetiredKey
|
||
{
|
||
const TCHAR* Action;
|
||
FKey Key;
|
||
};
|
||
const FRetiredKey Retired[] = {
|
||
{TEXT("SpeedUp"), EKeys::NumPadSix}, {TEXT("SpeedDown"), EKeys::NumPadFour},
|
||
{TEXT("SpeedUp"), EKeys::Equals}, {TEXT("SpeedDown"), EKeys::Hyphen},
|
||
{TEXT("TestScenes"), EKeys::Tilde}
|
||
};
|
||
int32 Removed = 0;
|
||
for (const FRetiredKey& Entry : Retired)
|
||
{
|
||
const FName EntryAction(Entry.Action);
|
||
Removed += Actions.RemoveAll([&EntryAction, &Entry](const FInputActionKeyMapping& Map)
|
||
{
|
||
return Map.ActionName == EntryAction && Map.Key == Entry.Key && !Map.bShift && !Map.bCtrl && !Map.bAlt && !Map.bCmd;
|
||
});
|
||
}
|
||
// Une touche est libre si aucune action ni aucun axe du fichier du joueur ne l'utilise.
|
||
auto KeyFree = [&Actions, &Axes](const FKey& Key)
|
||
{
|
||
return !Actions.ContainsByPredicate([&Key](const FInputActionKeyMapping& Map) { return Map.Key == Key; })
|
||
&& !Axes.ContainsByPredicate([&Key](const FInputAxisKeyMapping& Map) { return Map.Key == Key; });
|
||
};
|
||
const bool bHasPanel = Actions.ContainsByPredicate([](const FInputActionKeyMapping& Map) { return Map.ActionName == KbActionPanel; });
|
||
const bool bPanelAdded = Actions.Num() > 0 && !bHasPanel && KeyFree(EKeys::Q);
|
||
if (bPanelAdded)
|
||
{
|
||
Actions.Add(FInputActionKeyMapping(KbActionPanel, EKeys::Q));
|
||
}
|
||
// Axes nouveaux de KEY2 (§ 8b) : chaque sens n'est ajoute que sur sa touche libre ; sinon « (no key) » dans le menu.
|
||
struct FNewAxisKey
|
||
{
|
||
FName Axis;
|
||
FKey Key;
|
||
float Scale;
|
||
};
|
||
const FNewAxisKey NewAxes[] = {
|
||
{FName(TEXT("CameraHeight")), EKeys::G, 1.f}, {FName(TEXT("CameraHeight")), EKeys::B, -1.f},
|
||
{FName(TEXT("CoupleMoveY")), EKeys::V, 1.f}, {FName(TEXT("CoupleMoveY")), EKeys::X, -1.f}
|
||
};
|
||
int32 AxesAdded = 0;
|
||
for (const FNewAxisKey& Entry : NewAxes)
|
||
{
|
||
// Un sens deja lie par le joueur garde ses touches.
|
||
const bool bHasSign = Axes.ContainsByPredicate([&Entry](const FInputAxisKeyMapping& Map)
|
||
{
|
||
return Map.AxisName == Entry.Axis && (Map.Scale > 0.f) == (Entry.Scale > 0.f);
|
||
});
|
||
if (Axes.Num() > 0 && !bHasSign && KeyFree(Entry.Key))
|
||
{
|
||
Axes.Add(FInputAxisKeyMapping(Entry.Axis, Entry.Key, Entry.Scale));
|
||
++AxesAdded;
|
||
}
|
||
}
|
||
Layout = KbLayoutCustom;
|
||
UE_LOG(LogLifePlay, Display, TEXT("Clavier : %s passe de la version %d a %d : %d liaisons retirees (pave, Equals, Hyphen, Tilde), ActionPanel %s, %d touches d'axe ajoutees (CameraHeight G/B, CoupleMoveY V/X), Layout=Custom"),
|
||
*Path, SavedVersion, KbVersion, Removed, bPanelAdded ? TEXT("ajoute sur Q") : bHasPanel ? TEXT("deja lie") : TEXT("sans touche"), AxesAdded);
|
||
}
|
||
if (Actions.Num() > 0)
|
||
{
|
||
const TArray<FInputActionKeyMapping> Current = Settings->GetActionMappings();
|
||
for (const FInputActionKeyMapping& Map : Current)
|
||
{
|
||
Settings->RemoveActionMapping(Map, false);
|
||
}
|
||
for (const FInputActionKeyMapping& Map : Actions)
|
||
{
|
||
Settings->AddActionMapping(Map, false);
|
||
}
|
||
}
|
||
if (Axes.Num() > 0)
|
||
{
|
||
const TArray<FInputAxisKeyMapping> Current = Settings->GetAxisMappings();
|
||
for (const FInputAxisKeyMapping& Map : Current)
|
||
{
|
||
Settings->RemoveAxisMapping(Map, false);
|
||
}
|
||
for (const FInputAxisKeyMapping& Map : Axes)
|
||
{
|
||
Settings->AddAxisMapping(Map, false);
|
||
}
|
||
}
|
||
Settings->ForceRebuildKeymaps();
|
||
UE_LOG(LogLifePlay, Display, TEXT("Clavier : %d actions et %d axes relus depuis %s"), Actions.Num(), Axes.Num(), *Path);
|
||
if (bMigrate)
|
||
{
|
||
// KEY2 (§ 5) : le fichier migre est reecrit tout de suite (Version=2).
|
||
SaveSaved();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::SaveSaved() const
|
||
{
|
||
UInputSettings* Settings = UInputSettings::GetInputSettings();
|
||
if (!Settings)
|
||
{
|
||
return;
|
||
}
|
||
const FString Path = KeyboardIniPath();
|
||
IFileManager::Get().MakeDirectory(*FPaths::GetPath(Path), true);
|
||
FConfigFile File;
|
||
int32 ActionCount = 0;
|
||
int32 AxisCount = 0;
|
||
for (const FInputActionKeyMapping& Map : Settings->GetActionMappings())
|
||
{
|
||
if (Map.Key.IsValid())
|
||
{
|
||
File.AddToSection(InputSection, TEXT("+ActionMappings"), ExportAction(Map));
|
||
++ActionCount;
|
||
}
|
||
}
|
||
for (const FInputAxisKeyMapping& Map : Settings->GetAxisMappings())
|
||
{
|
||
if (Map.Key.IsValid())
|
||
{
|
||
File.AddToSection(InputSection, TEXT("+AxisMappings"), ExportAxis(Map));
|
||
++AxisCount;
|
||
}
|
||
}
|
||
// KEY2 (§ 4, § 5, § 8b) : disposition, version du fichier et option du glisser du couple.
|
||
File.AddToSection(KbSection, TEXT("Layout"), Layout);
|
||
File.AddToSection(KbSection, TEXT("Version"), FString::FromInt(KbVersion));
|
||
File.AddToSection(KbSection, TEXT("CoupleDrag"), FString(bCoupleDragKeys ? TEXT("Keys") : TEXT("Mouse")));
|
||
const bool bWrote = File.Write(Path);
|
||
UE_LOG(LogLifePlay, Display, TEXT("Clavier : %d actions et %d axes %s dans %s"), ActionCount, AxisCount, bWrote ? TEXT("enregistres") : TEXT("non ecrits"), *Path);
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::ApplyToPlayer() const
|
||
{
|
||
if (UInputSettings* Settings = UInputSettings::GetInputSettings())
|
||
{
|
||
Settings->ForceRebuildKeymaps();
|
||
SaveSaved();
|
||
}
|
||
if (UWorld* World = GetWorld())
|
||
{
|
||
if (APlayerController* PC = World->GetFirstPlayerController())
|
||
{
|
||
if (UPlayerInput* Input = PC->PlayerInput)
|
||
{
|
||
Input->ForceRebuildingKeyMaps(false);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void ULPKeyboardSubsystem::RefreshMenu()
|
||
{
|
||
if (Live().Owner.Get() == this && Live().Menu.IsValid())
|
||
{
|
||
Live().Menu->Rebuild();
|
||
}
|
||
}
|