开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > OA系统 > 查看源码
BarChart.java
资源名称：OA.rar　[点击查看]
上传用户：mingda
上传日期：2017-06-20
资源大小：27691k
文件大小：84k
源码类别：

OA系统

开发平台：

Java

BarChart.java：源码内容
  1. // Decompiled by DJ v2.9.9.60 Copyright 2000 Atanas Neshkov  Date: 2002-12-03 18:39:45
  2. // Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
  3. // Decompiler options: packimports(3) 
  4. // Source File Name:   BarChart.java
  6. package cn.com.fcsoft.chart;
  8. import java.awt.*;
  9. import java.awt.event.MouseEvent;
  10. import java.util.*;
  12. // Referenced classes of package com.objectplanet.chart:
  13. //            Chart, ChartSample, LineChart, PieChart
  15. public class BarChart extends Chart
  16. {
  18.     private void paintBar(Graphics g, int i, int j)
  19.     {
  20.         ChartSample chartsample = getSample(i, j);
  21.         int k = getSeriesCount();
  22.         if(chartsample == null || chartsample.value == null || chartsample.value.isNaN() || chartsample.getFloatValue() == 0.0D && barType == 1 && k > 1)
  23.             return;
  24.         int l = getSeriesRange(i);
  25.         double d = chartsample.getFloatValue();
  26.         if(barType != 1 && (d < super.currentLowerRange[l] && super.currentLowerRange[l] > 0.0D || d > super.currentUpperRange[l] && super.currentUpperRange[l] < 0.0D))
  27.             return;
  28.         if(multiColorOn)
  29.         {
  30.             if(getSeriesCount() > 1 || barType == 1 || super.multiSeriesOn)
  31.                 g.setColor(getSampleColor(i));
  32.             else
  33.                 g.setColor(getSampleColor(j));
  34.         } else
  35.         {
  36.             g.setColor(getSampleColor(0));
  37.         }
  38.         boolean flag = chartsample != null && chartsample.isSelected();
  39.         Rectangle rectangle = barBounds[i][j];
  40.         Color color = getChartForeground();
  41.         if(barOutlineOn)
  42.         {
  43.             g.fillRect(rectangle.x, rectangle.y, rectangle.width + 1, rectangle.height);
  44.             Color color1 = g.getColor();
  45.             if(barOutlineColor != null)
  46.                 g.setColor(barOutlineColor);
  47.             else
  48.                 g.setColor(color);
  49.             g.drawRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
  50.             if(flag)
  51.                 g.drawRect(rectangle.x + 1, rectangle.y + 1, rectangle.width - 2, rectangle.height != 2 ? rectangle.height - 2 : 1);
  52.             g.setColor(color1);
  53.         } else
  54.         {
  55.             if(super.gridAlignment == 1)
  56.                 g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
  57.             else
  58.                 g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
  59.             if(flag)
  60.             {
  61.                 Color color2 = g.getColor();
  62.                 if(barOutlineColor != null)
  63.                     g.setColor(barOutlineColor);
  64.                 else
  65.                     g.setColor(color);
  66.                 if(super.gridAlignment == 1)
  67.                     g.drawRect(rectangle.x, rectangle.y, rectangle.width - 1, rectangle.height);
  68.                 else
  69.                     g.drawRect(rectangle.x, rectangle.y, rectangle.width - 1, rectangle.height - 1);
  70.                 g.setColor(color2);
  71.             }
  72.         }
  73.         if(is3DModeOn())
  74.             paint3DBar(g, rectangle, flag, d);
  75.     }
  77.     public void setBarLabelsOn(boolean flag)
  78.     {
  79.         super.sampleLabelsOn = flag;
  80.         super.hasChanged = true;
  81.         autoRepaint();
  82.     }
  84.     public void setAutoLabelSpacingOn(boolean flag)
  85.     {
  86.         autoLabelSpacingOn = flag;
  87.         super.hasChanged = true;
  88.         autoRepaint();
  89.     }
  91.     protected void processEvent(AWTEvent awtevent)
  92.     {
  93.         switch(awtevent.getID())
  94.         {
  95.         case 504: 
  96.         default:
  97.             break;
  99.         case 505: 
  100.             selectedSample = -1;
  101.             selectedSeries = -1;
  102.             repaint();
  103.             break;
  105.         case 503: 
  106.         case 506: 
  107.             MouseEvent mouseevent = (MouseEvent)awtevent;
  108.             boolean flag = isValueLabelsOn() && valueLabelStyle == 2;
  109.             flag = flag || super.sampleLabelsOn && (super.barLabelStyle == 1 || super.barLabelStyle == 2);
  110.             if(!flag)
  111.                 break;
  112.             mousePosition.x = mouseevent.getX();
  113.             mousePosition.y = mouseevent.getY();
  114.             ChartSample chartsample = super.checkSelection(mousePosition);
  115.             if(chartsample != null)
  116.             {
  117.                 mousePosition.x = -1;
  118.                 mousePosition.y = -1;
  119.             } else
  120.             {
  121.                 chartsample = checkSelection(mousePosition);
  122.             }
  123.             if(chartsample != null)
  124.             {
  125.                 if(chartsample.getIndex() != selectedSample || chartsample.getSeries() != selectedSeries)
  126.                 {
  127.                     selectedSample = chartsample.getIndex();
  128.                     selectedSeries = chartsample.getSeries();
  129.                     repaint();
  130.                 }
  131.                 break;
  132.             }
  133.             boolean flag1 = selectedSample != -1 || selectedSeries != -1;
  134.             selectedSample = -1;
  135.             selectedSeries = -1;
  136.             if(flag1)
  137.                 repaint();
  138.             break;
  139.         }
  140.         super.processEvent(awtevent);
  141.     }
  143.     public void setBarLabels(String as[])
  144.     {
  145.         super.barLabels = as;
  146.         super.hasChanged = true;
  147.         autoRepaint();
  148.     }
  150.     public String[] getBarLabels()
  151.     {
  152.         if(super.barLabels != null)
  153.             return super.barLabels;
  154.         else
  155.             return getSampleLabels();
  156.     }
  158.     public String[] getLegendLabels()
  159.     {
  160.         if(super.legendLabels != null)
  161.             return super.legendLabels;
  162.         if(getSeriesCount() > 1 || barType == 1 || super.multiSeriesOn)
  163.             return getSeriesLabels();
  164.         else
  165.             return getSampleLabels();
  166.     }
  168.     public void setBarType(int i)
  169.     {
  170.         if(i == 0 || i == 1)
  171.         {
  172.             barType = i;
  173.             super.hasChanged = true;
  174.             autoRepaint();
  175.         } else
  176.         {
  177.             throw new IllegalArgumentException("Invalid bar type: " + i);
  178.         }
  179.     }
  181.     public int getBarType()
  182.     {
  183.         return barType;
  184.     }
  186.     double getHighestValue(int i)
  187.     {
  188.         if(barType == 0)
  189.             return super.getHighestValue(i);
  190.         double d = 0.0D;
  191.         int j = getSampleCount();
  192.         int k = getSeriesCount();
  193.         for(int l = 0; l < j; l++)
  194.         {
  195.             double d1 = 0.0D;
  196.             for(int i1 = 0; i1 < k; i1++)
  197.             {
  198.                 ChartSample chartsample = getSample(i1, l);
  199.                 if(chartsample != null && chartsample.value != null && !chartsample.value.isNaN() && chartsample.value.doubleValue() > 0.0D)
  200.                     d1 += chartsample.value.doubleValue();
  201.             }
  203.             d = Math.max(d, d1);
  204.         }
  206.         return d;
  207.     }
  209.     double getLowestValue(int i)
  210.     {
  211.         if(barType == 0)
  212.             return super.getLowestValue(i);
  213.         double d = 0.0D;
  214.         int j = getSampleCount();
  215.         int k = getSeriesCount();
  216.         for(int l = 0; l < j; l++)
  217.         {
  218.             double d1 = 0.0D;
  219.             for(int i1 = 0; i1 < k; i1++)
  220.             {
  221.                 ChartSample chartsample = getSample(i1, l);
  222.                 if(chartsample != null && chartsample.value != null && !chartsample.value.isNaN() && chartsample.value.doubleValue() < 0.0D)
  223.                     d1 += chartsample.value.doubleValue();
  224.             }
  226.             d = Math.min(d, d1);
  227.         }
  229.         return d;
  230.     }
  232.     public void setBarAlignment(int i)
  233.     {
  234.         if(i == 0 || i == 1)
  235.         {
  236.             super.gridAlignment = i;
  237.             super.hasChanged = true;
  238.             autoRepaint();
  239.         } else
  240.         {
  241.             throw new IllegalArgumentException("Alignment must be HORIZONTAL or VERTICAL");
  242.         }
  243.     }
  245.     public int getgridAlignment()
  246.     {
  247.         return super.gridAlignment;
  248.     }
  250.     protected void calculateChartData(Rectangle rectangle, Rectangle rectangle1)
  251.     {
  252.         calculateZeroLines(rectangle);
  253.         int i = getSampleCount();
  254.         int j = getSeriesCount();
  255.         if(is3DModeOn() && i > 0 && j > 0)
  256.             if(super.depth3d >= 0)
  257.             {
  258.                 super.depth3dPoint.x = super.depth3d;
  259.                 super.depth3dPoint.y = -super.depth3d;
  260.             } else
  261.             if(super.gridAlignment == 1)
  262.             {
  263.                 double d = (double)rectangle.width / (double)i;
  264.                 double d3 = d * barWidthFraction;
  265.                 if(barType == 0)
  266.                     d3 /= j;
  267.                 super.depth3dPoint.x = (int)Math.round(d3 * 1.25D);
  268.                 super.depth3dPoint.y = (int)Math.round(-d3 / 1.25D);
  269.             } else
  270.             {
  271.                 double d1 = (double)rectangle.height / (double)i;
  272.                 double d4 = d1 * barWidthFraction;
  273.                 if(barType == 0)
  274.                     d4 /= j;
  275.                 super.depth3dPoint.x = (int)Math.round(d4 * 1.25D * 0.75D);
  276.                 super.depth3dPoint.y = (int)Math.round(-((d4 / 1.25D) * 0.75D));
  277.             }
  278.         if(barBounds == null || barBounds.length != j || barBounds[0].length != i)
  279.         {
  280.             Rectangle arectangle[][] = new Rectangle[j][i];
  281.             for(int l = 0; l < j; l++)
  282.             {
  283.                 for(int j1 = 0; j1 < i; j1++)
  284.                     if(barBounds != null && l < barBounds.length && j1 < barBounds[0].length && barBounds[l][j1] != null)
  285.                         arectangle[l][j1] = barBounds[l][j1];
  287.             }
  289.             barBounds = arectangle;
  290.         }
  291.         for(int k = 0; k < i; k++)
  292.         {
  293.             for(int i1 = 0; i1 < j; i1++)
  294.                 if(barBounds[i1][k] == null)
  295.                     barBounds[i1][k] = new Rectangle();
  297.         }
  299.         double d2 = 0.0D;
  300.         double d5 = rectangle1.width;
  301.         if(i > 0 && j > 0)
  302.         {
  303.             if(super.gridAlignment == 1)
  304.                 d2 = (double)rectangle1.width / (double)i;
  305.             else
  306.                 d2 = (double)rectangle1.height / (double)i;
  307.             d5 = d2 * barWidthFraction;
  308.             if(barType == 0)
  309.                 d5 /= j;
  310.         }
  311.         double d6 = d2 * (1.0D - barWidthFraction);
  312.         double d7 = 0.0D;
  313.         boolean flag = is3DModeOn();
  314.         if(super.gridAlignment == 1)
  315.         {
  316.             d7 = (double)rectangle1.x + d6 / 2D;
  317.             if(flag)
  318.                 d7 -= super.depth3dPoint.x;
  319.         } else
  320.         {
  321.             d7 = (double)rectangle1.y + d6 / 2D;
  322.             if(flag)
  323.                 d7 -= super.depth3dPoint.y;
  324.         }
  325.         if(super.gridAlignment == 1)
  326.         {
  327.             for(int k1 = 0; k1 < i; k1++)
  328.             {
  329.                 for(int i2 = 0; i2 < j; i2++)
  330.                 {
  331.                     Rectangle rectangle2 = barBounds[i2][k1];
  332.                     rectangle2.x = (int)Math.round(d7);
  333.                     rectangle2.width = (int)Math.round(d7 + d5) - rectangle2.x;
  334.                     boolean flag1 = barType == 1;
  335.                     int k2 = flag1 ? 0 : getSeriesRange(i2);
  336.                     double d8 = getSampleValue(i2, k1);
  337.                     if(d8 >= 0.0D)
  338.                     {
  339.                         double d10 = 0.0D;
  340.                         if(super.currentUpperRange[k2] != 0.0D)
  341.                             d10 = (d8 / super.currentUpperRange[k2]) * (double)(super.zeroLine[k2] - rectangle1.y);
  342.                         rectangle2.height = (int)Math.round(d10);
  343.                         rectangle2.y = super.zeroLine[k2] - rectangle2.height;
  344.                         rectangle2.height = Math.max(0, rectangle2.height);
  345.                         if(flag1 && i2 > 0)
  346.                         {
  347.                             double d14 = 0.0D;
  348.                             for(int i4 = 0; i4 < i2; i4++)
  349.                                 if(getSampleValue(i4, k1) >= 0.0D)
  350.                                     d14 += getSampleValue(i4, k1);
  352.                             double d18 = 0.0D;
  353.                             if(super.currentUpperRange[k2] != 0.0D)
  354.                                 d18 = (d14 / super.currentUpperRange[k2]) * (double)(super.zeroLine[k2] - rectangle1.y);
  355.                             double d22 = (double)super.zeroLine[k2] - d18 - d10;
  356.                             rectangle2.y = (int)Math.round(d22);
  357.                             rectangle2.height = (int)Math.round((d10 + d22) - (double)Math.round(d22));
  358.                         }
  359.                         int i3 = rectangle2.y + rectangle2.height;
  360.                         int k3 = rectangle1.y + rectangle1.height;
  361.                         if(i3 > k3)
  362.                             rectangle2.height -= i3 - k3;
  363.                     } else
  364.                     {
  365.                         double d11 = 0.0D;
  366.                         if(super.currentLowerRange[k2] != 0.0D)
  367.                             d11 = (d8 / super.currentLowerRange[k2]) * (double)((rectangle1.y + rectangle1.height) - super.zeroLine[k2]);
  368.                         rectangle2.height = (int)Math.round(d11);
  369.                         rectangle2.y = super.zeroLine[k2];
  370.                         if(flag1 && i2 > 0)
  371.                         {
  372.                             double d15 = 0.0D;
  373.                             for(int j4 = 0; j4 < i2; j4++)
  374.                                 if(getSampleValue(j4, k1) < 0.0D)
  375.                                     d15 += getSampleValue(j4, k1);
  377.                             double d19 = 0.0D;
  378.                             if(super.currentLowerRange[k2] != 0.0D)
  379.                                 d19 = (d15 / super.currentLowerRange[k2]) * (double)((rectangle1.y + rectangle1.height) - super.zeroLine[k2]);
  380.                             double d23 = (double)super.zeroLine[k2] + d19;
  381.                             rectangle2.y = (int)Math.round(d23);
  382.                             rectangle2.height = (int)Math.round((d11 + d23) - (double)Math.round(d23));
  383.                         }
  384.                         if(rectangle2.y < rectangle1.y)
  385.                         {
  386.                             rectangle2.height -= rectangle1.y - rectangle2.y;
  387.                             rectangle2.y = rectangle1.y;
  388.                         }
  389.                     }
  390.                     if(flag)
  391.                         rectangle2.y -= super.depth3dPoint.y;
  392.                     if(barType == 0 || i2 == j - 1)
  393.                         d7 += d5;
  394.                 }
  396.                 d7 += d6;
  397.             }
  399.         } else
  400.         {
  401.             for(int l1 = 0; l1 < i; l1++)
  402.             {
  403.                 for(int j2 = 0; j2 < j; j2++)
  404.                 {
  405.                     Rectangle rectangle3 = barBounds[j2][l1];
  406.                     rectangle3.y = (int)Math.round(d7);
  407.                     rectangle3.height = (int)Math.round(d7 + d5) - rectangle3.y;
  408.                     boolean flag2 = barType == 1;
  409.                     int l2 = flag2 ? 0 : getSeriesRange(j2);
  410.                     double d9 = getSampleValue(j2, l1);
  411.                     if(d9 >= 0.0D)
  412.                     {
  413.                         double d12 = 0.0D;
  414.                         if(super.currentUpperRange[l2] != 0.0D)
  415.                             d12 = (d9 / super.currentUpperRange[l2]) * (double)((rectangle1.x + rectangle1.width) - super.zeroLine[l2]);
  416.                         rectangle3.width = (int)Math.round(d12);
  417.                         rectangle3.x = super.zeroLine[l2];
  418.                         if(barType == 1 && j2 > 0)
  419.                         {
  420.                             double d16 = 0.0D;
  421.                             for(int k4 = 0; k4 < j2; k4++)
  422.                                 if(getSampleValue(k4, l1) >= 0.0D)
  423.                                     d16 += getSampleValue(k4, l1);
  425.                             double d20 = 0.0D;
  426.                             if(super.currentUpperRange[l2] != 0.0D)
  427.                                 d20 = (d16 / super.currentUpperRange[l2]) * (double)((rectangle1.x + rectangle1.width) - super.zeroLine[l2]);
  428.                             double d24 = (double)super.zeroLine[l2] + d20;
  429.                             rectangle3.x = (int)Math.round(d24);
  430.                             rectangle3.width = (int)Math.round((d12 + d24) - (double)Math.round(d24));
  431.                         }
  432.                         if(rectangle3.x < rectangle1.x)
  433.                         {
  434.                             rectangle3.width -= rectangle1.x - rectangle3.x;
  435.                             rectangle3.x = rectangle1.x;
  436.                         }
  437.                     } else
  438.                     {
  439.                         double d13 = 0.0D;
  440.                         if(super.currentLowerRange[l2] != 0.0D)
  441.                             d13 = (d9 / super.currentLowerRange[l2]) * (double)(super.zeroLine[l2] - rectangle1.x);
  442.                         rectangle3.width = (int)Math.round(d13);
  443.                         rectangle3.x = super.zeroLine[l2] - rectangle3.width;
  444.                         if(barType == 1 && j2 > 0)
  445.                         {
  446.                             double d17 = 0.0D;
  447.                             for(int l4 = 0; l4 < j2; l4++)
  448.                                 if(getSampleValue(l4, l1) < 0.0D)
  449.                                     d17 += getSampleValue(l4, l1);
  451.                             double d21 = 0.0D;
  452.                             if(super.currentLowerRange[l2] != 0.0D)
  453.                                 d21 = (d17 / super.currentLowerRange[l2]) * (double)(super.zeroLine[l2] - rectangle1.x);
  454.                             double d25 = (double)super.zeroLine[l2] - d21 - d13;
  455.                             rectangle3.x = (int)Math.round(d25);
  456.                             rectangle3.width = (int)Math.round((d13 + d25) - (double)Math.round(d25));
  457.                         }
  458.                         int j3 = rectangle3.x + rectangle3.width;
  459.                         int l3 = rectangle1.x + rectangle1.width;
  460.                         if(j3 > l3)
  461.                             rectangle3.width -= j3 - l3;
  462.                     }
  463.                     if(flag)
  464.                         rectangle3.x -= super.depth3dPoint.x;
  465.                     if(barType == 0 || j2 == j - 1)
  466.                         d7 += d5;
  467.                 }
  469.                 d7 += d6;
  470.             }
  472.         }
  473.     }
  475.     private void paintBarLabels(Graphics g, Rectangle rectangle)
  476.     {
  477.         if(!super.sampleLabelsOn || super.barLabelStyle == 1)
  478.             return;
  479.         String as[] = getBarLabels();
  480.         if(as == null)
  481.             return;
  482.         Font font = getFont("barLabelFont");
  483.         g.setFont(font);
  484.         FontMetrics fontmetrics = g.getFontMetrics();
  485.         if(super.gridAlignment == 1)
  486.         {
  487.             int i = getLabelAngle("barLabelAngle");
  488.             int k = 0;
  489.             int i1 = Math.min(as.length, getSampleCount());
  490.             for(int k1 = 0; k1 < i1; k1++)
  491.                 if(as[k1] != null)
  492.                 {
  493.                     Color color1 = getSampleLabelColor(k1);
  494.                     if(color1 != null)
  495.                         g.setColor(color1);
  496.                     else
  497.                         g.setColor(getForeground());
  498.                     Dimension dimension1 = getLabelSize(as[k1], font);
  499.                     Dimension dimension3 = getAngledLabelSize(dimension1, i);
  500.                     int i2 = barBounds[0][k1].x;
  501.                     int k2 = (barBounds[barBounds.length - 1][k1].x + barBounds[barBounds.length - 1][k1].width) - i2;
  502.                     int i3 = i2 + k2 / 2;
  503.                     if(i % 90 == 0)
  504.                         i2 = i3 - dimension3.width / 2;
  505.                     else
  506.                     if(i % 180 > 90)
  507.                         i2 = (i3 + k2 / 2) - dimension3.width;
  508.                     else
  509.                         i2 = i3 - k2 / 2;
  510.                     int k3 = rectangle.x - 2 - (is3DModeOn() ? super.depth3dPoint.x : 0);
  511.                     if(i3 >= k3 && i3 <= rectangle.x + rectangle.width + 2)
  512.                     {
  513.                         int i4 = rectangle.y + rectangle.height + 6;
  514.                         if(i % 180 == 0)
  515.                             i4 += fontmetrics.getMaxAscent() - 4;
  516.                         if(is3DModeOn())
  517.                             i4 -= super.depth3dPoint.y;
  518.                         if(super.sampleScrollerOn)
  519.                             i4 += 10;
  520.                         if(isValueLabelsOn() && valueLabelStyle == 0 && super.lowerRange[0] < 0.0D)
  521.                         {
  522.                             int k4 = rectangle.y;
  523.                             int l4 = super.zeroLine[0] - (is3DModeOn() ? super.depth3dPoint.y : 0);
  524.                             for(int i5 = 0; i5 < barBounds.length; i5++)
  525.                             {
  526.                                 int k5 = barBounds[i5][k1].y + barBounds[i5][k1].height;
  527.                                 if(k5 > k4 && k5 > l4)
  528.                                     k4 = k5;
  529.                             }
  531.                             i4 = Math.max(i4, k4 + fontmetrics.getMaxAscent() + 10);
  532.                             k4 = (rectangle.y + rectangle.height) - (is3DModeOn() ? super.depth3dPoint.y : 0);
  533.                             i4 = Math.min(i4, k4 + fontmetrics.getMaxAscent() + 10);
  534.                         }
  535.                         if(autoLabelSpacingOn)
  536.                         {
  537.                             if(as[k1] != null && as[k1].trim().length() > 0 && (i2 > k || k1 == 0))
  538.                             {
  539.                                 paintLabel(g, as[k1], i2, i4, dimension1, 0, i);
  540.                                 k = i2 + dimension3.width;
  541.                             }
  542.                         } else
  543.                         {
  544.                             paintLabel(g, as[k1], i2, i4, dimension1, 0, i);
  545.                         }
  546.                     }
  547.                 }
  549.         } else
  550.         {
  551.             int j = getLabelAngle("barLabelAngle");
  552.             int l = Math.min(as.length, getSampleCount());
  553.             for(int j1 = 0; j1 < l; j1++)
  554.                 if(as[j1] != null)
  555.                 {
  556.                     Color color = getSampleLabelColor(j1);
  557.                     if(color != null)
  558.                         g.setColor(color);
  559.                     else
  560.                         g.setColor(getForeground());
  561.                     Dimension dimension = getLabelSize(as[j1], font);
  562.                     Dimension dimension2 = getAngledLabelSize(dimension, j);
  563.                     int l1 = (barBounds[barBounds.length - 1][j1].y + barBounds[barBounds.length - 1][j1].height) - barBounds[0][j1].y;
  564.                     int j2 = barBounds[0][j1].y + l1 / 2;
  565.                     int l2 = j2 - dimension2.height / 2;
  566.                     if(j % 180 == 0)
  567.                         l2 += fontmetrics.getAscent() - 1;
  568.                     else
  569.                     if(j % 180 > 90)
  570.                         l2 = j2 - l1 / 2;
  571.                     else
  572.                         l2 = (j2 + l1 / 2) - dimension2.height;
  573.                     if(j % 180 != 0 || l2 >= rectangle.y - 2 && l2 <= (rectangle.y + rectangle.height) - (is3DModeOn() ? super.depth3dPoint.y : 0))
  574.                     {
  575.                         int j3 = rectangle.x - dimension2.width - 3;
  576.                         if(is3DModeOn())
  577.                             j3 -= super.depth3dPoint.x;
  578.                         if(super.sampleScrollerOn)
  579.                             j3 -= 10;
  580.                         if(isValueLabelsOn() && valueLabelStyle == 0 && super.lowerRange[0] < 0.0D)
  581.                         {
  582.                             int l3 = rectangle.x + rectangle.width;
  583.                             int j4 = 0;
  584.                             double d = 0.0D;
  585.                             for(int j5 = 0; j5 < barBounds.length; j5++)
  586.                                 if(getSampleValue(j5, j1) < 0.0D)
  587.                                 {
  588.                                     if(barType == 1)
  589.                                         d += getSampleValue(j5, j1);
  590.                                     else
  591.                                         d = getSampleValue(j5, j1);
  592.                                     if(barBounds[j5][j1].x < l3)
  593.                                     {
  594.                                         String s = getLabel("valueLabelPrefix");
  595.                                         String s1 = getLabel("valueLabelPostfix");
  596.                                         l3 = barBounds[j5][j1].x;
  597.                                         String s2 = formatNumber(d, getSampleDecimalCount(0));
  598.                                         s2 = s == null ? s2 : s + s2;
  599.                                         s2 = s1 == null ? s2 : s2 + s1;
  600.                                         j4 = fontmetrics.stringWidth(s2);
  601.                                     }
  602.                                 }
  604.                             j3 = Math.min(j3, l3 - j4 - dimension2.width - 3);
  605.                             l3 = rectangle.x - (is3DModeOn() ? super.depth3dPoint.x : 0);
  606.                             j3 = Math.max(j3, l3 - j4 - dimension2.width - 3);
  607.                             l3 -= super.sampleScrollerOn ? 10 : 0;
  608.                             j3 = Math.min(j3, l3 - dimension2.width - 3);
  609.                         }
  610.                         paintLabel(g, as[j1], j3, l2, dimension, 1, j);
  611.                     }
  612.                 }
  614.         }
  615.     }
  617.     private void paintFloatingLabels(Graphics g, Rectangle rectangle)
  618.     {
  619.         boolean flag = valueLabelStyle == 2 || super.barLabelStyle == 1 || super.barLabelStyle == 2;
  620.         if(flag && selectedSeries >= 0 && selectedSample >= -1)
  621.         {
  622.             Font font = getFont("floatingLabelFont");
  623.             g.setFont(font);
  624.             FontMetrics fontmetrics = g.getFontMetrics();
  625.             if(selectedSample >= 0)
  626.             {
  627.                 String s = constructFloatingLabel(selectedSeries, selectedSample, true);
  628.                 paintFloatingLabel(g, rectangle, selectedSeries, selectedSample, s, font, fontmetrics);
  629.             } else
  630.             if(isFloatingOnLegendOn())
  631.             {
  632.                 int i = getSampleCount();
  633.                 for(int j = 0; j < i; j++)
  634.                 {
  635.                     String s1 = constructFloatingLabel(selectedSeries, j, false);
  636.                     paintFloatingLabel(g, rectangle, selectedSeries, j, s1, font, fontmetrics);
  637.                 }
  639.             }
  640.         }
  641.     }
  643.     public void setMultiColorOn(boolean flag)
  644.     {
  645.         multiColorOn = flag;
  646.         super.hasChanged = true;
  647.         autoRepaint();
  648.     }
  650.     private void paintBars(Graphics g, Rectangle rectangle)
  651.     {
  652.         int i = getSeriesCount();
  653.         int j = getSampleCount();
  654.         if(rectangle.width < 0 || rectangle.height < 0)
  655.             return;
  656.         boolean flag = is3DModeOn();
  657.         if(flag)
  658.             g.setClip((rectangle.x - super.depth3dPoint.x) + 1, rectangle.y + 1, (rectangle.width + super.depth3dPoint.x) - 1, rectangle.height - super.depth3dPoint.y - 1);
  659.         else
  660.         if(super.parentChart != null && super.parentChart.is3DModeOn())
  661.             g.setClip((rectangle.x + 1) - super.parentChart.depth3dPoint.x, (rectangle.y + 1) - super.parentChart.depth3dPoint.y, rectangle.width - 1, rectangle.height - 1);
  662.         else
  663.             g.setClip(rectangle.x + 1, rectangle.y + 1, rectangle.width - 1, rectangle.height - 1);
  664.         if(super.gridAlignment == 1)
  665.         {
  666.             if(barType == 0)
  667.             {
  668.                 for(int k = 0; k < j; k++)
  669.                 {
  670.                     for(int i2 = 0; i2 < i; i2++)
  671.                         paintBar(g, i2, k);
  673.                 }
  675.             } else
  676.             {
  677.                 for(int l = 0; l < j; l++)
  678.                 {
  679.                     for(int j2 = i - 1; j2 >= 0; j2--)
  680.                         if(getSampleValue(j2, l) < 0.0D)
  681.                             paintBar(g, j2, l);
  683.                 }
  685.                 for(int i1 = 0; i1 < j; i1++)
  686.                 {
  687.                     for(int k2 = 0; k2 < i; k2++)
  688.                         if(getSampleValue(k2, i1) >= 0.0D)
  689.                             paintBar(g, k2, i1);
  691.                 }
  693.             }
  694.         } else
  695.         if(barType == 0)
  696.         {
  697.             for(int j1 = j - 1; j1 >= 0; j1--)
  698.             {
  699.                 for(int l2 = i - 1; l2 >= 0; l2--)
  700.                     paintBar(g, l2, j1);
  702.             }
  704.         } else
  705.         {
  706.             for(int k1 = j - 1; k1 >= 0; k1--)
  707.             {
  708.                 for(int i3 = i - 1; i3 >= 0; i3--)
  709.                     if(getSampleValue(i3, k1) < 0.0D)
  710.                         paintBar(g, i3, k1);
  712.             }
  714.             for(int l1 = j - 1; l1 >= 0; l1--)
  715.             {
  716.                 for(int j3 = 0; j3 < i; j3++)
  717.                     if(getSampleValue(j3, l1) >= 0.0D)
  718.                         paintBar(g, j3, l1);
  720.             }
  722.         }
  723.         if(flag)
  724.         {
  725.             g.setColor(getBackground());
  726.             Polygon polygon = new Polygon();
  727.             polygon.addPoint(rectangle.x + rectangle.width, rectangle.y + rectangle.height);
  728.             polygon.addPoint(rectangle.x + rectangle.width, ((rectangle.y + rectangle.height) - super.depth3dPoint.y) + 1);
  729.             polygon.addPoint((rectangle.x + rectangle.width) - super.depth3dPoint.x - 1, ((rectangle.y + rectangle.height) - super.depth3dPoint.y) + 1);
  730.             g.fillPolygon(polygon);
  731.             g.setColor(getChartForeground());
  732.             g.drawLine(rectangle.x + rectangle.width, rectangle.y + rectangle.height, (rectangle.x + rectangle.width) - super.depth3dPoint.x, (rectangle.y + rectangle.height) - super.depth3dPoint.y);
  733.             polygon.xpoints[0] = rectangle.x;
  734.             polygon.ypoints[0] = rectangle.y;
  735.             polygon.xpoints[1] = rectangle.x - super.depth3dPoint.x;
  736.             polygon.ypoints[1] = rectangle.y;
  737.             polygon.xpoints[2] = rectangle.x - super.depth3dPoint.x;
  738.             polygon.ypoints[2] = rectangle.y - super.depth3dPoint.y;
  739.             g.setColor(getBackground());
  740.             g.fillPolygon(polygon);
  741.             g.setColor(getChartForeground());
  742.             g.drawLine(rectangle.x, rectangle.y, rectangle.x - super.depth3dPoint.x, rectangle.y - super.depth3dPoint.y);
  743.         }
  744.     }
  746.     public void setValueLabelStyle(int i)
  747.     {
  748.         switch(i)
  749.         {
  750.         case 0: // ''
  751.         case 1: // '01'
  752.         case 2: // '02'
  753.             valueLabelStyle = i;
  754.             super.hasChanged = true;
  755.             autoRepaint();
  756.             break;
  758.         default:
  759.             throw new IllegalArgumentException("Invalid valueLabelStyle: " + i);
  760.         }
  761.     }
  763.     public int getValueLabelStyle()
  764.     {
  765.         return valueLabelStyle;
  766.     }
  768.     public boolean isMultiColorOn()
  769.     {
  770.         return multiColorOn;
  771.     }
  773.     public boolean isBarOutlineOn()
  774.     {
  775.         return barOutlineOn;
  776.     }
  778.     public ChartSample checkSelection(Point point)
  779.     {
  780.         ChartSample chartsample = null;
  781.         int i = getSeriesCount();
  782.         if(isLegendOn() && super.legendBounds != null)
  783.         {
  784.             for(int j = 0; j < super.legendBounds.length; j++)
  785.             {
  786.                 if(super.legendBounds[j] == null || !super.legendBounds[j].contains(point))
  787.                     continue;
  788.                 if(i > 1 || barType == 1 || super.multiSeriesOn)
  789.                 {
  790.                     chartsample = new ChartSample(-1);
  791.                     chartsample.setSeries(j);
  792.                 } else
  793.                 {
  794.                     chartsample = getSample(0, j);
  795.                 }
  796.                 break;
  797.             }
  799.         }
  800.         if(chartsample == null && barBounds != null)
  801.         {
  802.             for(int k = getSampleCount(); k != 0;)
  803.             {
  804.                 int l = super.gridAlignment != 0 ? k - 1 : getSampleCount() - k;
  805.                 k--;
  806.                 for(int i1 = getSeriesCount(); i1 != 0;)
  807.                 {
  808.                     int j1 = super.gridAlignment != 0 ? i1 - 1 : getSeriesCount() - i1;
  809.                     j1 = barType != 1 ? j1 : i1 - 1;
  810.                     i1--;
  811.                     Rectangle rectangle = barBounds[j1][l];
  812.                     if(rectangle != null && rectangle != null)
  813.                     {
  814.                         Rectangle rectangle1 = rectangle;
  815.                         if(barType != 1 || getSeriesCount() <= 1)
  816.                             if(super.gridAlignment == 1 && rectangle1.height < 3)
  817.                             {
  818.                                 rectangle1.y -= 3 - rectangle1.height;
  819.                                 rectangle1.height = 6;
  820.                             } else
  821.                             if(super.gridAlignment == 0 && rectangle1.width < 3)
  822.                             {
  823.                                 rectangle1.x -= 3 - rectangle1.width;
  824.                                 rectangle1.width = 6;
  825.                             }
  826.                         if(rectangle1.contains(point))
  827.                             return getSample(j1, l);
  828.                         if(is3DModeOn())
  829.                         {
  830.                             if(super.gridAlignment != 1 || barType != 1 || getSampleValues(j1)[l] > 0.0D || j1 == 0)
  831.                             {
  832.                                 Polygon polygon = new Polygon();
  833.                                 polygon.addPoint(rectangle.x, rectangle.y);
  834.                                 polygon.addPoint(polygon.xpoints[0] + super.depth3dPoint.x, polygon.ypoints[0] + super.depth3dPoint.y);
  835.                                 polygon.addPoint(polygon.xpoints[1] + rectangle.width, polygon.ypoints[1]);
  836.                                 polygon.addPoint(rectangle.x + rectangle.width, rectangle.y);
  837.                                 if(polygon.contains(point))
  838.                                     return getSample(j1, l);
  839.                             }
  840.                             if(super.gridAlignment != 0 || barType != 1 || getSampleValues(j1)[l] > 0.0D || j1 == 0)
  841.                             {
  842.                                 Polygon polygon1 = new Polygon();
  843.                                 polygon1.addPoint((rectangle.x + rectangle.width) - 1, rectangle.y);
  844.                                 polygon1.addPoint(rectangle.x + super.depth3dPoint.x + rectangle.width, rectangle.y + super.depth3dPoint.y);
  845.                                 polygon1.addPoint(rectangle.x + super.depth3dPoint.x + rectangle.width, rectangle.y + super.depth3dPoint.y + rectangle.height);
  846.                                 polygon1.addPoint((rectangle.x + rectangle.width) - 1, rectangle.y + rectangle.height);
  847.                                 if(polygon1.contains(point))
  848.                                     return getSample(j1, l);
  849.                             }
  850.                         }
  851.                     }
  852.                 }
  854.             }
  856.         }
  857.         return chartsample;
  858.     }
  860.     protected void renderData(Graphics g, Rectangle rectangle, Rectangle rectangle1)
  861.     {
  862.         paintBars(g, rectangle);
  863.         if(is3DModeOn())
  864.         {
  865.             for(int i = super.rangeOn.length - 1; i >= 0; i--)
  866.                 paint3DZeroDivider(g, rectangle, i);
  868.             if(isRangeOn(1))
  869.                 paint3DEdges(super.og, rectangle);
  870.         }
  871.         paintValueLabels(g, rectangle);
  872.     }
  874.     public void reset()
  875.     {
  876.         super.reset();
  877.         multiColorOn = false;
  878.         super.barLabelStyle = 0;
  879.         valueLabelStyle = 0;
  880.         barOutlineOn = true;
  881.         autoLabelSpacingOn = false;
  882.         barWidthFraction = 0.40000000000000002D;
  883.         barType = 0;
  884.         super.multiSeriesOn = false;
  885.         barWidthFraction = 0.40000000000000002D;
  886.         selectedSeries = -1;
  887.         selectedSample = -1;
  888.         barOutlineColor = null;
  889.     }
  891.     public BarChart()
  892.     {
  893.         this(1);
  894.     }
  896.     public BarChart(int i)
  897.     {
  898.         this(i, 100D);
  899.     }
  901.     public BarChart(int i, double d)
  902.     {
  903.         this(i, d, 0.0D);
  904.     }
  906.     public BarChart(int i, double d, double d1)
  907.     {
  908.         this(1, i, d, d1);
  909.     }
  911.     public BarChart(int i, int j, double d, double d1)
  912.     {
  913.         super(j);
  914.         super.chartType = "bar";
  915.         setAutomaticRepaintOn(false);
  916.         setSeriesCount(i);
  917.         super.upperRange[0] = super.currentUpperRange[0] = d;
  918.         super.lowerRange[0] = super.currentLowerRange[0] = d1;
  919.         mousePosition = new Point();
  920.         setAutomaticRepaintOn(true);
  921.     }
  923.     public boolean isBarLabelsOn()
  924.     {
  925.         return super.sampleLabelsOn;
  926.     }
  928.     public boolean isAutoLabelSpacingOn()
  929.     {
  930.         return autoLabelSpacingOn;
  931.     }
  933.     public void setMultiSeriesOn(boolean flag)
  934.     {
  935.         super.multiSeriesOn = flag;
  936.         super.hasChanged = true;
  937.         autoRepaint();
  938.     }
  940.     private String constructFloatingLabel(int i, int j, boolean flag)
  941.     {
  942.         if(i < 0 || i >= getSeriesCount() || j < 0 || j >= getSampleCount())
  943.             return "";
  944.         String s = "";
  945.         if(super.sampleLabelsOn && (super.barLabelStyle == 1 || super.barLabelStyle == 2))
  946.             if(getSeriesCount() == 1)
  947.             {
  948.                 if(getSampleLabel(j) != null)
  949.                     s += getSampleLabel(j);
  950.             } else
  951.             {
  952.                 String s1 = getSeriesLabel(i);
  953.                 if(flag && s1 != null)
  954.                     if(s1.endsWith("n"))
  955.                         s += s1;
  956.                     else
  957.                         s += s1 + " : ";
  958.                 if(getSampleLabel(j) != null)
  959.                     s += getSampleLabel(j);
  960.             }
  961.         if(isValueLabelsOn() && valueLabelStyle == 2)
  962.         {
  963.             String s2 = getLabel("valueLabelPrefix_" + i);
  964.             if(s2 == null)
  965.                 s2 = getLabel("valueLabelPrefix");
  966.             String s3 = getLabel("valueLabelPostfix_" + i);
  967.             if(s3 == null)
  968.                 s3 = getLabel("valueLabelPostfix");
  969.             if(s.length() > 0)
  970.             {
  971.                 String s4 = formatNumber(getSampleValue(i, j), getSampleDecimalCount(i));
  972.                 s4 = s2 == null ? s4 : s2 + s4;
  973.                 s4 = s3 == null ? s4 : s4 + s3;
  974.                 if(s.endsWith("n"))
  975.                     s += s4;
  976.                 else
  977.                     s = s + " : " + s4;
  978.             } else
  979.             {
  980.                 s = formatNumber(getSampleValue(i, j), getSampleDecimalCount(i));
  981.                 s = s2 == null ? s : s2 + s;
  982.                 s = s3 == null ? s : s + s3;
  983.             }
  984.         }
  985.         return s;
  986.     }
  988.     private void paintValueLabels(Graphics g, Rectangle rectangle)
  989.     {
  990.         g.setClip(0, 0, 32767, 32767);
  991.         int i = getSampleCount();
  992.         int j = getSeriesCount();
  993.         if(i == 0 || j == 0 || valueLabelStyle == 2)
  994.             return;
  995.         Font font = getFont("valueLabelFont");
  996.         getSize();
  997.         g.setFont(font);
  998.         FontMetrics fontmetrics = g.getFontMetrics();
  999.         boolean flag = is3DModeOn();
  1000.         int k = rectangle.y;
  1001.         int l = (k + rectangle.height) - (flag ? super.depth3dPoint.y : 0);
  1002.         int i1 = rectangle.x - (flag ? super.depth3dPoint.x : 0);
  1003.         int j1 = rectangle.x + rectangle.width;
  1004.         getChartBackground();
  1005.         int k1 = getLabelAngle("valueLabelAngle");
  1006.         int l1 = fontmetrics.getHeight();
  1007.         int i2 = fontmetrics.getDescent();
  1008.         int j2 = fontmetrics.getAscent();
  1009.         if(valueLabelStyle == 0 && j > 1 && barType == 1)
  1010.         {
  1011.             if(!isValueLabelsOn(0))
  1012.                 return;
  1013.             int k2 = getSampleDecimalCount(0);
  1014.             String s = getLabel("valueLabelPrefix");
  1015.             String s1 = getLabel("valueLabelPostfix");
  1016.             for(int j3 = 0; j3 < i; j3++)
  1017.             {
  1018.                 double d = 0.0D;
  1019.                 double d2 = 0.0D;
  1020.                 boolean flag1 = false;
  1021.                 for(int l3 = 0; l3 < j; l3++)
  1022.                 {
  1023.                     ChartSample chartsample1 = getSample(l3, j3);
  1024.                     if(chartsample1 != null && chartsample1.value != null)
  1025.                     {
  1026.                         flag1 = true;
  1027.                         double d3 = chartsample1.getFloatValue();
  1028.                         if(d3 >= 0.0D)
  1029.                             d += d3;
  1030.                         else
  1031.                             d2 += d3;
  1032.                     }
  1033.                 }
  1035.                 if(flag1)
  1036.                 {
  1037.                     String s5 = formatNumber(d, k2);
  1038.                     s5 = s == null ? s5 : s + s5;
  1039.                     s5 = s1 == null ? s5 : s5 + s1;
  1040.                     Dimension dimension1 = getLabelSize(s5, font);
  1041.                     Dimension dimension3 = getAngledLabelSize(dimension1, k1);
  1042.                     int i4 = fontmetrics.stringWidth(s5);
  1043.                     String s6 = formatNumber(d2, k2);
  1044.                     s6 = s == null ? s6 : s + s6;
  1045.                     s6 = s1 == null ? s6 : s6 + s1;
  1046.                     Dimension dimension4 = getLabelSize(s6, font);
  1047.                     Dimension dimension5 = getAngledLabelSize(dimension4, k1);
  1048.                     int l4 = fontmetrics.stringWidth(s6);
  1049.                     Rectangle rectangle2 = barBounds[0][j3];
  1050.                     Rectangle rectangle3 = barBounds[0][j3];
  1051.                     for(int i5 = 0; i5 < barBounds.length; i5++)
  1052.                     {
  1053.                         Rectangle rectangle4 = barBounds[i5][j3];
  1054.                         if(rectangle4 != null)
  1055.                             if(super.gridAlignment == 1)
  1056.                             {
  1057.                                 if(rectangle4.y < rectangle2.y)
  1058.                                     rectangle2 = rectangle4;
  1059.                                 if(rectangle4.y + rectangle4.height > rectangle3.y + rectangle3.height)
  1060.                                     rectangle3 = rectangle4;
  1061.                             } else
  1062.                             {
  1063.                                 if(rectangle4.x + rectangle4.width > rectangle2.x + rectangle2.width)
  1064.                                     rectangle2 = rectangle4;
  1065.                                 if(rectangle4.x < rectangle3.x)
  1066.                                     rectangle3 = rectangle4;
  1067.                             }
  1068.                     }
  1070.                     int j5 = (rectangle2.x + rectangle2.width / 2) - dimension3.width / 2;
  1071.                     int k5 = rectangle2.y - 2;
  1072.                     if(k1 % 180 != 0)
  1073.                         k5 -= dimension3.height;
  1074.                     int l5 = (rectangle3.x + rectangle3.width / 2) - dimension5.width / 2;
  1075.                     int i6 = (rectangle3.y + rectangle3.height + l1) - i2;
  1076.                     if(k1 % 180 != 0)
  1077.                         i6 = rectangle3.y + rectangle3.height + 2;
  1078.                     if(super.gridAlignment == 0)
  1079.                     {
  1080.                         j5 = rectangle2.x + rectangle2.width + 2;
  1081.                         k5 = ((rectangle2.y + rectangle2.height / 2 + l1 / 2) - i2) + 1;
  1082.                         l5 = rectangle3.x - l4 - 1;
  1083.                         i6 = k5;
  1084.                     }
  1085.                     if(flag)
  1086.                         if(super.gridAlignment == 1)
  1087.                         {
  1088.                             j5 += super.depth3dPoint.x;
  1089.                             k5 += super.depth3dPoint.y;
  1090.                         } else
  1091.                         {
  1092.                             j5 += super.depth3dPoint.x;
  1093.                             k5 += super.depth3dPoint.y;
  1094.                         }
  1095.                     if(super.gridAlignment == 1)
  1096.                     {
  1097.                         if(k1 % 180 == 0)
  1098.                         {
  1099.                             k5 = Math.max(k5, rectangle.y - 2);
  1100.                             k5 = Math.min((rectangle.y + rectangle.height) - 2, k5);
  1101.                             i6 = Math.max((rectangle.y + j2) - (flag ? super.depth3dPoint.y : 0), i6);
  1102.                             i6 = Math.min((rectangle.y + rectangle.height + j2) - (flag ? super.depth3dPoint.y : 0), i6);
  1103.                         } else
  1104.                         {
  1105.                             k5 = Math.max(k5, rectangle.y - dimension3.height - 2);
  1106.                             k5 = Math.min(k5, (rectangle.y + rectangle.height) - dimension3.height - 2);
  1107.                             i6 = Math.min(i6, (rectangle.y + rectangle.height + 2) - (flag ? super.depth3dPoint.y : 0));
  1108.                             i6 = Math.max(i6, (rectangle.y + 2) - (flag ? super.depth3dPoint.y : 0));
  1109.                         }
  1110.                     } else
  1111.                     {
  1112.                         j5 = Math.min(rectangle.x + rectangle.width + 2, j5);
  1113.                         j5 = Math.max(rectangle.x + 2, j5);
  1114.                         l5 = Math.max(rectangle.x - l4 - 1 - (flag ? super.depth3dPoint.x : 0), l5);
  1115.                         l5 = Math.min((rectangle.x + rectangle.width) - l4 - 1 - (flag ? super.depth3dPoint.x : 0), l5);
  1116.                     }
  1117.                     boolean flag3 = true;
  1118.                     boolean flag4 = true;
  1119.                     if(super.gridAlignment == 1)
  1120.                     {
  1121.                         if(j5 + i4 / 2 < i1 - 3 || j5 + i4 / 2 > j1 + 3)
  1122.                             flag3 = false;
  1123.                         if(l5 + l4 / 2 < i1 - 3 || l5 + l4 / 2 > j1 + 3)
  1124.                             flag4 = false;
  1125.                     } else
  1126.                     {
  1127.                         if(k5 - l1 / 2 < k - 3 || k5 - l1 / 2 > l)
  1128.                             flag3 = false;
  1129.                         if(i6 - l1 / 2 < k - 3 || i6 - l1 / 2 > l)
  1130.                             flag4 = false;
  1131.                     }
  1132.                     g.setColor(getForeground());
  1133.                     if(d >= 0.0D && super.upperRange[0] > 0.0D && flag3 && (d != 0.0D || d2 >= 0.0D))
  1134.                         paintLabel(g, s5, j5, k5, dimension1, 0, super.gridAlignment != 1 ? 0 : k1);
  1135.                     if(d2 < 0.0D && super.lowerRange[0] < 0.0D && flag4)
  1136.                         paintLabel(g, s6, l5, i6, dimension4, 0, super.gridAlignment != 1 ? 0 : k1);
  1137.                 }
  1138.             }
  1140.         } else
  1141.         if(valueLabelStyle == 0 || valueLabelStyle == 1)
  1142.         {
  1143.             for(int l2 = 0; l2 < i; l2++)
  1144.             {
  1145.                 for(int i3 = 0; i3 < j; i3++)
  1146.                 {
  1147.                     ChartSample chartsample = getSample(i3, l2);
  1148.                     if(chartsample != null && chartsample.value != null && !chartsample.value.isNaN() && isValueLabelsOn(i3))
  1149.                     {
  1150.                         String s2 = getLabel("valueLabelPrefix_" + i3);
  1151.                         if(s2 == null)
  1152.                             s2 = getLabel("valueLabelPrefix");
  1153.                         String s3 = getLabel("valueLabelPostfix_" + i3);
  1154.                         if(s3 == null)
  1155.                             s3 = getLabel("valueLabelPostfix");
  1156.                         double d1 = chartsample.getFloatValue();
  1157.                         int k3 = getSampleDecimalCount(i3);
  1158.                         String s4 = formatNumber(d1, k3);
  1159.                         s4 = s2 == null ? s4 : s2 + s4;
  1160.                         s4 = s3 == null ? s4 : s4 + s3;
  1161.                         Dimension dimension = getLabelSize(s4, font);
  1162.                         Dimension dimension2 = getAngledLabelSize(dimension, k1);
  1163.                         Rectangle rectangle1 = barBounds[i3][l2];
  1164.                         int j4 = 0;
  1165.                         int k4 = 0;
  1166.                         boolean flag2 = true;
  1167.                         if(valueLabelStyle == 0)
  1168.                         {
  1169.                             if(super.gridAlignment == 1)
  1170.                             {
  1171.                                 j4 = (rectangle1.x + rectangle1.width / 2) - dimension2.width / 2;
  1172.                                 if(d1 >= 0.0D)
  1173.                                 {
  1174.                                     if(k1 % 180 == 0)
  1175.                                     {
  1176.                                         k4 = rectangle1.y - 2;
  1177.                                         k4 = Math.max(k - 2, k4);
  1178.                                         k4 = Math.min(l - 1, k4);
  1179.                                     } else
  1180.                                     {
  1181.                                         k4 = rectangle1.y - 2 - dimension2.height;
  1182.                                         k4 = Math.max(k4, k - dimension2.height - 2);
  1183.                                         k4 = Math.min(k4, l - dimension2.height - 2);
  1184.                                     }
  1185.                                     if(k1 % 180 > 0 && k1 % 180 < 90)
  1186.                                         j4 = ((rectangle1.x + rectangle1.width) - dimension2.width) + 1;
  1187.                                     else
  1188.                                     if(k1 % 180 > 90)
  1189.                                         j4 = rectangle1.x - 1;
  1190.                                     if(flag && j == 1)
  1191.                                     {
  1192.                                         k4 += super.depth3dPoint.y;
  1193.                                         j4 += super.depth3dPoint.x;
  1194.                                         if(k1 % 180 == 0)
  1195.                                             k4 = Math.max(k - 2, k4);
  1196.                                         else
  1197.                                             k4 = Math.max(k - dimension2.height - 2, k4);
  1198.                                     }
  1199.                                 } else
  1200.                                 {
  1201.                                     if(k1 % 180 == 0)
  1202.                                     {
  1203.                                         k4 = rectangle1.y + rectangle1.height + j2;
  1204.                                         k4 = Math.min(l + j2, k4);
  1205.                                         if(flag)
  1206.                                             k4 = Math.max((k - super.depth3dPoint.y) + j2, k4);
  1207.                                         else
  1208.                                             k4 = Math.max(k + j2, k4);
  1209.                                     } else
  1210.                                     {
  1211.                                         k4 = rectangle1.y + rectangle1.height + 3;
  1212.                                         k4 = Math.min(l + 3, k4);
  1213.                                         if(flag)
  1214.                                             k4 = Math.max((k - super.depth3dPoint.y) + 2, k4);
  1215.                                         else
  1216.                                             k4 = Math.max(k + 2, k4);
  1217.                                     }
  1218.                                     if(k1 % 180 > 0 && k1 % 180 < 90)
  1219.                                         j4 = rectangle1.x - 1;
  1220.                                     else
  1221.                                     if(k1 % 180 > 90)
  1222.                                         j4 = ((rectangle1.x + rectangle1.width) - dimension2.width) + 1;
  1223.                                 }
  1224.                             } else
  1225.                             {
  1226.                                 if(d1 >= 0.0D)
  1227.                                 {
  1228.                                     j4 = rectangle1.x + rectangle1.width + 3;
  1229.                                     j4 = Math.min(rectangle.x + rectangle.width + 3, j4);
  1230.                                     j4 = Math.max(i1 + 3, j4);
  1231.                                 } else
  1232.                                 {
  1233.                                     j4 = rectangle1.x - dimension.width - 3;
  1234.                                     j4 = Math.max(i1 - dimension.width - 3, j4);
  1235.                                     j4 = Math.min((i1 + rectangle.width) - dimension.width - 3, j4);
  1236.                                 }
  1237.                                 k4 = ((rectangle1.y + rectangle1.height / 2 + l1 / 2) - i2) + 1;
  1238.                                 if(flag && j == 1 && d1 >= 0.0D)
  1239.                                 {
  1240.                                     k4 += super.depth3dPoint.y;
  1241.                                     j4 += super.depth3dPoint.x;
  1242.                                     j4 = Math.min(rectangle.x + rectangle.width + 3, j4);
  1243.                                 }
  1244.                             }
  1245.                         } else
  1246.                         if(super.gridAlignment == 1)
  1247.                         {
  1248.                             j4 = ((rectangle1.x + rectangle1.width / 2) - dimension2.width / 2) + 1;
  1249.                             if(d1 >= 0.0D)
  1250.                             {
  1251.                                 if(k1 % 180 == 0)
  1252.                                 {
  1253.                                     k4 = rectangle1.y + fontmetrics.getAscent();
  1254.                                     k4 = Math.max(k4, (rectangle.y + dimension2.height) - 1);
  1255.                                     k4 = Math.min(k4, (rectangle.y + rectangle.height) - 2);
  1256.                                 } else
  1257.                                 {
  1258.                                     k4 = rectangle1.y + 3;
  1259.                                     k4 = Math.min(k4, (rectangle1.y + rectangle1.height) - dimension2.height - 2);
  1260.                                     k4 = Math.max(k4, rectangle.y + 3);
  1261.                                 }
  1262.                             } else
  1263.                             if(k1 % 180 == 0)
  1264.                             {
  1265.                                 k4 = (rectangle1.y + rectangle1.height) - 2;
  1266.                                 k4 = Math.min(k4, (rectangle.y + rectangle.height) - 2 - (flag ? super.depth3dPoint.y : 0));
  1267.                                 k4 = Math.max(k4, (rectangle.y + dimension2.height) - 1);
  1268.                             } else
  1269.                             {
  1270.                                 k4 = (rectangle1.y + rectangle1.height) - dimension2.height - 2;
  1271.                                 k4 = Math.min(k4, (rectangle.y + rectangle.height) - dimension2.height - 2 - (flag ? super.depth3dPoint.y : 0));
  1272.                                 k4 = Math.max(k4, (rectangle.y + 3) - (flag ? super.depth3dPoint.y : 0));
  1273.                             }
  1274.                             if(barType == 1 && j > 1)
  1275.                                 flag2 = dimension2.height < rectangle1.height;
  1276.                         } else
  1277.                         {
  1278.                             k4 = ((rectangle1.y + rectangle1.height / 2 + l1 / 2) - i2) + 1;
  1279.                             if(d1 >= 0.0D)
  1280.                             {
  1281.                                 j4 = (rectangle1.x + rectangle1.width) - dimension.width - 1;
  1282.                                 j4 = Math.max(j4, rectangle1.x + 2);
  1283.                                 j4 = Math.min(j4, (rectangle.x + rectangle.width) - dimension.width - 1);
  1284.                             } else
  1285.                             {
  1286.                                 j4 = rectangle1.x + 2;
  1287.                                 j4 = Math.max(j4, (rectangle.x + 2) - (flag ? super.depth3dPoint.x : 0));
  1288.                                 j4 = Math.min(j4, (rectangle.x + rectangle.width) - dimension.width - 1 - (flag ? super.depth3dPoint.x : 0));
  1289.                             }
  1290.                             if(barType == 1 && j > 1)
  1291.                                 flag2 = dimension2.width < rectangle1.width;
  1292.                         }
  1293.                         Object obj = null;
  1294.                         if(valueLabelStyle == 0)
  1295.                         {
  1296.                             g.setColor(getForeground());
  1297.                             Color color = getChartBackground();
  1298.                         } else
  1299.                         {
  1300.                             Color color2 = getSampleColor(0);
  1301.                             if(multiColorOn)
  1302.                                 if(j > 1 || barType == 1 || super.multiSeriesOn)
  1303.                                     color2 = getSampleColor(i3);
  1304.                                 else
  1305.                                     color2 = getSampleColor(l2);
  1306.                             if((color2.getRed() + color2.getGreen() + color2.getBlue()) / 3 > 110)
  1307.                                 g.setColor(Color.black);
  1308.                             else
  1309.                                 g.setColor(Color.white);
  1310.                             Color color1 = color2;
  1311.                         }
  1312.                         if(super.gridAlignment == 1)
  1313.                         {
  1314.                             if(j4 + dimension2.width / 2 < i1 - 3 || j4 + dimension2.width / 2 > j1 + 3)
  1315.                                 flag2 = false;
  1316.                         } else
  1317.                         if(k4 - l1 / 2 < k - 3 || k4 - l1 / 2 > l)
  1318.                             flag2 = false;
  1319.                         if(flag2)
  1320.                             paintLabel(g, s4, j4, k4, dimension, 0, super.gridAlignment != 1 ? 0 : k1);
  1321.                     }
  1322.                 }
  1324.             }
  1326.         }
  1327.     }
  1329.     public void setBarWidth(double d)
  1330.     {
  1331.         d = Math.max(0.0D, d);
  1332.         d = Math.min(1.0D, d);
  1333.         barWidthFraction = d;
  1334.         super.hasChanged = true;
  1335.         autoRepaint();
  1336.     }
  1338.     public double getBarWidth()
  1339.     {
  1340.         return barWidthFraction;
  1341.     }
  1343.     public void setBarLabelStyle(int i)
  1344.     {
  1345.         switch(i)
  1346.         {
  1347.         case 0: // ''
  1348.         case 1: // '01'
  1349.         case 2: // '02'
  1350.             super.barLabelStyle = i;
  1351.             super.hasChanged = true;
  1352.             autoRepaint();
  1353.             break;
  1355.         default:
  1356.             throw new IllegalArgumentException("Invalid barLabelStyle: " + i);
  1357.         }
  1358.     }
  1360.     public int getBarLabelStyle()
  1361.     {
  1362.         return super.barLabelStyle;
  1363.     }
  1365.     public void render(Graphics g)
  1366.     {
  1367.         render(g, !isServletModeOn());
  1368.     }
  1370.     void render(Graphics g, boolean flag)
  1371.     {
  1372.         Rectangle rectangle = getGraphBounds();
  1373.         Rectangle rectangle1 = getDataBounds(rectangle);
  1374.         calculateChartData(rectangle, rectangle1);
  1375.         for(int i = 0; i < super.overlayCharts.size(); i++)
  1376.         {
  1377.             Chart chart = (Chart)super.overlayCharts.elementAt(i);
  1378.             if(chart != null && isOverlayChartOn(i))
  1379.             {
  1380.                 Rectangle rectangle2 = new Rectangle(rectangle);
  1381.                 Rectangle rectangle3 = new Rectangle(rectangle1);
  1382.                 if(is3DModeOn())
  1383.                 {
  1384.                     rectangle2.x -= super.depth3dPoint.x;
  1385.                     rectangle2.y -= super.depth3dPoint.y;
  1386.                     rectangle3.x -= super.depth3dPoint.x;
  1387.                     rectangle3.y -= super.depth3dPoint.y;
  1388.                 }
  1389.                 chart.calculateChartData(rectangle2, rectangle3);
  1390.             }
  1391.         }
  1393.         Dimension dimension = getSize();
  1394.         if(flag && super.offscreen == null)
  1395.         {
  1396.             super.offscreen = createImage(Math.max(1, dimension.width), Math.max(1, dimension.height));
  1397.             super.hasChanged = true;
  1398.         }
  1399.         if(!flag || super.hasChanged || super.offscreen == null)
  1400.         {
  1401.             if(!super.externalGraphicsOn && !flag)
  1402.                 super.og = g;
  1403.             else
  1404.             if(flag || super.externalGraphicsOn)
  1405.             {
  1406.                 if(!super.externalGraphicsOn && super.offscreen != null)
  1407.                     super.og = super.offscreen.getGraphics();
  1408.                 super.og.setColor(getBackground());
  1409.                 super.og.fillRect(0, 0, dimension.width, dimension.height);
  1410.             }
  1411.             paintTitle(super.og, dimension);
  1412.             if(isLegendOn())
  1413.                 paintLegend(super.og, rectangle, getLegendLabels());
  1414.             paintGrid(super.og, rectangle);
  1415.             paintBarLabels(super.og, rectangle);
  1416.             if(super.upperRange != super.lowerRange)
  1417.             {
  1418.                 renderData(super.og, rectangle, rectangle1);
  1419.                 for(int j = 0; j < super.overlayCharts.size(); j++)
  1420.                 {
  1421.                     Chart chart1 = (Chart)super.overlayCharts.elementAt(j);
  1422.                     if(chart1 != null && isOverlayChartOn(j))
  1423.                     {
  1424.                         Rectangle rectangle4 = new Rectangle(rectangle);
  1425.                         Rectangle rectangle5 = new Rectangle(rectangle1);
  1426.                         rectangle4.x -= super.depth3dPoint.x;
  1427.                         rectangle4.y -= super.depth3dPoint.y;
  1428.                         rectangle5.x -= super.depth3dPoint.x;
  1429.                         rectangle5.y -= super.depth3dPoint.y;
  1430.                         if(chart1 instanceof LineChart)
  1431.                             chart1.renderData(super.og, rectangle4, getLineChartBounds(rectangle5));
  1432.                         else
  1433.                         if(chart1 instanceof PieChart)
  1434.                             chart1.renderData(super.og, rectangle4, rectangle5);
  1435.                         else
  1436.                             chart1.renderData(super.og, rectangle, rectangle1);
  1437.                     }
  1438.                 }
  1440.             }
  1441.             if(!super.externalGraphicsOn && super.og != g)
  1442.                 super.og.dispose();
  1443.             super.hasChanged = false;
  1444.         }
  1445.         if((flag || super.externalGraphicsOn) && super.offscreen != null)
  1446.             g.drawImage(super.offscreen, 0, 0, this);
  1447.         paintFloatingLabels(g, rectangle);
  1448.     }
  1450.     private void paint3DBar(Graphics g, Rectangle rectangle, boolean flag, double d)
  1451.     {
  1452.         Polygon polygon = new Polygon();
  1453.         polygon.addPoint(rectangle.x, rectangle.y);
  1454.         polygon.addPoint(polygon.xpoints[0] + super.depth3dPoint.x, polygon.ypoints[0] + super.depth3dPoint.y);
  1455.         polygon.addPoint(polygon.xpoints[1] + rectangle.width, polygon.ypoints[1]);
  1456.         polygon.addPoint(rectangle.x + rectangle.width, rectangle.y);
  1457.         Polygon polygon1 = new Polygon();
  1458.         polygon1.addPoint(rectangle.x + rectangle.width, rectangle.y);
  1459.         polygon1.addPoint(polygon.xpoints[2], polygon.ypoints[2]);
  1460.         polygon1.addPoint(polygon.xpoints[2], polygon.ypoints[2] + rectangle.height);
  1461.         polygon1.addPoint(rectangle.x + rectangle.width, rectangle.y + rectangle.height);
  1462.         g.setColor(g.getColor().darker());
  1463.         g.fillPolygon(polygon);
  1464.         g.setColor(g.getColor().darker());
  1465.         g.fillPolygon(polygon1);
  1466.         if(barOutlineOn)
  1467.         {
  1468.             if(barOutlineColor != null)
  1469.                 g.setColor(barOutlineColor);
  1470.             else
  1471.                 g.setColor(getChartForeground());
  1472.             g.drawPolygon(polygon);
  1473.             g.drawPolygon(polygon1);
  1474.             if(flag)
  1475.             {
  1476.                 g.drawLine(polygon1.xpoints[1] - 1, polygon1.ypoints[1] + 1, polygon1.xpoints[2] - 1, polygon1.ypoints[2]);
  1477.                 g.drawLine(polygon.xpoints[1], polygon.ypoints[1] + 1, polygon.xpoints[2] - 1, polygon.ypoints[2] + 1);
  1478.                 if(super.gridAlignment == 1)
  1479.                 {
  1480.                     g.drawLine(polygon1.xpoints[2] - 1, polygon1.ypoints[2], polygon1.xpoints[3] - 1, polygon1.ypoints[3]);
  1481.                     g.drawLine(polygon.xpoints[0] + 1, polygon.ypoints[0], polygon.xpoints[1] + 1, polygon.ypoints[1]);
  1482.                     if(rectangle.height != 0)
  1483.                         g.drawLine(polygon1.xpoints[0], polygon1.ypoints[0] + 1, polygon1.xpoints[1], polygon1.ypoints[1] + 1);
  1484.                     else
  1485.                         g.drawLine(polygon.xpoints[3] - 1, polygon.ypoints[3] - 1, polygon.xpoints[0] + 1, polygon.ypoints[0] - 1);
  1486.                 } else
  1487.                 {
  1488.                     g.drawLine(polygon1.xpoints[2], polygon1.ypoints[2] - 1, polygon1.xpoints[3], polygon1.ypoints[3] - 1);
  1489.                     g.drawLine(polygon.xpoints[0], polygon.ypoints[0] + 1, polygon.xpoints[1], polygon.ypoints[1] + 1);
  1490.                     if(rectangle.width != 0)
  1491.                         g.drawLine(polygon.xpoints[2] - 1, polygon.ypoints[2], polygon.xpoints[3] - 1, polygon.ypoints[3]);
  1492.                     else
  1493.                         g.drawLine(polygon1.xpoints[3] + 1, polygon1.ypoints[3] - 1, polygon1.xpoints[0] + 1, polygon1.ypoints[0] + 1);
  1494.                 }
  1495.             }
  1496.         } else
  1497.         if(flag)
  1498.         {
  1499.             if(barOutlineColor != null)
  1500.                 g.setColor(barOutlineColor);
  1501.             else
  1502.                 g.setColor(getChartForeground());
  1503.             g.drawPolygon(polygon);
  1504.             g.drawLine(polygon1.xpoints[1], polygon1.ypoints[1], polygon1.xpoints[2], polygon1.ypoints[2]);
  1505.             if(super.gridAlignment == 1)
  1506.             {
  1507.                 g.drawLine(polygon1.xpoints[2], polygon1.ypoints[2], polygon1.xpoints[3], polygon1.ypoints[3]);
  1508.             } else
  1509.             {
  1510.                 g.drawLine(polygon1.xpoints[2], polygon1.ypoints[2] - 1, polygon1.xpoints[3], polygon1.ypoints[3] - 1);
  1511.                 g.drawLine(polygon1.xpoints[3] - 1, polygon1.ypoints[3] - 1, polygon1.xpoints[0] - 1, polygon1.ypoints[0]);
  1512.             }
  1513.         }
  1514.     }
  1516.     public int getValuePosition(double d)
  1517.     {
  1518.         return getValuePosition(0, d, getGraphBounds());
  1519.     }
  1521.     public void setBarOutlineOn(boolean flag)
  1522.     {
  1523.         barOutlineOn = flag;
  1524.         super.hasChanged = true;
  1525.         autoRepaint();
  1526.     }
  1528.     public boolean isMultiSeriesOn()
  1529.     {
  1530.         return super.multiSeriesOn;
  1531.     }
  1533.     private void paint3DZeroDivider(Graphics g, Rectangle rectangle, int i)
  1534.     {
  1535.         i = Math.min(super.rangeOn.length - 1, Math.max(0, i));
  1536.         if(!super.rangeOn[i])
  1537.             return;
  1538.         g.setColor(i != 0 ? getRangeColor(i) : getChartForeground());
  1539.         if(super.gridAlignment == 1)
  1540.         {
  1541.             int j = Math.max(super.zeroLine[i], rectangle.y);
  1542.             j = Math.min(j, rectangle.y + rectangle.height);
  1543.             int l = rectangle.x - super.depth3dPoint.x;
  1544.             int j1 = j - super.depth3dPoint.y;
  1545.             g.drawLine(l, j1, l + rectangle.width, j1);
  1546.             g.drawLine(l + rectangle.width, j1, rectangle.x + rectangle.width, j);
  1547.         } else
  1548.         {
  1549.             int k = Math.max(super.zeroLine[i], rectangle.x);
  1550.             k = Math.min(k, rectangle.x + rectangle.width);
  1551.             int i1 = rectangle.y - super.depth3dPoint.y;
  1552.             int k1 = k - super.depth3dPoint.x;
  1553.             g.drawLine(k1, i1, k1, i1 + rectangle.height);
  1554.             g.drawLine(k1, i1, k, rectangle.y);
  1555.         }
  1556.     }
  1558.     private Rectangle getLineChartBounds(Rectangle rectangle)
  1559.     {
  1560.         Rectangle rectangle1 = new Rectangle(rectangle);
  1561.         int i = barType != 1 ? getSeriesCount() : 1;
  1562.         if(barBounds != null && barBounds.length > 0 && barBounds[0] != null && barBounds[0].length > 0)
  1563.         {
  1564.             int j = (barBounds[0][0].x + (barBounds[0][0].width * i) / 2) - rectangle.x;
  1565.             rectangle1.x += j;
  1566.             rectangle1.width -= j * 2;
  1567.         }
  1568.         return rectangle1;
  1569.     }
  1571.     public Rectangle getGraphBounds()
  1572.     {
  1573.         if(!super.hasChanged && super.currentBounds != null)
  1574.             return super.currentBounds;
  1575.         Rectangle rectangle = super.getGraphBounds(getLegendLabels());
  1576.         Dimension dimension = getSize();
  1577.         int i = rectangle.x;
  1578.         int j = dimension.width - rectangle.width - rectangle.x;
  1579.         int k = rectangle.y;
  1580.         int l = dimension.height - rectangle.height - rectangle.y;
  1581.         for(int i1 = 0; i1 < super.rangeAdjusterOn.length; i1++)
  1582.             if(super.rangeAdjusterOn[i1])
  1583.                 if(super.gridAlignment == 1)
  1584.                 {
  1585.                     if(super.rangeAdjusterPosition[i1] == 0)
  1586.                         i += 6;
  1587.                     else
  1588.                         j += 6;
  1589.                 } else
  1590.                 if(super.rangeAdjusterPosition[i1] == 0)
  1591.                     l += 6;
  1592.                 else
  1593.                     k += 6;
  1595.         if(super.sampleLabelsOn && (super.barLabelStyle == 0 || super.barLabelStyle == 2))
  1596.         {
  1597.             Font font = getFont("barLabelFont");
  1598.             FontMetrics fontmetrics = getFontMetrics(font);
  1599.             int k1 = getLabelAngle("barLabelAngle");
  1600.             if(super.gridAlignment == 1)
  1601.             {
  1602.                 int k2 = 0;
  1603.                 String as[] = getBarLabels();
  1604.                 for(int l4 = 0; l4 < as.length; l4++)
  1605.                 {
  1606.                     Dimension dimension3 = getLabelSize(as[l4], font);
  1607.                     Dimension dimension5 = getAngledLabelSize(dimension3, k1);
  1608.                     k2 = Math.max(dimension5.height, k2);
  1609.                 }
  1611.                 l += k2;
  1612.                 if(k1 % 180 == 0)
  1613.                     l -= fontmetrics.getMaxDescent();
  1614.             } else
  1615.             {
  1616.                 int l2 = 0;
  1617.                 String as1[] = getBarLabels();
  1618.                 for(int i5 = 0; i5 < as1.length; i5++)
  1619.                 {
  1620.                     Dimension dimension4 = getLabelSize(as1[i5], font);
  1621.                     Dimension dimension6 = getAngledLabelSize(dimension4, k1);
  1622.                     l2 = Math.max(l2, dimension6.width);
  1623.                 }
  1625.                 i += l2;
  1626.             }
  1627.         }
  1628.         boolean flag = false;
  1629.         for(int j1 = 0; j1 < super.rangeOn.length; j1++)
  1630.             flag = super.rangeOn[j1] ? true : flag;
  1632.         if(flag || super.rangeLabelsOn || super.targetsLabel.size() > 0)
  1633.         {
  1634.             FontMetrics fontmetrics1 = getFontMetrics(getFont("rangeLabelFont"));
  1635.             String s1 = getLabel("rangeLabelPrefix");
  1636.             String s2 = getLabel("rangeLabelPostfix");
  1637.             if(super.gridAlignment == 1)
  1638.             {
  1639.                 int l3 = 0;
  1640.                 int j5 = 0;
  1641.                 for(Enumeration enumeration = super.targetsLabel.keys(); enumeration.hasMoreElements();)
  1642.                 {
  1643.                     String s8 = (String)enumeration.nextElement();
  1644.                     String s13 = getTargetLabel(s8);
  1645.                     if(s13 != null && s13.length() > 0)
  1646.                         if(super.rangePosition[0] == 0)
  1647.                             l3 = Math.max(l3, fontmetrics1.stringWidth(s13));
  1648.                         else
  1649.                             j5 = Math.max(j5, fontmetrics1.stringWidth(s13));
  1650.                 }
  1652.                 if(super.rangeLabelsOn && super.rangeOn[0])
  1653.                 {
  1654.                     int k5 = getRangeDecimalCount(0);
  1655.                     String s9 = formatNumber(super.upperRange[0], k5);
  1656.                     String s14 = formatNumber(super.lowerRange[0], k5);
  1657.                     s9 = s1 == null ? s9 : s1 + s9;
  1658.                     s14 = s1 == null ? s14 : s1 + s14;
  1659.                     s9 = s2 == null ? s9 : s9 + s2;
  1660.                     s14 = s2 == null ? s14 : s14 + s2;
  1661.                     if(super.rangePosition[0] == 0)
  1662.                     {
  1663.                         l3 = Math.max(l3, fontmetrics1.stringWidth(s9));
  1664.                         l3 = Math.max(l3, fontmetrics1.stringWidth(s14));
  1665.                     } else
  1666.                     {
  1667.                         j5 = Math.max(j5, fontmetrics1.stringWidth(s9));
  1668.                         j5 = Math.max(j5, fontmetrics1.stringWidth(s14));
  1669.                     }
  1670.                 }
  1671.                 if(super.rangeOn[1])
  1672.                 {
  1673.                     int l5 = getRangeDecimalCount(1);
  1674.                     String s10 = formatNumber(super.upperRange[1], l5);
  1675.                     String s15 = formatNumber(super.lowerRange[1], l5);
  1676.                     if(super.rangePosition[1] == 0)
  1677.                     {
  1678.                         l3 = Math.max(l3, fontmetrics1.stringWidth(s10));
  1679.                         l3 = Math.max(l3, fontmetrics1.stringWidth(s15));
  1680.                     } else
  1681.                     {
  1682.                         j5 = Math.max(j5, fontmetrics1.stringWidth(s10));
  1683.                         j5 = Math.max(j5, fontmetrics1.stringWidth(s15));
  1684.                     }
  1685.                 }
  1686.                 i += l3 + 2;
  1687.                 j += j5 <= 0 ? 0 : j5 + 2;
  1688.             } else
  1689.             {
  1690.                 if(super.targetsValue.size() > 0)
  1691.                     k += fontmetrics1.getMaxAscent();
  1692.                 if(super.rangeLabelsOn && super.rangeOn[0])
  1693.                 {
  1694.                     if(super.rangePosition[0] == 0)
  1695.                     {
  1696.                         l += fontmetrics1.getMaxAscent();
  1697.                         if(super.targetsLabel.size() > 0)
  1698.                             l += fontmetrics1.getHeight();
  1699.                     } else
  1700.                     {
  1701.                         k += fontmetrics1.getMaxAscent();
  1702.                         if(super.targetsLabel.size() > 0)
  1703.                             k += fontmetrics1.getHeight();
  1704.                     }
  1705.                     int i4 = getRangeDecimalCount(0);
  1706.                     String s4 = formatNumber(super.upperRange[0], i4);
  1707.                     s4 = s1 == null ? s4 : s1 + s4;
  1708.                     s4 = s2 == null ? s4 : s4 + s2;
  1709.                     j = Math.max(j, fontmetrics1.stringWidth(s4) / 2 + 5);
  1710.                     String s6 = formatNumber(super.lowerRange[0], i4);
  1711.                     s6 = s1 == null ? s6 : s1 + s6;
  1712.                     s6 = s2 == null ? s6 : s6 + s2;
  1713.                     i = Math.max(i, fontmetrics1.stringWidth(s6) / 2 + 5);
  1714.                 }
  1715.                 if(super.rangeOn[1])
  1716.                 {
  1717.                     if(super.rangePosition[1] == 0)
  1718.                         l += fontmetrics1.getMaxAscent();
  1719.                     else
  1720.                         k += fontmetrics1.getMaxAscent();
  1721.                     int j4 = getRangeDecimalCount(1);
  1722.                     String s5 = formatNumber(super.upperRange[1], j4);
  1723.                     j = Math.max(j, fontmetrics1.stringWidth(s5) / 2 + 5);
  1724.                     String s7 = formatNumber(super.lowerRange[1], j4);
  1725.                     i = Math.max(i, fontmetrics1.stringWidth(s7) / 2 + 5);
  1726.                 }
  1727.             }
  1728.         }
  1729.         if(isValueLabelsOn(0) && valueLabelStyle == 0)
  1730.         {
  1731.             Font font1 = getFont("valueLabelFont");
  1732.             FontMetrics fontmetrics2 = getFontMetrics(font1);
  1733.             int i3 = getSampleDecimalCount(0);
  1734.             if(super.gridAlignment == 1)
  1735.             {
  1736.                 double d = getHighestValue(0);
  1737.                 int i6 = getLabelAngle("valueLabelAngle");
  1738.                 String s11 = formatNumber(d, i3);
  1739.                 Dimension dimension8 = getLabelSize(s11, font1);
  1740.                 Dimension dimension11 = getAngledLabelSize(dimension8, i6);
  1741.                 k += dimension11.height - 4;
  1742.                 double d5 = getLowestValue(0);
  1743.                 if(d5 < 0.0D)
  1744.                 {
  1745.                     String s12 = formatNumber(d5, i3);
  1746.                     Dimension dimension9 = getLabelSize(s12, font1);
  1747.                     Dimension dimension12 = getAngledLabelSize(dimension9, i6);
  1748.                     l += dimension12.height - 2;
  1749.                     if(i6 % 180 == 0)
  1750.                         l -= fontmetrics2.getDescent();
  1751.                 }
  1752.             } else
  1753.             {
  1754.                 double d1 = getHighestValue(0);
  1755.                 double d4 = 0.0D;
  1756.                 if(super.upperRange[0] - super.lowerRange[0] != 0.0D)
  1757.                     d4 = (d1 - super.lowerRange[0]) / (super.upperRange[0] - super.lowerRange[0]);
  1758.                 rectangle.x = i;
  1759.                 rectangle.width = dimension.width - i - j;
  1760.                 int j6 = (int)Math.round((double)rectangle.x + d4 * (double)rectangle.width);
  1761.                 int k6 = fontmetrics2.stringWidth(formatNumber(d1, i3));
  1762.                 j6 += k6;
  1763.                 if(j6 > rectangle.x + rectangle.width)
  1764.                     j += Math.min(j6 - rectangle.width - rectangle.x, k6);
  1765.                 double d6 = getLowestValue(0);
  1766.                 d4 = 0.0D;
  1767.                 if(super.upperRange[0] - super.lowerRange[0] != 0.0D)
  1768.                     d4 = (d6 - super.lowerRange[0]) / (super.upperRange[0] - super.lowerRange[0]);
  1769.                 j6 = (int)Math.round((double)rectangle.x + d4 * (double)rectangle.width);
  1770.                 k6 = fontmetrics2.stringWidth(formatNumber(d6, i3));
  1771.                 j6 -= k6;
  1772.                 if(j6 < rectangle.x)
  1773.                     i += Math.min(rectangle.x - j6, k6 - 6 - (super.sampleScrollerOn ? 10 : 0));
  1774.             }
  1775.         }
  1776.         String s = getLabel("sampleAxisLabel");
  1777.         if(s != null)
  1778.         {
  1779.             int l1 = getLabelAngle("sampleAxisLabelAngle");
  1780.             l1 = super.gridAlignment != 0 ? 0 : l1;
  1781.             Font font2 = getFont("sampleAxisLabelFont");
  1782.             getFontMetrics(font2);
  1783.             Dimension dimension1 = getLabelSize(s, font2);
  1784.             Dimension dimension2 = getAngledLabelSize(dimension1, l1);
  1785.             if(super.gridAlignment == 1)
  1786.                 l += dimension2.height + 3;
  1787.             else
  1788.                 i += dimension2.width + 5;
  1789.         }
  1790.         int i2 = 0;
  1791.         do
  1792.         {
  1793.             String s3 = i2 != 0 ? getLabel("rangeAxisLabel_2") : getLabel("rangeAxisLabel");
  1794.             if(s3 != null && super.rangeOn[i2])
  1795.             {
  1796.                 int k4 = i2 != 0 ? getLabelAngle("rangeAxisLabelAngle_2") : getLabelAngle("rangeAxisLabelAngle");
  1797.                 k4 = super.gridAlignment != 1 ? 0 : k4;
  1798.                 Font font3 = getFont("rangeAxisLabelFont");
  1799.                 FontMetrics fontmetrics3 = getFontMetrics(font3);
  1800.                 Dimension dimension7 = getLabelSize(s3, font3);
  1801.                 Dimension dimension10 = getAngledLabelSize(dimension7, k4);
  1802.                 if(super.gridAlignment == 1)
  1803.                 {
  1804.                     if(super.rangePosition[i2] == 0)
  1805.                         i += dimension10.width + 20;
  1806.                     else
  1807.                         j += dimension10.width + 20;
  1808.                 } else
  1809.                 if(super.rangePosition[i2] == 0)
  1810.                     l += (dimension10.height + 5) - (k4 % 360 != 0 ? 0 : fontmetrics3.getDescent());
  1811.                 else
  1812.                     k += dimension10.height + 5;
  1813.             }
  1814.         } while(++i2 < 2);
  1815.         if(is3DModeOn())
  1816.             if(super.depth3d >= 0)
  1817.             {
  1818.                 l += super.depth3d;
  1819.                 i += super.depth3d;
  1820.             } else
  1821.             {
  1822.                 int j2 = Math.max(1, getSampleCount());
  1823.                 if(barType == 0)
  1824.                     j2 *= Math.max(1, getSeriesCount());
  1825.                 if(super.gridAlignment == 1)
  1826.                 {
  1827.                     int j3 = 0;
  1828.                     if((double)j2 + barWidthFraction * 1.25D > 0.0D)
  1829.                         j3 = (int)(((double)rectangle.width * barWidthFraction * 1.25D) / ((double)j2 + barWidthFraction * 1.25D));
  1830.                     i += j3;
  1831.                     rectangle.width = dimension.width - i - j;
  1832.                     double d2 = 0.0D;
  1833.                     if(j2 > 0)
  1834.                         d2 = (double)(rectangle.width / j2) * barWidthFraction;
  1835.                     l += (int)Math.round(d2 / 1.25D);
  1836.                 } else
  1837.                 {
  1838.                     int k3 = 0;
  1839.                     if((double)(1.25F * (float)j2) + barWidthFraction * 0.75D > 0.0D)
  1840.                         k3 = (int)(((double)rectangle.height * barWidthFraction * 0.75D) / ((double)(1.25F * (float)j2) + barWidthFraction * 0.75D));
  1841.                     l += k3;
  1842.                     rectangle.height = dimension.height - k - l;
  1843.                     double d3 = (double)(rectangle.height / j2) * barWidthFraction;
  1844.                     i += (int)Math.round(d3 * 1.25D * 0.75D);
  1845.                 }
  1846.             }
  1847.         Insets insets = getGraphInsets();
  1848.         if(insets != null)
  1849.         {
  1850.             k = insets.top != -1 ? insets.top : k;
  1851.             i = insets.left != -1 ? insets.left : i;
  1852.             l = insets.bottom != -1 ? insets.bottom : l;
  1853.             j = insets.right != -1 ? insets.right : j;
  1854.         }
  1855.         rectangle.x = i;
  1856.         rectangle.width = dimension.width - i - j - 1;
  1857.         rectangle.y = k;
  1858.         rectangle.height = dimension.height - k - l - 1;
  1859.         super.currentBounds = rectangle;
  1860.         return rectangle;
  1861.     }
  1863.     public void setBarOutlineColor(Color color)
  1864.     {
  1865.         barOutlineColor = color;
  1866.         super.hasChanged = true;
  1867.         autoRepaint();
  1868.     }
  1870.     private void paintFloatingLabel(Graphics g, Rectangle rectangle, int i, int j, String s, Font font, FontMetrics fontmetrics)
  1871.     {
  1872.         if(i < 0 || i >= getSeriesCount() || j < 0 || j >= getSampleCount())
  1873.             return;
  1874.         Rectangle rectangle1 = barBounds[i][j];
  1875.         if(rectangle1 == null)
  1876.             return;
  1877.         if(super.gridAlignment == 1)
  1878.         {
  1879.             if(rectangle1.x + rectangle1.width < rectangle.x - super.depth3dPoint.x || rectangle1.x > rectangle.x + rectangle.width)
  1880.                 return;
  1881.             if(rectangle1.y + rectangle1.height < rectangle.y || rectangle1.y > (rectangle.y + rectangle.height) - super.depth3dPoint.y)
  1882.                 return;
  1883.         } else
  1884.         {
  1885.             if(rectangle1.y + rectangle1.height < rectangle.y || rectangle1.y > (rectangle.y + rectangle.height) - super.depth3dPoint.y)
  1886.                 return;
  1887.             if(rectangle1.x + rectangle1.width < rectangle.x - super.depth3dPoint.x || rectangle1.x > rectangle.x + rectangle.width)
  1888.                 return;
  1889.         }
  1890.         Dimension dimension = getLabelSize(s, font);
  1891.         int k = mousePosition.x + 3;
  1892.         if(super.gridAlignment == 1)
  1893.             k = ((rectangle1.x + rectangle1.width / 2) - dimension.width / 2) + 1;
  1894.         else
  1895.         if(mousePosition.x < 0)
  1896.             k = (rectangle1.x + rectangle1.width / 2) - dimension.width / 2;
  1897.         int l = (mousePosition.y - dimension.height) + fontmetrics.getAscent();
  1898.         if(super.gridAlignment == 0 || mousePosition.y < 0)
  1899.             l = ((rectangle1.y + rectangle1.height / 2) - dimension.height / 2) + fontmetrics.getAscent();
  1900.         if(barType == 1 && l - dimension.height / 2 < rectangle1.y)
  1901.             l = rectangle1.y + dimension.height / 2 + 1;
  1902.         else
  1903.         if(is3DModeOn() && super.depth3dPoint.y != 0 && super.gridAlignment == 1 && mousePosition.y < rectangle1.y && mousePosition.y >= 0)
  1904.         {
  1905.             k += (-super.depth3dPoint.x * (rectangle1.y - mousePosition.y)) / super.depth3dPoint.y;
  1906.             Rectangle rectangle2 = null;
  1907.             if(i < getSeriesCount() - 1)
  1908.                 rectangle2 = barBounds[i + 1][j];
  1909.             else
  1910.             if(j < getSampleCount() - 1)
  1911.                 rectangle2 = barBounds[0][j + 1];
  1912.             if(rectangle2 != null)
  1913.             {
  1914.                 int i1 = (-super.depth3dPoint.x * (rectangle2.y - mousePosition.y)) / super.depth3dPoint.y;
  1915.                 if(l >= rectangle2.y && k > rectangle2.x - 10)
  1916.                     k = rectangle2.x - 10;
  1917.                 else
  1918.                 if(l < rectangle2.y && k > (rectangle2.x + i1) - 10)
  1919.                     k = (rectangle2.x + i1) - 10;
  1920.             }
  1921.         }
  1922.         Dimension dimension1 = getSize();
  1923.         k = Math.max(k, 3);
  1924.         k = Math.min(k, dimension1.width - dimension.width - 3);
  1925.         l = Math.max(l, fontmetrics.getAscent() + 1);
  1926.         l = Math.min(l, ((dimension1.height - dimension.height) + fontmetrics.getAscent()) - 1);
  1927.         int j1 = fontmetrics.getHeight();
  1928.         int k1 = fontmetrics.getDescent();
  1929.         g.setColor(new Color(255, 255, 231));
  1930.         g.fillRect(k - 2, ((l - j1) + k1 * 2) - 2, dimension.width + 5, dimension.height);
  1931.         g.setColor(getChartForeground());
  1932.         if(getSeriesCount() == 1 && multiColorOn)
  1933.             g.setColor(getSampleColor(j).darker());
  1934.         else
  1935.         if(multiColorOn)
  1936.             g.setColor(getSampleColor(i).darker());
  1937.         g.drawRect(k - 3, ((l - j1) + k1 * 2) - 3, dimension.width + 5, dimension.height);
  1938.         g.setColor(Color.black);
  1939.         paintLabel(g, s, k, l, dimension, 0, 0);
  1940.     }
  1942.     public static final int SIDE_BY_SIDE_BARS = 0;
  1943.     public static final int STACKED_BARS = 1;
  1944.     public static final int VALUE_LABELS_OUTSIDE = 0;
  1945.     public static final int VALUE_LABELS_INSIDE = 1;
  1946.     public static final int VALUE_LABELS_FLOATING = 2;
  1947.     public static final int BAR_LABELS_BELOW = 0;
  1948.     public static final int BAR_LABELS_FLOATING = 1;
  1949.     public static final int BAR_LABELS_BELOW_AND_FLOATING = 2;
  1950.     private boolean multiColorOn;
  1951.     private int valueLabelStyle;
  1952.     private boolean barOutlineOn;
  1953.     private Color barOutlineColor;
  1954.     private boolean autoLabelSpacingOn;
  1955.     private double barWidthFraction;
  1956.     private int barType;
  1957.     private Rectangle barBounds[][];
  1958.     private int selectedSeries;
  1959.     private int selectedSample;
  1960.     private Point mousePosition;
  1961. }