/** Called when a window is destroyed to give the renderer a chance to free resources */
void FSlateOpenGLRenderer::OnWindowDestroyed( const TSharedRef<SWindow>& InWindow )
{
FSlateOpenGLViewport* Viewport = WindowToViewportMap.Find( &InWindow.Get() );
if( Viewport )
{
Viewport->Destroy();
}
WindowToViewportMap.Remove( &InWindow.Get() );
}
void FSlateOpenGLRenderer::CreateViewport( const TSharedRef<SWindow> InWindow )
{
#if UE_BUILD_DEBUG
// Ensure a viewport for this window doesnt already exist
FSlateOpenGLViewport* Viewport = WindowToViewportMap.Find( &InWindow.Get() );
check(!Viewport);
#endif
FSlateOpenGLViewport& NewViewport = WindowToViewportMap.Add( &InWindow.Get(), FSlateOpenGLViewport() );
NewViewport.Initialize( InWindow, SharedContext );
}
void FWindowsTextInputMethodSystem::ActivateContext(const TSharedRef<ITextInputMethodContext>& Context)
{
UE_LOG(LogWindowsTextInputMethodSystem, Verbose, TEXT("Activating context %p..."), &(Context.Get()));
HRESULT Result;
// General Implementation
ActiveContext = Context;
check(ContextToInternalContextMap.Contains(Context));
FInternalContext& InternalContext = ContextToInternalContextMap[Context];
const TSharedPtr<FGenericWindow> GenericWindow = Context->GetWindow();
InternalContext.WindowHandle = GenericWindow.IsValid() ? reinterpret_cast<HWND>(GenericWindow->GetOSWindowHandle()) : nullptr;
// IMM Implementation
InternalContext.IMMContext.IsComposing = false;
InternalContext.IMMContext.IsDeactivating = false;
::ImmAssociateContext(InternalContext.WindowHandle, IMMContextId);
// TSF Implementation
TComPtr<FTextStoreACP>& TextStore = InternalContext.TSFContext;
ITfDocumentMgr* Unused;
Result = TSFThreadManager->AssociateFocus(InternalContext.WindowHandle, TextStore->TSFDocumentManager, &Unused);
if(FAILED(Result))
{
UE_LOG(LogWindowsTextInputMethodSystem, Error, TEXT("Activating a context failed while setting focus on a TSF document manager."));
}
UE_LOG(LogWindowsTextInputMethodSystem, Verbose, TEXT("Activated context %p!"), &(Context.Get()));
}
/**
参考 FCoreStyle::Create()
*/
TSharedRef<class FSlateStyleSet> FHUDStyle::Create()
{
TSharedRef<FSlateStyleSet> StyleRef = FSlateGameResources::New(FHUDStyle::GetStyleSetName(), "/Game/Slate", "/Game/Slate");
auto& Style = StyleRef.Get();
/**
FSlateStyleSet::Set("XXX", スタイル) は第二引数に様々なスタイル(ブラシも可)を取るオーバーロードを持つ
ここでスタイル(ブラシ)を登録しておく
Style.Set("XXX", FSlateImageBrush(FPaths::GameContentDir() / TEXT("YYY.png"), FVector2D(32, 32)));
Style.Set("XXX", FSlateBoxBrush(FPaths::GameContentDir() / TEXT("YYY.png"), FMargin(3.0f / 8.0f)));
Style.Set("XXX", FSlateBoxBrush(FPaths::GameContentDir() / TEXT("YYY.png"), FMargin(3.0f / 8.0f)));
Style.Set("XXX", FTextBlockStyle()
.SetFont(FSlateFontInfo(FPaths::GameContentDir() / TEXT("YYY.ttf"), 14))
.SetColorAndOpacity(FLinearColor::White)
.SetShadowOffset(FIntPoint(-1, 1))
);
Style.Set("XXX", FTextBlockStyle()
.SetFont(FSlateFontInfo(FPaths::GameContentDir() / TEXT("YYY.otf"), 14))
.SetColorAndOpacity(FLinearColor::White)
.SetShadowOffset(FIntPoint(-1, 1))
);
*/
//!< https://wiki.unrealengine.com/First_Person_Shooter_C%2B%2B_Tutorial からクロスヘア画像を持ってきた
Style.Set("Crosshair", new FSlateImageBrush(FPaths::GameContentDir() / TEXT("Crosshair_fps_tutorial") / TEXT("crosshair") + TEXT(".TGA"), FVector2D(16, 16)));
//!< UnrealEngine\Engine\Content\Slate\Testing\UE4Icon.png をコピーしてきた
Style.Set("UE4Icon", new FSlateImageBrush(FPaths::GameContentDir() / TEXT("Slate") / TEXT("UE4Icon") + TEXT(".png"), FVector2D(50, 50)));
return StyleRef;
}
TSharedRef<FSlateStyleSet> FARUIStyle::Create()
{
TSharedRef<FSlateStyleSet> StyleRef = FSlateGameResources::New(FARUIStyle::GetStyleName(), "/Game/UI/Styles", "/Game/UI/Styles");
FSlateStyleSet& Set = StyleRef.Get();
return StyleRef;
}
FReply FKismetVariableDragDropAction::DroppedOnAction(TSharedRef<FEdGraphSchemaAction> Action)
{
if(Action->GetTypeId() == FEdGraphSchemaAction_K2Var::StaticGetTypeId())
{
FEdGraphSchemaAction_K2Var* VarAction = (FEdGraphSchemaAction_K2Var*)&Action.Get();
// Only let you drag and drop if variables are from same BP class, and not onto itself
UBlueprint* BP = UBlueprint::GetBlueprintFromClass(Cast<UClass>(VariableSource.Get()));
FName TargetVarName = VarAction->GetVariableName();
if( (BP != NULL) &&
(VariableName != TargetVarName) &&
(VariableSource == VarAction->GetVariableClass()) )
{
bool bMoved = FBlueprintEditorUtils::MoveVariableBeforeVariable(BP, VariableName, TargetVarName, true);
// If we moved successfully
if(bMoved)
{
// Change category of var to match the one we dragged on to as well
FText MovedVarCategory = FBlueprintEditorUtils::GetBlueprintVariableCategory(BP, VariableName, GetLocalVariableScope());
FText TargetVarCategory = FBlueprintEditorUtils::GetBlueprintVariableCategory(BP, TargetVarName, GetLocalVariableScope());
if(!MovedVarCategory.EqualTo(TargetVarCategory))
{
FBlueprintEditorUtils::SetBlueprintVariableCategory(BP, VariableName, GetLocalVariableScope(), TargetVarCategory, true);
}
// Update Blueprint after changes so they reflect in My Blueprint tab.
FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(BP);
}
}
return FReply::Handled();
}
return FReply::Unhandled();
}
void FSlateD3DRenderer::Private_CreateViewport( TSharedRef<SWindow> InWindow, const FVector2D &WindowSize )
{
TSharedRef< FGenericWindow > NativeWindow = InWindow->GetNativeWindow().ToSharedRef();
bool bFullscreen = IsViewportFullscreen( *InWindow );
bool bWindowed = true;//@todo implement fullscreen: !bFullscreen;
DXGI_SWAP_CHAIN_DESC SwapChainDesc;
FMemory::Memzero(&SwapChainDesc, sizeof(SwapChainDesc) );
SwapChainDesc.BufferCount = 1;
SwapChainDesc.BufferDesc.Width = FMath::TruncToInt(WindowSize.X);
SwapChainDesc.BufferDesc.Height = FMath::TruncToInt(WindowSize.Y);
SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
SwapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
SwapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
SwapChainDesc.OutputWindow = (HWND)NativeWindow->GetOSWindowHandle();
SwapChainDesc.SampleDesc.Count = 1;
SwapChainDesc.SampleDesc.Quality = 0;
SwapChainDesc.Windowed = bWindowed;
SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
SwapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
TRefCountPtr<IDXGIDevice> DXGIDevice;
HRESULT Hr = GD3DDevice->QueryInterface( __uuidof(IDXGIDevice), (void**)DXGIDevice.GetInitReference() );
check( SUCCEEDED(Hr) );
TRefCountPtr<IDXGIAdapter> DXGIAdapter;
Hr = DXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void **)DXGIAdapter.GetInitReference() );
check( SUCCEEDED(Hr) );
TRefCountPtr<IDXGIFactory> DXGIFactory;
DXGIAdapter->GetParent(__uuidof(IDXGIFactory), (void **)DXGIFactory.GetInitReference() );
check( SUCCEEDED(Hr) );
FSlateD3DViewport Viewport;
Hr = DXGIFactory->CreateSwapChain(DXGIDevice.GetReference(), &SwapChainDesc, Viewport.D3DSwapChain.GetInitReference() );
check( SUCCEEDED(Hr) );
Hr = DXGIFactory->MakeWindowAssociation((HWND)NativeWindow->GetOSWindowHandle(),DXGI_MWA_NO_ALT_ENTER);
check(SUCCEEDED(Hr));
uint32 Width = FMath::TruncToInt(WindowSize.X);
uint32 Height = FMath::TruncToInt(WindowSize.Y);
Viewport.ViewportInfo.MaxDepth = 1.0f;
Viewport.ViewportInfo.MinDepth = 0.0f;
Viewport.ViewportInfo.Width = Width;
Viewport.ViewportInfo.Height = Height;
Viewport.ViewportInfo.TopLeftX = 0;
Viewport.ViewportInfo.TopLeftY = 0;
CreateBackBufferResources( Viewport.D3DSwapChain, Viewport.BackBufferTexture, Viewport.RenderTargetView );
Viewport.ProjectionMatrix = CreateProjectionMatrixD3D( Width, Height );
WindowToViewportMap.Add( &InWindow.Get(), Viewport );
}
void FSlateD3DRenderer::Private_ResizeViewport( const TSharedRef<SWindow> InWindow, uint32 Width, uint32 Height, bool bFullscreen )
{
FSlateD3DViewport* Viewport = WindowToViewportMap.Find( &InWindow.Get() );
if( Viewport && ( Width != Viewport->ViewportInfo.Width || Height != Viewport->ViewportInfo.Height || bFullscreen != Viewport->bFullscreen ) )
{
GD3DDeviceContext->OMSetRenderTargets(0,NULL,NULL);
Viewport->BackBufferTexture.SafeRelease();
Viewport->RenderTargetView.SafeRelease();
Viewport->DepthStencilView.SafeRelease();
Viewport->ViewportInfo.Width = Width;
Viewport->ViewportInfo.Height = Height;
Viewport->bFullscreen = bFullscreen;
Viewport->ProjectionMatrix = CreateProjectionMatrixD3D( Width, Height );
DXGI_SWAP_CHAIN_DESC Desc;
Viewport->D3DSwapChain->GetDesc( &Desc );
HRESULT Hr = Viewport->D3DSwapChain->ResizeBuffers( Desc.BufferCount, Viewport->ViewportInfo.Width, Viewport->ViewportInfo.Height, Desc.BufferDesc.Format, Desc.Flags );
check( SUCCEEDED(Hr) );
CreateBackBufferResources( Viewport->D3DSwapChain, Viewport->BackBufferTexture,Viewport->RenderTargetView );
}
}
void CopyInterpLinearColorTrack(TSharedRef<ISequencer> Sequencer, UInterpTrackLinearColorProp* LinearColorPropTrack, UMovieSceneColorTrack* ColorTrack)
{
if (FMatineeImportTools::CopyInterpLinearColorTrack(LinearColorPropTrack, ColorTrack))
{
Sequencer.Get().NotifyMovieSceneDataChanged( EMovieSceneDataChangeType::MovieSceneStructureItemAdded );
}
}
TSharedRef< FSlateStyleSet > FCrashReportClientStyle::Create()
{
TSharedRef<FSlateStyleSet> StyleRef = MakeShareable(new FSlateStyleSet("CrashReportClientStyle"));
FSlateStyleSet& Style = StyleRef.Get();
const FTextBlockStyle DefaultText = FTextBlockStyle()
.SetFont(TTF_FONT("Fonts/Roboto-Black", 10))
.SetColorAndOpacity(FSlateColor::UseForeground())
.SetShadowOffset(FVector2D::ZeroVector)
.SetShadowColorAndOpacity(FLinearColor::Black);
// Set the client app styles
Style.Set(TEXT("Code"), FTextBlockStyle(DefaultText)
.SetFont(TTF_FONT("Fonts/DroidSansMono", 8))
.SetColorAndOpacity(FSlateColor(FLinearColor::White * 0.8f))
);
Style.Set(TEXT("Title"), FTextBlockStyle(DefaultText)
.SetFont(TTF_FONT("Fonts/Roboto-Bold", 12))
);
Style.Set(TEXT("Status"), FTextBlockStyle(DefaultText)
.SetColorAndOpacity(FSlateColor::UseSubduedForeground())
);
return StyleRef;
}
bool FPluginHelpers::SavePluginDescriptor(const FString& NewProjectFilename, const FPluginDescriptor& PluginDescriptor)
{
FString Text;
TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&Text);
Writer->WriteObjectStart();
// Write all the simple fields
Writer->WriteValue(TEXT("FileVersion"), PluginDescriptor.FileVersion);
Writer->WriteValue(TEXT("FriendlyName"), PluginDescriptor.FriendlyName);
Writer->WriteValue(TEXT("Version"), PluginDescriptor.Version);
Writer->WriteValue(TEXT("VersionName"), PluginDescriptor.VersionName);
Writer->WriteValue(TEXT("CreatedBy"), PluginDescriptor.CreatedBy);
Writer->WriteValue(TEXT("CreatedByURL"), PluginDescriptor.CreatedByURL);
Writer->WriteValue(TEXT("Category"), PluginDescriptor.Category);
Writer->WriteValue(TEXT("Description"), PluginDescriptor.Description);
Writer->WriteValue(TEXT("EnabledByDefault"), PluginDescriptor.bEnabledByDefault);
// Write the module list
FModuleDescriptor::WriteArray(Writer.Get(), TEXT("Modules"), PluginDescriptor.Modules);
Writer->WriteObjectEnd();
Writer->Close();
return FFileHelper::SaveStringToFile(Text, *NewProjectFilename);
}
void Construct(const FArguments& InArgs, const TSharedRef<FFriendsStatusViewModel>& InViewModel)
{
FriendStyle = *InArgs._FriendStyle;
ViewModel = InViewModel;
FFriendsStatusViewModel* ViewModelPtr = &InViewModel.Get();
const TArray<FFriendsStatusViewModel::FOnlineState>& StatusOptions = ViewModelPtr->GetStatusList();
SFriendsAndChatCombo::FItemsArray ComboMenuItems;
for (const auto& StatusOption : StatusOptions)
{
if (StatusOption.bIsDisplayed)
{
ComboMenuItems.AddItem(StatusOption.DisplayText, GetStatusBrush(StatusOption.State), FName(*StatusOption.DisplayText.ToString()));
}
}
SUserWidget::Construct(SUserWidget::FArguments()
[
SNew(SFriendsAndChatCombo)
.FriendStyle(&FriendStyle)
.ButtonText(ViewModelPtr, &FFriendsStatusViewModel::GetStatusText)
.bShowIcon(true)
.DropdownItems(ComboMenuItems)
.bSetButtonTextToSelectedItem(false)
.bAutoCloseWhenClicked(true)
.ButtonSize(FriendStyle.StatusButtonSize)
.OnDropdownItemClicked(this, &SFriendsStatusImpl::HandleStatusChanged)
.IsEnabled(this, &SFriendsStatusImpl::IsStatusEnabled)
]);
}
void SEditorViewport::Construct( const FArguments& InArgs )
{
ChildSlot
[
SAssignNew( ViewportWidget, SViewport )
.ShowEffectWhenDisabled( false )
.EnableGammaCorrection( false ) // Scene rendering handles this
.AddMetaData(InArgs.MetaData.Num() > 0 ? InArgs.MetaData[0] : MakeShareable(new FTagMetaData(TEXT("LevelEditorViewport"))))
[
SAssignNew( ViewportOverlay, SOverlay )
+SOverlay::Slot()
[
SNew( SBorder )
.BorderImage( this, &SEditorViewport::OnGetViewportBorderBrush )
.BorderBackgroundColor( this, &SEditorViewport::OnGetViewportBorderColorAndOpacity )
.Visibility( this, &SEditorViewport::OnGetViewportContentVisibility )
.Padding(0.0f)
.ShowEffectWhenDisabled( false )
]
]
];
TSharedRef<FEditorViewportClient> ViewportClient = MakeEditorViewportClient();
if (!ViewportClient->VisibilityDelegate.IsBound())
{
ViewportClient->VisibilityDelegate.BindSP(this, &SEditorViewport::IsVisible);
}
SceneViewport = MakeShareable( new FSceneViewport( &ViewportClient.Get(), ViewportWidget ) );
ViewportClient->Viewport = SceneViewport.Get();
ViewportWidget->SetViewportInterface(SceneViewport.ToSharedRef());
Client = ViewportClient;
if ( Client->IsRealtime() )
{
ActiveTimerHandle = RegisterActiveTimer( 0.f, FWidgetActiveTimerDelegate::CreateSP( this, &SEditorViewport::EnsureTick ) );
}
CommandList = MakeShareable( new FUICommandList );
// Ensure the commands are registered
FEditorViewportCommands::Register();
BindCommands();
TSharedPtr<SWidget> ViewportToolbar = MakeViewportToolbar();
if( ViewportToolbar.IsValid() )
{
ViewportOverlay->AddSlot()
.VAlign(VAlign_Top)
[
ViewportToolbar.ToSharedRef()
];
}
PopulateViewportOverlays(ViewportOverlay.ToSharedRef());
}
void FHttpManager::AddThreadedRequest(const TSharedRef<IHttpThreadedRequest>& Request)
{
{
FScopeLock ScopeLock(&RequestLock);
Requests.Add(Request);
}
Thread->AddRequest(&Request.Get());
}
void UJavascriptMultiBox::Setup(TSharedRef<SBox> Box)
{
Box->SetContent(SNew(SSpacer));
Target = &(Box.Get());
OnHook.Execute(FName("Main"),this,FJavascriptMenuBuilder());
Target = nullptr;
}
void SequencerHelpers::GetDescendantNodes(TSharedRef<FSequencerDisplayNode> DisplayNode, TSet<TSharedRef<FSequencerDisplayNode>>& Nodes)
{
for (auto ChildNode : DisplayNode.Get().GetChildNodes())
{
Nodes.Add(ChildNode);
GetDescendantNodes(ChildNode, Nodes);
}
}
void FSlateD3DRenderer::DrawWindows( FSlateDrawBuffer& InWindowDrawBuffer )
{
// Update the font cache with new text before elements are batched
FontCache->UpdateCache();
// Iterate through each element list and set up an RHI window for it if needed
TArray<FSlateWindowElementList>& WindowElementLists = InWindowDrawBuffer.GetWindowElementLists();
for( int32 ListIndex = 0; ListIndex < WindowElementLists.Num(); ++ListIndex )
{
FSlateWindowElementList& ElementList = WindowElementLists[ListIndex];
if ( ElementList.GetWindow().IsValid() )
{
TSharedRef<SWindow> WindowToDraw = ElementList.GetWindow().ToSharedRef();
// Add all elements for this window to the element batcher
ElementBatcher->AddElements( ElementList.GetDrawElements() );
bool bUnused = false;
ElementBatcher->FillBatchBuffers( ElementList, bUnused );
// All elements for this window have been batched and rendering data updated
ElementBatcher->ResetBatches();
FVector2D WindowSize = WindowToDraw->GetSizeInScreen();
FSlateD3DViewport* Viewport = WindowToViewportMap.Find( &WindowToDraw.Get() );
check(Viewport);
RenderingPolicy->UpdateBuffers( ElementList );
check(Viewport);
GD3DDeviceContext->RSSetViewports(1, &Viewport->ViewportInfo );
ID3D11RenderTargetView* RTV = Viewport->RenderTargetView;
ID3D11DepthStencilView* DSV = Viewport->DepthStencilView;
GD3DDeviceContext->OMSetRenderTargets( 1, &RTV, NULL );
RenderingPolicy->DrawElements( ViewMatrix*Viewport->ProjectionMatrix, ElementList.GetRenderBatches() );
GD3DDeviceContext->OMSetRenderTargets(0, NULL, NULL);
const bool bUseVSync = false;
Viewport->D3DSwapChain->Present( bUseVSync ? 1 : 0, 0);
// All elements have been drawn. Reset all cached data
ElementBatcher->ResetBatches();
}
}
// flush the cache if needed
FontCache->ConditionalFlushCache();
}
/**
* Creates necessary resources to render a window and sends draw commands to the rendering thread
*
* @param WindowDrawBuffer The buffer containing elements to draw
*/
void FSlateOpenGLRenderer::DrawWindows( FSlateDrawBuffer& InWindowDrawBuffer )
{
// Update the font cache with new text before elements are batched
FontCache->UpdateCache();
// Draw each window. For performance. All elements are batched before anything is rendered
TArray<FSlateWindowElementList>& WindowElementLists = InWindowDrawBuffer.GetWindowElementLists();
for( int32 ListIndex = 0; ListIndex < WindowElementLists.Num(); ++ListIndex )
{
FSlateWindowElementList& ElementList = WindowElementLists[ListIndex];
if ( ElementList.GetWindow().IsValid() )
{
TSharedRef<SWindow> WindowToDraw = ElementList.GetWindow().ToSharedRef();
const FVector2D WindowSize = WindowToDraw->GetSizeInScreen();
FSlateOpenGLViewport* Viewport = WindowToViewportMap.Find( &WindowToDraw.Get() );
check(Viewport);
//@todo Slate OpenGL: Move this to ResizeViewport
if( WindowSize.X != Viewport->ViewportRect.Right || WindowSize.Y != Viewport->ViewportRect.Bottom )
{
//@todo implement fullscreen
const bool bFullscreen = false;
Private_ResizeViewport( WindowSize, *Viewport, bFullscreen );
}
Viewport->MakeCurrent();
// Batch elements. Note that we must set the current viewport before doing this so we have a valid rendering context when calling OpenGL functions
ElementBatcher->AddElements( ElementList.GetDrawElements() );
//@ todo Slate: implement for opengl
bool bRequiresStencilTest = false;
ElementBatcher->FillBatchBuffers( ElementList, bRequiresStencilTest );
ElementBatcher->ResetBatches();
RenderingPolicy->UpdateBuffers( ElementList );
check(Viewport);
glViewport( Viewport->ViewportRect.Left, Viewport->ViewportRect.Top, Viewport->ViewportRect.Right, Viewport->ViewportRect.Bottom );
// Draw all elements
RenderingPolicy->DrawElements( ViewMatrix*Viewport->ProjectionMatrix, ElementList.GetRenderBatches() );
Viewport->SwapBuffers();
// Reset all batch data for this window
ElementBatcher->ResetBatches();
}
}
FontCache->ConditionalFlushCache();
}
// note that we cannot call parent implementation because lock might be possible non-multiple
void FCurlHttpManager::AddRequest(TSharedRef<class IHttpRequest> Request)
{
FScopeLock ScopeLock(&RequestLock);
Requests.AddUnique(Request);
FCurlHttpRequest* CurlRequest = static_cast< FCurlHttpRequest* >( &Request.Get() );
HandlesToRequests.Add(CurlRequest->GetEasyHandle(), Request);
}
void FConnectionDrawingPolicy::Draw(TMap<TSharedRef<SWidget>, FArrangedWidget>& PinGeometries, FArrangedChildren& ArrangedNodes)
{
PinToPinWidgetMap.Empty();
for (TMap<TSharedRef<SWidget>, FArrangedWidget>::TIterator ConnectorIt(PinGeometries); ConnectorIt; ++ConnectorIt)
{
TSharedRef<SWidget> SomePinWidget = ConnectorIt.Key();
SGraphPin& PinWidget = static_cast<SGraphPin&>(SomePinWidget.Get());
PinToPinWidgetMap.Add(PinWidget.GetPinObj(), StaticCastSharedRef<SGraphPin>(SomePinWidget));
}
for (TMap<TSharedRef<SWidget>, FArrangedWidget>::TIterator ConnectorIt(PinGeometries); ConnectorIt; ++ConnectorIt)
{
TSharedRef<SWidget> SomePinWidget = ConnectorIt.Key();
SGraphPin& PinWidget = static_cast<SGraphPin&>(SomePinWidget.Get());
UEdGraphPin* ThePin = PinWidget.GetPinObj();
if (ThePin->Direction == EGPD_Output)
{
for (int32 LinkIndex=0; LinkIndex < ThePin->LinkedTo.Num(); ++LinkIndex)
{
FArrangedWidget* LinkStartWidgetGeometry = NULL;
FArrangedWidget* LinkEndWidgetGeometry = NULL;
UEdGraphPin* TargetPin = ThePin->LinkedTo[LinkIndex];
DetermineLinkGeometry(PinGeometries, ArrangedNodes, SomePinWidget, ThePin, TargetPin, /*out*/ LinkStartWidgetGeometry, /*out*/ LinkEndWidgetGeometry);
if ((LinkEndWidgetGeometry != NULL) && (LinkStartWidgetGeometry != NULL))
{
float Thickness = 1.0f;
FLinearColor WireColor = FLinearColor::White;
bool bDrawBubbles = false;
bool bBidirectional = false;
DetermineWiringStyle(ThePin, TargetPin, /*inout*/ Thickness, /*inout*/ WireColor, /*inout*/ bDrawBubbles, /*inout*/ bBidirectional);
DrawSplineWithArrow(LinkStartWidgetGeometry->Geometry, LinkEndWidgetGeometry->Geometry, WireColor, Thickness, bDrawBubbles, bBidirectional);
}
}
}
}
}
void FBlueprintProfilerConnectionDrawingPolicy::Draw(TMap<TSharedRef<SWidget>, FArrangedWidget>& InPinGeometries, FArrangedChildren& ArrangedNodes)
{
// Build the execution roadmap (also populates execution times)
BuildExecutionRoadmap();
PinGeometries = &InPinGeometries;
PinToPinWidgetMap.Empty();
for (TMap<TSharedRef<SWidget>, FArrangedWidget>::TIterator ConnectorIt(InPinGeometries); ConnectorIt; ++ConnectorIt)
{
TSharedRef<SWidget> SomePinWidget = ConnectorIt.Key();
SGraphPin& PinWidget = static_cast<SGraphPin&>(SomePinWidget.Get());
PinToPinWidgetMap.Add(PinWidget.GetPinObj(), StaticCastSharedRef<SGraphPin>(SomePinWidget));
}
for (TMap<TSharedRef<SWidget>, FArrangedWidget>::TIterator ConnectorIt(InPinGeometries); ConnectorIt; ++ConnectorIt)
{
TSharedRef<SWidget> SomePinWidget = ConnectorIt.Key();
SGraphPin& PinWidget = static_cast<SGraphPin&>(SomePinWidget.Get());
UEdGraphPin* ThePin = PinWidget.GetPinObj();
if (ThePin->Direction == EGPD_Output)
{
for (int32 LinkIndex=0; LinkIndex < ThePin->LinkedTo.Num(); ++LinkIndex)
{
FArrangedWidget* LinkStartWidgetGeometry = nullptr;
FArrangedWidget* LinkEndWidgetGeometry = nullptr;
UEdGraphPin* TargetPin = ThePin->LinkedTo[LinkIndex];
DetermineLinkGeometry(ArrangedNodes, SomePinWidget, ThePin, TargetPin, /*out*/ LinkStartWidgetGeometry, /*out*/ LinkEndWidgetGeometry);
if (( LinkEndWidgetGeometry && LinkStartWidgetGeometry ) && !IsConnectionCulled( *LinkStartWidgetGeometry, *LinkEndWidgetGeometry ))
{
FScriptPerfConnectionParams Params;
DeterminePerfWiringStyle(ThePin, TargetPin, Params);
DrawInterpColorSpline(LinkStartWidgetGeometry->Geometry, LinkEndWidgetGeometry->Geometry, Params);
}
}
}
}
}
// note that we cannot call parent implementation because lock might be possible non-multiple
void FCurlHttpManager::RemoveRequest(const TSharedRef<class IHttpRequest>& Request)
{
FScopeLock ScopeLock(&RequestLock);
// Keep track of requests that have been removed to be destroyed later
PendingDestroyRequests.AddUnique(FRequestPendingDestroy(DeferredDestroyDelay,Request));
FCurlHttpRequest* CurlRequest = static_cast< FCurlHttpRequest* >( &Request.Get() );
HandlesToRequests.Remove(CurlRequest->GetEasyHandle());
Requests.Remove(Request);
}
void FSlateD3DRenderer::CreateViewport( const TSharedRef<SWindow> InWindow )
{
#if UE_BUILD_DEBUG
// Ensure a viewport for this window doesnt already exist
FSlateD3DViewport* Viewport = WindowToViewportMap.Find( &InWindow.Get() );
check(!Viewport);
#endif
FVector2D WindowSize = InWindow->GetSizeInScreen();
Private_CreateViewport( InWindow, WindowSize );
}
bool FLauncherProfileManager::SaveJSONProfile(const ILauncherProfileRef& Profile)
{
if (Profile->GetId().IsValid())
{
FString Text;
TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&Text);
Profile->Save(Writer.Get());
Writer->Close();
return FFileHelper::SaveStringToFile(Text, *Profile->GetFilePath());
}
return false;
}
void FLauncherProfileManager::SaveSimpleProfiles()
{
for (TArray<ILauncherSimpleProfilePtr>::TIterator It(SimpleProfiles); It; ++It)
{
FString SimpleProfileFileName = FLauncherProfile::GetProfileFolder() / (*It)->GetDeviceName() + TEXT(".uslp");
FString Text;
TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&Text);
(*It)->Save(Writer.Get());
Writer->Close();
FFileHelper::SaveStringToFile(Text, *SimpleProfileFileName);
}
}
TSharedPtr<ITextInputMethodChangeNotifier> FWindowsTextInputMethodSystem::RegisterContext(const TSharedRef<ITextInputMethodContext>& Context)
{
UE_LOG(LogWindowsTextInputMethodSystem, Verbose, TEXT("Registering context %p..."), &(Context.Get()));
HRESULT Result;
FInternalContext& InternalContext = ContextToInternalContextMap.Add(Context);
// TSF Implementation
TComPtr<FTextStoreACP>& TextStore = InternalContext.TSFContext;
TextStore.Attach(new FTextStoreACP(Context));
Result = TSFThreadManager->CreateDocumentMgr(&(TextStore->TSFDocumentManager));
if(FAILED(Result) || !TextStore->TSFDocumentManager)
{
UE_LOG(LogWindowsTextInputMethodSystem, Error, TEXT("Registering a context failed while creating the TSF document manager."));
TextStore.Reset();
return nullptr;
}
Result = TextStore->TSFDocumentManager->CreateContext(TSFClientId, 0, static_cast<ITextStoreACP*>(TextStore), &(TextStore->TSFContext), &(TextStore->TSFEditCookie));
if(FAILED(Result) || !TextStore->TSFContext)
{
UE_LOG(LogWindowsTextInputMethodSystem, Error, TEXT("Registering a context failed while creating the TSF context."));
TextStore.Reset();
return nullptr;
}
Result = TextStore->TSFDocumentManager->Push(TextStore->TSFContext);
if(FAILED(Result))
{
UE_LOG(LogWindowsTextInputMethodSystem, Error, TEXT("Registering a context failed while pushing a TSF context onto the TSF document manager."));
TextStore.Reset();
return nullptr;
}
Result = TextStore->TSFContextOwnerCompositionServices.FromQueryInterface(IID_ITfContextOwnerCompositionServices, TextStore->TSFContext);
if(FAILED(Result) || !TextStore->TSFContextOwnerCompositionServices)
{
UE_LOG(LogWindowsTextInputMethodSystem, Error, TEXT("Registering a context failed while getting the TSF context owner composition services."));
Result = TextStore->TSFDocumentManager->Pop(TF_POPF_ALL);
if(FAILED(Result))
{
UE_LOG(LogWindowsTextInputMethodSystem, Error, TEXT("Failed to pop a TSF context off from TSF document manager while recovering from failing."));
}
TextStore.Reset();
return nullptr;
}
UE_LOG(LogWindowsTextInputMethodSystem, Verbose, TEXT("Registered context %p!"), &(Context.Get()));
return MakeShareable( new FTextInputMethodChangeNotifier(TextStore) );
}
void FConnectionDrawingPolicy::Draw(TMap<TSharedRef<SWidget>, FArrangedWidget>& InPinGeometries, FArrangedChildren& ArrangedNodes)
{
PinGeometries = &InPinGeometries;
PinToPinWidgetMap.Empty();
for (TMap<TSharedRef<SWidget>, FArrangedWidget>::TIterator ConnectorIt(InPinGeometries); ConnectorIt; ++ConnectorIt)
{
TSharedRef<SWidget> SomePinWidget = ConnectorIt.Key();
SGraphPin& PinWidget = static_cast<SGraphPin&>(SomePinWidget.Get());
PinToPinWidgetMap.Add(PinWidget.GetPinObj(), StaticCastSharedRef<SGraphPin>(SomePinWidget));
}
for (TMap<TSharedRef<SWidget>, FArrangedWidget>::TIterator ConnectorIt(InPinGeometries); ConnectorIt; ++ConnectorIt)
{
TSharedRef<SWidget> SomePinWidget = ConnectorIt.Key();
SGraphPin& PinWidget = static_cast<SGraphPin&>(SomePinWidget.Get());
UEdGraphPin* ThePin = PinWidget.GetPinObj();
if (ThePin->Direction == EGPD_Output)
{
for (int32 LinkIndex=0; LinkIndex < ThePin->LinkedTo.Num(); ++LinkIndex)
{
FArrangedWidget* LinkStartWidgetGeometry = nullptr;
FArrangedWidget* LinkEndWidgetGeometry = nullptr;
UEdGraphPin* TargetPin = ThePin->LinkedTo[LinkIndex];
DetermineLinkGeometry(ArrangedNodes, SomePinWidget, ThePin, TargetPin, /*out*/ LinkStartWidgetGeometry, /*out*/ LinkEndWidgetGeometry);
if (( LinkEndWidgetGeometry && LinkStartWidgetGeometry ) && !IsConnectionCulled( *LinkStartWidgetGeometry, *LinkEndWidgetGeometry ))
{
FConnectionParams Params;
DetermineWiringStyle(ThePin, TargetPin, /*inout*/ Params);
DrawSplineWithArrow(LinkStartWidgetGeometry->Geometry, LinkEndWidgetGeometry->Geometry, Params);
}
}
}
}
}
void SGraphPanel::UpdateSelectedNodesPositions (FVector2D PositionIncrement)
{
for (FGraphPanelSelectionSet::TIterator NodeIt(SelectionManager.SelectedNodes); NodeIt; ++NodeIt)
{
TSharedRef<SNode>* pWidget = NodeToWidgetLookup.Find(*NodeIt);
if (pWidget != NULL)
{
SNode& Widget = pWidget->Get();
SNode::FNodeSet NodeFilter;
Widget.MoveTo(Widget.GetPosition() + PositionIncrement, NodeFilter);
}
}
}
void FTextHistory::Rebuild(TSharedRef< FString, ESPMode::ThreadSafe > InDisplayString)
{
const bool bIsOutOfDate = IsOutOfDate();
// FTextHistory_Base will never report being out-of-date, but we need to keep the history revision in sync
// with the head culture regardless so that FTextSnapshot::IdenticalTo still works correctly
Revision = FTextLocalizationManager::Get().GetTextRevision();
if(bIsOutOfDate)
{
InDisplayString.Get() = FTextInspector::GetDisplayString(ToText(false));
}
}
void FSlateOpenGLRenderer::UpdateFullscreenState( const TSharedRef<SWindow> InWindow, uint32 OverrideResX, uint32 OverrideResY )
{
FSlateOpenGLViewport* Viewport = WindowToViewportMap.Find( &InWindow.Get() );
if( Viewport )
{
bool bFullscreen = IsViewportFullscreen( *InWindow );
// todo: support Fullscreen modes in OpenGL
// uint32 ResX = OverrideResX ? OverrideResX : GSystemResolution.ResX;
// uint32 ResY = OverrideResY ? OverrideResY : GSystemResolution.ResY;
Private_ResizeViewport( FVector2D( Viewport->ViewportRect.Right, Viewport->ViewportRect.Bottom ), *Viewport, bFullscreen );
}
}
