/// <summary> /// Flags Unity projects for debugging with this addin /// </summary> protected override bool CanExecute (SolutionEntityItem item, ExecutionContext context, ConfigurationSelector configuration) { if (CanExecuteProject (item as Project, context)) { return context.ExecutionHandler.CanExecute (new UnityExecutionCommand (item.BaseDirectory.FullPath)); } return base.CanExecute (item, context, configuration); }
public void UpdateImports(SolutionEntityItem item, List<String> imports) { // Remove imports imports.Remove (importCocoaApplication); imports.Remove (importConsoleApplication); imports.Remove (importCocoaLibrary); // Check project nature MonobjcProject project = item as MonobjcProject; if (project == null) { return; } switch (project.ApplicationType) { case MonobjcProjectType.CocoaApplication: imports.Add (importCocoaApplication); break; case MonobjcProjectType.ConsoleApplication: imports.Add (importConsoleApplication); break; case MonobjcProjectType.CocoaLibrary: imports.Add (importCocoaLibrary); break; } }
protected override void Clean (MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration) { var proj = item as MonoGameContentProject; MonoGameContentProjectConfiguration cfg = null; if (proj != null) cfg = proj.GetConfiguration (configuration) as MonoGameContentProjectConfiguration; if (proj == null) { monitor.Log.WriteLine("Cleaning for Unknown MonoGame Project"); base.Clean (monitor, item, configuration); } var manager = new PipelineManager(proj.BaseDirectory.FullPath, Path.Combine(cfg.OutputDirectory, cfg.MonoGamePlatform), cfg.IntermediateOutputDirectory); monitor.Log.WriteLine("Detected {0} MonoGame Platform", cfg.MonoGamePlatform); foreach(var file in proj.Files) { if (file.BuildAction == "Compile") { try { monitor.Log.WriteLine("Cleaning {0}", file.FilePath.FileName); manager.CleanContent(file.FilePath.FullPath, null); } catch(Exception ex) { monitor.Log.WriteLine(ex.Message); } } } base.Clean (monitor, item, configuration); }
public static void GenerateExecutionModeCommands(SolutionEntityItem project, CanExecuteDelegate runCheckDelegate, CommandArrayInfo info) { CommandExecutionContext ctx = new CommandExecutionContext (project, runCheckDelegate); bool supportsParameterization = false; foreach (List<IExecutionMode> modes in GetExecutionModeCommands (ctx, false, true)) { foreach (IExecutionMode mode in modes) { CommandInfo ci = info.Add (mode.Name, new CommandItem (ctx, mode)); if ((mode.ExecutionHandler is ParameterizedExecutionHandler) || ((mode is CustomExecutionMode) && ((CustomExecutionMode)mode).PromptForParameters)) { // It will prompt parameters, so we need command to end with '..'. // However, some commands may end with '...' already and we don't want to break // already-translated strings by altering them if (!ci.Text.EndsWith ("...")) ci.Text += "..."; supportsParameterization = true; } else { // The parameters window will be shown if ctrl is pressed ci.Description = GettextCatalog.GetString ("Run With: {0}", ci.Text); if (SupportsParameterization (mode, ctx)) { ci.Description += " - " + GettextCatalog.GetString ("Hold Control key to display the execution parameters dialog."); supportsParameterization = true; } } } if (info.Count > 0) info.AddSeparator (); } if (supportsParameterization) { info.AddSeparator (); info.Add (GettextCatalog.GetString ("Edit Custom Modes..."), new CommandItem (ctx, null)); } }
protected override BuildResult Compile (MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, BuildData buildData) { var proj = item as Project; if (proj == null) return base.Compile (monitor, item, buildData); if (!proj.GetProjectTypes().Any(x => supportedProjectTypes.ContainsKey(x))) return base.Compile (monitor, item, buildData); var files = buildData.Items.Where(x => x is ProjectFile).Cast<ProjectFile>().ToArray(); foreach (var file in files.Where(f => f.BuildAction == "MonoGameContentReference")) { var path = System.IO.Path.Combine (Path.GetDirectoryName (file.FilePath.ToString ()), "bin", supportedProjectTypes[platform]); monitor.Log.WriteLine("Processing {0}", path); if (!Directory.Exists (path)) continue; foreach (var output in Directory.GetFiles (path, "*.*", SearchOption.AllDirectories)) { var link = string.Format ("Content{0}", output.Replace (path, "")); if (proj.Files.FirstOrDefault (x => Path.GetFileName (x.FilePath.ToString ()) == Path.GetFileName (output)) == null) { monitor.Log.WriteLine ("Auto Including Content {0}", output); proj.Files.Add (new ProjectFile (output, BuildAction.BundleResource) { Link = new MonoDevelop.Core.FilePath (link), Flags = ProjectItemFlags.DontPersist | ProjectItemFlags.Hidden, Visible = false, }); } } } return base.Compile (monitor, item, buildData); }
/// <summary> /// Builds the specified solution item. /// </summary> /// <param name = "monitor">The monitor.</param> /// <param name = "item">The item.</param> /// <param name = "configuration">The configuration.</param> /// <returns>The build result.</returns> protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration) { BuildResult result = new BuildResult (); // Pre-build monitor.BeginTask (GettextCatalog.GetString ("Pre-Building..."), 1); this.PreBuild (result, monitor, item, configuration); monitor.EndTask(); if (result.ErrorCount > 0) { return result; } // Build monitor.BeginTask (GettextCatalog.GetString ("Building"), 1); result.Append (base.Build (monitor, item, configuration)); monitor.EndTask(); if (result.ErrorCount > 0) { return result; } // Post-build monitor.BeginTask (GettextCatalog.GetString ("Post-Building..."), 1); this.PostBuild (result, monitor, item, configuration); monitor.EndTask(); return result; }
public override void SaveProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project) { EnsureNuGetPackageBuildImportsTargetUpdater currentUpdater = Updater; if (currentUpdater != null) { currentUpdater.UpdateProject (project); } }
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { DotNetProject project = (DotNetProject) entry; GtkDesignInfo info = GtkDesignInfo.FromProject (project); // The code generator must run in the GUI thread since it needs to // access to Gtk classes Generator gen = new Generator (); lock (gen) { Gtk.Application.Invoke (delegate { gen.Run (monitor, project, configuration); }); Monitor.Wait (gen); } BuildResult res = base.Build (monitor, entry, configuration); if (gen.Messages != null) { foreach (string s in gen.Messages) // res.AddWarning (info.GuiBuilderProject.File, 0, 0, null, s); // TODO: Add gtkx file name in the Generator res.AddWarning ("", 0, 0, null, s); if (gen.Messages.Length > 0) info.ForceCodeGenerationOnBuild (); } return res; }
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { BuildResult res = base.Build (monitor, entry, configuration); if (res.ErrorCount > 0 || !(entry is DotNetProject)) return res; DotNetProject project = (DotNetProject) entry; AddinData data = AddinData.GetAddinData (project); if (data == null) return res; monitor.Log.WriteLine (AddinManager.CurrentLocalizer.GetString ("Verifying add-in description...")); string fileName = data.AddinManifestFileName; ProjectFile file = data.Project.Files.GetFile (fileName); if (file == null) return res; string addinFile; if (file.BuildAction == BuildAction.EmbeddedResource) addinFile = project.GetOutputFileName (ConfigurationSelector.Default); else addinFile = file.FilePath; AddinDescription desc = data.AddinRegistry.GetAddinDescription (new ProgressStatusMonitor (monitor), addinFile); StringCollection errors = desc.Verify (); foreach (string err in errors) { res.AddError (data.AddinManifestFileName, 0, 0, "", err); monitor.Log.WriteLine ("ERROR: " + err); } return res; }
protected override BuildResult Compile(MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, BuildData buildData) { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Compile Called"); #endif try { var proj = item as MonoGameProject; if (proj == null) { return base.Compile (monitor, item, buildData); } monitor.Log.WriteLine("Compiling for {0}", proj.MonoGamePlatform); var results = new System.Collections.Generic.List<BuildResult>(); foreach(var file in proj.Files) { if (MonoGameBuildAction.IsMonoGameBuildAction(file.BuildAction)) { buildData.Items.Add(file); var buildResult = MonoGameContentProcessor.Compile(file, monitor, buildData); results.Add(buildResult); } } return base.Compile (monitor, item, buildData).Append(results); } finally { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Compile Ended"); #endif } }
public override void LoadProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject msproject) { base.LoadProject (monitor, item, msproject); var dnp = item as DotNetProject; if (dnp == null) return; // Convert .projitems imports into project references foreach (var sp in msproject.Imports.Where (im => im.Label == "Shared" && im.Project.EndsWith (".projitems"))) { var projitemsFile = sp.Project; if (!string.IsNullOrEmpty (projitemsFile)) { projitemsFile = MSBuildProjectService.FromMSBuildPath (item.ItemDirectory, projitemsFile); projitemsFile = Path.Combine (Path.GetDirectoryName (msproject.FileName), projitemsFile); if (File.Exists (projitemsFile)) { MSBuildSerializer iser = Handler.CreateSerializer (); iser.SerializationContext.BaseFile = projitemsFile; iser.SerializationContext.ProgressMonitor = monitor; MSBuildProject p = new MSBuildProject (); p.Load (projitemsFile); Handler.LoadProjectItems (p, iser, ProjectItemFlags.Hidden | ProjectItemFlags.DontPersist); var r = new ProjectReference (ReferenceType.Project, Path.GetFileNameWithoutExtension (projitemsFile)); r.Flags = ProjectItemFlags.DontPersist; r.SetItemsProjectPath (projitemsFile); dnp.References.Add (r); } } } }
protected UnitTest (string name, IWorkspaceObject ownerSolutionItem) { this.name = name; this.ownerSolutionItem = ownerSolutionItem; ownerSolutionEntityItem = ownerSolutionItem as SolutionEntityItem; if (ownerSolutionEntityItem != null) ownerSolutionEntityItem.DefaultConfigurationChanged += OnConfugurationChanged; }
public bool BuildEnabledForItem (SolutionEntityItem item) { foreach (SolutionConfigurationEntry entry in configurations) { if (entry.Item == item) return entry.Build && item.Configurations [entry.ItemConfiguration] != null; } return false; }
protected override void Clean (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { base.Clean (monitor, entry, configuration); CProject project = (CProject) entry; CProjectConfiguration conf = (CProjectConfiguration) project.GetConfiguration (configuration); project.Compiler.Clean (project.Files, conf, monitor); }
public string GetMappedConfiguration (SolutionEntityItem item) { foreach (SolutionConfigurationEntry entry in configurations) { if (entry.Item == item) return entry.ItemConfiguration; } return null; }
public IEnumerable<string> GetRequiredImports(SolutionEntityItem item) { MonobjcProject project = item as MonobjcProject; if (project != null) { if (project.CompileTarget == CompileTarget.Exe) yield return target; } }
protected override BuildResult Compile (IProgressMonitor monitor, SolutionEntityItem item, BuildData buildData) { MoonlightProject proj = item as MoonlightProject; if (proj == null) return base.Compile (monitor, item, buildData); var objDir = GetObjDir (proj, buildData.Configuration); if (!Directory.Exists (objDir)) Directory.CreateDirectory (objDir); var codeDomProvider = proj.LanguageBinding.GetCodeDomProvider (); string appName = proj.Name; var toResGen = new List<FilePath> (); List<BuildResult> results = new List<BuildResult> (); foreach (ProjectFile pf in proj.Files) { if (pf.BuildAction == BuildAction.Resource || pf.BuildAction == BuildAction.Page || pf.BuildAction == BuildAction.ApplicationDefinition) toResGen.Add (pf.FilePath); if (pf.FilePath.Extension == ".xaml" && pf.Generator == "MSBuild:MarkupCompilePass1") { var outFile = objDir.Combine (proj.LanguageBinding.GetFileName (pf.FilePath.FileName + ".g")); buildData.Items.Add (new ProjectFile (outFile, BuildAction.Compile)); if (!File.Exists (outFile) || File.GetLastWriteTime (outFile) < File.GetLastWriteTime (pf.FilePath)) { string rel = pf.ProjectVirtualPath; monitor.Log.WriteLine ("Generating codebehind accessors for {0}...", rel); BuildResult result = XamlG.GenerateFile (codeDomProvider, appName, pf.FilePath, rel, outFile); if (result.Failed) return result; results.Add (result); } } } string resFile = objDir.Combine (appName + ".g.resources"); if (toResGen.Count > 0) { DateTime lastMod = DateTime.MinValue; if (File.Exists (resFile)) lastMod = File.GetLastWriteTime (resFile); foreach (string f in toResGen) { if (File.GetLastWriteTime (f) > lastMod) { BuildResult result = Respack (monitor, proj, toResGen, resFile); if (result.Failed) return result; results.Add (result); break; } } buildData.Items.Add (new ProjectFile (resFile, BuildAction.EmbeddedResource) { ResourceId = appName + ".g.resources" }); } else { if (File.Exists (resFile)) File.Delete (resFile); } return base.Compile (monitor, item, buildData).Append (results); }
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { CProject project = (CProject) entry; CProjectConfiguration conf = (CProjectConfiguration) project.GetConfiguration (configuration); if (conf.CompileTarget != CompileTarget.Bin) project.WriteMDPkgPackage (configuration); return base.Build (monitor, entry, configuration); }
void CheckNHibernateProject (SolutionEntityItem item) { DotNetProject project = item as DotNetProject; if (project != null) { if (NHibernateService.HasNHibernateProject (project)) { NHibernateProject nhproject = NHibernateService.GetNHibernateProject (project); nhproject.CheckAndGenerateCodeFiles (); } } }
protected override void Clean (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { base.Clean (monitor, entry, configuration); ValaProject project = entry as ValaProject; if (project == null) return; project.Compiler.Clean (project.Files, (ValaProjectConfiguration) project.GetConfiguration(configuration), monitor); }
public override void Initialize (OptionsDialog dialog, object dataObject) { base.Initialize (dialog, dataObject); solutionItem = dataObject as SolutionEntityItem; if (solutionItem != null) workspaceItem = solutionItem.ParentSolution; else workspaceItem = dataObject as WorkspaceItem; }
public override void SaveProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project) { try { MSBuildProjectImportsMerger merger = ImportsMerger; if (merger != null) { merger.Merge (project); } } finally { ImportsMerger = null; } }
public void UpdateImports (SolutionEntityItem item, List<string> imports) { imports.Remove (target05); imports.Remove (target08); AspNetAppProject project = item as AspNetAppProject; if (project != null) { if (project.FileFormat.Id == "MSBuild05") imports.Add (target05); else imports.Add (target08); } }
ExecutionCommand CreateCommand (SolutionEntityItem item) { DotNetProject project = item as DotNetProject; if (project == null || project.CompileTarget != CompileTarget.Library || project.ParentSolution == null) return null; SolutionAddinData sdata = project.ParentSolution.GetAddinData (); if (sdata == null || project.GetAddinData () == null || project.GetAddinData ().IsRoot) return null; RegistryInfo ri = sdata.ExternalRegistryInfo; if (ri == null || string.IsNullOrEmpty (ri.TestCommand)) return null; FilePath cmd; string args; if (ri.TestCommand [0] == '"') { // If the file name is quoted, unquote it int i = ri.TestCommand.IndexOf ('"', 1); if (i == -1) throw new UserException ("Invalid add-in test command: " + ri.TestCommand); cmd = ri.TestCommand.Substring (1, i - 1); args = ri.TestCommand.Substring (i + 1).Trim (); } else { int i = ri.TestCommand.IndexOf (' '); if (i == -1) { cmd = ri.TestCommand; args = string.Empty; } else { cmd = ri.TestCommand.Substring (0, i); args = ri.TestCommand.Substring (i + 1).Trim (); } } // If the command is an absolute file, take it // It not, consider it is a file relative to the startup path // If a relative file can't be found, use it as is if (!cmd.IsAbsolute) { FilePath absCmd = cmd.ToAbsolute (ri.ApplicationPath); if (System.IO.File.Exists (absCmd)) cmd = absCmd; } ProcessExecutionCommand pcmd = Runtime.ProcessService.CreateCommand (cmd) as ProcessExecutionCommand; if (pcmd == null) return null; pcmd.Arguments = args; pcmd.EnvironmentVariables ["MONO_ADDINS_REGISTRY"] = sdata.TestRegistryPath; return pcmd; }
protected override void Clean (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { SolutionItemConfiguration conf = entry.GetConfiguration (configuration) as SolutionItemConfiguration; if (conf != null) { conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.BeforeClean, configuration); if (monitor.IsCancelRequested) return; } base.Clean (monitor, entry, configuration); if (conf != null && !monitor.IsCancelRequested) conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.AfterClean, configuration); }
public override void Save (IProgressMonitor monitor, SolutionEntityItem entry) { base.Save (monitor, entry); DotNetProject project = entry as DotNetProject; if (project != null) { AddinData data = AddinData.GetAddinData (project); if (data != null) { Gtk.Application.Invoke (delegate { data.CheckOutputPath (); }); } } }
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { DotNetProject project = entry as DotNetProject; AddinData data = project != null ? AddinData.GetAddinData (project) : null; if (data != null) monitor.BeginTask (null, buildingSolution ? 2 : 3); BuildResult res = base.Build (monitor, entry, configuration); if (res.ErrorCount > 0 || data == null) return res; monitor.Step (1); monitor.Log.WriteLine (AddinManager.CurrentLocalizer.GetString ("Verifying add-in description...")); string fileName = data.AddinManifestFileName; ProjectFile file = data.Project.Files.GetFile (fileName); if (file == null) return res; string addinFile; if (file.BuildAction == BuildAction.EmbeddedResource) addinFile = project.GetOutputFileName (ConfigurationSelector.Default); else addinFile = file.FilePath; AddinDescription desc = data.AddinRegistry.GetAddinDescription (new ProgressStatusMonitor (monitor), addinFile); StringCollection errors = desc.Verify (); foreach (string err in errors) { res.AddError (data.AddinManifestFileName, 0, 0, "", err); monitor.Log.WriteLine ("ERROR: " + err); } if (!buildingSolution && project.ParentSolution != null) { monitor.Step (1); SolutionAddinData sdata = project.ParentSolution.GetAddinData (); if (sdata != null && sdata.Registry != null) { sdata.Registry.Update (new ProgressStatusMonitor (monitor)); DispatchService.GuiDispatch (delegate { sdata.NotifyChanged (); }); } } monitor.EndTask (); return res; }
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { SolutionItemConfiguration conf = entry.GetConfiguration (configuration) as SolutionItemConfiguration; if (conf != null) { conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.BeforeBuild, configuration); if (monitor.IsCancelRequested) return new BuildResult (new CompilerResults (null), ""); } BuildResult res = base.Build (monitor, entry, configuration); if (conf != null && !monitor.IsCancelRequested && !res.Failed) conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.AfterBuild, configuration); return res; }
protected override BuildResult Build(MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration) { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Build Called"); #endif try { return base.Build (monitor, item, configuration); } finally { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Build Ended"); #endif } }
protected override void Execute (IProgressMonitor monitor, SolutionEntityItem entry, ExecutionContext context, ConfigurationSelector configuration) { SolutionItemConfiguration conf = entry.GetConfiguration (configuration) as SolutionItemConfiguration; if (conf != null) { ExecutionContext localContext = new ExecutionContext (Runtime.ProcessService.DefaultExecutionHandler, context.ConsoleFactory); conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.BeforeExecute, localContext, configuration); if (monitor.IsCancelRequested) return; } base.Execute (monitor, entry, context, configuration); if (conf != null && !monitor.IsCancelRequested) { ExecutionContext localContext = new ExecutionContext (Runtime.ProcessService.DefaultExecutionHandler, context.ConsoleFactory); conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.AfterExecute, localContext, configuration); } }
public ProjectOptionsDialog(Gtk.Window parentWindow, SolutionEntityItem project) : base(parentWindow, project) { this.Title = GettextCatalog.GetString("Project Options") + " - " + project.Name; this.DefaultWidth = 960; this.DefaultHeight = 680; }
public virtual bool CanHandleItem(SolutionEntityItem item) { return(!(IsMigration && IsMigrationRequired) && Type.IsAssignableFrom(item.GetType())); }
public virtual bool CanHandleItem(SolutionEntityItem item) { return(Type.IsAssignableFrom(item.GetType())); }
public static void GenerateExecutionModeCommands(SolutionEntityItem project, CanExecuteDelegate runCheckDelegate, CommandArrayInfo info) { CommandExecutionContext ctx = new CommandExecutionContext(project, runCheckDelegate); bool supportsParameterization = false; foreach (List <IExecutionMode> modes in GetExecutionModeCommands(ctx, false, true)) { foreach (IExecutionMode mode in modes) { CommandInfo ci = info.Add(mode.Name, new CommandItem(ctx, mode)); if ((mode.ExecutionHandler is ParameterizedExecutionHandler) || ((mode is CustomExecutionMode) && ((CustomExecutionMode)mode).PromptForParameters)) { // It will prompt parameters, so we need command to end with '..'. // However, some commands may end with '...' already and we don't want to break // already-translated strings by altering them if (!ci.Text.EndsWith("...")) { ci.Text += "..."; } supportsParameterization = true; } else { // The parameters window will be shown if ctrl is pressed ci.Description = GettextCatalog.GetString("Run With: {0}", ci.Text); if (SupportsParameterization(mode, ctx)) { ci.Description += " - " + GettextCatalog.GetString("Hold Control key to display the execution parameters dialog."); supportsParameterization = true; } } } if (info.Count > 0) { info.AddSeparator(); } } var targets = new List <ExecutionTarget> (); if (project != null) { FlattenExecutionTargets(targets, project.GetExecutionTargets(IdeApp.Workspace.ActiveConfiguration)); } if (targets.Count > 1) { foreach (var t in targets) { var h = new TargetedExecutionHandler(Runtime.ProcessService.DefaultExecutionHandler, t); CommandInfo ci = info.Add(t.FullName, new CommandItem(ctx, new ExecutionMode(t.Id, t.FullName, h))); ci.Description = GettextCatalog.GetString("Run With: {0}", ci.Text); } info.AddSeparator(); } if (supportsParameterization) { info.AddSeparator(); info.Add(GettextCatalog.GetString("Edit Custom Modes..."), new CommandItem(ctx, null)); } }
public override bool CanHandleItem(SolutionEntityItem item) { return(true); }
public StartupOptionsPanelWidget(Solution sol) { this.Build(); this.sol = sol; startupItems = new List <SolutionEntityItem> (); foreach (SolutionEntityItem it in sol.GetAllSolutionItems <SolutionEntityItem> ()) { // Include in the list if it can run in any of the existing execution modes and configurations foreach (IExecutionModeSet mset in Runtime.ProcessService.GetExecutionModes()) { bool matched = false; foreach (IExecutionMode mode in mset.ExecutionModes) { foreach (SolutionConfiguration sc in sol.Configurations) { if (it.CanExecute(new ExecutionContext(mode, null, IdeApp.Workspace.ActiveExecutionTarget), sc.Selector)) { startupItems.Add(it); matched = true; break; } } if (matched) { break; } } if (matched) { break; } } } listStore = new ListStore(typeof(SolutionItem), typeof(bool), typeof(string)); treeItems.Model = listStore; CellRendererToggle crt = new CellRendererToggle(); treeItems.AppendColumn("", crt, "active", 1); treeItems.AppendColumn(GettextCatalog.GetString("Project"), new CellRendererText(), "text", 2); if (startupItems.Count > 0) { for (int n = 0; n < startupItems.Count; n++) { SolutionEntityItem it = startupItems [n]; comboItems.AppendText(it.Name); listStore.AppendValues(it, sol.MultiStartupItems.Contains(it), it.Name); if (sol.StartupItem == it) { comboItems.Active = n; } } } else { comboItems.AppendText(GettextCatalog.GetString("The solution does not contain any executable project")); comboItems.Active = 0; comboItems.Sensitive = false; radioMulti.Sensitive = false; radioSingle.Sensitive = false; } radioSingle.Active = sol.SingleStartup; radioMulti.Active = !sol.SingleStartup; UpdateButtons(); crt.Toggled += OnItemToggled; treeItems.Selection.Changed += OnSelectionChanged; }
protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem project, ConfigurationSelector configuration) { AspNetAppProject aspProject = project as AspNetAppProject; //get the config object and validate AspNetAppProjectConfiguration config = (AspNetAppProjectConfiguration)aspProject.GetConfiguration(configuration); if (config == null) { monitor.Log.WriteLine(GettextCatalog.GetString ("Project configuration is invalid. Skipping CodeBehind member generation.")); return(base.Build(monitor, project, configuration)); } if (config.DisableCodeBehindGeneration) { monitor.Log.WriteLine(GettextCatalog.GetString ("Skipping updating of CodeBehind partial classes, because this feature is disabled.")); return(base.Build(monitor, project, configuration)); } CodeBehindWriter writer = CodeBehindWriter.CreateForProject(monitor, aspProject); if (!writer.SupportsPartialTypes) { monitor.Log.WriteLine(GettextCatalog.GetString ("The code generator for {0} does not support partial classes. Skipping CodeBehind member generation.", aspProject.LanguageBinding.Language));; return(base.Build(monitor, project, configuration)); } //get the extension used for codebehind files string langExt = aspProject.LanguageBinding.GetFileName("a"); langExt = langExt.Substring(1, langExt.Length - 1); List <CodeBehindWarning> errors = new List <CodeBehindWarning> (); monitor.Log.WriteLine(GettextCatalog.GetString("Generating CodeBehind members...")); bool updatedParseDb = false; //go over all the files generating members where necessary foreach (ProjectFile file in aspProject.Files) { WebSubtype type = AspNetAppProject.DetermineWebSubtype(file.FilePath); if (type != WebSubtype.WebForm && type != WebSubtype.WebControl && type != WebSubtype.MasterPage) { continue; } //find the designer file ProjectFile designerFile = aspProject.Files.GetFile(file.Name + ".designer" + langExt); if (designerFile == null) { aspProject.Files.GetFile(file.Name + ".Designer" + langExt); } if (designerFile == null) { continue; } //only regenerate the designer class if it's older than the aspx (etc) file if (System.IO.File.GetLastWriteTimeUtc(designerFile.FilePath) > System.IO.File.GetLastWriteTimeUtc(file.FilePath)) { continue; } //need parse DB to be up to date if (!updatedParseDb) { updatedParseDb = true; monitor.Log.Write(GettextCatalog.GetString("Waiting for project type database to finish updating...")); ProjectDom dom = ProjectDomService.GetProjectDom(aspProject); dom.ForceUpdate(true); monitor.Log.WriteLine(GettextCatalog.GetString(" complete.")); } //parse the ASP.NET file var parsedDocument = ProjectDomService.Parse(aspProject, file.FilePath) as AspNetParsedDocument; if (parsedDocument == null) { continue; } var ccu = CodeBehind.GenerateCodeBehind(aspProject, designerFile.FilePath, parsedDocument, errors); if (ccu == null) { continue; } writer.Write(ccu, designerFile.FilePath); } writer.WriteOpenFiles(); //write out a friendly message aout what we did if (writer.WrittenCount > 0) { monitor.Log.WriteLine(GettextCatalog.GetString("{0} CodeBehind designer classes updated.", writer.WrittenCount)); } else { monitor.Log.WriteLine(GettextCatalog.GetString("No changes made to CodeBehind classes.")); } //and construct and return a build result BuildResult baseResult = base.Build(monitor, project, configuration); foreach (CodeBehindWarning cbw in errors) { if (cbw.FileName != null) { baseResult.AddWarning(cbw.FileName, cbw.Line, cbw.Column, null, cbw.WarningText); } else { baseResult.AddWarning(cbw.WarningText); } } return(baseResult); }
public BreakpointPropertiesDialog(Breakpoint bp, bool isNew) { this.Build(); this.bp = bp; entryFile.Text = bp.FileName; entryLine.Text = bp.Line.ToString(); if (!isNew) { entryFile.IsEditable = false; entryLine.IsEditable = false; entryFile.ModifyBase(Gtk.StateType.Normal, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); entryFile.ModifyBase(Gtk.StateType.Active, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); entryLine.ModifyBase(Gtk.StateType.Normal, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); entryLine.ModifyBase(Gtk.StateType.Active, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); } if (string.IsNullOrEmpty(bp.ConditionExpression)) { radioBreakAlways.Active = true; } else { entryCondition.Text = bp.ConditionExpression; if (bp.BreakIfConditionChanges) { radioBreakChange.Active = true; } else { radioBreakTrue.Active = true; } } spinHitCount.Value = bp.HitCount; if (bp.HitAction == HitAction.Break) { radioActionBreak.Active = true; } else { radioActionTrace.Active = true; entryTraceExpr.Text = bp.TraceExpression; } Project project = IdeApp.Workspace.GetProjectContainingFile(bp.FileName); if (project != null) { // Check the startup project of the solution too, since the current project may be a library SolutionEntityItem startup = project.ParentSolution.StartupItem; boxConditionOptions.Sensitive = DebuggingService.IsFeatureSupported(project, DebuggerFeatures.ConditionalBreakpoints) || DebuggingService.IsFeatureSupported(startup, DebuggerFeatures.ConditionalBreakpoints); boxAction.Sensitive = DebuggingService.IsFeatureSupported(project, DebuggerFeatures.Tracepoints) || DebuggingService.IsFeatureSupported(startup, DebuggerFeatures.Tracepoints); } UpdateControls(); }
public override bool CanHandleItem(SolutionEntityItem item) { throw new NotImplementedException(); }
protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { return(base.Build(monitor, entry, configuration)); }
public static BuildResult Compile(IProgressMonitor monitor, SolutionEntityItem item, BuildData buildData, ItemCompileCallback callback) { return(Services.ProjectService.GetExtensionChain(item).Compile(monitor, item, buildData, callback)); }
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.Package && pref.LoadedReference != null) { refto = pref.LoadedReference; } data.Add(new DataValue("refto", refto)); return(data); } return(handler.Serialize(obj)); }
public BreakpointPropertiesDialog(Breakpoint bp, bool isNew) { this.Build(); this.isNew = isNew; this.bp = bp; spinColumn.Adjustment.Upper = int.MaxValue; spinColumn.Adjustment.Lower = 1; spinLine.Adjustment.Upper = int.MaxValue; spinLine.Adjustment.Lower = 1; if (bp is FunctionBreakpoint) { FunctionBreakpoint fb = (FunctionBreakpoint)bp; labelFileFunction.LabelProp = GettextCatalog.GetString("Function:"); if (fb.ParamTypes != null) { // FIXME: support non-C# syntax based on fb.Language entryFileFunction.Text = fb.FunctionName + " (" + string.Join(", ", fb.ParamTypes) + ")"; } else { entryFileFunction.Text = fb.FunctionName; } if (!isNew) { // We don't use ".Sensitive = false" because we want the user to be able to select & copy the text. entryFileFunction.ModifyBase(Gtk.StateType.Normal, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); entryFileFunction.ModifyBase(Gtk.StateType.Active, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); entryFileFunction.IsEditable = false; } // Function breakpoints only support breaking on the first line hboxLineColumn.Destroy(); labelLine.Destroy(); table1.NRows--; } else { labelFileFunction.LabelProp = GettextCatalog.GetString("File:"); entryFileFunction.Text = ((Breakpoint)bp).FileName; // We don't use ".Sensitive = false" because we want the user to be able to select & copy the text. entryFileFunction.ModifyBase(Gtk.StateType.Normal, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); entryFileFunction.ModifyBase(Gtk.StateType.Active, Style.Backgrounds [(int)Gtk.StateType.Insensitive]); entryFileFunction.IsEditable = false; //spinColumn.Value = bp.Column; spinLine.Value = bp.Line; if (!isNew) { spinColumn.IsEditable = false; spinColumn.Sensitive = false; spinLine.IsEditable = false; spinLine.Sensitive = false; } // Note: We hide the column spin button for now because we don't support it yet hboxColumn.Hide(); } if (string.IsNullOrEmpty(bp.ConditionExpression)) { radioBreakAlways.Active = true; } else { entryCondition.Text = bp.ConditionExpression; if (bp.BreakIfConditionChanges) { radioBreakChange.Active = true; } else { radioBreakTrue.Active = true; } } spinHitCount.Value = bp.HitCount; if (bp.HitAction == HitAction.Break) { radioActionBreak.Active = true; } else { radioActionTrace.Active = true; entryTraceExpr.Text = bp.TraceExpression; } Project project = null; if (!string.IsNullOrEmpty(bp.FileName)) { project = IdeApp.Workspace.GetProjectContainingFile(bp.FileName); } if (project != null) { // Check the startup project of the solution too, since the current project may be a library SolutionEntityItem startup = project.ParentSolution.StartupItem; boxConditionOptions.Sensitive = DebuggingService.IsFeatureSupported(project, DebuggerFeatures.ConditionalBreakpoints) || DebuggingService.IsFeatureSupported(startup, DebuggerFeatures.ConditionalBreakpoints); boxAction.Sensitive = DebuggingService.IsFeatureSupported(project, DebuggerFeatures.Tracepoints) || DebuggingService.IsFeatureSupported(startup, DebuggerFeatures.Tracepoints); } UpdateControls(); }
string GetSelectedConfiguration(SolutionEntityItem item) { var entry = configuration.GetEntryForItem(item); return(entry != null ? entry.ItemConfiguration : (item.DefaultConfiguration != null ? item.DefaultConfiguration.Id : "")); }
public void InitializeItem(SolutionItem policyParent, ProjectCreateInformation projectCreateInformation, string defaultLanguage, SolutionEntityItem item) { MonoDevelop.Projects.Project project = item as MonoDevelop.Projects.Project; if (project == null) { MessageService.ShowError(GettextCatalog.GetString("Can't create project with type: {0}", type)); return; } // Set the file before setting the name, to make sure the file extension is kept project.FileName = Path.Combine(projectCreateInformation.ProjectBasePath, projectCreateInformation.ProjectName); project.Name = projectCreateInformation.ProjectName; var dnp = project as DotNetProject; if (dnp != null) { if (policyParent.ParentSolution != null && !policyParent.ParentSolution.FileFormat.SupportsFramework(dnp.TargetFramework)) { SetClosestSupportedTargetFramework(policyParent.ParentSolution.FileFormat, dnp); } var substitution = new string[, ] { { "ProjectName", GetProjectNameForSubstitution(projectCreateInformation) } }; foreach (var desc in references) { if (!projectCreateInformation.ShouldCreate(desc.CreateCondition)) { continue; } if (desc.ProjectReference.ReferenceType == ReferenceType.Project) { string referencedProjectName = ReplaceParameters(desc.ProjectReference.Reference, substitution, projectCreateInformation); var parsedReference = ProjectReference.RenameReference(desc.ProjectReference, referencedProjectName); dnp.References.Add(parsedReference); } else { dnp.References.Add(desc.ProjectReference); } } } foreach (SingleFileDescriptionTemplate resourceTemplate in resources) { try { if (!projectCreateInformation.ShouldCreate(resourceTemplate.CreateCondition)) { continue; } var projectFile = new ProjectFile(resourceTemplate.SaveFile(policyParent, project, defaultLanguage, project.BaseDirectory, null)); projectFile.BuildAction = BuildAction.EmbeddedResource; project.Files.Add(projectFile); } catch (Exception ex) { if (!IdeApp.IsInitialized) { throw; } MessageService.ShowError(GettextCatalog.GetString("File {0} could not be written.", resourceTemplate.Name), ex); } } foreach (FileDescriptionTemplate fileTemplate in files) { try { if (!projectCreateInformation.ShouldCreate(fileTemplate.CreateCondition)) { continue; } fileTemplate.SetProjectTagModel(projectCreateInformation.Parameters); fileTemplate.AddToProject(policyParent, project, defaultLanguage, project.BaseDirectory, null); } catch (Exception ex) { if (!IdeApp.IsInitialized) { throw; } MessageService.ShowError(GettextCatalog.GetString("File {0} could not be written.", fileTemplate.Name), ex); } finally { fileTemplate.SetProjectTagModel(null); } } }
public override bool CanHandleItem(SolutionEntityItem item) { return((item is DotNetProject) && ((DotNetProject)item).LanguageName == language); }
public abstract bool CanHandleItem(SolutionEntityItem item);
public override bool CanHandleItem(SolutionEntityItem item) { return(ItemType != null && ItemType.IsAssignableFrom(item.GetType())); }
protected override BuildResult Compile(IProgressMonitor monitor, SolutionEntityItem item, BuildData buildData) { return(base.Compile(monitor, item, buildData)); }
protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration) { var proj = item as MonoMacProject; if (proj == null || proj.CompileTarget != CompileTarget.Exe) { return(base.Build(monitor, item, configuration)); } var conf = (MonoMacProjectConfiguration)configuration.GetConfiguration(item); var resDir = conf.AppDirectory.Combine("Contents", "Resources"); var appDir = conf.AppDirectory; //make sure the codebehind files are updated before building var res = MacBuildUtilities.UpdateCodeBehind(monitor, proj.CodeBehindGenerator, proj.Files); if (res.ErrorCount > 0) { return(res); } res = res.Append(base.Build(monitor, item, configuration)); if (res.ErrorCount > 0) { return(res); } //copy exe, mdb, refs, copy-to-output, Content files to Resources var filesToCopy = GetCopyFiles(proj, configuration, conf).Where(NeedsBuilding).ToList(); if (filesToCopy.Count > 0) { monitor.BeginTask("Copying resource files to app bundle", filesToCopy.Count); foreach (var f in filesToCopy) { f.EnsureOutputDirectory(); File.Copy(f.Input, f.Output, true); monitor.Log.WriteLine("Copied {0}", f.Output.ToRelative(appDir)); monitor.Step(1); } monitor.EndTask(); } if (!PropertyService.IsMac) { res.AddWarning("Cannot compile xib files on non-Mac platforms"); } else { //Interface Builder files if (res.Append(MacBuildUtilities.CompileXibFiles(monitor, proj.Files, resDir)).ErrorCount > 0) { return(res); } } //info.plist var plistOut = conf.AppDirectory.Combine("Contents", "Info.plist"); var appInfoIn = proj.Files.GetFile(proj.BaseDirectory.Combine("Info.plist")); if (new FilePair(proj.FileName, plistOut).NeedsBuilding() || (appInfoIn != null && new FilePair(appInfoIn.FilePath, plistOut).NeedsBuilding())) { if (res.Append(MergeInfoPlist(monitor, proj, conf, appInfoIn, plistOut)).ErrorCount > 0) { return(res); } } //launch script var ls = conf.LaunchScript; if (!File.Exists(ls)) { if (!Directory.Exists(ls.ParentDirectory)) { Directory.CreateDirectory(ls.ParentDirectory); } var src = AddinManager.CurrentAddin.GetFilePath("MonoMacLaunchScript.sh"); File.Copy(src, ls, true); var fi = new UnixFileInfo(ls); fi.FileAccessPermissions |= FileAccessPermissions.UserExecute | FileAccessPermissions.GroupExecute | FileAccessPermissions.OtherExecute; } //pkginfo var pkgInfo = conf.AppDirectory.Combine("Contents", "PkgInfo"); if (!File.Exists(pkgInfo)) { using (var f = File.OpenWrite(pkgInfo)) f.Write(new byte [] { 0X41, 0X50, 0X50, 0X4C, 0x3f, 0x3f, 0x3f, 0x3f }, 0, 8); // "APPL???" } return(res); }
void OpenEvent(object sender, EventArgs e) { if (!btn_new.Sensitive) { return; } if (notebook.Page == 0) { if (!CreateProject()) { return; } Solution parentSolution = null; if (parentFolder == null) { WorkspaceItem item = (WorkspaceItem)newItem; parentSolution = item as Solution; if (parentSolution != null) { if (parentSolution.RootFolder.Items.Count > 0) { currentEntry = parentSolution.RootFolder.Items [0] as SolutionItem; } parentFolder = parentSolution.RootFolder; } } else { SolutionItem item = (SolutionItem)newItem; parentSolution = parentFolder.ParentSolution; currentEntry = item; } if (btn_new.Label == Gtk.Stock.GoForward) { // There are features to show. Go to the next page if (currentEntry != null) { try { featureList.Fill(parentFolder, currentEntry, SolutionItemFeatures.GetFeatures(parentFolder, currentEntry)); } catch (Exception ex) { LoggingService.LogError(ex.ToString()); } } notebook.Page++; btn_new.Label = Gtk.Stock.Ok; return; } } else { // Already in fetatures page if (!featureList.Validate()) { return; } } // New combines (not added to parent combines) already have the project as child. if (!newSolution) { // Make sure the new item is saved before adding. In this way the // version control add-in will be able to put it under version control. if (currentEntry is SolutionEntityItem) { // Inherit the file format from the solution SolutionEntityItem eitem = (SolutionEntityItem)currentEntry; eitem.FileFormat = parentFolder.ParentSolution.FileFormat; IdeApp.ProjectOperations.Save(eitem); } parentFolder.AddItem(currentEntry, true); } if (notebook.Page == 1) { featureList.ApplyFeatures(); } if (parentFolder != null) { IdeApp.ProjectOperations.Save(parentFolder.ParentSolution); } else { IdeApp.ProjectOperations.Save(newItem); } if (openSolution) { selectedItem.OpenCreatedSolution(); } Respond(ResponseType.Ok); }
protected override BuildResult Compile(MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, BuildData buildData) { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Compile Called"); #endif try { var cfg = buildData.Configuration as MonoGameContentProjectConfiguration; var proj = item as MonoGameContentProject; if (proj == null || cfg == null) { monitor.Log.WriteLine("Compiling for Unknown MonoGame Project"); return(base.Compile(monitor, item, buildData)); } monitor.Log.WriteLine("Detected {0} MonoGame Platform", cfg.MonoGamePlatform); var result = new BuildResult(); var manager = new PipelineManager(proj.BaseDirectory.FullPath, Path.Combine(buildData.Configuration.OutputDirectory, cfg.MonoGamePlatform), buildData.Configuration.IntermediateOutputDirectory); manager.Logger = new MonitorBuilder(monitor, result); manager.Platform = (TargetPlatform)Enum.Parse(typeof(TargetPlatform), cfg.MonoGamePlatform); try { foreach (var pr in proj.ParentSolution.GetAllProjects()) { if (pr is DotNetAssemblyProject) { var dot = pr as DotNetAssemblyProject; foreach (var r in dot.References) { if (r.Package.Name == "monogame-contentpipeline") { var output = dot.GetOutputFileName(buildData.ConfigurationSelector).FullPath; monitor.Log.WriteLine("Adding {0} to Content Pipeline Assembly List", output); manager.AddAssembly(output); proj.Manager.AddAssembly(output); break; } } } } } catch (Exception ex) { result.AddWarning(string.Format("Problem processing Content Extensions {0}", ex.Message)); } var dict = new Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary(); if (cfg != null) { if (cfg.XnaCompressContent.ToLowerInvariant() == "true") { // tell the manager to compress the output } } foreach (var file in proj.Files) { if (file.BuildAction == "Compile") { try { dict.Clear(); foreach (object key in file.ExtendedProperties.Keys) { string k = key as string; if (k != null && k.StartsWith("ProcessorParameters_")) { if (!dict.ContainsKey(k.Replace("ProcessorParameters_", String.Empty))) { dict.Add(k.Replace("ProcessorParameters_", String.Empty), file.ExtendedProperties[k]); } else { dict[k.Replace("ProcessorParameters_", String.Empty)] = file.ExtendedProperties[k]; } } } // check if the file has changed and rebuild if required. manager.BuildContent(file.FilePath.FullPath, null, file.ExtendedProperties.Contains("Importer") ? (string)file.ExtendedProperties["Importer"] : null, file.ExtendedProperties.Contains("Processor") ? (string)file.ExtendedProperties["Processor"] : null, dict); } catch (Exception ex) { monitor.Log.WriteLine(ex.ToString()); result.AddError(ex.Message); } } } return(result); } finally { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Compile Ended"); #endif } }
List <ProjectReference> GetProjectReferences(SolutionEntityItem solutionItem) { return(solutionItem.Items.OfType <ProjectReference> () .Where(item => item.ReferenceType == ReferenceType.Project) .ToList()); }
public ProjectOptionsDialog(Gtk.Window parentWindow, SolutionEntityItem project) : base(parentWindow, project) { this.Title = GettextCatalog.GetString("Project Options") + " - " + project.Name; }
public WorkspaceItemCreatedInformation CreateEntry(ProjectCreateInformation projectCreateInformation, string defaultLanguage) { WorkspaceItem workspaceItem = null; if (string.IsNullOrEmpty(type)) { workspaceItem = new Solution(); } else { Type workspaceItemType = addin.GetType(type, false); if (workspaceItemType != null) { workspaceItem = Activator.CreateInstance(workspaceItemType) as WorkspaceItem; } if (workspaceItem == null) { MessageService.ShowError(GettextCatalog.GetString("Can't create solution with type: {0}", type)); return(null); } } workspaceItem.Name = StringParserService.Parse(name, new string[, ] { { "ProjectName", projectCreateInformation.SolutionName } }); workspaceItem.SetLocation(projectCreateInformation.SolutionPath, workspaceItem.Name); ProjectCreateInformation localProjectCI; if (!string.IsNullOrEmpty(directory) && directory != ".") { localProjectCI = new ProjectCreateInformation(projectCreateInformation); localProjectCI.SolutionPath = Path.Combine(localProjectCI.SolutionPath, directory); localProjectCI.ProjectBasePath = Path.Combine(localProjectCI.ProjectBasePath, directory); if (!Directory.Exists(localProjectCI.SolutionPath)) { Directory.CreateDirectory(localProjectCI.SolutionPath); } if (!Directory.Exists(localProjectCI.ProjectBasePath)) { Directory.CreateDirectory(localProjectCI.ProjectBasePath); } } else { localProjectCI = projectCreateInformation; } var workspaceItemCreatedInfo = new WorkspaceItemCreatedInformation(workspaceItem); Solution solution = workspaceItem as Solution; if (solution != null) { for (int i = 0; i < entryDescriptors.Count; i++) { ProjectCreateInformation entryProjectCI; var entry = entryDescriptors[i] as ICustomProjectCIEntry; if (entry != null) { entryProjectCI = entry.CreateProjectCI(localProjectCI); } else { entryProjectCI = localProjectCI; } var solutionItemDesc = entryDescriptors[i]; SolutionEntityItem info = solutionItemDesc.CreateItem(entryProjectCI, defaultLanguage); if (info == null) { continue; } solutionItemDesc.InitializeItem(solution.RootFolder, entryProjectCI, defaultLanguage, info); IConfigurationTarget configurationTarget = info as IConfigurationTarget; if (configurationTarget != null) { foreach (ItemConfiguration configuration in configurationTarget.Configurations) { bool flag = false; foreach (SolutionConfiguration solutionCollection in solution.Configurations) { if (solutionCollection.Id == configuration.Id) { flag = true; } } if (!flag) { solution.AddConfiguration(configuration.Id, true); } } } if ((info is Project) && (solutionItemDesc is ProjectDescriptor)) { workspaceItemCreatedInfo.AddPackageReferenceForCreatedProject((Project)info, (ProjectDescriptor)solutionItemDesc); } solution.RootFolder.Items.Add(info); if (startupProject == info.Name) { solution.StartupItem = info; } } } if (!workspaceItem.FileFormat.CanWrite(workspaceItem)) { // The default format can't write solutions of this type. Find a compatible format. FileFormat f = IdeApp.Services.ProjectService.FileFormats.GetFileFormatsForObject(workspaceItem).First(); workspaceItem.ConvertToFormat(f, true); } return(workspaceItemCreatedInfo); }
public virtual void SaveProject(IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject project) { }
public void InitializeItem(SolutionItem policyParent, ProjectCreateInformation projectCreateInformation, string defaultLanguage, SolutionEntityItem item) { MonoDevelop.Projects.Project project = item as MonoDevelop.Projects.Project; if (project == null) { MessageService.ShowError(GettextCatalog.GetString("Can't create project with type: {0}", type)); return; } string pname = StringParserService.Parse(name, new string[, ] { { "ProjectName", projectCreateInformation.ProjectName } }); // Set the file before setting the name, to make sure the file extension is kept project.FileName = Path.Combine(projectCreateInformation.ProjectBasePath, pname); project.Name = pname; var dnp = project as DotNetProject; if (dnp != null) { if (policyParent.ParentSolution != null && !policyParent.ParentSolution.FileFormat.SupportsFramework(dnp.TargetFramework)) { SetClosestSupportedTargetFramework(policyParent.ParentSolution.FileFormat, dnp); } foreach (ProjectReference projectReference in references) { dnp.References.Add(projectReference); } } foreach (SingleFileDescriptionTemplate resourceTemplate in resources) { try { ProjectFile projectFile = new ProjectFile(resourceTemplate.SaveFile(policyParent, project, defaultLanguage, project.BaseDirectory, null)); projectFile.BuildAction = BuildAction.EmbeddedResource; project.Files.Add(projectFile); } catch (Exception ex) { MessageService.ShowException(ex, GettextCatalog.GetString("File {0} could not be written.", resourceTemplate.Name)); LoggingService.LogError(GettextCatalog.GetString("File {0} could not be written.", resourceTemplate.Name), ex); } } foreach (FileDescriptionTemplate fileTemplate in files) { try { fileTemplate.AddToProject(policyParent, project, defaultLanguage, project.BaseDirectory, null); } catch (Exception ex) { MessageService.ShowException(ex, GettextCatalog.GetString("File {0} could not be written.", fileTemplate.Name)); LoggingService.LogError(GettextCatalog.GetString("File {0} could not be written.", fileTemplate.Name), ex); } } }
protected override BuildResult Build(MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration) { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Build Called"); #endif try { return(base.Build(monitor, item, configuration)); } finally { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Build Ended"); #endif } }
public virtual void Deserialize(object obj, ITypeSerializer handler, DataCollection data) { if (obj is ProjectFile) { ProjectFile pf = (ProjectFile)obj; //Map the old FileCopy action to the Content BuildAction with CopyToOutputDirectory set to "always" //BuildActionDataType handles mapping the BuildAction to "Content" DataValue value = data ["buildaction"] as DataValue; bool isFileCopy = value != null && value.Value == "FileCopy"; DataValue resourceId = data.Extract("resource_id") as DataValue; handler.Deserialize(obj, data); if (isFileCopy) { pf.CopyToOutputDirectory = FileCopyMode.Always; } if (resourceId != null) { pf.ResourceId = resourceId.Value; } } else if (obj is SolutionEntityItem) { DataValue ac = null; DataItem confItem = data ["Configurations"] as DataItem; if (confItem != null) { ac = (DataValue)confItem.ItemData.Extract("active"); } DataItem items = data.Extract("Items") as DataItem; if (items != null) { ReadItems(handler, (SolutionEntityItem)obj, items); } handler.Deserialize(obj, data); if (ac != null) { SolutionEntityItem item = (SolutionEntityItem)obj; item.DefaultConfigurationId = ac.Value; } DotNetProject np = obj as DotNetProject; if (np != null) { // Import the framework version TargetFrameworkMoniker fx = null; DataValue vfx = data["targetFramework"] as DataValue; if (vfx != null) { fx = TargetFrameworkMoniker.Parse(vfx.Value); } else { vfx = data ["clr-version"] as DataValue; if (vfx != null && vfx.Value == "Net_2_0") { fx = TargetFrameworkMoniker.NET_2_0; } else if (vfx != null && vfx.Value == "Net_1_1") { fx = TargetFrameworkMoniker.NET_1_1; } } if (fx != null) { np.TargetFramework = Runtime.SystemAssemblyService.GetTargetFramework(fx); } // Get the compile target from one of the configurations if (np.Configurations.Count > 0) { np.CompileTarget = (CompileTarget)Enum.Parse(typeof(CompileTarget), (string)np.Configurations [0].ExtendedProperties ["Build/target"]); } } } else if (obj is ProjectReference) { ProjectReference pref = (ProjectReference)obj; DataValue refto = data.Extract("refto") as DataValue; handler.Deserialize(obj, data); if (refto != null) { pref.Reference = refto.Value; if (pref.ReferenceType == ReferenceType.Assembly) { string basePath = Path.GetDirectoryName(handler.SerializationContext.BaseFile); pref.Reference = FileService.RelativeToAbsolutePath(basePath, pref.Reference); } } } else { handler.Deserialize(obj, data); } }
protected override IEnumerable <ExecutionTarget> GetExecutionTargets(SolutionEntityItem item, ConfigurationSelector configuration) { return(ExecutionTargets); }