Esempio n. 1
0
        public IEnumerable GetItemsSource()
        {
            var baseItemsSource = _decoratedItemsSourceBridge.GetItemsSource() ?? Enumerable.Empty <object>();

            if (!IsGenericEnumerable(baseItemsSource))
            {
                foreach (var item in baseItemsSource)
                {
                    yield return(item);
                }
                yield break;
            }

            var genericEnumerableArgumentType = GetEnumerableGenericArgumentType(baseItemsSource);

            if (genericEnumerableArgumentType != typeof(MvxGroupedData) && GroupedDataConverter == null) // sorry, no grouping support!
            {
                foreach (var item in baseItemsSource)
                {
                    yield return(item);
                }
                yield break;
            }

            IMvxGroupedDataConverter groupedDataConverter =
                genericEnumerableArgumentType == typeof(MvxGroupedData) ? new MvxDefaultGroupedDataConverter() : GroupedDataConverter;

            _groupedItemsConverter.Initialize(baseItemsSource, groupedDataConverter);

            foreach (var groupedItemRow in _groupedItemsConverter.Source)
            {
                yield return(groupedItemRow);
            }
        }
Esempio n. 2
0
        public void Initialize(IEnumerable groupedItems, IMvxGroupedDataConverter groupedDataConverter)
        {
            _observableItemsSource.Clear();
            foreach (var disposables in _collectionChangedDisposables)
            {
                disposables.Dispose();
            }
            _collectionChangedDisposables.Clear();

            foreach (var mvxGroupable in groupedItems.Cast <object>().Select(groupedDataConverter.ConvertToMvxGroupedData))
            {
                _observableItemsSource.Add(mvxGroupable);
                foreach (var child in mvxGroupable.Items)
                {
                    _observableItemsSource.Add(child);
                }
            }

            var observableGroups = groupedItems as INotifyCollectionChanged;

            if (observableGroups != null)
            {
                var observableGroupsDisposeSubscription =
                    observableGroups.WeakSubscribe(
                        (sender, args) =>
                {
                    switch (args.Action)
                    {
                    case NotifyCollectionChangedAction.Reset:
                        _observableItemsSource.Clear();
                        break;

                    case NotifyCollectionChangedAction.Add:
                        foreach (var item in Enumerable.Cast <object>(args.NewItems))
                        {
                            _observableItemsSource.Add(groupedDataConverter.ConvertToMvxGroupedData(item));
                        }
                        break;

                    case NotifyCollectionChangedAction.Remove:
                        foreach (var item in Enumerable.Cast <object>(args.OldItems))
                        {
                            var mvxGroupedData = groupedDataConverter.ConvertToMvxGroupedData(item);
                            _observableItemsSource.Remove(mvxGroupedData);
                            foreach (var childItem in mvxGroupedData.Items)
                            {
                                _observableItemsSource.Remove(childItem);
                            }
                        }
                        break;

                    default:
                        throw new InvalidOperationException("No move/replace in Grouped Items yet...");
                    }
                });
                _collectionChangedDisposables.Add(observableGroupsDisposeSubscription);
            }
        }