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 SyncBack (XcodeSyncBackContext context)
{
var hFile = context.ProjectDir.Combine (Type.ObjCName + ".h");
var parsed = NSObjectInfoService.ParseHeader (hFile);
var objcType = context.ProjectInfo.GetType (Type.ObjCName);
if (objcType == null) {
context.ReportError ("Missing objc type {0}", Type.ObjCName);
return;
}
if (parsed.ObjCName != objcType.ObjCName) {
context.ReportError ("Parsed type name {0} does not match original {1}",
parsed.ObjCName, objcType.ObjCName);
return;
}
if (!objcType.IsUserType) {
context.ReportError ("Parsed type {0} is not a user type", objcType);
return;
}
//FIXME: detect unresolved types
parsed.MergeCliInfo (objcType);
context.ProjectInfo.ResolveTypes (parsed);
context.TypeSyncJobs.Add (new XcodeSyncObjcBackJob () {
HFile = hFile,
DesignerFile = objcType.GetDesignerFile (),
Type = parsed,
});
}
/// <summary>
/// Adds any newly created resource files to MonoDevelop's DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not new files were added to the project.
/// </returns>
bool AddFilesToMD(IProgressMonitor monitor, XcodeSyncBackContext context)
{
bool filesAdded = false;
if (context.FileSyncJobs.Count == 0)
{
return(false);
}
foreach (var file in context.FileSyncJobs)
{
if (!file.IsFreshlyAdded)
{
continue;
}
monitor.Log.WriteLine("Adding '{0}' to project '{1}'", file.SyncedRelative, dnp.Name);
FilePath path = new FilePath(file.Original);
string buildAction = HasInterfaceDefinitionExtension(path) ? BuildAction.InterfaceDefinition : BuildAction.BundleResource;
context.Project.AddFile(path, buildAction);
filesAdded = true;
}
return(filesAdded);
}
public override void SyncBack (XcodeSyncBackContext context)
{
context.FileSyncJobs.Add (new XcodeSyncFileBackJob () {
Original = source,
SyncedRelative = targetRelative
});
}
/// <summary>
/// Adds any newly created resource files to MonoDevelop's DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not new files were added to the project.
/// </returns>
bool AddFilesToMD(IProgressMonitor monitor, XcodeSyncBackContext context)
{
bool needsEndTask = false;
if (context.FileSyncJobs.Count == 0)
{
return(false);
}
foreach (var file in context.FileSyncJobs)
{
if (!file.IsFreshlyAdded)
{
continue;
}
monitor.Log.WriteLine("Adding new file to project: {0}", file.SyncedRelative);
FilePath path = new FilePath(file.Original);
string buildAction = HasInterfaceDefinitionExtension(path) ? BuildAction.InterfaceDefinition : BuildAction.Content;
context.Project.AddFile(path, buildAction);
needsEndTask = true;
}
if (needsEndTask)
{
monitor.EndTask();
return(true);
}
return(false);
}
/// <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();
}
public override void SyncBack(IProgressMonitor monitor, XcodeSyncBackContext context)
{
monitor.Log.WriteLine("Queueing sync-back of changes made to the {0} class from Xcode.", Type.CliName);
var objcType = context.ProjectInfo.GetType(Type.ObjCName);
var hFile = GetObjCHeaderPath(context);
if (objcType == null)
{
context.ReportError("Missing Objective-C type: {0}", Type.ObjCName);
return;
}
if (!objcType.IsUserType)
{
context.ReportError("Parsed Objective-C type '{0}' is not a user type", objcType);
return;
}
var parsed = NSObjectInfoService.ParseHeader(hFile);
if (parsed == null)
{
context.ReportError("Error parsing Objective-C type: {0}", Type.ObjCName);
return;
}
if (parsed.ObjCName != objcType.ObjCName)
{
context.ReportError("Parsed type name '{0}' does not match original: {1}",
parsed.ObjCName, objcType.ObjCName);
return;
}
parsed.MergeCliInfo(objcType);
context.TypeSyncJobs.Add(XcodeSyncObjcBackJob.UpdateType(parsed, objcType.GetDesignerFile()));
}
public override void SyncBack(XcodeSyncBackContext context)
{
var hFile = context.ProjectDir.Combine(Type.ObjCName + ".h");
var objcType = context.ProjectInfo.GetType(Type.ObjCName);
if (objcType == null)
{
context.ReportError("Missing objc type {0}", Type.ObjCName);
return;
}
if (!objcType.IsUserType)
{
context.ReportError("Parsed type {0} is not a user type", objcType);
return;
}
var parsed = NSObjectInfoService.ParseHeader(hFile);
if (parsed == null)
{
context.ReportError("Error parsing objc type {0}", Type.ObjCName);
return;
}
if (parsed.ObjCName != objcType.ObjCName)
{
context.ReportError("Parsed type name {0} does not match original {1}",
parsed.ObjCName, objcType.ObjCName);
return;
}
parsed.MergeCliInfo(objcType);
context.TypeSyncJobs.Add(XcodeSyncObjcBackJob.UpdateType(parsed, objcType.GetDesignerFile()));
}
/// <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;
}
foreach (var file in context.FileSyncJobs)
{
monitor.Log.WriteLine("Copying {0} file from Xcode: {1}", file.IsFreshlyAdded ? "added" : "changed", file.SyncedRelative);
if (!Directory.Exists(file.Original.ParentDirectory))
{
Directory.CreateDirectory(file.Original.ParentDirectory);
}
var tempFile = file.Original.ParentDirectory.Combine(".#" + file.Original.ParentDirectory.FileName);
File.Copy(context.ProjectDir.Combine(file.SyncedRelative), tempFile);
FileService.SystemRename(tempFile, file.Original);
context.SetSyncTimeToNow(file.SyncedRelative);
}
monitor.EndTask();
}
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);
}
void UpdateCliTypes (IProgressMonitor monitor, XcodeSyncBackContext context)
{
var provider = dnp.LanguageBinding.GetCodeDomProvider ();
var options = new System.CodeDom.Compiler.CodeGeneratorOptions ();
var writer = MonoDevelop.DesignerSupport.CodeBehindWriter.CreateForProject (
new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor (), dnp);
monitor.BeginTask (GettextCatalog.GetString ("Detecting changed types from Xcode"), 0);
Dictionary<string,ProjectFile> newFiles;
var updates = context.GetTypeUpdates (out newFiles);
if (updates == null || updates.Count == 0) {
monitor.Log.WriteLine ("No changed types found");
monitor.EndTask ();
return;
}
monitor.Log.WriteLine ("Found {0} changed types", updates.Count);
monitor.EndTask ();
monitor.BeginTask (GettextCatalog.GetString ("Updating types in MonoDevelop"), updates.Count);
foreach (var df in updates) {
monitor.Log.WriteLine ("Syncing {0} types from Xcode to file '{1}'", df.Value.Count, df.Key);
if (provider is Microsoft.CSharp.CSharpCodeProvider) {
var cs = new CSharpCodeCodebehind () {
Types = df.Value,
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
};
writer.WriteFile (df.Key, cs.TransformText ());
} else {
var ccu = GenerateCompileUnit (provider, options, df.Key, df.Value);
writer.WriteFile (df.Key, ccu);
}
monitor.Step (1);
}
writer.WriteOpenFiles ();
foreach (var df in updates) {
foreach (var type in df.Value) {
context.SetSyncTimeToNow (type.ObjCName + ".h");
context.SetSyncTimeToNow (type.ObjCName + ".m");
}
}
foreach (var job in context.TypeSyncJobs) {
context.ProjectInfo.InsertUpdatedType (job.Type);
}
if (newFiles != null) {
foreach (var f in newFiles) {
monitor.Log.WriteLine ("Added new designer file {0}", f.Key);
dnp.AddFile (f.Value);
}
monitor.Log.WriteLine ("Saving project '{0}'", dnp.Name);
Ide.IdeApp.ProjectOperations.Save (dnp);
}
monitor.EndTask ();
}
void CopyFilesToMD (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return;
foreach (var file in context.FileSyncJobs) {
monitor.Log.WriteLine ("Copying changed file from Xcode: {0}", file.SyncedRelative);
var tempFile = file.Original.ParentDirectory.Combine (".#" + file.Original.ParentDirectory.FileName);
File.Copy (context.ProjectDir.Combine (file.SyncedRelative), tempFile);
FileService.SystemRename (tempFile, file.Original);
context.SetSyncTimeToNow (file.SyncedRelative);
}
Gtk.Application.Invoke (delegate {
FileService.NotifyFilesChanged (context.FileSyncJobs.Select (f => f.Original));
});
monitor.EndTask ();
}
public XcodeSyncBackContext GetChanges (NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext (projectDir, syncTimeCache, infoService, project);
foreach (var item in items) {
if (item.NeedsSyncBack (ctx)) {
item.SyncBack (ctx);
}
}
return ctx;
}
/// <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;
foreach (var file in context.FileSyncJobs) {
monitor.Log.WriteLine ("Copying {0} file from Xcode: {1}", file.IsFreshlyAdded ? "added" : "changed", file.SyncedRelative);
if (!Directory.Exists (file.Original.ParentDirectory))
Directory.CreateDirectory (file.Original.ParentDirectory);
var tempFile = file.Original.ParentDirectory.Combine (".#" + file.Original.ParentDirectory.FileName);
File.Copy (context.ProjectDir.Combine (file.SyncedRelative), tempFile);
FileService.SystemRename (tempFile, file.Original);
context.SetSyncTimeToNow (file.SyncedRelative);
}
monitor.EndTask ();
}
/// <summary>
/// Updates the cli types.
/// </summary>
/// <returns>
/// Returns whether or not any files were added to the project.
/// </returns>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// A sync-back context.
/// </param>
/// <param name='typesAdded'>
/// An output variable specifying whether or not any types were added to the project.
/// </param>
bool UpdateCliTypes (IProgressMonitor monitor, XcodeSyncBackContext context, out bool typesAdded)
{
var provider = dnp.LanguageBinding.GetCodeDomProvider ();
var options = new System.CodeDom.Compiler.CodeGeneratorOptions ();
var writer = MonoDevelop.DesignerSupport.CodeBehindWriter.CreateForProject (
new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor (), dnp);
monitor.BeginTask (GettextCatalog.GetString ("Detecting changes made in Xcode to custom user types..."), 0);
Dictionary<string, NSObjectTypeInfo> newTypes;
Dictionary<string, ProjectFile> newFiles;
var updates = context.GetTypeUpdates (monitor, provider, out newTypes, out newFiles);
if ((updates == null || updates.Count == 0) && newTypes == null && newFiles == null) {
monitor.Log.WriteLine ("No changes found.");
monitor.EndTask ();
typesAdded = false;
return false;
}
monitor.EndTask ();
int count = updates.Count + (newTypes != null ? newTypes.Count : 0);
monitor.BeginTask (GettextCatalog.GetString ("Updating custom user types in MonoDevelop..."), count);
// First, add new types...
if (newTypes != null && newTypes.Count > 0) {
foreach (var nt in newTypes) {
monitor.Log.WriteLine ("Adding new type: {0}", nt.Value.CliName);
if (provider is Microsoft.CSharp.CSharpCodeProvider) {
var cs = new CSharpCodeTypeDefinition () {
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
Type = nt.Value,
};
string baseDir = Path.GetDirectoryName (nt.Key);
if (!Directory.Exists (baseDir))
Directory.CreateDirectory (baseDir);
writer.WriteFile (nt.Key, cs.TransformText ());
} else {
// FIXME: implement support for non-C# languages
}
monitor.Step (1);
}
typesAdded = true;
} else {
typesAdded = false;
}
// Next, generate the designer files for any added/changed types
foreach (var df in updates) {
monitor.Log.WriteLine ("Generating designer file: {0}", df.Key);
if (provider is Microsoft.CSharp.CSharpCodeProvider) {
var cs = new CSharpCodeCodebehind () {
Types = df.Value,
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
};
writer.WriteFile (df.Key, cs.TransformText ());
} else {
var ccu = GenerateCompileUnit (provider, options, df.Key, df.Value);
writer.WriteFile (df.Key, ccu);
}
monitor.Step (1);
}
writer.WriteOpenFiles ();
// Update sync timestamps
foreach (var df in updates) {
foreach (var type in df.Value)
context.SetSyncTime (type.ObjCName + ".h", DateTime.Now);
}
// Add new files to the DotNetProject
if (newFiles != null) {
foreach (var f in newFiles) {
monitor.Log.WriteLine ("Added new designer file: {0}", f.Key);
dnp.AddFile (f.Value);
}
}
monitor.EndTask ();
return newFiles != null && newFiles.Count > 0;
}
/// <summary>
/// Adds any newly created resource files to MonoDevelop's DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not new files were added to the project.
/// </returns>
bool AddFilesToMD (IProgressMonitor monitor, XcodeSyncBackContext context)
{
bool filesAdded = false;
if (context.FileSyncJobs.Count == 0)
return false;
foreach (var file in context.FileSyncJobs) {
if (!file.IsFreshlyAdded)
continue;
monitor.Log.WriteLine ("Adding '{0}' to project '{1}'", file.SyncedRelative, dnp.Name);
FilePath path = new FilePath (file.Original);
string buildAction = HasInterfaceDefinitionExtension (path) ? BuildAction.InterfaceDefinition : BuildAction.Content;
context.Project.AddFile (path, buildAction);
filesAdded = true;
}
return filesAdded;
}
public override void SyncBack(XcodeSyncBackContext context)
{
context.FileSyncJobs.Add(new XcodeSyncFileBackJob(source, targetRelative, false));
}
public override void SyncBack (IProgressMonitor monitor, XcodeSyncBackContext context)
{
monitor.Log.WriteLine ("Queueing sync-back of changes made to the {0} class from Xcode.", Type.CliName);
var objcType = context.ProjectInfo.GetType (Type.ObjCName);
var hFile = GetObjCHeaderPath (context);
if (objcType == null) {
context.ReportError ("Missing Objective-C type: {0}", Type.ObjCName);
return;
}
if (!objcType.IsUserType) {
context.ReportError ("Parsed Objective-C type '{0}' is not a user type", objcType);
return;
}
var parsed = NSObjectInfoService.ParseHeader (hFile);
if (parsed == null) {
context.ReportError ("Error parsing Objective-C type: {0}", Type.ObjCName);
return;
}
if (parsed.ObjCName != objcType.ObjCName) {
context.ReportError ("Parsed type name '{0}' does not match original: {1}",
parsed.ObjCName, objcType.ObjCName);
return;
}
parsed.MergeCliInfo (objcType);
context.TypeSyncJobs.Add (XcodeSyncObjcBackJob.UpdateType (parsed, objcType.GetDesignerFile ()));
}
static bool SyncFile (IProgressMonitor monitor, XcodeSyncBackContext context, XcodeSyncFileBackJob file)
{
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);
return true;
} else {
monitor.ReportWarning (string.Format ("'{0}' does not exist.", file.SyncedRelative));
return false;
}
}
public abstract void SyncBack(XcodeSyncBackContext context);
public override void SyncBack(IProgressMonitor monitor, XcodeSyncBackContext context)
{
monitor.Log.WriteLine("Queueing sync-back of changes made to '{0}' from Xcode.", targetRelative);
context.FileSyncJobs.Add(new XcodeSyncFileBackJob(source, targetRelative, false));
}
public override void SyncBack (XcodeSyncBackContext context)
{
context.FileSyncJobs.Add (new XcodeSyncFileBackJob (source, targetRelative, false));
}
/// <summary>
/// Adds any newly created resource files to MonoDevelop's DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not new files were added to the project.
/// </returns>
bool AddFilesToMD (IProgressMonitor monitor, XcodeSyncBackContext context)
{
bool needsEndTask = false;
if (context.FileSyncJobs.Count == 0)
return false;
foreach (var file in context.FileSyncJobs) {
if (!file.IsFreshlyAdded)
continue;
monitor.Log.WriteLine ("Adding new file to project: {0}", file.SyncedRelative);
FilePath path = new FilePath (file.Original);
string buildAction = HasInterfaceDefinitionExtension (path) ? BuildAction.InterfaceDefinition : BuildAction.Content;
context.Project.AddFile (path, buildAction);
needsEndTask = true;
}
if (needsEndTask) {
monitor.EndTask ();
return true;
}
return false;
}
public abstract void SyncBack (IProgressMonitor monitor, XcodeSyncBackContext context);
public override void SyncBack (IProgressMonitor monitor, XcodeSyncBackContext context)
{
monitor.Log.WriteLine ("Queueing sync-back of changes made to '{0}' from Xcode.", targetRelative);
context.FileSyncJobs.Add (new XcodeSyncFileBackJob (source, targetRelative, false));
}
/// <summary>
/// Updates the cli types.
/// </summary>
/// <returns>
/// Returns whether or not any files were added to the project.
/// </returns>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// A sync-back context.
/// </param>
/// <param name='typesAdded'>
/// An output variable specifying whether or not any types were added to the project.
/// </param>
bool UpdateCliTypes(IProgressMonitor monitor, XcodeSyncBackContext context, out bool typesAdded)
{
var provider = dnp.LanguageBinding.GetCodeDomProvider();
var options = new System.CodeDom.Compiler.CodeGeneratorOptions();
var writer = MonoDevelop.DesignerSupport.CodeBehindWriter.CreateForProject(
new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor(), dnp);
monitor.BeginTask(GettextCatalog.GetString("Detecting changes made in Xcode"), 0);
Dictionary <string, NSObjectTypeInfo> newTypes;
Dictionary <string, ProjectFile> newFiles;
var updates = context.GetTypeUpdates(monitor, provider, out newTypes, out newFiles);
if ((updates == null || updates.Count == 0) && newTypes == null && newFiles == null)
{
monitor.Log.WriteLine("No changes found");
monitor.EndTask();
typesAdded = false;
return(false);
}
monitor.Log.WriteLine("Found {0} changed types", updates.Count);
monitor.EndTask();
int count = updates.Count + (newTypes != null ? newTypes.Count : 0);
monitor.BeginTask(GettextCatalog.GetString("Updating types in MonoDevelop"), count);
// First, add new types...
if (newTypes != null && newTypes.Count > 0)
{
foreach (var nt in newTypes)
{
if (provider is Microsoft.CSharp.CSharpCodeProvider)
{
var cs = new CSharpCodeTypeDefinition()
{
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
Type = nt.Value,
};
string baseDir = Path.GetDirectoryName(nt.Key);
if (!Directory.Exists(baseDir))
{
Directory.CreateDirectory(baseDir);
}
writer.WriteFile(nt.Key, cs.TransformText());
}
else
{
// FIXME: implement support for non-C# languages
}
monitor.Step(1);
}
typesAdded = true;
}
else
{
typesAdded = false;
}
// Next, generate the designer files for any added/changed types
foreach (var df in updates)
{
monitor.Log.WriteLine("Syncing {0} types from Xcode to file '{1}'", df.Value.Count, df.Key);
if (provider is Microsoft.CSharp.CSharpCodeProvider)
{
var cs = new CSharpCodeCodebehind()
{
Types = df.Value,
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
};
writer.WriteFile(df.Key, cs.TransformText());
}
else
{
var ccu = GenerateCompileUnit(provider, options, df.Key, df.Value);
writer.WriteFile(df.Key, ccu);
}
monitor.Step(1);
}
writer.WriteOpenFiles();
// Update sync timestamps
foreach (var df in updates)
{
foreach (var type in df.Value)
{
context.SetSyncTimeToNow(type.ObjCName + ".h");
context.SetSyncTimeToNow(type.ObjCName + ".m");
}
}
// Add new files to the DotNetProject
if (newFiles != null)
{
foreach (var f in newFiles)
{
monitor.Log.WriteLine("Added new designer file {0}", f.Key);
dnp.AddFile(f.Value);
}
}
monitor.EndTask();
return(newFiles != null && newFiles.Count > 0);
}
/// <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 ();
}
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;
}
/// <summary>
/// Adds the custom classes from user interface definition files.
/// </summary>
/// <returns>
/// <c>true</c> if new types were added to the project, or <c>false</c> otherwise.
/// </returns>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// A sync-back context.
/// </param>
bool AddCustomClassesFromUIDefinitionFiles (IProgressMonitor monitor, XcodeSyncBackContext context)
{
var provider = dnp.LanguageBinding.GetCodeDomProvider ();
var options = new System.CodeDom.Compiler.CodeGeneratorOptions ();
var writer = MonoDevelop.DesignerSupport.CodeBehindWriter.CreateForProject (
new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor (), dnp);
bool addedTypes = false;
bool beganTask = false;
// Collect our list of custom classes from UI definition files
foreach (var job in context.FileSyncJobs) {
if (!HasInterfaceDefinitionExtension (job.Original))
continue;
if (!beganTask) {
monitor.BeginTask (GettextCatalog.GetString ("Generating custom classes defined in UI definition files..."), 0);
beganTask = true;
}
string relative = job.SyncedRelative.ParentDirectory;
string dir = dnp.BaseDirectory;
if (!string.IsNullOrEmpty (relative))
dir = Path.Combine (dir, relative);
foreach (var type in GetCustomTypesFromUIDefinition (job.Original)) {
if (context.ProjectInfo.ContainsType (type.ObjCName))
continue;
string designerPath = Path.Combine (dir, type.ObjCName + ".designer." + provider.FileExtension);
string path = Path.Combine (dir, type.ObjCName + "." + provider.FileExtension);
string ns = dnp.GetDefaultNamespace (path);
type.CliName = ns + "." + provider.CreateValidIdentifier (type.ObjCName);
if (provider is Microsoft.CSharp.CSharpCodeProvider) {
CodebehindTemplateBase cs = new CSharpCodeTypeDefinition () {
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
Type = type,
};
writer.WriteFile (path, cs.TransformText ());
List<NSObjectTypeInfo> types = new List<NSObjectTypeInfo> ();
types.Add (type);
cs = new CSharpCodeCodebehind () {
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
Types = types,
};
writer.WriteFile (designerPath, cs.TransformText ());
context.ProjectInfo.InsertUpdatedType (type);
} else {
// FIXME: implement support for non-C# languages
}
dnp.AddFile (new ProjectFile (path));
dnp.AddFile (new ProjectFile (designerPath) { DependsOn = path });
addedTypes = true;
}
}
writer.WriteOpenFiles ();
if (beganTask)
monitor.EndTask ();
return addedTypes;
}
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;
}
/// <summary>
/// Syncs modified 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 CopyNewAndModifiedFiles (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return;
var modified = new List<XcodeSyncFileBackJob> (context.FileSyncJobs.Where (job => job.IsNewOrModified));
if (modified.Count == 0)
return;
monitor.BeginStepTask (string.Format ("Copying new and modified files from Xcode back to {0}...", dnp.Name), modified.Count, 1);
foreach (var file in modified) {
if (file.Status == XcodeSyncFileStatus.Modified)
monitor.Log.WriteLine ("Copying modified file '{0}'", file.SyncedRelative);
else
monitor.Log.WriteLine ("Copying new file '{0}'", file.SyncedRelative);
SyncFile (monitor, context, file);
monitor.Step (1);
}
monitor.EndTask ();
}
void CopyFilesToMD (XcodeSyncBackContext context)
{
foreach (var file in context.FileSyncJobs) {
XC4Debug.Log ("Copying changed file from Xcode: {0}", file.SyncedRelative);
var tempFile = file.Original.ParentDirectory.Combine (".#" + file.Original.ParentDirectory.FileName);
File.Copy (context.ProjectDir.Combine (file.SyncedRelative), tempFile);
FileService.SystemRename (tempFile, file.Original);
context.SetSyncTimeToNow (file.SyncedRelative);
}
Gtk.Application.Invoke (delegate {
FileService.NotifyFilesChanged (context.FileSyncJobs.Select (f => f.Original));
});
}
/// <summary>
/// Adds the custom classes from user interface definition files.
/// </summary>
/// <returns>
/// <c>true</c> if new types were added to the project, or <c>false</c> otherwise.
/// </returns>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// A sync-back context.
/// </param>
bool AddCustomClassesFromUIDefinitionFiles(IProgressMonitor monitor, XcodeSyncBackContext context)
{
var provider = dnp.LanguageBinding.GetCodeDomProvider();
var options = new System.CodeDom.Compiler.CodeGeneratorOptions();
var writer = MonoDevelop.DesignerSupport.CodeBehindWriter.CreateForProject(
new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor(), dnp);
bool addedTypes = false;
monitor.BeginTask(GettextCatalog.GetString("Generating custom classes defined in UI definition files"), 0);
// Collect our list of custom classes from UI definition files
foreach (var job in context.FileSyncJobs)
{
if (!HasInterfaceDefinitionExtension(job.Original))
{
continue;
}
string relative = job.SyncedRelative.ParentDirectory;
string dir = dnp.BaseDirectory;
if (!string.IsNullOrEmpty(relative))
{
dir = Path.Combine(dir, relative);
}
foreach (var type in GetCustomTypesFromUIDefinition(job.Original))
{
if (context.ProjectInfo.ContainsType(type.ObjCName))
{
continue;
}
string designerPath = Path.Combine(dir, type.ObjCName + ".designer." + provider.FileExtension);
string path = Path.Combine(dir, type.ObjCName + "." + provider.FileExtension);
string ns = dnp.GetDefaultNamespace(path);
type.CliName = ns + "." + provider.CreateValidIdentifier(type.ObjCName);
if (provider is Microsoft.CSharp.CSharpCodeProvider)
{
CodebehindTemplateBase cs = new CSharpCodeTypeDefinition()
{
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
Type = type,
};
writer.WriteFile(path, cs.TransformText());
List <NSObjectTypeInfo> types = new List <NSObjectTypeInfo> ();
types.Add(type);
cs = new CSharpCodeCodebehind()
{
WrapperNamespace = infoService.WrapperRoot,
Provider = provider,
Types = types,
};
writer.WriteFile(designerPath, cs.TransformText());
context.ProjectInfo.InsertUpdatedType(type);
}
else
{
// FIXME: implement support for non-C# languages
}
dnp.AddFile(new ProjectFile(path));
dnp.AddFile(new ProjectFile(designerPath)
{
DependsOn = path
});
addedTypes = true;
}
}
writer.WriteOpenFiles();
monitor.EndTask();
return(addedTypes);
}
/// <summary>
/// Adds any newly created content files to MonoDevelop's DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not new files were added to the project.
/// </returns>
bool AddNewFilesToProject (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return false;
var added = new List<XcodeSyncFileBackJob> (context.FileSyncJobs.Where (job => job.Status == XcodeSyncFileStatus.Added));
if (added.Count == 0)
return false;
monitor.BeginStepTask (string.Format ("Adding new files to {0}...", dnp.Name), added.Count, 1);
foreach (var file in added) {
if (File.Exists (file.Original)) {
monitor.Log.WriteLine ("Adding '{0}'", file.SyncedRelative);
string buildAction = BuildAction.Content;
if (HasInterfaceDefinitionExtension (file.Original))
buildAction = BuildAction.InterfaceDefinition;
context.Project.AddFile (file.Original, buildAction);
}
monitor.Step (1);
}
monitor.EndTask ();
return true;
}
void ScanForAddedFiles(XcodeSyncBackContext ctx, HashSet <string> knownFiles, string directory, string relativePath)
{
foreach (var file in Directory.EnumerateFiles(directory))
{
if (file.EndsWith("~") || file.EndsWith(".m"))
{
continue;
}
if (knownFiles.Contains(file))
{
continue;
}
if (file.EndsWith(".h"))
{
NSObjectTypeInfo parsed = NSObjectInfoService.ParseHeader(file);
ctx.TypeSyncJobs.Add(XcodeSyncObjcBackJob.NewType(parsed, relativePath));
}
else
{
FilePath original, relative;
if (relativePath != null)
{
relative = new FilePath(Path.Combine(relativePath, Path.GetFileName(file)));
}
else
{
relative = new FilePath(Path.GetFileName(file));
}
original = ctx.Project.BaseDirectory.Combine(relative);
ctx.FileSyncJobs.Add(new XcodeSyncFileBackJob(original, relative, true));
}
}
foreach (var dir in Directory.EnumerateDirectories(directory))
{
string relative;
// Ignore *.xcodeproj directories and any directories named DerivedData at the toplevel
if (dir.EndsWith(".xcodeproj") || (relativePath == null && Path.GetFileName(dir) == "DerivedData"))
{
continue;
}
if (relativePath != null)
{
relative = Path.Combine(relativePath, Path.GetFileName(dir));
}
else
{
relative = Path.GetFileName(dir);
}
ScanForAddedFiles(ctx, knownFiles, dir, relative);
}
}
/// <summary>
/// Removes any deleted files from the DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not any files were removed from the project.
/// </returns>
bool RemoveDeletedFilesFromProject (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return false;
var removed = new List<XcodeSyncFileBackJob> (context.FileSyncJobs.Where (job => job.Status == XcodeSyncFileStatus.Removed));
if (removed.Count == 0)
return false;
monitor.BeginStepTask (string.Format ("Removing deleted files from {0}...", dnp.Name), removed.Count, 1);
foreach (var file in removed) {
monitor.Log.WriteLine ("Removing '{0}'", file.SyncedRelative);
context.Project.Files.Remove (file.Original);
monitor.Step (1);
}
monitor.EndTask ();
return true;
}
public XcodeSyncBackContext GetChanges (NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext (projectDir, syncTimeCache, infoService, project);
var needsSync = new List<XcodeSyncedItem> (items.Where (i => i.NeedsSyncBack (ctx)));
if (needsSync.Count > 0) {
Ide.IdeApp.Workbench.StatusBar.BeginProgress (GettextCatalog.GetString ("Synchronizing external project changes..."));
for (int i = 0; i < needsSync.Count; i++) {
var item = needsSync [i];
item.SyncBack (ctx);
Ide.IdeApp.Workbench.StatusBar.SetProgressFraction ((i + 1.0) / needsSync.Count);
}
Ide.IdeApp.Workbench.StatusBar.EndProgress ();
Ide.IdeApp.Workbench.StatusBar.ShowMessage (string.Format (GettextCatalog.GetPluralString ("Synchronized {0} file", "Synchronized {0} files", needsSync.Count), needsSync.Count));
}
return ctx;
}
public abstract void SyncBack (XcodeSyncBackContext context);
void ScanForAddedFiles (IProgressMonitor monitor, XcodeSyncBackContext ctx, HashSet<string> knownFiles, string directory, string relativePath)
{
foreach (var file in Directory.EnumerateFiles (directory)) {
if (file.EndsWith ("~") || file.EndsWith (".m"))
continue;
if (knownFiles.Contains (file))
continue;
if (file.EndsWith (".h")) {
NSObjectTypeInfo parsed = NSObjectInfoService.ParseHeader (file);
monitor.Log.WriteLine ("New Objective-C header file found: {0}", Path.Combine (relativePath, Path.GetFileName (file)));
ctx.TypeSyncJobs.Add (XcodeSyncObjcBackJob.NewType (parsed, relativePath));
} else {
FilePath original, relative;
if (relativePath != null)
relative = new FilePath (Path.Combine (relativePath, Path.GetFileName (file)));
else
relative = new FilePath (Path.GetFileName (file));
original = ctx.Project.BaseDirectory.Combine (relative);
monitor.Log.WriteLine ("New content file found: {0}", relative);
ctx.FileSyncJobs.Add (new XcodeSyncFileBackJob (original, relative, true));
}
}
foreach (var dir in Directory.EnumerateDirectories (directory)) {
string relative;
// Ignore *.xcodeproj directories and any directories named DerivedData at the toplevel
if (dir.EndsWith (".xcodeproj") || (relativePath == null && Path.GetFileName (dir) == "DerivedData"))
continue;
if (relativePath != null)
relative = Path.Combine (relativePath, Path.GetFileName (dir));
else
relative = Path.GetFileName (dir);
ScanForAddedFiles (monitor, ctx, knownFiles, dir, relative);
}
}
public abstract void SyncBack(IProgressMonitor monitor, XcodeSyncBackContext context);
public override void SyncBack (IProgressMonitor monitor, XcodeSyncBackContext context)
{
monitor.Log.WriteLine ("Queueing sync-back of changes made to '{0}' from Xcode.", targetRelative);
string target = context.ProjectDir.Combine (targetRelative);
XcodeSyncFileStatus status;
if (File.Exists (target))
status = XcodeSyncFileStatus.Modified;
else
status = XcodeSyncFileStatus.Removed;
context.FileSyncJobs.Add (new XcodeSyncFileBackJob (source, targetRelative, status));
}
public override void SyncBack (XcodeSyncBackContext context)
{
throw new InvalidOperationException ();
}