izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
bb9ed201650b1303c825750794335750464fd0ff
UnrealEngineUWP/Engine/Source/Editor/GameProjectGeneration/Private/SNewClassDialog.cpp

1518 lines
51 KiB
C++
Raw Normal View History

Update copyright notices to 2015. [CL 2379638 by Ben Marsh in Main branch]
2014-12-07 19:09:38 -05:00
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
#include "GameProjectGenerationPrivatePCH.h"
#include "SourceCodeNavigation.h"
#include "ClassViewerModule.h"
#include "ClassViewerFilter.h"
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
#include "Editor/ContentBrowser/Public/ContentBrowserModule.h"
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
#include "Editor/ClassViewer/Private/SClassViewer.h"
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
#include "DesktopPlatformModule.h"
UE4: One more non-unity fix. [CL 2215354 by Bob Tellez in Main branch]
2014-07-14 21:16:56 -04:00
#include "Editor/Documentation/Public/IDocumentation.h"
Add the ability to link to object class documentation throughout the UI [CL 2226010 by Marc Audy in Main branch]
2014-07-21 17:31:27 -04:00
#include "EditorClassUtils.h"
Slate: Moved SWizard into AppFramework module [CL 2275535 by Max Preussner in Main branch]
2014-08-27 21:25:34 -04:00
#include "SWizard.h"
Removed a bunch of stuff from Slate standard include, created SlateBasics.h * Moved Slate.h into SlateBasics.h and began shifting less commonly used headers into SlateExtras.h. * Slate.h now simply includes SlateBasics.h and SlateExtras.h. * Slate.h includes a deprecated warning now to indicate that SlateBasics.h + specific includes should be used instead. * Moved dozens of inlined functions using Slate widgets into .cpp files to avoid header dependencies. * All code samples now include SlateBasics.h and SlateExtras.h so future shifts will not break most those projects, but not trigger the deprecation warning of including Slate.h. #BUN [CL 2329610 by Wes Hunt in Main branch]
2014-10-14 22:50:06 -04:00
#include "SHyperlink.h"
#UE4 DOCS: Added tutorial highlighting meta data to the Add Code to Project wizard: the major frame, the "type of code to add" scroll box, the class name, and path. #Code_Review Jamie.Dale [CL 2338726 by Ian Shadden in Main branch]
2014-10-23 13:16:00 -04:00
#include "TutorialMetaData.h"
Prepare cpp files for header cleanup. #codereview Robert.Manuszewski [CL 2356864 by Mikolaj Sieluzycki in Main branch]
2014-11-12 04:58:53 -05:00
#include "GameFramework/GameMode.h"
#include "GameFramework/GameState.h"
#include "GameFramework/Pawn.h"
#include "GameFramework/WorldSettings.h"
#include "GameFramework/PlayerController.h"
#include "GameFramework/Character.h"
#include "GameFramework/Actor.h"
#include "Camera/PlayerCameraManager.h"
#include "GameFramework/HUD.h"
#include "GameFramework/PlayerState.h"
#include "Kismet/BlueprintFunctionLibrary.h"
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
#include "Kismet2/KismetEditorUtilities.h"
#include "AssetRegistryModule.h"
New class workflow improvements We now sync the Content Browser view after adding a new class, and also open the BP editor when adding a new BP class. [CL 2475251 by Jamie Dale in Main branch]
2015-03-11 11:54:24 -04:00
#include "AssetEditorManager.h"
#include "ContentBrowserModule.h"
[INTEGRATE] Change 2417820 by Mike.Fricker@MFRICKER_G3686_Alpha on 2015/01/24 11:57:38 After adding a new class, we now always open the IDE to edit source if the hot reload completed successfully - Also, we display a quick pop-up notification indicating success instead of a modal prompt [CL 2419701 by Ben Marsh in Main branch]
2015-01-26 20:14:10 -05:00
#include "SNotificationList.h"
#include "NotificationManager.h"
Add includes to files to remove the need of including Engine.h. [CL 2508000 by Mikolaj Sieluzycki in Main branch]
2015-04-10 03:30:54 -04:00
#include "Engine/BlueprintGeneratedClass.h"
Slate: Moved SWizard into AppFramework module [CL 2275535 by Max Preussner in Main branch]
2014-08-27 21:25:34 -04:00
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
#define LOCTEXT_NAMESPACE "GameProjectGeneration"
Slate: Moved SWizard into AppFramework module [CL 2275535 by Max Preussner in Main branch]
2014-08-27 21:25:34 -04:00
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
struct FParentClassItem
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
FNewClassInfo ParentClassInfo;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
FParentClassItem(const FNewClassInfo& InParentClassInfo)
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
: ParentClassInfo(InParentClassInfo)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{}
};
class FNativeClassParentFilter : public IClassViewerFilter
{
public:
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
FNativeClassParentFilter()
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
{
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
ProjectModules = GameProjectUtils::GetCurrentProjectModules();
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
}
UE4 Refactoring. Changed OVERRIDE and FINAL macros to keywords override and final. [CL 2104397 by Jaroslaw Palczynski in Main branch]
2014-06-13 06:14:46 -04:00
virtual bool IsClassAllowed(const FClassViewerInitializationOptions& InInitOptions, const UClass* InClass, TSharedRef< FClassViewerFilterFuncs > InFilterFuncs ) override
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
// We allow a class that belongs to any module in the current project, as you don't actually choose the destination module until after you've selected your parent class
return GameProjectUtils::IsValidBaseClassForCreation(InClass, ProjectModules);
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
UE4 Refactoring. Changed OVERRIDE and FINAL macros to keywords override and final. [CL 2104397 by Jaroslaw Palczynski in Main branch]
2014-06-13 06:14:46 -04:00
virtual bool IsUnloadedClassAllowed(const FClassViewerInitializationOptions& InInitOptions, const TSharedRef< const IUnloadedBlueprintData > InUnloadedClassData, TSharedRef< FClassViewerFilterFuncs > InFilterFuncs) override
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
return false;
}
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
private:
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
/** The list of currently available modules for this project */
TArray<FModuleContextInfo> ProjectModules;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
};
Added additional checks in the New Class Dialog to disallow creating classes whose generated headers would clash with existing engine headers. #jira UE-4770 - LIVE: Users are able to name a new class "Platform" even though there is already a class by that name in the Engine. [CL 2357149 by Richard TalbotWatkin in Main branch]
2014-11-12 11:31:40 -05:00
static void FindPublicEngineHeaderFiles(TArray<FString>& OutFiles, const FString& Path)
{
TArray<FString> ModuleDirs;
IFileManager::Get().FindFiles(ModuleDirs, *(Path / TEXT("*")), false, true);
for (const FString& ModuleDir : ModuleDirs)
{
IFileManager::Get().FindFilesRecursive(OutFiles, *(Path / ModuleDir / TEXT("Classes")), TEXT("*.h"), true, false, false);
IFileManager::Get().FindFilesRecursive(OutFiles, *(Path / ModuleDir / TEXT("Public")), TEXT("*.h"), true, false, false);
}
}
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
BEGIN_SLATE_FUNCTION_BUILD_OPTIMIZATION
void SNewClassDialog::Construct( const FArguments& InArgs )
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
ClassDomain = InArgs._ClassDomain;
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
{
Expose ProjectHasCodeFiles, GenerateBasicSourceCode, GetCurrentProjectModules and DetermineModuleIncludePath from GameProjectGenerationModule [CL 2327274 by Marc Audy in Main branch]
2014-10-13 11:47:21 -04:00
TArray<FModuleContextInfo> CurrentModules = GameProjectUtils::GetCurrentProjectModules();
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
check(CurrentModules.Num()); // this should never happen since GetCurrentProjectModules is supposed to add a dummy runtime module if the project currently has no modules
Fixed the code generated by the New Project wizard not compiling TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard GetClassLocation was failing because it was doing the validation based upon the current project, and not the project that was being created. I've changed the validation logic and creation functions to use a module context that must be provided; this allows the functions used to generate code for a new project to override the module validation information. [CL 2075544 by Jamie Dale in Main branch]
2014-05-16 10:47:37 -04:00
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
AvailableModules.Reserve(CurrentModules.Num());
Expose ProjectHasCodeFiles, GenerateBasicSourceCode, GetCurrentProjectModules and DetermineModuleIncludePath from GameProjectGenerationModule [CL 2327274 by Marc Audy in Main branch]
2014-10-13 11:47:21 -04:00
for(const FModuleContextInfo& ModuleInfo : CurrentModules)
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
{
Expose ProjectHasCodeFiles, GenerateBasicSourceCode, GetCurrentProjectModules and DetermineModuleIncludePath from GameProjectGenerationModule [CL 2327274 by Marc Audy in Main branch]
2014-10-13 11:47:21 -04:00
AvailableModules.Emplace(MakeShareable(new FModuleContextInfo(ModuleInfo)));
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
}
}
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
// If we've been given an initial path that maps to a valid project module, use that as our initial module and path
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if (ClassDomain == EClassDomain::Blueprint)
{
NewClassPath = InArgs._InitialPath.IsEmpty() ? TEXT("/Game") : InArgs._InitialPath;
}
else if(!InArgs._InitialPath.IsEmpty())
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
{
const FString AbsoluteInitialPath = FPaths::ConvertRelativePathToFull(InArgs._InitialPath);
for(const auto& AvailableModule : AvailableModules)
{
if(AbsoluteInitialPath.StartsWith(AvailableModule->ModuleSourcePath))
{
SelectedModuleInfo = AvailableModule;
NewClassPath = AbsoluteInitialPath;
break;
}
}
}
[INTEGRATE] Change 2421194 by Mike.Fricker@MFRICKER_G3686_Alpha on 2015/01/27 17:44:17 Improvements to naming of newly-created C++ and BP components through SCS tree - Strip off "_C" suffix on newly created Blueprint classes - Don't strip "Component" from Blueprint class names unless it is the suffix - Changed prefix for newly-created C++ components from "My" to "New" - New Blueprint components default to the name of the class unless they are Blueprints of UActorComponent, in which case the name is just "NewComponent" - New C++ components default to the name of the class unless they inherit from UActorComponent, in which case the name is just "NewComponent" #codereview matt.kuhlenschmidt [CL 2425794 by Ben Marsh in Main branch]
2015-01-30 10:35:05 -05:00
DefaultClassPrefix = InArgs._DefaultClassPrefix;
DefaultClassName = InArgs._DefaultClassName;
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
// If we didn't get given a valid path override (see above), try and automatically work out the best default module
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
// If we have a runtime module with the same name as our project, then use that
// Otherwise, set out default target module as the first runtime module in the list
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if(ClassDomain == EClassDomain::Native && !SelectedModuleInfo.IsValid())
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
{
const FString ProjectName = FApp::GetGameName();
for(const auto& AvailableModule : AvailableModules)
{
if(AvailableModule->ModuleName == ProjectName)
{
SelectedModuleInfo = AvailableModule;
break;
}
if(AvailableModule->ModuleType == EHostType::Runtime)
{
SelectedModuleInfo = AvailableModule;
// keep going in case we find a better match
}
}
if (!SelectedModuleInfo.IsValid())
{
// No runtime modules? Just take the first available module then
SelectedModuleInfo = AvailableModules[0];
}
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
NewClassPath = SelectedModuleInfo->ModuleSourcePath;
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
}
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
ClassLocation = GameProjectUtils::EClassLocation::UserDefined; // the first call to UpdateInputValidity will set this correctly based on NewClassPath
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
ParentClassInfo = FNewClassInfo(InArgs._Class);
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
bShowFullClassTree = false;
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
LastPeriodicValidityCheckTime = 0;
PeriodicValidityCheckFrequency = 4;
bLastInputValidityCheckSuccessful = true;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
bPreventPeriodicValidityChecksUntilNextChange = false;
FClassViewerInitializationOptions Options;
Options.Mode = EClassViewerMode::ClassPicker;
Options.DisplayMode = EClassViewerDisplayMode::TreeView;
Options.bIsActorsOnly = false;
Options.bIsPlaceableOnly = false;
Options.bIsBlueprintBaseOnly = false;
Options.bShowUnloadedBlueprints = false;
Options.bShowNoneOption = false;
Options.bShowObjectRootClass = true;
Cleaned up the parent class tree when adding new component classes UE-9554 - Add BP/C++ Component's Show all classes list not expanded by default It now hides the Object root if UObject is not a valid base class type, as this allows the next level of classes to be expanded out which looks much better when adding new component classes. This involved a lot of shuffling of module dependencies so that we could link GameProjectGeneration to ClassViewer, as previously ClassViewer was directly linking to GameProjectGeneration. I went through and fixed everything that was linking to GameProjectGeneration to instead list it as a dynamic dependency (which it is, as nothing needs to link to it), and then verified that everything was using ClassViewer correctly (found some places that were only marking it as a dynamic dependency without also adding it as an include module, causing issues with missing API macro definitions as they were including ClassViewer headers via a relative include path). #codereview Andrew.Rodham [CL 2451499 by Jamie Dale in Main branch]
2015-02-19 08:07:13 -05:00
Options.bExpandRootNodes = true;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if (InArgs._ClassViewerFilter.IsValid())
{
Options.ClassFilter = InArgs._ClassViewerFilter;
}
else if (InArgs._ClassDomain == EClassDomain::Native)
{
// Prevent creating native classes based on blueprint classes
Options.ClassFilter = MakeShareable(new FNativeClassParentFilter());
}
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
Cleaned up the parent class tree when adding new component classes UE-9554 - Add BP/C++ Component's Show all classes list not expanded by default It now hides the Object root if UObject is not a valid base class type, as this allows the next level of classes to be expanded out which looks much better when adding new component classes. This involved a lot of shuffling of module dependencies so that we could link GameProjectGeneration to ClassViewer, as previously ClassViewer was directly linking to GameProjectGeneration. I went through and fixed everything that was linking to GameProjectGeneration to instead list it as a dynamic dependency (which it is, as nothing needs to link to it), and then verified that everything was using ClassViewer correctly (found some places that were only marking it as a dynamic dependency without also adding it as an include module, causing issues with missing API macro definitions as they were including ClassViewer headers via a relative include path). #codereview Andrew.Rodham [CL 2451499 by Jamie Dale in Main branch]
2015-02-19 08:07:13 -05:00
// Only show the Object root class if it's a valid base (this helps keep the tree clean)
if (Options.ClassFilter.IsValid() && !Options.ClassFilter->IsClassAllowed(Options, UObject::StaticClass(), MakeShareable(new FClassViewerFilterFuncs)))
{
Options.bShowObjectRootClass = false;
}
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
ClassViewer = StaticCastSharedRef<SClassViewer>(FModuleManager::LoadModuleChecked<FClassViewerModule>("ClassViewer").CreateClassViewer(Options, FOnClassPicked::CreateSP(this, &SNewClassDialog::OnAdvancedClassSelected)));
[INTEGRATE] Change 2441435 by Jamie.Dale@Pitbull_JDaleReleases on 2015/02/11 07:46:05 The class wizard now filters out non-Blueprintable component types when adding a new BP component UE-9604 - Add Blueprint Component dialog ignores Blueprintable metadata, allowing you to create a blueprint from any component at all This vastly limits the selection until UE-8946 has been addressed. This change also makes the class wizard verify that its featured classes pass the active class filter (as some featured component classes aren't currently Blueprintable). [CL 2448686 by Matthew Griffin in Main branch]
2015-02-17 10:07:24 -05:00
// Make sure the featured classes all pass the active class filter
TArray<FNewClassInfo> ValidatedFeaturedClasses;
ValidatedFeaturedClasses.Reserve(InArgs._FeaturedClasses.Num());
for (const FNewClassInfo& FeaturedClassInfo : InArgs._FeaturedClasses)
{
if (FeaturedClassInfo.ClassType != FNewClassInfo::EClassType::UObject || ClassViewer->IsClassAllowed(FeaturedClassInfo.BaseClass))
{
ValidatedFeaturedClasses.Add(FeaturedClassInfo);
}
}
SetupParentClassItems(ValidatedFeaturedClasses);
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
UpdateInputValidity();
Add the ability to link to object class documentation throughout the UI [CL 2226010 by Marc Audy in Main branch]
2014-07-21 17:31:27 -04:00
TSharedRef<SWidget> DocWidget = IDocumentation::Get()->CreateAnchor(TAttribute<FString>(this, &SNewClassDialog::GetSelectedParentDocLink));
DocWidget->SetVisibility(TAttribute<EVisibility>(this, &SNewClassDialog::GetDocLinkVisibility));
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
const float EditableTextHeight = 26.0f;
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
IContentBrowserSingleton& ContentBrowser = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser").Get();
FPathPickerConfig BlueprintPathConfig;
if (ClassDomain == EClassDomain::Blueprint)
{
BlueprintPathConfig.DefaultPath = InArgs._InitialPath;
BlueprintPathConfig.bFocusSearchBoxWhenOpened = false;
BlueprintPathConfig.bAllowContextMenu = false;
BlueprintPathConfig.bAllowClassesFolder = false;
BlueprintPathConfig.OnPathSelected = FOnPathSelected::CreateSP(this, &SNewClassDialog::OnBlueprintPathSelected);
}
OnAddedToProject = InArgs._OnAddedToProject;
[INTEGRATE] Change 2417935 by Matt.Kuhlenschmidt@matt_kuhlenschmidt_main on 2015/01/24 16:23:14 Added an experimental method to add a new C++ class derived from ActorComponent to an actor. The purpose of this is to add scripting support directly on an actor without subclassing the actor. [CL 2419710 by Ben Marsh in Main branch]
2015-01-26 20:16:24 -05:00
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
ChildSlot
[
SNew(SBorder)
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
.Padding(18)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
.BorderImage( FEditorStyle::GetBrush("Docking.Tab.ContentAreaBrush") )
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
SNew(SVerticalBox)
#UE4 DOCS: Added tutorial highlighting meta data to the Add Code to Project wizard: the major frame, the "type of code to add" scroll box, the class name, and path. #Code_Review Jamie.Dale [CL 2338726 by Ian Shadden in Main branch]
2014-10-23 13:16:00 -04:00
.AddMetaData<FTutorialMetaData>(TEXT("AddCodeMajorAnchor"))
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
+SVerticalBox::Slot()
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
SAssignNew( MainWizard, SWizard)
.ShowPageList(false)
Editor: Switched SNewClassDialog to use colorized buttons [CL 2516711 by Michael Noland in Main branch]
2015-04-17 23:22:28 -04:00
.ButtonStyle(FEditorStyle::Get(), "FlatButton.Default")
Fix orange cancel buttons in the new class and new project wizard dialogs [CL 2517975 by Matt Kuhlenschmidt in Main branch]
2015-04-20 14:25:22 -04:00
.CancelButtonStyle(FEditorStyle::Get(), "FlatButton.Default")
Editor: Switched SNewClassDialog to use colorized buttons [CL 2516711 by Michael Noland in Main branch]
2015-04-17 23:22:28 -04:00
.FinishButtonStyle(FEditorStyle::Get(), "FlatButton.Success")
.ButtonTextStyle(FEditorStyle::Get(), "LargeText")
.ForegroundColor(FEditorStyle::Get().GetSlateColor("WhiteBrush"))
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.CanFinish(this, &SNewClassDialog::CanFinish)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.FinishButtonText( ClassDomain == EClassDomain::Native ? LOCTEXT("FinishButtonText_Native", "Create Class") : LOCTEXT("FinishButtonText_Blueprint", "Create Blueprint Class") )
.FinishButtonToolTip (
ClassDomain == EClassDomain::Native ?
LOCTEXT("FinishButtonToolTip_Native", "Creates the code files to add your new class.") :
LOCTEXT("FinishButtonToolTip_Blueprint", "Creates the new Blueprint class based on the specified parent class.")
)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.OnCanceled(this, &SNewClassDialog::CancelClicked)
.OnFinished(this, &SNewClassDialog::FinishClicked)
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
.InitialPageIndex(ParentClassInfo.IsSet() ? 1 : 0)
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
.PageFooter()
[
// Get IDE information
SNew(SBorder)
.Visibility( this, &SNewClassDialog::GetGlobalErrorLabelVisibility )
.BorderImage( FEditorStyle::GetBrush("NewClassDialog.ErrorLabelBorder") )
.Padding(FMargin(0, 5))
.Content()
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.VAlign(VAlign_Center)
.Padding(2.f)
.AutoWidth()
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("MessageLog.Warning"))
]
+SHorizontalBox::Slot()
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text( this, &SNewClassDialog::GetGlobalErrorLabelText )
.TextStyle( FEditorStyle::Get(), "NewClassDialog.ErrorLabelFont" )
]
+SHorizontalBox::Slot()
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
.AutoWidth()
.Padding(5.f, 0.f)
[
SNew(SGetSuggestedIDEWidget)
]
]
]
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Choose parent class
+SWizard::Page()
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
.CanShow(!ParentClassInfo.IsSet()) // We can't move to this widget page if we've been given a parent class to use
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
SNew(SVerticalBox)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Title
+SVerticalBox::Slot()
.AutoHeight()
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
.Padding(0)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
SNew(STextBlock)
.TextStyle( FEditorStyle::Get(), "NewClassDialog.PageTitle" )
.Text( LOCTEXT( "ParentClassTitle", "Choose Parent Class" ) )
]
// Title spacer
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0, 2, 0, 8)
[
SNew(SSeparator)
]
// Page description and view options
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0, 10)
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.FillWidth(1.f)
.VAlign(VAlign_Center)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
SNew(STextBlock)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Text(
ClassDomain == EClassDomain::Native ?
LOCTEXT("ChooseParentClassDescription_Native", "This will add a C++ header and source code file to your game project.") :
LOCTEXT("ChooseParentClassDescription_Blueprint", "This will add a new Blueprint class to your game project.")
)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Full tree checkbox
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(4, 0, 0, 0)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
SNew(SCheckBox)
.IsChecked( this, &SNewClassDialog::IsFullClassTreeChecked )
.OnCheckStateChanged( this, &SNewClassDialog::OnFullClassTreeChanged )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
SNew(STextBlock)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.Text( LOCTEXT( "FullClassTree", "Show All Classes" ) )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
]
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Add Code list
+SVerticalBox::Slot()
.FillHeight(1.f)
.Padding(0, 10)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
SNew(SBorder)
#UE4 DOCS: Added tutorial highlighting meta data to the Add Code to Project wizard: the major frame, the "type of code to add" scroll box, the class name, and path. #Code_Review Jamie.Dale [CL 2338726 by Ian Shadden in Main branch]
2014-10-23 13:16:00 -04:00
.AddMetaData<FTutorialMetaData>(TEXT("AddCodeOptions"))
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.BorderImage( FEditorStyle::GetBrush("ToolPanel.GroupBorder") )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Basic view
SAssignNew(ParentClassListView, SListView< TSharedPtr<FParentClassItem> >)
.ListItemsSource(&ParentClassItemsSource)
.SelectionMode(ESelectionMode::Single)
.ClearSelectionOnClick(false)
.OnGenerateRow(this, &SNewClassDialog::MakeParentClassListViewWidget)
.OnMouseButtonDoubleClick( this, &SNewClassDialog::OnParentClassItemDoubleClicked )
.OnSelectionChanged(this, &SNewClassDialog::OnClassSelected)
.Visibility(this, &SNewClassDialog::GetBasicParentClassVisibility)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
+SVerticalBox::Slot()
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Advanced view
SNew(SBox)
.Visibility(this, &SNewClassDialog::GetAdvancedParentClassVisibility)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
ClassViewer.ToSharedRef()
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
]
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Class selection
+SVerticalBox::Slot()
.Padding(30, 2)
.AutoHeight()
[
SNew(SHorizontalBox)
#UE4 DOCS: Added tutorial highlighting meta data to the Add Code to Project wizard: the major frame, the "type of code to add" scroll box, the class name, and path. #Code_Review Jamie.Dale [CL 2338726 by Ian Shadden in Main branch]
2014-10-23 13:16:00 -04:00
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Class label
+SHorizontalBox::Slot()
.AutoWidth()
[
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
.VAlign(VAlign_Center)
.Padding(0, 0, 12, 0)
[
SNew(STextBlock)
.TextStyle( FEditorStyle::Get(), "NewClassDialog.SelectedParentClassLabel" )
.Text( LOCTEXT( "ParentClassLabel", "Selected Class" ) )
]
+SVerticalBox::Slot()
.AutoHeight()
.VAlign(VAlign_Center)
.Padding(0, 0, 12, 0)
[
SNew(STextBlock)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
.TextStyle(FEditorStyle::Get(), "NewClassDialog.SelectedParentClassLabel")
.Text(LOCTEXT("ParentClassSourceLabel", "Selected Class Source"))
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Class selection preview
+SHorizontalBox::Slot()
[
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
.VAlign(VAlign_Center)
.Padding(0, 0, 12, 0)
[
Add the ability to link to object class documentation throughout the UI [CL 2226010 by Marc Audy in Main branch]
2014-07-21 17:31:27 -04:00
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.VAlign(VAlign_Center)
Add the ability to link to object class documentation throughout the UI [CL 2226010 by Marc Audy in Main branch]
2014-07-21 17:31:27 -04:00
.AutoWidth()
[
SNew(STextBlock)
.Text( this, &SNewClassDialog::GetSelectedParentClassName )
]
+SHorizontalBox::Slot()
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.VAlign(VAlign_Center)
Add the ability to link to object class documentation throughout the UI [CL 2226010 by Marc Audy in Main branch]
2014-07-21 17:31:27 -04:00
.AutoWidth()
[
DocWidget
]
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
]
+ SVerticalBox::Slot()
.AutoHeight()
.VAlign(VAlign_Bottom)
.HAlign(HAlign_Left)
.Padding(0.0f, 0.0f, 0.0f, 0.0f)
[
SNew(SHyperlink)
[INTEGRATE] Change 2436956 by Michael.Noland@mnoland-T2784-Reference on 2015/02/07 16:50:09 Editor: Change native/BP hyperlink underline colors to be driven by the common style colors as well [CL 2446951 by Matthew Griffin in Main branch]
2015-02-16 08:38:28 -05:00
.Style(FEditorStyle::Get(), "Common.GotoNativeCodeHyperlink")
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
.OnNavigate(this, &SNewClassDialog::OnEditCodeClicked)
.Text(this, &SNewClassDialog::GetSelectedParentClassFilename)
Changed tooltip to indicate which application will be used to open source files when clicking on their class's hyperlink. #jira UE-9271 - Blueprint Option 'Click to Open Source File' Misleading [CL 2440038 by Richard TalbotWatkin in Main branch]
2015-02-10 13:26:26 -05:00
.ToolTipText(FText::Format(LOCTEXT("GoToCode_ToolTip", "Click to open this source file in {0}"), FSourceCodeNavigation::GetSuggestedSourceCodeIDE()))
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
.Visibility(this, &SNewClassDialog::GetSourceHyperlinkVisibility)
]
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
]
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Name class
+SWizard::Page()
.OnEnter(this, &SNewClassDialog::OnNamePageEntered)
[
SNew(SVerticalBox)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Title
+SVerticalBox::Slot()
.AutoHeight()
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
.Padding(0)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
SNew(STextBlock)
.TextStyle( FEditorStyle::Get(), "NewClassDialog.PageTitle" )
.Text( this, &SNewClassDialog::GetNameClassTitle )
]
// Title spacer
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0, 2, 0, 8)
[
SNew(SSeparator)
]
+SVerticalBox::Slot()
.FillHeight(1.f)
.Padding(0, 10)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0, 0, 0, 5)
[
SNew(STextBlock)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Text(LOCTEXT("ClassNameDescription", "Enter a name for your new class. Class names may only contain alphanumeric characters, and may not contain a space.") )
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0, 0, 0, 2)
[
SNew(STextBlock)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Text( ClassDomain == EClassDomain::Native ?
LOCTEXT("ClassNameDetails_Native", "When you click the \"Create\" button below, a header (.h) file and a source (.cpp) file will be made using this name.") :
LOCTEXT("ClassNameDetails_Blueprint", "When you click the \"Create\" button below, a new Blueprint class will be created.")
)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
// Name Error label
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0, 5)
[
// Constant height, whether the label is visible or not
SNew(SBox).HeightOverride(20)
[
SNew(SBorder)
.Visibility( this, &SNewClassDialog::GetNameErrorLabelVisibility )
.BorderImage( FEditorStyle::GetBrush("NewClassDialog.ErrorLabelBorder") )
.Content()
[
SNew(STextBlock)
.Text( this, &SNewClassDialog::GetNameErrorLabelText )
.TextStyle( FEditorStyle::Get(), "NewClassDialog.ErrorLabelFont" )
]
]
]
// Properties
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(SBorder)
.BorderImage(FEditorStyle::GetBrush("DetailsView.CategoryTop"))
.BorderBackgroundColor(FLinearColor(0.6f, 0.6f, 0.6f, 1.0f ))
.Padding(FMargin(6.0f, 4.0f, 7.0f, 4.0f))
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0)
[
SNew(SGridPanel)
.FillColumn(1, 1.0f)
// Name label
+SGridPanel::Slot(0, 0)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
.VAlign(VAlign_Center)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.Padding(0, 0, 12, 0)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
SNew(STextBlock)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.TextStyle( FEditorStyle::Get(), "NewClassDialog.SelectedParentClassLabel" )
.Text( LOCTEXT( "NameLabel", "Name" ) )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Name edit box
+SGridPanel::Slot(1, 0)
.Padding(0.0f, 3.0f)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
.VAlign(VAlign_Center)
[
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
SNew(SBox)
.HeightOverride(EditableTextHeight)
#UE4 DOCS: Added tutorial highlighting meta data to the Add Code to Project wizard: the major frame, the "type of code to add" scroll box, the class name, and path. #Code_Review Jamie.Dale [CL 2338726 by Ian Shadden in Main branch]
2014-10-23 13:16:00 -04:00
.AddMetaData<FTutorialMetaData>(TEXT("ClassName"))
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SAssignNew( ClassNameEditBox, SEditableTextBox)
.Text( this, &SNewClassDialog::OnGetClassNameText )
.OnTextChanged( this, &SNewClassDialog::OnClassNameTextChanged )
]
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
+SHorizontalBox::Slot()
.AutoWidth()
.Padding(6.0f, 0.0f, 0.0f, 0.0f)
[
Expose ProjectHasCodeFiles, GenerateBasicSourceCode, GetCurrentProjectModules and DetermineModuleIncludePath from GameProjectGenerationModule [CL 2327274 by Marc Audy in Main branch]
2014-10-13 11:47:21 -04:00
SAssignNew(AvailableModulesCombo, SComboBox<TSharedPtr<FModuleContextInfo>>)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
.ToolTipText( LOCTEXT("ModuleComboToolTip", "Choose the target module for your new class") )
.OptionsSource( &AvailableModules )
.InitiallySelectedItem( SelectedModuleInfo )
.OnSelectionChanged( this, &SNewClassDialog::SelectedModuleComboBoxSelectionChanged )
.OnGenerateWidget( this, &SNewClassDialog::MakeWidgetForSelectedModuleCombo )
[
SNew(STextBlock)
.Text( this, &SNewClassDialog::GetSelectedModuleComboText )
]
]
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Native C++ properties
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
+SHorizontalBox::Slot()
.AutoWidth()
.Padding(6.0f, 0.0f, 0.0f, 0.0f)
[
SNew(SHorizontalBox)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
+SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SCheckBox)
.Style(FEditorStyle::Get(), "Property.ToggleButton.Start")
.IsChecked(this, &SNewClassDialog::IsClassLocationActive, GameProjectUtils::EClassLocation::Public)
.OnCheckStateChanged(this, &SNewClassDialog::OnClassLocationChanged, GameProjectUtils::EClassLocation::Public)
fix for UE-10324 Unable to toggle between Public and Private class when using Add Code to Project [CL 2476785 by Jason Hoffman in Main branch]
2015-03-12 10:06:48 -04:00
.ToolTipText(LOCTEXT("ClassLocation_Public", "A public class can be included and used inside other modules in addition to the module it resides in"))
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
SNew(SBox)
.VAlign(VAlign_Center)
.HAlign(HAlign_Left)
.Padding(FMargin(4.0f, 0.0f, 3.0f, 0.0f))
[
SNew(STextBlock)
.Text(LOCTEXT("Public", "Public"))
.ColorAndOpacity(this, &SNewClassDialog::GetClassLocationTextColor, GameProjectUtils::EClassLocation::Public)
]
]
]
+SHorizontalBox::Slot()
.AutoWidth()
[
SNew(SCheckBox)
.Style(FEditorStyle::Get(), "Property.ToggleButton.End")
.IsChecked(this, &SNewClassDialog::IsClassLocationActive, GameProjectUtils::EClassLocation::Private)
.OnCheckStateChanged(this, &SNewClassDialog::OnClassLocationChanged, GameProjectUtils::EClassLocation::Private)
fix for UE-10324 Unable to toggle between Public and Private class when using Add Code to Project [CL 2476785 by Jason Hoffman in Main branch]
2015-03-12 10:06:48 -04:00
.ToolTipText(LOCTEXT("ClassLocation_Private", "A private class can only be included and used within the module it resides in"))
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
SNew(SBox)
.VAlign(VAlign_Center)
.HAlign(HAlign_Right)
.Padding(FMargin(3.0f, 0.0f, 4.0f, 0.0f))
[
SNew(STextBlock)
.Text(LOCTEXT("Private", "Private"))
.ColorAndOpacity(this, &SNewClassDialog::GetClassLocationTextColor, GameProjectUtils::EClassLocation::Private)
]
]
]
]
]
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
// Path label
+SGridPanel::Slot(0, 1)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.VAlign(ClassDomain == EClassDomain::Blueprint ? VAlign_Top : VAlign_Center)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.Padding(0, 0, 12, 0)
[
SNew(STextBlock)
.TextStyle( FEditorStyle::Get(), "NewClassDialog.SelectedParentClassLabel" )
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
.Text( LOCTEXT( "PathLabel", "Path" ) )
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
// Path edit box
+SGridPanel::Slot(1, 1)
.Padding(0.0f, 3.0f)
.VAlign(VAlign_Center)
[
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
SNew(SVerticalBox)
// Blueprint Class asset path
+ SVerticalBox::Slot()
.Padding(0)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
SNew(SBox)
// Height override to force the visibility of a scrollbar (our parent is autoheight)
.HeightOverride(200)
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Visible : EVisibility::Collapsed)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
ContentBrowser.CreatePathPicker(BlueprintPathConfig)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Native C++ path
+ SVerticalBox::Slot()
.Padding(0)
.AutoHeight()
[
SNew(SBox)
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
.HeightOverride(EditableTextHeight)
.AddMetaData<FTutorialMetaData>(TEXT("Path"))
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
[
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SNew(SEditableTextBox)
.Text(this, &SNewClassDialog::OnGetClassPathText)
.OnTextChanged(this, &SNewClassDialog::OnClassPathTextChanged)
]
+SHorizontalBox::Slot()
.AutoWidth()
.Padding(6.0f, 1.0f, 0.0f, 0.0f)
[
SNew(SButton)
.VAlign(VAlign_Center)
.OnClicked(this, &SNewClassDialog::HandleChooseFolderButtonClicked)
.Text( LOCTEXT( "BrowseButtonText", "Choose Folder" ) )
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
]
]
// Header output label
+SGridPanel::Slot(0, 2)
.VAlign(VAlign_Center)
.Padding(0, 0, 12, 0)
[
SNew(STextBlock)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.TextStyle( FEditorStyle::Get(), "NewClassDialog.SelectedParentClassLabel" )
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
.Text( LOCTEXT( "HeaderFileLabel", "Header File" ) )
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
// Header output text
+SGridPanel::Slot(1, 2)
.Padding(0.0f, 3.0f)
.VAlign(VAlign_Center)
[
SNew(SBox)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.VAlign(VAlign_Center)
.HeightOverride(EditableTextHeight)
[
SNew(STextBlock)
.Text(this, &SNewClassDialog::OnGetClassHeaderFileText)
]
]
// Source output label
+SGridPanel::Slot(0, 3)
.VAlign(VAlign_Center)
.Padding(0, 0, 12, 0)
[
SNew(STextBlock)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.TextStyle( FEditorStyle::Get(), "NewClassDialog.SelectedParentClassLabel" )
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
.Text( LOCTEXT( "SourceFileLabel", "Source File" ) )
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
// Source output text
+SGridPanel::Slot(1, 3)
.Padding(0.0f, 3.0f)
.VAlign(VAlign_Center)
[
SNew(SBox)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Visibility(ClassDomain == EClassDomain::Blueprint ? EVisibility::Collapsed : EVisibility::Visible)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
.VAlign(VAlign_Center)
.HeightOverride(EditableTextHeight)
[
SNew(STextBlock)
.Text(this, &SNewClassDialog::OnGetClassSourceFileText)
]
]
]
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0.0f)
[
SNew(SBorder)
.Padding(FMargin(0.0f, 3.0f, 0.0f, 0.0f))
.BorderImage(FEditorStyle::GetBrush("DetailsView.CategoryBottom"))
.BorderBackgroundColor(FLinearColor(0.6f, 0.6f, 0.6f, 1.0f ))
]
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
]
]
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
];
// Select the first item
if ( InArgs._Class == NULL && ParentClassItemsSource.Num() > 0 )
{
ParentClassListView->SetSelection(ParentClassItemsSource[0], ESelectInfo::Direct);
}
}
void SNewClassDialog::Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
// Every few seconds, the class name/path is checked for validity in case the disk contents changed and the location is now valid or invalid.
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
// After class creation, periodic checks are disabled to prevent a brief message indicating that the class you created already exists.
// This feature is re-enabled if the user did not restart and began editing parameters again.
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
if ( !bPreventPeriodicValidityChecksUntilNextChange && (InCurrentTime > LastPeriodicValidityCheckTime + PeriodicValidityCheckFrequency) )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
UpdateInputValidity();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
}
TSharedRef<ITableRow> SNewClassDialog::MakeParentClassListViewWidget(TSharedPtr<FParentClassItem> ParentClassItem, const TSharedRef<STableViewBase>& OwnerTable)
{
if ( !ensure(ParentClassItem.IsValid()) )
{
return SNew( STableRow<TSharedPtr<FParentClassItem>>, OwnerTable );
}
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
if ( !ParentClassItem->ParentClassInfo.IsSet() )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
return SNew( STableRow<TSharedPtr<FParentClassItem>>, OwnerTable );
}
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
const FString ClassName = ParentClassItem->ParentClassInfo.GetClassName();
const FString ClassDescription = ParentClassItem->ParentClassInfo.GetClassDescription();
const FSlateBrush* const ClassBrush = ParentClassItem->ParentClassInfo.GetClassIcon();
Fix new class dialog class tooltips pointing to the wrong documentation page location [CL 2237172 by Marc Audy in Main branch]
2014-07-30 13:01:03 -04:00
const UClass* Class = ParentClassItem->ParentClassInfo.BaseClass;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
const int32 ItemHeight = 64;
const int32 DescriptionIndent = 32;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
return
SNew( STableRow<TSharedPtr<FParentClassItem>>, OwnerTable )
.Style(FEditorStyle::Get(), "NewClassDialog.ParentClassListView.TableRow")
Fix new class dialog class tooltips pointing to the wrong documentation page location [CL 2237172 by Marc Audy in Main branch]
2014-07-30 13:01:03 -04:00
.ToolTip(IDocumentation::Get()->CreateToolTip(FText::FromString(ClassDescription), nullptr, FEditorClassUtils::GetDocumentationPage(Class), FEditorClassUtils::GetDocumentationExcerpt(Class)))
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[
SNew(SBox).HeightOverride(ItemHeight)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.Padding(8)
.AutoHeight()
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(0, 0, 4, 0)
[
SNew(SImage)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
.Image(ClassBrush)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
+SHorizontalBox::Slot()
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.TextStyle( FEditorStyle::Get(), "NewClassDialog.ParentClassItemTitle" )
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
.Text(FText::FromString(ClassName))
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
]
+SVerticalBox::Slot()
.FillHeight(1.f)
.Padding(DescriptionIndent, 0, 0, 0)
[
SNew(STextBlock)
Condensed the class wizard layout so it wastes less space TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard ReviewedBy Max.Preussner [CL 2072777 by Jamie Dale in Main branch]
2014-05-14 07:07:29 -04:00
//.AutoWrapText(true)
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
.Text(FText::FromString(ClassDescription))
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
]
]
];
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
FText SNewClassDialog::GetSelectedParentClassName() const
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
return ParentClassInfo.IsSet() ? FText::FromString(ParentClassInfo.GetClassName()) : FText::GetEmpty();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
FString GetClassHeaderPath(const UClass* Class)
{
if (Class)
{
FString ClassHeaderPath;
if (FSourceCodeNavigation::FindClassHeaderPath(Class, ClassHeaderPath) && IFileManager::Get().FileSize(*ClassHeaderPath) != INDEX_NONE)
{
return ClassHeaderPath;
}
}
return FString();
}
EVisibility SNewClassDialog::GetSourceHyperlinkVisibility() const
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if (ClassDomain == EClassDomain::Blueprint)
{
return EVisibility::Collapsed;
}
UE-8578: Slate Widget fails to compile once added to a new project Slate Widget was failing, because of missing Slate dependencies. Testing introduced a couple of problems which all was fixed by this CL: 1. I introduced AdditionalDependencies in .uproject file and change "Add Code To Project..." procedure to fill this array if needed. UBT reads this field and builds the project with required modules. Needed for Slate classes. 2. Changed UHT to #include missing headers in generated.h files if it was missing an include for it's super class. It was causing problems if we were trying to add a subclass of BrushShape -- BrushShape.h didn't have #include "Brush.h" and UBrushShape was inheriting from UBrush. 3. Above problems also occured for Slate classes, but not all of them was UCLASSes, so I had to fixed that manually. 4. "Add Code To Project..." functionality was not invalidating UBT makefiles, which lead to omitting new source files during hot-reloading (even thought it was reporting a success). This change also should improve a bit performance, cause right now there is no "gathering" step -- there is only invalidate step which is a lot quicker. 5. Fixed "Selected Class Source" link to source class in Slate Widget and Slate Widget Style class. #codereview Robert.Manuszewski [CL 2481488 by Jaroslaw Palczynski in Main branch]
2015-03-17 09:34:18 -04:00
return (ParentClassInfo.GetBaseClassHeaderFilename().Len() > 0 ? EVisibility::Visible : EVisibility::Hidden);
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
FText SNewClassDialog::GetSelectedParentClassFilename() const
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
{
UE-8578: Slate Widget fails to compile once added to a new project Slate Widget was failing, because of missing Slate dependencies. Testing introduced a couple of problems which all was fixed by this CL: 1. I introduced AdditionalDependencies in .uproject file and change "Add Code To Project..." procedure to fill this array if needed. UBT reads this field and builds the project with required modules. Needed for Slate classes. 2. Changed UHT to #include missing headers in generated.h files if it was missing an include for it's super class. It was causing problems if we were trying to add a subclass of BrushShape -- BrushShape.h didn't have #include "Brush.h" and UBrushShape was inheriting from UBrush. 3. Above problems also occured for Slate classes, but not all of them was UCLASSes, so I had to fixed that manually. 4. "Add Code To Project..." functionality was not invalidating UBT makefiles, which lead to omitting new source files during hot-reloading (even thought it was reporting a success). This change also should improve a bit performance, cause right now there is no "gathering" step -- there is only invalidate step which is a lot quicker. 5. Fixed "Selected Class Source" link to source class in Slate Widget and Slate Widget Style class. #codereview Robert.Manuszewski [CL 2481488 by Jaroslaw Palczynski in Main branch]
2015-03-17 09:34:18 -04:00
const FString ClassHeaderPath = ParentClassInfo.GetBaseClassHeaderFilename();
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
if (ClassHeaderPath.Len() > 0)
{
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
return FText::FromString(FPaths::GetCleanFilename(*ClassHeaderPath));
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
return FText::GetEmpty();
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
}
Add the ability to link to object class documentation throughout the UI [CL 2226010 by Marc Audy in Main branch]
2014-07-21 17:31:27 -04:00
EVisibility SNewClassDialog::GetDocLinkVisibility() const
{
return (ParentClassInfo.BaseClass == nullptr || FEditorClassUtils::GetDocumentationLink(ParentClassInfo.BaseClass).IsEmpty() ? EVisibility::Hidden : EVisibility::Visible);
}
FString SNewClassDialog::GetSelectedParentDocLink() const
{
return FEditorClassUtils::GetDocumentationLink(ParentClassInfo.BaseClass);
}
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
void SNewClassDialog::OnEditCodeClicked()
{
UE-8578: Slate Widget fails to compile once added to a new project Slate Widget was failing, because of missing Slate dependencies. Testing introduced a couple of problems which all was fixed by this CL: 1. I introduced AdditionalDependencies in .uproject file and change "Add Code To Project..." procedure to fill this array if needed. UBT reads this field and builds the project with required modules. Needed for Slate classes. 2. Changed UHT to #include missing headers in generated.h files if it was missing an include for it's super class. It was causing problems if we were trying to add a subclass of BrushShape -- BrushShape.h didn't have #include "Brush.h" and UBrushShape was inheriting from UBrush. 3. Above problems also occured for Slate classes, but not all of them was UCLASSes, so I had to fixed that manually. 4. "Add Code To Project..." functionality was not invalidating UBT makefiles, which lead to omitting new source files during hot-reloading (even thought it was reporting a success). This change also should improve a bit performance, cause right now there is no "gathering" step -- there is only invalidate step which is a lot quicker. 5. Fixed "Selected Class Source" link to source class in Slate Widget and Slate Widget Style class. #codereview Robert.Manuszewski [CL 2481488 by Jaroslaw Palczynski in Main branch]
2015-03-17 09:34:18 -04:00
const FString ClassHeaderPath = ParentClassInfo.GetBaseClassHeaderFilename();
Add link to code from Add Code to Project window [CL 2214916 by Marc Audy in Main branch]
2014-07-14 16:50:34 -04:00
if (ClassHeaderPath.Len() > 0)
{
const FString AbsoluteHeaderPath = IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*ClassHeaderPath);
FSourceCodeNavigation::OpenSourceFile(AbsoluteHeaderPath);
}
}
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
void SNewClassDialog::OnParentClassItemDoubleClicked( TSharedPtr<FParentClassItem> TemplateItem )
{
// Advance to the name page
const int32 NamePageIdx = 1;
if ( MainWizard->CanShowPage(NamePageIdx) )
{
MainWizard->ShowPage(NamePageIdx);
}
}
void SNewClassDialog::OnClassSelected(TSharedPtr<FParentClassItem> Item, ESelectInfo::Type SelectInfo)
{
if ( Item.IsValid() )
{
ClassViewer->ClearSelection();
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
ParentClassInfo = Item->ParentClassInfo;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
else
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
ParentClassInfo = FNewClassInfo();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
}
void SNewClassDialog::OnAdvancedClassSelected(UClass* Class)
{
ParentClassListView->ClearSelection();
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
ParentClassInfo = FNewClassInfo(Class);
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
ECheckBoxState SNewClassDialog::IsFullClassTreeChecked() const
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
return bShowFullClassTree ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
void SNewClassDialog::OnFullClassTreeChanged(ECheckBoxState NewCheckedState)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
bShowFullClassTree = (NewCheckedState == ECheckBoxState::Checked);
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
EVisibility SNewClassDialog::GetBasicParentClassVisibility() const
{
return bShowFullClassTree ? EVisibility::Collapsed : EVisibility::Visible;
}
EVisibility SNewClassDialog::GetAdvancedParentClassVisibility() const
{
return bShowFullClassTree ? EVisibility::Visible : EVisibility::Collapsed;
}
EVisibility SNewClassDialog::GetNameErrorLabelVisibility() const
{
return GetNameErrorLabelText().IsEmpty() ? EVisibility::Hidden : EVisibility::Visible;
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
FText SNewClassDialog::GetNameErrorLabelText() const
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
if ( !bLastInputValidityCheckSuccessful )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
return LastInputValidityErrorText;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
return FText::GetEmpty();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
EVisibility SNewClassDialog::GetGlobalErrorLabelVisibility() const
{
Replaced the "Get Visual Studio" hyperlink in the SNewProjectWizard and SNewClassDialog with an "Install Visual Studio" button on Windows - Added IDesktopPlatform::GetUserTempPath() and implemented it for windows - Created SGetSuggestedIDEWidget class that handles whether to show a "Download X" hyperlink vs. an "Install X" button (depending on whether the platform supports on-demand installation) - Analytics event added ("Editor.Usage.InstalledIDE") that fires whenever the "Install X" button is clicked - Changed SourceCodeIDEURL_Windows in BaseEditor.ini from the VSC 2013 web page link to the installer download link (need to replace with perma-link once we have it) [CL 2409158 by Dan Hertzka in Main branch]
2015-01-16 13:29:54 -05:00
return GetGlobalErrorLabelText().IsEmpty() ? EVisibility::Collapsed : EVisibility::Visible;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
FText SNewClassDialog::GetGlobalErrorLabelText() const
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
if ( !FSourceCodeNavigation::IsCompilerAvailable() )
{
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
return FText::Format( LOCTEXT("NoCompilerFound", "No compiler was found. In order to use C++ code, you must first install {0}."), FSourceCodeNavigation::GetSuggestedSourceCodeIDE() );
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for STextBlock. UETOOL-213 - Minimize Slate FString -> FText conversion (remove SLATE_TEXT_ATTRIBUTE) This fixes any editor/engine specific code that was passing text to Slate as FString rather than FText. [CL 2399803 by Jamie Dale in Main branch]
2015-01-07 09:52:40 -05:00
return FText::GetEmpty();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
void SNewClassDialog::OnNamePageEntered()
{
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
// Set the default class name based on the selected parent class, eg MyActor
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
const FString ParentClassName = ParentClassInfo.GetClassNameCPP();
[INTEGRATE] Change 2421194 by Mike.Fricker@MFRICKER_G3686_Alpha on 2015/01/27 17:44:17 Improvements to naming of newly-created C++ and BP components through SCS tree - Strip off "_C" suffix on newly created Blueprint classes - Don't strip "Component" from Blueprint class names unless it is the suffix - Changed prefix for newly-created C++ components from "My" to "New" - New Blueprint components default to the name of the class unless they are Blueprints of UActorComponent, in which case the name is just "NewComponent" - New C++ components default to the name of the class unless they inherit from UActorComponent, in which case the name is just "NewComponent" #codereview matt.kuhlenschmidt [CL 2425794 by Ben Marsh in Main branch]
2015-01-30 10:35:05 -05:00
const FString PotentialNewClassName = FString::Printf(TEXT("%s%s"),
DefaultClassPrefix.IsEmpty() ? TEXT("My") : *DefaultClassPrefix,
DefaultClassName.IsEmpty() ? (ParentClassName.IsEmpty() ? TEXT("Class") : *ParentClassName) : *DefaultClassName);
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
// Only set the default if the user hasn't changed the class name from the previous default
if(LastAutoGeneratedClassName.IsEmpty() || NewClassName == LastAutoGeneratedClassName)
{
NewClassName = PotentialNewClassName;
LastAutoGeneratedClassName = PotentialNewClassName;
}
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
UpdateInputValidity();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
// Steal keyboard focus to accelerate name entering
Refactor to unify keyboard and controller input and focus. Native controller navigation support. [CL 2345039 by Chris Gagnon in Main branch]
2014-10-30 12:29:36 -04:00
FSlateApplication::Get().SetKeyboardFocus(ClassNameEditBox, EFocusCause::SetDirectly);
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
FText SNewClassDialog::GetNameClassTitle() const
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
static const FString NoneString = TEXT("None");
const FText ParentClassName = GetSelectedParentClassName();
if(!ParentClassName.IsEmpty() && ParentClassName.ToString() != NoneString)
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
{
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
return FText::Format( LOCTEXT( "NameClassTitle", "Name Your New {0}" ), ParentClassName );
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
}
Fixed code relying on SLATE_TEXT_ATTRIBUTE for SHyperlink Made sure everything was using FText rather than FString. [CL 2370982 by Jamie Dale in Main branch]
2014-11-26 13:56:07 -05:00
return LOCTEXT( "NameClassGenericTitle", "Name Your New Class" );
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
FText SNewClassDialog::OnGetClassNameText() const
{
return FText::FromString(NewClassName);
}
void SNewClassDialog::OnClassNameTextChanged(const FText& NewText)
{
NewClassName = NewText.ToString();
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
UpdateInputValidity();
}
FText SNewClassDialog::OnGetClassPathText() const
{
return FText::FromString(NewClassPath);
}
void SNewClassDialog::OnClassPathTextChanged(const FText& NewText)
{
NewClassPath = NewText.ToString();
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
// If the user has selected a path which matches the root of a known module, then update our selected module to be that module
for(const auto& AvailableModule : AvailableModules)
{
if(NewClassPath.StartsWith(AvailableModule->ModuleSourcePath))
{
SelectedModuleInfo = AvailableModule;
AvailableModulesCombo->SetSelectedItem(SelectedModuleInfo);
break;
}
}
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
UpdateInputValidity();
}
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
void SNewClassDialog::OnBlueprintPathSelected(const FString& NewPath)
{
NewClassPath = NewPath;
UpdateInputValidity();
}
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
FText SNewClassDialog::OnGetClassHeaderFileText() const
{
return FText::FromString(CalculatedClassHeaderName);
}
FText SNewClassDialog::OnGetClassSourceFileText() const
{
return FText::FromString(CalculatedClassSourceName);
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
void SNewClassDialog::CancelClicked()
{
CloseContainingWindow();
}
bool SNewClassDialog::CanFinish() const
{
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
return bLastInputValidityCheckSuccessful && ParentClassInfo.IsSet() && FSourceCodeNavigation::IsCompilerAvailable();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
void SNewClassDialog::FinishClicked()
{
check(CanFinish());
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if (ClassDomain == EClassDomain::Blueprint)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
FString PackagePath = NewClassPath / NewClassName;
[INTEGRATE] Change 2417935 by Matt.Kuhlenschmidt@matt_kuhlenschmidt_main on 2015/01/24 16:23:14 Added an experimental method to add a new C++ class derived from ActorComponent to an actor. The purpose of this is to add scripting support directly on an actor without subclassing the actor. [CL 2419710 by Ben Marsh in Main branch]
2015-01-26 20:16:24 -05:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if (!ParentClassInfo.BaseClass)
[INTEGRATE] Change 2417820 by Mike.Fricker@MFRICKER_G3686_Alpha on 2015/01/24 11:57:38 After adding a new class, we now always open the IDE to edit source if the hot reload completed successfully - Also, we display a quick pop-up notification indicating success instead of a modal prompt [CL 2419701 by Ben Marsh in Main branch]
2015-01-26 20:14:10 -05:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// @todo show fail reason in error label
FMessageDialog::Open(EAppMsgType::Ok, LOCTEXT("AddCodeFailed_Blueprint_NoBase", "No parent class has been specified. Failed to generate new Blueprint class."));
[INTEGRATE] Change 2417820 by Mike.Fricker@MFRICKER_G3686_Alpha on 2015/01/24 11:57:38 After adding a new class, we now always open the IDE to edit source if the hot reload completed successfully - Also, we display a quick pop-up notification indicating success instead of a modal prompt [CL 2419701 by Ben Marsh in Main branch]
2015-01-26 20:14:10 -05:00
}
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
else if (FindObject<UBlueprint>(ANY_PACKAGE, *PackagePath))
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// @todo show fail reason in error label
FMessageDialog::Open(EAppMsgType::Ok, LOCTEXT("AddCodeFailed_Blueprint_AlreadyExists", "The chosen Blueprint class already exists, please try again with a different name."));
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
else if (!NewClassPath.IsEmpty() && !NewClassName.IsEmpty())
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
UPackage* Package = CreatePackage(NULL, *PackagePath);
if (Package)
[INTEGRATE] Change 2417820 by Mike.Fricker@MFRICKER_G3686_Alpha on 2015/01/24 11:57:38 After adding a new class, we now always open the IDE to edit source if the hot reload completed successfully - Also, we display a quick pop-up notification indicating success instead of a modal prompt [CL 2419701 by Ben Marsh in Main branch]
2015-01-26 20:14:10 -05:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Create and init a new Blueprint
UBlueprint* NewBP = FKismetEditorUtilities::CreateBlueprint(const_cast<UClass*>(ParentClassInfo.BaseClass), Package, FName(*NewClassName), BPTYPE_Normal, UBlueprint::StaticClass(), UBlueprintGeneratedClass::StaticClass());
if (NewBP)
{
// Notify the asset registry
FAssetRegistryModule::AssetCreated(NewBP);
[INTEGRATE] Change 2417820 by Mike.Fricker@MFRICKER_G3686_Alpha on 2015/01/24 11:57:38 After adding a new class, we now always open the IDE to edit source if the hot reload completed successfully - Also, we display a quick pop-up notification indicating success instead of a modal prompt [CL 2419701 by Ben Marsh in Main branch]
2015-01-26 20:14:10 -05:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Mark the package dirty...
Package->MarkPackageDirty();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
OnAddedToProject.ExecuteIfBound( NewClassName, PackagePath, FString() );
New class workflow improvements We now sync the Content Browser view after adding a new class, and also open the BP editor when adding a new BP class. [CL 2475251 by Jamie Dale in Main branch]
2015-03-11 11:54:24 -04:00
// Sync the content browser to the new asset
TArray<UObject*> SyncAssets;
SyncAssets.Add(NewBP);
FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
ContentBrowserModule.Get().SyncBrowserToAssets(SyncAssets);
// Open the editor for the new asset
FAssetEditorManager::Get().OpenEditorForAsset(NewBP);
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Successfully created the code and potentially opened the IDE. Close the dialog.
CloseContainingWindow();
return;
}
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
}
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// @todo show fail reason in error label
// Failed to add blueprint
const FText Message = FText::Format( LOCTEXT("AddCodeFailed_Blueprint", "Failed to create package for class {0}. Please try again with a different name."), FText::FromString(NewClassName) );
FMessageDialog::Open(EAppMsgType::Ok, Message);
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
else
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
FString HeaderFilePath;
FString CppFilePath;
FText FailReason;
const TSet<FString>& DisallowedHeaderNames = FSourceCodeNavigation::GetSourceFileDatabase().GetDisallowedHeaderNames();
Improved the error message when adding a new class fails due to a compile error The fact that the error message said "failed to add class" despite the class itself being added was causing confusion. In the case where adding a new class fails to hot-reload (probably due a compiler error) we now state that the class itself has been added, but that you'll need to recompile the module before it will appear in the editor, and offer an easy way to open the output log to see more detailed compiler output. We also automatically close the class wizard so that you're not left looking at an error message saying that "the class name is already in use". [CL 2515833 by Jamie Dale in Main branch]
2015-04-17 10:02:43 -04:00
const GameProjectUtils::EAddCodeToProjectResult AddCodeResult = GameProjectUtils::AddCodeToProject(NewClassName, NewClassPath, *SelectedModuleInfo, ParentClassInfo, DisallowedHeaderNames, HeaderFilePath, CppFilePath, FailReason);
if (AddCodeResult == GameProjectUtils::EAddCodeToProjectResult::Succeeded)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
{
OnAddedToProject.ExecuteIfBound( NewClassName, NewClassPath, SelectedModuleInfo->ModuleName );
// Prevent periodic validity checks. This is to prevent a brief error message about the class already existing while you are exiting.
bPreventPeriodicValidityChecksUntilNextChange = true;
// Display a nag if we didn't automatically hot-reload for the newly added class
Added config migration path for newer versions of the engine. Newly installed versions of the engine will now attempt to copy the project-agnostic config settings from a previous engine installation. This happens by way of a versioned manifest that copies old versions when the manifest does not exist, or is a different version. This code path is benign for non-installed versions of the engine (or FPaths::ShouldSaveToUserDir() is false). EditorGameAgnosticSettings and EditorUserSettings ini paths have been renamed to EditorSettings and EditorPerProjectUserSettings respectively to better convey their purpose. In general, most settings should be saved in EditorSettings (project-agnostic) so that they apply regardless of which project is open. We have some way to go migrating existing settings for this to be the case, however. Some previously per-project configuration files are now project-agnostic (such as Editor.ini, EditorKeyBindings.ini, and EditorLayout.ini) GEditor->Access...Settings and GEditor->Get...Settings have been removed in favor of direct access of the CDO through GetMutableDefault<> and GetDefault<> respectively. Global config ini filenames that are not set up are now neither loaded nor saved on build machines, to handle the problem of indeterminate state more generically. This addresses UETOOL-270 (Most editor preferences should be project-agnostic) [CL 2517558 by Andrew Rodham in Main branch]
2015-04-20 10:12:55 -04:00
const bool bWasHotReloaded = GetDefault<UEditorPerProjectUserSettings>()->bAutomaticallyHotReloadNewClasses;
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if( bWasHotReloaded )
{
FNotificationInfo Notification( FText::Format( LOCTEXT("AddedClassSuccessNotification", "Added new class {0}"), FText::FromString(NewClassName) ) );
FSlateNotificationManager::Get().AddNotification( Notification );
}
if ( HeaderFilePath.IsEmpty() || CppFilePath.IsEmpty() || !FSlateApplication::Get().SupportsSourceAccess() )
{
if( !bWasHotReloaded )
{
// Code successfully added, notify the user. We are either running on a platform that does not support source access or a file was not given so don't ask about editing the file
const FText Message = FText::Format(
Improved the error message when adding a new class fails due to a compile error The fact that the error message said "failed to add class" despite the class itself being added was causing confusion. In the case where adding a new class fails to hot-reload (probably due a compiler error) we now state that the class itself has been added, but that you'll need to recompile the module before it will appear in the editor, and offer an easy way to open the output log to see more detailed compiler output. We also automatically close the class wizard so that you're not left looking at an error message saying that "the class name is already in use". [CL 2515833 by Jamie Dale in Main branch]
2015-04-17 10:02:43 -04:00
LOCTEXT("AddCodeSuccessWithHotReload", "Successfully added class '{0}', however you must recompile the '{1}' module before it will appear in the Content Browser.")
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
, FText::FromString(NewClassName), FText::FromString(SelectedModuleInfo->ModuleName) );
FMessageDialog::Open(EAppMsgType::Ok, Message);
}
else
{
// Code was added and hot reloaded into the editor, but the user doesn't have a code IDE installed so we can't open the file to edit it now
}
}
else
{
bool bEditSourceFilesNow = false;
if( bWasHotReloaded )
{
// Code was hot reloaded, so always edit the new classes now
bEditSourceFilesNow = true;
}
else
{
// Code successfully added, notify the user and ask about opening the IDE now
const FText Message = FText::Format(
Improved the error message when adding a new class fails due to a compile error The fact that the error message said "failed to add class" despite the class itself being added was causing confusion. In the case where adding a new class fails to hot-reload (probably due a compiler error) we now state that the class itself has been added, but that you'll need to recompile the module before it will appear in the editor, and offer an easy way to open the output log to see more detailed compiler output. We also automatically close the class wizard so that you're not left looking at an error message saying that "the class name is already in use". [CL 2515833 by Jamie Dale in Main branch]
2015-04-17 10:02:43 -04:00
LOCTEXT("AddCodeSuccessWithHotReloadAndSync", "Successfully added class '{0}', however you must recompile the '{1}' module before it will appear in the Content Browser.\n\nWould you like to edit the code now?")
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
, FText::FromString(NewClassName), FText::FromString(SelectedModuleInfo->ModuleName) );
bEditSourceFilesNow = ( FMessageDialog::Open( EAppMsgType::YesNo, Message ) == EAppReturnType::Yes );
}
if( bEditSourceFilesNow )
{
TArray<FString> SourceFiles;
SourceFiles.Add(IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*HeaderFilePath));
SourceFiles.Add(IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*CppFilePath));
FSourceCodeNavigation::OpenSourceFiles(SourceFiles);
}
}
New class workflow improvements We now sync the Content Browser view after adding a new class, and also open the BP editor when adding a new BP class. [CL 2475251 by Jamie Dale in Main branch]
2015-03-11 11:54:24 -04:00
// Sync the content browser to the new class
UPackage* const ClassPackage = FindPackage(nullptr, *(FString("/Script/") + SelectedModuleInfo->ModuleName));
if ( ClassPackage )
{
UClass* const NewClass = static_cast<UClass*>(FindObjectWithOuter(ClassPackage, UClass::StaticClass(), *NewClassName));
if ( NewClass )
{
TArray<UObject*> SyncAssets;
SyncAssets.Add(NewClass);
FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
ContentBrowserModule.Get().SyncBrowserToAssets(SyncAssets);
}
}
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Successfully created the code and potentially opened the IDE. Close the dialog.
CloseContainingWindow();
}
Improved the error message when adding a new class fails due to a compile error The fact that the error message said "failed to add class" despite the class itself being added was causing confusion. In the case where adding a new class fails to hot-reload (probably due a compiler error) we now state that the class itself has been added, but that you'll need to recompile the module before it will appear in the editor, and offer an easy way to open the output log to see more detailed compiler output. We also automatically close the class wizard so that you're not left looking at an error message saying that "the class name is already in use". [CL 2515833 by Jamie Dale in Main branch]
2015-04-17 10:02:43 -04:00
else if (AddCodeResult == GameProjectUtils::EAddCodeToProjectResult::FailedToHotReload)
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
{
Improved the error message when adding a new class fails due to a compile error The fact that the error message said "failed to add class" despite the class itself being added was causing confusion. In the case where adding a new class fails to hot-reload (probably due a compiler error) we now state that the class itself has been added, but that you'll need to recompile the module before it will appear in the editor, and offer an easy way to open the output log to see more detailed compiler output. We also automatically close the class wizard so that you're not left looking at an error message saying that "the class name is already in use". [CL 2515833 by Jamie Dale in Main branch]
2015-04-17 10:02:43 -04:00
OnAddedToProject.ExecuteIfBound( NewClassName, NewClassPath, SelectedModuleInfo->ModuleName );
// Prevent periodic validity checks. This is to prevent a brief error message about the class already existing while you are exiting.
bPreventPeriodicValidityChecksUntilNextChange = true;
// Failed to compile new code
const FText Message = FText::Format(
LOCTEXT("AddCodeFailed_HotReloadFailed", "Successfully added class '{0}', however you must recompile the '{1}' module before it will appear in the Content Browser. {2}\n\nWould you like to open the Output Log to see more details?")
, FText::FromString(NewClassName), FText::FromString(SelectedModuleInfo->ModuleName), FailReason );
We now offer to show the Output Log when adding a new C++ fails in the editor [CL 2472880 by Jamie Dale in Main branch]
2015-03-09 15:38:57 -04:00
if( FMessageDialog::Open(EAppMsgType::YesNo, Message) == EAppReturnType::Yes )
{
FGlobalTabmanager::Get()->InvokeTab(FName("OutputLog"));
}
Improved the error message when adding a new class fails due to a compile error The fact that the error message said "failed to add class" despite the class itself being added was causing confusion. In the case where adding a new class fails to hot-reload (probably due a compiler error) we now state that the class itself has been added, but that you'll need to recompile the module before it will appear in the editor, and offer an easy way to open the output log to see more detailed compiler output. We also automatically close the class wizard so that you're not left looking at an error message saying that "the class name is already in use". [CL 2515833 by Jamie Dale in Main branch]
2015-04-17 10:02:43 -04:00
// We did manage to add the code itself, so we can close the dialog.
CloseContainingWindow();
}
else
{
// @todo show fail reason in error label
// Failed to add code
const FText Message = FText::Format( LOCTEXT("AddCodeFailed_AddCodeFailed", "Failed to add class '{0}'. {1}"), FText::FromString(NewClassName), FailReason );
FMessageDialog::Open(EAppMsgType::Ok, Message);
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
}
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
}
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
FReply SNewClassDialog::HandleChooseFolderButtonClicked()
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
if ( DesktopPlatform )
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
TSharedPtr<SWindow> ParentWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
void* ParentWindowWindowHandle = (ParentWindow.IsValid()) ? ParentWindow->GetNativeWindow()->GetOSWindowHandle() : nullptr;
FString FolderName;
const FString Title = LOCTEXT("NewClassBrowseTitle", "Choose a source location").ToString();
const bool bFolderSelected = DesktopPlatform->OpenDirectoryDialog(
ParentWindowWindowHandle,
Title,
NewClassPath,
FolderName
);
if ( bFolderSelected )
{
if ( !FolderName.EndsWith(TEXT("/")) )
{
FolderName += TEXT("/");
}
NewClassPath = FolderName;
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
// If the user has selected a path which matches the root of a known module, then update our selected module to be that module
for(const auto& AvailableModule : AvailableModules)
{
if(NewClassPath.StartsWith(AvailableModule->ModuleSourcePath))
{
SelectedModuleInfo = AvailableModule;
AvailableModulesCombo->SetSelectedItem(SelectedModuleInfo);
break;
}
}
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
UpdateInputValidity();
}
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
return FReply::Handled();
}
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
FText SNewClassDialog::GetSelectedModuleComboText() const
{
FFormatNamedArguments Args;
Args.Add(TEXT("ModuleName"), FText::FromString(SelectedModuleInfo->ModuleName));
Args.Add(TEXT("ModuleType"), FText::FromString(EHostType::ToString(SelectedModuleInfo->ModuleType)));
return FText::Format(LOCTEXT("ModuleComboEntry", "{ModuleName} ({ModuleType})"), Args);
}
Expose ProjectHasCodeFiles, GenerateBasicSourceCode, GetCurrentProjectModules and DetermineModuleIncludePath from GameProjectGenerationModule [CL 2327274 by Marc Audy in Main branch]
2014-10-13 11:47:21 -04:00
void SNewClassDialog::SelectedModuleComboBoxSelectionChanged(TSharedPtr<FModuleContextInfo> Value, ESelectInfo::Type SelectInfo)
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
{
const FString& OldModulePath = SelectedModuleInfo->ModuleSourcePath;
const FString& NewModulePath = Value->ModuleSourcePath;
SelectedModuleInfo = Value;
// Update the class path to be rooted to the new module location
const FString AbsoluteClassPath = FPaths::ConvertRelativePathToFull(NewClassPath) / ""; // Ensure trailing /
if(AbsoluteClassPath.StartsWith(OldModulePath))
{
NewClassPath = AbsoluteClassPath.Replace(*OldModulePath, *NewModulePath);
}
UpdateInputValidity();
}
Expose ProjectHasCodeFiles, GenerateBasicSourceCode, GetCurrentProjectModules and DetermineModuleIncludePath from GameProjectGenerationModule [CL 2327274 by Marc Audy in Main branch]
2014-10-13 11:47:21 -04:00
TSharedRef<SWidget> SNewClassDialog::MakeWidgetForSelectedModuleCombo(TSharedPtr<FModuleContextInfo> Value)
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
{
FFormatNamedArguments Args;
Args.Add(TEXT("ModuleName"), FText::FromString(Value->ModuleName));
Args.Add(TEXT("ModuleType"), FText::FromString(EHostType::ToString(Value->ModuleType)));
return SNew(STextBlock)
.Text(FText::Format(LOCTEXT("ModuleComboEntry", "{ModuleName} ({ModuleType})"), Args));
}
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
FSlateColor SNewClassDialog::GetClassLocationTextColor(GameProjectUtils::EClassLocation InLocation) const
{
return (ClassLocation == InLocation) ? FSlateColor(FLinearColor(0, 0, 0)) : FSlateColor(FLinearColor(0.72f, 0.72f, 0.72f, 1.f));
}
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
ECheckBoxState SNewClassDialog::IsClassLocationActive(GameProjectUtils::EClassLocation InLocation) const
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
{
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
return (ClassLocation == InLocation) ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
}
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
void SNewClassDialog::OnClassLocationChanged(ECheckBoxState InCheckedState, GameProjectUtils::EClassLocation InLocation)
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
{
Slate - ESlateCheckBoxState has been renamed to ECheckBoxState. [CL 2384008 by Nick Darnell in Main branch]
2014-12-10 14:24:09 -05:00
if(InCheckedState == ECheckBoxState::Checked)
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
{
const FString AbsoluteClassPath = FPaths::ConvertRelativePathToFull(NewClassPath) / ""; // Ensure trailing /
GameProjectUtils::EClassLocation TmpClassLocation = GameProjectUtils::EClassLocation::UserDefined;
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
GameProjectUtils::GetClassLocation(AbsoluteClassPath, *SelectedModuleInfo, TmpClassLocation);
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
The class wizard now displays the modules listed in your .uproject file as available targets for the new class TTP# 342920 - EDITOR: Cloned C++ projects do not compile correctly TTP# 342762 - Editor: Feature Request: Relax the restrictions on what game modules can have new classes created within them This has allowed the validation logic to be simplified, as it pushes the responsibility onto the user to say which module they want their new class to go into, rather than relying on the validation logic to correctly infer which module the class should be going into. This also relaxes the previous naming restrictions due to assumptions about module names, as you're now able to add code to any module listed in your .uproject file. I've tested: - Adding code to a normal project. - Adding code to a cloned project. - Creating a new code based project. - Adding code to an empty/blueprint based project. All of these cases generated code which compiled correctly. #codereview Ben.Marsh, Max.Preussner [CL 2242790 by Jamie Dale in Main branch]
2014-08-04 18:21:05 -04:00
const FString RootPath = SelectedModuleInfo->ModuleSourcePath;
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
const FString PublicPath = RootPath / "Public" / ""; // Ensure trailing /
const FString PrivatePath = RootPath / "Private" / ""; // Ensure trailing /
// Update the class path to be rooted to the Public or Private folder based on InVisibility
switch(InLocation)
{
case GameProjectUtils::EClassLocation::Public:
if(AbsoluteClassPath.StartsWith(PrivatePath))
{
NewClassPath = AbsoluteClassPath.Replace(*PrivatePath, *PublicPath);
}
else if(AbsoluteClassPath.StartsWith(RootPath))
{
NewClassPath = AbsoluteClassPath.Replace(*RootPath, *PublicPath);
}
fix for UE-10324 Unable to toggle between Public and Private class when using Add Code to Project [CL 2476785 by Jason Hoffman in Main branch]
2015-03-12 10:06:48 -04:00
else
{
NewClassPath = PublicPath;
}
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
break;
case GameProjectUtils::EClassLocation::Private:
if(AbsoluteClassPath.StartsWith(PublicPath))
{
NewClassPath = AbsoluteClassPath.Replace(*PublicPath, *PrivatePath);
}
else if(AbsoluteClassPath.StartsWith(RootPath))
{
NewClassPath = AbsoluteClassPath.Replace(*RootPath, *PrivatePath);
}
fix for UE-10324 Unable to toggle between Public and Private class when using Add Code to Project [CL 2476785 by Jason Hoffman in Main branch]
2015-03-12 10:06:48 -04:00
else
{
NewClassPath = PrivatePath;
}
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
break;
default:
break;
}
// Will update ClassVisibility correctly
UpdateInputValidity();
}
}
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
void SNewClassDialog::UpdateInputValidity()
{
bLastInputValidityCheckSuccessful = true;
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
if (ClassDomain == EClassDomain::Blueprint)
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
bLastInputValidityCheckSuccessful = GameProjectUtils::IsValidClassNameForCreation(NewClassName, LastInputValidityErrorText);
ClassLocation = GameProjectUtils::EClassLocation::UserDefined;
if (bLastInputValidityCheckSuccessful)
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
IAssetRegistry& AssetRegistry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(AssetRegistryConstants::ModuleName).Get();
if (AssetRegistry.GetAssetByObjectPath(*(NewClassPath / NewClassName)).IsValid())
{
bLastInputValidityCheckSuccessful = false;
LastInputValidityErrorText = FText::Format(LOCTEXT("AssetAlreadyExists", "An asset called {0} already exists in {1}."), FText::FromString(NewClassName), FText::FromString(NewClassPath));
}
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
}
}
else
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Validate the path first since this has the side effect of updating the UI
bLastInputValidityCheckSuccessful = GameProjectUtils::CalculateSourcePaths(NewClassPath, *SelectedModuleInfo, CalculatedClassHeaderName, CalculatedClassSourceName, &LastInputValidityErrorText);
CalculatedClassHeaderName /= ParentClassInfo.GetHeaderFilename(NewClassName);
CalculatedClassSourceName /= ParentClassInfo.GetSourceFilename(NewClassName);
Improved the way the class wizard informs users about whether a class with be Public or Private TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard It now displays a checkbox for Public and Private, with a tooltip explaining what each option means. If you're not using a Public/Private layout for your code, it disables these options and also displays a tooltip explaining why. Clicking on one of these check boxes will adjust the current path to place the class either in the Public or Private folder, preserving any sub-path information correctly. Finally, when creating a class in the Public or Classes folder, the class wizard will now automatically add the MODULENAME_API macro to the class declaration. Also improved the button alignment used for the wizard. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2072761 by Jamie Dale in Main branch]
2014-05-14 06:47:25 -04:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// If the source paths check as succeeded, check to see if we're using a Public/Private class
if(bLastInputValidityCheckSuccessful)
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
GameProjectUtils::GetClassLocation(NewClassPath, *SelectedModuleInfo, ClassLocation);
// We only care about the Public and Private folders
if(ClassLocation != GameProjectUtils::EClassLocation::Public && ClassLocation != GameProjectUtils::EClassLocation::Private)
{
ClassLocation = GameProjectUtils::EClassLocation::UserDefined;
}
}
else
{
ClassLocation = GameProjectUtils::EClassLocation::UserDefined;
}
// Validate the class name only if the path is valid
if ( bLastInputValidityCheckSuccessful )
{
const TSet<FString>& DisallowedHeaderNames = FSourceCodeNavigation::GetSourceFileDatabase().GetDisallowedHeaderNames();
bLastInputValidityCheckSuccessful = GameProjectUtils::IsValidClassNameForCreation(NewClassName, *SelectedModuleInfo, DisallowedHeaderNames, LastInputValidityErrorText);
}
// Validate that the class is valid for the currently selected module
// As a project can have multiple modules, this lets us update the class validity as the user changes the target module
if ( bLastInputValidityCheckSuccessful && ParentClassInfo.BaseClass )
{
bLastInputValidityCheckSuccessful = GameProjectUtils::IsValidBaseClassForCreation(ParentClassInfo.BaseClass, *SelectedModuleInfo);
if ( !bLastInputValidityCheckSuccessful )
{
LastInputValidityErrorText = FText::Format(
LOCTEXT("NewClassError_InvalidBaseClassForModule", "{0} cannot be used as a base class in the {1} module. Please make sure that {0} is API exported."),
FText::FromString(ParentClassInfo.BaseClass->GetName()),
FText::FromString(SelectedModuleInfo->ModuleName)
);
}
Added support for showing game and engine classes in the Content Browser UE-7184 - Show game c++ classes and engine c++ classes in the content browser The Content Browser now has extra entries for "Game C++ Classes" and "Engine C++ Classes" (with "Game" and "Engine" being renamed to "Game Content" and "Engine Content" respectively). These new folders serve as hosts for the list of available C++ modules, with each module internally mirroring the folder structure on disk. For example: - Game C++ Classes - ShooterGame - Classes - Bots - ShooterBot - ShooterAIController - [...] - [...] The Content Browser allows you to navigate and search these classes like you can with assets, and provides convenient access to either edit an existing class, or create a new class (either within a selected folder, or derived from a selected class). As the Content Browser only shows you known UClass types, any new classes need to be compiled into a loaded module before they will appear. This means that adding a new class will now automatically hot-reload your target module. Should you prefer to handle building and loading your modules manually, you can disable the automatic hot-reload via "Editor Settings" -> "Miscellaneous" -> "Hot Reload" -> "Automatically Hot Reload New Classes" (see UEditorUserSettings::bAutomaticallyHotReloadNewClasses). [CL 2409386 by Jamie Dale in Main branch]
2015-01-16 15:39:47 -05:00
}
}
#ttp 322244 - LIVE: Feature Request: During "Add Code to Project", allow user to select path where files go #proj UE4 #branch UE4 #summary You can now choose where to place a class added via the New Class Wizard #extra This tries to be smart about your placement if you have Public and Private folders for your project. - By default the header would go into Public, and the source file would go into Private. - If you select the Public/Classes folder for the path, the source file will still go into Private. - If you have a sub-path, eg) /Public/MyStuff/MyClass.h, this will be mirrored in the placement of the source file, eg) /Private/MyStuff/MyClass.cpp #extra If you're not using Public or Private folders it will just place the source at whatever path you specified. #extra It will verify that your source code is going to a valid module folder for your game, and also allows matching of modules that start with your game name, eg) MyGame, MyGameEditor. #reviewedby Thomas.Sarkanen, Max.Preussner [CL 2046528 by Jamie Dale in Main branch]
2014-04-23 18:50:08 -04:00
LastPeriodicValidityCheckTime = FSlateApplication::Get().GetCurrentTime();
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
// Since this function was invoked, periodic validity checks should be re-enabled if they were disabled.
bPreventPeriodicValidityChecksUntilNextChange = false;
}
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
const FNewClassInfo& SNewClassDialog::GetSelectedParentClassInfo() const
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
return ParentClassInfo;
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
void SNewClassDialog::SetupParentClassItems(const TArray<FNewClassInfo>& UserSpecifiedFeaturedClasses)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
TArray<FNewClassInfo> DefaultFeaturedClasses;
const TArray<FNewClassInfo>* ArrayToUse = &UserSpecifiedFeaturedClasses;
Added support for the Class Wizard to create non-UObject classes TTP# 332794 - EDITOR: Usability improvements for the New Class Wizard Abstracted away the parent class information into FNewClassInfo, which can hold either a UClass*, or an enum value corresponding to a pre-defined non-UObject type class (currently; an empty class, a Slate widget, and a Slate widget style). Made the interface of GenerateClassHeaderFile and GenerateClassCPPFile more consistent. They now both take an unprefixed class name as well as the base class information; any extra information they can then generate internally. They also no longer rely on the filename to work out the class name, as the Slate classes may add a prefix or suffix to the filename due to the way the templates are set-up. Updated everything in the SNewClassDialog and GameProjectUtils that was previously working with a UClass* to work with a FNewClassInfo instead. ReviewedBy Thomas.Sarkanen, Max.Preussner [CL 2075367 by Jamie Dale in Main branch]
2014-05-16 07:26:51 -04:00
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
// Setup the featured classes list
if (ArrayToUse->Num() == 0)
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
{
[INTEGRATE] Change 2435332 by Andrew.Rodham@AndrewRodham_4.7 on 2015/02/06 09:25:07 Generalized "Add Code to Project" dialog to allow creation of both c++ and blueprint class types. The add component option when blueprintable components is enabled, now opens up this dialog rather than the parent class picker. UE-8491 - IWCE: New C++ Component and New Blueprint Component should prompt you for a component type to subclass [CL 2446735 by Matthew Griffin in Main branch]
2015-02-16 04:29:11 -05:00
DefaultFeaturedClasses = ClassDomain == EClassDomain::Native ? FFeaturedClasses::AllNativeClasses() : FFeaturedClasses::ActorClasses();
ArrayToUse = &DefaultFeaturedClasses;
}
for (const auto& Featured : *ArrayToUse)
{
ParentClassItemsSource.Add( MakeShareable( new FParentClassItem(Featured) ) );
Engine source (Main branch up to CL 2026164)
2014-03-14 14:13:41 -04:00
}
}
void SNewClassDialog::CloseContainingWindow()
{
FWidgetPath WidgetPath;
TSharedPtr<SWindow> ContainingWindow = FSlateApplication::Get().FindWidgetWindow( AsShared(), WidgetPath);
if ( ContainingWindow.IsValid() )
{
ContainingWindow->RequestDestroyWindow();
}
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue Copy Permalink