/// <seealso cref= InvokeCallbackListener#onResponse(InvokeFuture) </seealso>
public virtual void onResponse(InvokeFuture future)
{
InvokeCallback callback = future.InvokeCallback;
if (callback != null)
{
CallbackTask task = new CallbackTask(this, RemoteAddress, future);
if (callback.Executor != null)
{
// There is no need to switch classloader, because executor is provided by user.
try
{
callback.Executor.execute(task);
}
catch (RejectedExecutionException)
{
logger.LogWarning("Callback thread pool busy.");
}
}
else
{
task.run();
}
}
}
void task_OnClicked(CallbackTask task)
{
if (firstDrag)
{
_fireItemActivated(((CallbackTaskWithObject <ItemType>)task).UserObject);
}
}
private bool openEditorContextForSlide(Slide slide)
{
bool openedEditContext = false;
slideEditorContext = new SlideEditorContext(slide, "Slide " + (slideshow.indexOf(slide) + 1), this, standaloneController, uiCallback, undoBuffer, medicalSlideTemplate, AllowSlideSceneSetup, (panelName, rml) =>
{
slideEditorContext.setWysiwygRml(panelName, rml, true);
});
if (standaloneController.SharePluginController != null)
{
CallbackTask cleanupBeforeShareTask = new CallbackTask("Lecture.SharePluginTask", standaloneController.SharePluginController.Name, standaloneController.SharePluginController.IconName, standaloneController.SharePluginController.Category, 0, false, (item) =>
{
shareSlideshow();
});
slideEditorContext.addTask(cleanupBeforeShareTask);
}
slideEditorContext.Focus += (obj) =>
{
slideEditorContext = obj;
};
slideEditorContext.Blur += obj =>
{
if (slideEditorContext == obj)
{
slideEditorContext.RecordResizeUndo -= slideEditorContext_RecordResizeUndo;
slideEditorContext = null;
}
};
slideEditorContext.RecordResizeUndo += slideEditorContext_RecordResizeUndo;
editorController.runEditorContext(slideEditorContext.MvcContext);
openedEditContext = true;
return(openedEditContext);
}
private void CreateOverrideTaskItem_OnClicked(CallbackTask item)
{
MessageBox.show($"This will override the file at {MedicalConfig.OverrideBackingFile}. Are you sure you want to continue?", "Create Override?", MessageBoxStyle.Yes | MessageBoxStyle.No | MessageBoxStyle.IconQuest, result =>
{
MedicalConfig.saveOverride();
MessageBox.show($"Created override file at {MedicalConfig.OverrideBackingFile}", "Override Created", MessageBoxStyle.Ok | MessageBoxStyle.IconInfo);
});
}
void FixedUpdate()
{
if (nextFixedUpdate != null)
{
var awaiter = nextFixedUpdate.Awaiter;
nextFixedUpdate = null;
awaiter.Complete();
}
}
void Update()
{
if (nextFrame != null)
{
var awaiter = nextFrame.Awaiter;
nextFrame = null;
awaiter.Complete();
}
}
/// <summary>
/// Initializes a new Instance of ExtenedMetroWindow.
/// Begins the startup behaviour:
/// 1. [MTA] Call App.InitializeSession
/// Once done:
/// 2. [MTA] Initialize ViewModel
/// 3. [MTA] Assign dispatcher to ViewModel
/// 4. [SYNC] Call OnInitializeSession
/// Once done:
/// 5. [SYNC] Call OnInitializedViewModel
/// </summary>
public ExtenedMetroWindow()
{
loadingWindow = new LoadingWindow
{
IsIndeterminate = true,
Title = "Loading"
};
CallbackTask.Run(App.InitializeSession, StartUpInitializeSession);
loadingWindow.Show();
}
public void AddCallback(System.Action callback)
{
if (callback != null)
{
var t = mTasks.Count > 0 ? mTasks[mTasks.Count - 1] : null;
var task = t as CallbackTask;
if (task == null)
{
task = new CallbackTask(callback);
AddTask(task);
}
else
{
task.callback += callback;
}
}
}
public CollectedStatisticsWindow()
{
if (Settings.Current.StartupMaximized)
{
WindowState = WindowState.Maximized;
}
loadingWindow = new LoadingWindow
{
IsIndeterminate = true,
Title = App.GetSharedResource("Loading"),
Header = App.GetWindowResource("Stat_LoadingHeader"),
Message = App.GetWindowResource("Stat_LoadingMessage"),
ShowActivated = true
};
loadingWindow.Show();
IsEnabled = false;
CallbackTask.Run(App.InitializeSession, InitializedSession);
logger.TraceResource("WinInit");
InitializeComponent();
logger.TraceResource("WinInitD");
}
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 TypeControllerManager(StandaloneController standaloneController, EditorPlugin plugin)
{
this.standaloneController = standaloneController;
propEditController = plugin.PropEditController;
EditorController editorController = plugin.EditorController;
editorController.ProjectChanged += editorController_ProjectChanged;
editorController.ResourceProviderClosing += editorController_ResourceProviderClosing;
editorController.ResourceProviderOpened += editorController_ResourceProviderOpened;
//MVC Type Controller
MvcTypeController mvcTypeController = new MvcTypeController(editorController);
mvcTypeController.OpenEditor += (file, editingMvcContex) =>
{
mvcEditorContext = new MvcEditorContext(editingMvcContex, file, mvcTypeController, plugin.EditorController, plugin.UICallback);
plugin.UICallback.CurrentEditingMvcContext = editingMvcContex;
if (standaloneController.SharePluginController != null)
{
CallbackTask cleanupBeforeShareTask = new CallbackTask("Lecture.SharePluginTask", standaloneController.SharePluginController.Name, standaloneController.SharePluginController.IconName, standaloneController.SharePluginController.Category, 0, false, (item) =>
{
MessageBox.show("Before sharing your Editor Project it will be saved. Do you wish to continue?", "Share Editor Project", MessageBoxStyle.IconQuest | MessageBoxStyle.Yes | MessageBoxStyle.No, (result) =>
{
if (result == MessageBoxStyle.Yes)
{
editorController.saveAllCachedResources();
standaloneController.SharePluginController.sharePlugin(editorController.ResourceProvider.BackingProvider, PluginCreationTool.EditorTools);
}
});
});
mvcEditorContext.addTask(cleanupBeforeShareTask);
}
mvcEditorContext.Focused += (obj) =>
{
mvcEditorContext = obj;
};
mvcEditorContext.Blured += (obj) =>
{
if (mvcEditorContext == obj)
{
mvcEditorContext = null;
}
};
editorController.runEditorContext(mvcEditorContext.MvcContext);
};
//Rml type controller
RmlTypeController rmlTypeController = new RmlTypeController(editorController);
rmlTypeController.OpenEditor += (file) =>
{
rmlEditorContext = new RmlEditorContext(file, rmlTypeController, mvcTypeController.CurrentObject, plugin.EditorController, plugin.UICallback);
rmlEditorContext.Focus += (obj) =>
{
rmlEditorContext = obj;
};
rmlEditorContext.Blur += obj =>
{
rmlTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (rmlEditorContext == obj)
{
rmlEditorContext = null;
}
};
editorController.runEditorContext(rmlEditorContext.MvcContext);
};
//Rcss Type Controller
RcssTypeController rcssTypeController = new RcssTypeController(editorController);
rcssTypeController.OpenEditor += (file) =>
{
rcssEditorContext = new RcssEditorContext(file, rmlTypeController.LastRmlFile, rcssTypeController);
rcssEditorContext.Focus += (obj) =>
{
rcssEditorContext = obj;
};
rcssEditorContext.Blur += (obj) =>
{
rcssTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (rcssEditorContext == obj)
{
rcssEditorContext = null;
}
};
editorController.runEditorContext(rcssEditorContext.MvcContext);
};
//Plugin type controller
PluginTypeController pluginTypeController = new PluginTypeController(editorController);
pluginTypeController.OpenEditor += (file, ddPlugin) =>
{
pluginEditorContext = new PluginEditorContext(ddPlugin, file, pluginTypeController, plugin.EditorController, plugin.UICallback, standaloneController);
pluginEditorContext.Focus += obj =>
{
pluginEditorContext = obj;
};
pluginEditorContext.Blur += obj =>
{
if (pluginEditorContext == obj)
{
pluginEditorContext = null;
}
};
editorController.runEditorContext(pluginEditorContext.MvcContext);
};
//Dependency type controller
DependencyTypeController dependencyTypeController = new DependencyTypeController(editorController);
dependencyTypeController.OpenEditor += (file, ddDep) =>
{
dependencyEditorContext = new DependencyEditorContext(ddDep, file, dependencyTypeController, plugin.EditorController, plugin.UICallback);
dependencyEditorContext.Focus += obj =>
{
dependencyEditorContext = obj;
};
dependencyEditorContext.Blur += obj =>
{
if (dependencyEditorContext == obj)
{
dependencyEditorContext = null;
}
};
editorController.runEditorContext(dependencyEditorContext.MvcContext);
};
//Movement Sequence type controller
MovementSequenceTypeController movementSequenceTypeController = new MovementSequenceTypeController(editorController);
movementSequenceTypeController.OpenEditor += (file, movementSequence) =>
{
movementSequenceEditorContext = new MovementSequenceEditorContext(movementSequence, file, movementSequenceTypeController);
movementSequenceEditorContext.Focus += obj =>
{
movementSequenceEditorContext = obj;
};
movementSequenceEditorContext.Blur += obj =>
{
if (movementSequenceEditorContext == obj)
{
movementSequenceEditorContext = null;
}
};
editorController.runEditorContext(movementSequenceEditorContext.MvcContext);
};
//Movement Sequence type controller
OffsetSequenceTypeController offsetSequenceTypeController = new OffsetSequenceTypeController(editorController);
offsetSequenceTypeController.OpenEditor += (file, movementSequence) =>
{
offsetSequenceEditorContext = new OffsetSequenceEditorContext(movementSequence, file, offsetSequenceTypeController, plugin.UICallback, plugin.SimObjectMover);
offsetSequenceEditorContext.Focus += obj =>
{
offsetSequenceEditorContext = obj;
};
offsetSequenceEditorContext.Blur += obj =>
{
if (offsetSequenceEditorContext == obj)
{
offsetSequenceEditorContext = null;
}
};
editorController.runEditorContext(offsetSequenceEditorContext.MvcContext);
};
//TRML Type controller
TRmlTypeController trmlTypeController = new TRmlTypeController(editorController);
trmlTypeController.OpenEditor += (file) =>
{
trmlEditorContext = new TRmlEditorContext(file, rmlTypeController.LastRmlFile, trmlTypeController);
trmlEditorContext.Focus += obj =>
{
trmlEditorContext = obj;
};
trmlEditorContext.Blur += obj =>
{
trmlTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (trmlEditorContext == obj)
{
trmlEditorContext = null;
}
};
editorController.runEditorContext(trmlEditorContext.MvcContext);
};
//Timeline type controller
TimelineTypeController timelineTypeController = new TimelineTypeController(editorController);
timelineTypeController.OpenEditor += (file, timeline) =>
{
propEditController.removeAllOpenProps();
timelineEditorContext = new TimelineEditorContext(timeline, file, timelineTypeController, propEditController, standaloneController.PropFactory, plugin.EditorController, plugin.UICallback, plugin.TimelineController);
timelineEditorContext.Focus += obj =>
{
timelineEditorContext = obj;
};
timelineEditorContext.Blur += obj =>
{
if (obj == timelineEditorContext)
{
timelineEditorContext = null;
}
};
editorController.runEditorContext(timelineEditorContext.MvcContext);
};
//Xml Type Controller
XmlTypeController xmlTypeController = new XmlTypeController(editorController);
xmlTypeController.OpenEditor += (file) =>
{
xmlEditorContext = new XmlEditorContext(file, rmlTypeController.LastRmlFile, xmlTypeController);
xmlEditorContext.Focus += (obj) =>
{
xmlEditorContext = obj;
};
xmlEditorContext.Blur += (obj) =>
{
xmlTypeController.updateCachedText(obj.CurrentFile, obj.CurrentText);
if (xmlEditorContext == obj)
{
xmlEditorContext = null;
}
};
editorController.runEditorContext(xmlEditorContext.MvcContext);
};
//Prop type controller
PropTypeController propTypeController = new PropTypeController(editorController);
propTypeController.OpenEditor += (file, propDefinition) =>
{
propEditorContext = new PropEditorContext(propDefinition, file, propTypeController, plugin.EditorController, plugin.UICallback);
propEditorContext.Focus += obj =>
{
propEditorContext = obj;
};
propEditorContext.Blur += obj =>
{
if (propEditorContext == obj)
{
propEditorContext = null;
}
};
editorController.runEditorContext(propEditorContext.MvcContext);
};
//Add item templates
editorController.addItemTemplate(new EmptyViewItemTemplate(rmlTypeController, mvcTypeController));
editorController.addItemTemplate(new ViewWithTimelineItemTemplate(rmlTypeController, mvcTypeController, timelineTypeController));
//Add type controllers to editor controller, this also adds some item templates
editorController.addTypeController(timelineTypeController);
editorController.addTypeController(movementSequenceTypeController);
editorController.addTypeController(offsetSequenceTypeController);
editorController.addTypeController(rmlTypeController);
editorController.addTypeController(trmlTypeController);
editorController.addTypeController(rcssTypeController);
editorController.addTypeController(mvcTypeController);
editorController.addTypeController(pluginTypeController);
editorController.addTypeController(dependencyTypeController);
editorController.addTypeController(xmlTypeController);
editorController.addTypeController(propTypeController);
//Add any final item templates
editorController.addItemTemplate(new PluginBrandingResourceItemTemplate());
}
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 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();
};
}
/// <summary>
/// Starts the methodToCall asynchronously and waits for its completion.
/// </summary>
public void StartServiceAndWait()
{
serviceTask.Start(TaskScheduler.Default);
CallbackTask.Wait();
}
public void initialize(StandaloneController standaloneController)
{
standaloneController.DocumentController.addDocumentHandler(new PatientDocumentHandler(standaloneController));
this.standaloneController = standaloneController;
standaloneController.PatientDataController.PatientDataChanged += new Action <PatientDataFile>(PatientDataController_PatientDataChanged);
GUIManager guiManager = standaloneController.GUIManager;
//Dialogs
mandibleMovementDialog = new MandibleMovementDialog(standaloneController.MovementSequenceController, standaloneController.MusclePositionController);
guiManager.addManagedDialog(mandibleMovementDialog);
notesDialog = new NotesDialog(standaloneController.MedicalStateController);
guiManager.addManagedDialog(notesDialog);
stateList = new StateListDialog(standaloneController.MedicalStateController);
guiManager.addManagedDialog(stateList);
savePatientDialog = new SavePatientDialog(guiManager);
savePatientDialog.SaveFile += new EventHandler(savePatientDialog_SaveFile);
openPatientDialog = new OpenPatientDialog(guiManager);
openPatientDialog.OpenFile += new EventHandler(openPatientDialog_OpenFile);
//Tasks Menu
TaskController taskController = standaloneController.TaskController;
AnatomyTaskManager anatomyTasks = standaloneController.AnatomyTaskManager;
taskController.addTask(new ShowToothContactsTask(0));
PinableMDIDialogOpenTask mandibleMovementTask = new PinableMDIDialogOpenTask(mandibleMovementDialog, "Medical.ManualMovement", "Manual Movement", "DentalSimIcons/ManualMovement", "Dental Simulation", 2);
taskController.addTask(mandibleMovementTask);
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.Eminence", "Eminence", "DentalSimIcons/Eminence", "Dental Simulation", GetType(), "DentalSim.Wizards.", "Eminence.mvc", standaloneController.TimelineController, standaloneController.MvcCore), new String[] { "Outer Skull", "Inner Skull" });
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.Dentition", "Dentition", "DentalSimIcons/Dentition", "Dental Simulation", GetType(), "DentalSim.Wizards.", "Dentition.mvc", standaloneController.TimelineController, standaloneController.MvcCore), TeethNames);
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.DiscClockFace", "Disc Clock Face", "DentalSimIcons/DiscClockFace", "Dental Simulation", GetType(), "DentalSim.Wizards.DiscClock.", "DiscClockFace.mvc", standaloneController.TimelineController, standaloneController.MvcCore, true), new String[] { "Left TMJ Disc", "Right TMJ Disc" });
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.Mandible", "Mandible", "DentalSimIcons/Mandible", "Dental Simulation", GetType(), "DentalSim.Wizards.", "Mandible.mvc", standaloneController.TimelineController, standaloneController.MvcCore), new String[] { "Mandible" });
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.ClinicalDoppler", "Doppler", "DentalSimIcons/ClinicalDoppler", "Dental Simulation", GetType(), "DentalSim.Wizards.ClinicalDoppler.", "ClinicalDoppler.mvc", standaloneController.TimelineController, standaloneController.MvcCore), new String[] { "Left TMJ Disc", "Right TMJ Disc", "Mandible" });
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.ClinicalCT", "CT", "DentalSimIcons/ClinicalCT", "Dental Simulation", GetType(), "DentalSim.Wizards.ClinicalCT.", "ClinicalCT.mvc", standaloneController.TimelineController, standaloneController.MvcCore), new String[] { "Left TMJ Disc", "Right TMJ Disc", "Mandible" });
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.ClinicalMRI", "MRI", "DentalSimIcons/ClinicalMRI", "Dental Simulation", GetType(), "DentalSim.Wizards.ClinicalMRI.", "ClinicalMRI.mvc", standaloneController.TimelineController, standaloneController.MvcCore), new String[] { "Left TMJ Disc", "Right TMJ Disc", "Mandible" });
anatomyTasks.addTask(new StartEmbeddedMvcTask("DentalSim.ClinicalOrthoAndSkeletal", "Orthodontic and Skeletal", "DentalSimIcons/ClinicalOrthodonticAndSkeletal", "Dental Simulation", GetType(), "DentalSim.Wizards.", "ClinicalOrthoAndSkeletal.mvc", standaloneController.TimelineController, standaloneController.MvcCore), new String[] { "Left TMJ Disc", "Right TMJ Disc", "Mandible" });
taskController.addTask(new ShowPopupTask(openPatientDialog, "Medical.OpenPatient", "Open", "DentalSimIcons/Open", TaskMenuCategories.Scene, 1));
PinableMDIDialogOpenTask statesTask = new PinableMDIDialogOpenTask(stateList, "Medical.StateList", "States", "DentalSimIcons/StatesIcon", TaskMenuCategories.Scene);
taskController.addTask(statesTask);
PinableMDIDialogOpenTask notesTask = new PinableMDIDialogOpenTask(notesDialog, "Medical.Notes", "Notes", "DentalSimIcons/NotesIcon", TaskMenuCategories.Scene);
taskController.addTask(notesTask);
CallbackTask saveTaskItem = new CallbackTask("Medical.SavePatient", "Save", "CommonToolstrip/Save", TaskMenuCategories.Scene, 2, false);
saveTaskItem.OnClicked += new CallbackTask.ClickedCallback(saveTaskItem_OnClicked);
taskController.addTask(saveTaskItem);
CallbackTask saveAsTaskItem = new CallbackTask("Medical.SavePatientAs", "Save As", "CommonToolstrip/SaveAs", TaskMenuCategories.Scene, 3, false);
saveAsTaskItem.OnClicked += new CallbackTask.ClickedCallback(saveAsTaskItem_OnClicked);
taskController.addTask(saveAsTaskItem);
//Movement Sequences
MovementSequenceController movementSequenceController = standaloneController.MovementSequenceController;
Assembly assembly = GetType().Assembly;
//Border Movements
movementSequenceController.addMovementSequence("Border Movements", new EmbeddedMovementSequenceInfo(assembly, "Posselt Sagittal", "DentalSim.Sequences.BorderMovements.Posselt Sagittal.seq"));
//Excursion
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Left Tooth Contact Bruxism", "DentalSim.Sequences.Excursion.Left Tooth Contact Bruxism.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Left Tooth Contact Maximal", "DentalSim.Sequences.Excursion.Left Tooth Contact Maximal.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Left Tooth Contact", "DentalSim.Sequences.Excursion.Left Tooth Contact.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Open Bilateral", "DentalSim.Sequences.Excursion.Open Bilateral.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Open Left", "DentalSim.Sequences.Excursion.Open Left.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Open Right", "DentalSim.Sequences.Excursion.Open Right.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Right Tooth Contact Bruxism", "DentalSim.Sequences.Excursion.Right Tooth Contact Bruxism.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Right Tooth Contact Maximal", "DentalSim.Sequences.Excursion.Right Tooth Contact Maximal.seq"));
movementSequenceController.addMovementSequence("Excursion", new EmbeddedMovementSequenceInfo(assembly, "Right Tooth Contact", "DentalSim.Sequences.Excursion.Right Tooth Contact.seq"));
//Normal Chewing
movementSequenceController.addMovementSequence("Normal Chewing", new EmbeddedMovementSequenceInfo(assembly, "Chewing Left Side", "DentalSim.Sequences.NormalChewing.Chewing Left Side.seq"));
movementSequenceController.addMovementSequence("Normal Chewing", new EmbeddedMovementSequenceInfo(assembly, "Chewing Right Side", "DentalSim.Sequences.NormalChewing.Chewing Right Side.seq"));
//Protrusion
movementSequenceController.addMovementSequence("Protrusion", new EmbeddedMovementSequenceInfo(assembly, "Open Protrusion", "DentalSim.Sequences.Protrusion.Open Protrusion.seq"));
movementSequenceController.addMovementSequence("Protrusion", new EmbeddedMovementSequenceInfo(assembly, "Protrusion Maximal", "DentalSim.Sequences.Protrusion.Protrusion Maximal.seq"));
movementSequenceController.addMovementSequence("Protrusion", new EmbeddedMovementSequenceInfo(assembly, "Protrusion Tooth Contact Edge to Edge", "DentalSim.Sequences.Protrusion.Protrusion Tooth Contact Edge to Edge.seq"));
//Vertical Opening
movementSequenceController.addMovementSequence("Vertical Opening", new EmbeddedMovementSequenceInfo(assembly, "Hinge Opening", "DentalSim.Sequences.VerticalOpening.Hinge Opening.seq"));
movementSequenceController.addMovementSequence("Vertical Opening", new EmbeddedMovementSequenceInfo(assembly, "Maximal Opening", "DentalSim.Sequences.VerticalOpening.Maximal Opening.seq"));
movementSequenceController.addMovementSequence("Vertical Opening", new EmbeddedMovementSequenceInfo(assembly, "Tapping Teeth", "DentalSim.Sequences.VerticalOpening.Tapping Teeth.seq"));
}
