public virtual void AnimateHideBackground(Action callback = null, float animationDuration = 0.5f, float delay = 0f)
{
if (!_isHiding || _tweenId < 0)
{
_isHiding = true;
canvasGroup.blocksRaycasts = false;
TweenManager.EndTween(_tweenId);
_tweenId = TweenManager.TweenFloat(
f =>
{
if (this != null && canvasGroup != null)
{
canvasGroup.alpha = f;
}
},
canvasGroup.alpha,
0f,
animationDuration,
delay,
callback += () =>
{
if (this != null && gameObject != null)
{
Destroy(gameObject, 0.01f);
}
},
false,
Tween.TweenType.Linear);
}
}
/// <summary>
/// Animates the slider to the 'on' state.
/// </summary>
private void AnimateOn()
{
TweenManager.EndTween(m_HandleSizeTweener);
TweenManager.EndTween(m_PopupScaleTweener);
TweenManager.EndTween(m_HandlePositionYTweener);
TweenManager.EndTween(m_PopupTextColorTweener);
if (m_HasPopup)
{
m_HandleSizeTweener = TweenManager.TweenVector2(vector2 => handleGraphicTransform.sizeDelta = vector2,
handleGraphicTransform.sizeDelta, new Vector2(38, 38), m_AnimationDuration, 0f, null, false,
Tween.TweenType.SoftEaseOutQuint);
m_HandlePositionYTweener = TweenManager.TweenFloat(
f => handleGraphicTransform.anchoredPosition = new Vector2(handleGraphicTransform.anchoredPosition.x, f),
handleGraphicTransform.anchoredPosition.y, slider.wholeNumbers && m_HasDots ? 36 : 30,
m_AnimationDuration, 0, null, false, Tween.TweenType.EaseOutSept);
m_PopupScaleTweener = TweenManager.TweenVector3(vector3 => m_PopupTransform.localScale = vector3,
m_PopupTransform.localScale, Vector3.one, m_AnimationDuration, 0, null, false, Tween.TweenType.EaseOutSept);
}
else
{
m_HandleSizeTweener = TweenManager.TweenVector2(vector2 => handleGraphicTransform.sizeDelta = vector2,
handleGraphicTransform.sizeDelta, new Vector2(24, 24), m_AnimationDuration, 0, null, false, Tween.TweenType.SoftEaseOutQuint);
}
m_PopupTextColorTweener = TweenManager.TweenColor(color => m_PopupText.color = color, () => m_PopupText.color,
() => m_PopupText.color.WithAlpha(1f), m_AnimationDuration * 0.66f, m_AnimationDuration * 0.33f);
}
protected override void TweenIndicator(int targetTab, bool animate = true)
{
if (m_Indicator == null || m_Tabs == null)
{
return;
}
float targetPosition = m_ForceSameTabSize || m_Tabs.Length <= targetTab || targetTab < 0 || m_Tabs[targetTab] == null ?
targetTab * m_TabWidth :
m_Tabs[targetTab].rectTransform.anchoredPosition.x - (m_Tabs[targetTab].rectTransform.GetProperSize().x / 2);
float targetSize = m_ForceSameTabSize || m_Tabs.Length <= targetTab || targetTab < 0 || m_Tabs[targetTab] == null ?
m_TabWidth :
m_Tabs[targetTab].rectTransform.GetProperSize().x;
TweenManager.EndTween(m_IndicatorSizeTweener);
TweenManager.EndTween(m_IndicatorTweener);
if (animate)
{
if (!m_ForceSameTabSize)
{
m_IndicatorSizeTweener = TweenManager.TweenFloat(value => m_Indicator.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, value), m_Indicator.GetProperSize().x, targetSize, 0.5f);
}
m_IndicatorTweener = TweenManager.TweenVector2(vector2 => m_Indicator.anchoredPosition = vector2, m_Indicator.anchoredPosition, new Vector2(targetPosition, 0), 0.5f);
}
else
{
if (!m_ForceSameTabSize)
{
m_Indicator.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, targetSize);
}
m_Indicator.anchoredPosition = new Vector2(targetPosition, 0);
}
}
/// <summary>
/// Starts animating a shadow on or off.
/// </summary>
/// <param name="set">If true, animate the shadow on. Otherwise animate it off.</param>
/// <param name="tweenType">The type of tween curve to use. 'Custom' is not supported.</param>
/// <param name="instant">Should the transition be instant and not animate?</param>
public void SetShadow(bool set, Tween.TweenType tweenType, bool instant = false)
{
if (gameObject == null)
{
return;
}
isVisible = set;
if (set)
{
gameObject.SetActive(true);
}
if (Application.isPlaying && !instant)
{
TweenManager.EndTween(m_Tweener);
m_Tweener = TweenManager.TweenFloat(f => canvasGroup.alpha = f, () => canvasGroup.alpha, set ? 1f : 0f, 0.5f, 0f, () => gameObject.SetActive(set), tweenType: tweenType);
}
else
{
canvasGroup.alpha = set ? 1f : 0f;
gameObject.SetActive(set);
}
}
public void OnDateClicked()
{
if (m_CalendarCanvasGroup != null)
{
TweenManager.TweenFloat(f => m_CalendarCanvasGroup.alpha = f, m_CalendarCanvasGroup.alpha, 1f, 0.5f);
m_CalendarCanvasGroup.blocksRaycasts = true;
}
if (m_YearCanvasGroup != null)
{
TweenManager.TweenFloat(f => m_YearCanvasGroup.alpha = f, m_YearCanvasGroup.alpha, 0f, 0.5f, 0.01f, callback: () =>
{
m_YearCanvasGroup.gameObject.SetActive(false); // HACK: to disable the big list of GameObjects to avoid lag during dialog movement
});
m_YearCanvasGroup.blocksRaycasts = false;
}
if (m_TextDate != null)
{
m_TextDate.color = new Color(m_TextDate.color.r, m_TextDate.color.g, m_TextDate.color.b, 1.0f);
}
if (m_TextYear != null)
{
m_TextYear.color = new Color(m_TextYear.color.r, m_TextYear.color.g, m_TextYear.color.b, 0.5f);
}
}
private void AnimateActiveLineSelect(bool instant = false)
{
CancelActivelineTweeners();
if (m_LineTransform == null || m_ActiveLineTransform == null)
{
return;
}
if (instant)
{
m_ActiveLineTransform.anchoredPosition = Vector2.zero;
m_ActiveLineTransform.sizeDelta = new Vector2(m_LineTransform.GetProperSize().x, m_ActiveLineTransform.sizeDelta.y);
activeLineCanvasGroup.alpha = 1;
}
else
{
float lineLength = m_LineTransform.GetProperSize().x;
m_ActiveLineTransform.sizeDelta = new Vector2(0, m_ActiveLineTransform.sizeDelta.y);
m_ActiveLineTransform.position = Input.mousePosition;
m_ActiveLineTransform.anchoredPosition = new Vector2(Mathf.Clamp(m_ActiveLineTransform.anchoredPosition.x, -lineLength / 2, lineLength / 2), 0);
activeLineCanvasGroup.alpha = 1;
m_ActiveLinePosTweener = TweenManager.TweenFloat(f => m_ActiveLineTransform.anchoredPosition = new Vector2(f, m_ActiveLineTransform.anchoredPosition.y), m_ActiveLineTransform.anchoredPosition.x, 0f, m_AnimationDuration * 2);
m_ActiveLineSizeTweener = TweenManager.TweenFloat(f => m_ActiveLineTransform.sizeDelta = new Vector2(f, m_ActiveLineTransform.sizeDelta.y), m_ActiveLineTransform.sizeDelta.x, m_LineTransform.GetProperSize().x, m_AnimationDuration * 2);
}
}
public void SetPage(int index, bool animate)
{
index = Mathf.Clamp(index, 0, m_Pages.Length - 1);
TweenIndicator(index, animate);
TweenTabsContainer(index, animate);
TweenPagesContainer(index, animate);
if (m_LowerUnselectedTabAlpha)
{
if (animate)
{
for (int i = 0; i < m_Tabs.Length; i++)
{
int i1 = i;
TweenManager.TweenFloat(f => m_Tabs[i1].canvasGroup.alpha = f, () => m_Tabs[i1].canvasGroup.alpha, () => m_Pages[i1].interactable ? (i1 == index ? 1f : 0.5f) : 0.15f, 0.5f);
}
}
else
{
for (int i = 0; i < m_Tabs.Length; i++)
{
m_Tabs[i].canvasGroup.alpha = m_Pages[i].interactable ? (i == index ? 1f : 0.5f) : 0.15f;
}
}
}
}
/// <summary>
/// Hides and destroys the dropdown object.
/// </summary>
public void Hide()
{
for (int i = 0; i < m_ListItemAutoTweeners.Count; i++)
{
TweenManager.EndTween(m_ListItemAutoTweeners[i]);
}
m_IsExapanded = false;
if (m_BaseSelectable != null)
{
m_BaseSelectable.interactable = true;
}
for (int i = 0; i < m_ListItems.Count; i++)
{
int i1 = i;
CanvasGroup canvasGroup = m_ListItems[i].canvasGroup;
TweenManager.TweenFloat(f => canvasGroup.alpha = f, canvasGroup.alpha, 0f, m_AnimationDuration * 0.66f, (m_ListItems.Count - i1) * (m_AnimationDuration / 6), null, false, Tween.TweenType.Linear);
}
m_AutoTweeners.Add(TweenManager.TweenFloat(f => m_DropdownCanvasGroup.alpha = f, m_DropdownCanvasGroup.alpha, 0f, m_AnimationDuration * 0.66f, m_AnimationDuration, null, false, Tween.TweenType.Linear));
TweenManager.TweenFloat(f => m_ShadowCanvasGroup.alpha = f, m_ShadowCanvasGroup.alpha, 0f, m_AnimationDuration * 0.66f, m_AnimationDuration, () =>
{
for (int i = 0; i < m_AutoTweeners.Count; i++)
{
TweenManager.EndTween(m_AutoTweeners[i]);
}
Destroy(m_DropdownPanel.gameObject);
}, false, Tween.TweenType.Linear);
}
/// <summary>
/// Animates the slider to the 'off' state.
/// </summary>
private void AnimateOff()
{
TweenManager.EndTween(m_HandleSizeTweener);
TweenManager.EndTween(m_PopupScaleTweener);
TweenManager.EndTween(m_HandlePositionYTweener);
TweenManager.EndTween(m_PopupTextColorTweener);
if (m_HasPopup)
{
m_HandlePositionYTweener =
TweenManager.TweenFloat(
f => handleGraphicTransform.anchoredPosition = new Vector2(handleGraphicTransform.anchoredPosition.x, f),
handleGraphicTransform.anchoredPosition.y,
MaterialUIScaler.GetRootScaler(transform).canvas.pixelPerfect ? 1f : 0f, m_AnimationDuration, 0, null, false, Tween.TweenType.EaseOutCubed);
m_PopupScaleTweener = TweenManager.TweenVector3(vector3 => m_PopupTransform.localScale = vector3,
m_PopupTransform.localScale, Vector3.zero, m_AnimationDuration);
}
m_HandleSizeTweener = TweenManager.TweenVector2(vector2 => handleGraphicTransform.sizeDelta = vector2,
handleGraphicTransform.sizeDelta, new Vector2(16, 16), m_AnimationDuration, 0, null, false,
Tween.TweenType.EaseOutSept);
m_PopupTextColorTweener = TweenManager.TweenColor(color => m_PopupText.color = color, m_PopupText.color,
m_PopupText.color.WithAlpha(0f), m_AnimationDuration * 0.25f);
}
private void AnimateHintTextSelect()
{
CancelHintTextTweeners();
m_HintTextFloatingValueTweener = TweenManager.TweenFloat(f => hintTextFloatingValue = f, hintTextFloatingValue, 1f, m_AnimationDuration, 0, () =>
{
m_AnimateHintText = false;
SetHintLayoutToFloatingValue();
});
m_AnimateHintText = true;
}
public void OnYearClicked()
{
m_YearCanvasGroup.gameObject.SetActive(true); // HACK: to disable the big list of GameObjects to avoid lag during dialog movement
TweenManager.TweenFloat(f => m_CalendarCanvasGroup.alpha = f, m_CalendarCanvasGroup.alpha, 0f, 0.5f);
TweenManager.TweenFloat(f => m_YearCanvasGroup.alpha = f, m_YearCanvasGroup.alpha, 1f, 0.5f, 0.01f); // HACK: 0.01f of delay, because if not, the animation is not played
m_DatePickerYearList.CenterToSelectedYear(m_CurrentDate.Year);
m_CalendarCanvasGroup.blocksRaycasts = false;
m_YearCanvasGroup.blocksRaycasts = true;
m_TextDate.color = new Color(m_TextDate.color.r, m_TextDate.color.g, m_TextDate.color.b, 0.5f);
m_TextYear.color = new Color(m_TextYear.color.r, m_TextYear.color.g, m_TextYear.color.b, 1.0f);
}
private void AnimateHintTextDeselect()
{
CancelHintTextTweeners();
if (!inputField.isFocused && inputField.text.Length == 0)
{
m_HintTextFloatingValueTweener = TweenManager.TweenFloat(f => hintTextFloatingValue = f,
() => hintTextFloatingValue, 0f, m_AnimationDuration, 0f, () =>
{
m_AnimateHintText = false;
SetHintLayoutToFloatingValue();
});
m_AnimateHintText = true;
}
}
public virtual void Transition(bool show, float attenuation, float animationDuration, float delay = 0, System.Action callback = null)
{
attenuation = Mathf.Clamp01(attenuation);
if (gameObject != null && isShow != show)
{
gameObject.SetActive(true);
isShow = show;
//var inverseTargetValue = show ? 0f : attenuation;
var targetValue = show ? attenuation : 0f;
var currentValue = Mathf.Clamp01(rectTransform.localScale.y);
TweenManager.EndTween(tweenId);
tweenId = TweenManager.TweenFloat((value) =>
{
//Update Color and Scale
if (gameObject != null)
{
if (canvasGroup != null)
{
canvasGroup.alpha = value;
}
if (rectTransform != null)
{
rectTransform.localScale = new Vector3(rectTransform.localScale.x, value, rectTransform.localScale.z);
}
}
},
currentValue,
targetValue,
animationDuration,
0,
() =>
{
tweenId = -1;
if (gameObject != null && !isShow)
{
gameObject.SetActive(false);
}
callback.InvokeIfNotNull();
});
}
else
{
isShow = show;
callback.InvokeIfNotNull();
}
}
/// <summary>
/// Called when [slider value changed].
/// </summary>
/// <param name="value">The value.</param>
public void OnSliderValueChanged(float value)
{
TweenManager.EndTween(m_HandleAnchorMinTweener);
TweenManager.EndTween(m_HandleAnchorMaxTweener);
if (slider.wholeNumbers && SliderValueRange() < 100 && Application.isPlaying)
{
m_HandleAnchorMinTweener = TweenManager.TweenFloat(
f => handleGraphicTransform.anchorMin = new Vector2(f, handleGraphicTransform.anchorMin.y),
handleGraphicTransform.anchorMin.x, m_Slider.handleRect.anchorMin.x, m_AnimationDuration * 0.5f,
0, null, false, Tween.TweenType.EaseOutSept);
m_HandleAnchorMaxTweener = TweenManager.TweenFloat(
f => handleGraphicTransform.anchorMax = new Vector2(f, handleGraphicTransform.anchorMax.y),
handleGraphicTransform.anchorMax.x, m_Slider.handleRect.anchorMax.x, m_AnimationDuration * 0.5f,
0, null, false, Tween.TweenType.EaseOutSept);
}
else
{
Vector2 anchor = handleGraphicTransform.anchorMin;
anchor.x = m_Slider.handleRect.anchorMin.x;
handleGraphicTransform.anchorMin = anchor;
anchor = handleGraphicTransform.anchorMax;
anchor.x = m_Slider.handleRect.anchorMax.x;
handleGraphicTransform.anchorMax = anchor;
handleGraphicTransform.anchoredPosition = new Vector2(0f, handleGraphicTransform.anchoredPosition.y);
}
if (m_DelayedInit)
{
m_FillTransform.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Left, 0, fillAreaTransform.GetProperSize().x *handleGraphicTransform.anchorMin.x);
}
m_PopupText.text = slider.value.ToString("#0.#");
if (m_ValueText != null)
{
m_ValueText.text = slider.value.ToString("#0.##") + (string.IsNullOrEmpty(m_ValueTextSuffix) ? "" : m_ValueTextSuffix);
}
if (m_InputField != null)
{
m_InputField.inputField.text = slider.value.ToString("#0.##");
}
}
private void AnimateActiveLineDeselect(bool instant = false)
{
CancelActivelineTweeners();
if (activeLineTransform == null)
{
return;
}
if (instant)
{
activeLineCanvasGroup.alpha = 0;
}
else
{
activeLineCanvasGroup.alpha = 1;
m_ActiveLineAlphaTweener = TweenManager.TweenFloat(f => activeLineCanvasGroup.alpha = f, activeLineCanvasGroup.alpha, 0f, m_AnimationDuration * 2);
}
}
public virtual void AnimateShowBackground(Action callback = null, float animationDuration = 0.5f, float delay = 0f)
{
if (_isHiding || _tweenId < 0)
{
_isHiding = false;
canvasGroup.blocksRaycasts = true;
TweenManager.EndTween(_tweenId);
_tweenId = TweenManager.TweenFloat(
f =>
{
if (this != null && canvasGroup != null)
{
canvasGroup.alpha = f;
}
},
canvasGroup.alpha,
m_BackgroundAlpha,
animationDuration,
delay,
callback);
}
}
public void Show()
{
m_PanelRootRectTransform.gameObject.SetActive(true);
if (!m_HasExpandedInfo)
{
if (m_AutoExpandedPosition)
{
m_ExpandedPosition = m_PanelRootRectTransform.GetPositionRegardlessOfPivot();
}
if (m_AutoExpandedSize)
{
m_ExpandedSize = m_PanelRootRectTransform.sizeDelta;
}
CalculateExpandMode();
m_HasExpandedInfo = true;
}
if (m_DarkenBackground || m_ClickBackgroundToClose)
{
if (m_ClickableBackground == null)
{
m_ClickableBackground = PrefabManager.InstantiateGameObject(PrefabManager.ResourcePrefabs.clickableBackground, m_PanelRootRectTransform.parent).GetAddComponent <RectTransform>();
m_ClickableBackground.SetSiblingIndex(m_PanelRootRectTransform.GetSiblingIndex());
m_BackgroundImage = m_ClickableBackground.gameObject.GetComponent <Image>();
m_BackgroundTrigger = m_ClickableBackground.gameObject.GetComponent <EventTrigger>();
EventTrigger.Entry entry = new EventTrigger.Entry();
entry.callback.AddListener(baseEventData => OnBackgroundClick());
m_BackgroundTrigger.triggers.Add(entry);
}
m_ClickableBackground.sizeDelta = new Vector2(10000, 10000);
m_ClickableBackground.anchoredPosition = m_ExpandedPosition;
m_BackgroundImage.color = Color.clear;
m_ClickableBackground.gameObject.SetActive(true);
}
m_PanelContentCanvasGroup.alpha = 0f;
if (m_RippleHasShadow && m_PanelShadowCanvasGroup != null)
{
m_PanelShadowCanvasGroup.alpha = 0f;
}
if (m_FinalExpandMode != ExpandMode.Rectangular)
{
m_MaskRect = rippleMask;
m_MaskRect.SetParentAndScale(m_PanelRootRectTransform.parent, Vector3.one);
RippleData rippleData = new RippleData
{
RippleParent = m_MaskRect,
Shadow = m_RippleHasShadow
};
m_Ripple = RippleManager.instance.GetRipple();
m_Ripple.Setup(rippleData, m_MaskRect.position, null);
m_Ripple.rectTransform.localScale = Vector3.one;
m_Ripple.rectTransform.sizeDelta = m_BaseRectTransform.sizeDelta;
m_Ripple.color = Color.white;
m_Ripple.canvasGroup.alpha = 1f;
m_Ripple.SubmitSizeForSoftening();
m_CircleExpandedSize = Mathf.Sqrt(Mathf.Pow(Tween.QuintOut(0f, m_ExpandedSize.x, 1f, 0.5f), 2) +
Mathf.Pow(Tween.QuintOut(0f, m_ExpandedSize.y, 1f, 0.5f), 2));
}
if (m_FinalExpandMode != ExpandMode.Radial)
{
m_WidthDuration = 1f;
m_HeightDuration = 1f;
if (m_ExpandedSize.x > m_ExpandedSize.y)
{
m_HeightDuration = (2 * (m_ExpandedSize.y / m_ExpandedSize.x) + 1f) / 3f;
}
else if (m_ExpandedSize.x < m_ExpandedSize.y)
{
m_WidthDuration = (2 * (m_ExpandedSize.x / m_ExpandedSize.y) + 1f) / 3f;
}
}
m_BaseRectTransform.gameObject.SetActive(false);
m_Shadow = m_PanelShadowCanvasGroup != null;
if (m_FinalExpandMode == ExpandMode.Radial)
{
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(expandedPosition);
m_PanelRootRectTransform.sizeDelta = expandedSize;
TweenManager.TweenFloat(f =>
{
m_MaskRect.sizeDelta = m_PanelRootRectTransform.sizeDelta;
m_MaskRect.position = m_PanelRootRectTransform.GetPositionRegardlessOfPivot();
m_Ripple.rectTransform.sizeDelta = Tween.CubeSoftOut(m_Ripple.rectTransform.sizeDelta, new Vector2(m_CircleExpandedSize, m_CircleExpandedSize), f, 1f);
m_Ripple.rectTransform.position = Tween.CubeSoftOut(m_BaseRectTransform.GetPositionRegardlessOfPivot(), m_PanelRootRectTransform.GetPositionRegardlessOfPivot(), f, 1f);
m_Ripple.SubmitSizeForSoftening();
if (m_Shadow)
{
m_PanelShadowCanvasGroup.alpha = Tween.CubeInOut(0f, 1f, f - 0.5f, 0.5f);
}
m_PanelContentCanvasGroup.alpha = Tween.CubeInOut(0f, 1f, f - 0.5f, 0.25f);
m_Ripple.color = m_Ripple.color.WithAlpha(Tween.CubeInOut(1f, 0f, f - 0.5f, 0.5f));
},
0f, 1f, m_AnimationDuration, tweenType: Tween.TweenType.Linear);
TweenManager.TimedCallback(m_AnimationDuration, m_Ripple.InstantContract);
}
else if (m_FinalExpandMode == ExpandMode.Rectangular)
{
TweenManager.TweenFloat(f =>
{
if (m_ExpandedPosition.y > m_BaseRectTransform.position.y)
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintOut(m_BaseRectTransform.sizeDelta.x, expandedSize.x, f, m_WidthDuration),
Tween.QuintSoftOut(m_BaseRectTransform.sizeDelta.y, expandedSize.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintOut(m_BaseRectTransform.GetPositionRegardlessOfPivot().x, expandedPosition.x, f, m_WidthDuration),
Tween.QuintSoftOut(m_BaseRectTransform.GetPositionRegardlessOfPivot().y, expandedPosition.y, f, m_HeightDuration)));
}
else
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintSoftOut(m_BaseRectTransform.sizeDelta.x, expandedSize.x, f, m_WidthDuration),
Tween.QuintOut(m_BaseRectTransform.sizeDelta.y, expandedSize.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintSoftOut(m_BaseRectTransform.GetPositionRegardlessOfPivot().x, expandedPosition.x, f, m_WidthDuration),
Tween.QuintOut(m_BaseRectTransform.GetPositionRegardlessOfPivot().y, expandedPosition.y, f, m_HeightDuration)));
}
if (m_Shadow)
{
m_PanelShadowCanvasGroup.alpha = Tween.QuintOut(0f, 1f, f, 0.25f);
}
m_PanelContentCanvasGroup.alpha = Tween.QuintInOut(0f, 1f, f - 0.5f, 0.5f);
},
0f, 1f, m_AnimationDuration, tweenType: Tween.TweenType.Linear);
}
else if (m_FinalExpandMode == ExpandMode.Hybrid)
{
Vector2 startPos = m_BaseRectTransform.GetPositionRegardlessOfPivot();
m_PanelRootRectTransform.sizeDelta = m_BaseRectTransform.sizeDelta;
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(m_BaseRectTransform.GetPositionRegardlessOfPivot());
TweenManager.TweenFloat(f =>
{
if (m_ExpandedPosition.y > m_BaseRectTransform.position.y)
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintOut(m_BaseRectTransform.sizeDelta.x, expandedSize.x, f, m_WidthDuration),
Tween.QuintSoftOut(m_BaseRectTransform.sizeDelta.y, expandedSize.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintOut(startPos.x, expandedPosition.x, f, m_WidthDuration),
Tween.QuintSoftOut(startPos.y, expandedPosition.y, f, m_HeightDuration)));
}
else
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintSoftOut(m_BaseRectTransform.sizeDelta.x, expandedSize.x, f, m_WidthDuration),
Tween.QuintOut(m_BaseRectTransform.sizeDelta.y, expandedSize.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintSoftOut(startPos.x, expandedPosition.x, f, m_WidthDuration),
Tween.QuintOut(startPos.y, expandedPosition.y, f, m_HeightDuration)));
}
m_MaskRect.sizeDelta = m_PanelRootRectTransform.sizeDelta;
m_MaskRect.position = m_PanelRootRectTransform.GetPositionRegardlessOfPivot();
m_Ripple.rectTransform.sizeDelta = Tween.CubeSoftOut(m_Ripple.rectTransform.sizeDelta, new Vector2(m_CircleExpandedSize, m_CircleExpandedSize), f - 0.2f, 1f);
m_Ripple.rectTransform.anchoredPosition = Vector2.zero;
m_Ripple.SubmitSizeForSoftening();
if (m_Shadow)
{
m_PanelShadowCanvasGroup.alpha = Tween.CubeInOut(0f, 1f, f - 0.4f, 0.6f);
}
m_PanelContentCanvasGroup.alpha = Tween.CubeInOut(0f, 1f, f - 0.4f, 0.3f);
m_Ripple.color = m_Ripple.color.WithAlpha(Tween.CubeInOut(1f, 0f, f - 0.5f, 0.5f));
},
0f, 1f, m_AnimationDuration, tweenType: Tween.TweenType.Linear);
if (m_DarkenBackground)
{
TweenManager.TweenColor(color => m_BackgroundImage.color = color, m_BackgroundImage.color, MaterialColor.disabledDark, m_AnimationDuration * 0.5f, m_AnimationDuration * 0.5f, tweenType: Tween.TweenType.EaseInOutCubed);
}
TweenManager.TimedCallback(m_AnimationDuration * 0.7f, m_Ripple.InstantContract);
}
}
/// <summary>
/// Instantiates the dropdown object and expands it.
/// </summary>
public void Show()
{
Canvas rootCanvas = m_BaseTransform.GetRootCanvas();
rootCanvas.CopySettingsToOtherCanvas(m_DropdownCanvas);
m_DropdownCanvas.pixelPerfect = true;
m_DropdownCanvas.sortingOrder = 30000;
m_DropdownPanel = PrefabManager.InstantiateGameObject(PrefabManager.ResourcePrefabs.dropdownPanel, m_DropdownCanvas.transform).GetComponent <RectTransform>();
m_PanelLayer = m_DropdownPanel.GetChildByName <RectTransform>("PanelLayer");
m_DropdownCanvasGroup = m_DropdownPanel.GetComponent <CanvasGroup>();
m_ShadowCanvasGroup = m_DropdownPanel.GetChildByName <CanvasGroup>("Shadow");
m_DropdownPanel.GetRootCanvas().scaleFactor = rootCanvas.scaleFactor;
m_CancelPanel = m_DropdownPanel.GetChildByName <RectTransform>("Cancel Panel");
m_CancelPanel.sizeDelta = scaler.canvas.pixelRect.size * 2;
DropdownTrigger trigger = m_DropdownPanel.gameObject.GetChildByName <DropdownTrigger>("Cancel Panel");
trigger.index = -1;
trigger.dropdown = this;
m_DropdownPanel.gameObject.GetChildByName <Image>("ScrollRect").color = m_PanelColor;
m_ListItemTemplate = new DropdownListItem();
m_ListItemTemplate.rectTransform = m_DropdownPanel.GetChildByName <RectTransform>("Item");
m_ListItemTemplate.canvasGroup = m_ListItemTemplate.rectTransform.GetComponent <CanvasGroup>();
m_ListItemTemplate.text = m_ListItemTemplate.rectTransform.GetChildByName <Text>("Text");
if (m_OptionDataList.imageType == ImageDataType.Sprite)
{
m_ListItemTemplate.image = m_ListItemTemplate.rectTransform.GetChildByName <Image>("Icon");
Destroy(m_ListItemTemplate.rectTransform.GetChildByName <VectorImage>("Icon").gameObject);
}
else
{
m_ListItemTemplate.image = m_ListItemTemplate.rectTransform.GetChildByName <VectorImage>("Icon");
Destroy(m_ListItemTemplate.rectTransform.GetChildByName <Image>("Icon").gameObject);
}
m_ListItems = new List <DropdownListItem>();
for (int i = 0; i < m_OptionDataList.options.Count; i++)
{
m_ListItems.Add(CreateItem(m_OptionDataList.options[i], i));
}
for (int i = 0; i < m_ListItems.Count; i++)
{
Selectable selectable = m_ListItems[i].rectTransform.GetComponent <Selectable>();
Navigation navigation = new Navigation();
navigation.mode = Navigation.Mode.Explicit;
if (i > 0)
{
navigation.selectOnUp = m_ListItems[i - 1].rectTransform.GetComponent <Selectable>();
}
if (i < m_ListItems.Count - 1)
{
navigation.selectOnDown = m_ListItems[i + 1].rectTransform.GetComponent <Selectable>();
}
selectable.navigation = navigation;
}
if (m_BaseSelectable != null)
{
if (m_ListItems.Count > 0)
{
Navigation navigation = Navigation.defaultNavigation;
navigation.selectOnDown = m_ListItems[0].rectTransform.GetComponent <Selectable>();
m_BaseSelectable.navigation = navigation;
}
}
float maxWidth = CalculateMaxItemWidth();
float buttonWidth = m_BaseTransform.rect.width;
m_FullHeight = m_OptionDataList.options.Count * LayoutUtility.GetPreferredHeight(m_ListItemTemplate.rectTransform) + 16;
m_ExpandedSize = new Vector2(Mathf.Max(maxWidth, buttonWidth), m_FullHeight);
m_TempMaxHeight = m_MaxHeight;
if (m_TempMaxHeight == 0)
{
m_TempMaxHeight = MaterialUIScaler.GetRootScaler(m_DropdownPanel).canvas.GetComponent <RectTransform>().rect.height - 32;
}
if (m_ExpandedSize.y > m_TempMaxHeight)
{
m_ExpandedSize.y = m_TempMaxHeight;
}
else
{
m_DropdownPanel.GetChildByName <Image>("Handle").gameObject.SetActive(false);
}
Destroy(m_ListItemTemplate.rectTransform.gameObject);
m_DropdownPanel.position = m_BaseTransform.GetPositionRegardlessOfPivot();
if (m_ExpandStartType == ExpandStartType.ExpandFromBaseTransformWidth)
{
if (m_VerticalPivotType == VerticalPivotType.BelowBase)
{
m_DropdownPanel.position = new Vector3(m_DropdownPanel.position.x, m_DropdownPanel.position.y - m_BaseTransform.GetProperSize().y / 2, m_DropdownPanel.position.z);
}
else if (m_VerticalPivotType == VerticalPivotType.AboveBase)
{
m_DropdownPanel.position = new Vector3(m_DropdownPanel.position.x, m_DropdownPanel.position.y + m_BaseTransform.GetProperSize().y / 2, m_DropdownPanel.position.z);
}
}
m_ExpandedPosition = CalculatedPosition();
m_ExpandedPosition.z = m_BaseTransform.position.z;
m_DropdownCanvasGroup.alpha = 0f;
m_ShadowCanvasGroup.alpha = 0f;
if (m_ExpandStartType == ExpandStartType.ExpandFromBaseTransformWidth)
{
m_DropdownPanel.sizeDelta = new Vector2(m_BaseTransform.rect.size.x, 0f);
}
else if (m_ExpandStartType == ExpandStartType.ExpandFromBaseTransformHeight)
{
m_DropdownPanel.sizeDelta = new Vector2(0f, m_BaseTransform.rect.size.y);
}
else if (m_ExpandStartType == ExpandStartType.ExpandFromBaseTransformSize)
{
m_DropdownPanel.sizeDelta = m_BaseTransform.rect.size;
}
else
{
m_DropdownPanel.sizeDelta = Vector2.zero;
}
m_DropdownPanel.gameObject.SetActive(true);
for (int i = 0; i < m_ListItemAutoTweeners.Count; i++)
{
TweenManager.EndTween(m_ListItemAutoTweeners[i]);
}
m_AutoTweeners = new List <int>();
m_ListItemAutoTweeners = new List <int>();
m_AutoTweeners.Add(TweenManager.TweenFloat(f => m_DropdownCanvasGroup.alpha = f, m_DropdownCanvasGroup.alpha, 1f, m_AnimationDuration * 0.66f, 0, null, false, Tween.TweenType.Linear));
m_AutoTweeners.Add(TweenManager.TweenFloat(f => m_ShadowCanvasGroup.alpha = f, m_ShadowCanvasGroup.alpha, 1f, m_AnimationDuration * 0.66f, 0, null, false, Tween.TweenType.Linear));
m_AutoTweeners.Add(TweenManager.TweenVector2(vector2 => m_DropdownPanel.sizeDelta = vector2, m_DropdownPanel.sizeDelta, m_ExpandedSize, m_AnimationDuration, m_AnimationDuration / 3, null, false, Tween.TweenType.EaseInOutQuint));
m_AutoTweeners.Add(TweenManager.TweenVector3(UpdateDropdownPos, m_DropdownPanel.position, m_ExpandedPosition, m_AnimationDuration, m_AnimationDuration / 3, () =>
{
if (m_BaseSelectable != null && m_IsExapanded)
{
m_BaseSelectable.interactable = false;
}
Vector2 tempVector2 = m_PanelLayer.anchoredPosition;
tempVector2.x = Mathf.RoundToInt(tempVector2.x);
tempVector2.y = Mathf.RoundToInt(tempVector2.y);
m_PanelLayer.anchoredPosition = tempVector2;
}, false, Tween.TweenType.EaseInOutQuint));
for (int i = 0; i < m_ListItems.Count; i++)
{
int i1 = i;
CanvasGroup canvasGroup = m_ListItems[i].canvasGroup;
m_ListItemAutoTweeners.Add(TweenManager.TweenFloat(f => canvasGroup.alpha = f, canvasGroup.alpha, 1f, m_AnimationDuration * 1.66f, (i1 * (m_AnimationDuration / 6) + m_AnimationDuration) - m_ScrollPosOffset / 800, null, false, Tween.TweenType.Linear));
}
if (m_FullHeight > m_TempMaxHeight)
{
m_DropdownPanel.GetChildByName <ScrollRect>("ScrollRect").gameObject.AddComponent <RectMask2D>();
}
m_IsExapanded = true;
m_TimeShown = Time.unscaledTime;
}
public void Hide()
{
m_Shadow = m_PanelShadowCanvasGroup != null;
if (m_FinalExpandMode != ExpandMode.Rectangular)
{
m_MaskRect = rippleMask;
m_MaskRect.SetParentAndScale(m_PanelRootRectTransform.parent, Vector3.one);
RippleData rippleData = new RippleData
{
RippleParent = m_MaskRect,
Shadow = m_RippleHasShadow
};
m_Ripple = RippleManager.instance.GetRipple();
m_Ripple.Setup(rippleData, m_MaskRect.position, null);
m_Ripple.rectTransform.localScale = Vector3.one;
m_Ripple.rectTransform.sizeDelta = m_BaseRectTransform.sizeDelta;
m_Ripple.color = Color.white;
m_Ripple.canvasGroup.alpha = 1f;
m_Ripple.SubmitSizeForSoftening();
m_CircleExpandedSize = Mathf.Sqrt(Mathf.Pow(Tween.QuintOut(0f, m_ExpandedSize.x, 1f, 0.5f), 2) + Mathf.Pow(Tween.QuintOut(0f, m_ExpandedSize.y, 1f, 0.5f), 2));
}
if (m_FinalExpandMode != ExpandMode.Radial)
{
m_WidthDuration = 1f;
m_HeightDuration = 1f;
if (m_ExpandedSize.x > m_ExpandedSize.y)
{
m_HeightDuration = (2 * (m_ExpandedSize.y / m_ExpandedSize.x) + 1f) / 3f;
}
else if (m_ExpandedSize.x < m_ExpandedSize.y)
{
m_WidthDuration = (2 * (m_ExpandedSize.x / m_ExpandedSize.y) + 1f) / 3f;
}
}
if (m_FinalExpandMode == ExpandMode.Radial)
{
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(expandedPosition);
m_PanelRootRectTransform.sizeDelta = expandedSize;
TweenManager.TweenFloat(f =>
{
m_MaskRect.sizeDelta = m_PanelRootRectTransform.sizeDelta;
m_MaskRect.position = m_PanelRootRectTransform.GetPositionRegardlessOfPivot();
m_Ripple.rectTransform.sizeDelta = Tween.QuintSoftOut(new Vector2(m_CircleExpandedSize, m_CircleExpandedSize), m_BaseRectTransform.sizeDelta, f, 1f);
m_Ripple.rectTransform.position = Tween.QuintSoftOut(m_PanelRootRectTransform.GetPositionRegardlessOfPivot(), m_BaseRectTransform.GetPositionRegardlessOfPivot(), f, 1f);
m_Ripple.SubmitSizeForSoftening();
if (m_Shadow)
{
m_PanelShadowCanvasGroup.alpha = Tween.QuintOut(1f, 0f, f, 0.5f);
}
m_PanelContentCanvasGroup.alpha = Tween.QuintOut(1f, 0f, f, 0.5f);
m_Ripple.color = m_Ripple.color.WithAlpha(Tween.QuintSoftOut(1f, 0f, f - 0.8f, 0.2f));
},
0f, 1f, m_AnimationDuration, tweenType: Tween.TweenType.Linear);
TweenManager.TimedCallback(m_AnimationDuration, m_Ripple.InstantContract);
TweenManager.TimedCallback(m_AnimationDuration * 0.5f, () => m_BaseRectTransform.gameObject.SetActive(true));
}
else if (m_FinalExpandMode == ExpandMode.Rectangular)
{
TweenManager.TweenFloat(f =>
{
if (m_ExpandedPosition.y > m_BaseRectTransform.position.y)
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintInOut(expandedSize.x, m_BaseRectTransform.sizeDelta.x, f, m_WidthDuration),
Tween.QuintSoftOut(expandedSize.y, m_BaseRectTransform.sizeDelta.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintInOut(expandedPosition.x, m_BaseRectTransform.GetPositionRegardlessOfPivot().x, f, m_WidthDuration),
Tween.QuintSoftOut(expandedPosition.y, m_BaseRectTransform.GetPositionRegardlessOfPivot().y, f, m_HeightDuration)));
}
else
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintSoftOut(expandedSize.x, m_BaseRectTransform.sizeDelta.x, f, m_WidthDuration),
Tween.QuintInOut(expandedSize.y, m_BaseRectTransform.sizeDelta.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintSoftOut(expandedPosition.x, m_BaseRectTransform.GetPositionRegardlessOfPivot().x, f, m_WidthDuration),
Tween.QuintInOut(expandedPosition.y, m_BaseRectTransform.GetPositionRegardlessOfPivot().y, f, m_HeightDuration)));
}
if (m_Shadow)
{
m_PanelShadowCanvasGroup.alpha = Tween.QuintOut(1f, 0f, f - 0.75f, 0.25f);
}
m_PanelContentCanvasGroup.alpha = Tween.QuintSoftOut(1f, 0f, f, 0.25f);
},
0f, 1f, m_AnimationDuration, tweenType: Tween.TweenType.Linear);
TweenManager.TimedCallback(m_AnimationDuration * 0.7f, () => m_BaseRectTransform.gameObject.SetActive(true));
}
else if (m_FinalExpandMode == ExpandMode.Hybrid)
{
Vector2 endPos = m_BaseRectTransform.GetPositionRegardlessOfPivot();
TweenManager.TweenFloat(f =>
{
if (m_ExpandedPosition.y > m_BaseRectTransform.position.y)
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintInOut(expandedSize.x, m_BaseRectTransform.sizeDelta.x, f, m_WidthDuration),
Tween.QuintSoftOut(expandedSize.y, m_BaseRectTransform.sizeDelta.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintInOut(expandedPosition.x, endPos.x, f, m_WidthDuration),
Tween.QuintSoftOut(expandedPosition.y, endPos.y, f, m_HeightDuration)));
}
else
{
m_PanelRootRectTransform.sizeDelta = new Vector2(
Tween.QuintSoftOut(expandedSize.x, m_BaseRectTransform.sizeDelta.x, f, m_WidthDuration),
Tween.QuintInOut(expandedSize.y, m_BaseRectTransform.sizeDelta.y, f, m_HeightDuration));
m_PanelRootRectTransform.SetPositionRegardlessOfPivot(new Vector2(
Tween.QuintSoftOut(expandedPosition.x, endPos.x, f, m_WidthDuration),
Tween.QuintInOut(expandedPosition.y, endPos.y, f, m_HeightDuration)));
}
m_MaskRect.sizeDelta = m_PanelRootRectTransform.sizeDelta;
m_MaskRect.position = m_PanelRootRectTransform.GetPositionRegardlessOfPivot();
m_Ripple.rectTransform.sizeDelta = Tween.QuintSoftOut(new Vector2(m_CircleExpandedSize, m_CircleExpandedSize), m_BaseRectTransform.sizeDelta, f, Mathf.Min(m_WidthDuration, m_HeightDuration));
m_Ripple.rectTransform.anchoredPosition = Vector2.zero;
m_Ripple.SubmitSizeForSoftening();
if (m_Shadow)
{
m_PanelShadowCanvasGroup.alpha = Tween.QuintOut(1f, 0f, f, 0.15f);
}
m_PanelContentCanvasGroup.alpha = Tween.QuintOut(1f, 0f, f, 0.15f);
m_Ripple.color = m_Ripple.color.WithAlpha(Tween.QuintSoftOut(1f, 0f, f - 0.8f, 0.2f));
},
0f, 1f, m_AnimationDuration, tweenType: Tween.TweenType.Linear);
TweenManager.TimedCallback(m_AnimationDuration, m_Ripple.InstantContract);
TweenManager.TimedCallback(m_AnimationDuration * 0.8f, () => m_BaseRectTransform.gameObject.SetActive(true));
}
if (m_DarkenBackground)
{
TweenManager.TweenColor(color => m_BackgroundImage.color = color, m_BackgroundImage.color, Color.clear, m_AnimationDuration * 0.5f, m_AnimationDuration * 0.5f, () => m_ClickableBackground.gameObject.SetActive(false), tweenType: Tween.TweenType.EaseInOutCubed);
}
TweenManager.TimedCallback(m_AnimationDuration, () => m_PanelRootRectTransform.gameObject.SetActive(false));
}
public virtual void AnimateHideBackground()
{
background.blocksRaycasts = false;
TweenManager.TweenFloat(f => background.alpha = f, background.alpha, 0f, m_AnimationDuration, 0f, () => UnityEngine.Object.Destroy(background.gameObject), false, Tween.TweenType.Linear);
}
public virtual void AnimateShowBackground()
{
background.blocksRaycasts = true;
TweenManager.TweenFloat(f => background.alpha = f, background.alpha, m_BackgroundAlpha, m_AnimationDuration);
}
private void ValidateText()
{
if (validationText == null)
{
return;
}
if (!m_ValidateOnStart && !m_HasBeenSelected)
{
return;
}
m_ValidationText.color = IsSelected() ? m_ValidationActiveColor : m_ValidationInactiveColor;
ITextValidator validator = null;
if (m_TextValidator != null && m_TextValidator.GetComponent <ITextValidator>() != null)
{
validator = m_TextValidator.GetComponent <ITextValidator>();
validator.Init(this);
}
if (m_CustomTextValidator != null)
{
validator = customTextValidator;
m_HasValidation = true;
}
if (validator != null && m_HasValidation)
{
TweenManager.EndTween(m_ValidationTweener);
if (!validator.IsTextValid())
{
if (Application.isPlaying)
{
validationCanvasGroup.gameObject.SetActive(true);
validationCanvasGroup.interactable = true;
validationCanvasGroup.blocksRaycasts = true;
m_ValidationTweener = TweenManager.TweenFloat(f => validationCanvasGroup.alpha = f, validationCanvasGroup.alpha, 1f, m_AnimationDuration / 2, tweenType: Tween.TweenType.Linear);
return;
}
}
else
{
if (Application.isPlaying)
{
m_ValidationTweener = TweenManager.TweenFloat(f => validationCanvasGroup.alpha = f, validationCanvasGroup.alpha, 0f, m_AnimationDuration / 2, 0, () =>
{
validationCanvasGroup.interactable = false;
validationCanvasGroup.blocksRaycasts = false;
validationCanvasGroup.gameObject.SetActive(false);
}, false, Tween.TweenType.Linear);
return;
}
}
}
validationCanvasGroup.alpha = 0;
validationCanvasGroup.interactable = false;
validationCanvasGroup.blocksRaycasts = false;
validationCanvasGroup.gameObject.SetActive(false);
}
