public ExportSolutionDialog(WorkspaceItem item, FileFormat selectedFormat) { this.Build(); labelNewFormat.Text = item.FileFormat.Name; formats = Services.ProjectService.FileFormats.GetFileFormatsForObject (item); foreach (FileFormat format in formats) comboFormat.AppendText (format.Name); int sel = Array.IndexOf (formats, selectedFormat); if (sel == -1) sel = 0; comboFormat.Active = sel; if (formats.Length < 2) { table.Remove (newFormatLabel); newFormatLabel.Destroy (); newFormatLabel = null; table.Remove (comboFormat); comboFormat.Destroy (); comboFormat = null; } //auto height folderEntry.WidthRequest = 380; Resize (1, 1); folderEntry.Path = item.ItemDirectory; UpdateControls (); }
public override TargetFrameworkMoniker GetDefaultTargetFrameworkForFormat (FileFormat format) { // Note: This value is used only when serializing the TargetFramework to the .csproj file. // Any component of the TargetFramework that is different from this base TargetFramework // value will be serialized. // // Therefore, if we only specify the TargetFrameworkIdentifier, then both the // TargetFrameworkVersion and TargetFrameworkProfile values will be serialized. return new TargetFrameworkMoniker (".NETPortable", "1.0"); }
public override bool SupportsFormat (FileFormat format) { int version; if (!format.Id.StartsWith ("MSBuild")) return false; if (!int.TryParse (format.Id.Substring ("MSBuild".Length), out version)) return false; return version >= 10; }
public override TargetFrameworkMoniker GetDefaultTargetFrameworkForFormat (FileFormat format) { switch (format.Id) { case "MSBuild05": return TargetFrameworkMoniker.NET_2_0; case "MSBuild08": return TargetFrameworkMoniker.NET_2_0; case "MSBuild10": return TargetFrameworkMoniker.NET_4_0; } return Services.ProjectService.DefaultTargetFramework.Id; }
public ExportProjectDialog (IWorkspaceObject entry, FileFormat selectedFormat) { this.Build(); FileFormat f = entry is WorkspaceItem ? ((WorkspaceItem)entry).FileFormat : ((SolutionEntityItem)entry).FileFormat; labelNewFormat.Text = f.Name; formats = Services.ProjectService.FileFormats.GetFileFormatsForObject (entry); foreach (FileFormat format in formats) comboFormat.AppendText (format.Name); int sel = Array.IndexOf (formats, selectedFormat); if (sel == -1) sel = 0; comboFormat.Active = sel; folderEntry.Path = entry.ItemDirectory; UpdateControls (); }
public SourcesZipEditorWidget (PackageBuilder target, FileFormat selectedFormat) { this.Build(); this.target = (SourcesZipPackageBuilder) target; loading = true; if (target.RootSolutionItem is SolutionFolder) formats = Services.ProjectService.FileFormats.GetFileFormatsForObject (target.Solution); else formats = Services.ProjectService.FileFormats.GetFileFormatsForObject (target.RootSolutionItem); if (selectedFormat == null) selectedFormat = this.target.FileFormat; if (selectedFormat == null) selectedFormat = formats [0]; int sel = 0; for (int n=0; n<formats.Length; n++) { comboFormat.AppendText (formats[n].Name); if (formats[n].Name == selectedFormat.Name) sel = n; } comboFormat.Active = sel; this.target.FileFormat = formats [sel]; string[] archiveFormats = DeployService.SupportedArchiveFormats; int zel = 1; for (int n=0; n<archiveFormats.Length; n++) { comboZip.AppendText (archiveFormats [n]); if (this.target.TargetFile.EndsWith (archiveFormats [n])) zel = n; } if (!string.IsNullOrEmpty (this.target.TargetFile)) { string ext = archiveFormats [zel]; folderEntry.Path = System.IO.Path.GetDirectoryName (this.target.TargetFile); entryZip.Text = System.IO.Path.GetFileName (this.target.TargetFile.Substring (0, this.target.TargetFile.Length - ext.Length)); comboZip.Active = zel; } loading = false; }
FilePath WriteFile (IProgressMonitor monitor, FilePath file, object item, FileFormat format) { if (format == null) { if (defaultFormat.CanWrite (item)) format = defaultFormat; else { FileFormat[] formats = formatManager.GetFileFormatsForObject (item); format = formats.Length > 0 ? formats [0] : null; } if (format == null) return null; file = format.GetValidFileName (item, file); } FileService.RequestFileEdit (file); format.Format.WriteFile (file, item, monitor); return file; }
public int Run(string[] arguments) { if (arguments.Length == 0 || arguments [0] == "--help") { Console.WriteLine(""); Console.WriteLine("Project Export Tool"); Console.WriteLine("Usage: mdtool project-export <source-project-file> [-d:dest-path] [-f:format-name]"); Console.WriteLine(""); Console.WriteLine("Options"); Console.WriteLine(" -d:<dest-path> Directory where the project will be exported."); Console.WriteLine(" -f:\"<format-name>\" Format to which export the project or solution."); Console.WriteLine(" -l Show a list of all allowed target formats."); Console.WriteLine(" -p:<project-name> When exporting a solution, name of a project to be"); Console.WriteLine(" included in the export. It can be specified multiple"); Console.WriteLine(" times."); Console.WriteLine(""); Console.WriteLine(" The format name is optional. A list of allowed file formats will be"); Console.WriteLine(" shown if none is provided."); Console.WriteLine(""); return(0); } string projectFile = null; string destPath = null; string formatName = null; bool formatList = false; List <string> projects = new List <string> (); string[] itemsToExport = null; foreach (string s in arguments) { if (s.StartsWith("-d:")) { destPath = s.Substring(3); } else if (s.StartsWith("-f:")) { formatName = s.Substring(3); } else if (s.StartsWith("-p:")) { projects.Add(s.Substring(3)); } else if (s == "-l") { formatList = true; } else if (projectFile != null) { Console.WriteLine("Only one project can be converted at a time."); return(1); } else { projectFile = s; } } if (projectFile == null) { Console.WriteLine("Project or solution file name not provided."); return(1); } projectFile = FileService.GetFullPath(projectFile); if (!File.Exists(projectFile)) { Console.WriteLine("File {0} not found.", projectFile); return(1); } ConsoleProgressMonitor monitor = new ConsoleProgressMonitor(); monitor.IgnoreLogMessages = true; object item; if (Services.ProjectService.IsWorkspaceItemFile(projectFile)) { item = Services.ProjectService.ReadWorkspaceItem(monitor, projectFile); if (projects.Count > 0) { Solution sol = item as Solution; if (sol == null) { Console.WriteLine("The -p option can only be used when exporting a solution."); return(1); } for (int n = 0; n < projects.Count; n++) { string pname = projects [n]; if (pname.Length == 0) { Console.WriteLine("Project name not specified in -p option."); return(1); } Project p = sol.FindProjectByName(pname); if (p == null) { Console.WriteLine("Project '" + pname + "' not found in solution."); return(1); } projects[n] = p.ItemId; } itemsToExport = projects.ToArray(); } } else { if (projects.Count > 0) { Console.WriteLine("The -p option can't be used when exporting a single project"); return(1); } item = Services.ProjectService.ReadSolutionItem(monitor, projectFile); } FileFormat[] formats = Services.ProjectService.FileFormats.GetFileFormatsForObject(item); if (formats.Length == 0) { Console.WriteLine("Can't convert file to any format: " + projectFile); return(1); } FileFormat format = null; if (formatName == null || formatList) { Console.WriteLine(); Console.WriteLine("Target formats:"); for (int n = 0; n < formats.Length; n++) { Console.WriteLine(" {0}. {1}", n + 1, formats [n].Name); } Console.WriteLine(); if (formatList) { return(0); } int op = 0; do { Console.Write("Convert to format: "); string s = Console.ReadLine(); if (s.Length == 0) { return(1); } if (int.TryParse(s, out op)) { if (op > 0 && op <= formats.Length) { break; } } } while (true); format = formats [op - 1]; } else { foreach (FileFormat f in formats) { if (f.Name == formatName) { format = f; } } if (format == null) { Console.WriteLine("Unknown file format: " + formatName); return(1); } } if (destPath == null) { destPath = Path.GetDirectoryName(projectFile); } destPath = FileService.GetFullPath(destPath); string ofile = Services.ProjectService.Export(monitor, projectFile, itemsToExport, destPath, format); if (ofile != null) { Console.WriteLine("Saved file: " + ofile); return(0); } else { Console.WriteLine("Project export failed."); return(1); } }
public string Export(IProgressMonitor monitor, string rootSourceFile, string[] includedChildIds, string targetPath, FileFormat format) { IWorkspaceFileObject obj; if (IsWorkspaceItemFile(rootSourceFile)) { obj = ReadWorkspaceItem(monitor, rootSourceFile) as Solution; } else { obj = ReadSolutionItem(monitor, rootSourceFile); if (obj == null) { throw new InvalidOperationException("File is not a solution or project."); } } using (obj) { return(Export(monitor, obj, includedChildIds, targetPath, format)); } }
object ReadFile (IProgressMonitor monitor, string file, Type expectedType, out FileFormat format) { FileFormat[] formats = formatManager.GetFileFormats (file, expectedType); if (formats.Length == 0) throw new InvalidOperationException ("Unknown file format: " + file); format = formats [0]; object obj = format.Format.ReadFile (file, expectedType, monitor); if (obj == null) throw new InvalidOperationException ("Invalid file format: " + file); return obj; }
static void SetClosestSupportedTargetFramework (FileFormat format, DotNetProject project) { // If the solution format can't write this project due to an unsupported framework, try finding the // closest valid framework. DOn't worry about whether it's installed, that's up to the user to correct. TargetFramework curFx = project.TargetFramework; var candidates = Runtime.SystemAssemblyService.GetTargetFrameworks () .Where (fx => //only frameworks with the same ID, else version comparisons are meaningless fx.Id.Identifier == curFx.Id.Identifier && //don't consider profiles, only full frameworks fx.Id.Profile == null && //and the project and format must support the framework project.SupportsFramework (fx) && format.SupportsFramework (fx)) //FIXME: string comparisons aren't a valid way to compare profiles, but it works w/released .NET versions .OrderBy (fx => fx.Id.Version) .ToList (); TargetFramework newFx = candidates.FirstOrDefault (fx => string.CompareOrdinal (fx.Id.Version, curFx.Id.Version) > 0) ?? candidates.LastOrDefault (); if (newFx != null) project.TargetFramework = newFx; }
public void TryFixingFramework (FileFormat format, DotNetProject item) { // If the solution format can't write this project it may be due to an unsupported // framework. Try finding a compatible framework. TargetFramework curFx = item.TargetFramework; foreach (TargetFramework fx in Runtime.SystemAssemblyService.GetTargetFrameworks ()) { item.TargetFramework = fx; if (format.CanWrite (item)) return; } item.TargetFramework = curFx; }
public virtual bool SupportsFormat(FileFormat format) { return(true); }
public override void CopyFrom (PackageBuilder other) { base.CopyFrom (other); SourcesZipPackageBuilder builder = (SourcesZipPackageBuilder) other; targetFile = builder.targetFile; format = builder.format; fileFormat = builder.fileFormat; }
public override void InitializeSettings (SolutionItem entry) { targetFile = Path.Combine (entry.BaseDirectory, entry.Name) + ".tar.gz"; if (entry.ParentSolution != null) fileFormat = entry.ParentSolution.FileFormat; }
public override TargetFrameworkMoniker GetDefaultTargetFrameworkForFormat(FileFormat format) { //Keep default version invalid(1.0) or MonoDevelop will omit from serialization return new TargetFrameworkMoniker(".NETMicroFramework", "1.0"); }
internal ProjectService () { AddinManager.AddExtensionNodeHandler (FileFormatsExtensionPath, OnFormatExtensionChanged); AddinManager.AddExtensionNodeHandler (SerializableClassesExtensionPath, OnSerializableExtensionChanged); AddinManager.AddExtensionNodeHandler (ExtendedPropertiesExtensionPath, OnPropertiesExtensionChanged); AddinManager.AddExtensionNodeHandler (ProjectBindingsExtensionPath, OnProjectsExtensionChanged); AddinManager.ExtensionChanged += OnExtensionChanged; defaultFormat = formatManager.GetFileFormat (MSBuildProjectService.DefaultFormat); }
public void RegisterFileFormat (IFileFormat format, string id, string name, bool canDefault) { FileFormat f = new FileFormat (format, id, name, canDefault); fileFormats.Add (f); }
string Export(IProgressMonitor monitor, IWorkspaceFileObject obj, string[] includedChildIds, string targetPath, FileFormat format) { string rootSourceFile = obj.FileName; string sourcePath = Path.GetFullPath(Path.GetDirectoryName(rootSourceFile)); targetPath = Path.GetFullPath(targetPath); if (sourcePath != targetPath) { if (!CopyFiles(monitor, obj, obj.GetItemFiles(true), targetPath, true)) { return(null); } string newFile = Path.Combine(targetPath, Path.GetFileName(rootSourceFile)); if (IsWorkspaceItemFile(rootSourceFile)) { obj = ReadWorkspaceItem(monitor, newFile); } else { obj = (SolutionEntityItem)ReadSolutionItem(monitor, newFile); } using (obj) { List <FilePath> oldFiles = obj.GetItemFiles(true); ExcludeEntries(obj, includedChildIds); if (format != null) { obj.ConvertToFormat(format, true); } obj.Save(monitor); List <FilePath> newFiles = obj.GetItemFiles(true); foreach (FilePath f in newFiles) { if (!f.IsChildPathOf(targetPath)) { if (obj is Solution) { monitor.ReportError("The solution '" + obj.Name + "' is referencing the file '" + f.FileName + "' which is located outside the root solution directory.", null); } else { monitor.ReportError("The project '" + obj.Name + "' is referencing the file '" + f.FileName + "' which is located outside the project directory.", null); } } oldFiles.Remove(f); } // Remove old files foreach (FilePath file in oldFiles) { if (File.Exists(file)) { File.Delete(file); // Exclude empty directories FilePath dir = file.ParentDirectory; if (Directory.GetFiles(dir).Length == 0 && Directory.GetDirectories(dir).Length == 0) { try { Directory.Delete(dir); } catch (Exception ex) { monitor.ReportError(null, ex); } } } } return(obj.FileName); } } else { using (obj) { ExcludeEntries(obj, includedChildIds); if (format != null) { obj.ConvertToFormat(format, true); } obj.Save(monitor); return(obj.FileName); } } }
void IWorkspaceFileObject.ConvertToFormat(FileFormat format, bool convertChildren) { this.FileFormat = format; }
public void Export (IWorkspaceObject entry, FileFormat format) { ExportProjectDialog dlg = new ExportProjectDialog (entry, format); try { if (MessageService.RunCustomDialog (dlg) == (int) Gtk.ResponseType.Ok) { using (IProgressMonitor mon = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor (true)) { string folder = dlg.TargetFolder; string file = entry is WorkspaceItem ? ((WorkspaceItem)entry).FileName : ((SolutionEntityItem)entry).FileName; Services.ProjectService.Export (mon, file, folder, dlg.Format); } } } finally { dlg.Destroy (); } }
public override TargetFrameworkMoniker GetDefaultTargetFrameworkForFormat (FileFormat format) { return new TargetFrameworkMoniker("4.0"); }
internal protected override Task OnSave(ProgressMonitor monitor) { return(FileFormat.WriteFile(FileName, this, monitor)); }
public string Export (IProgressMonitor monitor, string rootSourceFile, string targetPath, FileFormat format) { rootSourceFile = GetTargetFile (rootSourceFile); return Export (monitor, rootSourceFile, null, targetPath, format); }
public override bool SupportsFormat (FileFormat format) { return format.Id == "MSBuild10"; }
string Export (IProgressMonitor monitor, IWorkspaceFileObject obj, string[] includedChildIds, string targetPath, FileFormat format) { string rootSourceFile = obj.FileName; string sourcePath = Path.GetFullPath (Path.GetDirectoryName (rootSourceFile)); targetPath = Path.GetFullPath (targetPath); if (sourcePath != targetPath) { if (!CopyFiles (monitor, obj, obj.GetItemFiles (true), targetPath, true)) return null; string newFile = Path.Combine (targetPath, Path.GetFileName (rootSourceFile)); if (IsWorkspaceItemFile (rootSourceFile)) obj = ReadWorkspaceItem (monitor, newFile); else obj = (SolutionEntityItem) ReadSolutionItem (monitor, newFile); using (obj) { List<FilePath> oldFiles = obj.GetItemFiles (true); ExcludeEntries (obj, includedChildIds); if (format != null) obj.ConvertToFormat (format, true); obj.Save (monitor); List<FilePath> newFiles = obj.GetItemFiles (true); foreach (FilePath f in newFiles) { if (!f.IsChildPathOf (targetPath)) { if (obj is Solution) monitor.ReportError ("The solution '" + obj.Name + "' is referencing the file '" + f.FileName + "' which is located outside the root solution directory.", null); else monitor.ReportError ("The project '" + obj.Name + "' is referencing the file '" + f.FileName + "' which is located outside the project directory.", null); } oldFiles.Remove (f); } // Remove old files foreach (FilePath file in oldFiles) { if (File.Exists (file)) { File.Delete (file); // Exclude empty directories FilePath dir = file.ParentDirectory; if (Directory.GetFiles (dir).Length == 0 && Directory.GetDirectories (dir).Length == 0) { try { Directory.Delete (dir); } catch (Exception ex) { monitor.ReportError (null, ex); } } } } return obj.FileName; } } else { using (obj) { ExcludeEntries (obj, includedChildIds); if (format != null) obj.ConvertToFormat (format, true); obj.Save (monitor); return obj.FileName; } } }
/// <summary> /// Returns the default framework for a given format /// </summary> /// <returns> /// The default target framework for the format. /// </returns> /// <param name='format'> /// A format /// </param> /// <remarks> /// This method is used to determine what's the correct target framework for a project /// deserialized using a specific format. /// </remarks> public virtual TargetFrameworkMoniker GetDefaultTargetFrameworkForFormat (FileFormat format) { return GetDefaultTargetFrameworkId (); }
internal ProjectService () { extensionChainSlot = Thread.AllocateDataSlot (); AddinManager.AddExtensionNodeHandler (FileFormatsExtensionPath, OnFormatExtensionChanged); AddinManager.AddExtensionNodeHandler (SerializableClassesExtensionPath, OnSerializableExtensionChanged); AddinManager.AddExtensionNodeHandler (ExtendedPropertiesExtensionPath, OnPropertiesExtensionChanged); AddinManager.AddExtensionNodeHandler (ProjectBindingsExtensionPath, OnProjectsExtensionChanged); AddinManager.ExtensionChanged += OnExtensionChanged; defaultFormat = formatManager.GetFileFormat ("MSBuild05"); }
string WriteFile (IProgressMonitor monitor, string file, object item, FileFormat format) { if (format == null) { if (defaultFormat.CanWrite (item)) format = defaultFormat; else { FileFormat[] formats = formatManager.GetFileFormatsForObject (item); format = formats.Length > 0 ? formats [0] : null; } if (format == null) return null; file = format.GetValidFileName (item, file); } if (!FileService.RequestFileEdit (file)) throw new UserException (GettextCatalog.GetString ("The project could not be saved"), GettextCatalog.GetString ("Write permission has not been granted for file '{0}'", file)); format.Format.WriteFile (file, item, monitor); return file; }
public string Export(IProgressMonitor monitor, string rootSourceFile, string targetPath, FileFormat format) { rootSourceFile = GetTargetFile(rootSourceFile); return(Export(monitor, rootSourceFile, null, targetPath, format)); }
public string Export (IProgressMonitor monitor, string rootSourceFile, string[] includedChildIds, string targetPath, FileFormat format) { IWorkspaceFileObject obj; if (IsWorkspaceItemFile (rootSourceFile)) { obj = ReadWorkspaceItem (monitor, rootSourceFile) as Solution; } else { obj = ReadSolutionItem (monitor, rootSourceFile); if (obj == null) throw new InvalidOperationException ("File is not a solution or project."); } using (obj) { return Export (monitor, obj, includedChildIds, targetPath, format); } }
public void RegisterFileFormat (IFileFormat format, string id, string name) { FileFormat f = new FileFormat (format, id, name); fileFormats.Add (f); }
public Solution GetWrapperSolution (IProgressMonitor monitor, string filename) { // First of all, check if a solution with the same name already exists FileFormat[] formats = Services.ProjectService.FileFormats.GetFileFormats (filename, typeof(SolutionEntityItem)); if (formats.Length == 0) formats = new FileFormat [] { DefaultFileFormat }; Solution tempSolution = new Solution (); FileFormat solutionFileFormat; if (formats [0].CanWrite (tempSolution)) solutionFileFormat = formats [0]; else solutionFileFormat = MonoDevelop.Projects.Formats.MD1.MD1ProjectService.FileFormat; string solFileName = solutionFileFormat.GetValidFileName (tempSolution, filename); if (File.Exists (solFileName)) { return (Solution) Services.ProjectService.ReadWorkspaceItem (monitor, solFileName); } else { // Create a temporary solution and add the project to the solution tempSolution.SetLocation (Path.GetDirectoryName (filename), Path.GetFileNameWithoutExtension (filename)); SolutionEntityItem sitem = Services.ProjectService.ReadSolutionItem (monitor, filename); tempSolution.ConvertToFormat (solutionFileFormat, false); tempSolution.RootFolder.Items.Add (sitem); tempSolution.CreateDefaultConfigurations (); tempSolution.Save (monitor); return tempSolution; } }
public override TargetFrameworkMoniker GetDefaultTargetFrameworkForFormat (FileFormat format) { switch (format.Id) { case "MSBuild08": return new TargetFrameworkMoniker ("Silverlight", "3.0"); default: return new TargetFrameworkMoniker ("Silverlight", "4.0"); } }
public void Export (WorkspaceItem item, FileFormat format) { ExportSolutionDialog dlg = new ExportSolutionDialog (item, format); try { if (MessageService.RunCustomDialog (dlg) == (int) Gtk.ResponseType.Ok) { using (IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor (true)) { Services.ProjectService.Export (monitor, item.FileName, dlg.TargetFolder, dlg.Format); } } } finally { dlg.Destroy (); } }
public void RegisterFileFormat(IFileFormat format, string id, string name, bool canDefault) { FileFormat f = new FileFormat(format, id, name, canDefault); fileFormats.Add(f); }