SGameMenuPageWidget.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Math/IntPoint.h"
#include "Delegates/Delegate.h"
#include "Internationalization/Text.h"
#include "Math/Color.h"
#include "Layout/Visibility.h"
#include "Layout/Margin.h"
#include "Animation/CurveHandle.h"
#include "Animation/CurveSequence.h"
#include "Styling/ISlateStyle.h"
#include "Styling/SlateColor.h"
#include "Styling/SlateWidgetStyleAsset.h"
#include "Input/Reply.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/SCompoundWidget.h"
#include "Engine/GameViewportClient.h"
#include "GameFramework/PlayerController.h"
#include "GameMenuWidgetStyle.h"
 
class UGameViewportClient;
class FGameMenuPage;
class SVerticalBox;
class SWidget;
struct FFocusEvent;
struct FGeometry;
struct FKeyEvent;
struct FPointerEvent;
 
namespace EPanelState
{
    enum Type
    {
        /* Menu is opening. */
        Opening,
        /* Menu is open. */
        Open,
        /* Menu is closing. */
        Closing,
        /* Menu is closed. */
        Closed
    };
 
};
 
DECLARE_DELEGATE_OneParam(FPanelStateChanged, bool);
 
// Simple class to contain the menu panels/animations
class FMenuPanel
{
public:
    FMenuPanel();
 
    void Tick(float Delta);
 
    /* Close the panel */
    void ClosePanel(TSharedRef<SWidget> OwnerWidget);
    
    /* Open the panel */
    void OpenPanel(TSharedRef<SWidget> OwnerWidget);
 
    /* Force the panel to be fully open. */
    void ForcePanelOpen();
 
    /* Force the panel to be fully closed. */
    void ForcePanelClosed();
    
    void SetStyle(const FGameMenuStyle* InStyle);
 
    /* Delegate called when the panel becomes open or closed. */
    FPanelStateChanged  OnStateChanged;
    
    /* Animation curve/handle for panel animation. */
    FCurveHandle AnimationHandle;
 
    /* The current state of the panel. */
    EPanelState::Type   CurrentState;
 
private:        
    /* Animation sequence used to open or close the panel. */
    FCurveSequence AnimationSequence;
};
 
class FGameMenuPage;
 
// Simple Menu page widget class
class GAMEMENUBUILDER_API SGameMenuPageWidget : public SCompoundWidget
{
public:
    SLATE_BEGIN_ARGS(SGameMenuPageWidget)
    : _PCOwner() {}
 
    SLATE_STYLE_ARGUMENT(FGameMenuStyle, MenuStyle)
 
    
    SLATE_ARGUMENT(TWeakObjectPtr<APlayerController>, PCOwner)
 
    
    SLATE_ARGUMENT(bool, GameMenu)
 
    
    SLATE_END_ARGS()
        
    
    DECLARE_DELEGATE(FOnToggleMenu);
    
    DECLARE_DELEGATE_TwoParams(FOnSelectionChanged, TSharedPtr<class FGameMenuItem>, TSharedPtr<class FGameMenuItem>);
 
    void Construct(const FArguments& InArgs);
 
    //~ Begin SWidget Interface
    virtual void Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime ) override;
 
    virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
 
    virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
 
    virtual bool SupportsKeyboardFocus() const override { return true; }
 
    virtual FReply OnFocusReceived(const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent) override;
 
    //~ End SWidget Interface
 
    virtual void OnMainPanelStateChange(bool bWasOpened);
 
    
    virtual void OnSubPanelStateChange(bool bWasOpened);
 
    void SetupAnimations();
 
    void EnterSubMenu(TSharedPtr<FGameMenuPage> InSubMenu);
 
    void MenuGoBack(bool bIsCancel=false);
 
    void ConfirmMenuItem();
 
    void BuildAndShowMenu(TSharedPtr< FGameMenuPage > InMenu);
 
    void HideMenu();
 
    void UpdateArrows(TSharedPtr<class FGameMenuItem> InMenuItem);
 
    void ChangeOption(int32 InMoveBy);
 
    void LockControls(bool bEnable);
 
    void OpenMainPanel(TSharedPtr< FGameMenuPage > InMenu);
        
    bool SelectItem(int32 InSelection);
 
    void ResetMenu();
 
    /* The viewport I am attached to. */
    TWeakObjectPtr<UGameViewportClient> MyGameViewport;
 
    TSharedPtr< FGameMenuPage > GetCurrentMenu();
protected:
 
    /* Set the current menu. Also sets the owner widget of that menu to this and resets the previous menu owner. */
    void SetCurrentMenu(TSharedPtr< FGameMenuPage > InMenu);
 
    EVisibility GetSlateVisibility() const;
 
    /* Returns true if the submenu should be visible. */
    EVisibility GetSubMenuVisiblity() const;
 
    float GetUIScale() const;
 
    void BuildPanelButtons(TSharedPtr< FGameMenuPage > InPanel, TSharedPtr<SVerticalBox> InBox, int32 InPreviousIndex);
 
    FLinearColor GetPanelsColor() const;    
    FSlateColor GetPanelsBackgroundColor() const;
    FMargin GetMainMenuOffset() const;
    FMargin GetSubMenuOffset() const;
    FMargin GetMenuTitleOffset() const;
    FMargin GetMenuOffset() const;
    FMargin GetMenuItemPadding() const;
    FMargin GetSubMenuItemPadding() const;
    FSlateColor GetTitleColor() const;
    FSlateColor GetTextColor() const;
 
    virtual FReply SelectionChanged(int32 SelectionIndex);
 
    virtual FReply MouseButtonClicked(int32 SelectionIndex);
 
    FText GetOptionText(TSharedPtr<class FGameMenuItem> MenuItem) const;
 
    FText GetMenuTitle() const; 
 
    EVisibility GetMenuTitleVisibility() const;
 
    void FadeIn();
 
    void SetTitleAnimation(bool bShowTitle);
 
    /* Opens any pending sub menu if there is one. */
    void OpenPendingSubMenu();
 
    //FKey ControllerHideMenuKey;
    
    FText CurrentMenuTitle;
 
    bool bConsoleVisible;
    
    FMenuPanel  MainMenuPanel;
 
    FMenuPanel  SubMenuPanel;
    
    TSharedPtr< FGameMenuPage > NextMenu;
 
    TSharedPtr< FGameMenuPage > CurrentMenu;
 
    TAttribute<float> UIScale;
 
    FCurveSequence MenuWidgetAnimation;
 
    FCurveHandle TopColorCurve;
 
    FCurveHandle ColorFadeCurve;
 
    FCurveHandle MenuAnimationCurve;
 
    FCurveSequence TitleWidgetAnimation;
 
    /* Used to animate the title widget (NYI) */
    FCurveHandle TitleWidgetCurve;
 
    TWeakObjectPtr<class APlayerController> PCOwner;
 
    FIntPoint ScreenRes;
 
    int32 MainAnimNumber;
 
    int32 SelectedIndex;
    
    uint8 bMenuHiding : 1;
 
    uint8 bMenuHidden : 1;
 
    uint8 bGameMenu : 1;
 
    uint8 bControlsLocked : 1;
    
    TSharedPtr< FGameMenuPage > PendingMainMenu;
    
    TSharedPtr< FGameMenuPage > PendingSubMenu;
    
    TSharedPtr<SVerticalBox> MainPanel;
 
    TSharedPtr<SVerticalBox> SubPanel;
 
    const FGameMenuStyle* MenuStyle;
        
    TArray< TSharedPtr< FGameMenuPage>> MenuHistory;
 
    FOnToggleMenu OnToggleMenu;
    
    FOnSelectionChanged OnSelectionChange;
};