FReply SObjectWidget::OnDragDetected(const FGeometry& MyGeometry, const FPointerEvent& PointerEvent) { if ( CanRouteEvent() ) { UDragDropOperation* Operation = nullptr; WidgetObject->NativeOnDragDetected( MyGeometry, PointerEvent, Operation ); if ( Operation ) { FVector2D ScreenCursorPos = PointerEvent.GetScreenSpacePosition(); FVector2D ScreenDrageePosition = MyGeometry.AbsolutePosition; float DPIScale = UWidgetLayoutLibrary::GetViewportScale(WidgetObject); TSharedRef<FUMGDragDropOp> DragDropOp = FUMGDragDropOp::New(Operation, ScreenCursorPos, ScreenDrageePosition, DPIScale, SharedThis(this)); return FReply::Handled().BeginDragDrop(DragDropOp); } } return FReply::Unhandled(); }
void SMultiBoxWidget::AddBlockWidget( const FMultiBlock& Block, TSharedPtr<SHorizontalBox> HorizontalBox, TSharedPtr<SVerticalBox> VerticalBox, EMultiBlockLocation::Type InLocation, bool bSectionContainsIcons ) { check( MultiBox.IsValid() ); bool bDisplayExtensionHooks = FMultiBoxSettings::DisplayMultiboxHooks.Get() && Block.GetExtensionHook() != NAME_None; TSharedRef<SWidget> BlockWidget = Block.MakeWidget(SharedThis(this), InLocation, bSectionContainsIcons)->AsWidget(); TWeakPtr<SWidget> BlockWidgetWeakPtr = BlockWidget; TWeakPtr<const FMultiBlock> BlockWeakPtr = Block.AsShared(); const ISlateStyle* const StyleSet = MultiBox->GetStyleSet(); TSharedRef<SWidget> FinalWidget = SNew( SOverlay ) + SOverlay::Slot() [ BlockWidget ] + SOverlay::Slot() [ // This overlay prevents users from clicking on the actual block when in edit mode and also allows new blocks // to be dropped on disabled blocks SNew( SMultiBlockDragHandle, SharedThis( this ), Block.AsShared(), MultiBox->GetCustomizationName() ) .Visibility( this, &SMultiBoxWidget::GetCustomizationVisibility, BlockWeakPtr, BlockWidgetWeakPtr ) ] + SOverlay::Slot() .HAlign( HAlign_Right ) .VAlign( VAlign_Top ) .Padding( FMargin(0.0f, 2.0f, 1.0f, 0.0f ) ) [ // The delete button for removing blocks is only visible when in edit mode SNew( SButton ) .Visibility( this, &SMultiBoxWidget::GetCustomizationVisibility, BlockWeakPtr, BlockWidgetWeakPtr ) .ContentPadding(0) .OnClicked( this, &SMultiBoxWidget::OnDeleteBlockClicked, BlockWeakPtr ) .ButtonStyle( StyleSet, "MultiBox.DeleteButton" ) ]; switch (MultiBox->GetType()) { case EMultiBoxType::MenuBar: case EMultiBoxType::ToolBar: { HorizontalBox->AddSlot() .AutoWidth() .Padding( 0 ) [ SNew(SVerticalBox) +SVerticalBox::Slot() .HAlign(HAlign_Center) .AutoHeight() [ SNew(STextBlock) .Visibility(bDisplayExtensionHooks ? EVisibility::Visible : EVisibility::Collapsed) .ColorAndOpacity(StyleSet->GetColor("MultiboxHookColor")) .Text(Block.GetExtensionHook().ToString()) ] +SVerticalBox::Slot() [ FinalWidget ] ]; } break; case EMultiBoxType::VerticalToolBar: { VerticalBox->AddSlot() .AutoHeight() .Padding( 0.0f, 1.0f, 0.0f, 1.0f ) [ SNew(SVerticalBox) +SVerticalBox::Slot() .HAlign(HAlign_Center) .AutoHeight() [ SNew(STextBlock) .Visibility(bDisplayExtensionHooks ? EVisibility::Visible : EVisibility::Collapsed) .ColorAndOpacity(StyleSet->GetColor("MultiboxHookColor")) .Text(Block.GetExtensionHook().ToString()) ] +SVerticalBox::Slot() [ FinalWidget ] ]; } break; case EMultiBoxType::ButtonRow: { TileViewWidgets.Add( FinalWidget ); } break; case EMultiBoxType::Menu: { VerticalBox->AddSlot() .AutoHeight() .Padding( 1.0f, 0.0f, 1.0f, 0.0f ) [ SNew(SHorizontalBox) +SHorizontalBox::Slot() .AutoWidth() .VAlign(VAlign_Center) [ SNew(STextBlock) .Visibility(bDisplayExtensionHooks ? EVisibility::Visible : EVisibility::Collapsed) .ColorAndOpacity(StyleSet->GetColor("MultiboxHookColor")) .Text(Block.GetExtensionHook().ToString()) ] +SHorizontalBox::Slot() [ FinalWidget ] ]; } break; } }
TSharedRef<FEditorViewportClient> SPhATPreviewViewport::MakeEditorViewportClient() { EditorViewportClient = MakeShareable(new FPhATEdPreviewViewportClient(PhATPtr, PhATPtr.Pin()->GetSharedData(), SharedThis(this))); EditorViewportClient->bSetListenerPosition = false; EditorViewportClient->SetRealtime(!FPhAT::IsPIERunning()); EditorViewportClient->VisibilityDelegate.BindSP(this, &SPhATPreviewViewport::IsVisible); return EditorViewportClient.ToSharedRef(); }
void FObjectPropertyNode::InternalInitChildNodes( FName SinglePropertyName ) { HiddenCategories.Empty(); // Assemble a list of category names by iterating over all fields of BaseClass. // build a list of classes that we need to look at TSet<UClass*> ClassesToConsider; for( int32 i = 0; i < GetNumObjects(); ++i ) { UObject* TempObject = GetUObject( i ); if( TempObject ) { ClassesToConsider.Add( TempObject->GetClass() ); } } const bool bShouldShowHiddenProperties = !!HasNodeFlags(EPropertyNodeFlags::ShouldShowHiddenProperties); const bool bShouldShowDisableEditOnInstance = !!HasNodeFlags(EPropertyNodeFlags::ShouldShowDisableEditOnInstance); TSet<FName> Categories; for( TFieldIterator<UProperty> It(BaseClass.Get()); It; ++It ) { bool bHidden = false; FName CategoryName = FObjectEditorUtils::GetCategoryFName(*It); for( UClass* Class : ClassesToConsider ) { if( FEditorCategoryUtils::IsCategoryHiddenFromClass(Class, CategoryName.ToString()) ) { HiddenCategories.Add( CategoryName ); bHidden = true; break; } } bool bMetaDataAllowVisible = true; FString MetaDataVisibilityCheckString = It->GetMetaData(TEXT("bShowOnlyWhenTrue")); if (MetaDataVisibilityCheckString.Len()) { //ensure that the metadata visibility string is actually set to true in order to show this property GConfig->GetBool(TEXT("UnrealEd.PropertyFilters"), *MetaDataVisibilityCheckString, bMetaDataAllowVisible, GEditorUserSettingsIni); } if (bMetaDataAllowVisible) { const bool bShowIfNonHiddenEditableProperty = (*It)->HasAnyPropertyFlags(CPF_Edit) && !bHidden; const bool bShowIfDisableEditOnInstance = !(*It)->HasAnyPropertyFlags(CPF_DisableEditOnInstance) || bShouldShowDisableEditOnInstance; if( bShouldShowHiddenProperties || (bShowIfNonHiddenEditableProperty && bShowIfDisableEditOnInstance) ) { Categories.Add( CategoryName ); } } } ////////////////////////////////////////// // Add the category headers and the child items that belong inside of them. // Only show category headers if this is the top level object window and the parent window allows headers. if( HasNodeFlags(EPropertyNodeFlags::ShowCategories) ) { FString CategoryDelimiterString; CategoryDelimiterString.AppendChar( FPropertyNodeConstants::CategoryDelimiterChar ); TArray< FPropertyNode* > ParentNodesToSort; for( const FName& FullCategoryPath : Categories ) { // Figure out the nesting level for this category TArray< FString > FullCategoryPathStrings; FullCategoryPath.ToString().ParseIntoArray( FullCategoryPathStrings, *CategoryDelimiterString, true ); TSharedPtr<FPropertyNode> ParentLevelNode = SharedThis(this); FString CurCategoryPathString; for( int32 PathLevelIndex = 0; PathLevelIndex < FullCategoryPathStrings.Num(); ++PathLevelIndex ) { // Build up the category path name for the current path level index if( CurCategoryPathString.Len() != 0 ) { CurCategoryPathString += FPropertyNodeConstants::CategoryDelimiterChar; } CurCategoryPathString += FullCategoryPathStrings[ PathLevelIndex ]; const FName CategoryName( *CurCategoryPathString ); // Check to see if we've already created a category at the specified path level bool bFoundMatchingCategory = false; { for( int32 CurNodeIndex = 0; CurNodeIndex < ParentLevelNode->GetNumChildNodes(); ++CurNodeIndex ) { TSharedPtr<FPropertyNode>& ChildNode = ParentLevelNode->GetChildNode( CurNodeIndex ); check( ChildNode.IsValid() ); // Is this a category node? FCategoryPropertyNode* ChildCategoryNode = ChildNode->AsCategoryNode(); if( ChildCategoryNode != NULL ) { // Does the name match? if( ChildCategoryNode->GetCategoryName() == CategoryName ) { // Descend by using the child node as the new parent bFoundMatchingCategory = true; ParentLevelNode = ChildNode; break; } } } } // If we didn't find the category, then we'll need to create it now! if( !bFoundMatchingCategory ) { // Create the category node and assign it to its parent node TSharedPtr<FCategoryPropertyNode> NewCategoryNode( new FCategoryPropertyNode ); { NewCategoryNode->SetCategoryName( CategoryName ); FPropertyNodeInitParams InitParams; InitParams.ParentNode = ParentLevelNode; InitParams.Property = NULL; InitParams.ArrayOffset = 0; InitParams.ArrayIndex = INDEX_NONE; InitParams.bAllowChildren = true; InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties; InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance; NewCategoryNode->InitNode( InitParams ); // Recursively expand category properties if the category has been flagged for auto-expansion. if (BaseClass->IsAutoExpandCategory(*CategoryName.ToString()) && !BaseClass->IsAutoCollapseCategory(*CategoryName.ToString())) { NewCategoryNode->SetNodeFlags(EPropertyNodeFlags::Expanded, true); } // Add this node to it's parent. Note that no sorting happens here, so the parent's // list of child nodes will not be in the correct order. We'll keep track of which // nodes we added children to so we can sort them after we're finished adding new nodes. ParentLevelNode->AddChildNode(NewCategoryNode); ParentNodesToSort.AddUnique( ParentLevelNode.Get() ); } // Descend into the newly created category by using this node as the new parent ParentLevelNode = NewCategoryNode; } } } } else { // Iterate over all fields, creating items. for( TFieldIterator<UProperty> It(BaseClass.Get()); It; ++It ) { const bool bShowIfNonHiddenEditableProperty = (*It)->HasAnyPropertyFlags(CPF_Edit) && !FEditorCategoryUtils::IsCategoryHiddenFromClass(BaseClass.Get(), FObjectEditorUtils::GetCategory(*It)); const bool bShowIfDisableEditOnInstance = !(*It)->HasAnyPropertyFlags(CPF_DisableEditOnInstance) || bShouldShowDisableEditOnInstance; if (bShouldShowHiddenProperties || (bShowIfNonHiddenEditableProperty && bShowIfDisableEditOnInstance)) { UProperty* CurProp = *It; if( SinglePropertyName == NAME_None || CurProp->GetFName() == SinglePropertyName ) { TSharedPtr<FItemPropertyNode> NewItemNode( new FItemPropertyNode ); FPropertyNodeInitParams InitParams; InitParams.ParentNode = SharedThis(this); InitParams.Property = CurProp; InitParams.ArrayOffset = 0; InitParams.ArrayIndex = INDEX_NONE; InitParams.bAllowChildren = SinglePropertyName == NAME_None; InitParams.bForceHiddenPropertyVisibility = bShouldShowHiddenProperties; InitParams.bCreateDisableEditOnInstanceNodes = bShouldShowDisableEditOnInstance; NewItemNode->InitNode( InitParams ); AddChildNode(NewItemNode); if( SinglePropertyName != NAME_None ) { // Generate no other children break; } } } } } }
FReply STimeline::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) { Owner->ChangeSelection(SharedThis(this), MouseEvent); return FReply::Unhandled(); }
TSharedRef<FEditorViewportClient> STileMapEditorViewport::MakeEditorViewportClient() { EditorViewportClient = MakeShareable(new FTileMapEditorViewportClient(TileMapEditorPtr, SharedThis(this))); return EditorViewportClient.ToSharedRef(); }
TSharedRef<class SEditorViewport> STileMapEditorViewport::GetViewportWidget() { return SharedThis(this); }
TSharedRef<FEditorViewportClient> SPythonEditorViewport::MakeEditorViewportClient() { PreviewScene = new FPreviewScene(); TSharedPtr<FEditorViewportClient> client = MakeShareable(new FPythonEditorViewportClient(nullptr, PreviewScene, SharedThis(this))); client->SetRealtime(true); client->SetViewportType(ELevelViewportType::LVT_Perspective); FExposureSettings settings; settings.bFixed = true; #if ENGINE_MINOR_VERSION > 18 settings.FixedEV100 = 0; #else settings.LogOffset = 0; #endif client->ExposureSettings = settings; return client.ToSharedRef(); }
TSharedRef<SEditorViewport> SPythonEditorViewport::GetViewportWidget() { return SharedThis(this); }
void FLandscapeToolKit::Init(const TSharedPtr< class IToolkitHost >& InitToolkitHost) { LandscapeEditorWidgets = SNew(SLandscapeEditor, SharedThis(this)); FModeToolkit::Init(InitToolkitHost); }
void SVisualLogger::Construct(const FArguments& InArgs, const TSharedRef<SDockTab>& ConstructUnderMajorTab, const TSharedPtr<SWindow>& ConstructUnderWindow) { bPausedLogger = false; bGotHistogramData = false; FLogVisualizer::Get().SetCurrentVisualizer(SharedThis(this)); ////////////////////////////////////////////////////////////////////////// // Visual Logger Events FLogVisualizer::Get().GetVisualLoggerEvents().OnItemSelectionChanged = FOnItemSelectionChanged::CreateRaw(this, &SVisualLogger::OnItemSelectionChanged); FLogVisualizer::Get().GetVisualLoggerEvents().OnFiltersChanged = FOnFiltersChanged::CreateRaw(this, &SVisualLogger::OnFiltersChanged); FLogVisualizer::Get().GetVisualLoggerEvents().OnObjectSelectionChanged = FOnObjectSelectionChanged::CreateRaw(this, &SVisualLogger::OnObjectSelectionChanged); FLogVisualizer::Get().GetVisualLoggerEvents().OnLogLineSelectionChanged = FOnLogLineSelectionChanged::CreateRaw(this, &SVisualLogger::OnLogLineSelectionChanged); ////////////////////////////////////////////////////////////////////////// // Command Action Lists const FVisualLoggerCommands& Commands = FVisualLoggerCommands::Get(); FUICommandList& ActionList = *CommandList; ULogVisualizerSettings* Settings = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>(); FCategoryFiltersManager::Get().LoadPresistentData(); ActionList.MapAction(Commands.StartRecording, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandIsVisible)); ActionList.MapAction(Commands.StopRecording, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandIsVisible)); ActionList.MapAction(Commands.Pause, FExecuteAction::CreateRaw(this, &SVisualLogger::HandlePauseCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandlePauseCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandlePauseCommandIsVisible)); ActionList.MapAction(Commands.Resume, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleResumeCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleResumeCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleResumeCommandIsVisible)); ActionList.MapAction(Commands.LoadFromVLog, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleLoadCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleLoadCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleLoadCommandCanExecute)); ActionList.MapAction(Commands.SaveToVLog, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute)); ActionList.MapAction(Commands.FreeCamera, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleCameraCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleCameraCommandCanExecute), FIsActionChecked::CreateRaw(this, &SVisualLogger::HandleCameraCommandIsChecked), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleCameraCommandCanExecute)); ActionList.MapAction(Commands.ToggleGraphs, FExecuteAction::CreateLambda([](){bool& bEnableGraphsVisualization = ULogVisualizerSessionSettings::StaticClass()->GetDefaultObject<ULogVisualizerSessionSettings>()->bEnableGraphsVisualization; bEnableGraphsVisualization = !bEnableGraphsVisualization; }), FCanExecuteAction::CreateLambda([this]()->bool{return bGotHistogramData; }), FIsActionChecked::CreateLambda([]()->bool{return ULogVisualizerSessionSettings::StaticClass()->GetDefaultObject<ULogVisualizerSessionSettings>()->bEnableGraphsVisualization; }), FIsActionButtonVisible::CreateLambda([this]()->bool{return bGotHistogramData; })); ActionList.MapAction(Commands.ResetData, FExecuteAction::CreateRaw(this, &SVisualLogger::ResetData), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute)); ActionList.MapAction( Commands.MoveCursorLeft, FExecuteAction::CreateRaw(this, &SVisualLogger::OnMoveCursorLeftCommand)); ActionList.MapAction( Commands.MoveCursorRight, FExecuteAction::CreateRaw(this, &SVisualLogger::OnMoveCursorRightCommand)); // Tab Spawners TabManager = FGlobalTabmanager::Get()->NewTabManager(ConstructUnderMajorTab); TSharedRef<FWorkspaceItem> AppMenuGroup = TabManager->AddLocalWorkspaceMenuCategory(LOCTEXT("VisualLoggerGroupName", "Visual Logger")); TabManager->RegisterTabSpawner(ToolbarTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, ToolbarTabId)) .SetDisplayName(LOCTEXT("ToolbarTabTitle", "Toolbar")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "ToolbarTabIcon")); TabManager->RegisterTabSpawner(FiltersTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, FiltersTabId)) .SetDisplayName(LOCTEXT("FiltersTabTitle", "Filters")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "FiltersTabIcon")); TabManager->RegisterTabSpawner(MainViewTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, MainViewTabId)) .SetDisplayName(LOCTEXT("MainViewTabTitle", "MainView")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "MainViewTabIcon")); TabManager->RegisterTabSpawner(LogsListTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, LogsListTabId)) .SetDisplayName(LOCTEXT("LogsListTabTitle", "LogsList")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "LogsListTabIcon")); TabManager->RegisterTabSpawner(StatusViewTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, StatusViewTabId)) .SetDisplayName(LOCTEXT("StatusViewTabTitle", "StatusView")) .SetGroup(AppMenuGroup) .SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "StatusViewTabIcon")); // Default Layout const TSharedRef<FTabManager::FLayout> Layout = FTabManager::NewLayout("VisualLoggerLayout_v1.0") ->AddArea ( FTabManager::NewPrimaryArea() ->SetOrientation(Orient_Vertical) ->Split ( FTabManager::NewStack() ->AddTab(ToolbarTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ) ->Split ( FTabManager::NewStack() ->AddTab(FiltersTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ) ->Split ( FTabManager::NewStack() ->AddTab(MainViewTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ) ->Split ( FTabManager::NewSplitter() ->SetOrientation(Orient_Horizontal) ->SetSizeCoefficient(0.6f) ->Split ( FTabManager::NewStack() ->AddTab(StatusViewTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ->SetSizeCoefficient(0.3f) ) ->Split ( FTabManager::NewStack() ->AddTab(LogsListTabId, ETabState::OpenedTab) ->SetHideTabWell(true) ->SetSizeCoefficient(0.7f) ) ) ); TabManager->SetOnPersistLayout(FTabManager::FOnPersistLayout::CreateRaw(this, &SVisualLogger::HandleTabManagerPersistLayout)); // Load the potentially previously saved new layout TSharedRef<FTabManager::FLayout> UserConfiguredNewLayout = FLayoutSaveRestore::LoadFromConfig(GEditorLayoutIni, Layout); TabManager->RestoreFrom(UserConfiguredNewLayout, TSharedPtr<SWindow>()); // Window Menu FMenuBarBuilder MenuBarBuilder = FMenuBarBuilder(TSharedPtr<FUICommandList>()); #if 0 //disabled File menu for now (SebaK) MenuBarBuilder.AddPullDownMenu( LOCTEXT("FileMenuLabel", "File"), FText::GetEmpty(), FNewMenuDelegate::CreateRaw(this, &SVisualLogger::FillFileMenu, TabManager), "File" ); #endif MenuBarBuilder.AddPullDownMenu( LOCTEXT("WindowMenuLabel", "Window"), FText::GetEmpty(), FNewMenuDelegate::CreateStatic(&SVisualLogger::FillWindowMenu, TabManager), "Window" ); MenuBarBuilder.AddMenuEntry( LOCTEXT("SettingsMenuLabel", "Settings"), FText::GetEmpty(), FSlateIcon(), FUIAction( FExecuteAction::CreateLambda( [this](){ ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings"); if (SettingsModule != nullptr) { SettingsModule->ShowViewer("Editor", "General", "VisualLogger"); } } )), "Settings" ); ChildSlot [ SNew(SVerticalBox) + SVerticalBox::Slot() .AutoHeight() [ MenuBarBuilder.MakeWidget() ] + SVerticalBox::Slot() .FillHeight(1.0f) [ TabManager->RestoreFrom(Layout, ConstructUnderWindow).ToSharedRef() ] ]; VisualLoggerCanvasRenderer = MakeShareable(new FVisualLoggerCanvasRenderer()); DrawOnCanvasDelegateHandle = UDebugDrawService::Register(TEXT("VisLog"), FDebugDrawDelegate::CreateRaw(VisualLoggerCanvasRenderer.Get(), &FVisualLoggerCanvasRenderer::DrawOnCanvas)); //UGameplayDebuggingComponent::OnDebuggingTargetChangedDelegate.AddSP(this, &SVisualLogger::SelectionChanged); }
TSharedRef<SWidget> SErrorText::AsWidget() { return SharedThis(this); }
void FAssetEditorToolkit::InitAssetEditor( const EToolkitMode::Type Mode, const TSharedPtr< class IToolkitHost >& InitToolkitHost, const FName AppIdentifier, const TSharedRef<FTabManager::FLayout>& StandaloneDefaultLayout, const bool bCreateDefaultStandaloneMenu, const bool bCreateDefaultToolbar, const TArray<UObject*>& ObjectsToEdit, const bool bInIsToolbarFocusable ) { // Must not already be editing an object check( ObjectsToEdit.Num() > 0 ); check( EditingObjects.Num() == 0 ); bIsToolbarFocusable = bInIsToolbarFocusable; // cache reference to ToolkitManager; also ensure it was initialized. FToolkitManager& ToolkitManager = FToolkitManager::Get(); EditingObjects.Append( ObjectsToEdit ); // Store "previous" asset editing toolkit host, and clear it out PreviousWorldCentricToolkitHost = PreviousWorldCentricToolkitHostForNewAssetEditor; PreviousWorldCentricToolkitHostForNewAssetEditor.Reset(); ToolkitMode = Mode; TSharedPtr<SWindow> ParentWindow; TSharedPtr<SDockTab> NewMajorTab; TSharedPtr< SStandaloneAssetEditorToolkitHost > NewStandaloneHost; if( ToolkitMode == EToolkitMode::WorldCentric ) // @todo toolkit major: Do we need to remember this setting on a per-asset editor basis? Probably. { // Keep track of the level editor we're attached to (if any) ToolkitHost = InitToolkitHost; } else if( ensure( ToolkitMode == EToolkitMode::Standalone ) ) { // Open a standalone app to edit this asset. check( AppIdentifier != NAME_None ); // Create the label and the link for the toolkit documentation. TAttribute<FText> Label = TAttribute<FText>( this, &FAssetEditorToolkit::GetToolkitName ); FString DocLink = GetDocumentationLink(); if ( !DocLink.StartsWith( "Shared/" ) ) { DocLink = FString("Shared/") + DocLink; } // Create a new SlateToolkitHost NewMajorTab = SNew(SDockTab) .ContentPadding(0.0f) .TabRole(ETabRole::MajorTab) .ToolTip( IDocumentation::Get()->CreateToolTip( Label, nullptr, DocLink, GetToolkitFName().ToString() ) ) .Icon( this, &FAssetEditorToolkit::GetDefaultTabIcon ) .Label( Label ); { static_assert(sizeof(EAssetEditorToolkitTabLocation) == sizeof(int32), "EAssetEditorToolkitTabLocation is the incorrect size"); // Work out where we should create this asset editor EAssetEditorToolkitTabLocation SavedAssetEditorToolkitTabLocation = EAssetEditorToolkitTabLocation::Standalone; GConfig->GetInt( TEXT("AssetEditorToolkitTabLocation"), *ObjectsToEdit[0]->GetPathName(), reinterpret_cast<int32&>(SavedAssetEditorToolkitTabLocation), GEditorUserSettingsIni ); const FName AssetEditorToolkitTab = (SavedAssetEditorToolkitTabLocation == EAssetEditorToolkitTabLocation::Docked) ? "DockedToolkit" : "StandaloneToolkit"; FGlobalTabmanager::Get()->InsertNewDocumentTab( AssetEditorToolkitTab, FTabManager::ESearchPreference::PreferLiveTab, NewMajorTab.ToSharedRef() ); } #if PLATFORM_MAC FSuperSearchModule& SuperSearchModule = FModuleManager::LoadModuleChecked< FSuperSearchModule >(TEXT("SuperSearch")); TSharedPtr< SEditableTextBox > ExposedEditableTextBox; TSharedRef<SWidget> SuperSearchWidget = SuperSearchModule.MakeSearchBox(ExposedEditableTextBox); #endif IUserFeedbackModule& UserFeedback = FModuleManager::LoadModuleChecked<IUserFeedbackModule>(TEXT("UserFeedback")); TSharedRef<SWidget> UserFeedbackWidget = UserFeedback.CreateFeedbackWidget(GetBaseToolkitName()); IIntroTutorials& IntroTutorials = FModuleManager::LoadModuleChecked<IIntroTutorials>(TEXT("IntroTutorials")); TSharedRef<SWidget> TutorialWidget = IntroTutorials.CreateTutorialsWidget(GetToolkitContextFName(), NewMajorTab->GetParentWindow()); NewMajorTab->SetRightContent( SNew(SHorizontalBox) + SHorizontalBox::Slot() .AutoWidth() .Padding(8.0f, 0.0f, 0.0f, 0.0f) .VAlign(VAlign_Center) [ UserFeedbackWidget ] #if PLATFORM_MAC +SHorizontalBox::Slot() .AutoWidth() .Padding(16.0f, 0.0f, 0.0f, 0.0f) .VAlign(VAlign_Center) [ SuperSearchWidget ] #endif +SHorizontalBox::Slot() .AutoWidth() .Padding(8.0f, 0.0f, 8.0f, 0.0f) .VAlign(VAlign_Center) [ TutorialWidget ] ); const TSharedRef<FTabManager> NewTabManager = FGlobalTabmanager::Get()->NewTabManager( NewMajorTab.ToSharedRef() ); NewTabManager->SetOnPersistLayout(FTabManager::FOnPersistLayout::CreateRaw(this, &FAssetEditorToolkit::HandleTabManagerPersistLayout)); this->TabManager = NewTabManager; NewMajorTab->SetContent ( SAssignNew( NewStandaloneHost, SStandaloneAssetEditorToolkitHost, NewTabManager, AppIdentifier ) .OnRequestClose(this, &FAssetEditorToolkit::OnRequestClose) ); // Assign our toolkit host before we setup initial content. (Important: We must cache this pointer here as SetupInitialContent // will callback into the toolkit host.) ToolkitHost = NewStandaloneHost; } check( ToolkitHost.IsValid() ); ToolkitManager.RegisterNewToolkit( SharedThis( this ) ); if (ToolkitMode == EToolkitMode::Standalone) { TSharedRef<FTabManager::FLayout> LayoutToUse = FLayoutSaveRestore::LoadFromConfig(GEditorLayoutIni, StandaloneDefaultLayout); // Actually create the widget content NewStandaloneHost->SetupInitialContent( LayoutToUse, NewMajorTab, bCreateDefaultStandaloneMenu ); } StandaloneHost = NewStandaloneHost; if (bCreateDefaultToolbar) { GenerateToolbar(); } else { Toolbar = SNullWidget::NullWidget; } ToolkitCommands->MapAction( FAssetEditorCommonCommands::Get().SaveAsset, FExecuteAction::CreateSP( this, &FAssetEditorToolkit::SaveAsset_Execute ), FCanExecuteAction::CreateSP( this, &FAssetEditorToolkit::CanSaveAsset )); ToolkitCommands->MapAction( FGlobalEditorCommonCommands::Get().FindInContentBrowser, FExecuteAction::CreateSP( this, &FAssetEditorToolkit::FindInContentBrowser_Execute ) ); ToolkitCommands->MapAction( FGlobalEditorCommonCommands::Get().ViewReferences, FExecuteAction::CreateSP( this, &FAssetEditorToolkit::ViewReferences_Execute ), FCanExecuteAction::CreateSP( this, &FAssetEditorToolkit::CanViewReferences )); ToolkitCommands->MapAction( FGlobalEditorCommonCommands::Get().OpenDocumentation, FExecuteAction::CreateSP( this, &FAssetEditorToolkit::BrowseDocumentation_Execute ) ); ToolkitCommands->MapAction( FAssetEditorCommonCommands::Get().ReimportAsset, FExecuteAction::CreateSP( this, &FAssetEditorToolkit::Reimport_Execute ) ); FGlobalEditorCommonCommands::MapActions(ToolkitCommands); if( IsWorldCentricAssetEditor() ) { ToolkitCommands->MapAction( FAssetEditorCommonCommands::Get().SwitchToStandaloneEditor, FExecuteAction::CreateStatic( &FAssetEditorToolkit::SwitchToStandaloneEditor_Execute, TWeakPtr< FAssetEditorToolkit >( AsShared() ) ) ); } else { if( GetPreviousWorldCentricToolkitHost().IsValid() ) { ToolkitCommands->MapAction( FAssetEditorCommonCommands::Get().SwitchToWorldCentricEditor, FExecuteAction::CreateStatic( &FAssetEditorToolkit::SwitchToWorldCentricEditor_Execute, TWeakPtr< FAssetEditorToolkit >( AsShared() ) ) ); } } // NOTE: Currently, the AssetEditorManager will keep a hard reference to our object as we're editing it FAssetEditorManager::Get().NotifyAssetsOpened( EditingObjects, this ); }
void FShotThumbnail::DrawThumbnail() { OwningSection.Pin()->DrawViewportThumbnail(SharedThis(this)); FadeInCurve.PlayReverse( OwningSection.Pin()->GetSequencerWidget() ); }
void FPropertyTable::UpdateColumns() { if( Orientation == EPropertyTableOrientation::AlignPropertiesInColumns) { TMultiMap< UProperty*, TSharedRef< IPropertyTableColumn > > ColumnsMap; for (int ColumnIdx = 0; ColumnIdx < Columns.Num(); ++ColumnIdx) { TSharedRef< IDataSource > DataSource = Columns[ColumnIdx]->GetDataSource(); TSharedPtr< FPropertyPath > PropertyPath = DataSource->AsPropertyPath(); if( PropertyPath.IsValid() && PropertyPath->GetNumProperties() > 0 ) { ColumnsMap.Add(PropertyPath->GetRootProperty().Property.Get(), Columns[ColumnIdx]); } } Columns.Empty(); if ( ShowRowHeader ) { TSharedRef< IPropertyTableColumn > NewColumn = MakeShareable( new FPropertyTableRowHeaderColumn( SharedThis( this ) ) ); Columns.Add( NewColumn ); } if ( ShowObjectName ) { TSharedRef< IPropertyTableColumn > NewColumn = MakeShareable( new FPropertyTableObjectNameColumn( SharedThis( this ) ) ); NewColumn->SetFrozen( true ); Columns.Add( NewColumn ); } TArray< TWeakObjectPtr< UStruct > > UniqueTypes; TArray< int > TypeCounter; for( auto ObjectIter = SourceObjects.CreateConstIterator(); ObjectIter; ++ObjectIter ) { auto Object = *ObjectIter; if( !Object.IsValid() ) { continue; } const TSharedRef< FObjectPropertyNode > RootObjectNode = GetObjectPropertyNode( Object ); TWeakObjectPtr< UStruct > Type; if ( RootPath->GetNumProperties() == 0 ) { Type = RootObjectNode->GetObjectBaseClass(); } else { const TSharedPtr< FPropertyNode > PropertyNode = FPropertyNode::FindPropertyNodeByPath( RootPath, RootObjectNode ); if ( !PropertyNode.IsValid() ) { continue; } const TWeakObjectPtr< UProperty > Property = PropertyNode->GetProperty(); if ( !Property.IsValid() || !Property->IsA( UStructProperty::StaticClass() ) ) { continue; } UStructProperty* StructProperty = Cast< UStructProperty >( Property.Get() ); Type = StructProperty->Struct; } if ( !Type.IsValid() ) { continue; } int FoundIndex = -1; if ( UniqueTypes.Find( Type, /*OUT*/FoundIndex ) ) { TypeCounter[ FoundIndex ] = TypeCounter[ FoundIndex ] + 1; continue; } UniqueTypes.Add( Type ); TypeCounter.Add( 1 ); } if ( UniqueTypes.Num() > 0 ) { int HighestCountIndex = 0; int HighestCount = 0; for (int Index = 0; Index < TypeCounter.Num(); Index++) { if ( TypeCounter[Index] > HighestCount ) { HighestCountIndex = Index; HighestCount = TypeCounter[Index]; } } TWeakObjectPtr< UStruct > PrimaryType = UniqueTypes[ HighestCountIndex ]; for (TFieldIterator<UProperty> PropertyIter( PrimaryType.Get(), EFieldIteratorFlags::IncludeSuper); PropertyIter; ++PropertyIter) { TWeakObjectPtr< UProperty > Property = *PropertyIter; if ( PropertyIter->HasAnyPropertyFlags(CPF_AssetRegistrySearchable) ) { TArray< TSharedRef< IPropertyTableColumn > > MapResults; ColumnsMap.MultiFind(Property.Get(), MapResults); if(MapResults.Num() > 0) { for (int MapIdx = 0; MapIdx < MapResults.Num(); ++MapIdx) { Columns.Add(MapResults[MapIdx]); } } else { TSharedRef< IPropertyTableColumn > NewColumn = CreateColumn( Property ); Columns.Add( NewColumn ); } } } } } else { Columns.Empty(); if( SourceObjects.Num() > 0 ) { UClass* ObjectClass = SourceObjects[0]->GetClass(); TSharedRef< IPropertyTableColumn > HeadingColumn = MakeShareable( new FPropertyTablePropertyNameColumn( SharedThis( this ) ) ); Columns.Add( HeadingColumn ); for( auto ObjectIter = SourceObjects.CreateConstIterator(); ObjectIter; ++ObjectIter ) { auto Object = *ObjectIter; if( Object.IsValid() ) { const TSharedRef< FObjectPropertyNode > ObjectNode = GetObjectPropertyNode( Object ); const TSharedPtr< FPropertyNode > PropertyNode = FPropertyNode::FindPropertyNodeByPath( RootPath, ObjectNode ); UProperty* Property = PropertyNode->GetProperty(); if ( Property != NULL && Property->IsA( UArrayProperty::StaticClass() ) ) { for (int ChildIdx = 0; ChildIdx < PropertyNode->GetNumChildNodes(); ChildIdx++) { TSharedPtr< FPropertyNode > ChildNode = PropertyNode->GetChildNode( ChildIdx ); FPropertyInfo Extension; Extension.Property = ChildNode->GetProperty(); Extension.ArrayIndex = ChildNode->GetArrayIndex(); TSharedRef< FPropertyPath > Path = FPropertyPath::CreateEmpty()->ExtendPath( Extension ); TSharedRef< IPropertyTableColumn > NewColumn = MakeShareable( new FPropertyTableColumn( SharedThis( this ), Object, Path ) ); Columns.Add( NewColumn ); } } else if ( Property != NULL ) { TSharedRef< IPropertyTableColumn > NewColumn = MakeShareable( new FPropertyTableColumn( SharedThis( this ), Object ) ); Columns.Add( NewColumn ); } } } } } ColumnsChanged.Broadcast(); }
TSharedPtr<SWidget> SPythonEditorViewport::MakeViewportToolbar() { return SNew(SCommonEditorViewportToolbarBase, SharedThis(this)); }
BEGIN_SLATE_FUNCTION_BUILD_OPTIMIZATION TSharedRef< SWidget > SWorldHierarchyItem::GenerateWidgetForColumn( const FName& ColumnID ) { TSharedPtr< SWidget > TableRowContent = SNullWidget::NullWidget; if (ColumnID == HierarchyColumns::ColumnID_LevelLabel) { TableRowContent = SNew(SHorizontalBox) +SHorizontalBox::Slot() .AutoWidth() [ SNew(SExpanderArrow, SharedThis(this)) ] +SHorizontalBox::Slot() .VAlign(VAlign_Center) .AutoWidth() [ SNew(SBox) .WidthOverride(7) // in case brush for this item is empty [ SNew(SImage) .Image(this, &SWorldHierarchyItem::GetLevelIconBrush) ] ] +SHorizontalBox::Slot() .VAlign(VAlign_Center) .AutoWidth() [ SNew(STextBlock) .Font(this, &SWorldHierarchyItem::GetLevelDisplayNameFont) .Text(this, &SWorldHierarchyItem::GetLevelDisplayNameText) .ColorAndOpacity(this, &SWorldHierarchyItem::GetLevelDisplayNameColorAndOpacity) .HighlightText(HighlightText) .ToolTipText(this, &SWorldHierarchyItem::GetLevelDisplayNameTooltip) ] ; } else if (ColumnID == HierarchyColumns::ColumnID_Lock) { TableRowContent = SAssignNew(LockButton, SButton) .ContentPadding(0 ) .ButtonStyle(FEditorStyle::Get(), "ToggleButton") .IsEnabled(this, &SWorldHierarchyItem::IsLockEnabled) .OnClicked(this, &SWorldHierarchyItem::OnToggleLock) .ToolTipText(this, &SWorldHierarchyItem::GetLevelLockToolTip) .HAlign(HAlign_Center) .VAlign(VAlign_Center) .Content() [ SNew(SImage) .Image(this, &SWorldHierarchyItem::GetLevelLockBrush) ] ; } else if (ColumnID == HierarchyColumns::ColumnID_Visibility) { TableRowContent = SAssignNew(VisibilityButton, SButton) .ContentPadding(0) .ButtonStyle(FEditorStyle::Get(), "ToggleButton") .IsEnabled(this, &SWorldHierarchyItem::IsVisibilityEnabled) .OnClicked(this, &SWorldHierarchyItem::OnToggleVisibility) .ToolTipText(LOCTEXT("VisibilityButtonToolTip", "Toggle Level Visibility")) .HAlign(HAlign_Center) .VAlign(VAlign_Center) .Content() [ SNew( SImage ) .Image(this, &SWorldHierarchyItem::GetLevelVisibilityBrush) ] ; } else if (ColumnID == HierarchyColumns::ColumnID_Color) { TableRowContent = SAssignNew(ColorButton, SButton) .ContentPadding(0) .ButtonStyle(FEditorStyle::Get(), "ToggleButton") .IsEnabled(true) .OnClicked(this, &SWorldHierarchyItem::OnChangeColor) .ToolTipText(LOCTEXT("LevelColorButtonToolTip", "Change Level Color")) .HAlign(HAlign_Center) .VAlign(VAlign_Center) .Visibility(this, &SWorldHierarchyItem::GetColorButtonVisibility) .Content() [ SNew(SImage) .ColorAndOpacity(this, &SWorldHierarchyItem::GetDrawColor) .Image(this, &SWorldHierarchyItem::GetLevelColorBrush) ] ; } else if (ColumnID == HierarchyColumns::ColumnID_Kismet) { TableRowContent = SAssignNew(KismetButton, SButton) .ContentPadding(0) .ButtonStyle(FEditorStyle::Get(), "ToggleButton") .IsEnabled(this, &SWorldHierarchyItem::IsKismetEnabled) .OnClicked(this, &SWorldHierarchyItem::OnOpenKismet) .ToolTipText(LOCTEXT("KismetButtonToolTip", "Open Level Blueprint")) .HAlign(HAlign_Center) .VAlign(VAlign_Center) .Content() [ SNew(SImage) .Image(this, &SWorldHierarchyItem::GetLevelKismetBrush) ] ; } else if (ColumnID == HierarchyColumns::ColumnID_SCCStatus) { TableRowContent = SNew(SVerticalBox) +SVerticalBox::Slot() .FillHeight(1.0f) .HAlign(HAlign_Center) .VAlign(VAlign_Center) [ SNew(SHorizontalBox) +SHorizontalBox::Slot() .FillWidth(1.0f) .VAlign(VAlign_Center) [ SNew( SImage ) .Image(this, &SWorldHierarchyItem::GetSCCStateImage) .ToolTipText(this, &SWorldHierarchyItem::GetSCCStateTooltip) ] ] ; } else if (ColumnID == HierarchyColumns::ColumnID_Save) { TableRowContent = SAssignNew(SaveButton, SButton) .ContentPadding(0) .ButtonStyle(FEditorStyle::Get(), "ToggleButton") .IsEnabled(this, &SWorldHierarchyItem::IsSaveEnabled) .OnClicked(this, &SWorldHierarchyItem::OnSave) .ToolTipText(LOCTEXT("SaveButtonToolTip", "Save Level")) .HAlign( HAlign_Center ) .VAlign( VAlign_Center ) .Content() [ SNew(SImage) .Image(this, &SWorldHierarchyItem::GetLevelSaveBrush) ] ; } return TableRowContent.ToSharedRef(); }
FReply SARInventoryItem::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) { Icon = MyUIResources->GetBrush(FName("Active_Brush")); return FReply::Handled().DetectDrag(SharedThis(this), MouseEvent.GetEffectingButton()).CaptureMouse(SharedThis(this)); }
TSharedPtr<SWidget> STileMapEditorViewport::MakeViewportToolbar() { return SNew(STileMapEditorViewportToolbar, SharedThis(this)); }
/** Used to construct widgets */ void Construct( const FArguments& InArgs ) { // Set this widget as focused, to allow users to hit ESC to cancel. ParentWindow = InArgs._ParentWindow.Get(); ParentWindow->SetWidgetToFocusOnActivate(SharedThis(this)); DeltaTransform.Set(FVector::ZeroVector); ChildSlot [ SNew(SBorder) .BorderImage( FEditorStyle::GetBrush( "ToolPanel.GroupBorder" ) ) [ SNew(SVerticalBox) // Add user input block +SVerticalBox::Slot() .AutoHeight() .Padding(2) [ SNew(SVerticalBox) +SVerticalBox::Slot() .AutoHeight() .Padding(3) [ SNew( SHorizontalBox ) + SHorizontalBox::Slot() .FillWidth(1) .VAlign( VAlign_Center ) [ SNew( SVectorInputBox ) .X( this, &SDlgDeltaTransform::GetDeltaX ) .Y( this, &SDlgDeltaTransform::GetDeltaY ) .Z( this, &SDlgDeltaTransform::GetDeltaZ ) .bColorAxisLabels( true ) .OnXCommitted( this, &SDlgDeltaTransform::OnSetDelta, 0 ) .OnYCommitted( this, &SDlgDeltaTransform::OnSetDelta, 1 ) .OnZCommitted( this, &SDlgDeltaTransform::OnSetDelta, 2 ) ] ] ] // Add Ok, Ok to all and Cancel buttons. +SVerticalBox::Slot() .AutoHeight() .Padding(5) .HAlign(HAlign_Right) [ SNew(SUniformGridPanel) .SlotPadding(FEditorStyle::GetMargin("StandardDialog.SlotPadding")) .MinDesiredSlotWidth(FEditorStyle::GetFloat("StandardDialog.MinDesiredSlotWidth")) .MinDesiredSlotHeight(FEditorStyle::GetFloat("StandardDialog.MinDesiredSlotHeight")) +SUniformGridPanel::Slot(0,0) [ SNew(SButton) .HAlign(HAlign_Center) .ContentPadding(FEditorStyle::GetMargin("StandardDialog.ContentPadding")) .Text( NSLOCTEXT("ModalDialogs", "SDlgDeltaTransform_OK", "OK") ) .OnClicked( this, &SDlgDeltaTransform::OnButtonClick, FDlgDeltaTransform::OK ) ] +SUniformGridPanel::Slot(1,0) [ SNew(SButton) .HAlign(HAlign_Center) .ContentPadding(FEditorStyle::GetMargin("StandardDialog.ContentPadding")) .Text( NSLOCTEXT("ModalDialogs", "SDlgDeltaTransform_Cancel", "Cancel") ) .OnClicked( this, &SDlgDeltaTransform::OnButtonClick, FDlgDeltaTransform::Cancel ) ] ] ] ]; }
TSharedRef<FEditorViewportClient> SStaticMeshEditorViewport::MakeEditorViewportClient() { EditorViewportClient = MakeShareable( new FStaticMeshEditorViewportClient(StaticMeshEditorPtr, SharedThis(this), PreviewScene, StaticMesh, NULL) ); EditorViewportClient->bSetListenerPosition = false; EditorViewportClient->SetRealtime( false ); EditorViewportClient->VisibilityDelegate.BindSP( this, &SStaticMeshEditorViewport::IsVisible ); return EditorViewportClient.ToSharedRef(); }
TSharedRef< IPropertyTableRow > FPropertyTable::CreateRow( const TWeakObjectPtr< UObject >& Object ) { return MakeShareable( new FPropertyTableRow( SharedThis( this ), Object ) ); }
bool FWebJSScripting::HandleExecuteUObjectMethodMessage(CefRefPtr<CefListValue> MessageArguments) { FGuid ObjectKey; // Message arguments are Name, Value, bGlobal if (MessageArguments->GetSize() != 4 || MessageArguments->GetType(0) != VTYPE_STRING || MessageArguments->GetType(1) != VTYPE_STRING || MessageArguments->GetType(2) != VTYPE_STRING || MessageArguments->GetType(3) != VTYPE_LIST ) { // Wrong message argument types or count return false; } if (!FGuid::Parse(FString(MessageArguments->GetString(0).ToWString().c_str()), ObjectKey)) { // Invalid GUID return false; } // Get the promise callback and use that to report any results from executing this function. FGuid ResultCallbackId; if (!FGuid::Parse(FString(MessageArguments->GetString(2).ToWString().c_str()), ResultCallbackId)) { // Invalid GUID return false; } UObject* Object = GuidToPtr(ObjectKey); if (Object == nullptr) { // Unknown uobject id InvokeJSErrorResult(ResultCallbackId, TEXT("Unknown UObject ID")); return true; } FName MethodName = MessageArguments->GetString(1).ToWString().c_str(); UFunction* Function = Object->FindFunction(MethodName); if (!Function) { InvokeJSErrorResult(ResultCallbackId, TEXT("Unknown UObject Function")); return true; } // Coerce arguments to function arguments. uint16 ParamsSize = Function->ParmsSize; TArray<uint8> Params; UProperty* ReturnParam = nullptr; UProperty* PromiseParam = nullptr; // Convert cef argument list to a dictionary, so we can use FStructDeserializer to convert it for us if (ParamsSize > 0) { CefRefPtr<CefDictionaryValue> NamedArgs = CefDictionaryValue::Create(); int32 CurrentArg = 0; CefRefPtr<CefListValue> CefArgs = MessageArguments->GetList(3); for ( TFieldIterator<UProperty> It(Function); It; ++It ) { UProperty* Param = *It; if (Param->PropertyFlags & CPF_Parm) { if (Param->PropertyFlags & CPF_ReturnParm) { ReturnParam = Param; } else { UStructProperty *StructProperty = Cast<UStructProperty>(Param); if (StructProperty && StructProperty->Struct->IsChildOf(FWebJSResponse::StaticStruct())) { PromiseParam = Param; } else { CopyContainerValue(NamedArgs, CefArgs, CefString(*Param->GetName()), CurrentArg); CurrentArg++; } } } } // UFunction is a subclass of UStruct, so we can treat the arguments as a struct for deserialization Params.AddUninitialized(ParamsSize); Function->InitializeStruct(Params.GetData()); FWebJSStructDeserializerBackend Backend = FWebJSStructDeserializerBackend(SharedThis(this), NamedArgs); FStructDeserializer::Deserialize(Params.GetData(), *Function, Backend); } if (PromiseParam) { FWebJSResponse* PromisePtr = PromiseParam->ContainerPtrToValuePtr<FWebJSResponse>(Params.GetData()); if (PromisePtr) { *PromisePtr = FWebJSResponse(SharedThis(this), ResultCallbackId); } } Object->ProcessEvent(Function, Params.GetData()); CefRefPtr<CefListValue> Results = CefListValue::Create(); if ( ! PromiseParam ) // If PromiseParam is set, we assume that the UFunction will ensure it is called with the result { if ( ReturnParam ) { FStructSerializerPolicies ReturnPolicies; ReturnPolicies.PropertyFilter = [&](const UProperty* CandidateProperty, const UProperty* ParentProperty) { return ParentProperty != nullptr || CandidateProperty == ReturnParam; }; FWebJSStructSerializerBackend ReturnBackend(SharedThis(this)); FStructSerializer::Serialize(Params.GetData(), *Function, ReturnBackend, ReturnPolicies); CefRefPtr<CefDictionaryValue> ResultDict = ReturnBackend.GetResult(); // Extract the single return value from the serialized dictionary to an array CopyContainerValue(Results, ResultDict, 0, CefString(*ReturnParam->GetName())); } InvokeJSFunction(ResultCallbackId, Results, false); } return true; }
TSharedRef< IPropertyTableRow > FPropertyTable::CreateRow( const TWeakObjectPtr< UProperty >& Property ) { return MakeShareable( new FPropertyTableRow( SharedThis( this ), FPropertyPath::Create( Property ) ) ); }
bool STimeline::IsSelected() const { // Ask the tree if we are selected return Owner->IsNodeSelected(SharedThis(const_cast<STimeline*>(this))); }
TSharedRef< IPropertyTableRow > FPropertyTable::CreateRow( const TSharedRef< FPropertyPath >& PropertyPath ) { return MakeShareable( new FPropertyTableRow( SharedThis( this ), PropertyPath ) ); }
void SMultiBoxWidget::UpdateDropAreaPreviewBlock( TSharedRef<const FMultiBlock> MultiBlock, TSharedPtr<FUICommandDragDropOp> DragDropContent, const FGeometry& DragAreaGeometry, const FVector2D& DragPos ) { TSharedPtr<const FUICommandInfo> UICommand = DragDropContent->UICommand; FName OriginMultiBox = DragDropContent->OriginMultiBox; FVector2D LocalDragPos = DragAreaGeometry.AbsoluteToLocal( DragPos ); FVector2D DrawSize = DragAreaGeometry.GetDrawSize(); bool bAddedNewBlock = false; bool bValidCommand = true; if( DragPreview.UICommand != UICommand ) { TSharedPtr<const FMultiBlock> ExistingBlock = MultiBox->FindBlockFromCommand( UICommand ); // Check that the command does not already exist and that we can create it or that we are dragging an exisiting block in this box if( !ExistingBlock.IsValid() || ( ExistingBlock.IsValid() && OriginMultiBox == MultiBox->GetCustomizationName() ) ) { TSharedPtr<const FMultiBlock> NewBlock = ExistingBlock; if( !ExistingBlock.IsValid() ) { NewBlock = MultiBox->MakeMultiBlockFromCommand( UICommand, true ); } if( NewBlock.IsValid() ) { DragPreview.Reset(); DragPreview.UICommand = UICommand; DragPreview.PreviewBlock = MakeShareable( new FDropPreviewBlock( NewBlock.ToSharedRef(), NewBlock->MakeWidget( SharedThis(this), EMultiBlockLocation::None, NewBlock->HasIcon() ) ) ); bAddedNewBlock = true; } } else { // this command cannot be dropped here bValidCommand = false; } } if( bValidCommand ) { // determine whether or not to insert before or after bool bInsertBefore = false; if( MultiBox->GetType() == EMultiBoxType::ToolBar ) { DragPreview.InsertOrientation = EOrientation::Orient_Horizontal; if( LocalDragPos.X < DrawSize.X / 2 ) { // Insert before horizontally bInsertBefore = true; } else { // Insert after horizontally bInsertBefore = false; } } else { DragPreview.InsertOrientation = EOrientation::Orient_Vertical; if( LocalDragPos.Y < DrawSize.Y / 2 ) { // Insert before vertically bInsertBefore = true; } else { // Insert after vertically bInsertBefore = false; } } int32 CurrentIndex = DragPreview.InsertIndex; DragPreview.InsertIndex = INDEX_NONE; // Find the index of the multiblock being dragged over. This is where we will insert the new block if( DragPreview.PreviewBlock.IsValid() ) { const TArray< TSharedRef< const FMultiBlock > >& Blocks = MultiBox->GetBlocks(); for (int32 BlockIdx = 0; BlockIdx < Blocks.Num(); ++BlockIdx) { TSharedRef<const FMultiBlock> Block = Blocks[BlockIdx]; if( Block == MultiBlock ) { if( bInsertBefore) { DragPreview.InsertIndex = BlockIdx; } else { DragPreview.InsertIndex = FMath::Min(Blocks.Num()-1, BlockIdx+1); } break; } } } if( CurrentIndex != DragPreview.InsertIndex && DragPreview.InsertIndex != INDEX_NONE ) { BuildMultiBoxWidget(); } } }
void FPropertyTable::UpdateRows() { if( Orientation == EPropertyTableOrientation::AlignPropertiesInColumns ) { TMultiMap< UObject*, TSharedRef< IPropertyTableRow > > RowsMap; for (int RowIdx = 0; RowIdx < Rows.Num(); ++RowIdx) { RowsMap.Add(Rows[RowIdx]->GetDataSource()->AsUObject().Get(), Rows[RowIdx]); } Rows.Empty(); for( auto ObjectIter = SourceObjects.CreateConstIterator(); ObjectIter; ++ObjectIter ) { const TWeakObjectPtr< UObject >& Object = *ObjectIter; if( Object.IsValid() ) { const TSharedRef< FObjectPropertyNode > ObjectNode = GetObjectPropertyNode( Object ); const TSharedPtr< FPropertyNode > PropertyNode = FPropertyNode::FindPropertyNodeByPath( RootPath, ObjectNode ); //@todo This system will need to change in order to properly support arrays [11/30/2012 Justin.Sargent] if ( PropertyNode.IsValid() ) { UProperty* Property = PropertyNode->GetProperty(); if ( Property != NULL && Property->IsA( UArrayProperty::StaticClass() ) ) { for (int ChildIdx = 0; ChildIdx < PropertyNode->GetNumChildNodes(); ChildIdx++) { TSharedPtr< FPropertyNode > ChildNode = PropertyNode->GetChildNode( ChildIdx ); FPropertyInfo Extension; Extension.Property = ChildNode->GetProperty(); Extension.ArrayIndex = ChildNode->GetArrayIndex(); TSharedRef< FPropertyPath > Path = FPropertyPath::CreateEmpty()->ExtendPath( Extension ); TArray< TSharedRef< IPropertyTableRow > > MapResults; bool Found = false; RowsMap.MultiFind(Object.Get(), MapResults); for (int MapIdx = 0; MapIdx < MapResults.Num(); ++MapIdx) { if (FPropertyPath::AreEqual(Path, MapResults[MapIdx]->GetPartialPath())) { Found = true; Rows.Add(MapResults[MapIdx]); break; } } if (!Found) { Rows.Add( MakeShareable( new FPropertyTableRow( SharedThis( this ), Object, Path ) ) ); } } } else { TArray< TSharedRef< IPropertyTableRow > > MapResults; bool Found = false; RowsMap.MultiFind(Object.Get(), MapResults); for (int MapIdx = 0; MapIdx < MapResults.Num(); ++MapIdx) { if (MapResults[MapIdx]->GetPartialPath()->GetNumProperties() == 0) { Found = true; Rows.Add(MapResults[MapIdx]); break; } } if (!Found) { Rows.Add( MakeShareable( new FPropertyTableRow( SharedThis( this ), Object ) ) ); } } } } } } const TSharedPtr< IPropertyTableColumn > Column = SortedByColumn.Pin(); if ( Column.IsValid() && SortedColumnMode != EColumnSortMode::None ) { Column->Sort( Rows, SortedColumnMode ); } RowsChanged.Broadcast(); }
TSharedPtr<SWidget> SPhATPreviewViewport::MakeViewportToolbar() { return SNew(SPhATPreviewViewportToolBar, SharedThis(this)) .PhATPtr(PhATPtr) .IsEnabled(FSlateApplication::Get().GetNormalExecutionAttribute()); }
FReply SMainMenuWidget::OnFocusReceived(const FGeometry& aGeometry, const FFocusEvent& inFocusEvent) { return FReply::Handled().LockMouseToWidget(SharedThis(this)); }