public PanelTab AddTab(PanelTab tab, int tabIndex = -1)
{
if (!tab)
{
return(null);
}
return(AddTab(tab.Content, tabIndex));
}
public static bool TryGetTab(string tabID, out PanelTab tab)
{
if (string.IsNullOrEmpty(tabID))
{
tab = null;
return(false);
}
return(idToTab.TryGetValue(tabID, out tab));
}
public static void TabDragStateChanged(PanelTab tab, bool isDragging)
{
if (isDragging)
{
OnStartedDraggingTab?.Invoke(tab);
}
else
{
OnStoppedDraggingTab?.Invoke(tab);
}
}
public int GetTabIndex(PanelTab tab)
{
for (int i = 0; i < tabs.Count; i++)
{
if (tabs[i] == tab)
{
return(i);
}
}
return(-1);
}
public override bool Execute(PanelTab panelTab, PointerEventData eventData)
{
PanelDirection anchorDirection = GetAnchorDirection(eventData);
if (anchorDirection == PanelDirection.None)
{
return(false);
}
Panel detachedPanel = PanelManager.Instance.DetachPanelTab(panelTab.Panel, panelTab.Panel.GetTabIndex(panelTab));
PanelManager.Instance.AnchorPanel(detachedPanel, panel, anchorDirection);
return(true);
}
public void OnPanelTabTranslate(PanelTab panelTab, PointerEventData draggingPointer)
{
if (draggedPanel == panelTab.Panel)
{
if (hoveredAnchorZone != null && hoveredAnchorZone.GetAnchoredPreviewRectangleAt(draggingPointer, out Rect previewRect))
{
previewPanel.anchoredPosition = previewRect.position;
previewPanel.sizeDelta = previewRect.size;
}
else
{
RectTransformUtility.ScreenPointToLocalPointInRectangle(previewPanelCanvas.RectTransform, draggingPointer.position, previewPanelCanvas.Internal.worldCamera, out Vector2 position);
previewPanel.anchoredPosition = position;
previewPanel.sizeDelta = panelTab.Panel.FloatingSize;
}
}
}
public bool OnBeginPanelTabTranslate(PanelTab panelTab, PointerEventData draggingPointer)
{
if (draggedPanel != null)
{
CancelDraggingPanel();
}
if (panelTab.Panel.NumberOfTabs == 1 && panelTab.Panel.Canvas.PreventDetachingLastDockedPanel && panelTab.Panel.Canvas.Internal.IsLastDockedPanel(panelTab.Panel))
{
return(false);
}
draggedPanel = panelTab.Panel;
if (!draggedPanel.IsDocked)
{
draggedPanel.FloatingSize = draggedPanel.Size;
}
AnchorZonesSetActive(true);
if (draggedPanel.NumberOfTabs <= 1)
{
draggedPanel.Internal.PanelAnchorZone.SetActive(false);
}
if (RectTransformUtility.RectangleContainsScreenPoint(draggedPanel.Internal.HeaderAnchorZone.RectTransform, draggingPointer.position, draggedPanel.Canvas.Internal.worldCamera))
{
draggedPanel.Internal.HeaderAnchorZone.OnPointerEnter(draggingPointer);
draggingPointer.pointerEnter = draggedPanel.Internal.HeaderAnchorZone.gameObject;
}
previewPanelCanvas = draggedPanel.Canvas;
if (previewPanel.parent != previewPanelCanvas.RectTransform)
{
previewPanel.SetParent(previewPanelCanvas.RectTransform, false);
}
previewPanel.gameObject.SetActive(true);
previewPanel.SetAsLastSibling();
return(true);
}
public void OnPointerEnteredCanvas(PanelCanvas canvas, PointerEventData pointer)
{
if (draggedPanel != null && pointer.pointerDrag != null)
{
PanelHeader header = pointer.pointerDrag.GetComponent <PanelHeader>();
if (header != null)
{
if (header.Panel == draggedPanel && header.Panel.RectTransform.parent != canvas.RectTransform)
{
previewPanelCanvas = canvas;
header.Panel.RectTransform.SetParent(canvas.RectTransform, false);
header.Panel.RectTransform.SetAsLastSibling();
}
}
else
{
PanelTab tab = pointer.pointerDrag.GetComponent <PanelTab>();
if (tab != null)
{
if (tab.Panel == draggedPanel && previewPanel.parent != canvas.RectTransform)
{
previewPanelCanvas = canvas;
if (hoveredAnchorZone && hoveredAnchorZone.Panel.Canvas != canvas)
{
hoveredAnchorZone.OnPointerExit(pointer);
}
previewPanel.SetParent(canvas.RectTransform, false);
previewPanel.SetAsLastSibling();
}
}
}
}
}
public abstract bool Execute(PanelTab panelTab, PointerEventData eventData);
public InternalSettings(PanelTab tab)
{
this.tab = tab;
rectTransform = (RectTransform)tab.transform;
}
private static ISerializedElement Serialize(IPanelGroupElement element)
{
if (element == null)
{
return(null);
}
if (element is Panel panel)
{
if (panel.Internal.IsDummy)
{
return(new SerializedDummyPanel()
{
size = panel.Size
});
}
tabsTemp.Clear();
for (int i = 0; i < panel.NumberOfTabs; i++)
{
PanelTab tab = panel[i];
tabsTemp.Add(new SerializedPanelTab()
{
id = tab.ID,
//minSize = tab.MinSize,
//label = tab.Label
});
}
if (tabsTemp.Count == 0)
{
return(null);
}
if (panel.IsDocked)
{
return(new SerializedPanel()
{
activeTab = panel.ActiveTab,
tabs = tabsTemp.ToArray(),
size = panel.Size,
floatingSize = panel.FloatingSize
});
}
else
{
return(new SerializedUnanchoredPanel()
{
active = panel.gameObject.activeSelf,
activeTab = panel.ActiveTab,
tabs = tabsTemp.ToArray(),
position = panel.Position,
size = panel.Size,
floatingSize = panel.Size
});
}
}
PanelGroup panelGroup = (PanelGroup)element;
ISerializedElement[] children = new ISerializedElement[panelGroup.Count];
for (int i = 0; i < panelGroup.Count; i++)
{
children[i] = Serialize(panelGroup[i]);
}
return(new SerializedPanelGroup()
{
horizontal = panelGroup.IsInSameDirection(PanelDirection.Right),
children = children,
size = panelGroup.Size
});
}
public Panel DetachTab(PanelTab tab)
{
return(DetachTab(GetTabIndex(tab)));
}
public void RemoveTab(PanelTab tab)
{
RemoveTab(GetTabIndex(tab));
}
public PanelTab AddTab(RectTransform tabContent, int tabIndex = -1)
{
if (!tabContent)
{
return(null);
}
// Reset active tab because otherwise, it acts buggy in rare cases
if (activeTab >= 0 && activeTab < tabs.Count)
{
tabs[activeTab].Internal.SetActive(false);
}
activeTab = -1;
if (tabIndex < 0 || tabIndex > tabs.Count)
{
tabIndex = tabs.Count;
}
int thisTabIndex = GetTabIndex(tabContent);
if (thisTabIndex == -1)
{
PanelTab tab = PanelUtils.GetAssociatedTab(tabContent);
if (!tab)
{
tab = Instantiate(tabPrefab, tabsParent, false);
tabs.Insert(tabIndex, tab);
tabContent.anchorMin = Vector2.zero;
tabContent.anchorMax = Vector2.one;
tabContent.sizeDelta = Vector2.zero;
tabContent.anchoredPosition = Vector2.zero;
tabContent.localScale = Vector3.one;
}
else
{
tabs.Insert(tabIndex, tab);
tab.Internal.rectTransform.SetParent(null, false); // workaround for a rare internal Unity crash
tab.Internal.rectTransform.SetParent(tabsParent, false);
tab.Panel.Internal.RemoveTab(tab.Index, false);
}
tab.Internal.Initialize(this, tabContent);
tab.Internal.rectTransform.SetSiblingIndex(tabIndex);
tabContent.SetParent(null, false); // workaround for a rare internal Unity crash
tabContent.SetParent(contentParent, false);
Internal.RecalculateMinSize();
}
else if (thisTabIndex != tabIndex)
{
if (tabIndex == tabs.Count)
{
tabIndex = tabs.Count - 1;
}
PanelTab tab = tabs[thisTabIndex];
tab.Internal.rectTransform.SetSiblingIndex(tabIndex);
tabs.RemoveAt(thisTabIndex);
tabs.Insert(tabIndex, tab);
}
ActiveTab = tabIndex;
return(tabs[tabIndex]);
}
public static void ActiveTabChanged(PanelTab tab)
{
OnActiveTabChanged?.Invoke(tab);
}
public static void TabClosed(PanelTab tab)
{
onTabClosed?.Invoke(tab);
}
