/// <summary>
/// Initializes a new instance of the <see cref="SelectableCollectionSelector{T}"/> class.
/// </summary>
/// <param name="items">The source items.</param>
public SelectableCollectionSelector(IReadOnlyObservableList <T> items) : base(items)
{
foreach (var selectableItem in Items)
{
SelectionChangedEventManager.AddListener(selectableItem, this);
}
}
public void SetSource([NotNull] IReadOnlyObservableList <TFrom> newSource)
{
if (newSource == null)
{
throw new ArgumentNullException(nameof(newSource));
}
using (_targetItems.EnterMassUpdate())
{
if (_sourceItems != null)
{
_sourceItems.CollectionChanged -= SourceItemsOnCollectionChanged;
if (_sourceItems is IDisposable disposable)
{
disposable.Dispose();
}
}
_sourceItems = newSource;
_sourceItems.CollectionChanged += SourceItemsOnCollectionChanged;
_targetItems.Clear();
_lookup.Clear();
AddNewItems(newSource);
}
}
public MainViewModel()
{
LiveLinqQueryResult = Source
.ToLiveLinq()
.Select(vm => vm.Name.Select(str => string.Join(string.Empty, str.Reverse())))
.ToReadOnlyObservableList();
AddCommand.Subscribe(_ => Add());
}
/// <summary>
/// Initializes a new instance of the <see cref="CollectionSelector{T}" /> class.
/// </summary>
/// <param name="items">The source items.</param>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="items" /> is <strong>null</strong>.</exception>
public CollectionSelector(IReadOnlyObservableList <T> items)
{
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
Items = items;
CollectionChangedEventManager.AddListener(Items, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionalSwitchableListSource{T}"/> class.
/// </summary>
/// <param name="condition">The condition.</param>
/// <param name="positiveSource">The positive source.</param>
/// <param name="negativeSource">The negative source.</param>
public ConditionalSwitchableListSource(IObservable <bool> condition,
IReadOnlyObservableList <T> positiveSource, IReadOnlyObservableList <T> negativeSource)
{
_condition = condition ?? throw new ArgumentNullException(nameof(condition));
_positiveSource = positiveSource;
_negativeSource = negativeSource;
_subscription = condition.Subscribe(this);
}
private void _SubscribeChangedEvents(IReadOnlyObservableList <MappingMonitor.MappingModel> projModels)
{
foreach (var entry in projModels)
{
entry.PropertyChanged -= MappingModel_PropertyChanged;
entry.PropertyChanged += MappingModel_PropertyChanged;
}
projModels.CollectionChanged -= MappingModelTables_CollectionChanged;
projModels.CollectionChanged += MappingModelTables_CollectionChanged;
}
public ProjectionManager(RootView rootView, ISubscribableRouter subscribableRouter)
{
_rootView = rootView;
_views = new MessagingTracker <IView>(subscribableRouter);
_sceneRoots = new ObservableList <ISceneNodeComponent>();
SceneRoots = new ReadOnlyObservableList <ISceneNodeComponent>(_sceneRoots);
subscribableRouter.Add <ICompositionMessage <ISceneNodeComponent> >(Interpret);
subscribableRouter.Add <IDecompositionMessage <ISceneNodeComponent> >(Interpret);
}
protected override string FormatValue(IReadOnlyObservableList <DataObjectViewModel> value)
{
if (value.Count == 0)
{
return(BaseObjectCollectionViewModelResources.NoItems);
}
if (value.Count == 1)
{
return(string.Format(BaseObjectCollectionViewModelResources.OneItem, value[0].Name));
}
return(string.Format(BaseObjectCollectionViewModelResources.MoreItems, value.Count, value[0].Name));
}
public TrackingCollection(
[CanBeNull] IReadOnlyObservableList <TFrom> sourceItems,
[NotNull] Func <TFrom, TTo> createTargetItemFunc)
{
_sourceItems = sourceItems;
_createTargetItemFunc = createTargetItemFunc ?? throw new ArgumentNullException(nameof(createTargetItemFunc));
_targetItemsWrapper = new ReadOnlyObservableCollectionWrapper <TTo, TTo>(_targetItems);
if (sourceItems != null)
{
SetSource(sourceItems);
}
}
public void SetSource(IReadOnlyObservableList <T> newInner)
{
if (_inner != null)
{
_inner.PropertyChanged -= InnerOnPropertyChanged;
_inner.CollectionChanged -= InnerCollectionChanged;
}
_inner = newInner;
newInner.PropertyChanged += InnerOnPropertyChanged;
newInner.CollectionChanged += InnerCollectionChanged;
CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
protected override NotifyCollectionChangedEventArgs BuildCompositeEventArgs(IReadOnlyObservableList <T> sender, NotifyCollectionChangedEventArgs e)
{
int GetSenderStartIndex() => ObservableCollections.TakeWhile(x => x != sender).Sum(x => x.Count);
int GetNewItemsIndex() => GetSenderStartIndex() + (e.NewStartingIndex >= 0 ? e.NewStartingIndex : throw new InvalidOperationException());
int GetOldItemsIndex() => GetSenderStartIndex() + (e.OldStartingIndex >= 0 ? e.OldStartingIndex : throw new InvalidOperationException());
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
{
return(CollectionChangedEventArgs.InsertRange(e.NewItems, GetNewItemsIndex()));
}
case NotifyCollectionChangedAction.Remove:
{
return(CollectionChangedEventArgs.RemoveRange(e.OldItems, GetOldItemsIndex()));
}
case NotifyCollectionChangedAction.Replace:
{
return(CollectionChangedEventArgs.ReplaceRange(e.OldItems, e.NewItems, GetOldItemsIndex()));
}
case NotifyCollectionChangedAction.Move:
{
return(CollectionChangedEventArgs.MoveRange(e.OldItems, GetOldItemsIndex(), GetNewItemsIndex()));
}
case NotifyCollectionChangedAction.Reset:
{
if (sender.Count == Count)
{
return(CollectionChangedEventArgs.Clear());
}
return(CollectionChangedEventArgs.RemoveRange(sender.ToList(), GetSenderStartIndex()));
}
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CastingReadOnlyObservableList{TSource, TTarget}"/> class.
/// </summary>
/// <param name="source">The source.</param>
public CastingReadOnlyObservableList(IReadOnlyObservableList <TSource> source) : base(source, nameof(Count), "Item[]")
{
_source = source;
}
/// <summary>
/// Initializes a new instance of the <see cref="TransactionalReadOnyObservableList{T}" /> class.
/// </summary>
/// <param name="source">The source.</param>
public TransactionalReadOnyObservableList(IReadOnlyObservableList <T> source) : base(source)
{
}
protected override void SetValueToModel(IReadOnlyObservableList <CompoundObjectViewModel> value)
{
throw new NotSupportedException();
}
public MirroredBindableList(IReadOnlyObservableList <TSource> source, Func <TSource, TTarget> sourceToTarget, Func <TTarget, TSource> targetToSource)
: this((IEnumerable <TSource>)source, sourceToTarget, targetToSource)
{
source.CollectionChanged += OnSourceCollectionChanged;
}
public GuiThreadQueuedReadOnlyObservableList(IReadOnlyObservableList <T> list)
{
_list = list;
_list.PropertyChanged += (s, a) => GuiCallbackQueue.Enqueue(() => GuiPropertyChanged?.Invoke(s, a));
_list.CollectionChanged += (s, a) => GuiCallbackQueue.Enqueue(() => GuiCollectionChanged?.Invoke(s, a));
}
