626 lines
22 KiB
C#
626 lines
22 KiB
C#
///Credit perchik
|
|
///Sourced from - http://forum.unity3d.com/threads/receive-onclick-event-and-pass-it-on-to-lower-ui-elements.293642/
|
|
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace UnityEngine.UI.Extensions
|
|
{
|
|
[RequireComponent(typeof(RectTransform))]
|
|
[AddComponentMenu("UI/Extensions/ComboBox")]
|
|
public class ComboBox : MonoBehaviour
|
|
{
|
|
#region declarations
|
|
#region private members
|
|
|
|
private bool _isActive = false; //is the drop down panel active
|
|
|
|
private Button comboBtn;
|
|
private Image comboBtnImg;
|
|
private Text comboBtnText;
|
|
|
|
private Button overlayBtn;
|
|
|
|
private GridLayoutGroup itemLayout;
|
|
|
|
|
|
private float _scrollbarWidth = 20.0f;
|
|
|
|
private int scrollOffset; //offset of the selected item
|
|
|
|
private int _itemsToDisplay = 4; //how many items to show in the dropdown panel
|
|
|
|
private bool _hideFirstItem = false; //lets us hide the prompt after something is chosen
|
|
|
|
private int _selectedIndex = 0;
|
|
|
|
private List<ComboBoxItem> _items; //conceptual items in the list
|
|
|
|
private bool _interactable = true;
|
|
|
|
private Canvas _canvas;
|
|
|
|
#region private rect transforms
|
|
/// <remarks> All of these have to be properties so that the editor script can access them</remarks>
|
|
|
|
private RectTransform _overlay; //overlayRT is a screensized box to handle clicks *not* on the button. (although this might have to change with multiple things on the screen.
|
|
private RectTransform overlayRT
|
|
{
|
|
get
|
|
{
|
|
if (_overlay == null)
|
|
{
|
|
_overlay = rectTransform.FindChild("Overlay").GetComponent<RectTransform>();
|
|
overlayBtn = _overlay.gameObject.GetComponent<Button>();
|
|
}
|
|
return _overlay;
|
|
}
|
|
set
|
|
{
|
|
_overlay = value;
|
|
}
|
|
}
|
|
|
|
private RectTransform _rectTransform;
|
|
private RectTransform rectTransform
|
|
{
|
|
get
|
|
{
|
|
if (_rectTransform == null)
|
|
{
|
|
_rectTransform = GetComponent<RectTransform>();
|
|
}
|
|
return _rectTransform;
|
|
}
|
|
set { _rectTransform = value; }
|
|
}
|
|
|
|
private RectTransform _comboBtnRT;
|
|
private RectTransform comboBtnRT
|
|
{
|
|
get
|
|
{
|
|
if (_comboBtnRT == null)
|
|
{
|
|
_comboBtnRT = rectTransform.FindChild("ComboButton").GetComponent<RectTransform>();
|
|
comboBtn = _comboBtnRT.GetComponent<Button>();
|
|
comboBtnImg = _comboBtnRT.FindChild("Image").GetComponent<Image>();
|
|
comboBtnText = _comboBtnRT.FindChild("Text").GetComponent<Text>();
|
|
}
|
|
return _comboBtnRT;
|
|
}
|
|
set
|
|
{
|
|
_comboBtnRT = value;
|
|
}
|
|
}
|
|
|
|
private GameObject _scrollPanel;
|
|
private GameObject scrollPanel
|
|
{
|
|
get
|
|
{
|
|
if (_scrollPanel == null)
|
|
_scrollPanel = overlayRT.FindChild("ScrollPanel").gameObject;
|
|
return _scrollPanel;
|
|
}
|
|
set
|
|
{
|
|
_scrollPanel = value;
|
|
}
|
|
}
|
|
|
|
private RectTransform _scrollPanelRT;
|
|
private RectTransform scrollPanelRT
|
|
{
|
|
get
|
|
{
|
|
if (_scrollPanelRT == null)
|
|
_scrollPanelRT = scrollPanel.GetComponent<RectTransform>();
|
|
return _scrollPanelRT;
|
|
}
|
|
set
|
|
{
|
|
_scrollPanelRT = value;
|
|
}
|
|
}
|
|
|
|
private RectTransform _itemsRT;
|
|
private RectTransform itemsRT
|
|
{
|
|
get
|
|
{
|
|
if (_itemsRT == null)
|
|
{
|
|
_itemsRT = scrollPanelRT.Find("Items").GetComponent<RectTransform>();
|
|
itemLayout = _itemsRT.gameObject.GetComponent<GridLayoutGroup>();
|
|
}
|
|
return _itemsRT;
|
|
}
|
|
set
|
|
{
|
|
_itemsRT = value;
|
|
}
|
|
}
|
|
|
|
private RectTransform _scrollbarRT;
|
|
private RectTransform scrollbarRT
|
|
{
|
|
get
|
|
{
|
|
if (_scrollbarRT == null)
|
|
_scrollbarRT = scrollPanelRT.Find("Scrollbar").GetComponent<RectTransform>();
|
|
return _scrollbarRT;
|
|
}
|
|
set
|
|
{
|
|
_scrollbarRT = value;
|
|
}
|
|
}
|
|
|
|
private RectTransform _slidingAreaRT;
|
|
private RectTransform slidingAreaRT
|
|
{
|
|
get
|
|
{
|
|
if (_slidingAreaRT == null)
|
|
_slidingAreaRT = scrollbarRT.Find("SlidingArea").GetComponent<RectTransform>();
|
|
return _slidingAreaRT;
|
|
}
|
|
set
|
|
{
|
|
_slidingAreaRT = value;
|
|
}
|
|
}
|
|
|
|
private RectTransform _scrollHandleRT;
|
|
private RectTransform scrollHandleRT
|
|
{
|
|
get
|
|
{
|
|
if (_scrollHandleRT == null)
|
|
_scrollHandleRT = slidingAreaRT.Find("Handle").GetComponent<RectTransform>();
|
|
return _scrollHandleRT;
|
|
}
|
|
set
|
|
{
|
|
_scrollHandleRT = value;
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
#region public accessors
|
|
|
|
public string HeaderOption = "";
|
|
public Color32 disabledTextColor = new Color32(174, 174, 174, 255);
|
|
public bool Interactable
|
|
{
|
|
get
|
|
{
|
|
return _interactable;
|
|
}
|
|
set
|
|
{
|
|
_interactable = value;
|
|
|
|
comboBtn.interactable = _interactable;
|
|
if (comboBtnImg.sprite != null)
|
|
{
|
|
comboBtnImg.color = _interactable ?
|
|
comboBtn.colors.normalColor :
|
|
comboBtn.colors.disabledColor;
|
|
}
|
|
else
|
|
{
|
|
comboBtnImg.color = new Color(1, 1, 1, 0); //transparent
|
|
}
|
|
if (!Application.isPlaying)//stop it from messing up in the editor
|
|
return;
|
|
if (!_interactable && _isActive)
|
|
ToggleComboBox(false);
|
|
}
|
|
}
|
|
|
|
public int SelectedIndex
|
|
{
|
|
get
|
|
{
|
|
return _selectedIndex;
|
|
}
|
|
set
|
|
{
|
|
if (_selectedIndex == value)
|
|
return;
|
|
if (value > -1 && value < Items.Count)
|
|
{
|
|
_selectedIndex = value;
|
|
RefreshSelected();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public List<ComboBoxItem> Items
|
|
{
|
|
get
|
|
{
|
|
if (_items == null)
|
|
{
|
|
_items = new List<ComboBoxItem>();
|
|
}
|
|
|
|
return _items;
|
|
}
|
|
set
|
|
{
|
|
_items = value;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
public bool HideFirstItem
|
|
{
|
|
get
|
|
{
|
|
return _hideFirstItem;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
scrollOffset--;
|
|
else
|
|
scrollOffset++;
|
|
_hideFirstItem = value;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
public int ItemsToDisplay
|
|
{
|
|
get
|
|
{
|
|
return _itemsToDisplay;
|
|
}
|
|
set
|
|
{
|
|
if (_itemsToDisplay == value)
|
|
return;
|
|
_itemsToDisplay = value;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
public System.Action<int> OnSelectionChanged;//fires when selection is changed.
|
|
|
|
#endregion
|
|
|
|
|
|
#endregion
|
|
|
|
#region public methods
|
|
|
|
/// <summary>
|
|
/// Update the main button with the selected item's parameters
|
|
/// </summary>
|
|
public void RefreshSelected()
|
|
{
|
|
//get the selected item
|
|
ComboBoxItem item = (SelectedIndex > -1 && SelectedIndex < Items.Count) ? Items[SelectedIndex] : null;
|
|
if (item == null) return;
|
|
|
|
bool hasImage = (item.Image != null);
|
|
comboBtnImg.sprite = hasImage ? item.Image : null;
|
|
comboBtnImg.color = !hasImage ? new Color(1, 1, 1, 0)//transparent if there's no image.
|
|
: !Interactable ? new Color(1, 1, 1, .5f) //semitransparent if the combobox is disabled
|
|
: Color.white; //fully opaque if it has an image and the combobox is enabled
|
|
UpdateComboBoxText(comboBtnRT, hasImage);
|
|
comboBtnText.text = item.Caption;
|
|
|
|
comboBtn.onClick.RemoveAllListeners();
|
|
comboBtn.onClick.AddListener(() =>
|
|
{
|
|
ToggleComboBox(true);
|
|
});
|
|
if (!Application.isPlaying) return; //if it was running in editor we stop here.
|
|
|
|
for (int i = 0; i < itemsRT.childCount; i++)
|
|
{
|
|
Image tempImg = itemsRT.GetChild(i).GetComponent<Image>();
|
|
tempImg.color = (SelectedIndex == (i + (HideFirstItem ? 1 : 0))) ? comboBtn.colors.highlightedColor : comboBtn.colors.normalColor;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// what happens when an item in the list is selected
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
public void OnItemClicked(int index)
|
|
{
|
|
Debug.Log("item " + index + " was clicked");
|
|
bool selectionChanged = (index != SelectedIndex);
|
|
SelectedIndex = index;
|
|
ToggleComboBox(true);
|
|
if (selectionChanged && OnSelectionChanged != null) OnSelectionChanged(index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add items to the dropdown list. Accepts any object of type ComboBoxItem, String, or Image
|
|
/// </summary>
|
|
/// <param name="list"></param>
|
|
public void AddItems(params object[] list)
|
|
{
|
|
List<ComboBoxItem> cbItems = new List<ComboBoxItem>();
|
|
foreach (var obj in list)
|
|
{
|
|
if (obj is ComboBoxItem)
|
|
{
|
|
cbItems.Add((ComboBoxItem)obj);
|
|
}
|
|
else if (obj is string)
|
|
{
|
|
cbItems.Add(new ComboBoxItem(caption: (string)obj));
|
|
}
|
|
else if (obj is Sprite)
|
|
{
|
|
cbItems.Add(new ComboBoxItem(image: (Sprite)obj));
|
|
}
|
|
else
|
|
{
|
|
throw new System.Exception("Only ComboBoxItems, Strings, and Sprite types are allowed");
|
|
}
|
|
}
|
|
Items.AddRange(cbItems);
|
|
Items = Items.Distinct().ToList();//remove any duplicates
|
|
|
|
}
|
|
|
|
public void ClearItems()
|
|
{
|
|
Items.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Redraw the graphics (in response to something changing)
|
|
/// </summary>
|
|
public void UpdateGraphics()
|
|
{
|
|
//center the handle in the scrollbar
|
|
float scrollbarWidth = Items.Count - (HideFirstItem ? 1 : 0) > ItemsToDisplay ? _scrollbarWidth : 0.0f;
|
|
scrollHandleRT.offsetMin = -scrollbarWidth / 2 * Vector2.one;
|
|
scrollHandleRT.offsetMax = scrollbarWidth / 2 * Vector2.one;
|
|
|
|
if (rectTransform.sizeDelta != comboBtnRT.sizeDelta)
|
|
{
|
|
comboBtnRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, rectTransform.sizeDelta.x);
|
|
comboBtnRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, rectTransform.sizeDelta.y);
|
|
comboBtnText.rectTransform.offsetMax = new Vector2(4, 0);
|
|
|
|
scrollPanelRT.SetParent(transform, true);
|
|
scrollPanelRT.anchoredPosition = new Vector2(0, -comboBtnRT.sizeDelta.y);
|
|
|
|
|
|
//make hte overlay fill the whole screen
|
|
overlayRT.SetParent(_canvas.transform, false);
|
|
overlayRT.offsetMax = Vector2.zero;
|
|
overlayRT.offsetMin = Vector2.zero;
|
|
|
|
//reattach to correct parents, maintining global position
|
|
overlayRT.SetParent(transform, true);
|
|
scrollPanelRT.SetParent(overlayRT, true);
|
|
|
|
scrollPanel.GetComponent<ScrollRect>().scrollSensitivity = comboBtnRT.sizeDelta.y;
|
|
|
|
UpdateComboBoxText(comboBtnRT, Items[SelectedIndex].Image != null);
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// toggle the drop down list
|
|
/// </summary>
|
|
/// <param name="directClick">whether it was toggled by directly clicking on </param>
|
|
public void ToggleComboBox(bool directClick)
|
|
{
|
|
if (HeaderOption != "") HideFirstItem = true;
|
|
_isActive = !_isActive;
|
|
// Debug.Log("toggling combo box tp "+ _isActive);
|
|
overlayRT.gameObject.SetActive(_isActive);
|
|
if (_isActive)
|
|
{
|
|
transform.SetAsLastSibling();
|
|
FixScrollOffset();
|
|
}
|
|
else if (directClick)
|
|
{
|
|
scrollOffset = Mathf.RoundToInt(_itemsRT.anchoredPosition.y / rectTransform.sizeDelta.y);
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region private methods
|
|
|
|
private void Awake()
|
|
{
|
|
_canvas = GetComponentInParent<Canvas>();
|
|
Initialize();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize the control
|
|
/// </summary>
|
|
private void Initialize()
|
|
{
|
|
overlayRT.gameObject.SetActive(false);
|
|
overlayBtn.onClick.AddListener(() => { ToggleComboBox(false); });
|
|
|
|
if (HeaderOption != "") AddItems(HeaderOption);
|
|
|
|
//float dropdownHeight = comboBtnRT.sizeDelta.y * Mathf.Min(ItemsToDisplay, Items.Length - (HideFirstItem ? 1 : 0));
|
|
|
|
//scrollPanelRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, dropdownHeight);
|
|
//scrollPanelRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, comboBtnRT.sizeDelta.x);
|
|
|
|
ScrollRect scrollPanelScrollRect = scrollPanel.GetComponent<ScrollRect>();
|
|
scrollPanelScrollRect.scrollSensitivity = comboBtnRT.sizeDelta.y;
|
|
scrollPanelScrollRect.content = itemsRT;
|
|
|
|
itemLayout.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
|
|
itemLayout.constraintCount = 1;
|
|
|
|
//float scrollbarWidth = Items.Length - (HideFirstItem ? 1 : 0) > _itemsToDisplay ? _scrollbarWidth : 0.0f;
|
|
//itemsRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, scrollPanelRT.sizeDelta.x - scrollbarWidth);
|
|
|
|
//itemLayout.cellSize = new Vector2(comboBtnRT.sizeDelta.x - scrollbarWidth, comboBtnRT.sizeDelta.y);
|
|
//itemLayout.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
|
|
//itemLayout.constraintCount = 1;
|
|
|
|
//scrollbarRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, scrollbarWidth);
|
|
//scrollbarRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, dropdownHeight);
|
|
|
|
//slidingAreaRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 0);
|
|
//slidingAreaRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, dropdownHeight - scrollbarRT.sizeDelta.x);
|
|
|
|
//scrollHandleRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, scrollbarWidth);
|
|
//scrollHandleRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, scrollbarWidth);
|
|
|
|
Interactable = Interactable; //call the logic in the getter.
|
|
|
|
Refresh();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Redraw the component, with realigning.
|
|
/// </summary>
|
|
public void Refresh()
|
|
{
|
|
// Debug.Log("Refreshing");
|
|
|
|
int itemsLength = Items.Count - (HideFirstItem ? 1 : 0);
|
|
if (itemsLength < 1)
|
|
return;
|
|
|
|
float dropdownHeight = comboBtnRT.sizeDelta.y * Mathf.Min(_itemsToDisplay, itemsLength);
|
|
float scrollbarWidth = itemsLength > ItemsToDisplay ? _scrollbarWidth : 0.0f;
|
|
|
|
|
|
scrollPanelRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, dropdownHeight);
|
|
scrollPanelRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, comboBtnRT.sizeDelta.x);
|
|
|
|
itemsRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, scrollPanelRT.sizeDelta.x - scrollbarWidth);
|
|
|
|
itemLayout.cellSize = new Vector2(comboBtnRT.sizeDelta.x - scrollbarWidth, comboBtnRT.sizeDelta.y);
|
|
|
|
scrollbarRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, scrollbarWidth);
|
|
scrollbarRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, dropdownHeight);
|
|
|
|
slidingAreaRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 0);
|
|
slidingAreaRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, dropdownHeight - scrollbarRT.sizeDelta.x);
|
|
|
|
scrollHandleRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, scrollbarWidth);
|
|
scrollHandleRT.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, scrollbarWidth);
|
|
|
|
for (int i = itemsRT.childCount - 1; i >= 0; i--)//delete in reverse to avoid having to re-allocate memory on each delete. (ie if I deleted child 0, everythign would get shifted forward in the array)
|
|
{
|
|
DestroyImmediate(itemsRT.GetChild(0).gameObject);
|
|
}
|
|
|
|
for (int i = (HideFirstItem ? 1 : 0); i < Items.Count; i++) //for each element to be shown in the dropdown list
|
|
{
|
|
ComboBoxItem item = Items[i];
|
|
item.OnUpdate = Refresh;
|
|
|
|
Transform itemTfm = Instantiate(comboBtnRT) as Transform;//copy the top level combo box
|
|
itemTfm.name += " " + i;
|
|
itemTfm.SetParent(itemsRT, false);
|
|
itemTfm.GetComponent<Image>().sprite = null; //hide the original background image (so that the dropdown box shows)
|
|
|
|
Text itemText = itemTfm.Find("Text").GetComponent<Text>();
|
|
itemText.text = item.Caption;
|
|
if (item.IsDisabled) itemText.color = disabledTextColor;
|
|
|
|
Image itemImg = itemTfm.Find("Image").GetComponent<Image>();
|
|
itemImg.sprite = item.Image;
|
|
itemImg.color = (item.Image == null) ? new Color(1, 1, 1, 0)
|
|
: item.IsDisabled ? new Color(1, 1, 1, .5f)
|
|
: Color.white;
|
|
Button itemBtn = itemTfm.GetComponent<Button>();
|
|
itemBtn.interactable = !item.IsDisabled;
|
|
|
|
int indx = i;
|
|
itemBtn.onClick.RemoveAllListeners();
|
|
itemBtn.onClick.AddListener(() =>
|
|
{
|
|
OnItemClicked(indx);
|
|
if (item.OnSelect != null) item.OnSelect();
|
|
}
|
|
);
|
|
|
|
}
|
|
|
|
RefreshSelected();
|
|
UpdateComboBoxItems();
|
|
UpdateGraphics();
|
|
FixScrollOffset();
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// adjusts all of the items in the dropdown list to account for any images
|
|
/// </summary>
|
|
private void UpdateComboBoxItems()
|
|
{
|
|
//decide if any item in the list has images
|
|
bool includeImages = false;
|
|
foreach (ComboBoxItem item in Items)
|
|
{
|
|
if (item.Image != null)
|
|
{
|
|
includeImages = true; break;
|
|
}
|
|
}
|
|
|
|
//either align all of the text 10 units from the side, or 8+image width.
|
|
foreach (Transform child in itemsRT)
|
|
{
|
|
UpdateComboBoxText(child, includeImages);
|
|
}
|
|
}
|
|
|
|
|
|
private void UpdateComboBoxText(Transform child, bool includeImages)
|
|
{
|
|
child.Find("Text").GetComponent<RectTransform>().offsetMin = Vector2.right * (includeImages ? comboBtnImg.rectTransform.rect.width + 8.0f : 10.0f);
|
|
}
|
|
|
|
|
|
private void FixScrollOffset()
|
|
{
|
|
int selectedIndex = SelectedIndex + (HideFirstItem ? 1 : 0);
|
|
if (selectedIndex < scrollOffset)
|
|
scrollOffset = selectedIndex;
|
|
else
|
|
if (selectedIndex > scrollOffset + ItemsToDisplay - 1)
|
|
scrollOffset = selectedIndex - ItemsToDisplay + 1;
|
|
|
|
|
|
int itemsCount = Items.Count - (HideFirstItem ? 1 : 0);
|
|
if (scrollOffset > itemsCount - ItemsToDisplay)
|
|
scrollOffset = itemsCount - ItemsToDisplay;
|
|
if (scrollOffset < 0)
|
|
scrollOffset = 0;
|
|
|
|
_itemsRT.anchoredPosition = new Vector2(0.0f, scrollOffset * rectTransform.sizeDelta.y);
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|