public static DropdownState Dropdown(Rect position, string[] options, DropdownState state, DropdownStyles styles = null) { setup(); if (styles == null) { styles = defaultDropdownStyles_; } switch (state.currentStatus) { case DropdownState.status.Closed: return(closedDropdown(position, options, state, styles)); case DropdownState.status.Opening: return(openingDropdown(position, options, state, styles)); case DropdownState.status.Opened: return(openedDropdown(position, options, state, styles)); case DropdownState.status.Closing: return(closingDropdown(position, options, state, styles)); } return(state); }
private DropdownState DropdownStateSelection(DropdownState value, bool isEnemy = false, bool showIdle = false) { using (new GUILayout.HorizontalScope()) { DropdownState result = value; Button(Local["Menu_Btn_None"], DropdownState.None); Button(Local["Menu_Btn_Never"], DropdownState.Never); Button(Local[!isEnemy ? "Menu_Btn_InteractionPlayer" : "Menu_Btn_InteractionEnemy"], DropdownState.Interaction); Button(Local["Menu_Btn_ForcedShow"], DropdownState.ForcedShow); Button(Local["Menu_Btn_OnPause"], DropdownState.OnPause); Button(Local["Menu_Btn_Always"], DropdownState.Always); if (showIdle) { Button(Local["Menu_Btn_Idleness"], DropdownState.Idleness); } void Button(string text, DropdownState state) { if (GUILayout.Button(text, value == state ? _downButtonStyle : _buttonStyle, GUILayout.ExpandWidth(false))) { result = state; } } return(result); } }
static int drawDropdownList(Rect position, string[] options, DropdownState state, DropdownStyles styles) { int newSelect = -1; float offsetY = position.yMax; float totalOptionHeight = position.height * options.Length; if (offsetY + totalOptionHeight > Screen.height) { offsetY = position.yMin - totalOptionHeight; } for (int i = 0; i < options.Length; i++) { var optionPosition = position; optionPosition.y = offsetY + position.height * i; string text = string.Format("{0}{1}", i == state.Select ? " ✓ " : " ", options[i]); if (GUI.Button(optionPosition, text, styles.Option)) { newSelect = i; } } return(newSelect); }
/// <summary> /// Raises the MouseDown event. /// </summary> /// <param name="e">A MouseEventArgs that contains the event data.</param> protected override void OnMouseDown(MouseEventArgs e) { base.OnMouseDown(e); SetFlag(Mouse_Up, false); SetFlag(Mouse_Down, true); if (GetFlag(Disabled)) { _dropdownState = DropdownState.Disabled; Invalidate(); return; } if (e.Button == MouseButtons.Left) { if (_buttonRectangle.Contains(this.PointToClient(Cursor.Position))) { SetFlag(NonButtonArea, false); _dropdownState = DropdownState.Pressed; Invalidate(); } else { SetFlag(NonButtonArea, true); _dropdownState = DropdownState.Default; Invalidate(); } } }
/// <summary> /// Raises the MouseLeave event. /// </summary> /// <param name="e">A MouseEventArgs that contains the event data.</param> protected override void OnMouseLeave(EventArgs e) { base.OnMouseLeave(e); SetFlag(Mouse_Enter, false); SetFlag(Mouse_Leave, true); if (GetFlag(Show_Popup)) {// pop up is open _dropdownState = DropdownState.Pressed; Invalidate(); } else {// pop up is closed if (GetFlag(Have_Focus)) { _dropdownState = DropdownState.Default; Invalidate(); } else {// lost focus _dropdownState = DropdownState.Normal; Invalidate(); } } }
public DisableCombatText() { ShowAvoidOnCombatText = SettingsRoot.Instance.ShowAvoidOnCombatText.CurrentState; ShowMissOnCombatText = SettingsRoot.Instance.ShowMissOnCombatText.CurrentState; ShowAttackOfOpportunityOnCombatText = SettingsRoot.Instance.ShowAttackOfOpportunityOnCombatText.CurrentState; ShowCriticalHitOnCombatText = SettingsRoot.Instance.ShowCriticalHitOnCombatText.CurrentState; ShowSneakAttackOnCombatText = SettingsRoot.Instance.ShowSneakAttackOnCombatText.CurrentState; ShowDamageOnCombatText = SettingsRoot.Instance.ShowDamageOnCombatText.CurrentState; ShowSavesInCombatText = SettingsRoot.Instance.ShowSavesInCombatText.CurrentState; ShowPartyActions = SettingsRoot.Instance.ShowPartyActions.CurrentState; ShowEnemyActions = SettingsRoot.Instance.ShowEnemyActions.CurrentState; ShowPartyHP = SettingsRoot.Instance.ShowPartyHP.CurrentState; ShowEnemyHP = SettingsRoot.Instance.ShowEnemyHP.CurrentState; SettingsRoot.Instance.ShowAvoidOnCombatText.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowMissOnCombatText.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowAttackOfOpportunityOnCombatText.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowCriticalHitOnCombatText.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowSneakAttackOnCombatText.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowDamageOnCombatText.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowSavesInCombatText.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowPartyActions.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowEnemyActions.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowPartyHP.CurrentState = DropdownState.None; SettingsRoot.Instance.ShowEnemyHP.CurrentState = DropdownState.None; }
static DropdownState closedDropdown(Rect position, string[] options, DropdownState state, DropdownStyles styles) { if (drawCaption(position, options, state, styles)) { state.currentStatus = DropdownState.status.Opening; } return(state); }
private void ControlLostFocus(object sender, EventArgs e) { SetFlag(Have_Focus, false); if (!GetFlag(Show_Popup) && GetFlag(Mouse_Leave)) { _dropdownState = DropdownState.Normal; Invalidate(); } }
private static void DrawBackground(Graphics g, Rectangle bounds, DropdownState state, Color background) { Color c = background; if (state != DropdownState.Disabled) { g.FillRectangle(new SolidBrush(c), bounds); } else { g.FillRectangle(SystemBrushes.ControlLight, bounds); } }
private static void DrawHighlight(Graphics g, Rectangle bounds, DropdownState state) { switch (state) { case DropdownState.Hot: g.FillRectangle(new SolidBrush(_FocusBackGroundColor), bounds); break; case DropdownState.Pressed: g.FillRectangle(new SolidBrush(_FocusPressedColor), bounds); break; } }
/// <summary> /// Raises the MouseEnter event. /// </summary> /// <param name="e">A MouseEventArgs that contains the event data.</param> protected override void OnMouseEnter(EventArgs e) { base.OnMouseEnter(e); SetFlag(Mouse_Leave, false); if (GetFlag(Show_Popup)) { return; } SetFlag(Popup_Shown, false); SetFlag(Mouse_Enter, true); _dropdownState = DropdownState.Hot; Invalidate(); }
static DropdownState openedDropdown(Rect position, string[] options, DropdownState state, DropdownStyles styles) { if (drawCaption(position, options, state, styles)) { state.currentStatus = DropdownState.status.Closing; } int newSelect = drawDropdownList(position, options, state, styles); if (newSelect >= 0) { state.nextSelect = newSelect; state.currentStatus = DropdownState.status.Closing; } return(state); }
/// <summary> /// Raises the MouseMove event. /// </summary> /// <param name="e">A MouseEventArgs that contains the event data.</param> protected override void OnMouseMove(MouseEventArgs e) { base.OnMouseMove(e); if (GetFlag(Show_Popup)) { return; } if (_buttonRectangle.Contains(this.PointToClient(Cursor.Position))) {// button area of control if (_dropdownState != DropdownState.Hot) { _dropdownState = DropdownState.Hot; Invalidate(); } } }
/// <summary> /// Raises the MouseUp event. /// </summary> /// <param name="e">A MouseEventArgs that contains the event data.</param> protected override void OnMouseUp(MouseEventArgs e) { base.OnMouseUp(e); SetFlag(Mouse_Down, false); SetFlag(Mouse_Up, true); if (!GetFlag(Have_Focus)) { _dropdownState = DropdownState.Normal; Invalidate(); return; } if (GetFlag(Mouse_Up) && GetFlag(Mouse_Enter) && GetFlag(Popup_Shown)) { SetFlag(Popup_Shown, false); return; } if (GetFlag(Popup_Shown)) { SetFlag(Popup_Shown, false); if (!GetFlag(Mouse_Enter)) { return; } } if (!GetFlag(Show_Popup) && !GetFlag(NonButtonArea)) { _dropdownState = DropdownState.Pressed; Invalidate(); OpenPopupWindow(); AnimateDropdownControl(); } else { _dropdownState = DropdownState.Hot; Invalidate(); } }
/// <summary> /// Initializes a new instance of the Dropdown Control class. /// </summary> public DropdownControl() { SetStyle(ControlStyles.ResizeRedraw | ControlStyles.OptimizedDoubleBuffer | ControlStyles.Selectable | ControlStyles.UserMouse | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true); _dropdownState = DropdownState.Normal; _dockSide = DockSide.Left; _hostControl = null; _showDropShadow = true; ControlAdded += ClientControlAdded; LostFocus += ControlLostFocus; GotFocus += ControlGotFocus; TextChanged += ControlTextChanged; }
static DropdownState openingDropdown(Rect position, string[] options, DropdownState state, DropdownStyles styles) { const float fadeTime = 0.1f; float dt = Time.time - state.currentStatusStartTime; drawCaption(position, options, state, styles); var prevColor = GUI.color; GUI.color = new Color(1, 1, 1, dt / fadeTime); drawDropdownList(position, options, state, styles); GUI.color = prevColor; if (dt >= fadeTime) { state.currentStatus = DropdownState.status.Opened; } return(state); }
static bool drawCaption(Rect position, string[] options, DropdownState state, DropdownStyles styles) { if (0 <= state.Select && state.Select < options.Length) { state.Caption = options[state.Select]; } // Caption bool pushed = GUI.Button(position, state.Caption, styles.Caption); // Arrow var arrowPosition = new Rect( position.xMax - styles.ArrowMargin - styles.ArrowSize, position.center.y - styles.ArrowSize / 2, styles.ArrowSize, styles.ArrowSize); var prevColor = GUI.color; GUI.color = styles.ArrowColor; GUI.DrawTexture(arrowPosition, arrowTexture_); GUI.color = prevColor; return(pushed); }
/// <summary> /// Draws a button with a chevron /// </summary> /// <param name="c">DropdownControl instance.</param> /// <param name="g">The graphics used to draw the button.</param> /// <param name="state">On of the DropdownState values that specifies the visual state of the button.</param> public static void DrawDropDownButton(DropdownControl c, Graphics g, DropdownState state) { Rectangle r = ButtonBounds(c.ClientRectangle, c.ButtonSide); r = new Rectangle(r.X, r.Y, r.Width - 1, r.Height - 1); DrawHighlight(g, r, state); // x,y offset to center image chevron on split button int XPos = ((r.Width / 2) - (_Chevron1.Width / 2)); int YPos = (r.Height / 2) - (_Chevron1.Height / 2); switch (state) { case DropdownState.Normal: case DropdownState.Default: g.DrawImage(_Chevron1, r.X + XPos, YPos); break; case DropdownState.Disabled: g.DrawImage(_Chevron3, r.X + XPos, YPos); break; case DropdownState.Pressed: g.DrawImage(_Chevron2, r.X + XPos, YPos); g.DrawRectangle(new Pen(_FocusBorderColor), r); break; case DropdownState.Hot: g.DrawImage(_Chevron4, r.X + XPos, YPos); using (Pen p = new Pen(_FocusColor)) { g.DrawRectangle(p, r); } break; } }
// static public int Dropdown(Rect position, DropdownState state) { int result = state.selected; GUIContent content = state.selected >= 0 && state.selected < state.items.Count ? state.items[state.selected] : GUIContent.none; if (GUI.Button(position, content, skin.GetStyle("dropdown"))) { state.expanded = !state.expanded; } GUI.Label(position, state.expanded ? labelArrowUp : labelArrowDown, skin.GetStyle("dropdownbutton")); if (state.expanded) { GUIStyle verticalScrollbar = GUI.skin.verticalScrollbar; Rect viewRect = new Rect(0f, 0f, position.width, 0f); var itemStyle = skin.GetStyle("dropdownitem"); bool scrollbar = false; for (int i = 0; i < state.items.Count; i++) { viewRect.height += Mathf.Max(itemStyle.CalcHeight(state.items[i], viewRect.width), state.itemMinHeight); } if (viewRect.height > state.maxHeight) { scrollbar = true; // Recalculate viewRect height for new width without scrollbar viewRect.width = position.width - (verticalScrollbar.fixedWidth + verticalScrollbar.margin.left); viewRect.height = 0f; for (int i = 0; i < state.items.Count; i++) { viewRect.height += Mathf.Max(itemStyle.CalcHeight(state.items[i], viewRect.width), state.itemMinHeight); } } // float clipWidth = viewRect.width; float clipHeight = Mathf.Min(viewRect.height, state.maxHeight); Event evt = Event.current; Rect scrollRect = new Rect(position.x, position.y + position.height, position.width, clipHeight); // Override scroll delta if (evt.rawType == EventType.ScrollWheel && scrollRect.Contains(evt.mousePosition)) { evt.delta = new Vector2(evt.delta.x, ((evt.delta.y > 0f ? 1f : -1f) * state.itemMinHeight) / 20f); } // Manually draw VerticalScrollbar to fix String.Concat garbage every frame in GUI.VerticalScrollbar if (scrollbar) { var scrollbarRect = new Rect(scrollRect.x + scrollRect.width - verticalScrollbar.fixedWidth, scrollRect.y, verticalScrollbar.fixedWidth, scrollRect.height); state.scrollPosition.y = GUI.VerticalScrollbar(scrollbarRect, state.scrollPosition.y, clipHeight, 0f, viewRect.height); } state.scrollPosition = GUI.BeginScrollView(scrollRect, state.scrollPosition, viewRect, GUIStyle.none, GUIStyle.none); // Clip y Min Max Vector2 clipY = new Vector2(state.scrollPosition.y, state.scrollPosition.y + clipHeight); float y = 0f; for (int i = 0; i < state.items.Count; i++) { GUIContent item = state.items[i]; float h = Mathf.Max(itemStyle.CalcHeight(item, viewRect.width), state.itemMinHeight); bool selected = i == state.selected; if (DropdownItem(new Rect(0f, y, viewRect.width, h), clipY, item, selected, itemStyle)) { result = i; state.expanded = false; } y += h; } GUI.EndScrollView(true); // Handle click outside of the scrollRect and Escape button if ((evt.rawType == EventType.MouseUp && !scrollRect.Contains(evt.mousePosition)) || (evt.rawType == EventType.KeyDown && evt.keyCode == KeyCode.Escape)) { state.expanded = false; } } return(result); }
private void PopupWindowFormClosing(object sender, FormClosingEventArgs e) { _dropdownState = DropdownState.Default; Invalidate(); }
private void OnPopupWindowStateChange() { _dropdownState = DropdownState.Default; Invalidate(); }
/// <summary> /// Draws a text box with a button to one side. /// </summary> /// <param name="c">DropdownControl instance.</param> /// <param name="g">The Graphics used to draw the control.</param> /// <param name="state">One of the DropdownState values that specifies the visual state of the control.</param> public static void DrawDropDownControl(DropdownControl c, Graphics g, DropdownState state) { DrawDropDownControl(c, g, Flags, state); }
public override void OnGUI(Rect window) #endif { Event evt = Event.current; Rect horizontalBarRect = new Rect(0, 30, 0, 0); Rect backButtonRect = new Rect(5, 0, 30, 30); Rect refreshButtonRect = new Rect(window.width - 30 + k_Margin, 0, 30, 30); switch (state) { case DropdownState.None: EditorGUILayout.LabelField("Bundle Locations", dropdownTitleStyle); EditorGUILayout.Space(10); EditorGUI.LabelField(horizontalBarRect, "", new GUIStyle(horizontalBarStyle) { fixedWidth = window.width }); //List all options foreach (var option in options) { option.Draw(() => { state = option.state; switch (option.state) { case DropdownState.BuiltIn: case DropdownState.EditorHosted: var args = new DropdownWindowEventArgs(); args.GroupType = m_GroupType; args.Option = option; args.IsCustom = false; OnValueChanged(args); return; case DropdownState.Custom: var custom = new DropdownWindowEventArgs(); custom.GroupType = m_GroupType; custom.Option = option; custom.IsCustom = true; OnValueChanged(custom); return; default: return; } }); } return; case DropdownState.CCD: switch (CCDState) { case CCDDropdownState.Bucket: EditorGUI.LabelField(backButtonRect, EditorGUIUtility.IconContent(backIcon)); if (evt.type == EventType.MouseDown && backButtonRect.Contains(evt.mousePosition)) { state = DropdownState.None; CCDState = CCDDropdownState.Bucket; m_WindowRect.height = 120; return; } #if (ENABLE_CCD && UNITY_2019_4_OR_NEWER) if (CloudProjectSettings.projectId != String.Empty) { EditorGUI.LabelField(refreshButtonRect, EditorGUIUtility.IconContent(refreshIcon)); if (evt.type == EventType.MouseDown && refreshButtonRect.Contains(evt.mousePosition) && !m_isRefreshingCCDDataSources) { m_isRefreshingCCDDataSources = true; await ProfileDataSourceSettings.UpdateCCDDataSourcesAsync(CloudProjectSettings.projectId, true); SyncProfileGroupTypes(); m_isRefreshingCCDDataSources = false; return; } } #endif EditorGUILayout.LabelField("Cloud Content Delivery Buckets", dropdownTitleStyle); EditorGUILayout.Space(10); EditorGUI.LabelField(horizontalBarRect, "", new GUIStyle(horizontalBarStyle) { fixedWidth = window.width }); if (CloudProjectSettings.projectId == String.Empty) { EditorStyles.helpBox.fontSize = 12; EditorGUILayout.LabelField("Connecting to Cloud Content Delivery requires enabling Cloud Project Settings in the Services Window.", EditorStyles.helpBox); } else { #if !ENABLE_CCD //Used to Display whether or not a user has the CCD Package EditorStyles.helpBox.fontSize = 12; EditorGUILayout.HelpBox("Connecting to Cloud Content Delivery requires the CCD Management SDK Package", MessageType.Warning); var installPackageButton = GUILayout.Button("Install CCD Management SDK Package"); if (installPackageButton) { editorWindow.Close(); AddressableAssetUtility.InstallCCDPackage(); } #else scrollPos = EditorGUILayout.BeginScrollView(scrollPos, GUILayout.ExpandHeight(true)); m_WindowRect.height = m_ProfileGroupTypes.Count > 0 ? k_MaxHeight : 80; Dictionary <string, ProfileGroupType> buckets = new Dictionary <string, ProfileGroupType>(); m_ProfileGroupTypes.ForEach((groupType) => { var parts = groupType.GroupTypePrefix.Split(ProfileGroupType.k_PrefixSeparator); var bucketId = parts[2]; var bucketName = groupType.GetVariableBySuffix($"{nameof(CcdBucket)}{nameof(CcdBucket.Name)}"); if (!buckets.ContainsKey(bucketId)) { buckets.Add(bucketId, groupType); } }); CCDOption.DrawBuckets(buckets, (KeyValuePair <string, ProfileGroupType> bucket) => { CCDState = CCDDropdownState.Badge; m_BucketId = bucket.Key; m_Bucket = bucket.Value; }); EditorGUILayout.EndScrollView(); #endif } break; #if (ENABLE_CCD && UNITY_2019_4_OR_NEWER) case CCDDropdownState.Badge: EditorGUI.LabelField(backButtonRect, EditorGUIUtility.IconContent(backIcon)); if (evt.type == EventType.MouseDown && backButtonRect.Contains(evt.mousePosition)) { state = DropdownState.CCD; CCDState = CCDDropdownState.Bucket; m_WindowRect.height = 120; } EditorGUI.LabelField(refreshButtonRect, EditorGUIUtility.IconContent(refreshIcon)); if (evt.type == EventType.MouseDown && refreshButtonRect.Contains(evt.mousePosition) && !m_isRefreshingCCDDataSources) { m_isRefreshingCCDDataSources = true; await ProfileDataSourceSettings.UpdateCCDDataSourcesAsync(CloudProjectSettings.projectId, true); SyncProfileGroupTypes(); m_isRefreshingCCDDataSources = false; return; } EditorGUILayout.LabelField(String.Format("{0} Badges", m_Bucket.GetVariableBySuffix($"{nameof(CcdBucket)}{nameof(CcdBucket.Name)}").Value), dropdownTitleStyle); EditorGUILayout.Space(10); EditorGUI.LabelField(horizontalBarRect, "", new GUIStyle(horizontalBarStyle) { fixedWidth = window.width }); scrollPos = EditorGUILayout.BeginScrollView(scrollPos, GUILayout.ExpandHeight(true)); if (bool.Parse(m_Bucket.GetVariableBySuffix("PromoteOnly").Value)) { const string promotionOnlyBucketInfo = "Using Build & Release directly to this bucket is not supported, but you can load content."; EditorStyles.helpBox.fontSize = 11; EditorStyles.helpBox.margin = new RectOffset(20, 20, 5, 5); EditorGUILayout.HelpBox(promotionOnlyBucketInfo, MessageType.Info); } var selectedProfileGroupTypes = m_ProfileGroupTypes.Where(groupType => groupType.GroupTypePrefix.StartsWith( String.Join( ProfileGroupType.k_PrefixSeparator.ToString(), new string[] { "CCD", CloudProjectSettings.projectId, m_BucketId } ))).ToList(); m_WindowRect.height = m_ProfileGroupTypes.Count > 0 ? k_MaxHeight : 80; HashSet <ProfileGroupType> groupTypes = new HashSet <ProfileGroupType>(); selectedProfileGroupTypes.ForEach((groupType) => { var parts = groupType.GroupTypePrefix.Split(ProfileGroupType.k_PrefixSeparator); var badgeName = String.Join(ProfileGroupType.k_PrefixSeparator.ToString(), parts, 3, parts.Length - 3); if (!groupTypes.Contains(groupType)) { groupTypes.Add(groupType); } }); CCDOption.DrawBadges(groupTypes, m_BucketId, (ProfileGroupType groupType) => { var args = new DropdownWindowEventArgs(); args.GroupType = m_GroupType; args.Option = new CCDOption(); args.Option.BuildPath = groupType.GetVariableBySuffix("BuildPath").Value; args.Option.LoadPath = groupType.GetVariableBySuffix("LoadPath").Value; args.IsCustom = false; OnValueChanged(args); editorWindow.Close(); }); EditorGUILayout.EndScrollView(); break; default: CCDState = CCDDropdownState.Bucket; break; #endif } break; case DropdownState.BuiltIn: case DropdownState.EditorHosted: default: editorWindow.Close(); break; } }
private static void DrawDropDownControl(DropdownControl c, Graphics g, TextFormatFlags flags, DropdownState state) { Rectangle bounds = c.ClientRectangle; if (_Chevron1 == null) { GetChevrons(); } Rectangle r = new Rectangle(bounds.X, bounds.Y, bounds.Width - 1, bounds.Height - 1); DrawBackground(g, r, state, c.BackColor); if (state != DropdownState.Disabled) { if (state == DropdownState.Default || state == DropdownState.Pressed) { g.DrawRectangle(new Pen(_FocusColor), r); } else { g.DrawRectangle(new Pen(_BorderColor), r); } } else { g.DrawRectangle(new Pen(_DisabledBoarderColor), r); } DrawDropDownButton(c, g, state); DrawTextArea(g, r, c.ButtonSide); DrawText(g, _textBounds, c.Text, c.Font, c.ForeColor); }