コード例 #1
0
        public static string GetFormatterContent(Serie serie, SerieData serieData,
                                                 double dataValue, double dataTotal, SerieLabel serieLabel, Color color)
        {
            if (serieLabel == null)
            {
                serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
            }
            var numericFormatter = serieLabel == null ? serie.label.numericFormatter : serieLabel.numericFormatter;
            var serieName        = serie.name;
            var dataName         = serieData != null ? serieData.name : null;

            if (serieLabel.formatterFunction != null)
            {
                return(serieLabel.formatterFunction(serieData.index, dataValue));
            }
            if (string.IsNullOrEmpty(serieLabel.formatter))
            {
                return(ChartCached.NumberToStr(dataValue, numericFormatter));
            }
            else
            {
                var content = serieLabel.formatter;
                FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, dataValue,
                                                         dataTotal, serieName, dataName, color);
                return(content);
            }
        }
コード例 #2
0
 public string GetFormatterContent(float value, float minValue, float maxValue, bool isLog = false)
 {
     if (showAsPositiveNumber && value < 0)
     {
         value = Mathf.Abs(value);
     }
     if (string.IsNullOrEmpty(m_Formatter))
     {
         if (isLog)
         {
             return(ChartCached.NumberToStr(value, numericFormatter));
         }
         if (minValue >= -1 && minValue <= 1 && maxValue >= -1 && maxValue <= 1)
         {
             int minAcc = ChartHelper.GetFloatAccuracy(minValue);
             int maxAcc = ChartHelper.GetFloatAccuracy(maxValue);
             int curAcc = ChartHelper.GetFloatAccuracy(value);
             int acc    = Mathf.Max(Mathf.Max(minAcc, maxAcc), curAcc);
             return(ChartCached.FloatToStr(value, numericFormatter, acc));
         }
         return(ChartCached.NumberToStr(value, numericFormatter));
     }
     else
     {
         var content = m_Formatter;
         FormatterHelper.ReplaceAxisLabelContent(ref content, numericFormatter, value);
         return(content);
     }
 }
コード例 #3
0
ファイル: AxisLabel.cs プロジェクト: zcf112/UnityDemo
        public string GetFormatterDateTime(DateTime dateTime)
        {
            var format = string.IsNullOrEmpty(numericFormatter) ? "yyyy/M/d" : numericFormatter;

            if (!string.IsNullOrEmpty(m_Formatter))
            {
                var content = m_Formatter;
                FormatterHelper.ReplaceAxisLabelContent(ref content, dateTime.ToString(format));
                return(m_TextLimit.GetLimitContent(content));
            }
            else
            {
                var content = dateTime.ToString(format);
                return(m_TextLimit.GetLimitContent(content));
            }
        }
コード例 #4
0
ファイル: AxisLabel.cs プロジェクト: zcf112/UnityDemo
 public string GetFormatterContent(string category)
 {
     if (string.IsNullOrEmpty(category))
     {
         return(category);
     }
     if (string.IsNullOrEmpty(m_Formatter))
     {
         return(m_TextLimit.GetLimitContent(category));
     }
     else
     {
         var content = m_Formatter;
         FormatterHelper.ReplaceAxisLabelContent(ref content, category);
         return(m_TextLimit.GetLimitContent(content));
     }
 }
コード例 #5
0
        public static string GetFormatterContent(Serie serie, MarkLineData data)
        {
            var serieLabel       = data.label;
            var numericFormatter = serieLabel.numericFormatter;

            if (serieLabel.formatterFunction != null)
            {
                return(serieLabel.formatterFunction(data.index, data.runtimeValue));
            }
            if (string.IsNullOrEmpty(serieLabel.formatter))
            {
                return(ChartCached.NumberToStr(data.runtimeValue, numericFormatter));
            }
            else
            {
                var content = serieLabel.formatter;
                FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, data.runtimeValue,
                                                         0, serie.name, data.name, Color.clear);
                return(content);
            }
        }
コード例 #6
0
        public string GetFormatterDateTime(int labelIndex, double value)
        {
            if (m_FormatterFunction != null)
            {
                return(m_FormatterFunction(labelIndex, value, null));
            }
            var timestamp = (int)value;
            var dateTime  = DateTimeUtil.GetDateTime(timestamp);
            var format    = string.IsNullOrEmpty(numericFormatter) ? "yyyy/M/d" : numericFormatter;

            if (!string.IsNullOrEmpty(m_Formatter))
            {
                var content = m_Formatter;
                FormatterHelper.ReplaceAxisLabelContent(ref content, dateTime.ToString(format));
                return(m_TextLimit.GetLimitContent(content));
            }
            else
            {
                var content = dateTime.ToString(format);
                return(m_TextLimit.GetLimitContent(content));
            }
        }
コード例 #7
0
        public static string GetFormatterContent(Serie serie, SerieData serieData,
                                                 float dataValue, float dataTotal, SerieLabel serieLabel = null)
        {
            if (serieLabel == null)
            {
                serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
            }
            var numericFormatter = GetLabelNumericFormatter(serie, serieData);
            var serieName        = serie.name;
            var dataName         = serieData != null ? serieData.name : null;

            if (string.IsNullOrEmpty(serieLabel.formatter))
            {
                return(ChartCached.NumberToStr(dataValue, numericFormatter));
            }
            else
            {
                var content = serieLabel.formatter;
                FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, dataValue,
                                                         dataTotal, serieName, dataName);
                return(content);
            }
        }
コード例 #8
0
        public static void InitRadarTooltip(ref StringBuilder sb, Tooltip tooltip, Serie serie, Radar radar,
                                            ThemeInfo themeInfo)
        {
            if (!serie.show)
            {
                return;
            }
            if (serie.radarIndex != radar.index)
            {
                return;
            }
            var dataIndex = tooltip.runtimeDataIndex[1];
            var serieData = serie.GetSerieData(dataIndex);

            if (!serieData.show)
            {
                return;
            }
            var numericFormatter = GetItemNumericFormatter(tooltip, serie, serieData);

            switch (serie.radarType)
            {
            case RadarType.Multiple:
                if (radar.isAxisTooltip)
                {
                    var dimension = tooltip.runtimeDataIndex[2];
                    if (!string.IsNullOrEmpty(serie.name))
                    {
                        sb.Append(serie.name).Append("\n");
                    }
                    var total = serie.GetDataTotal(dimension);
                    var first = true;
                    for (int i = 0; i < serie.dataCount; i++)
                    {
                        var sd = serie.GetSerieData(i);
                        if (!sd.show)
                        {
                            continue;
                        }
                        var key           = sd.name;
                        var value         = sd.GetData(dimension);
                        var itemFormatter = GetItemFormatter(tooltip, serie, sd);
                        numericFormatter = GetItemNumericFormatter(tooltip, serie, sd);
                        if (!first)
                        {
                            sb.Append("\n");
                        }
                        first = false;
                        sb.Append("<color=#").Append(themeInfo.GetColorStr(i)).Append(">● </color>");
                        if (string.IsNullOrEmpty(itemFormatter))
                        {
                            if (string.IsNullOrEmpty(key))
                            {
                                key = radar.indicatorList[dataIndex].name;
                            }
                            if (string.IsNullOrEmpty(key))
                            {
                                sb.AppendFormat("{0}\n", ChartCached.FloatToStr(value, numericFormatter));
                            }
                            else
                            {
                                sb.AppendFormat("{0}: {1}\n", key, ChartCached.FloatToStr(value, numericFormatter));
                            }
                        }
                        else
                        {
                            string content = itemFormatter;
                            FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, value, total, serie.name, sd.name);
                            sb.Append(content);
                        }
                    }
                }
                else
                {
                    if (serie.index != tooltip.runtimeDataIndex[0])
                    {
                        return;
                    }
                    sb.Append(serieData.name);
                    for (int i = 0; i < radar.indicatorList.Count; i++)
                    {
                        string key   = radar.indicatorList[i].name;
                        float  value = serieData.GetData(i);
                        if ((i == 0 && !string.IsNullOrEmpty(serieData.name)) || i > 0)
                        {
                            sb.Append(FormatterHelper.PH_NN);
                        }
                        sb.AppendFormat("{0}: {1}", key, ChartCached.FloatToStr(value, numericFormatter));
                    }
                }
                break;

            case RadarType.Single:
                var key2           = serieData.name;
                var value2         = serieData.GetData(1);
                var total2         = serie.GetDataTotal(1);
                var itemFormatter2 = GetItemFormatter(tooltip, serie, serieData);
                if (string.IsNullOrEmpty(itemFormatter2))
                {
                    if (string.IsNullOrEmpty(key2))
                    {
                        key2 = radar.indicatorList[dataIndex].name;
                    }
                    sb.AppendFormat("{0}: {1}", key2, ChartCached.FloatToStr(value2, numericFormatter));
                }
                else
                {
                    string content = itemFormatter2;
                    FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, value2, total2, serie.name, serieData.name);
                    sb.Append(content);
                }

                break;
            }
        }
コード例 #9
0
 public static string GetFormatterContent(Tooltip tooltip, int dataIndex, Series series, ThemeInfo themeInfo,
                                          string category = null, DataZoom dataZoom = null, bool isCartesian = false, Radar radar = null)
 {
     if (string.IsNullOrEmpty(tooltip.formatter))
     {
         var sb            = ChartHelper.sb;
         var title         = tooltip.titleFormatter;
         var formatTitle   = !string.IsNullOrEmpty(title);
         var titleIsIgnroe = false;
         var needCategory  = false;
         var first         = true;
         var isScatter     = false;
         sb.Length = 0;
         if ("{i}".Equals(tooltip.titleFormatter))
         {
             title         = string.Empty;
             formatTitle   = false;
             titleIsIgnroe = true;
         }
         for (int i = 0; i < series.Count; i++)
         {
             var serie = series.GetSerie(i);
             if (serie.type == SerieType.Scatter || serie.type == SerieType.EffectScatter)
             {
                 if (serie.show && IsSelectedSerie(tooltip, serie.index))
                 {
                     isScatter = true;
                     var itemFormatter = GetItemFormatter(tooltip, serie, null);
                     if (string.IsNullOrEmpty(itemFormatter))
                     {
                         if (!first)
                         {
                             sb.Append(FormatterHelper.PH_NN);
                         }
                         InitDefaultContent(ref sb, tooltip, serie, dataIndex, category, themeInfo, dataZoom, isCartesian, radar);
                         first = false;
                         continue;
                     }
                     var itemTitle = title;
                     if (!string.IsNullOrEmpty(itemTitle))
                     {
                         FormatterHelper.ReplaceContent(ref itemTitle, dataIndex, tooltip.numericFormatter, serie, series, themeInfo, category, dataZoom);
                         sb.Append(itemTitle).Append(FormatterHelper.PH_NN);
                     }
                     var dataIndexList = tooltip.runtimeSerieIndex[serie.index];
                     foreach (var tempIndex in dataIndexList)
                     {
                         string content  = itemFormatter;
                         var    foundDot = FormatterHelper.ReplaceContent(ref content, tempIndex, tooltip.numericFormatter, serie, series, themeInfo, category, dataZoom);
                         if (!foundDot)
                         {
                             sb.Append(ChartCached.ColorToDotStr(themeInfo.GetColor(serie.index)));
                         }
                         sb.Append(content).Append(FormatterHelper.PH_NN);
                     }
                 }
             }
             else if (IsNeedTooltipSerie(serie, tooltip))
             {
                 var serieData = serie.GetSerieData(dataIndex, dataZoom);
                 if (serieData == null)
                 {
                     continue;
                 }
                 var itemFormatter = GetItemFormatter(tooltip, serie, serieData);
                 needCategory = needCategory || (serie.type == SerieType.Line || serie.type == SerieType.Bar);
                 if (formatTitle)
                 {
                     FormatterHelper.ReplaceContent(ref title, dataIndex, tooltip.numericFormatter, serie, series, themeInfo, category, dataZoom);
                 }
                 if (serie.show)
                 {
                     if (string.IsNullOrEmpty(itemFormatter) || serie.type == SerieType.Radar)
                     {
                         if (!first)
                         {
                             sb.Append(FormatterHelper.PH_NN);
                         }
                         InitDefaultContent(ref sb, tooltip, serie, dataIndex, category, themeInfo, dataZoom, isCartesian, radar);
                         first = false;
                         continue;
                     }
                     string content = itemFormatter;
                     FormatterHelper.ReplaceContent(ref content, dataIndex, tooltip.numericFormatter, serie, series, themeInfo, category, dataZoom);
                     if (!first)
                     {
                         sb.Append(FormatterHelper.PH_NN);
                     }
                     var dotColorIndex = serie.type == SerieType.Pie || serie.type == SerieType.Radar || serie.type == SerieType.Ring ? dataIndex : i;
                     sb.Append(ChartCached.ColorToDotStr(themeInfo.GetColor(dotColorIndex)));
                     sb.Append(content);
                     first = false;
                 }
             }
         }
         if (isScatter)
         {
             return(FormatterHelper.TrimAndReplaceLine(sb));
         }
         else if (string.IsNullOrEmpty(title))
         {
             if (needCategory && !titleIsIgnroe)
             {
                 return(category + FormatterHelper.PH_NN + FormatterHelper.TrimAndReplaceLine(sb));
             }
             else
             {
                 return(FormatterHelper.TrimAndReplaceLine(sb));
             }
         }
         else
         {
             title = FormatterHelper.TrimAndReplaceLine(title);
             return(title + FormatterHelper.PH_NN + FormatterHelper.TrimAndReplaceLine(sb));
         }
     }
     else
     {
         string content = tooltip.formatter;
         FormatterHelper.ReplaceContent(ref content, dataIndex, tooltip.numericFormatter, null, series, themeInfo, category, dataZoom);
         return(content);
     }
 }
コード例 #10
0
        public static string GetPolarFormatterContent(Tooltip tooltip, Series series, ThemeInfo themeInfo, AngleAxis angleAxis)
        {
            if (string.IsNullOrEmpty(tooltip.formatter))
            {
                var sb = ChartHelper.sb;
                sb.Length = 0;
                var title       = tooltip.titleFormatter;
                var formatTitle = !string.IsNullOrEmpty(title);
                if ("{i}".Equals(tooltip.titleFormatter))
                {
                    title       = string.Empty;
                    formatTitle = false;
                }
                else if (string.IsNullOrEmpty(title))
                {
                    var angle = angleAxis.clockwise ? tooltip.runtimeAngle : 360 - tooltip.runtimeAngle;
                    title = ChartCached.FloatToStr(angle);
                }
                foreach (var serie in series.list)
                {
                    if (serie.show && IsSelectedSerie(tooltip, serie.index))
                    {
                        if (formatTitle)
                        {
                            FormatterHelper.ReplaceContent(ref title, 0, tooltip.numericFormatter, serie, series, themeInfo, null, null);
                        }
                        var dataIndexList = tooltip.runtimeSerieIndex[serie.index];

                        for (int i = 0; i < dataIndexList.Count; i++)
                        {
                            var   dataIndex = dataIndexList[i];
                            var   serieData = serie.GetSerieData(dataIndex);
                            var   itemFormatter = GetItemFormatter(tooltip, serie, serieData);
                            var   numericFormatter = GetItemNumericFormatter(tooltip, serie, serieData);
                            float xValue, yValue;
                            serie.GetXYData(dataIndex, null, out xValue, out yValue);
                            if (string.IsNullOrEmpty(itemFormatter))
                            {
                                sb.Append("<color=#").Append(themeInfo.GetColorStr(serie.index)).Append(">● </color>");
                                if (!string.IsNullOrEmpty(serie.name))
                                {
                                    sb.Append(serie.name).Append(": ");
                                }
                                sb.AppendFormat("{0}", ChartCached.FloatToStr(xValue, numericFormatter));
                                if (i != dataIndexList.Count - 1)
                                {
                                    sb.Append(FormatterHelper.PH_NN);
                                }
                            }
                            else
                            {
                                string content = itemFormatter;
                                FormatterHelper.ReplaceContent(ref content, dataIndex, tooltip.numericFormatter, serie, series, themeInfo, null, null);
                                var dotColorIndex = serie.type == SerieType.Pie || serie.type == SerieType.Radar || serie.type == SerieType.Ring ? dataIndex : serie.index;
                                sb.Append(ChartCached.ColorToDotStr(themeInfo.GetColor(dotColorIndex)));
                                sb.Append(content);
                            }
                        }
                        sb.Append(FormatterHelper.PH_NN);
                    }
                }
                if (string.IsNullOrEmpty(title))
                {
                    return(FormatterHelper.TrimAndReplaceLine(sb));
                }
                else
                {
                    title = FormatterHelper.TrimAndReplaceLine(title);
                    return(title + FormatterHelper.PH_NN + FormatterHelper.TrimAndReplaceLine(sb));
                }
            }
            else
            {
                string content = tooltip.formatter;
                FormatterHelper.ReplaceContent(ref content, 0, tooltip.numericFormatter, null, series, themeInfo, null, null);
                return(content);
            }
        }