Exemplo n.º 1
0
        internal TemplatedItemsList(TemplatedItemsList <TView, TItem> parent, IEnumerable itemSource, TView itemsView, BindableProperty itemTemplateProperty, int windowSize = int.MaxValue)
        {
            if (itemsView == null)
            {
                throw new ArgumentNullException("itemsView");
            }
            if (itemTemplateProperty == null)
            {
                throw new ArgumentNullException("itemTemplateProperty");
            }

            Parent = parent;

            _itemsView = itemsView;
            _itemsView.PropertyChanged += BindableOnPropertyChanged;
            _itemTemplateProperty       = itemTemplateProperty;

            if (itemSource != null)
            {
                ListProxy = new ListProxy(itemSource, windowSize);
                ListProxy.CollectionChanged += OnProxyCollectionChanged;
            }
            else
            {
                ListProxy = new ListProxy(new object[0]);
            }
        }
Exemplo n.º 2
0
        public int GetGroupIndexFromGlobal(int globalIndex, out int leftOver)
        {
            leftOver = 0;

            var index = 0;

            for (var i = 0; i < _groupedItems.Count; i++)
            {
                if (index == globalIndex)
                {
                    return(i);
                }

                TemplatedItemsList <TView, TItem> group = _groupedItems[i];
                int count = group.GetDescendantCount();

                if (index + count >= globalIndex)
                {
                    leftOver = globalIndex - index;
                    return(i);
                }

                index += count + 1;
            }

            return(-1);
        }
Exemplo n.º 3
0
        protected MultiPage()
        {
            _templatedItems = new TemplatedItemsList <MultiPage <T>, T>(this, ItemsSourceProperty, ItemTemplateProperty);
            _templatedItems.CollectionChanged += OnTemplatedItemsChanged;

            _children = new ElementCollection <T>(InternalChildren);
            InternalChildren.CollectionChanged += OnChildrenChanged;
        }
Exemplo n.º 4
0
        static void SetGroup(TItem item, TemplatedItemsList <TView, TItem> group)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            item.SetValue(GroupProperty, group);
        }
Exemplo n.º 5
0
            public string this[int index]
            {
                get
                {
                    TemplatedItemsList <TView, TItem> list = _itemsList._groupedItems[index];
                    AttachList(list);

                    return(list.ShortName);
                }
            }
Exemplo n.º 6
0
        public int IndexOf(TItem item)
        {
            TemplatedItemsList <TView, TItem> group = GetGroup(item);

            if (group != null && group != this)
            {
                return(-1);
            }

            return(GetIndex(item));
        }
Exemplo n.º 7
0
            void AttachList(TemplatedItemsList <TView, TItem> list)
            {
                if (_attachedItems.Contains(list))
                {
                    return;
                }

                list.PropertyChanging += OnChildListPropertyChanging;
                list.PropertyChanged  += OnChildListPropertyChanged;
                _attachedItems.Add(list);
            }
Exemplo n.º 8
0
        TemplatedItemsList <TView, TItem> InsertGrouped(object item, int index)
        {
            var children = item as IEnumerable;

            var groupProxy = new TemplatedItemsList <TView, TItem>(this, children, _itemsView, _itemTemplateProperty);

            if (GroupDisplayBinding != null)
            {
                groupProxy.SetBinding(NameProperty, GroupDisplayBinding.Clone());
            }
            else if (GroupHeaderTemplate == null && item != null)
            {
                groupProxy.Name = item.ToString();
            }

            if (GroupShortNameBinding != null)
            {
                groupProxy.SetBinding(ShortNameProperty, GroupShortNameBinding.Clone());
            }

            groupProxy.BindingContext = item;

            if (GroupHeaderTemplate != null)
            {
                groupProxy.HeaderContent = (TItem)GroupHeaderTemplate.CreateContent(groupProxy.ItemsSource, _itemsView);
                groupProxy.HeaderContent.BindingContext = groupProxy.ItemsSource;
                //groupProxy.HeaderContent.BindingContext = groupProxy;
                //groupProxy.HeaderContent.SetBinding (BindingContextProperty, "ItemsSource");
            }
            else
            {
                // HACK: TemplatedItemsList shouldn't assume what the default is, but it needs
                // to be able to setup bindings. Needs some internal-API tweaking there isn't
                // time for right now.
                groupProxy.HeaderContent = _itemsView.CreateDefault(ListProxy.ProxiedEnumerable);
                groupProxy.HeaderContent.BindingContext = groupProxy;
                groupProxy.HeaderContent.SetBinding(TextCell.TextProperty, "Name");
            }

            SetIndex(groupProxy.HeaderContent, index);
            SetIsGroupHeader(groupProxy.HeaderContent, true);

            _itemsView.SetupContent(groupProxy.HeaderContent, index);

            _templatedObjects.Insert(index, groupProxy.HeaderContent);
            _groupedItems.Insert(index, item, groupProxy);

            groupProxy.CollectionChanged += OnInnerCollectionChanged;

            return(groupProxy);
        }
Exemplo n.º 9
0
        public int GetGlobalIndexForGroup(TemplatedItemsList <TView, TItem> group)
        {
            if (group == null)
            {
                throw new ArgumentNullException("group");
            }

            int groupIndex = _groupedItems.Values.IndexOf(group);

            var index = 0;

            for (var i = 0; i < groupIndex; i++)
            {
                index += _groupedItems[i].GetDescendantCount() + 1;
            }

            return(index);
        }
Exemplo n.º 10
0
        internal void NotifyRowTapped(int groupIndex, int inGroupIndex, Cell cell = null)
        {
            TemplatedItemsList <ItemsView <Cell>, Cell> group = TemplatedItems.GetGroup(groupIndex);

            bool changed = _previousGroupSelected != groupIndex || _previousRowSelected != inGroupIndex;

            _previousRowSelected   = inGroupIndex;
            _previousGroupSelected = groupIndex;
            if (cell == null)
            {
                cell = group[inGroupIndex];
            }

            // Set SelectedItem before any events so we don't override any changes they may have made.
            SetValueCore(SelectedItemProperty, cell.BindingContext, SetValueFlags.ClearOneWayBindings | SetValueFlags.ClearDynamicResource | (changed ? SetValueFlags.RaiseOnEqual : 0));

            cell.OnTapped();

            ItemTapped?.Invoke(this, new ItemTappedEventArgs(group, cell.BindingContext));
        }
Exemplo n.º 11
0
 internal ItemsView()
 {
     TemplatedItems = new TemplatedItemsList <ItemsView <TVisual>, TVisual>(this, ItemsSourceProperty, ItemTemplateProperty);
 }
Exemplo n.º 12
0
        void OnCollectionChangedGrouped(NotifyCollectionChangedEventArgs e)
        {
            if (_groupedItems == null)
            {
                _groupedItems = new OrderedDictionary <object, TemplatedItemsList <TView, TItem> >();
            }

            List <TemplatedItemsList <TView, TItem> > newItems = null, oldItems = null;

            switch (e.Action)
            {
            case NotifyCollectionChangedAction.Add:
                if (e.NewStartingIndex == -1)
                {
                    goto case NotifyCollectionChangedAction.Reset;
                }

                for (int i = e.NewStartingIndex; i < _templatedObjects.Count; i++)
                {
                    SetIndex(_templatedObjects[i], i + e.NewItems.Count);
                }

                newItems = new List <TemplatedItemsList <TView, TItem> >(e.NewItems.Count);

                for (var i = 0; i < e.NewItems.Count; i++)
                {
                    TemplatedItemsList <TView, TItem> converted = InsertGrouped(e.NewItems[i], e.NewStartingIndex + i);
                    newItems.Add(converted);
                }

                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newItems, e.NewStartingIndex));

                break;

            case NotifyCollectionChangedAction.Remove:
                if (e.OldStartingIndex == -1)
                {
                    goto case NotifyCollectionChangedAction.Reset;
                }

                int removeIndex = e.OldStartingIndex;
                for (int i = removeIndex + e.OldItems.Count; i < _templatedObjects.Count; i++)
                {
                    SetIndex(_templatedObjects[i], removeIndex++);
                }

                oldItems = new List <TemplatedItemsList <TView, TItem> >(e.OldItems.Count);
                for (var i = 0; i < e.OldItems.Count; i++)
                {
                    int index = e.OldStartingIndex + i;
                    TemplatedItemsList <TView, TItem> til = _groupedItems[index];
                    til.CollectionChanged -= OnInnerCollectionChanged;
                    oldItems.Add(til);
                    _groupedItems.RemoveAt(index);
                    _templatedObjects.RemoveAt(index);
                    til.Dispose();
                }

                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, oldItems, e.OldStartingIndex));

                break;

            case NotifyCollectionChangedAction.Replace:
                if (e.OldStartingIndex == -1)
                {
                    goto case NotifyCollectionChangedAction.Reset;
                }

                oldItems = new List <TemplatedItemsList <TView, TItem> >(e.OldItems.Count);
                newItems = new List <TemplatedItemsList <TView, TItem> >(e.NewItems.Count);

                for (var i = 0; i < e.OldItems.Count; i++)
                {
                    int index = e.OldStartingIndex + i;

                    TemplatedItemsList <TView, TItem> til = _groupedItems[index];
                    til.CollectionChanged -= OnInnerCollectionChanged;
                    oldItems.Add(til);

                    _groupedItems.RemoveAt(index);
                    _templatedObjects.RemoveAt(index);

                    newItems.Add(InsertGrouped(e.NewItems[i], index));
                    til.Dispose();
                }

                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, newItems, oldItems, e.OldStartingIndex));

                break;

            case NotifyCollectionChangedAction.Move:
                if (e.OldStartingIndex == -1 || e.NewStartingIndex == -1)
                {
                    goto case NotifyCollectionChangedAction.Reset;
                }

                bool movingForward = e.OldStartingIndex < e.NewStartingIndex;

                if (movingForward)
                {
                    int moveIndex = e.OldStartingIndex;
                    for (int i = moveIndex + e.OldItems.Count; i <= e.NewStartingIndex; i++)
                    {
                        SetIndex(_templatedObjects[i], moveIndex++);
                    }
                }
                else
                {
                    for (var i = 0; i < e.OldStartingIndex - e.NewStartingIndex; i++)
                    {
                        TItem item = _templatedObjects[i + e.NewStartingIndex];
                        SetIndex(item, GetIndex(item) + e.OldItems.Count);
                    }
                }

                oldItems = new List <TemplatedItemsList <TView, TItem> >(e.OldItems.Count);

                for (var i = 0; i < e.OldItems.Count; i++)
                {
                    oldItems.Add(_groupedItems[e.OldStartingIndex]);

                    _templatedObjects.RemoveAt(e.OldStartingIndex);
                    _groupedItems.RemoveAt(e.OldStartingIndex);
                }

                int insertIndex = e.NewStartingIndex;
                if (e.OldStartingIndex < e.NewStartingIndex)
                {
                    insertIndex -= e.OldItems.Count - 1;
                }

                for (var i = 0; i < oldItems.Count; i++)
                {
                    TemplatedItemsList <TView, TItem> til = oldItems[i];
                    _templatedObjects.Insert(insertIndex + i, til.HeaderContent);
                    _groupedItems.Insert(insertIndex + i, til.BindingContext, til);
                    SetIndex(til.HeaderContent, insertIndex + i);
                }

                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, oldItems, e.OldStartingIndex, e.NewStartingIndex));

                break;

            case NotifyCollectionChangedAction.Reset:
                GroupedReset();
                break;
            }
        }
Exemplo n.º 13
0
 internal ShortNamesProxy(TemplatedItemsList <TView, TItem> itemsList)
 {
     _itemsList = itemsList;
     _itemsList.CollectionChanged += OnItemsListCollectionChanged;
 }