public TypeControllerManager(StandaloneController standaloneController, EditorPlugin plugin)
{
this.standaloneController = standaloneController;
propEditController = plugin.PropEditController;
EditorController editorController = plugin.EditorController;
editorController.ProjectChanged += editorController_ProjectChanged;
editorController.ResourceProviderClosing += editorController_ResourceProviderClosing;
editorController.ResourceProviderOpened += editorController_ResourceProviderOpened;
//MVC Type Controller
MvcTypeController mvcTypeController = new MvcTypeController(editorController);
mvcTypeController.OpenEditor += (file, editingMvcContex) =>
{
mvcEditorContext = new MvcEditorContext(editingMvcContex, file, mvcTypeController, plugin.EditorController, plugin.UICallback);
plugin.UICallback.CurrentEditingMvcContext = editingMvcContex;
if (standaloneController.SharePluginController != null)
{
CallbackTask cleanupBeforeShareTask = new CallbackTask("Lecture.SharePluginTask", standaloneController.SharePluginController.Name, standaloneController.SharePluginController.IconName, standaloneController.SharePluginController.Category, 0, false, (item) =>
{
MessageBox.show("Before sharing your Editor Project it will be saved. Do you wish to continue?", "Share Editor Project", MessageBoxStyle.IconQuest | MessageBoxStyle.Yes | MessageBoxStyle.No, (result) =>
{
if (result == MessageBoxStyle.Yes)
{
editorController.saveAllCachedResources();
standaloneController.SharePluginController.sharePlugin(editorController.ResourceProvider.BackingProvider, PluginCreationTool.EditorTools);
}
});
});
mvcEditorContext.addTask(cleanupBeforeShareTask);
}
mvcEditorContext.Focused += (obj) =>
{
mvcEditorContext = obj;
};
mvcEditorContext.Blured += (obj) =>
{
if (mvcEditorContext == obj)
{
mvcEditorContext = null;
}
};
editorController.runEditorContext(mvcEditorContext.MvcContext);
};
//Rml type controller
RmlTypeController rmlTypeController = new RmlTypeController(editorController);
rmlTypeController.OpenEditor += (file) =>
{
rmlEditorContext = new RmlEditorContext(file, rmlTypeController, mvcTypeController.CurrentObject, plugin.EditorController, plugin.UICallback);
rmlEditorContext.Focus += (obj) =>
{
rmlEditorContext = obj;
};
rmlEditorContext.Blur += obj =>
{
rmlTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (rmlEditorContext == obj)
{
rmlEditorContext = null;
}
};
editorController.runEditorContext(rmlEditorContext.MvcContext);
};
//Rcss Type Controller
RcssTypeController rcssTypeController = new RcssTypeController(editorController);
rcssTypeController.OpenEditor += (file) =>
{
rcssEditorContext = new RcssEditorContext(file, rmlTypeController.LastRmlFile, rcssTypeController);
rcssEditorContext.Focus += (obj) =>
{
rcssEditorContext = obj;
};
rcssEditorContext.Blur += (obj) =>
{
rcssTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (rcssEditorContext == obj)
{
rcssEditorContext = null;
}
};
editorController.runEditorContext(rcssEditorContext.MvcContext);
};
//Plugin type controller
PluginTypeController pluginTypeController = new PluginTypeController(editorController);
pluginTypeController.OpenEditor += (file, ddPlugin) =>
{
pluginEditorContext = new PluginEditorContext(ddPlugin, file, pluginTypeController, plugin.EditorController, plugin.UICallback, standaloneController);
pluginEditorContext.Focus += obj =>
{
pluginEditorContext = obj;
};
pluginEditorContext.Blur += obj =>
{
if (pluginEditorContext == obj)
{
pluginEditorContext = null;
}
};
editorController.runEditorContext(pluginEditorContext.MvcContext);
};
//Dependency type controller
DependencyTypeController dependencyTypeController = new DependencyTypeController(editorController);
dependencyTypeController.OpenEditor += (file, ddDep) =>
{
dependencyEditorContext = new DependencyEditorContext(ddDep, file, dependencyTypeController, plugin.EditorController, plugin.UICallback);
dependencyEditorContext.Focus += obj =>
{
dependencyEditorContext = obj;
};
dependencyEditorContext.Blur += obj =>
{
if (dependencyEditorContext == obj)
{
dependencyEditorContext = null;
}
};
editorController.runEditorContext(dependencyEditorContext.MvcContext);
};
//Movement Sequence type controller
MovementSequenceTypeController movementSequenceTypeController = new MovementSequenceTypeController(editorController);
movementSequenceTypeController.OpenEditor += (file, movementSequence) =>
{
movementSequenceEditorContext = new MovementSequenceEditorContext(movementSequence, file, movementSequenceTypeController);
movementSequenceEditorContext.Focus += obj =>
{
movementSequenceEditorContext = obj;
};
movementSequenceEditorContext.Blur += obj =>
{
if (movementSequenceEditorContext == obj)
{
movementSequenceEditorContext = null;
}
};
editorController.runEditorContext(movementSequenceEditorContext.MvcContext);
};
//Movement Sequence type controller
OffsetSequenceTypeController offsetSequenceTypeController = new OffsetSequenceTypeController(editorController);
offsetSequenceTypeController.OpenEditor += (file, movementSequence) =>
{
offsetSequenceEditorContext = new OffsetSequenceEditorContext(movementSequence, file, offsetSequenceTypeController, plugin.UICallback, plugin.SimObjectMover);
offsetSequenceEditorContext.Focus += obj =>
{
offsetSequenceEditorContext = obj;
};
offsetSequenceEditorContext.Blur += obj =>
{
if (offsetSequenceEditorContext == obj)
{
offsetSequenceEditorContext = null;
}
};
editorController.runEditorContext(offsetSequenceEditorContext.MvcContext);
};
//TRML Type controller
TRmlTypeController trmlTypeController = new TRmlTypeController(editorController);
trmlTypeController.OpenEditor += (file) =>
{
trmlEditorContext = new TRmlEditorContext(file, rmlTypeController.LastRmlFile, trmlTypeController);
trmlEditorContext.Focus += obj =>
{
trmlEditorContext = obj;
};
trmlEditorContext.Blur += obj =>
{
trmlTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (trmlEditorContext == obj)
{
trmlEditorContext = null;
}
};
editorController.runEditorContext(trmlEditorContext.MvcContext);
};
//Timeline type controller
TimelineTypeController timelineTypeController = new TimelineTypeController(editorController);
timelineTypeController.OpenEditor += (file, timeline) =>
{
propEditController.removeAllOpenProps();
timelineEditorContext = new TimelineEditorContext(timeline, file, timelineTypeController, propEditController, standaloneController.PropFactory, plugin.EditorController, plugin.UICallback, plugin.TimelineController);
timelineEditorContext.Focus += obj =>
{
timelineEditorContext = obj;
};
timelineEditorContext.Blur += obj =>
{
if (obj == timelineEditorContext)
{
timelineEditorContext = null;
}
};
editorController.runEditorContext(timelineEditorContext.MvcContext);
};
//Xml Type Controller
XmlTypeController xmlTypeController = new XmlTypeController(editorController);
xmlTypeController.OpenEditor += (file) =>
{
xmlEditorContext = new XmlEditorContext(file, rmlTypeController.LastRmlFile, xmlTypeController);
xmlEditorContext.Focus += (obj) =>
{
xmlEditorContext = obj;
};
xmlEditorContext.Blur += (obj) =>
{
xmlTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (xmlEditorContext == obj)
{
xmlEditorContext = null;
}
};
editorController.runEditorContext(xmlEditorContext.MvcContext);
};
//Prop type controller
PropTypeController propTypeController = new PropTypeController(editorController);
propTypeController.OpenEditor += (file, propDefinition) =>
{
propEditorContext = new PropEditorContext(propDefinition, file, propTypeController, plugin.EditorController, plugin.UICallback);
propEditorContext.Focus += obj =>
{
propEditorContext = obj;
};
propEditorContext.Blur += obj =>
{
if (propEditorContext == obj)
{
propEditorContext = null;
}
};
editorController.runEditorContext(propEditorContext.MvcContext);
};
//Add item templates
editorController.addItemTemplate(new EmptyViewItemTemplate(rmlTypeController, mvcTypeController));
editorController.addItemTemplate(new ViewWithTimelineItemTemplate(rmlTypeController, mvcTypeController, timelineTypeController));
//Add type controllers to editor controller, this also adds some item templates
editorController.addTypeController(timelineTypeController);
editorController.addTypeController(movementSequenceTypeController);
editorController.addTypeController(offsetSequenceTypeController);
editorController.addTypeController(rmlTypeController);
editorController.addTypeController(trmlTypeController);
editorController.addTypeController(rcssTypeController);
editorController.addTypeController(mvcTypeController);
editorController.addTypeController(pluginTypeController);
editorController.addTypeController(dependencyTypeController);
editorController.addTypeController(xmlTypeController);
editorController.addTypeController(propTypeController);
//Add any final item templates
editorController.addItemTemplate(new PluginBrandingResourceItemTemplate());
}
public XmlEditorContext(String file, String rmlPreviewFile, XmlTypeController typeController)
{
this.typeController = typeController;
this.currentFile = file;
this.rmlPreviewFile = rmlPreviewFile;
mvcContext = new AnomalousMvcContext();
mvcContext.StartupAction = "Common/Start";
mvcContext.FocusAction = "Common/Focus";
mvcContext.BlurAction = "Common/Blur";
mvcContext.SuspendAction = "Common/Suspended";
mvcContext.ResumeAction = "Common/Resumed";
TextEditorView textEditorView = new TextEditorView("RmlEditor", () => this.typeController.loadText(currentFile), wordWrap: false, textHighlighter: XmlTextHighlighter.Instance);
textEditorView.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Left);
textEditorView.ComponentCreated += (view, component) =>
{
textEditorComponent = component;
};
mvcContext.Views.add(textEditorView);
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 Rml File", "CommonToolstrip/Save", "File", "Editor/Save", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Cut", "Cut", "Editor/CutIcon", "Edit", "Editor/Cut", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Copy", "Copy", "Editor/CopyIcon", "Edit", "Editor/Copy", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("Paste", "Paste", "Editor/PasteIcon", "Edit", "Editor/Paste", mvcContext));
taskbar.addTask(new RunMvcContextActionTask("SelectAll", "Select All", "Editor/SelectAllIcon", "Edit", "Editor/SelectAll", mvcContext));
mvcContext.Views.add(taskbar);
mvcContext.Controllers.add(new MvcController("Editor",
new RunCommandsAction("Show",
new ShowViewCommand("RmlEditor"),
new ShowViewCommand("InfoBar")),
new RunCommandsAction("Close", new CloseAllViewsCommand()),
new CallbackAction("Save", context =>
{
save();
}),
new CallbackAction("Cut", context =>
{
textEditorComponent.cut();
}),
new CallbackAction("Copy", context =>
{
textEditorComponent.copy();
}),
new CallbackAction("Paste", context =>
{
textEditorComponent.paste();
}),
new CallbackAction("SelectAll", context =>
{
textEditorComponent.selectAll();
})));
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);
}