示例#1
0
        public static void Capture(Control ctrl)
        {
            if (ctrl == null)
                throw new ArgumentNullException();

            capturedCtrl = ctrl;
        }
        /// <summary>
        /// Sets the specified element at the specified index into the child
        /// collection. It also corrects the parent.
        /// Note that the function requires that _item[index] == null and it
        /// also requires that the passed in child is not connected to another UIElement.
        /// </summary>
        /// <exception cref="ArgumentException">If the new child has already a parent or if the slot a the specified index is not null.</exception>
        private void ConnectChild(int index, Control value)
        {
            // Every function that calls this function needs to call VerifyAccess to prevent
            // foreign threads from changing the tree.
            //
            // We also need to ensure that the tree is homogenous with respect
            // to the dispatchers that the elements belong to.
            //
            Debug.Assert(items[index] == null);

            value.Parent = owner;

            // The child might be dirty. Hence we need to propagate dirty information
            // from the parent and from the child.
            //Control.PropagateFlags(_owner, Control.Flags.IsSubtreeDirtyForRender);
            //Control.PropagateFlags(value, Control.Flags.IsSubtreeDirtyForRender);
            //value._flags |= Control.Flags.IsDirtyForRender;
            items[index] = value;
            version++;

            //Control.PropagateResumeLayout(value);

            // Fire notifications
            owner.OnChildrenChanged(value, null /* no removed child */, index);
        }
        /// <summary>
        /// Removes the specified element from the UIElementCollection.
        /// </summary>
        /// <param name="element">The UIElement to remove from the UIElementCollection.</param>
        /// <remarks>
        /// The UIElements that follow the removed UIElements move up to occupy
        /// the vacated spot. The indexes of the UIElements that are moved are
        /// also updated.
        ///
        /// If element is null then the first null entry is removed. Note that removing
        /// a null entry is linear in the size of the collection.
        /// </remarks>
        public void Remove(Control element)
        {
            int indexToRemove = -1;

            if (element != null)
            {
                if (element.Parent != owner)
                {
                    // If the UIElement is not in this collection we silently return without
                    // failing. This is the same behavior that ArrayList implements.
                    return;
                }

                Debug.Assert(element.Parent != null);

                DisconnectChild(indexToRemove = IndexOf(element));
            }
            else
            {
                // This is the case where element == null. We then remove the first null entry.
                for (int i = 0; i < size; i++)
                    if (items[i] == null)
                    {
                        indexToRemove = i;
                        break;
                    }
            }

            if (indexToRemove != -1)
            {
                --size;

                for (int i = indexToRemove; i < size; i++)
                {
                    Control child = items[i + 1];
                    items[i] = child;
                }

                items[size] = null;
            }

            //_owner.InvalidateMeasure();
        }
        /// <summary>
        /// Inserts an element into the UIElementCollection at the specified index.
        /// </summary>
        /// <param name="index">The zero-based index at which value should be inserted.</param>
        /// <param name="element">The UIElement to insert. </param>
        /// <exception cref="ArgumentOutOfRangeException">
        /// index is less than zero.
        ///
        /// -or-
        ///
        /// index is greater than Count.
        /// </exception>
        /// <remarks>
        /// If Count already equals Capacity, the capacity of the
        /// UIElementCollection is increased before the new UIElement
        /// is inserted.
        ///
        /// If index is equal to Count, value is added to the
        /// end of UIElementCollection.
        ///
        /// The UIElements that follow the insertion point move down to
        /// accommodate the new UIElement. The indexes of the UIElements that are
        /// moved are also updated.
        /// </remarks>
        public void Insert(int index, Control element)
        {
            if (index < 0 || index > size)
                throw new ArgumentOutOfRangeException("index");

            if (element == null)
                throw new ArgumentNullException("element");

            if (element.Parent != null)  // or a element target can be added.
                throw new System.ArgumentException("element has parent");

            if ((items == null) || (size == items.Length))
                EnsureCapacity(size + 1);

            for (int i = size - 1; i >= index; i--)
            {
                Control child = items[i];
                items[i + 1] = child;
            }

            items[index] = null;

            size++;
            ConnectChild(index, element);
            // Note SetUIElement that increments the version to ensure proper enumerator
            // functionality.
            //_owner.InvalidateMeasure();
        }
        /// <summary>
        /// Returns the zero-based index of the UIElement. If the UIElement is not
        /// in the UIElementCollection -1 is returned. If null is passed to the method, the index
        /// of the first entry with null is returned. If there is no null entry -1 is returned.
        /// </summary>
        /// <param name="UIElement">The UIElement to locate in the UIElementCollection.</param>
        public int IndexOf(Control element)
        {
            if (element == null || element.Parent == owner)
            {
                for (int i = 0; i < size; i++)
                {
                    if (items[i] == element)
                        return i;
                }

                // not found, return -1
                return -1;
            }
            else
                return -1;
        }
示例#6
0
 internal void OnChildrenChanged(Control added, Control removed, int indexAffected)
 {
     if (added != null)
         added.Invalidate();
     else
         Invalidate();
 }
 public virtual bool Contains(Control child)
 {
     return children.IndexOf(child) != -1;
 }
 public ControlCollection2(Control owner)
 {
     this.owner = owner;
 }
        /// <summary>
        /// Appends a UIElement to the end of the UIElementCollection.
        /// </summary>
        /// <param name="visual">The UIElement to be added to the end of the UIElementCollection.</param>
        /// <returns>The UIElementCollection index at which the UIElement has been added.</returns>
        /// <remarks>Adding a null is allowed.</remarks>
        /// <exception cref="ArgumentException">If the new child has already a parent.</exception>
        public int Add(Control element)
        {
            if (element == null)
                throw new ArgumentNullException("element");

            if (element.Parent != null)
            {
                throw new System.ArgumentException("element has parent");
            }

            if ((items == null) || (size == items.Length))
                EnsureCapacity(size + 1);

            int addedPosition = size++;
            Debug.Assert(items[addedPosition] == null);

            ConnectChild(addedPosition, element);
            version++;

            // invalidate measure on parent
            //_owner.InvalidateMeasure();

            return addedPosition;
        }
示例#10
0
 public RenderTask(Control sender, Rect dirtyArea)
 {
     Sender = sender;
     DirtyArea = dirtyArea;
 }
        /// <summary>
        /// Determines whether a element is in the UIElementCollection.
        /// </summary>
        public bool Contains(Control element)
        {
            if (element == null)
            {
                for (int i = 0; i < _size; i++)
                {
                    if (_items[i] == null)
                    {
                        return true;
                    }
                }

                return false;
            }
            else
            {
                return (element.Parent == _owner);
            }
        }
示例#12
0
        private Control FindTouchTarget(Control root, Point p)
        {
            return root.GetValidChildFromScreenPoint(p);

            if (lastEventTarget != null)
            {
                // old:
                Control target = lastEventTarget.GetValidChildFromScreenPoint(p);
                if (target != null)
                    return target;
                else if (lastEventTarget.ContainsScreenPoint(p))
                    return lastEventTarget;
                else
                {
                    Control par = lastEventTarget.GetValidParentFromScreenPoint(p);
                    return par != null ? par.GetValidChildFromScreenPoint(p) : (root != null ? root.GetValidChildFromScreenPoint(p) : null);
                }

                // new:
                //var par = lastEventTarget.GetValidParentFromScreenPoint(p);
                //return par != null ? par.GetValidChildFromScreenPoint(p) : (root != null ? root.GetValidChildFromScreenPoint(p) : null);
            }
            else
                return root.GetValidChildFromScreenPoint(p);
        }
示例#13
0
        private Control GetTouchTarget(Point p)
        {
            Control result = null;

            //dt = DateTime.Now;
            if (TouchCapture.Captured != null)
                result = TouchCapture.Captured;
            else if (desktop.Children.Contains(cw))
                return cw;
            //else if (modalWindow != null)
            //    res = FindTouchTarget(modalWindow, p);
            else
                result = FindTouchTarget(desktop, p);
            //ts = DateTime.Now - dt;

            lastEventTarget = result;
            return result;
        }
示例#14
0
 public static void ReleaseCapture()
 {
     capturedCtrl = null;
 }
示例#15
0
 internal Enumerator(ControlCollection collection)
 {
     _collection = collection;
     _index = -1; // not started.
     _version = _collection.version;
     _currentElement = null;
 }
示例#16
0
        /// <summary>
        /// Determines whether a element is in the UIElementCollection.
        /// </summary>
        public bool Contains(Control element)
        {
            if (element == null)
            {
                for (int i = 0; i < size; i++)
                    if (items[i] == null)
                        return true;

                return false;
            }
            else
                return (element.Parent == owner);
        }
示例#17
0
 /// <summary>
 /// Advances the enumerator to the next element of the collection.
 /// </summary>
 public bool MoveNext()
 {
     if (_version == _collection.version)
     {
         if ((_index > -2) && (_index < (_collection.size - 1)))
         {
             _index++;
             _currentElement = _collection[_index];
             return true;
         }
         else
         {
             _currentElement = null;
             _index = -2; // -2 <=> reached the end.
             return false;
         }
     }
     else
     {
         throw new InvalidOperationException("collection changed");
     }
 }
示例#18
0
 public ControlCollection(Control owner)
 {
     Debug.Assert(owner != null);
     this.owner = owner;
 }
示例#19
0
 public virtual void Add(Control child)
 {
     child.Parent = owner;
     int idx = children.Add(child);
     owner.OnChildrenChanged(child, null, idx);
 }
示例#20
0
 /// <summary>
 /// Strongly typed version of CopyTo
 /// Copies the collection into the Array.
 /// </summary>
 public virtual void CopyTo(Control[] array, int index)
 {
     CopyTo((Array)array, index);
 }
示例#21
0
 public virtual void Remove(Control child)
 {
     int idx = children.IndexOf(child);
     children.Remove(child);
     child.Parent = null;
     owner.OnChildrenChanged(null, child, idx);
 }
示例#22
0
        public void SetHub(Control page)
        {
            if (hub != null)
            {
                if (hub is Hub)
                    (hub as Hub).Exit();
                Children.Remove(hub);
                //hub.Visible = false;
            }

            hub = page;
            btnHome.Visible = hub != hubHome;

            hub.Visible = true;
            Children.Add(hub);
        }