Merge branch 'master' into aboutTab-hyperlink

Author: Lytvynenko-Danylo

com.stansassets.plugins-dev-kit/Editor/Config/PluginsDevKitPackage.cs

@@ -10,12 +10,14 @@ static class PluginsDevKitPackage
         public static readonly string UIToolkitPath = $"{RootPath}/Editor/UIToolkit";
         public static readonly string UIToolkitControlsPath = $"{UIToolkitPath}/Controls";
 
+#if UNITY_2019_4_OR_NEWER
         /// <summary>
         ///  Foundation package info.
         /// </summary>
         public static PackageInfo GetPackageInfo()
         {
             return PackageManagerUtility.GetPackageInfo(Name);
         }
+#endif
     }
 }

com.stansassets.plugins-dev-kit/Editor/IMGUI/Controls.meta

@@ -0,0 +1,69 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+
+namespace StansAssets.Plugins.Editor
+{
+    [Serializable]
+    public abstract class IMGUIHyperButton
+    {
+        bool m_IsMouseOver = false;
+        Rect m_LabelRect = new Rect();
+
+        [SerializeField]
+        bool m_IsSelected = false;
+
+        protected abstract void OnNormal(params GUILayoutOption[] options);
+        protected abstract void OnMouseOver(params GUILayoutOption[] options);
+
+        /// <summary>
+        /// True if current elements selection state is locked
+        /// </summary>
+        public bool IsSelectionLock => m_IsSelected;
+
+        /// <summary>
+        /// Locked button in a selected state
+        /// OnMouseOver mode UI will be drawn, and button will not accept 
+        /// the mouse click event.
+        /// </summary>
+        public void LockSelectedState(bool val)
+        {
+            m_IsSelected = val;
+        }
+
+        public virtual bool Draw(params GUILayoutOption[] options)
+        {
+            if (m_IsSelected)
+            {
+                OnMouseOver(options);
+                return false;
+            }
+
+            if (!m_IsMouseOver)
+                OnNormal(options);
+            else
+                OnMouseOver(options);
+
+            if (Event.current.type == EventType.Repaint)
+            {
+                m_LabelRect = GUILayoutUtility.GetLastRect();
+                m_IsMouseOver = m_LabelRect.Contains(Event.current.mousePosition);
+            }
+
+            if (Event.current.type == EventType.Repaint)
+                if (m_IsMouseOver)
+                    EditorGUIUtility.AddCursorRect(m_LabelRect, MouseCursor.Link);
+
+            var clicked = false;
+            if (m_IsMouseOver)
+                if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
+                {
+                    clicked = true;
+                    GUI.changed = true;
+                    Event.current.Use();
+                }
+
+            return clicked;
+        }
+    }
+}

com.stansassets.plugins-dev-kit/Editor/IMGUI/Controls/IMGUIHyperButton.cs

@@ -0,0 +1,139 @@
+using System;
+using StansAssets.Foundation.Extensions;
+using UnityEngine;
+using UnityEditor;
+
+namespace StansAssets.Plugins.Editor
+{
+    [Serializable]
+    public class IMGUIHyperLabel : IMGUIHyperButton
+    {
+        [SerializeField]
+        GUIContent m_Content;
+        [SerializeField]
+        GUIContent m_HighlightedContext;
+
+        [SerializeField]
+        GUIStyle m_Style;
+        [SerializeField]
+        GUIStyle m_MouseOverStyle;
+
+        [SerializeField]
+        bool m_OverrideGuiColor;
+
+        public IMGUIHyperLabel(GUIContent content)
+            : this(content, EditorStyles.label) { }
+
+        public IMGUIHyperLabel(GUIContent content, GUIStyle style)
+        {
+            m_Content = content;
+            m_Style = new GUIStyle(style);
+            m_MouseOverStyle = new GUIStyle(style);
+        }
+
+        public void SetColor(Color color)
+        {
+            m_Style.normal.textColor = color;
+        }
+
+        public void SetMouseOverColor(Color color)
+        {
+            m_MouseOverStyle.normal.textColor = color;
+        }
+
+        public void HighLight(string pattern)
+        {
+            if (m_HighlightedContext == null) m_HighlightedContext = new GUIContent(m_Content);
+
+            var indexes = m_Content.text.AllIndexesOf(pattern, StringComparison.OrdinalIgnoreCase);
+            if (indexes.Count == 0)
+            {
+                m_HighlightedContext.text = m_Content.text;
+            }
+            else
+            {
+                m_HighlightedContext.text = string.Empty;
+                var lastCopyIndex = 0;
+                foreach (var index in indexes)
+                {
+                    m_HighlightedContext.text += m_Content.text.Substring(lastCopyIndex, index - lastCopyIndex);
+                    m_HighlightedContext.text += "<color=yellow>";
+                    m_HighlightedContext.text += m_Content.text.Substring(index, pattern.Length);
+                    m_HighlightedContext.text += "</color>";
+
+                    lastCopyIndex = index + pattern.Length;
+                }
+
+                m_HighlightedContext.text += m_Content.text.Substring(lastCopyIndex, m_Content.text.Length - lastCopyIndex);
+            }
+        }
+
+        public void DisableHighLight()
+        {
+            m_HighlightedContext = null;
+        }
+
+        public bool DrawWithCalcSize()
+        {
+            var width = CalcSize().x + 5f;
+            return Draw(GUILayout.Width(width));
+        }
+
+        protected override void OnNormal(params GUILayoutOption[] options)
+        {
+            if (m_OverrideGuiColor)
+                using (new IMGUIChangeColor(m_Style.normal.textColor))
+                {
+                    using (new IMGUIChangeContentColor(m_Style.normal.textColor))
+                    {
+                        EditorGUILayout.LabelField(HighlightedContext ?? m_Content, m_Style, options);
+                    }
+                }
+            else
+                EditorGUILayout.LabelField(HighlightedContext ?? m_Content, m_Style, options);
+        }
+
+        protected override void OnMouseOver(params GUILayoutOption[] options)
+        {
+            var c = GUI.color;
+            GUI.color = m_MouseOverStyle.normal.textColor;
+
+            EditorGUILayout.LabelField(m_Content, m_MouseOverStyle, options);
+            GUI.color = c;
+        }
+
+        public Vector2 CalcSize()
+        {
+            return m_Style.CalcSize(m_Content);
+        }
+
+        public void SetContent(GUIContent content)
+        {
+            m_Content = content;
+        }
+
+        public void SetStyle(GUIStyle style)
+        {
+            m_Style = new GUIStyle(style);
+        }
+
+        public void GuiColorOverride(bool value)
+        {
+            m_OverrideGuiColor = value;
+        }
+
+        public GUIContent Content => m_Content;
+
+        public Color Color => m_Style.normal.textColor;
+
+        GUIContent HighlightedContext
+        {
+            get
+            {
+                if (m_HighlightedContext != null && string.IsNullOrEmpty(m_HighlightedContext.text)) return null;
+
+                return m_HighlightedContext;
+            }
+        }
+    }
+}

com.stansassets.plugins-dev-kit/Editor/IMGUI/Controls/IMGUIHyperButton.cs.meta

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace StansAssets.Plugins.Editor
+{
+    [Serializable]
+    public class IMGUIHyperToolbar
+    {
+        [SerializeField]
+        int m_ButtonsWidth = 0;
+        [SerializeField]
+        int m_ButtonsHeight = 0;
+        [SerializeField]
+        float m_ItemsSpace = 5f;
+        [SerializeField]
+        List<IMGUIHyperLabel> m_Buttons = new List<IMGUIHyperLabel>();
+
+        public void AddButtons(params IMGUIHyperLabel[] buttons)
+        {
+            if (m_Buttons == null) m_Buttons = new List<IMGUIHyperLabel>();
+
+            foreach (var newBtn in buttons) m_Buttons.Add(newBtn);
+
+            ValidateButtons();
+        }
+
+        void ValidateButtons()
+        {
+            if (m_Buttons.Count == 0) return;
+
+            var hasActive = false;
+            foreach (var button in m_Buttons)
+                if (button.IsSelectionLock)
+                {
+                    hasActive = true;
+                    break;
+                }
+
+            if (!hasActive) m_Buttons[0].LockSelectedState(true);
+        }
+
+        public void SetSelectedIndex(int index)
+        {
+            foreach (var button in m_Buttons) button.LockSelectedState(false);
+
+            var selectedButton = m_Buttons[index];
+            selectedButton.LockSelectedState(true);
+        }
+
+        /// <summary>
+        /// Draw toolbar with buttons.
+        /// Returns selected button index
+        /// </summary>
+        public int Draw()
+        {
+            if (m_Buttons == null) return 0;
+
+            EditorGUILayout.BeginHorizontal();
+            {
+                EditorGUILayout.Space();
+
+                foreach (var button in m_Buttons)
+                {
+                    float width;
+
+                    if (m_ButtonsWidth == 0)
+                        width = button.CalcSize().x + m_ItemsSpace;
+                    else
+                        width = m_ButtonsWidth;
+
+                    bool click;
+                    click = m_ButtonsHeight != 0 
+                        ? button.Draw(GUILayout.Width(width), GUILayout.Height(m_ButtonsHeight)) 
+                        : button.Draw(GUILayout.Width(width));
+
+                    if (click) SetSelectedIndex(m_Buttons.IndexOf(button));
+                }
+
+                EditorGUILayout.Space();
+            }
+            EditorGUILayout.EndHorizontal();
+
+            return SelectionIndex;
+        }
+
+        /// <summary>
+        /// Set's custom width for all toolbar buttons.
+        /// The default value is 0. When value is 0 button width is calculated
+        /// based on button GUI rect.
+        /// </summary>
+        /// <param name="width">width value</param>
+        public void SetButtonsWidth(int width)
+        {
+            m_ButtonsWidth = width;
+        }
+
+        /// <summary>
+        /// Set's custom height for all toolbar buttons.
+        /// The default value is 0. When value is 0 button height is calculated
+        /// based on button GUI rect.
+        /// </summary>
+        /// <param name="height">height value</param>
+        public void SetButtonsHeight(int height)
+        {
+            m_ButtonsHeight = height;
+        }
+
+        /// <summary>
+        /// Set's space between items.
+        /// Default space it 5
+        /// </summary>
+        /// <param name="space">items space value</param>
+        public void SetItemsSpace(float space)
+        {
+            m_ItemsSpace = space;
+        }
+
+        /// <summary>
+        /// Toolbar buttons
+        /// </summary>
+        public List<IMGUIHyperLabel> Buttons => m_Buttons;
+
+        public int SelectionIndex
+        {
+            get
+            {
+                foreach (var button in m_Buttons)
+                    if (button.IsSelectionLock)
+                        return m_Buttons.IndexOf(button);
+
+                return 0;
+            }
+        }
+    }
+}