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); }