static bool ShouldActivateInput(RayEventData eventData, GameObject currentObject, out bool hasScrollHandler)
{
hasScrollHandler = false;
var selectionFlags = currentObject.GetComponent <ISelectionFlags>();
if (selectionFlags != null && selectionFlags.selectionFlags == SelectionFlags.Direct && !UIUtils.IsDirectEvent(eventData))
{
return(false);
}
hasScrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(currentObject);
return(ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentObject) ||
ExecuteEvents.GetEventHandler <IPointerDownHandler>(currentObject) ||
ExecuteEvents.GetEventHandler <IPointerUpHandler>(currentObject)
|| ExecuteEvents.GetEventHandler <IDragHandler>(currentObject) ||
ExecuteEvents.GetEventHandler <IBeginDragHandler>(currentObject) ||
ExecuteEvents.GetEventHandler <IEndDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler <IRayDragHandler>(currentObject) ||
ExecuteEvents.GetEventHandler <IRayBeginDragHandler>(currentObject) ||
ExecuteEvents.GetEventHandler <IRayEndDragHandler>(currentObject)
|| hasScrollHandler);
}
protected override void Awake()
{
base.Awake();
s_LayerMask = LayerMask.GetMask("UI");
m_TempRayEvent = new RayEventData(eventSystem);
}
protected override void Awake()
{
base.Awake();
s_LayerMask = LayerMask.GetMask("UI");
m_TempRayEvent = new RayEventData(eventSystem);
InputUtils.GetBindingDictionaryFromActionMap(m_UIActionMap, m_Controls);
}
public void OnDragStarted(GameObject gameObject, RayEventData eventData)
{
var droppable = ComponentUtils <IDroppable> .GetComponent(gameObject);
if (droppable != null)
{
m_Droppables[eventData.rayOrigin] = droppable;
}
}
public void OnDragStarted(GameObject gameObject, RayEventData eventData)
{
var droppable = gameObject.GetComponent <IDroppable>();
if (droppable != null)
{
SetCurrentDropObject(eventData.rayOrigin, droppable.GetDropObject());
}
}
public void OnRayExited(GameObject gameObject, RayEventData eventData)
{
var tooltip = gameObject.GetComponent <ITooltip>();
if (tooltip != null)
{
HideTooltip(tooltip);
}
}
protected override void Awake()
{
base.Awake();
s_LayerMask = LayerMask.GetMask("UI");
m_TempRayEvent = new RayEventData(eventSystem);
IBlockUIInteractionMethods.setUIBlockedForRayOrigin = SetUIBlockedForRayOrigin;
}
public void OnRayExited(GameObject gameObject, RayEventData eventData)
{
if (gameObject && gameObject != this.gameObject)
{
k_TooltipList.Clear();
gameObject.GetComponents(k_TooltipList);
foreach (var tooltip in k_TooltipList)
{
HideTooltip(tooltip);
}
}
}
public void OnRayHovering(GameObject gameObject, RayEventData eventData)
{
if (gameObject == this.gameObject)
{
return;
}
var tooltip = gameObject.GetComponent <ITooltip>();
if (tooltip != null)
{
ShowTooltip(tooltip);
}
}
public void OnRayEntered(GameObject gameObject, RayEventData eventData)
{
var dropReceiver = gameObject.GetComponent <IDropReceiver>();
if (dropReceiver != null)
{
if (dropReceiver.CanDrop(GetCurrentDropObject(eventData.rayOrigin)))
{
dropReceiver.OnDropHoverStarted();
m_HoverObjects[eventData.rayOrigin] = gameObject;
SetCurrentDropReceiver(eventData.rayOrigin, dropReceiver);
}
}
}
public void OnRayHovering(GameObject gameObject, RayEventData eventData)
{
if (gameObject == this.gameObject)
{
return;
}
k_TooltipList.Clear();
gameObject.GetComponents(k_TooltipList);
foreach (var tooltip in k_TooltipList)
{
ShowTooltip(tooltip);
}
}
RayEventData GetTempEventDataClone(RayEventData eventData)
{
var clone = m_TempRayEvent;
clone.rayOrigin = eventData.rayOrigin;
clone.node = eventData.node;
clone.hovered.Clear();
clone.hovered.AddRange(eventData.hovered);
clone.pointerEnter = eventData.pointerEnter;
clone.pointerCurrentRaycast = eventData.pointerCurrentRaycast;
clone.pointerLength = eventData.pointerLength;
return(clone);
}
static bool HoveringInteractable(RayEventData eventData, GameObject currentObject, out bool hasScrollHandler)
{
hasScrollHandler = false;
var selectionFlags = ComponentUtils <ISelectionFlags> .GetComponent(currentObject);
if (selectionFlags != null && selectionFlags.selectionFlags == SelectionFlags.Direct && !UIUtils.IsDirectEvent(eventData))
{
return(false);
}
hasScrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(currentObject);
return(ExecuteEvents.GetEventHandler <IEventSystemHandler>(currentObject));
}
public void OnDragEnded(GameObject gameObject, RayEventData eventData)
{
var droppable = gameObject.GetComponent <IDroppable>();
if (droppable != null)
{
var rayOrigin = eventData.rayOrigin;
SetCurrentDropObject(rayOrigin, null);
var dropReceiver = GetCurrentDropReceiver(rayOrigin);
var dropObject = droppable.GetDropObject();
if (dropReceiver != null && dropReceiver.CanDrop(dropObject))
{
dropReceiver.ReceiveDrop(droppable.GetDropObject());
}
}
}
public void OnDragEnded(GameObject gameObject, RayEventData eventData)
{
var droppable = ComponentUtils <IDroppable> .GetComponent(gameObject);
if (droppable != null)
{
var rayOrigin = eventData.rayOrigin;
m_Droppables.Remove(rayOrigin);
var dropReceiver = GetCurrentDropReceiver(rayOrigin);
var dropObject = droppable.GetDropObject();
if (dropReceiver != null && dropReceiver.CanDrop(dropObject))
{
dropReceiver.ReceiveDrop(droppable.GetDropObject());
}
}
}
public void OnRayExited(GameObject gameObject, RayEventData eventData)
{
if (!gameObject)
{
return;
}
var dropReceiver = gameObject.GetComponent <IDropReceiver>();
if (dropReceiver != null)
{
if (m_HoverObjects.Remove(eventData.rayOrigin))
{
dropReceiver.OnDropHoverEnded();
SetCurrentDropReceiver(eventData.rayOrigin, null);
}
}
}
void HandlePointerExitAndEnter(RayEventData eventData, GameObject newEnterTarget)
{
// Cache properties before executing base method, so we can complete additional ray events later
var cachedEventData = GetTempEventDataClone(eventData);
// This will modify the event data (new target will be set)
base.HandlePointerExitAndEnter(eventData, newEnterTarget);
if (newEnterTarget == null || cachedEventData.pointerEnter == null)
{
for (var i = 0; i < cachedEventData.hovered.Count; ++i)
{
var hovered = cachedEventData.hovered[i];
ExecuteEvents.Execute(hovered, eventData, ExecuteRayEvents.rayExitHandler);
if (rayExited != null)
{
rayExited(hovered, eventData);
}
}
if (newEnterTarget == null)
{
return;
}
}
Transform t = null;
// if we have not changed hover target
if (cachedEventData.pointerEnter == newEnterTarget && newEnterTarget)
{
t = newEnterTarget.transform;
while (t != null)
{
ExecuteEvents.Execute(t.gameObject, cachedEventData, ExecuteRayEvents.rayHoverHandler);
t = t.parent;
}
return;
}
GameObject commonRoot = FindCommonRoot(cachedEventData.pointerEnter, newEnterTarget);
// and we already an entered object from last time
if (cachedEventData.pointerEnter != null)
{
// send exit handler call to all elements in the chain
// until we reach the new target, or null!
t = cachedEventData.pointerEnter.transform;
while (t != null)
{
// if we reach the common root break out!
if (commonRoot != null && commonRoot.transform == t)
{
break;
}
ExecuteEvents.Execute(t.gameObject, cachedEventData, ExecuteRayEvents.rayExitHandler);
if (rayExited != null)
{
rayExited(t.gameObject, cachedEventData);
}
t = t.parent;
}
}
// now issue the enter call up to but not including the common root
cachedEventData.pointerEnter = newEnterTarget;
t = newEnterTarget.transform;
while (t != null && t.gameObject != commonRoot)
{
ExecuteEvents.Execute(t.gameObject, cachedEventData, ExecuteRayEvents.rayEnterHandler);
if (rayEntered != null)
{
rayEntered(t.gameObject, cachedEventData);
}
t = t.parent;
}
}
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl)
{
if (!(rayOrigin.gameObject.activeSelf || draggedObject) || !proxy.active)
{
return;
}
var preProcessRaycastSource = m_Owner.preProcessRaycastSource;
if (preProcessRaycastSource != null)
{
preProcessRaycastSource(rayOrigin);
}
if (eventData == null)
{
eventData = new RayEventData(m_Owner.eventSystem);
}
hoveredObject = m_Owner.GetRayIntersection(this); // Check all currently running raycasters
eventData.node = node;
eventData.rayOrigin = rayOrigin;
eventData.pointerLength = m_Owner.GetPointerLength(eventData.rayOrigin);
var uiActions = (UIActions)input;
var select = uiActions.select;
if (isValid != null && !isValid(this))
{
var currentRaycast = eventData.pointerCurrentRaycast;
currentRaycast.gameObject = null;
eventData.pointerCurrentRaycast = currentRaycast;
hoveredObject = null;
m_Owner.HandlePointerExitAndEnter(eventData, null, true); // Send only exit events
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
HideScrollFeedback();
return;
}
m_Owner.HandlePointerExitAndEnter(eventData, hoveredObject); // Send enter and exit events
var hasScrollHandler = false;
var hasInteractable = hasObject && HoveringInteractable(eventData, currentObject, out hasScrollHandler);
// Proceed only if pointer is interacting with something
if (!hasInteractable)
{
// If we have an object, the ray is blocked--input should not bleed through
if (hasObject && select.wasJustPressed)
{
consumeControl(select);
}
HideScrollFeedback();
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
return;
}
// Send select pressed and released events
if (select.wasJustPressed)
{
m_Owner.OnSelectPressed(this);
consumeControl(select);
}
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
// Send Drag Events
if (draggedObject != null)
{
ExecuteEvents.Execute(draggedObject, eventData, ExecuteEvents.dragHandler);
ExecuteEvents.Execute(draggedObject, eventData, ExecuteRayEvents.dragHandler);
}
// Send scroll events
if (currentObject && hasScrollHandler)
{
var verticalScroll = uiActions.verticalScroll;
var horizontalScroll = uiActions.horizontalScroll;
var verticalScrollValue = verticalScroll.value;
var horizontalScrollValue = horizontalScroll.value;
if (!Mathf.Approximately(verticalScrollValue, 0f) || !Mathf.Approximately(horizontalScrollValue, 0f))
{
consumeControl(verticalScroll);
consumeControl(horizontalScroll);
eventData.scrollDelta = new Vector2(horizontalScrollValue, verticalScrollValue);
ExecuteEvents.ExecuteHierarchy(currentObject, eventData, ExecuteEvents.scrollHandler);
}
if (m_ScrollFeedback.Count == 0)
{
ShowScrollFeedback();
}
}
}
