internal async Task Initialize(ProgressMonitor monitor) { monitor.BeginTask(GettextCatalog.GetString("Initializing Main Window"), 4); try { monitors = (IdeProgressMonitorManager)await Runtime.GetService <ProgressMonitorManager> (); documentManager = await Runtime.GetService <DocumentManager> (); await Runtime.GetService <DocumentModelRegistry> (); await Runtime.GetService <DocumentControllerService> (); Counters.Initialization.Trace("Creating DefaultWorkbench"); workbench = (DefaultWorkbench)await Runtime.GetService <IShell> (); monitor.Step(1); Counters.Initialization.Trace("Initializing Workspace"); workbench.InitializeWorkspace(); monitor.Step(1); Counters.Initialization.Trace("Initializing Layout"); workbench.InitializeLayout(); monitor.Step(1); ((Gtk.Window)workbench).Visible = false; workbench.WorkbenchTabsChanged += WorkbenchTabsChanged; IdeApp.Workspace.StoringUserPreferences += OnStoringWorkspaceUserPreferences; IdeApp.Workspace.LoadingUserPreferences += OnLoadingWorkspaceUserPreferences; IdeApp.FocusOut += delegate(object o, EventArgs args) { if (!fileEventsFrozen) { fileEventsFrozen = true; FileService.FreezeEvents(); } }; IdeApp.FocusIn += delegate(object o, EventArgs args) { if (fileEventsFrozen) { fileEventsFrozen = false; FileService.ThawEvents(); } }; pads = null; // Make sure we get an up to date pad list. monitor.Step(1); } finally { monitor.EndTask(); } }
public void SetProgress(double progress) { int ns = (int)(progress * 100); monitor.Step(ns - step); step = ns; }
void InstallEntry(ProgressMonitor monitor, DeployContext ctx, SolutionFolderItem entry, ConfigurationSelector configuration) { foreach (DeployFile df in DeployService.GetDeployFiles(ctx, new SolutionFolderItem[] { entry }, configuration)) { string targetPath = df.ResolvedTargetFile; if (targetPath == null) { monitor.ReportWarning("Could not copy file '" + df.RelativeTargetPath + "': Unknown target directory."); continue; } CopyFile(monitor, df.SourcePath, df.ResolvedTargetFile, df.FileAttributes); } SolutionFolder c = entry as SolutionFolder; if (c != null) { monitor.BeginTask("Installing solution '" + c.Name + "'", c.Items.Count); foreach (SolutionFolderItem ce in c.Items) { InstallEntry(monitor, ctx, ce, configuration); monitor.Step(1); } monitor.EndTask(); } }
protected override void OnReadProject(ProgressMonitor monitor, MonoDevelop.Projects.MSBuild.MSBuildProject msproject) { base.OnReadProject(monitor, msproject); var ext = msproject.GetMonoDevelopProjectExtension("MonoDevelop.Autotools.MakefileInfo"); if (ext == null) { return; } data = MakefileData.Read(ext); if (data == null) { return; } monitor.BeginTask(GettextCatalog.GetString("Updating project from Makefile"), 1); try { data.OwnerProject = Project; if (data.SupportsIntegration) { data.UpdateProject(monitor, false); } monitor.Step(1); } catch (Exception e) { monitor.ReportError(GettextCatalog.GetString( "\tError loading Makefile for project {0}", Project.Name), e); } finally { monitor.EndTask(); } }
private void MakeStaticLibrary(Project project, ProjectFileCollection projectFiles, CProjectConfiguration configuration, ProjectPackageCollection packages, CompilerResults cr, ProgressMonitor monitor, string outputName) { if (!NeedsUpdate(projectFiles, configuration, outputName)) { return; } string objectFiles = string.Join(" ", ObjectFiles(projectFiles, configuration, true)); string args = string.Format("rcs \"{0}\" {1}", outputName, objectFiles); monitor.BeginTask(GettextCatalog.GetString("Generating static library {0} from object files", Path.GetFileName(outputName)), 1); string errorOutput; int exitCode = ExecuteCommand("ar", args, Path.GetDirectoryName(outputName), monitor, out errorOutput); if (exitCode == 0) { monitor.Step(1); } monitor.EndTask(); ParseCompilerOutput(errorOutput, cr); ParseLinkerOutput(errorOutput, cr); CheckReturnCode(exitCode, cr); }
protected async override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.ExecuteTargetName)) { await base.OnExecute(monitor, context, configuration); return; } OperationConsole console = context.ConsoleFactory.CreateConsole(); monitor.BeginTask(GettextCatalog.GetString("Executing {0}", Project.Name), 1); try { ProcessWrapper process = Runtime.ProcessService.StartProcess("make", data.ExecuteTargetName, Project.BaseDirectory, console.Out, console.Error, null); await process.Task; monitor.Log.WriteLine(GettextCatalog.GetString("The application exited with code: {0}", process.ExitCode)); monitor.Step(1); } catch (Exception e) { monitor.ReportError(GettextCatalog.GetString("Project could not be executed: "), e); return; } finally { monitor.EndTask(); console.Dispose(); } }
void Step() { completedWork++; if (monitor != null && completedWork % reportingThinningFactor == 0) { monitor.Step(reportingThinningFactor); } }
void RunActionsWithProgressMonitor(ProgressMonitor monitor, IList <PaketAction> actions) { foreach (PaketAction action in actions) { action.Monitor = monitor; action.Run(); monitor.Step(1); } }
void RunActionsWithProgressMonitor(ProgressMonitor monitor, IList <IPackageAction> packageActions) { foreach (IPackageAction action in packageActions) { action.Execute(monitor.CancellationToken); instrumentationService.InstrumentPackageAction(action); monitor.Step(1); } }
void RunActionsWithProgressMonitor(ProgressMonitor monitor, IList <IPackageAction> packageActions) { foreach (IPackageAction action in packageActions) { action.Execute(); InstrumentPackageAction(action); monitor.Step(1); } }
public async Task SaveAsync (ProgressMonitor monitor) { monitor.BeginTask (GettextCatalog.GetString ("Saving Workspace..."), Items.Count); List<WorkspaceItem> items = new List<WorkspaceItem> (Items); foreach (WorkspaceItem it in items) { await it.SaveAsync (monitor); monitor.Step (1); } monitor.EndTask (); }
public void OnReload() { using (ProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) { m.BeginTask(null, CurrentNodes.Length); foreach (ITreeNavigator nav in CurrentNodes) { Project p = (Project)nav.DataItem; p.ParentFolder.ReloadItem(m, p); m.Step(1); } m.EndTask(); } }
public void OnReload() { using (ProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) { m.BeginTask(null, CurrentNodes.Length); foreach (ITreeNavigator node in CurrentNodes) { Solution solution = (Solution)node.DataItem; solution.ParentWorkspace.ReloadItem(m, solution); m.Step(1); } m.EndTask(); } }
/// <summary> /// Tries to apply the actions passed in <paramref name="actions"/>. /// </summary> /// <param name="actions">The actions to apply.</param> /// <returns>The fixed code actions.</returns> public IEnumerable <ActionSummary> TryFixIssues(IEnumerable <ActionSummary> actions) { if (actions == null) { throw new ArgumentNullException("actions"); } // enumerate once var actionSummaries = actions as IList <ActionSummary> ?? actions.ToList(); var issueSummaries = actionSummaries.Select(action => action.IssueSummary).ToList(); var files = issueSummaries.Select(issue => issue.File).Distinct().ToList(); monitor.BeginTask("Applying fixes", files.Count); var appliedActions = new List <ActionSummary> (issueSummaries.Count); Parallel.ForEach(files, file => { monitor.Step(1); var fileSummaries = issueSummaries.Where(summary => summary.File == file); var inspectorIds = new HashSet <string> (fileSummaries.Select(summary => summary.InspectorIdString)); bool isOpen; var data = TextFileProvider.Instance.GetTextEditorData(file.FilePath, out isOpen); IRefactoringContext refactoringContext; var realActions = GetIssues(data, file, inspectorIds, out refactoringContext).SelectMany(issue => issue.Actions).ToList(); if (realActions.Count == 0 || refactoringContext == null) { return; } var fileActionSummaries = actionSummaries.Where(summary => summary.IssueSummary.File == file).ToList(); var matches = matcher.Match(fileActionSummaries, realActions).ToList(); var appliedFixes = RefactoringService.ApplyFixes(matches.Select(match => match.Action), refactoringContext); appliedActions.AddRange(matches.Where(match => appliedFixes.Contains(match.Action)).Select(match => match.Summary)); if (!isOpen) { // If the file is open we leave it to the user to explicitly save the file data.Save(); } }); return(appliedActions); }
static async Task BuildPackages(ICollection packages) { ProgressMonitor mon = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor(true); // Run the deploy command in a background thread to avoid // deadlocks with the gui thread using (mon) { mon.BeginTask("Creating packages", packages.Count); foreach (Package p in packages) { await DeployService.BuildPackage(mon, p); mon.Step(1); } mon.EndTask(); } }
public void OnUnload() { HashSet <Solution> solutions = new HashSet <Solution> (); using (ProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) { m.BeginTask(null, CurrentNodes.Length); foreach (ITreeNavigator nav in CurrentNodes) { UnknownSolutionItem p = (UnknownSolutionItem)nav.DataItem; solutions.Add(p.ParentSolution); p.Enabled = false; p.ParentFolder.ReloadItem(m, p); m.Step(1); } m.EndTask(); } IdeApp.ProjectOperations.SaveAsync(solutions); }
private bool PrecompileHeaders(ProjectFileCollection projectFiles, CProjectConfiguration configuration, string args, ProgressMonitor monitor, CompilerResults cr) { monitor.BeginTask(GettextCatalog.GetString("Precompiling headers"), 1); bool success = true; foreach (ProjectFile file in projectFiles) { if (file.Subtype == Subtype.Code && CProject.IsHeaderFile(file.Name)) { string precomp = Path.Combine(configuration.IntermediateOutputDirectory, "prec"); precomp = Path.Combine(precomp, configuration.Id); precomp = Path.Combine(precomp, Path.GetFileName(file.Name) + ".ghc"); if (file.BuildAction == BuildAction.Compile) { if (!File.Exists(precomp) || configuration.UseCcache || File.GetLastWriteTime(file.Name) > File.GetLastWriteTime(precomp)) { if (DoPrecompileHeader(file, precomp, args, monitor, cr) == false) { success = false; break; } } } else { //remove old files or they'll interfere with the build if (File.Exists(precomp)) { File.Delete(precomp); } } } } if (success) { monitor.Step(1); } monitor.EndTask(); return(success); }
void CreateDefaultCatalog(ProgressMonitor monitor) { IFileScanner[] scanners = TranslationService.GetFileScanners(); Catalog catalog = new Catalog(this); List <Project> projects = new List <Project> (); foreach (Project p in ParentSolution.GetAllProjects()) { if (IsIncluded(p)) { projects.Add(p); } } foreach (Project p in projects) { monitor.Log.WriteLine(GettextCatalog.GetString("Scanning project {0}...", p.Name)); foreach (ProjectFile file in p.Files) { if (!File.Exists(file.FilePath)) { continue; } if (file.Subtype == Subtype.Code) { string mimeType = DesktopService.GetMimeTypeForUri(file.FilePath); foreach (IFileScanner fs in scanners) { if (fs.CanScan(this, catalog, file.FilePath, mimeType)) { fs.UpdateCatalog(this, catalog, monitor, file.FilePath); } } } } if (monitor.CancellationToken.IsCancellationRequested) { return; } monitor.Step(1); } catalog.Save(Path.Combine(this.BaseDirectory, "messages.po")); }
protected async override Task <BuildResult> OnClean(ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext) { if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.CleanTargetName)) { return(await base.OnClean(monitor, configuration, operationContext)); } monitor.BeginTask(GettextCatalog.GetString("Cleaning project"), 1); try { string baseDir = Project.BaseDirectory; ProcessWrapper process = Runtime.ProcessService.StartProcess("make", data.CleanTargetName, baseDir, monitor.Log, monitor.Log, null); await process.Task; if (process.ExitCode > 0) { throw new Exception(GettextCatalog.GetString("An unspecified error occurred while running '{0}'", "make " + data.CleanTargetName)); } monitor.Step(1); } catch (Exception e) { monitor.ReportError(GettextCatalog.GetString("Project could not be cleaned: "), e); var res = new BuildResult(); res.AddError(GettextCatalog.GetString("Project could not be cleaned: ") + e.Message); return(res); } finally { monitor.EndTask(); } monitor.ReportSuccess(GettextCatalog.GetString("Project successfully cleaned")); return(BuildResult.CreateSuccess()); }
public void OnReload() { var solutions = new HashSet <Solution> (); using (ProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) { m.BeginTask(null, CurrentNodes.Length); foreach (ITreeNavigator node in CurrentNodes) { UnknownSolutionItem entry = (UnknownSolutionItem)node.DataItem; if (!entry.Enabled) { entry.Enabled = true; solutions.Add(entry.ParentSolution); } entry.ParentFolder.ReloadItem(m, entry); m.Step(1); } m.EndTask(); } IdeApp.ProjectOperations.SaveAsync(solutions); }
async Task WriteWorkspaceItem(FilePath actualFile, FilePath outFile, WorkspaceItem item, ProgressMonitor monitor) { Workspace ws = item as Workspace; if (ws != null) { monitor.BeginTask(null, ws.Items.Count); try { foreach (WorkspaceItem it in ws.Items) { await it.SaveAsync(monitor); monitor.Step(1); } } finally { monitor.EndTask(); } } await Task.Run(delegate { StreamWriter sw = new StreamWriter(outFile); try { monitor.BeginTask(GettextCatalog.GetString("Saving item: {0}", actualFile), 1); XmlTextWriter tw = new XmlTextWriter(sw); tw.Formatting = Formatting.Indented; XmlDataSerializer ser = new XmlDataSerializer(MD1ProjectService.DataContext); ser.SerializationContext.BaseFile = actualFile; ser.SerializationContext.ProgressMonitor = monitor; ser.Serialize(sw, item, typeof(WorkspaceItem)); } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Could not save item: {0}", actualFile), ex); throw; } finally { monitor.EndTask(); sw.Close(); } }); }
public static Task WaitForRunningTools(ProgressMonitor monitor) { TaskInfo[] operations; lock (runningTasks) { operations = runningTasks.Values.ToArray(); } if (operations.Length == 0) { return(Task.FromResult(true)); } monitor.BeginTask("Waiting for custom tools...", operations.Length); List <Task> tasks = new List <Task> (); foreach (var t in operations) { tasks.Add(t.Task.ContinueWith(ta => { if (!monitor.CancellationToken.IsCancellationRequested) { monitor.Step(1); } })); } var cancelTask = new TaskCompletionSource <bool> (); var allDone = Task.WhenAll(tasks); var cancelReg = monitor.CancellationToken.Register(() => { cancelTask.SetResult(true); }); return(Task.WhenAny(allDone, cancelTask.Task).ContinueWith(t => { monitor.EndTask(); cancelReg.Dispose(); })); }
public Translation AddNewTranslation(string isoCode, ProgressMonitor monitor) { try { Translation tr = new Translation(this, isoCode); translations.Add(tr); string templateFile = Path.Combine(this.BaseDirectory, "messages.po"); string translationFile = GetFileName(isoCode); if (!File.Exists(templateFile)) { CreateDefaultCatalog(monitor); } File.Copy(templateFile, translationFile); monitor.ReportSuccess(String.Format(GettextCatalog.GetString("Language '{0}' successfully added."), isoCode)); monitor.Step(1); SaveAsync(monitor); return(tr); } catch (Exception e) { monitor.ReportError(String.Format(GettextCatalog.GetString("Language '{0}' could not be added: "), isoCode), e); return(null); } finally { monitor.EndTask(); } }
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); }
internal void LoadSolution(Solution sol, SlnFile sln, ProgressMonitor monitor, SolutionLoadContext ctx) { var version = sln.FormatVersion; //Parse the .sln file var folder = sol.RootFolder; sol.Version = "0.1"; //FIXME: monitor.BeginTask("Loading projects ..", sln.Projects.Count + 1); Dictionary <string, SolutionFolderItem> items = new Dictionary <string, SolutionFolderItem> (); List <string> sortedList = new List <string> (); List <Task> loadTasks = new List <Task> (); foreach (SlnProject sec in sln.Projects) { try { // Valid guid? new Guid(sec.TypeGuid); } catch (FormatException) { monitor.Step(1); //Use default guid as projectGuid LoggingService.LogDebug(GettextCatalog.GetString( "Invalid Project type guid '{0}' on line #{1}. Ignoring.", sec.Id, sec.Line)); continue; } string projTypeGuid = sec.TypeGuid.ToUpper(); string projectName = sec.Name; string projectPath = sec.FilePath; string projectGuid = sec.Id; lock (items) sortedList.Add(projectGuid); if (projTypeGuid == MSBuildProjectService.FolderTypeGuid) { //Solution folder SolutionFolder sfolder = new SolutionFolder(); sfolder.Name = projectName; sfolder.ItemId = projectGuid; DeserializeSolutionItem(monitor, sol, sfolder, sec); foreach (string f in ReadFolderFiles(sec)) { sfolder.Files.Add(MSBuildProjectService.FromMSBuildPath(Path.GetDirectoryName(sol.FileName), f)); } lock (items) items.Add(projectGuid, sfolder); monitor.Step(1); continue; } if (projectPath.StartsWith("http://")) { monitor.ReportWarning(GettextCatalog.GetString( "{0}({1}): Projects with non-local source (http://...) not supported. '{2}'.", sol.FileName, sec.Line, projectPath)); monitor.Step(1); continue; } string path = MSBuildProjectService.FromMSBuildPath(Path.GetDirectoryName(sol.FileName), projectPath); if (String.IsNullOrEmpty(path)) { monitor.ReportWarning(GettextCatalog.GetString( "Invalid project path found in {0} : {1}", sol.FileName, projectPath)); LoggingService.LogWarning(GettextCatalog.GetString( "Invalid project path found in {0} : {1}", sol.FileName, projectPath)); monitor.Step(1); continue; } projectPath = Path.GetFullPath(path); SolutionItem item = null; Task <SolutionItem> loadTask; DateTime ti = DateTime.Now; if (sol.IsSolutionItemEnabled(projectPath)) { loadTask = Services.ProjectService.ReadSolutionItem(monitor, projectPath, format, projTypeGuid, projectGuid, ctx); } else { loadTask = Task.FromResult <SolutionItem> (new UnloadedSolutionItem() { FileName = projectPath }); } var ft = loadTask.ContinueWith(ta => { try { item = ta.Result; if (item == null) { throw new UnknownSolutionItemTypeException(projTypeGuid); } } catch (Exception cex) { var e = UnwrapException(cex).First(); string unsupportedMessage = e.Message; if (e is UserException) { var ex = (UserException)e; LoggingService.LogError("{0}: {1}", ex.Message, ex.Details); monitor.ReportError(string.Format("{0}{1}{1}{2}", ex.Message, Environment.NewLine, ex.Details), null); } else { LoggingService.LogError(string.Format("Error while trying to load the project {0}", projectPath), e); monitor.ReportWarning(GettextCatalog.GetString( "Error while trying to load the project '{0}': {1}", projectPath, e.Message)); } SolutionItem uitem; uitem = new UnknownSolutionItem() { FileName = projectPath, LoadError = unsupportedMessage, }; item = uitem; item.ItemId = projectGuid; item.TypeGuid = projTypeGuid; } item.UnresolvedProjectDependencies = ReadSolutionItemDependencies(sec); // Deserialize the object DeserializeSolutionItem(monitor, sol, item, sec); lock (items) { if (!items.ContainsKey(projectGuid)) { items.Add(projectGuid, item); } else { monitor.ReportError(GettextCatalog.GetString("Invalid solution file. There are two projects with the same GUID. The project {0} will be ignored.", projectPath), null); } } monitor.Step(1); }); loadTasks.Add(ft); } Task.WaitAll(loadTasks.ToArray()); sol.LoadedProjects = new HashSet <string> (items.Keys); var nested = sln.Sections.GetSection("NestedProjects"); if (nested != null) { LoadNestedProjects(nested, items, monitor); } // Resolve project dependencies foreach (var it in items.Values.OfType <SolutionItem> ()) { if (it.UnresolvedProjectDependencies != null) { foreach (var id in it.UnresolvedProjectDependencies.ToArray()) { SolutionFolderItem dep; if (items.TryGetValue(id, out dep) && dep is SolutionItem) { it.UnresolvedProjectDependencies.Remove(id); it.ItemDependencies.Add((SolutionItem)dep); } } if (it.UnresolvedProjectDependencies.Count == 0) { it.UnresolvedProjectDependencies = null; } } } //Add top level folders and projects to the main folder foreach (string id in sortedList) { SolutionFolderItem ce; if (items.TryGetValue(id, out ce) && ce.ParentFolder == null) { folder.Items.Add(ce); } } //FIXME: This can be just SolutionConfiguration also! LoadSolutionConfigurations(sln.SolutionConfigurationsSection, sol, monitor); LoadProjectConfigurationMappings(sln.ProjectConfigurationsSection, sol, items, monitor); foreach (var e in sln.Sections) { string name = e.Id; if (name.StartsWith("MonoDevelopProperties.")) { int i = name.IndexOf('.'); LoadMonoDevelopConfigurationProperties(name.Substring(i + 1), e, sol, monitor); } } monitor.EndTask(); }
public static void Initialize(ProgressMonitor monitor) { // Already done in IdeSetup, but called again since unit tests don't use IdeSetup. DispatchService.Initialize(); Counters.Initialization.Trace("Creating Workbench"); workbench = new Workbench(); Counters.Initialization.Trace("Creating Root Workspace"); workspace = new RootWorkspace(); Counters.Initialization.Trace("Creating Services"); projectOperations = new ProjectOperations(); helpOperations = new HelpOperations(); commandService = new CommandManager(); ideServices = new IdeServices(); CustomToolService.Init(); commandService.CommandTargetScanStarted += CommandServiceCommandTargetScanStarted; commandService.CommandTargetScanFinished += CommandServiceCommandTargetScanFinished; commandService.KeyBindingFailed += KeyBindingFailed; KeyBindingService.LoadBindingsFromExtensionPath("/MonoDevelop/Ide/KeyBindingSchemes"); KeyBindingService.LoadCurrentBindings("MD2"); commandService.CommandError += delegate(object sender, CommandErrorArgs args) { LoggingService.LogInternalError(args.ErrorMessage, args.Exception); }; FileService.ErrorHandler = FileServiceErrorHandler; monitor.BeginTask(GettextCatalog.GetString("Loading Workbench"), 6); Counters.Initialization.Trace("Loading Commands"); commandService.LoadCommands("/MonoDevelop/Ide/Commands"); monitor.Step(1); // Before startup commands. Counters.Initialization.Trace("Running Pre-Startup Commands"); AddinManager.AddExtensionNodeHandler("/MonoDevelop/Ide/PreStartupHandlers", OnExtensionChanged); monitor.Step(1); Counters.Initialization.Trace("Initializing Workbench"); workbench.Initialize(monitor); monitor.Step(1); MonoDevelop.Ide.WelcomePage.WelcomePageService.Initialize(); MonoDevelop.Ide.WelcomePage.WelcomePageService.ShowWelcomePage(); monitor.Step(1); Counters.Initialization.Trace("Restoring Workbench State"); workbench.Show("SharpDevelop.Workbench.WorkbenchMemento"); monitor.Step(1); Counters.Initialization.Trace("Flushing GUI events"); DispatchService.RunPendingEvents(); Counters.Initialization.Trace("Flushed GUI events"); MessageService.RootWindow = workbench.RootWindow; Xwt.MessageDialog.RootWindow = Xwt.Toolkit.CurrentEngine.WrapWindow(workbench.RootWindow); commandService.EnableIdleUpdate = true; if (Customizer != null) { Customizer.OnIdeInitialized(); } // Startup commands Counters.Initialization.Trace("Running Startup Commands"); AddinManager.AddExtensionNodeHandler("/MonoDevelop/Ide/StartupHandlers", OnExtensionChanged); monitor.Step(1); monitor.EndTask(); // Set initial run flags Counters.Initialization.Trace("Upgrading Settings"); if (PropertyService.Get("MonoDevelop.Core.FirstRun", false)) { isInitialRun = true; PropertyService.Set("MonoDevelop.Core.FirstRun", false); PropertyService.Set("MonoDevelop.Core.LastRunVersion", BuildInfo.Version); PropertyService.Set("MonoDevelop.Core.LastRunRevision", CurrentRevision); PropertyService.SaveProperties(); } string lastVersion = PropertyService.Get("MonoDevelop.Core.LastRunVersion", "1.9.1"); int lastRevision = PropertyService.Get("MonoDevelop.Core.LastRunRevision", 0); if (lastRevision != CurrentRevision && !isInitialRun) { isInitialRunAfterUpgrade = true; if (lastRevision == 0) { switch (lastVersion) { case "1.0": lastRevision = 1; break; case "2.0": lastRevision = 2; break; case "2.2": lastRevision = 3; break; case "2.2.1": lastRevision = 4; break; } } upgradedFromRevision = lastRevision; PropertyService.Set("MonoDevelop.Core.LastRunVersion", BuildInfo.Version); PropertyService.Set("MonoDevelop.Core.LastRunRevision", CurrentRevision); PropertyService.SaveProperties(); } // The ide is now initialized isInitialized = true; if (isInitialRun) { try { OnInitialRun(); } catch (Exception e) { LoggingService.LogError("Error found while initializing the IDE", e); } } if (isInitialRunAfterUpgrade) { try { OnUpgraded(upgradedFromRevision); } catch (Exception e) { LoggingService.LogError("Error found while initializing the IDE", e); } } if (initializedEvent != null) { initializedEvent(null, EventArgs.Empty); initializedEvent = null; } //FIXME: we should really make this on-demand. consumers can display a "loading help cache" message like VS MonoDevelop.Projects.HelpService.AsyncInitialize(); UpdateInstrumentationIcon(); IdeApp.Preferences.EnableInstrumentation.Changed += delegate { UpdateInstrumentationIcon(); }; AutoTestService.Start(commandService, Preferences.EnableAutomatedTesting); AutoTestService.NotifyEvent("MonoDevelop.Ide.IdeStart"); Gtk.LinkButton.SetUriHook((button, uri) => Xwt.Desktop.OpenUrl(uri)); }
public object ReadFile(FilePath fileName, bool hasParentSolution, ProgressMonitor monitor) { FilePath basePath = fileName.ParentDirectory; MonoMakefile mkfile = new MonoMakefile(fileName); string aname = mkfile.GetVariable("LIBRARY"); if (aname == null) { aname = mkfile.GetVariable("PROGRAM"); } if (!string.IsNullOrEmpty(aname)) { monitor.BeginTask("Loading '" + fileName + "'", 0); var project = Services.ProjectService.CreateProject("C#"); project.FileName = fileName; var ext = new MonoMakefileProjectExtension(); project.AttachExtension(ext); ext.Read(mkfile); monitor.EndTask(); return(project); } string subdirs; StringBuilder subdirsBuilder = new StringBuilder(); subdirsBuilder.Append(mkfile.GetVariable("common_dirs")); if (subdirsBuilder.Length != 0) { subdirsBuilder.Append("\t"); subdirsBuilder.Append(mkfile.GetVariable("net_2_0_dirs")); } if (subdirsBuilder.Length == 0) { subdirsBuilder.Append(mkfile.GetVariable("SUBDIRS")); } subdirs = subdirsBuilder.ToString(); if (subdirs != null && (subdirs = subdirs.Trim(' ', '\t')) != "") { object retObject; SolutionFolder folder; if (!hasParentSolution) { Solution sol = new Solution(); sol.AttachExtension(new MonoMakefileSolutionExtension()); sol.FileName = fileName; folder = sol.RootFolder; retObject = sol; foreach (string conf in MonoMakefile.MonoConfigurations) { SolutionConfiguration sc = new SolutionConfiguration(conf); sol.Configurations.Add(sc); } } else { folder = new SolutionFolder(); folder.Name = Path.GetFileName(Path.GetDirectoryName(fileName)); retObject = folder; } subdirs = subdirs.Replace('\t', ' '); string[] dirs = subdirs.Split(' '); monitor.BeginTask("Loading '" + fileName + "'", dirs.Length); HashSet <string> added = new HashSet <string> (); foreach (string dir in dirs) { if (!added.Add(dir)) { continue; } monitor.Step(1); if (dir == null) { continue; } string tdir = dir.Trim(); if (tdir == "") { continue; } string mfile = Path.Combine(Path.Combine(basePath, tdir), "Makefile"); if (File.Exists(mfile) && CanRead(mfile, typeof(SolutionItem))) { SolutionFolderItem it = (SolutionFolderItem)ReadFile(mfile, true, monitor); folder.Items.Add(it); } } monitor.EndTask(); return(retObject); } return(null); }
public void UpdateTranslations(ProgressMonitor monitor, params Translation[] translations) { monitor.BeginTask(null, Translations.Count + 1); try { List <Project> projects = new List <Project> (); foreach (Project p in ParentSolution.GetAllProjects()) { if (IsIncluded(p)) { projects.Add(p); } } monitor.BeginTask(GettextCatalog.GetString("Updating message catalog"), projects.Count); CreateDefaultCatalog(monitor); monitor.Log.WriteLine(GettextCatalog.GetString("Done")); } finally { monitor.EndTask(); monitor.Step(1); } if (monitor.CancellationToken.IsCancellationRequested) { monitor.Log.WriteLine(GettextCatalog.GetString("Operation cancelled.")); return; } Dictionary <string, bool> isIncluded = new Dictionary <string, bool> (); foreach (Translation translation in translations) { isIncluded[translation.IsoCode] = true; } foreach (Translation translation in this.Translations) { if (!isIncluded.ContainsKey(translation.IsoCode)) { continue; } string poFileName = translation.PoFile; monitor.BeginTask(GettextCatalog.GetString("Updating {0}", translation.PoFile), 1); try { var pb = new ProcessArgumentBuilder(); pb.Add("-U"); pb.AddQuoted(poFileName); pb.Add("-v"); pb.AddQuoted(this.BaseDirectory.Combine("messages.po")); var process = Runtime.ProcessService.StartProcess(Translation.GetTool("msgmerge"), pb.ToString(), this.BaseDirectory, monitor.Log, monitor.Log, null); process.WaitForOutput(); } catch (System.ComponentModel.Win32Exception) { var msg = GettextCatalog.GetString("Did not find msgmerge. Please ensure that gettext tools are installed."); monitor.ReportError(msg, null); } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Could not update file {0}", translation.PoFile), ex); } finally { monitor.EndTask(); monitor.Step(1); } if (monitor.CancellationToken.IsCancellationRequested) { monitor.Log.WriteLine(GettextCatalog.GetString("Operation cancelled.")); return; } } }
public static void TransferFiles( ProgressMonitor monitor, FilePath sourcePath, FilePath targetPath, bool removeFromSource) { // When transfering directories, targetPath is the directory where the source // directory will be transfered, including the destination directory or file name. // For example, if sourcePath is /a1/a2/a3 and targetPath is /b1/b2, the // new folder or file will be /b1/b2 bool sourceIsFolder = Directory.Exists(sourcePath); bool movingFolder = removeFromSource && sourceIsFolder; // We need to remove all files + directories from the source project // but when dealing with the VCS addins we need to process only the // files so we do not create a 'file' in the VCS which corresponds // to a directory in the project and blow things up. var filesToRemove = new List <SystemFile> (); try { GetAllFilesRecursive(sourcePath, filesToRemove); } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Could not get any file from '{0}'.", sourcePath), ex); return; } // Strip out all the directories to leave us with just the files. List <SystemFile> filesToMove = filesToRemove.Where(f => !Directory.Exists(f.Path)).ToList(); // Ensure that the destination folder is created, even if no files // are copied try { if (sourceIsFolder && !Directory.Exists(targetPath) && !movingFolder) { FileService.CreateDirectory(targetPath); } } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Could not create directory '{0}'.", targetPath), ex); return; } // Transfer files // If moving a folder, do it all at once if (movingFolder) { try { FileService.MoveDirectory(sourcePath, targetPath); } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Directory '{0}' could not be moved.", sourcePath), ex); return; } } if (removeFromSource) { monitor.BeginTask(GettextCatalog.GetString("Moving files..."), filesToMove.Count); } else { monitor.BeginTask(GettextCatalog.GetString("Copying files..."), filesToMove.Count); } foreach (SystemFile file in filesToMove) { var sourceFile = file.Path; FilePath newFile; if (sourceIsFolder) { newFile = targetPath.Combine(sourceFile.ToRelative(sourcePath)); } else if (sourceFile == sourcePath) { newFile = targetPath; } else if (sourceFile.ParentDirectory != targetPath.ParentDirectory) { newFile = targetPath.ParentDirectory.Combine(sourceFile.ToRelative(sourcePath.ParentDirectory)); } else { newFile = GetTargetCopyName(sourceFile, false); } if (!movingFolder) { try { FilePath fileDir = newFile.ParentDirectory; if (!Directory.Exists(fileDir)) { FileService.CreateDirectory(fileDir); } if (removeFromSource) { // File.Move() does not have an overwrite argument and will fail if the destFile path exists, however, the user // has already chosen to overwrite the destination file. if (File.Exists(newFile)) { File.Delete(newFile); } FileService.MoveFile(sourceFile, newFile); } else { FileService.CopyFile(sourceFile, newFile); } } catch (Exception ex) { if (removeFromSource) { monitor.ReportError(GettextCatalog.GetString("File '{0}' could not be moved.", sourceFile), ex); } else { monitor.ReportError(GettextCatalog.GetString("File '{0}' could not be copied.", sourceFile), ex); } monitor.Step(1); continue; } } monitor.Step(1); } monitor.EndTask(); }
public async Task <string> DownloadSampleAsync(ProgressMonitor progressMonitor = null) { try { string projectPath = string.Empty; if (!string.IsNullOrEmpty(SelectedSample.DownloadUrl)) { progressMonitor?.BeginTask("Downloading...", 1); string zipProjectPath = Path.Combine(UserProfile.Current.TempDir, $"{SelectedSample.Name}.zip"); projectPath = Path.Combine(UserProfile.Current.TempDir, SelectedSample.Name); if (!File.Exists(zipProjectPath)) { await _sampleImporterService.DownloadSampleAsync(new Uri(SelectedSample.DownloadUrl), zipProjectPath); } progressMonitor?.Step(); if (!Directory.Exists(projectPath)) { Directory.CreateDirectory(projectPath); ZipFile.ExtractToDirectory(zipProjectPath, projectPath); } var solutions = Directory.GetFiles(projectPath, "*.sln", SearchOption.AllDirectories); var solution = solutions.FirstOrDefault(); if (!string.IsNullOrEmpty(solution)) { projectPath = solution; } } else { var content = await _sampleImporterService.GetSampleContentAsync(SelectedSample); progressMonitor?.BeginTask("Downloading...", content.Count); var folders = content.Where(c => c.Type == ContentType.Dir); foreach (var folder in folders) { string directoryPath = Path.Combine(_projectsPath, folder.Path); if (!Directory.Exists(directoryPath)) { progressMonitor?.Step(); progressMonitor?.Log.WriteLine("Creating folder" + ": " + directoryPath); Directory.CreateDirectory(directoryPath); } } var files = content.Where(c => c.Type == ContentType.File); foreach (var file in files) { string filePath = Path.Combine(_projectsPath, file.Path); progressMonitor?.Step(); progressMonitor?.Log.WriteLine("Downloading file" + ": " + filePath); await _downloaderService.DownloadFileAsync(file.DownloadUrl, filePath, CancellationToken.None); } var projectFile = files.FirstOrDefault(c => c.Path.EndsWith(".sln", StringComparison.InvariantCultureIgnoreCase)); if (projectFile != null) { projectPath = Path.Combine(_projectsPath, projectFile.Path); } } return(projectPath); } catch (Exception ex) { LoggingService.LogError(ex.Message); return(string.Empty); } }