public static byte[] SerializeCanvasToArray(PanelCanvas canvas)
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
Debug.LogError("Can serialize in Play mode only!");
return(null);
}
#endif
canvas.ForceRebuildLayoutImmediate();
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, new SerializedCanvas
{
active = canvas.gameObject.activeSelf,
useFreeSpace = canvas.LeaveFreeSpace,
rootPanelGroup = Serialize(canvas.RootPanelGroup) as SerializedPanelGroup,
unanchoredPanelGroup = Serialize(canvas.UnanchoredPanelGroup) as SerializedPanelGroup
});
return(stream.ToArray());
}
}
public void RegisterCanvas(PanelCanvas canvas)
{
if (!canvases.Contains(canvas))
{
canvases.Add(canvas);
}
}
public static Panel CreatePanel(RectTransform content, PanelCanvas canvas, Panel panelPrefab)
{
bool canvasWasNull = canvas == null;
if (canvasWasNull)
{
if (content != null)
{
canvas = content.GetComponentInParent <PanelCanvas>();
}
if (canvas == null)
{
canvas = Object.FindObjectOfType <PanelCanvas>();
if (!canvas)
{
Debug.LogError("Panels require a DynamicPanelsCanvas!");
return(null);
}
}
}
Panel result = null;
if (content != null)
{
PanelTab currentTab = GetAssociatedTab(content);
if (currentTab != null)
{
result = currentTab.Panel;
}
}
if (result == null)
{
result = Object.Instantiate(panelPrefab, canvas.RectTransform, false);
result.gameObject.name = "DynamicPanel";
result.RectTransform.SetAsLastSibling();
if (content != null)
{
Rect contentRect = content.rect;
result.RectTransform.anchoredPosition = (Vector2)canvas.RectTransform.InverseTransformPoint(content.TransformPoint(contentRect.position)) + canvas.Size * 0.5f;
result.FloatingSize = contentRect.size;
}
}
else if (result.Canvas != canvas && !canvasWasNull)
{
canvas.UnanchoredPanelGroup.AddElement(result);
}
if (content != null)
{
result.AddTab(content);
}
return(result);
}
public static Panel CreatePanelFor(RectTransform content, PanelCanvas canvas, Panel panelPrefab)
{
if (!content)
{
Debug.LogError("Content is null!");
return(null);
}
return(Internal.CreatePanel(content, canvas, panelPrefab));
}
public PanelGroup(PanelCanvas canvas, PanelDirection direction)
{
Canvas = canvas;
Internal = new InternalSettings(this);
this.direction = direction;
elements = new List <IPanelGroupElement>(2);
surroundings = new IPanelGroupElement[4];
}
public void StopCanvasOperations(PanelCanvas canvas)
{
CancelDraggingPanel();
for (int i = 0; i < panels.Count; i++)
{
if (panels[i].Canvas == canvas)
{
panels[i].Internal.Stop();
}
}
}
public static void SerializeCanvas(PanelCanvas canvas)
{
byte[] data = SerializeCanvasToArray(canvas);
if (data == null || data.Length == 0)
{
Debug.LogError("Couldn't serialize!");
return;
}
PlayerPrefs.SetString(canvas.ID, Convert.ToBase64String(data));
PlayerPrefs.Save();
}
public void UnregisterCanvas(PanelCanvas canvas)
{
canvases.Remove(canvas);
StopCanvasOperations(canvas);
if (previewPanelCanvas == canvas)
{
previewPanelCanvas = draggedPanel != null ? draggedPanel.Canvas : null;
}
if (previewPanel.parent == canvas.RectTransform)
{
previewPanel.SetParent(null, false);
}
}
public void AnchorPanel(IPanelGroupElement source, PanelCanvas canvas, PanelDirection anchorDirection)
{
PanelGroup rootGroup = canvas.RootPanelGroup;
PanelGroup tempGroup = new PanelGroup(canvas, PanelDirection.Right);
for (int i = 0; i < rootGroup.Count; i++)
{
if (rootGroup[i].Group == rootGroup)
{
tempGroup.AddElement(rootGroup[i]);
}
}
rootGroup.AddElement(tempGroup);
AnchorPanel(source, tempGroup, anchorDirection);
}
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 InternalSettings(PanelCanvas canvas)
{
this.canvas = canvas;
#if UNITY_EDITOR
if (!canvas.UnityCanvas) // is null while inspecting this component in edit mode
{
return;
}
#endif
if (canvas.UnityCanvas.renderMode == RenderMode.ScreenSpaceOverlay ||
(canvas.UnityCanvas.renderMode == RenderMode.ScreenSpaceCamera && !canvas.UnityCanvas.worldCamera))
{
worldCamera = null;
}
else
{
worldCamera = canvas.UnityCanvas.worldCamera ? canvas.UnityCanvas.worldCamera : Camera.main;
}
}
public bool OnBeginPanelTranslate(Panel panel)
{
if (panel.IsDocked)
{
return(false);
}
if (draggedPanel != null)
{
CancelDraggingPanel();
}
draggedPanel = panel;
previewPanelCanvas = draggedPanel.Canvas;
for (int i = 0; i < canvases.Count; i++)
{
canvases[i].Internal.ReceiveRaycasts(true);
}
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 static void DeserializeCanvas(PanelCanvas canvas)
{
DeserializeCanvasFromArray(canvas, Convert.FromBase64String(PlayerPrefs.GetString(canvas.ID, string.Empty)));
}
public static void DeserializeCanvasFromArray(PanelCanvas canvas, byte[] data)
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
Debug.LogError("Can deserialize in Play mode only!");
return;
}
#endif
if (data == null || data.Length == 0)
{
Debug.LogError("Data is null!");
return;
}
SerializedCanvas serializedCanvas;
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream(data))
{
serializedCanvas = formatter.Deserialize(stream) as SerializedCanvas;
}
if (serializedCanvas == null)
{
return;
}
sizesHolder.Clear();
canvas.LeaveFreeSpace = serializedCanvas.useFreeSpace;
if (serializedCanvas.rootPanelGroup != null)
{
PanelGroup rootPanelGroup = canvas.RootPanelGroup;
ISerializedElement[] children = serializedCanvas.rootPanelGroup.children;
for (int i = children.Length - 1; i >= 0; i--)
{
IPanelGroupElement element = Deserialize(canvas, children[i]);
if (element != null)
{
if (rootPanelGroup.Count == 0)
{
rootPanelGroup.AddElement(element);
}
else
{
rootPanelGroup.AddElementBefore(rootPanelGroup[0], element);
}
sizesHolder.Insert(0, new GroupElementSizeHolder(element, children[i].size));
}
}
}
if (sizesHolder.Count > 0)
{
canvas.ForceRebuildLayoutImmediate();
for (int i = 0; i < sizesHolder.Count; i++)
{
sizesHolder[i].element.ResizeTo(sizesHolder[i].size, PanelDirection.Right, PanelDirection.Top);
}
}
if (serializedCanvas.unanchoredPanelGroup != null)
{
ISerializedElement[] children = serializedCanvas.unanchoredPanelGroup.children;
for (int i = 0; i < children.Length; i++)
{
if (children[i] is SerializedUnanchoredPanel unanchoredPanel)
{
Panel panel = Deserialize(canvas, unanchoredPanel) as Panel;
if (panel != null)
{
panel.Detach();
canvas.UnanchoredPanelGroup.RestrictPanelToBounds(panel);
}
}
}
}
for (int i = 0; i < canvas.UnanchoredPanelGroup.Count; i++)
{
Panel panel = canvas.UnanchoredPanelGroup[i] as Panel;
if (panel != null)
{
panel.RectTransform.SetAsLastSibling();
}
}
canvas.gameObject.SetActive(serializedCanvas.active);
}
private static IPanelGroupElement Deserialize(PanelCanvas canvas, ISerializedElement element)
{
if (element == null)
{
return(null);
}
if (element is SerializedDummyPanel)
{
return(canvas.Internal.DummyPanel);
}
if (element is SerializedPanel serializedPanel)
{
Panel panel = null;
SerializedPanelTab[] tabs = serializedPanel.tabs;
for (int i = 0; i < tabs.Length; i++)
{
if (!PanelNotificationCenter.TryGetTab(tabs[i].id, out PanelTab tab))
{
continue;
}
if (panel == null)
{
panel = tab.Detach();
canvas.UnanchoredPanelGroup.AddElement(panel);
}
else
{
panel.AddTab(tab);
}
}
if (panel != null)
{
if (serializedPanel.activeTab < tabs.Length)
{
int activeTabIndex = panel.GetTabIndex(tabs[serializedPanel.activeTab].id);
if (activeTabIndex >= 0)
{
panel.ActiveTab = activeTabIndex;
}
}
if (serializedPanel is SerializedUnanchoredPanel unanchoredPanel)
{
panel.RectTransform.anchoredPosition = unanchoredPanel.position;
panel.gameObject.SetActive(unanchoredPanel.active);
}
panel.FloatingSize = serializedPanel.floatingSize;
}
return(panel);
}
if (element is SerializedPanelGroup serializedPanelGroup)
{
ISerializedElement[] children = serializedPanelGroup.children;
if (children == null || children.Length == 0)
{
return(null);
}
PanelGroup panelGroup = new PanelGroup(canvas, serializedPanelGroup.horizontal ? PanelDirection.Right : PanelDirection.Top);
for (int i = 0; i < children.Length; i++)
{
if (children[i] == null)
{
continue;
}
IPanelGroupElement childElement = Deserialize(canvas, children[i]);
if (childElement != null)
{
panelGroup.AddElement(childElement);
sizesHolder.Add(new GroupElementSizeHolder(childElement, children[i].size));
}
}
if (panelGroup.Count > 0)
{
return(panelGroup);
}
}
return(null);
}
public UnanchoredPanelGroup(PanelCanvas canvas) : base(canvas, PanelDirection.None)
{
}
