public void AddBuiltFile(string filePath) { string fpath = FileService.GetFullPath(filePath); string bd = FileService.GetFullPath(BaseDirectory); if (fpath.StartsWith(bd + Path.DirectorySeparatorChar) || fpath == bd) { string rel = FileService.AbsoluteToRelativePath(bd, fpath); rel = FileService.NormalizeRelativePath(rel); rel = "$(top_builddir)" + Path.DirectorySeparatorChar + rel; builtFiles.Add(rel); } }
public override void ActivateItem() { StockIconsNode node = (StockIconsNode)CurrentNode.DataItem; GtkDesignInfo info = GtkDesignInfo.FromProject(node.Project); GuiBuilderProject gp = info.GuiBuilderProject; Stetic.Project sp = gp.SteticProject; sp.ImagesRootPath = FileService.AbsoluteToRelativePath(info.GtkGuiFolder, gp.Project.BaseDirectory); sp.ImportFileCallback = delegate(string file) { return(GuiBuilderService.ImportFile(gp.Project, file)); }; sp.EditIcons(); gp.Save(true); }
string GetName() { if (ConfigFile.ParentDirectory == WorkspaceFileObject.BaseDirectory) { return(ConfigFile.FileName); } if (!ConfigFile.IsChildPathOf(WorkspaceFileObject.BaseDirectory)) { return(ConfigFile.FileName); } return(FileService.AbsoluteToRelativePath(WorkspaceFileObject.BaseDirectory, ConfigFile)); }
public static string DecodePath(SolutionEntityItem item, string path) { IPathHandler ph = item.GetItemHandler() as IPathHandler; if (ph != null) { return(ph.DecodePath(path)); } else { string basePath = Path.GetDirectoryName(item.FileName); return(FileService.AbsoluteToRelativePath(basePath, path)); } }
static DocumentUserPrefs CreateDocumentPrefs(UserPreferencesEventArgs args, Document document) { string path = (string)document.OriginalFileName ?? document.FileName; var dp = new DocumentUserPrefs(); dp.FileName = FileService.AbsoluteToRelativePath(args.Item.BaseDirectory, path); if (document.GetContent <ITextView> () is ITextView view) { var pos = view.Caret.Position.BufferPosition; var line = pos.Snapshot.GetLineFromPosition(pos.Position); dp.Line = line.LineNumber + 1; dp.Column = pos.Position - line.Start + 1; } return(dp); }
void OnStoringWorkspaceUserPreferences(object s, UserPreferencesEventArgs args) { WorkbenchUserPrefs prefs = new WorkbenchUserPrefs(); foreach (Document document in Documents) { if (!String.IsNullOrEmpty(document.FileName)) { DocumentUserPrefs dp = new DocumentUserPrefs(); dp.FileName = FileService.AbsoluteToRelativePath(args.Item.BaseDirectory, document.FileName); if (document.Editor != null) { dp.Line = document.Editor.Caret.Line; dp.Column = document.Editor.Caret.Column; } prefs.Files.Add(dp); } } foreach (Pad pad in Pads) { IMementoCapable mc = pad.GetMementoCapable(); if (mc != null) { ICustomXmlSerializer mem = mc.Memento; if (mem != null) { PadUserPrefs data = new PadUserPrefs(); data.Id = pad.Id; StringWriter w = new StringWriter(); XmlTextWriter tw = new XmlTextWriter(w); mem.WriteTo(tw); XmlDocument doc = new XmlDocument(); doc.LoadXml(w.ToString()); data.State = doc.DocumentElement; prefs.Pads.Add(data); } } } if (ActiveDocument != null) { prefs.ActiveDocument = FileService.AbsoluteToRelativePath(args.Item.BaseDirectory, ActiveDocument.FileName); } args.Properties.SetValue("MonoDevelop.Ide.Workbench", prefs); }
DataCollection ICustomDataItem.Serialize(ITypeSerializer handler) { DataCollection data = handler.Serialize(this); DataItem items = new DataItem(); items.Name = "Items"; items.UniqueNames = false; string baseDir = Path.GetDirectoryName(handler.SerializationContext.BaseFile); foreach (WorkspaceItem it in Items) { DataValue item = new DataValue("Item", FileService.AbsoluteToRelativePath(baseDir, it.FileName)); items.ItemData.Add(item); } data.Add(items); return(data); }
void AddFile(string fileName) { string relativePath = FileService.AbsoluteToRelativePath(project.BaseDirectory, fileName); TreeIter iter = GetPath(System.IO.Path.GetDirectoryName(relativePath)); object[] values = new object[] { DesktopService.GetPixbufForFile(fileName, IconSize.Menu), null, System.IO.Path.GetFileName(fileName), fileName, false }; if (!store.IterIsValid(iter)) { store.AppendValues(values); return; } store.AppendValues(iter, values); }
public override bool AddToProject(SolutionItem policyParent, Project project, string language, string directory, string name) { bool addedSomething = false; directory = Path.Combine(directory, dirName); if (templates.Count == 0) { string relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, directory); if (project.AddDirectory(relPath) != null) { addedSomething = true; } } foreach (FileDescriptionTemplate t in templates) { addedSomething |= t.AddToProject(policyParent, project, language, directory, name); } return(addedSomething); }
public override void DeleteItem() { GuiBuilderWindow w = (GuiBuilderWindow)CurrentNode.DataItem; string fn = FileService.AbsoluteToRelativePath(w.Project.Project.BaseDirectory, w.SourceCodeFile); using (ConfirmWindowDeleteDialog dialog = new ConfirmWindowDeleteDialog(w.Name, fn, w.RootWidget)) { if (dialog.Run() == (int)Gtk.ResponseType.Yes) { if (dialog.DeleteFile) { ProjectFile file = w.Project.Project.GetProjectFile(w.SourceCodeFile); if (file != null) { w.Project.Project.Files.Remove(file); } } w.Project.Remove(w); w.Project.SaveProject(false); IdeApp.ProjectOperations.SaveAsync(w.Project.Project); } } }
protected virtual void OnButtonBrowseClicked(object sender, System.EventArgs e) { var dlg = new SelectFileDialog(GettextCatalog.GetString("Select File")) { CurrentFolder = entry.BaseDirectory, SelectMultiple = false, TransientFor = this.Toplevel as Gtk.Window, }; if (!dlg.Run()) { return; } if (System.IO.Path.IsPathRooted(dlg.SelectedFile)) { entryCommand.Text = FileService.AbsoluteToRelativePath(entry.BaseDirectory, dlg.SelectedFile); } else { entryCommand.Text = dlg.SelectedFile; } }
void ResultPathDataFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter) { if (TreeIter.Zero.Equals(iter)) { return; } var pathRenderer = (CellRendererText)cell; var searchResult = (SearchResult)store.GetValue(iter, SearchResultColumn); if (searchResult == null) { return; } string pathMarkup = searchResult.PathMarkup; if (pathMarkup == null) { bool didRead = (bool)store.GetValue(iter, DidReadColumn); var fileName = searchResult.FileName; string baseSolutionPath = null; if (pathMode == PathMode.Relative) { var workspace = IdeApp.Workspace; var solutions = workspace != null?workspace.GetAllSolutions() : null; baseSolutionPath = solutions != null && solutions.Count == 1 ? solutions [0].BaseDirectory : null; } var finalFileName = baseSolutionPath == null ? fileName : FileService.AbsoluteToRelativePath(baseSolutionPath, fileName); var directory = System.IO.Path.GetDirectoryName(finalFileName); pathMarkup = MarkupText(directory, didRead); searchResult.PathMarkup = pathMarkup; } pathRenderer.Markup = pathMarkup; }
public string GetRelativePath(Project project, string path, bool isGenerated) { string fpath = Path.GetFullPath(path); string bd = Path.GetFullPath(project.BaseDirectory); if (fpath.StartsWith(bd + Path.DirectorySeparatorChar) || fpath == bd) { string rel = FileService.AbsoluteToRelativePath(bd, fpath); rel = FileService.NormalizeRelativePath(rel); if (isGenerated) { return(rel); } else { return("$(srcdir)" + Path.DirectorySeparatorChar + rel); } } bd = Path.GetFullPath(BaseDirectory); if (fpath.StartsWith(bd + Path.DirectorySeparatorChar) || fpath == bd) { string rel = FileService.AbsoluteToRelativePath(bd, fpath); rel = FileService.NormalizeRelativePath(rel); string file = "$(top_builddir)" + Path.DirectorySeparatorChar + rel; if (builtFiles.Contains(file)) { return(file); } else { globalFilesReferences.Add(file); return("$(top_srcdir)" + Path.DirectorySeparatorChar + rel); } } throw new InvalidOperationException("The project '" + project.Name + "' references the file '" + Path.GetFileName(path) + "' which is located outside the solution directory."); }
public override async Task <bool> AddToProjectAsync(SolutionFolderItem policyParent, Project project, string language, string directory, string name) { bool addedSomething = false; directory = Path.Combine(directory, dirName); if (templates.Count == 0) { string relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, directory); if (project.AddDirectory(relPath) != null) { addedSomething = true; } } foreach (FileDescriptionTemplate t in templates) { if (t.EvaluateCreateCondition()) { addedSomething |= await t.AddToProjectAsync(policyParent, project, language, directory, name); } } return(addedSomething); }
public void IncludeToProject () { Set<SolutionEntityItem> projects = new Set<SolutionEntityItem> (); foreach (ITreeNavigator node in CurrentNodes) { Project project = node.GetParentDataItem (typeof(Project), true) as Project; if (node.HasChildren ()) { List<SystemFile> filesToAdd = new List<SystemFile> (); ITreeNavigator nav = node.Clone (); GetFiles (nav, filesToAdd); foreach (SystemFile file in filesToAdd) project.AddFile (file.Path); projects.Add (project); } else { ProjectFolder pf = node.DataItem as ProjectFolder; if (pf != null) { project.AddDirectory (FileService.AbsoluteToRelativePath (project.BaseDirectory, pf.Path)); projects.Add (project); } } } IdeApp.ProjectOperations.Save (projects); }
void OnStoringWorkspaceUserPreferences(object s, UserPreferencesEventArgs args) { WorkbenchUserPrefs prefs = new WorkbenchUserPrefs(); var nbId = 0; var fwId = 1; foreach (var window in DockWindow.GetAllWindows()) { int x, y; window.GetPosition(out x, out y); var fwp = new FloatingWindowUserPrefs { WindowId = fwId, X = x, Y = y, Width = window.Allocation.Width, Height = window.Allocation.Height }; foreach (var nb in window.Container.GetNotebooks()) { AddNotebookDocuments(args, fwp.Files, nb, nbId++); } if (fwp.Files.Count > 0) { prefs.FloatingWindows.Add(fwp); fwId++; } } var mainContainer = workbench.TabControl.Container; foreach (var nb in mainContainer.GetNotebooks()) { AddNotebookDocuments(args, prefs.Files, nb, nbId++); } foreach (Pad pad in Pads) { IMementoCapable mc = pad.GetMementoCapable(); if (mc != null) { ICustomXmlSerializer mem = mc.Memento; if (mem != null) { PadUserPrefs data = new PadUserPrefs(); data.Id = pad.Id; StringWriter w = new StringWriter(); XmlTextWriter tw = new XmlTextWriter(w); mem.WriteTo(tw); XmlDocument doc = new XmlDocument(); doc.LoadXml(w.ToString()); data.State = doc.DocumentElement; prefs.Pads.Add(data); } } } if (ActiveDocument != null) { prefs.ActiveDocument = FileService.AbsoluteToRelativePath(args.Item.BaseDirectory, ActiveDocument.FileName); } args.Properties.SetValue("MonoDevelop.Ide.Workbench", prefs); }
public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, CSharpResolver resolver, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IEntity entity, bool smartWrap, bool createFooter = false) { var tooltipInfo = new TooltipInformation(); if (resolver == null) { resolver = file != null?file.GetResolver(compilation, textEditorData.Caret.Location) : new CSharpResolver(compilation); } var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions()); sig.BreakLineAfterReturnType = smartWrap; try { tooltipInfo.SignatureMarkup = sig.GetMarkup(entity); } catch (Exception e) { LoggingService.LogError("Got exception while creating markup for :" + entity, e); return(new TooltipInformation()); } tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(entity) ?? ""; if (entity is IMember) { var evt = (IMember)entity; if (evt.ReturnType.Kind == TypeKind.Delegate) { tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(evt.ReturnType)); } } if (entity is IMethod) { var method = (IMethod)entity; if (method.IsExtensionMethod) { tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.DeclaringTypeDefinition.FullName); } } if (createFooter) { if (entity is IType) { var type = entity as IType; var def = type.GetDefinition(); if (def != null) { if (!string.IsNullOrEmpty(def.ParentAssembly.AssemblyName)) { var project = def.GetSourceProject(); if (project != null) { var relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, def.Region.FileName); tooltipInfo.FooterMarkup = "<small>" + GettextCatalog.GetString("Project:\t{0}", AmbienceService.EscapeText(def.ParentAssembly.AssemblyName)) + "</small>" + Environment.NewLine + "<small>" + GettextCatalog.GetString("File:\t\t{0} (line {1})", AmbienceService.EscapeText(relPath), def.Region.Begin.Line) + "</small>"; } } } } else if (entity.DeclaringTypeDefinition != null) { var project = entity.DeclaringTypeDefinition.GetSourceProject(); if (project != null) { var relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, entity.Region.FileName); tooltipInfo.FooterMarkup = "<small>" + GettextCatalog.GetString("Project:\t{0}", AmbienceService.EscapeText(project.Name)) + "</small>" + Environment.NewLine + "<small>" + GettextCatalog.GetString("From:\t{0}", AmbienceService.EscapeText(entity.DeclaringType.FullName)) + "</small>" + Environment.NewLine + "<small>" + GettextCatalog.GetString("File:\t\t{0} (line {1})", AmbienceService.EscapeText(relPath), entity.Region.Begin.Line) + "</small>"; } } } return(tooltipInfo); }
void ProcessProjectReferences(DotNetProject project, out string references, out string dllReferences, AutotoolsContext ctx) { StringWriter refWriter = new StringWriter(); StringWriter dllRefWriter = new StringWriter(); pkgs = new Set <SystemPackage> (); // grab pkg-config references foreach (ProjectReference reference in project.References) { if (reference.ReferenceType == ReferenceType.Package) { // Get pkg-config keys SystemPackage pkg = reference.Package; if (pkg != null && !pkg.IsCorePackage) { if (pkgs.Contains(pkg)) { continue; } pkgs.Add(pkg); refWriter.WriteLine(" \\"); if (generateAutotools) { refWriter.Write("\t$("); refWriter.Write(AutotoolsContext.GetPkgConfigVariable(pkg.Name)); refWriter.Write("_LIBS)"); } else { refWriter.Write("\t-pkg:{0}", pkg.Name); } pkgs.Add(pkg); } else { refWriter.WriteLine(" \\"); // store all refs for easy access AssemblyName assembly = SystemAssemblyService.ParseAssemblyName(reference.Reference); refWriter.Write("\t" + assembly.Name); refWriter.Write(""); } } else if (reference.ReferenceType == ReferenceType.Assembly) { string assemblyPath = Path.GetFullPath(reference.Reference); dllRefWriter.WriteLine(" \\"); dllRefWriter.Write("\t"); ctx.AddGlobalReferencedFile(MakefileData.ToMakefilePath(FileService.AbsoluteToRelativePath( Path.GetFullPath(ctx.BaseDirectory), assemblyPath))); dllRefWriter.Write(MakefileData.ToMakefilePath(FileService.AbsoluteToRelativePath( project.BaseDirectory, assemblyPath))); } else if (reference.ReferenceType == ReferenceType.Project) { continue; // handled per-config } else { throw new Exception(GettextCatalog.GetString("Project reference type '{0}' not supported yet", reference.ReferenceType.ToString())); } } references = refWriter.ToString(); dllReferences = dllRefWriter.ToString(); }
void CreateConfigureDotAC(Solution solution, string defaultConf, IProgressMonitor monitor, AutotoolsContext context) { monitor.Log.WriteLine(GettextCatalog.GetString("Creating configure.ac")); TemplateEngine templateEngine = new TemplateEngine(); templateEngine.Variables["WARNING"] = "Warning: This is an automatically generated file, do not edit!"; // add solution configuration options StringBuilder config_options = new StringBuilder(); foreach (SolutionConfiguration config in solution.Configurations) { string name = context.EscapeAndUpperConfigName(config.Id).ToLower(); string def = config.Id == defaultConf ? "YES" : "NO"; string ac_var = "enable_" + name; // test to see if a configuration was enabled config_options.AppendFormat("AC_ARG_ENABLE({0},\n", name); config_options.AppendFormat(" AC_HELP_STRING([--enable-{0}],\n", name); config_options.AppendFormat(" [Use '{0}' Configuration [default={1}]]),\n", context.EscapeAndUpperConfigName(config.Id), def); config_options.AppendFormat(" {0}=yes, {0}=no)\n", ac_var); config_options.AppendFormat("AM_CONDITIONAL({0}, test x${1} = xyes)\n", ac_var.ToUpper(), ac_var); // if yes, populate some vars config_options.AppendFormat("if test \"x${0}\" = \"xyes\" ; then\n", ac_var); // AppendConfigVariables ( combine, config.Name, config_options ); config_options.Append(" CONFIG_REQUESTED=\"yes\"\nfi\n"); } // if no configuration was specified, set to default (if there is a default) if (defaultConf != null) { config_options.Append("if test -z \"$CONFIG_REQUESTED\" ; then\n"); // AppendConfigVariables ( combine, defaultConf, config_options ); config_options.AppendFormat(" AM_CONDITIONAL(ENABLE_{0}, true)\n", context.EscapeAndUpperConfigName(defaultConf)); config_options.AppendFormat("\tenable_{0}=yes\n", context.EscapeAndUpperConfigName(defaultConf).ToLower()); config_options.Append("fi\n"); } // Add specific user switch if (switchs != null) { foreach (Switch s in switchs) { string name = s.SwitchName.ToLowerInvariant(); config_options.AppendLine(string.Format(@"AC_ARG_ENABLE({0}, AC_HELP_STRING([--enable-{0}], [{1}]), enable_{2}=yes, enable_{2}=no) AM_CONDITIONAL(ENABLE_{3}, test x$enable_{2} = xyes)", name, s.HelpStr, name.Replace('-', '_'), name.Replace('-', '_').ToUpperInvariant())); } } templateEngine.Variables ["CONFIG_OPTIONS"] = config_options.ToString(); // build compiler checks StringBuilder compiler_checks = new StringBuilder(); foreach (string compiler in context.GetCommandChecks()) { compiler_checks.AppendFormat("AC_PATH_PROG({0}, {1}, no)\n", compiler.ToUpper(), compiler); compiler_checks.AppendFormat("if test \"x${0}\" = \"xno\"; then\n", compiler.ToUpper()); compiler_checks.AppendFormat(" AC_MSG_ERROR([{0} Not found])\n", compiler); compiler_checks.Append("fi\n"); } templateEngine.Variables["COMPILER_CHECKS"] = compiler_checks.ToString(); // build list of *.in files StringBuilder configFiles = new StringBuilder(); string tmpmf = null; foreach (string makefile in context.GetAutoConfFiles()) { tmpmf = FileService.AbsoluteToRelativePath(solution_dir, makefile); if (PlatformID.Unix != Environment.OSVersion.Platform) { tmpmf = tmpmf.Replace("\\", "/"); } AutotoolsContext.CheckSpaces(tmpmf); configFiles.Append(FileService.NormalizeRelativePath(tmpmf)); configFiles.Append("\n"); } templateEngine.Variables["CONFIG_FILES"] = configFiles.ToString(); // build list of pkgconfig checks we must make StringWriter packageChecks = new StringWriter(); packageChecks.WriteLine("dnl package checks, common for all configs"); Set <SystemPackage> commonPackages = context.GetCommonRequiredPackages(); foreach (SystemPackage pkg in commonPackages) { packageChecks.WriteLine("PKG_CHECK_MODULES([{0}], [{1}])", AutotoolsContext.GetPkgConfigVariable(pkg.Name), pkg.Name); } packageChecks.WriteLine("\ndnl package checks, per config"); foreach (SolutionConfiguration config in solution.Configurations) { Set <SystemPackage> pkgs = context.GetRequiredPackages(config.Id, true); if (pkgs == null || pkgs.Count == 0) { continue; } packageChecks.WriteLine(@"if test ""x$enable_{0}"" = ""xyes""; then", context.EscapeAndUpperConfigName(config.Id).ToLower()); foreach (SystemPackage pkg in pkgs) { packageChecks.WriteLine("\tPKG_CHECK_MODULES([{0}], [{1}])", AutotoolsContext.GetPkgConfigVariable(pkg.Name), pkg.Name); } packageChecks.WriteLine("fi"); } templateEngine.Variables["PACKAGE_CHECKS"] = packageChecks.ToString(); templateEngine.Variables["SOLUTION_NAME"] = solution_name; templateEngine.Variables["VERSION"] = solution_version; string configureFileName = Path.Combine(solution_dir, "configure.ac"); StreamWriter writer = new StreamWriter(configureFileName); Stream stream = context.GetTemplateStream("configure.ac.template"); StreamReader reader = new StreamReader(stream); templateEngine.Process(reader, writer); reader.Close(); writer.Close(); context.AddGeneratedFile(configureFileName); }
string GetRelativePath(string path) { return(FileService.AbsoluteToRelativePath(project.BaseDirectory, path)); }
public Makefile Deploy(AutotoolsContext ctx, SolutionFolderItem entry, ProgressMonitor monitor) { generateAutotools = ctx.MakefileType == MakefileType.AutotoolsMakefile; monitor.BeginTask(GettextCatalog.GetString( "Creating {0} for Project {1}", generateAutotools ? "Makefile.am" : "Makefile", entry.Name), 1); Makefile makefile = new Makefile(); try { if (!CanDeploy(entry, generateAutotools ? MakefileType.AutotoolsMakefile : MakefileType.SimpleMakefile)) { throw new Exception(GettextCatalog.GetString("Not a deployable project.")); } Project project = entry as Project; TemplateEngine templateEngine = new TemplateEngine(); ISimpleAutotoolsSetup setup = FindSetupForProject(project); // Handle files to be deployed deployDirs = new Dictionary <string, StringBuilder> (); deployFileVars = new Dictionary <string, string> (); builtFiles = new List <string> (); deployFileCopyVars = new StringBuilder(); deployFileCopyTargets = new StringBuilder(); //used only for simple makefile generation templateFilesTargets = null; installTarget = null; installDeps = null; installDirs = null; uninstallTarget = null; // handle configuration specific variables conf_vars = new StringBuilder(); // grab all project files files = new StringBuilder(); res_files = new StringBuilder(); extras = new StringBuilder(); datafiles = new StringBuilder(); Set <string> extraFiles = new Set <string> (); string includes = String.Empty; string references, dllReferences; DotNetProject netProject = project as DotNetProject; ProcessProjectReferences(netProject, out references, out dllReferences, ctx); templateEngine.Variables["REFERENCES"] = references; templateEngine.Variables["DLL_REFERENCES"] = dllReferences; templateEngine.Variables["WARNING"] = "Warning: This is an automatically generated file, do not edit!"; if (entry is DotNetProject dotnetProject) { templateEngine.Variables ["RESGEN"] = "resgen"; } string pfpath = null; foreach (ProjectFile projectFile in project.Files) { pfpath = FileService.NormalizeRelativePath(projectFile.FilePath.ToRelative(project.BaseDirectory)); switch (projectFile.BuildAction) { case BuildAction.Compile: if (projectFile.Subtype != Subtype.Code) { continue; } files.AppendFormat("\\\n\t{0} ", MakefileData.ToMakefilePath(pfpath)); break; case BuildAction.Content: case BuildAction.None: extraFiles.Add(MakefileData.ToMakefilePath(pfpath)); break; case BuildAction.EmbeddedResource: if (!projectFile.FilePath.IsChildPathOf(ctx.BaseDirectory)) { // file is not within directory hierarchy, copy it in string rdir = Path.Combine(Path.GetDirectoryName(project.FileName), resourcedir); if (!Directory.Exists(rdir)) { Directory.CreateDirectory(rdir); } string newPath = Path.Combine(rdir, Path.GetFileName(projectFile.FilePath)); FileService.CopyFile(projectFile.FilePath, newPath); pfpath = project.GetRelativeChildPath(newPath); pfpath = FileService.NormalizeRelativePath(pfpath); } if (!String.IsNullOrEmpty(projectFile.ResourceId) && projectFile.ResourceId != Path.GetFileName(pfpath)) { res_files.AppendFormat("\\\n\t{0},{1} ", MakefileData.ToMakefilePath(pfpath), MakefileData.EscapeString(projectFile.ResourceId)); } else { res_files.AppendFormat("\\\n\t{0} ", MakefileData.ToMakefilePath(pfpath)); } break; case "FileCopy": datafiles.AppendFormat("\\\n\t{0} ", MakefileData.ToMakefilePath(pfpath)); break; } } if (!generateAutotools) { templateFilesTargets = new StringBuilder(); installTarget = new StringBuilder(); uninstallTarget = new StringBuilder(); installDeps = new StringBuilder(); installDirs = new List <string> (); customCommands = new StringBuilder(); string programFilesDir = ctx.DeployContext.GetDirectory(TargetDirectory.ProgramFiles); //FIXME:temp programFilesDir = TranslateDir(programFilesDir); installDirs.Add(programFilesDir); installTarget.Append("\tmake pre-install-local-hook prefix=$(prefix)\n"); installTarget.Append("\tmake install-satellite-assemblies prefix=$(prefix)\n"); installTarget.AppendFormat("\tmkdir -p '$(DESTDIR){0}'\n", programFilesDir); installTarget.AppendFormat("\t$(call cp,$(ASSEMBLY),$(DESTDIR){0})\n", programFilesDir); installTarget.AppendFormat("\t$(call cp,$(ASSEMBLY_MDB),$(DESTDIR){0})\n", programFilesDir); //remove dir? uninstallTarget.Append("\tmake pre-uninstall-local-hook prefix=$(prefix)\n"); uninstallTarget.Append("\tmake uninstall-satellite-assemblies prefix=$(prefix)\n"); uninstallTarget.AppendFormat("\t$(call rm,$(ASSEMBLY),$(DESTDIR){0})\n", programFilesDir); uninstallTarget.AppendFormat("\t$(call rm,$(ASSEMBLY_MDB),$(DESTDIR){0})\n", programFilesDir); installDeps.Append(" $(ASSEMBLY) $(ASSEMBLY_MDB)"); conf_vars.AppendFormat("srcdir=.\n"); conf_vars.AppendFormat("top_srcdir={0}\n\n", FileService.AbsoluteToRelativePath(project.BaseDirectory, ctx.TargetSolution.BaseDirectory)); conf_vars.AppendFormat("include $(top_srcdir)/config.make\n\n"); // Don't emit for top level project makefile(eg. pdn.make), as it would be // included by top level solution makefile if (ctx.TargetSolution.BaseDirectory != project.BaseDirectory) { string customhooks = Path.Combine(project.BaseDirectory, "custom-hooks.make"); bool include = File.Exists(customhooks); includes = "include $(top_srcdir)/Makefile.include\n"; includes += String.Format("{0}include $(srcdir)/custom-hooks.make\n\n", include ? "" : "#"); if (include) { makefile.SetVariable("EXTRA_DIST", "$(srcdir)/custom-hooks.make"); } } } bool buildEnabled; List <ConfigSection> configSections = new List <ConfigSection> (); allDeployVars = new Dictionary <string, DeployFileData> (); foreach (SolutionConfiguration combineConfig in ctx.TargetSolution.Configurations) { DotNetProjectConfiguration config = GetProjectConfig(combineConfig.Id, project, out buildEnabled) as DotNetProjectConfiguration; if (config == null) { continue; } ConfigSection configSection = new ConfigSection(combineConfig.Id); string assembly = MakefileData.GetUnixPath(project.GetRelativeChildPath(config.CompiledOutputName)); configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY_COMPILER_COMMAND = {0}\n", setup.GetCompilerCommand(project, config.Id)); configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY_COMPILER_FLAGS = {0}\n", setup.GetCompilerFlags(project, config.Id)); // add check for compiler command in configure.ac ctx.AddCommandCheck(setup.GetCompilerCommand(project, config.Id)); configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY = {0}\n", AutotoolsContext.EscapeStringForAutomake(assembly)); configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY_MDB = {0}\n", config.DebugSymbols ? "$(ASSEMBLY).mdb" : String.Empty); string target; switch (config.CompileTarget) { case CompileTarget.Exe: target = "exe"; break; case CompileTarget.Library: target = "library"; break; case CompileTarget.WinExe: target = "winexe"; break; case CompileTarget.Module: target = "module"; break; default: throw new Exception(GettextCatalog.GetString("Unknown target {0}", config.CompileTarget)); } configSection.BuildVariablesBuilder.AppendFormat("COMPILE_TARGET = {0}\n", target); // for project references, we need a ref to the dll for the current configuration StringWriter projectReferences = new StringWriter(); string pref = null; foreach (ProjectReference reference in netProject.References) { if (reference.ReferenceType != ReferenceType.Project) { continue; } Project refp = reference.ResolveProject(ctx.TargetSolution); if (refp == null) { throw new Exception(GettextCatalog.GetString("Couldn't find referenced project '{0}'", reference.Reference)); } if (!(refp is DotNetProject)) { continue; } DotNetProjectConfiguration dnpc = GetProjectConfig(combineConfig.Id, refp, out buildEnabled) as DotNetProjectConfiguration; if (dnpc == null) { throw new Exception(GettextCatalog.GetString ("Could not add reference to project '{0}'", refp.Name)); } projectReferences.WriteLine(" \\"); projectReferences.Write("\t"); pref = project.GetRelativeChildPath(dnpc.CompiledOutputName); projectReferences.Write(MakefileData.ToMakefilePath(pref)); } configSection.BuildVariablesBuilder.AppendFormat("PROJECT_REFERENCES = {0}\n", projectReferences.ToString()); string buildDir = project.GetRelativeChildPath(config.OutputDirectory); configSection.BuildVariablesBuilder.AppendFormat("BUILD_DIR = {0}\n", MakefileData.ToMakefilePath(buildDir)); // Register files built by this configuration. // Built files won't be distributed. foreach (string bfile in builtFiles) { ctx.AddBuiltFile(Path.Combine(config.OutputDirectory, bfile)); } DeployFileCollection deployFiles = DeployService.GetDeployFiles( ctx.DeployContext, new SolutionFolderItem[] { project }, config.Selector); ProcessDeployFilesForConfig(deployFiles, project, configSection, ctx, config); configSections.Add(configSection); if (!generateAutotools) { EmitCustomCommandTargets(config.CustomCommands, project, customCommands, combineConfig.Id, new CustomCommandType [] { CustomCommandType.BeforeBuild, CustomCommandType.AfterBuild, CustomCommandType.BeforeClean, CustomCommandType.AfterClean }, monitor); } else { if (config.CustomCommands.Count > 0) { monitor.ReportWarning(GettextCatalog.GetString("Custom commands are not supported for autotools based makefiles. Ignoring.")); } } // Register files generated by the compiler ctx.AddBuiltFile(project.GetOutputFileName(combineConfig.Selector)); if (config.DebugSymbols) { ctx.AddBuiltFile(project.GetOutputFileName(combineConfig.Selector) + ".mdb"); } if (config.SignAssembly) { string spath = project.GetRelativeChildPath(config.AssemblyKeyFile); spath = FileService.NormalizeRelativePath(spath); extraFiles.Add(MakefileData.ToMakefilePath(spath)); } if (buildEnabled && pkgs.Count > 0) { ctx.AddRequiredPackages(combineConfig.Id, pkgs); } } foreach (string ef in extraFiles) { extras.AppendFormat("\\\n\t{0} ", ef); } Dictionary <string, DeployFileData> commonDeployVars = new Dictionary <string, DeployFileData> (allDeployVars); foreach (ConfigSection configSection in configSections) { List <string> toRemove = new List <string> (); foreach (KeyValuePair <string, DeployFileData> pair in commonDeployVars) { if (!configSection.DeployFileVars.ContainsKey(pair.Key)) { toRemove.Add(pair.Key); } } foreach (string s in toRemove) { commonDeployVars.Remove(s); } } //emit the config sections here.. to conf_vars foreach (ConfigSection configSection in configSections) { conf_vars.AppendFormat(generateAutotools ? "if ENABLE_{0}\n" : "ifeq ($(CONFIG),{0})\n", ctx.EscapeAndUpperConfigName(configSection.Name)); conf_vars.Append(configSection.BuildVariablesBuilder.ToString()); conf_vars.Append("\n"); if (ctx.Switches != null) { foreach (Switch s in ctx.Switches) { conf_vars.AppendLine(string.Format(@"if ENABLE_{0} ASSEMBLY_COMPILER_FLAGS += -define:{1} endif", s.SwitchName.Replace('-', '_').ToUpperInvariant(), s.Define)); } } foreach (KeyValuePair <string, DeployFileData> pair in allDeployVars) { string targetDeployVar = pair.Key; if (pair.Value.File.ContainsPathReferences) { //Template files are not handled per-config continue; } if (configSection.DeployFileVars.ContainsKey(targetDeployVar)) { //use the dfile from the config section DeployFile dfile = configSection.DeployFileVars [targetDeployVar]; string fname = MakefileData.ToMakefilePath( FileService.AbsoluteToRelativePath( Path.GetFullPath(project.BaseDirectory), Path.GetFullPath(dfile.SourcePath))); conf_vars.AppendFormat("{0}_SOURCE={1}\n", targetDeployVar, fname); if (!commonDeployVars.ContainsKey(targetDeployVar)) { //FOO_DLL=$(BUILD_DIR)/foo.dll conf_vars.AppendFormat("{0}=$(BUILD_DIR)/{1}\n", targetDeployVar, MakefileData.ToMakefilePath(dfile.RelativeTargetPath)); } } else { // not common and not part of @configSection conf_vars.AppendFormat("{0}=\n", pair.Key); } } conf_vars.Append("\nendif\n\n"); } conf_vars.AppendFormat("AL=al\n"); conf_vars.AppendFormat("SATELLITE_ASSEMBLY_NAME=$(notdir $(basename $(ASSEMBLY))).resources.dll\n"); foreach (KeyValuePair <string, DeployFileData> pair in allDeployVars) { HandleDeployFile(pair.Value, pair.Key, project, ctx); if (commonDeployVars.ContainsKey(pair.Key)) { //FOO_DLL=$(BUILD_DIR)/foo.dll deployFileCopyVars.AppendFormat("{0} = $(BUILD_DIR)/{1}\n", pair.Key, MakefileData.ToMakefilePath(pair.Value.File.RelativeTargetPath)); } } conf_vars.Append('\n'); StringBuilder vars = new StringBuilder(); foreach (KeyValuePair <string, StringBuilder> pair in deployDirs) { //PROGRAM_FILES= .. etc conf_vars.AppendFormat("{0} = {1} \n\n", pair.Key, pair.Value.ToString()); //Build list of deploy dir variables vars.AppendFormat("$({0}) ", pair.Key); } if (!generateAutotools) { installTarget.Insert(0, String.Format("install-local:{0}\n", installDeps.ToString())); installTarget.Append("\tmake post-install-local-hook prefix=$(prefix)\n"); uninstallTarget.Insert(0, String.Format("uninstall-local:{0}\n", installDeps.ToString())); uninstallTarget.Append("\tmake post-uninstall-local-hook prefix=$(prefix)\n"); } if (!generateAutotools && customCommands.Length > 0) { customCommands.Insert(0, "# Targets for Custom commands\n"); } templateEngine.Variables["CONFIG_VARS"] = conf_vars.ToString(); templateEngine.Variables["DEPLOY_FILE_VARS"] = vars.ToString(); templateEngine.Variables["COPY_DEPLOY_FILES_VARS"] = deployFileCopyVars.ToString(); templateEngine.Variables["COPY_DEPLOY_FILES_TARGETS"] = deployFileCopyTargets.ToString(); templateEngine.Variables["ALL_TARGET"] = (ctx.TargetSolution.BaseDirectory == project.BaseDirectory) ? "all-local" : "all"; templateEngine.Variables["INCLUDES"] = includes; templateEngine.Variables["FILES"] = files.ToString(); templateEngine.Variables["RESOURCES"] = res_files.ToString(); templateEngine.Variables["EXTRAS"] = extras.ToString(); templateEngine.Variables["DATA_FILES"] = datafiles.ToString(); templateEngine.Variables["CLEANFILES"] = vars.ToString(); if (!generateAutotools) { templateEngine.Variables["TEMPLATE_FILES_TARGETS"] = templateFilesTargets.ToString(); templateEngine.Variables["INSTALL_TARGET"] = installTarget.ToString(); templateEngine.Variables["UNINSTALL_TARGET"] = uninstallTarget.ToString(); templateEngine.Variables["CUSTOM_COMMAND_TARGETS"] = customCommands.ToString(); } // Create project specific makefile Stream stream = ctx.GetTemplateStream( generateAutotools ? "Makefile.am.project.template" : "Makefile.noauto.project.template"); StreamReader reader = new StreamReader(stream); string txt = templateEngine.Process(reader); reader.Close(); makefile.Append(txt); monitor.Step(1); } finally { monitor.EndTask(); } return(makefile); }
public static async Task IncludeBundleAsync(this Project currentProject, FigmaBundle bundle, bool includeImages = false, bool savesInProject = true) { Ide.IdeApp.Workbench.StatusBar.ShowMessage("Including files into current project…"); var figmaFolder = Path.Combine(currentProject.BaseDirectory.FullPath, FigmaBundle.FigmaDirectoryName); if (!currentProject.PathExistsInProject(figmaFolder)) { //we add figma folder in the case doesn't exists currentProject.AddDirectory(FileService.AbsoluteToRelativePath(currentProject.BaseDirectory, figmaFolder)); } //now we need to add the content //bundle var fullBundlePath = bundle.DirectoryPath; if (!currentProject.PathExistsInProject(fullBundlePath)) { currentProject.AddDirectory(FileService.AbsoluteToRelativePath(currentProject.BaseDirectory, fullBundlePath)); } //manifest var manifestFullDirectoryPath = bundle.ManifestFilePath; if (!currentProject.PathExistsInProject(manifestFullDirectoryPath)) { currentProject.AddFile(manifestFullDirectoryPath); } //document var documentFullDirectoryPath = bundle.DocumentFilePath; if (!currentProject.PathExistsInProject(documentFullDirectoryPath)) { currentProject.AddFile(documentFullDirectoryPath); } //TODO: images are not enabled by now if (includeImages) { //resources var resourcesDirectoryPath = bundle.ResourcesDirectoryPath; currentProject.AddDirectory(FileService.AbsoluteToRelativePath(currentProject.BaseDirectory, resourcesDirectoryPath)); //we add to the project for each resource inside the //foreach (var image in Directory.EnumerateFiles (resourcesDirectoryPath, "*.png")) { // currentProject.AddFile (image); //} var images = Directory.EnumerateFiles(resourcesDirectoryPath, $"*{FigmaBundle.ImageFormat}").Select(s => new FilePath(s)); foreach (var item in images) { if (!currentProject.PathExistsInProject(item)) { var projectFile = new ProjectFile(item, BuildAction.BundleResource); projectFile.Metadata.SetValue("LogicalName", projectFile.ResourceId, ""); currentProject.AddFile(projectFile); } } } if (savesInProject) { await IdeApp.ProjectOperations.SaveAsync(currentProject); } }
// Handle unique deploy files, emits non-perconfig stuff, like targets for deploy files, // un/install commands void HandleDeployFile(DeployFileData data, string targetDeployVar, Project project, AutotoolsContext ctx) { DeployFile dfile = data.File; string dependencyDeployFile = null; //Dependency for the deployfile target if (dfile.ContainsPathReferences) { // Template file, copy to .in file string full_fname = Path.Combine(project.BaseDirectory, Path.GetFileName(dfile.RelativeTargetPath)); string fname = full_fname; string infname = fname + ".in"; if (File.Exists(infname) && project.IsFileInProject(infname)) { string datadir = Path.Combine(project.BaseDirectory, "data"); if (!Directory.Exists(datadir)) { Directory.CreateDirectory(datadir); } infname = Path.Combine(datadir, Path.GetFileName(dfile.RelativeTargetPath) + ".in"); } //Absolute path required File.Copy(dfile.SourcePath, infname, true); //Path relative to TargetCombine fname = FileService.NormalizeRelativePath( FileService.AbsoluteToRelativePath(ctx.TargetSolution.BaseDirectory, full_fname)); infname = fname + ".in"; ctx.AddAutoconfFile(MakefileData.ToMakefilePath(fname)); ctx.AddGeneratedFile(full_fname + ".in"); //Path relative to project fname = FileService.NormalizeRelativePath( FileService.AbsoluteToRelativePath(project.BaseDirectory, full_fname)); infname = fname + ".in"; extras.AppendFormat("\\\n\t{0} ", MakefileData.ToMakefilePath(infname)); //dependencyDeployFile here should be filename relative to the project dependencyDeployFile = fname; } else { dependencyDeployFile = String.Format("$({0}_SOURCE)", targetDeployVar); } builtFiles.Add(Path.GetFileName(dfile.RelativeTargetPath)); if (dfile.ContainsPathReferences) { deployFileCopyTargets.AppendFormat("$(eval $(call emit-deploy-wrapper,{0},{1}{2}))\n", targetDeployVar, MakefileData.ToMakefilePath(dependencyDeployFile), (dfile.FileAttributes & DeployFileAttributes.Executable) != 0 ? ",x" : String.Empty); } else { // The emit-deploy-target macro copies the deployable file to the output directory. // This is not needed if the file is already there (e.g. for an .mdb file) if (Path.GetFullPath(dfile.SourcePath) != Path.GetFullPath(Path.Combine(data.Configuration.OutputDirectory, dfile.RelativeTargetPath))) { deployFileCopyTargets.AppendFormat("$(eval $(call emit-deploy-target,{0}))\n", targetDeployVar); } } switch (dfile.TargetDirectoryID) { case TargetDirectory.Gac: // TODO break; default: string var; if (dfile.TargetDirectoryID != TargetDirectory.Binaries) { string ddir = FileService.NormalizeRelativePath(dfile.RelativeTargetPath.ParentDirectory.ToString().Trim('/', ' ')); if (ddir.Length > 0) { ddir = "/" + ddir; } var = ctx.GetDeployDirectoryVar(dfile.TargetDirectoryID + ddir); } else { var = "BINARIES"; } StringBuilder sb; if (!deployDirs.TryGetValue(var, out sb)) { sb = new StringBuilder(); deployDirs [var] = sb; } sb.AppendFormat("\\\n\t$({0}) ", targetDeployVar); break; } if (!generateAutotools) { string installDir = Path.GetDirectoryName(ctx.DeployContext.GetResolvedPath(dfile.TargetDirectoryID, dfile.RelativeTargetPath)); //FIXME: temp installDir = TranslateDir(installDir); if (!installDirs.Contains(installDir)) { installTarget.AppendFormat("\tmkdir -p '$(DESTDIR){0}'\n", installDir); installDirs.Add(installDir); } installTarget.AppendFormat("\t$(call cp,$({0}),$(DESTDIR){1})\n", targetDeployVar, installDir); uninstallTarget.AppendFormat("\t$(call rm,$({1}),$(DESTDIR){0})\n", installDir, targetDeployVar); } }
public void TestGetRelativePath() { Assert.AreEqual(@"blub", FileService.AbsoluteToRelativePath(@"/a", @"/a/blub")); }
public virtual DataCollection Serialize(object obj, ITypeSerializer handler) { if (obj is ProjectFile) { ProjectFile pf = (ProjectFile)obj; DataCollection data = handler.Serialize(obj); //Map the Content build action to the old FileCopy action if CopyToOutputDirectory is set if (pf.BuildAction == BuildAction.Content && pf.CopyToOutputDirectory != FileCopyMode.None) { DataValue value = data ["buildaction"] as DataValue; if (value != null) { data.Remove(value); data.Add(new DataValue("buildaction", "FileCopy")); data.Extract("copyToOutputDirectory"); } } // Don't store the resource id if it matches the default. if (pf.BuildAction == BuildAction.EmbeddedResource && pf.ResourceId != Path.GetFileName(pf.FilePath)) { data.Add(new DataValue("resource_id", pf.ResourceId)); } return(data); } else if (obj is SolutionEntityItem) { DotNetProject project = obj as DotNetProject; if (project != null) { foreach (DotNetProjectConfiguration config in project.Configurations) { config.ExtendedProperties ["Build/target"] = project.CompileTarget.ToString(); } } DataCollection data = handler.Serialize(obj); SolutionEntityItem item = (SolutionEntityItem)obj; if (item.DefaultConfiguration != null) { DataItem confItem = data ["Configurations"] as DataItem; if (confItem != null) { confItem.UniqueNames = true; if (item.ParentSolution != null) { confItem.ItemData.Add(new DataValue("active", item.ParentSolution.DefaultConfigurationId)); } } } if (project != null) { data.Extract("targetFramework"); data.Add(new DataValue("targetFramework", project.TargetFramework.Id.ToLegacyIdString())); } WriteItems(handler, (SolutionEntityItem)obj, data); return(data); } else if (obj is ProjectReference) { ProjectReference pref = (ProjectReference)obj; DataCollection data = handler.Serialize(obj); string refto = pref.Reference; if (pref.ReferenceType == ReferenceType.Assembly) { string basePath = Path.GetDirectoryName(handler.SerializationContext.BaseFile); refto = FileService.AbsoluteToRelativePath(basePath, refto); } else if (pref.ReferenceType == ReferenceType.Gac && pref.LoadedReference != null) { refto = pref.LoadedReference; } data.Add(new DataValue("refto", refto)); return(data); } return(handler.Serialize(obj)); }
public void TestGetRelativePathCase3() { Assert.AreEqual(@"../a/blub", FileService.AbsoluteToRelativePath(@"/hello", @"/a/blub")); }
public string LocalToVirtualPath(string filename) { string rel = FileService.AbsoluteToRelativePath(BaseDirectory, filename); return("~/" + rel.Replace(Path.DirectorySeparatorChar, '/')); }
public void TestGetRelativePathCase4() { Assert.AreEqual(@".", FileService.AbsoluteToRelativePath(@"/aa/bb/cc", @"/aa/bb/cc")); }
public Makefile Deploy(AutotoolsContext ctx, SolutionItem entry, IProgressMonitor monitor) { generateAutotools = ctx.MakefileType == MakefileType.AutotoolsMakefile; monitor.BeginTask(GettextCatalog.GetString( "Creating {0} for Solution {1}", generateAutotools ? "Makefile.am" : "Makefile", entry.Name), 1); Makefile solutionMakefile = new Makefile(); StringBuilder solutionTop = new StringBuilder(); try { SolutionFolder solutionFolder = (SolutionFolder)entry; string targetDirectory = solutionFolder.BaseDirectory; StringBuilder subdirs = new StringBuilder(); subdirs.Append("#Warning: This is an automatically generated file, do not edit!\n"); if (!generateAutotools) { solutionTop.AppendFormat("top_srcdir={0}\n", FileService.AbsoluteToRelativePath( entry.BaseDirectory, ctx.TargetSolution.BaseDirectory)); solutionTop.Append("include $(top_srcdir)/config.make\n"); solutionTop.Append("include $(top_srcdir)/Makefile.include\n"); solutionTop.Append("include $(top_srcdir)/rules.make\n\n"); solutionTop.Append("#include $(top_srcdir)/custom-hooks.make\n\n"); } ArrayList children = new ArrayList(); foreach (SolutionConfiguration config in solutionFolder.ParentSolution.Configurations) { if (!ctx.IsSupportedConfiguration(config.Id)) { continue; } if (generateAutotools) { subdirs.AppendFormat("if {0}\n", "ENABLE_" + ctx.EscapeAndUpperConfigName(config.Id)); } else { subdirs.AppendFormat("ifeq ($(CONFIG),{0})\n", ctx.EscapeAndUpperConfigName(config.Id)); } subdirs.Append(" SUBDIRS = "); foreach (SolutionItem ce in CalculateSubDirOrder(ctx, solutionFolder, config)) { string baseDirectory; if (!(ce is SolutionEntityItem) && !(ce is SolutionFolder)) { continue; } // Ignore projects which can't be deployed IMakefileHandler handler = AutotoolsContext.GetMakefileHandler(ce, ctx.MakefileType); if (handler == null) { continue; } baseDirectory = ce.BaseDirectory; if (solutionFolder.BaseDirectory == baseDirectory) { subdirs.Append(" . "); } else { if (!baseDirectory.StartsWith(solutionFolder.BaseDirectory)) { throw new Exception(GettextCatalog.GetString( "Child projects must be in sub-directories of their parent")); } // add the subdirectory to the list string path = FileService.AbsoluteToRelativePath(targetDirectory, baseDirectory); if (path.StartsWith("." + Path.DirectorySeparatorChar)) { path = path.Substring(2); } AutotoolsContext.CheckSpaces(path); subdirs.Append(" "); subdirs.Append(AutotoolsContext.EscapeStringForAutomake(path)); } if (!children.Contains(ce)) { children.Add(ce); } } subdirs.Append("\nendif\n"); } solutionTop.Append(subdirs.ToString()); string includedProject = null; // deploy recursively foreach (SolutionItem ce in children) { IMakefileHandler handler = AutotoolsContext.GetMakefileHandler(ce, ctx.MakefileType); Makefile makefile; string outpath; if (handler != null && handler.CanDeploy(ce, ctx.MakefileType)) { ctx.RegisterBuiltProject(ce); makefile = handler.Deploy(ctx, ce, monitor); if (targetDirectory == ce.BaseDirectory) { if (includedProject != null) { throw new Exception(GettextCatalog.GetString( "More than 1 project in the same directory as the top-level solution is not supported.")); } // project is in the solution directory string projectMakefileName = ce.Name + ".make"; includedProject = String.Format("include {0}", projectMakefileName); outpath = Path.Combine(targetDirectory, projectMakefileName); ctx.AddGeneratedFile(outpath); if (!generateAutotools) { solutionMakefile.SetVariable("EXTRA_DIST", projectMakefileName); } } else { makefile.AppendToVariable("EXTRA_DIST", generateAutotools ? String.Empty : "Makefile"); outpath = Path.Combine(ce.BaseDirectory, "Makefile"); if (generateAutotools) { ctx.AddAutoconfFile(outpath); outpath = outpath + ".am"; } else { makefile.Append("install: install-local\nuninstall: uninstall-local\nclean: clean-local\n"); if (ce is SolutionFolder) { //non TargetCombine makefile.Append("dist-local: dist-local-recursive\n"); } else { makefile.Append("include $(top_srcdir)/rules.make\n"); } } ctx.AddGeneratedFile(outpath); } StreamWriter writer = new StreamWriter(outpath); makefile.Write(writer); writer.Close(); } else { monitor.Log.WriteLine("Project '{0}' skipped.", ce.Name); } } if (includedProject != null) { solutionTop.Append(GettextCatalog.GetString("\n# Include project specific makefile\n")); solutionTop.Append(includedProject); } if (generateAutotools) { solutionMakefile.Append(solutionTop.ToString()); } else { TemplateEngine templateEngine = new TemplateEngine(); templateEngine.Variables ["MAKEFILE_SOLUTION_TOP"] = solutionTop.ToString(); Stream stream = ctx.GetTemplateStream("Makefile.solution.template"); StreamReader reader = new StreamReader(stream); StringWriter sw = new StringWriter(); templateEngine.Process(reader, sw); reader.Close(); solutionMakefile.Append(sw.ToString()); if (solutionFolder.IsRoot) { // Emit dist and distcheck targets only for TargetCombine reader = new StreamReader(Path.Combine(ctx.TemplateDir, "make-dist.targets")); solutionMakefile.Append(reader.ReadToEnd()); reader.Close(); } } monitor.Step(1); } finally { monitor.EndTask(); } return(solutionMakefile); }
public void TestGetRelativeGoSeveralUpCaseAtEnd() { Assert.AreEqual(@"../..", FileService.AbsoluteToRelativePath(@"/aa/bb/cc/dd", @"/aa/bb")); }