ue 自定义继承webbrowser实现 js调用ue的方法

实现的效果如下:

image.png

官方的webbowser的源码中都是通过WebBrowserWidget实现的
官方的源码如下

// Copyright Epic Games, Inc. All Rights Reserved.

#include "WebBrowser.h"
#include "SWebBrowser.h"
#include "Widgets/Layout/SBox.h"
#include "Widgets/Text/STextBlock.h"
#include "Async/TaskGraphInterfaces.h"
#include "UObject/ConstructorHelpers.h"

#if WITH_EDITOR
#include "Materials/MaterialInterface.h"
#include "Materials/MaterialExpressionMaterialFunctionCall.h"
#include "Materials/MaterialExpressionTextureSample.h"
#include "Materials/MaterialExpressionTextureSampleParameter2D.h"
#include "Materials/MaterialFunction.h"
#include "Factories/MaterialFactoryNew.h"
#include "AssetRegistry/AssetRegistryModule.h"
#include "PackageHelperFunctions.h"
#endif

#define LOCTEXT_NAMESPACE "WebBrowser"

/
// UWebBrowser

UWebBrowser::UWebBrowser(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    bIsVariable = true;
}

void UWebBrowser::LoadURL(FString NewURL)
{
    if ( WebBrowserWidget.IsValid() )
    {
        return WebBrowserWidget->LoadURL(NewURL);
    }
}

void UWebBrowser::LoadString(FString Contents, FString DummyURL)
{
    if ( WebBrowserWidget.IsValid() )
    {
        return WebBrowserWidget->LoadString(Contents, DummyURL);
    }
}

void UWebBrowser::ExecuteJavascript(const FString& ScriptText)
{
    if (WebBrowserWidget.IsValid())
    {
        return WebBrowserWidget->ExecuteJavascript(ScriptText);
    }
}

FText UWebBrowser::GetTitleText() const
{
    if ( WebBrowserWidget.IsValid() )
    {
        return WebBrowserWidget->GetTitleText();
    }

    return FText::GetEmpty();
}

FString UWebBrowser::GetUrl() const
{
    if (WebBrowserWidget.IsValid())
    {
        return WebBrowserWidget->GetUrl();
    }

    return FString();
}

void UWebBrowser::ReleaseSlateResources(bool bReleaseChildren)
{
    Super::ReleaseSlateResources(bReleaseChildren);

    WebBrowserWidget.Reset();
}

TSharedRef<SWidget> UWebBrowser::RebuildWidget()
{
    if ( IsDesignTime() )
    {
        return SNew(SBox)
            .HAlign(HAlign_Center)
            .VAlign(VAlign_Center)
            [
                SNew(STextBlock)
                .Text(LOCTEXT("Web Browser", "Web Browser"))
            ];
    }
    else
    {
        WebBrowserWidget = SNew(SWebBrowser)
            .InitialURL(InitialURL)
            .ShowControls(false)
            .SupportsTransparency(bSupportsTransparency)
            .OnUrlChanged(BIND_UOBJECT_DELEGATE(FOnTextChanged, HandleOnUrlChanged))
            .OnBeforePopup(BIND_UOBJECT_DELEGATE(FOnBeforePopupDelegate, HandleOnBeforePopup))
            .OnConsoleMessage(BIND_UOBJECT_DELEGATE(FOnConsoleMessageDelegate, HandleOnConsoleMessage));

        return WebBrowserWidget.ToSharedRef();
    }
}

void UWebBrowser::SynchronizeProperties()
{
    Super::SynchronizeProperties();

    if ( WebBrowserWidget.IsValid() )
    {

    }
}

void UWebBrowser::HandleOnUrlChanged(const FText& InText)
{
    OnUrlChanged.Broadcast(InText);
}

void UWebBrowser::HandleOnConsoleMessage(const FString& Message, const FString& Source, int32 Line, EWebBrowserConsoleLogSeverity Severity)
{
    OnConsoleMessage.Broadcast(Message, Source, Line);
}

bool UWebBrowser::HandleOnBeforePopup(FString URL, FString Frame)
{
    if (OnBeforePopup.IsBound())
    {
        if (IsInGameThread())
        {
            OnBeforePopup.Broadcast(URL, Frame);
        }
        else
        {
            // Retry on the GameThread.
            TWeakObjectPtr<UWebBrowser> WeakThis = this;
            FFunctionGraphTask::CreateAndDispatchWhenReady([WeakThis, URL, Frame]()
            {
                if (WeakThis.IsValid())
                {
                    WeakThis->HandleOnBeforePopup(URL, Frame);
                }
            }, TStatId(), nullptr, ENamedThreads::GameThread);
        }

        return true;
    }

    return false;
}

#if WITH_EDITOR

const FText UWebBrowser::GetPaletteCategory()
{
    return LOCTEXT("Experimental", "Experimental");
}

#endif

/

#undef LOCTEXT_NAMESPACE

我们发现代码都有类似

if (WebBrowserWidget.IsValid())
    {
        return WebBrowserWidget->ExecuteJavascript(ScriptText);
    }

官方sWebBrowserView.cpp的代码如下

// Copyright Epic Games, Inc. All Rights Reserved.

#include "SWebBrowserView.h"
#include "Misc/CommandLine.h"
#include "Misc/ConfigCacheIni.h"
#include "Containers/Ticker.h"
#include "WebBrowserModule.h"
#include "Layout/WidgetPath.h"
#include "Framework/Application/MenuStack.h"
#include "Framework/Application/SlateApplication.h"
#include "IWebBrowserDialog.h"
#include "IWebBrowserWindow.h"
#include "WebBrowserViewport.h"
#include "IWebBrowserAdapter.h"

#if PLATFORM_ANDROID && USE_ANDROID_JNI
#   include "Android/AndroidWebBrowserWindow.h"
#elif PLATFORM_IOS
#   include "IOS/IOSPlatformWebBrowser.h"
#elif PLATFORM_SPECIFIC_WEB_BROWSER
#   include COMPILED_PLATFORM_HEADER(PlatformWebBrowser.h)
#elif WITH_CEF3
#   include "CEF/CEFWebBrowserWindow.h"
#else
#   define DUMMY_WEB_BROWSER 1
#endif

#define LOCTEXT_NAMESPACE "WebBrowser"

SWebBrowserView::SWebBrowserView()
{
}

SWebBrowserView::~SWebBrowserView()
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->OnDocumentStateChanged().RemoveAll(this);
        BrowserWindow->OnNeedsRedraw().RemoveAll(this);
        BrowserWindow->OnTitleChanged().RemoveAll(this);
        BrowserWindow->OnUrlChanged().RemoveAll(this);
        BrowserWindow->OnToolTip().RemoveAll(this);
        BrowserWindow->OnShowPopup().RemoveAll(this);
        BrowserWindow->OnDismissPopup().RemoveAll(this);

        BrowserWindow->OnShowDialog().Unbind();
        BrowserWindow->OnDismissAllDialogs().Unbind();
        BrowserWindow->OnCreateWindow().Unbind();
        BrowserWindow->OnCloseWindow().Unbind();
        BrowserWindow->OnSuppressContextMenu().Unbind();
        BrowserWindow->OnDragWindow().Unbind();
        BrowserWindow->OnConsoleMessage().Unbind();

        if (BrowserWindow->OnBeforeBrowse().IsBoundToObject(this))
        {
            BrowserWindow->OnBeforeBrowse().Unbind();
        }

        if (BrowserWindow->OnLoadUrl().IsBoundToObject(this))
        {
            BrowserWindow->OnLoadUrl().Unbind();
        }

        if (BrowserWindow->OnBeforePopup().IsBoundToObject(this))
        {
            BrowserWindow->OnBeforePopup().Unbind();
        }
    }

    TSharedPtr<SWindow> SlateParentWindow = SlateParentWindowPtr.Pin();
    if (SlateParentWindow.IsValid())
    {
        SlateParentWindow->GetOnWindowDeactivatedEvent().RemoveAll(this);
    }

    if (SlateParentWindow.IsValid())
    {
        SlateParentWindow->GetOnWindowActivatedEvent().RemoveAll(this);
    }
}

void SWebBrowserView::Construct(const FArguments& InArgs, const TSharedPtr<IWebBrowserWindow>& InWebBrowserWindow)
{
    OnLoadCompleted = InArgs._OnLoadCompleted;
    OnLoadError = InArgs._OnLoadError;
    OnLoadStarted = InArgs._OnLoadStarted;
    OnTitleChanged = InArgs._OnTitleChanged;
    OnUrlChanged = InArgs._OnUrlChanged;
    OnBeforeNavigation = InArgs._OnBeforeNavigation;
    OnLoadUrl = InArgs._OnLoadUrl;
    OnShowDialog = InArgs._OnShowDialog;
    OnDismissAllDialogs = InArgs._OnDismissAllDialogs;
    OnBeforePopup = InArgs._OnBeforePopup;
    OnCreateWindow = InArgs._OnCreateWindow;
    OnCloseWindow = InArgs._OnCloseWindow;
    AddressBarUrl = FText::FromString(InArgs._InitialURL);
    PopupMenuMethod = InArgs._PopupMenuMethod;
    OnUnhandledKeyDown = InArgs._OnUnhandledKeyDown;
    OnUnhandledKeyUp = InArgs._OnUnhandledKeyUp;
    OnUnhandledKeyChar = InArgs._OnUnhandledKeyChar;
    OnConsoleMessage = InArgs._OnConsoleMessage;

    BrowserWindow = InWebBrowserWindow;
    if(!BrowserWindow.IsValid())
    {

        static bool AllowCEF = !FParse::Param(FCommandLine::Get(), TEXT("nocef"));
        bool bBrowserEnabled = true;
        GConfig->GetBool(TEXT("Browser"), TEXT("bEnabled"), bBrowserEnabled, GEngineIni);
        if (AllowCEF && bBrowserEnabled)
        {
            FCreateBrowserWindowSettings Settings;
            Settings.InitialURL = InArgs._InitialURL;
            Settings.bUseTransparency = InArgs._SupportsTransparency;
            Settings.bInterceptLoadRequests = InArgs._InterceptLoadRequests;
            Settings.bThumbMouseButtonNavigation = InArgs._SupportsThumbMouseButtonNavigation;
            Settings.ContentsToLoad = InArgs._ContentsToLoad;
            Settings.bShowErrorMessage = InArgs._ShowErrorMessage;
            Settings.BackgroundColor = InArgs._BackgroundColor;
            Settings.BrowserFrameRate = InArgs._BrowserFrameRate;
            Settings.Context = InArgs._ContextSettings;
            Settings.AltRetryDomains = InArgs._AltRetryDomains;

            // IWebBrowserModule::Get() was already callled in WebBrowserWidgetModule.cpp so we don't need to force the load again here
            if (IWebBrowserModule::IsAvailable() && IWebBrowserModule::Get().IsWebModuleAvailable())
            {
                BrowserWindow = IWebBrowserModule::Get().GetSingleton()->CreateBrowserWindow(Settings);
            }
        }
    }

    SlateParentWindowPtr = InArgs._ParentWindow;

    if (BrowserWindow.IsValid())
    {
#ifndef DUMMY_WEB_BROWSER
        // The inner widget creation is handled by the WebBrowserWindow implementation.
        const auto& BrowserWidgetRef = static_cast<FWebBrowserWindow*>(BrowserWindow.Get())->CreateWidget();
        ChildSlot
        [
            BrowserWidgetRef
        ];
        BrowserWidget = BrowserWidgetRef;
#endif

        if(OnCreateWindow.IsBound())
        {
            BrowserWindow->OnCreateWindow().BindSP(this, &SWebBrowserView::HandleCreateWindow);
        }

        if(OnCloseWindow.IsBound())
        {
            BrowserWindow->OnCloseWindow().BindSP(this, &SWebBrowserView::HandleCloseWindow);
        }

        BrowserWindow->OnDocumentStateChanged().AddSP(this, &SWebBrowserView::HandleBrowserWindowDocumentStateChanged);
        BrowserWindow->OnNeedsRedraw().AddSP(this, &SWebBrowserView::HandleBrowserWindowNeedsRedraw);
        BrowserWindow->OnTitleChanged().AddSP(this, &SWebBrowserView::HandleTitleChanged);
        BrowserWindow->OnUrlChanged().AddSP(this, &SWebBrowserView::HandleUrlChanged);
        BrowserWindow->OnToolTip().AddSP(this, &SWebBrowserView::HandleToolTip);
        OnCreateToolTip = InArgs._OnCreateToolTip;

        if (!BrowserWindow->OnBeforeBrowse().IsBound())
        {
            BrowserWindow->OnBeforeBrowse().BindSP(this, &SWebBrowserView::HandleBeforeNavigation);
        }
        else
        {
            check(!OnBeforeNavigation.IsBound());
        }

        if (!BrowserWindow->OnLoadUrl().IsBound())
        {
            BrowserWindow->OnLoadUrl().BindSP(this, &SWebBrowserView::HandleLoadUrl);
        }
        else
        {
            check(!OnLoadUrl.IsBound());
        }

        if (!BrowserWindow->OnBeforePopup().IsBound())
        {
            BrowserWindow->OnBeforePopup().BindSP(this, &SWebBrowserView::HandleBeforePopup);
        }
        else
        {
            check(!OnBeforePopup.IsBound());
        }

        if (!BrowserWindow->OnUnhandledKeyDown().IsBound())
        {
            BrowserWindow->OnUnhandledKeyDown().BindSP(this, &SWebBrowserView::UnhandledKeyDown);
        }

        if (!BrowserWindow->OnUnhandledKeyUp().IsBound())
        {
            BrowserWindow->OnUnhandledKeyUp().BindSP(this, &SWebBrowserView::UnhandledKeyUp);
        }

        if (!BrowserWindow->OnUnhandledKeyChar().IsBound())
        {
            BrowserWindow->OnUnhandledKeyChar().BindSP(this, &SWebBrowserView::UnhandledKeyChar);
        }
        
        BrowserWindow->OnShowDialog().BindSP(this, &SWebBrowserView::HandleShowDialog);
        BrowserWindow->OnDismissAllDialogs().BindSP(this, &SWebBrowserView::HandleDismissAllDialogs);
        BrowserWindow->OnShowPopup().AddSP(this, &SWebBrowserView::HandleShowPopup);
        BrowserWindow->OnDismissPopup().AddSP(this, &SWebBrowserView::HandleDismissPopup);

        BrowserWindow->OnSuppressContextMenu().BindSP(this, &SWebBrowserView::HandleSuppressContextMenu);


        OnSuppressContextMenu = InArgs._OnSuppressContextMenu;

        BrowserWindow->OnDragWindow().BindSP(this, &SWebBrowserView::HandleDrag);
        OnDragWindow = InArgs._OnDragWindow;

        if (!BrowserWindow->OnConsoleMessage().IsBound())
        {
            BrowserWindow->OnConsoleMessage().BindSP(this, &SWebBrowserView::HandleConsoleMessage);
        }

        BrowserViewport = MakeShareable(new FWebBrowserViewport(BrowserWindow));
#if WITH_CEF3
        BrowserWidget->SetViewportInterface(BrowserViewport.ToSharedRef());
#endif
        // If we could not obtain the parent window during widget construction, we'll defer and keep trying.
        SetupParentWindowHandlers();
    }
    else
    {
        OnLoadError.ExecuteIfBound();
    }
}

int32 SWebBrowserView::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
    if (!SlateParentWindowPtr.IsValid())
    {
        SWebBrowserView* MutableThis = const_cast<SWebBrowserView*>(this);
        MutableThis->SetupParentWindowHandlers();
    }

    int32 Layer = SCompoundWidget::OnPaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
    
    // Cache a reference to our parent window, if we didn't already reference it.
    if (!SlateParentWindowPtr.IsValid())
    {
        SWindow* ParentWindow = OutDrawElements.GetPaintWindow();

        TSharedRef<SWindow> SlateParentWindowRef = StaticCastSharedRef<SWindow>(ParentWindow->AsShared());
        SlateParentWindowPtr = SlateParentWindowRef;
        if (BrowserWindow.IsValid())
        {
            BrowserWindow->SetParentWindow(SlateParentWindowRef);
        }
    }

    return Layer;
}

void SWebBrowserView::HandleWindowDeactivated()
{
    if (BrowserViewport.IsValid())
    {
        BrowserViewport->OnFocusLost(FFocusEvent());
    }
}

void SWebBrowserView::HandleWindowActivated()
{
    if (BrowserViewport.IsValid())
    {
        if (HasAnyUserFocusOrFocusedDescendants())
        {
            BrowserViewport->OnFocusReceived(FFocusEvent());
        }   
    }
}

void SWebBrowserView::LoadURL(FString NewURL)
{
    AddressBarUrl = FText::FromString(NewURL);
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->LoadURL(NewURL);
    }
}

void SWebBrowserView::LoadString(FString Contents, FString DummyURL)
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->LoadString(Contents, DummyURL);
    }
}

void SWebBrowserView::Reload()
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->Reload();
    }
}

void SWebBrowserView::StopLoad()
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->StopLoad();
    }
}

FText SWebBrowserView::GetTitleText() const
{
    if (BrowserWindow.IsValid())
    {
        return FText::FromString(BrowserWindow->GetTitle());
    }
    return LOCTEXT("InvalidWindow", "Browser Window is not valid/supported");
}

FString SWebBrowserView::GetUrl() const
{
    if (BrowserWindow.IsValid())
    {
        return BrowserWindow->GetUrl();
    }

    return FString();
}

FText SWebBrowserView::GetAddressBarUrlText() const
{
    if(BrowserWindow.IsValid())
    {
        return AddressBarUrl;
    }
    return FText::GetEmpty();
}

bool SWebBrowserView::IsLoaded() const
{
    if (BrowserWindow.IsValid())
    {
        return (BrowserWindow->GetDocumentLoadingState() == EWebBrowserDocumentState::Completed);
    }

    return false;
}

bool SWebBrowserView::IsLoading() const
{
    if (BrowserWindow.IsValid())
    {
        return (BrowserWindow->GetDocumentLoadingState() == EWebBrowserDocumentState::Loading);
    }

    return false;
}

bool SWebBrowserView::CanGoBack() const
{
    if (BrowserWindow.IsValid())
    {
        return BrowserWindow->CanGoBack();
    }
    return false;
}

void SWebBrowserView::GoBack()
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->GoBack();
    }
}

bool SWebBrowserView::CanGoForward() const
{
    if (BrowserWindow.IsValid())
    {
        return BrowserWindow->CanGoForward();
    }
    return false;
}

void SWebBrowserView::GoForward()
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->GoForward();
    }
}

bool SWebBrowserView::IsInitialized() const
{
    return BrowserWindow.IsValid() &&  BrowserWindow->IsInitialized();
}

void SWebBrowserView::SetupParentWindowHandlers()
{
    if (!SlateParentWindowPtr.IsValid())
    {
        SlateParentWindowPtr = FSlateApplication::Get().FindWidgetWindow(SharedThis(this));

        TSharedPtr<SWindow> SlateParentWindow = SlateParentWindowPtr.Pin();
        if (SlateParentWindow.IsValid() && BrowserWindow.IsValid())
        {
            if (!SlateParentWindow->GetOnWindowDeactivatedEvent().IsBoundToObject(this))
            {
                SlateParentWindow->GetOnWindowDeactivatedEvent().AddSP(this, &SWebBrowserView::HandleWindowDeactivated);
            }

            if (!SlateParentWindow->GetOnWindowActivatedEvent().IsBoundToObject(this))
            {
                SlateParentWindow->GetOnWindowActivatedEvent().AddSP(this, &SWebBrowserView::HandleWindowActivated);
            }

            BrowserWindow->SetParentWindow(SlateParentWindow);
        }
    }
}

void SWebBrowserView::HandleBrowserWindowDocumentStateChanged(EWebBrowserDocumentState NewState)
{
    switch (NewState)
    {
    case EWebBrowserDocumentState::Completed:
        {
            if (BrowserWindow.IsValid())
            {
                for (auto Adapter : Adapters)
                {
                    Adapter->ConnectTo(BrowserWindow.ToSharedRef());
                }
            }

            OnLoadCompleted.ExecuteIfBound();
        }
        break;

    case EWebBrowserDocumentState::Error:
        OnLoadError.ExecuteIfBound();
        break;

    case EWebBrowserDocumentState::Loading:
        OnLoadStarted.ExecuteIfBound();
        break;
    }
}

void SWebBrowserView::HandleBrowserWindowNeedsRedraw()
{
    if (FSlateApplication::Get().IsSlateAsleep())
    {
        // Tell slate that the widget needs to wake up for one frame to get redrawn
        RegisterActiveTimer(0.f, FWidgetActiveTimerDelegate::CreateLambda([this](double InCurrentTime, float InDeltaTime) { return EActiveTimerReturnType::Stop; }));
    }
}

void SWebBrowserView::HandleTitleChanged( FString NewTitle )
{
    const FText NewTitleText = FText::FromString(NewTitle);
    OnTitleChanged.ExecuteIfBound(NewTitleText);
}

void SWebBrowserView::HandleUrlChanged( FString NewUrl )
{
    AddressBarUrl = FText::FromString(NewUrl);
    OnUrlChanged.ExecuteIfBound(AddressBarUrl);
}

void SWebBrowserView::CloseBrowser()
{
    BrowserWindow->CloseBrowser(true /*force*/, true /*block until closed*/);
}

void SWebBrowserView::HandleToolTip(FString ToolTipText)
{
    if(ToolTipText.IsEmpty())
    {
        FSlateApplication::Get().CloseToolTip();
        SetToolTip(nullptr);
    }
    else if (OnCreateToolTip.IsBound())
    {
        SetToolTip(OnCreateToolTip.Execute(FText::FromString(ToolTipText)));
        FSlateApplication::Get().UpdateToolTip(true);
    }
    else
    {
        SetToolTipText(FText::FromString(ToolTipText));
        FSlateApplication::Get().UpdateToolTip(true);
    }
}

bool SWebBrowserView::HandleBeforeNavigation(const FString& Url, const FWebNavigationRequest& Request)
{
    if(OnBeforeNavigation.IsBound())
    {
        return OnBeforeNavigation.Execute(Url, Request);
    }
    return false;
}

bool SWebBrowserView::HandleLoadUrl(const FString& Method, const FString& Url, FString& OutResponse)
{
    if(OnLoadUrl.IsBound())
    {
        return OnLoadUrl.Execute(Method, Url, OutResponse);
    }
    return false;
}

EWebBrowserDialogEventResponse SWebBrowserView::HandleShowDialog(const TWeakPtr<IWebBrowserDialog>& DialogParams)
{
    if(OnShowDialog.IsBound())
    {
        return OnShowDialog.Execute(DialogParams);
    }
    return EWebBrowserDialogEventResponse::Unhandled;
}

void SWebBrowserView::HandleDismissAllDialogs()
{
    OnDismissAllDialogs.ExecuteIfBound();
}


bool SWebBrowserView::HandleBeforePopup(FString URL, FString Target)
{
    if (OnBeforePopup.IsBound())
    {
        return OnBeforePopup.Execute(URL, Target);
    }

    return false;
}

void SWebBrowserView::ExecuteJavascript(const FString& ScriptText)
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->ExecuteJavascript(ScriptText);
    }
}

void SWebBrowserView::GetSource(TFunction<void (const FString&)> Callback) const
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->GetSource(Callback);
    }
}


bool SWebBrowserView::HandleCreateWindow(const TWeakPtr<IWebBrowserWindow>& NewBrowserWindow, const TWeakPtr<IWebBrowserPopupFeatures>& PopupFeatures)
{
    if(OnCreateWindow.IsBound())
    {
        return OnCreateWindow.Execute(NewBrowserWindow, PopupFeatures);
    }
    return false;
}

bool SWebBrowserView::HandleCloseWindow(const TWeakPtr<IWebBrowserWindow>& NewBrowserWindow)
{
    if(OnCloseWindow.IsBound())
    {
        return OnCloseWindow.Execute(NewBrowserWindow);
    }
    return false;
}

void SWebBrowserView::BindUObject(const FString& Name, UObject* Object, bool bIsPermanent)
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->BindUObject(Name, Object, bIsPermanent);
    }
}

void SWebBrowserView::UnbindUObject(const FString& Name, UObject* Object, bool bIsPermanent)
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->UnbindUObject(Name, Object, bIsPermanent);
    }
}

void SWebBrowserView::BindAdapter(const TSharedRef<IWebBrowserAdapter>& Adapter)
{
    Adapters.Add(Adapter);
    if (BrowserWindow.IsValid())
    {
        Adapter->ConnectTo(BrowserWindow.ToSharedRef());
    }
}

void SWebBrowserView::UnbindAdapter(const TSharedRef<IWebBrowserAdapter>& Adapter)
{
    Adapters.Remove(Adapter);
    if (BrowserWindow.IsValid())
    {
        Adapter->DisconnectFrom(BrowserWindow.ToSharedRef());
    }
}

void SWebBrowserView::BindInputMethodSystem(ITextInputMethodSystem* TextInputMethodSystem)
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->BindInputMethodSystem(TextInputMethodSystem);
    }
}

void SWebBrowserView::UnbindInputMethodSystem()
{
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->UnbindInputMethodSystem();
    }
}

void SWebBrowserView::HandleShowPopup(const FIntRect& PopupSize)
{
    check(!PopupMenuPtr.IsValid())

    TSharedPtr<SViewport> MenuContent;
    SAssignNew(MenuContent, SViewport)
                .ViewportSize(PopupSize.Size())
                .EnableGammaCorrection(false)
                .EnableBlending(false)
                .IgnoreTextureAlpha(true)
#if WITH_CEF3
                .RenderTransform(this, &SWebBrowserView::GetPopupRenderTransform)
#endif
                .Visibility(EVisibility::Visible);
        MenuViewport = MakeShareable(new FWebBrowserViewport(BrowserWindow, true));
    MenuContent->SetViewportInterface(MenuViewport.ToSharedRef());
    FWidgetPath WidgetPath;
    FSlateApplication::Get().GeneratePathToWidgetUnchecked(SharedThis(this), WidgetPath);
    if (WidgetPath.IsValid())
    {
        TSharedRef< SWidget > MenuContentRef = MenuContent.ToSharedRef();
        const FGeometry& BrowserGeometry = WidgetPath.Widgets.Last().Geometry;
        const FVector2D NewPosition = BrowserGeometry.LocalToAbsolute(PopupSize.Min);


        // Open the pop-up. The popup method will be queried from the widget path passed in.
        TSharedPtr<IMenu> NewMenu = FSlateApplication::Get().PushMenu(SharedThis(this), WidgetPath, MenuContentRef, NewPosition, FPopupTransitionEffect( FPopupTransitionEffect::ComboButton ), false);
        NewMenu->GetOnMenuDismissed().AddSP(this, &SWebBrowserView::HandleMenuDismissed);
        PopupMenuPtr = NewMenu;
    }

}

TOptional <FSlateRenderTransform> SWebBrowserView::GetPopupRenderTransform() const
{
    if (BrowserWindow.IsValid())
    {
#if !defined(DUMMY_WEB_BROWSER) && WITH_CEF3
        TOptional<FSlateRenderTransform> LocalRenderTransform = FSlateRenderTransform();
        if (static_cast<FWebBrowserWindow*>(BrowserWindow.Get())->UsingAcceleratedPaint())
        {
            // the accelerated renderer for CEF generates inverted textures (compared to the slate co-ord system), so flip it here
            LocalRenderTransform = FSlateRenderTransform(Concatenate(FScale2D(1, -1), FVector2D(0, PopupMenuPtr.Pin()->GetContent()->GetDesiredSize().Y)));
        }
        return LocalRenderTransform;
#else
        return FSlateRenderTransform();
#endif
    }
    else
    {
        return FSlateRenderTransform();
    }
}

void SWebBrowserView::HandleMenuDismissed(TSharedRef<IMenu>)
{
    PopupMenuPtr.Reset();
}

void SWebBrowserView::HandleDismissPopup()
{
    if (PopupMenuPtr.IsValid())
    {
        PopupMenuPtr.Pin()->Dismiss();
        FSlateApplication::Get().SetKeyboardFocus(SharedThis(this), EFocusCause::SetDirectly);
    }
}

bool SWebBrowserView::HandleSuppressContextMenu()
{
    if (OnSuppressContextMenu.IsBound())
    {
        return OnSuppressContextMenu.Execute();
    }

    return false;
}

bool SWebBrowserView::HandleDrag(const FPointerEvent& MouseEvent)
{
    if (OnDragWindow.IsBound())
    {
        return OnDragWindow.Execute(MouseEvent);
    }
    return false;
}

bool SWebBrowserView::UnhandledKeyDown(const FKeyEvent& KeyEvent)
{
    if (OnUnhandledKeyDown.IsBound())
    {
        return OnUnhandledKeyDown.Execute(KeyEvent);
    }
    return false;
}

bool SWebBrowserView::UnhandledKeyUp(const FKeyEvent& KeyEvent)
{
    if (OnUnhandledKeyUp.IsBound())
    {
        return OnUnhandledKeyUp.Execute(KeyEvent);
    }
    return false;
}

bool SWebBrowserView::UnhandledKeyChar(const FCharacterEvent& CharacterEvent)
{
    if (OnUnhandledKeyChar.IsBound())
    {
        return OnUnhandledKeyChar.Execute(CharacterEvent);
    }
    return false;
}

void SWebBrowserView::SetParentWindow(TSharedPtr<SWindow> Window)
{
    SetupParentWindowHandlers();
    if (BrowserWindow.IsValid())
    {
        BrowserWindow->SetParentWindow(Window);
    }
}

void SWebBrowserView::SetBrowserKeyboardFocus()
{
    BrowserWindow->OnFocus(HasAnyUserFocusOrFocusedDescendants(), false);
}

void SWebBrowserView::HandleConsoleMessage(const FString& Message, const FString& Source, int32 Line, EWebBrowserConsoleLogSeverity Serverity)
{
    OnConsoleMessage.ExecuteIfBound(Message, Source, Line, Serverity);
}

#undef LOCTEXT_NAMESPACE

因此实现原理在WebBrowserWidget我们继承官方的WebBrowser进行扩展即可

首先实现html的代码