virtual void ShutdownModule() override
{
if (!Initialized)
{
return;
}
Initialized = false;
// unregister video player factory
IMediaModule* MediaModule = FModuleManager::GetModulePtr<IMediaModule>("Media");
if (MediaModule != nullptr)
{
MediaModule->UnregisterPlayerFactory(*this);
}
// unregister logging callback
FVlc::LogUnset(VlcInstance);
// release LibVLC instance
FVlc::Release((FLibvlcInstance*)VlcInstance);
VlcInstance = nullptr;
// shut down LibVLC
FVlc::Shutdown();
// unregister settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterSettings("Project", "Plugins", "VlcMedia");
}
}
void FLogVisualizerModule::StartupModule()
{
FLogVisualizerStyle::Initialize();
FLogVisualizer::Initialize();
FVisualLoggerCommands::Register();
IModularFeatures::Get().RegisterModularFeature(VisualLoggerTabName, this);
FGlobalTabmanager::Get()->RegisterNomadTabSpawner(
VisualLoggerTabName,
FOnSpawnTab::CreateRaw(this, &FLogVisualizerModule::SpawnLogVisualizerTab))
.SetGroup(WorkspaceMenu::GetMenuStructure().GetDeveloperToolsMiscCategory())
.SetDisplayName(NSLOCTEXT("LogVisualizerApp", "TabTitle", "Visual Logger"))
.SetTooltipText(NSLOCTEXT("LogVisualizerApp", "TooltipText", "Opens Visual Logger tool."))
.SetIcon(FSlateIcon(FLogVisualizerStyle::GetStyleSetName(), "LogVisualizerApp.TabIcon"));
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->RegisterSettings("Editor", "General", "VisualLogger",
LOCTEXT("AIToolsSettingsName", "Visual Logger"),
LOCTEXT("AIToolsSettingsDescription", "General settings for UE4 AI Tools."),
ULogVisualizerSettings::StaticClass()->GetDefaultObject()
);
}
}
virtual void StartupModule() override
{
// load required libraries
FHttpModule* HttpModule = FModuleManager::LoadModulePtr<FHttpModule>("Http");
if (HttpModule == nullptr)
{
UE_LOG(LogPhilipsHue, Log, TEXT("Failed to load Http module"));
return;
}
// register settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
ISettingsSectionPtr SettingsSection = SettingsModule->RegisterSettings("Project", "Plugins", "PhilipsHue",
LOCTEXT("PhilipsHueSettingsName", "Philips Hue"),
LOCTEXT("PhilipsHueSettingsDescription", "Configure the Philips Hue plug-in."),
GetMutableDefault<UPhilipsHueSettings>()
);
if (SettingsSection.IsValid())
{
SettingsSection->OnModified().BindRaw(this, &FPhilipsHueModule::HandleSettingsSaved);
}
}
}
virtual void StartupModule() override
{
// this is an example of a hotfix, declared here for no particular reason. Once we have other examples, it can be deleted.
#if 0
FCoreDelegates::GetHotfixDelegate(EHotfixDelegates::Test).BindRaw(this, &FWindowsTargetPlatformModule::HotfixTest);
#endif
TargetSettings = NewObject<UWindowsTargetSettings>(GetTransientPackage(), "WindowsTargetSettings", RF_Standalone);
// We need to manually load the config properties here, as this module is loaded before the UObject system is setup to do this
GConfig->GetArray(TEXT("/Script/WindowsTargetPlatform.WindowsTargetSettings"), TEXT("TargetedRHIs"), TargetSettings->TargetedRHIs, GEngineIni);
// When this is initialized the UEnum for EMinimumSupportedOS hasn't been registered.
FString MinOSString;
if (GConfig->GetString(TEXT("/Script/WindowsTargetPlatform.WindowsTargetSettings"), TEXT("MinimumOSVersion"), MinOSString, GEngineIni))
{
// We need to parse the string and compare manually.
TargetSettings->MinimumOSVersion = MinOSString == TEXT("MSOS_XP") ? EMinimumSupportedOS::MSOS_XP : EMinimumSupportedOS::MSOS_Vista;
}
TargetSettings->AddToRoot();
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->RegisterSettings("Project", "Platforms", "Windows",
LOCTEXT("TargetSettingsName", "Windows"),
LOCTEXT("TargetSettingsDescription", "Settings for Windows target platform"),
TargetSettings
);
}
}
virtual void StartupModule( ) override
{
if (!SupportsSlateRemote())
{
return;
}
// register settings
ISettingsModule* SettingsModule = ISettingsModule::Get();
if (SettingsModule != nullptr)
{
FSettingsSectionDelegates SettingsDelegates;
SettingsDelegates.ModifiedDelegate = FOnSettingsSectionModified::CreateRaw(this, &FSlateRemoteModule::HandleSettingsSaved);
SettingsModule->RegisterSettings("Project", "Plugins", "SlateRemote",
LOCTEXT("SlateRemoteSettingsName", "Slate Remote"),
LOCTEXT("SlateRemoteSettingsDescription", "Configure the Slate Remote plug-in."),
GetMutableDefault<USlateRemoteSettings>(),
SettingsDelegates
);
}
// register application events
FCoreDelegates::ApplicationHasReactivatedDelegate.AddRaw(this, &FSlateRemoteModule::HandleApplicationHasReactivated);
FCoreDelegates::ApplicationWillDeactivateDelegate.AddRaw(this, &FSlateRemoteModule::HandleApplicationWillDeactivate);
RestartServices();
}
/**
* Registers Other Tools settings
*/
void RegisterContentEditorsSettings( ISettingsModule& SettingsModule )
{
// content browser
SettingsModule.RegisterSettings("Editor", "ContentEditors", "ContentBrowser",
LOCTEXT("ContentEditorsContentBrowserSettingsName", "Content Browser"),
LOCTEXT("ContentEditorsContentBrowserSettingsDescription", "Change the behavior of the Content Browser."),
GetMutableDefault<UContentBrowserSettings>()
);
// destructable mesh editor
/* SettingsModule.RegisterSettings("Editor", "ContentEditors", "DestructableMeshEditor",
LOCTEXT("ContentEditorsDestructableMeshEditorSettingsName", "Destructable Mesh Editor"),
LOCTEXT("ContentEditorsDestructableMeshEditorSettingsDescription", "Change the behavior of the Destructable Mesh Editor."),
GetMutableDefault<UDestructableMeshEditorSettings>()
);*/
// graph editors
SettingsModule.RegisterSettings("Editor", "ContentEditors", "GraphEditor",
LOCTEXT("ContentEditorsGraphEditorSettingsName", "Graph Editors"),
LOCTEXT("ContentEditorsGraphEditorSettingsDescription", "Customize Anim, Blueprint and Material Editor."),
GetMutableDefault<UGraphEditorSettings>()
);
// graph editors
SettingsModule.RegisterSettings("Editor", "ContentEditors", "BlueprintEditor",
LOCTEXT("ContentEditorsBlueprintEditorSettingsName", "Blueprint Editor"),
LOCTEXT("ContentEditorsGraphBlueprintSettingsDescription", "Customize Blueprint Editors."),
GetMutableDefault<UBlueprintEditorSettings>()
);
}
void FGameplayDebuggerModule::StartupModule()
{
// This code will execute after your module is loaded into memory (but after global variables are initialized, of course.)
FWorldDelegates::OnPostWorldInitialization.AddRaw(this, &FGameplayDebuggerModule::OnWorldInitialized);
UGameplayDebuggerConfig* SettingsCDO = UGameplayDebuggerConfig::StaticClass()->GetDefaultObject<UGameplayDebuggerConfig>();
if (SettingsCDO)
{
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule)
{
SettingsModule->RegisterSettings("Project", "Engine", "GameplayDebugger",
NSLOCTEXT("GameplayDebuggerModule", "SettingsName", "Gameplay Debugger"),
NSLOCTEXT("GameplayDebuggerModule", "SettingsDescription", "Settings for the gameplay debugger tool."),
SettingsCDO);
}
if (SettingsCDO->bEnableExtension_GameHUD)
{
AddonManager.RegisterExtension("GameHUD", FOnGetExtension::CreateStatic(&FGameplayDebuggerExtension_HUD::MakeInstance));
}
if (SettingsCDO->bEnableExtension_Spectator)
{
AddonManager.RegisterExtension("Spectator", FOnGetExtension::CreateStatic(&FGameplayDebuggerExtension_Spectator::MakeInstance));
}
AddonManager.NotifyExtensionsChanged();
}
}
/**
* Unregisters all settings.
*/
void UnregisterSettings( )
{
ISettingsModule* SettingsModule = ISettingsModule::Get();
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterViewer("Editor");
// general settings
SettingsModule->UnregisterSettings("Editor", "General", "InputBindings");
SettingsModule->UnregisterSettings("Editor", "General", "LoadingSaving");
SettingsModule->UnregisterSettings("Editor", "General", "GameAgnostic");
SettingsModule->UnregisterSettings("Editor", "General", "UserSettings");
SettingsModule->UnregisterSettings("Editor", "General", "AutomationTest");
SettingsModule->UnregisterSettings("Editor", "General", "Experimental");
// level editor settings
SettingsModule->UnregisterSettings("Editor", "LevelEditor", "PlayIn");
SettingsModule->UnregisterSettings("Editor", "LevelEditor", "Viewport");
// other tools
SettingsModule->UnregisterSettings("Editor", "ContentEditors", "ContentBrowser");
// SettingsModule->UnregisterSettings("Editor", "ContentEditors", "DestructableMeshEditor");
SettingsModule->UnregisterSettings("Editor", "ContentEditors", "GraphEditor");
}
}
// Handles creating the editor settings tab.
TSharedRef<SDockTab> HandleSpawnSettingsTab( const FSpawnTabArgs& SpawnTabArgs )
{
ISettingsModule* SettingsModule = ISettingsModule::Get();
TSharedRef<SWidget> SettingsEditor = SNullWidget::NullWidget;
if (SettingsModule != nullptr)
{
ISettingsContainerPtr SettingsContainer = SettingsModule->GetContainer("Editor");
if (SettingsContainer.IsValid())
{
ISettingsEditorModule& SettingsEditorModule = ISettingsEditorModule::GetRef();
ISettingsEditorModelRef SettingsEditorModel = SettingsEditorModule.CreateModel(SettingsContainer.ToSharedRef());
SettingsEditor = SettingsEditorModule.CreateEditor(SettingsEditorModel);
SettingsEditorModelPtr = SettingsEditorModel;
}
}
return SNew(SDockTab)
.TabRole(ETabRole::NomadTab)
[
SettingsEditor
];
}
void FGameAnalyticsEditor::ShutdownModule()
{
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if( SettingsModule != nullptr )
{
SettingsModule->UnregisterSettings( "Project", "Plugins", "GameAnalytics" );
}
}
void FEditorLiveStreaming::ShutdownModule()
{
// Unregister settings
ISettingsModule* SettingsModule = ISettingsModule::Get();
if( SettingsModule != nullptr )
{
SettingsModule->UnregisterSettings( "Editor", "General", "EditorLiveStreaming" );
}
}
virtual void ShutdownModule() override
{
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterSettings("Project", "Platforms", "iOS");
}
}
virtual void ShutdownModule() override
{
ISettingsModule* SettingsModule = ISettingsModule::Get();
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterSettings("Project", "Platforms", "Android");
}
}
virtual void StartupModule() override
{
// register settings detail panel customization
FPropertyEditorModule& PropertyModule = FModuleManager::LoadModuleChecked<FPropertyEditorModule>("PropertyEditor");
PropertyModule.RegisterCustomClassLayout(
"IOSRuntimeSettings",
FOnGetDetailCustomizationInstance::CreateStatic(&FIOSTargetSettingsCustomization::MakeInstance)
);
FOnUpdateMaterialShaderQuality UpdateMaterials = FOnUpdateMaterialShaderQuality::CreateLambda([]()
{
FGlobalComponentRecreateRenderStateContext Recreate;
FlushRenderingCommands();
UMaterial::AllMaterialsCacheResourceShadersForRendering();
UMaterialInstance::AllMaterialsCacheResourceShadersForRendering();
});
PropertyModule.RegisterCustomClassLayout(
UShaderPlatformQualitySettings::StaticClass()->GetFName(),
FOnGetDetailCustomizationInstance::CreateStatic(&FMaterialShaderQualitySettingsCustomization::MakeInstance, UpdateMaterials)
);
PropertyModule.NotifyCustomizationModuleChanged();
// register settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->RegisterSettings("Project", "Platforms", "iOS",
LOCTEXT("RuntimeSettingsName", "iOS"),
LOCTEXT("RuntimeSettingsDescription", "Settings and resources for the iOS platform"),
GetMutableDefault<UIOSRuntimeSettings>()
);
{
static FName NAME_OPENGL_ES2_IOS(TEXT("GLSL_ES2_IOS"));
const UShaderPlatformQualitySettings* IOSMaterialQualitySettings = UMaterialShaderQualitySettings::Get()->GetShaderPlatformQualitySettings(NAME_OPENGL_ES2_IOS);
SettingsModule->RegisterSettings("Project", "Platforms", "iOSES2Quality",
LOCTEXT("IOSES2QualitySettingsName", "iOS Material Quality - ES2"),
LOCTEXT("IOSES2QualitySettingsDescription", "Settings for iOS ES2 material quality"),
IOSMaterialQualitySettings
);
}
{
static FName NAME_SF_METAL(TEXT("SF_METAL"));
const UShaderPlatformQualitySettings* IOSMaterialQualitySettings = UMaterialShaderQualitySettings::Get()->GetShaderPlatformQualitySettings(NAME_SF_METAL);
SettingsModule->RegisterSettings("Project", "Platforms", "iOSMetalQuality",
LOCTEXT("IOSMetalQualitySettingsName", "iOS Material Quality - Metal"),
LOCTEXT("IOSMetalQualitySettingsDescription", "Settings for iOS Metal material quality"),
IOSMaterialQualitySettings
);
}
}
}
void FIntroTutorials::ShutdownModule()
{
if (!bDisableTutorials && !IsRunningCommandlet())
{
FSourceCodeNavigation::AccessOnCompilerNotFound().RemoveAll( this );
FAssetToolsModule* AssetToolsModule = FModuleManager::GetModulePtr<FAssetToolsModule>("AssetTools");
if (AssetToolsModule)
{
IAssetTools& AssetTools = AssetToolsModule->Get();
for(const auto& RegisteredClassTypeAction : RegisteredClassTypeActions)
{
AssetTools.UnregisterClassTypeActions(RegisteredClassTypeAction);
}
}
}
if (BlueprintEditorExtender.IsValid() && FModuleManager::Get().IsModuleLoaded("Kismet"))
{
FBlueprintEditorModule& BPEditorModule = FModuleManager::LoadModuleChecked<FBlueprintEditorModule>("Kismet");
BPEditorModule.GetMenuExtensibilityManager()->RemoveExtender(BlueprintEditorExtender);
}
if (MainMenuExtender.IsValid() && FModuleManager::Get().IsModuleLoaded("LevelEditor"))
{
FLevelEditorModule& LevelEditorModule = FModuleManager::LoadModuleChecked<FLevelEditorModule>( "LevelEditor" );
LevelEditorModule.GetMenuExtensibilityManager()->RemoveExtender(MainMenuExtender);
}
if (FModuleManager::Get().IsModuleLoaded("MainFrame"))
{
IMainFrameModule& MainFrameModule = FModuleManager::LoadModuleChecked<IMainFrameModule>(TEXT("MainFrame"));
MainFrameModule.OnMainFrameCreationFinished().RemoveAll(this);
}
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterSettings("Editor", "General", "Tutorials");
SettingsModule->UnregisterSettings("Project", "Engine", "Tutorials");
}
if(FModuleManager::Get().IsModuleLoaded("PropertyEditor"))
{
FPropertyEditorModule& PropertyEditorModule = FModuleManager::GetModuleChecked<FPropertyEditorModule>("PropertyEditor");
PropertyEditorModule.UnregisterCustomPropertyTypeLayout("TutorialContent");
PropertyEditorModule.UnregisterCustomPropertyTypeLayout("TutorialWidgetReference");
PropertyEditorModule.UnregisterCustomClassLayout("EditorTutorial");
}
if(ContentIntroCurve.IsValid())
{
ContentIntroCurve.Get()->RemoveFromRoot();
ContentIntroCurve = nullptr;
}
FGlobalTabmanager::Get()->UnregisterNomadTabSpawner(TEXT("TutorialsBrowser"));
}
/** Unregister settings objects. */
void UnregisterSettings()
{
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
// @todo sequencer: this should be moved into LevelSequenceEditor
SettingsModule->UnregisterSettings("Project", "Plugins", "LevelSequencer");
}
}
void FEditorLiveStreaming::ShutdownModule()
{
// Unregister settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if( SettingsModule != nullptr )
{
SettingsModule->UnregisterSettings( "Editor", "General", "EditorLiveStreaming" );
}
}
void UEditorLoadingSavingSettings::CheckSourceControlCompatability()
{
if (!bEnableSourceControlCompatabilityCheck || !bMonitorContentDirectories)
{
return;
}
if (ISourceControlModule::Get().IsEnabled() && bDetectChangesOnRestart)
{
// Persistent shared payload captured by the lambdas below
struct FPersistentPayload { TSharedPtr<SNotificationItem> Notification; };
TSharedRef<FPersistentPayload> Payload = MakeShareable(new FPersistentPayload);
FNotificationInfo Info(LOCTEXT("AutoReimport_NotificationTitle", "We noticed that your auto-reimport settings are set up to detect source content changes on restart.\nThis might cause unexpected behavior when starting up after getting latest from source control.\n\nWe recommend disabling this specific behavior."));
auto OnTurnOffClicked = [=]{
auto* Settings = GetMutableDefault<UEditorLoadingSavingSettings>();
Settings->bDetectChangesOnRestart = false;
Settings->SaveConfig();
Payload->Notification->SetEnabled(false);
Payload->Notification->Fadeout();
};
Info.ButtonDetails.Emplace(LOCTEXT("AutoReimport_TurnOff", "Don't detect changes on start-up"), FText(), FSimpleDelegate::CreateLambda(OnTurnOffClicked), SNotificationItem::ECompletionState::CS_None);
auto OnIgnoreClicked = [=]{
Payload->Notification->SetEnabled(false);
Payload->Notification->Fadeout();
};
Info.ButtonDetails.Emplace(LOCTEXT("AutoReimport_Ignore", "Ignore"), FText(), FSimpleDelegate::CreateLambda(OnIgnoreClicked), SNotificationItem::ECompletionState::CS_None);
Info.bUseLargeFont = false;
Info.bFireAndForget = false;
Info.CheckBoxStateChanged = FOnCheckStateChanged::CreateLambda([](ECheckBoxState State){
GetMutableDefault<UEditorLoadingSavingSettings>()->bEnableSourceControlCompatabilityCheck = (State != ECheckBoxState::Checked);
});
Info.CheckBoxText = LOCTEXT("AutoReimport_DontShowAgain", "Don't show again");
Info.Hyperlink = FSimpleDelegate::CreateLambda([]{
// Open Settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
// Ensure that the advanced properties are visible
GConfig->SetBool(TEXT("DetailCategoriesAdvanced"), TEXT("EditorLoadingSavingSettings.AutoReimport"), true, GEditorPerProjectIni);
SettingsModule->ShowViewer("Editor", "General", "LoadingSaving");
}
});
Info.HyperlinkText = LOCTEXT("AutoReimport_OpenSettings", "Settings");
Payload->Notification = FSlateNotificationManager::Get().AddNotification(Info);
}
}
virtual void ShutdownModule() override
{
// unregister settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterSettings("Project", "Plugins", "PhilipsHue");
}
}
void FGameplayDebuggerModule::ShutdownModule()
{
// This function may be called during shutdown to clean up your module. For modules that support dynamic reloading,
// we call this function before unloading the module.
FWorldDelegates::OnPostWorldInitialization.RemoveAll(this);
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule)
{
SettingsModule->UnregisterSettings("Project", "Engine", "GameplayDebugger");
}
}
/**
* Registers Project settings.
*
* @param SettingsModule A reference to the settings module.
*/
void RegisterProjectSettings( ISettingsModule& SettingsModule )
{
// general project settings
SettingsModule.RegisterSettings("Project", "Project", "General",
LOCTEXT("GeneralGameSettingsName", "Description"),
LOCTEXT("GeneralGameSettingsDescription", "Descriptions and other information about your project."),
GetMutableDefault<UGeneralProjectSettings>()
);
// map related settings
SettingsModule.RegisterSettings("Project", "Project", "Maps",
LOCTEXT("GameMapsSettingsName", "Maps & Modes"),
LOCTEXT("GameMapsSettingsDescription", "Default maps, game modes and other map related settings."),
GetMutableDefault<UGameMapsSettings>()
);
// packaging settings
SettingsModule.RegisterSettings("Project", "Project", "Packaging",
LOCTEXT("ProjectPackagingSettingsName", "Packaging"),
LOCTEXT("ProjectPackagingSettingsDescription", "Fine tune how your project is packaged for release."),
GetMutableDefault<UProjectPackagingSettings>()
);
// platforms settings
TWeakPtr<SWidget> ProjectTargetPlatformEditorPanel = FModuleManager::LoadModuleChecked<IProjectTargetPlatformEditorModule>("ProjectTargetPlatformEditor").CreateProjectTargetPlatformEditorPanel();
SettingsModule.RegisterSettings("Project", "Project", "SupportedPlatforms",
LOCTEXT("ProjectSupportedPlatformsSettingsName", "Supported Platforms"),
LOCTEXT("ProjectSupportedPlatformsSettingsDescription", "Specify which platforms your project supports."),
ProjectTargetPlatformEditorPanel.Pin().ToSharedRef()
);
// movie settings
SettingsModule.RegisterSettings("Project", "Project", "Movies",
LOCTEXT("MovieSettingsName", "Movies"),
LOCTEXT("MovieSettingsDescription", "Movie player settings"),
GetMutableDefault<UMoviePlayerSettings>()
);
/*
// game session
SettingsModule.RegisterSettings("Project", "Project", "GameSession",
LOCTEXT("GameSessionettingsName", "Game Session"),
LOCTEXT("GameSessionSettingsDescription", "Game Session settings."),
GetMutableDefault<UGameSessionSettings>()
);
// head-up display
SettingsModule.RegisterSettings("Project", "Project", "HUD",
LOCTEXT("HudSettingsName", "HUD"),
LOCTEXT("HudSettingsDescription", "Head-up display (HUD) settings."),
GetMutableDefault<UHudSettings>()
);*/
}
void FEditorLiveStreaming::StartupModule()
{
// Register settings
ISettingsModule* SettingsModule = ISettingsModule::Get();
if( ensure( SettingsModule != nullptr ) )
{
SettingsModule->RegisterSettings( "Editor", "General", "EditorLiveStreaming",
LOCTEXT( "EditorLiveStreamingSettingsName", "Live Streaming"),
LOCTEXT( "EditorLiveStreamingSettingsDescription", "Settings for broadcasting live from the editor"),
GetMutableDefault< UEditorLiveStreamingSettings >()
);
}
}
virtual void ShutdownModule( ) override
{
// unregister settings
ISettingsModule* SettingsModule = ISettingsModule::Get();
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterSettings("Editor", "ContentEditors", "TextureEditor");
}
// unregister menu extensions
MenuExtensibilityManager.Reset();
ToolBarExtensibilityManager.Reset();
}
/** Register settings objects. */
void RegisterSettings()
{
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
// @todo sequencer: this should be moved into LevelSequenceEditor
SettingsModule->RegisterSettings("Project", "Plugins", "LevelSequencer",
LOCTEXT("LevelSequenceEditorSettingsName", "Level Sequencer"),
LOCTEXT("LevelSequenceEditorSettingsDescription", "Configure the Level Sequence Editor."),
GetMutableDefault<ULevelSequenceEditorSettings>()
);
}
}
void FEditorLiveStreaming::StartupModule()
{
// Register settings
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if( ensure( SettingsModule != nullptr ) )
{
SettingsModule->RegisterSettings( "Editor", "Advanced", "EditorLiveStreaming",
LOCTEXT( "EditorLiveStreamingSettingsName", "Live Streaming"),
LOCTEXT( "EditorLiveStreamingSettingsDescription", "Settings for broadcasting live from the editor"),
GetMutableDefault< UEditorLiveStreamingSettings >()
);
}
}
void FLogVisualizerModule::ShutdownModule()
{
FGlobalTabmanager::Get()->UnregisterTabSpawner(VisualLoggerTabName);
FVisualLoggerCommands::Unregister();
IModularFeatures::Get().UnregisterModularFeature(VisualLoggerTabName, this);
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->UnregisterSettings("Editor", "General", "VisualLogger");
}
FLogVisualizer::Shutdown();
FLogVisualizerStyle::Shutdown();
}
/**
* Registers Level Editor settings.
*
* @param SettingsModule A reference to the settings module.
*/
void RegisterLevelEditorSettings( ISettingsModule& SettingsModule )
{
// play-in settings
SettingsModule.RegisterSettings("Editor", "LevelEditor", "PlayIn",
LOCTEXT("LevelEditorPlaySettingsName", "Play"),
LOCTEXT("LevelEditorPlaySettingsDescription", "Set up window sizes and other options for the Play In Editor (PIE) feature."),
GetMutableDefault<ULevelEditorPlaySettings>()
);
// view port settings
SettingsModule.RegisterSettings("Editor", "LevelEditor", "Viewport",
LOCTEXT("LevelEditorViewportSettingsName", "Viewports"),
LOCTEXT("LevelEditorViewportSettingsDescription", "Configure the look and feel of the Level Editor view ports."),
GetMutableDefault<ULevelEditorViewportSettings>()
);
}
virtual void StartupModule() override
{
TargetSettings = ConstructObject<UHTML5TargetSettings>(UHTML5TargetSettings::StaticClass(), GetTransientPackage(), "HTML5TargetSettings", RF_Standalone);
TargetSettings->AddToRoot();
ISettingsModule* SettingsModule = ISettingsModule::Get();
if (SettingsModule != nullptr)
{
SettingsModule->RegisterSettings("Project", "Platforms", "HTML5",
LOCTEXT("TargetSettingsName", "HTML5"),
LOCTEXT("TargetSettingsDescription", "HTML5 platform settings description text here"),
TargetSettings
);
}
}
virtual void StartupModule() override
{
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
RegisterEngineSettings(*SettingsModule);
RegisterProjectSettings(*SettingsModule);
SettingsModule->RegisterViewer("Project", *this);
}
FGlobalTabmanager::Get()->RegisterNomadTabSpawner(ProjectSettingsTabName, FOnSpawnTab::CreateRaw(this, &FProjectSettingsViewerModule::HandleSpawnSettingsTab))
.SetDisplayName(LOCTEXT("ProjectSettingsTabTitle", "Project Settings"))
.SetMenuType(ETabSpawnerMenuType::Hidden);
}
virtual void StartupModule( ) override
{
ISettingsModule* SettingsModule = ISettingsModule::Get();
if (SettingsModule != nullptr)
{
RegisterGeneralSettings(*SettingsModule);
RegisterLevelEditorSettings(*SettingsModule);
RegisterContentEditorsSettings(*SettingsModule);
SettingsModule->RegisterViewer("Editor", *this);
}
FGlobalTabmanager::Get()->RegisterNomadTabSpawner(EditorSettingsTabName, FOnSpawnTab::CreateRaw(this, &FEditorSettingsViewerModule::HandleSpawnSettingsTab))
.SetDisplayName(LOCTEXT("EditorSettingsTabTitle", "Editor Preferences"))
.SetMenuType(ETabSpawnerMenuType::Hide);
}