public WatcherExEventArgs(FileSystemWatcherEx watcher,
object arguments,
ArgumentType argType)
{
Watcher = watcher;
Arguments = arguments;
ArgType = argType;
Filter = NotifyFilters.Attributes;
}
public WatcherExEventArgs(FileSystemWatcherEx watcher,
object arguments,
ArgumentType argType,
NotifyFilters filter)
{
Watcher = watcher;
Arguments = arguments;
ArgType = argType;
Filter = filter;
}
public CurrentDirectoryViewModel(FileListViewModel rootModel, Model.DirectoryModel model)
: base(rootModel, model)
{
IsLoaded = false;
_rootModel = rootModel;
_subEntries = new CollectionViewSource();
_subEntries.Source = SubEntriesInternal;
_subEntries.SortDescriptions.Add(new SortDescription("IsDirectory", ListSortDirection.Descending));
_subEntries.SortDescriptions.Add(new SortDescription("FullName", ListSortDirection.Ascending));
_refreshCommand = new SimpleCommand
{
CanExecuteDelegate = x => true,
ExecuteDelegate = x => Refresh()
};
#region FileSystemWatcher
_watcher = new FileSystemWatcherEx(model.EmbeddedDirectoryEntry);
var handler = (FileSystemEventHandlerEx) delegate(object sender, FileSystemEventArgsEx args)
{
if (args.FullPath.Equals(model.FullName))
{
Refresh();
}
};
var renameHandler = (RenameEventHandlerEx) delegate(object sender, RenameEventArgsEx args)
{
if (args.OldFullPath.Equals(model.FullName))
{
Refresh();
}
};
_watcher.OnChanged += handler;
_watcher.OnCreated += handler;
_watcher.OnDeleted += handler;
_watcher.OnRenamed += renameHandler;
#endregion
}
public DirectoryTreeViewModel()
{
setUpBackgroundWorker();
#region FileSystemWatcher
_watcher = new FileSystemWatcherEx(DirectoryInfoEx.DesktopDirectory);
var handler = (FileSystemEventHandlerEx) delegate(object sender, FileSystemEventArgsEx args)
{
BroadcastChange(args.FullPath, args.ChangeType);
};
var renameHandler = (RenameEventHandlerEx) delegate(object sender, RenameEventArgsEx args)
{
BroadcastChange(args.OldFullPath, args.ChangeType);
};
_watcher.OnChanged += handler;
_watcher.OnCreated += handler;
_watcher.OnDeleted += handler;
_watcher.OnRenamed += renameHandler;
#endregion
}
public DirectoryTreeViewModel()
{
setUpBackgroundWorker();
#region FileSystemWatcher
try
{
if (IsWin8())
{
_watcher = new FileSystemWatcherEx(DirectoryInfoEx.MyComputerDirectory);
}
else
{
_watcher = new FileSystemWatcherEx(DirectoryInfoEx.DesktopDirectory);
}
}
catch (Exception e) {
Debug.Write(e.Message);
}
var handler = (FileSystemEventHandlerEx) delegate(object sender, FileSystemEventArgsEx args)
{
BroadcastChange(args.FullPath, args.ChangeType);
};
var renameHandler = (RenameEventHandlerEx) delegate(object sender, RenameEventArgsEx args)
{
BroadcastChange(args.OldFullPath, args.ChangeType);
};
_watcher.OnChanged += handler;
_watcher.OnCreated += handler;
_watcher.OnDeleted += handler;
_watcher.OnRenamed += renameHandler;
#endregion
}
//--------------------------------------------------------------------------------
/// <summary>
/// Actually creates the necessary FileSystemWatcher objects, depending oin which
/// notify filters and change types the user specified.
/// </summary>
/// <param name="changeType"></param>
/// <param name="filter"></param>
private void CreateWatcher(bool changedWatcher, NotifyFilters filter)
{
Debug.WriteLine(string.Format("WatcherEx.CreateWatcher({0}, {1})", changedWatcher.ToString(), filter.ToString()));
FileSystemWatcherEx watcher = null;
int bufferSize = (int)this.watcherInfo.BufferKBytes * 1024;
// Each "Change" filter gets its own watcher so we can determine *what*
// actually changed. This will allow us to react only to the change events
// that we actually want. The reason I do this is because some programs
// fire TWO events for certain changes. For example, Notepad sends two
// events when a file is created. One for CreationTime, and one for
// Attributes.
if (changedWatcher)
{
// if we're not handling the currently specified filter, get out
if (HandleNotifyFilter(filter))
{
watcher = new FileSystemWatcherEx(this.watcherInfo.WatchPath);
watcher.IncludeSubdirectories = this.watcherInfo.IncludeSubFolders;
watcher.Filter = this.watcherInfo.FileFilter;
watcher.NotifyFilter = filter;
watcher.InternalBufferSize = bufferSize;
switch (filter)
{
case NotifyFilters.Attributes:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedAttribute);
break;
case NotifyFilters.CreationTime:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedCreationTime);
break;
case NotifyFilters.DirectoryName:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedDirectoryName);
break;
case NotifyFilters.FileName:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedFileName);
break;
case NotifyFilters.LastAccess:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedLastAccess);
break;
case NotifyFilters.LastWrite:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedLastWrite);
break;
case NotifyFilters.Security:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedSecurity);
break;
case NotifyFilters.Size:
watcher.Changed += new FileSystemEventHandler(watcher_ChangedSize);
break;
}
}
}
// All other FileSystemWatcher events are handled through a single "main"
// watcher.
else
{
if (HandleWatchesFilter(WatcherChangeTypes.Created) ||
HandleWatchesFilter(WatcherChangeTypes.Deleted) ||
HandleWatchesFilter(WatcherChangeTypes.Renamed) ||
this.watcherInfo.WatchForError ||
this.watcherInfo.WatchForDisposed)
{
watcher = new FileSystemWatcherEx(this.watcherInfo.WatchPath, watcherInfo.MonitorPathInterval);
watcher.IncludeSubdirectories = this.watcherInfo.IncludeSubFolders;
watcher.Filter = this.watcherInfo.FileFilter;
watcher.InternalBufferSize = bufferSize;
}
if (HandleWatchesFilter(WatcherChangeTypes.Created))
{
watcher.Created += new FileSystemEventHandler(watcher_CreatedDeleted);
}
if (HandleWatchesFilter(WatcherChangeTypes.Deleted))
{
watcher.Deleted += new FileSystemEventHandler(watcher_CreatedDeleted);
}
if (HandleWatchesFilter(WatcherChangeTypes.Renamed))
{
watcher.Renamed += new RenamedEventHandler(watcher_Renamed);
}
if (watcherInfo.MonitorPathInterval > 0)
{
watcher.EventPathAvailability += new PathAvailabilityHandler(watcher_EventPathAvailability);
}
}
if (watcher != null)
{
if (this.watcherInfo.WatchForError)
{
watcher.Error += new ErrorEventHandler(watcher_Error);
}
if (this.watcherInfo.WatchForDisposed)
{
watcher.Disposed += new EventHandler(watcher_Disposed);
}
this.watchers.Add(watcher);
}
}
