CEFWebBrowserWindow.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Input/CursorReply.h"
#include "Input/Events.h"
#include "Input/Reply.h"
#include "Widgets/SViewport.h"
#include "WebBrowserSingleton.h"
 
#if WITH_CEF3
 
#include "IWebBrowserWindow.h"
#include "CEFBrowserHandler.h"
 
#include "CEFLibCefIncludes.h"
 
#include "CapturedCefBuffer.h"
 
#endif
 
class FBrowserBufferedVideo;
class FCEFBrowserHandler;
class FCEFJSScripting;
class FSlateUpdatableTexture;
class IWebBrowserPopupFeatures;
class IWebBrowserWindow;
struct Rect;
class FSlateShaderResource;
enum class EWebBrowserDocumentState;
struct FGeometry;
struct FPointerEvent;
class UObject;
struct FInputEvent;
class FWebJSScripting;
class FCEFImeHandler;
class ITextInputMethodSystem;
class FCEFWebBrowserWindowRHIHelper;
 
#if WITH_CEF3
 
struct FWebBrowserWindowInfo
{
    FWebBrowserWindowInfo(CefRefPtr<CefBrowser> InBrowser, CefRefPtr<FCEFBrowserHandler> InHandler)
        : Browser(InBrowser)
        , Handler(InHandler)
    {}
    CefRefPtr<CefBrowser> Browser;
    CefRefPtr<FCEFBrowserHandler> Handler;
};
 
struct FWebBrowserDragRegion
{
    FWebBrowserDragRegion(const FIntRect& InRect, bool bInDraggable)
        : Rect(InRect)
        , bDraggable(bInDraggable)
    {}
 
    FIntRect Rect;
    bool bDraggable;
};
 
class FCEFWebBrowserWindow
    : public IWebBrowserWindow
    , public TSharedFromThis<FCEFWebBrowserWindow>
{
    // Allow the Handler to access functions only it needs
    friend class FCEFBrowserHandler;
 
    // The WebBrowserSingleton should be the only one creating instances of this class
    friend class FWebBrowserSingleton;
 
    // CreateWidget should only be called by the WebBrowserView
    friend class SWebBrowserView;
 
private:
    FCEFWebBrowserWindow(CefRefPtr<CefBrowser> Browser, CefRefPtr<FCEFBrowserHandler> Handler, FString Url, TOptional<FString> ContentsToLoad, bool bShowErrorMessage, bool bThumbMouseButtonNavigation, bool bUseTransparency, bool bJSBindingToLoweringEnabled, bool bUsingAcceleratedPaint);
 
    TSharedRef<SViewport> CreateWidget();
 
public:
    virtual ~FCEFWebBrowserWindow();
 
    bool IsShowingErrorMessages() const { return bShowErrorMessage; }
    bool IsThumbMouseButtonNavigationEnabled() const { return bThumbMouseButtonNavigation; }
    bool UseTransparency() const { return bUseTransparency; }
    bool UsingAcceleratedPaint() const { return bUsingAcceleratedPaint; }
    
public:
 
    // IWebBrowserWindow Interface
 
    virtual void LoadURL(FString NewURL) override;
    virtual void LoadString(FString Contents, FString DummyURL) override;
    virtual void SetViewportSize(FIntPoint WindowSize, FIntPoint WindowPos) override;
    virtual FIntPoint GetViewportSize() const override { return FIntPoint::NoneValue; }
    virtual FSlateShaderResource* GetTexture(bool bIsPopup = false) override;
    virtual bool IsValid() const override;
    virtual bool IsInitialized() const override;
    virtual bool IsClosing() const override;
    virtual EWebBrowserDocumentState GetDocumentLoadingState() const override;
    virtual FString GetTitle() const override;
    virtual FString GetUrl() const override;
    virtual void GetSource(TFunction<void (const FString&)> Callback) const override;
    virtual bool OnKeyDown(const FKeyEvent& InKeyEvent) override;
    virtual bool OnKeyUp(const FKeyEvent& InKeyEvent) override;
    virtual bool OnKeyChar(const FCharacterEvent& InCharacterEvent) override;
    virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup) override;
    virtual FReply OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup) override;
    virtual FReply OnMouseButtonDoubleClick(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup) override;
    virtual FReply OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup) override;
    virtual void OnMouseLeave(const FPointerEvent& MouseEvent) override;
    virtual void SetSupportsMouseWheel(bool bValue) override;
    virtual bool GetSupportsMouseWheel() const override;
    virtual FReply OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup) override;
    virtual FReply OnTouchGesture(const FGeometry& MyGeometry, const FPointerEvent& GestureEvent, bool bIsPopup) override;
    virtual void OnFocus(bool SetFocus, bool bIsPopup) override;
    virtual void OnCaptureLost() override;
    virtual bool CanGoBack() const override;
    virtual void GoBack() override;
    virtual bool CanGoForward() const override;
    virtual void GoForward() override;
    virtual bool IsLoading() const override;
    virtual void Reload() override;
    virtual void StopLoad() override;
    virtual void ExecuteJavascript(const FString& Script) override;
    virtual void CloseBrowser(bool bForce, bool bBlockTillClosed) override;
    virtual void BindUObject(const FString& Name, UObject* Object, bool bIsPermanent = true) override;
    virtual void UnbindUObject(const FString& Name, UObject* Object = nullptr, bool bIsPermanent = true) override;
    virtual void BindInputMethodSystem(ITextInputMethodSystem* TextInputMethodSystem) override;
    virtual void UnbindInputMethodSystem() override;
    virtual int GetLoadError() override;
    virtual void SetIsDisabled(bool bValue) override;
    virtual TSharedPtr<SWindow> GetParentWindow() const override;
    virtual void SetParentWindow(TSharedPtr<SWindow> Window) override;
    virtual void ShowFloatingCloseButton(bool bShow, bool bDraggable) override
    {       
    }
 
    DECLARE_DERIVED_EVENT(FCEFWebBrowserWindow, IWebBrowserWindow::FOnDocumentStateChanged, FOnDocumentStateChanged);
    virtual FOnDocumentStateChanged& OnDocumentStateChanged() override
    {
        return DocumentStateChangedEvent;
    }
 
    DECLARE_DERIVED_EVENT(FCEFWebBrowserWindow, IWebBrowserWindow::FOnTitleChanged, FOnTitleChanged);
    virtual FOnTitleChanged& OnTitleChanged() override
    {
        return TitleChangedEvent;
    }
 
    DECLARE_DERIVED_EVENT(FCEFWebBrowserWindow, IWebBrowserWindow::FOnUrlChanged, FOnUrlChanged);
    virtual FOnUrlChanged& OnUrlChanged() override
    {
        return UrlChangedEvent;
    }
 
    DECLARE_DERIVED_EVENT(FCEFWebBrowserWindow, IWebBrowserWindow::FOnToolTip, FOnToolTip);
    virtual FOnToolTip& OnToolTip() override
    {
        return ToolTipEvent;
    }
 
    DECLARE_DERIVED_EVENT(FCEFWebBrowserWindow, IWebBrowserWindow::FOnNeedsRedraw, FOnNeedsRedraw);
    virtual FOnNeedsRedraw& OnNeedsRedraw() override
    {
        return NeedsRedrawEvent;
    }
 
    virtual FOnBeforeBrowse& OnBeforeBrowse() override
    {
        return BeforeBrowseDelegate;
    }
 
    virtual FOnLoadUrl& OnLoadUrl() override
    {
        return LoadUrlDelegate;
    }
 
    virtual FOnCreateWindow& OnCreateWindow() override
    {
        return WebBrowserHandler->OnCreateWindow();
    }
 
    virtual FOnCloseWindow& OnCloseWindow() override
    {
        return CloseWindowDelegate;
    }
 
    virtual FOnFloatingCloseButtonPressed& OnFloatingCloseButtonPressed() override
    {
        return FloatingCloseButtonPressedDelegate;
    }
 
    virtual FCursorReply OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent ) override
    {
        return Cursor == EMouseCursor::Default ? FCursorReply::Unhandled() : FCursorReply::Cursor(Cursor);
    }
 
    virtual FOnBeforePopupDelegate& OnBeforePopup() override
    {
        return WebBrowserHandler->OnBeforePopup();
    }
 
    virtual FOnBeforeResourceLoadDelegate& OnBeforeResourceLoad() override
    {
        if (!WebBrowserHandler->OnBeforeResourceLoad().IsBoundToObject(this))
        {
            WebBrowserHandler->OnBeforeResourceLoad().BindSP(this, &FCEFWebBrowserWindow::HandleOnBeforeResourceLoad);
        }
 
        return BeforeResourceLoadDelegate;
    }
 
    virtual FOnResourceLoadCompleteDelegate& OnResourceLoadComplete() override
    {
        if (!WebBrowserHandler->OnResourceLoadComplete().IsBoundToObject(this))
        {
            WebBrowserHandler->OnResourceLoadComplete().BindSP(this, &FCEFWebBrowserWindow::HandleOnResourceLoadComplete);
        }
 
        return ResourceLoadCompleteDelegate;
    }
 
    virtual FOnConsoleMessageDelegate& OnConsoleMessage() override
    {
        if (!WebBrowserHandler->OnConsoleMessage().IsBoundToObject(this))
        {
            WebBrowserHandler->OnConsoleMessage().BindSP(this, &FCEFWebBrowserWindow::HandleOnConsoleMessage);
        }
 
        return ConsoleMessageDelegate;
    }
 
    DECLARE_DERIVED_EVENT(FCEFWebBrowserWindow, IWebBrowserWindow::FOnShowPopup, FOnShowPopup);
    virtual FOnShowPopup& OnShowPopup() override
    {
        return ShowPopupEvent;
    }
 
    DECLARE_DERIVED_EVENT(FCEFWebBrowserWindow, IWebBrowserWindow::FOnDismissPopup, FOnDismissPopup);
    virtual FOnDismissPopup& OnDismissPopup() override
    {
        return DismissPopupEvent;
    }
 
    virtual FOnShowDialog& OnShowDialog() override
    {
        return ShowDialogDelegate;
    }
 
    virtual FOnDismissAllDialogs& OnDismissAllDialogs() override
    {
        return DismissAllDialogsDelegate;
    }
 
    virtual FOnSuppressContextMenu& OnSuppressContextMenu() override
    {
        return SuppressContextMenuDelgate;
    }
 
    virtual FOnDragWindow& OnDragWindow() override
    {
        return DragWindowDelegate;
    }
        
    virtual FOnUnhandledKeyDown& OnUnhandledKeyDown() override
    {
        return UnhandledKeyDownDelegate;
    }
 
    virtual FOnUnhandledKeyUp& OnUnhandledKeyUp() override
    {
        return UnhandledKeyUpDelegate;
    }
 
    virtual FOnUnhandledKeyChar& OnUnhandledKeyChar() override
    {
        return UnhandledKeyCharDelegate;
    }
 
private:
 
    CefRefPtr<CefBrowser> GetCefBrowser();
 
    void SetTitle(const CefString& InTitle);
 
    void SetUrl(const CefString& InUrl);
 
    void SetToolTip(const CefString& InToolTip);
 
    void GetViewRect(CefRect& Rect);
 
    void NotifyDocumentError(CefLoadHandler::ErrorCode InErrorCode, const CefString& ErrorText, const CefString& FailedUrl);
    
    void NotifyDocumentError(int ErrorCode);
 
    void NotifyDocumentLoadingStateChange(bool IsLoading);
 
    void OnPaint(CefRenderHandler::PaintElementType Type, const CefRenderHandler::RectList& DirtyRects, const void* Buffer, int Width, int Height);
 
    void OnAcceleratedPaint(CefRenderHandler::PaintElementType type, const CefRenderHandler::RectList& DirtyRects,
#if CEF_VERSION_MAJOR < 128
        void* SharedHandle);
#else
        const CefAcceleratedPaintInfo& Info);
#endif
 
    bool OnCursorChange(CefCursorHandle Cursor, cef_cursor_type_t Type, const CefCursorInfo& CustomCursorInfo);
 
    bool OnProcessMessageReceived(CefRefPtr<CefBrowser> Browser, CefRefPtr<CefFrame> frame, CefProcessId SourceProcess, CefRefPtr<CefProcessMessage> Message);
 
    bool OnBeforeBrowse(CefRefPtr<CefBrowser> Browser, CefRefPtr<CefFrame> Frame, CefRefPtr<CefRequest> Request, bool user_gesture, bool bIsRedirect);
 
    void HandleOnBeforeResourceLoad(const CefString& URL, CefRequest::ResourceType Type, FRequestHeaders& AdditionalHeaders, const bool AllowUserCredentials);
    void HandleOnResourceLoadComplete(const CefString& URL, CefRequest::ResourceType Type, CefResourceRequestHandler::URLRequestStatus Status, int64 ContentLength);
    void HandleOnConsoleMessage(CefRefPtr<CefBrowser> Browser, cef_log_severity_t Level, const CefString& Message, const CefString& Source, int32 Line);
 
    TOptional<FString> GetResourceContent( CefRefPtr< CefFrame > Frame, CefRefPtr< CefRequest > Request);
 
    FModifierKeysState SlateModifiersFromCefModifiers(const CefKeyEvent& CefEvent);
 
    bool OnUnhandledKeyEvent(const CefKeyEvent& CefEvent);
 
    bool OnJSDialog(CefJSDialogHandler::JSDialogType DialogType, const CefString& MessageText, const CefString& DefaultPromptText, CefRefPtr<CefJSDialogCallback> Callback, bool& OutSuppressMessage);
 
    bool OnFileDialog(CefDialogHandler::FileDialogMode Mode, const CefString& DialogTitle, const CefString& DefaultFilePath, const std::vector<CefString>& AcceptFilters,
#if CEF_VERSION_MAJOR < 128
        int SelectedAcceptFilter,
#else
        const std::vector<CefString>& AcceptExtensions,
        const std::vector<CefString>& AcceptDescriptions,
#endif
        CefRefPtr<CefFileDialogCallback> Callback);
 
    bool OnBeforeUnloadDialog(const CefString& MessageText, bool IsReload, CefRefPtr<CefJSDialogCallback> Callback);
 
    void OnResetDialogState();
 
    void OnRenderProcessTerminated(CefRequestHandler::TerminationStatus Status);
 
 
    bool RequestCreateWindow(const TSharedRef<IWebBrowserWindow>& NewBrowserWindow, const TSharedPtr<IWebBrowserPopupFeatures>& BrowserPopupFeatures);
 
    //bool SupportsCloseWindows();
    //bool RequestCloseWindow(const TSharedRef<IWebBrowserWindow>& BrowserWindow);
 
 
    void OnBrowserClosing();
 
    void OnBrowserClosed();
 
    void SetPopupMenuPosition(CefRect PopupSize);
 
    void ShowPopupMenu(bool bShow);
 
    void OnImeCompositionRangeChanged(
        CefRefPtr<CefBrowser> Browser,
        const CefRange& SelectionRange,
        const CefRenderHandler::RectList& CharacterBounds);
 
    void UpdateDragRegions(const TArray<FWebBrowserDragRegion>& Regions);
 
public:
 
    static int32 GetCefKeyboardModifiers(const FKeyEvent& KeyEvent);
 
    static int32 GetCefMouseModifiers(const FPointerEvent& InMouseEvent);
 
    static int32 GetCefInputModifiers(const FInputEvent& InputEvent);
 
 
    static bool CanSupportAcceleratedPaint();
public:
 
    void UpdateCachedGeometry(const FGeometry& AllottedGeometry);
 
 
    void CheckTickActivity() override;
 
    void UpdateVideoBuffering();
 
    CefRefPtr<CefDictionaryValue> GetProcessInfo();
 
    bool URLRequestAllowsCredentials(const FString& URL) const { return WebBrowserHandler->URLRequestAllowsCredentials(URL); }
 
    WEBBROWSER_API bool HasCorrectNativeCefBuffer() const;
    
    WEBBROWSER_API void SetUseCapturedCefBuffer(const bool bValue);
    
    WEBBROWSER_API bool HasResizeBug() const;
    
    WEBBROWSER_API TSharedPtr<FCapturedCefBuffer> GetCapturedCefBuffer();
 
    WEBBROWSER_API void SetNeedsResize(const bool bInValue);
    
private:
 
    FSlateRenderer* const GetRenderer();
 
    void HandleRenderingError();
 
    void ReleaseTextures();
 
    bool CreateInitialTextures();
 
    void RequestNavigationInternal(FString Url, FString Contents);
 
    bool HasPendingNavigation();
 
    void ProcessPendingNavigation();
 
    void SetIsHidden(bool bValue);
 
    void PopulateCefKeyEvent(const FKeyEvent& InKeyEvent, CefKeyEvent& OutKeyEvent);
 
    CefMouseEvent GetCefMouseEvent(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup);
 
    bool IsInDragRegion(const FIntPoint& Point);
 
    bool BlockInputInDirectHwndMode() const;
 
#if PLATFORM_WINDOWS
    bool LoadCustomCEF3Cursor(cef_cursor_type_t Type);
#endif
private:
 
    EWebBrowserDocumentState DocumentState;
 
    FSlateUpdatableTexture* UpdatableTextures[2];
 
    CefRefPtr<CefBrowser> InternalCefBrowser;
 
    CefRefPtr<FCEFBrowserHandler> WebBrowserHandler;
 
    FString Title;
 
    FString CurrentUrl;
 
    FString ToolTipText;
 
    FIntPoint ViewportSize;
 
    FIntPoint ViewportPos;
 
    float ViewportDPIScaleFactor;
 
    bool bIsClosing;
 
    bool bIsInitialized;
 
    TOptional<FString> ContentsToLoad;
 
    FOnDocumentStateChanged DocumentStateChangedEvent;
 
    bool bShowErrorMessage;
 
    bool bThumbMouseButtonNavigation;
 
    bool bUseTransparency;
 
    bool bUsingAcceleratedPaint;
 
    FOnTitleChanged TitleChangedEvent;
 
    FOnUrlChanged UrlChangedEvent;
 
    FOnToolTip ToolTipEvent;
 
    FOnNeedsRedraw NeedsRedrawEvent;
 
    FOnBeforeBrowse BeforeBrowseDelegate;
 
    FOnLoadUrl LoadUrlDelegate;
 
    FOnCloseWindow CloseWindowDelegate;
 
    FOnFloatingCloseButtonPressed FloatingCloseButtonPressedDelegate;
 
    FOnBeforeResourceLoadDelegate BeforeResourceLoadDelegate;
 
    FOnResourceLoadCompleteDelegate ResourceLoadCompleteDelegate;
 
    FOnConsoleMessageDelegate ConsoleMessageDelegate;
 
    FOnShowPopup ShowPopupEvent;
 
    FOnDismissPopup DismissPopupEvent;
 
    FOnShowDialog ShowDialogDelegate;
 
    FOnDismissAllDialogs DismissAllDialogsDelegate;
 
    FOnSuppressContextMenu SuppressContextMenuDelgate;
 
    FOnDragWindow DragWindowDelegate;
    
    FOnUnhandledKeyDown UnhandledKeyDownDelegate;
 
    FOnUnhandledKeyUp UnhandledKeyUpDelegate;
 
    FOnUnhandledKeyChar UnhandledKeyCharDelegate;
 
    EMouseCursor::Type Cursor;
 
    bool bIsDisabled;
 
    bool bIsHidden;
 
    bool bTickedLastFrame;
    
    bool bNeedsResize;
 
    bool bDraggingWindow;
 
    TOptional<FKeyEvent> PreviousKeyDownEvent;
    TOptional<FKeyEvent> PreviousKeyUpEvent;
    TOptional<FCharacterEvent> PreviousCharacterEvent;
    bool bIgnoreKeyDownEvent;
    bool bIgnoreKeyUpEvent;
    bool bIgnoreCharacterEvent;
 
    bool bMainHasFocus;
    bool bPopupHasFocus;
 
    bool bSupportsMouseWheel;
 
    FIntPoint PopupPosition;
    bool bShowPopupRequested;
 
    bool bRecoverFromRenderProcessCrash;
 
    int ErrorCode;
 
    bool bDeferNavigations;
 
    FString PendingAbortUrl;
 
    FString PendingLoadUrl;
 
    TUniquePtr<FBrowserBufferedVideo> BufferedVideo;
#if PLATFORM_MAC
    void *LastPaintedSharedHandle;
#endif
    
    TSharedPtr<FCEFJSScripting> Scripting;
 
#if !PLATFORM_LINUX
    TSharedPtr<FCEFImeHandler> Ime;
#endif
 
    TArray<FWebBrowserDragRegion> DragRegions;
 
    TWeakPtr<SWindow> ParentWindow;
 
    TUniquePtr<FCEFWebBrowserWindowRHIHelper> RHIRenderHelper;
 
#if PLATFORM_WINDOWS || PLATFORM_MAC
    bool bInDirectHwndMode;
#endif
 
    bool bHasCorrectNativeCefBuffer = true;
    TSharedPtr<FCapturedCefBuffer> CapturedCefBuffer;
};
 
typedef FCEFWebBrowserWindow FWebBrowserWindow;
 
#endif