Exemple #1
0
        protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
        {
            base.PrepareContainerForItemOverride(element, item);

            if (CurrentItem != null && CurrentItem.Equals(item))
            {
                LoadInlineElement();
            }

            Control dataRow = element as Control;

            if (dataRow != null)
            {
                dataRow.MouseLeftButtonUp -= MouseLeftButtonUpEventHandler;
                dataRow.MouseLeftButtonUp += MouseLeftButtonUpEventHandler;

                Button drillDownButton = dataRow.Template.FindName("PART_DrillDownButton", dataRow) as Button;

                if (drillDownButton != null)
                {
                    drillDownButton.Click -= DrillDownButtonClickEventHandler;
                    drillDownButton.Click += DrillDownButtonClickEventHandler;
                }
            }

            if (ItemVirtualized != null)
            {
                ItemVirtualized(this, new ItemVirtualizedEventArgs(element, item));
            }
        }
Exemple #2
0
        public virtual Boolean MoveNext()
        {
            Boolean result;

            if (!Completed)
            {
                if (ProgressQueue.Count > 0)
                {
                    TreeNodeType node = ProgressQueue.Dequeue();

                    foreach (TreeNodeType child in node.Children)
                    {
                        ProgressQueue.Enqueue(child);
                    }

                    CurrentItem = node;
                }
                else // Enumeration is complete.
                {
                    CurrentItem = InvalidItem;
                    Completed   = true;
                }

                result = !CurrentItem.Equals(InvalidItem);
            }
            else
            {
                result = false;
            }

            return(result);
        }
        public virtual Boolean MoveNext()
        {
            Boolean result;

            if (!Completed)
            {
                if (CurrentItem.Equals(InvalidItem) && !Root.Equals(InvalidItem))  // Need to initialize the enumeration.
                {
                    ProgressStack.Clear();

                    ITreeNode <NodeValueType, TreeNodeType> node = Root;
                    while (node.HasChildren)
                    {
                        ProgressStack.Push(new List <TreeNodeType>(node.Children));

                        Int32 index = GetTargetIndex(node.Children);
                        node = node.Children[index];
                    }
                }

                if (ProgressStack.Count > 0)
                {
                    IList <TreeNodeType> nodes = ProgressStack.Peek();

                    while (nodes.Count == 0 && ProgressStack.Count > 0)
                    {
                        ProgressStack.Pop();
                        nodes = ProgressStack.Peek();
                    }

                    if (nodes.Count > 0)
                    {
                        Int32 index = GetTargetIndex(nodes);
                        CurrentItem = nodes[index];

                        nodes.RemoveAt(index);
                    }
                    else // Enumeration is complete.
                    {
                        CurrentItem = InvalidItem;
                        Completed   = true;
                    }
                }

                result = !CurrentItem.Equals(InvalidItem);
            }
            else
            {
                result = false;
            }

            return(result);
        }
Exemple #4
0
    public void Update()
    {
        var preUpdateItem = CurrentItem;

        Sort();

        if (!preUpdateItem.Equals(contents[currentTurn]))
        {
            currentTurn = 0;
            while (!CurrentItem.Equals(preUpdateItem))
            {
                currentTurn++;
            }
        }
    }
Exemple #5
0
    public bool Remove(T target)
    {
        if (target.Equals(CurrentItem))
        {
            return(contents.Remove(target));
        }

        var preRemovalItem = CurrentItem;
        var wasRemoved     = contents.Remove(target);

        if (wasRemoved && !CurrentItem.Equals(preRemovalItem))
        {
            currentTurn--;
        }
        return(wasRemoved);
    }
Exemple #6
0
        /// <summary>
        /// Adds a new item of <typeparamref name="T"/> to the navigation history, and resets the forward history.
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            lock (SyncRoot)
            {
                // Don't add same item twice...
                if (_index >= 0 && CurrentItem.Equals(item))
                {
                    return;
                }

                if (CanGoForward)
                {
                    // Remove excess items.
                    History.RemoveRange(_index + 1, Count - _index - 1);
                }
                History.Add(item);

                _index++;
            }
        }
Exemple #7
0
        public override List <int> ApplyRule(List <int> inputItems, int uniqueItemsCount)
        {
            InputItems  = inputItems;
            OutputItems = new List <int>(InputItems);
            for (int i = 0; i < OutputItems.Count; i++)
            {
                CurrentIndex = i;
                while (i > 0 && i % 2 == 0 && CurrentItem.Equals(OutputItems[CurrentIndex - 2]))
                {
                    int number = NextItem;
                    if (number.Equals(NEGATIVE))
                    {
                        number = GetNextRandomNumber(uniqueItemsCount);
                    }

                    OutputItems[CurrentIndex] = number;
                }
            }

            return(OutputItems);
        }