Unity 3D: Как вызывать меню и попапы в Unity

» Раздел: Программирование - редакторы

В один прекрасный момент вам приспичило создать меню. Контекстное или слитое c общим меню Unity. И тут вы поняли что ничего о том как это делается и не знаете. Или знаете не всё. Данная статья - обзор по способам построить меню в Unity. Этих способов благо достаточно - и каждый из них специфичен.
В чем сабж статьи?
Если вдруг вам приходится заниматься редакторами профессионально, как мне на день насущный, то данные знания для вас просто обязательны - меню применяются повсеместно. Когда я начинал только изучать это мне приходилось пилить велосипедные комбобоксы из юнити-вики, потому что я не знал как делать это правильно. Способ тот кривой и вам на такие вещи я натыкаться не советую - почему бы не начать сразу делать их правильно?

Итак, способы

ContextMenu

Самый первый способ, с которым, вы вероятно даже сталкивались - это ContextMenu.
Следующий пример демонстрирует принцип работы данного атрибута:
using UnityEngine;

public class MyClass : MonoBehaviour {

	[ContextMenu("Say message for XGM")]
	void SayMessage() 
	{
		Debug.Log ("I love you, XGM");
	}
}
В результате мы получим пункт меню в следующем месте:
При нажатии на данный пункт выполнится наш метод SayMessage().
Однако, данный способ применяется в очень узком месте:
  • только в скриптах, наследуемых от класса Behaviour (всех сценариях и компонентах)
  • только для методов экземпляра (никакого 'static'!)
  • метод не должен иметь параметров
Способ применения: когда нужно быстренько вызвать какой-нибудь метод из компонента. В таких случаях переписывать инспектор объекта с целью добавить пару кнопок - нецелесообразно. Да и некоторые пунктики лучше иметь именно там.
Этот способ используется в игровом билде (что логично, так как все компоненты лежат там).
Для данного способа чуть ниже (в разделе "Параметры строки меню") будет расписано чуть подробней.

ContextMenuItem

Данный способ похож на предыдущий - это тоже атрибут. Но пишется он не туда и не так.
Пример написания:
using UnityEngine;

public class MyClass : MonoBehaviour
{
    [ContextMenuItem("Say message for XGM", "SayMessage")] 
    public string ff;

    void SayMessage()
    {
        Debug.Log("I love you, XGM");
    }
}
Данный способ добавляет контекстное меню для нашего поля(в примере - поле ff). При щелчке правой кнопкой мыши мы увидим меню с данным пунктом:
Первым параметром мы указываем название поля, вторым - название метода, который будет вызван.
В остальном требования те же:
  • используется только в скриптах, наследуемых от класса Behaviour (всех сценариях и компонентах)
  • только для методов экземпляра (никакого 'static'!)
  • метод не должен иметь параметров
Способ применения: аналогично первому способу, но с учетом того, что выполнение метода относится к определенному полю, а не компоненту в целом.
Этот способ всё так же лепится в игровую сборку.
Для данного способа чуть ниже (в разделе "Параметры строки меню") будет расписано чуть подробней.
Лично по мне - данный способ весьма не очевиден, на практике я им ни разу и не пользовался. Однако раз уж статья про меню - странно было бы упустить этот способ, тем более что в документации нет примера на C# (хотя, он и очевиден, но принцип действия не очень).
Внимание
Все последующие способы являются расширением редактора и относятся только к сборке редактора. Это говорит о том, что скрипты, исполняющие данный код должны лежать в папке /Assets/Editor/ вашего проекта.

MenuItem

С атрибутами, однако, мы еще не закончили. Остался у нас в запасе один, о котором я умолчал. Это атрибут MenuItem, добавляющие пункты в основное меню редактора.
Пример кода:
using UnityEditor;
using UnityEngine;

public static class MyClass 
{
    [MenuItem("Window/MenuItem")]
    static void SayMessage()
    {
        Debug.Log("I love you, XGM");
    }
}
Данный способ приведет к следующему результату:
Естественно, у данного способа есть свои ограничения, но они отличаются от тех, что вы прочли ранее:
  • функция, которой принадлежит атрибут, обязательно должна быть статичной
  • функция не должна иметь параметров
Прошу заметить - в официальной документации Unity предоставлен ошибочный пример применения данной функции. Там она используется в компонентах MonoBehaviour, которые для редактора в принципе не нужны. Естественно, что пример безумно дурной и если вы в реальной ситуации заюзаете данный метод вот таким образом ваша игра просто не скомпилируется (нельзя использовать методы редактора в игровом билде, но если вы не удержались то должны предварить это соответствующей ограничивающей директивой).
Способ применения: используется повсеместно - для открытия окон, для исполнения последовательности действий.
Кроме того данный способ имеет немного "читерства" и гибкой настройки, о которой я напишу чуть ниже в разделе "Параметры строки меню".
Данный способ всегда должен указывать на раздел, то есть нельзя просто добавить пункт в меню, он обязательно должен находиться в каком-то месте. Помимо этого данный способ позволяет встраивать меню в существующие уже места. Это создает подобный пункт не только в основном меню, но и в контекстном меню в иерархии или проекте, если вы определили элемент туда.
Помимо этого данный атрибут может по желанию реализовывать несколько параметров:
isValidateFunction - помечает функцию как функцию-валидатор. Это значит, что данная функция не показывает пункт меню, а проверяет его доступность. Такая функция должна возвращать bool, говорящий, задисейблена данная кнопка или активна. Используется в паре с обычным пунктом меню (не валидатором с точно таким же путем, включая дополнительные параметры).
Пример:
    [MenuItem("Test/ShowMessage", true)]
    static bool CanBeShow()
    {
        return "ILove".Length == 5;
    }

    [MenuItem("Test/ShowMessage", false)]
    static void ShowMessage()
    {
        Debug.Log("I love you, XGM");
    }
Опять же, про это почему то в документации особо-то и не расписывали.
priority - порядок пункта меню. Обычно стандартные элементы отсчитывают порядок от 0 и выше и, следовательно, указав "-1" мы установим наш пункт в самом верху списка.
Если вы укажете больше одного идентичного пути, то будет задействован только последний указанный. Таким образом вы можете подменять стандартные пункты меню Unity на свои.
Так же в рамках данного способа вы можете изменять контекстные меню инспектора, с таким же результатом как у способа ContextMenu. Однако, тут есть свой сахар - вы можете изменять пункты уже написанных компонентов, таких как Transform, Rigidbody и так далее.
Для этого способа зарезервировано меню CONTEXT, после которого вы вводите название нужного вам компонента:
using UnityEditor;
using UnityEngine;

public static class MyClass
{
    [MenuItem("CONTEXT/Transform/ShowMessage")]
    static void ShowMessage(MenuCommand command)
    {
        Debug.Log("I love you, XGM");
    }
}
Как вы могли заметить, я применил в функции параметр - он не обязателен, но возможен при таком раскладе. Данный параметр содержит в себе поле 'context', содержащее ссылку на компонент.
У данного способа так же нет ограничений в виде конкретного типа - например в качестве пути вы можете указать CONTEXT/MonoBehaviour/ и прикрепить пункт сразу ко всем наследникам данного класса. Указывать можно любой тип, наследуемый от Component (включая сам тип Component).
Помимо 'CONTEXT/' вы так же можете использовать следующие "специальные пути":
  • 'Assets/' - для добавления пункта в контекстное меню в окне ассетов
  • 'Assets/Create/' - для добавления пункта в меню кнопки 'Create' в окне с ассетами

GUI методы

Нельзя обойти стороной GUI методы, существующие для вызова попапов - однако среди стандартных это, зачастую, выборка значения.
Итак, попапы собственно есть следующие:
  • EditorGUILayout.Popup - строковый попап. Принцип работы: узнаем индекс строки из массива
  • EditorGUILayout.IntPopup - числовой попап. Принцип работы: узнаем индекс числа из массива, при том можно подменить числа "строковым отображением" (показывать текст, подразумевать число)
  • EditorGUILayout.EnumPopup - попап для перечислений. Принцип работы: указываем текущее значение перечислителя, получаем новое.
  • EditorGUILayout.MaskField - попап, позволяющий выбрать несколько значений, компонуя их в маску (обычно так делают выборки слоев/тегов)
В случае с отображением "строки" опять же применимы правила форматирования строки, такие как сепараторы и косая черта, о которых я писал выше.
Особо за них говорить нечего, всё можно узнать в документации.

ShowAsDropDown

Следующий способ - использовать отдельное окно. Однако вызывать его не просто так, а "по-особенному", через метод ShowAsDropDown. Соль этого окна в том, что оно закрывается при щелчке вне.
Для того, чтобы результат "ушел обратно" при успешных действиях - обычно делается делегат, который обрабатывается у родителя. Однако это не единственный способ вернуть значение - можно юзать функторы, а может даже втупую забить код для конкретной ситуации. Но опять же в целях универсальности лучше использовать делегат, гарантирующий обратный вызов.
Пример:
public class AutocompleteMenu : EditorWindow
{
    public int visibleCount = 6;

    public static void Open(Vector2 position, OnControlEventDelegate onControlEvent, params GUIContent[] variants)
    {
        var window = CreateInstance<AutocompleteMenu>();
        window.variants = variants;
        window.onControlEvent = onControlEvent;
        window.ShowAsDropDown(new Rect(position.x, position.y, 1, 1), new Vector2(200, 20*window.visibleCount));
    }

    public delegate void OnControlEventDelegate(Event @event);
    public OnControlEventDelegate onControlEvent;
}
Соответственно далее в такое окно дописывается метод OnGUI где рисуется абсолютно кастомный попап под наши потребности.
Метод "ShowAsDropDown" просит указать место своего появления в абсолютных координатах. Часто нам нужно отображать такой попап на месте щелчка мышью. Такие координаты мыши можно достать следующей командой:
var screenMousePos = GUIUtility.GUIToScreenPoint(Event.current.mousePosition);
Соль этого способа в том, что вид попапа может быть любым - вы можете сделать, например, выбор иконок или оформить окно по своему желанию.

PopupWindow

Данный способ по сути является автоматизацией предыдущего, предоставляя методы OnOpen/OnClose и заготовленный метод Show.
Суть в том чтобы пронаследовать наш класс от класса PopupWindow. Однако запомните - данная реализация ограничена в плане возврата обратного значения. Если вы используете попап для конкретных целей - данное окно вам подойдет, но для универсальных попапов желательно использовать ShowAsDropDown.

DisplayPopupMenu

Следующий способ - обычный попап, который используется во всех стандартных способах. По сути он лежит "в корне" работы GUI методов, которые я описывал немногим выше.
Этот способ использует делегат для обратного вызова.
Соль в вызове метода EditorUtility.DisplayPopupMenu, при вызове которого мы указываем ссылку на метод. Если вы хотите запаковать вызов пункта в метод без делегата вам понадобится создать класс аля:
public class PopupCallback
{
    public static PopupCallback instance;
    public int controlId;
    public bool change;

    public delegate void SetValueDelegate(object data);

    public static void Init(int controlId)
    {
        instance = new PopupCallback { controlId = controlId };
    }

    public static bool Its(int controlId)
    {
        return instance.w(x => x.change) && instance.controlId == controlId;
    }

    public object obj;
    public static EditorUtility.SelectMenuItemFunction SetValueStandart(int controlId)
    {
        Init(controlId);
        return instance._SetValue;
    }

    public static SetValueDelegate SetValue(int controlId)
    {
        Init(controlId);
        return instance._SetValue;
    }

    public void _SetValue(object userData, string[] options, int selected)
    {
        change = true;
        obj = selected;
    }

    public void _SetValue(object data)
    {
        change = true;
        obj = data;
    }

    public static object GetValue()
    {
        var result = instance.obj;
        instance = null;
        return result;
    }

    public static T GetValue<T>()
    {
        var result = (T)instance.obj;
        instance = null;
        return result;
    }
}
Данный класс содержит методы, необходимые для манипуляций с данными попапа. Если коротко - то в коде GUI вы должны завести id для вашего контрола и затем вызвать EditorUtility.DisplayPopupMenu. В данный метод вы подставляете на место делегата метод PopupCallback.SetValueStandart. После проверяете, равен ли id инстанса в PopupCallback вашему id (это уже идет код чтобы отловить обратный вызов). В положительном случае - достаете из инстанса данные.
Не совсем очевидно, но это именно то что делают Unity для формирования таких методов.
Кстати, у нас на сайте есть пример использования такого подхода. Так что при желании можно вкуривать этот код

GenericMenu

Завершает данный список класс GenericMenu. Его синтаксис необычайно прост - вы создаете экземпляр этого класса и добавляете через методы новые пункты. По завершению вызываете ShowAsContext. Каждый пункт может иметь свой обратный вызов, что упрощает создание меню с командами.

Кастомный попап без фокуса

Отдельной темой является создание попапов без фокуса. Дело в том, что на данный момент это нельзя сделать напрямую. Несмотря на это - потребность в таком попапе есть, притом существенная - это кастомные подсказки со встроенными картинками, это "умная строка", не сбивающая ввод текста и предлагающая варианты для окончания и прочие случаи, при которых новое окно не должно влиять на поведение.
Для таких целей я портировал костыль. Чтобы его использовать скопируйте целиком следующий код:

PopupWindowWithoutFocus.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEditor;
using UnityEngine;

internal class PopupWindowWithoutFocus : EditorWindow
{
    // Fields
    private Rect m_ActivatorRect;
    private const float m_BorderWidth = 1f;
    private Vector2 m_LastWantedSize = Vector2.zero;
    private PopupLocationHelper.PopupLocation[] m_LocationPriorityOrder;
    private PopupWindowContent m_WindowContent;
    private static Rect s_LastActivatorRect;
    private static double s_LastClosedTime;
    private static PopupWindowWithoutFocus s_PopupWindowWithoutFocus;

    // Methods
    private PopupWindowWithoutFocus()
    {
        hideFlags = HideFlags.DontSave;
    }

    private void FitWindowToContent()
    {
        Vector2 windowSize = m_WindowContent.GetWindowSize();
        if (m_LastWantedSize != windowSize)
        {
            m_LastWantedSize = windowSize;
            Vector2 minSize = windowSize + new Vector2(2f * m_BorderWidth, 2f * m_BorderWidth);
            Rect rect = PopupLocationHelper.GetDropDownRect(m_ActivatorRect, minSize, minSize, null, m_LocationPriorityOrder);
            var baseType = GetType().BaseType;
            if (baseType != null)
            {
                var fieldInfo = baseType.GetField("m_Pos", BindingFlags.Instance | BindingFlags.NonPublic);
                if (fieldInfo != null)
                    fieldInfo.SetValue(this, rect);
            }
            var vector3 = new Vector2(rect.width, rect.height);
            maxSize = vector3;
            base.minSize = vector3;
        }
    }

    public static void Hide()
    {
        if (s_PopupWindowWithoutFocus != null)
        {
            s_PopupWindowWithoutFocus.Close();
        }
    }

    private void Init(Rect activatorRect, PopupWindowContent windowContent, PopupLocationHelper.PopupLocation[] locationPriorityOrder)
    {
        m_WindowContent = windowContent;
        m_WindowContent.GetType()
            .GetProperty("editorWindow")
            .GetSetMethod(true)
            .Invoke(m_WindowContent, new object[] {this});
        m_ActivatorRect = GUIToScreenRect(activatorRect);
        m_LastWantedSize = windowContent.GetWindowSize();
        m_LocationPriorityOrder = locationPriorityOrder;
        Vector2 minSize = windowContent.GetWindowSize() + new Vector2(m_BorderWidth * 2f, m_BorderWidth * 2f);
        position = PopupLocationHelper.GetDropDownRect(m_ActivatorRect, minSize, minSize, null, m_LocationPriorityOrder);
        ShowPopup();
        Repaint();
    }

    internal static Rect GUIToScreenRect(Rect guiRect)
    {
        Vector2 vector = GUIUtility.GUIToScreenPoint(new Vector2(guiRect.x, guiRect.y));
        guiRect.x = vector.x;
        guiRect.y = vector.y;
        return guiRect;
    }


    public static bool IsVisible()
    {
        return (s_PopupWindowWithoutFocus != null);
    }

    private void OnDisable()
    {
        s_LastClosedTime = EditorApplication.timeSinceStartup;
        if (m_WindowContent != null)
        {
            m_WindowContent.OnClose();
        }
        s_PopupWindowWithoutFocus = null;
    }

    private void OnEnable()
    {
        s_PopupWindowWithoutFocus = this;
    }

    private static bool OnGlobalMouseOrKeyEvent(EventType type, KeyCode keyCode, Vector2 mousePosition)
    {
        if (s_PopupWindowWithoutFocus != null)
        {
            if ((type == EventType.KeyDown) && (keyCode == KeyCode.Escape))
            {
                s_PopupWindowWithoutFocus.Close();
                return true;
            }
            if ((type == EventType.MouseDown) && !s_PopupWindowWithoutFocus.position.Contains(mousePosition))
            {
                s_PopupWindowWithoutFocus.Close();
                return true;
            }
        }
        return false;
    }

    internal void OnGUI()
    {
        FitWindowToContent();
        var rect = new Rect(m_BorderWidth, m_BorderWidth, position.width - (2f * m_BorderWidth), position.height - (2f * m_BorderWidth));
        m_WindowContent.OnGUI(rect);
        GUI.Label(new Rect(0f, 0f, position.width, position.height), GUIContent.none, "grey_border");
    }

    private static bool ShouldShowWindow(Rect activatorRect)
    {
        if (((EditorApplication.timeSinceStartup - s_LastClosedTime) < 0.2) && !(activatorRect != s_LastActivatorRect))
        {
            return false;
        }
        s_LastActivatorRect = activatorRect;
        return true;
    }

    public static void Show(Rect activatorRect, PopupWindowContent windowContent)
    {
        Show(activatorRect, windowContent, null);
    }

    internal static void Show(Rect activatorRect, PopupWindowContent windowContent, PopupLocationHelper.PopupLocation[] locationPriorityOrder)
    {
        if (ShouldShowWindow(activatorRect))
        {
            if (s_PopupWindowWithoutFocus == null)
            {
                s_PopupWindowWithoutFocus = CreateInstance<PopupWindowWithoutFocus>();
            }
            s_PopupWindowWithoutFocus.Init(activatorRect, windowContent, locationPriorityOrder);
        }
    }
}


internal static class PopupLocationHelper
{
    private static Type _typePopupLocationHelper;
    private static Type typePopupLocationHelper
    {
        get
        {
            if (_typePopupLocationHelper == null)
                _typePopupLocationHelper = typeof(EditorGUI).Assembly.GetType("UnityEditor.PopupLocationHelper");
            return _typePopupLocationHelper;
        }
    }

    private static Type _typeContainerWindow;
    private static Type typeContainerWindow
    {
        get
        {
            if (_typeContainerWindow == null)
                _typeContainerWindow = typeof(EditorGUI).Assembly.GetType("UnityEditor.ContainerWindow");
            return _typeContainerWindow;
        }
    }

    private static MethodInfo _methodFitWindowRectToScreen;
    private static MethodInfo methodFitWindowRectToScreen
    {
        get
        {
            if (_methodFitWindowRectToScreen == null)
                _methodFitWindowRectToScreen = typeContainerWindow.GetMethod("FitWindowRectToScreen", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            return _methodFitWindowRectToScreen;
        }
    }

    private static MethodInfo _methodFitRectToScreen;
    private static MethodInfo methodFitRectToScreen
    {
        get
        {
            if (_methodFitRectToScreen == null)
                _methodFitRectToScreen = typeContainerWindow.GetMethod("FitRectToScreen", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            return _methodFitRectToScreen;
        }
    }

    // Methods
    private static Rect FitRect(Rect rect, object popupContainerWindow)
    {
        if (popupContainerWindow != null)
        {
            return (Rect)methodFitWindowRectToScreen.Invoke(popupContainerWindow, new object[] {rect, true, true});
        }
        return (Rect) methodFitRectToScreen.Invoke(null, new object[] {rect, true, true});
    }

    public static Rect GetDropDownRect(Rect buttonRect, Vector2 minSize, Vector2 maxSize, object popupContainerWindow)
    {
        return GetDropDownRect(buttonRect, minSize, maxSize, popupContainerWindow, null);
    }

    public static Rect GetDropDownRect(Rect buttonRect, Vector2 minSize, Vector2 maxSize, object popupContainerWindow, PopupLocation[] locationPriorityOrder)
    {
        if (locationPriorityOrder == null)
        {
            PopupLocation[] locationArray1 = new PopupLocation[2];
            locationArray1[1] = PopupLocation.Above;
            locationPriorityOrder = locationArray1;
        }
        List<Rect> rects = new List<Rect>();
        PopupLocation[] locationArray = locationPriorityOrder;
        for (int i = 0; i < locationArray.Length; i++)
        {
            Rect rect;
            switch (locationArray[i])
            {
                case PopupLocation.Below:
                    if (!PopupBelow(buttonRect, minSize, maxSize, popupContainerWindow, out rect))
                    {
                        break;
                    }
                    return rect;

                case PopupLocation.Above:
                    if (!PopupAbove(buttonRect, minSize, maxSize, popupContainerWindow, out rect))
                    {
                        goto Label_0079;
                    }
                    return rect;

                case PopupLocation.Left:
                    if (!PopupLeft(buttonRect, minSize, maxSize, popupContainerWindow, out rect))
                    {
                        goto Label_0099;
                    }
                    return rect;

                case PopupLocation.Right:
                    if (!PopupRight(buttonRect, minSize, maxSize, popupContainerWindow, out rect))
                    {
                        goto Label_00B9;
                    }
                    return rect;

                default:
                    {
                        continue;
                    }
            }
            rects.Add(rect);
            continue;
        Label_0079:
            rects.Add(rect);
            continue;
        Label_0099:
            rects.Add(rect);
            continue;
        Label_00B9:
            rects.Add(rect);
        }
        return GetLargestRect(rects);
    }

    private static Rect GetLargestRect(IEnumerable<Rect> rects)
    {
        var rect = new Rect();
        foreach (Rect rect2 in rects)
        {
            if ((rect2.height * rect2.width) > (rect.height * rect.width))
            {
                rect = rect2;
            }
        }
        return rect;
    }

    private static bool PopupAbove(Rect buttonRect, Vector2 minSize, Vector2 maxSize, object popupContainerWindow, out Rect resultRect)
    {
        Rect rect = new Rect(buttonRect.x, buttonRect.y - maxSize.y, maxSize.x, maxSize.y);
        float num = 0f;
        rect.yMin -= num;
        rect = FitRect(rect, popupContainerWindow);
        float a = Mathf.Max((buttonRect.y - rect.y) - num, 0f);
        if (a >= minSize.y)
        {
            float height = Mathf.Min(a, maxSize.y);
            resultRect = new Rect(rect.x, buttonRect.y - height, rect.width, height);
            return true;
        }
        resultRect = new Rect(rect.x, buttonRect.y - a, rect.width, a);
        return false;
    }

    private static bool PopupBelow(Rect buttonRect, Vector2 minSize, Vector2 maxSize, object popupContainerWindow, out Rect resultRect)
    {
        var rect = new Rect(buttonRect.x, buttonRect.yMax, maxSize.x, maxSize.y)
        {
            height = maxSize.y + k_SpaceFromBottom
        };
        rect = FitRect(rect, popupContainerWindow);
        float a = Mathf.Max((rect.yMax - buttonRect.yMax) - k_SpaceFromBottom, 0f);
        if (a >= minSize.y)
        {
            float height = Mathf.Min(a, maxSize.y);
            resultRect = new Rect(rect.x, buttonRect.yMax, rect.width, height);
            return true;
        }
        resultRect = new Rect(rect.x, buttonRect.yMax, rect.width, a);
        return false;
    }

    private static bool PopupLeft(Rect buttonRect, Vector2 minSize, Vector2 maxSize, object popupContainerWindow, out Rect resultRect)
    {
        var rect = new Rect(buttonRect.x - maxSize.x, buttonRect.y, maxSize.x, maxSize.y);
        const float num = 0f;
        rect.xMin -= num;
        rect.height += k_SpaceFromBottom;
        rect = FitRect(rect, popupContainerWindow);
        float a = Mathf.Max((buttonRect.x - rect.x) - num, 0f);
        float width = Mathf.Min(a, maxSize.x);
        resultRect = new Rect(rect.x, rect.y, width, rect.height - k_SpaceFromBottom);
        return (a >= minSize.x);
    }

    private static bool PopupRight(Rect buttonRect, Vector2 minSize, Vector2 maxSize, object popupContainerWindow, out Rect resultRect)
    {
        var rect = new Rect(buttonRect.xMax, buttonRect.y, maxSize.x, maxSize.y);
        const float num = 0f;
        rect.xMax += num;
        rect.height += k_SpaceFromBottom;
        rect = FitRect(rect, popupContainerWindow);
        float a = Mathf.Max((rect.xMax - buttonRect.xMax) - num, 0f);
        float width = Mathf.Min(a, maxSize.x);
        resultRect = new Rect(rect.x, rect.y, width, rect.height - k_SpaceFromBottom);
        return (a >= minSize.x);
    }

    // Properties
    private static float k_SpaceFromBottom
    {
        get
        {
            if (Application.platform == RuntimePlatform.OSXEditor)
            {
                return 10f;
            }
            return 0f;
        }
    }

    // Nested Types
    public enum PopupLocation
    {
        Below,
        Above,
        Left,
        Right
    }
}
В качестве примера используйте этот код:

пример

using UnityEditor;
using UnityEngine;

public class ExampleUnfocusWindow : PopupWindowContent
{
    [MenuItem("Window/ExampleUnfocusWindow")]
    public static void Open()
    {
        Open(new Vector2());
    }

    public static void Open(Vector2 position)
    {
        var locationPriorityOrder = new PopupLocationHelper.PopupLocation[3];
        locationPriorityOrder[0] = PopupLocationHelper.PopupLocation.Left;
        locationPriorityOrder[2] = PopupLocationHelper.PopupLocation.Right;
        PopupWindowWithoutFocus.Show(new Rect(position.x, position.y, 6, 6), new ExampleUnfocusWindow(), locationPriorityOrder);
    }

    public override Vector2 GetWindowSize()
    {
        return new Vector2(200, 200);
    }

    public override void OnOpen()
    {
        base.OnOpen();
    }

    public override void OnClose()
    {
        base.OnClose();
    }

    public override void OnGUI(Rect rect)
    {
        GUI.Box(rect, "Hello world");
    }
}

Настройка строки меню

Некоторые из указанных выше способов поддерживают расширенное форматирование для строки.
Если вы укажете в качестве пункта пустую строку, вместо неё будет задействован сепаратор (вертикальная черта).
Если вы разделите части строки дробной чертой /, вы создадите подпункт с иерархией.
Так же вы можете задать сочетание клавиш, при котором будет происходить вызов пункта меню. Для этого вам понадобится написать некоторую последовательность символов через пробел, после вашего пути.
В качестве спецсимволов зарезервированы:
% - ctrl
# - shift
& - alt
_ - отсутствие спецсимвола
Таким образом, если вы хотите назначить пункту меню клавишу G вы должны написать что-то подобное следующему:
[MenuItem("Test/ShowMessage _g")]
Так же пункты можно комбинировать, чтобы добиться сочетания аля 'ctrl+shift'.
Естественно, что не всем клавиши можно представить буквой, потому для некоторых клавиш используются специальные ключевые слова LEFT, RIGHT, UP, DOWN, F1 .. F12, HOME, END, PGUP, PGDN.
Важно понимать, что перед вводом сочетания клавиш нужно обязательно поставить пробел.
Подробнее об этой фиче вы можете узнать в официальной документации (хотя я вроде всё сам перечислил).

Никогда не думал что чтобы рассказать про меню нужно столько написать. А ведь я еще кастомные меню особо не расписывал
» Заготовки

стандартный класс попапа, появляющегося в позиции курсора

using UnityEditor;
using UnityEngine;

public class Popup : EditorWindow
{
    public static void Open(Vector2 size)
    {
        var window = CreateInstance<PopupArithmetic>();
        var screenMousePos = GUIUtility.GUIToScreenPoint(Event.current.mousePosition);
        window.ShowAsDropDown(new Rect(screenMousePos.x, screenMousePos.y, 1, 1), size);
    }
}

Просмотров: 3 483

alexprey #1 - 3 года назад 0
А на вторую часть скриншотов нету?
Devion #2 - 3 года назад 0
там нет смысла от скринов ибо:
  • либо это кастомный попап, который оформлен как мы захотим. Соответственно скринить нечего, ибо результат у каждого юзера свой
  • либо это те же попапы что и сверху, но не имеющие специфики в месте. Собственно именно в этом была соль первых скриншотов - показать где попапы те юзаются.
Devion #3 - 2 года назад (отредактировано ) 0
Добавил к статье пункт Создание попапа без фокуса. Такие попапы широко могут использоваться для создания собственного оформления подсказок в редакторе или, например, для предложения вариантов автозавершения строки.
Давненько искал способ сделать так, и даже спрашивал на форумах, но в ответ лишь пожимали плечами. Совершенно случайно бегая под рефлектором нашел как это делают в юнити, найденный код портировал, чем и делюсь.