public void OnMove(AxisEventData eventData)
{
int nTemp = (1 << (int)EventTriggerType.Move);
int nEventMask = (int)this.EventTypeMask;
if ((nEventMask & nTemp) == nTemp)
{
this.Handle(eventData, EventTriggerType.Move);
}
}
public override void OnMove(AxisEventData eventData)
{
if (!IsActive() || !IsInteractable())
{
base.OnMove(eventData);
return;
}
switch (eventData.moveDir)
{
case MoveDirection.Left:
if (axis == Axis.Horizontal && FindSelectableOnLeft() == null)
{
Set(reverseValue ? value + stepSize : value - stepSize);
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Right:
if (axis == Axis.Horizontal && FindSelectableOnRight() == null)
{
Set(reverseValue ? value - stepSize : value + stepSize);
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Up:
if (axis == Axis.Vertical && FindSelectableOnUp() == null)
{
Set(reverseValue ? value - stepSize : value + stepSize);
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Down:
if (axis == Axis.Vertical && FindSelectableOnDown() == null)
{
Set(reverseValue ? value + stepSize : value - stepSize);
}
else
{
base.OnMove(eventData);
}
break;
}
}
/// <summary>
/// Raises the move event.
/// </summary>
/// <param name="eventData">Event data.</param>
public override void OnMove(AxisEventData eventData)
{
if (!IsActive() || !IsInteractable())
{
base.OnMove(eventData);
return;
}
switch (eventData.moveDir)
{
case MoveDirection.Left:
if (IsHorizontal() && FindSelectableOnLeft() == null)
{
Decrease();
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Right:
if (IsHorizontal() && FindSelectableOnRight() == null)
{
Increase();
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Up:
if (!IsHorizontal() && FindSelectableOnUp() == null)
{
Increase();
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Down:
if (!IsHorizontal() && FindSelectableOnDown() == null)
{
Decrease();
}
else
{
base.OnMove(eventData);
}
break;
}
}
public void OnMove(AxisEventData eventData)
{
if (onEventMove != null)
{
onEventMove(eventData);
}
if (onMove != null)
{
onMove(gameObject);
}
}
protected AxisEventData GetAxisEventData(float x, float y, float moveDeadZone)
{
if (this._axisEventData == null)
{
this._axisEventData = new AxisEventData(EventSystem.get_current());
}
((AbstractEventData)this._axisEventData).Reset();
this._axisEventData.set_moveVector(new Vector2(x, y));
this._axisEventData.set_moveDir(Input.DetermineMoveDirection(x, y, moveDeadZone));
return(this._axisEventData);
}
public void OnMove(AxisEventData eventData)
{
if (isTopButtonInMenu == true && eventData.moveVector.y > 0)
{
dialRotateHandler.CheckIfDialTransformRotateNeeded(+1);
}
if (isBottomButtonInMenu == true && eventData.moveVector.y < 0)
{
dialRotateHandler.CheckIfDialTransformRotateNeeded(-1);
}
}
public override void OnMove(AxisEventData eventData)
{
if (OverrideNavigation)
{
OnNavigate.Invoke(eventData);
}
else
{
DoMove(eventData);
}
}
public override void OnMove(AxisEventData eventData)
{
if (this.onMove != null)
{
this.onMove.Call(new object[]
{
base.gameObject,
eventData.moveVector
});
}
}
/// <summary>
/// OnUpdateSelected event.
/// </summary>
/// <param name="eventData">Event data.</param>
public virtual void OnUpdateSelected(BaseEventData eventData)
{
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
var axisEvent = new AxisEventData(EventSystem.current)
{
moveDir = MoveDirection.Left,
};
OnMoveEvent.Invoke(axisEvent);
return;
}
if (Input.GetKeyDown(KeyCode.RightArrow))
{
var axisEvent = new AxisEventData(EventSystem.current)
{
moveDir = MoveDirection.Right,
};
OnMoveEvent.Invoke(axisEvent);
return;
}
if (Input.GetKeyDown(KeyCode.UpArrow))
{
var axisEvent = new AxisEventData(EventSystem.current)
{
moveDir = MoveDirection.Up,
};
OnMoveEvent.Invoke(axisEvent);
return;
}
if (Input.GetKeyDown(KeyCode.DownArrow))
{
var axisEvent = new AxisEventData(EventSystem.current)
{
moveDir = MoveDirection.Down,
};
OnMoveEvent.Invoke(axisEvent);
return;
}
if (Input.GetKeyDown(KeyCode.Tab) || Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.KeypadEnter))
{
var isEnter = Input.GetKey(KeyCode.Return) || Input.GetKey(KeyCode.KeypadEnter);
var isShift = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
if (!(isEnter && isShift))
{
OnSubmitEvent.Invoke(eventData, isEnter);
}
return;
}
}
private static void MoveSelection(MoveDirection dir)
{
EventSystem eventSystem = EventSystem.current;
AxisEventData data = new AxisEventData(eventSystem)
{
moveDir = dir,
selectedObject = eventSystem.currentSelectedGameObject,
};
ExecuteEvents.Execute(data.selectedObject, data, ExecuteEvents.moveHandler);
}
/// <summary>
/// Hack-y solution to allow navigation of multiple UI's with one EventSystem
/// Works for both navigating between objects and setting values on sliders
/// </summary>
/// <param name="direction">Direction to send to the UI navigation system</param>
private void NavigateMenu(MoveDirection direction)
{
eventSystem.SetSelectedGameObject(currentSelected);
AxisEventData axisData = new AxisEventData(eventSystem);
axisData.moveDir = direction;
ExecuteEvents.Execute(currentSelected, axisData, ExecuteEvents.moveHandler);
currentSelected = eventSystem.currentSelectedGameObject;
CheckForSelectedOutOfBounds();
ScrollToActive();
}
// Token: 0x060029BC RID: 10684 RVA: 0x0045B990 File Offset: 0x00459B90
public override void OnMove(AxisEventData eventData)
{
if (!this.IsActive() || !this.IsInteractable())
{
base.OnMove(eventData);
return;
}
switch (eventData.moveDir)
{
case MoveDirection.Left:
if (this.axis == CSlider.Axis.Horizontal && this.FindSelectableOnLeft() == null)
{
this.Set((!this.reverseValue) ? (this.value - this.stepSize) : (this.value + this.stepSize));
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Up:
if (this.axis == CSlider.Axis.Vertical && this.FindSelectableOnUp() == null)
{
this.Set((!this.reverseValue) ? (this.value + this.stepSize) : (this.value - this.stepSize));
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Right:
if (this.axis == CSlider.Axis.Horizontal && this.FindSelectableOnRight() == null)
{
this.Set((!this.reverseValue) ? (this.value + this.stepSize) : (this.value - this.stepSize));
}
else
{
base.OnMove(eventData);
}
break;
case MoveDirection.Down:
if (this.axis == CSlider.Axis.Vertical && this.FindSelectableOnDown() == null)
{
this.Set((!this.reverseValue) ? (this.value - this.stepSize) : (this.value + this.stepSize));
}
else
{
base.OnMove(eventData);
}
break;
}
}
//キー移動でSE鳴らす
public void OnMove(AxisEventData eventData)
{
if (eventData.selectedObject == this.gameObject)
{
return;
}
if (highlited != null)
{
AudioSource.PlayClipAtPoint(highlited, Vector3.zero);
}
}
private void OnEnable()
{
if (defaultButtonObj != null)
{
EventSystem.current.SetSelectedGameObject(defaultButtonObj);
currentButton = EventSystem.current.currentSelectedGameObject;
currentAxis = new AxisEventData(EventSystem.current);
currentAxis.moveDir = MoveDirection.None;
ExecuteEvents.Execute(currentButton, currentAxis, ExecuteEvents.moveHandler);
}
}
private void OnSecondaryNavigate(float obj)
{
if (_navigationEnabled)
{
AxisEventData axisEventData = new AxisEventData(eventSystem: EventSystem.current);
MoveDirection moveDir = obj > 0 ? MoveDirection.Right : MoveDirection.Left;
axisEventData.moveDir = moveDir;
axisEventData.moveVector = Vector2.right * obj;
_currentlySelected.OnMove(eventData: axisEventData);
}
}
/// <summary>
/// Called once every frame while InputModule is active.
/// </summary>
public override void Process()
{
if (!eventSystem)
{
return;
}
GameObject target = eventSystem.currentSelectedGameObject;
bool submit = Input.GetButtonDown(_submitKeyboard);
bool cancel = Input.GetButtonDown(_cancelKeyboard);
float x = Input.GetAxisRaw(_horizontalKeyboard);
float y = Input.GetAxisRaw(_verticalKeyboard);
var count = 1;
foreach (InputDevice device in HInput.Devices)
{
if (device == null)
{
continue;
}
x += device.GetControl(_horizontalGamepad);
y += device.GetControl(_verticalGamepad);
submit |= device.GetControl(_submitGamepad).WasPressed;
cancel |= device.GetControl(_cancelGamepad).WasPressed;
count++;
}
if (submit)
{
ExecuteEvents.Execute(target, GetBaseEventData(), ExecuteEvents.submitHandler);
}
if (cancel)
{
ExecuteEvents.Execute(target, GetBaseEventData(), ExecuteEvents.cancelHandler);
}
currentDelay -= Time.deltaTime;
if (!eventSystem.sendNavigationEvents || currentDelay >= 0)
{
return;
}
x /= count;
y /= count;
AxisEventData moveData = GetAxisEventData(x, y, _deadZone);
ExecuteEvents.Execute(target, moveData, ExecuteEvents.moveHandler);
if (moveData.moveDir != MoveDirection.None)
{
currentDelay = _navigationDelay;
}
}
public override void OnMove(AxisEventData eventData)
{
if (!gameObject.activeSelf)
{
return;
}
if (onMove != null)
{
onMove(gameObject, eventData);
}
}
// ----------------
override public void OnMove(AxisEventData data)
{
if ((data.moveDir == MoveDirection.Left) || (data.moveDir == MoveDirection.Right))
{
this.OnSwitch((data.moveDir == MoveDirection.Left) ? -1 : 1);
data.Use();
}
else
{
base.OnMove(data);
}
}
private AxisEventData GetOrCreateCachedAxisEvent()
{
var result = m_CachedAxisEvent;
if (result == null)
{
result = new AxisEventData(eventSystem);
m_CachedAxisEvent = result;
}
return(result);
}
public override void OnMove(AxisEventData eventData)
{
base.OnMove(eventData);
if (eventData.moveDir == MoveDirection.Left)
{
PrevValue();
}
if (eventData.moveDir == MoveDirection.Right)
{
NextValue();
}
}
protected virtual AxisEventData GetAxisEventData(float x, float y, float moveDeadZone)
{
if (m_AxisEventData == null)
{
m_AxisEventData = new AxisEventData(eventSystem);
}
m_AxisEventData.Reset();
m_AxisEventData.moveVector = new Vector2(x, y);
m_AxisEventData.moveDir = DetermineMoveDirection(x, y, moveDeadZone);
return(m_AxisEventData);
}
// sends navigation event within a canvas
private static bool SendMoveEventToSelectedObject(AxisEventData axisEventData, EventSystem eventSystem, BaseEventData data)
{
// eventSystem must have a selected object
if (eventSystem.currentSelectedGameObject == null)
{
return(false);
}
ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler);
return(axisEventData.used);
}
protected bool SendMoveEventToSelectedObject()
{
float time = Time.unscaledTime;
Vector2 movement = GetRawMoveVector();
if (Mathf.Approximately(movement.x, 0f) && Mathf.Approximately(movement.y, 0f))
{
m_ConsecutiveMoveCount = 0;
return(false);
}
bool allow = input.GetButtonDown(m_HorizontalAxis) || input.GetButtonDown(m_VerticalAxis);
bool similarDir = (Vector2.Dot(movement, m_LastMoveVector) > 0);
if (!allow)
{
if (similarDir && m_ConsecutiveMoveCount == 1)
{
allow = time > (m_PrevActionTime + m_RepeatDelay);
}
else
{
allow = time > (m_PrevActionTime + 1f / m_InputActionsPerSecond);
}
}
if (!allow)
{
return(false);
}
AxisEventData axisEventData = GetAxisEventData(movement.x, movement.y, 0.6f);
if (axisEventData.moveDir != MoveDirection.None)
{
ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler);
if (!similarDir)
{
m_ConsecutiveMoveCount = 0;
}
m_ConsecutiveMoveCount++;
m_PrevActionTime = time;
m_LastMoveVector = movement;
}
else
{
m_ConsecutiveMoveCount = 0;
}
return(axisEventData.used);
}
public void OnMove(AxisEventData eventData)
{
EventSystemGame.current.PlaySound("Swap");
/*
* if (eventData.moveVector.y < 0)
* EventSystemGame.current.PlaySound("SwapDown");
* else
* {
* EventSystemGame.current.PlaySound("SwapUp");
* }
*/
}
void IMoveHandler.OnMove(AxisEventData eventData)
{
if (onMoveCallBack != null)
{
onMoveCallBack();
}
if (onMove != null)
{
data = new UGUIData(gameObject, eventData, parameter);
onMove(ref data);
}
}
public override void OnMove(AxisEventData eventData)
{
switch (eventData.moveDir)
{
case MoveDirection.Left:
menuNav.SelectPreviousItem();
break;
case MoveDirection.Right:
menuNav.SelectNextItem();
break;
}
}
public void OnMove(AxisEventData eventData)
{
switch (eventData.moveDir)
{
case MoveDirection.Left:
leftEvent.Invoke();
break;
case MoveDirection.Right:
rightEvent.Invoke();
break;
}
}
public void OnMove(AxisEventData eventData)
{
curEventData = eventData;
if (luaOnMove != null)
{
luaOnMove();
}
else
{
Debug.LogWarningFormat("OnMove but not find lua OnMove fun !");
}
}
/// <summary>
/// Selects the result.
/// </summary>
/// <param name="eventData">Event data.</param>
protected virtual void SelectResult(AxisEventData eventData)
{
if (!DisplayListView.gameObject.activeInHierarchy)
{
return;
}
if (DisplayListView.DataSource.Count == 0)
{
return;
}
switch (eventData.moveDir)
{
case MoveDirection.Up:
if (DisplayListView.SelectedIndex == 0)
{
DisplayListView.SelectedIndex = DisplayListView.DataSource.Count - 1;
}
else
{
DisplayListView.SelectedIndex -= 1;
}
DisplayListView.ScrollTo(DisplayListView.SelectedIndex);
InputFieldProxy.caretPosition = CaretPosition;
break;
case MoveDirection.Down:
if (DisplayListView.SelectedIndex == (DisplayListView.DataSource.Count - 1))
{
DisplayListView.SelectedIndex = 0;
}
else
{
DisplayListView.SelectedIndex += 1;
}
DisplayListView.ScrollTo(DisplayListView.SelectedIndex);
InputFieldProxy.caretPosition = CaretPosition;
break;
default:
if (Input2Query(InputFieldProxy.text) != Query)
{
ApplyFilter(InputFieldProxy.text);
}
break;
}
}
void Update()
{
if (EventSystem.current != null)
{
m_AxisEventData = new AxisEventData(EventSystem.current);
if (Mapper.jInputOnUp && UGUIOperationInvalid != true ||
Mapper.jInputOnUp2p && UGUIOperationInvalid2p != true ||
Mapper.jInputOnUp3p && UGUIOperationInvalid3p != true ||
Mapper.jInputOnUp4p && UGUIOperationInvalid4p != true)
{
UGUIUpMove();
}
if (Mapper.jInputOnDown && UGUIOperationInvalid != true ||
Mapper.jInputOnDown2p && UGUIOperationInvalid2p != true ||
Mapper.jInputOnDown3p && UGUIOperationInvalid3p != true ||
Mapper.jInputOnDown4p && UGUIOperationInvalid4p != true)
{
UGUIDownMove();
}
if (Mapper.jInputOnRight && UGUIOperationInvalid != true ||
Mapper.jInputOnRight2p && UGUIOperationInvalid2p != true ||
Mapper.jInputOnRight3p && UGUIOperationInvalid3p != true ||
Mapper.jInputOnRight4p && UGUIOperationInvalid4p != true)
{
UGUIRightMove();
}
if (Mapper.jInputOnLeft && UGUIOperationInvalid != true ||
Mapper.jInputOnLeft2p && UGUIOperationInvalid2p != true ||
Mapper.jInputOnLeft3p && UGUIOperationInvalid3p != true ||
Mapper.jInputOnLeft4p && UGUIOperationInvalid4p != true)
{
UGUILeftMove();
}
if (Mapper.UGUIOnSubmit && UGUIOperationInvalid != true ||
Mapper.UGUIOnSubmit2p && UGUIOperationInvalid2p != true ||
Mapper.UGUIOnSubmit3p && UGUIOperationInvalid3p != true ||
Mapper.UGUIOnSubmit4p && UGUIOperationInvalid4p != true)
{
UGUISubmit();
}
if (Mapper.UGUIOnCancel && UGUIOperationInvalid != true ||
Mapper.UGUIOnCancel2p && UGUIOperationInvalid2p != true ||
Mapper.UGUIOnCancel3p && UGUIOperationInvalid3p != true ||
Mapper.UGUIOnCancel4p && UGUIOperationInvalid4p != true)
{
UGUICancel();
}
}
}
protected virtual AxisEventData GetAxisEventData(float x, float y, float moveDeadZone)
{
if (m_AxisEventData == null)
m_AxisEventData = new AxisEventData(eventSystem);
m_AxisEventData.Reset();
m_AxisEventData.moveVector = new Vector2(x, y);
m_AxisEventData.moveDir = DetermineMoveDirection(x, y, moveDeadZone);
return m_AxisEventData;
}
