public SlideshowStyleManager(SlideshowEditController editorController, LectureUICallback uiCallback)
{
this.editorController = editorController;
this.uiCallback = uiCallback;
editInterface = new EditInterface("Theme");
ReflectedEditInterface.expandEditInterface(this, ReflectedEditInterface.DefaultScanner, editInterface);
}
/// <summary>
/// Get the EditInterface for this SceneNode.
/// </summary>
/// <returns>The node's EditInterface.</returns>
protected override EditInterface createEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, memberScanner, Name + " Scene Node", null);
var movableObjectEdits = editInterface.createEditInterfaceManager <MovableObjectDefinition>();
var childNodeEdits = editInterface.createEditInterfaceManager <SceneNodeDefinition>();
editInterface.addCommand(new EditInterfaceCommand("Add Entity", addEntity));
editInterface.addCommand(new EditInterfaceCommand("Add Light", addLight));
editInterface.addCommand(new EditInterfaceCommand("Add Camera", addCamera));
editInterface.addCommand(new EditInterfaceCommand("Add Manual Object", addManualObject));
editInterface.addCommand(new EditInterfaceCommand("Add Child Node", addChildNode));
editInterface.IconReferenceTag = EngineIcons.Node;
movableObjectEdits.addCommand(new EditInterfaceCommand("Remove", removeMovableObject));
childNodeEdits.addCommand(new EditInterfaceCommand("Remove", removeChildNode));
foreach (MovableObjectDefinition movable in movableObjects.Values)
{
addMovableObjectEdit(movable);
}
foreach (SceneNodeDefinition child in childNodes.Values)
{
addChildNodeEdit(child);
}
}
return(editInterface);
}
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, EditInterfaceName);
}
return(editInterface);
}
/// <summary>
/// Get an EditInterface.
/// </summary>
/// <returns>An EditInterface for the definition or null if there is not interface.</returns>
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, memberScanner, name + " Ogre Scene", null);
}
return(editInterface);
}
protected override EditInterface createEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, String.Format("{0} - IK Drag Control", Name));
}
return(editInterface);
}
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, name + " - BEPUIk Scene", null);
editInterface.addSubInterface(rootSolver.getEditInterface());
}
return(editInterface);
}
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, name + "Simulation Scene", null);
editInterface.addSubInterface(windowPresets.getEditInterface());
}
return(editInterface);
}
/// <summary>
/// Get the EditInterface for the MovableObject.
/// </summary>
/// <returns>The EditInterface.</returns>
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, typeof(MovableObjectDefinition), memberScanner, String.Format("{0} - {1}", name, InterfaceName), null);
setupEditInterface(editInterface);
}
return(editInterface);
}
protected override EditInterface createEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, memberScanner, this.Name + " - Reshapeable Rigid Body", null);
editInterface.IconReferenceTag = EngineIcons.RigidBody;
}
return(editInterface);
}
protected override sealed EditInterface createEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, String.Format("{0} - {1}", Name, EditInterfaceName));
customizeEditInterface(editInterface);
}
return(editInterface);
}
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, GetType().Name, null);
customizeEditInterface(editInterface);
}
return(editInterface);
}
protected override EditInterface createEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, String.Format("{0} - IK Bone", Name));
editInterface.Renderer = new BoneRenderer(this);
}
return(editInterface);
}
/// <summary>
/// This function will provide the customized EditInterface for this
/// class when it is scanned by the ReflectedEditInterface scanner. If
/// it is not scanned with that scanner this function is not
/// automatically called.
/// </summary>
/// <param name="memberName">The name of the member that contains this object.</param>
/// <param name="scanner">The MemberScanner used to scan the parent object.</param>
/// <returns>A new EditInterface for this class.</returns>
public EditInterface getEditInterface(string memberName, MemberScanner scanner)
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, BehaviorEditMemberScanner.Scanner, memberName + " - " + this.GetType().Name, null);
customizeEditInterface(editInterface);
}
return(editInterface);
}
public EditInterface getEditInterface(string memberName, MemberScanner scanner)
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, scanner, memberName, null);
editInterface.addCommand(new EditInterfaceCommand("Capture Layers", callback => captureState()));
editInterface.addCommand(new EditInterfaceCommand("Preview", callback => apply()));
}
return(editInterface);
}
protected override EditInterface createEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(behaviorTemplate, BehaviorEditMemberScanner.Scanner, Name + " - " + behaviorTemplate.GetType().Name, null);
behaviorTemplate.callCustomizeEditInterface(editInterface);
editInterface.IconReferenceTag = EngineIcons.Behavior;
}
return(editInterface);
}
public override EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, "Setup Scene");
editInterface.addCommand(new EditInterfaceCommand("Capture", callback =>
{
captureSceneState(callback);
fireChangesMade();
}));
}
return(editInterface);
}
public EditInterface getEditInterface(string memberName, MemberScanner scanner)
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, scanner, memberName, null);
editInterface.addCommand(new EditInterfaceCommand("Capture Camera Position", captureCameraPosition));
editInterface.addCommand(new EditInterfaceCommand("Preview", callback =>
{
callback.runOneWayCustomQuery(CustomEditQueries.PreviewCameraPosition, this);
}));
}
return(editInterface);
}
public EditInterface getEditInterface()
{
if (editInterface == null)
{
preActionEdit = new TimelinePreActionEditInterface(timeline);
postActionEdit = new TimelinePostActionEditInterface(timeline);
editInterface = ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, "Timeline", null);
editInterface.addSubInterface(preActionEdit.getEditInterface());
editInterface.addSubInterface(postActionEdit.getEditInterface());
editInterface.addCommand(new EditInterfaceCommand("Reverse Sides", callback => timeline.reverseSides()));
}
return(editInterface);
}
public MaterialController(OgreModelEditorController controller)
{
this.controller = controller;
editInterface = ReflectedEditInterface.createEditInterface(this, "Materials");
editInterface.addCommand(new EditInterfaceCommand("Add", () =>
{
createMaterial("NewMaterial");
}));
var descriptionManager = editInterface.createEditInterfaceManager <MaterialDescription>(i => i.getEditInterface());
descriptionManager.addCommand(new EditInterfaceCommand("Remove", cb =>
{
var desc = descriptionManager.resolveSourceObject(cb.getSelectedEditInterface());
removeMaterial(desc);
}));
}
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createUnscannedEditInterface("Pre Actions", null);
editInterface.addCommand(new EditInterfaceCommand("Add Pre Action", addAction));
var actionManager = editInterface.createEditInterfaceManager <TimelineInstantAction>();
actionManager.addCommand(new EditInterfaceCommand("Remove", removeAction));
foreach (TimelineInstantAction action in timeline.PreActions)
{
preActionAdded(action);
}
}
return(editInterface);
}
/// <summary>
/// Get the EditInterface.
/// </summary>
/// <returns>The EditInterface.</returns>
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, genericSimObjectScanner, name, null);
editInterface.IconReferenceTag = EngineIcons.SimObject;
var elementEditInterfaces = editInterface.createEditInterfaceManager <SimElementDefinition>();
elementEditInterfaces.addCommand(new EditInterfaceCommand("Remove", removeSimElementDefinition));
foreach (SimElementDefinition definition in definitions)
{
createElementInterface(definition);
}
foreach (AddSimElementCommand command in PluginManager.Instance.getCreateSimElementCommands())
{
editInterface.addCommand(new EditInterfaceCommand(command.Name, callback =>
{
callback.getInputString("Enter a name.", delegate(String result, ref String errorPrompt)
{
if (result == null || result == "")
{
errorPrompt = "Please enter a non empty name.";
return(false);
}
foreach (SimElementDefinition definition in definitions)
{
if (definition.Name == result)
{
errorPrompt = "That name is already in use. Please provide another.";
return(false);
}
}
command.execute(result, callback, this);
return(true);
});
}));
}
GenericClipboardEntry clipboardEntry = new GenericClipboardEntry(typeof(SimElementDefinition));
clipboardEntry.PasteFunction = pasteObject;
editInterface.ClipboardEntry = clipboardEntry;
}
return(editInterface);
}
internal EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, Name + " - IK Solver", null);
editInterface.addCommand(new EditInterfaceCommand("Add Child Solver", callback =>
{
addChildSolver(new BEPUikSolverDefinition()
{
Name = "Child"
});
}));
childSolversManager = editInterface.createEditInterfaceManager <BEPUikSolverDefinition>();
childSolversManager.addCommand(new EditInterfaceCommand("Remove", callback =>
{
removeChildSolver(childSolversManager.resolveSourceObject(callback.getSelectedEditInterface()));
}));
foreach (var child in childSolvers)
{
childSolversManager.addSubInterface(child, child.getEditInterface());
}
}
return(editInterface);
}
/// <summary>
/// If you need complete control over edit interface construction override this function.
/// </summary>
protected virtual EditInterface createEditInterface()
{
return(ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, Name, null));
}
public EditInterface createEditInterface()
{
EditInterface editInterface = ReflectedEditInterface.createEditInterface(this, memberScanner, GetType().Name, null);
return(editInterface);
}
/// <summary>
/// This function will fill out the EditInterface with the rest of the
/// properties for this MovableObject.
/// </summary>
/// <param name="editInterface">The EditInterface to fill out.</param>
protected override void setupEditInterface(EditInterface editInterface)
{
ReflectedEditInterface.expandEditInterface(this, memberScanner, editInterface);
editInterface.IconReferenceTag = EngineIcons.Entity;
}
/// <summary>
/// Get the EditInterface for this SimSceneDefinition.
/// </summary>
/// <returns>The EditInterface for this SimSceneDefinition.</returns>
public EditInterface getEditInterface()
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, "Sim Scene", () =>
{
if (hasSimSubSceneDefinitions())
{
if (DefaultSubScene == null)
{
throw new ValidationException("Please specify one of the Subscenes as the default.");
}
if (!hasSimSubSceneDefinition(DefaultSubScene))
{
throw new ValidationException("{0} is not a valid Subscene. Please specify an existing scene.", DefaultSubScene);
}
}
});
editInterface.IconReferenceTag = EngineIcons.Scene;
simElementEditor = new EditInterface("Sim Element Managers");
var elementManagerInterfaces = simElementEditor.createEditInterfaceManager <SimElementManagerDefinition>();
elementManagerInterfaces.addCommand(new EditInterfaceCommand("Destroy", destroySimElementManagerDefinition));
foreach (AddSimElementManagerCommand command in PluginManager.Instance.getCreateSimElementManagerCommands())
{
simElementEditor.addCommand(new EditInterfaceCommand(command.Name, callback =>
{
callback.getInputString("Enter a name.", delegate(String input, ref String errorPrompt)
{
if (input == null || input == "")
{
errorPrompt = "Please enter a non empty name.";
return(false);
}
if (this.hasSimElementManagerDefinition(input))
{
errorPrompt = "That name is already in use. Please provide another.";
return(false);
}
SimElementManagerDefinition def = command.execute(input, callback);
this.addSimElementManagerDefinition(def);
return(true);
});
}));
}
editInterface.addSubInterface(simElementEditor);
subScenes = new EditInterface("Subscenes");
var subSceneInterfaces = subScenes.createEditInterfaceManager <SimSubSceneDefinition>();
subSceneInterfaces.addCommand(new EditInterfaceCommand("Destroy", destroySimSubSceneDefinition));
EditInterfaceCommand createSubSceneCommand = new EditInterfaceCommand("Create Subscene", createSimSubSceneDefinition);
subScenes.addCommand(createSubSceneCommand);
editInterface.addSubInterface(subScenes);
foreach (SimElementManagerDefinition elementDef in elementManagers)
{
createEditInterface(elementDef);
}
foreach (SimSubSceneDefinition subSceneDef in subSceneDefinitions.Values)
{
createEditInterface(subSceneDef);
}
}
return(editInterface);
}
public EditInterface getEditInterface()
{
return(ReflectedEditInterface.createEditInterface(this, ReflectedEditInterface.DefaultScanner, Name, null));
}
