C# PointerEventData.Use方法代码示例

        /// <summary>
        /// When this slot gets an item dropped on it,
        /// it verifies that it is of the same ItemType.
        /// If so, it adds the item to the slot.If not,
        /// it uses the eventData as the drop was successful.
        /// </summary>
        /// <param name="eventData">The `PointerEventData` of the event</param>
        public override void OnDrop(PointerEventData eventData)
        {
            DraggableItemType itemType = Draggable.DraggedItem.GetComponent<DraggableItemType>();

            if (itemType == null) {
                eventData.Use();
                return;
            }

            if (itemType.ItemType == Type) {
                base.OnDrop(eventData);
            } else {
                eventData.Use();
            }
        }

        public override void OnBeginDrag(PointerEventData eventData)
        {
            if (!interactable)
            {
                return;
            }

            //Debug.Log("OnBeginDrag (isFocused: {0}, isUsed: {1}, delta: {2})".Fmt(isFocused, eventData.used, eventData.delta));

            // Pass event to parent if it is a vertical drag
            if (Mathf.Abs(eventData.delta.y) > Mathf.Abs(eventData.delta.x))
            {
                //Debug.Log("Passing To Parent");

                var parent = transform.parent;

                if (parent != null)
                {
                    eventData.pointerDrag = ExecuteEvents.GetEventHandler<IBeginDragHandler>(parent.gameObject);

                    if (eventData.pointerDrag != null)
                    {
                        ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.beginDragHandler);
                    }
                }

                return;
            }
            eventData.Use();

            _dragStartAmount = double.Parse(text);
            _currentValue = _dragStartAmount;

            var minStep = 1f;

            // Use a larger minimum step for integer numbers, since there are no fractional values
            if (contentType == ContentType.IntegerNumber)
            {
                minStep *= 10;
            }

            _dragStep = Math.Max(minStep, _dragStartAmount*0.05f);

            if (isFocused)
            {
                DeactivateInputField();
            }
        }

        /// <summary>
        /// Raises the end drag event.
        /// </summary>
        /// <param name="eventData">Event data.</param>
        public virtual void OnEndDrag(PointerEventData eventData)
        {
            // Check if a drag was initialized at all
            if (!this.m_DragHasBegan)
                return;

            // Reset the drag begin bool
            this.m_DragHasBegan = false;

            // Destroy the dragged icon object
            if (this.m_CurrentDraggedObject != null)
            {
                Destroy(this.m_CurrentDraggedObject);
            }

            // Reset the variables
            this.m_CurrentDraggedObject = null;
            this.m_CurrentDraggingPlane = null;

            // Use the event
            eventData.Use();

            // Check if we are returning the icon to the same slot
            // By checking if the slot is highlighted
            if (this.IsHighlighted(eventData))
                return;

            // Check if no drop was preformed
            if (!this.m_DropPreformed)
            {
                // Try to throw away the assigned content
                this.OnThrowAway();
            }
            else
            {
                // Reset the drop preformed variable
                this.m_DropPreformed = false;
            }
        }

        /// <summary>
        /// Raises the drop event.
        /// </summary>
        /// <param name="eventData">Event data.</param>
        public virtual void OnDrop(PointerEventData eventData)
        {
            // Get the source slot
            UISlotBase source = (eventData.pointerPress != null) ? eventData.pointerPress.GetComponent<UISlotBase>() : null;

            // Make sure we have the source slot and it's assigned
            if (source == null || !source.IsAssigned())
                return;

            // Notify the source that a drop was performed so it does not unassign
            source.dropPreformed = true;

            // Check if this slot is enabled and it's drag and drop feature is enabled
            if (!this.enabled || !this.m_DragAndDropEnabled)
                return;

            // Prepare a variable indicating whether the assign process was successful
            bool assignSuccess = false;

            // Normal empty slot assignment
            if (!this.IsAssigned())
            {
                // Assign the target slot with the info from the source
                assignSuccess = this.Assign(source);

                // Unassign the source on successful assignment and the source is not static
                if (assignSuccess && !source.isStatic)
                    source.Unassign();
            }
            // The target slot is assigned
            else
            {
                // If the target slot is not static
                // and we have a source slot that is not static
                if (!this.isStatic && !source.isStatic)
                {
                    // Check if we can swap
                    if (this.CanSwapWith(source) && source.CanSwapWith(this))
                    {
                        // Swap the slots
                        assignSuccess = source.PerformSlotSwap(this);
                    }
                }
                // If the target slot is not static
                // and the source slot is a static one
                else if (!this.isStatic && source.isStatic)
                {
                    assignSuccess = this.Assign(source);
                }
            }

            // If this slot failed to be assigned
            if (!assignSuccess)
            {
                this.OnAssignBySlotFailed(source);
            }

            // Use the event
            eventData.Use();
        }

        /// <summary>
        /// Raises the drag event.
        /// </summary>
        /// <param name="eventData">Event data.</param>
        public virtual void OnDrag(PointerEventData eventData)
        {
            // Check if the dragging has been started
            if (this.m_DragHasBegan)
            {
                // Update the dragged object's position
                if (this.m_CurrentDraggedObject != null)
                    this.UpdateDraggedPosition(eventData);

                // Use the event
                eventData.Use();
            }
        }

        /// <summary>
        /// Raises the begin drag event.
        /// </summary>
        /// <param name="eventData">Event data.</param>
        public virtual void OnBeginDrag(PointerEventData eventData)
        {
            if (!this.enabled || !this.IsAssigned() || !this.m_DragAndDropEnabled)
            {
                eventData.Reset();
                return;
            }

            // Check if we have a key modifier and if it's held down
            if (!this.DragKeyModifierIsDown())
            {
                eventData.Reset();
                return;
            }

            // Start the drag
            this.m_DragHasBegan = true;

            // Create the temporary icon for dragging
            this.CreateTemporaryIcon(eventData);

            // Prevent event propagation
            eventData.Use();
        }

        /// <summary>
        /// This event is fired when an item is dropped
        /// onto this slot. Will accept the item
        /// into the slot OR swap the item. If the item is
        /// `Stackable`, will attempt to stack it
        /// </summary>
        /// <param name="eventData">The `PointerEventData` of the event</param>
        public virtual void OnDrop(PointerEventData eventData)
        {
            if (eventData.used || Draggable.DraggedItem == null) {
                return;
            }

            //  if this slot doesn't have an item,
            //  add this one
            if (Item == null) {
                AddItem(Draggable.DraggedItem);
            } else {

                Stackable stackableItem = Draggable.DraggedItem.GetComponent<Items.Stackable>();
                Stackable slotStackableItem = Item.GetComponent<Items.Stackable>();

                //  the dropped item is stackable, as is
                //  the item in this slot. Attempt to stack.
                //  will return if successful.
                if (stackableItem != null && slotStackableItem != null) {
                    try {
                        slotStackableItem.Add(stackableItem);

                        Draggable.DraggedItem.OnEndDrag(eventData);
                        Draggable.DraggedItem = null;

                        //  manually spawn the tooltip as the
                        //  `OnPointerEnter` event won't trigger
                        //  automatically
                        TooltipTrigger tooltipTrigger = Item.GetComponent<TooltipTrigger>();
                        if (tooltipTrigger != null) {
                            tooltipTrigger.OnPointerEnter(
                                new PointerEventData(EventSystem.current)
                            );
                        }

                    //  if the item isn't stackable, swap items
                    } catch (NotStackableException e) {
                        Slot otherSlot = Draggable.DraggedItem.OldSlot;
                        otherSlot.AddItem(RemoveItem());
                        AddItem(Draggable.DraggedItem);

                        Draggable.DraggedItem.OnEndDrag(eventData);
                        Draggable.DraggedItem = null;
                    }
                } else {

                    //  swap the item with the item
                    //  that was dropped
                    Draggable otherItem = Draggable.DraggedItem;
                    Slot otherSlot = otherItem.OldSlot;

                    //  if other slot is currently occupied,
                    //  the draggable item will need to be
                    //  dropped before it can be swapped
                    if (otherSlot.Item != null) {
                        return;
                    }

                    //  try to swap items- will only fail
                    //  if one slot requires a specific
                    //  `ItemType`
                    try {
                        //  don't remove the item from
                        //  this slot until it successfully
                        //  gets added to the other slot
                        Draggable itemInThisSlot = Item;
                        otherSlot.AddItem(itemInThisSlot);

                        RemoveItem();
                        AddItem(otherItem);
                    } catch(CannotAddItemException e) {
                        Debug.LogWarning(e);
                        return;
                    }
                }
            }

            Item.OnEndDrag(eventData);
            eventData.Use();
        }

 /// <summary>
 /// When this stack is clicked, check if the
 /// user is holding down the key modifier. If
 /// so, display the `StackableSplitter` which
 /// allows the user to enter a number to
 /// remove from this stack
 /// </summary>
 /// <param name="eventData">The `PointerEventData` of the event</param>
 public void OnPointerClick(PointerEventData eventData)
 {
     if (Input.GetKey(keyModifier)) {
         StackableSplitterFactory.Create(this);
         eventData.Use();
     }
 }

        public override void OnPointerClick(PointerEventData eventData)
        {
            //Debug.Log("OnPointerClick (isFocused: {0}, isUsed: {1}, isDragging: {2})".Fmt(isFocused, eventData.used, eventData.dragging));

            if (!interactable)
            {
                return;
            }

            if (eventData.dragging)
            {
                return;
            }

            EventSystem.current.SetSelectedGameObject(gameObject, eventData);

            base.OnPointerClick(eventData);

            if ((m_Keyboard == null || !m_Keyboard.active))
            {
                OnSelect(eventData);
            }
            else
            {
                UpdateLabel();
                eventData.Use();
            }
        }

        public override void OnEndDrag(PointerEventData eventData)
        {
            if (!interactable)
            {
                return;
            }

            //Debug.Log("OnEndDrag (isFocused: {0}, isUsed: {1})".Fmt(isFocused, eventData.used));

            //base.OnEndDrag(eventData);

            eventData.Use();

            if (_dragStartAmount != _currentValue)
            {
                DeactivateInputField();
                SendOnSubmit();
            }
        }

		public void OnPointerClick(PointerEventData eventData) {

			ExecuteEvents.Execute<IHeatmapHandler>(eventData.pointerPress, eventData, HeatmapEvents.heatmapHandler);
			eventData.Use();

		}