Наследование: System.Windows.Controls.Primitives.IRecyclingItemContainerGenerator, System.Windows.Controls.Primitives.IItemContainerGenerator, System.Windows.IWeakEventListener
Пример #1
0
        private void CreateItemCollectionAndGenerator()
        { 
            _items = new ItemCollection(this);
 
            // the generator must attach its collection change handler before 
            // the control itself, so that the generator is up-to-date by the
            // time the control tries to use it (bug 892806 et al.) 
            _itemContainerGenerator = new ItemContainerGenerator(this);

            _itemContainerGenerator.ChangeAlternationCount();
 
            ((INotifyCollectionChanged)_items).CollectionChanged += new NotifyCollectionChangedEventHandler(OnItemCollectionChanged);
 
            if (IsInitPending) 
            {
                _items.BeginInit(); 
            }
            else if (IsInitialized)
            {
                _items.BeginInit(); 
                _items.EndInit();
            } 
 
            ((INotifyCollectionChanged)_groupStyle).CollectionChanged += new NotifyCollectionChangedEventHandler(OnGroupStyleChanged);
        } 
Пример #2
0
 private ItemContainerGenerator(ItemContainerGenerator parent, IGeneratorHost host, DependencyObject peer, int level)
 {
     _parent = parent;
     _host = host;
     _peer = peer;
     _level = level;
     OnRefresh();
 }
Пример #3
0
        public VisualCommentsHelper(Dispatcher disp, ItemContainerGenerator gen, Comment placeholder)
        {
            _gen = gen;
            _placeholder = placeholder;

            disp.BeginInvoke(new Action(DeferredFocusSet),
                             System.Windows.Threading.DispatcherPriority.Background, null);
        }
Пример #4
0
        /// <summary>
        /// Selects the tree view item.
        /// </summary>
        /// <param name="owningItemGenerator">The owning item generator.</param>
        /// <param name="dataItem">The data item.</param>
        public static void SelectTreeViewItem(ItemContainerGenerator owningItemGenerator, object dataItem)
        {
            if (owningItemGenerator == null) return;

            var treeViewItem = owningItemGenerator.ContainerFromItem(dataItem) as TreeViewItem;
            if (treeViewItem != null)
            {
                treeViewItem.IsSelected = true;
            }
        }
Пример #5
0
        /// <summary>
        /// Expands the tree view item.
        /// </summary>
        /// <param name="owningItemGenerator">The owning item generator.</param>
        /// <param name="dataItem">The data item.</param>
        /// <returns></returns>
        public static TreeViewItem ExpandTreeViewItem(ItemContainerGenerator owningItemGenerator, object dataItem)
        {
            if (owningItemGenerator == null) return null;

            var treeViewItem = owningItemGenerator.ContainerFromItem(dataItem) as TreeViewItem;
            if (treeViewItem != null)
            {
                treeViewItem.IsExpanded = true;
            }
            return treeViewItem;
        }
Пример #6
0
 private static TreeViewItem ContainerFromItem(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection, object item)
 {
     foreach (object curChildItem in itemCollection)
     {
         TreeViewItem parentContainer = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);
         TreeViewItem containerThatMightContainItem = (TreeViewItem)parentContainer.ItemContainerGenerator.ContainerFromItem(item);
         if (containerThatMightContainItem != null)
             return containerThatMightContainItem;
         TreeViewItem recursionResult = ContainerFromItem(parentContainer.ItemContainerGenerator, parentContainer.Items, item);
         if (recursionResult != null)
             return recursionResult;
     }
     return null;
 }
Пример #7
0
 private static object ItemFromContainer(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection, TreeViewItem container)
 {
     foreach (object curChildItem in itemCollection)
     {
         TreeViewItem parentContainer = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);
         TreeViewItem itemThatMightBelongToContainer = (TreeViewItem)parentContainer.ItemContainerGenerator.ItemFromContainer(container);
         if (itemThatMightBelongToContainer != null)
             return itemThatMightBelongToContainer;
         TreeViewItem recursionResult = ItemFromContainer(parentContainer.ItemContainerGenerator, parentContainer.Items, container) as TreeViewItem;
         if (recursionResult != null)
             return recursionResult;
     }
     return null;
 }
Пример #8
0
		static void ContainerStatusChanged(DataGrid dataGrid, ItemContainerGenerator generator)
		{
			if (generator != null && generator.Status == GeneratorStatus.ContainersGenerated && dataGrid.SelectedItems.Count == 1)
			{
				var row = (DataGridRow)dataGrid.ItemContainerGenerator.ContainerFromItem(dataGrid.SelectedItems[0]);
				if (row != null)
				{
					var cell = DataGridHelper.GetCell(dataGrid, row.GetIndex(), 1);
					if (cell != null)
					{
						SelectCellMethod.Invoke(dataGrid, new object[] { cell, false, false, false });
					}
				}
			}
		}
Пример #9
0
 private static bool Deselect(ItemContainerGenerator itemContainerGenerator)
 {
     if (itemContainerGenerator.Status != GeneratorStatus.ContainersGenerated) return false;
       foreach (object item in itemContainerGenerator.Items)
       {
     TreeViewItem treeViewItem = (TreeViewItem)itemContainerGenerator.ContainerFromItem(item);
     if (treeViewItem.IsSelected)
     {
       treeViewItem.IsSelected = false;
       return true;
     }
     bool retVal = Deselect(treeViewItem.ItemContainerGenerator);
     if (retVal)
       return true;
       }
       return false;
 }
Пример #10
0
        private static object ExpandPathToNodeAndSelectBestMatchRecursively(UIElement treeView, ItemContainerGenerator owningItemGenerator, object currentNodeDataItem, Func<object, IEnumerable> childNodeDataItemSelector, Func<object, string, int, bool> matchPathToNode, string[] pathTokens, int tokenIndex)
        {
            var foundNode = default(object);
            var currentToken = pathTokens[tokenIndex];

            // Check whether this is the node we are looking for.
            if ((matchPathToNode(currentNodeDataItem, currentToken, tokenIndex)))
            {
                // Expand this item before looking at the children. The update layout call is needed because although the
                // item has been expanded, none of the expanded items will have been created, and so calls to the
                // treeViewItem.ItemGenerator will return null until the UI has had a chance to create the child items.
                var currentTreeViewItem = ExpandTreeViewItem(owningItemGenerator, currentNodeDataItem);
                if (treeView != null)
                {
                    treeView.UpdateLayout();
                }

                if (tokenIndex < pathTokens.Length - 1)
                {
                    // Now see if we can continue to match any of the children.
                    var currentChildItemCenerator = currentTreeViewItem == null ? null : currentTreeViewItem.ItemContainerGenerator;
                    var childNodes = childNodeDataItemSelector(currentNodeDataItem);
                    if (childNodes != null)
                    {
                        foreach (var childNode in childNodes)
                        {
                            foundNode = ExpandPathToNodeAndSelectBestMatchRecursively(treeView, currentChildItemCenerator, childNode, childNodeDataItemSelector, matchPathToNode, pathTokens, tokenIndex + 1);
                            if (foundNode != null)
                            {
                                break;
                            }
                        }
                    }
                }

                // This node is a match, but none of the children are (or there are no children). Select this node instead.
                if (foundNode == null)
                {
                    foundNode = currentNodeDataItem;
                    SelectTreeViewItem(owningItemGenerator, currentNodeDataItem);
                }
            }
            return foundNode;
        }
        public void ItemContainerGeneratorBasicTest()
        {
            TestGeneratorHost host = new TestGeneratorHost();
            ItemContainerGenerator generator = new ItemContainerGenerator(host);

            ItemsChangedEventArgs lastChangedArg = null;

            generator.ItemsChanged += (sender, e) => lastChangedArg = e;

            host.View.Add("item1");
            Assert.AreEqual(NotifyCollectionChangedAction.Add, lastChangedArg.Action);
            Assert.AreEqual(0, lastChangedArg.NewStartingIndex);
            Assert.AreEqual(1, lastChangedArg.ItemsCount);
            Assert.AreEqual(0, lastChangedArg.ContainersCount);

            FrameworkElement container1 = generator.Generate(0);
            Assert.IsTrue(host.Containers.ContainsKey("item1"));
            Assert.AreEqual("item1", container1.GetValue(TestGeneratorHost.ItemForItemContainerProperty));

            host.View[0] = "item2";
            Assert.IsFalse(host.Containers.ContainsKey("item1"));
            Assert.IsTrue(host.Containers.ContainsKey("item2"));
            Assert.IsNull(container1.GetValue(TestGeneratorHost.ItemForItemContainerProperty));

            FrameworkElement container2 = generator.Generate(0);
            Assert.IsTrue(host.Containers.ContainsKey("item2"));
            Assert.AreEqual("item2", container2.GetValue(TestGeneratorHost.ItemForItemContainerProperty));

            host.View.Remove("item2");
            Assert.IsFalse(host.Containers.ContainsKey("item2"));
            Assert.IsNull(container2.GetValue(TestGeneratorHost.ItemForItemContainerProperty));

            host.View.Add("item3");
            Assert.IsFalse(host.Containers.ContainsKey("item3"));

            FrameworkElement container3 = generator.Generate(0);
            Assert.IsTrue(host.Containers.ContainsKey("item3"));
            Assert.AreEqual("item3", container3.GetValue(TestGeneratorHost.ItemForItemContainerProperty));

            generator.Dispose();
            Assert.IsFalse(host.Containers.ContainsKey("item3"));
            Assert.IsNull(container3.GetValue(TestGeneratorHost.ItemForItemContainerProperty));
        }
        private void ExpandNextItemInQueueAndSelectIfLastItem(ItemCollection items, ItemContainerGenerator itemContainerGenerator)
        {
            var sampleName = _queueOfIndividualnodesToExpandAndSelectTheLast.Dequeue();
            var sample = items.FirstOrDefault(s => (
                        ((s is Sample) && ((Sample)s).Name == sampleName)
                        || ((s is Group) && ((Group)s).Name == sampleName))
                        );
            if (sample == null)
                return; 
            var container = (TreeViewItem)itemContainerGenerator.ContainerFromItem(sample);

                if (_queueOfIndividualnodesToExpandAndSelectTheLast.Count == 0)
                {
                    container.IsSelected = true;
                }
                else
                {
                    ExpandNextItemInQueueAndSelectIfLastItem(container.Items, container.ItemContainerGenerator);
                }
        }
Пример #13
0
        //-------------------------------------------------------------------
        //
        //  Private Methods
        //
        //-------------------------------------------------------------------

        #region Private Methods

        // apply styles described in View.
        private void ApplyNewView()
        {
            ViewBase newView = View;

            if (newView != null)
            {
                // update default style key of ListView
                DefaultStyleKey = newView.DefaultStyleKey;
            }
            else
            {
                ClearValue(DefaultStyleKeyProperty);
            }

            // Encounter a new view after loaded means user is switching view.
            // Force to regenerate all containers.
            if (IsLoaded)
            {
                ItemContainerGenerator.Refresh();
            }
        }
Пример #14
0
        private void ConnectToGenerator()
        {
            Debug.Assert(_itemContainerGenerator == null, "Attempted to connect to a generator when Panel._itemContainerGenerator is non-null.");

            ItemsControl itemsOwner = ItemsControl.GetItemsOwner(this);
            if (itemsOwner == null)
            {
                // This can happen if IsItemsHost=true, but the panel is not nested in an ItemsControl
                throw new InvalidOperationException(SR.Get(SRID.Panel_ItemsControlNotFound));
            }

            IItemContainerGenerator itemsOwnerGenerator = itemsOwner.ItemContainerGenerator;
            if (itemsOwnerGenerator != null)
            {
                _itemContainerGenerator = itemsOwnerGenerator.GetItemContainerGeneratorForPanel(this);
                if (_itemContainerGenerator != null)
                {
                    _itemContainerGenerator.ItemsChanged += new ItemsChangedEventHandler(OnItemsChanged);
                    ((IItemContainerGenerator)_itemContainerGenerator).RemoveAll();
                }
            }
        }
Пример #15
0
 private static TreeViewItem ContainerFromItem(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection, object item)
 {
     foreach (object curChildItem in itemCollection)
     {
         TreeViewItem parentContainer = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);
         if (parentContainer == null)
         {
             return(null);
         }
         TreeViewItem containerThatMightContainItem = (TreeViewItem)parentContainer.ItemContainerGenerator.ContainerFromItem(item);
         if (containerThatMightContainItem != null)
         {
             return(containerThatMightContainItem);
         }
         TreeViewItem recursionResult = ContainerFromItem(parentContainer.ItemContainerGenerator, parentContainer.Items, item);
         if (recursionResult != null)
         {
             return(recursionResult);
         }
     }
     return(null);
 }
Пример #16
0
 private static object ItemFromContainer(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection, TreeViewItem container)
 {
     foreach (object curChildItem in itemCollection)
     {
         TreeViewItem parentContainer = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);
         if (parentContainer == null)
         {
             return(null);
         }
         TreeViewItem itemThatMightBelongToContainer = (TreeViewItem)parentContainer.ItemContainerGenerator.ItemFromContainer(container);
         if (itemThatMightBelongToContainer != null)
         {
             return(itemThatMightBelongToContainer);
         }
         TreeViewItem recursionResult = ItemFromContainer(parentContainer.ItemContainerGenerator, parentContainer.Items, container) as TreeViewItem;
         if (recursionResult != null)
         {
             return(recursionResult);
         }
     }
     return(null);
 }
Пример #17
0
        private static TreeViewItem FindContainer(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection, Predicate <TreeViewItem> condition)
        {
            foreach (object curChildItem in itemCollection)
            {
                TreeViewItem containerThatMightMeetTheCondition = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);

                if (containerThatMightMeetTheCondition == null)
                {
                    return(null);
                }

                if (condition(containerThatMightMeetTheCondition))
                {
                    return(containerThatMightMeetTheCondition);
                }

                TreeViewItem recursionResult = FindContainer(containerThatMightMeetTheCondition.ItemContainerGenerator, containerThatMightMeetTheCondition.Items, condition);
                if (recursionResult != null)
                {
                    return(recursionResult);
                }
            }
            return(null);
        }
Пример #18
0
        /// <summary>Finds the TreeViewItem from the collection.</summary>
        /// <param name="parentItemContainerGenerator">The parent item container.</param>
        /// <param name="itemCollection">The item collection.</param>
        /// <param name="predicate">The TreeViewItem.</param>
        /// <returns>The TreeViewItem found.</returns>
        static TreeViewItem FindTreeViewItem(
            ItemContainerGenerator parentItemContainerGenerator, 
            ItemCollection itemCollection, 
            Predicate<TreeViewItem> predicate)
        {
            foreach (var trvItem in
                from object item in itemCollection
                select item as TreeViewItem ?? (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(item))
            {
                if (predicate(trvItem))
                {
                    return trvItem;
                }

                TreeViewItem nestedSearchResult = FindTreeViewItem(
                    trvItem.ItemContainerGenerator, trvItem.Items, predicate);
                if (nestedSearchResult != null)
                {
                    return nestedSearchResult;
                }
            }

            return null;
        }
Пример #19
0
        void InvokeItemsChanged(object o, NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
            case NotifyCollectionChangedAction.Add:
                SetLogicalParent(native, e.NewItems);
                break;

            case NotifyCollectionChangedAction.Remove:
                SetLogicalParent(IntPtr.Zero, e.OldItems);
                break;

            case NotifyCollectionChangedAction.Replace:
                SetLogicalParent(IntPtr.Zero, e.OldItems);
                SetLogicalParent(native, e.NewItems);
                break;
            }

            ItemContainerGenerator.OnOwnerItemsItemsChanged(o, e);
            if (!itemsIsDataBound)
            {
                OnItemsChanged(e);
            }
        }
Пример #20
0
 private int ElementIndex(ListBoxItem listItem)
 {
     return(ItemContainerGenerator.IndexFromContainer(listItem));
 }
Пример #21
0
 /// <summary>
 /// Treeview doesn't have a simple clear selection
 /// </summary>
 /// <remarks>
 /// Got this here:
 /// http://stackoverflow.com/questions/676819/wpf-treeview-clear-selection
 /// </remarks>
 private static void ClearTreeViewSelection(ItemCollection items, ItemContainerGenerator containerGenerator)
 {
     if (items != null && containerGenerator != null)
     {
         for (int cntr = 0; cntr < items.Count; cntr++)
         {
             // Can't use item directly, because it could be any UIElement
             TreeViewItem itemContainer = containerGenerator.ContainerFromIndex(cntr) as TreeViewItem;
             if (itemContainer != null)
             {
                 // Recurse
                 ClearTreeViewSelection(itemContainer.Items, itemContainer.ItemContainerGenerator);
                 itemContainer.IsSelected = false;
             }
         }
     }
 }
Пример #22
0
        private static TreeViewItem FindContainer(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection, Predicate<TreeViewItem> condition)
        {
            foreach (object curChildItem in itemCollection)
            {
                TreeViewItem containerThatMightMeetTheCondition = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);

                if (containerThatMightMeetTheCondition == null)
                    return null;

                if (condition(containerThatMightMeetTheCondition))
                    return containerThatMightMeetTheCondition;

                TreeViewItem recursionResult = FindContainer(containerThatMightMeetTheCondition.ItemContainerGenerator, containerThatMightMeetTheCondition.Items, condition);
                if (recursionResult != null)
                    return recursionResult;
            }
            return null;
        }
Пример #23
0
        private static IEnumerable<TreeViewItem> GetTreeViewItems(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection)
        {
            foreach (object curChildItem in itemCollection)
            {
                TreeViewItem container = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);

                if (container != null)
                    yield return container;

                foreach (var treeViewItem in GetTreeViewItems(container.ItemContainerGenerator, container.Items))
                    yield return treeViewItem;
            }
        }
Пример #24
0
            // update container and index with current values
            internal ItemInfo Refresh(ItemContainerGenerator generator)
            {
                if (Container == null && Index < 0)
                {
                    Container = generator.ContainerFromItem(Item);
                }

                if (Index < 0 && Container != null)
                {
                    Index = generator.IndexFromContainer(Container);
                }

                if (Container == null && Index >= 0)
                {
                    Container = generator.ContainerFromIndex(Index);
                }

                if (Container == SentinelContainer && Index >= 0)
                {
                    Container = null;   // caller explicitly wants null container
                }

                return this;
            }
        private static TreeViewItem ContainerFromItem(ItemContainerGenerator parentItemContainerGenerator, ItemCollection itemCollection, object item)
        {
            //todo:needed?
                //if (parentItemContainerGenerator.Status == System.Windows.Controls.Primitives.GeneratorStatus.NotStarted)
                //{
                //    IItemContainerGenerator generator = parentItemContainerGenerator;
                //    GeneratorPosition position = generator.GeneratorPositionFromIndex(0);
                //    using (generator.StartAt(position, GeneratorDirection.Forward, true))
                //    {
                //        foreach (object o in itemCollection)
                //        {
                //            DependencyObject dp = generator.GenerateNext();
                //            generator.PrepareItemContainer(dp);
                //        }
                //    }
                //}
                foreach (object curChildItem in itemCollection)
                {
                    TreeViewItem parentContainer = (TreeViewItem)parentItemContainerGenerator.ContainerFromItem(curChildItem);
                    if (parentContainer != null)
                    {
                        TreeViewItem containerThatMightContainItem = (TreeViewItem)parentContainer.ItemContainerGenerator.ContainerFromItem(item);

                        if (containerThatMightContainItem != null)
                            return containerThatMightContainItem;
                        TreeViewItem recursionResult = ContainerFromItem(parentContainer.ItemContainerGenerator, parentContainer.Items, item);
                        if (recursionResult != null)
                            return recursionResult;
                    }
                }
                return null;
        }
Пример #26
0
        void UseGenerator(ItemContainerGenerator generator) 
        {
            if (generator == _generator) 
                return; 

            if (_generator != null) 
                _generator.PanelChanged -= new EventHandler(OnPanelChanged);

            _generator = generator;
 
            if (_generator != null)
                _generator.PanelChanged += new EventHandler(OnPanelChanged); 
        } 
Пример #27
0
 public BatchGenerator(ItemContainerGenerator factory)
 {
     _factory = factory;
     _factory._isGeneratingBatches = true;
     _factory.SetStatus(GeneratorStatus.GeneratingContainers);
 }
Пример #28
0
        private void CreateItemCollectionAndGenerator()
        {
            _items = new ItemCollection(this);

            // ItemInfos must get adjusted before the generator's change handler is called,
            // so that any new ItemInfos arising from the generator don't get adjusted by mistake
            // (see Win8 690623).
            ((INotifyCollectionChanged)_items).CollectionChanged += new NotifyCollectionChangedEventHandler(OnItemCollectionChanged1);

            // the generator must attach its collection change handler before
            // the control itself, so that the generator is up-to-date by the
            // time the control tries to use it (bug 892806 et al.)
            _itemContainerGenerator = new ItemContainerGenerator(this);

            _itemContainerGenerator.ChangeAlternationCount();

            ((INotifyCollectionChanged)_items).CollectionChanged += new NotifyCollectionChangedEventHandler(OnItemCollectionChanged2);

            if (IsInitPending)
            {
                _items.BeginInit();
            }
            else if (IsInitialized)
            {
                _items.BeginInit();
                _items.EndInit();
            }

            ((INotifyCollectionChanged)_groupStyle).CollectionChanged += new NotifyCollectionChangedEventHandler(OnGroupStyleChanged);
        }
Пример #29
0
 private ItemContainerGenerator(ItemContainerGenerator parent, GroupItem groupItem)
     : this(parent, parent.Host, groupItem, parent.Level + 1)
 {
 }
Пример #30
0
		// Token: 0x06004E0E RID: 19982 RVA: 0x0015FCB8 File Offset: 0x0015DEB8
		internal void PrepareItemContainer(object item, ItemsControl parentItemsControl)
		{
			if (this.Generator == null)
			{
				return;
			}
			if (this._itemsHost != null)
			{
				this._itemsHost.IsItemsHost = true;
			}
			bool flag = parentItemsControl != null && VirtualizingPanel.GetIsVirtualizingWhenGrouping(parentItemsControl);
			if (this.Generator != null)
			{
				if (!flag)
				{
					this.Generator.Release();
				}
				else
				{
					this.Generator.RemoveAllInternal(true);
				}
			}
			ItemContainerGenerator parent = this.Generator.Parent;
			GroupStyle groupStyle = parent.GroupStyle;
			Style style = groupStyle.ContainerStyle;
			if (style == null && groupStyle.ContainerStyleSelector != null)
			{
				style = groupStyle.ContainerStyleSelector.SelectStyle(item, this);
			}
			if (style != null)
			{
				if (!style.TargetType.IsInstanceOfType(this))
				{
					throw new InvalidOperationException(SR.Get("StyleForWrongType", new object[]
					{
						style.TargetType.Name,
						base.GetType().Name
					}));
				}
				base.Style = style;
				base.WriteInternalFlag2(InternalFlags2.IsStyleSetFromGenerator, true);
			}
			if (base.ContentIsItem || !base.HasNonDefaultValue(ContentControl.ContentProperty))
			{
				base.Content = item;
				base.ContentIsItem = true;
			}
			if (!base.HasNonDefaultValue(ContentControl.ContentTemplateProperty))
			{
				base.ContentTemplate = groupStyle.HeaderTemplate;
			}
			if (!base.HasNonDefaultValue(ContentControl.ContentTemplateSelectorProperty))
			{
				base.ContentTemplateSelector = groupStyle.HeaderTemplateSelector;
			}
			if (!base.HasNonDefaultValue(ContentControl.ContentStringFormatProperty))
			{
				base.ContentStringFormat = groupStyle.HeaderStringFormat;
			}
			Helper.ClearVirtualizingElement(this);
			if (flag)
			{
				Helper.SetItemValuesOnContainer(parentItemsControl, this, item);
				if (this._expander != null)
				{
					Helper.SetItemValuesOnContainer(parentItemsControl, this._expander, item);
				}
			}
		}
Пример #31
0
        private TreeViewItem GetTreeViewItem(ItemContainerGenerator containerGenerator, IDataSourceViewModel item)
        {
            var container = (TreeViewItem) containerGenerator.ContainerFromItem(item);
            if (container != null)
                return container;

            foreach (object childItem in containerGenerator.Items)
            {
                var parent = containerGenerator.ContainerFromItem(childItem) as TreeViewItem;
                if (parent == null)
                    continue;

                container = parent.ItemContainerGenerator.ContainerFromItem(item) as TreeViewItem;
                if (container != null)
                    return container;

                container = GetTreeViewItem(parent.ItemContainerGenerator, item);
                if (container != null)
                    return container;
            }
            return null;
        }
Пример #32
0
        //------------------------------------------------------
        //
        // Internal Methods
        //
        //------------------------------------------------------

        internal void PrepareItemContainer(object item, ItemsControl parentItemsControl)
        {
            if (Generator == null)
            {
                return;     // user-declared GroupItem - ignore (
            }
            // If a GroupItem is being recycled set back IsItemsHost
            if (_itemsHost != null)
            {
                _itemsHost.IsItemsHost = true;
            }

            bool isVirtualizingWhenGrouping = (parentItemsControl != null && VirtualizingPanel.GetIsVirtualizingWhenGrouping(parentItemsControl));

            // Release any previous containers. Also ensures Items and GroupStyle are hooked up correctly
            if (Generator != null)
            {
                if (!isVirtualizingWhenGrouping)
                {
                    Generator.Release();
                }
                else
                {
                    Generator.RemoveAllInternal(true /*saveRecycleQueue*/);
                }
            }

            ItemContainerGenerator generator  = Generator.Parent;
            GroupStyle             groupStyle = generator.GroupStyle;

            // apply the container style
            Style style = groupStyle.ContainerStyle;

            // no ContainerStyle set, try ContainerStyleSelector
            if (style == null)
            {
                if (groupStyle.ContainerStyleSelector != null)
                {
                    style = groupStyle.ContainerStyleSelector.SelectStyle(item, this);
                }
            }

            // apply the style, if found
            if (style != null)
            {
                // verify style is appropriate before applying it
                if (!style.TargetType.IsInstanceOfType(this))
                {
                    throw new InvalidOperationException(SR.Get(SRID.StyleForWrongType, style.TargetType.Name, this.GetType().Name));
                }

                this.Style = style;
                this.WriteInternalFlag2(InternalFlags2.IsStyleSetFromGenerator, true);
            }

            // forward the header template information
            if (ContentIsItem || !HasNonDefaultValue(ContentProperty))
            {
                this.Content  = item;
                ContentIsItem = true;
            }
            if (!HasNonDefaultValue(ContentTemplateProperty))
            {
                this.ContentTemplate = groupStyle.HeaderTemplate;
            }
            if (!HasNonDefaultValue(ContentTemplateSelectorProperty))
            {
                this.ContentTemplateSelector = groupStyle.HeaderTemplateSelector;
            }
            if (!HasNonDefaultValue(ContentStringFormatProperty))
            {
                this.ContentStringFormat = groupStyle.HeaderStringFormat;
            }

            //
            // Clear previously cached items sizes
            //
            Helper.ClearVirtualizingElement(this);

            //
            // ItemValueStorage:  restore saved values for this item onto the new container
            //
            if (isVirtualizingWhenGrouping)
            {
                Helper.SetItemValuesOnContainer(parentItemsControl, this, item);

                if (_expander != null)
                {
                    Helper.SetItemValuesOnContainer(parentItemsControl, _expander, item);
                }
            }
        }
Пример #33
0
 private ListBoxItem ElementAt(int index)
 {
     return(ItemContainerGenerator.ContainerFromIndex(index) as ListBoxItem);
 }
Пример #34
0
        void IsDropDownOpenChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            bool open = (bool)e.NewValue;

            if (_popup != null)
            {
                _popup.IsOpen = open;
            }
            if (_dropDownToggle != null)
            {
                _dropDownToggle.IsChecked = open;
            }

            if (open)
            {
                ComboBoxItem t = null;
                FocusedIndex = Items.Count > 0 ? Math.Max(SelectedIndex, 0) : -1;
                if (FocusedIndex > -1)
                {
                    t = ItemContainerGenerator.ContainerFromIndex(FocusedIndex) as ComboBoxItem;
                }

                // If the ItemsPresenter hasn't attached yet 't' will be null.
                // When the itemsPresenter attaches, focus will be set when the
                // item is loaded
                if (t != null)
                {
                    t.Focus();
                }

                LayoutUpdated += UpdatePopupSizeAndPosition;

                OnDropDownOpened(EventArgs.Empty);

                // Raises UIA Event
                AutomationPeer peer = ((ComboBox)sender).AutomationPeer;
                if (peer != null)
                {
                    peer.RaisePropertyChangedEvent(ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty,
                                                   ExpandCollapseState.Collapsed,
                                                   ExpandCollapseState.Expanded);
                }
            }
            else
            {
                Focus();

                LayoutUpdated -= UpdatePopupSizeAndPosition;

                OnDropDownClosed(EventArgs.Empty);

                // Raises UIA Event
                AutomationPeer peer = ((ComboBox)sender).AutomationPeer;
                if (peer != null)
                {
                    peer.RaisePropertyChangedEvent(ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty,
                                                   ExpandCollapseState.Expanded,
                                                   ExpandCollapseState.Collapsed);
                }
            }

            UpdateDisplayedItem(open && SelectedItem is UIElement ? null : SelectedItem);
            UpdateVisualState(true);
        }
Пример #35
0
        /// <summary>
        /// Gets the generated (UI) EnhancedTreeViewItem.
        /// </summary>
        /// <param name="containerGenerator">The ItemContainerGenerator from the "parent".</param>
        /// <param name="item">The (bound) item to get the generated UI Item.</param>
        /// <returns>The generated UI EnhancedTreeViewItem. null if nothing to return.</returns>
        private static EnhancedTreeViewItem ContainerFromItem(ItemContainerGenerator containerGenerator, object item)
        {
            if (containerGenerator != null)
            {
                var container = containerGenerator.ContainerFromItem(item) as EnhancedTreeViewItem;
                if (container != null)
                {
                    return container;
                }
                // Get items from Container through Reflection. This Property is only public in verision > .NET 4.5
                IEnumerable items = containerGenerator.GetPropertyValue("Items") as IEnumerable;
                if (items != null)
                {
                    foreach (var childItem in items)
                    {
                        var parent = containerGenerator.ContainerFromItem(childItem) as EnhancedTreeViewItem;
                        if (parent == null)
                        {
                            continue;
                        }

                        container = parent.ItemContainerGenerator.ContainerFromItem(item) as EnhancedTreeViewItem;
                        if (container != null)
                        {
                            return container;
                        }

                        container = ContainerFromItem(parent.ItemContainerGenerator, item);
                        if (container != null)
                        {
                            return container;
                        }
                    }
                }
            }
            return null;
        }
Пример #36
0
        /// <summary>
        ///     Method which generates the focus trail cell
        ///     if it is not already generated and adds it to 
        ///     the block lists appropriately.
        /// </summary>
        private bool GenerateChildForFocusTrail(
            ItemContainerGenerator generator,
            List<int> realizedColumnIndices,
            List<int> realizedColumnDisplayIndices,
            Size constraint,
            int displayIndex,
            ref int displayIndexListIterator)
        {
            DataGrid dataGrid = ParentDataGrid;
            DataGridColumn column = dataGrid.ColumnFromDisplayIndex(displayIndex);
            if (column.IsVisible)
            {
                int columnIndex = dataGrid.ColumnIndexFromDisplayIndex(displayIndex);

                UIElement child = generator.ContainerFromIndex(columnIndex) as UIElement;
                if (child == null)
                {
                    int childIndex = columnIndex;
                    Size childSize;
                    using (((IItemContainerGenerator)generator).StartAt(IndexToGeneratorPositionForStart(generator, childIndex, out childIndex), GeneratorDirection.Forward, true))
                    {
                        child = GenerateChild(generator, constraint, column, ref childIndex, out childSize);
                    }
                }

                if (child != null && DataGridHelper.TreeHasFocusAndTabStop(child))
                {
                    AddToIndicesListIfNeeded(
                        realizedColumnIndices,
                        realizedColumnDisplayIndices,
                        columnIndex,
                        displayIndex,
                        ref displayIndexListIterator);
                    return true;
                }
            }

            return false;
        }
Пример #37
0
        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
            if (!e.Handled)
            {
                var key = e.Key;
                if (FlowDirection == FlowDirection.RightToLeft)
                {
                    if (key == Key.Left)
                    {
                        key = Key.Right;
                    }
                    else if (key == Key.Right)
                    {
                        key = Key.Left;
                    }
                }

                e.Handled = true;
                switch (key)
                {
                case Key.Escape:
                    IsDropDownOpen = false;
                    break;

                case Key.Enter:
                case Key.Space:
                    if (IsDropDownOpen && FocusedIndex != SelectedIndex)
                    {
                        SelectedIndex  = FocusedIndex;
                        IsDropDownOpen = false;
                    }
                    else
                    {
                        IsDropDownOpen = true;
                    }
                    break;

                case Key.Right:
                case Key.Down:
                    if (IsDropDownOpen)
                    {
                        if (FocusedIndex < Items.Count - 1)
                        {
                            FocusedIndex++;
                            ((Control)ItemContainerGenerator.ContainerFromIndex(FocusedIndex)).Focus();
                        }
                    }
                    else
                    {
                        SelectedIndex = Math.Min(SelectedIndex + 1, Items.Count - 1);
                    }
                    break;

                case Key.Left:
                case Key.Up:
                    if (IsDropDownOpen)
                    {
                        if (FocusedIndex > 0)
                        {
                            FocusedIndex--;
                            ((Control)ItemContainerGenerator.ContainerFromIndex(FocusedIndex)).Focus();
                        }
                    }
                    else if (SelectedIndex != -1)
                    {
                        SelectedIndex = Math.Max(SelectedIndex - 1, 0);
                    }
                    break;

                default:
                    e.Handled = false;
                    break;
                }
            }
            else
            {
                Console.WriteLine("Already handled");
            }
        }
 /// <summary>
 /// Creates a new instance used to queue action for completion or items changes of <see cref="ItemContainerGenerator"/>
 /// </summary>
 /// <param name="generator">The <see cref="ItemContainerGenerator"/> to be used.</param>
 /// <param name="action">The <see cref="System.Action"/> that should be invoked.</param>
 public ItemContainerGeneratorAction(ItemContainerGenerator generator, Action action)
 {
     this.Generator = generator;
     this.Action = action;
 }
Пример #39
0
        void UpdateDisplayedItem(object selectedItem)
        {
            object content;

            // Can't do anything with no content presenter
            if (_contentPresenter == null)
            {
                return;
            }

            // Return the currently displayed object (which is a UIElement)
            // to its original container.
            if (DisplayedItem != null)
            {
                content = _contentPresenter.Content;
                DisplayedItem.Content = content;
                DisplayedItem         = null;
            }
            _contentPresenter.Content = null;

            if (selectedItem == null)
            {
                _contentPresenter.Content         = NothingSelectedFallback;
                _contentPresenter.ContentTemplate = null;
                SelectionBoxItem         = null;
                SelectionBoxItemTemplate = null;
                return;
            }

            // If the currently selected item is a ComboBoxItem (not ListBoxItem!), we
            // display its Content instead of the CBI itself.
            content = selectedItem;
            if (content is ComboBoxItem)
            {
                content = ((ComboBoxItem)content).Content;
            }

            // Only allow DisplayedItem to be non-null if we physically move
            // its content. This will only happen if DisplayedItem == SelectedItem
            DisplayedItem = ItemContainerGenerator.ContainerFromIndex(SelectedIndex) as ComboBoxItem;

            SelectionBoxItem         = content;
            SelectionBoxItemTemplate = ItemTemplate;

            // If displayed item is avaiable, we can get the right template from there. Otherwise
            // we need to create a container, read the template and destroy it.
            if (DisplayedItem != null)
            {
                SelectionBoxItemTemplate = DisplayedItem.ContentTemplate;
                if (content is UIElement)
                {
                    DisplayedItem.Content = null;
                }
                else
                {
                    DisplayedItem = null;
                }
            }
            else
            {
                bool         fresh;
                ComboBoxItem container = ItemContainerGenerator.ContainerFromIndex(SelectedIndex) as ComboBoxItem;
                if (container == null)
                {
                    var index = ItemContainerGenerator.GeneratorPositionFromIndex(SelectedIndex);
                    using (ItemContainerGenerator.StartAt(index, GeneratorDirection.Forward, true))
                        container = ItemContainerGenerator.GenerateNext(out fresh) as ComboBoxItem;
                    ItemContainerGenerator.PrepareItemContainer(container);
                }
                SelectionBoxItemTemplate = container.ContentTemplate;
            }

            _contentPresenter.Content         = SelectionBoxItem;
            _contentPresenter.ContentTemplate = SelectionBoxItemTemplate;
        }
Пример #40
0
            //------------------------------------------------------
            //
            //  Constructors
            //
            //------------------------------------------------------

            internal Generator(ItemContainerGenerator factory, GeneratorPosition position, GeneratorDirection direction, bool allowStartAtRealizedItem)
            {
                _factory = factory;
                _direction = direction;

                _factory.MapChanged += new MapChangedHandler(OnMapChanged);

                _factory.MoveToPosition(position, direction, allowStartAtRealizedItem, ref _cachedState);
                _done = (_factory.ItemsInternal.Count == 0);

                _factory.SetStatus(GeneratorStatus.GeneratingContainers);
            }
Пример #41
0
 /// <summary>
 /// Initializes a new instance of the TreeView class.
 /// </summary>
 public TreeView()
 {
     DefaultStyleKey = typeof(TreeView);
     ItemContainerGenerator = new ItemContainerGenerator(this);
 }
Пример #42
0
 public void SetGenerator(ItemContainerGenerator generator)
 {
     this.Generator = generator;
     generator.ItemsChanged += new ItemsChangedEventHandler(OnItemsChanged);
 }
Пример #43
0
 private static TreeViewItem FindTreeViewItem(ItemContainerGenerator itemContainerGenerator, object dataContext)
 {
     if (itemContainerGenerator.Status != GeneratorStatus.ContainersGenerated) return null;
       if (itemContainerGenerator.Items.Contains(dataContext))
     return (TreeViewItem)itemContainerGenerator.ContainerFromItem(dataContext);
       foreach (object item in itemContainerGenerator.Items)
       {
     TreeViewItem treeViewItem = (TreeViewItem)itemContainerGenerator.ContainerFromItem(item);
     TreeViewItem retVal = FindTreeViewItem(treeViewItem.ItemContainerGenerator, dataContext);
     if (retVal != null)
       return retVal;
       }
       return null;
 }
Пример #44
0
 /// <summary>
 /// Called by ListBoxItem instances when they get focus
 /// </summary>
 /// <param name="listBoxItemNewFocus">ListBoxItem that got focus</param>
 internal override void NotifyListItemGotFocus(ListBoxItem listBoxItemNewFocus)
 {
     // Track the focused index
     _focusedIndex = ItemContainerGenerator.IndexFromContainer(listBoxItemNewFocus);
 }
Пример #45
0
        protected override void OnKeyDown(KeyEventArgs e)
        {
            if (!e.Handled)
            {
                bool handled         = false;
                int  newFocusedIndex = -1;
                switch (e.Key)
                {
                case Key.Space:
                case Key.Enter:
                    if ((Key.Enter != e.Key) || KeyboardNavigation.GetAcceptsReturn(this))
                    {
                        if (ModifierKeys.Alt != (Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Alt)))
                        {
                            // KeyEventArgs.OriginalSource (used by WPF) isn't available in Silverlight; use FocusManager.GetFocusedElement instead
                            ListBoxItem listBoxItem = FocusManager.GetFocusedElement() as ListBoxItem;
                            if (null != listBoxItem)
                            {
                                if ((ModifierKeys.Control == (Keyboard.Modifiers & ModifierKeys.Control)) && listBoxItem.IsSelected)
                                {
                                    SelectedItem = null;
                                }
                                else
                                {
                                    SelectedItem = ItemContainerGenerator.ItemFromContainer(listBoxItem);
                                }
                                handled = true;
                            }
                        }
                    }
                    break;

                case Key.Home:
                    newFocusedIndex = 0;
                    break;

                case Key.End:
                    newFocusedIndex = Items.Count - 1;
                    break;

                case Key.PageUp:
                    newFocusedIndex = NavigateByPage(false);
                    break;

                case Key.PageDown:
                    newFocusedIndex = NavigateByPage(true);
                    break;

                case Key.Left:
                    if (IsVerticalOrientation())
                    {
                        ElementScrollViewerScrollInDirection(Key.Left);
                    }
                    else
                    {
                        newFocusedIndex = _focusedIndex - 1;
                    }
                    break;

                case Key.Up:
                    if (IsVerticalOrientation())
                    {
                        newFocusedIndex = _focusedIndex - 1;
                    }
                    else
                    {
                        ElementScrollViewerScrollInDirection(Key.Up);
                    }
                    break;

                case Key.Right:
                    if (IsVerticalOrientation())
                    {
                        ElementScrollViewerScrollInDirection(Key.Right);
                    }
                    else
                    {
                        newFocusedIndex = _focusedIndex + 1;
                    }
                    break;

                case Key.Down:
                    if (IsVerticalOrientation())
                    {
                        newFocusedIndex = _focusedIndex + 1;
                    }
                    else
                    {
                        ElementScrollViewerScrollInDirection(Key.Down);
                    }
                    break;

                // case Key.Divide:  // Feature only used by SelectionMode.Extended
                // case Key.Oem2:  // Key not supported by Silverlight
                //    break;
                // case Key.Oem5:  // Key not supported by Silverlight
                //     break;
                default:
                    Debug.Assert(!handled);
                    break;
                }
                if ((-1 != newFocusedIndex) &&
                    (-1 != _focusedIndex) &&
                    (newFocusedIndex != _focusedIndex) &&
                    (0 <= newFocusedIndex) &&
                    (newFocusedIndex < Items.Count))
                {
                    // A key press will change the focused ListBoxItem
                    ListBoxItem listBoxItem = (ListBoxItem)ItemContainerGenerator.ContainerFromIndex(newFocusedIndex);
                    Debug.Assert(null != listBoxItem);
                    ScrollIntoView(ItemContainerGenerator.ItemFromContainer(listBoxItem));
                    if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
                    {
                        listBoxItem.Focus();
                    }
                    else
                    {
                        SelectedItem = ItemContainerGenerator.ItemFromContainer(listBoxItem);
                    }
                    handled = true;
                }
                if (handled)
                {
                    e.Handled = true;
                }
            }
        }