private void CollapsedPackageActionsOnBeforeShowDropdown()
{
var newDropdownMenu = new DropdownMenu();
foreach (var extension in m_PackageActions.Where(a => a.visible))
{
var packageActionText = !string.IsNullOrEmpty(extension.text) ? extension.text : extension.tooltip;
if (!extension.visibleDropdownItems.Any())
{
newDropdownMenu.AppendAction(packageActionText, a => { extension.action?.Invoke(m_Window.activeSelection); });
}
else
{
if (extension.action != null)
{
newDropdownMenu.AppendAction($"{packageActionText}/{packageActionText}", a => { extension.action?.Invoke(m_Window.activeSelection); });
}
foreach (var item in extension.visibleDropdownItems)
{
newDropdownMenu.AppendAction($"{packageActionText}/{item.text}", a => { item.action?.Invoke(m_Window.activeSelection); }, item.statusCallback);
}
}
}
m_CollapsedPackageActions.menu = newDropdownMenu;
}
void Start()
{
Menu = FindObjectOfType <DropdownMenu>();
Scroller = FindObjectOfType <MenuScroller>();
Menu.Hide();
Menu.StatsMenu.CreateStats();
}
private void DisplayAssetStoreCachePathSetting()
{
assetsCacheLocationInfo.enableRichText = true;
assetsCacheLocationInfo.text = string.Format(L10n.Tr("Your assets will be store in <b>{0}</b> subfolder."), k_AssetStoreFolder);
assetsCacheDropdown.SetIcon("folder");
var assetsCacheDropdownMenu = new DropdownMenu();
assetsCacheDropdownMenu.AppendAction(k_OpenFolder, action =>
{
if (!string.IsNullOrWhiteSpace(assetsCachePath.text))
{
m_ApplicationProxy.RevealInFinder(Paths.Combine(assetsCachePath.text, k_AssetStoreFolder));
}
}, action => m_CurrentAssetStoreConfig.status == AssetStoreCachePathManager.ConfigStatus.InvalidPath ? DropdownMenuAction.Status.Disabled : DropdownMenuAction.Status.Normal, "openLocation");
assetsCacheDropdownMenu.AppendAction(k_ChangeLocation, action =>
{
var path = m_ApplicationProxy.OpenFolderPanel("Select Assets Cache Location", Paths.Combine(assetsCachePath.text, k_AssetStoreFolder));
if (!string.IsNullOrWhiteSpace(path))
{
path = path.NormalizePath();
if (path.EndsWith(Path.DirectorySeparatorChar + k_AssetStoreFolder))
{
path = path.Substring(0, path.Length - k_AssetStoreFolder.Length - 1);
}
if (string.CompareOrdinal(path, m_CurrentAssetStoreConfig.path.NormalizePath()) == 0)
{
return;
}
if (!CancelDownloadInProgress())
{
return;
}
var status = m_AssetStoreCachePathProxy.SetConfig(path);
if (status == AssetStoreCachePathManager.ConfigStatus.Failed)
{
DisplayAssetsCacheErrorBox(HelpBoxMessageType.Error, L10n.Tr($"Cannot set the Assets Cache location, \"{path}\" is invalid or inaccessible."));
}
}
}, action => m_CurrentAssetStoreConfig.source != ConfigSource.Environment ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled, "selectLocation");
assetsCacheDropdownMenu.AppendAction(k_ResetToDefaultLocation, action =>
{
if (!CancelDownloadInProgress())
{
return;
}
var status = m_AssetStoreCachePathProxy.ResetConfig();
if (status == AssetStoreCachePathManager.ConfigStatus.Failed)
{
DisplayAssetsCacheErrorBox(HelpBoxMessageType.Error, L10n.Tr("Cannot reset the Assets Cache location to default."));
}
}, action => m_CurrentAssetStoreConfig.source == ConfigSource.User ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled, "resetLocation");
assetsCacheDropdown.menu = assetsCacheDropdownMenu;
GetAssetStoreCacheConfig();
m_AssetStoreCachePathProxy.onConfigChanged += RefreshAssetStoreCachePathConfig;
}
public ToolbarPopupSearchField()
{
AddToClassList(popupVariantUssClassName);
menu = new DropdownMenu();
searchButton.clickable.clicked += this.ShowMenu;
}
public static void Execute(Atom parent)
{
var nb =new NavBar ();
nb.BrandText="App Title";
nb.Add ("Home");
nb.Add ("License");
nb.Add ("Contact");
var dd = new DropdownMenu ();
dd.Text = "Config";
dd.Nav.Add ("Users");
dd.Nav.Add ("Groups");
nb.Add (dd);
var log = new Div ();
var code = new Div ();
new Div (d=>{
d.ClassName="bs-docs-example";
d.JQuery.Append(nb).Append(log).Append("C# code".Header(4)).Append(code);
parent.Append(d);
});
nb.Selected += (e) => {
var i = e.CurrentTarget.As<NavItem> ();
log.Text= "{0} Clicked".Fmt(i.Text);
};
var rq =jQuery.GetData<string> ("code/demonavbar.html");
rq.Done (s=> code.Text=s);
}
public void AddDropdownItems(DropdownMenu menu)
{
m_LoadAllDiff = m_Total - m_NumberOfPackagesShown <= (int)AssetsToLoad.Min;
var minDiff = m_LoadAllDiff;
if (!minDiff)
{
AddDropdownItem(menu, (int)AssetsToLoad.Min);
}
m_LoadAllDiff = m_Total - m_NumberOfPackagesShown <= (int)AssetsToLoad.Max;
var maxDiff = m_LoadAllDiff;
if (!maxDiff)
{
AddDropdownItem(menu, (int)AssetsToLoad.Max);
}
var showDropDownArea = !minDiff || !maxDiff;
if (showDropDownArea)
{
AddDropdownItem(menu, (int)AssetsToLoad.All);
}
}
/**
* Used to get around an odd bug with setActive (we only need to set inactive once, not for every slot. Also, each slot needs the reference).
* */
public void PassDropdown(GameObject dropDownObject, DropdownMenu script, GameObject background, GameObject actualBackground)
{
this.actualBackground = actualBackground;
dropDownMenu = dropDownObject;
dropdownScript = script;
dropDownMenuBackground = background;
}
public MarkerTrack(Timeline owner) : base(owner)
{
name = "Markers";
AddToClassList("markerTrack");
RegisterCallback <AttachToPanelEvent>(OnAttachToPanel);
RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel);
m_MarkerOverlapIndicators = new List <MarkerOverlapIndicator>();
var manipulator = new ContextualMenuManipulator(evt =>
{
DropdownMenu menu = evt.menu;
float time = m_Owner.WorldPositionToTime(evt.mousePosition.x);
if (m_Owner.ViewMode == TimelineViewMode.frames)
{
time = (float)TimelineUtility.RoundToFrame(time, Clip.SampleRate);
}
string timeStr = TimelineUtility.GetTimeString(m_Owner.ViewMode, time, (int)Clip.SampleRate);
menu.AppendAction($"Add Marker at {timeStr}", null, DropdownMenuAction.Status.Disabled);
menu.AppendSeparator();
var menuStatus = EditorApplication.isPlaying ? DropdownMenuAction.Status.Disabled : DropdownMenuAction.Status.Normal;
foreach (Type markerType in MarkerAttribute.GetMarkerTypes())
{
evt.menu.AppendAction(MarkerAttribute.GetDescription(markerType), action => OnAddAnnotationSelection(markerType, time), a => menuStatus, markerType);
}
});
this.AddManipulator(manipulator);
}
public static ContextualMenuPopulateEvent GetPooled(EventBase triggerEvent, DropdownMenu menu, IEventHandler target, ContextualMenuManager menuManager)
{
ContextualMenuPopulateEvent e = GetPooled(triggerEvent);
if (triggerEvent != null)
{
triggerEvent.Acquire();
e.triggerEvent = triggerEvent;
IMouseEvent mouseEvent = triggerEvent as IMouseEvent;
if (mouseEvent != null)
{
e.modifiers = mouseEvent.modifiers;
e.mousePosition = mouseEvent.mousePosition;
e.localMousePosition = mouseEvent.mousePosition;
e.mouseDelta = mouseEvent.mouseDelta;
e.button = mouseEvent.button;
e.clickCount = mouseEvent.clickCount;
}
IMouseEventInternal mouseEventInternal = triggerEvent as IMouseEventInternal;
if (mouseEventInternal != null)
{
((IMouseEventInternal)e).triggeredByOS = mouseEventInternal.triggeredByOS;
}
}
e.target = target;
e.menu = menu;
e.m_ContextualMenuManager = menuManager;
return(e);
}
public void Setup()
{
m_Instance = new CopyAllTheFields();
m_Menu = new DropdownMenu();
m_Menu.AddCopyValue(m_Instance);
m_Actions = m_Menu.MenuItems().OfType <DropdownMenuAction>().ToArray();
}
public DropdownMenu OpenAt(DropdownContext context, Vector2 worldPos)
{
DropdownMenu menu = OpenInternal(context);
menu.PositionMenu(worldPos, Space.World);
return(menu);
}
private void AddContextMenuOptions(DropdownMenu objMenu, Tuple <string, Action>[] contextualMenuOptions)
{
for (int i = 0; i < contextualMenuOptions.Length; i++)
{
int localIndex = i;
objMenu.AppendAction(contextualMenuOptions[i].Item1, dropdownMenuAction => contextualMenuOptions[localIndex].Item2.Invoke());
}
}
public static DropdownMenu CreateAndroid(IGUIMessages receiver, bool makeNetworkGUI)
{
DropdownMenu dropdown = new DropdownMenu(receiver,(int)(Screen.height*0.02),(int)(Screen.height*0.08), makeNetworkGUI);
dropdown.positionOpen = new Rect(Screen.width-120,40,120,150);
dropdown.positionClosed = new Rect(Screen.width-80,0,80,40);
dropdown.SetUpButtons((int)(Screen.height*0.02),(int)(Screen.height*0.08));
return dropdown;
}
public static void AddCopyValue <TValue>(this DropdownMenu menu, TValue value)
{
menu.AppendAction($"{k_CopyPrefix}All", action => { EditorGUIUtility.systemCopyBuffer = JsonSerialization.ToJson(value); });
menu.AppendSeparator(k_CopyPrefix);
var visitor = new DropdownMenuCopyVisitor(menu);
PropertyContainer.Visit(value, visitor);
}
public static void ShowMenu(this VisualElement visualElement, DropdownMenu menu)
{
if (visualElement != null && menu != null && menu.MenuItems().Any())
{
Vector2 p = new Vector2(visualElement.layout.xMin, visualElement.layout.yMax);
p = visualElement.parent.LocalToWorld(p);
menu.DoDisplayEditorMenu(p);
}
}
public void DisplayMenu(EventBase triggerEvent, IEventHandler target)
{
DropdownMenu menu = new DropdownMenu();
using (ContextualMenuPopulateEvent cme = ContextualMenuPopulateEvent.GetPooled(triggerEvent, menu, target, this))
{
target.SendEvent(cme);
}
}
private void PopulateContextMenu(ContextualMenuPopulateEvent populateEvent)
{
DropdownMenu dropdownMenu = populateEvent.menu;
if (IsCloseable)
{
dropdownMenu.AppendAction("Close Tab", e => OnClose(this));
}
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
DropdownMenu.Dispose();
}
void AppendWorlds(DropdownMenu menu, WorldCategoryHelper.Category category)
{
foreach (var world in category.Worlds)
{
menu.AppendAction(world.Name, OnWorldSelected, a =>
(BaseState.SelectedWorldName == world.Name)
? DropdownMenuAction.Status.Checked
: DropdownMenuAction.Status.Normal, world);
}
}
public ToolbarMenu()
{
Toolbar.SetToolbarStyleSheet(this);
clickable = new Clickable(this.ShowMenu);
this.AddManipulator(clickable);
menu = new DropdownMenu();
AddToClassList(ussClassName);
}
public static void SetupOptions <T>(this DropdownMenu self, T initialValue, Action <T> callback, Func <T, bool> statusCallback) where T : Enum
{
foreach (T value in Enum.GetValues(typeof(T)))
{
self.AppendAction(value.ToString(),
a => { callback.Invoke(value); },
a => { return(statusCallback.Invoke(value) ? DropdownMenuAction.Status.Checked : DropdownMenuAction.Status.Normal); });
}
callback.Invoke(initialValue);
}
void AddNoteMenuItems(DropdownMenu menu, string menuText, string category, Action <VisualElement, SpriteAlignment> createMethod)
{
Array spriteAlignments = Enum.GetValues(typeof(SpriteAlignment));
Array.Reverse(spriteAlignments);
foreach (SpriteAlignment align in spriteAlignments)
{
SpriteAlignment alignment = align;
menu.AppendAction(menuText + "/" + category + "/" + alignment, (a) => createMethod(this, alignment), DropdownMenuAction.AlwaysEnabled);
}
}
public void POpulateStatTypes(string curren, DropdownMenu menu)
{
List <string> temp = new List <string>();
foreach (StatTypes item in Enum.GetValues(typeof(StatTypes)))
{
temp.Add(item.ToString());
}
PopulateMenu(temp, curren, menu);
}
public HeaderBar(IGUIMessages receiver, bool makeNetworkGUI)
{
this.receiver = receiver;
# if UNITY_WEBPLAYER
dropdownMenu = DropdownMenu.Create(receiver, makeNetworkGUI);
# elif UNITY_ANDROID
dropdownMenu = DropdownMenu.CreateAndroid(receiver, makeNetworkGUI);
# else
dropdownMenu = DropdownMenu.Create(receiver, makeNetworkGUI);
# endif
}
private void CreateDropdown(DropdownMenu menu)
{
foreach (ShapeBlueprintFactory.ShapeBlueprintType shapeType in Enum
.GetValues(typeof(ShapeBlueprintFactory.ShapeBlueprintType))
.Cast <ShapeBlueprintFactory.ShapeBlueprintType>())
{
menu.AppendAction(
shapeType.ToString(),
menuAction => CreateBlueprint(shapeType),
DropdownMenuAction.AlwaysEnabled);
}
}
public ExtendableToolbarMenu()
{
ResolveDependencies();
m_BuiltInItems = new List <MenuDropdownItem>();
m_DropdownItems = new List <MenuDropdownItem>();
menu = new DropdownMenu();
clicked += OnClicked;
m_NeedRefresh = true;
}
public void OnDropdownButtonClicked()
{
if (DropdownMenu == null)
{
return;
}
var menuPosition = new Vector2(layout.xMin, layout.center.y + 2);
menuPosition = parent.LocalToWorld(menuPosition);
var menuRect = new Rect(menuPosition, Vector2.zero);
DropdownMenu.DropDown(menuRect);
}
public void UpdateMenu()
{
var menu = new DropdownMenu();
EditorApplication.delayCall -= UpdateMenu;
if (m_Enabled && m_Total == 0)
{
EditorApplication.delayCall += UpdateMenu;
}
AddDropdownItems(menu);
loadAssetsDropdown.menu = menu.MenuItems().Count > 0 ? menu : null;
}
private void DisplayPackagesCacheSetting()
{
packagesCacheDropdown.SetIcon("folder");
var packagesCacheDropdownMenu = new DropdownMenu();
packagesCacheDropdownMenu.AppendAction(k_OpenFolder, action =>
{
if (!string.IsNullOrWhiteSpace(currentPackagesNormalizedPath))
{
m_ApplicationProxy.RevealInFinder(currentPackagesNormalizedPath);
}
}, action => DropdownMenuAction.Status.Normal, "openLocation");
packagesCacheDropdownMenu.AppendAction(k_ChangeLocation, action =>
{
var path = m_ApplicationProxy.OpenFolderPanel(L10n.Tr("Select Packages Cache Location"), currentPackagesNormalizedPath);
path = path.NormalizePath();
if (!string.IsNullOrWhiteSpace(path) && string.CompareOrdinal(path, currentPackagesNormalizedPath) != 0)
{
m_UpmCacheRootClient.SetCacheRoot(path);
}
}, action => m_CurrentPackagesConfig.source != ConfigSource.Environment ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled, "selectLocation");
packagesCacheDropdownMenu.AppendAction(k_ResetToDefaultLocation, action =>
{
m_UpmCacheRootClient.ClearCacheRoot();
}, action => m_CurrentPackagesConfig.source == ConfigSource.User ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled, "resetLocation");
packagesCacheDropdown.menu = packagesCacheDropdownMenu;
m_UpmCacheRootClient.onGetCacheRootOperationError += OnPackagesGetCacheRootOperationError;
m_UpmCacheRootClient.onGetCacheRootOperationResult += OnPackagesGetCacheRootOperationResult;
m_UpmCacheRootClient.onSetCacheRootOperationError += OnPackagesSetCacheRootOperationError;
m_UpmCacheRootClient.onSetCacheRootOperationResult += OnPackagesSetCacheRootOperationResult;
m_UpmCacheRootClient.onClearCacheRootOperationError += OnPackagesClearCacheRootOperationError;
m_UpmCacheRootClient.onClearCacheRootOperationResult += OnPackagesClearCacheRootOperationResult;
if (!m_ApplicationProxy.isBatchMode && m_ApplicationProxy.isUpmRunning)
{
packagesCachePath.text = string.Empty;
packagesCacheDropdown.SetEnabled(false);
UIUtils.SetElementDisplay(packagesCacheErrorBox, false);
m_UpmCacheRootClient.GetCacheRoot();
}
else
{
packagesCachePath.text = string.Empty;
packagesCacheDropdown.SetEnabled(false);
DisplayPackagesCacheErrorBox(HelpBoxMessageType.Error, L10n.Tr("Cannot get the Packages Cache location, UPM server is not running."));
}
}
// ECS Specific contextual menu entries fall in here
public void BuildContextualMenu(DropdownMenu menu,
VisualElement targetElement,
Store store,
Vector2 mousePosition)
{
if (targetElement == null)
{
return;
}
var componentRow = targetElement.GetFirstOfType <ComponentRow>();
if (componentRow?.Component != null)
{
menu.AppendAction("Update", menuAction =>
{
var filter = new SearcherFilter(SearcherContext.Type)
.WithComponentData(m_Stencil)
.WithSharedComponentData(m_Stencil);
componentRow.UpdateType(mousePosition, filter);
}, eventBase => DropdownMenuAction.Status.Normal);
menu.AppendAction("Delete", menuAction =>
{
store.Dispatch(new RemoveComponentFromQueryAction((ComponentQueryDeclarationModel)componentRow.GraphElementModel, componentRow.Component));
}, eventBase => DropdownMenuAction.Status.Normal);
return;
}
if (targetElement is CriterionRow criterionRow && criterionRow.Criterion != null)
{
menu.AppendAction("Update", menuAction =>
{
criterionRow.Update(mousePosition);
}, eventBase => DropdownMenuAction.Status.Normal);
menu.AppendAction("Delete", menuAction =>
{
store.Dispatch(new RemoveCriterionAction((ICriteriaModelContainer)criterionRow.GraphElementModel, criterionRow.CriteriaModel, criterionRow.Criterion));
}, eventBase => DropdownMenuAction.Status.Normal);
return;
}
var criteriaModelRow = targetElement.GetFirstOfType <CriteriaModelRow>();
if (criteriaModelRow?.CriteriaModel != null)
{
menu.AppendAction("Delete", menuAction =>
{
store.Dispatch(new RemoveCriteriaModelAction((ICriteriaModelContainer)criteriaModelRow.GraphElementModel, criteriaModelRow.CriteriaModel));
}, eventBase => DropdownMenuAction.Status.Normal);
}
}
public void OnAdvancedMenuCreate(DropdownMenu menu)
{
if (!Unsupported.IsDeveloperMode())
{
return;
}
menu.AppendSeparator();
menu.AppendAction("Internal/Always show development tools", a =>
{
OnDevelopmentToolToggle();
}, a => !Unsupported.IsDeveloperMode() ? DropdownMenuAction.Status.Hidden :
AlwaysShowDevTools?DropdownMenuAction.Status.Checked: DropdownMenuAction.Status.Normal);
}
/// <summary>
/// Displays the contextual menu.
/// </summary>
/// <param name="triggerEvent">The event that triggered the display of the menu.</param>
/// <param name="target">The element for which the menu is displayed.</param>
public void DisplayMenu(EventBase triggerEvent, IEventHandler target)
{
DropdownMenu menu = new DropdownMenu();
using (ContextualMenuPopulateEvent cme = ContextualMenuPopulateEvent.GetPooled(triggerEvent, menu, target, this))
{
target?.SendEvent(cme);
}
if (Application.platform == RuntimePlatform.OSXEditor || Application.platform == RuntimePlatform.OSXPlayer)
{
displayMenuHandledOSX = true;
}
}
public void PopulateMenu(IEnumerable list, string current, DropdownMenu dropDown)
{
dropDown.ClearList();
dropDown.ClearListeners();
foreach (string item in list)
{
dropDown.AddList(item, current);
}
dropDown.droptDown.RefreshShownValue();
dropDown.droptDown.onValueChanged.AddListener(delegate { Save(); });
}
public HeaderBar(Control c, NetworkInterface nif)
{
dropdownMenu = new DropdownMenu(c,nif);
}
/// <summary>
///
/// </summary>
/// <param _Name="component"></param>
public override void Initialize(IComponent component)
{
_DropdownMenu = (DropdownMenu)component;
base.Initialize(component);
}
public TutorialHeader(Control c)
{
dropdownMenu = new DropdownMenu(c,null);
}
