public SlideshowEditController(StandaloneController standaloneController, LectureUICallback uiCallback, PropEditController propEditController, EditorController editorController, TimelineController timelineController)
        {
            this.standaloneController        = standaloneController;
            this.uiCallback                  = uiCallback;
            this.propEditController          = propEditController;
            this.editorController            = editorController;
            this.timelineController          = timelineController;
            editorController.ProjectChanged += editorController_ProjectChanged;
            slideImageManager                = new SlideImageManager(this);
            this.AllowSlideSceneSetup        = true;

            //Show Type Controller
            showTypeController = new ShowTypeController(editorController);
            editorController.addTypeController(showTypeController);
            timelineTypeController = new TimelineTypeController(editorController);
            editorController.addTypeController(timelineTypeController);

            medicalSlideTemplate = new MedicalSlideItemTemplate(standaloneController.SceneViewController, standaloneController.MedicalStateController);
            medicalSlideTemplate.SlideCreated += (slide) =>
            {
                if (lastEditSlide != null)
                {
                    int insertIndex = slideshow.indexOf(lastEditSlide);
                    if (insertIndex != -1)
                    {
                        ++insertIndex;
                    }
                    addSlide(slide, insertIndex);
                }
                else
                {
                    addSlide(slide);
                }
            };
            editorController.addItemTemplate(medicalSlideTemplate);
        }
        public SlideEditorContext(Slide slide, String slideName, SlideshowEditController editorController, StandaloneController standaloneController, LectureUICallback uiCallback, UndoRedoBuffer undoBuffer, MedicalSlideItemTemplate itemTemplate, bool autoSetupScene, Action <String, String> wysiwygUndoCallback)
        {
            this.slide      = slide;
            this.uiCallback = uiCallback;
            if (uiCallback.hasCustomQuery(PlayTimelineAction.CustomActions.EditTimeline))
            {
                uiCallback.removeCustomQuery(PlayTimelineAction.CustomActions.EditTimeline);
            }
            uiCallback.addOneWayCustomQuery(PlayTimelineAction.CustomActions.EditTimeline, new Action <PlayTimelineAction>(action_EditTimeline));
            this.slideEditorController          = editorController;
            this.undoBuffer                     = undoBuffer;
            this.imageRenderer                  = standaloneController.ImageRenderer;
            this.itemTemplate                   = itemTemplate;
            this.wysiwygUndoCallback            = wysiwygUndoCallback;
            this.editorController               = editorController;
            this.layerController                = standaloneController.LayerController;
            this.sceneViewController            = standaloneController.SceneViewController;
            panelResizeWidget                   = new PanelResizeWidget();
            panelResizeWidget.RecordResizeUndo += panelResizeWidget_RecordResizeUndo;

            displayManager = new SlideDisplayManager(editorController.VectorMode);

            RunCommandsAction previewTriggerAction = new RunCommandsAction("PreviewTrigger");

            imageStrategy       = new SlideImageStrategy(slide, undoBuffer, this.slideEditorController.ResourceProvider, slide.UniqueName);
            linkTriggerStrategy = new SlideTriggerStrategy(slide, createTriggerActionBrowser(), undoBuffer, "a", "TriggerLink", "Lecture.Icon.TriggerIcon", standaloneController.NotificationManager, previewTriggerAction);
            linkTriggerStrategy.PreviewTrigger += triggerStrategy_PreviewTrigger;
            buttonTriggerStragegy = new SlideTriggerStrategy(slide, createTriggerActionBrowser(), undoBuffer, "button", "Trigger", "Lecture.Icon.TriggerIcon", standaloneController.NotificationManager, previewTriggerAction);
            buttonTriggerStragegy.PreviewTrigger += triggerStrategy_PreviewTrigger;
            inputStrategy = new SlideInputStrategy(slide, undoBuffer, standaloneController.NotificationManager, previewTriggerAction, "input", CommonResources.NoIcon);
            inputStrategy.PreviewTrigger += triggerStrategy_PreviewTrigger;

            mvcContext = new AnomalousMvcContext();
            mvcContext.StartupAction = "Common/Start";
            mvcContext.FocusAction   = "Common/Focus";
            mvcContext.BlurAction    = "Common/Blur";
            mvcContext.SuspendAction = "Common/Suspended";
            mvcContext.ResumeAction  = "Common/Resumed";

            showEditorWindowsCommand  = new RunCommandsAction("ShowEditors");
            closeEditorWindowsCommand = new RunCommandsAction("CloseEditors");

            RunCommandsAction showCommand = new RunCommandsAction("Show",
                                                                  new ShowViewCommand("InfoBar"),
                                                                  new RunActionCommand("Editor/SetupScene"),
                                                                  new RunActionCommand("Editor/ShowEditors")
                                                                  );

            refreshPanelEditors(false);

            htmlDragDrop = new DragAndDropTaskManager <WysiwygDragDropItem>(
                new WysiwygDragDropItem("Heading", "Editor/HeaderIcon", "<h1>Add Heading Here</h1>"),
                new WysiwygDragDropItem("Paragraph", "Editor/ParagraphsIcon", "<p>Add paragraph text here.</p>"),
                new WysiwygCallbackDragDropItem("Image", "Editor/ImageIcon", String.Format("<img src=\"{0}\" class=\"Center\" style=\"width:80%;\"></img>", RmlWysiwygComponent.DefaultImage),
                                                () => //Markup Callback
            {
                String actionName           = Guid.NewGuid().ToString();
                ShowPopupImageAction action = new ShowPopupImageAction(actionName)
                {
                    ImageName = RmlWysiwygComponent.DefaultImage
                };
                slide.addAction(action);
                return(String.Format("<img src=\"{0}\" class=\"Center\" style=\"width:80%;\" onclick=\"{1}\"></img>", RmlWysiwygComponent.DefaultImage, actionName));
            }),
                new WysiwygDragDropItem("Data Dispaly", CommonResources.NoIcon, "<data type=\"volume\" target=\"\">Data Display</data>"),
                new WysiwygCallbackDragDropItem("Trigger", "Lecture.Icon.TriggerIcon", "<button class=\"Trigger\" onclick=\"\">Add trigger text here.</a>",
                                                () => //Markup Callback
            {
                String actionName       = Guid.NewGuid().ToString();
                SetupSceneAction action = new SetupSceneAction(actionName);
                action.captureSceneState(uiCallback);
                slide.addAction(action);
                return(String.Format("<button class=\"Trigger\" onclick=\"{0}\">Add trigger text here.</a>", actionName));
            }),
                new WysiwygCallbackDragDropItem("Slider", CommonResources.NoIcon, "<input type=\"range\" min=\"0\" max=\"100\" value=\"0\" change=\"\"/>",
                                                () => //Markup Callback
            {
                String actionName       = Guid.NewGuid().ToString();
                BlendSceneAction action = new BlendSceneAction(actionName);
                action.captureSceneToStartAndEnd(uiCallback);
                slide.addAction(action);
                return(String.Format("<input type=\"range\" min=\"0\" max=\"100\" value=\"0\" onchange=\"{0}\"/>", actionName));
            })
                );
            htmlDragDrop.Dragging += (item, position) =>
            {
                foreach (var editor in rmlEditors.Values)
                {
                    editor.Component.setPreviewElement(position, item.PreviewMarkup, item.PreviewTagType);
                }
            };
            htmlDragDrop.DragEnded += (item, position) =>
            {
                bool allowAdd = true;
                foreach (var editor in rmlEditors.Values)
                {
                    if (allowAdd && editor.Component.contains(position))
                    {
                        editor.Component.insertRml(item.createDocumentMarkup());
                        setCurrentRmlEditor(editor.View.Name);
                        allowAdd = false;
                    }
                    else
                    {
                        editor.Component.cancelAndHideEditor();
                        editor.Component.clearPreviewElement(false);
                    }
                }
            };
            htmlDragDrop.ItemActivated += (item) =>
            {
                rmlEditors[currentRmlEditor].Component.insertRml(item.createDocumentMarkup());
            };

            taskbar = new SlideTaskbarView("InfoBar", slideName);
            taskbar.addTask(new CallbackTask("Save", "Save", "CommonToolstrip/Save", "", 0, true, item =>
            {
                saveAll();
            }));
            taskbar.addTask(new CallbackTask("Undo", "Undo", "Lecture.Icon.Undo", "Edit", 0, true, item =>
            {
                undoBuffer.undo();
            }));
            taskbar.addTask(new CallbackTask("Redo", "Redo", "Lecture.Icon.Redo", "Edit", 0, true, item =>
            {
                undoBuffer.execute();
            }));
            foreach (Task htmlDragDropTask in htmlDragDrop.Tasks)
            {
                taskbar.addTask(htmlDragDropTask);
            }
            taskbar.addTask(new CallbackTask("AddSlide", "Add Slide", "Lecture.Icon.AddSlide", "Edit", 0, true, item =>
            {
                slideEditorController.createSlide();
            }));
            taskbar.addTask(new CallbackTask("DuplicateSlide", "Duplicate Slide", "Lecture.Icon.DuplicateSlide", "Edit", 0, true, item =>
            {
                slideEditorController.duplicateSlide(slide);
            }));
            taskbar.addTask(new CallbackTask("RemoveSlide", "Remove Slide", "Lecture.Icon.RemoveSlide", "Edit", 0, true, item =>
            {
                editorController.removeSelectedSlides();
            }));
            taskbar.addTask(new CallbackTask("Capture", "Capture", "Lecture.Icon.Capture", "Edit", 0, true, item =>
            {
                editorController.capture();
            }));
            taskbar.addTask(new CallbackTask("EditTimeline", "Edit Timeline", "Lecture.Icon.EditTimeline", "Edit", 0, true, item =>
            {
                editorController.editTimeline(slide, "Timeline.tl", "Timeline");
            }));
            taskbar.addTask(new CallbackTask("Present", "Present", "Lecture.Icon.Present", "Edit", 0, true, item =>
            {
                editorController.runSlideshow(slide);
            }));
            taskbar.addTask(new CallbackTask("PresentFromBeginning", "Present From Beginning", "Lecture.Icon.PresentBeginning", "Edit", 0, true, item =>
            {
                editorController.runSlideshow(0);
            }));

            slideLayoutPicker = new SlideLayoutPickerTask();
            makeTempPresets();
            slideLayoutPicker.ChangeSlideLayout += slideLayoutPicker_ChangeSlideLayout;
            taskbar.addTask(slideLayoutPicker);

            styleManager = new SlideshowStyleManager(editorController, uiCallback);
            styleManager.addStyleFile(Path.Combine(slide.UniqueName, Slide.StyleSheetName), "This Slide");
            styleManager.addStyleFile("SlideMasterStyles.rcss", "All Slides");
            taskbar.addTask(new CallbackTask("EditSlideshowTheme", "Edit Slideshow Theme", "Lecture.Icon.EditStyle", "Edit", 0, true, item =>
            {
                IntVector2 taskPosition = item.CurrentTaskPositioner.findGoodWindowPosition(SlideshowStyleManager.Width, SlideshowStyleManager.Height);
                styleManager.showEditor(taskPosition.x, taskPosition.y);
            }));

            taskbar.addTask(new CallbackTask("ResetSlide", "Reset Slide", "Lecture.Icon.RevertIcon", "Edit", 0, true, item =>
            {
                resetSlide();
            }));

            mvcContext.Views.add(taskbar);

            setupScene = new RunCommandsAction("SetupScene");
            if (autoSetupScene)
            {
                setupScene.addCommand(new CallbackCommand(context =>
                {
                    undoState  = LayerState.CreateAndCapture();
                    undoCamera = sceneViewController.ActiveWindow != null ? sceneViewController.ActiveWindow.createCameraPosition() : null;
                }));
                slide.populateCommand(setupScene);
                setupScene.addCommand(new CallbackCommand(context =>
                {
                    if (undoState != null)
                    {
                        layerController.pushUndoState(undoState);
                        undoState = null;
                    }
                    if (undoCamera != null)
                    {
                        if (sceneViewController.ActiveWindow != null)
                        {
                            sceneViewController.ActiveWindow.pushUndoState(undoCamera);
                        }
                        undoCamera = null;
                    }
                }));
            }

            mvcContext.Controllers.add(new MvcController("Editor",
                                                         setupScene,
                                                         showCommand,
                                                         showEditorWindowsCommand,
                                                         closeEditorWindowsCommand,
                                                         new RunCommandsAction("Close", new CloseAllViewsCommand())
                                                         ));

            mvcContext.Controllers.add(new MvcController("Common",
                                                         new RunCommandsAction("Start", new RunActionCommand("Editor/Show")),
                                                         new CallbackAction("Focus", context =>
            {
                htmlDragDrop.CreateIconPreview();
                GlobalContextEventHandler.setEventContext(eventContext);
                if (Focus != null)
                {
                    Focus.Invoke(this);
                }
                slideLayoutPicker.createLayoutPicker();
                panelResizeWidget.createResizeWidget();
                if (currentRmlEditor != null)     //Make sure we have an active editor
                {
                    String current   = currentRmlEditor;
                    currentRmlEditor = null;
                    setCurrentRmlEditor(current);
                }
                this.slideEditorController.VectorModeChanged += slideEditorController_VectorModeChanged;
            }),
                                                         new CallbackAction("Blur", blur),
                                                         new RunCommandsAction("Suspended", new SaveViewLayoutCommand()),
                                                         new RunCommandsAction("Resumed", new RestoreViewLayoutCommand()),
                                                         previewTriggerAction));

            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);

            ButtonEvent undoEvent = new ButtonEvent(EventLayers.Gui);

            undoEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
            undoEvent.addButton(KeyboardButtonCode.KC_Z);
            undoEvent.FirstFrameUpEvent += eventManager =>
            {
                undoBuffer.undo();
            };
            eventContext.addEvent(undoEvent);

            ButtonEvent redoEvent = new ButtonEvent(EventLayers.Gui);

            redoEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
            redoEvent.addButton(KeyboardButtonCode.KC_Y);
            redoEvent.FirstFrameUpEvent += eventManager =>
            {
                undoBuffer.execute();
            };
            eventContext.addEvent(redoEvent);

            ButtonEvent runEvent = new ButtonEvent(EventLayers.Gui);

            runEvent.addButton(KeyboardButtonCode.KC_F5);
            runEvent.FirstFrameUpEvent += eventManager =>
            {
                ThreadManager.invoke(() =>
                {
                    editorController.runSlideshow(0);
                });
            };
            eventContext.addEvent(runEvent);

            ButtonEvent captureEvent = new ButtonEvent(EventLayers.Gui);

            captureEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
            captureEvent.addButton(KeyboardButtonCode.KC_SPACE);
            captureEvent.FirstFrameUpEvent += eventManager =>
            {
                editorController.capture();
            };
            eventContext.addEvent(captureEvent);
        }