public String createProject(EditorResourceProvider resourceProvider, string projectName)
{
EmbeddedResourceHelpers.CopyResourceToStream(EmbeddedTemplateNames.SimpleMvcContext_mvc, MvcContextName, resourceProvider, Assembly.GetExecutingAssembly());
DDAtlasPlugin ddPlugin = new DDAtlasPlugin();
ddPlugin.PluginName = projectName;
ddPlugin.PluginNamespace = projectName;
StartAnomalousMvcTask mvcTask = new StartAnomalousMvcTask("Task", projectName, "", "Apps");
mvcTask.ContextFile = MvcContextName;
ddPlugin.addTask(mvcTask);
saveObject(ddPlugin, resourceProvider, "Plugin.ddp");
resourceProvider.createDirectory("", "Timeline");
resourceProvider.createDirectory("", "Resources");
Assembly editorAssembly = Assembly.GetExecutingAssembly();
EmbeddedResourceHelpers.CopyResourceToStream(EmbeddedTemplateNames.MasterTemplate_trml, "MasterTemplate.trml", resourceProvider, Assembly.GetExecutingAssembly());
using (StreamWriter streamWriter = new StreamWriter(resourceProvider.openWriteStream("Index.rml")))
{
streamWriter.Write(indexRml, projectName);
}
return(null);
}
public TemplateSlide createTemplateSlide(EditorResourceProvider resourceProvider)
{
TemplateSlide slide = new TemplateSlide();
slide.LayoutStrategy = LayoutStrategy.createDerivedStrategy(slide, this, resourceProvider, false, true);
return(slide);
}
private void saveObject(Saveable saveable, EditorResourceProvider resourceProvider, String filename)
{
using (XmlTextWriter writer = new XmlTextWriter(resourceProvider.openWriteStream(filename), Encoding.Unicode))
{
writer.Formatting = Formatting.Indented;
EditorController.XmlSaver.saveObject(saveable, writer);
}
}
void editorController_ResourceProviderClosing(EditorResourceProvider obj)
{
if (FilesystemWatcherDisposing != null)
{
FilesystemWatcherDisposing.Invoke(editorFilesystemWatcher);
}
editorFilesystemWatcher.Dispose();
}
void editorController_ResourceProviderOpened(EditorResourceProvider obj)
{
editorFilesystemWatcher = new EditorFilesystemWatcher(obj);
if (FilesystemWatcherCreated != null)
{
FilesystemWatcherCreated.Invoke(editorFilesystemWatcher);
}
}
private void openResourceProvider(String projectPath)
{
resourceProvider = new EditorResourceProvider(projectTypes.openResourceProvider(projectPath));
resourceProviderRocketFSExtension = new ResourceProviderRocketFSExtension(resourceProvider);
RocketInterface.Instance.FileInterface.addExtension(resourceProviderRocketFSExtension);
timelineController.setResourceProvider(ResourceProvider);
if (ResourceProviderOpened != null)
{
ResourceProviderOpened.Invoke(resourceProvider);
}
}
public string createProject(EditorResourceProvider resourceProvider, string projectName)
{
DDAtlasDependency dependency = new DDAtlasDependency()
{
PluginNamespace = projectName,
VersionString = "1.0.0.0",
};
saveObject(dependency, resourceProvider, "Dependency.ddd");
return(null);
}
private void closeResourceProvider()
{
if (resourceProvider != null)
{
if (ResourceProviderClosing != null)
{
ResourceProviderClosing.Invoke(resourceProvider);
}
RocketInterface.Instance.FileInterface.removeExtension(resourceProviderRocketFSExtension);
resourceProviderRocketFSExtension = null;
projectTypes.resourceProviderClosed(resourceProvider.BackingProvider);
resourceProvider = null;
}
}
public EditorFilesystemWatcher(EditorResourceProvider editorResourceProvider)
{
this.editorResourceProvider = editorResourceProvider;
fileWatcher = new FileSystemWatcher(editorResourceProvider.BackingLocation);
fileWatcher.IncludeSubdirectories = true;
fileWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite;
fileWatcher.Created += new FileSystemEventHandler(fileWatcher_Created);
fileWatcher.Deleted += new FileSystemEventHandler(fileWatcher_Deleted);
fileWatcher.Changed += new FileSystemEventHandler(fileWatcher_Changed);
fileWatcher.Renamed += new RenamedEventHandler(fileWatcher_Renamed);
fileWatcher.EnableRaisingEvents = true;
directoryWatcher = new FileSystemWatcher(editorResourceProvider.BackingLocation);
directoryWatcher.IncludeSubdirectories = true;
directoryWatcher.NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.LastWrite;
directoryWatcher.Created += new FileSystemEventHandler(directoryWatcher_Created);
directoryWatcher.Deleted += new FileSystemEventHandler(directoryWatcher_Deleted);
directoryWatcher.Changed += new FileSystemEventHandler(directoryWatcher_Changed);
directoryWatcher.Renamed += new RenamedEventHandler(directoryWatcher_Renamed);
directoryWatcher.EnableRaisingEvents = true;
}
public ResourceProviderTextCachedResource(String file, Encoding textEncoding, String text, EditorResourceProvider resourceProvider)
: base(file, textEncoding, text)
{
this.resourceProvider = resourceProvider;
}
public override SlidePanel clone(Slide originalSlide, Slide destinationSlide, bool asTemplate, EditorResourceProvider resourceProvider)
{
RmlSlidePanel clone;
if (asTemplate)
{
String rml;
try
{
using (StreamReader sr = new StreamReader(resourceProvider.openFile(this.getRmlFilePath(originalSlide))))
{
rml = sr.ReadToEnd();
}
}
catch (Exception ex)
{
rml = "An error occured";
Logging.Log.Warning("{0} when trying to load the rml for slide '{1}'. Message: {2}. Rml not templated", ex.GetType().Name, originalSlide.UniqueName, ex.Message);
}
clone = new RmlSlidePanelTemplate()
{
Rml = rml
};
}
else
{
clone = new RmlSlidePanel();
}
applyToExisting(destinationSlide, clone, true, resourceProvider);
return(clone);
}
public override bool applyToExisting(Slide slide, SlidePanel panel, bool overwriteContent, EditorResourceProvider resourceProvider)
{
if (panel is RmlSlidePanel)
{
if (overwriteContent)
{
((RmlSlidePanel)panel).rmlFile = this.rmlFile;
}
return(base.applyToExisting(slide, panel, overwriteContent, resourceProvider));
}
return(false);
}
public String createProject(EditorResourceProvider resourceProvider, String projectName)
{
return(null);
}
public virtual bool applyToExisting(Slide slide, SlidePanel panel, bool overwriteContent, EditorResourceProvider resourceProvider)
{
panel.Size = this.Size;
panel.ElementName = this.ElementName;
return(true);
}
public String createProject(EditorResourceProvider resourceProvider, string projectName)
{
AnomalousMvcContext mvcContext = new AnomalousMvcContext();
mvcContext.StartupAction = "Common/Startup";
mvcContext.ShutdownAction = "Common/Shutdown";
RmlView view = new RmlView("Index");
view.RmlFile = "Index.rml";
view.ElementName = new BorderLayoutElementName(GUILocationNames.ContentArea, BorderLayoutLocations.Left);
view.Buttons.add(new CloseButtonDefinition("Close", "Common/ExitApp"));
mvcContext.Views.add(view);
mvcContext.Controllers.add(new MvcController("Common",
new RunCommandsAction("Startup",
new SaveCameraPositionCommand(),
new SaveLayersCommand(),
new SaveMusclePositionCommand(),
new SaveMedicalStateCommand(),
new HideMainInterfaceCommand(),
new RunActionCommand("Index/Show")),
new RunCommandsAction("Shutdown",
new RestoreCameraPositionCommand(),
new RestoreLayersCommand(),
new RestoreMusclePositionCommand(),
new RestoreMedicalStateCommand(),
new ShowMainInterfaceCommand()
),
new RunCommandsAction("ExitApp",
new ShutdownCommand())
));
mvcContext.Controllers.add(new MvcController("Index",
new RunCommandsAction("Show",
new PlayTimelineCommand(TimelineName),
new ShowViewCommand("Index")
)
));
saveObject(mvcContext, resourceProvider, MvcContextName);
DDAtlasPlugin ddPlugin = new DDAtlasPlugin();
ddPlugin.PluginName = projectName;
ddPlugin.PluginNamespace = projectName;
StartAnomalousMvcTask mvcTask = new StartAnomalousMvcTask("Task", projectName, "", "Apps");
mvcTask.ContextFile = MvcContextName;
ddPlugin.addTask(mvcTask);
saveObject(ddPlugin, resourceProvider, "Plugin.ddp");
Timeline mainTimeline = new Timeline();
saveObject(mainTimeline, resourceProvider, TimelineName);
resourceProvider.createDirectory("", "Resources");
EmbeddedResourceHelpers.CopyResourceToStream(EmbeddedTemplateNames.MasterTemplate_trml, "MasterTemplate.trml", resourceProvider, Assembly.GetExecutingAssembly());
using (StreamWriter streamWriter = new StreamWriter(resourceProvider.openWriteStream("Index.rml")))
{
streamWriter.Write(indexRml, projectName);
}
return(null);
}
public void copyLayoutToSlide(Slide slide, EditorResourceProvider resourceProvider, bool overwriteContent)
{
slide.LayoutStrategy = LayoutStrategy.createDerivedStrategy(slide, this, resourceProvider, overwriteContent, false);
}
public SlideLayoutStrategy createDerivedStrategy(Slide destinationSlide, Slide thisPanelSlide, EditorResourceProvider resourceProvider, bool overwriteContent, bool createTemplates)
{
SlideLayoutStrategy destinationSlideStrategy = destinationSlide.LayoutStrategy;
BorderSlideLayoutStrategy copiedLayoutStrategy = new BorderSlideLayoutStrategy();
foreach (SlidePanel panel in panels.Values)
{
SlidePanel copiedPanel = destinationSlideStrategy.getPanel(panel.ElementName);
if (copiedPanel != null) //Already exists in the destination, so duplicate it instead of creating a new one
{
copiedPanel = copiedPanel.clone(destinationSlide, destinationSlide, createTemplates, resourceProvider);
panel.applyToExisting(destinationSlide, copiedPanel, overwriteContent, resourceProvider);
}
else
{
copiedPanel = panel.clone(thisPanelSlide, destinationSlide, createTemplates, resourceProvider);
}
copiedLayoutStrategy.addPanel(copiedPanel);
}
return(copiedLayoutStrategy);
}
public override bool applyToExisting(Slide slide, SlidePanel panel, bool overwriteContent, EditorResourceProvider resourceProvider)
{
//Do the base version first, this will fix any filenames
bool result = base.applyToExisting(slide, panel, overwriteContent, resourceProvider);
if (result)
{
if (panel is RmlSlidePanel)
{
String rmlPath = ((RmlSlidePanel)panel).getRmlFilePath(slide);
if (overwriteContent || !resourceProvider.exists(rmlPath))
{
resourceProvider.ResourceCache.add(new ResourceProviderTextCachedResource(rmlPath, Encoding.UTF8, Rml, resourceProvider));
}
}
else
{
result = false;
}
}
return(result);
}
public abstract SlidePanel clone(Slide cloneOwnerSlide, Slide destinationSlide, bool asTemplate, EditorResourceProvider resourceProvider);
public static void CopyResourceToStream(String embeddedResource, String destinationFile, EditorResourceProvider resourceProvider, Assembly assembly)
{
using (Stream stream = resourceProvider.openWriteStream(destinationFile))
{
using (Stream resourceStream = assembly.GetManifestResourceStream(embeddedResource))
{
resourceStream.CopyTo(stream);
}
}
}
