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;
}
public List<WorkItem> LoadByWorkItem(IProgressMonitor progress)
{
var ids = this.clientService.GetWorkItemIds(this.query, CachedMetaData.Instance.Fields);
var list = new List<WorkItem>();
progress.BeginTask("Loading WorkItems", ids.Count);
foreach (var id in ids)
{
list.Add(clientService.GetWorkItem(id));
progress.Step(1);
}
progress.EndTask();
return list;
}
public List<WorkItem> LoadByPage(IProgressMonitor progress)
{
var ids = this.clientService.GetWorkItemIds(this.query, CachedMetaData.Instance.Fields);
int pages = (int)Math.Ceiling((double)ids.Count / (double)50);
var result = new List<WorkItem>();
progress.BeginTask("Loading WorkItems", pages);
for (int i = 0; i < pages; i++)
{
var idList = new List<int>(ids.Skip(i * 50).Take(50));
var items = this.clientService.PageWorkitemsByIds(this.query, idList);
result.AddRange(items);
progress.Step(1);
}
progress.EndTask();
return result;
}
public void Save(IProgressMonitor monitor)
{
if (HasSlnData && !SavingSolution && Item.ParentSolution != null)
{
// The project has data that has to be saved in the solution, but the solution is not being saved. Do it now.
monitor.BeginTask(null, 2);
SaveItem(monitor);
monitor.Step(1);
Solution sol = Item.ParentSolution;
SolutionFormat.SlnFileFormat.WriteFile(sol.FileName, sol, SolutionFormat, false, monitor);
sol.NeedsReload = false;
monitor.EndTask();
}
else
{
SaveItem(monitor);
}
}
public void OnUnload()
{
HashSet <Solution> solutions = new HashSet <Solution> ();
using (IProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) {
m.BeginTask(null, CurrentNodes.Length);
foreach (ITreeNavigator nav in CurrentNodes)
{
Project p = (Project)nav.DataItem;
p.Enabled = false;
p.ParentFolder.ReloadItem(m, p);
m.Step(1);
solutions.Add(p.ParentSolution);
}
m.EndTask();
}
IdeApp.ProjectOperations.Save(solutions);
}
/// <summary>
/// Compile the project
/// </summary>
/// <param name="projectFiles">
/// Collection of project files
/// <see cref="ProjectFileCollection"/>
/// </param>
/// <param name="packages">
/// Collection of depended packages
/// <see cref="ProjectPackageCollection"/>
/// </param>
/// <param name="configuration">
/// Project configuration
/// <see cref="ValaProjectConfiguration"/>
/// </param>
/// <param name="monitor">
/// Progress monitor to be used
/// <see cref="IProgressMonitor"/>
/// </param>
/// <returns>
/// Result of the compilation
/// <see cref="ICompilerResult"/>
/// </returns>
public BuildResult Compile(
ProjectFileCollection projectFiles,
ProjectPackageCollection packages,
ValaProjectConfiguration configuration,
IProgressMonitor monitor)
{
if (!appsChecked)
{
appsChecked = true;
compilerFound = CheckApp(compilerCommand);
} /// Check for compiler
if (!compilerFound)
{
BuildResult cres = new BuildResult();
cres.AddError("Compiler not found: " + compilerCommand);
return(cres);
} /// No compiler!
CompilerResults cr = new CompilerResults(new TempFileCollection());
bool success = true;
/// Build compiler params string
string compilerArgs = GetCompilerFlags(configuration) + " " + GeneratePkgCompilerArgs(packages);
/// Build executable name
string outputName = Path.Combine(configuration.OutputDirectory,
configuration.CompiledOutputName);
monitor.BeginTask(GettextCatalog.GetString("Compiling source"), 1);
success = DoCompilation(projectFiles, compilerArgs, outputName, monitor, cr);
GenerateDepfile(configuration, packages);
if (success)
{
monitor.Step(1);
}
monitor.EndTask();
return(new BuildResult(cr, ""));
}
public static bool WaitForRunningTools(IProgressMonitor monitor)
{
IAsyncOperation[] operations;
lock (runningTasks) {
operations = runningTasks.Values.ToArray();
}
if (operations.Length == 0)
{
return(true);
}
monitor.BeginTask("Waiting for custom tools...", operations.Length);
var evt = new AutoResetEvent(false);
monitor.CancelRequested += delegate {
evt.Set();
};
OperationHandler checkOp = delegate {
monitor.Step(1);
if (operations.All(op => op.IsCompleted))
{
evt.Set();
}
};
foreach (var o in operations)
{
o.Completed += checkOp;
}
evt.WaitOne();
bool success = operations.All(op => op.Success);
if (!success)
{
monitor.ReportError("Error in custom tool", null);
}
monitor.EndTask();
return(success);
}
private bool PrecompileHeaders(ProjectFileCollection projectFiles,
CProjectConfiguration configuration,
string args,
IProgressMonitor 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);
}
protected override void OnClean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
if (ParentSolution == null)
{
return;
}
SolutionConfiguration conf = ParentSolution.GetConfiguration(configuration);
if (conf == null)
{
return;
}
try {
monitor.BeginTask(GettextCatalog.GetString("Cleaning Solution: {0} ({1})", Name, configuration.ToString()), Items.Count);
foreach (SolutionItem item in Items)
{
if (item is SolutionFolder)
{
item.Clean(monitor, configuration);
}
else if (item is SolutionEntityItem)
{
SolutionEntityItem si = (SolutionEntityItem)item;
// ce can be null if you add items to the root solution folder which
// causes them to be placed in an autogenerated 'Project Items' folder
SolutionConfigurationEntry ce = conf.GetEntryForItem(si);
if (ce != null && ce.Build)
{
si.Clean(monitor, ce.ItemConfigurationSelector);
}
}
else
{
item.Clean(monitor, configuration);
}
monitor.Step(1);
}
}
finally {
monitor.EndTask();
}
}
void WriteWorkspaceItem(FilePath actualFile, FilePath outFile, WorkspaceItem item, IProgressMonitor monitor)
{
Workspace ws = item as Workspace;
if (ws != null)
{
monitor.BeginTask(null, ws.Items.Count);
try
{
foreach (WorkspaceItem it in ws.Items)
{
it.Save(monitor);
monitor.Step(1);
}
}
finally
{
monitor.EndTask();
}
}
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();
}
}
protected override void Clean(IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
Project proj = entry as Project;
if (proj == null)
{
base.Clean(monitor, entry, configuration);
return;
}
MakefileData data = proj.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.CleanTargetName))
{
base.Clean(monitor, entry, configuration);
return;
}
monitor.BeginTask(GettextCatalog.GetString("Cleaning project"), 1);
try {
string baseDir = proj.BaseDirectory;
ProcessWrapper process = Runtime.ProcessService.StartProcess(data.AbsoluteMakeCommand,
data.CleanTargetName,
baseDir,
monitor.Log,
monitor.Log,
null);
process.WaitForOutput();
if (process.ExitCode > 0)
{
throw new Exception(GettextCatalog.GetString("An unspecified error occurred while running '{0} {1}'", data.AbsoluteMakeCommand, data.CleanTargetName));
}
monitor.Step(1);
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Project could not be cleaned: "), e);
return;
} finally {
monitor.EndTask();
}
monitor.ReportSuccess(GettextCatalog.GetString("Project successfully cleaned"));
}
void UpdateRepository(IProgressMonitor monitor, Uri baseUri, RepositoryRecord rr)
{
Uri absUri = new Uri(baseUri, rr.Url);
monitor.BeginTask("Updating from " + absUri.ToString(), 2);
Repository newRep = null;
Exception error = null;
try {
var provider = service.GetAddinRepositoryProvider(rr.ProviderId);
newRep = provider.DownloadRepository(monitor, absUri, rr);
} catch (Exception ex) {
error = ex;
}
if (newRep == null)
{
monitor.ReportError("Could not get information from repository" + ": " + absUri.ToString(), error);
return;
}
monitor.Step(1);
foreach (ReferenceRepositoryEntry re in newRep.Repositories)
{
Uri refRepUri = new Uri(absUri, re.Url);
string refRepUrl = refRepUri.ToString();
RepositoryRecord refRep = FindRepositoryRecord(refRepUrl);
if (refRep == null)
{
refRep = RegisterRepository(refRepUrl, true, rr.ProviderId);
}
refRep.Enabled = rr.Enabled;
// Update the repo if the modified timestamp changes or if there is no timestamp info
if (refRep.LastModified != re.LastModified || re.LastModified == DateTime.MinValue || !File.Exists(refRep.File))
{
refRep.LastModified = re.LastModified;
UpdateRepository(monitor, refRepUri, refRep);
}
}
monitor.EndTask();
rr.UpdateCachedRepository(newRep);
}
void CreateDefaultCatalog(IProgressMonitor 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.IsCancelRequested)
{
return;
}
monitor.Step(1);
}
catalog.Save(Path.Combine(this.BaseDirectory, "messages.po"));
}
protected override void OnClean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
if (ParentSolution == null)
{
return;
}
SolutionConfiguration conf = ParentSolution.GetConfiguration(configuration);
if (conf == null)
{
return;
}
try {
monitor.BeginTask(GettextCatalog.GetString("Cleaning Solution {0}", Name), Items.Count);
foreach (SolutionItem item in Items)
{
if (item is SolutionFolder)
{
item.Clean(monitor, configuration);
}
else if (item is SolutionEntityItem)
{
SolutionEntityItem si = (SolutionEntityItem)item;
SolutionConfigurationEntry ce = conf.GetEntryForItem(si);
if (ce.Build)
{
si.Clean(monitor, ce.ItemConfigurationSelector);
}
}
else
{
item.Clean(monitor, configuration);
}
monitor.Step(1);
}
}
finally {
monitor.EndTask();
}
}
protected override SolutionEntityItem LoadSolutionItem(IProgressMonitor monitor, string fileName)
{
SolutionEntityItem entry = base.LoadSolutionItem(monitor, fileName);
if (entry == null)
{
return(null);
}
Project project = entry as Project;
if (project == null)
{
return(entry);
}
//Project
MakefileData data = entry.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null)
{
return(entry);
}
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(
"Error loading Makefile for project {0}", project.Name), e);
} finally {
monitor.EndTask();
}
entry.SetNeedsBuilding(false);
return(entry);
}
protected override void Execute(IProgressMonitor monitor, SolutionEntityItem entry, ExecutionContext context, ConfigurationSelector configuration)
{
Project project = entry as Project;
if (project == null)
{
base.Execute(monitor, entry, context, configuration);
return;
}
MakefileData data = project.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.ExecuteTargetName))
{
base.Execute(monitor, entry, context, configuration);
return;
}
IConsole console = context.ConsoleFactory.CreateConsole(true);
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);
process.WaitForOutput();
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();
}
}
public void OnReload()
{
var solutions = new HashSet <Solution> ();
using (IProgressMonitor 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.Save(solutions);
}
/// <summary>
/// Cleans the files produced by this solution item
/// </summary>
/// <param name='monitor'>
/// A progress monitor
/// </param>
/// <param name='configuration'>
/// Configuration to use to clean the project
/// </param>
public void Clean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
ITimeTracker tt = Counters.BuildProjectTimer.BeginTiming("Cleaning " + Name);
try {
try {
SolutionEntityItem it = this as SolutionEntityItem;
SolutionItemConfiguration iconf = it != null?it.GetConfiguration(configuration) : null;
string confName = iconf != null ? iconf.Id : configuration.ToString();
monitor.BeginTask(GettextCatalog.GetString("Cleaning: {0} ({1})", Name, confName), 1);
RunTarget(monitor, ProjectService.CleanTarget, configuration);
monitor.Step(1);
} finally {
monitor.EndTask();
}
}
finally {
tt.End();
}
}
public IEnumerable<Tuple<ProjectDom, FilePath>> GetFileNames(Solution solution, ProjectDom dom, ICompilationUnit unit, IProgressMonitor monitor)
{
int counter = 0;
ReadOnlyCollection<Project> allProjects = solution.GetAllProjects();
if (monitor != null)
monitor.BeginTask(GettextCatalog.GetString("Finding references in solution..."),
allProjects.Sum<Project>(p => p.Files.Count));
foreach (Project project in allProjects) {
if (monitor != null && monitor.IsCancelRequested) yield break;
ProjectDom currentDom = ProjectDomService.GetProjectDom(project);
foreach (ProjectFile projectFile in (Collection<ProjectFile>) project.Files) {
if (monitor != null && monitor.IsCancelRequested) yield break;
yield return Tuple.Create<ProjectDom, FilePath>(currentDom, projectFile.FilePath);
if (monitor != null) {
if (counter % 10 == 0) monitor.Step(10);
++counter;
}
}
}
if (monitor != null) monitor.EndTask();
}
public static bool WaitForRunningTools(IProgressMonitor monitor)
{
IAsyncOperation[] operations;
lock (runningTasks) {
operations = runningTasks.Values.ToArray();
}
if (operations.Length == 0)
{
return(true);
}
monitor.BeginTask("Waiting for custom tools...", operations.Length);
var evt = new AutoResetEvent(false);
monitor.CancelRequested += delegate {
evt.Set();
};
OperationHandler checkOp = delegate {
monitor.Step(1);
if (operations.All(op => op.IsCompleted))
{
evt.Set();
}
};
foreach (var o in operations)
{
o.Completed += checkOp;
}
evt.WaitOne();
monitor.EndTask();
//the tool operations display warnings themselves
return(operations.Any(op => !op.SuccessWithWarnings));
}
public IEnumerable <Tuple <ProjectDom, FilePath> > GetFileNames(Solution solution, ProjectDom dom, ICompilationUnit unit, IProgressMonitor monitor)
{
int counter = 0;
ReadOnlyCollection <Project> allProjects = solution.GetAllProjects();
if (monitor != null)
{
monitor.BeginTask(GettextCatalog.GetString("Finding references in solution..."),
allProjects.Sum <Project>(p => p.Files.Count));
}
foreach (Project project in allProjects)
{
if (monitor != null && monitor.IsCancelRequested)
{
yield break;
}
ProjectDom currentDom = ProjectDomService.GetProjectDom(project);
foreach (ProjectFile projectFile in (Collection <ProjectFile>)project.Files)
{
if (monitor != null && monitor.IsCancelRequested)
{
yield break;
}
yield return(Tuple.Create <ProjectDom, FilePath>(currentDom, projectFile.FilePath));
if (monitor != null)
{
if (counter % 10 == 0)
{
monitor.Step(10);
}
++counter;
}
}
}
if (monitor != null)
{
monitor.EndTask();
}
}
/// <summary>
/// Copies resource files from the Xcode project (back) to the MonoDevelop project directory.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
void CopyFilesToMD(IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
{
return;
}
monitor.BeginStepTask("Copying files from Xcode back to MonoDevelop...", context.FileSyncJobs.Count, 1);
foreach (var file in context.FileSyncJobs)
{
monitor.Log.WriteLine("Copying {0} file from Xcode: {1}", file.IsFreshlyAdded ? "new" : "changed", file.SyncedRelative);
if (!Directory.Exists(file.Original.ParentDirectory))
{
Directory.CreateDirectory(file.Original.ParentDirectory);
}
var tempFile = file.Original.ParentDirectory.Combine(".#" + file.Original.ParentDirectory.FileName);
FilePath path = context.ProjectDir.Combine(file.SyncedRelative);
if (File.Exists(path))
{
File.Copy(path, tempFile);
FileService.SystemRename(tempFile, file.Original);
DateTime mtime = File.GetLastWriteTime(file.Original);
context.SetSyncTime(file.SyncedRelative, mtime);
}
else
{
monitor.ReportWarning(string.Format("'{0}' does not exist.", file.SyncedRelative));
}
monitor.Step(1);
}
monitor.EndTask();
}
void InstallEntry (IProgressMonitor monitor, DeployContext ctx, SolutionItem entry, ConfigurationSelector configuration)
{
foreach (DeployFile df in DeployService.GetDeployFiles (ctx, new SolutionItem[] { 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 (SolutionItem ce in c.Items) {
InstallEntry (monitor, ctx, ce, configuration);
monitor.Step (1);
}
monitor.EndTask ();
}
}
void UpdateRepository(IProgressMonitor monitor, Uri baseUri, RepositoryRecord rr)
{
Uri absUri = new Uri(baseUri, rr.Url);
monitor.BeginTask("Updating from " + absUri.ToString(), 2);
Repository newRep = null;
Exception error = null;
try {
newRep = (Repository)service.Store.DownloadObject(monitor, absUri.ToString(), typeof(Repository));
} catch (Exception ex) {
error = ex;
}
if (newRep == null)
{
monitor.ReportError("Could not get information from repository" + ": " + absUri.ToString(), error);
return;
}
monitor.Step(1);
foreach (ReferenceRepositoryEntry re in newRep.Repositories)
{
Uri refRepUri = new Uri(absUri, re.Url);
string refRepUrl = refRepUri.ToString();
RepositoryRecord refRep = FindRepositoryRecord(refRepUrl);
if (refRep == null)
{
refRep = RegisterRepository(refRepUrl, true);
}
if (refRep.LastModified < re.LastModified)
{
UpdateRepository(monitor, refRepUri, refRep);
}
}
monitor.EndTask();
rr.UpdateCachedRepository(newRep);
}
public void UpdateRepository(IProgressStatus statusMonitor, string url)
{
repoList = null;
IProgressMonitor monitor = ProgressStatusMonitor.GetProgressMonitor(statusMonitor);
monitor.BeginTask("Updating repositories", service.Configuration.Repositories.Count);
try {
int num = service.Configuration.Repositories.Count;
for (int n = 0; n < num; n++)
{
RepositoryRecord rr = (RepositoryRecord)service.Configuration.Repositories [n];
if ((url == null || rr.Url == url) && !rr.IsReference)
{
UpdateRepository(monitor, new Uri(rr.Url), rr);
}
monitor.Step(1);
}
} finally {
monitor.EndTask();
}
service.SaveConfiguration();
}
public XcodeSyncBackContext GetChanges(IProgressMonitor monitor, NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext(projectDir, syncTimeCache, infoService, project);
var needsSync = new List <XcodeSyncedItem> (items.Where(i => i.NeedsSyncBack(ctx)));
var knownFiles = GetKnownFiles();
ScanForAddedFiles(ctx, knownFiles, projectDir, null);
if (needsSync.Count > 0)
{
monitor.BeginStepTask(GettextCatalog.GetString("Synchronizing Xcode project changes"), needsSync.Count, 1);
for (int i = 0; i < needsSync.Count; i++)
{
var item = needsSync [i];
item.SyncBack(ctx);
monitor.Step(1);
}
monitor.Log.WriteLine(GettextCatalog.GetPluralString("Synchronized {0} file", "Synchronized {0} files", needsSync.Count), needsSync.Count);
monitor.EndTask();
}
return(ctx);
}
static IAsyncOperation BuildPackages(ICollection packages)
{
IProgressMonitor mon = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor(true);
// Run the deploy command in a background thread to avoid
// deadlocks with the gui thread
System.Threading.Thread t = new System.Threading.Thread(
delegate() {
using (mon) {
mon.BeginTask("Creating packages", packages.Count);
foreach (Package p in packages)
{
DeployService.BuildPackage(mon, p);
mon.Step(1);
}
mon.EndTask();
}
});
t.IsBackground = true;
t.Start();
return(mon.AsyncOperation);
}
public Translation AddNewTranslation(string isoCode, IProgressMonitor 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);
this.Save(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();
}
}
protected override void DoClean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
var cfg = GetConfiguration(configuration) as DProjectConfiguration;
// delete obj/res files
monitor.BeginTask("Delete intermediate files", Files.Count);
foreach (var f in Files)
{
try {
if (File.Exists(f.LastGenOutput))
{
File.Delete(f.LastGenOutput);
}
} catch (Exception ex) {
monitor.ReportError("Error while removing " + f, ex);
} finally {
f.LastGenOutput = string.Empty;
monitor.Step(1);
}
}
monitor.EndTask();
// delete target file
monitor.BeginTask("Delete output file", 1);
if (File.Exists(cfg.CompiledOutputName))
{
File.Delete(cfg.CompiledOutputName);
}
DeleteSupportFiles(monitor, cfg.Selector);
monitor.EndTask();
monitor.ReportSuccess("Cleanup successful!");
}
public static void Initialize (IProgressMonitor monitor)
{
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 ();
AutoTestService.Start (commandService, Preferences.EnableAutomatedTesting);
commandService.CommandTargetScanStarted += CommandServiceCommandTargetScanStarted;
commandService.CommandTargetScanFinished += CommandServiceCommandTargetScanFinished;
KeyBindingService.LoadBindingsFromExtensionPath ("/MonoDevelop/Ide/KeyBindingSchemes");
KeyBindingService.LoadCurrentBindings ("MD2");
commandService.CommandError += delegate (object sender, CommandErrorArgs args) {
MessageService.ShowException (args.Exception, args.ErrorMessage);
};
FileService.ErrorHandler = FileServiceErrorHandler;
monitor.BeginTask (GettextCatalog.GetString("Loading Workbench"), 5);
Counters.Initialization.Trace ("Loading Commands");
commandService.LoadCommands ("/MonoDevelop/Ide/Commands");
monitor.Step (1);
Counters.Initialization.Trace ("Initializing Workbench");
workbench.Initialize (monitor);
monitor.Step (1);
InternalLog.EnableErrorNotification ();
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;
commandService.EnableIdleUpdate = true;
// Default file format
MonoDevelop.Projects.Services.ProjectServiceLoaded += delegate(object sender, EventArgs e) {
((ProjectService)sender).DefaultFileFormatId = IdeApp.Preferences.DefaultProjectFileFormat;
};
IdeApp.Preferences.DefaultProjectFileFormatChanged += delegate {
IdeApp.Services.ProjectService.DefaultFileFormatId = IdeApp.Preferences.DefaultProjectFileFormat;
};
// Perser service initialization
MonoDevelop.Projects.Dom.Parser.ProjectDomService.TrackFileChanges = true;
MonoDevelop.Projects.Dom.Parser.ProjectDomService.ParseProgressMonitorFactory = new ParseProgressMonitorFactory ();
// Startup commands
Counters.Initialization.Trace ("Running Startup Commands");
AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Ide/StartupHandlers", OnExtensionChanged);
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", BuildVariables.PackageVersion);
PropertyService.Set ("MonoDevelop.Core.LastRunVersion", 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", BuildVariables.PackageVersion);
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);
// load previous combine
if ((bool)PropertyService.Get("SharpDevelop.LoadPrevProjectOnStartup", false)) {
RecentOpen recentOpen = Workbench.RecentOpen;
if (recentOpen.RecentProjectsCount > 0) {
IdeApp.Workspace.OpenWorkspaceItem(recentOpen.RecentProjects.First ().ToString()).WaitForCompleted ();
}
}
commandService.CommandSelected += OnCommandSelected;
commandService.CommandDeselected += OnCommandDeselected;
//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.EnableInstrumentationChanged += delegate {
UpdateInstrumentationIcon ();
};
AutoTestService.NotifyEvent ("MonoDevelop.Ide.IdeStart");
}
// Note: This method may throw TimeoutException or AppleScriptException
public void UpdateProject (IProgressMonitor monitor, List<XcodeSyncedItem> allItems, XcodeProject emptyProject)
{
items = allItems;
monitor.BeginTask (GettextCatalog.GetString ("Updating Xcode project for {0}...", name), items.Count);
var ctx = new XcodeSyncContext (projectDir, syncTimeCache);
var toRemove = new HashSet<string> (itemMap.Keys);
var toClose = new HashSet<string> ();
var syncList = new List<XcodeSyncedItem> ();
bool updateProject = false;
foreach (var item in items) {
bool needsSync = item.NeedsSyncOut (monitor, ctx);
if (needsSync)
syncList.Add (item);
var files = item.GetTargetRelativeFileNames ();
foreach (var file in files) {
toRemove.Remove (file);
if (!itemMap.ContainsKey (file)) {
monitor.Log.WriteLine ("'{0}' needs to be updated.", file);
updateProject = true;
} else if (needsSync) {
monitor.Log.WriteLine ("'{0}' needs to be closed.", file);
toClose.Add (file);
}
itemMap[file] = item;
}
}
updateProject = updateProject || toRemove.Any ();
bool removedOldProject = false;
if (updateProject) {
if (pendingProjectWrite == null && ProjectExists ()) {
monitor.Log.WriteLine ("A project file needs to be updated, closing and removing old project.");
CloseProject ();
DeleteXcproj (monitor);
removedOldProject = true;
}
} else {
foreach (var f in toClose)
CloseFile (monitor, projectDir.Combine (f));
}
foreach (var f in toRemove) {
itemMap.Remove (f);
syncTimeCache.Remove (f);
var path = projectDir.Combine (f);
if (File.Exists (path))
File.Delete (path);
}
if (removedOldProject) {
HackRelocateProject (monitor);
ctx.ProjectDir = projectDir;
}
foreach (var item in items) {
if (updateProject)
item.AddToProject (emptyProject, projectDir);
}
foreach (var item in syncList) {
item.SyncOut (monitor, ctx);
monitor.Step (1);
}
if (updateProject) {
monitor.Log.WriteLine ("Queued write of '{0}'.", xcproj);
pendingProjectWrite = emptyProject;
}
monitor.EndTask ();
monitor.ReportSuccess (GettextCatalog.GetString ("Xcode project updated."));
}
public XcodeSyncBackContext GetChanges (IProgressMonitor monitor, NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext (projectDir, syncTimeCache, infoService, project);
var needsSync = new List<XcodeSyncedItem> (items.Where (i => i.NeedsSyncBack (monitor, ctx)));
var knownFiles = GetKnownFiles ();
if (Directory.Exists (projectDir)) {
monitor.BeginTask ("Scanning for newly-added files in the Xcode project...", 0);
ScanForAddedFiles (monitor, ctx, knownFiles, projectDir, null);
monitor.EndTask ();
}
if (needsSync.Count > 0) {
monitor.BeginStepTask (GettextCatalog.GetString ("Synchronizing changes made to known files in Xcode back to MonoDevelop..."), needsSync.Count, 1);
for (int i = 0; i < needsSync.Count; i++) {
var item = needsSync [i];
item.SyncBack (monitor, ctx);
monitor.Step (1);
}
monitor.EndTask ();
}
return ctx;
}
public override void Revert (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
{
foreach (var group in localPaths.GroupBy (f => GetRepository (f))) {
var repository = group.Key;
var files = group.ToArray ();
var c = GetHeadCommit (repository);
RevTree tree = c != null ? c.Tree : null;
List<FilePath> changedFiles = new List<FilePath> ();
List<FilePath> removedFiles = new List<FilePath> ();
monitor.BeginTask (GettextCatalog.GetString ("Reverting files"), 3);
monitor.BeginStepTask (GettextCatalog.GetString ("Reverting files"), files.Length, 2);
DirCache dc = repository.LockDirCache ();
DirCacheBuilder builder = dc.Builder ();
try {
HashSet<string> entriesToRemove = new HashSet<string> ();
HashSet<string> foldersToRemove = new HashSet<string> ();
// Add the new entries
foreach (FilePath fp in files) {
string p = repository.ToGitPath (fp);
// Register entries to be removed from the index
if (Directory.Exists (fp))
foldersToRemove.Add (p);
else
entriesToRemove.Add (p);
TreeWalk tw = tree != null ? TreeWalk.ForPath (repository, p, tree) : null;
if (tw == null) {
// Removed from the index
}
else {
// Add new entries
TreeWalk r;
if (tw.IsSubtree) {
// It's a directory. Make sure we remove existing index entries of this directory
foldersToRemove.Add (p);
// We have to iterate through all folder files. We need a new iterator since the
// existing rw is not recursive
r = new NGit.Treewalk.TreeWalk(repository);
r.Reset (tree);
r.Filter = PathFilterGroup.CreateFromStrings(new string[]{p});
r.Recursive = true;
r.Next ();
} else {
r = tw;
}
do {
// There can be more than one entry if reverting a whole directory
string rpath = repository.FromGitPath (r.PathString);
DirCacheEntry e = new DirCacheEntry (r.PathString);
e.SetObjectId (r.GetObjectId (0));
e.FileMode = r.GetFileMode (0);
if (!Directory.Exists (Path.GetDirectoryName (rpath)))
Directory.CreateDirectory (rpath);
DirCacheCheckout.CheckoutEntry (repository, rpath, e);
builder.Add (e);
changedFiles.Add (rpath);
} while (r.Next ());
}
monitor.Step (1);
}
// Add entries we want to keep
int count = dc.GetEntryCount ();
for (int n=0; n<count; n++) {
DirCacheEntry e = dc.GetEntry (n);
string path = e.PathString;
if (!entriesToRemove.Contains (path) && !foldersToRemove.Any (f => IsSubpath (f,path)))
builder.Add (e);
}
builder.Commit ();
}
catch {
dc.Unlock ();
throw;
}
monitor.EndTask ();
monitor.BeginTask (null, files.Length);
foreach (FilePath p in changedFiles) {
FileService.NotifyFileChanged (p);
monitor.Step (1);
}
foreach (FilePath p in removedFiles) {
FileService.NotifyFileRemoved (p);
monitor.Step (1);
}
monitor.EndTask ();
}
}
public void Merge (string branch, bool saveLocalChanges, IProgressMonitor monitor)
{
IEnumerable<DiffEntry> statusList = null;
Stash stash = null;
StashCollection stashes = GetStashes (RootRepository);
monitor.BeginTask (null, 4);
try {
// Get a list of files that are different in the target branch
statusList = GitUtil.GetChangedFiles (RootRepository, branch);
monitor.Step (1);
if (saveLocalChanges) {
monitor.BeginTask (GettextCatalog.GetString ("Merging"), 3);
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName ("_tmp_"));
monitor.Step (1);
}
// Apply changes
ObjectId branchId = RootRepository.Resolve (branch);
NGit.Api.Git git = new NGit.Api.Git (RootRepository);
MergeCommandResult mergeResult = git.Merge ().SetStrategy (MergeStrategy.RESOLVE).Include (branchId).Call ();
if (mergeResult.GetMergeStatus () == MergeStatus.CONFLICTING || mergeResult.GetMergeStatus () == MergeStatus.FAILED) {
var conflicts = mergeResult.GetConflicts ();
bool commit = true;
if (conflicts != null) {
foreach (string conflictFile in conflicts.Keys) {
ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
GitUtil.HardReset (RootRepository, GetHeadCommit (RootRepository));
commit = false;
break;
} else if (res == ConflictResult.Skip) {
Revert (RootRepository.FromGitPath (conflictFile), false, monitor);
break;
}
}
}
if (commit)
git.Commit ().Call ();
}
} finally {
if (saveLocalChanges)
monitor.Step (1);
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
monitor.EndTask ();
}
}
monitor.Step (1);
// Notify changes
if (statusList != null)
NotifyFileChanges (monitor, statusList);
monitor.EndTask ();
}
public void Rebase (string upstreamRef, bool saveLocalChanges, IProgressMonitor monitor)
{
StashCollection stashes = GitUtil.GetStashes (RootRepository);
Stash stash = null;
try
{
if (saveLocalChanges) {
monitor.BeginTask (GettextCatalog.GetString ("Rebasing"), 3);
monitor.Log.WriteLine (GettextCatalog.GetString ("Saving local changes"));
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName ("_tmp_"));
monitor.Step (1);
}
NGit.Api.Git git = new NGit.Api.Git (RootRepository);
RebaseCommand rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.BEGIN);
rebase.SetUpstream (upstreamRef);
var gmonitor = new GitMonitor (monitor);
rebase.SetProgressMonitor (gmonitor);
bool aborted = false;
try {
var result = rebase.Call ();
while (!aborted && result.GetStatus () == RebaseResult.Status.STOPPED) {
rebase = git.Rebase ();
rebase.SetProgressMonitor (gmonitor);
rebase.SetOperation (RebaseCommand.Operation.CONTINUE);
bool commitChanges = true;
var conflicts = GitUtil.GetConflictedFiles (RootRepository);
foreach (string conflictFile in conflicts) {
ConflictResult res = ResolveConflict (RootRepository.FromGitPath (conflictFile));
if (res == ConflictResult.Abort) {
aborted = true;
commitChanges = false;
rebase.SetOperation (RebaseCommand.Operation.ABORT);
break;
} else if (res == ConflictResult.Skip) {
rebase.SetOperation (RebaseCommand.Operation.SKIP);
commitChanges = false;
break;
}
}
if (commitChanges) {
NGit.Api.AddCommand cmd = git.Add ();
foreach (string conflictFile in conflicts)
cmd.AddFilepattern (conflictFile);
cmd.Call ();
}
result = rebase.Call ();
}
} catch {
if (!aborted) {
rebase = git.Rebase ();
rebase.SetOperation (RebaseCommand.Operation.ABORT);
rebase.SetProgressMonitor (gmonitor);
rebase.Call ();
}
throw;
} finally {
gmonitor.Dispose ();
}
} finally {
if (saveLocalChanges)
monitor.Step (1);
// Restore local changes
if (stash != null) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Restoring local changes"));
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
monitor.EndTask ();
}
}
}
public override void Update (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
{
IEnumerable<DiffEntry> statusList = null;
monitor.BeginTask (GettextCatalog.GetString ("Updating"), 5);
// Fetch remote commits
string remote = GetCurrentRemote ();
if (remote == null)
throw new InvalidOperationException ("No remotes defined");
monitor.Log.WriteLine (GettextCatalog.GetString ("Fetching from '{0}'", remote));
RemoteConfig remoteConfig = new RemoteConfig (RootRepository.GetConfig (), remote);
Transport tn = Transport.Open (RootRepository, remoteConfig);
using (var gm = new GitMonitor (monitor))
tn.Fetch (gm, null);
monitor.Step (1);
string upstreamRef = GitUtil.GetUpstreamSource (RootRepository, GetCurrentBranch ());
if (upstreamRef == null)
upstreamRef = GetCurrentRemote () + "/" + GetCurrentBranch ();
if (GitService.UseRebaseOptionWhenPulling)
Rebase (upstreamRef, GitService.StashUnstashWhenUpdating, monitor);
else
Merge (upstreamRef, GitService.StashUnstashWhenUpdating, monitor);
monitor.Step (1);
// Notify changes
if (statusList != null)
NotifyFileChanges (monitor, statusList);
monitor.EndTask ();
}
public override void MoveDirectory (FilePath localSrcPath, FilePath localDestPath, bool force, IProgressMonitor monitor)
{
VersionInfo[] versionedFiles = GetDirectoryVersionInfo (localSrcPath, false, true);
base.MoveDirectory (localSrcPath, localDestPath, force, monitor);
monitor.BeginTask ("Moving files", versionedFiles.Length);
foreach (VersionInfo vif in versionedFiles) {
if (vif.IsDirectory)
continue;
FilePath newDestPath = vif.LocalPath.ToRelative (localSrcPath).ToAbsolute (localDestPath);
Add (newDestPath, false, monitor);
monitor.Step (1);
}
monitor.EndTask ();
}
public IEnumerable <SearchResult> FindAll(Scope scope, IProgressMonitor monitor, string pattern, string replacePattern, FilterOptions filter)
{
if (filter.RegexSearch)
{
RegexOptions regexOptions = RegexOptions.Compiled;
if (!filter.CaseSensitive)
{
regexOptions |= RegexOptions.IgnoreCase;
}
regex = new Regex(pattern, regexOptions);
}
IsRunning = true;
FoundMatchesCount = SearchedFilesCount = 0;
monitor.BeginTask(scope.GetDescription(filter, pattern, replacePattern), 50);
try {
int totalWork = scope.GetTotalWork(filter);
int step = Math.Max(1, totalWork / 50);
var contents = new List <Tuple <FileProvider, string, List <SearchResult> > >();
foreach (var provider in scope.GetFiles(monitor, filter))
{
try {
contents.Add(Tuple.Create(provider, provider.ReadString(), new List <SearchResult> ()));
} catch (FileNotFoundException) {
MessageService.ShowError(string.Format(GettextCatalog.GetString("File {0} not found.")), provider.FileName);
}
}
var results = new List <SearchResult>();
Parallel.ForEach(contents, content => {
if (monitor.IsCancelRequested)
{
return;
}
try {
Interlocked.Increment(ref searchedFilesCount);
content.Item3.AddRange(FindAll(monitor, content.Item1, content.Item2, pattern, replacePattern, filter));
lock (results) {
results.AddRange(content.Item3);
}
FoundMatchesCount += content.Item3.Count;
if (searchedFilesCount % step == 0)
{
monitor.Step(1);
}
} catch (Exception e) {
LoggingService.LogError("Exception during search.", e);
}
});
if (replacePattern != null)
{
foreach (var content in contents)
{
if (content.Item3.Count == 0)
{
continue;
}
try {
content.Item1.BeginReplace(content.Item2);
Replace(content.Item1, content.Item3, replacePattern);
content.Item1.EndReplace();
} catch (Exception e) {
LoggingService.LogError("Exception during replace.", e);
}
}
}
return(results);
} finally {
monitor.EndTask();
IsRunning = false;
}
}
//FIXME: Check whether autogen.sh is required or not
protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
Project project = entry as Project;
if (project == null)
{
return(base.Build(monitor, entry, configuration));
}
MakefileData data = project.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.BuildTargetName))
{
return(base.Build(monitor, entry, configuration));
}
//FIXME: Gen autofoo ? autoreconf?
string output = String.Empty;
int exitCode = 0;
monitor.BeginTask(GettextCatalog.GetString("Building {0}", project.Name), 1);
try
{
string baseDir = project.BaseDirectory;
string args = string.Format("-j {0} {1}", data.ParallelProcesses, data.BuildTargetName);
StringWriter swOutput = new StringWriter();
LogTextWriter chainedOutput = new LogTextWriter();
chainedOutput.ChainWriter(monitor.Log);
chainedOutput.ChainWriter(swOutput);
ProcessWrapper process = Runtime.ProcessService.StartProcess("make",
args,
baseDir,
chainedOutput,
chainedOutput,
null);
process.WaitForOutput();
exitCode = process.ExitCode;
output = swOutput.ToString();
chainedOutput.Close();
swOutput.Close();
monitor.Step(1);
}
catch (Exception e)
{
monitor.ReportError(GettextCatalog.GetString("Project could not be built: "), e);
return(null);
}
finally
{
monitor.EndTask();
}
TempFileCollection tf = new TempFileCollection();
Regex regexError = data.GetErrorRegex(false);
Regex regexWarning = data.GetWarningRegex(false);
BuildResult cr = ParseOutput(tf, output, project.BaseDirectory, regexError, regexWarning);
if (exitCode != 0 && cr.FailedBuildCount == 0)
{
cr.AddError(GettextCatalog.GetString("Build failed. See Build Output panel."));
}
return(cr);
}
/// <summary>
/// Sign the native libraries inside the bundle.
/// </summary>
/// <param name = 'monitor'>The progress monitor.</param>
/// <param name = 'project'>The project.</param>
/// <param name = 'maker'>The bundle maker.</param>
public static void SignNativeBinaries(IProgressMonitor monitor, MonobjcProject project, BundleMaker maker)
{
if (project.Signing && !String.IsNullOrEmpty(project.SigningIdentity)) {
String[] files = Directory.GetFiles (maker.MacOSDirectory, "*.dylib");
if (files == null || files.Count() == 0) {
return;
}
monitor.BeginTask (GettextCatalog.GetString ("Signing native libraries..."), files.Length);
foreach (String file in files) {
using (StringWriter outputWriter = new StringWriter()) {
using (StringWriter errorWriter = new StringWriter()) {
CodeSign.PerformSigning (file, project.SigningIdentity, outputWriter, errorWriter);
LoggingService.LogInfo ("CodeSign returns: " + outputWriter.ToString ());
}
}
monitor.Step (1);
}
monitor.EndTask ();
}
}
/// <summary>
/// Embeds the XIB files.
/// </summary>
/// <param name = 'monitor'>The progress monitor.</param>
/// <param name = 'project'>The project.</param>
/// <param name = 'maker'>The bundle maker.</param>
/// <param name = 'result'>The build result.</param>
public static void EmbedXIBFiles(IProgressMonitor monitor, MonobjcProject project, BuildResult result)
{
XibCompiler xibCompiler = new XibCompiler ();
IEnumerable<FilePair> files = project.GetIBFiles (Constants.EmbeddedInterfaceDefinition, null);
if (files == null || files.Count() == 0) {
return;
}
monitor.BeginTask (GettextCatalog.GetString ("Embed XIB files..."), files.Count ());
foreach (FilePair pair in files) {
// If the destination file is a place-holder, change its dates
FileInfo sourceInfo = new FileInfo (pair.Source);
FileInfo destInfo = new FileInfo (pair.Destination);
if (destInfo.Length == 0) {
DateTime dateTime = sourceInfo.CreationTime.Subtract (new TimeSpan (0, 0, 1));
File.SetCreationTime (pair.Destination, dateTime);
File.SetLastAccessTime (pair.Destination, dateTime);
File.SetLastWriteTime (pair.Destination, dateTime);
}
FilePath relativeFile = pair.Source.ToRelative (project.BaseDirectory);
monitor.Log.WriteLine (GettextCatalog.GetString ("Compiling {0}", relativeFile));
xibCompiler.Logger = new BuildLogger (pair.Source, monitor, result);
xibCompiler.Compile (pair.Source, pair.DestinationDir);
monitor.Step (1);
}
monitor.EndTask ();
}
/// <summary>
/// Copies the Monobjc assemblies.
/// </summary>
/// <param name="monitor">The monitor.</param>
/// <param name="project">The project.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="maker">The maker.</param>
public static void CopyMonobjcAssemblies(IProgressMonitor monitor, MonobjcProject project, ConfigurationSelector configuration, BundleMaker maker)
{
IEnumerable<String> assemblies = project.ProjectMonobjcAssemblies.Select (a => a.GetReferencedFileNames (configuration) [0]);
monitor.BeginTask (GettextCatalog.GetString ("Copying Monobjc assemblies..."), assemblies.Count ());
foreach (String assembly in assemblies) {
String filename = Path.GetFileName (assembly);
monitor.Log.WriteLine (GettextCatalog.GetString ("Copying {0}", filename));
File.Copy (assembly, Path.Combine (maker.ResourcesFolder, filename), true);
monitor.Step (1);
}
monitor.EndTask ();
}
//FIXME: Check whether autogen.sh is required or not
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
Project project = entry as Project;
if (project == null)
return base.Build (monitor, entry, configuration);
MakefileData data = project.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty (data.BuildTargetName))
return base.Build (monitor, entry, configuration);
//FIXME: Gen autofoo ? autoreconf?
string output = String.Empty;
int exitCode = 0;
monitor.BeginTask (GettextCatalog.GetString ("Building {0}", project.Name), 1);
try {
string baseDir = project.BaseDirectory;
StringBuilder args = new StringBuilder ();
if (data.RelativeMakeCommand.EndsWith ("make", StringComparison.OrdinalIgnoreCase))
args.AppendFormat (" -j {0}", data.ParallelProcesses, data.BuildTargetName);
args.AppendFormat (" {0}", data.BuildTargetName);
StringWriter swOutput = new StringWriter ();
LogTextWriter chainedOutput = new LogTextWriter ();
chainedOutput.ChainWriter (monitor.Log);
chainedOutput.ChainWriter (swOutput);
ProcessWrapper process = Runtime.ProcessService.StartProcess (data.AbsoluteMakeCommand,
args.ToString (),
baseDir,
chainedOutput,
chainedOutput,
null);
process.WaitForOutput ();
exitCode = process.ExitCode;
output = swOutput.ToString ();
chainedOutput.Close ();
swOutput.Close ();
monitor.Step (1);
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Project could not be built: "), e);
return null;
} finally {
monitor.EndTask ();
}
TempFileCollection tf = new TempFileCollection ();
Regex regexError = data.GetErrorRegex (false);
Regex regexWarning = data.GetWarningRegex (false);
BuildResult cr = ParseOutput (tf, output, project.BaseDirectory, regexError, regexWarning);
if (exitCode != 0 && cr.FailedBuildCount == 0)
cr.AddError (GettextCatalog.GetString ("Build failed. See Build Output panel."));
else
entry.SetNeedsBuilding (false, configuration);
return cr;
}
protected override void Execute (IProgressMonitor monitor, SolutionEntityItem entry, ExecutionContext context, ConfigurationSelector configuration)
{
Project project = entry as Project;
if (project == null) {
base.Execute (monitor, entry, context, configuration);
return;
}
MakefileData data = project.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty (data.ExecuteTargetName)) {
base.Execute (monitor, entry, context, configuration);
return;
}
IConsole console = context.ConsoleFactory.CreateConsole (true);
monitor.BeginTask (GettextCatalog.GetString ("Executing {0}", project.Name), 1);
try
{
ProcessWrapper process = Runtime.ProcessService.StartProcess (data.AbsoluteMakeCommand,
data.ExecuteTargetName,
project.BaseDirectory,
console.Out,
console.Error,
null);
process.WaitForOutput ();
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 ();
}
}
/// <summary>
/// Copies the content files.
/// </summary>
/// <param name = 'monitor'>The progress monitor.</param>
/// <param name = 'project'>The project.</param>
/// <param name = 'configuration'>The configuration.</param>
/// <param name = 'maker'>The bundle maker.</param>
public static void CopyOutputFiles(IProgressMonitor monitor, MonobjcProject project, ConfigurationSelector configuration, BundleMaker maker)
{
IEnumerable<FilePair> files = project.GetOutputFiles (configuration, maker.ResourcesFolder);
if (files == null || files.Count() == 0) {
return;
}
monitor.BeginTask (GettextCatalog.GetString ("Copying output files..."), files.Count ());
foreach (FilePair pair in files) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Copying {0}", pair.Source.ToRelative (project.BaseDirectory)));
pair.Copy (false);
monitor.Step (1);
}
monitor.EndTask ();
}
public Translation AddNewTranslation (string isoCode, IProgressMonitor 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);
this.Save (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 ();
}
}
/// <summary>
/// Combines the artwork.
/// </summary>
public static void EncryptContentFiles(IProgressMonitor monitor, MonobjcProject project, ConfigurationSelector configuration, BundleMaker maker)
{
IEnumerable<FilePair> files = project.GetEncryptedContentFiles (configuration, maker.ResourcesFolder);
if (files == null || files.Count() == 0) {
return;
}
Aes provider = FileEncrypter.GetProvider (project.EncryptionSeed);
monitor.BeginTask (GettextCatalog.GetString ("Encrypting content files..."), files.Count ());
foreach (FilePair pair in files) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Encrypting {0}", pair.Source.ToRelative (project.BaseDirectory)));
pair.Encrypt(provider);
monitor.Step (1);
}
monitor.EndTask ();
}
void CreateDefaultCatalog (IProgressMonitor 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.IsCancelRequested)
return;
monitor.Step (1);
}
catalog.Save (Path.Combine (this.BaseDirectory, "messages.po"));
}
/// <summary>
/// Compiles the XIB files.
/// </summary>
/// <param name = 'monitor'>The progress monitor.</param>
/// <param name = 'project'>The project.</param>
/// <param name = 'maker'>The bundle maker.</param>
/// <param name = 'result'>The build result.</param>
public static void CompileXIBFiles(IProgressMonitor monitor, MonobjcProject project, BundleMaker maker, BuildResult result)
{
XibCompiler xibCompiler = new XibCompiler ();
IEnumerable<FilePair> files = project.GetIBFiles (Constants.InterfaceDefinition, maker.ResourcesFolder);
if (files == null || files.Count() == 0) {
return;
}
List<FilePair> pairs = new List<FilePair> (files);
monitor.BeginTask (GettextCatalog.GetString ("Compiling XIB files..."), files.Count ());
foreach (FilePair pair in pairs) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Compiling {0}", pair.Source.ToRelative (project.BaseDirectory)));
xibCompiler.Logger = new BuildLogger (pair.Source, monitor, result);
xibCompiler.Compile (pair.Source, pair.DestinationDir);
monitor.Step (1);
}
monitor.EndTask ();
}
public void UpdateTranslations (IProgressMonitor 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.IsCancelRequested) {
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.IsCancelRequested) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Operation cancelled."));
return;
}
}
}
public IEnumerable <SearchResult> FindAll(Scope scope, IProgressMonitor monitor, string pattern, string replacePattern, FilterOptions filter)
{
if (filter.RegexSearch)
{
RegexOptions regexOptions = RegexOptions.Compiled;
if (!filter.CaseSensitive)
{
regexOptions |= RegexOptions.IgnoreCase;
}
regex = new Regex(pattern, regexOptions);
}
IsRunning = true;
FoundMatchesCount = SearchedFilesCount = 0;
monitor.BeginTask(scope.GetDescription(filter, pattern, replacePattern), 50);
try {
int totalWork = scope.GetTotalWork(filter);
int step = Math.Max(1, totalWork / 50);
string content;
var results = new System.Collections.Concurrent.ConcurrentBag <SearchResult>();
Parallel.ForEach(scope.GetFiles(monitor, filter), provider => {
if (monitor.IsCancelRequested)
{
return;
}
Interlocked.Increment(ref searchedFilesCount);
try {
content = provider.ReadString();
if (replacePattern != null)
{
provider.BeginReplace(content);
}
} catch (System.IO.FileNotFoundException) {
Application.Invoke(delegate {
MessageService.ShowError(string.Format(GettextCatalog.GetString("File {0} not found.")), provider.FileName);
});
return;
}
foreach (SearchResult result in FindAll(monitor, provider, content, pattern, replacePattern, filter))
{
if (monitor.IsCancelRequested)
{
return;
}
FoundMatchesCount++;
results.Add(result);
}
if (replacePattern != null)
{
provider.EndReplace();
}
if (searchedFilesCount % step == 0)
{
monitor.Step(1);
}
});
return(results);
} finally {
monitor.EndTask();
IsRunning = false;
}
}
public void SwitchToBranch (IProgressMonitor monitor, string branch)
{
monitor.BeginTask (GettextCatalog.GetString ("Switching to branch {0}", branch), GitService.StashUnstashWhenSwitchingBranches ? 4 : 2);
// Get a list of files that are different in the target branch
IEnumerable<DiffEntry> statusList = GitUtil.GetChangedFiles (RootRepository, branch);
StashCollection stashes = null;
Stash stash = null;
if (GitService.StashUnstashWhenSwitchingBranches) {
stashes = GitUtil.GetStashes (RootRepository);
// Remove the stash for this branch, if exists
string currentBranch = GetCurrentBranch ();
stash = GetStashForBranch (stashes, currentBranch);
if (stash != null)
stashes.Remove (stash);
// Create a new stash for the branch. This allows switching branches
// without losing local changes
using (var gm = new GitMonitor (monitor))
stash = stashes.Create (gm, GetStashName (currentBranch));
monitor.Step (1);
}
// Switch to the target branch
DirCache dc = RootRepository.LockDirCache ();
try {
RevWalk rw = new RevWalk (RootRepository);
ObjectId branchHeadId = RootRepository.Resolve (branch);
if (branchHeadId == null)
throw new InvalidOperationException ("Branch head commit not found");
RevCommit branchCommit = rw.ParseCommit (branchHeadId);
DirCacheCheckout checkout = new DirCacheCheckout (RootRepository, null, dc, branchCommit.Tree);
checkout.Checkout ();
RefUpdate u = RootRepository.UpdateRef(Constants.HEAD);
u.Link ("refs/heads/" + branch);
monitor.Step (1);
} catch {
dc.Unlock ();
if (GitService.StashUnstashWhenSwitchingBranches) {
// If something goes wrong, restore the work tree status
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
}
throw;
}
// Restore the branch stash
if (GitService.StashUnstashWhenSwitchingBranches) {
stash = GetStashForBranch (stashes, branch);
if (stash != null) {
using (var gm = new GitMonitor (monitor))
stash.Apply (gm);
stashes.Remove (stash);
}
monitor.Step (1);
}
// Notify file changes
NotifyFileChanges (monitor, statusList);
if (BranchSelectionChanged != null)
BranchSelectionChanged (this, EventArgs.Empty);
monitor.EndTask ();
}
public override void Step(int work)
{
base.Step(work);
statusMonitor.Step(work);
}
void NotifyFileChanges (IProgressMonitor monitor, IEnumerable<DiffEntry> statusList)
{
List<DiffEntry> changes = new List<DiffEntry> (statusList);
// Files added to source branch not present to target branch.
var removed = changes.Where (c => c.GetChangeType () == DiffEntry.ChangeType.ADD).Select (c => GetRepository (c.GetNewPath ()).FromGitPath (c.GetNewPath ())).ToList ();
var modified = changes.Where (c => c.GetChangeType () != DiffEntry.ChangeType.ADD).Select (c => GetRepository (c.GetNewPath ()).FromGitPath (c.GetNewPath ())).ToList ();
monitor.BeginTask (GettextCatalog.GetString ("Updating solution"), removed.Count + modified.Count);
FileService.NotifyFilesChanged (modified);
monitor.Step (modified.Count);
FileService.NotifyFilesRemoved (removed);
monitor.Step (removed.Count);
monitor.EndTask ();
}
protected override void Clean (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
Project proj = entry as Project;
if (proj == null) {
base.Clean (monitor, entry, configuration);
return;
}
MakefileData data = proj.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty (data.CleanTargetName)) {
base.Clean (monitor, entry, configuration);
return;
}
monitor.BeginTask (GettextCatalog.GetString ("Cleaning project"), 1);
try {
string baseDir = proj.BaseDirectory;
ProcessWrapper process = Runtime.ProcessService.StartProcess (data.AbsoluteMakeCommand,
data.CleanTargetName,
baseDir,
monitor.Log,
monitor.Log,
null);
process.WaitForOutput ();
if (process.ExitCode > 0)
throw new Exception ( GettextCatalog.GetString ("An unspecified error occurred while running '{0} {1}'", data.AbsoluteMakeCommand, data.CleanTargetName) );
monitor.Step (1);
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Project could not be cleaned: "), e);
return;
} finally {
monitor.EndTask ();
}
monitor.ReportSuccess (GettextCatalog.GetString ("Project successfully cleaned"));
}
public Makefile Deploy(AutotoolsContext ctx, SolutionItem entry, IProgressMonitor monitor)
{
generateAutotools = ctx.MakefileType == MakefileType.AutotoolsMakefile;
monitor.BeginTask(GettextCatalog.GetString(
"Creating {0} for Solution {1}",
generateAutotools ? "Makefile.am" : "Makefile", entry.Name), 1);
Makefile solutionMakefile = new Makefile();
StringBuilder solutionTop = new StringBuilder();
try
{
SolutionFolder solutionFolder = (SolutionFolder)entry;
string targetDirectory = solutionFolder.BaseDirectory;
StringBuilder subdirs = new StringBuilder();
subdirs.Append("#Warning: This is an automatically generated file, do not edit!\n");
if (!generateAutotools)
{
solutionTop.AppendFormat("top_srcdir={0}\n", FileService.AbsoluteToRelativePath(
entry.BaseDirectory, ctx.TargetSolution.BaseDirectory));
solutionTop.Append("include $(top_srcdir)/config.make\n");
solutionTop.Append("include $(top_srcdir)/Makefile.include\n");
solutionTop.Append("include $(top_srcdir)/rules.make\n\n");
solutionTop.Append("#include $(top_srcdir)/custom-hooks.make\n\n");
}
ArrayList children = new ArrayList();
foreach (SolutionConfiguration config in solutionFolder.ParentSolution.Configurations)
{
if (!ctx.IsSupportedConfiguration(config.Id))
{
continue;
}
if (generateAutotools)
{
subdirs.AppendFormat("if {0}\n", "ENABLE_" + ctx.EscapeAndUpperConfigName(config.Id));
}
else
{
subdirs.AppendFormat("ifeq ($(CONFIG),{0})\n", ctx.EscapeAndUpperConfigName(config.Id));
}
subdirs.Append(" SUBDIRS = ");
foreach (SolutionItem ce in CalculateSubDirOrder(ctx, solutionFolder, config))
{
string baseDirectory;
if (!(ce is SolutionEntityItem) && !(ce is SolutionFolder))
{
continue;
}
// Ignore projects which can't be deployed
IMakefileHandler handler = AutotoolsContext.GetMakefileHandler(ce, ctx.MakefileType);
if (handler == null)
{
continue;
}
baseDirectory = ce.BaseDirectory;
if (solutionFolder.BaseDirectory == baseDirectory)
{
subdirs.Append(" . ");
}
else
{
if (!baseDirectory.StartsWith(solutionFolder.BaseDirectory))
{
throw new Exception(GettextCatalog.GetString(
"Child projects must be in sub-directories of their parent"));
}
// add the subdirectory to the list
string path = FileService.AbsoluteToRelativePath(targetDirectory, baseDirectory);
if (path.StartsWith("." + Path.DirectorySeparatorChar))
{
path = path.Substring(2);
}
AutotoolsContext.CheckSpaces(path);
subdirs.Append(" ");
subdirs.Append(AutotoolsContext.EscapeStringForAutomake(path));
}
if (!children.Contains(ce))
{
children.Add(ce);
}
}
subdirs.Append("\nendif\n");
}
solutionTop.Append(subdirs.ToString());
string includedProject = null;
// deploy recursively
foreach (SolutionItem ce in children)
{
IMakefileHandler handler = AutotoolsContext.GetMakefileHandler(ce, ctx.MakefileType);
Makefile makefile;
string outpath;
if (handler != null && handler.CanDeploy(ce, ctx.MakefileType))
{
ctx.RegisterBuiltProject(ce);
makefile = handler.Deploy(ctx, ce, monitor);
if (targetDirectory == ce.BaseDirectory)
{
if (includedProject != null)
{
throw new Exception(GettextCatalog.GetString(
"More than 1 project in the same directory as the top-level solution is not supported."));
}
// project is in the solution directory
string projectMakefileName = ce.Name + ".make";
includedProject = String.Format("include {0}", projectMakefileName);
outpath = Path.Combine(targetDirectory, projectMakefileName);
ctx.AddGeneratedFile(outpath);
if (!generateAutotools)
{
solutionMakefile.SetVariable("EXTRA_DIST", projectMakefileName);
}
}
else
{
makefile.AppendToVariable("EXTRA_DIST", generateAutotools ? String.Empty : "Makefile");
outpath = Path.Combine(ce.BaseDirectory, "Makefile");
if (generateAutotools)
{
ctx.AddAutoconfFile(outpath);
outpath = outpath + ".am";
}
else
{
makefile.Append("install: install-local\nuninstall: uninstall-local\nclean: clean-local\n");
if (ce is SolutionFolder)
{
//non TargetCombine
makefile.Append("dist-local: dist-local-recursive\n");
}
else
{
makefile.Append("include $(top_srcdir)/rules.make\n");
}
}
ctx.AddGeneratedFile(outpath);
}
StreamWriter writer = new StreamWriter(outpath);
makefile.Write(writer);
writer.Close();
}
else
{
monitor.Log.WriteLine("Project '{0}' skipped.", ce.Name);
}
}
if (includedProject != null)
{
solutionTop.Append(GettextCatalog.GetString("\n# Include project specific makefile\n"));
solutionTop.Append(includedProject);
}
if (generateAutotools)
{
solutionMakefile.Append(solutionTop.ToString());
}
else
{
TemplateEngine templateEngine = new TemplateEngine();
templateEngine.Variables ["MAKEFILE_SOLUTION_TOP"] = solutionTop.ToString();
Stream stream = ctx.GetTemplateStream("Makefile.solution.template");
StreamReader reader = new StreamReader(stream);
StringWriter sw = new StringWriter();
templateEngine.Process(reader, sw);
reader.Close();
solutionMakefile.Append(sw.ToString());
if (solutionFolder.IsRoot)
{
// Emit dist and distcheck targets only for TargetCombine
reader = new StreamReader(Path.Combine(ctx.TemplateDir, "make-dist.targets"));
solutionMakefile.Append(reader.ReadToEnd());
reader.Close();
}
}
monitor.Step(1);
}
finally
{
monitor.EndTask();
}
return(solutionMakefile);
}
protected override SolutionEntityItem LoadSolutionItem (IProgressMonitor monitor, string fileName)
{
SolutionEntityItem entry = base.LoadSolutionItem (monitor, fileName);
if (entry == null)
return null;
Project project = entry as Project;
if (project == null)
return entry;
//Project
MakefileData data = entry.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null)
return entry;
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 (
"Error loading Makefile for project {0}", project.Name), e);
} finally {
monitor.EndTask ();
}
entry.SetNeedsBuilding (false);
return entry;
}
public void Save (IProgressMonitor monitor)
{
if (HasSlnData && !SavingSolution && Item.ParentSolution != null) {
// The project has data that has to be saved in the solution, but the solution is not being saved. Do it now.
monitor.BeginTask (null, 2);
SaveItem (monitor);
monitor.Step (1);
Solution sol = Item.ParentSolution;
SolutionFormat.SlnFileFormat.WriteFile (sol.FileName, sol, SolutionFormat, false, monitor);
sol.NeedsReload = false;
monitor.EndTask ();
} else
SaveItem (monitor);
}
public void TransferFiles (IProgressMonitor monitor, Project sourceProject, FilePath sourcePath, Project targetProject,
FilePath targetPath, bool removeFromSource, bool copyOnlyProjectFiles)
{
// 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
if (targetProject == null)
throw new ArgumentNullException ("targetProject");
if (!targetPath.IsChildPathOf (targetProject.BaseDirectory))
throw new ArgumentException ("Invalid project folder: " + targetPath);
if (sourceProject != null && !sourcePath.IsChildPathOf (sourceProject.BaseDirectory))
throw new ArgumentException ("Invalid project folder: " + sourcePath);
if (copyOnlyProjectFiles && sourceProject == null)
throw new ArgumentException ("A source project must be specified if copyOnlyProjectFiles is True");
bool sourceIsFolder = Directory.Exists (sourcePath);
bool movingFolder = (removeFromSource && sourceIsFolder && (
!copyOnlyProjectFiles ||
IsDirectoryHierarchyEmpty (sourcePath)));
// 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.
List<ProjectFile> filesToRemove = null;
List<ProjectFile> filesToMove = null;
try {
//get the real ProjectFiles
if (sourceProject != null) {
if (sourceIsFolder) {
var virtualPath = sourcePath.ToRelative (sourceProject.BaseDirectory);
// Grab all the child nodes of the folder we just dragged/dropped
filesToRemove = sourceProject.Files.GetFilesInVirtualPath (virtualPath).ToList ();
// Add the folder itself so we can remove it from the soruce project if its a Move operation
var folder = sourceProject.Files.Where (f => f.ProjectVirtualPath == virtualPath).FirstOrDefault ();
if (folder != null)
filesToRemove.Add (folder);
} else {
filesToRemove = new List<ProjectFile> ();
var pf = sourceProject.Files.GetFileWithVirtualPath (sourceProject.GetRelativeChildPath (sourcePath));
if (pf != null)
filesToRemove.Add (pf);
}
}
//get all the non-project files and create fake ProjectFiles
if (!copyOnlyProjectFiles || sourceProject == null) {
var col = new List<ProjectFile> ();
GetAllFilesRecursive (sourcePath, col);
if (sourceProject != null) {
var names = new HashSet<string> (filesToRemove.Select (f => sourceProject.BaseDirectory.Combine (f.ProjectVirtualPath).ToString ()));
foreach (var f in col)
if (names.Add (f.Name))
filesToRemove.Add (f);
} else {
filesToRemove = col;
}
}
} 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.
filesToMove = filesToRemove.Where (f => f.Subtype != Subtype.Directory).ToList ();
// If copying a single file, bring any grouped children along
ProjectFile sourceParent = null;
if (filesToMove.Count == 1 && sourceProject != null) {
var pf = filesToMove[0];
if (pf != null && pf.HasChildren)
foreach (ProjectFile child in pf.DependentChildren)
filesToMove.Add (child);
sourceParent = pf;
}
// 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;
}
}
monitor.BeginTask (GettextCatalog.GetString ("Copying files..."), filesToMove.Count);
ProjectFile targetParent = null;
foreach (ProjectFile file in filesToMove) {
bool fileIsLink = file.Project != null && file.IsLink;
var sourceFile = fileIsLink
? file.Project.BaseDirectory.Combine (file.ProjectVirtualPath)
: file.FilePath;
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 && !fileIsLink) {
try {
FilePath fileDir = newFile.ParentDirectory;
if (!Directory.Exists (fileDir) && !file.IsLink)
FileService.CreateDirectory (fileDir);
if (removeFromSource)
FileService.MoveFile (sourceFile, newFile);
else
FileService.CopyFile (sourceFile, newFile);
} catch (Exception ex) {
monitor.ReportError (GettextCatalog.GetString ("File '{0}' could not be created.", newFile), ex);
monitor.Step (1);
continue;
}
}
if (sourceProject != null) {
if (fileIsLink) {
var linkFile = (ProjectFile) file.Clone ();
if (movingFolder) {
var abs = linkFile.Link.ToAbsolute (sourceProject.BaseDirectory);
var relSrc = abs.ToRelative (sourcePath);
var absTarg = relSrc.ToAbsolute (targetPath);
linkFile.Link = absTarg.ToRelative (targetProject.BaseDirectory);
} else {
linkFile.Link = newFile.ToRelative (targetProject.BaseDirectory);
}
targetProject.Files.Add (linkFile);
} else if (targetProject.Files.GetFile (newFile) == null) {
ProjectFile projectFile = (ProjectFile) file.Clone ();
projectFile.Name = newFile;
if (targetParent == null) {
if (file == sourceParent)
targetParent = projectFile;
} else if (sourceParent != null) {
if (projectFile.DependsOn == sourceParent.Name)
projectFile.DependsOn = targetParent.Name;
}
targetProject.Files.Add (projectFile);
}
}
monitor.Step (1);
}
if (removeFromSource) {
// Remove all files and directories under 'sourcePath'
foreach (var v in filesToRemove)
sourceProject.Files.Remove (v);
}
var pfolder = sourcePath.ParentDirectory;
// If this was the last item in the folder, make sure we keep
// a reference to the folder, so it is not deleted from the tree.
if (removeFromSource && sourceProject != null && pfolder.CanonicalPath != sourceProject.BaseDirectory.CanonicalPath && pfolder.IsChildPathOf (sourceProject.BaseDirectory)) {
pfolder = pfolder.ToRelative (sourceProject.BaseDirectory);
if (!sourceProject.Files.GetFilesInVirtualPath (pfolder).Any ()) {
var folderFile = new ProjectFile (sourceProject.BaseDirectory.Combine (pfolder));
folderFile.Subtype = Subtype.Directory;
sourceProject.Files.Add (folderFile);
}
}
monitor.EndTask ();
}
public static void Initialize(IProgressMonitor monitor)
{
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();
AutoTestService.Start(commandService, Preferences.EnableAutomatedTesting);
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"), 5);
Counters.Initialization.Trace("Loading Commands");
commandService.LoadCommands("/MonoDevelop/Ide/Commands");
monitor.Step(1);
Counters.Initialization.Trace("Initializing Workbench");
workbench.Initialize(monitor);
monitor.Step(1);
InternalLog.EnableErrorNotification();
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;
commandService.EnableIdleUpdate = true;
// Perser service initialization
TypeSystemService.TrackFileChanges = true;
TypeSystemService.ParseProgressMonitorFactory = new ParseProgressMonitorFactory();
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.EnableInstrumentationChanged += delegate {
UpdateInstrumentationIcon();
};
AutoTestService.NotifyEvent("MonoDevelop.Ide.IdeStart");
}