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>;