void HandleProjectFileChangedInProject (object sender, ProjectFileEventArgs args)
		{
			foreach (ProjectFileEventInfo e in args) {
				if (IsXibFile (e.ProjectFile))
					ThreadPool.QueueUserWorkItem (delegate { UpdateXibCodebehind (e.ProjectFile); });
			}
		}

 internal static void Log(String messageFormat, ProjectFileEventArgs e)
 {
     foreach (ProjectFileEventInfo info in e) {
         ProjectFile projectFile = info.ProjectFile;
         Log (messageFormat, projectFile.Name);
     }
 }

		void HandleSolutionFileChangedInProject (object sender, ProjectFileEventArgs e)
		{
			if (e.Project is DotNetProject) {
				projectTimestamps [(DotNetProject)e.Project] = DateTime.Now;
				OnChanged ();
			}
		}

		void OnFilePropertyChangedInProject (object sender, ProjectFileEventArgs args)
		{
			var pad = IdeApp.Workbench.GetPad <PropertyPad> ();
			if (pad == null)
				return;

			var grid = ((PropertyPad)pad.Content).PropertyGrid;
			if (args.Any (arg => arg.ProjectFile == file))
				grid.Refresh ();
		}

		void OnFilePropertyChangedInProject (object sender, ProjectFileEventArgs args)
		{
			var pad = IdeApp.Workbench.GetPad <PropertyPad> ();
			if (pad == null)
				return;

			var grid = ((PropertyPad)pad.Content).PropertyGrid;
			if (grid.IsEditing)
				return;

			if (args.Any (arg => arg.ProjectFile == file))
				grid.Populate (saveEditSession: false);
		}

		void OnFileAdded (object o, ProjectFileEventArgs a)
		{
			if (a.ProjectFile.Name.EndsWith (".desktop")) {
				DesktopEntry de = new DesktopEntry ();
				try {
					de.Load (a.ProjectFile.Name);
					a.ProjectFile.BuildAction = BuildAction.Content;
					DeployProperties props = DeployService.GetDeployProperties (a.ProjectFile);
					props.TargetDirectory = LinuxTargetDirectory.DesktopApplications;
					if (string.IsNullOrEmpty (de.Exec)) {
						LinuxDeployData dd = LinuxDeployData.GetLinuxDeployData (a.Project);
						if (dd.GenerateScript && !string.IsNullOrEmpty (dd.ScriptName)) {
							de.Exec = dd.ScriptName;
							de.Save (a.ProjectFile.Name);
						}
					}
				} catch (Exception ex) {
					LoggingService.LogError ("Could not read .desktop file", ex);
				}
			}
		}

 protected override void OnFilePropertyChangedInProject(ProjectFileEventArgs e)
 {
     NeedsFullRebuild = true;
     base.OnFilePropertyChangedInProject (e);
 }

		void CheckFileChanges (ProjectFileEventArgs e)
		{
			bool updateTypes = false, updateProject = false;
			
			foreach (ProjectFileEventInfo finf in e) {
				if (finf.Project != dnp)
					continue;
				if (finf.ProjectFile.BuildAction == BuildAction.Compile) {
					updateTypes = true;
				} else if (IncludeInSyncedProject (finf.ProjectFile)) {
					updateProject = true;
				}
			}
			
			if (updateTypes) {
				using (var monitor = GetStatusMonitor (GettextCatalog.GetString ("Syncing types to Xcode..."))) {
					//FIXME: make this async (and safely async)
					//FIXME: only update the project if obj-c types change
					updateProject |= UpdateTypes (monitor);
				}
			}
			
			if (updateProject) {
				using (var monitor = GetStatusMonitor (GettextCatalog.GetString ("Syncing project to Xcode..."))) {
					//FIXME: make this async (and safely async)
					var running = xcode.CheckRunning ();
					UpdateXcodeProject (monitor);
					if (running) {
						try {
							xcode.OpenProject (monitor);
						} catch (AppleScriptException) {
							ShowXcodeScriptError ();
						} catch (TimeoutException) {
							ShowXcodeScriptError ();
						}
					}
				}
			}
		}

		protected override void OnFileAddedToProject (ProjectFileEventArgs e)
		{
			//short-circuit if the project is being deserialised
			if (Project.Loading) {
				base.OnFileAddedToProject (e);
				return;
			}

			bool webConfigChange = false;
			List<string> filesToAdd = new List<string> ();

			foreach (ProjectFileEventInfo fargs in e) {
				IEnumerable<string> files = MonoDevelop.DesignerSupport.CodeBehind.GuessDependencies
					(Project, fargs.ProjectFile, groupedExtensions);
				if (files != null)
					filesToAdd.AddRange (files);
				if (IsWebConfig (fargs.ProjectFile.FilePath))
					webConfigChange = true;
			}

			if (webConfigChange)
				UpdateWebConfigRefs ();

			//let the base fire the event before we add files
			//don't want to fire events out of order of files being added
			base.OnFileAddedToProject (e);

			//make sure that the parent and child files are in the project
			foreach (string file in filesToAdd) {
				//NOTE: this only adds files if they are not already in the project
				Project.AddFile (file);
			}
		}

		protected override void OnFileChangedInProject (ProjectFileEventArgs e)
		{
			IDELogger.Log ("MonobjcProject::OnFileChangedInProject '{0}'", e);

			this.ResolverHandler.ClearCache();
			this.XcodeHandler.ClearXcodeProject();

			base.OnFileChangedInProject (e);

			this.CodeBehindHandler.GenerateDesignCodeForXib (e);
		}

		void OnFileRemoved (object sender, ProjectFileEventArgs e)
		{
			ArrayList toDelete = new ArrayList ();

			foreach (ProjectFileEventInfo args in e) {
				var doc = TypeSystemService.ParseFile (args.Project, args.ProjectFile.Name);
				if (doc == null)
					continue;
	
				foreach (var t in doc.TopLevelTypeDefinitions) {
					GuiBuilderWindow win = GetWindowForClass (t.FullName);
					if (win != null)
						toDelete.Add (win);
				}
			}
			
			foreach (GuiBuilderWindow win in toDelete)
				Remove (win);
		}

		/// <summary>
		/// Raises the FileChangedInProject event.
		/// </summary>
		protected virtual void OnFileChangedInProject (ProjectFileEventArgs e)
		{
			if (FileChangedInProject != null) {
				FileChangedInProject (this, e);
			}
		}

		/// <summary>
		/// Raises the FileAddedToProject event.
		/// </summary>
		protected virtual void OnFileAddedToProject (ProjectFileEventArgs e)
		{
			buildActions = null;
			if (FileAddedToProject != null) {
				FileAddedToProject (this, e);
			}
		}

		/// <summary>
		/// Raises the FileRemovedFromProject event.
		/// </summary>
		protected virtual void OnFileRemovedFromProject (ProjectFileEventArgs e)
		{
			buildActions = null;
			if (FileRemovedFromProject != null) {
				FileRemovedFromProject (this, e);
			}
		}

		void NotifyFileAddedToProject (IEnumerable<ProjectFile> objs)
		{
			if (!objs.Any ())
				return;
			
			var args = new ProjectFileEventArgs ();
			
			foreach (ProjectFile file in objs) {
				if (file.Project != null)
					throw new InvalidOperationException ("ProjectFile already belongs to a project");
				file.SetProject (this);
				args.Add (new ProjectFileEventInfo (this, file));
				ResolveDependencies (file);
			}

			SetDirty ();
			NotifyModified ("Files");
			OnFileAddedToProject (args);
		}

		void NotifyFileRemovedFromProject (IEnumerable<ProjectFile> objs)
		{
			if (!objs.Any ())
				return;
			
			var args = new ProjectFileEventArgs ();
			
			foreach (ProjectFile file in objs) {
				file.SetProject (null);
				args.Add (new ProjectFileEventInfo (this, file));
				if (DependencyResolutionEnabled) {
					if (unresolvedDeps.Contains (file))
						unresolvedDeps.Remove (file);
					foreach (ProjectFile f in file.DependentChildren) {
						f.DependsOnFile = null;
						if (!string.IsNullOrEmpty (f.DependsOn))
							unresolvedDeps.Add (f);
					}
					file.DependsOnFile = null;
				}
			}
			SetDirty ();
			NotifyModified ("Files");
			OnFileRemovedFromProject (args);
		}

 protected override void OnFileRemovedFromProject(ProjectFileEventArgs e)
 {
     base.OnFileRemovedFromProject(e);
     NeedsFullRebuild = true;
     foreach (var pf in e)
         GlobalParseCache.RemoveModule (pf.ProjectFile.FilePath);
 }

		void OnFileAdded (object sender, ProjectFileEventArgs e)
		{
			foreach (ProjectFileEventInfo args in e) {
				var doc = TypeSystemService.ParseFile (args.Project, args.ProjectFile.Name);
				if (doc == null)
					continue;
	
				string dir = Path.Combine (Path.Combine (Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData), "stetic"), "deleted-designs");
				if (!Directory.Exists (dir) || Directory.GetFiles (dir).Length == 0)
					continue;
	
				foreach (var t in doc.TopLevelTypeDefinitions) {
					string path = Path.Combine (dir, t.FullName + ".xml");
					if (!System.IO.File.Exists (path))
						continue;
					XmlDocument xmldoc = new XmlDocument ();
					xmldoc.Load (path);
					AddNewComponent (xmldoc.DocumentElement);
					System.IO.File.Delete (path);
				}
			}
		}

		//based on MoonlightProject
		protected override void OnFileAddedToProject (ProjectFileEventArgs args)
		{
			//short-circuit if the project is being deserialised
			if (Loading) {
				base.OnFileAddedToProject (args);
				return;
			}
			
			/* TODO
			if (String.IsNullOrEmpty (MainNibFile) && Path.GetFileName (e.ProjectFile.FilePath) == "MainWindow.xib") {
				MainNibFile = e.ProjectFile.FilePath;
			}
			*/
			
			List<string> filesToAdd = new List<string> ();
			foreach (ProjectFileEventInfo e in args) {
				//find any related files, e.g codebehind
				//FIXME: base this on the controller class names defined in the xib
				var files = MonoDevelop.DesignerSupport.CodeBehind.GuessDependencies (this, e.ProjectFile, groupedExtensions);
				if (files != null)
					filesToAdd.AddRange (files);
			}
			//let the base fire the event before we add files
			//don't want to fire events out of order of files being added
			base.OnFileAddedToProject (args);
			
			//make sure that the parent and child files are in the project
			foreach (string file in filesToAdd) {
				//NOTE: this only adds files if they are not already in the project
				AddFile (file);
			}
		}

		/// <summary>
		/// Raises the FilePropertyChangedInProject event.
		/// </summary>
		protected virtual void OnFilePropertyChangedInProject (ProjectFileEventArgs e)
		{
			buildActions = null;
			if (FilePropertyChangedInProject != null) {
				FilePropertyChangedInProject (this, e);
			}
		}