コード例 #1
0
		public override void OnEnter()
		{
			GameObject _go = Fsm.GetOwnerDefaultTarget(gameObject);
			if (_go!=null)
			{
				_selectable = _go.GetComponent<UnityEngine.UI.Selectable>();
			}
			
			DoGetValue();

			Finish();
		}
コード例 #2
0
		public override void OnEnter()
		{
			GameObject _go = Fsm.GetOwnerDefaultTarget(gameObject);
			if (_go!=null)
			{
				_selectable = _go.GetComponent<UnityEngine.UI.Selectable>();
			}

			if (_selectable!=null && resetOnExit.Value)
			{
				_originalValue = _selectable.navigation.mode;
			}

			DoSetValue();

			Finish();
		}
コード例 #3
0
ファイル: UITools.cs プロジェクト: fkavum/infated
        /// <summary>
        /// Selects a Selectable UI element and visually shows it as selected.
        /// </summary>
        /// <param name="selectable"></param>
        /// <param name="allowStealFocus"></param>
        public static void Select(UnityEngine.UI.Selectable selectable, bool allowStealFocus = true)
        {
            var currentEventSystem = UnityEngine.EventSystems.EventSystem.current;

            if (currentEventSystem == null || selectable == null)
            {
                return;
            }
            if (currentEventSystem.alreadySelecting)
            {
                return;
            }
            if (currentEventSystem.currentSelectedGameObject == null || allowStealFocus)
            {
                currentEventSystem.SetSelectedGameObject(selectable.gameObject);
                selectable.Select();
                selectable.OnSelect(null);
            }
        }
コード例 #4
0
        // -----------------
        private GameObject FindFirstSelectableInScene()
        {
            UnityEngine.UI.Selectable topMost = null;

            UnityEngine.UI.Selectable[] selectableList = (UnityEngine.UI.Selectable[])GameObject.FindObjectsOfType(typeof(UnityEngine.UI.Selectable));

            for (int i = 0; i < selectableList.Length; ++i)
            {
                UnityEngine.UI.Selectable s = selectableList[i];
                if (s.navigation.mode == UnityEngine.UI.Navigation.Mode.None)
                {
                    continue;
                }

                topMost = s;                    // TODO : compare
            }

            return((topMost != null) ? topMost.gameObject : null);
        }
コード例 #5
0
        public override void OnEnter()
        {
            var _go = Fsm.GetOwnerDefaultTarget(gameObject);

            if (_go != null)
            {
                _selectable = _go.GetComponent <UnityEngine.UI.Selectable>();
            }

            if (_selectable != null && resetOnExit.Value)
            {
                _originalState = _selectable.IsInteractable();
            }

            DoSetValue();


            Finish();
        }
コード例 #6
0
        static StackObject *set_selectOnRight_9(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
        {
            CSHotFix.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            StackObject *ptr_of_this_method;
            StackObject *__ret = ILIntepreter.Minus(__esp, 2);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
            UnityEngine.UI.Selectable value = (UnityEngine.UI.Selectable) typeof(UnityEngine.UI.Selectable).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);
            ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
            ptr_of_this_method = ILIntepreter.GetObjectAndResolveReference(ptr_of_this_method);
            UnityEngine.UI.Navigation instance_of_this_method;
            instance_of_this_method = (UnityEngine.UI.Navigation) typeof(UnityEngine.UI.Navigation).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));

            instance_of_this_method.selectOnRight = value;

            WriteBackInstance(__domain, ptr_of_this_method, __mStack, ref instance_of_this_method);

            return(__ret);
        }
コード例 #7
0
        public void Apply(UnityEngine.UI.Selectable sel, UnityEngine.UI.Image img)
        {
            sel.transition = this.transition;

            sel.spriteState = this.spriteState;
            sel.colors      = this.colorStates;

            UnityEngine.UI.Graphic graphic = sel.targetGraphic;
            if (graphic != null)
            {
                graphic.color = this.normalColor;
            }

            if (img != null)
            {
                img.type   = UnityEngine.UI.Image.Type.Sliced;
                img.color  = this.normalColor;
                img.sprite = this.normalSprite;
            }
        }
コード例 #8
0
                public void Apply(
                    UnityEngine.UI.Selectable sel,
                    UnityEngine.UI.Image img,
                    bool assignTG = true,
                    UnityEngine.UI.Image.Type?imgTy = UnityEngine.UI.Image.Type.Sliced)
                {
                    this.ApplySel(sel);
                    this.ApplyG(img);
                    img.sprite = this.sprite;

                    if (assignTG == true)
                    {
                        sel.targetGraphic = img;
                    }

                    if (imgTy.HasValue == true)
                    {
                        img.type = imgTy.Value;
                    }
                }
コード例 #9
0
		public override void OnEnter()
		{
			GameObject _go = Fsm.GetOwnerDefaultTarget(gameObject);
			if (_go!=null)
			{
				_selectable = _go.GetComponent<UnityEngine.UI.Selectable>();
			}

			if (_selectable!=null && resetOnExit.Value)
			{
				_originalColorBlock = _selectable.colors;
			}

			DoSetValue();

			if (!everyFrame)
			{
				Finish();
			}
		}
コード例 #10
0
        static StackObject *FindSelectableOnDown_25(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
        {
            CSHotFix.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            StackObject *ptr_of_this_method;
            StackObject *__ret = ILIntepreter.Minus(__esp, 1);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
            UnityEngine.UI.Selectable instance_of_this_method = (UnityEngine.UI.Selectable) typeof(UnityEngine.UI.Selectable).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            var result_of_this_method = instance_of_this_method.FindSelectableOnDown();

            object obj_result_of_this_method = result_of_this_method;

            if (obj_result_of_this_method is CrossBindingAdaptorType)
            {
                return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
            }
            return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
        }
コード例 #11
0
        static int _m_Select(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


            UnityEngine.UI.Selectable __cl_gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1);


            try {
                {
                    __cl_gen_to_be_invoked.Select(  );



                    return(0);
                }
            } catch (System.Exception __gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
            }
        }
コード例 #12
0
        static int _m_IsInteractable(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


            UnityEngine.UI.Selectable __cl_gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1);


            try {
                {
                    bool __cl_gen_ret = __cl_gen_to_be_invoked.IsInteractable(  );
                    LuaAPI.lua_pushboolean(L, __cl_gen_ret);



                    return(1);
                }
            } catch (System.Exception __gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
            }
        }
コード例 #13
0
        static int _m_FindSelectableOnDown(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


            UnityEngine.UI.Slider __cl_gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1);


            try {
                {
                    UnityEngine.UI.Selectable __cl_gen_ret = __cl_gen_to_be_invoked.FindSelectableOnDown(  );
                    translator.Push(L, __cl_gen_ret);



                    return(1);
                }
            } catch (System.Exception __gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
            }
        }
コード例 #14
0
        public override void OnEnter()
        {
            GameObject _go = Fsm.GetOwnerDefaultTarget(gameObject);

            if (_go != null)
            {
                _selectable = _go.GetComponent <UnityEngine.UI.Selectable>();
            }

            if (_selectable != null && resetOnExit.Value)
            {
                _originalColorBlock = _selectable.colors;
            }

            DoSetValue();

            if (!everyFrame)
            {
                Finish();
            }
        }
コード例 #15
0
        static int _m_OnDeselect(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


            UnityEngine.UI.Selectable __cl_gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1);


            try {
                {
                    UnityEngine.EventSystems.BaseEventData eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData));

                    __cl_gen_to_be_invoked.OnDeselect(eventData);



                    return(0);
                }
            } catch (System.Exception __gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
            }
        }
コード例 #16
0
        static int _m_FindSelectableOnUp(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1);



                {
                    UnityEngine.UI.Selectable gen_ret = gen_to_be_invoked.FindSelectableOnUp(  );
                    translator.Push(L, gen_ret);



                    return(1);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
コード例 #17
0
        static int _m_OnPointerExit(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1);



                {
                    UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData));

                    gen_to_be_invoked.OnPointerExit(_eventData);



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
コード例 #18
0
        static int _m_OnSelectUI(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


            xc.AudioManager __cl_gen_to_be_invoked = (xc.AudioManager)translator.FastGetCSObj(L, 1);


            try {
                {
                    UnityEngine.UI.Selectable select_ui = (UnityEngine.UI.Selectable)translator.GetObject(L, 2, typeof(UnityEngine.UI.Selectable));
                    string sprite_name       = LuaAPI.lua_tostring(L, 3);
                    string check_sprite_name = LuaAPI.lua_tostring(L, 4);

                    __cl_gen_to_be_invoked.OnSelectUI(select_ui, sprite_name, check_sprite_name);



                    return(0);
                }
            } catch (System.Exception __gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
            }
        }
コード例 #19
0
        protected IEnumerator SelectElement(UnityEngine.UI.Selectable elementToSelect)
        {
            yield return(null);

            UITools.Select(elementToSelect);
        }
コード例 #20
0
ファイル: SPTools.cs プロジェクト: pharazone/IsoTest
        /// <summary>
        /// Replaces all the references in the supplied array (does not work with internal properties).
        /// </summary>
        /// <param name="find">Find.</param>
        /// <param name="replaceWith">Replace with.</param>
        /// <param name="spriteRenderersOnly">If set to <c>true</c> sprite renderers only.</param>
        /// <returns>The replaced references count.</returns>
        public static int ReplaceReferences(Component[] components, Sprite find, Sprite replaceWith, bool spriteRenderersOnly)
        {
            if (components == null || components.Length == 0)
            {
                return(0);
            }

            int count = 0;

            foreach (Object comp in components)
            {
                // Handle sprite renderers differently
                if (comp is SpriteRenderer)
                {
                    if ((comp as SpriteRenderer).sprite == find)
                    {
                        (comp as SpriteRenderer).sprite = replaceWith;
                        count++;
                    }
                }
                else if (comp is UnityEngine.UI.Image)
                {
                    // If this component is not a sprite renderer
                    if (spriteRenderersOnly)
                    {
                        continue;
                    }

                    if ((comp as UnityEngine.UI.Image).sprite == find)
                    {
                        (comp as UnityEngine.UI.Image).sprite = replaceWith;
                        count++;
                    }
                }
                else if (comp is UnityEngine.UI.Selectable)
                {
                    // If this component is not a sprite renderer
                    if (spriteRenderersOnly)
                    {
                        continue;
                    }

                    UnityEngine.UI.Selectable  selectable = (comp as UnityEngine.UI.Selectable);
                    UnityEngine.UI.SpriteState ss         = selectable.spriteState;

                    if (ss.highlightedSprite == find)
                    {
                        ss.highlightedSprite = replaceWith;
                        count++;
                    }
                    if (ss.pressedSprite == find)
                    {
                        ss.pressedSprite = replaceWith;
                        count++;
                    }
                    if (ss.disabledSprite == find)
                    {
                        ss.disabledSprite = replaceWith;
                        count++;
                    }

                    selectable.spriteState = ss;
                }
                else
                {
                    // If this component is not a sprite renderer
                    if (spriteRenderersOnly)
                    {
                        continue;
                    }

                    // Get the fileds info
                    FieldInfo[] fields = comp.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);

                    foreach (FieldInfo fieldInfo in fields)
                    {
                        if (fieldInfo == null)
                        {
                            continue;
                        }

                        object fieldValue = fieldInfo.GetValue(comp);

                        // Handle arrays
                        if (fieldInfo.FieldType.IsArray)
                        {
                            var fieldValueArray = fieldValue as System.Array;

                            if (fieldValueArray == null || fieldValueArray.GetType() != typeof(Sprite[]))
                            {
                                continue;
                            }

                            bool         changed  = false;
                            System.Array newArray = new System.Array[fieldValueArray.Length];
                            fieldValueArray.CopyTo(newArray, 0);

                            for (int i = 0; i < newArray.Length; i++)
                            {
                                object element = newArray.GetValue(i);

                                if (element != null && element.GetType() == typeof(Sprite))
                                {
                                    Sprite o = element as Sprite;

                                    // Check if the value is what we are looking for
                                    if (o == find)
                                    {
                                        newArray.SetValue((replaceWith as object), i);
                                        changed = true;
                                        count++;
                                    }
                                }
                            }

                            // Repalce the array
                            if (changed)
                            {
                                fieldInfo.SetValue(comp, newArray);
                            }
                        }
                        // Handle structs
                        else if (fieldInfo.FieldType.IsValueType && !fieldInfo.FieldType.IsEnum && !fieldInfo.IsLiteral)
                        {
                            FieldInfo[] structFields = fieldInfo.FieldType.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);

                            foreach (FieldInfo structFieldInfo in structFields)
                            {
                                if (structFieldInfo == null)
                                {
                                    continue;
                                }

                                if (structFieldInfo.FieldType == typeof(Sprite))
                                {
                                    Sprite structFieldValue = structFieldInfo.GetValue(fieldValue) as Sprite;

                                    // Check if the value is what we are looking for
                                    if (structFieldValue == find)
                                    {
                                        // Replace
                                        structFieldInfo.SetValue(fieldValue, (replaceWith as object));
                                        count++;
                                    }
                                }
                            }

                            fieldInfo.SetValue(comp, fieldValue);
                        }
                        // Handle direct sprites
                        else if (fieldInfo.FieldType == typeof(Sprite))
                        {
                            // Check if the value is what we are looking for
                            if ((fieldValue as Sprite) == find)
                            {
                                // Replace
                                fieldInfo.SetValue(comp, (replaceWith as object));
                                count++;
                            }
                        }
                    }
                }

                if (PrefabUtility.GetPrefabType((comp as Component).gameObject) != PrefabType.None)
                {
                    EditorUtility.SetDirty((comp as Component));
                }
            }

            return(count);
        }
コード例 #21
0
        public override void OnQuestListUpdated()
        {
            if (!m_isAwake)
            {
                return;
            }
            UnityEngine.UI.Selectable elementToSelect = null;
            showingActiveQuestsHeading.SetActive(isShowingActiveQuests);
            showingCompletedQuestHeading.SetActive(!isShowingActiveQuests);
            selectionPanelContentManager.Clear();
            var questTitleTemplate = isShowingActiveQuests ? activeQuestHeadingTemplate : completedQuestHeadingTemplate;

            // Get group names, and draw selected quest in its panel while we're at it:
            var groupNames            = new List <string>();
            int numGroupless          = 0;
            var repaintedQuestDetails = false;

            if (quests.Length > 0)
            {
                foreach (var quest in quests)
                {
                    if (IsSelectedQuest(quest))
                    {
                        RepaintSelectedQuest(quest);
                        repaintedQuestDetails = true;
                    }
                    var groupName = quest.Group;
                    if (string.IsNullOrEmpty(groupName))
                    {
                        numGroupless++;
                    }
                    if (string.IsNullOrEmpty(groupName) || groupNames.Contains(groupName))
                    {
                        continue;
                    }
                    groupNames.Add(groupName);
                }
            }
            if (!repaintedQuestDetails)
            {
                RepaintSelectedQuest(null);
            }

            // Add quests by group:
            foreach (var groupName in groupNames)
            {
                var groupFoldout = selectionPanelContentManager.Instantiate <StandardUIFoldoutTemplate>(questGroupTemplate);
                selectionPanelContentManager.Add(groupFoldout, questSelectionContentContainer);
                groupFoldout.Assign(groupName, IsGroupExpanded(groupName));
                var targetGroupName    = groupName;
                var targetGroupFoldout = groupFoldout;
                if (!keepGroupsExpanded)
                {
                    groupFoldout.foldoutButton.onClick.AddListener(() => { OnClickGroup(targetGroupName, targetGroupFoldout); });
                }
                if (string.Equals(foldoutToSelect, groupName))
                {
                    elementToSelect = groupFoldout.foldoutButton;
                    foldoutToSelect = null;
                }
                foreach (var quest in quests)
                {
                    if (string.Equals(quest.Group, groupName))
                    {
                        var questTitle = selectionPanelContentManager.Instantiate <StandardUIQuestTitleButtonTemplate>(questTitleTemplate);
                        questTitle.Assign(quest.Title, quest.Heading.text, OnToggleTracking);
                        selectionPanelContentManager.Add(questTitle, groupFoldout.interiorPanel);
                        var target = quest.Title;
                        questTitle.button.onClick.AddListener(() => { OnClickQuest(target); });
                        if (showDetailsOnSelect)
                        {
                            AddShowDetailsOnSelect(questTitle.button, target);
                        }
                        if (string.Equals(quest.Title, questTitleToSelect))
                        {
                            elementToSelect    = questTitle.button;
                            questTitleToSelect = null;
                        }
                    }
                }
            }

            // Add groupless quests:
            foreach (var quest in quests)
            {
                if (!string.IsNullOrEmpty(quest.Group))
                {
                    continue;
                }
                var questTitle = selectionPanelContentManager.Instantiate <StandardUIQuestTitleButtonTemplate>(questTitleTemplate);
                questTitle.Assign(quest.Title, quest.Heading.text, OnToggleTracking);
                selectionPanelContentManager.Add(questTitle, questSelectionContentContainer);
                var target = quest.Title;
                questTitle.button.onClick.AddListener(() => { OnClickQuest(target); });
                if (showDetailsOnSelect)
                {
                    AddShowDetailsOnSelect(questTitle.button, target);
                }
                if (string.Equals(quest.Title, questTitleToSelect))
                {
                    elementToSelect    = questTitle.button;
                    questTitleToSelect = null;
                }
            }

            // If no quests, add no quests text:
            if (quests.Length == 0 && showNoQuestsText)
            {
                var questTitle = selectionPanelContentManager.Instantiate <StandardUIQuestTitleButtonTemplate>(completedQuestHeadingTemplate);
                var dummyText  = IsShowingActiveQuests ? noActiveQuestsText : noCompletedQuestsText;
                questTitle.Assign(dummyText, dummyText, null);
                selectionPanelContentManager.Add(questTitle, questSelectionContentContainer);
            }

            SetStateToggleButtons();
            mainPanel.RefreshSelectablesList();
            if (mainPanel != null)
            {
                UnityEngine.UI.LayoutRebuilder.MarkLayoutForRebuild(mainPanel.GetComponent <RectTransform>());
            }
            if (elementToSelect != null)
            {
                StartCoroutine(SelectElement(elementToSelect));
            }
            else if (UnityEngine.EventSystems.EventSystem.current.currentSelectedGameObject == null && mainPanel != null && mainPanel.firstSelected != null && InputDeviceManager.autoFocus)
            {
                UITools.Select(mainPanel.firstSelected.GetComponent <UnityEngine.UI.Selectable>());
            }
        }
コード例 #22
0
 public void Awake()
 {
     m_selectable = GetComponent <UnityEngine.UI.Selectable>();
 }
コード例 #23
0
 private IEnumerator SelectNextFrameCoroutine(UnityEngine.UI.Selectable selectable)
 {
     yield return(null);
     //UITools.Select(selectable);
 }
コード例 #24
0
        public static bool SelectDownPrefix(ref UnityEngine.UI.Selectable ___curSelected, ref UnityEngine.UI.Selectable ___prevSelected)
        {
            if (___curSelected.name == "VSyncButton")
            {
                ___prevSelected.GetComponent <MenuButtonHelper>().mouseEnteredSlot = false;
                ___curSelected = Globals.targetFPSButton.GetComponent <UnityEngine.UI.Selectable>();
                return(false);
            }
            else if (___curSelected.name == "TargetFPSButton")
            {
                ___prevSelected.GetComponent <MenuButtonHelper>().mouseEnteredSlot = false;
                ___curSelected = GameObject.Find("MainGUI/MainMenu/SettingsGraphics/ScrollView/Content/BorderlessWindowButton").GetComponent <UnityEngine.UI.Selectable>();
                return(false);
            }


            return(true);
        }
コード例 #25
0
 public void ApplySel(UnityEngine.UI.Selectable selectable)
 {
     selectable.spriteState = this.spriteState;
     selectable.transition  = this.transition;
     selectable.colors      = this.colors;
 }
コード例 #26
0
 new void Start()
 {
     playOnAwake       = true;
     m_SelectableCache = GetComponent <UnityEngine.UI.Selectable>();
 }
コード例 #27
0
ファイル: VRUISetupHelper.cs プロジェクト: ly774508966/VRDF
 /// <summary>
 /// Normal UI Element Callback is still called with the mouse when this VRButton isn't on a 2D UI with Image
 /// </summary>
 /// <param name="selectable">The selectable for which we check the registration of the events</param>
 /// <returns>True if the Click callback should be registered</returns>
 public static bool ShouldRegisterForSimulator(UnityEngine.UI.Selectable selectable)
 {
     return(selectable.targetGraphic == null && selectable.GetComponent <UnityEngine.UI.Image>() == null);
 }
コード例 #28
0
 public void SelectGui(UnityEngine.UI.Selectable guiElement)
 {
     StartCoroutine(DelaySelection(guiElement));
 }