public override void setupAction(Slide slide, RunCommandsAction action) { action.addCommand(new PlayTimelineCommand() { Timeline = Path.Combine(slide.UniqueName, timelineFileName), }); }
public override void addToController(Slide slide, MvcController controller, AnomalousMvcContext context) { RunCommandsAction action = new RunCommandsAction(name); setupAction(slide, action); controller.Actions.add(action); }
protected void customizeController(MvcController controller, RunCommandsAction showCommand) { if (startupAction != null) { startupAction.setupAction(this, showCommand); } }
public void populateCommand(RunCommandsAction action) { if (startupAction != null) { StartupAction.setupAction(this, action); } }
public SlideInputStrategy(Slide slide, UndoRedoBuffer undoBuffer, NotificationGUIManager notificationManager, RunCommandsAction previewTriggerAction, String tag, String previewIconName = CommonResources.NoIcon) : base(tag, previewIconName) { this.slide = slide; this.undoBuffer = undoBuffer; this.notificationManager = notificationManager; this.previewTriggerAction = previewTriggerAction; }
public BlendSceneAction(String name) { action = new RunCommandsAction(name); Layers = true; Camera = true; MusclePosition = true; MedicalState = true; AllowPreview = true; }
public SetupSceneAction(String name) { action = new RunCommandsAction(name); Layers = true; Camera = true; MusclePosition = true; MedicalState = true; HighlightTeeth = true; AllowPreview = true; }
public override void setupAction(Slide slide, RunCommandsAction action) { RunCommandsAction clone = CopySaver.Default.copy(this.action); foreach (var command in clone.Commands) { action.addCommand(command); } clone.clear(); }
/// <summary> /// Create a slide trigger strategy. The ActionTypeBrowser determines the slide action types that can be put on the slide. /// Be sure to set the DefaultSelection on this browser, this is used when the trigger has no action as the default. /// </summary> public SlideTriggerStrategy(Slide slide, Browser actionTypeBrowser, UndoRedoBuffer undoBuffer, String tag, String primaryClassName, String previewIconName, NotificationGUIManager notificationManager, RunCommandsAction previewTriggerAction) : base(tag, previewIconName, true) { this.primaryClassName = primaryClassName; this.previewTriggerAction = previewTriggerAction; this.undoBuffer = undoBuffer; this.slide = slide; this.actionTypeBrowser = actionTypeBrowser; this.notificationManager = notificationManager; ResizeHandles = ResizeType.Top | ResizeType.Height; }
public void createViews(String name, RunCommandsAction showCommand, AnomalousMvcContext context, SlideDisplayManager displayManager, Slide slide) { SlideInstanceLayoutStrategy instanceStrategy = createLayoutStrategy(displayManager); foreach (SlidePanel panel in panels.Values) { MyGUIView view = panel.createView(slide, name); instanceStrategy.addView(view); showCommand.addCommand(new ShowViewCommand(view.Name)); context.Views.add(view); } }
private void refreshPanelPreviews(RunCommandsAction showEditorWindowsCommand) { SlideDisplayManager displayManager = new SlideDisplayManager(true); SlideInstanceLayoutStrategy instanceLayout = slide.LayoutStrategy.createLayoutStrategy(displayManager); foreach (RmlSlidePanel panel in slide.Panels.Where(p => p is RmlSlidePanel)) { String editorViewName = panel.createViewName("RmlView"); RmlView rmlView = new RmlView(editorViewName); rmlView.ElementName = panel.ElementName; rmlView.RmlFile = panel.getRmlFilePath(slide); instanceLayout.addView(rmlView); mvcContext.Views.add(rmlView); showEditorWindowsCommand.addCommand(new ShowViewCommand(rmlView.Name)); } }
private static void createController(AnomalousMvcContext mvcContext, String name, bool backButton) { MvcController controller = new MvcController(name); RunCommandsAction show = new RunCommandsAction("Show"); show.addCommand(new ShowViewCommand(name)); if (backButton) { show.addCommand(new RecordBackAction()); } controller.Actions.add(show); RunCommandsAction close = new RunCommandsAction("Close"); close.addCommand(new CloseViewCommand()); controller.Actions.add(close); mvcContext.Controllers.add(controller); }
public SetupSceneAction(String name, CameraPosition cameraPosition, LayerState layers, MusclePosition musclePosition, PresetState medicalState, bool captureHighlight, bool isHighlighted) { action = new RunCommandsAction(name); Layers = layers != null; Camera = cameraPosition != null; MusclePosition = musclePosition != null; MedicalState = medicalState != null; HighlightTeeth = captureHighlight; if (Layers) { ChangeLayersCommand changeLayersCommand = new ChangeLayersCommand(); changeLayersCommand.Layers.copyFrom(layers); action.addCommand(changeLayersCommand); } if (MusclePosition) { SetMusclePositionCommand musclePositionCommand = new SetMusclePositionCommand(); musclePositionCommand.MusclePosition = musclePosition; action.addCommand(musclePositionCommand); } if (Camera) { MoveCameraCommand moveCameraCommand = new MoveCameraCommand(); moveCameraCommand.CameraPosition = cameraPosition; action.addCommand(moveCameraCommand); } if (MedicalState) { ChangeMedicalStateCommand medicalStateCommand = new ChangeMedicalStateCommand(); medicalStateCommand.PresetState = medicalState; action.addCommand(medicalStateCommand); } if (HighlightTeeth) { action.addCommand(new ChangeTeethHighlightsCommand(isHighlighted)); } AllowPreview = true; }
public override void addToController(Slide slide, MvcController controller, AnomalousMvcContext context) { String closeCommandName = String.Format("CloseImagePopup__{0}", name); RunCommandsAction openAction = new RunCommandsAction(name, new ShowViewCommand(name)); controller.Actions.add(openAction); RunCommandsAction closeAction = new RunCommandsAction(closeCommandName, new CloseViewCommand()); controller.Actions.add(closeAction); RawRmlView popupView = new RawRmlView(name); popupView.ElementName = new LayoutElementName(GUILocationNames.ContentAreaPopup); popupView.Buttons.add(new CloseButtonDefinition(String.Format("CloseButton__{0}", name), String.Format("{0}/{1}", slide.UniqueName, closeCommandName))); popupView.Rml = String.Format(ImageRml, imageName); popupView.FakePath = Path.Combine(slide.UniqueName, "ImagePopup.rml"); context.Views.add(popupView); }
public void setupContext(AnomalousMvcContext context, String name, ResourceProvider resourceProvider, SlideDisplayManager displayManager) { MvcController controller = new MvcController(name); RunCommandsAction showCommand = new RunCommandsAction("Show"); showCommand.addCommand(new CloseAllViewsCommand()); String timelinePath = Path.Combine(UniqueName, "Timeline.tl"); if (resourceProvider.exists(timelinePath)) { showCommand.addCommand(new PlayTimelineCommand(timelinePath)); } foreach (var action in triggerActions.Values) { action.addToController(this, controller, context); } context.Controllers.add(controller); layoutStrategy.createViews(name, showCommand, context, displayManager, this); controller.Actions.add(showCommand); customizeController(controller, showCommand); }
/// <summary> /// Setup a RunCommandsAction that works for this SlideAction. /// </summary> /// <param name="slide"></param> /// <param name="action"></param> public abstract void setupAction(Slide slide, RunCommandsAction action);
public EditorUICallback(StandaloneController standaloneController, EditorController editorController, PropEditController propEditController) : base(standaloneController, editorController, propEditController) { this.addOneWayCustomQuery(AnomalousMvcContext.CustomQueries.Preview, delegate(AnomalousMvcContext context) { previewMvcContext(context); }); this.addSyncCustomQuery<Browser>(ViewBrowserEditableProperty.CustomQueries.BuildBrowser, () => { Browser browser = new Browser("Views", "Choose View"); if (CurrentEditingMvcContext != null) { foreach (View view in CurrentEditingMvcContext.Views) { browser.addNode(null, null, new BrowserNode(view.Name, view.Name)); } } return browser; }); this.addSyncCustomQuery<Browser, Type>(ModelBrowserEditableProperty.CustomQueries.BuildBrowser, (assignableFromType) => { Browser browser = new Browser("Models", "Choose Model"); if (CurrentEditingMvcContext != null) { foreach (MvcModel model in CurrentEditingMvcContext.Models) { if (assignableFromType.IsAssignableFrom(model.GetType())) { browser.addNode(null, null, new BrowserNode(model.Name, model.Name)); } } } return browser; }); this.addOneWayCustomQuery(View.CustomQueries.AddControllerForView, delegate(View view) { AnomalousMvcContext context = CurrentEditingMvcContext; String controllerName = view.Name; if (context.Controllers.hasItem(controllerName)) { MessageBox.show(String.Format("There is already a controller named {0}. Cannot create a new one.", controllerName), "Error", MessageBoxStyle.IconError | MessageBoxStyle.Ok); } else { MvcController controller = new MvcController(controllerName); RunCommandsAction showCommand = new RunCommandsAction("Show"); showCommand.addCommand(new ShowViewCommand(view.Name)); controller.Actions.add(showCommand); RunCommandsAction closeCommand = new RunCommandsAction("Close"); closeCommand.addCommand(new CloseViewCommand()); controller.Actions.add(closeCommand); context.Controllers.add(controller); } }); this.addSyncCustomQuery<Browser>(ActionBrowserEditableProperty.CustomQueries.BuildBrowser, () => { return createActionBrowser(); }); this.addSyncCustomQuery<Browser>(ElementAttributeEditor.CustomQueries.BuildActionBrowser, () => { return createActionBrowser(); }); this.addSyncCustomQuery<Browser, IEnumerable<String>, String, String>(ElementAttributeEditor.CustomQueries.BuildFileBrowser, (searchPatterns, prompt, leadingPath) => { return createFileBrowser(searchPatterns, prompt, leadingPath); }); this.addCustomQuery<String, String>(PlaySoundAction.CustomQueries.Record, (queryResult, soundFile) => { this.getInputString("Enter a name for the sound file.", delegate(String result, ref String errorMessage) { String finalSoundFile = Path.ChangeExtension(result, ".ogg"); String error = null; QuickSoundRecorder.ShowDialog(standaloneController.MedicalController, finalSoundFile, editorController.ResourceProvider.openWriteStream, newSoundFile => { queryResult.Invoke(newSoundFile, ref error); }); return true; }); }); this.addSyncCustomQuery<Browser>(TimelinePreActionEditInterface.CustomQueries.BuildActionBrowser, () => { var browser = new Browser("Pre Actions", "Choose Pre Action"); browser.addNode(null, null, new BrowserNode("Change Scene", typeof(OpenNewSceneAction))); browser.addNode(null, null, new BrowserNode("Show Skip To Post Actions Prompt", typeof(SkipToPostActions))); browser.addNode(null, null, new BrowserNode("Run Mvc Action", typeof(RunMvcAction))); return browser; }); this.addSyncCustomQuery<Browser>(TimelinePostActionEditInterface.CustomQueries.BuildActionBrowser, () => { var browser = new Browser("Post Actions", "Choose Post Action"); browser.addNode(null, null, new BrowserNode("Load Another Timeline", typeof(LoadAnotherTimeline))); browser.addNode(null, null, new BrowserNode("Repeat Previous", typeof(RepeatPreviousPostActions))); browser.addNode(null, null, new BrowserNode("Run Mvc Action", typeof(RunMvcAction))); return browser; }); }
public TimelineEditorContext(Timeline timeline, Slide slide, String name, SlideshowEditController slideshowEditController, PropEditController propEditController, PropFactory propFactory, EditorController editorController, GuiFrameworkUICallback uiCallback, TimelineController timelineController) { this.slide = slide; this.currentTimeline = timeline; this.slideshowEditController = slideshowEditController; 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()); var timelineEditorView = new TimelineEditorView("TimelineEditor", currentTimeline, timelineController, editorController, propEditController) { DisplayTitle = "Main Timeline" }; timelineEditorView.ComponentCreated += timelineEditorView_ComponentCreated; mvcContext.Views.add(timelineEditorView); ExpandingGenericEditorView genericEditor = new ExpandingGenericEditorView("TimelinePropertiesEditor", currentTimeline.getEditInterface(), editorController, uiCallback) { DisplayTitle = "Properties" }; genericEditor.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Left) { AllowedDockLocations = DockLocation.Left | DockLocation.Right | DockLocation.Floating }; mvcContext.Views.add(genericEditor); PropTimelineView propTimelineView = new PropTimelineView("PropTimeline", propEditController, propFactory) { DisplayTitle = "Prop Timeline" }; propTimelineView.Buttons.add(new CloseButtonDefinition("Close", "PropTimeline/Close")); mvcContext.Views.add(propTimelineView); OpenPropManagerView propManagerView = new OpenPropManagerView("PropManager", propEditController) { DisplayTitle = "Prop Manager" }; propManagerView.Buttons.add(new CloseButtonDefinition("Close", "PropManager/Close")); mvcContext.Views.add(propManagerView); MovementSequenceEditorView movementSequenceEditor = new MovementSequenceEditorView("MovementSequenceEditor", listenForSequenceChanges: true) { DisplayTitle = "Movement Sequence" }; movementSequenceEditor.Buttons.add(new CloseButtonDefinition("Close", "MovementSequenceEditor/Close")); movementSequenceEditor.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Top) { AllowedDockLocations = DockLocation.Top | DockLocation.Bottom | DockLocation.Floating }; mvcContext.Views.add(movementSequenceEditor); SlideTaskbarView taskbar = new SlideTaskbarView("TimelineInfoBar", name); taskbar.addTask(new CallbackTask("SaveAll", "Save All", "CommonToolstrip/Save", "", 0, true, item => { saveAll(); })); 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)); taskbar.addTask(new CallbackTask("EditSlide", "Edit Slide", "Lecture.Icon.EditSlide", "", 0, true, item => { slideshowEditController.editSlide(slide); })); mvcContext.Views.add(taskbar); RunCommandsAction showCommand = new RunCommandsAction("Show", new ShowViewCommand("TimelineEditor"), new ShowViewCommand("TimelinePropertiesEditor"), new ShowViewCommand("TimelineInfoBar")); refreshPanelPreviews(showCommand); mvcContext.Controllers.add(new MvcController("TimelineEditor", showCommand, new RunCommandsAction("Close", new CloseAllViewsCommand()), 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 void setupAction(Slide slide, RunCommandsAction action) { //Does not setup single action, this does nothing }
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); }
public CommonUICallback(StandaloneController standaloneController, EditorController editorController, PropEditController propEditController) { this.editorController = editorController; this.standaloneController = standaloneController; this.propEditController = propEditController; this.addOneWayCustomQuery(CameraPosition.CustomEditQueries.CaptureCameraPosition, delegate(CameraPosition camPos) { SceneViewWindow activeWindow = standaloneController.SceneViewController.ActiveWindow; if (activeWindow != null) { camPos.Translation = activeWindow.Translation; camPos.LookAt = activeWindow.LookAt; activeWindow.calculateIncludePoint(camPos); } }); this.addOneWayCustomQuery(CameraPosition.CustomEditQueries.PreviewCameraPosition, delegate(CameraPosition camPos) { SceneViewWindow activeWindow = standaloneController.SceneViewController.ActiveWindow; if (activeWindow != null) { CameraPosition undo = activeWindow.createCameraPosition(); activeWindow.setPosition(camPos, MedicalConfig.CameraTransitionTime); activeWindow.pushUndoState(undo); } }); this.addCustomQuery <PresetState>(ChangeMedicalStateCommand.CustomEditQueries.CapturePresetState, delegate(SendResult <PresetState> resultCallback) { PresetStateCaptureDialog stateCaptureDialog = new PresetStateCaptureDialog(resultCallback); stateCaptureDialog.SmoothShow = true; stateCaptureDialog.open(true); }); this.addOneWayCustomQuery(RmlView.CustomQueries.OpenFileInRmlViewer, delegate(String file) { editorController.openEditor(file); }); this.addCustomQuery <Browser>(ViewCollection.CustomQueries.CreateViewBrowser, delegate(SendResult <Browser> resultCallback) { Browser browser = new Browser("Views", "Choose View Type"); standaloneController.MvcCore.ViewHostFactory.createViewBrowser(browser); String errorPrompt = null; resultCallback(browser, ref errorPrompt); }); this.addCustomQuery <Browser>(ModelCollection.CustomQueries.CreateModelBrowser, delegate(SendResult <Browser> resultCallback) { Browser browser = new Browser("Models", "Choose Model Type"); browser.addNode(null, null, new BrowserNode("DataModel", typeof(DataModel), DataModel.DefaultName)); browser.addNode(null, null, new BrowserNode("Navigation", typeof(NavigationModel), NavigationModel.DefaultName)); browser.addNode(null, null, new BrowserNode("MedicalStateInfo", typeof(MedicalStateInfoModel), MedicalStateInfoModel.DefaultName)); browser.addNode(null, null, new BrowserNode("BackStack", typeof(BackStackModel), BackStackModel.DefaultName)); String error = null; resultCallback(browser, ref error); }); this.addCustomQuery <Type>(RunCommandsAction.CustomQueries.ShowCommandBrowser, delegate(SendResult <Type> resultCallback) { this.showBrowser(RunCommandsAction.CreateCommandBrowser(), resultCallback); }); this.addCustomQuery <Color>(ShowTextAction.CustomQueries.ChooseColor, queryDelegate => { ColorDialog colorDialog = new ColorDialog(); colorDialog.showModal((result, color) => { if (result == NativeDialogResult.OK) { String errorPrompt = null; queryDelegate.Invoke(color, ref errorPrompt); } }); }); this.addOneWayCustomQuery <ShowPropAction>(ShowPropAction.CustomQueries.KeepOpenToggle, showPropAction => { if (showPropAction.KeepOpen) { propEditController.removeOpenProp(showPropAction); } else { propEditController.addOpenProp(showPropAction); } }); this.addSyncCustomQuery <Browser, IEnumerable <String>, String>(FileBrowserEditableProperty.CustomQueries.BuildBrowser, (searchPattern, prompt) => { return(createFileBrowser(searchPattern, prompt)); }); this.addSyncCustomQuery <Browser>(AnatomyManager.CustomQueries.BuildBrowser, () => { return(AnatomyManager.buildBrowser()); }); this.addSyncCustomQuery <Browser>(PropBrowserEditableProperty.CustomQueries.BuildBrowser, () => { Browser browser = new Browser("Props", "Choose Prop"); foreach (var propDef in standaloneController.TimelineController.PropFactory.PropDefinitions) { if (standaloneController.LicenseManager.allowPropUse(propDef.PropLicenseId)) { browser.addNode(propDef.BrowserPath, new BrowserNode(propDef.PrettyName, propDef.Name)); } } return(browser); }); this.addSyncCustomQuery <Browser>(ElementNameEditableProperty.CustomQueries.BuildBrowser, () => { Browser browser = new Browser("Screen Location Name", "Choose Screen Location Name"); foreach (var elementName in standaloneController.GUIManager.NamedLinks) { browser.addNode(null, null, new BrowserNode(elementName.UniqueDerivedName, elementName)); } return(browser); }); addOneWayCustomQuery <String>(PlaySoundAction.CustomQueries.EditExternally, soundFile => { if (soundFile != null && editorController.ResourceProvider.exists(soundFile)) { String fullPath = editorController.ResourceProvider.getFullFilePath(soundFile); OtherProcessManager.openLocalURL(fullPath); } }); }
public override void setupAction(Slide slide, RunCommandsAction action) { action.addCommand(new StopTimelineCommand()); }
public SlideshowRuntime(Slideshow slideshow, ResourceProvider resourceProvider, GUIManager guiManager, int startIndex, TaskController additionalTasks) { this.guiManager = guiManager; Assembly assembly = Assembly.GetExecutingAssembly(); using (Stream resourceStream = assembly.GetManifestResourceStream(SlideshowProps.BaseContextProperties.File)) { mvcContext = SharedXmlSaver.Load <AnomalousMvcContext>(resourceStream); } navModel = (NavigationModel)mvcContext.Models[SlideshowProps.BaseContextProperties.NavigationModel]; displayManager = new SlideDisplayManager(slideshow.VectorMode); foreach (Slide slide in slideshow.Slides) { String slideName = slide.UniqueName; slide.setupContext(mvcContext, slideName, resourceProvider, displayManager); NavigationLink link = new NavigationLink(slideName, null, slideName + "/Show"); navModel.addNavigationLink(link); } RunCommandsAction runCommands = (RunCommandsAction)mvcContext.Controllers["Common"].Actions["Start"]; runCommands.addCommand(new NavigateToIndexCommand() { Index = startIndex }); taskbar = new ClosingTaskbar(); taskbarLink = new SingleChildChainLink(SlideTaskbarName, taskbar); taskbar.Close += close; previousTask = new CallbackTask("Slideshow.Back", "Back", PreviousTaskName, "None", arg => { back(); }); nextTask = new CallbackTask("Slideshow.Forward", "Forward", NextTaskName, "None", arg => { next(); }); taskbar.addItem(new TaskTaskbarItem(previousTask)); taskbar.addItem(new TaskTaskbarItem(nextTask)); taskbar.addItem(new TaskTaskbarItem(new CallbackTask("Slideshow.Reload", "Reload", ReloadTaskName, "None", arg => { reload(); }))); //taskbar.addItem(new TaskTaskbarItem(new CallbackTask("Slideshow.ToggleMode", "Toggle Display Mode", "SlideshowIcons/NormalVectorToggle", "None", arg => //{ // displayManager.VectorMode = !displayManager.VectorMode; // guiManager.layout(); //}))); taskbar.addItem(new TaskTaskbarItem(new CallbackTask("Slideshow.ZoomIn", "Zoom In", "SlideshowIcons/ZoomIn", "None", arg => { zoomIn(); }))); taskbar.addItem(new TaskTaskbarItem(new CallbackTask("Slideshow.ResetZoom", "Reset Zoom", "SlideshowIcons/ResetZoom", "None", arg => { if (displayManager.AdditionalZoomMultiple != 1.0f) { displayManager.AdditionalZoomMultiple = 1.0f; guiManager.layout(); } }))); taskbar.addItem(new TaskTaskbarItem(new CallbackTask("Slideshow.ZoomOut", "Zoom Out", "SlideshowIcons/ZoomOut", "None", arg => { zoomOut(); }))); eventContext = new EventContext(); ButtonEvent nextEvent = new ButtonEvent(EventLayers.Gui); nextEvent.addButton(KeyboardButtonCode.KC_RIGHT); nextEvent.FirstFrameUpEvent += eventManager => { next(); }; eventContext.addEvent(nextEvent); ButtonEvent backEvent = new ButtonEvent(EventLayers.Gui); backEvent.addButton(KeyboardButtonCode.KC_LEFT); backEvent.FirstFrameUpEvent += eventManager => { back(); }; eventContext.addEvent(backEvent); ButtonEvent zoomInEvent = new ButtonEvent(EventLayers.Gui); zoomInEvent.addButton(KeyboardButtonCode.KC_EQUALS); zoomInEvent.FirstFrameUpEvent += eventManager => { zoomIn(); }; eventContext.addEvent(zoomInEvent); ButtonEvent zoomOutEvent = new ButtonEvent(EventLayers.Gui); zoomOutEvent.addButton(KeyboardButtonCode.KC_MINUS); zoomOutEvent.FirstFrameUpEvent += eventManager => { zoomOut(); }; eventContext.addEvent(zoomOutEvent); ButtonEvent closeEvent = new ButtonEvent(EventLayers.Gui); closeEvent.addButton(KeyboardButtonCode.KC_ESCAPE); closeEvent.FirstFrameUpEvent += eventManager => { ThreadManager.invoke(close); //Delay so we do not modify the input collection }; eventContext.addEvent(closeEvent); foreach (Task task in additionalTasks.Tasks) { taskbar.addItem(new TaskTaskbarItem(task)); } mvcContext.Blurred += (ctx) => { guiManager.deactivateLink(SlideTaskbarName); guiManager.removeLinkFromChain(taskbarLink); GlobalContextEventHandler.disableEventContext(eventContext); }; mvcContext.Focused += (ctx) => { guiManager.addLinkToChain(taskbarLink); guiManager.pushRootContainer(SlideTaskbarName); setNavigationIcons(); GlobalContextEventHandler.setEventContext(eventContext); }; mvcContext.RemovedFromStack += (ctx) => { taskbar.Dispose(); }; }