EActiveTimerReturnType UpdateScrollerState(double InCurrentTime, float InDeltaTime)
{
if (ScrollerState == EScrollerState::Stop_Wait)
{
TimeElapsed = 0.0f;
ScrollerState = EScrollerState::FadeOff;
ScrollBox->SetScrollOffset(ScrollOffset);
auto PinnedActiveTimerHandle = ActiveTimerHandle.Pin();
if (PinnedActiveTimerHandle.IsValid())
{
UnRegisterActiveTimer(PinnedActiveTimerHandle.ToSharedRef());
}
ActiveTimerHandle = RegisterActiveTimer(0, FWidgetActiveTimerDelegate::CreateSP(this, &SAutoTextScrollerImpl::UpdateScrollerState));
}
else if (ScrollerState == EScrollerState::Start_Wait)
{
TimeElapsed = 0.0f;
ScrollOffset = 0.0f;
ScrollerState = EScrollerState::Scrolling;
ScrollBox->SetScrollOffset(ScrollOffset);
auto PinnedActiveTimerHandle = ActiveTimerHandle.Pin();
if (PinnedActiveTimerHandle.IsValid())
{
UnRegisterActiveTimer(PinnedActiveTimerHandle.ToSharedRef());
}
ActiveTimerHandle = RegisterActiveTimer(0, FWidgetActiveTimerDelegate::CreateSP(this, &SAutoTextScrollerImpl::UpdateScrollerState));
}
return EActiveTimerReturnType::Continue;
}
TSharedPtr<SWidget> HLODOutliner::FHLODOutlinerDragDropOp::GetDefaultDecorator() const
{
TSharedRef<SVerticalBox> VerticalBox = SNew(SVerticalBox);
VerticalBox->AddSlot()
[
SNew(SBorder)
.BorderImage(FEditorStyle::GetBrush("Graph.ConnectorFeedback.Border"))
.Visibility(this, &FHLODOutlinerDragDropOp::GetOverrideVisibility)
.Content()
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.AutoWidth()
.Padding(0.0f, 0.0f, 3.0f, 0.0f)
[
SNew(SImage)
.Image(this, &FHLODOutlinerDragDropOp::GetOverrideIcon)
]
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text(this, &FHLODOutlinerDragDropOp::GetOverrideText)
]
]
];
if (LODActorOp.IsValid())
{
auto Content = LODActorOp->GetDefaultDecorator();
if (Content.IsValid())
{
Content->SetVisibility(TAttribute<EVisibility>(this, &FHLODOutlinerDragDropOp::GetDefaultVisibility));
VerticalBox->AddSlot()[Content.ToSharedRef()];
}
}
if (StaticMeshActorOp.IsValid())
{
auto Content = StaticMeshActorOp->GetDefaultDecorator();
if (Content.IsValid())
{
Content->SetVisibility(TAttribute<EVisibility>(this, &FHLODOutlinerDragDropOp::GetDefaultVisibility));
VerticalBox->AddSlot()[Content.ToSharedRef()];
}
}
return VerticalBox;
}
TSharedRef<SDockTab> FMerge::GenerateMergeWidget(const UBlueprint& Object, TSharedRef<FBlueprintEditor> Editor)
{
auto ActiveTabPtr = ActiveTab.Pin();
if( ActiveTabPtr.IsValid() )
{
// just bring the tab to the foreground:
auto CurrentTab = FGlobalTabmanager::Get()->InvokeTab(MergeToolTabId);
check( CurrentTab == ActiveTabPtr );
return ActiveTabPtr.ToSharedRef();
}
// merge the local asset with the depot, SCC provides us with the last common revision as
// a basis for the merge:
TSharedPtr<SWidget> Contents;
if (!PendingMerge(Object))
{
// this should load up the merge-tool, with an asset picker, where they
// can pick the asset/revisions to merge against
Contents = GenerateMergeTabContents(Editor, nullptr, FRevisionInfo::InvalidRevision(), nullptr, FRevisionInfo::InvalidRevision(), &Object, FOnMergeResolved());
}
else
{
// @todo DO: this will probably need to be async.. pulling down some old versions of assets:
const FString& PackageName = Object.GetOutermost()->GetName();
const FString& AssetName = Object.GetName();
FSourceControlStatePtr SourceControlState = FMergeToolUtils::GetSourceControlState(PackageName);
if (!SourceControlState.IsValid())
{
DisplayErrorMessage(
FText::Format(
LOCTEXT("MergeFailedNoSourceControl", "Aborted Load of {0} from {1} because the source control state was invalidated")
, FText::FromString(AssetName)
, FText::FromString(PackageName)
)
);
Contents = SNew(SHorizontalBox);
}
else
{
ISourceControlState const& SourceControlStateRef = *SourceControlState;
FRevisionInfo CurrentRevInfo = FRevisionInfo::InvalidRevision();
const UBlueprint* RemoteBlueprint = Cast< UBlueprint >(LoadHeadRev(PackageName, AssetName, SourceControlStateRef, CurrentRevInfo));
FRevisionInfo BaseRevInfo = FRevisionInfo::InvalidRevision();
const UBlueprint* BaseBlueprint = Cast< UBlueprint >(LoadBaseRev(PackageName, AssetName, SourceControlStateRef, BaseRevInfo));
Contents = GenerateMergeTabContents(Editor, BaseBlueprint, BaseRevInfo, RemoteBlueprint, CurrentRevInfo, &Object, FOnMergeResolved());
}
}
TSharedRef<SDockTab> Tab = FGlobalTabmanager::Get()->InvokeTab(MergeToolTabId);
Tab->SetContent(Contents.ToSharedRef());
ActiveTab = Tab;
return Tab;
}
FReply SInlineEditableTextBlock::OnMouseButtonDoubleClick( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent )
{
auto PinnedActiveTimerHandle = ActiveTimerHandle.Pin();
if (PinnedActiveTimerHandle.IsValid())
{
UnRegisterActiveTimer(PinnedActiveTimerHandle.ToSharedRef());
}
return FReply::Unhandled();
}
FPropertyPath FDetailItemNode::GetPropertyPath() const
{
FPropertyPath Ret;
auto PropertyNode = Customization.GetPropertyNode();
if( PropertyNode.IsValid() )
{
Ret = *FPropertyNode::CreatePropertyPath( PropertyNode.ToSharedRef() );
}
return Ret;
}
FReply SInlineEditableTextBlock::OnDragOver( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
// Cancel during a drag over event, otherwise the widget may enter edit mode.
auto PinnedActiveTimerHandle = ActiveTimerHandle.Pin();
if (PinnedActiveTimerHandle.IsValid())
{
UnRegisterActiveTimer(PinnedActiveTimerHandle.ToSharedRef());
}
return FReply::Unhandled();
}
void SDetailsViewBase::HighlightProperty(const FPropertyPath& Property)
{
auto PrevHighlightedNodePtr = CurrentlyHighlightedNode.Pin();
if (PrevHighlightedNodePtr.IsValid())
{
PrevHighlightedNodePtr->SetIsHighlighted(false);
}
auto NextNodePtr = FindTreeNodeFromPropertyRecursive( RootTreeNodes, Property );
if (NextNodePtr.IsValid())
{
NextNodePtr->SetIsHighlighted(true);
auto ParentCategory = NextNodePtr->GetParentCategory();
if (ParentCategory.IsValid())
{
DetailTree->SetItemExpansion(ParentCategory.ToSharedRef(), true);
}
DetailTree->RequestScrollIntoView(NextNodePtr.ToSharedRef());
}
CurrentlyHighlightedNode = NextNodePtr;
}
void SToolkitDisplay::RemoveToolkit( const TSharedRef< IToolkit >& DestroyingToolkit )
{
for( auto ToolkitIt = ActiveToolkits.CreateConstIterator(); ToolkitIt; ++ToolkitIt )
{
if( ( *ToolkitIt )->Toolkit == DestroyingToolkit )
{
// Remove this widget!
VBox->RemoveSlot( ToolkitIt->ToSharedRef() );
ActiveToolkits.RemoveAt( ToolkitIt.GetIndex() );
break;
}
}
}
void SToolkitDisplay::RemoveEditorMode( FEdMode* EditorMode )
{
for( auto ToolkitIt = ActiveToolkits.CreateConstIterator(); ToolkitIt; ++ToolkitIt )
{
if( ( *ToolkitIt )->EditorMode == EditorMode )
{
// Remove this widget!
VBox->RemoveSlot( ToolkitIt->ToSharedRef() );
ActiveToolkits.RemoveAt( ToolkitIt.GetIndex() );
break;
}
}
}
TSharedRef<FPropertyEditorToolkit> FPropertyEditorToolkit::CreateEditor( const EToolkitMode::Type Mode, const TSharedPtr< IToolkitHost >& InitToolkitHost, const TArray<UObject*>& ObjectsToEdit )
{
if( ObjectsToEdit.Num() == 1 )
{
auto ExistingEditor = FindExistingEditor( ObjectsToEdit[0] );
if( ExistingEditor.IsValid() )
{
ExistingEditor->FocusWindow();
return ExistingEditor.ToSharedRef();
}
}
TSharedRef< FPropertyEditorToolkit > NewEditor( new FPropertyEditorToolkit() );
NewEditor->Initialize( Mode, InitToolkitHost, ObjectsToEdit );
return NewEditor;
}
void FCurveSequence::Resume()
{
if ( bIsPaused )
{
// Make sure the widget that owns the sequence is still valid
auto PinnedOwner = OwnerWidget.Pin();
if ( PinnedOwner.IsValid() )
{
bIsPaused = false;
RegisterActiveTimerIfNeeded( PinnedOwner.ToSharedRef() );
// Update the start time to be the same relative to the current time as it was when paused
const double NewStartTime = FSlateApplicationBase::Get().GetCurrentTime() - ( PauseTime - StartTime );
SetStartTime( NewStartTime );
}
}
}
const TSharedRef< SWidget > FActorInfoColumn::ConstructRowWidget( FTreeItemRef TreeItem, const STableRow<FTreeItemPtr>& Row )
{
auto SceneOutliner = SceneOutlinerWeak.Pin();
check(SceneOutliner.IsValid());
TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox);
TSharedRef<STextBlock> MainText = SNew( STextBlock )
.Text( this, &FActorInfoColumn::GetTextForItem, TWeakPtr<ITreeItem>(TreeItem) )
.HighlightText( SceneOutliner->GetFilterHighlightText() )
.ColorAndOpacity( FSlateColor::UseSubduedForeground() );
HorizontalBox->AddSlot()
.AutoWidth()
.VAlign(VAlign_Center)
[
MainText
];
auto Hyperlink = ConstructClassHyperlink(*TreeItem);
if (Hyperlink.IsValid())
{
// If we got a hyperlink, disable hide default text, and show the hyperlink
MainText->SetVisibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FActorInfoColumn::GetColumnDataVisibility, false)));
Hyperlink->SetVisibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FActorInfoColumn::GetColumnDataVisibility, true)));
HorizontalBox->AddSlot()
.VAlign(VAlign_Center)
.AutoWidth()
[
// Make sure that the hyperlink shows as black (by multiplying black * desired color) when selected so it is readable against the orange background even if blue/green/etc... normally
SNew(SBorder)
.BorderImage(FEditorStyle::GetBrush("NoBorder"))
.ColorAndOpacity_Static([](TWeakPtr<const STableRow<FTreeItemPtr>> WeakRow)->FLinearColor{
auto TableRow = WeakRow.Pin();
return TableRow.IsValid() && TableRow->IsSelected() ? FLinearColor::Black : FLinearColor::White;
}, TWeakPtr<const STableRow<FTreeItemPtr>>(StaticCastSharedRef<const STableRow<FTreeItemPtr>>(Row.AsShared())))
[
Hyperlink.ToSharedRef()
]
];
}
return HorizontalBox;
}
/** Handle a click on the specified editor viewport client */
bool FComponentVisualizerManager::HandleClick(FLevelEditorViewportClient* InViewportClient, HHitProxy* HitProxy, const FViewportClick& Click)
{
bool bHandled = HandleProxyForComponentVis(InViewportClient, HitProxy, Click);
if (bHandled && Click.GetKey() == EKeys::RightMouseButton)
{
TSharedPtr<SWidget> MenuWidget = GenerateContextMenuForComponentVis();
if (MenuWidget.IsValid())
{
auto ParentLevelEditor = InViewportClient->ParentLevelEditor.Pin();
if (ParentLevelEditor.IsValid())
{
FSlateApplication::Get().PushMenu(
ParentLevelEditor.ToSharedRef(),
MenuWidget.ToSharedRef(),
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu));
return true;
}
}
}
return false;
}
/** Constructs this widget with InArgs */
void Construct( const FArguments& InArgs )
{
Style = InArgs._Style;
HighlightedText = InArgs._HighlightedText;
Label = InArgs._Label;
HintColorAndOpacity = InArgs._HintColorAndOpacity;
AllowHintText = InArgs._AllowHintText;
ShowClassBackground = InArgs._ShowClassBackground;
AssetThumbnail = InArgs._AssetThumbnail;
bHasRenderedThumbnail = false;
WidthLastFrame = 0;
GenericThumbnailBorderPadding = 2.f;
AssetThumbnail->OnAssetDataChanged().AddSP(this, &SAssetThumbnail::OnAssetDataChanged);
const FAssetData& AssetData = AssetThumbnail->GetAssetData();
UClass* Class = FindObject<UClass>(ANY_PACKAGE, *AssetData.AssetClass.ToString());
FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>(TEXT("AssetTools"));
TWeakPtr<IAssetTypeActions> AssetTypeActions;
if ( Class != NULL )
{
AssetTypeActions = AssetToolsModule.Get().GetAssetTypeActionsForClass(Class);
}
AssetColor = FLinearColor::White;
if ( AssetTypeActions.IsValid() )
{
AssetColor = AssetTypeActions.Pin()->GetTypeColor();
}
TSharedRef<SOverlay> OverlayWidget = SNew(SOverlay);
FName Substyle;
if ( Class == UClass::StaticClass() )
{
Substyle = FName(".ClassBackground");
ClassAssetClass = FindObject<UClass>(ANY_PACKAGE, *AssetData.AssetName.ToString());
}
else if(AssetTypeActions.IsValid())
{
Substyle = FName(".AssetBackground");
}
const FName BackgroundBrushName( *(Style.ToString() + Substyle.ToString()) );
ClassThumbnailBrushOverride = InArgs._ClassThumbnailBrushOverride;
OverlayWidget->AddSlot()
[
SNew(SBorder)
.BorderImage( this, &SAssetThumbnail::GetBackgroundBrush )
.BorderBackgroundColor( this, &SAssetThumbnail::GetAssetColor )
.Padding( GenericThumbnailBorderPadding )
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
.Visibility(this, &SAssetThumbnail::GetClassThumbnailVisibility)
[
SNew( SImage )
.Image( this, &SAssetThumbnail::GetClassThumbnailBrush )
]
];
// The generic representation of the thumbnail, for use before the rendered version, if it exists
OverlayWidget->AddSlot()
[
SNew(SBorder)
.BorderImage( this, &SAssetThumbnail::GetBackgroundBrush )
.BorderBackgroundColor( this, &SAssetThumbnail::GetAssetColor )
.Padding( GenericThumbnailBorderPadding )
.VAlign(VAlign_Center) .HAlign(HAlign_Center)
.Visibility(this, &SAssetThumbnail::GetGenericThumbnailVisibility)
[
SAssignNew(LabelTextBlock, STextBlock)
.Text( GetLabelText() )
.Font( GetTextFont() )
.ColorAndOpacity( FEditorStyle::GetColor(Style, ".ColorAndOpacity") )
.ShadowOffset( FEditorStyle::GetVector(Style, ".ShadowOffset") )
.ShadowColorAndOpacity( FEditorStyle::GetColor(Style, ".ShadowColorAndOpacity") )
.WrapTextAt(this, &SAssetThumbnail::GetTextWrapWidth)
.HighlightText( HighlightedText )
]
];
if ( InArgs._ThumbnailPool.IsValid() && !InArgs._ForceGenericThumbnail && Class != UClass::StaticClass() )
{
ViewportFadeAnimation = FCurveSequence();
ViewportFadeCurve = ViewportFadeAnimation.AddCurve(0.f, 0.25f, ECurveEaseFunction::QuadOut);
TSharedPtr<SViewport> Viewport =
SNew( SViewport )
.EnableGammaCorrection(false);
Viewport->SetViewportInterface( AssetThumbnail.ToSharedRef() );
AssetThumbnail->GetViewportRenderTargetTexture(); // Access the render texture to push it on the stack if it isnt already rendered
InArgs._ThumbnailPool->OnThumbnailRendered().AddSP(this, &SAssetThumbnail::OnThumbnailRendered);
InArgs._ThumbnailPool->OnThumbnailRenderFailed().AddSP(this, &SAssetThumbnail::OnThumbnailRenderFailed);
if ( ShouldRender() && (!InArgs._AllowFadeIn || InArgs._ThumbnailPool->IsRendered(AssetThumbnail)) )
{
bHasRenderedThumbnail = true;
ViewportFadeAnimation.JumpToEnd();
}
// The viewport for the rendered thumbnail, if it exists
OverlayWidget->AddSlot()
[
SNew(SBorder)
.Padding(0)
.BorderImage(FEditorStyle::GetBrush("NoBrush"))
.ColorAndOpacity(this, &SAssetThumbnail::GetViewportColorAndOpacity)
.Visibility(this, &SAssetThumbnail::GetViewportVisibility)
[
Viewport.ToSharedRef()
]
];
}
OverlayWidget->AddSlot()
.HAlign( HAlign_Center )
.VAlign( VAlign_Top )
.Padding(FMargin(2,2,2,2))
[
SNew(SBorder)
.BorderImage( FEditorStyle::GetBrush( Style, ".HintBackground" ) )
.BorderBackgroundColor( this, &SAssetThumbnail::GetHintBackgroundColor) //Adjust the opacity of the border itself
.ColorAndOpacity( HintColorAndOpacity ) //adjusts the opacity of the contents of the border
.Visibility( this, &SAssetThumbnail::GetHintTextVisibility )
.Padding(0)
[
SAssignNew( HintTextBlock, STextBlock )
.Text( GetLabelText() )
.Font( GetHintTextFont() )
.ColorAndOpacity( FEditorStyle::GetColor( Style, ".HintColorAndOpacity" ) )
.ShadowOffset( FEditorStyle::GetVector( Style, ".HintShadowOffset" ) )
.ShadowColorAndOpacity( FEditorStyle::GetColor( Style, ".HintShadowColorAndOpacity" ) )
.WrapTextAt(this, &SAssetThumbnail::GetTextWrapWidth)
.HighlightText( HighlightedText )
]
];
// The asset color strip, only visible when the rendered viewport is
OverlayWidget->AddSlot()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Bottom)
[
SNew(SBorder)
.BorderImage(FEditorStyle::GetBrush("WhiteBrush"))
.BorderBackgroundColor(AssetColor)
.Visibility(this, &SAssetThumbnail::GetViewportVisibility)
.Padding(this, &SAssetThumbnail::GetAssetColorStripPadding)
];
ChildSlot
[
OverlayWidget
];
}
virtual void Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime) override
{
const float ContentSize = ScrollBox->GetDesiredSize().X;
const float Speed = 20.0f;
const float StartDelay = 2.0f;
const float EndDelay = 2.0f;
const float FadeOnDelay = 0.5f;
const float FadeOffDelay = 0.5f;
TimeElapsed += InDeltaTime;
switch (ScrollerState)
{
case EScrollerState::FadeOn:
{
FontAlpha = TimeElapsed / FadeOnDelay;
if (TimeElapsed >= FadeOnDelay)
{
FontAlpha = 1.0f;
TimeElapsed = 0.0f;
ScrollOffset = 0.0f;
ScrollerState = EScrollerState::Start;
}
}break;
case EScrollerState::Start:
{
// Unregister Tick Delegate
auto PinnedActiveTimerHandle = ActiveTimerHandle.Pin();
if (PinnedActiveTimerHandle.IsValid())
{
UnRegisterActiveTimer(PinnedActiveTimerHandle.ToSharedRef());
}
// Check to see if we need to scroll
if (ExternalScrollbar->DistanceFromBottom() == 0.0f && ExternalScrollbar->DistanceFromTop() == 0.0f)
{
// Don't run auto scrolling if text already fits.
break;
}
else
{
ActiveTimerHandle = RegisterActiveTimer(StartDelay, FWidgetActiveTimerDelegate::CreateSP(this, &SAutoTextScrollerImpl::UpdateScrollerState));
ScrollerState = EScrollerState::Start_Wait;
}
}break;
case EScrollerState::Start_Wait:
break;
case EScrollerState::Scrolling:
{
ScrollOffset += Speed * InDeltaTime;
if (ExternalScrollbar->DistanceFromBottom()==0.0f)
{
ScrollOffset = ContentSize;
TimeElapsed = 0.0f;
ScrollerState = EScrollerState::Stop;
}
}break;
case EScrollerState::Stop:
{
// Unregister Tick Delegate
auto PinnedActiveTimerHandle = ActiveTimerHandle.Pin();
if (PinnedActiveTimerHandle.IsValid())
{
UnRegisterActiveTimer(PinnedActiveTimerHandle.ToSharedRef());
}
// Check to see if we need to scroll
if (ExternalScrollbar->DistanceFromBottom() == 0.0f && ExternalScrollbar->DistanceFromTop() == 0.0f)
{
// Don't run auto scrolling if text already fits.
break;
}
else
{
ActiveTimerHandle = RegisterActiveTimer(EndDelay, FWidgetActiveTimerDelegate::CreateSP(this, &SAutoTextScrollerImpl::UpdateScrollerState));
ScrollerState = EScrollerState::Stop_Wait;
}
}break;
case EScrollerState::Stop_Wait:
break;
case EScrollerState::FadeOff:
{
FontAlpha = 1.0f - TimeElapsed / FadeOffDelay;
if (TimeElapsed >= FadeOffDelay)
{
FontAlpha = 0.0f;
TimeElapsed = 0.0f;
ScrollOffset = 0.0f;
ScrollerState = EScrollerState::FadeOn;
}
}break;
};
ScrollBox->SetScrollOffset(ScrollOffset);
}
void FEditorLiveStreaming::BroadcastStatusCallback( const FLiveStreamingStatus& Status )
{
TSharedPtr< SNotificationItem > Notification( NotificationWeakPtr.Pin() );
if( Notification.IsValid() )
{
// Don't bother clobbering existing message with text about web cam starting/stopping, unless we're already broadcasting.
// We want to make sure people see the persistent text about login state.
if( SubmittedVideoFrameCount > 0 ||
( Status.StatusType != FLiveStreamingStatus::EStatusType::WebCamStarted &&
Status.StatusType != FLiveStreamingStatus::EStatusType::WebCamStopped &&
Status.StatusType != FLiveStreamingStatus::EStatusType::WebCamTextureNotReady &&
Status.StatusType != FLiveStreamingStatus::EStatusType::WebCamTextureReady &&
Status.StatusType != FLiveStreamingStatus::EStatusType::ChatConnected &&
Status.StatusType != FLiveStreamingStatus::EStatusType::ChatDisconnected ) )
{
Notification->SetText( Status.CustomStatusDescription );
}
}
else
{
// Only spawn a notification if we're actually still trying to broadcast, not if we're stopping broadcasting. We don't want
// to revive our notification that we intentionally expired.
if( bIsBroadcasting )
{
FNotificationInfo Info( Status.CustomStatusDescription );
Info.FadeInDuration = 0.1f;
Info.FadeOutDuration = 0.5f;
Info.ExpireDuration = 1.5f;
Info.bUseThrobber = false;
Info.bUseSuccessFailIcons = true;
Info.bUseLargeFont = true;
Info.bFireAndForget = false;
Info.bAllowThrottleWhenFrameRateIsLow = false;
NotificationWeakPtr = FSlateNotificationManager::Get().AddNotification( Info );
}
}
Notification = NotificationWeakPtr.Pin();
if( Notification.IsValid() )
{
SNotificationItem::ECompletionState State = SNotificationItem::CS_Pending;
if( Status.StatusType == FLiveStreamingStatus::EStatusType::Failure )
{
State = SNotificationItem::CS_Fail;
}
else if( Status.StatusType == FLiveStreamingStatus::EStatusType::BroadcastStarted ||
Status.StatusType == FLiveStreamingStatus::EStatusType::WebCamStarted ||
Status.StatusType == FLiveStreamingStatus::EStatusType::ChatConnected )
{
State = SNotificationItem::CS_Success;
}
Notification->SetCompletionState( State );
}
// If the web cam just turned on, then we'll go ahead and show it
if( Status.StatusType == FLiveStreamingStatus::EStatusType::WebCamTextureReady )
{
bool bIsImageFlippedHorizontally = false;
bool bIsImageFlippedVertically = false;
UTexture2D* WebCamTexture = LiveStreamer->GetWebCamTexture( bIsImageFlippedHorizontally, bIsImageFlippedVertically );
if( ensure( WebCamTexture != nullptr ) )
{
IMainFrameModule& MainFrameModule = FModuleManager::LoadModuleChecked<IMainFrameModule>( TEXT( "MainFrame" ) );
check( MainFrameModule.IsWindowInitialized() );
auto RootWindow = MainFrameModule.GetParentWindow();
check( RootWindow.IsValid() );
// Allow the user to customize the image mirroring, too!
const auto& Settings = *GetDefault< UEditorLiveStreamingSettings >();
if( Settings.bMirrorWebCamImage )
{
bIsImageFlippedHorizontally = !bIsImageFlippedHorizontally;
}
// How many pixels from the edge of the main frame window to where the broadcast status window appears
const int WindowBorderPadding = 50;
// @todo livestream: Currently this window is not created as "topmost". We don't really want it to be OS-topmost, but we do want it to be the most
// topmost "regular" window in our application (not on top of tooltips, etc.)
// Create a window that will show the web cam video feed
BroadcastStatusWindow = SNew( SWindow )
.Title( LOCTEXT( "StreamingWindowTitle", "Web Camera" ) )
.ClientSize( FVector2D( WebCamTexture->GetSizeX(), WebCamTexture->GetSizeY() ) )
.ScreenPosition( FVector2D(
RootWindow->GetRectInScreen().Right - WebCamTexture->GetSizeX() - WindowBorderPadding,
RootWindow->GetRectInScreen().Top + WindowBorderPadding ) )
// @todo livestream: Ideally the user could freely resize the window, but it gets a bit tricky to preserve the web cam aspect. Plus, we don't really like how letterboxing/columnboxing looks with this.
.SizingRule( ESizingRule::FixedSize )
.AutoCenter( EAutoCenter::None )
.bDragAnywhere( true )
.SupportsMaximize( true )
.SupportsMinimize( true )
.FocusWhenFirstShown( false )
.ActivateWhenFirstShown( false )
.SaneWindowPlacement( false );
WebCamDynamicImageBrush = MakeShareable( new FSlateDynamicImageBrush(
WebCamTexture,
FVector2D( WebCamTexture->GetSizeX(), WebCamTexture->GetSizeY() ),
WebCamTexture->GetFName() ) );
// If the web cam image is coming in flipped, we'll apply mirroring to the Slate brush
if( bIsImageFlippedHorizontally && bIsImageFlippedVertically )
{
WebCamDynamicImageBrush->Mirroring = ESlateBrushMirrorType::Both;
}
else if( bIsImageFlippedHorizontally )
{
WebCamDynamicImageBrush->Mirroring = ESlateBrushMirrorType::Horizontal;
}
else if( bIsImageFlippedVertically )
{
WebCamDynamicImageBrush->Mirroring = ESlateBrushMirrorType::Vertical;
}
// @todo livestream: Currently if the user closes the window, the camera is deactivated and it doesn't turn back on unless the broadcast is restarted. We could allow the camera to be reactivated though.
BroadcastStatusWindow->SetOnWindowClosed(
FOnWindowClosed::CreateStatic( []( const TSharedRef<SWindow>& Window, FEditorLiveStreaming* This )
{
// User closed the broadcast status window, so go ahead and shut down the web cam
This->LiveStreamer->StopWebCam();
This->BroadcastStatusWindow.Reset();
This->WebCamDynamicImageBrush.Reset();
},
this ) );
BroadcastStatusWindow->SetContent(
SNew( SImage )
.Image( WebCamDynamicImageBrush.Get() )
);
FSlateApplication::Get().AddWindowAsNativeChild(
BroadcastStatusWindow.ToSharedRef(),
RootWindow.ToSharedRef() );
}
}
else if( Status.StatusType == FLiveStreamingStatus::EStatusType::WebCamTextureNotReady )
{
CloseBroadcastStatusWindow();
}
}
bool FDirectInputPadDevice::Init(bool bBackGround)
{
UDirectInputPadFunctionLibrary::InitDirectInputPadJoystickLibrary();
// MainWindowのウインドウハンドルを取得する
HWND hWnd = NULL;
TSharedPtr<SWindow> MainWindow;
#if WITH_EDITOR
if(GIsEditor)
{
auto& MainFrameModule = IMainFrameModule::Get();
MainWindow = MainFrameModule.GetParentWindow();
}
else
#endif
{
MainWindow = GEngine->GameViewport->GetWindow();
}
if(MainWindow.IsValid() && MainWindow->GetNativeWindow().IsValid())
{
hWnd = static_cast<HWND>(MainWindow->GetNativeWindow()->GetOSWindowHandle());
}
DDriver_ = MakeShareable<FDirectInputDriver>(new FDirectInputDriver());
if(!DDriver_->Init())
{
bInit_ = false;
return bInit_;
}
DFactory_ = MakeShareable<FDirectInputJoystickFactory>(new FDirectInputJoystickFactory());
if(!DFactory_->Init(hWnd, DDriver_, bBackGround))
{
bInit_ = false;
return bInit_;
}
XInputDeviceNum_ = DFactory_->GetXInputDeviceNum();
DInputDeviceNum_ = 0;
XJoysticks_.SetNum(MAX_JOYSTICKS);
uint32 DJoyNum = MAX_JOYSTICKS - XInputDeviceNum_;
DJoyNum =( DFactory_->EnabledJoystickNum() < DJoyNum) ? DFactory_->EnabledJoystickNum() : DJoyNum;
UE_LOG(LogDirectInputPadPlugin, Log, TEXT("DirectInputPad detected: %d"), DJoyNum);
for(uint32 i=0; i<DJoyNum; ++i)
{
//UE_LOG(LogDirectInputPadPlugin, Log, TEXT("DIPad %d"),i);
auto joy = DFactory_->GetJoystick(i);
if(joy.IsValid())
{
joy->SetPlayerIndex(XInputDeviceNum_+i);
XJoysticks_[XInputDeviceNum_+i] = MakeShareable<FXInputJoystickEmu>(new FXInputJoystickEmu());
XJoysticks_[XInputDeviceNum_+i]->Init(joy.ToSharedRef());
++DInputDeviceNum_;
}
}
bInit_ = true;
return bInit_;
}
/** Constructs this widget with InArgs */
void Construct( const FArguments& InArgs )
{
Style = InArgs._Style;
HighlightedText = InArgs._HighlightedText;
Label = InArgs._Label;
HintColorAndOpacity = InArgs._HintColorAndOpacity;
bAllowHintText = InArgs._AllowHintText;
AssetThumbnail = InArgs._AssetThumbnail;
bHasRenderedThumbnail = false;
WidthLastFrame = 0;
GenericThumbnailBorderPadding = 2.f;
AssetThumbnail->OnAssetDataChanged().AddSP(this, &SAssetThumbnail::OnAssetDataChanged);
const FAssetData& AssetData = AssetThumbnail->GetAssetData();
UClass* Class = FindObject<UClass>(ANY_PACKAGE, *AssetData.AssetClass.ToString());
FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>(TEXT("AssetTools"));
TSharedPtr<IAssetTypeActions> AssetTypeActions;
if ( Class != NULL )
{
AssetTypeActions = AssetToolsModule.Get().GetAssetTypeActionsForClass(Class).Pin();
}
AssetColor = FLinearColor::White;
if( InArgs._AssetTypeColorOverride.IsSet() )
{
AssetColor = InArgs._AssetTypeColorOverride.GetValue();
}
else if ( AssetTypeActions.IsValid() )
{
AssetColor = AssetTypeActions->GetTypeColor();
}
TSharedRef<SOverlay> OverlayWidget = SNew(SOverlay);
UpdateThumbnailClass(AssetData.AssetName, Class);
ClassThumbnailBrushOverride = InArgs._ClassThumbnailBrushOverride;
// The generic representation of the thumbnail, for use before the rendered version, if it exists
OverlayWidget->AddSlot()
[
SNew(SBorder)
.BorderImage(GetAssetBackgroundBrush())
.BorderBackgroundColor(AssetColor.CopyWithNewOpacity(0.3f))
.Padding(GenericThumbnailBorderPadding)
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
.Visibility(this, &SAssetThumbnail::GetGenericThumbnailVisibility)
[
SNew(SOverlay)
+SOverlay::Slot()
[
SAssignNew(GenericLabelTextBlock, STextBlock)
.Text(GetLabelText())
.Font(GetTextFont())
.Justification(ETextJustify::Center)
.ColorAndOpacity(FEditorStyle::GetColor(Style, ".ColorAndOpacity"))
.ShadowOffset(FEditorStyle::GetVector(Style, ".ShadowOffset"))
.ShadowColorAndOpacity( FEditorStyle::GetColor(Style, ".ShadowColorAndOpacity"))
.HighlightText(HighlightedText)
]
+SOverlay::Slot()
[
SAssignNew(GenericThumbnailImage, SImage)
.Image(this, &SAssetThumbnail::GetClassThumbnailBrush)
]
]
];
if ( InArgs._ThumbnailPool.IsValid() && !InArgs._ForceGenericThumbnail )
{
ViewportFadeAnimation = FCurveSequence();
ViewportFadeCurve = ViewportFadeAnimation.AddCurve(0.f, 0.25f, ECurveEaseFunction::QuadOut);
TSharedPtr<SViewport> Viewport =
SNew( SViewport )
.EnableGammaCorrection(false);
Viewport->SetViewportInterface( AssetThumbnail.ToSharedRef() );
AssetThumbnail->GetViewportRenderTargetTexture(); // Access the render texture to push it on the stack if it isnt already rendered
InArgs._ThumbnailPool->OnThumbnailRendered().AddSP(this, &SAssetThumbnail::OnThumbnailRendered);
InArgs._ThumbnailPool->OnThumbnailRenderFailed().AddSP(this, &SAssetThumbnail::OnThumbnailRenderFailed);
if ( ShouldRender() && (!InArgs._AllowFadeIn || InArgs._ThumbnailPool->IsRendered(AssetThumbnail)) )
{
bHasRenderedThumbnail = true;
ViewportFadeAnimation.JumpToEnd();
}
// The viewport for the rendered thumbnail, if it exists
OverlayWidget->AddSlot()
[
SAssignNew(RenderedThumbnailWidget, SBorder)
.Padding(0)
.BorderImage(FEditorStyle::GetBrush("NoBrush"))
.ColorAndOpacity(this, &SAssetThumbnail::GetViewportColorAndOpacity)
[
Viewport.ToSharedRef()
]
];
}
if( ThumbnailClass.Get() && bIsClassType )
{
OverlayWidget->AddSlot()
.VAlign(VAlign_Bottom)
.HAlign(HAlign_Right)
.Padding(TAttribute<FMargin>(this, &SAssetThumbnail::GetClassIconPadding))
[
SAssignNew(ClassIconWidget, SBorder)
.BorderImage(FEditorStyle::GetNoBrush())
[
SNew(SImage)
.Image(this, &SAssetThumbnail::GetClassIconBrush)
]
];
}
if( bAllowHintText )
{
OverlayWidget->AddSlot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Top)
.Padding(FMargin(2, 2, 2, 2))
[
SNew(SBorder)
.BorderImage(FEditorStyle::GetBrush(Style, ".HintBackground"))
.BorderBackgroundColor(this, &SAssetThumbnail::GetHintBackgroundColor) //Adjust the opacity of the border itself
.ColorAndOpacity(HintColorAndOpacity) //adjusts the opacity of the contents of the border
.Visibility(this, &SAssetThumbnail::GetHintTextVisibility)
.Padding(0)
[
SAssignNew(HintTextBlock, STextBlock)
.Text(GetLabelText())
.Font(GetHintTextFont())
.ColorAndOpacity(FEditorStyle::GetColor(Style, ".HintColorAndOpacity"))
.ShadowOffset(FEditorStyle::GetVector(Style, ".HintShadowOffset"))
.ShadowColorAndOpacity(FEditorStyle::GetColor(Style, ".HintShadowColorAndOpacity"))
.HighlightText(HighlightedText)
]
];
}
// The asset color strip
OverlayWidget->AddSlot()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Bottom)
[
SAssignNew(AssetColorStripWidget, SBorder)
.BorderImage(FEditorStyle::GetBrush("WhiteBrush"))
.BorderBackgroundColor(AssetColor)
.Padding(this, &SAssetThumbnail::GetAssetColorStripPadding)
];
if( InArgs._AllowAssetSpecificThumbnailOverlay && AssetTypeActions.IsValid() )
{
// Does the asset provide an additional thumbnail overlay?
TSharedPtr<SWidget> AssetSpecificThumbnailOverlay = AssetTypeActions->GetThumbnailOverlay(AssetData);
if( AssetSpecificThumbnailOverlay.IsValid() )
{
OverlayWidget->AddSlot()
[
AssetSpecificThumbnailOverlay.ToSharedRef()
];
}
}
ChildSlot
[
OverlayWidget
];
UpdateThumbnailVisibilities();
}
