void csSCF::RegisterClasses (char const* pluginPath,
iDocument* doc, const char* context)
{
if (doc)
{
csRef<iDocumentNode> rootnode = doc->GetRoot();
if (rootnode != 0)
{
csRef<iDocumentNode> pluginnode = rootnode->GetNode("plugin");
if (pluginnode)
{
csRef<iDocumentNode> scfnode = pluginnode->GetNode("scf");
if (scfnode.IsValid())
RegisterClassesInt (pluginPath, scfnode, context);
else
csPrintfErr("SCF_ERROR: missing <scf> node in metadata for %s "
"in context `%s'\n", pluginPath != 0 ? pluginPath : "{unknown}",
GetContextName(context));
}
else
csPrintfErr("SCF_ERROR: missing root <plugin> node in metadata "
"for %s in context `%s'\n",
pluginPath != 0 ? pluginPath : "{unknown}", GetContextName(context));
}
}
}
bool csSCF::RegisterClass (const char *iClassID, const char *iLibraryName,
const char *iFactoryClass, const char *iDesc, const char *Dependencies,
const char* context)
{
CS::Threading::RecursiveMutexScopedLock lock (mutex);
size_t idx;
csStringID contextID =
context ? contexts.Request (context) : csInvalidStringID;
if (IsVerbose(SCF_VERBOSE_CLASS_REGISTER))
csPrintfErr("SCF_NOTIFY: registering class %s in context %s (from %s)\n",
iClassID, CS::Quote::Single (GetContextName(context)), iLibraryName);
if ((idx = ClassRegistry->FindClass(iClassID)) != (size_t)-1)
{
scfFactory *cf = (scfFactory *)ClassRegistry->Get (idx);
if (ContextClash (cf->classContext, contextID))
{
csPrintfErr("SCF_WARNING: class %s (from %s) has already been "
"registered in the same context %s (in %s)\n",
iClassID, iLibraryName, CS::Quote::Single (GetContextName(context)),
get_library_name(cf->LibraryName));
}
else
{
/*
The user may want to override a standard CS plugin by putting
a plugin exhibiting the same class ID into the e.g. app directory.
In this case a warning is probably not desired. But for debugging
purposes we emit something.
*/
#ifdef CS_DEBUG
// Don't report when the already registered class is static.
if (cf->classContext != staticContextID)
{
// @@@ some way to have this warning in non-debug builds would be nice.
csPrintfErr("SCF_NOTIFY: class %s (from %s) has already been "
"registered in a different context: %s vs. %s (from %s); this "
"message appears only in debug builds\n",
iClassID, iLibraryName,
CS::Quote::Single (GetContextName(context)),
CS::Quote::Single (GetContextName(cf->classContext)),
get_library_name(cf->LibraryName));
}
#endif
}
return false;
}
scfFactory* factory = new scfFactory (iClassID, iLibraryName, iFactoryClass,
0, iDesc, Dependencies, contextID);
ClassRegistry->Push (factory);
SortClassRegistry = true;
return true;
}
void csSCF::RegisterClassesInt(char const* pluginPath, iDocumentNode* scfnode,
const char* context)
{
bool const seen = pluginPath != 0 && libraryNames->Contains(pluginPath);
if (IsVerbose(SCF_VERBOSE_PLUGIN_REGISTER))
{
char const* s = pluginPath != 0 ? pluginPath : "{unknown}";
char const* c = GetContextName(context);
if (!seen)
csPrintfErr("SCF_NOTIFY: registering plugin %s in context `%s'\n", s, c);
else
csPrintfErr("SCF_NOTIFY: ignoring duplicate plugin registration %s "
"in context `%s'\n", s, c);
}
if (seen)
return; // *** RETURN: Do not re-register ***
csRef<iDocumentNode> classesnode = scfnode->GetNode("classes");
if (classesnode)
{
csRef<iDocumentNodeIterator> classiter = classesnode->GetNodes("class");
csRef<iDocumentNode> classnode;
while ((classnode = classiter->Next()))
{
csString classname = get_node_value(classnode, "name");
csString imp = get_node_value(classnode, "implementation");
csString desc = get_node_value(classnode, "description");
// For backward compatibility, we build a comma-delimited dependency
// string from the individual dependency nodes. In the future,
// iSCF::GetClassDependencies() should be updated to return an
// iStringArray, rather than a simple comma-delimited string.
csString depend;
csRef<iDocumentNode> depnode = classnode->GetNode("requires");
if (depnode)
{
csRef<iDocumentNodeIterator> depiter = depnode->GetNodes("class");
csRef<iDocumentNode> depclassnode;
while ((depclassnode = depiter->Next()))
{
if (!depend.IsEmpty()) depend << ", ";
depend << depclassnode->GetContentsValue();
}
}
char const* pdepend = (depend.IsEmpty() ? 0 : depend.GetData());
RegisterClass(classname, pluginPath, imp, desc, pdepend, context);
}
}
}
static void
describeContext (FILE *out, const CONTEXT context) {
RECT rect;
CONTEXT oldContext = SetContext (context);
GetContextClipRect (&rect);
fprintf(out, "Context '%s':\n"
"\tClipRect = (%d, %d)-(%d, %d) (%d x %d)\n",
GetContextName (context),
rect.corner.x, rect.corner.y,
rect.corner.x + rect.extent.width,
rect.corner.y + rect.extent.height,
rect.extent.width, rect.extent.height);
SetContext (oldContext);
}
/** UI_COMMAND takes long for the compile to optimize */
PRAGMA_DISABLE_OPTIMIZATION
void FLevelEditorModesCommands::RegisterCommands()
{
EditorModeCommands.Empty();
int editorMode = 0;
FKey EdModeKeys[9] = { EKeys::One, EKeys::Two, EKeys::Three, EKeys::Four, EKeys::Five, EKeys::Six, EKeys::Seven, EKeys::Eight, EKeys::Nine };
for ( const FEditorModeInfo& Mode : FEditorModeRegistry::Get().GetSortedModeInfo() )
{
// If the mode isn't visible don't create a menu option for it.
if (!Mode.bVisible)
{
continue;
}
FName EditorModeCommandName = FName(*(FString("EditorMode.") + Mode.ID.ToString()));
TSharedPtr<FUICommandInfo> EditorModeCommand =
FInputBindingManager::Get().FindCommandInContext(GetContextName(), EditorModeCommandName);
// If a command isn't yet registered for this mode, we need to register one.
if ( !EditorModeCommand.IsValid() )
{
FFormatNamedArguments Args;
Args.Add( TEXT("Mode"), Mode.Name );
const FText Tooltip = FText::Format( NSLOCTEXT("LevelEditor", "ModeTooltipF", "Activate {Mode} Editing Mode"), Args );
FUICommandInfo::MakeCommandInfo(
this->AsShared(),
EditorModeCommand,
EditorModeCommandName,
Mode.Name,
Tooltip,
Mode.IconBrush,
EUserInterfaceActionType::ToggleButton,
editorMode < 9 ? FInputChord( EModifierKey::Shift, EdModeKeys[editorMode] ) : FInputChord() );
EditorModeCommands.Add(EditorModeCommand);
}
editorMode++;
}
}
static void
drawContext (CONTEXT context, double hue /* no pun intended */)
{
FRAME drawFrame;
CONTEXT oldContext;
FONT oldFont;
DrawMode oldMode;
Color oldFgCol;
Color rectCol;
Color lineCol;
Color textCol;
bool haveClippingRect;
RECT rect;
LINE line;
TEXT text;
POINT p1, p2, p3, p4;
drawFrame = GetContextFGFrame ();
rectCol = hsvaToRgba (hue, 1.0, 0.5, 100);
lineCol = hsvaToRgba (hue, 1.0, 1.0, 90);
textCol = lineCol;
// Save the original context.
oldContext = SetContext (context);
// Get the clipping rectangle of the specified context.
haveClippingRect = GetContextClipRect (&rect);
// Switch back the old context; we're going to draw in it.
(void) SetContext (oldContext);
p1 = rect.corner;
p2.x = rect.corner.x + rect.extent.width - 1;
p2.y = rect.corner.y;
p3.x = rect.corner.x;
p3.y = rect.corner.y + rect.extent.height - 1;
p4.x = rect.corner.x + rect.extent.width - 1;
p4.y = rect.corner.y + rect.extent.height - 1;
oldFgCol = SetContextForeGroundColor (rectCol);
DrawFilledRectangle (&rect);
SetContextForeGroundColor (lineCol);
line.first = p1; line.second = p2; DrawLine (&line);
line.first = p2; line.second = p4; DrawLine (&line);
line.first = p1; line.second = p3; DrawLine (&line);
line.first = p3; line.second = p4; DrawLine (&line);
line.first = p1; line.second = p4; DrawLine (&line);
line.first = p2; line.second = p3; DrawLine (&line);
// Gimme C'99! So I can do:
// DrawLine ((LINE) { .first = p1, .second = p2 })
oldFont = SetContextFont (TinyFont);
SetContextForeGroundColor (textCol);
// Text prim does not yet support alpha via Color.a
oldMode = SetContextDrawMode (MAKE_DRAW_MODE (DRAW_ALPHA, textCol.a));
text.baseline.x = (p1.x + (p2.x + 1)) / 2;
text.baseline.y = p1.y + 8;
text.pStr = GetContextName (context);
text.align = ALIGN_CENTER;
text.CharCount = (COUNT) ~0;
font_DrawText (&text);
(void) SetContextDrawMode (oldMode);
(void) SetContextForeGroundColor (oldFgCol);
(void) SetContextFont (oldFont);
}
void csSCF::ScanPluginsInt (csPathsList const* pluginPaths,
const char* context)
{
if (pluginPaths)
{
// Search plugins in pluginpaths
csRef<iStringArray> plugins;
size_t i, j;
for (i = 0; i < pluginPaths->Length(); i++)
{
csPathsList::Entry const& pathrec = (*pluginPaths)[i];
if (IsVerbose(SCF_VERBOSE_PLUGIN_SCAN))
{
char const* x = scannedDirs.Contains(pathrec.path) ? "re-" : "";
csPrintfErr("SCF_NOTIFY: %sscanning plugin directory: %s "
"(context `%s'; recursive %s)\n", x, pathrec.path.GetData(),
GetContextName(pathrec.type),
pathrec.scanRecursive ? "yes" : "no");
}
if (plugins)
plugins->Empty();
csRef<iStringArray> messages =
csScanPluginDir (pathrec.path, plugins, pathrec.scanRecursive);
scannedDirs.Request(pathrec.path);
if ((messages != 0) && (messages->GetSize () > 0))
{
csPrintfErr("SCF_WARNING: the following issue(s) arose while "
"scanning '%s':", pathrec.path.GetData());
for (j = 0; j < messages->GetSize (); j++)
csPrintfErr(" %s\n", messages->Get (j));
}
csRef<iDocument> metadata;
csRef<iString> msg;
for (j = 0; j < plugins->GetSize (); j++)
{
char const* plugin = plugins->Get(j);
msg = csGetPluginMetadata (plugin, metadata);
if (msg != 0)
{
csPrintfErr("SCF_ERROR: metadata retrieval error for %s: %s\n",
plugin, msg->GetData ());
}
// It is possible for an error or warning message to be generated even
// when metadata is also obtained. Likewise, it is possible for no
// metadata to be obtained yet also to have no error message. The
// latter case is indicative of csScanPluginDir() returning "potential"
// plugins which turn out to not be Crystal Space plugins after all.
// For instance, on Windows, the scan might find a DLL which is not a
// Crystal Space DLL; that is, which does not contain embedded
// metadata. This is a valid case, which we simply ignore since it is
// legal for non-CS libraries to exist alongside CS plugins in the
// scanned directories.
if (metadata)
RegisterClasses(plugin, metadata,
context ? context : pathrec.type.GetData());
}
}
}
}
/** UI_COMMAND takes long for the compile to optimize */
PRAGMA_DISABLE_OPTIMIZATION
void FLevelViewportCommands::RegisterCommands()
{
UI_COMMAND( ToggleMaximize, "Maximize Viewport", "Toggles the Maximize state of the current viewport", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ToggleGameView, "Game View", "Toggles game view. Game view shows the scene as it appears in game", EUserInterfaceActionType::ToggleButton, FInputChord( EKeys::G ) );
UI_COMMAND( ToggleImmersive, "Immersive Mode", "Switches this viewport between immersive mode and regular mode", EUserInterfaceActionType::ToggleButton, FInputChord( EKeys::F11 ) );
UI_COMMAND( CreateCamera, "Create Camera Here", "Creates a new camera actor at the current location of this viewport's camera", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( HighResScreenshot, "High Resolution Screenshot...", "Opens the control panel for high resolution screenshots", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( UseDefaultShowFlags, "Use Defaults", "Resets all show flags to default", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( PilotSelectedActor, "Pilot Selected Actor", "Move the selected actor around using the viewport controls, and bind the viewport to the actor's location and orientation.", EUserInterfaceActionType::Button, FInputChord( EModifierKey::Control | EModifierKey::Shift, EKeys::P ) );
UI_COMMAND( EjectActorPilot, "Eject from Actor Pilot", "Stop piloting an actor with the current viewport. Unlocks the viewport's position and orientation from the actor the viewport is currently piloting.", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( ToggleActorPilotCameraView, "Actor Pilot Camera View", "Toggles showing the exact camera view when using the viewport to pilot a camera", EUserInterfaceActionType::ToggleButton, FInputChord( EModifierKey::Control | EModifierKey::Shift, EKeys::C ) );
UI_COMMAND( ViewportConfig_OnePane, "Layout One Pane", "Changes the viewport arrangement to one pane", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_TwoPanesH, "Layout Two Panes (horizontal)", "Changes the viewport arrangement to two panes, side-by-side", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_TwoPanesV, "Layout Two Panes (vertical)", "Changes the viewport arrangement to two panes, one above the other", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_ThreePanesLeft, "Layout Three Panes (one left, two right)", "Changes the viewport arrangement to three panes, one on the left, two on the right", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_ThreePanesRight, "Layout Three Panes (one right, two left)", "Changes the viewport arrangement to three panes, one on the right, two on the left", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_ThreePanesTop, "Layout Three Panes (one top, two bottom)", "Changes the viewport arrangement to three panes, one on the top, two on the bottom", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_ThreePanesBottom, "Layout Three Panes (one bottom, two top)", "Changes the viewport arrangement to three panes, one on the bottom, two on the top", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_FourPanesLeft, "Layout Four Panes (one left, three right)", "Changes the viewport arrangement to four panes, one on the left, three on the right", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_FourPanesRight, "Layout Four Panes (one right, three left)", "Changes the viewport arrangement to four panes, one on the right, three on the left", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_FourPanesTop, "Layout Four Panes (one top, three bottom)", "Changes the viewport arrangement to four panes, one on the top, three on the bottom", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_FourPanesBottom, "Layout Four Panes (one bottom, three top)", "Changes the viewport arrangement to four panes, one on the bottom, three on the top", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ViewportConfig_FourPanes2x2, "Layout Four Panes (2x2)", "Changes the viewport arrangement to four panes, in a 2x2 grid", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( ApplyMaterialToActor, "Apply Material", "Attempts to apply a dropped material to this object", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( ToggleCinematicPreview, "Toggles Cinematic Preview", "If enabled, allows Matinee or Sequencer previews to play in this viewport", EUserInterfaceActionType::ToggleButton, FInputChord() );
UI_COMMAND( FindInLevelScriptBlueprint, "Find In Level Script", "Finds references of a selected actor in the level script blueprint", EUserInterfaceActionType::Button, FInputChord(EModifierKey::Control, EKeys::K) );
UI_COMMAND( AdvancedSettings, "Advanced Settings...", "Opens the advanced viewport settings", EUserInterfaceActionType::Button, FInputChord());
// Generate a command for each buffer visualization mode
{
struct FMaterialIterator
{
const TSharedRef<class FBindingContext> Parent;
FLevelViewportCommands::TBufferVisualizationModeCommandMap& CommandMap;
FMaterialIterator(const TSharedRef<class FBindingContext> InParent, FLevelViewportCommands::TBufferVisualizationModeCommandMap& InCommandMap)
: Parent(InParent)
, CommandMap(InCommandMap)
{
}
void ProcessValue(const FString& InMaterialName, const UMaterial* InMaterial, const FText& InDisplayName)
{
FName ViewportCommandName = *(FString(TEXT("BufferVisualizationMenu")) + InMaterialName);
FBufferVisualizationRecord& Record = CommandMap.Add(ViewportCommandName, FBufferVisualizationRecord());
Record.Name = *InMaterialName;
const FText MaterialNameText = FText::FromString( InMaterialName );
Record.Command = FUICommandInfoDecl( Parent, ViewportCommandName, MaterialNameText, MaterialNameText )
.UserInterfaceType( EUserInterfaceActionType::RadioButton )
.DefaultChord( FInputChord() );
}
};
BufferVisualizationModeCommands.Empty();
FName ViewportCommandName = *(FString(TEXT("BufferVisualizationOverview")));
FBufferVisualizationRecord& OverviewRecord = BufferVisualizationModeCommands.Add(ViewportCommandName, FBufferVisualizationRecord());
OverviewRecord.Name = NAME_None;
OverviewRecord.Command = FUICommandInfoDecl( this->AsShared(), ViewportCommandName, LOCTEXT("BufferVisualization", "Overview"), LOCTEXT("BufferVisualization", "Overview") )
.UserInterfaceType( EUserInterfaceActionType::RadioButton )
.DefaultChord( FInputChord() );
FMaterialIterator It(this->AsShared(), BufferVisualizationModeCommands);
GetBufferVisualizationData().IterateOverAvailableMaterials(It);
}
const TArray<FShowFlagData>& ShowFlagData = GetShowFlagMenuItems();
// Generate a command for each show flag
for( int32 ShowFlag = 0; ShowFlag < ShowFlagData.Num(); ++ShowFlag )
{
const FShowFlagData& SFData = ShowFlagData[ShowFlag];
FFormatNamedArguments Args;
Args.Add( TEXT("ShowFlagName"), SFData.DisplayName );
FText LocalizedName;
switch( SFData.Group )
{
case SFG_Visualize:
LocalizedName = FText::Format( LOCTEXT("VisualizeFlagLabel", "Visualize {ShowFlagName}"), Args );
break;
default:
LocalizedName = FText::Format( LOCTEXT("ShowFlagLabel", "Show {ShowFlagName}"), Args );
break;
}
//@todo Slate: The show flags system does not support descriptions currently
const FText ShowFlagDesc;
TSharedPtr<FUICommandInfo> ShowFlagCommand
= FUICommandInfoDecl( this->AsShared(), SFData.ShowFlagName, LocalizedName, ShowFlagDesc )
.UserInterfaceType( EUserInterfaceActionType::ToggleButton )
.DefaultChord( SFData.InputChord )
.Icon(SFData.Group == EShowFlagGroup::SFG_Normal ?
FSlateIcon(FEditorStyle::GetStyleSetName(), FEditorStyle::Join( GetContextName(), TCHAR_TO_ANSI( *FString::Printf( TEXT(".%s"), *SFData.ShowFlagName.ToString() ) ) ) ) :
FSlateIcon());
ShowFlagCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowFlagCommand, SFData.DisplayName ) );
}
// Generate a command for each volume class
{
UI_COMMAND( ShowAllVolumes, "Show All Volumes", "Shows all volumes", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( HideAllVolumes, "Hide All Volumes", "Hides all volumes", EUserInterfaceActionType::Button, FInputChord() );
TArray< UClass* > VolumeClasses;
UUnrealEdEngine::GetSortedVolumeClasses(&VolumeClasses);
for( int32 VolumeClassIndex = 0; VolumeClassIndex < VolumeClasses.Num(); ++VolumeClassIndex )
{
//@todo Slate: The show flags system does not support descriptions currently
const FText VolumeDesc;
const FName VolumeName = VolumeClasses[VolumeClassIndex]->GetFName();
FText DisplayName;
FEngineShowFlags::FindShowFlagDisplayName( VolumeName.ToString(), DisplayName );
FFormatNamedArguments Args;
Args.Add( TEXT("ShowFlagName"), DisplayName );
const FText LocalizedName = FText::Format( LOCTEXT("ShowFlagLabel_Visualize", "Visualize {ShowFlagName}"), Args );
TSharedPtr<FUICommandInfo> ShowVolumeCommand
= FUICommandInfoDecl( this->AsShared(), VolumeName, LocalizedName, VolumeDesc )
.UserInterfaceType( EUserInterfaceActionType::ToggleButton );
ShowVolumeCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowVolumeCommand, DisplayName ) );
}
}
// Generate a command for show/hide all layers
{
UI_COMMAND( ShowAllLayers, "Show All Layers", "Shows all layers", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( HideAllLayers, "Hide All Layers", "Hides all layers", EUserInterfaceActionType::Button, FInputChord() );
}
// Generate a command for each sprite category
{
UI_COMMAND( ShowAllSprites, "Show All Sprites", "Shows all sprites", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( HideAllSprites, "Hide All Sprites", "Hides all sprites", EUserInterfaceActionType::Button, FInputChord() );
// get all the known layers
// Get a fresh list as GUnrealEd->SortedSpriteInfo may not yet be built.
TArray<FSpriteCategoryInfo> SortedSpriteInfo;
UUnrealEdEngine::MakeSortedSpriteInfo(SortedSpriteInfo);
FString SpritePrefix = TEXT("ShowSprite_");
for( int32 InfoIndex = 0; InfoIndex < SortedSpriteInfo.Num(); ++InfoIndex )
{
const FSpriteCategoryInfo& SpriteInfo = SortedSpriteInfo[InfoIndex];
const FName CommandName = FName( *(SpritePrefix + SpriteInfo.Category.ToString()) );
FFormatNamedArguments Args;
Args.Add( TEXT("SpriteName"), SpriteInfo.DisplayName );
const FText LocalizedName = FText::Format( NSLOCTEXT("UICommands", "SpriteShowFlagName", "Show {SpriteName} Sprites"), Args );
TSharedPtr<FUICommandInfo> ShowSpriteCommand
= FUICommandInfoDecl( this->AsShared(), CommandName, LocalizedName, SpriteInfo.Description )
.UserInterfaceType( EUserInterfaceActionType::ToggleButton );
ShowSpriteCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowSpriteCommand, SpriteInfo.DisplayName ) );
}
}
// Generate a command for each Stat category
{
UI_COMMAND(HideAllStats, "Hide All Stats", "Hides all Stats", EUserInterfaceActionType::Button, FInputChord());
// Bind a listener here for any additional stat commands that get registered later.
UEngine::NewStatDelegate.AddRaw(this, &FLevelViewportCommands::HandleNewStat);
#if STATS
FStatGroupGameThreadNotifier::Get().NewStatGroupDelegate.BindRaw(this, &FLevelViewportCommands::HandleNewStatGroup);
#endif
}
// Map the bookmark index to default key.
// If the max bookmark number ever increases the new bookmarks will not have default keys
TArray< FKey > NumberKeyNames;
NumberKeyNames.Add( EKeys::Zero );
NumberKeyNames.Add( EKeys::One );
NumberKeyNames.Add( EKeys::Two );
NumberKeyNames.Add( EKeys::Three );
NumberKeyNames.Add( EKeys::Four );
NumberKeyNames.Add( EKeys::Five );
NumberKeyNames.Add( EKeys::Six );
NumberKeyNames.Add( EKeys::Seven );
NumberKeyNames.Add( EKeys::Eight );
NumberKeyNames.Add( EKeys::Nine );
for( int32 BookmarkIndex = 0; BookmarkIndex < AWorldSettings::MAX_BOOKMARK_NUMBER; ++BookmarkIndex )
{
TSharedRef< FUICommandInfo > JumpToBookmark =
FUICommandInfoDecl(
this->AsShared(), //Command class
FName( *FString::Printf( TEXT( "JumpToBookmark%i" ), BookmarkIndex ) ), //CommandName
FText::Format( NSLOCTEXT("LevelEditorCommands", "JumpToBookmark", "Jump to Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label
FText::Format( NSLOCTEXT("LevelEditorCommands", "JumpToBookmark_ToolTip", "Moves the viewport to the location and orientation stored at bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip
.UserInterfaceType( EUserInterfaceActionType::Button ) //interface type
.DefaultChord( FInputChord( NumberKeyNames.IsValidIndex( BookmarkIndex ) ? NumberKeyNames[BookmarkIndex] : EKeys::Invalid ) ); //default chord
JumpToBookmarkCommands.Add( JumpToBookmark );
TSharedRef< FUICommandInfo > SetBookmark =
FUICommandInfoDecl(
this->AsShared(), //Command class
FName( *FString::Printf( TEXT( "SetBookmark%i" ), BookmarkIndex ) ), //CommandName
FText::Format( NSLOCTEXT("LevelEditorCommands", "SetBookmark", "Set Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label
FText::Format( NSLOCTEXT("LevelEditorCommands", "SetBookmark_ToolTip", "Stores the viewports location and orientation in bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip
.UserInterfaceType( EUserInterfaceActionType::Button ) //interface type
.DefaultChord( FInputChord( EModifierKey::Control, NumberKeyNames.IsValidIndex( BookmarkIndex ) ? NumberKeyNames[BookmarkIndex] : EKeys::Invalid ) ); //default chord
SetBookmarkCommands.Add( SetBookmark );
TSharedRef< FUICommandInfo > ClearBookMark =
FUICommandInfoDecl(
this->AsShared(), //Command class
FName( *FString::Printf( TEXT( "ClearBookmark%i" ), BookmarkIndex ) ), //CommandName
FText::Format( NSLOCTEXT("LevelEditorCommands", "ClearBookmark", "Clear Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label
FText::Format( NSLOCTEXT("LevelEditorCommands", "ClearBookmark_ToolTip", "Clears the viewports location and orientation in bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip
.UserInterfaceType( EUserInterfaceActionType::Button ) //interface type
.DefaultChord( FInputChord() ); //default chord
ClearBookmarkCommands.Add( ClearBookMark );
}
UI_COMMAND( ClearAllBookMarks, "Clear All Bookmarks", "Clears all the bookmarks", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( EnablePreviewMesh, "Hold To Enable Preview Mesh", "When held down a preview mesh appears under the cursor", EUserInterfaceActionType::Button, FInputChord(EKeys::Backslash) );
UI_COMMAND( CyclePreviewMesh, "Cycles Preview Mesh", "Cycles available preview meshes", EUserInterfaceActionType::Button, FInputChord( EModifierKey::Shift, EKeys::Backslash ) );
}