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