1847 lines
47 KiB
C++
1847 lines
47 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "ApplePlatformWebBrowser.h"
|
|
|
|
#if !WITH_CEF3 && (PLATFORM_IOS || PLATFORM_MAC)
|
|
|
|
#if PLATFORM_IOS
|
|
#include "IOS/IOSView.h"
|
|
#include "IOS/IOSAppDelegate.h"
|
|
#else
|
|
#include "Mac/CocoaWindow.h"
|
|
#include "Mac/CocoaThread.h"
|
|
#include "Mac/MacWindow.h"
|
|
#include "Mac/MacApplication.h"
|
|
#endif
|
|
|
|
#include "Async/Async.h"
|
|
#include "Widgets/SLeafWidget.h"
|
|
#include "PlatformHttp.h"
|
|
#include "HAL/PlatformProcess.h"
|
|
|
|
#include "Framework/Application/SlateApplication.h"
|
|
#include "Framework/Docking/TabManager.h"
|
|
#include "Rendering/SlateRenderer.h"
|
|
#include "Textures/SlateUpdatableTexture.h"
|
|
#include "Widgets/Docking/SDockTab.h"
|
|
|
|
#import <MetalKit/MetalKit.h>
|
|
#include "ExternalTexture.h"
|
|
#include "WebBrowserModule.h"
|
|
#include "WebViewCloseButton.h"
|
|
#include "IWebBrowserSingleton.h"
|
|
|
|
#include "Apple/AppleAsyncTask.h"
|
|
#include "AppleCookieManager.h"
|
|
#include "WebView3DInputHandler.h"
|
|
|
|
DEFINE_LOG_CATEGORY(LogAppleWebBrowser);
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
TAutoConsoleVariable<bool> CVarWebViewEnableInspectable(
|
|
TEXT("webview.EnableInspectable"),
|
|
false,
|
|
TEXT("Allows webview to be debuggable through Safari Web Inspector."),
|
|
ECVF_Default
|
|
);
|
|
#endif
|
|
|
|
class SAppleWebBrowserWidget : public SViewport
|
|
{
|
|
SLATE_BEGIN_ARGS(SAppleWebBrowserWidget)
|
|
: _InitialURL("about:blank")
|
|
, _UseTransparency(false)
|
|
{ }
|
|
|
|
SLATE_ARGUMENT(FString, InitialURL);
|
|
SLATE_ARGUMENT(bool, UseTransparency);
|
|
SLATE_ARGUMENT(TSharedPtr<FWebBrowserWindow>, WebBrowserWindow);
|
|
SLATE_ARGUMENT(FString, UserAgentApplication);
|
|
|
|
SLATE_END_ARGS()
|
|
|
|
SAppleWebBrowserWidget()
|
|
: WebViewWrapper(nil)
|
|
{}
|
|
|
|
void Construct(const FArguments& Args)
|
|
{
|
|
WebBrowserWindowPtr = Args._WebBrowserWindow;
|
|
Is3DBrowser = false;
|
|
bAcquiredInitialFocus = false;
|
|
bFocused = false;
|
|
|
|
bool bEnableFloatingCloseButton = false;
|
|
GConfig->GetBool(TEXT("Browser"), TEXT("bEnableFloatingCloseButton"), bEnableFloatingCloseButton, GEngineIni);
|
|
|
|
WebViewWrapper = [AppleWebViewWrapper alloc];
|
|
[WebViewWrapper create : this userAgentApplication : Args._UserAgentApplication.GetNSString() useTransparency : Args._UseTransparency enableFloatingCloseButton : bEnableFloatingCloseButton];
|
|
|
|
#if !PLATFORM_TVOS
|
|
OnSafeFrameChangedEventHandle = FCoreDelegates::OnSafeFrameChangedEvent.AddLambda( [this]()
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper didRotate];
|
|
}
|
|
});
|
|
|
|
|
|
TextureSamplePool = new FWebBrowserTextureSamplePool();
|
|
WebBrowserTextureSamplesQueue = MakeShared<FWebBrowserTextureSampleQueue, ESPMode::ThreadSafe>();
|
|
WebBrowserTexture = nullptr;
|
|
WebBrowserMaterial = nullptr;
|
|
WebBrowserBrush = nullptr;
|
|
|
|
// create external texture
|
|
WebBrowserTexture = NewObject<UWebBrowserTexture>((UObject*)GetTransientPackage(), NAME_None, RF_Transient | RF_Public);
|
|
|
|
if (WebBrowserTexture.IsValid())
|
|
{
|
|
WebBrowserTexture->UpdateResource();
|
|
WebBrowserTexture->AddToRoot();
|
|
}
|
|
|
|
// create wrapper material
|
|
IWebBrowserSingleton* WebBrowserSingleton = IWebBrowserModule::Get().GetSingleton();
|
|
|
|
UMaterialInterface* DefaultWBMaterial = Args._UseTransparency ? WebBrowserSingleton->GetDefaultTranslucentMaterial() : WebBrowserSingleton->GetDefaultMaterial();
|
|
if (WebBrowserSingleton && DefaultWBMaterial)
|
|
{
|
|
// create wrapper material
|
|
WebBrowserMaterial = UMaterialInstanceDynamic::Create(DefaultWBMaterial, nullptr);
|
|
|
|
if (WebBrowserMaterial.IsValid())
|
|
{
|
|
WebBrowserMaterial->SetTextureParameterValue("SlateUI", WebBrowserTexture.Get());
|
|
WebBrowserMaterial->AddToRoot();
|
|
|
|
// create Slate brush
|
|
WebBrowserBrush = MakeShareable(new FSlateBrush());
|
|
{
|
|
WebBrowserBrush->SetResourceObject(WebBrowserMaterial.Get());
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
LoadURL(Args._InitialURL);
|
|
}
|
|
|
|
void UpdateFrameWithViewport(FIntPoint WindowSize, FIntPoint WindowPos) {
|
|
CGRect NewFrame;
|
|
#if PLATFORM_MAC
|
|
TSharedPtr<FGenericWindow> EnclosedWindow = WebBrowserWindowPtr.Pin()->GetParentWindow()->GetNativeWindow();
|
|
|
|
if(!Is3DBrowser)
|
|
{
|
|
NSWindow* ParentWindow = (NSWindow*)EnclosedWindow->GetOSWindowHandle();
|
|
float ScaleFactor = [ParentWindow backingScaleFactor];
|
|
const FVector2D CocoaPosition = FMacApplication::ConvertSlatePositionToCocoa(WindowPos.X, WindowPos.Y);
|
|
|
|
WindowSize.X /= ScaleFactor;
|
|
WindowSize.Y /= ScaleFactor;
|
|
|
|
NSRect ParentFrame = [ParentWindow frame];
|
|
NSRect Rect = NSMakeRect(CocoaPosition.X - ParentFrame.origin.x, (CocoaPosition.Y - ParentFrame.origin.y) - WindowSize.Y,
|
|
FMath::Max(WindowSize.X, 1), FMath::Max(WindowSize.Y, 1));
|
|
Rect = [ParentWindow frameRectForContentRect : Rect];
|
|
|
|
// CGRect and NSRect have the same memory layout
|
|
NewFrame = NSRectToCGRect(Rect);
|
|
|
|
if(PastEnclosedWindow != EnclosedWindow)
|
|
{
|
|
WindowFrame = NewFrame;
|
|
PastEnclosedWindow = EnclosedWindow;
|
|
LeaveDeadWindow();
|
|
}
|
|
}
|
|
#else
|
|
{
|
|
UIView* View = [IOSAppDelegate GetDelegate].IOSView;
|
|
CGFloat ContentScaleFactor = View.contentScaleFactor;
|
|
|
|
FVector2D PosVector2D = WindowPos * ContentScaleFactor;
|
|
|
|
WindowPos /= ContentScaleFactor;
|
|
WindowSize /= ContentScaleFactor;
|
|
|
|
NewFrame.size.width = WindowSize.X;
|
|
NewFrame.size.height = WindowSize.Y;
|
|
|
|
NewFrame.origin.x = WindowPos.X;
|
|
NewFrame.origin.y = WindowPos.Y;
|
|
}
|
|
#endif
|
|
|
|
if(!Is3DBrowser && (bForceRecomputeWindowOnPaint || NewFrame.size.width != WindowFrame.size.width || NewFrame.size.height != WindowFrame.size.height))
|
|
{
|
|
// WindowFrame is only used when we are a 2D web browser
|
|
WindowFrame = NewFrame;
|
|
bForceRecomputeWindowOnPaint = false;
|
|
}
|
|
|
|
#if PLATFORM_IOS
|
|
[WebViewWrapper updateframe : WindowFrame window : nil];
|
|
#else
|
|
[WebViewWrapper updateframe : WindowFrame window : EnclosedWindow.Get()];
|
|
#endif
|
|
}
|
|
|
|
void WriteWebBrowserTexture(AppleWebViewWrapper* NativeWebBrowserPtr,
|
|
FGuid PlayerGuid, FIntPoint Size)
|
|
{
|
|
ENQUEUE_RENDER_COMMAND(WriteWebBrowser)(
|
|
[NativeWebBrowserPtr, PlayerGuid, Size](FRHICommandListImmediate& RHICmdList)
|
|
{
|
|
AppleWebViewWrapper* NativeWebBrowser = NativeWebBrowserPtr;
|
|
|
|
if (NativeWebBrowser == nil)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FTextureRHIRef VideoTexture = [NativeWebBrowser GetVideoTexture];
|
|
bool bStaleVideoTexture = VideoTexture != nullptr && VideoTexture->GetSizeXY() != Size;
|
|
|
|
if (VideoTexture == nullptr || bStaleVideoTexture)
|
|
{
|
|
// We need this texture to be accessible and writable from the CPU because we need to call
|
|
// replaceRegion:mipmapLevel:withBytes:bytesPerRow: to copy over a screenshot captured in WKWebView
|
|
// using takeSnapshotWithConfiguration:completionHandler: which gives us an UI/NSImage.
|
|
const FRHITextureCreateDesc Desc =
|
|
FRHITextureCreateDesc::Create2D(TEXT("SAppleWebBrowserWidget_VideoTexture"), Size, PF_R8G8B8A8)
|
|
.SetFlags(ETextureCreateFlags::CPUWritable | ETextureCreateFlags::CPUReadback);
|
|
|
|
VideoTexture = RHICmdList.CreateTexture(Desc);
|
|
[NativeWebBrowser SetVideoTexture : VideoTexture];
|
|
|
|
if (VideoTexture == nullptr)
|
|
{
|
|
UE_LOG(LogAppleWebBrowser, Warning, TEXT("CreateTexture failed!"));
|
|
return;
|
|
}
|
|
|
|
[NativeWebBrowser SetVideoTextureValid : false];
|
|
|
|
}
|
|
|
|
if ([NativeWebBrowser UpdateVideoFrame : VideoTexture->GetNativeResource()])
|
|
{
|
|
// if region changed, need to reregister UV scale/offset
|
|
//UE_LOG(LogAppleWebBrowser, Log, TEXT("UpdateVideoFrame RT: %s"), *Params.PlayerGuid.ToString());
|
|
}
|
|
|
|
if (![NativeWebBrowser IsVideoTextureValid])
|
|
{
|
|
FSamplerStateInitializerRHI SamplerStateInitializer(SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp);
|
|
FSamplerStateRHIRef SamplerStateRHI = RHICreateSamplerState(SamplerStateInitializer);
|
|
FExternalTextureRegistry::Get().RegisterExternalTexture(PlayerGuid, VideoTexture, SamplerStateRHI);
|
|
|
|
[NativeWebBrowser SetVideoTextureValid : true];
|
|
}
|
|
});
|
|
}
|
|
|
|
void Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
if (WebBrowserWindowPtr.IsValid())
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> WebBrowserWindow = WebBrowserWindowPtr.Pin();
|
|
WebBrowserWindow->SetTickLastFrame();
|
|
if (TSharedPtr<SWindow> ParentWindow = WebBrowserWindow->GetParentWindow())
|
|
{
|
|
bool ShouldSet3DBrowser = ParentWindow->IsVirtualWindow();
|
|
if (Is3DBrowser != ShouldSet3DBrowser)
|
|
{
|
|
Is3DBrowser = ShouldSet3DBrowser;
|
|
[WebViewWrapper set3D : Is3DBrowser];
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we are a 3D browser, we should let the Widget Interaction component fully control focus
|
|
// Otherwise, to keep parity with CEF, we should initially gain focus on the WebBrowser widget.
|
|
if(!bAcquiredInitialFocus && !Is3DBrowser && InKeyWindow())
|
|
{
|
|
FSlateApplication::Get().SetKeyboardFocus(SharedThis(this), EFocusCause::SetDirectly);
|
|
FSlateApplication::Get().ReleaseAllPointerCapture();
|
|
bAcquiredInitialFocus = true;
|
|
}
|
|
|
|
FVector2D Position = AllottedGeometry.GetAccumulatedRenderTransform().GetTranslation();
|
|
FVector2D Size = TransformVector(AllottedGeometry.GetAccumulatedRenderTransform(), AllottedGeometry.GetLocalSize());
|
|
FSlateRect SlateRect = AllottedGeometry.GetRenderBoundingRect();
|
|
|
|
UpdateFrameWithViewport(FIntPoint(static_cast<int32_t>(Size.X), static_cast<int32_t>(Size.Y)),
|
|
FIntPoint(static_cast<int32_t>(Position.X), static_cast<int32_t>(Position.Y)));
|
|
|
|
#if !PLATFORM_TVOS
|
|
if (Is3DBrowser)
|
|
{
|
|
if (WebBrowserTexture.IsValid())
|
|
{
|
|
TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe> WebBrowserTextureSample;
|
|
WebBrowserTextureSamplesQueue->Peek(WebBrowserTextureSample);
|
|
|
|
WebBrowserTexture->TickResource(WebBrowserTextureSample);
|
|
}
|
|
|
|
if (WebBrowserTexture.IsValid())
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> WebBrowserWindow = WebBrowserWindowPtr.Pin();
|
|
bool TextureWritten = false;
|
|
|
|
// GetViewportSize not 100% accurate in 3D mode, we use it as a
|
|
// reasonable default if we need to only
|
|
FIntPoint ViewportSize = WebBrowserWindow->GetViewportSize();
|
|
|
|
if(TSharedPtr<SWindow> ParentWindow = WebBrowserWindow->GetParentWindow())
|
|
{
|
|
FVector2f WindowSize = ParentWindow->GetSizeInScreen();
|
|
ViewportSize.X = static_cast<int32>(WindowSize.X);
|
|
ViewportSize.Y = static_cast<int32>(WindowSize.Y);
|
|
#if !PLATFORM_MAC
|
|
// needs to be on main thread for getScreenScale
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
FIntPoint ScaledViewportSize = ViewportSize;
|
|
CGFloat ScreenScale = [WebViewWrapper getScreenScale];
|
|
ScaledViewportSize.X *= ScreenScale;
|
|
ScaledViewportSize.Y *= ScreenScale;
|
|
|
|
WriteWebBrowserTexture(WebViewWrapper, WebBrowserTexture->GetExternalTextureGuid(), ScaledViewportSize);
|
|
});
|
|
TextureWritten = true;
|
|
#endif
|
|
}
|
|
|
|
if(!TextureWritten)
|
|
{
|
|
WriteWebBrowserTexture(WebViewWrapper, WebBrowserTexture->GetExternalTextureGuid(), ViewportSize);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|
|
int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
bool bIsVisible = !WebBrowserWindowPtr.IsValid() || WebBrowserWindowPtr.Pin()->IsVisible();
|
|
|
|
if (bIsVisible && Is3DBrowser && WebBrowserBrush.IsValid())
|
|
{
|
|
FSlateDrawElement::MakeBox(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), WebBrowserBrush.Get(), ESlateDrawEffect::None);
|
|
}
|
|
#endif
|
|
return LayerId;
|
|
}
|
|
|
|
virtual FVector2D ComputeDesiredSize(float) const override
|
|
{
|
|
return FVector2D(640, 480);
|
|
}
|
|
|
|
void LoadURL(const FString& InNewURL)
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper loadurl : [NSURL URLWithString : [NSString stringWithUTF8String : TCHAR_TO_UTF8(*InNewURL)]]];
|
|
}
|
|
}
|
|
|
|
void LoadString(const FString& InContents, const FString& InDummyURL)
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper loadstring : [NSString stringWithUTF8String : TCHAR_TO_UTF8(*InContents)] dummyurl : [NSURL URLWithString : [NSString stringWithUTF8String : TCHAR_TO_UTF8(*InDummyURL)]]];
|
|
}
|
|
}
|
|
|
|
void StopLoad()
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper stopLoading];
|
|
}
|
|
}
|
|
|
|
void Reload()
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper reload];
|
|
}
|
|
}
|
|
|
|
void Close()
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
FCoreDelegates::OnSafeFrameChangedEvent.Remove(OnSafeFrameChangedEventHandle);
|
|
#endif
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper close];
|
|
[WebViewWrapper release];
|
|
WebViewWrapper = nil;
|
|
}
|
|
WebBrowserWindowPtr.Reset();
|
|
|
|
#if !PLATFORM_TVOS
|
|
delete TextureSamplePool;
|
|
TextureSamplePool = nullptr;
|
|
|
|
WebBrowserTextureSamplesQueue->RequestFlush();
|
|
if (WebBrowserBrush.IsValid())
|
|
{
|
|
WebBrowserBrush->SetResourceObject(nullptr);
|
|
}
|
|
if (WebBrowserMaterial.IsValid())
|
|
{
|
|
WebBrowserMaterial->RemoveFromRoot();
|
|
WebBrowserMaterial = nullptr;
|
|
}
|
|
if (WebBrowserTexture.IsValid())
|
|
{
|
|
WebBrowserTexture->RemoveFromRoot();
|
|
WebBrowserTexture = nullptr;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void ShowFloatingCloseButton(bool bShow, bool bDraggable)
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper showFloatingCloseButton: bShow setDraggable: bDraggable];
|
|
}
|
|
}
|
|
|
|
void GoBack()
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper goBack];
|
|
}
|
|
}
|
|
|
|
void GoForward()
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper goForward];
|
|
}
|
|
}
|
|
|
|
|
|
bool CanGoBack()
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
return [WebViewWrapper canGoBack];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CanGoForward()
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
return [WebViewWrapper canGoForward];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SetWebBrowserVisibility(bool InIsVisible)
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
UE_LOG(LogAppleWebBrowser, Warning, TEXT("SetWebBrowserVisibility %d!"), InIsVisible);
|
|
|
|
[WebViewWrapper setVisibility : InIsVisible];
|
|
}
|
|
}
|
|
|
|
bool HandleOnBeforePopup(const FString& UrlStr, const FString& FrameName)
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> BrowserWindow = WebBrowserWindowPtr.Pin();
|
|
if (BrowserWindow.IsValid() && BrowserWindow->OnBeforePopup().IsBound())
|
|
{
|
|
return BrowserWindow->OnBeforePopup().Execute(UrlStr, FrameName);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool HandleShouldOverrideUrlLoading(const FString& Url)
|
|
{
|
|
// UE-347936 Abnormal requests in EDA webpage, ignore these
|
|
if (WebBrowserWindowPtr.IsValid() && !Url.Equals(TEXT("about:blank")) && !Url.Equals(TEXT("about:srcdoc")))
|
|
{
|
|
// Capture vars needed for AsyncTask
|
|
NSString* UrlString = [NSString stringWithUTF8String : TCHAR_TO_UTF8(*Url)];
|
|
TWeakPtr<FWebBrowserWindow> AsyncWebBrowserWindowPtr = WebBrowserWindowPtr;
|
|
|
|
// Notify on the game thread
|
|
[FAppleAsyncTask CreateTaskWithBlock : ^ bool(void)
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> BrowserWindow = AsyncWebBrowserWindowPtr.Pin();
|
|
if (BrowserWindow.IsValid())
|
|
{
|
|
if (BrowserWindow->OnBeforeBrowse().IsBound())
|
|
{
|
|
FWebNavigationRequest RequestDetails;
|
|
RequestDetails.bIsRedirect = false;
|
|
RequestDetails.bIsMainFrame = true; // shouldOverrideUrlLoading is only called on the main frame
|
|
|
|
BrowserWindow->OnBeforeBrowse().Execute(UrlString, RequestDetails);
|
|
BrowserWindow->SetTitle("");
|
|
}
|
|
}
|
|
return true;
|
|
}];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void HandleReceivedTitle(const FString& Title)
|
|
{
|
|
if (WebBrowserWindowPtr.IsValid())
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> BrowserWindow = WebBrowserWindowPtr.Pin();
|
|
if (BrowserWindow.IsValid() && !BrowserWindow->GetTitle().Equals(Title))
|
|
{
|
|
BrowserWindow->SetTitle(Title);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProcessScriptMessage(const FString& InMessage)
|
|
{
|
|
if (WebBrowserWindowPtr.IsValid())
|
|
{
|
|
FString Message = InMessage;
|
|
TWeakPtr<FWebBrowserWindow> AsyncWebBrowserWindowPtr = WebBrowserWindowPtr;
|
|
|
|
[FAppleAsyncTask CreateTaskWithBlock : ^ bool(void)
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> BrowserWindow = AsyncWebBrowserWindowPtr.Pin();
|
|
if (BrowserWindow.IsValid())
|
|
{
|
|
TArray<FString> Params;
|
|
Message.ParseIntoArray(Params, TEXT("/"), false);
|
|
if (Params.Num() > 0)
|
|
{
|
|
for (int I = 0; I < Params.Num(); I++)
|
|
{
|
|
Params[I] = FPlatformHttp::UrlDecode(Params[I]);
|
|
}
|
|
|
|
FString Command = Params[0];
|
|
Params.RemoveAt(0, 1);
|
|
BrowserWindow->OnJsMessageReceived(Command, Params, "");
|
|
}
|
|
else
|
|
{
|
|
GLog->Logf(ELogVerbosity::Error, TEXT("Invalid message from browser view: %s"), *Message);
|
|
}
|
|
}
|
|
return true;
|
|
}];
|
|
}
|
|
}
|
|
|
|
void HandlePageLoad(const FString& InCurrentUrl, bool bIsLoading)
|
|
{
|
|
if (WebBrowserWindowPtr.IsValid())
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> BrowserWindow = WebBrowserWindowPtr.Pin();
|
|
if (BrowserWindow.IsValid())
|
|
{
|
|
BrowserWindow->NotifyDocumentLoadingStateChange(InCurrentUrl, bIsLoading);
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandleReceivedError(int ErrorCode, const FString& InCurrentUrl)
|
|
{
|
|
if (WebBrowserWindowPtr.IsValid())
|
|
{
|
|
TSharedPtr<FWebBrowserWindow> BrowserWindow = WebBrowserWindowPtr.Pin();
|
|
if (BrowserWindow.IsValid())
|
|
{
|
|
BrowserWindow->NotifyDocumentError(InCurrentUrl, ErrorCode);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ExecuteJavascript(const FString& Script)
|
|
{
|
|
if (WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper executejavascript : [NSString stringWithUTF8String : TCHAR_TO_UTF8(*Script)]];
|
|
}
|
|
}
|
|
|
|
void FloatingCloseButtonPressed()
|
|
{
|
|
if (WebBrowserWindowPtr.IsValid())
|
|
{
|
|
TWeakPtr<FWebBrowserWindow> AsyncWebBrowserWindowPtr = WebBrowserWindowPtr;
|
|
|
|
#if !PLATFORM_MAC
|
|
[FAppleAsyncTask CreateTaskWithBlock : ^ bool(void)
|
|
{
|
|
if (TSharedPtr<FWebBrowserWindow> BrowserWindow = AsyncWebBrowserWindowPtr.Pin())
|
|
{
|
|
BrowserWindow->FloatingCloseButtonPressed();
|
|
}
|
|
return true;
|
|
}];
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void LeaveDeadWindow()
|
|
{
|
|
if(WebViewWrapper != nil)
|
|
{
|
|
[WebViewWrapper leaveDeadWindow];
|
|
}
|
|
}
|
|
|
|
void OnFocus(bool SetFocus)
|
|
{
|
|
if(SetFocus && !Is3D())
|
|
{
|
|
FSlateApplication::Get().ReleaseAllPointerCapture();
|
|
}
|
|
else if(!FSlateApplication::Get().IsActive() && bFocused)
|
|
{
|
|
// we changed windows but we still want to retain focus and prevent
|
|
// mouse capture since we were the last widget focused.
|
|
bAcquiredInitialFocus = false;
|
|
}
|
|
|
|
bFocused = SetFocus;
|
|
}
|
|
|
|
bool Is3D() const
|
|
{
|
|
return Is3DBrowser;
|
|
}
|
|
|
|
bool InKeyWindow()
|
|
{
|
|
return WebViewWrapper != nil && [WebViewWrapper inKeyWindow];
|
|
}
|
|
|
|
void OnActiveTabChanged(TSharedPtr<SDockTab> ActiveTab, TSharedPtr<SDockTab> PreviouslyActiveTab)
|
|
{
|
|
}
|
|
|
|
~SAppleWebBrowserWidget()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
protected:
|
|
mutable __strong AppleWebViewWrapper* WebViewWrapper;
|
|
private:
|
|
TWeakPtr<FGenericWindow> PastEnclosedWindow;
|
|
TWeakPtr<FWebBrowserWindow> WebBrowserWindowPtr;
|
|
|
|
/** Enable 3D appearance */
|
|
bool Is3DBrowser;
|
|
bool bAcquiredInitialFocus;
|
|
bool bFocused;
|
|
bool bForceRecomputeWindowOnPaint = false;
|
|
|
|
#if !PLATFORM_TVOS
|
|
/** The external texture to render the webbrowser output. */
|
|
TWeakObjectPtr<UWebBrowserTexture> WebBrowserTexture;
|
|
|
|
/** The material for the external texture. */
|
|
TWeakObjectPtr<UMaterialInstanceDynamic> WebBrowserMaterial;
|
|
|
|
/** The Slate brush that renders the material. */
|
|
TSharedPtr<FSlateBrush> WebBrowserBrush;
|
|
|
|
/** The sample queue. */
|
|
TSharedPtr<FWebBrowserTextureSampleQueue, ESPMode::ThreadSafe> WebBrowserTextureSamplesQueue;
|
|
|
|
/** Texture sample object pool. */
|
|
FWebBrowserTextureSamplePool* TextureSamplePool;
|
|
|
|
// Handle to detect changes in valid area to move the floating close button */
|
|
FDelegateHandle OnSafeFrameChangedEventHandle;
|
|
#endif
|
|
|
|
CGRect WindowFrame;
|
|
};
|
|
|
|
|
|
|
|
|
|
@implementation AppleWebViewWrapper
|
|
|
|
#if !PLATFORM_TVOS
|
|
@synthesize WebView;
|
|
#if PLATFORM_IOS
|
|
@synthesize CloseButton;
|
|
#endif
|
|
@synthesize WebViewContainer;
|
|
@synthesize UserContentController;
|
|
#endif
|
|
@synthesize NextURL;
|
|
@synthesize NextContent;
|
|
#if PLATFORM_MAC
|
|
@synthesize GameWindowView;
|
|
#endif
|
|
|
|
-(void)create:(SAppleWebBrowserWidget*)InWebBrowserWidget userAgentApplication: (NSString*)UserAgentApplication useTransparency : (bool)InUseTransparency enableFloatingCloseButton : (bool)bEnableFloatingCloseButton;
|
|
{
|
|
WebBrowserWidget = InWebBrowserWidget;
|
|
NextURL = nil;
|
|
NextContent = nil;
|
|
VideoTexture = nil;
|
|
bNeedsAddToView = true;
|
|
Is3DBrowser = false;
|
|
bVideoTextureValid = false;
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
BOOL Inspectable = CVarWebViewEnableInspectable.GetValueOnAnyThread()? YES : NO;
|
|
#endif
|
|
#if PLATFORM_MAC
|
|
GameWindowView = nil;
|
|
#endif
|
|
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
#if PLATFORM_IOS
|
|
self.WebViewContainer = [[UIView alloc]initWithFrame:CGRectMake(1, 1, 100, 100)];
|
|
[self.WebViewContainer setOpaque : NO];
|
|
[self.WebViewContainer setBackgroundColor : [UIColor clearColor]];
|
|
#else
|
|
self.WebViewContainer = [[NSView alloc]initWithFrame:CGRectMake(1, 1, 100, 100)];
|
|
#endif
|
|
|
|
WKWebViewConfiguration* theConfiguration = [[WKWebViewConfiguration alloc] init];
|
|
|
|
self.UserContentController = [[WKUserContentController alloc] init];
|
|
|
|
theConfiguration.websiteDataStore = [WKWebsiteDataStore dataStoreForIdentifier: FAppleCookieManager::CookieManagerIdentifier];
|
|
|
|
[theConfiguration.preferences setValue:@YES forKey:@"allowFileAccessFromFileURLs"];
|
|
[theConfiguration.preferences setValue:@YES forKey:@"developerExtrasEnabled"];
|
|
|
|
NSString* MessageHandlerName = [NSString stringWithFString : FMobileJSScripting::JSMessageHandler];
|
|
[self.UserContentController addScriptMessageHandler:self name: MessageHandlerName];
|
|
|
|
theConfiguration.applicationNameForUserAgent = UserAgentApplication;
|
|
theConfiguration.userContentController = self.UserContentController;
|
|
|
|
self.WebView = [[WKWebView alloc]initWithFrame:CGRectMake(1, 1, 100, 100)configuration : theConfiguration];
|
|
#if !UE_BUILD_SHIPPING
|
|
self.WebView.inspectable = Inspectable;
|
|
#endif
|
|
[self.WebViewContainer addSubview : WebView];
|
|
self.WebView.navigationDelegate = self;
|
|
self.WebView.UIDelegate = self;
|
|
|
|
#if PLATFORM_IOS
|
|
self.WebView.scrollView.bounces = NO;
|
|
|
|
if (InUseTransparency)
|
|
{
|
|
[self.WebView setOpaque : NO];
|
|
[self.WebView setBackgroundColor : [UIColor clearColor]];
|
|
}
|
|
else
|
|
{
|
|
[self.WebView setOpaque : YES];
|
|
}
|
|
|
|
if (bEnableFloatingCloseButton)
|
|
{
|
|
CloseButton = MakeCloseButton();
|
|
[self.WebView addSubview : CloseButton];
|
|
|
|
CloseButton.TapHandler = [^
|
|
{
|
|
// WebBrowserWidget should have the same lifecycle as this
|
|
// CloseButton (see [AppleWebViewWrapper cleanup],
|
|
// which is only called by SAppleWebBrowserWidget::Close()),
|
|
// so using this raw ptr should be safe. Previously, a
|
|
// shared ptr was used, but the shared ptr was created in the
|
|
// SAppleWebBrowserWidget's Construct function,
|
|
// which caused strange behavior with the TSharedRef SNew creates,
|
|
// potentially leading to over-releasing.
|
|
if(WebBrowserWidget != nil)
|
|
{
|
|
WebBrowserWidget->FloatingCloseButtonPressed();
|
|
}
|
|
} copy];
|
|
}
|
|
#endif
|
|
|
|
[theConfiguration release];
|
|
[self setDefaultVisibility];
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)didRotate;
|
|
{
|
|
#if !PLATFORM_TVOS && !PLATFORM_MAC
|
|
dispatch_async(dispatch_get_main_queue(), ^ {
|
|
if (CloseButton)
|
|
{
|
|
[CloseButton setupLayout];
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)cleanup;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
if(self.UserContentController != nil)
|
|
{
|
|
[self.UserContentController removeAllScriptMessageHandlers];
|
|
[self.UserContentController removeAllUserScripts];
|
|
|
|
[self.UserContentController release];
|
|
|
|
self.UserContentController = nil;
|
|
}
|
|
|
|
if (self.WebView != nil)
|
|
{
|
|
#if PLATFORM_MAC
|
|
if(self.WebView.window.firstResponder == self.WebView)
|
|
{
|
|
[self.WebView.window makeFirstResponder: nil];
|
|
}
|
|
#endif
|
|
|
|
self.WebView.navigationDelegate = nil;
|
|
self.WebView.UIDelegate = nil;
|
|
|
|
[self.WebView removeFromSuperview];
|
|
[self.WebViewContainer removeFromSuperview];
|
|
|
|
[self.WebView release];
|
|
[self.WebViewContainer release];
|
|
|
|
self.WebView = nil;
|
|
self.WebViewContainer = nil;
|
|
WebBrowserWidget = nil;
|
|
}
|
|
|
|
#if !PLATFORM_MAC
|
|
if (CloseButton != nil)
|
|
{
|
|
[CloseButton release];
|
|
CloseButton = nil;
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
-(void)close;
|
|
{
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
[self cleanup];
|
|
});
|
|
}
|
|
|
|
-(void)showFloatingCloseButton:(BOOL)bShow setDraggable:(BOOL)bDraggable;
|
|
{
|
|
#if !PLATFORM_TVOS && !PLATFORM_MAC
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
if (CloseButton)
|
|
{
|
|
[CloseButton showButton:bShow setDraggable: bDraggable];
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogAppleWebBrowser, Warning, TEXT("[PlatformWebBrowser]: Close button not enabled in config. Add config for Engine:[Browser]bEnableFloatingCloseButton=true"));
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)dealloc;
|
|
{
|
|
[self cleanup];
|
|
[NextContent release];
|
|
NextContent = nil;
|
|
[NextURL release];
|
|
NextURL = nil;
|
|
|
|
[super dealloc];
|
|
}
|
|
|
|
-(void)leaveDeadWindow;
|
|
{
|
|
if(!bNeedsAddToView && !Is3DBrowser)
|
|
{
|
|
bNeedsAddToView = true;
|
|
}
|
|
}
|
|
|
|
-(void)updateframe:(CGRect)InFrame window:(FGenericWindow*)EnclosedWindow;
|
|
{
|
|
self.DesiredFrame = InFrame;
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
BOOL Inspectable = CVarWebViewEnableInspectable.GetValueOnAnyThread()? YES : NO;
|
|
#endif
|
|
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
if (self.WebView != nil)
|
|
{
|
|
|
|
#if !UE_BUILD_SHIPPING
|
|
self.WebView.inspectable = Inspectable;
|
|
#endif
|
|
|
|
#if PLATFORM_MAC
|
|
if(Is3DBrowser)
|
|
{
|
|
if(bNeedsAddToView || !Current3DWindow.IsValid())
|
|
{
|
|
// we handle display of 3D WebViews but choose to still add it to the view hierarchy
|
|
// as a completely transparent view for better integration
|
|
// (allows audio playback, some tick-like JS events dispatched for us, probably some other stuff)
|
|
self.WebViewContainer.alphaValue = 0.0;
|
|
bNeedsAddToView = false;
|
|
|
|
AsyncTask(ENamedThreads::Type::GameThread, [self]()
|
|
{
|
|
if (const TSharedPtr<SWindow> ActiveWindow = FSlateApplication::Get().GetActiveTopLevelWindow())
|
|
{
|
|
FMacWindow* MacGameWindow = static_cast<FMacWindow*>(ActiveWindow->GetNativeWindow().Get());
|
|
|
|
if(MacGameWindow != nullptr)
|
|
{
|
|
FCocoaWindow* GameCocoaWindow = MacGameWindow->GetWindowHandle();
|
|
|
|
Current3DWindow = ActiveWindow;
|
|
self.GameWindowView = GameCocoaWindow.openGLView;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bNeedsAddToView = true;
|
|
}
|
|
});
|
|
}
|
|
else if(GameWindowView != nil)
|
|
{
|
|
[self.GameWindowView addSubview : WebViewContainer];
|
|
self.GameWindowView = nil;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self.WebViewContainer.frame = self.DesiredFrame;
|
|
self.WebView.frame = WebViewContainer.bounds;
|
|
}
|
|
#else
|
|
if(!Is3DBrowser)
|
|
{
|
|
self.WebViewContainer.frame = self.DesiredFrame;
|
|
self.WebView.frame = WebViewContainer.bounds;
|
|
}
|
|
#endif
|
|
if (bNeedsAddToView)
|
|
{
|
|
bNeedsAddToView = false;
|
|
|
|
#if PLATFORM_IOS
|
|
[self.WebViewContainer setOpaque : NO];
|
|
[self.WebViewContainer setBackgroundColor : [UIColor clearColor]];
|
|
[[IOSAppDelegate GetDelegate].IOSView addSubview : WebViewContainer];
|
|
|
|
if (CloseButton != nil)
|
|
{
|
|
[CloseButton setupLayout];
|
|
}
|
|
#else
|
|
FCocoaWindow *CocoaWindow = ((FMacWindow*)EnclosedWindow)->GetWindowHandle();
|
|
NSView *CocoaWindowView = CocoaWindow.openGLView;
|
|
|
|
[CocoaWindowView addSubview : self.WebViewContainer];
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
if (NextContent != nil)
|
|
{
|
|
// Load web content from string
|
|
[self.WebView loadHTMLString : NextContent baseURL : NextURL];
|
|
NextContent = nil;
|
|
NextURL = nil;
|
|
}
|
|
else if (NextURL != nil)
|
|
{
|
|
// Load web content from URL
|
|
NSURLRequest *nsrequest = [NSURLRequest requestWithURL : NextURL];
|
|
[self.WebView loadRequest : nsrequest];
|
|
NextURL = nil;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(NSString *)UrlDecode:(NSString *)stringToDecode
|
|
{
|
|
NSString *result = [stringToDecode stringByReplacingOccurrencesOfString : @"+" withString:@" "];
|
|
result = [result stringByRemovingPercentEncoding];
|
|
return result;
|
|
}
|
|
|
|
#if !PLATFORM_TVOS
|
|
-(void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage : (WKScriptMessage *)message
|
|
{
|
|
if ([message.body isKindOfClass : [NSString class]])
|
|
{
|
|
NSString *Message = message.body;
|
|
if (WebBrowserWidget != nil && Message != nil)
|
|
{
|
|
//NSLog(@"Received message %@", Message);
|
|
WebBrowserWidget->ProcessScriptMessage(Message);
|
|
}
|
|
|
|
}
|
|
}
|
|
#endif
|
|
|
|
-(void)executejavascript:(NSString*)InJavaScript
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
const char* InJavaScriptCString = [InJavaScript UTF8String];
|
|
FString InJavaScriptFString = FString(InJavaScriptCString);
|
|
|
|
//NSLog(@"executejavascript %@", InJavaScript);
|
|
|
|
[self.WebView evaluateJavaScript : InJavaScript completionHandler : ^(id Object, NSError* Error)
|
|
{
|
|
if(Error != nil)
|
|
{
|
|
const char *domainString = [Error.domain UTF8String];
|
|
/*UE_LOG(LogAppleWebBrowser, Error, TEXT("executeJavaScript(\"%s\") errored with NSError %d in domain %hs!"),
|
|
*InJavaScriptFString, Error.code, domainString);*/
|
|
}
|
|
}];
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)loadurl:(NSURL*)InURL;
|
|
{
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
self.NextURL = InURL;
|
|
});
|
|
}
|
|
|
|
-(void)loadstring:(NSString*)InString dummyurl : (NSURL*)InURL;
|
|
{
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
self.NextContent = InString;
|
|
self.NextURL = InURL;
|
|
});
|
|
}
|
|
|
|
-(void)set3D:(bool)InIs3DBrowser;
|
|
{
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
if (Is3DBrowser != InIs3DBrowser)
|
|
{
|
|
//default is 2D
|
|
Is3DBrowser = InIs3DBrowser;
|
|
[self setDefaultVisibility];
|
|
}
|
|
});
|
|
}
|
|
|
|
-(void)setDefaultVisibility;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
if (Is3DBrowser)
|
|
{
|
|
[self.WebViewContainer setHidden : YES];
|
|
}
|
|
else
|
|
{
|
|
[self.WebViewContainer setHidden : NO];
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)setVisibility:(bool)InIsVisible;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
if (InIsVisible)
|
|
{
|
|
[self setDefaultVisibility];
|
|
}
|
|
else
|
|
{
|
|
[self.WebViewContainer setHidden : YES];
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)stopLoading;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
[self.WebView stopLoading];
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)reload;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
[self.WebView reload];
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)goBack;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
[self.WebView goBack];
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(void)goForward;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
[self.WebView goForward];
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(bool)canGoBack;
|
|
{
|
|
#if PLATFORM_TVOS
|
|
return false;
|
|
#else
|
|
return [self.WebView canGoBack];
|
|
#endif
|
|
}
|
|
|
|
-(bool)canGoForward;
|
|
{
|
|
#if PLATFORM_TVOS
|
|
return false;
|
|
#else
|
|
return [self.WebView canGoForward];
|
|
#endif
|
|
}
|
|
|
|
-(FTextureRHIRef)GetVideoTexture;
|
|
{
|
|
return VideoTexture;
|
|
}
|
|
|
|
-(void)SetVideoTexture:(FTextureRHIRef)Texture;
|
|
{
|
|
VideoTexture = Texture;
|
|
}
|
|
|
|
-(void)SetVideoTextureValid:(bool)Condition;
|
|
{
|
|
bVideoTextureValid = Condition;
|
|
}
|
|
|
|
-(bool)IsVideoTextureValid;
|
|
{
|
|
return bVideoTextureValid;
|
|
}
|
|
|
|
-(bool)UpdateVideoFrame:(void*)ptr;
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
@synchronized(self) // Briefly block render thread
|
|
{
|
|
id<MTLTexture> ptrToMetalTexture = (id<MTLTexture>)ptr;
|
|
NSUInteger width = [ptrToMetalTexture width];
|
|
NSUInteger height = [ptrToMetalTexture height];
|
|
|
|
[self updateWebViewMetalTexture : ptrToMetalTexture];
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
#if !PLATFORM_MAC
|
|
-(CGFloat)getScreenScale
|
|
{
|
|
#if !PLATFORM_VISIONOS
|
|
for(UIScene* scene in UIApplication.sharedApplication.connectedScenes)
|
|
{
|
|
if([scene isMemberOfClass:[UIWindowScene class]])
|
|
{
|
|
for(UIWindow* window in ((UIWindowScene*)scene).windows)
|
|
{
|
|
if(window.isKeyWindow)
|
|
{
|
|
return ((UIWindowScene*)scene).screen.scale;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
-(void)updateWebViewMetalTexture:(id<MTLTexture>)texture
|
|
{
|
|
#if !PLATFORM_TVOS
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^
|
|
{
|
|
@autoreleasepool
|
|
{
|
|
WKSnapshotConfiguration *SnapshotConfig = [[WKSnapshotConfiguration alloc] init];
|
|
|
|
NSUInteger TextureWidth = [texture width];
|
|
NSUInteger TextureHeight = [texture height];
|
|
#if PLATFORM_MAC
|
|
NSUInteger Width = TextureWidth;
|
|
NSUInteger Height = TextureHeight;
|
|
WebView.frame = CGRectMake(0, 0, Width, Height);
|
|
#else
|
|
float ScreenScale = [self getScreenScale];
|
|
NSUInteger Width = TextureWidth / ScreenScale;
|
|
NSUInteger Height = TextureHeight / ScreenScale;
|
|
|
|
UIView* View = [IOSAppDelegate GetDelegate].IOSView;
|
|
CGFloat ContentScaleFactor = View.contentScaleFactor;
|
|
|
|
WebView.frame = CGRectMake(0, 0, ContentScaleFactor * Width, ContentScaleFactor * Height);
|
|
#endif
|
|
SnapshotConfig.rect = CGRectMake(0, 0, WebView.bounds.size.width, WebView.bounds.size.height);
|
|
|
|
[WebView takeSnapshotWithConfiguration : SnapshotConfig
|
|
completionHandler :
|
|
#if PLATFORM_MAC
|
|
^ void(NSImage *Image, NSError *Error)
|
|
#else
|
|
^ void(UIImage *Image, NSError *Error)
|
|
#endif
|
|
{
|
|
if(Error != nil)
|
|
{
|
|
UE_LOG(LogAppleWebBrowser, Error, TEXT("takeSnapshotWithConfiguration errored with NSError %d!"), Error.code);
|
|
|
|
[SnapshotConfig release];
|
|
return;
|
|
}
|
|
|
|
CGColorSpaceRef ColorSpace = CGColorSpaceCreateDeviceRGB();
|
|
CGContextRef WebViewContext = CGBitmapContextCreate(NULL, TextureWidth, TextureHeight, 8, 4 * TextureWidth, ColorSpace, (CGBitmapInfo)kCGImageAlphaPremultipliedLast);
|
|
|
|
#if PLATFORM_MAC
|
|
NSGraphicsContext *NewGfxContext = [NSGraphicsContext graphicsContextWithCGContext : WebViewContext
|
|
flipped : NO];
|
|
NSGraphicsContext *OldGfxContext = NSGraphicsContext.currentContext;
|
|
NSGraphicsContext.currentContext = NewGfxContext;
|
|
|
|
[Image drawInRect: WebView.frame];
|
|
|
|
NSGraphicsContext.currentContext = OldGfxContext;
|
|
#else
|
|
CGContextDrawImage(WebViewContext, CGRectMake(0, 0, TextureWidth, TextureHeight), Image.CGImage);
|
|
#endif
|
|
[texture replaceRegion : MTLRegionMake2D(0, 0, TextureWidth, TextureHeight)
|
|
mipmapLevel : 0
|
|
withBytes : CGBitmapContextGetData(WebViewContext)
|
|
bytesPerRow : 4 * TextureWidth];
|
|
|
|
Image = nil;
|
|
|
|
CGColorSpaceRelease(ColorSpace);
|
|
CGContextRelease(WebViewContext);
|
|
[SnapshotConfig release];
|
|
}];
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
-(bool)inKeyWindow;
|
|
{
|
|
#if PLATFORM_TVOS
|
|
return YES;
|
|
#else
|
|
if(self.WebViewContainer != nil && [self.WebViewContainer window] != nil)
|
|
{
|
|
return [[self.WebViewContainer window] isKeyWindow];
|
|
}
|
|
else
|
|
{
|
|
return NO;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !PLATFORM_TVOS
|
|
|
|
- (nullable WKWebView *)webView:(WKWebView *)InWebView createWebViewWithConfiguration:(WKWebViewConfiguration *)InConfiguration forNavigationAction:(WKNavigationAction *)InNavigationAction windowFeatures:(WKWindowFeatures *)InWindowFeatures
|
|
{
|
|
NSURLRequest *request = InNavigationAction.request;
|
|
FString UrlStr([[request URL] absoluteString]);
|
|
|
|
if (InNavigationAction.targetFrame == nil && !UrlStr.IsEmpty() && FPlatformProcess::CanLaunchURL(*UrlStr))
|
|
{
|
|
if (WebBrowserWidget->HandleOnBeforePopup(UrlStr, TEXT("_blank")))
|
|
{
|
|
// Launched the URL in external browser, don't create a new webview
|
|
return nil;
|
|
}
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
- (void)webView:(WKWebView*)InWebView decidePolicyForNavigationAction : (WKNavigationAction*)InNavigationAction decisionHandler : (void(^)(WKNavigationActionPolicy))InDecisionHandler
|
|
{
|
|
NSURLRequest *request = InNavigationAction.request;
|
|
FString UrlStr([[request URL] absoluteString]);
|
|
|
|
if (InNavigationAction.targetFrame == nil && !UrlStr.IsEmpty() && FPlatformProcess::CanLaunchURL(*UrlStr))
|
|
{
|
|
if (WebBrowserWidget->HandleOnBeforePopup(UrlStr, TEXT("_blank")))
|
|
{
|
|
// Launched the URL in external browser, don't open the link here too
|
|
InDecisionHandler(WKNavigationActionPolicyCancel);
|
|
return;
|
|
}
|
|
}
|
|
|
|
WebBrowserWidget->HandleShouldOverrideUrlLoading(UrlStr);
|
|
InDecisionHandler(WKNavigationActionPolicyAllow);
|
|
}
|
|
|
|
-(void)webView:(WKWebView *)InWebView didCommitNavigation : (WKNavigation *)InNavigation
|
|
{
|
|
NSString* CurrentUrl = [self.WebView URL].absoluteString;
|
|
NSString* Title = [self.WebView title];
|
|
|
|
// NSLog(@"didCommitNavigation: %@", CurrentUrl);
|
|
WebBrowserWidget->HandleReceivedTitle(Title);
|
|
WebBrowserWidget->HandlePageLoad(CurrentUrl, true);
|
|
}
|
|
|
|
-(void)webView:(WKWebView *)InWebView didFinishNavigation : (WKNavigation *)InNavigation
|
|
{
|
|
NSString* CurrentUrl = [self.WebView URL].absoluteString;
|
|
NSString* Title = [self.WebView title];
|
|
// NSLog(@"didFinishNavigation: %@", CurrentUrl);
|
|
WebBrowserWidget->HandleReceivedTitle(Title);
|
|
WebBrowserWidget->HandlePageLoad(CurrentUrl, false);
|
|
}
|
|
-(void)webView:(WKWebView *)InWebView didFailNavigation : (WKNavigation *)InNavigation withError : (NSError*)InError
|
|
{
|
|
if (InError.domain == NSURLErrorDomain && InError.code == NSURLErrorCancelled)
|
|
{
|
|
//ignore this one, interrupted load
|
|
return;
|
|
}
|
|
NSString* CurrentUrl = [InError.userInfo objectForKey : @"NSErrorFailingURLStringKey"];
|
|
// NSLog(@"didFailNavigation: %@, error %@", CurrentUrl, InError);
|
|
WebBrowserWidget->HandleReceivedError(InError.code, CurrentUrl);
|
|
}
|
|
-(void)webView:(WKWebView *)InWebView didFailProvisionalNavigation : (WKNavigation *)InNavigation withError : (NSError*)InError
|
|
{
|
|
NSString* CurrentUrl = [InError.userInfo objectForKey : @"NSErrorFailingURLStringKey"];
|
|
// NSLog(@"didFailProvisionalNavigation: %@, error %@", CurrentUrl, InError);
|
|
WebBrowserWidget->HandleReceivedError(InError.code, CurrentUrl);
|
|
}
|
|
#endif
|
|
@end
|
|
|
|
namespace {
|
|
static const FString JSGetSourceCommand = TEXT("GetSource");
|
|
static const FString JSMessageGetSourceScript =
|
|
TEXT(" window.webkit.messageHandlers.") + FMobileJSScripting::JSMessageHandler + TEXT(".postMessage('")+ JSGetSourceCommand +
|
|
TEXT("/' + encodeURIComponent(document.documentElement.innerHTML));");
|
|
|
|
}
|
|
|
|
FWebBrowserWindow::FWebBrowserWindow(FString InUrl, TOptional<FString> InContentsToLoad, bool InShowErrorMessage, bool InThumbMouseButtonNavigation, bool InUseTransparency, bool bInJSBindingToLoweringEnabled, FString InUserAgentApplication, bool bMobileJSReturnInDict)
|
|
: CurrentUrl(MoveTemp(InUrl))
|
|
, UserAgentApplication(MoveTemp(InUserAgentApplication))
|
|
, ContentsToLoad(MoveTemp(InContentsToLoad))
|
|
, bUseTransparency(InUseTransparency)
|
|
, DocumentState(EWebBrowserDocumentState::NoDocument)
|
|
, ErrorCode(0)
|
|
, WindowSize(FIntPoint(500, 500))
|
|
, bIsDisabled(false)
|
|
, bIsVisible(true)
|
|
, bTickedLastFrame(true)
|
|
{
|
|
bool bInjectJSOnPageStarted = false;
|
|
GConfig->GetBool(TEXT("Browser"), TEXT("bInjectJSOnPageStarted"), bInjectJSOnPageStarted, GEngineIni);
|
|
|
|
Scripting = MakeShared<FMobileJSScripting>(bInJSBindingToLoweringEnabled, bInjectJSOnPageStarted, bMobileJSReturnInDict);
|
|
WebView3DInput = MakeShared<FWebView3DInputHandler>();
|
|
}
|
|
|
|
FWebBrowserWindow::~FWebBrowserWindow()
|
|
{
|
|
CloseBrowser(true, false);
|
|
}
|
|
|
|
void FWebBrowserWindow::LoadURL(FString NewURL)
|
|
{
|
|
BrowserWidget->LoadURL(NewURL);
|
|
}
|
|
|
|
void FWebBrowserWindow::LoadString(FString Contents, FString DummyURL)
|
|
{
|
|
BrowserWidget->LoadString(Contents, DummyURL);
|
|
}
|
|
|
|
TOptional<FSlateRenderTransform> FWebBrowserWindow::GetWebBrowserRenderTransform() const
|
|
{
|
|
return FSlateRenderTransform();
|
|
}
|
|
|
|
TSharedRef<SViewport> FWebBrowserWindow::CreateWidget()
|
|
{
|
|
TSharedRef<SAppleWebBrowserWidget> BrowserWidgetRef =
|
|
SNew(SAppleWebBrowserWidget)
|
|
.UseTransparency(bUseTransparency)
|
|
.InitialURL(CurrentUrl)
|
|
.UserAgentApplication(UserAgentApplication)
|
|
.WebBrowserWindow(SharedThis(this))
|
|
.RenderTransform(this, &FWebBrowserWindow::GetWebBrowserRenderTransform);
|
|
|
|
BrowserWidget = BrowserWidgetRef;
|
|
|
|
Scripting->SetWindow(SharedThis(this));
|
|
|
|
return BrowserWidgetRef;
|
|
}
|
|
|
|
void FWebBrowserWindow::OnActiveTabChanged(TSharedPtr<SDockTab> ActiveTab, TSharedPtr<SDockTab> PreviouslyActiveTab)
|
|
{
|
|
}
|
|
|
|
void FWebBrowserWindow::SetViewportSize(FIntPoint ViewportSize, FIntPoint ViewportPos)
|
|
{
|
|
WindowSize = ViewportSize;
|
|
if(BrowserWidget != nullptr)
|
|
{
|
|
BrowserWidget->UpdateFrameWithViewport(WindowSize, ViewportPos);
|
|
}
|
|
}
|
|
|
|
FIntPoint FWebBrowserWindow::GetViewportSize() const
|
|
{
|
|
return WindowSize;
|
|
}
|
|
|
|
FSlateShaderResource* FWebBrowserWindow::GetTexture(bool bIsPopup /*= false*/)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
bool FWebBrowserWindow::IsValid() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool FWebBrowserWindow::IsInitialized() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool FWebBrowserWindow::IsClosing() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool FWebBrowserWindow::Is3D()
|
|
{
|
|
return BrowserWidget != nil ? BrowserWidget->Is3D() : false;
|
|
}
|
|
|
|
EWebBrowserDocumentState FWebBrowserWindow::GetDocumentLoadingState() const
|
|
{
|
|
return DocumentState;
|
|
}
|
|
|
|
FString FWebBrowserWindow::GetTitle() const
|
|
{
|
|
return Title;
|
|
}
|
|
|
|
FString FWebBrowserWindow::GetUrl() const
|
|
{
|
|
return CurrentUrl;
|
|
}
|
|
|
|
bool FWebBrowserWindow::OnKeyDown(const FKeyEvent& InKeyEvent)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendKeyEventToJS(*this, "keydown", InKeyEvent);
|
|
}
|
|
else
|
|
{
|
|
RedirectNSEvent();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool FWebBrowserWindow::OnKeyUp(const FKeyEvent& InKeyEvent)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendKeyEventToJS(*this, "keyup", InKeyEvent);
|
|
}
|
|
else
|
|
{
|
|
RedirectNSEvent();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool FWebBrowserWindow::OnKeyChar(const FCharacterEvent& InCharacterEvent)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendCharEventToJS(*this, InCharacterEvent);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void FWebBrowserWindow::RedirectNSEvent()
|
|
{
|
|
// by default, some events (mainly keystrokes) don't get redirected to NSApp when consumed in Slate
|
|
#if PLATFORM_MAC
|
|
if (const TSharedPtr<GenericApplication> Application = FSlateApplication::Get().GetPlatformApplication())
|
|
{
|
|
if(BrowserWidget != nullptr && BrowserWidget->InKeyWindow())
|
|
{
|
|
static_cast<FMacApplication*>(Application.Get())->ResendLastEvent();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
FReply FWebBrowserWindow::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendMouseEventToJS(*this, "down", MouseEvent);
|
|
}
|
|
|
|
return FReply::Handled().ReleaseMouseCapture().ReleaseMouseLock();
|
|
}
|
|
|
|
FReply FWebBrowserWindow::OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendMouseEventToJS(*this, "up", MouseEvent);
|
|
WebView3DInput->SendMouseEventToJS(*this, "click", MouseEvent);
|
|
}
|
|
|
|
return FReply::Handled().ReleaseMouseCapture().ReleaseMouseLock();
|
|
}
|
|
|
|
FReply FWebBrowserWindow::OnMouseButtonDoubleClick(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendMouseEventToJS(*this, "dblclick", MouseEvent);
|
|
}
|
|
|
|
return FReply::Handled().ReleaseMouseCapture().ReleaseMouseLock();
|
|
}
|
|
|
|
FReply FWebBrowserWindow::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendMouseEventToJS(*this, "move", MouseEvent);
|
|
}
|
|
|
|
return FReply::Handled().ReleaseMouseCapture().ReleaseMouseLock();
|
|
}
|
|
|
|
void FWebBrowserWindow::OnMouseLeave(const FPointerEvent& MouseEvent)
|
|
{
|
|
}
|
|
|
|
void FWebBrowserWindow::SetSupportsMouseWheel(bool bValue)
|
|
{
|
|
|
|
}
|
|
|
|
bool FWebBrowserWindow::GetSupportsMouseWheel() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FReply FWebBrowserWindow::OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bIsPopup)
|
|
{
|
|
if(Is3D())
|
|
{
|
|
WebView3DInput->SendMouseEventToJS(*this, "wheel", MouseEvent);
|
|
}
|
|
|
|
return FReply::Handled();
|
|
}
|
|
|
|
FReply FWebBrowserWindow::OnTouchGesture(const FGeometry& MyGeometry, const FPointerEvent& GestureEvent, bool bIsPopup)
|
|
{
|
|
return FReply::Unhandled();
|
|
}
|
|
|
|
|
|
void FWebBrowserWindow::OnFocus(bool SetFocus, bool bIsPopup)
|
|
{
|
|
if(BrowserWidget != nullptr)
|
|
{
|
|
BrowserWidget->OnFocus(SetFocus);
|
|
}
|
|
}
|
|
|
|
void FWebBrowserWindow::OnCaptureLost()
|
|
{
|
|
}
|
|
|
|
bool FWebBrowserWindow::CanGoBack() const
|
|
{
|
|
return BrowserWidget->CanGoBack();
|
|
}
|
|
|
|
void FWebBrowserWindow::GoBack()
|
|
{
|
|
BrowserWidget->GoBack();
|
|
}
|
|
|
|
bool FWebBrowserWindow::CanGoForward() const
|
|
{
|
|
return BrowserWidget->CanGoForward();
|
|
}
|
|
|
|
void FWebBrowserWindow::GoForward()
|
|
{
|
|
BrowserWidget->GoForward();
|
|
}
|
|
|
|
bool FWebBrowserWindow::IsLoading() const
|
|
{
|
|
return DocumentState != EWebBrowserDocumentState::Loading;
|
|
}
|
|
|
|
void FWebBrowserWindow::Reload()
|
|
{
|
|
BrowserWidget->Reload();
|
|
}
|
|
|
|
void FWebBrowserWindow::StopLoad()
|
|
{
|
|
BrowserWidget->StopLoad();
|
|
}
|
|
|
|
void FWebBrowserWindow::GetSource(TFunction<void(const FString&)> Callback) const
|
|
{
|
|
//@todo: decide what to do about multiple pending requests
|
|
GetPageSourceCallback.Emplace(Callback);
|
|
|
|
// Ugly hack: Work around the fact that ExecuteJavascript is non-const.
|
|
const_cast<FWebBrowserWindow*>(this)->ExecuteJavascript(JSMessageGetSourceScript);
|
|
}
|
|
|
|
int FWebBrowserWindow::GetLoadError()
|
|
{
|
|
return ErrorCode;
|
|
}
|
|
|
|
void FWebBrowserWindow::NotifyDocumentError(const FString& InCurrentUrl, int InErrorCode)
|
|
{
|
|
if (!CurrentUrl.Equals(InCurrentUrl, ESearchCase::CaseSensitive))
|
|
{
|
|
CurrentUrl = InCurrentUrl;
|
|
UrlChangedEvent.Broadcast(CurrentUrl);
|
|
}
|
|
|
|
ErrorCode = InErrorCode;
|
|
DocumentState = EWebBrowserDocumentState::Error;
|
|
DocumentStateChangedEvent.Broadcast(DocumentState);
|
|
}
|
|
|
|
void FWebBrowserWindow::NotifyDocumentLoadingStateChange(const FString& InCurrentUrl, bool IsLoading)
|
|
{
|
|
// Ignore a load completed notification if there was an error.
|
|
// For load started, reset any errors from previous page load.
|
|
bool bIsNotError = DocumentState != EWebBrowserDocumentState::Error;
|
|
if (IsLoading || bIsNotError)
|
|
{
|
|
if (!CurrentUrl.Equals(InCurrentUrl, ESearchCase::CaseSensitive))
|
|
{
|
|
CurrentUrl = InCurrentUrl;
|
|
UrlChangedEvent.Broadcast(CurrentUrl);
|
|
}
|
|
|
|
if (bIsNotError && !InCurrentUrl.StartsWith("javascript:"))
|
|
{
|
|
if (IsLoading)
|
|
{
|
|
Scripting->PageStarted(SharedThis(this));
|
|
}
|
|
else
|
|
{
|
|
Scripting->PageLoaded(SharedThis(this));
|
|
}
|
|
}
|
|
ErrorCode = 0;
|
|
DocumentState = IsLoading
|
|
? EWebBrowserDocumentState::Loading
|
|
: EWebBrowserDocumentState::Completed;
|
|
DocumentStateChangedEvent.Broadcast(DocumentState);
|
|
}
|
|
|
|
}
|
|
|
|
void FWebBrowserWindow::SetIsDisabled(bool bValue)
|
|
{
|
|
bIsDisabled = bValue;
|
|
}
|
|
|
|
TSharedPtr<SWindow> FWebBrowserWindow::GetParentWindow() const
|
|
{
|
|
if (ParentWindow.IsValid())
|
|
{
|
|
return ParentWindow.Pin();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void FWebBrowserWindow::SetParentWindow(TSharedPtr<SWindow> Window)
|
|
{
|
|
ParentWindow = Window;
|
|
}
|
|
|
|
void FWebBrowserWindow::SetParentDockTab(TSharedPtr<SDockTab> DockTab)
|
|
{
|
|
}
|
|
|
|
TWeakPtr<SDockTab> FWebBrowserWindow::GetParentDockTab()
|
|
{
|
|
return ParentDockTab;
|
|
}
|
|
|
|
void FWebBrowserWindow::ShowFloatingCloseButton(bool bShow, bool bDraggable)
|
|
{
|
|
if (BrowserWidget)
|
|
{
|
|
BrowserWidget->ShowFloatingCloseButton(bShow, bDraggable);
|
|
}
|
|
}
|
|
|
|
void FWebBrowserWindow::ExecuteJavascript(const FString& Script)
|
|
{
|
|
BrowserWidget->ExecuteJavascript(Script);
|
|
}
|
|
|
|
void FWebBrowserWindow::CloseBrowser(bool bForce, bool bBlockTillClosed /* ignored */)
|
|
{
|
|
BrowserWidget->Close();
|
|
}
|
|
|
|
bool FWebBrowserWindow::OnJsMessageReceived(const FString& Command, const TArray<FString>& Params, const FString& Origin)
|
|
{
|
|
if (Command.Equals(JSGetSourceCommand, ESearchCase::CaseSensitive) && GetPageSourceCallback.IsSet() && Params.Num() == 1)
|
|
{
|
|
GetPageSourceCallback.GetValue()(Params[0]);
|
|
GetPageSourceCallback.Reset();
|
|
return true;
|
|
}
|
|
return Scripting->OnJsMessageReceived(Command, Params, Origin);
|
|
}
|
|
|
|
void FWebBrowserWindow::BindUObject(const FString& Name, UObject* Object, bool bIsPermanent /*= true*/)
|
|
{
|
|
Scripting->BindUObject(Name, Object, bIsPermanent);
|
|
}
|
|
|
|
void FWebBrowserWindow::UnbindUObject(const FString& Name, UObject* Object /*= nullptr*/, bool bIsPermanent /*= true*/)
|
|
{
|
|
Scripting->UnbindUObject(Name, Object, bIsPermanent);
|
|
}
|
|
|
|
void FWebBrowserWindow::CheckTickActivity()
|
|
{
|
|
if (bIsVisible != bTickedLastFrame)
|
|
{
|
|
bIsVisible = bTickedLastFrame;
|
|
BrowserWidget->SetWebBrowserVisibility(bIsVisible);
|
|
}
|
|
|
|
bTickedLastFrame = false;
|
|
}
|
|
|
|
void FWebBrowserWindow::SetTickLastFrame()
|
|
{
|
|
bTickedLastFrame = !bIsDisabled;
|
|
}
|
|
|
|
bool FWebBrowserWindow::IsVisible()
|
|
{
|
|
return bIsVisible;
|
|
}
|
|
|
|
void FWebBrowserWindow::FloatingCloseButtonPressed()
|
|
{
|
|
if (OnFloatingCloseButtonPressed().IsBound())
|
|
{
|
|
OnFloatingCloseButtonPressed().Execute();
|
|
}
|
|
}
|
|
#endif
|