public async Task Lookup(T value, ITreeSelector <VM, T> parentSelector,
ICompareHierarchy <T> comparer, params ITreeLookupProcessor <VM, T>[] processors)
{
IEnumerable <VM> subentries = _loadSubEntries ?
await parentSelector.EntryHelper.LoadAsync() :
parentSelector.EntryHelper.AllNonBindable;
if (subentries != null)
{
foreach (VM current in subentries)
{
if (current is ISupportTreeSelector <VM, T> && current is ISupportEntriesHelper <VM> )
{
var currentSelectionHelper = (current as ISupportTreeSelector <VM, T>).Selection;
var compareResult = comparer.CompareHierarchy(currentSelectionHelper.Value, value);
switch (compareResult)
{
case HierarchicalResult.Current:
processors.Process(compareResult, parentSelector, currentSelectionHelper);
return;
case HierarchicalResult.Child:
if (processors.Process(compareResult, parentSelector, currentSelectionHelper))
{
await Lookup(value, currentSelectionHelper, comparer, processors);
return;
}
break;
}
}
}
}
}
public async Task Lookup(T value, ITreeSelector <VM, T> parentSelector,
ICompareHierarchy <T> comparer, params ITreeLookupProcessor <VM, T>[] processors)
{
if (parentSelector.EntryHelper.IsLoaded)
{
foreach (VM current in parentSelector.EntryHelper.AllNonBindable)
{
if (current is ISupportTreeSelector <VM, T> && current is ISupportEntriesHelper <VM> )
{
var currentSelectionHelper = (current as ISupportTreeSelector <VM, T>).Selection;
var compareResult = comparer.CompareHierarchy(currentSelectionHelper.Value, value);
switch (compareResult)
{
case HierarchicalResult.Child:
case HierarchicalResult.Current:
if (_hierarchy.Contains(currentSelectionHelper))
{
processors.Process(compareResult, parentSelector, currentSelectionHelper);
return;
}
break;
}
}
}
}
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (MatchResult.HasFlag(hr))
{
selector.EntryHelper.IsExpanded = false;
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (hr == HierarchicalResult.Child || hr == HierarchicalResult.Current)
{
parentSelector.SetSelectedChild(selector.Value);
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (_hr.HasFlag(hr))
{
selector.SetSelectedChild(default(T));
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (_hr.HasFlag(hr))
{
selector.EntryHelper.LoadAsync(UpdateMode.Replace, true);
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (_appliedResult.HasFlag(hr))
{
return(_processFunc(hr, parentSelector, selector));
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (hr == HierarchicalResult.Current)
{
selector.IsSelected = true;
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (_hr.HasFlag(hr))
{
selector.IsSelected = false;
}
return(true);
}
public TreeSelector(T currentValue, TVm currentViewModel, ITreeSelector <TVm, T> parentSelector,
IEntriesHelper <TVm> entryHelper)
{
RootSelector = parentSelector.RootSelector;
ParentSelector = parentSelector;
EntryHelper = entryHelper;
Value = currentValue;
ViewModel = currentViewModel;
}
public DirectoryTreeDragHelper(IEntriesHelper <IDirectoryNodeViewModel> entries,
ITreeSelector <IDirectoryNodeViewModel, IEntryModel> selection)
: base(
() => new[] { selection.RootSelector.SelectedViewModel },
ems => ems.First().Profile.DragDrop.QueryDrag(ems),
ems => ems.First().Profile.DragDrop.GetDataObject(ems),
(ems, da, eff) => ems.First().Profile.DragDrop.OnDragCompleted(ems, da, eff)
, d => (d as IEntryViewModel).EntryModel)
{
}
public TreeSelector(T currentValue, VM currentViewModel,
ITreeSelector <VM, T> parentSelector,
IEntriesHelper <VM> entryHelper)
{
RootSelector = parentSelector.RootSelector;
ParentSelector = parentSelector;
EntryHelper = entryHelper;
_currentValue = currentValue;
_currentViewModel = currentViewModel;
}
public bool Process(HierarchicalResult hr, ITreeSelector <IDirectoryNodeViewModel,
FileExplorer.Models.IEntryModel> parentSelector,
ITreeSelector <IDirectoryNodeViewModel, FileExplorer.Models.IEntryModel> selector)
{
if (hr == FileExplorer.Defines.HierarchicalResult.Current)
{
selector.ViewModel.IsBringIntoView = true;
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (MatchResult.HasFlag(hr))
{
selector.EntryHelper.IsExpanded = true;
}
if (hr == HierarchicalResult.Current)
{
((IIntoViewBringable)selector.ViewModel).IsBringIntoView = true;
}
return(true);
}
public bool Process(HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
if (MatchResult.HasFlag(hr))
{
selector.EntryHelper.IsExpanded = true;
}
if (hr == FileExplorer.Defines.HierarchicalResult.Current)
{
(selector.ViewModel as IDirectoryNodeViewModel).IsBringIntoView = true;
}
return(true);
}
public SearchNextUsingReverseLookup(ITreeSelector <VM, T> targetSelector)
{
_targetSelector = targetSelector;
_hierarchy = new Stack <ITreeSelector <VM, T> >();
var current = targetSelector;
while (current != null)
{
_hierarchy.Push(current);
current = current.ParentSelector;
}
}
public static bool Process <VM, T>(this ITreeLookupProcessor <VM, T>[] processors,
HierarchicalResult hr, ITreeSelector <VM, T> parentSelector, ITreeSelector <VM, T> selector)
{
foreach (var p in processors)
{
if (!p.Process(hr, parentSelector, selector))
{
return(false);
}
}
return(true);
}
public async Task Lookup(T value, ITreeSelector <VM, T> parentSelector,
ICompareHierarchy <T> comparer, params ITreeLookupProcessor <VM, T>[] processors)
{
foreach (VM current in await parentSelector.EntryHelper.LoadAsync())
{
if (current is ISupportTreeSelector <VM, T> )
{
var currentSelectionHelper = (current as ISupportTreeSelector <VM, T>).Selection;
var compareResult = comparer.CompareHierarchy(currentSelectionHelper.Value, value);
processors.Process(compareResult, parentSelector, currentSelectionHelper);
}
}
}
private static IEnumerable <IEntryModel> dataObjectFunc(IDataObject da,
ITreeSelector <IDirectoryNodeViewModel, IEntryModel> selection)
{
var profiles = selection.RootSelector.EntryHelper.All.Select(rvm => rvm.EntryModel.Profile);
foreach (var p in profiles)
{
var retVal = p.DragDrop.GetEntryModels(da);
if (retVal != null)
{
return(retVal);
}
}
return(null);
}
public DirectoryNodeDropHelper(IEntryModel curDir, IEntriesHelper <IDirectoryNodeViewModel> entries,
ITreeSelector <IDirectoryNodeViewModel, IEntryModel> selection)
: base(
new LambdaValueConverter <IEntryViewModel, IEntryModel>(
(evm) => evm.EntryModel,
(em) => EntryViewModel.FromEntryModel(em)),
new LambdaValueConverter <IEnumerable <IEntryModel>, IDataObject>(
ems => curDir.Profile.DragDrop.GetDataObject(ems),
da => dataObjectFunc(da, selection)),
(ems, eff) => curDir.Profile.DragDrop.QueryDrop(ems, curDir, eff),
(ems, da, eff) => curDir.Profile.DragDrop.OnDropCompleted(ems, da, curDir, eff))
{
}
public async Task Lookup(T value, ITreeSelector <TVm, T> parentSelector, ICompareHierarchy <T> comparer,
params ITreeLookupProcessor <TVm, T>[] processors)
{
foreach (var current in await parentSelector.EntryHelper.LoadAsync())
{
if (current is ISupportTreeSelector <TVm, T> selector)
{
var currentSelectionHelper = selector.Selection;
var compareResult = comparer.CompareHierarchy(currentSelectionHelper.Value, value);
switch (compareResult)
{
case HierarchicalResult.Current:
case HierarchicalResult.Child:
processors.Process(compareResult, parentSelector, currentSelectionHelper);
return;
}
}
}
}
public override void ReportChildSelected(Stack <ITreeSelector <VM, T> > path)
{
ITreeSelector <VM, T> _prevSelector = _selectedSelector;
T _prevSelectedValue = _selectedValue;
_prevPath = path;
_selectedSelector = path.Last();
_selectedValue = path.Last().Value;
if (_prevSelectedValue != null && !_prevSelectedValue.Equals(path.Last().Value))
{
_prevSelector.IsSelected = false;
}
OnPropertyChanged(nameof(SelectedValue));
OnPropertyChanged(nameof(SelectedViewModel));
SelectionChanged?.Invoke(this, EventArgs.Empty);
//WARNING: Commented out by Sorzus. I don't understand why you have to load all the root items if a child gets selected
//updateRootItems(path);
}
public override void ReportChildSelected(Stack <ITreeSelector <VM, T> > path)
{
ITreeSelector <VM, T> _prevSelector = _selectedSelector;
T _prevSelectedValue = _selectedValue;
_prevPath = path;
_selectedSelector = path.Last();
_selectedValue = path.Last().Value;
if (_prevSelectedValue != null && !_prevSelectedValue.Equals(path.Last().Value))
{
_prevSelector.IsSelected = false;
}
NotifyOfPropertyChanged(() => SelectedValue);
NotifyOfPropertyChanged(() => SelectedViewModel);
if (SelectionChanged != null)
{
SelectionChanged(this, EventArgs.Empty);
}
updateRootItems(path);
}
public async Task Lookup(T value, ITreeSelector <TVm, T> parentSelector, ICompareHierarchy <T> comparer,
params ITreeLookupProcessor <TVm, T>[] processors)
{
var subentries = _loadSubEntries
? await parentSelector.EntryHelper.LoadAsync()
: parentSelector.EntryHelper.AllNonBindable;
foreach (var current in subentries)
{
if (current is ISupportTreeSelector <TVm, T> selector)
{
var currentSelectionHelper = selector.Selection;
var compareResult = comparer.CompareHierarchy(currentSelectionHelper.Value, value);
if (processors.Process(compareResult, parentSelector, currentSelectionHelper))
{
await Lookup(value, currentSelectionHelper, comparer, processors);
}
break;
}
}
}
private async Task updateRootItemsAsync(ITreeSelector <VM, T> selector, ObservableCollection <VM> rootItems, int level)
{
if (level == 0)
{
return;
}
List <ITreeSelector <VM, T> > rootTreeSelectors = new List <ITreeSelector <VM, T> >();
await selector.LookupAsync(default(T), BroadcastNextLevel <VM, T> .LoadSubentriesIfNotLoaded,
new TreeLookupProcessor <VM, T>(HierarchicalResult.All, (hr, p, c) =>
{
rootTreeSelectors.Add(c);
return(true);
}));
foreach (var c in rootTreeSelectors)
{
rootItems.Add(c.ViewModel);
c.IsRoot = true;
await updateRootItemsAsync(c, rootItems, level - 1);
}
}
public void OnChildSelected(T newValue)
{
if (_selectedValue == null || !_selectedValue.Equals(newValue))
{
if (_prevSelected != null)
{
_prevSelected.SetIsSelected(false);
}
SetSelectedChild(newValue);
if (newValue != null)
{
LookupAsync(newValue, SearchNextLevel <VM, T> .LoadSubentriesIfNotLoaded,
new TreeLookupProcessor <VM, T>(HierarchicalResult.Related, (hr, p, c) =>
{
c.IsSelected = true;
_prevSelected = c;
return(true);
})).Forget();
}
}
}
public static ITreeRootSelector <VM, T> AsRoot <VM, T>(this ITreeSelector <VM, T> selector)
{
return(selector as ITreeRootSelector <VM, T>);
}
/// <summary>
/// Whether current directory is root directory
/// </summary>
/// <typeparam name="VM"></typeparam>
/// <typeparam name="T"></typeparam>
/// <param name="selector"></param>
/// <returns></returns>
public static bool IsFirstLevelSelector <VM, T>(this ITreeSelector <VM, T> selector)
{
return(selector.ParentSelector.Equals(selector.RootSelector));
}
public static ITreeRootSelector <TVm, T> AsRoot <TVm, T>(this ITreeSelector <TVm, T> selector) => selector as ITreeRootSelector <TVm, T>;
