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());
        }
Ejemplo n.º 2
0
        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);
        }