public EditInterfaceEditor(String title, EditInterface editInterface, GuiFrameworkUICallback uiCallback)
: base("Medical.GUI.Editor.RmlWysiwyg.ElementEditorComponents.EditInterfaceEditor.layout", title)
{
propertiesScroll = (ScrollView)widget.findWidget("PropertiesScroll");
propertiesForm = new ScrollingExpandingEditInterfaceViewer(propertiesScroll, uiCallback);
propertiesForm.EditInterface = editInterface;
}
public DebugVisualizer(StandaloneController standaloneController)
: base("Developer.GUI.DebugVisualizer.DebugVisualizer.layout")
{
this.medicalController = standaloneController.MedicalController;
this.pluginManager = medicalController.PluginManager;
standaloneController.SceneLoaded += standaloneController_SceneLoaded;
standaloneController.SceneUnloading += standaloneController_SceneUnloading;
uiCallback = new GuiFrameworkUICallback();
tree = new Tree((ScrollView)window.findWidget("TreeScroller"));
editTreeView = new EditInterfaceTreeView(tree, uiCallback);
propertiesForm = new ScrollablePropertiesForm((ScrollView)window.findWidget("TableScroller"), uiCallback);
objectEditor = new ObjectEditor(editTreeView, propertiesForm, uiCallback);
this.Resized += DebugVisualizer_Resized;
currentScene = standaloneController.MedicalController.CurrentScene;
splitter = new Splitter(window.findWidget("Splitter"));
splitter.Widget1Resized += a => tree.layout();
splitter.Widget2Resized += a => propertiesForm.layout();
}
public RmlWysiwygComponent(RawRmlWysiwygView view, AnomalousMvcContext context, MyGUIViewHost viewHost)
: this(context, viewHost, view)
{
if (view.FakePath != null)
{
this.FakeLoadLocation = RocketInterface.createValidFileUrl(context.ResourceProvider.getFullFilePath(view.FakePath));
}
else
{
this.FakeLoadLocation = RocketInterface.createValidFileUrl(context.ResourceProvider.BackingLocation);
}
this.uiCallback = view.UICallback;
this.undoBuffer = view.UndoBuffer;
this.contentId = view.ContentId;
rocketWidget.Context.ZoomLevel = view.ZoomLevel;
if (view.UndoRedoCallback != null)
{
undoRedoCallback = view.UndoRedoCallback;
}
documentName = null;
setDocumentRml(view.Rml, false);
view._fireComponentCreated(this);
}
private RmlElementEditor openRangeEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
//Find actions
String actionName = element.GetAttribute("onchange").StringValue;
if (String.IsNullOrEmpty(actionName))
{
actionName = Guid.NewGuid().ToString();
element.SetAttribute("onclick", actionName);
}
SlideAction action = slide.getAction(actionName);
if (action == null)
{
action = new BlendSceneAction(actionName);
slide.addAction(action);
}
//Make copy of action, this is really important, a lot of the function of this editor assumes this
//is copied.
SlideAction editingAction = CopySaver.Default.copy(action);
EditInterface editInterface = setupEditInterface(editingAction, slide);
editInterfaceEditor = new EditInterfaceEditor("Blend", editInterface, uiCallback);
//appearanceEditor = new EditInterfaceEditor("Appearance", elementStyle.getEditInterface(), uiCallback);
RmlElementEditor editor = RmlElementEditor.openEditor(element, left, top, this);
editor.addElementEditor(editInterfaceEditor);
return(editor);
}
public PropertiesEditor(String caption, String persistName, bool horizontal)
: base(horizontal ? MDIObjectEditor.HorizontalLayoutName : MDIObjectEditor.VerticalLayoutName, persistName)
{
window.Caption = caption;
uiCallback = new GuiFrameworkUICallback();
tree = new Tree((ScrollView)window.findWidget("TreeScroller"));
editTreeView = new EditInterfaceTreeView(tree, uiCallback);
editTreeView.EditInterfaceSelectionChanged += editTreeView_EditInterfaceSelectionChanged;
editTreeView.EditInterfaceAdded += editTreeView_EditInterfaceAdded;
editTreeView.EditInterfaceRemoved += editTreeView_EditInterfaceRemoved;
addRemoveButtons = new AddRemoveButtons((Button)window.findWidget("Add"), (Button)window.findWidget("Remove"), window.findWidget("AddRemovePanel"));
addRemoveButtons.VisibilityChanged += addRemoveButtons_VisibilityChanged;
tableScroller = (ScrollView)window.findWidget("TableScroller");
table = new ResizingTable(tableScroller);
propTable = new PropertiesTable(table, uiCallback, addRemoveButtons);
propTable.EditablePropertyValueChanged += propTable_EditablePropertyValueChanged;
addRemoveButtons.RemoveButtonClicked += addRemoveButtons_RemoveButtonClicked;
addRemoveButtons.AddButtonClicked += addRemoveButtons_AddButtonClicked;
objectEditor = new ObjectEditor(editTreeView, propTable, uiCallback);
this.Resized += DebugVisualizer_Resized;
gap = tableScroller.Bottom - addRemoveButtons.Top;
splitter = new Splitter(window.findWidget("Splitter"));
splitter.Widget1Resized += split => tree.layout();
splitter.Widget2Resized += split => table.layout();
}
public RmlWysiwygView(String name, GuiFrameworkUICallback uiCallback, UndoRedoBuffer undoBuffer)
: base(name)
{
RmlFile = name + ".rml";
this.UICallback = uiCallback;
this.undoBuffer = undoBuffer;
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
attributeEditor = new ElementAttributeEditor(element, uiCallback);
RmlElementEditor editor = RmlElementEditor.openEditor(element, left, top, this);
editor.addElementEditor(attributeEditor);
return(editor);
}
public GenericEditorView(String name, EditInterface editInterface, GuiFrameworkUICallback editUICallback, EditorController editorController, bool horizontalAlignment = false)
: base(name)
{
this.EditInterface = editInterface;
this.EditUICallback = editUICallback;
this.EditorController = editorController;
this.HorizontalAlignment = horizontalAlignment;
}
public ElementAttributeEditor(Element element, GuiFrameworkUICallback uiCallback)
: base("Medical.GUI.Editor.RmlWysiwyg.ElementEditorComponents.ElementAttributeEditor.layout", "Attributes")
{
propertiesScroll = (ScrollView)widget.findWidget("PropertiesScroll");
propertiesForm = new ScrollablePropertiesForm(propertiesScroll, uiCallback);
originalProperties = new List <RmlEditableProperty>(element.NumAttributes);
EditInterface editInterface = new EditInterface(element.TagName);
int index = 0;
String name;
String value;
RmlEditableProperty.CreateBrowser createBrowserCallback = null;
while (element.IterateAttributes(ref index, out name, out value))
{
createBrowserCallback = null;
RmlEditableProperty property;
switch (name.ToLowerInvariant())
{
case "onclick":
if (uiCallback.hasCustomQuery(CustomQueries.BuildActionBrowser))
{
createBrowserCallback = callback => uiCallback.runSyncCustomQuery <Browser>(CustomQueries.BuildActionBrowser);
}
property = new RmlEditableProperty(name, value, createBrowserCallback);
break;
case "src":
if (element.TagName == "img")
{
if (uiCallback.hasCustomQuery(CustomQueries.BuildFileBrowser))
{
createBrowserCallback = callback => uiCallback.runSyncCustomQuery <Browser, IEnumerable <String>, String, String>(CustomQueries.BuildFileBrowser, new String[] { "*.png", "*.jpg", "*jpeg", "*.gif", "*.bmp" }, "Images", "/");
}
property = new RmlEditableProperty(name, value, createBrowserCallback);
}
else
{
property = new RmlEditableProperty(name, value);
}
break;
default:
property = new RmlEditableProperty(name, value);
break;
}
property.ValueChanged += sender =>
{
fireChangesMade();
fireApplyChanges();
};
editInterface.addEditableProperty(property);
originalProperties.Add(property);
}
propertiesForm.EditInterface = editInterface;
}
public OffsetSequenceEditorView(String name, GuiFrameworkUICallback uiCallback, SimObjectMover simObjectMover, OffsetModifierSequence sequence = null)
: base(name)
{
ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Bottom)
{
AllowedDockLocations = DockLocation.Top | DockLocation.Bottom | DockLocation.Floating
};
Sequence = sequence;
UICallback = uiCallback;
SimObjectMover = simObjectMover;
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
switch (element.GetAttributeString("type"))
{
case "range":
return(openRangeEditor(element, uiCallback, left, top));
default:
return(null);
}
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
bool hasFullscreen = element.HasAttribute("onclick");
appearance = new ImageElementStyle(element);
appearance.Changed += appearance_Changed;
appearanceEditor = new EditInterfaceEditor("Appearance", appearance.getEditInterface(), uiCallback);
slideImageEditor = new SlideImageComponent(editorResourceProvider, subdirectory, element.GetAttributeString("src"), hasFullscreen);
RmlElementEditor editor = RmlElementEditor.openEditor(element, left, top, this);
editor.addElementEditor(slideImageEditor);
editor.addElementEditor(appearanceEditor);
return(editor);
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
elementStyle = new TextElementStyle(element, true);
elementStyle.Changed += elementStyle_Changed;
String rml = DecodeFromHtml(element.InnerRml);
textEditor = new ElementTextEditor(rml);
appearanceEditor = new EditInterfaceEditor("Appearance", elementStyle.getEditInterface(), uiCallback);
RmlElementEditor editor = RmlElementEditor.openEditor(element, left, top, this);
editor.addElementEditor(textEditor);
editor.addElementEditor(appearanceEditor);
return(editor);
}
public ScratchArea(ScratchAreaController scratchAreaController, GuiFrameworkUICallback uiCallback)
: base("Medical.GUI.ScratchArea.ScratchArea.layout")
{
this.scratchAreaController = scratchAreaController;
this.uiCallback = uiCallback;
uiCallback.addCustomQuery <SaveableClipboard>(ScratchAreaCustomQueries.GetClipboard, getClipboardCallback);
tree = new Tree((ScrollView)window.findWidget("TableScroll"));
editTreeView = new EditInterfaceTreeView(tree, uiCallback);
editTreeView.EditInterface = scratchAreaController.EditInterface;
editTreeView.EditInterfaceSelectionChanged += editTreeView_EditInterfaceSelectionChanged;
this.Resized += new EventHandler(ScratchArea_Resized);
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
elementStyle = new TextElementStyle(element, true);
elementStyle.Changed += elementStyle_Changed;
appearanceEditor = new EditInterfaceEditor("Appearance", elementStyle.getEditInterface(), uiCallback);
dataElementEditor = new DataElementEditor(element);
EditInterface editInterface = dataElementEditor.EditInterface;
editInterfaceEditor = new EditInterfaceEditor("Data Display Properties", editInterface, uiCallback);
dataElementEditor.EditInterfaceEditor = editInterfaceEditor;
RmlElementEditor editor = RmlElementEditor.openEditor(element, left, top, this);
editor.addElementEditor(editInterfaceEditor);
editor.addElementEditor(appearanceEditor);
return(editor);
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
RmlElementEditor editor = RmlElementEditor.openEditor(element, left, top, this);
switch (element.GetAttributeString("type"))
{
case "range":
attributeEditor = new ElementAttributeEditor(element, uiCallback);
editor.addElementEditor(attributeEditor);
break;
default:
textEditor = new ElementTextEditor(element.InnerRml);
attributeEditor = new ElementAttributeEditor(element, uiCallback);
editor.addElementEditor(textEditor);
editor.addElementEditor(attributeEditor);
break;
}
return(editor);
}
public DebugVisualizer(PluginManager pluginManager, SceneController sceneController)
: base("Anomaly.GUI.DebugVisualizer.DebugVisualizer.layout")
{
this.pluginManager = pluginManager;
this.sceneController = sceneController;
uiCallback = new GuiFrameworkUICallback();
tree = new Tree((ScrollView)window.findWidget("TreeScroller"));
editTreeView = new EditInterfaceTreeView(tree, uiCallback);
propertiesForm = new ScrollablePropertiesForm((ScrollView)window.findWidget("TableScroller"), uiCallback);
objectEditor = new ObjectEditor(editTreeView, propertiesForm, uiCallback);
this.Resized += DebugVisualizer_Resized;
currentScene = sceneController.CurrentScene;
splitter = new Splitter(window.findWidget("Splitter"));
splitter.Widget1Resized += a => tree.layout();
splitter.Widget2Resized += a => propertiesForm.layout();
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
elementStyle = new TextElementStyle(element, false);
elementStyle.Changed += elementStyle_Changed;
String rml = TextElementStrategy.DecodeFromHtml(element.InnerRml);
textEditor = new ElementTextEditor(rml);
String actionName = element.GetAttribute("onclick").StringValue;
if (String.IsNullOrEmpty(actionName))
{
actionName = Guid.NewGuid().ToString();
element.SetAttribute("onclick", actionName);
}
SlideAction action = slide.getAction(actionName);
if (action == null)
{
action = ((Func <String, SlideAction>)actionTypeBrowser.DefaultSelection.Value)(actionName);
slide.addAction(action);
}
//Make copy of action, this is really important, a lot of the function of this editor assumes this
//is copied.
SlideAction editingAction = CopySaver.Default.copy(action);
EditInterface editInterface = setupEditInterface(editingAction, slide);
actionEditor = new EditInterfaceEditor("Action", editInterface, uiCallback);
appearanceEditor = new EditInterfaceEditor("Appearance", elementStyle.getEditInterface(), uiCallback);
RmlElementEditor editor = RmlElementEditor.openEditor(element, left, top, this);
editor.addElementEditor(textEditor);
editor.addElementEditor(actionEditor);
editor.addElementEditor(appearanceEditor);
return(editor);
}
public OffsetSequenceEditorContext(OffsetModifierSequence movementSequence, String file, OffsetSequenceTypeController typeController, GuiFrameworkUICallback uiCallback, SimObjectMover simObjectMover)
{
this.typeController = typeController;
this.currentFile = file;
this.movementSequence = movementSequence;
this.simObjectMover = simObjectMover;
simObjectMover.ShowMoveTools = true;
simObjectMover.ShowRotateTools = false;
mvcContext = new AnomalousMvcContext();
mvcContext.StartupAction = "Common/Start";
mvcContext.FocusAction = "Common/Focus";
mvcContext.BlurAction = "Common/Blur";
mvcContext.SuspendAction = "Common/Suspended";
mvcContext.ResumeAction = "Common/Resumed";
mvcContext.Models.add(new EditMenuManager());
OffsetSequenceEditorView offsetSequenceView = new OffsetSequenceEditorView("SequenceEditor", uiCallback, simObjectMover, movementSequence);
offsetSequenceView.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Bottom);
mvcContext.Views.add(offsetSequenceView);
EditorTaskbarView taskbar = new EditorTaskbarView("InfoBar", currentFile, "Editor/Close");
taskbar.addTask(new CallbackTask("SaveAll", "Save All", "Editor/SaveAllIcon", "", 0, true, item =>
{
saveAll();
}));
taskbar.addTask(new RunMvcContextActionTask("Save", "Save Movement Sequence File", "CommonToolstrip/Save", "File", "Editor/Save", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Cut", "Cut", "Editor/CutIcon", "", "Editor/Cut", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Copy", "Copy", "Editor/CopyIcon", "", "Editor/Copy", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Paste", "Paste", "Editor/PasteIcon", "", "Editor/Paste", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("SelectAll", "Select All", "Editor/SelectAllIcon", "", "Editor/SelectAll", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Translation", "Translation", "Editor/TranslateIcon", "", "Editor/Translation", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Rotation", "Rotation", "Editor/RotateIcon", "", "Editor/Rotation", mvcContext));
mvcContext.Views.add(taskbar);
mvcContext.Controllers.add(new MvcController("Editor",
new RunCommandsAction("Show",
new ShowViewCommand("SequenceEditor"),
new ShowViewCommand("InfoBar")),
new RunCommandsAction("Close", new CloseAllViewsCommand()),
new CallbackAction("Save", context =>
{
save();
}),
new CutAction(),
new CopyAction(),
new PasteAction(),
new SelectAllAction(),
new CallbackAction("Translation", context =>
{
this.simObjectMover.ShowMoveTools = true;
this.simObjectMover.ShowRotateTools = false;
}),
new CallbackAction("Rotation", context =>
{
this.simObjectMover.ShowMoveTools = false;
this.simObjectMover.ShowRotateTools = true;
})));
mvcContext.Controllers.add(new MvcController("Common",
new RunCommandsAction("Start", new RunActionCommand("Editor/Show")),
new CallbackAction("Focus", context =>
{
GlobalContextEventHandler.setEventContext(eventContext);
if (Focus != null)
{
Focus.Invoke(this);
}
}),
new CallbackAction("Blur", context =>
{
GlobalContextEventHandler.disableEventContext(eventContext);
if (Blur != null)
{
Blur.Invoke(this);
}
}),
new RunCommandsAction("Suspended", new SaveViewLayoutCommand()),
new RunCommandsAction("Resumed", new RestoreViewLayoutCommand())));
eventContext = new EventContext();
ButtonEvent saveEvent = new ButtonEvent(EventLayers.Gui);
saveEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
saveEvent.addButton(KeyboardButtonCode.KC_S);
saveEvent.FirstFrameUpEvent += eventManager =>
{
saveAll();
};
eventContext.addEvent(saveEvent);
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("Editor/Cut");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_X }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("Editor/Copy");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_C }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("Editor/Paste");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_V }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("Editor/SelectAll");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_A }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("Editor/Translation");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_T }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("Editor/Rotation");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_R }));
}
public TimelineEditorContext(Timeline timeline, String path, TimelineTypeController timelineTypeController, PropEditController propEditController, PropFactory propFactory, EditorController editorController, GuiFrameworkUICallback uiCallback, TimelineController timelineController)
{
this.currentTimeline = timeline;
this.currentFile = path;
this.timelineTypeController = timelineTypeController;
this.propEditController = propEditController;
mvcContext = new AnomalousMvcContext();
mvcContext.StartupAction = "Common/Start";
mvcContext.FocusAction = "Common/Focus";
mvcContext.BlurAction = "Common/Blur";
mvcContext.SuspendAction = "Common/Suspended";
mvcContext.ResumeAction = "Common/Resumed";
mvcContext.Models.add(new EditMenuManager());
mvcContext.Models.add(new EditInterfaceHandler());
mvcContext.Views.add(new TimelineEditorView("TimelineEditor", currentTimeline, timelineController, editorController, propEditController));
ExpandingGenericEditorView genericEditor = new ExpandingGenericEditorView("TimelinePropertiesEditor", currentTimeline.getEditInterface(), editorController, uiCallback);
genericEditor.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Left);
mvcContext.Views.add(genericEditor);
PropTimelineView propTimelineView = new PropTimelineView("PropTimeline", propEditController, propFactory);
propTimelineView.Buttons.add(new CloseButtonDefinition("Close", "PropTimeline/Close"));
mvcContext.Views.add(propTimelineView);
OpenPropManagerView propManagerView = new OpenPropManagerView("PropManager", propEditController);
propManagerView.Buttons.add(new CloseButtonDefinition("Close", "PropManager/Close"));
mvcContext.Views.add(propManagerView);
MovementSequenceEditorView movementSequenceEditor = new MovementSequenceEditorView("MovementSequenceEditor", listenForSequenceChanges: true);
movementSequenceEditor.Buttons.add(new CloseButtonDefinition("Close", "MovementSequenceEditor/Close"));
movementSequenceEditor.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Top);
mvcContext.Views.add(movementSequenceEditor);
EditorTaskbarView taskbar = new EditorTaskbarView("TimelineInfoBar", currentFile, "TimelineEditor/Close");
taskbar.addTask(new CallbackTask("SaveAll", "Save All", "Editor/SaveAllIcon", "", 0, true, item =>
{
saveAll();
}));
taskbar.addTask(new RunMvcContextActionTask("Save", "Save Timeline", "CommonToolstrip/Save", "", "TimelineEditor/Save", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Cut", "Cut", "Editor/CutIcon", "", "TimelineEditor/Cut", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Copy", "Copy", "Editor/CopyIcon", "", "TimelineEditor/Copy", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Paste", "Paste", "Editor/PasteIcon", "", "TimelineEditor/Paste", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("SelectAll", "Select All", "Editor/SelectAllIcon", "", "TimelineEditor/SelectAll", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Translation", "Translation", "Editor/TranslateIcon", "", "TimelineEditor/Translation", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Rotation", "Rotation", "Editor/RotateIcon", "", "TimelineEditor/Rotation", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("PropTimeline", "Prop Timeline Editor", "Editor/PropTimelineEditorIcon", "", "PropTimeline/ShowIfNotOpen", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("PropManager", "Open Prop Manager", "Editor/PropManagerIcon", "", "PropManager/ShowIfNotOpen", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("MovementSequenceEditor", "Movement Sequence Editor", "Editor/MovementSequenceEditorIcon", "", "MovementSequenceEditor/ShowIfNotOpen", mvcContext));
mvcContext.Views.add(taskbar);
mvcContext.Controllers.add(new MvcController("TimelineEditor",
new RunCommandsAction("Show",
new ShowViewCommand("TimelineEditor"),
new ShowViewCommand("TimelinePropertiesEditor"),
new ShowViewCommand("TimelineInfoBar")
),
new RunCommandsAction("Close",
new CloseAllViewsCommand()),
new CallbackAction("Save", context =>
{
timelineTypeController.saveTimeline(currentTimeline, currentFile);
}),
new CutAction(),
new CopyAction(),
new PasteAction(),
new SelectAllAction(),
new CallbackAction("Translation", context =>
{
propEditController.setMoveMode();
}),
new CallbackAction("Rotation", context =>
{
propEditController.setRotateMode();
})
));
mvcContext.Controllers.add(new MvcController("PropTimeline",
new RunCommandsAction("ShowIfNotOpen",
new ShowViewIfNotOpenCommand("PropTimeline")
),
new RunCommandsAction("Close",
new CloseViewCommand())));
mvcContext.Controllers.add(new MvcController("PropManager",
new RunCommandsAction("ShowIfNotOpen",
new ShowViewIfNotOpenCommand("PropManager")),
new RunCommandsAction("Close",
new CloseViewCommand())));
mvcContext.Controllers.add(new MvcController("MovementSequenceEditor",
new RunCommandsAction("ShowIfNotOpen",
new ShowViewIfNotOpenCommand("MovementSequenceEditor")
),
new RunCommandsAction("Close",
new CloseViewCommand())));
mvcContext.Controllers.add(new MvcController("Common",
new RunCommandsAction("Start", new RunActionCommand("TimelineEditor/Show")),
new CallbackAction("Focus", context =>
{
GlobalContextEventHandler.setEventContext(eventContext);
if (Focus != null)
{
Focus.Invoke(this);
}
}),
new CallbackAction("Blur", context =>
{
GlobalContextEventHandler.disableEventContext(eventContext);
propEditController.removeAllOpenProps();
if (Blur != null)
{
Blur.Invoke(this);
}
}),
new RunCommandsAction("Suspended", new SaveViewLayoutCommand()),
new RunCommandsAction("Resumed", new RestoreViewLayoutCommand())));
eventContext = new EventContext();
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
saveAll();
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_S }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
if (timeline.TimelineController.Playing)
{
timeline.TimelineController.stopPlayback();
}
else
{
timeline.TimelineController.startPlayback(timeline, propEditController.MarkerPosition, false);
}
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_SPACE }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("TimelineEditor/Cut");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_X }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("TimelineEditor/Copy");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_C }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("TimelineEditor/Paste");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_V }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("TimelineEditor/SelectAll");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_A }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("TimelineEditor/Translation");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_T }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: eventManager =>
{
mvcContext.runAction("TimelineEditor/Rotation");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_R }));
eventContext.addEvent(new ButtonEvent(EventLayers.Gui,
frameUp: EventManager =>
{
mvcContext.runAction("PropTimeline/ShowIfNotOpen");
},
keys: new KeyboardButtonCode[] { KeyboardButtonCode.KC_LCONTROL, KeyboardButtonCode.KC_P }));
}
public override RmlElementEditor openEditor(Element element, GuiFrameworkUICallback uiCallback, int left, int top)
{
return(null);
}
public OffsetKeyframeProperties(Widget parentWidget, OffsetSequenceEditor sequenceEditor, GuiFrameworkUICallback uiCallback)
: base(parentWidget, "Medical.GUI.OffsetSequence.OffsetKeyframeProperties.layout")
{
this.sequenceEditor = sequenceEditor;
propertiesForm = new PropertiesForm(mainWidget, uiCallback);
}
public DependencyEditorContext(DDAtlasDependency plugin, String file, DependencyTypeController dependencyTypeController, EditorController editorController, GuiFrameworkUICallback uiCallback)
{
this.dependencyTypeController = dependencyTypeController;
this.currentFile = file;
this.plugin = plugin;
mvcContext = new AnomalousMvcContext();
mvcContext.StartupAction = "Common/Start";
mvcContext.FocusAction = "Common/Focus";
mvcContext.BlurAction = "Common/Blur";
mvcContext.SuspendAction = "Common/Suspended";
mvcContext.ResumeAction = "Common/Resumed";
mvcContext.Models.add(new EditMenuManager());
GenericPropertiesFormView genericPropertiesView = new GenericPropertiesFormView("MvcContext", plugin.EditInterface, editorController, uiCallback, true);
genericPropertiesView.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Left);
mvcContext.Views.add(genericPropertiesView);
EditorTaskbarView taskbar = new EditorTaskbarView("InfoBar", currentFile, "Editor/Close");
taskbar.addTask(new CallbackTask("SaveAll", "Save All", "Editor/SaveAllIcon", "", 0, true, item =>
{
saveAll();
}));
taskbar.addTask(new RunMvcContextActionTask("Save", "Save Dependency Definition File", "CommonToolstrip/Save", "File", "Editor/Save", mvcContext));
mvcContext.Views.add(taskbar);
mvcContext.Controllers.add(new MvcController("Editor",
new RunCommandsAction("Show",
new ShowViewCommand("MvcContext"),
new ShowViewCommand("InfoBar")),
new RunCommandsAction("Close", new CloseAllViewsCommand()),
new CallbackAction("Save", context =>
{
save();
})));
mvcContext.Controllers.add(new MvcController("Common",
new RunCommandsAction("Start", new RunActionCommand("Editor/Show")),
new CallbackAction("Focus", context =>
{
GlobalContextEventHandler.setEventContext(eventContext);
if (Focus != null)
{
Focus.Invoke(this);
}
}),
new CallbackAction("Blur", context =>
{
GlobalContextEventHandler.disableEventContext(eventContext);
if (Blur != null)
{
Blur.Invoke(this);
}
}),
new RunCommandsAction("Suspended", new SaveViewLayoutCommand()),
new RunCommandsAction("Resumed", new RestoreViewLayoutCommand())));
eventContext = new EventContext();
ButtonEvent saveEvent = new ButtonEvent(EventLayers.Gui);
saveEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
saveEvent.addButton(KeyboardButtonCode.KC_S);
saveEvent.FirstFrameUpEvent += eventManager =>
{
saveAll();
};
eventContext.addEvent(saveEvent);
}
