public void ClearSource()
{
_source1.Add(0);
_source2.Add(1);
_source.Add(_source1.Connect());
_source.Add(_source2.Connect());
_source.Clear();
_results.Data.Count.Should().Be(0);
}
public void ClearFixture()
{
var itemstoadd = Enumerable.Range(1, 100).Select(i => new Person("P" + i, i)).ToList();
_source.AddRange(itemstoadd);
_source.Clear();
Assert.AreEqual(2, _results.Messages.Count, "Should be 1 updates");
Assert.AreEqual(ListChangeReason.AddRange, _results.Messages[0].First().Reason, "First reason should be add range");
Assert.AreEqual(ListChangeReason.Clear, _results.Messages[1].First().Reason, "Second reason should be clear");
Assert.AreEqual(0, _results.Data.Count, "Should be 50 item in the cache");
}
public void BatchRemoves()
{
var people = Enumerable.Range(1, 100).Select(l => new Person("Name" + l, l)).ToArray();
_source.AddRange(people);
_source.Clear();
Assert.AreEqual(2, _results.Messages.Count, "Should be 2 updates");
Assert.AreEqual(80, _results.Messages[0].Adds, "Should be 80 addes");
Assert.AreEqual(80, _results.Messages[1].Removes, "Should be 80 removes");
Assert.AreEqual(0, _results.Data.Count, "Should be nothing cached");
}
public void ClearOneClearsResult()
{
_source1.AddRange(Enumerable.Range(1, 5));
_source2.AddRange(Enumerable.Range(1, 5));
_source1.Clear();
_results.Data.Count.Should().Be(0);
}
public void ClearOneClearsResult()
{
_source1.AddRange(Enumerable.Range(1, 5));
_source2.AddRange(Enumerable.Range(1, 5));
_source1.Clear();
Assert.AreEqual(0, _results.Data.Count);
}
public void CanCast()
{
_source.AddRange(Enumerable.Range(1, 10));
Assert.AreEqual(10, _results.Data.Count);
_source.Clear();
Assert.AreEqual(0, _results.Data.Count);
}
public void ClearOnlyClearsOneSource()
{
_source1.AddRange(Enumerable.Range(1, 5));
_source2.AddRange(Enumerable.Range(6, 5));
_source1.Clear();
Assert.AreEqual(5, _results.Data.Count);
CollectionAssert.AreEquivalent(Enumerable.Range(6, 5), _results.Data.Items);
}
public void CanCast()
{
_source.AddRange(Enumerable.Range(1, 10));
_results.Data.Count.Should().Be(10);
_source.Clear();
_results.Data.Count.Should().Be(0);
}
public void ClearOnlyClearsOneSource()
{
_source1.AddRange(Enumerable.Range(1, 5));
_source2.AddRange(Enumerable.Range(6, 5));
_source1.Clear();
_results.Data.Count.Should().Be(5);
_results.Data.Items.ShouldAllBeEquivalentTo(Enumerable.Range(6, 5));
}
public void ChangesAreNotYetAppliedDuringPreview()
{
_source.Clear();
// On preview, make sure the list is empty
var d = _source.Preview().Subscribe(_ =>
{
Assert.True(_source.Count == 0);
Assert.True(_source.Items.Count() == 0);
});
// Trigger a change
_source.Add(1);
// Cleanup
d.Dispose();
}
public void ClearSecondEnsuresFirstIsIncluded()
{
_source1.AddRange(Enumerable.Range(1, 5));
_source2.AddRange(Enumerable.Range(1, 5));
Assert.AreEqual(0, _results.Data.Count);
_source2.Clear();
Assert.AreEqual(5, _results.Data.Count);
CollectionAssert.AreEquivalent(Enumerable.Range(1, 5), _results.Data.Items);
}
public void ClearSecondEnsuresFirstIsIncluded()
{
Source1.AddRange(Enumerable.Range(1, 5));
Source2.AddRange(Enumerable.Range(1, 5));
_results.Data.Count.Should().Be(0);
Source2.Clear();
_results.Data.Count.Should().Be(5);
_results.Data.Items.Should().BeEquivalentTo(Enumerable.Range(1, 5));
}
public void EverythingIsUnsubscribedWhenStreamIsDisposed()
{
_source.AddRange(Enumerable.Range(1, 10).Select(i => new SubscribeableObject(i)));
_source.Clear();
Assert.AreEqual(2, _results.Messages.Count, "Should be 2 updates");
var items = _results.Messages[0].SelectMany(x => x.Range);
Assert.IsTrue(items.All(d => !d.IsSubscribed));
}
public void Clear()
{
var people = Enumerable.Range(1, 100).Select(l => new Person("Name" + l, l)).ToArray();
_source.AddRange(people);
_source.Clear();
_results.Messages.Count.Should().Be(2, "Should be 2 updates");
_results.Messages[0].Adds.Should().Be(100, "Should be 80 addes");
_results.Messages[1].Removes.Should().Be(100, "Should be 80 removes");
_results.Data.Count.Should().Be(0, "Should be nothing cached");
}
public void RemoveAllLists()
{
_source1.AddRange(Enumerable.Range(1, 5));
_source3.AddRange(Enumerable.Range(100, 5));
_source.Add(_source1.Connect());
_source.Add(_source2.Connect());
_source.Add(_source3.Connect());
_source2.AddRange(Enumerable.Range(6, 5));
_source.Clear();
_results.Data.Count.Should().Be(0);
}
public void RemoveAllLists()
{
_source1.AddRange(Enumerable.Range(1, 5));
_source3.AddRange(Enumerable.Range(100, 5));
_source.Add(_source1.Connect());
_source.Add(_source2.Connect());
_source.Add(_source3.Connect());
_source2.AddRange(Enumerable.Range(6, 5));
_source.Clear();
Assert.AreEqual(0, _results.Data.Count);
}
public void RemoveAllLists()
{
var items = _generator.Take(100).ToArray();
_source1.AddOrUpdate(items.Take(10));
_source2.AddOrUpdate(items.Skip(10).Take(10));
_source3.AddOrUpdate(items.Skip(20));
_source.Add(_source1.Connect());
_source.Add(_source2.Connect());
_source.Add(_source3.Connect());
_source.Clear();
_results.Data.Count.Should().Be(0);
}
public void RemoveAllLists()
{
var items = _generator.Take(100).ToArray();
_source1.AddOrUpdate(items.Take(10));
_source2.AddOrUpdate(items.Skip(10).Take(10));
_source3.AddOrUpdate(items.Skip(20));
_source.Add(_source1.Connect());
_source.Add(_source2.Connect());
_source.Add(_source3.Connect());
_source.Clear();
Assert.AreEqual(0, _results.Data.Count);
}
public void Clear()
{
var frientofchild1 = new PersonWithRelations("Friend1", 10);
var child1 = new PersonWithRelations("Child1", 10, new[] { frientofchild1 });
var child2 = new PersonWithRelations("Child2", 8);
var child3 = new PersonWithRelations("Child3", 8);
var mother = new PersonWithRelations("Mother", 35, new[] { child1, child2, child3 });
var child4 = new PersonWithRelations("Child4", 1);
var child5 = new PersonWithRelations("Child5", 2);
var anotherRelative1 = new PersonWithRelations("Another1", 2, new[] { child4, child5 });
var child6 = new PersonWithRelations("Child6", 1);
var child7 = new PersonWithRelations("Child7", 2);
var anotherRelative2 = new PersonWithRelations("Another2", 2, new[] { child6, child7 });
_source.AddRange(new[] { mother, anotherRelative1, anotherRelative2 });
_source.Clear();
_results.Data.Count.Should().Be(0);
}
private Task LoadImages(object?data)
{
if (!(data is BeginLoadingEvent eventData))
{
return(Task.CompletedTask);
}
if (!Directory.Exists(eventData.Location))
{
MessageBox.Show("Der Pfad Existiert Nicht");
return(Task.CompletedTask);
}
EventSystem.Publish(new PrepareLoadEvent());
_dataCollection.Clear();
_imageCollection.Clear();
EventSystem.Publish(new LoadDataEvent(eventData.Location));
EventSystem.Publish(new LoadImagesEvent(eventData.Location));
EventSystem.Publish(new PostLoadingEvent(eventData.Location));
return(Task.CompletedTask);
}
public PrismModuleStatusViewModel(
IModuleCatalog moduleCatalog,
IModuleManager moduleManager)
{
IsVisible = AppArguments.Instance.IsDebugMode;
this.moduleManager = moduleManager;
moduleList
.Connect()
.Bind(out var modules)
.Subscribe()
.AddTo(Anchors);
Modules = modules;
Observable.FromEventPattern<EventHandler<LoadModuleCompletedEventArgs>, LoadModuleCompletedEventArgs>(
h => moduleManager.LoadModuleCompleted += h,
h => moduleManager.LoadModuleCompleted -= h)
.StartWithDefault()
.Select(() => moduleCatalog.Modules.Select(x => new PrismModuleStatus(x)).ToArray())
.DistinctUntilChanged()
.Subscribe(
items =>
{
moduleList.Clear();
moduleList.AddRange(items);
})
.AddTo(Anchors);
allModulesLoaded = modules.ToObservableChangeSet()
.Select(() => modules.Any() && modules.All(x => x.IsLoaded))
.ToPropertyHelper(this, x => x.AllModulesLoaded)
.AddTo(Anchors);
LoadModuleCommand = CommandWrapper.Create<PrismModuleStatus>(LoadModuleCommandExecuted, LoadModuleCommandCanExecute);
}
void IAttachedListBox.Receive(ListBox selector)
{
_selector = selector;
var dataSource = ((ReadOnlyObservableCollection <LineProxy>)selector.ItemsSource)
.ToObservableChangeSet()
.Publish();
//Re-select any selected items which are scrolled back into view
var itemsAdded = dataSource.WhereReasonsAre(ListChangeReason.Add, ListChangeReason.AddRange)
.Subscribe(changes =>
{
var alreadySelected = _selected.Items.ToArray();
var newItems = changes.Flatten().Select(c => c.Current).ToArray();
foreach (var item in newItems)
{
if (alreadySelected.Contains(item) && !_selector.SelectedItems.Contains(item))
{
_selector.SelectedItems.Add(item);
}
}
});
//monitor items which have moved off screen [store these for off screen multi-select]
var itemsRemoved = dataSource.WhereReasonsAre(ListChangeReason.Remove, ListChangeReason.RemoveRange, ListChangeReason.Clear)
.Subscribe(changes =>
{
var oldItems = changes.Flatten().Select(c => c.Current).ToArray();
//edit ensures items are added in 1 batch
_recentlyRemovedFromVisibleRange.Edit(innerList =>
{
foreach (var item in oldItems.Where(item => !innerList.Contains(item)))
{
innerList.Add(item);
}
});
});
//clear selection when the mouse is clicked and no other key is pressed
var mouseDown = Observable.FromEventPattern <MouseButtonEventHandler, MouseButtonEventArgs>(
h => selector.PreviewMouseLeftButtonDown += h,
h => selector.PreviewMouseLeftButtonDown -= h)
.Select(evt => evt.EventArgs)
.Subscribe(mouseArgs =>
{
var isKeyDown = (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl) ||
Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightCtrl));
if (!isKeyDown)
{
_selected.Clear();
}
});
var mouseUpHandler = Observable.FromEventPattern <MouseButtonEventHandler, MouseButtonEventArgs>(
h => selector.PreviewMouseLeftButtonUp += h,
h => selector.PreviewMouseLeftButtonUp -= h)
.Select(x => MouseKeyState.Up);
var selectedChanged = Observable
.FromEventPattern <SelectionChangedEventHandler, SelectionChangedEventArgs>(
h => selector.SelectionChanged += h,
h => selector.SelectionChanged -= h)
.Select(evt => evt.EventArgs);
//Handle selecting multiple rows with the mouse
// TODO: Scroll up when the mouse it at the top of the screen
var mouseDragSelector = selectedChanged
.Scan(new ImmutableList <LineProxy>(), (state, latest) =>
{
return(state.Add(latest.AddedItems.OfType <LineProxy>().ToList()));
}).Select(list => list.Data.Distinct().ToArray())
.TakeUntil(mouseUpHandler)
.Repeat()
.Where(selection => selection.Length > 0)
.Subscribe(selection =>
{
var first = selection.OrderBy(proxy => proxy.Start).First();
var last = selection.OrderBy(proxy => proxy.Start).Last();
var fromCurrentPage = _selector.Items.OfType <LineProxy>()
.Where(lp => lp.Start >= first.Start && lp.Start <= last.Start)
.ToArray();
foreach (var item in fromCurrentPage)
{
_selector.SelectedItems.Add(item);
}
_logger.Debug($"{selection.Length} selected. Page={fromCurrentPage.Length}");
});
var selectionChanged = selectedChanged.Subscribe(OnSelectedItemsChanged);
_controlSubscriber.Disposable = new CompositeDisposable(mouseDown, mouseDragSelector, selectionChanged, itemsAdded, itemsRemoved, dataSource.Connect());
}
private void OnSelectedItemsChanged(SelectionChangedEventArgs args)
{
//Logic - by default when items scroll out of view they are no longer selected.
//this is because the panel is virtualised and and automatically unselected due
//to the control thinking that the item is not longer part of the overall collection
if (_isSelecting)
{
return;
}
try
{
_isSelecting = true;
_selected.Edit(innerList =>
{
var toAdd = args.AddedItems.OfType <LineProxy>().ToList();
//may need to track if last selected is off the page:
var isShiftKeyDown = Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift);
//get the last item at then end of the list
if (!isShiftKeyDown)
{
//if mouse down, we need to prevent items being cleated
//add items to list
foreach (var lineProxy in toAdd)
{
if (innerList.Contains(lineProxy))
{
continue;
}
_lastSelected = lineProxy;
innerList.Add(lineProxy);
}
}
else
{
//if shift down we need to override selected and manually select our selves
var last = _lastSelected.Index;
var allSelectedItems = _selector.SelectedItems.OfType <LineProxy>().ToArray();
var currentPage = _selector.Items.OfType <LineProxy>().ToArray();
//1. Determine whether all selected items are on the current page [plus whether last is on the current page]
var allOnCurrentPage = allSelectedItems.Intersect(currentPage).ToArray();
var lastInONcurrentPage = currentPage.Contains(_lastSelected);
if (lastInONcurrentPage && allOnCurrentPage.Length == allSelectedItems.Length)
{
innerList.Clear();
innerList.AddRange(allSelectedItems);
return;
}
args.Handled = true;
var maxOfRecent = toAdd.Max(lp => lp.Index);
int min;
int max;
if (last < maxOfRecent)
{
min = last;
max = maxOfRecent;
}
else
{
min = maxOfRecent;
max = last;
}
//maintain selection
_selector.SelectedItems.Clear();
var fromCurrentPage = _selector.Items.OfType <LineProxy>()
.Where(lp => lp.Index >= min && lp.Index <= max)
.ToArray();
var fromPrevious = _recentlyRemovedFromVisibleRange
.Items.Where(lp => lp.Index >= min && lp.Index <= max)
.ToArray();
_recentlyRemovedFromVisibleRange.Clear();
//maintain our record
innerList.Clear();
innerList.AddRange(fromCurrentPage);
foreach (var previous in fromPrevious)
{
if (!innerList.Contains(previous))
{
innerList.Add(previous);
}
}
//finally reload the actual selection:
foreach (var item in innerList)
{
_selector.SelectedItems.Add(item);
}
}
});
}
catch (Exception ex)
{
_logger.Error(ex, "There has been a problem with manual selection");
}
finally
{
_isSelecting = false;
}
}
private void ClearAllSelections()
{
_selected.Clear();
_recentlyRemovedFromVisibleRange.Clear();
_lastSelected = null;
}
