优化Legend的布局

Runtime/API/BaseChart_API.cs

@@ -679,11 +679,6 @@ namespace XCharts
             return chartPosition + m_Title.location.GetPosition(chartWidth, chartHeight);
         }
 
-        public Vector3 GetLegendPosition()
-        {
-            return chartPosition + m_Legend.location.GetPosition(chartWidth, chartHeight);
-        }
-
         [Obsolete("Use BaseChart.RefreshLabel() instead.", true)]
         public void ReinitChartLabel() { }
 

Runtime/Component/Main/Legend.cs

@@ -188,38 +188,22 @@ namespace XCharts
         /// </summary>
         /// <value></value>
         public Dictionary<string, LegendItem> buttonList { get { return m_DataBtnList; } }
-
+        /// <summary>
-        public float runtimeWidth
+        /// 运行时图例的总宽度
-        {
+        /// </summary>
-            get
+        public float runtimeWidth { get; internal set; }
-            {
+        /// <summary>
-                var width = 0f;
+        /// 运行时图例的总高度
-                foreach (var kv in buttonList)
+        /// </summary>
-                {
+        public float runtimeHeight { get; internal set; }
-                    if (orient == Orient.Horizonal)
+        /// <summary>
-                        width += kv.Value.width + m_ItemGap;
+        /// 多列时每列的宽度
-                    else if (kv.Value.width > width)
+        /// </summary>
-                        width = kv.Value.width;
+        public Dictionary<int, float> runtimeEachWidth { get; internal set; }
-                }
+        /// <summary>
-                return orient == Orient.Horizonal ? width - m_ItemGap : width;
+        /// 单列高度
-            }
+        /// </summary>
-        }
+        public float runtimeEachHeight { get; internal set; }
-
-        public float runtimeHeight
-        {
-            get
-            {
-                var height = 0f;
-                foreach (var kv in buttonList)
-                {
-                    if (orient == Orient.Vertical)
-                        height += kv.Value.height + m_ItemGap;
-                    else if (kv.Value.height > height)
-                        height = kv.Value.height;
-                }
-                return orient == Orient.Vertical ? height - m_ItemGap : height;
-            }
-        }
 
         /// <summary>
         /// 一个在顶部居中显示的默认图例。
@@ -237,6 +221,7 @@ namespace XCharts
                     m_ItemWidth = 24.0f,
                     m_ItemHeight = 12.0f,
                     m_ItemGap = 10f,
+                    runtimeEachWidth = new Dictionary<int, float>()
                 };
                 legend.location.top = 30;
                 legend.textStyle.offset = new Vector2(2, 0);

Runtime/Internal/BaseChart.cs

@@ -332,14 +332,8 @@ namespace XCharts
         private void InitLegend()
         {
             m_Legend.OnChanged();
-            TextAnchor anchor = m_Legend.location.runtimeTextAnchor;
+            var legendObject = ChartHelper.AddObject(s_LegendObjectName, transform, m_ChartMinAnchor,
-            Vector2 anchorMin = m_Legend.location.runtimeAnchorMin;
+                 m_ChartMaxAnchor, m_ChartPivot, new Vector2(chartWidth, chartHeight));
-            Vector2 anchorMax = m_Legend.location.runtimeAnchorMax;
-            Vector2 pivot = m_Legend.location.runtimePivot;
-
-            var legendObject = ChartHelper.AddObject(s_LegendObjectName, transform, anchorMin, anchorMax,
-                pivot, new Vector2(chartWidth, chartHeight));
-            legendObject.transform.localPosition = GetLegendPosition();
             legendObject.hideFlags = chartHideFlags;
             SeriesHelper.UpdateSerieNameList(m_Series, ref m_LegendRealShowName);
             List<string> datas;
@@ -428,7 +422,7 @@ namespace XCharts
                     OnLegendButtonClick(n, m_LegendRealShowName[n], n == 0 ? true : false);
                 }
             }
-            LegendHelper.ResetItemPosition(m_Legend, m_ChartWidth, m_ChartHeight);
+            LegendHelper.ResetItemPosition(m_Legend, m_ChartPosition, m_ChartWidth, m_ChartHeight);
         }
 
         private void InitSerieLabel()

Runtime/Internal/Helper/LegendHelper.cs

@@ -43,9 +43,9 @@ namespace XCharts
             var font = textStyle.font ? textStyle.font : themeInfo.font;
             var contentColor = GetContentColor(legend, themeInfo, active);
 
-            var objAnchorMin = legend.location.runtimeAnchorMin;
+            var objAnchorMin = new Vector2(0, 1);
-            var objAnchorMax = legend.location.runtimeAnchorMax;
+            var objAnchorMax = new Vector2(0, 1);
-            var objPivot = legend.location.runtimePivot;
+            var objPivot = new Vector2(0, 1);
             var btnObj = ChartHelper.AddObject(objName, parent, objAnchorMin, objAnchorMax, objPivot, sizeDelta, i);
             var iconObj = ChartHelper.AddObject("icon", btnObj.transform, anchorMin, anchorMax, pivot, iconSizeDelta);
             var contentObj = ChartHelper.AddObject("content", btnObj.transform, anchorMin, anchorMax, pivot, sizeDelta);
@@ -71,212 +71,146 @@ namespace XCharts
             return item;
         }
 
-        public static void ResetItemPosition(Legend legend, float chartWidth, float chartHeight)
+        public static void ResetItemPosition(Legend legend, Vector3 chartPos, float chartWidth, float chartHeight)
         {
             var startX = 0f;
             var startY = 0f;
-            var offsetX = 0f;
+            var legendMaxWidth = chartWidth - legend.location.left - legend.location.right;
-            var currWidth = 0f;
+            var legendMaxHeight = chartHeight - legend.location.top - legend.location.bottom;
-            var currHeight = 0f;
+            UpdateLegendWidthAndHeight(legend, legendMaxWidth, legendMaxHeight);
-            var legendWidth = chartWidth - legend.location.left - legend.location.right;
-            var legendHeight = chartHeight - legend.location.top - legend.location.bottom;
             var legendRuntimeWidth = legend.runtimeWidth;
             var legendRuntimeHeight = legend.runtimeHeight;
-            switch (legend.orient)
+            var isVertical = legend.orient == Orient.Vertical;
-            {
-                case Orient.Vertical:
             switch (legend.location.align)
             {
                 case Location.Align.TopCenter:
-                            startX = legendRuntimeWidth / 2;
+                    startX = chartPos.x + chartWidth / 2 - legendRuntimeWidth / 2;
-                            foreach (var kv in legend.buttonList)
+                    startY = chartPos.y + chartHeight - legend.location.top;
-                            {
-                                var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
-                                {
-                                    currHeight = 0;
-                                    offsetX += legendRuntimeWidth + legend.itemGap;
-                                }
-                                item.SetPosition(new Vector3(-startX + item.width / 2 + offsetX, -currHeight));
-                                currHeight += item.height + legend.itemGap;
-                            }
                     break;
                 case Location.Align.TopLeft:
-                            foreach (var kv in legend.buttonList)
+                    startX = chartPos.x + legend.location.left;
-                            {
+                    startY = chartPos.y + chartHeight - legend.location.top;
-                                var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
-                                {
-                                    currHeight = 0;
-                                    offsetX += legendRuntimeWidth + legend.itemGap;
-                                }
-                                item.SetPosition(new Vector3(0 + offsetX, -currHeight));
-                                currHeight += item.height + legend.itemGap;
-                            }
                     break;
                 case Location.Align.TopRight:
-                            foreach (var kv in legend.buttonList)
+                    startX = chartPos.x + chartWidth - legendRuntimeWidth - legend.location.right;
-                            {
+                    startY = chartPos.y + chartHeight - legend.location.top;
-                                var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
-                                {
-                                    currHeight = 0;
-                                    offsetX -= legendRuntimeWidth + legend.itemGap;
-                                }
-                                item.SetPosition(new Vector3(item.width - legendRuntimeWidth + offsetX, -currHeight));
-                                currHeight += item.height + legend.itemGap;
-                            }
                     break;
+                case Location.Align.Center:
+                    startX = chartPos.x + chartWidth / 2 - legendRuntimeWidth / 2;
+                    startY = chartPos.y + chartHeight / 2 + legendRuntimeHeight / 2;
+                    break;
+                case Location.Align.CenterLeft:
+                    startX = chartPos.x + legend.location.left;
+                    startY = chartPos.y + chartHeight / 2 + legendRuntimeHeight / 2;
+                    break;
+                case Location.Align.CenterRight:
+                    startX = chartPos.x + chartWidth - legendRuntimeWidth - legend.location.right;
+                    startY = chartPos.y + chartHeight / 2 + legendRuntimeHeight / 2;
+                    break;
+                case Location.Align.BottomCenter:
+                    startX = chartPos.x + chartWidth / 2 - legendRuntimeWidth / 2;
+                    startY = chartPos.y + legendRuntimeHeight + legend.location.bottom;
+                    break;
+                case Location.Align.BottomLeft:
+                    startX = chartPos.x + legend.location.left;
+                    startY = chartPos.y + legendRuntimeHeight + legend.location.bottom;
+                    break;
+                case Location.Align.BottomRight:
+                    startX = chartPos.x + chartWidth - legendRuntimeWidth - legend.location.right;
+                    startY = chartPos.y + legendRuntimeHeight + legend.location.bottom;
+                    break;
+            }
+            if (isVertical) SetVerticalItemPosition(legend, legendMaxHeight, startX, startY);
+            else SetHorizonalItemPosition(legend, legendMaxWidth, startX, startY);
+        }
 
-                        case Location.Align.Center:
+        private static void SetVerticalItemPosition(Legend legend, float legendMaxHeight, float startX, float startY)
-                            startX = legendRuntimeWidth / 2;
+        {
-                            startY = legendRuntimeHeight > legendHeight ? legendHeight / 2 : legendRuntimeHeight / 2;
+            var currHeight = 0f;
+            var offsetX = 0f;
+            var row = 0;
             foreach (var kv in legend.buttonList)
             {
                 var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
+                if (currHeight + item.height > legendMaxHeight)
                 {
                     currHeight = 0;
-                                    offsetX += legendRuntimeWidth + legend.itemGap;
+                    offsetX += legend.runtimeEachWidth[row];
+                    row++;
                 }
-                                item.SetPosition(new Vector3(-startX + item.width / 2 + offsetX, startY - currHeight));
+                item.SetPosition(new Vector3(startX + offsetX, startY - currHeight));
                 currHeight += item.height + legend.itemGap;
             }
-                            break;
+        }
-                        case Location.Align.CenterLeft:
+        private static void SetHorizonalItemPosition(Legend legend, float legendMaxWidth, float startX, float startY)
-                            startY = legendRuntimeHeight > legendHeight ? legendHeight / 2 : legendRuntimeHeight / 2;
+        {
+            var currWidth = 0f;
+            var offsetY = 0f;
             foreach (var kv in legend.buttonList)
             {
                 var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
+                if (currWidth + item.width > legendMaxWidth)
                 {
-                                    currHeight = 0;
+                    currWidth = 0;
-                                    offsetX += legendRuntimeWidth + legend.itemGap;
+                    offsetY += legend.runtimeEachHeight;
                 }
-                                item.SetPosition(new Vector3(offsetX, startY - currHeight - item.height));
+                item.SetPosition(new Vector3(startX + currWidth, startY - offsetY));
-                                currHeight += item.height + legend.itemGap;
-                            }
-                            break;
-                        case Location.Align.CenterRight:
-                            startX = 0;
-                            startY = legendRuntimeHeight > legendHeight ? legendHeight / 2 : legendRuntimeHeight / 2;
-                            foreach (var kv in legend.buttonList)
-                            {
-                                var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
-                                {
-                                    currHeight = 0;
-                                    offsetX -= legendRuntimeWidth + legend.itemGap;
-                                }
-                                item.SetPosition(new Vector3(item.width - legendRuntimeWidth + offsetX, startY - currHeight - item.height));
-                                currHeight += item.height + legend.itemGap;
-                            }
-                            break;
-                        case Location.Align.BottomCenter:
-                            startX = legendRuntimeWidth / 2;
-                            startY = legendRuntimeHeight > legendHeight ? legendHeight : legendRuntimeHeight;
-                            foreach (var kv in legend.buttonList)
-                            {
-                                var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
-                                {
-                                    currHeight = 0;
-                                    offsetX += legendRuntimeWidth + legend.itemGap;
-                                }
-                                item.SetPosition(new Vector3(-startX + item.width / 2 + offsetX, startY - currHeight - item.height));
-                                currHeight += item.height + legend.itemGap;
-                            }
-                            break;
-                        case Location.Align.BottomLeft:
-                            startX = 0;
-                            startY = legendRuntimeHeight > legendHeight ? legendHeight : legendRuntimeHeight;
-                            foreach (var kv in legend.buttonList)
-                            {
-                                var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
-                                {
-                                    currHeight = 0;
-                                    offsetX += legendRuntimeWidth + legend.itemGap;
-                                }
-                                item.SetPosition(new Vector3(startX + offsetX, startY - currHeight - item.height));
-                                currHeight += item.height + legend.itemGap;
-                            }
-                            break;
-                        case Location.Align.BottomRight:
-                            startX = 0;
-                            startY = legendRuntimeHeight > legendHeight ? legendHeight : legendRuntimeHeight;
-                            foreach (var kv in legend.buttonList)
-                            {
-                                var item = kv.Value;
-                                if (currHeight + item.height > legendHeight)
-                                {
-                                    currHeight = 0;
-                                    offsetX -= legendRuntimeWidth + legend.itemGap;
-                                }
-                                item.SetPosition(new Vector3(item.width - legendRuntimeWidth + offsetX, startY - currHeight - item.height));
-                                currHeight += item.height + legend.itemGap;
-                            }
-                            break;
-                    }
-                    break;
-                case Orient.Horizonal:
-                    switch (legend.location.align)
-                    {
-                        case Location.Align.TopLeft:
-                        case Location.Align.CenterLeft:
-                        case Location.Align.BottomLeft:
-                            var isBottom = legend.location.align == Location.Align.BottomLeft;
-                            foreach (var kv in legend.buttonList)
-                            {
-                                var item = kv.Value;
-                                if (currWidth + item.width > legendWidth)
-                                {
-                                    currWidth = 0f;
-                                    if (isBottom) currHeight += legend.itemGap + item.height;
-                                    else currHeight -= legend.itemGap + item.height;
-                                }
-                                item.SetPosition(new Vector3(currWidth, currHeight));
                 currWidth += item.width + legend.itemGap;
             }
-                            break;
+        }
-                        case Location.Align.TopCenter:
+
-                        case Location.Align.Center:
+        private static void UpdateLegendWidthAndHeight(Legend legend, float maxWidth, float maxHeight)
-                        case Location.Align.BottomCenter:
+        {
-                            isBottom = legend.location.align == Location.Align.BottomCenter;
+            var width = 0f;
-                            startX = legendRuntimeWidth > legendWidth ? legendWidth / 2 : legendRuntimeWidth / 2;
+            var height = 0f;
+            var realHeight = 0f;
+            var realWidth = 0f;
+            legend.runtimeEachWidth.Clear();
+            legend.runtimeEachHeight = 0;
+            if (legend.orient == Orient.Horizonal)
+            {
                 foreach (var kv in legend.buttonList)
                 {
-                                var item = kv.Value;
+                    if (width + kv.Value.width > maxWidth)
-                                if (currWidth + item.width > legendWidth)
                     {
-                                    currWidth = 0f;
+                        realWidth = width - legend.itemGap;
-                                    if (isBottom) currHeight += legend.itemGap + item.height;
+                        realHeight += height + legend.itemGap;
-                                    else currHeight -= legend.itemGap + item.height;
+                        if (legend.runtimeEachHeight < height + legend.itemGap)
+                        {
+                            legend.runtimeEachHeight = height + legend.itemGap;
                         }
-                                item.SetPosition(new Vector3(-startX + item.width / 2 + currWidth, currHeight));
+                        height = 0;
-                                currWidth += item.width + legend.itemGap;
+                        width = 0;
                     }
-                            break;
+                    width += kv.Value.width + legend.itemGap;
-                        case Location.Align.TopRight:
+                    if (kv.Value.height > height)
-                        case Location.Align.CenterRight:
+                        height = kv.Value.height;
-                        case Location.Align.BottomRight:
+                }
-                            isBottom = legend.location.align == Location.Align.BottomRight;
+                width -= legend.itemGap;
-                            startX = legendRuntimeWidth > legendWidth ? -legendWidth : -legendRuntimeWidth;
+                legend.runtimeHeight = realHeight + height;
+                legend.runtimeWidth = realWidth > 0 ? realWidth : width;
+            }
+            else
+            {
+                var row = 0;
                 foreach (var kv in legend.buttonList)
                 {
-                                var item = kv.Value;
+                    if (height + kv.Value.height > maxHeight)
-                                if (currWidth + item.width > legendWidth)
                     {
-                                    currWidth = 0f;
+                        realHeight = height - legend.itemGap;
-                                    if (isBottom) currHeight += legend.itemGap + item.height;
+                        realWidth += width + legend.itemGap;
-                                    else currHeight -= legend.itemGap + item.height;
+                        legend.runtimeEachWidth[row] = width + legend.itemGap;
+                        row++;
+                        height = 0;
+                        width = 0;
                     }
-                                item.SetPosition(new Vector3(startX + currWidth + item.width, currHeight));
+                    height += kv.Value.height + legend.itemGap;
-                                currWidth += item.width + legend.itemGap;
+                    if (kv.Value.width > width)
+                        width = kv.Value.width;
                 }
-                            break;
+                height -= legend.itemGap;
-                    }
+                legend.runtimeHeight = realHeight > 0 ? realHeight : height;
-                    break;
+                legend.runtimeWidth = realWidth + width;
             }
         }