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 bool addDataDrivenPlugin(String path)
{
bool loadedPlugin = false;
String pluginDirectory = null;
String fullPath;
//Try to load from virtual file system first
if (VirtualFileSystem.Instance.directoryExists(path))
{
fullPath = path;
String directoryName = Path.GetFileName(Path.GetDirectoryName(path));
if (!loadedPluginNames.Contains(directoryName))
{
loadedPluginNames.Add(directoryName);
pluginDirectory = String.Format("Plugins/{0}/", directoryName);
}
else
{
Log.Error("Cannot plugin file '{0}' from virtual file system because a plugin named '{1}' is already loaded.", path, directoryName);
}
}
else
{
fullPath = Path.GetFullPath(path);
if (!Directory.Exists(fullPath) && !File.Exists(fullPath))
{
fullPath = Path.Combine(additionalSearchPath, path);
}
if (File.Exists(fullPath))
{
String dataFileName = Path.GetFileNameWithoutExtension(fullPath);
try
{
if (!loadedPluginNames.Contains(dataFileName))
{
//Add the archive to the VirtualFileSystem if needed
if (!VirtualFileSystem.Instance.containsRealAbsolutePath(fullPath))
{
VirtualFileSystem.Instance.addArchive(fullPath);
}
pluginDirectory = String.Format("Plugins/{0}/", Path.GetFileNameWithoutExtension(path));
loadedPluginNames.Add(dataFileName);
}
else
{
Log.Error("Cannot load data file '{0}' from '{1}' because a plugin named '{2}' is already loaded.", path, fullPath, dataFileName);
}
}
catch (ZipAccess.ZipIOException e)
{
firePluginLoadError(String.Format("There was an error loading the plugin '{0}'.", dataFileName));
Log.Error("Cannot load data file '{0}' from '{1}' because of a zip read error: {2}. Deleting corrupted plugin.", path, fullPath, e.Message);
try
{
File.Delete(fullPath);
}
catch (Exception deleteEx)
{
Log.Error("Error deleting data file '{0}' from '{1}' because: {2}.", path, fullPath, deleteEx.Message);
}
}
}
else if (Directory.Exists(fullPath))
{
String directoryName = Path.GetFileName(Path.GetDirectoryName(fullPath));
if (!loadedPluginNames.Contains(directoryName))
{
loadedPluginNames.Add(directoryName);
pluginDirectory = String.Format("Plugins/{0}/", directoryName);
String rootPluginPath = fullPath.Replace("\\", "/");
if (!rootPluginPath.EndsWith("/"))
{
rootPluginPath += "/";
}
rootPluginPath = rootPluginPath.Replace(pluginDirectory, "");
//Add the archive to the VirtualFileSystem if needed
if (!VirtualFileSystem.Instance.containsRealAbsolutePath(rootPluginPath))
{
VirtualFileSystem.Instance.addArchive(rootPluginPath);
}
}
else
{
Log.Error("Cannot load data file '{0}' from '{1}' because a plugin named '{2}' is already loaded.", path, fullPath, directoryName);
}
}
else
{
Log.Error("Cannot load data file '{0}' from '{0}' or '{1}' because it was not found.", path, fullPath, Path.GetFullPath(path));
}
}
if (pluginDirectory != null)
{
String pluginDefinitionFile = pluginDirectory + "Plugin.ddp";
if (VirtualFileSystem.Instance.exists(pluginDefinitionFile))
{
using (Stream pluginStream = VirtualFileSystem.Instance.openStream(pluginDefinitionFile, Engine.Resources.FileMode.Open, Engine.Resources.FileAccess.Read))
{
try
{
DDAtlasPlugin plugin = SharedXmlSaver.Load <DDAtlasPlugin>(pluginStream);
if (plugin != null)
{
plugin.Location = fullPath;
plugin.PluginRootFolder = pluginDirectory;
addPlugin(plugin, false);
loadedPlugin = true;
}
else
{
throw new Exception(String.Format("Error loading '{0}' in path '{1}' from '{2}' because it was null.", pluginDefinitionFile, path, fullPath));
}
}
catch (Exception ex)
{
firePluginLoadError(String.Format("There was an error loading the plugin '{0}'.", Path.GetFileName(fullPath)));
Log.Error(ex.Message);
try
{
File.Delete(fullPath);
}
catch (Exception deleteEx)
{
Log.Error("Error deleting data file '{0}' from '{1}' because: {2}.", path, fullPath, deleteEx.Message);
managePluginInstructions.addFileToDelete(fullPath);
managePluginInstructions.savePersistantFile();
}
}
}
}
if (!loadedPlugin)
{
String dependencyDefinitionFile = pluginDirectory + "Dependency.ddd";
if (VirtualFileSystem.Instance.fileExists(dependencyDefinitionFile))
{
using (Stream stream = VirtualFileSystem.Instance.openStream(dependencyDefinitionFile, Engine.Resources.FileMode.Open, Engine.Resources.FileAccess.Read))
{
try
{
DDAtlasDependency dependency = SharedXmlSaver.Load <DDAtlasDependency>(stream);
if (dependency != null)
{
dependency.Location = fullPath;
dependency.RootFolder = pluginDirectory;
addDependency(dependency);
loadedPlugin = true;
}
else
{
throw new Exception(String.Format("Error loading '{0}' in path '{1}' from '{2}' because it was null.", dependencyDefinitionFile, path, fullPath));
}
}
catch (Exception ex)
{
firePluginLoadError(String.Format("There was an error loading the plugin '{0}'.", Path.GetFileName(fullPath)));
Log.Error(ex.Message);
try
{
File.Delete(fullPath);
}
catch (Exception deleteEx)
{
Log.Error("Error deleting data file '{0}' from '{1}' because: {2}.", path, fullPath, deleteEx.Message);
managePluginInstructions.addFileToDelete(fullPath);
managePluginInstructions.savePersistantFile();
}
}
}
}
else
{
Log.Error("Error loading '{0}' or '{1}' in path '{2}' from '{3}' because it does not exist.", pluginDefinitionFile, dependencyDefinitionFile, path, fullPath);
}
}
}
return(loadedPlugin);
}
public DependencyEditorContext(DDAtlasDependency plugin, String file, DependencyTypeController dependencyTypeController, EditorController editorController, GuiFrameworkUICallback uiCallback)
{
this.dependencyTypeController = dependencyTypeController;
this.currentFile = file;
this.plugin = plugin;
mvcContext = new AnomalousMvcContext();
mvcContext.StartupAction = "Common/Start";
mvcContext.FocusAction = "Common/Focus";
mvcContext.BlurAction = "Common/Blur";
mvcContext.SuspendAction = "Common/Suspended";
mvcContext.ResumeAction = "Common/Resumed";
mvcContext.Models.add(new EditMenuManager());
GenericPropertiesFormView genericPropertiesView = new GenericPropertiesFormView("MvcContext", plugin.EditInterface, editorController, uiCallback, true);
genericPropertiesView.ElementName = new MDILayoutElementName(GUILocationNames.MDI, DockLocation.Left);
mvcContext.Views.add(genericPropertiesView);
EditorTaskbarView taskbar = new EditorTaskbarView("InfoBar", currentFile, "Editor/Close");
taskbar.addTask(new CallbackTask("SaveAll", "Save All", "Editor/SaveAllIcon", "", 0, true, item =>
{
saveAll();
}));
taskbar.addTask(new RunMvcContextActionTask("Save", "Save Dependency Definition File", "CommonToolstrip/Save", "File", "Editor/Save", mvcContext));
mvcContext.Views.add(taskbar);
mvcContext.Controllers.add(new MvcController("Editor",
new RunCommandsAction("Show",
new ShowViewCommand("MvcContext"),
new ShowViewCommand("InfoBar")),
new RunCommandsAction("Close", new CloseAllViewsCommand()),
new CallbackAction("Save", context =>
{
save();
})));
mvcContext.Controllers.add(new MvcController("Common",
new RunCommandsAction("Start", new RunActionCommand("Editor/Show")),
new CallbackAction("Focus", context =>
{
GlobalContextEventHandler.setEventContext(eventContext);
if (Focus != null)
{
Focus.Invoke(this);
}
}),
new CallbackAction("Blur", context =>
{
GlobalContextEventHandler.disableEventContext(eventContext);
if (Blur != null)
{
Blur.Invoke(this);
}
}),
new RunCommandsAction("Suspended", new SaveViewLayoutCommand()),
new RunCommandsAction("Resumed", new RestoreViewLayoutCommand())));
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);
}