UnityEngine.EventSystems.UIBehaviour.IsActive()

Here are the examples of the csharp api UnityEngine.EventSystems.UIBehaviour.IsActive() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

71 Examples 7

19 Source : UISelectField.cs
with Apache License 2.0
from 365082218

protected virtual void ToggleList(bool state)
		{
			if (!this.IsActive())
				return;
			
			// Check if the list is not yet created
			if (this.m_ListObject == null)
				this.CreateList();
			
			// Make sure the creating of the list was successful
			if (this.m_ListObject == null)
				return;
			
			// Make sure we have the canvas group
			if (this.m_ListCanvasGroup != null)
			{
				// Disable or enable list interaction
				this.m_ListCanvasGroup.blocksRaycasts = state;
			}
			
			// Bring to front
			if (state) UIUtility.BringToFront(this.m_ListObject);
			
			// Start the opening/closing animation
			if (this.listAnimationType == ListAnimationType.None || this.listAnimationType == ListAnimationType.Fade)
			{
				float targetAlpha = (state ? 1f : 0f);
				
				// Fade In / Out
				this.TweenListAlpha(targetAlpha, ((this.listAnimationType == ListAnimationType.Fade) ? this.listAnimationDuration : 0f), true);
			}
			else if (this.listAnimationType == ListAnimationType.Animation)
			{
				this.TriggerListAnimation(state ? this.listAnimationOpenTrigger : this.listAnimationCloseTrigger);
			}
		}

19 Source : UISlotBase.cs
with Apache License 2.0
from 365082218

public virtual void OnPointerEnter(PointerEventData eventData)
		{
			this.isPointerInside = true;
			this.EvaluateAndTransitionHoveredState(false);
			
			// Check if tooltip is enabled
			if (this.enabled && this.IsActive() && this.m_TooltipEnabled)
			{
				// Start the tooltip delayed show coroutine
				// If delay is set at all
				if (this.m_TooltipDelay > 0f)
				{
					this.StartCoroutine("TooltipDelayedShow");
				}
				else
				{
					this.InternalShowTooltip();
				}
			}
		}

19 Source : UISlotBase.cs
with Apache License 2.0
from 365082218

protected bool IsHighlighted(BaseEventData eventData)
		{
			if (!this.IsActive())
				return false;

			if (eventData is PointerEventData)
			{
				PointerEventData pointerEventData = eventData as PointerEventData;
				return ((this.isPointerDown && !this.isPointerInside && pointerEventData.pointerPress == base.gameObject) || (!this.isPointerDown && this.isPointerInside && pointerEventData.pointerPress == base.gameObject) || (!this.isPointerDown && this.isPointerInside && pointerEventData.pointerPress == null));
			}
			
			return false;
		}

19 Source : UISlotBase.cs
with Apache License 2.0
from 365082218

protected bool IsPressed(BaseEventData eventData)
		{
			return this.IsActive() && this.isPointerInside && this.isPointerDown;
		}

19 Source : UISlotBase.cs
with Apache License 2.0
from 365082218

protected virtual void EvaluateAndTransitionHoveredState(bool instant)
		{
			if (!this.IsActive() || this.hoverTargetGraphic == null || !this.hoverTargetGraphic.gameObject.activeInHierarchy)
				return;
			
			// Determine what should the state of the hover target be
			bool highlighted = (this.m_PressForceHoverNormal ? (this.isPointerInside && !this.isPointerDown) : this.isPointerInside);
			
			// Do the transition
			switch (this.hoverTransition)
			{
				case Transition.ColorTint:
				{
					this.StartColorTween(this.hoverTargetGraphic, (highlighted ? this.hoverHighlightColor : this.hoverNormalColor), (instant ? 0f : this.hoverTransitionDuration));
					break;
				}
				case Transition.SpriteSwap:
				{
					this.DoSpriteSwap(this.hoverTargetGraphic, (highlighted ? this.hoverOverrideSprite : null));
					break;
				}
				case Transition.Animation:
				{
					this.TriggerHoverStateAnimation(highlighted ? this.hoverHighlightTrigger : this.hoverNormalTrigger);
					break;
				}
			}
		}

19 Source : UISlotBase.cs
with Apache License 2.0
from 365082218

protected virtual void EvaluateAndTransitionPressedState(bool instant)
		{
			if (!this.IsActive() || this.pressTargetGraphic == null || !this.pressTargetGraphic.gameObject.activeInHierarchy)
				return;
			
			// Do the transition
			switch (this.pressTransition)
			{
				case Transition.ColorTint:
				{
					this.StartColorTween(this.pressTargetGraphic, (this.isPointerDown ? this.pressPressColor : this.pressNormalColor), (instant ? 0f : this.pressTransitionDuration));
					break;
				}
				case Transition.SpriteSwap:
				{
					this.DoSpriteSwap(this.pressTargetGraphic, (this.isPointerDown ? this.pressOverrideSprite : null));
					break;
				}
				case Transition.Animation:
				{
					this.TriggerPressStateAnimation(this.isPointerDown ? this.pressPressTrigger : this.pressNormalTrigger);
					break;
				}
			}
			
			// If we should force normal state transition on the hover target
			if (this.m_PressForceHoverNormal)
				this.EvaluateAndTransitionHoveredState(false);
		}

19 Source : UISelectField.cs
with Apache License 2.0
from 365082218

protected virtual void ListDimensionsChanged()
		{
			if (!this.IsActive() || this.m_ListObject == null)
				return;
			
			// Check if the list size has changed
			if (this.m_LastListSize.Equals((this.m_ListObject.transform as RectTransform).sizeDelta))
				return;
			
			// Update the last list size
			this.m_LastListSize = (this.m_ListObject.transform as RectTransform).sizeDelta;
			
			// Update the list direction
			this.PositionListForDirection(this.m_Direction);
		}

19 Source : UIDragObject.cs
with Apache License 2.0
from 365082218

public override bool IsActive()
        {
            return base.IsActive() && this.m_Target != null;
        }

19 Source : UISliderExtended.cs
with Apache License 2.0
from 365082218

protected override void OnRectTransformDimensionsChange()
		{
			base.OnRectTransformDimensionsChange();
			
			if (!this.IsActive())
				return;
				
			this.UpdateGridProperties();
		}

19 Source : UISliderExtended.cs
with Apache License 2.0
from 365082218

public void OnValueChanged(float value)
		{
			if (!this.IsActive() || !this.HasOptions())
				return;
			
			// Transition
			if (this.m_OptionTransition == Transition.ColorTint)
			{
				// Transition out the current selected option
				Graphic currentTarget = 
					(this.m_OptionTransitionTarget == TransitionTarget.Text) ? 
						(this.m_CurrentOptionGameObject.GetComponentInChildren<Text>() as Graphic) : 
						(this.m_CurrentOptionGameObject.GetComponent<Image>() as Graphic);
				
				// Transition the current target to normal state
				this.StartColorTween(currentTarget, (this.m_OptionTransitionColorNormal * this.m_OptionTransitionMultiplier), this.m_OptionTransitionDuration);
				
				// Get the new value option index
				int newOptionIndex = Mathf.RoundToInt(value);
				
				// Validate the index
				if (newOptionIndex < 0 || newOptionIndex >= this.m_Options.Count)
					newOptionIndex = 0;
				
				// Get the new selected option game object
				GameObject newOptionGameObject = this.m_OptionGameObjects[newOptionIndex];
				
				if (newOptionGameObject != null)
				{
					Graphic newTarget = 
						(this.m_OptionTransitionTarget == TransitionTarget.Text) ? 
							(newOptionGameObject.GetComponentInChildren<Text>() as Graphic) : 
							(newOptionGameObject.GetComponent<Image>() as Graphic);
					
					// Transition the new target to active state
					this.StartColorTween(newTarget, (this.m_OptionTransitionColorActive * this.m_OptionTransitionMultiplier), this.m_OptionTransitionDuration);
				}
				
				// Save the new option game object
				this.m_CurrentOptionGameObject = newOptionGameObject;
			}
		}

19 Source : UISliderExtended.cs
with Apache License 2.0
from 365082218

protected void ValidateOptions()
		{
			if (!this.IsActive())
				return;
			
			if (!this.HasOptions())
			{
				// Destroy the options container if we have one
				if (this.m_OptionsContGameObject != null)
				{
					if (Application.isPlaying)
						Destroy(this.m_OptionsContGameObject);
					else
						DestroyImmediate(this.m_OptionsContGameObject);
				}
				return;
			}
			
			// Make sure we have the options container
			if (this.m_OptionsContGameObject == null)
				this.CreateOptionsContainer();
			
			// Make sure we use whole numbers when using options
			if (!this.wholeNumbers)
				this.wholeNumbers = true;
			
			// Make sure the max value is the options count, when using options
			this.minValue = 0f;
			this.maxValue = ((float)this.m_Options.Count - 1f);
			
			// Update the grid properties
			this.UpdateGridProperties();
			
			// Update the options properties
			this.UpdateOptionsProperties();
		}

19 Source : UITab.cs
with Apache License 2.0
from 365082218

protected void OnToggleStateChanged(bool state)
		{
			if (!this.IsActive() || !Application.isPlaying)
				return;
			
			this.InternalEvaluateAndTransitionState(false);
		}

19 Source : BoxSlider.cs
with GNU General Public License v3.0
from ARPOISE

protected override void OnRectTransformDimensionsChange()
		{
			base.OnRectTransformDimensionsChange();
			//This can be invoked before OnEnabled is called. So we shouldn't be accessing other objects, before OnEnable is called.
			if (!IsActive())
				return;
			UpdateVisuals();
		}

19 Source : BoxSlider.cs
with GNU General Public License v3.0
from ARPOISE

private bool MayDrag(PointerEventData eventData)
		{
			return IsActive() && IsInteractable() && eventData.button == PointerEventData.InputButton.Left;
		}

19 Source : TMP_Dropdown.cs
with MIT License
from ashishgopalhattimare

public void Show()
        {
            if (!IsActive() || !IsInteractable() || m_Dropdown != null)
                return;

            if (!validTemplate)
            {
                SetupTemplate();
                if (!validTemplate)
                    return;
            }

            // Get root Canvas.
            var list = TMP_ListPool<Canvas>.Get();
            gameObject.GetComponentsInParent(false, list);
            if (list.Count == 0)
                return;
            Canvas rootCanvas = list[0];
            TMP_ListPool<Canvas>.Release(list);

            m_Template.gameObject.SetActive(true);

            // Instantiate the drop-down template
            m_Dropdown = CreateDropdownList(m_Template.gameObject);
            m_Dropdown.name = "Dropdown List";
            m_Dropdown.SetActive(true);

            // Make drop-down RectTransform have same values as original.
            RectTransform dropdownRectTransform = m_Dropdown.transform as RectTransform;
            dropdownRectTransform.SetParent(m_Template.transform.parent, false);

            // Instantiate the drop-down list items

            // Find the dropdown item and disable it.
            DropdownItem itemTemplate = m_Dropdown.GetComponentInChildren<DropdownItem>();

            GameObject content = itemTemplate.rectTransform.parent.gameObject;
            RectTransform contentRectTransform = content.transform as RectTransform;
            itemTemplate.rectTransform.gameObject.SetActive(true);

            // Get the rects of the dropdown and item
            Rect dropdownContentRect = contentRectTransform.rect;
            Rect itemTemplateRect = itemTemplate.rectTransform.rect;

            // Calculate the visual offset between the item's edges and the background's edges
            Vector2 offsetMin = itemTemplateRect.min - dropdownContentRect.min + (Vector2)itemTemplate.rectTransform.localPosition;
            Vector2 offsetMax = itemTemplateRect.max - dropdownContentRect.max + (Vector2)itemTemplate.rectTransform.localPosition;
            Vector2 itemSize = itemTemplateRect.size;

            m_Items.Clear();

            Toggle prev = null;
            for (int i = 0; i < options.Count; ++i)
            {
                OptionData data = options[i];
                DropdownItem item = AddItem(data, value == i, itemTemplate, m_Items);
                if (item == null)
                    continue;

                // Automatically set up a toggle state change listener
                item.toggle.isOn = value == i;
                item.toggle.onValueChanged.AddListener(x => OnSelecreplacedem(item.toggle));

                // Select current option
                if (item.toggle.isOn)
                    item.toggle.Select();

                // Automatically set up explicit navigation
                if (prev != null)
                {
                    Navigation prevNav = prev.navigation;
                    Navigation toggleNav = item.toggle.navigation;
                    prevNav.mode = Navigation.Mode.Explicit;
                    toggleNav.mode = Navigation.Mode.Explicit;

                    prevNav.selectOnDown = item.toggle;
                    prevNav.selectOnRight = item.toggle;
                    toggleNav.selectOnLeft = prev;
                    toggleNav.selectOnUp = prev;

                    prev.navigation = prevNav;
                    item.toggle.navigation = toggleNav;
                }
                prev = item.toggle;
            }

            // Reposition all items now that all of them have been added
            Vector2 sizeDelta = contentRectTransform.sizeDelta;
            sizeDelta.y = itemSize.y * m_Items.Count + offsetMin.y - offsetMax.y;
            contentRectTransform.sizeDelta = sizeDelta;

            float extraSpace = dropdownRectTransform.rect.height - contentRectTransform.rect.height;
            if (extraSpace > 0)
                dropdownRectTransform.sizeDelta = new Vector2(dropdownRectTransform.sizeDelta.x, dropdownRectTransform.sizeDelta.y - extraSpace);

            // Invert anchoring and position if dropdown is partially or fully outside of canvas rect.
            // Typically this will have the effect of placing the dropdown above the button instead of below,
            // but it works as inversion regardless of initial setup.
            Vector3[] corners = new Vector3[4];
            dropdownRectTransform.GetWorldCorners(corners);

            RectTransform rootCanvasRectTransform = rootCanvas.transform as RectTransform;
            Rect rootCanvasRect = rootCanvasRectTransform.rect;
            for (int axis = 0; axis < 2; axis++)
            {
            bool outside = false;
            for (int i = 0; i < 4; i++)
            {
                Vector3 corner = rootCanvasRectTransform.InverseTransformPoint(corners[i]);
                    if (corner[axis] < rootCanvasRect.min[axis] || corner[axis] > rootCanvasRect.max[axis])
                {
                    outside = true;
                    break;
                }
            }
            if (outside)
                    RectTransformUtility.FlipLayoutOnAxis(dropdownRectTransform, axis, false, false);
            }

            for (int i = 0; i < m_Items.Count; i++)
            {
                RectTransform itemRect = m_Items[i].rectTransform;
                itemRect.anchorMin = new Vector2(itemRect.anchorMin.x, 0);
                itemRect.anchorMax = new Vector2(itemRect.anchorMax.x, 0);
                itemRect.ancreplaceddPosition = new Vector2(itemRect.ancreplaceddPosition.x, offsetMin.y + itemSize.y * (m_Items.Count - 1 - i) + itemSize.y * itemRect.pivot.y);
                itemRect.sizeDelta = new Vector2(itemRect.sizeDelta.x, itemSize.y);
            }

            // Fade in the popup
            AlphaFadeList(0.15f, 0f, 1f);

            // Make drop-down template and item template inactive
            m_Template.gameObject.SetActive(false);
            itemTemplate.gameObject.SetActive(false);

            m_Blocker = CreateBlocker(rootCanvas);
        }

19 Source : TMP_SubMeshUI.cs
with MIT License
from ashishgopalhattimare

protected override void OnTransformParentChanged()
        {
            if (!this.IsActive())
                return;

            m_ShouldRecalculateStencil = true;
            RecalculateClipping();
            RecalculateMasking();
        }

19 Source : TMP_SubMeshUI.cs
with MIT License
from ashishgopalhattimare

public override void SetVerticesDirty()
        {
            if (!this.IsActive())
                return;

            // This is called on the parent TextMeshPro component.
            if (m_TextComponent != null)
            {
                m_TextComponent.havePropertiesChanged = true;
                m_TextComponent.SetVerticesDirty();
            }
        }

19 Source : TMP_Dropdown.cs
with MIT License
from ashishgopalhattimare

public void Hide()
        {
            if (m_Dropdown != null)
            {
                AlphaFadeList(0.15f, 0f);

                // User could have disabled the dropdown during the OnValueChanged call.
                if (IsActive())
                StartCoroutine(DelayedDestroyDropdownList(0.15f));
            }
            if (m_Blocker != null)
                DestroyBlocker(m_Blocker);
            m_Blocker = null;
            Select();
        }

19 Source : TMP_SubMeshUI.cs
with MIT License
from ashishgopalhattimare

public void SetPivotDirty()
        {
            if (!this.IsActive())
                return;

            this.rectTransform.pivot = m_TextComponent.rectTransform.pivot;
        }

19 Source : TMP_Dropdown.cs
with MIT License
from BattleDawnNZ

public void Hide()
        {
            if (m_Dropdown != null)
            {
                AlphaFadeList(0.15f, 0f);

                // User could have disabled the dropdown during the OnValueChanged call.
                if (IsActive())
                    StartCoroutine(DelayedDestroyDropdownList(0.15f));
            }
            if (m_Blocker != null)
                DestroyBlocker(m_Blocker);
            m_Blocker = null;
            Select();
        }

19 Source : TMP_Dropdown.cs
with MIT License
from BattleDawnNZ

public void Show()
        {
            if (!IsActive() || !IsInteractable() || m_Dropdown != null)
                return;

            // Get root Canvas.
            var list = TMP_ListPool<Canvas>.Get();
            gameObject.GetComponentsInParent(false, list);
            if (list.Count == 0)
                return;

            Canvas rootCanvas = list[list.Count - 1];
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i].isRootCanvas)
                {
                    rootCanvas = list[i];
                    break;
                }
            }

            TMP_ListPool<Canvas>.Release(list);

            if (!validTemplate)
            {
                SetupTemplate();
                if (!validTemplate)
                    return;
            }

            m_Template.gameObject.SetActive(true);

            // popupCanvas used to replacedume the root canvas had the default sorting Layer, next line fixes (case 958281 - [UI] Dropdown list does not copy the parent canvas layer when the panel is opened)
            m_Template.GetComponent<Canvas>().sortingLayerID = rootCanvas.sortingLayerID;

            // Instantiate the drop-down template
            m_Dropdown = CreateDropdownList(m_Template.gameObject);
            m_Dropdown.name = "Dropdown List";
            m_Dropdown.SetActive(true);

            // Make drop-down RectTransform have same values as original.
            RectTransform dropdownRectTransform = m_Dropdown.transform as RectTransform;
            dropdownRectTransform.SetParent(m_Template.transform.parent, false);

            // Instantiate the drop-down list items

            // Find the dropdown item and disable it.
            DropdownItem itemTemplate = m_Dropdown.GetComponentInChildren<DropdownItem>();

            GameObject content = itemTemplate.rectTransform.parent.gameObject;
            RectTransform contentRectTransform = content.transform as RectTransform;
            itemTemplate.rectTransform.gameObject.SetActive(true);

            // Get the rects of the dropdown and item
            Rect dropdownContentRect = contentRectTransform.rect;
            Rect itemTemplateRect = itemTemplate.rectTransform.rect;

            // Calculate the visual offset between the item's edges and the background's edges
            Vector2 offsetMin = itemTemplateRect.min - dropdownContentRect.min + (Vector2)itemTemplate.rectTransform.localPosition;
            Vector2 offsetMax = itemTemplateRect.max - dropdownContentRect.max + (Vector2)itemTemplate.rectTransform.localPosition;
            Vector2 itemSize = itemTemplateRect.size;

            m_Items.Clear();

            Toggle prev = null;
            for (int i = 0; i < options.Count; ++i)
            {
                OptionData data = options[i];
                DropdownItem item = AddItem(data, value == i, itemTemplate, m_Items);
                if (item == null)
                    continue;

                // Automatically set up a toggle state change listener
                item.toggle.isOn = value == i;
                item.toggle.onValueChanged.AddListener(x => OnSelecreplacedem(item.toggle));

                // Select current option
                if (item.toggle.isOn)
                    item.toggle.Select();

                // Automatically set up explicit navigation
                if (prev != null)
                {
                    Navigation prevNav = prev.navigation;
                    Navigation toggleNav = item.toggle.navigation;
                    prevNav.mode = Navigation.Mode.Explicit;
                    toggleNav.mode = Navigation.Mode.Explicit;

                    prevNav.selectOnDown = item.toggle;
                    prevNav.selectOnRight = item.toggle;
                    toggleNav.selectOnLeft = prev;
                    toggleNav.selectOnUp = prev;

                    prev.navigation = prevNav;
                    item.toggle.navigation = toggleNav;
                }
                prev = item.toggle;
            }

            // Reposition all items now that all of them have been added
            Vector2 sizeDelta = contentRectTransform.sizeDelta;
            sizeDelta.y = itemSize.y * m_Items.Count + offsetMin.y - offsetMax.y;
            contentRectTransform.sizeDelta = sizeDelta;

            float extraSpace = dropdownRectTransform.rect.height - contentRectTransform.rect.height;
            if (extraSpace > 0)
                dropdownRectTransform.sizeDelta = new Vector2(dropdownRectTransform.sizeDelta.x, dropdownRectTransform.sizeDelta.y - extraSpace);

            // Invert anchoring and position if dropdown is partially or fully outside of canvas rect.
            // Typically this will have the effect of placing the dropdown above the button instead of below,
            // but it works as inversion regardless of initial setup.
            Vector3[] corners = new Vector3[4];
            dropdownRectTransform.GetWorldCorners(corners);

            RectTransform rootCanvasRectTransform = rootCanvas.transform as RectTransform;
            Rect rootCanvasRect = rootCanvasRectTransform.rect;
            for (int axis = 0; axis < 2; axis++)
            {
                bool outside = false;
                for (int i = 0; i < 4; i++)
                {
                    Vector3 corner = rootCanvasRectTransform.InverseTransformPoint(corners[i]);
                    if ((corner[axis] < rootCanvasRect.min[axis] && !Mathf.Approximately(corner[axis], rootCanvasRect.min[axis])) ||
                        (corner[axis] > rootCanvasRect.max[axis] && !Mathf.Approximately(corner[axis], rootCanvasRect.max[axis])))
                    {
                        outside = true;
                        break;
                    }
                }
                if (outside)
                    RectTransformUtility.FlipLayoutOnAxis(dropdownRectTransform, axis, false, false);
            }

            for (int i = 0; i < m_Items.Count; i++)
            {
                RectTransform itemRect = m_Items[i].rectTransform;
                itemRect.anchorMin = new Vector2(itemRect.anchorMin.x, 0);
                itemRect.anchorMax = new Vector2(itemRect.anchorMax.x, 0);
                itemRect.ancreplaceddPosition = new Vector2(itemRect.ancreplaceddPosition.x, offsetMin.y + itemSize.y * (m_Items.Count - 1 - i) + itemSize.y * itemRect.pivot.y);
                itemRect.sizeDelta = new Vector2(itemRect.sizeDelta.x, itemSize.y);
            }

            // Fade in the popup
            AlphaFadeList(0.15f, 0f, 1f);

            // Make drop-down template and item template inactive
            m_Template.gameObject.SetActive(false);
            itemTemplate.gameObject.SetActive(false);

            m_Blocker = CreateBlocker(rootCanvas);
        }

19 Source : UnityEngine_EventSystems_UIBehaviourWrap.cs
with MIT License
from bjfumac

[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int IsActive(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			UnityEngine.EventSystems.UIBehaviour obj = (UnityEngine.EventSystems.UIBehaviour)ToLua.CheckObject<UnityEngine.EventSystems.UIBehaviour>(L, 1);
			bool o = obj.IsActive();
			LuaDLL.lua_pushboolean(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

19 Source : MirrorImage.cs
with MIT License
from BlueMonk1107

public override void ModifyMesh(VertexHelper vh)
    {
        if(!IsActive())
            return;
        IMirror mirror = GetMirrorObject();
        vh.GetUIVertexStream(_vertices);
        mirror.Draw(_vertices);
        vh.Clear();
        vh.AddUIVertexTriangleStream(_vertices);
    }

19 Source : WordShowEffect.cs
with MIT License
from BlueMonk1107

public override void ModifyMesh(VertexHelper vh)
    {
        if (!IsActive())
            return;
        
        if (_oldText != _text.text)
        {
            _oldText = _text.text;
            Run();
        }
        
        if(_wordAlphaEffect == null)
            return;

        _wordAlphaEffect.ModifyMesh(vh,_currentWordIndex,_updateNum);
    }

19 Source : BoxSlider.cs
with GNU General Public License v2.0
from Caeden117

private bool MayDrag(PointerEventData eventData) =>
            IsActive() && IsInteractable() && eventData.button == PointerEventData.InputButton.Left;

19 Source : BoxSlider.cs
with MIT License
from cmaher

private bool CanDrag(PointerEventData eventData)
        {
            return IsActive() && IsInteractable() && eventData.button == PointerEventData.InputButton.Left;
        }

19 Source : Segment.cs
with MIT License
from cmaher

private void SetSelected(bool value)
        {
            if (value && button.IsActive() && button.IsInteractable())
            {
                if (segmentedControl.selectedSegment == this.button)
                {
                    if (segmentedControl.allowSwitchingOff)
                    {
                        Deselect();
                    }
                    else
                    {
                        MaintainSelection();
                    }
                }
                else
                {
                    if (segmentedControl.selectedSegment)
                    {
                        var segment = segmentedControl.selectedSegment.GetComponent<Segment>();
                        segmentedControl.selectedSegment = null;
                        if (segment)
                        {
                            segment.TransitionButton();
                        }
                    }

                    segmentedControl.selectedSegment = this.button;
                    TransitionButton();
                    segmentedControl.onValueChanged.Invoke(index);
                }
            }
            else if (segmentedControl.selectedSegment == this.button)
            {
                Deselect();
            }
        }

19 Source : StepperSide.cs
with MIT License
from cmaher

private void Press()
        {
            if (!button.IsActive() || !button.IsInteractable())
                return;

            if (leftmost)
            {
                stepper.StepDown();
            }
            else
            {
                stepper.StepUp();
            }
        }

19 Source : CUIGraphic.cs
with MIT License
from cmaher

protected virtual void modifyVertices(List<UIVertex> _verts)
        {
            if (!IsActive())
                return;

            tessellateGraphic(_verts);

            if (!isCurved)
            {
                return;
            }

            for (int index = 0; index < _verts.Count; index++)
            {
                var uiVertex = _verts[index];

                // finding the horizontal ratio position (0.0 - 1.0) of a vertex
                float horRatio = (uiVertex.position.x + rectTrans.rect.width * rectTrans.pivot.x) / rectTrans.rect.width;
                float verRatio = (uiVertex.position.y + rectTrans.rect.height * rectTrans.pivot.y) / rectTrans.rect.height;

                //Vector3 pos = Vector3.Lerp(refCurves[0].GetPoint(horRatio), refCurves[1].GetPoint(horRatio), verRatio);
                Vector3 pos = GetBCurveSandwichSpacePoint(horRatio, verRatio);

                uiVertex.position.x = pos.x;
                uiVertex.position.y = pos.y;
                uiVertex.position.z = pos.z;

                _verts[index] = uiVertex;
            }
        }

19 Source : BestFitOutline.cs
with MIT License
from cmaher

public override void ModifyMesh (Mesh mesh)
		{
			if (!this.IsActive ())
			{
				return;
			}

            List<UIVertex> verts = new List<UIVertex>();
            using (var helper = new VertexHelper(mesh))
            {
                helper.GetUIVertexStream(verts);
            }

            Text foundtext = GetComponent<Text>();

			float best_fit_adjustment = 1f;

			if (foundtext && foundtext.resizeTextForBestFit)  
			{
				best_fit_adjustment = (float)foundtext.cachedTextGenerator.fontSizeUsedForBestFit / (foundtext.resizeTextMaxSize-1); //max size seems to be exclusive 
			}
			
			int start = 0;
			int count = verts.Count;
			base.ApplyShadowZeroAlloc(verts, base.effectColor, start, verts.Count, base.effectDistance.x*best_fit_adjustment, base.effectDistance.y*best_fit_adjustment);
			start = count;
			count = verts.Count;
			base.ApplyShadowZeroAlloc(verts, base.effectColor, start, verts.Count, base.effectDistance.x*best_fit_adjustment, -base.effectDistance.y*best_fit_adjustment);
			start = count;
			count = verts.Count;
			base.ApplyShadowZeroAlloc(verts, base.effectColor, start, verts.Count, -base.effectDistance.x*best_fit_adjustment, base.effectDistance.y*best_fit_adjustment);
			start = count;
			count = verts.Count;
			base.ApplyShadowZeroAlloc(verts, base.effectColor, start, verts.Count, -base.effectDistance.x*best_fit_adjustment, -base.effectDistance.y*best_fit_adjustment);

            using (var helper = new VertexHelper())
            {
                helper.AddUIVertexTriangleStream(verts);
                helper.FillMesh(mesh);
            }
        }

19 Source : CurvedText.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper vh)
        {
            int count = vh.currentVertCount;
            if (!IsActive() || count == 0)
            {
                return;
            }
            for (int index = 0; index < vh.currentVertCount; index++)
            {
                UIVertex uiVertex = new UIVertex();
                vh.PopulateUIVertex(ref uiVertex, index);
                uiVertex.position.y += _curveForText.Evaluate(rectTrans.rect.width * rectTrans.pivot.x + uiVertex.position.x) * _curveMultiplier;
                vh.SetUIVertex(uiVertex, index);
            }
        }

19 Source : CylinderText.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper vh)
        {
            if (! IsActive()) return;

            int count = vh.currentVertCount;
            if (!IsActive() || count == 0)
            {
                return;
            }
            for (int index = 0; index < vh.currentVertCount; index++)
            {
                UIVertex uiVertex = new UIVertex();
                vh.PopulateUIVertex(ref uiVertex, index);

                // get x position
                var x = uiVertex.position.x;                

                // calculate bend based on pivot and radius
                uiVertex.position.z = -radius * Mathf.Cos(x / radius);
                uiVertex.position.x = radius * Mathf.Sin(x / radius);
                
                vh.SetUIVertex(uiVertex, index);
            }
        }

19 Source : LetterSpacing.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper vh)
        {
            if (! IsActive()) return;

            List<UIVertex> verts = new List<UIVertex>();
            vh.GetUIVertexStream(verts);

            Text text = GetComponent<Text>();
			if (text == null)
			{
				Debug.LogWarning("LetterSpacing: Missing Text component");
				return;
			}
			
			string[] lines = text.text.Split('\n');
			Vector3  pos;
			float    letterOffset    = spacing * (float)text.fontSize / 100f;
			float    alignmentFactor = 0;
			int      glyphIdx        = 0;
			
			switch (text.alignment)
			{
			case TextAnchor.LowerLeft:
			case TextAnchor.MiddleLeft:
			case TextAnchor.UpperLeft:
				alignmentFactor = 0f;
				break;
				
			case TextAnchor.LowerCenter:
			case TextAnchor.MiddleCenter:
			case TextAnchor.UpperCenter:
				alignmentFactor = 0.5f;
				break;
				
			case TextAnchor.LowerRight:
			case TextAnchor.MiddleRight:
			case TextAnchor.UpperRight:
				alignmentFactor = 1f;
				break;
			}
			
			for (int lineIdx=0; lineIdx < lines.Length; lineIdx++)
			{
				string line = lines[lineIdx];
				float lineOffset = (line.Length -1) * letterOffset * alignmentFactor;

				for (int charIdx = 0; charIdx < line.Length; charIdx++)
				{
					int idx1 = glyphIdx * 6 + 0;
					int idx2 = glyphIdx * 6 + 1;
					int idx3 = glyphIdx * 6 + 2;
					int idx4 = glyphIdx * 6 + 3;
                    int idx5 = glyphIdx * 6 + 4;
                    int idx6 = glyphIdx * 6 + 5;

                    // Check for truncated text (doesn't generate verts for all characters)
                    if (idx6 > verts.Count - 1) return;

                    UIVertex vert1 = verts[idx1];
                    UIVertex vert2 = verts[idx2];
                    UIVertex vert3 = verts[idx3];
                    UIVertex vert4 = verts[idx4];
                    UIVertex vert5 = verts[idx5];
                    UIVertex vert6 = verts[idx6];

                    pos = Vector3.right * (letterOffset * charIdx - lineOffset);

                    vert1.position += pos;
                    vert2.position += pos;
                    vert3.position += pos;
                    vert4.position += pos;
                    vert5.position += pos;
                    vert6.position += pos;

                    verts[idx1] = vert1;
					verts[idx2] = vert2;
					verts[idx3] = vert3;
					verts[idx4] = vert4;
                    verts[idx5] = vert5;
                    verts[idx6] = vert6;

                    glyphIdx++;
				}
				
				// Offset for carriage return character that still generates verts
				glyphIdx++;
			}
            vh.Clear();
            vh.AddUIVertexTriangleStream(verts);
        }

19 Source : MonoSpacing.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper vh)
        {
            if (! IsActive()) return;

            List<UIVertex> verts = new List<UIVertex>();
            vh.GetUIVertexStream(verts);
			
			string[] lines = text.text.Split('\n');
			// Vector3  pos;
			float    letterOffset    = Spacing * (float)text.fontSize / 100f;
			float    alignmentFactor = 0;
			int      glyphIdx        = 0;
			
			switch (text.alignment)
			{
			case TextAnchor.LowerLeft:
			case TextAnchor.MiddleLeft:
			case TextAnchor.UpperLeft:
				alignmentFactor = 0f;
				break;
				
			case TextAnchor.LowerCenter:
			case TextAnchor.MiddleCenter:
			case TextAnchor.UpperCenter:
				alignmentFactor = 0.5f;
				break;
				
			case TextAnchor.LowerRight:
			case TextAnchor.MiddleRight:
			case TextAnchor.UpperRight:
				alignmentFactor = 1f;
				break;
			}
			
			for (int lineIdx=0; lineIdx < lines.Length; lineIdx++)
			{
				string line = lines[lineIdx];
                float lineOffset = (line.Length - 1) * letterOffset * (alignmentFactor) - (alignmentFactor - 0.5f) * rectTransform.rect.width;

                var offsetX = -lineOffset + letterOffset / 2 * (1 - alignmentFactor * 2);

				for (int charIdx = 0; charIdx < line.Length; charIdx++)
				{
					int idx1 = glyphIdx * 6 + 0;
					int idx2 = glyphIdx * 6 + 1;
					int idx3 = glyphIdx * 6 + 2;
					int idx4 = glyphIdx * 6 + 3;
                    int idx5 = glyphIdx * 6 + 4;
                    int idx6 = glyphIdx * 6 + 5;

                    // Check for truncated text (doesn't generate verts for all characters)
                    if (idx6 > verts.Count - 1) return;

                    UIVertex vert1 = verts[idx1];
                    UIVertex vert2 = verts[idx2];
                    UIVertex vert3 = verts[idx3];
                    UIVertex vert4 = verts[idx4];
                    UIVertex vert5 = verts[idx5];
                    UIVertex vert6 = verts[idx6];

                    // pos = Vector3.right * (letterOffset * (charIdx) - lineOffset);
                    float charWidth = (vert2.position - vert1.position).x;
                    var smallChar = UseHalfCharWidth && (charWidth < HalfCharWidth);

                    var smallCharOffset = smallChar ? -letterOffset/4 : 0;
                    
                    vert1.position += new Vector3(-vert1.position.x + offsetX + -.5f * charWidth + smallCharOffset, 0, 0);
                    vert2.position += new Vector3(-vert2.position.x + offsetX + .5f * charWidth + smallCharOffset, 0, 0);
                    vert3.position += new Vector3(-vert3.position.x + offsetX + .5f * charWidth + smallCharOffset, 0, 0);
                    vert4.position += new Vector3(-vert4.position.x + offsetX + .5f * charWidth + smallCharOffset, 0, 0);
                    vert5.position += new Vector3(-vert5.position.x + offsetX + -.5f * charWidth + smallCharOffset, 0, 0);
                    vert6.position += new Vector3(-vert6.position.x + offsetX + -.5f * charWidth + smallCharOffset, 0, 0);

                    if (smallChar)
                        offsetX += letterOffset / 2;
                    else
                        offsetX += letterOffset;

                    verts[idx1] = vert1;
					verts[idx2] = vert2;
					verts[idx3] = vert3;
					verts[idx4] = vert4;
                    verts[idx5] = vert5;
                    verts[idx6] = vert6;

                    glyphIdx++;
				}
				
				// Offset for carriage return character that still generates verts
				glyphIdx++;
			}
            vh.Clear();
            vh.AddUIVertexTriangleStream(verts);
        }

19 Source : NicerOutline.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper vh)
        {
            if (!this.IsActive ())
			{
				return;
			}

	        m_Verts.Clear();
            vh.GetUIVertexStream(m_Verts);

            Text foundtext = GetComponent<Text>();

			float best_fit_adjustment = 1f;

			if (foundtext && foundtext.resizeTextForBestFit)
			{
				best_fit_adjustment = (float)foundtext.cachedTextGenerator.fontSizeUsedForBestFit / (foundtext.resizeTextMaxSize-1); //max size seems to be exclusive

			}

			float distanceX = this.effectDistance.x * best_fit_adjustment;
			float distanceY = this.effectDistance.y * best_fit_adjustment;

			int start = 0;
			int count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, distanceX, distanceY);
			start = count;
			count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, distanceX, -distanceY);
			start = count;
			count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, -distanceX, distanceY);
			start = count;
			count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, -distanceX, -distanceY);

			start = count;
			count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, distanceX, 0);
			start = count;
			count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, -distanceX, 0);

			start = count;
			count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, 0, distanceY);
			start = count;
			count = m_Verts.Count;
			this.ApplyShadow (m_Verts, this.effectColor, start, m_Verts.Count, 0, -distanceY);

            vh.Clear();
            vh.AddUIVertexTriangleStream(m_Verts);
        }

19 Source : CUIGraphic.cs
with MIT License
from cmaher

public override void ModifyMesh(Mesh _mesh)
        {

            if (!IsActive())
                return;

            using (VertexHelper vh = new VertexHelper(_mesh))
            {
                ModifyMesh(vh);
                vh.FillMesh(_mesh);
            }

        }

19 Source : CUIGraphic.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper _vh)
        {

            if (!IsActive())
                return;

            List<UIVertex> vertexList = new List<UIVertex>();
            _vh.GetUIVertexStream(vertexList);

            modifyVertices(vertexList);

            _vh.Clear();
            _vh.AddUIVertexTriangleStream(vertexList);
        }

19 Source : Gradient.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper vh)
        {
            int count = vh.currentVertCount;
            if (!IsActive() || count == 0)
            {
                return;
            }
            var vertexList = new List<UIVertex>();
            vh.GetUIVertexStream(vertexList);
            UIVertex uiVertex = new UIVertex();
            if (_gradientMode == GradientMode.Global)
            {
                if (_gradientDir == GradientDir.DiagonalLeftToRight || _gradientDir == GradientDir.DiagonalRightToLeft)
                {
#if UNITY_EDITOR
                    Debug.LogWarning("Diagonal dir is not supported in Global mode");
#endif
                    _gradientDir = GradientDir.Vertical;
                }
                float bottomY = _gradientDir == GradientDir.Vertical ? vertexList[vertexList.Count - 1].position.y : vertexList[vertexList.Count - 1].position.x;
                float topY = _gradientDir == GradientDir.Vertical ? vertexList[0].position.y : vertexList[0].position.x;

                float uiElementHeight = topY - bottomY;

                for (int i = 0; i < count; i++)
                {
                    vh.PopulateUIVertex(ref uiVertex, i);
                    if (!_overwriteAllColor && uiVertex.color != targetGraphic.color)
                        continue;
                    uiVertex.color *= Color.Lerp(_vertex2, _vertex1, ((_gradientDir == GradientDir.Vertical ? uiVertex.position.y : uiVertex.position.x) - bottomY) / uiElementHeight);
                    vh.SetUIVertex(uiVertex, i);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    vh.PopulateUIVertex(ref uiVertex, i);
                    if (!_overwriteAllColor && !CompareCarefully(uiVertex.color, targetGraphic.color))
                        continue;
                    switch (_gradientDir)
                    {
                        case GradientDir.Vertical:
                            uiVertex.color *= (i % 4 == 0 || (i - 1) % 4 == 0) ? _vertex1 : _vertex2;
                            break;
                        case GradientDir.Horizontal:
                            uiVertex.color *= (i % 4 == 0 || (i - 3) % 4 == 0) ? _vertex1 : _vertex2;
                            break;
                        case GradientDir.DiagonalLeftToRight:
                            uiVertex.color *= (i % 4 == 0) ? _vertex1 : ((i - 2) % 4 == 0 ? _vertex2 : Color.Lerp(_vertex2, _vertex1, 0.5f));
                            break;
                        case GradientDir.DiagonalRightToLeft:
                            uiVertex.color *= ((i - 1) % 4 == 0) ? _vertex1 : ((i - 3) % 4 == 0 ? _vertex2 : Color.Lerp(_vertex2, _vertex1, 0.5f));
                            break;

                    }
                    vh.SetUIVertex(uiVertex, i);
                }
            }
        }

19 Source : Gradient2.cs
with MIT License
from cmaher

public override void ModifyMesh(VertexHelper helper)
        {
            if (!IsActive() || helper.currentVertCount == 0)
                return;

            List<UIVertex> _vertexList = new List<UIVertex>();

            helper.GetUIVertexStream(_vertexList);

            int nCount = _vertexList.Count;
            switch (GradientType)
            {
                case Type.Horizontal:
                case Type.Vertical:
                    {
                        Rect bounds = GetBounds(_vertexList);
                        float min = bounds.xMin;
                        float w = bounds.width;
                        Func<UIVertex, float> GetPosition = v => v.position.x;

                        if (GradientType == Type.Vertical)
                        {
                            min = bounds.yMin;
                            w = bounds.height;
                            GetPosition = v => v.position.y;
                        }

                        float width = 1f / w / Zoom;
                        float zoomOffset = (1 - (1 / Zoom)) * 0.5f;
                        float offset = (Offset * (1 - zoomOffset)) - zoomOffset;

                        if (ModifyVertices)
                        {
                            SplitTrianglesAtGradientStops(_vertexList, bounds, zoomOffset, helper);
                        }

                        UIVertex vertex = new UIVertex();
                        for (int i = 0; i < helper.currentVertCount; i++)
                        {
                            helper.PopulateUIVertex(ref vertex, i);
                            vertex.color = BlendColor(vertex.color, EffectGradient.Evaluate((GetPosition(vertex) - min) * width - offset));
                            helper.SetUIVertex(vertex, i);
                        }
                    }
                    break;

                case Type.Diamond:
                    {
                        Rect bounds = GetBounds(_vertexList);

                        float height = 1f / bounds.height / Zoom;
                        float radius = bounds.center.y / 2f;
                        Vector3 center = (Vector3.right + Vector3.up) * radius + Vector3.forward * _vertexList[0].position.z;

                        if (ModifyVertices)
                        {
                            helper.Clear();
                            for (int i = 0; i < nCount; i++) helper.AddVert(_vertexList[i]);

                            UIVertex centralVertex = new UIVertex();
                            centralVertex.position = center;
                            centralVertex.normal = _vertexList[0].normal;
                            centralVertex.uv0 = new Vector2(0.5f, 0.5f);
                            centralVertex.color = Color.white;
                            helper.AddVert(centralVertex);

                            for (int i = 1; i < nCount; i++) helper.AddTriangle(i - 1, i, nCount);
                            helper.AddTriangle(0, nCount - 1, nCount);
                        }

                        UIVertex vertex = new UIVertex();

                        for (int i = 0; i < helper.currentVertCount; i++)
                        {
                            helper.PopulateUIVertex(ref vertex, i);

                            vertex.color = BlendColor(vertex.color, EffectGradient.Evaluate(
                                Vector3.Distance(vertex.position, center) * height - Offset));

                            helper.SetUIVertex(vertex, i);
                        }
                    }
                    break;

                case Type.Radial:
                    {
                        Rect bounds = GetBounds(_vertexList);

                        float width = 1f / bounds.width / Zoom;
                        float height = 1f / bounds.height / Zoom;

                        if (ModifyVertices)
                        {
                            helper.Clear();

                            float radiusX = bounds.width / 2f;
                            float radiusY = bounds.height / 2f;
                            UIVertex centralVertex = new UIVertex();
                            centralVertex.position = Vector3.right * bounds.center.x + Vector3.up * bounds.center.y + Vector3.forward * _vertexList[0].position.z;
                            centralVertex.normal = _vertexList[0].normal;
                            centralVertex.uv0 = new Vector2(0.5f, 0.5f);
                            centralVertex.color = Color.white;

                            int steps = 64;
                            for (int i = 0; i < steps; i++)
                            {
                                UIVertex curVertex = new UIVertex();
                                float angle = (float)i * 360f / (float)steps;
                                float cosX = Mathf.Cos(Mathf.Deg2Rad * angle);
                                float cosY = Mathf.Sin(Mathf.Deg2Rad * angle);

                                curVertex.position = Vector3.right * cosX * radiusX + Vector3.up * cosY * radiusY + Vector3.forward * _vertexList[0].position.z;
                                curVertex.normal = _vertexList[0].normal;
                                curVertex.uv0 = new Vector2((cosX + 1) * 0.5f, (cosY + 1) * 0.5f);
                                curVertex.color = Color.white;
                                helper.AddVert(curVertex);
                            }

                            helper.AddVert(centralVertex);

                            for (int i = 1; i < steps; i++) helper.AddTriangle(i - 1, i, steps);
                            helper.AddTriangle(0, steps - 1, steps);
                        }

                        UIVertex vertex = new UIVertex();

                        for (int i = 0; i < helper.currentVertCount; i++)
                        {
                            helper.PopulateUIVertex(ref vertex, i);

                            vertex.color = BlendColor(vertex.color, EffectGradient.Evaluate(
                                Mathf.Sqrt(
                                    Mathf.Pow(Mathf.Abs(vertex.position.x - bounds.center.x) * width, 2f) +
                                    Mathf.Pow(Mathf.Abs(vertex.position.y - bounds.center.y) * height, 2f)) * 2f - Offset));

                            helper.SetUIVertex(vertex, i);
                        }
                    }
                    break;
            }
        }

19 Source : TileSizeFitter.cs
with MIT License
from cmaher

private void UpdateRect()
        {
            if (!IsActive())
                return;

            m_Tracker.Clear();

            m_Tracker.Add(this, rectTransform,
                DrivenTransformProperties.Anchors |
                DrivenTransformProperties.AncreplaceddPosition);
            rectTransform.anchorMin = Vector2.zero;
            rectTransform.anchorMax = Vector2.one;
            rectTransform.ancreplaceddPosition = Vector2.zero;

            m_Tracker.Add(this, rectTransform,
                DrivenTransformProperties.SizeDeltaX |
                DrivenTransformProperties.SizeDeltaY);
            Vector2 sizeDelta = GetParentSize() - Border;
            if (TileSize.x > 0.001f)
                sizeDelta.x -= Mathf.Floor(sizeDelta.x / TileSize.x) * TileSize.x;
            else
                sizeDelta.x = 0;
            if (TileSize.y > 0.001f)
                sizeDelta.y -= Mathf.Floor(sizeDelta.y / TileSize.y) * TileSize.y;
            else
                sizeDelta.y = 0;
            rectTransform.sizeDelta = -sizeDelta;
        }

19 Source : TileSizeFitter.cs
with MIT License
from cmaher

protected void SetDirty()
        {
            if (!IsActive())
                return;

            UpdateRect();
        }

19 Source : ExtensionsToggle.cs
with MIT License
from cmaher

private void SetToggleGroup(ExtensionsToggleGroup newGroup, bool setMemberValue)
        {
            ExtensionsToggleGroup oldGroup = m_Group;

            // Sometimes IsActive returns false in OnDisable so don't check for it.
            // Rather remove the toggle too often than too little.
            if (m_Group != null)
                m_Group.UnregisterToggle(this);

            // At runtime the group variable should be set but not when calling this method from OnEnable or OnDisable.
            // That's why we use the setMemberValue parameter.
            if (setMemberValue)
                m_Group = newGroup;

            // Only register to the new group if this Toggle is active.
            if (m_Group != null && IsActive())
                m_Group.RegisterToggle(this);

            // If we are in a new group, and this toggle is on, notify group.
            // Note: Don't refer to m_Group here as it's not guaranteed to have been set.
            if (newGroup != null && newGroup != oldGroup && IsOn && IsActive())
                m_Group.NotifyToggleOn(this);
        }

19 Source : ExtensionsToggle.cs
with MIT License
from cmaher

void Set(bool value, bool sendCallback)
        {
            if (m_IsOn == value)
                return;

            // if we are in a group and set to true, do group logic
            m_IsOn = value;
            if (m_Group != null && IsActive())
            {
                if (m_IsOn || (!m_Group.AnyTogglesOn() && !m_Group.AllowSwitchOff))
                {
                    m_IsOn = true;
                    m_Group.NotifyToggleOn(this);
                }
            }

            // Always send event when toggle is clicked, even if value didn't change
            // due to already active toggle in a toggle group being clicked.
            // Controls like Dropdown rely on this.
            // It's up to the user to ignore a selection being set to the same value it already was, if desired.
            PlayEffect(toggleTransition == ToggleTransition.None);
            if (sendCallback)
            {
                onValueChanged.Invoke(m_IsOn);
                onToggleChanged.Invoke(this);
            }
        }

19 Source : ExtensionsToggle.cs
with MIT License
from cmaher

private void InternalToggle()
        {
            if (!IsActive() || !IsInteractable())
                return;

            IsOn = !IsOn;
        }

19 Source : BoxSlider.cs
with MIT License
from codeyuan666

protected override void OnRectTransformDimensionsChange()
		{
			base.OnRectTransformDimensionsChange();
			//This can be invoked before OnEnabled is called. So we shouldn't be accessing other objects, before OnEnable is called.
			if (!IsActive())
				return;
			UpdateVisuals();
		}

19 Source : BoxSlider.cs
with MIT License
from codeyuan666

private bool MayDrag(PointerEventData eventData)
		{
			return IsActive() && IsInteractable() && eventData.button == PointerEventData.InputButton.Left;
		}

19 Source : SwitchButton.cs
with Apache License 2.0
from dmitmel

public virtual void OnSubmit(BaseEventData eventData) {
            SelectNextValue();
            if (IsActive() && IsInteractable()) {
                DoStateTransition(SelectionState.Pressed, false);
            }
        }

19 Source : SwitchButton.cs
with Apache License 2.0
from dmitmel

void SelectNextValue() {
            if (IsActive() && IsInteractable()) {
                _value++;
                if (_value >= values.Length) _value = 0;
                UpdateGraphics();
                onValueChanged.Invoke(_value);
            }
        }

19 Source : UnityEngine_EventSystems_UIBehaviour_Wrap.cs
with MIT License
from focus-creative-games

[Puerts.MonoPInvokeCallback(typeof(Puerts.V8FunctionCallback))]
        private static void M_IsActive(IntPtr isolate, IntPtr info, IntPtr self, int paramLen, long data)
        {
            try
            {
                var obj = Puerts.Utils.GetSelf((int)data, self) as UnityEngine.EventSystems.UIBehaviour;
                
                
                {
                    
                    
                    
                    
                    {
                        
                        var result = obj.IsActive();
                        
                        Puerts.PuertsDLL.ReturnBoolean(isolate, info, result);
                        
                        
                    }
                }
                
                
            }
            catch (Exception e)
            {
                Puerts.PuertsDLL.ThrowException(isolate, "c# exception:" + e.Message + ",stack:" + e.StackTrace);
            }
        }

19 Source : LevelEditorExpander.cs
with MIT License
from Hertzole

private void InternalToggle()
        {
            if (!IsActive() || !IsInteractable())
            {
                return;
            }

            IsExpanded = !isExpanded;
        }

See More Examples