internal void FileRemoved(object sender, FileEventArgs e)
		{
			for (int i = 0; i < recentFiles.Count; ++i) {
				string file = recentFiles[i].ToString();
				if (e.FileName == file) {
					recentFiles.RemoveAt(i);
					break;
				}
			}
		}

		static void HandleFileServiceChange (object sender, FileEventArgs e)
		{
			bool foundOneChange = false;
			foreach (var file in e) {
				foreach (var view in openFiles) {
					if (SkipView (view) || !string.Equals (view.ContentName, file.FileName, fileNameComparer))
						continue;
					if (!view.IsDirty && (IdeApp.Workbench.AutoReloadDocuments || file.AutoReload))
						view.SourceEditorWidget.Reload ();
					else
						foundOneChange = true;
				}
			}

			if (foundOneChange)
				CommitViewChange (GetAllChangedFiles ());
		}

        void files_FileWritten(object sender, FileEventArgs e)
        {
            Url virtualPath = e.VirtualPath;

            if (!IsResizableImagePath(virtualPath))
                return;

            if(images.Sizes.Count == 0)
                return;

            byte[] image = GetImageBytes(virtualPath);

            foreach (ImageSizeElement size in images.Sizes.AllElements)
            {
                CreateSize(virtualPath, image, size);
            }
        }

        void files_FileCopied(object sender, FileEventArgs e)
        {
            if (IsResizedPath(e.VirtualPath))
                return;

            foreach (ImageSizeElement size in images.Sizes.AllElements)
            {
                Url sourceUrl = e.SourcePath;
                Url destinationUrl = e.VirtualPath;

                string sourcePath = ImagesUtility.GetResizedPath(sourceUrl, size.Name);

                if (!files.FileExists(sourcePath))
                    continue;

                string destinationPath = ImagesUtility.GetResizedPath(destinationUrl, size.Name);
                if(!files.FileExists(destinationPath))
                    files.CopyFile(sourcePath, destinationPath);
            }
        }

		static void HandleFileServiceChange (object sender, FileEventArgs e)
		{
			// The Ide.Document generates a file service changed event this needs to be skipped.
			if (!TypeSystemService.TrackFileChanges)
				return;
			bool foundOneChange = false;
			foreach (var file in e) {
				foreach (var view in openFiles) {
					if (SkipView (view) || !string.Equals (view.ContentName, file.FileName, fileNameComparer))
						continue;
					if (!view.IsDirty/* && (IdeApp.Workbench.AutoReloadDocuments || file.AutoReload)*/)
						view.SourceEditorWidget.Reload ();
					else
						foundOneChange = true;
				}
			}

			if (foundOneChange)
				CommitViewChange (GetAllChangedFiles ());
		}

		protected virtual void OnFileRenamed(FileEventArgs e)
		{
			if (FileRenamed != null) {
				FileRenamed(this, e);
			}
		}

		static void NotifyFileRemoved (object sender, FileEventArgs args)
		{
			foreach (FileEventInfo e in args) {
				if (!e.IsDirectory) {
					platformService.RecentFiles.NotifyFileRemoved (e.FileName);
				}
			}
		}

 void ProbeNppPlugin_FileSaved(object sender, FileEventArgs e)
 {
     try
     {
         if (!string.IsNullOrWhiteSpace(e.FileName))
         {
             CodeModel.CodeModel.OnFileSaved(e.FileName);
         }
     }
     catch (Exception ex)
     {
         Output.WriteLine(OutputStyle.Error, ex.ToString());
     }
 }

 void fileEvents(object sender, FileEventArgs e)
 {
     if (FileEvent != null) FileEvent(sender, e);
 }

        public void FileRenamed(object sender, FileEventArgs e)
        {
            if (e.IsDirectory)
                return;

            if (e.FileName == null)
                recentFiles.RenameItem (new Uri (e.SourceFile), new Uri (e.TargetFile));
            else
                recentFiles.RenameItem (new Uri (e.FileName), new Uri (e.TargetFile));
            UpdateLastFile ();
        }

 private void Plugin_FileActivated(object sender, FileEventArgs e)
 {
     try
     {
         OnFileActivated(e.BufferId);
         _fileScannerDefer.OnActivity();
     }
     catch (Exception ex)
     {
         Output.WriteLine(OutputStyle.Error, ex.ToString());
     }
 }

		void files_FileDeleted(object sender, FileEventArgs e)
		{
			if (!Enabled)
				return;

			if (!IsResizableImagePath(e.VirtualPath))
				return;

            foreach (ImageSizeElement size in images.Sizes.AllElements)
            {
                string resizedPath = ImagesUtility.GetResizedPath(e.VirtualPath, size.Name);

                if (files.FileExists(resizedPath))
                    files.DeleteFile(resizedPath);
            }
        }

 private void OnWarningAdded(object sender, FileEventArgs args) {
     if (_diskNodes.ContainsKey(args.Filename)) {
         _warningFiles.Add(args.Filename);
     }
 }

 private void OnErrorRemoved(object sender, FileEventArgs args) {
     _errorFiles.Remove(args.Filename);
 }

 private void OnErrorAdded(object sender, FileEventArgs args) {
     if (_diskNodes.ContainsKey(args.Filename)) {
         _errorFiles.Add(args.Filename);
     }
 }

 void OnFolderRemoved(object sender, FileEventArgs e)
 {
     var tb = Context.GetTreeBuilder (sender);
     if (tb == null)
         return;
     if (!tb.HasChildren ()) {
         tb.Remove ();
     } else {
         //this may have been removed but HasChildren could still be false, not sure why
         //but fully updating the parent's children works
         tb.MoveToParent ();
         tb.UpdateChildren ();
     }
 }

 private void Plugin_FileClosed(object sender, FileEventArgs e)
 {
     try
     {
         if (_fileDetails.ContainsKey(e.BufferId)) _fileDetails.Remove(e.BufferId);
     }
     catch (Exception ex)
     {
         Output.WriteLine(OutputStyle.Error, "Exception in FileOpened event: {0}", ex);
     }
 }

		void OnSystemFileDeleted (object sender, FileEventArgs args)
		{
			foreach (FileEventInfo e in args) {
				Project project = GetProjectForFile (e.FileName);

				ITreeBuilder tb = Context.GetTreeBuilder ();
				
				if (e.IsDirectory) {
					if (tb.MoveToObject (new ProjectFolder (e.FileName, project))) {
						if (tb.Options ["ShowAllFiles"] && (project == null || !ProjectFolderCommandHandler.PathExistsInProject (project, e.FileName))) {
							tb.Remove ();
							return;
						}
					}
				}
				else {
					if (tb.MoveToObject (new SystemFile (e.FileName, project))) {
						tb.Remove ();
						return;
					}
				}
				
				// Find the parent folder, and update it's children count
				
				string parentPath = Path.GetDirectoryName (e.FileName);
				if (tb.MoveToObject (new ProjectFolder (parentPath, project))) {
					if (tb.Options ["ShowAllFiles"] && Directory.Exists (parentPath))
						tb.UpdateChildren ();
				}
			}
		}

		void OnSystemFileAdded (object sender, FileEventArgs args)
		{
			foreach (FileEventInfo e in args) {
				Project project = GetProjectForFile (e.FileName);
				if (project == null) return;
				
				if (e.IsDirectory) {
					EnsureReachable (project, e.FileName + "/");
				} else {
					if (project.Files.GetFile (e.FileName) == null)
						AddFile (e.FileName, project);
				}
			}
		}

		void GotFileChanged (object sender, FileEventArgs args)
		{
			if (!isDisposed)
				HandleFileChanged (args.FileName);
		}