public void initialize(StandaloneController standaloneController)
{
GUIManager guiManager = standaloneController.GUIManager;
editorTimelineController = new TimelineController(standaloneController);
standaloneController.giveGUIsToTimelineController(editorTimelineController);
editorController = new EditorController(standaloneController, editorTimelineController);
editorController.ProjectTypes.addInfo(new ZipProjectType(".sl"));
standaloneController.DocumentController.addDocumentHandler(new SlideshowDocumentHandler(editorController));
//Prop Mover
MedicalController medicalController = standaloneController.MedicalController;
propMover = new SimObjectMover("LectureProps", medicalController.PluginManager.RendererPlugin, medicalController.EventManager, standaloneController.SceneViewController);
propEditController = new PropEditController(propMover);
editorUICallback = new LectureUICallback(standaloneController, editorController, propEditController);
slideshowEditController = new SlideshowEditController(standaloneController, editorUICallback, this.propEditController, editorController, editorTimelineController);
slideshowExplorer = new SlideshowExplorer(slideshowEditController);
guiManager.addManagedDialog(slideshowExplorer);
TaskController taskController = standaloneController.TaskController;
taskController.addTask(new MDIDialogOpenTask(slideshowExplorer, "Medical.SlideshowExplorer", "Authoring Tools", "Lecture.Icon.SmartLectureIcon", TaskMenuCategories.Create));
CommonEditorResources.initialize(standaloneController);
standaloneController.ViewHostFactory.addFactory(new SlideTaskbarFactory());
standaloneController.MedicalStateController.StateAdded += MedicalStateController_StateAdded;
standaloneController.MedicalStateController.BlendingStopped += MedicalStateController_BlendingStopped;
}
public DebugVisualizer(StandaloneController standaloneController)
: base("Developer.GUI.DebugVisualizer.DebugVisualizer.layout")
{
this.medicalController = standaloneController.MedicalController;
this.pluginManager = medicalController.PluginManager;
standaloneController.SceneLoaded += standaloneController_SceneLoaded;
standaloneController.SceneUnloading += standaloneController_SceneUnloading;
uiCallback = new GuiFrameworkUICallback();
tree = new Tree((ScrollView)window.findWidget("TreeScroller"));
editTreeView = new EditInterfaceTreeView(tree, uiCallback);
propertiesForm = new ScrollablePropertiesForm((ScrollView)window.findWidget("TableScroller"), uiCallback);
objectEditor = new ObjectEditor(editTreeView, propertiesForm, uiCallback);
this.Resized += DebugVisualizer_Resized;
currentScene = standaloneController.MedicalController.CurrentScene;
splitter = new Splitter(window.findWidget("Splitter"));
splitter.Widget1Resized += a => tree.layout();
splitter.Widget2Resized += a => propertiesForm.layout();
}
public BookmarksController(StandaloneController standaloneController, int width, int height, bool premiumBookmarks)
{
this.standaloneController = standaloneController;
this.premiumBookmarks = premiumBookmarks;
this.loadBookmarks = new LoadBookmarksBgTask(this);
SceneViewControllerExtensions.BookmarksController = this;
}
public RestartNotification(String text, String imageKey, StandaloneController standaloneController, bool autoStartPlatformUpdate, bool asAdmin)
: base(text, imageKey)
{
this.standaloneController = standaloneController;
this.autoStartPlatformUpdate = autoStartPlatformUpdate;
this.asAdmin = asAdmin;
}
public CloneWindowTask(StandaloneController standaloneController, CloneWindowDialog cloneWindowDialog)
: base("Medical.CloneWindow", "Clone Window", "PremiumFeatures/CloneWindow", TaskMenuCategories.System)
{
this.standaloneController = standaloneController;
this.cloneWindowDialog = cloneWindowDialog;
cloneWindowDialog.CreateCloneWindow += new EventHandler(cloneWindowDialog_CreateCloneWindow);
cloneWindowDialog.Closed += new EventHandler(cloneWindowDialog_Closed);
}
public AnomalousMvcCore(StandaloneController standaloneController, ViewHostFactory viewHostFactory)
{
this.standaloneController = standaloneController;
this.timelineController = standaloneController.TimelineController;
timelineController.TimelinePlaybackStopped += new EventHandler(timelineController_TimelinePlaybackStopped);
this.guiManager = standaloneController.GUIManager;
this.viewHostFactory = viewHostFactory;
viewHostManager = new ViewHostManager(guiManager, viewHostFactory);
}
public KinectIkController(StandaloneController controller)
{
this.medicalController = controller.MedicalController;
dragSimObjectDefinition = new GenericSimObjectDefinition("TestArrow");
dragControl = new BEPUikDragControlDefinition("DragControl");
dragSimObjectDefinition.addElement(dragControl);
//filter.Init(0.5f, 0.5f, 0.0f, 0.1f, 0.04f);
//filter.Init(1.0f, 0.0f, 0.0f, 0.1f, 0.04f);
}
public TestSoundRecord(StandaloneController standaloneController)
: base("UnitTestPlugin.GUI.TestSoundRecord.TestSoundRecord.layout")
{
this.standaloneController = standaloneController;
enabled = new CheckButton((Button)window.findWidget("Enabled"));
enabled.CheckedChanged += new MyGUIEvent(enabled_CheckedChanged);
enabled.Checked = PerformanceMonitor.Enabled;
Button reset = (Button)window.findWidget("ResetButton");
reset.MouseButtonClick += new MyGUIEvent(reset_MouseButtonClick);
}
public LectureUICallback(StandaloneController standaloneController, EditorController editorController, PropEditController propEditController)
: base(standaloneController, editorController, propEditController)
{
addCustomQuery <String, String>(PlaySoundAction.CustomQueries.Record, (queryResult, soundFile) =>
{
String finalSoundFile = Path.Combine(CurrentDirectory, Guid.NewGuid().ToString("D") + ".ogg");
String error = null;
QuickSoundRecorder.ShowDialog(standaloneController.MedicalController, finalSoundFile, editorController.ResourceProvider.openWriteStream,
newSoundFile =>
{
queryResult.Invoke(newSoundFile, ref error);
});
});
}
public PerformanceGui(StandaloneController standaloneController)
: base("Developer.GUI.Performance.PerformanceGui.layout")
{
this.standaloneController = standaloneController;
text = (TextBox)window.findWidget("Text");
enabled = new CheckButton((Button)window.findWidget("Enabled"));
enabled.CheckedChanged += new MyGUIEvent(enabled_CheckedChanged);
enabled.Checked = PerformanceMonitor.Enabled;
Button reset = (Button)window.findWidget("ResetButton");
reset.MouseButtonClick += new MyGUIEvent(reset_MouseButtonClick);
}
public PoseController(StandaloneController controller)
{
activeModes.Add("Main");
controller.SceneLoaded += controller_SceneLoaded;
controller.SceneUnloading += controller_SceneUnloading;
sceneViewController = controller.SceneViewController;
anatomyController = controller.AnatomyController;
musclePositionController = controller.MusclePositionController;
if (controller.MedicalController.CurrentScene != null)
{
controller_SceneLoaded(controller.MedicalController.CurrentScene);
}
}
public void initialize(StandaloneController standaloneController)
{
poseController = new PoseController(standaloneController);
GUIManager guiManager = standaloneController.GUIManager;
var resources = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceNames();
movementDialog = new MovementDialog(standaloneController.MusclePositionController, poseController, standaloneController.MedicalController);
guiManager.addManagedDialog(movementDialog);
var taskController = standaloneController.TaskController;
var movementDialogTask = new PinableMDIDialogOpenTask(movementDialog, "Medical.Movement.MovementDialogTask", "Movement", CommonResources.NoIcon, TaskMenuCategories.Explore);
taskController.addTask(movementDialogTask);
}
public MeasurementGUI(StandaloneController standaloneController)
: base("Developer.GUI.Measurement.MeasurementGUI.layout")
{
this.standaloneController = standaloneController;
text = (TextBox)window.findWidget("Text");
enabled = new CheckButton((Button)window.findWidget("Enabled"));
enabled.CheckedChanged += new MyGUIEvent(enabled_CheckedChanged);
enabled.Checked = false;
showLines = new CheckButton((Button)window.findWidget("Show"));
showLines.Checked = MeasurementController.ShowingMeasurements;
showLines.CheckedChanged += showLines_CheckedChanged;
}
public void initialize(StandaloneController standaloneController)
{
poseController = new KinectIkController(standaloneController);
kinectDebugger = new KinectDebugVisualizer(standaloneController);
sensorManager = new KinectSensorManager();
sensorManager.SkeletonFrameReady += sensorManager_SkeletonFrameReady;
sensorManager.StatusChanged += sensorManager_StatusChanged;
sensorManager.FaceFrameReady += sensorManager_FaceFrameReady;
kinectGui = new KinectGui(poseController, sensorManager, kinectDebugger);
standaloneController.GUIManager.addManagedDialog(kinectGui);
sequenceRecorder = new MovementSequenceRecorder(standaloneController.MedicalController, standaloneController.MovementSequenceController);
standaloneController.GUIManager.addManagedDialog(sequenceRecorder);
var taskController = standaloneController.TaskController;
taskController.addTask(new MDIDialogOpenTask(kinectGui, "KinectPlugin.KinectGui", "Kinect", "KinectPlugin.Kinect", "Kinect"));
taskController.addTask(new MDIDialogOpenTask(sequenceRecorder, "KinectPlugin.KinectMovementSequenceRecorder", "Record Sequence", "KinectPlugin.Record", "Kinect"));
}
public MaxExport(StandaloneController standaloneController)
: base("Developer.GUI.MaxExport.MaxExport.layout")
{
this.medicalController = standaloneController.MedicalController;
Button saveAll = (Button)window.findWidget("SaveAll");
saveAll.MouseButtonClick += saveAll_MouseButtonClick;
Button saveAllVisible = (Button)window.findWidget("SaveAllVisible");
saveAllVisible.MouseButtonClick += saveAllVisible_MouseButtonClick;
Button saveLeftTeethAsRight = (Button)window.findWidget("SaveLeftTeethAsRight");
saveLeftTeethAsRight.MouseButtonClick += saveLeftTeethAsRight_MouseButtonClick;
Button saveRightTeethAsLeft = (Button)window.findWidget("SaveRighteethAsLeft");
saveRightTeethAsLeft.MouseButtonClick += saveRightTeethAsLeft_MouseButtonClick;
}
public void initialize(StandaloneController standaloneController)
{
GUIManager guiManager = standaloneController.GUIManager;
testImageAtlas = new TestImageAtlas();
guiManager.addManagedDialog(testImageAtlas);
testSoundRecord = new TestSoundRecord(standaloneController);
guiManager.addManagedDialog(testSoundRecord);
testTextureSceneView = new TestTextureSceneView(standaloneController.SceneViewController);
guiManager.addManagedDialog(testTextureSceneView);
standaloneController.TaskController.addTask(new CallbackTask("UnitTest.SaveFileDialog", "Test Save File", CommonResources.NoIcon, "Unit Test", 0, false, (item) =>
{
FileSaveDialog saveDialog = new FileSaveDialog(MainWindow.Instance, wildcard: "All Files|*");
saveDialog.showModal((result, path) =>
{
Log.Debug("Save dialog returned '{0}', path '{1}'", result, path);
});
}));
//This is a test to make all the geometry in the scene one large object to test batching reduction, initial tests show huge improvement, only works under open gl.
standaloneController.TaskController.addTask(new CallbackTask("UnitTest.StaticTest", "Static Test", CommonResources.NoIcon, "Unit Test", (item) =>
{
var scene = standaloneController.MedicalController.CurrentScene;
var sceneManager = scene.getSimElementManager("Ogre") as OgrePlugin.OgreSceneManager;
var ogreScene = sceneManager.SceneManager;
var staticGeo = ogreScene.createStaticGeometry("Test");
staticGeo.addSceneNode(ogreScene.getRootSceneNode());
ogreScene.getRootSceneNode().setVisible(false);
staticGeo.build();
}));
standaloneController.TaskController.addTask(new MDIDialogOpenTask(testSoundRecord, "UnitTestPlugin.TestSoundRecord", "Sound Record", CommonResources.NoIcon, "Unit Test", true));
standaloneController.TaskController.addTask(new MDIDialogOpenTask(testTextureSceneView, "UnitTestPlugin.TestTextureSceneView", "Texture Scene View", CommonResources.NoIcon, "Unit Test", true));
standaloneController.TaskController.addTask(new MDIDialogOpenTask(testImageAtlas, "UnitTestPlugin.TestImageAtlas", "Image Atlas", CommonResources.NoIcon, "Unit Test", true));
}
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 void unload(StandaloneController standaloneController, bool willReload, bool shuttingDown)
{
}
public void initialize(StandaloneController standaloneController)
{
RocketInterface.Instance.FileInterface.addExtension(new RocketAssemblyResourceLoader(this.GetType().Assembly));
if (VirtualFileSystem.Instance.exists("Watermark/AnomalousMedical.png"))
{
standaloneController.ImageRenderer.LoadLogo = () =>
{
using (Stream stream = VirtualFileSystem.Instance.openStream("Watermark/AnomalousMedical.png", Engine.Resources.FileMode.Open))
{
return(new FreeImageBitmap(stream));
}
};
}
this.guiManager = standaloneController.GUIManager;
this.standaloneController = standaloneController;
standaloneController.MovementSequenceController.GroupAdded += MovementSequenceController_GroupAdded;
bool hasPremium = licenseManager.allowFeature(1);
standaloneController.AnatomyController.ShowPremiumAnatomy = hasPremium;
guiManager.SaveUIConfiguration += guiManager_SaveUIConfiguration;
guiManager.LoadUIConfiguration += guiManager_LoadUIConfiguration;
guiManager.MainGUIShown += guiManager_MainGUIShown;
guiManager.MainGUIHidden += guiManager_MainGUIHidden;
//Controllers
imageLicenseServer = new ImageLicenseServer(licenseManager);
bookmarksController = new BookmarksController(standaloneController, ScaleHelper.Scaled(100), ScaleHelper.Scaled(100), hasPremium);
//Create Dialogs
aboutDialog = new AboutDialog(licenseManager);
chooseSceneDialog = new ChooseSceneDialog(guiManager);
chooseSceneDialog.ChooseScene += new EventHandler(chooseSceneDialog_ChooseScene);
standaloneController.AnatomyController.ShowPremiumAnatomyChanged += AnatomyController_ShowPremiumAnatomyChanged;
anatomyFinder = new AnatomyFinder(standaloneController.AnatomyController, standaloneController.SceneViewController, standaloneController.LayerController, standaloneController.AnatomyTaskManager);
guiManager.addManagedDialog(anatomyFinder);
options = new OptionsDialog(guiManager);
options.VideoOptionsChanged += new EventHandler(options_VideoOptionsChanged);
options.RequestRestart += new EventHandler(options_RequestRestart);
bookmarks = new BookmarksGUI(bookmarksController, standaloneController.GUIManager, standaloneController.SceneViewController);
viewsGui = new ViewsGui(standaloneController.SceneViewController, standaloneController.AnatomyController);
guiManager.addManagedDialog(viewsGui);
//Taskbar
taskbar = new AppButtonTaskbar();
taskbar.OpenTaskMenu += taskbar_OpenTaskMenu;
taskbar.setAppIcon("AppButton/Hamburger", "AppButton/Hamburger");
taskbarLink = new SingleChildChainLink(GUILocationNames.Taskbar, taskbar);
guiManager.addLinkToChain(taskbarLink);
guiManager.pushRootContainer(GUILocationNames.Taskbar);
//Task Menu
taskMenu = new TaskMenu(standaloneController.DocumentController, standaloneController.TaskController, standaloneController.GUIManager, new LayoutElementName(GUILocationNames.FullscreenPopup));
taskMenu.GroupComparison = TaskMenuCategories.Sorter;
guiTaskManager = new GUITaskManager(taskbar, taskMenu, standaloneController.TaskController);
//Tasks Menu
TaskController taskController = standaloneController.TaskController;
standaloneController.AnatomyTaskManager.HighlightTasks += AnatomyTaskManager_HighlightTasks;
//Tasks
cameraMovementModeTask = new CameraMovementModeTask(standaloneController.SceneViewController);
taskController.addTask(cameraMovementModeTask);
Slideshow.AdditionalTasks.addTask(cameraMovementModeTask);
selectionOperatorTask = new SelectionOperatorTask(standaloneController.AnatomyController);
taskController.addTask(selectionOperatorTask);
Slideshow.AdditionalTasks.addTask(selectionOperatorTask);
var viewsTask = new PinableMDIDialogOpenTask(viewsGui, "Medical.Views", "Views", "AnomalousMedical/ViewIcon", TaskMenuCategories.Explore);
taskController.addTask(viewsTask);
//Patient Section
taskController.addTask(new ShowPopupTask(chooseSceneDialog, "Medical.NewPatient", "New", "AnomalousMedical/ChangeScene", TaskMenuCategories.Explore, 0));
taskController.addTask(new DialogOpenTask(aboutDialog, "Medical.About", "About", "AnomalousMedical/About", TaskMenuCategories.System, int.MaxValue - 2));
taskController.addTask(new VolumeControlTask());
CallbackTask unhideAllAnatomy = new CallbackTask("Medical.UnhideAllAnatomy", "Unhide All", "AnatomyFinder.ShowAll", TaskMenuCategories.Explore, int.MaxValue - 2, false, (item) =>
{
LayerState undo = LayerState.CreateAndCapture();
standaloneController.LayerController.unhideAll();
standaloneController.LayerController.pushUndoState(undo);
});
taskController.addTask(unhideAllAnatomy);
//Navigation Section
PinableMDIDialogOpenTask anatomyFinderTask = new PinableMDIDialogOpenTask(anatomyFinder, "Medical.AnatomyFinder", "Anatomy Finder", "AnomalousMedical/SearchIcon", TaskMenuCategories.Explore);
taskController.addTask(anatomyFinderTask);
Slideshow.AdditionalTasks.addTask(anatomyFinderTask);
ShowPopupTask bookmarkTask = null;
standaloneController.AnatomyController.setCommandPermission(AnatomyCommandPermissions.Unrestricted, PlatformConfig.UnrestrictedEnvironment);
standaloneController.AnatomyController.setCommandPermission(AnatomyCommandPermissions.PremiumActive, hasPremium);
if (PlatformConfig.UnrestrictedEnvironment || hasPremium)
{
//Explore
selectionModeTask = new SelectionModeTask(standaloneController.AnatomyController);
taskController.addTask(selectionModeTask);
Slideshow.AdditionalTasks.addTask(selectionModeTask);
bookmarkTask = new ShowPopupTask(bookmarks, "Medical.Bookmarks", "Bookmarks", "AnomalousMedical/FavoritesIcon", TaskMenuCategories.Explore);
taskController.addTask(bookmarkTask);
Slideshow.AdditionalTasks.addTask(bookmarkTask);
}
if (PlatformConfig.UnrestrictedEnvironment)
{
//System
CallbackTask helpTaskItem = new CallbackTask("Medical.Help", "Help", "AnomalousMedical/Help", TaskMenuCategories.System, int.MaxValue - 4, false);
helpTaskItem.OnClicked += new CallbackTask.ClickedCallback(helpTaskItem_OnClicked);
taskController.addTask(helpTaskItem);
taskController.addTask(new ShowPopupTask(options, "Medical.Options", "Options", "AnomalousMedical/Options", TaskMenuCategories.System, int.MaxValue - 3));
CallbackTask exitTaskItem = new CallbackTask("Medical.Exit", "Exit", "AnomalousMedical/Exit", TaskMenuCategories.System, int.MaxValue, false);
exitTaskItem.OnClicked += new CallbackTask.ClickedCallback(exitTaskItem_OnClicked);
taskController.addTask(exitTaskItem);
if (MedicalConfig.ShowDeveloperTools)
{
CallbackTask createOverrideTaskItem = new CallbackTask("Medical.CreateOverride", "CreateOverride", CommonResources.NoIcon, TaskMenuCategories.Developer, int.MaxValue, false);
createOverrideTaskItem.OnClicked += CreateOverrideTaskItem_OnClicked;
taskController.addTask(createOverrideTaskItem);
}
}
if (PlatformConfig.AllowFullscreenToggle)
{
CallbackTask toggleFullscreen = new CallbackTask("Medical.ToggleFullscreen", "Toggle Fullscreen", "AnomalousMedical/ToggleFullscreen", TaskMenuCategories.System, int.MaxValue - 2, false, (item) =>
{
MainWindow.Instance.toggleFullscreen();
});
taskController.addTask(toggleFullscreen);
//Fullscreen Toggle Shortcut
var toggleFullscreenMessageEvent = new ButtonEvent(EventLayers.Gui, frameUp: (evtMgr) =>
{
MainWindow.Instance.toggleFullscreen();
});
toggleFullscreenMessageEvent.addButton(KeyboardButtonCode.KC_RETURN);
toggleFullscreenMessageEvent.addButton(KeyboardButtonCode.KC_LMENU);
standaloneController.MedicalController.EventManager.addEvent(toggleFullscreenMessageEvent);
}
//Premium / Non Premium
if (!hasPremium)
{
if (PlatformConfig.UnrestrictedEnvironment)
{
buyScreens = new BuyScreenController(standaloneController);
taskMenuAd = new PremiumFeaturesTaskMenuAd(taskMenu);
selectionModeTask.SelectionModeChooser.ShowBuyMessage += SelectionModeChooser_ShowBuyMessage;
anatomyFinder.ShowBuyMessage += anatomyFinder_ShowBuyMessage;
bookmarks.ShowBuyMessage += bookmarks_ShowBuyMessage;
}
if (MedicalConfig.FirstRun)
{
guiTaskManager.addPinnedTask(anatomyFinderTask);
guiTaskManager.addPinnedTask(viewsTask);
guiTaskManager.addPinnedTask(cameraMovementModeTask);
if (bookmarkTask != null)
{
guiTaskManager.addPinnedTask(bookmarkTask);
}
guiTaskManager.addPinnedTask(unhideAllAnatomy);
}
}
standaloneController.AtlasPluginManager.RequestDependencyDownload += AtlasPluginManager_RequestDependencyDownload;
//Teeth mover
teethMover = new SimObjectMover("Teeth", standaloneController.MedicalController.PluginManager.RendererPlugin, standaloneController.MedicalController.EventManager, standaloneController.SceneViewController);
TeethToolController teethToolController = new TeethToolController(teethMover);
standaloneController.ImageRenderer.ImageRenderStarted += teethToolController.ScreenshotRenderStarted;
standaloneController.ImageRenderer.ImageRenderCompleted += teethToolController.ScreenshotRenderCompleted;
standaloneController.ViewHostFactory.addFactory(new WizardComponentFactory(teethToolController));
}
public override void createPlugin(StandaloneController standaloneController)
{
standaloneController.AtlasPluginManager.addPlugin(new MovementBodyAtlasPlugin());
}
public BuyScreenController(StandaloneController controller)
{
this.controller = controller;
}
public RunIntroTutorial(StandaloneController standaloneController)
: base("Medical.IntroductionTutorial.Bootstrap", "Introduction Tutorial", "IntroductionTutorial/Icon", "Anomalous Medical")
{
this.standaloneController = standaloneController;
this.ShowOnTaskbar = false;
}
public void initialize(StandaloneController standaloneController)
{
GUIManager guiManager = standaloneController.GUIManager;
//UI Helpers
gridProperties = new GridPropertiesDialog(standaloneController.MeasurementGrid);
guiManager.addManagedDialog(gridProperties);
developerRenderer = new DeveloperRenderPropertiesDialog(standaloneController.SceneViewController, standaloneController.ImageRenderer, guiManager, standaloneController.NotificationManager);
guiManager.addManagedDialog(developerRenderer);
discControl = new DiscControl();
guiManager.addManagedDialog(discControl);
advancedMandibleMovement = new AdvancedMandibleMovementDialog(standaloneController.MovementSequenceController, standaloneController.MusclePositionController);
guiManager.addManagedDialog(advancedMandibleMovement);
performanceGui = new PerformanceGui(standaloneController);
guiManager.addManagedDialog(performanceGui);
measurementGUI = new MeasurementGUI(standaloneController);
guiManager.addManagedDialog(measurementGUI);
debugVisualizer = new DebugVisualizer(standaloneController);
guiManager.addManagedDialog(debugVisualizer);
advancedCameraGui = new AdvancedCameraGui(standaloneController.SceneViewController);
guiManager.addManagedDialog(advancedCameraGui);
libRocketDebugger = new ShowLibRocketDebugger(guiManager, "ShowLibRocketDebugger", "Show LibRocket Debugger", "Developer.libRocketDebugger", "Developer");
resolutionGui = new ResolutionGui(standaloneController.MainWindow);
guiManager.addManagedDialog(resolutionGui);
RocketInterface.Instance.FileInterface.addExtension(new RocketAssemblyResourceLoader(this.GetType().Assembly));
changeRenderingMode = new ChangeRenderingMode(standaloneController.SceneViewController);
disablePhysics = new DisablePhysicsTask(int.MaxValue);
//Task Controller
TaskController taskController = standaloneController.TaskController;
taskController.addTask(new MDIDialogOpenTask(developerRenderer, "Developer.DeveloperRender", "Render", "AnomalousMedical/RenderIcon", TaskMenuCategories.Create));
if (MedicalConfig.ShowDeveloperTools)
{
taskController.addTask(new MDIDialogOpenTask(discControl, "Medical.DiscEditor", "Disc Editor", "Developer.DiscEditorIcon", TaskMenuCategories.Developer));
taskController.addTask(new MDIDialogOpenTask(advancedMandibleMovement, "Medical.AdvancedMandibleMovement", "Advanced Mandible Movement", "Developer.MovementIcon", TaskMenuCategories.Developer));
taskController.addTask(new MDIDialogOpenTask(gridProperties, "Medical.GridProperties", "Grid", "Developer.GridIcon", TaskMenuCategories.Developer));
taskController.addTask(new MDIDialogOpenTask(performanceGui, "Medical.Performance", "Performance", "Developer.StatisticsIcon", TaskMenuCategories.Developer));
taskController.addTask(new MDIDialogOpenTask(measurementGUI, "Developer.Measurement", "Measurements", "Developer.Measurements", TaskMenuCategories.Developer));
taskController.addTask(new MDIDialogOpenTask(debugVisualizer, "Developer.DebugVisualizer", "Debug Visualizer", "Developer.DebugVisualizer", TaskMenuCategories.Developer));
taskController.addTask(new MDIDialogOpenTask(advancedCameraGui, "Developer.AdvancedCameraGui", "Advanced Camera Settings", CommonResources.NoIcon, TaskMenuCategories.Developer));
taskController.addTask(new MDIDialogOpenTask(resolutionGui, "Developer.SetResolution", "Set Resolution", CommonResources.NoIcon, TaskMenuCategories.Developer));
taskController.addTask(libRocketDebugger);
taskController.addTask(new SaveMicrocodeCacheTask());
taskController.addTask(new CallbackTask("Developer.SaveToMax", "Save to 3ds Max", "Developer.MaxDumpIcon", TaskMenuCategories.Developer, (item) =>
{
if (!item.Active)
{
item.setActive(true);
MaxExport maxExport = new MaxExport(standaloneController);
guiManager.addManagedDialog(maxExport);
maxExport.Visible = true;
maxExport.Closed += (evt, args) =>
{
maxExport.Dispose();
item.setActive(false);
item.closeTask();
};
}
}));
taskController.addTask(new CallbackTask("Developer.TogglePhysicalTextures", "Toggle Physical Textures", CommonResources.NoIcon, TaskMenuCategories.Developer, (item) =>
{
if (standaloneController.VirtualTextureManager.Active)
{
standaloneController.VirtualTextureManager.suspend();
}
else
{
standaloneController.VirtualTextureManager.resume();
}
}));
taskController.addTask(new CallbackTask("Developer.ToggleCompactMode", "Toggle Compact Mode", CommonResources.NoIcon, TaskMenuCategories.Developer, item =>
{
standaloneController.GUIManager.CompactMode = !standaloneController.GUIManager.CompactMode;
standaloneController.GUIManager.layout();
}));
taskController.addTask(new CallbackTask("Developer.SpawnTestSplint", "Spawn Test Splint", CommonResources.NoIcon, TaskMenuCategories.Developer, item =>
{
GenericSimObjectDefinition def = new GenericSimObjectDefinition("TestSplint" + Guid.NewGuid());
def.addElement(new SceneNodeDefinition("Node"));
var rigidBody = new ReshapeableRigidBodyDefinition("RigidBody");
def.addElement(rigidBody);
MultiProp multiProp = new MultiProp();
def.addElement(new BehaviorDefinition("MultiProp", multiProp));
DynamicSplint splint = new DynamicSplint()
{
MultiPropName = "MultiProp",
};
def.addElement(new BehaviorDefinition("Behavior", splint));
PositionCollection positions;
using (var stream = VirtualFileSystem.Instance.openStream("Plugins/SplintProps/PartModels/SplintSpace.positions", Engine.Resources.FileMode.Open))
{
positions = new PositionCollection(stream);
}
Position position;
if (false)
{
position = positions.getPosition("MaxillaryGroup");
splint.StartIndex = 1;
splint.EndIndex = 17;
rigidBody.Mass = 0;
rigidBody.CollisionFilterMask = -3;
rigidBody.CollisionFilterGroup = 1;
}
else
{
position = positions.getPosition("MandibularGroup");
splint.StartIndex = 17;
splint.EndIndex = 33;
rigidBody.Mass = 1;
rigidBody.CollisionFilterMask = -5;
rigidBody.CollisionFilterGroup = 1;
var joint = new Generic6DofConstraintDefinition(Splint.JointName)
{
RigidBodyASimObject = "Mandible",
RigidBodyAElement = "Actor",
RigidBodyBSimObject = "this",
RigidBodyBElement = "RigidBody",
};
joint.TranslationMotor.LowerLimit = Vector3.Zero;
joint.TranslationMotor.UpperLimit = Vector3.Zero;
joint.XRotMotor.LoLimit = 0;
joint.XRotMotor.HiLimit = 0;
joint.YRotMotor.LoLimit = 0;
joint.YRotMotor.HiLimit = 0;
joint.ZRotMotor.LoLimit = 0;
joint.ZRotMotor.HiLimit = 0;
def.addElement(joint);
def.addElement(new BehaviorDefinition("JointHandler", new MultiPropJointHandler(joint.Name, multiProp.Name)));
//def.addElement(new BehaviorDefinition(Splint.SplintBehaviorName, new Splint()
//{
//}));
}
def.Translation = position.Translation;
def.Rotation = position.Rotation;
PropDefinition propDef = new PropDefinition(def);
standaloneController.PropFactory.addDefinition(propDef);
Vector3 translationOffset = Quaternion.quatRotate(MandibleController.StartRotation.inverse(), position.Translation - MandibleController.StartTranslation);
SimObject mandibleObject = MandibleController.Mandible.Owner;
Vector3 trans = mandibleObject.Translation + Quaternion.quatRotate(mandibleObject.Rotation, translationOffset);
Quaternion rotation = mandibleObject.Rotation;
standaloneController.PropFactory.createProp(def.Name, trans, rotation);
//SimObjectBase instance = def.register(standaloneController.MedicalController.CurrentScene.getDefaultSubScene());
//standaloneController.MedicalController.addSimObject(instance);
//standaloneController.MedicalController.CurrentScene.buildScene();
//if (SimObjectErrorManager.HasErrors)
//{
// standaloneController.NotificationManager.showCallbackNotification("Errors loading the prop.\nClick for details.", MessageBoxIcons.Error, () =>
// {
// SceneErrorWindow errorGui = new SceneErrorWindow(guiManager);
// errorGui.Visible = true;
// });
//}
}));
taskController.addTask(disablePhysics);
taskController.addTask(changeRenderingMode);
#if ALLOW_CRASH_PROGRAM
taskController.addTask(new CallbackTask("Developer.Crash", "Crash The Program", CommonResources.NoIcon, TaskMenuCategories.Developer, (item) =>
{
throw new Exception("Manually crashed program");
}));
#endif
}
standaloneController.ViewHostFactory.addFactory(new WizardComponentViews());
if (PlatformConfig.AllowFullscreenToggle && MedicalConfig.ShowDeveloperTools)
{
CallbackTask toggleBorderless = new CallbackTask("Developer.ToggleBorderless", "Toggle Borderless", "AnomalousMedical/ToggleFullscreen", TaskMenuCategories.Developer, int.MaxValue, false, (item) =>
{
MainWindow.Instance.toggleBorderless();
});
taskController.addTask(toggleBorderless);
}
if (standaloneController.VirtualTextureManager != null && MedicalConfig.ShowDeveloperTools)
{
virtualTextureDebugger = new VirtualTextureDebugger(standaloneController.VirtualTextureManager);
guiManager.addManagedDialog(virtualTextureDebugger);
taskController.addTask(new MDIDialogOpenTask(virtualTextureDebugger, "Developer.VirtualTextureDebugger", "Virtual Texture Debugger", CommonResources.NoIcon, TaskMenuCategories.Developer));
}
var screenshotButtonEvent = new ButtonEvent(EventLayers.Gui, frameUp: (evtMgr) =>
{
try
{
String screenshotFolder = Path.Combine(MedicalConfig.UserDocRoot, "Screenshots");
if (!Directory.Exists(screenshotFolder))
{
Directory.CreateDirectory(screenshotFolder);
}
OgreInterface.Instance.OgrePrimaryWindow.OgreRenderTarget.writeContentsToTimestampedFile(Path.Combine(screenshotFolder, "Screenshot"), ".png");
}
catch (Exception ex)
{
MessageBox.show(String.Format("{0} saving screenshot. Message {1}", ex.GetType().Name, ex.Message), "Error saving screenshot", MessageBoxStyle.IconError | MessageBoxStyle.Ok);
}
});
screenshotButtonEvent.addButton(KeyboardButtonCode.KC_F8);
screenshotButtonEvent.addButton(KeyboardButtonCode.KC_LSHIFT);
standaloneController.MedicalController.EventManager.addEvent(screenshotButtonEvent);
}
public DeveloperAtlasPlugin(StandaloneController standaloneController)
{
this.AllowUninstall = true;
}
public override void createPlugin(StandaloneController standaloneController)
{
standaloneController.AtlasPluginManager.addPlugin(new LecturePlugin());
}
static void HandleOnInitCompleted(AnomalousController anomalousController, StandaloneController controller)
{
touchForwarder = controller.MedicalController.TouchMouseGuiForwarder;
}
static void HandleAddAdditionalPlugins(AnomalousController anomalousController, StandaloneController controller)
{
controller.AtlasPluginManager.addPlugin(new PremiumBodyAtlasPlugin(controller)
{
AllowUninstall = false
});
controller.AtlasPluginManager.addPlugin(new DentalSimPlugin()
{
AllowUninstall = false
});
#if ALLOW_DATA_FILE
controller.AtlasPluginManager.addPlugin(new MovementBodyAtlasPlugin()
{
AllowUninstall = false
});
controller.AtlasPluginManager.addPlugin(new DeveloperAtlasPlugin(controller)
{
AllowUninstall = false
});
#endif
}
void HandleOnInitCompleted(AnomalousController anomalousController, StandaloneController controller)
{
setInputHandler(controller.MedicalController.InputHandler);
printRuntimeInfo();
}
public void unload(StandaloneController standaloneController, bool willReload, bool shuttingDown)
{
standaloneController.MedicalStateController.StateAdded -= MedicalStateController_StateAdded;
standaloneController.MedicalStateController.BlendingStopped -= MedicalStateController_BlendingStopped;
}
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);
}
