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

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

OA系统

开发平台：

Java

Chart.java：源码内容
  1.         double d1 = getHighestValue(i);
  2.         double d2 = getLowestValue(i);
  3.         if(i == 0)
  4.         {
  5.             for(Enumeration enumeration = targetsValue.elements(); enumeration.hasMoreElements();)
  6.                 d1 = Math.max(((Double)enumeration.nextElement()).doubleValue(), d1);
  8.         }
  9.         if(d1 > 0.0D)
  10.             setRange(i, d1 * Math.abs(d));
  11.         else
  12.         if(d1 == 0.0D && d2 == 0.0D)
  13.             setRange(i, 100D);
  14.         else
  15.             setRange(i, 0.0D);
  16.     }
  18.     public boolean isPrintAsBitmap()
  19.     {
  20.         return printAsBitmap;
  21.     }
  23.     public int addOverlayChart(Chart chart)
  24.     {
  25.         if(chart != null)
  26.         {
  27.             chart.overlayChartOn = true;
  28.             chart.parentChart = this;
  29.             overlayCharts.addElement(chart);
  30.             chart.setRange(0, getRange(0));
  31.             chart.setRange(1, getRange(1));
  32.             chart.setLowerRange(0, getLowerRange(0));
  33.             chart.setLowerRange(1, getLowerRange(1));
  34.             hasChanged = true;
  35.             autoRepaint();
  36.             return overlayCharts.lastIndexOf(chart);
  37.         } else
  38.         {
  39.             return 0;
  40.         }
  41.     }
  43.     public int getLastSelectedSeries()
  44.     {
  45.         return lastSelectedSeries;
  46.     }
  48.     public synchronized void setRange(int i, double d)
  49.     {
  50.         i = Math.max(0, Math.min(1, i));
  51.         upperRange[i] = d;
  52.         currentUpperRange[i] = Math.min(currentUpperRange[i], d);
  53.         if(!rangeAdjusterOn[i])
  54.             currentUpperRange[i] = d;
  55.         for(int j = 0; j < overlayCharts.size(); j++)
  56.             ((Chart)overlayCharts.elementAt(j)).setRange(i, d);
  58.         hasChanged = true;
  59.         autoRepaint();
  60.     }
  62.     public synchronized double getRange(int i)
  63.     {
  64.         return upperRange[Math.max(0, Math.min(1, i))];
  65.     }
  67.     public void setCurrentLowerRange(int i, double d)
  68.     {
  69.         i = Math.min(currentLowerRange.length - 1, Math.max(0, i));
  70.         int j = rangeAdjusted[i];
  71.         if(i == 0 && j == 2)
  72.             j = 0;
  73.         else
  74.         if(i == 1 && j == 2)
  75.             j = 1;
  76.         d = Math.max(lowerRange[j], d);
  77.         d = Math.min(currentUpperRange[j], d);
  78.         currentLowerRange[j] = d;
  79.         hasChanged = true;
  80.         autoRepaint();
  81.     }
  83.     public double getCurrentLowerRange(int i)
  84.     {
  85.         i = Math.min(currentLowerRange.length - 1, Math.max(0, i));
  86.         return currentLowerRange[i];
  87.     }
  89.     /**
  90.      * @deprecated Method setRange is deprecated
  91.      */
  93.     public synchronized void setRange(double d)
  94.     {
  95.         setRange(0, d);
  96.     }
  98.     /**
  99.      * @deprecated Method getRange is deprecated
  100.      */
  102.     public synchronized long getRange()
  103.     {
  104.         return (long)getRange(0);
  105.     }
  107.     /**
  108.      * @deprecated Method setCurrentLowerRange is deprecated
  109.      */
  111.     public void setCurrentLowerRange(double d)
  112.     {
  113.         setCurrentLowerRange(0, d);
  114.     }
  116.     /**
  117.      * @deprecated Method getCurrentLowerRange is deprecated
  118.      */
  120.     public double getCurrentLowerRange()
  121.     {
  122.         return getCurrentLowerRange(0);
  123.     }
  125.     public Rectangle getDataBounds(Rectangle rectangle)
  126.     {
  127.         chartDataBounds.setBounds(rectangle);
  128.         double d = 1.0D - leftScrollerFactor - rightScrollerFactor;
  129.         if(gridAlignment == 1)
  130.         {
  131.             chartDataBounds.width = (int)Math.round((double)rectangle.width / d);
  132.             chartDataBounds.x -= Math.round(leftScrollerFactor * (double)chartDataBounds.width);
  133.         } else
  134.         {
  135.             chartDataBounds.height = (int)Math.round((double)rectangle.height / d);
  136.             chartDataBounds.y -= Math.round(leftScrollerFactor * (double)chartDataBounds.height);
  137.         }
  138.         return chartDataBounds;
  139.     }
  141.     void calculateZeroLines(Rectangle rectangle)
  142.     {
  143.         for(int i = 0; i < zeroLine.length; i++)
  144.             if(currentUpperRange[i] - currentLowerRange[i] != 0.0D)
  145.                 if(gridAlignment == 1)
  146.                 {
  147.                     int j = (int)Math.round((double)rectangle.height * (currentUpperRange[i] / (currentUpperRange[i] - currentLowerRange[i])));
  148.                     zeroLine[i] = rectangle.y + j;
  149.                 } else
  150.                 {
  151.                     int k = (int)Math.round((double)rectangle.width * (currentUpperRange[i] / (currentUpperRange[i] - currentLowerRange[i])));
  152.                     zeroLine[i] = (rectangle.x + rectangle.width) - k;
  153.                 }
  155.     }
  157.     public void setRangePosition(int i, int j)
  158.     {
  159.         rangePosition[Math.min(1, Math.max(0, i))] = Math.min(1, Math.max(0, j));
  160.         hasChanged = true;
  161.         autoRepaint();
  162.     }
  164.     public int getRangePosition(int i)
  165.     {
  166.         return rangePosition[Math.min(1, Math.max(0, i))];
  167.     }
  169.     public boolean isTitleOn()
  170.     {
  171.         return chartTitleOn;
  172.     }
  174.     public void setLegendPosition(int i)
  175.     {
  176.         if(i == 2 || i == 3 || i == 0 || i == 1)
  177.         {
  178.             legendPosition = i;
  179.             hasChanged = true;
  180.             autoRepaint();
  181.         } else
  182.         {
  183.             throw new IllegalArgumentException("Should be TOP, BOTTOM, LEFT, or RIGHT");
  184.         }
  185.     }
  187.     public int getLegendPosition()
  188.     {
  189.         return legendPosition;
  190.     }
  192.     public void addImage(String s, Image image)
  193.     {
  194.         if(s != null)
  195.             try
  196.             {
  197.                 if(image != null)
  198.                 {
  199.                     images.put(s, image);
  200.                     imageTracker.addImage(image, 0);
  201.                     imageTracker.waitForAll();
  202.                 } else
  203.                 {
  204.                     images.remove(s);
  205.                 }
  206.             }
  207.             catch(InterruptedException interruptedexception)
  208.             {
  209.                 interruptedexception.printStackTrace();
  210.             }
  211.     }
  213.     public void setRangeDecimalCount(int i, int j)
  214.     {
  215.         i = Math.max(0, Math.min(rangeDecimalCount.length - 1, i));
  216.         rangeDecimalCount[i] = j;
  217.         hasChanged = true;
  218.         autoRepaint();
  219.     }
  221.     public int getRangeDecimalCount(int i)
  222.     {
  223.         i = Math.max(0, Math.min(rangeDecimalCount.length - 1, i));
  224.         return rangeDecimalCount[i];
  225.     }
  227.     /**
  228.      * @deprecated Method setRangeDecimalCount is deprecated
  229.      */
  231.     public void setRangeDecimalCount(int i)
  232.     {
  233.         setRangeDecimalCount(0, i);
  234.     }
  236.     public void setLegendColors(Color acolor[])
  237.     {
  238.         legendColors = acolor;
  239.         hasChanged = true;
  240.         autoRepaint();
  241.     }
  243.     public Color[] getLegendColors()
  244.     {
  245.         return legendColors;
  246.     }
  248.     /**
  249.      * @deprecated Method getRangeDecimalCount is deprecated
  250.      */
  252.     public int getRangeDecimalCount()
  253.     {
  254.         return getRangeDecimalCount(0);
  255.     }
  257.     public static void main(String args[])
  258.     {
  259.         System.out.println("webgraph " + getVersion());
  260.         System.out.println("Copyright 2002-2003, 方成公司.");
  261.     }
  263.     public void setSampleColor(int i, Color color)
  264.     {
  265.         if(i < 0)
  266.         {
  267.             throw new IllegalArgumentException("Negativ index");
  268.         } else
  269.         {
  270.             sampleColors[i % sampleColors.length] = color;
  271.             hasChanged = true;
  272.             autoRepaint();
  273.             return;
  274.         }
  275.     }
  277.     public Color getSampleColor(int i)
  278.     {
  279.         Color color = DEFAULT_SAMPLE_COLORS[i % DEFAULT_SAMPLE_COLORS.length];
  280.         if(sampleColors != null && sampleColors.length > 0)
  281.         {
  282.             color = sampleColors[i % sampleColors.length];
  283.             if(color == null)
  284.             {
  285.                 int j = Math.min(sampleColors.length, DEFAULT_SAMPLE_COLORS.length);
  286.                 color = DEFAULT_SAMPLE_COLORS[i % j];
  287.             }
  288.         }
  289.         return color;
  290.     }
  292.     private void paintSampleScroller(Graphics g, Rectangle rectangle)
  293.     {
  294.         if(gridAlignment == 1)
  295.         {
  296.             int i = rectangle.x;
  297.             int k = rectangle.y + rectangle.height + 1;
  298.             if(display3dOn)
  299.             {
  300.                 i -= depth3dPoint.x;
  301.                 k -= depth3dPoint.y;
  302.             }
  303.             sampleScrollerBounds.x = i;
  304.             sampleScrollerBounds.y = k;
  305.             sampleScrollerBounds.height = 8;
  306.             sampleScrollerBounds.width = rectangle.width;
  307.             g.setColor(getBackground().darker());
  308.             g.drawLine(i, k + 4, i + sampleScrollerBounds.width, k + 4);
  309.             g.setColor(getBackground().brighter());
  310.             g.drawLine(i, k + 5, i + sampleScrollerBounds.width, k + 5);
  311.             paintBox(g, Color.lightGray, i, k, 8, 8, leftPushed);
  312.             i += leftPushed ? 1 : 0;
  313.             g.setColor(Color.black);
  314.             g.drawLine(i + 3, k + 4, i + 3, k + 4);
  315.             g.drawLine(i + 4, k + 3, i + 4, k + 5);
  316.             g.drawLine(i + 5, k + 2, i + 5, k + 6);
  317.             i = (sampleScrollerBounds.x + sampleScrollerBounds.width) - 8;
  318.             paintBox(g, Color.lightGray, i, k, 8, 8, rightPushed);
  319.             i += rightPushed ? 1 : 0;
  320.             g.setColor(Color.black);
  321.             g.drawLine(i + 3, k + 2, i + 3, k + 6);
  322.             g.drawLine(i + 4, k + 3, i + 4, k + 5);
  323.             g.drawLine(i + 5, k + 4, i + 5, k + 4);
  324.             sampleScrollerSpace = sampleScrollerBounds.width - 18;
  325.             int i1 = (int)Math.round(leftScrollerFactor * (double)sampleScrollerSpace);
  326.             i = rectangle.x + 9 + i1;
  327.             if(display3dOn)
  328.                 i -= depth3dPoint.x;
  329.             int k1 = sampleScrollerSpace - (int)Math.round(rightScrollerFactor * (double)sampleScrollerSpace) - i1;
  330.             leftAdjusterPos = i;
  331.             rightAdjusterPos = leftAdjusterPos + k1;
  332.             paintBox(g, Color.lightGray, i, k, k1, 8, false);
  333.             g.setColor(Color.gray);
  334.             g.drawLine(i + 2, k + 1, i + 2, k + 7);
  335.             g.setColor(Color.white);
  336.             g.drawLine((i + k1) - 2, k + 1, (i + k1) - 2, k + 7);
  337.         } else
  338.         {
  339.             int j = rectangle.x - 10;
  340.             int l = rectangle.y;
  341.             if(display3dOn)
  342.             {
  343.                 j -= depth3dPoint.x;
  344.                 l -= depth3dPoint.y;
  345.             }
  346.             sampleScrollerBounds.x = j;
  347.             sampleScrollerBounds.y = l;
  348.             sampleScrollerBounds.height = rectangle.height;
  349.             sampleScrollerBounds.width = 7;
  350.             g.setColor(getBackground().darker());
  351.             g.drawLine(j + 4, l, j + 4, l + sampleScrollerBounds.height);
  352.             g.setColor(getBackground().brighter());
  353.             g.drawLine(j + 5, l, j + 5, l + sampleScrollerBounds.height);
  354.             paintBox(g, Color.lightGray, j, l, 8, 8, leftPushed);
  355.             l += leftPushed ? 1 : 0;
  356.             g.setColor(Color.black);
  357.             g.drawLine(j + 4, l + 3, j + 4, l + 3);
  358.             g.drawLine(j + 3, l + 4, j + 5, l + 4);
  359.             g.drawLine(j + 2, l + 5, j + 6, l + 5);
  360.             l = (sampleScrollerBounds.y + sampleScrollerBounds.height) - 8;
  361.             paintBox(g, Color.lightGray, j, l, 8, 8, rightPushed);
  362.             l += rightPushed ? 1 : 0;
  363.             g.setColor(Color.black);
  364.             g.drawLine(j + 4, l + 5, j + 4, l + 5);
  365.             g.drawLine(j + 3, l + 4, j + 5, l + 4);
  366.             g.drawLine(j + 2, l + 3, j + 6, l + 3);
  367.             sampleScrollerSpace = sampleScrollerBounds.height - 18;
  368.             int j1 = (int)Math.round(leftScrollerFactor * (double)sampleScrollerSpace);
  369.             l = rectangle.y + 9 + j1;
  370.             if(display3dOn)
  371.                 l -= depth3dPoint.y;
  372.             int l1 = sampleScrollerSpace - (int)Math.round(rightScrollerFactor * (double)sampleScrollerSpace) - j1;
  373.             leftAdjusterPos = l;
  374.             rightAdjusterPos = leftAdjusterPos + l1;
  375.             paintBox(g, Color.lightGray, j, l, 8, l1, false);
  376.             g.setColor(Color.gray);
  377.             g.drawLine(j + 1, l + 2, j + 7, l + 2);
  378.             g.setColor(Color.white);
  379.             g.drawLine(j + 1, (l + l1) - 2, j + 7, (l + l1) - 2);
  380.         }
  381.     }
  383.     public void setLegendOn(boolean flag)
  384.     {
  385.         legendOn = flag;
  386.         legend.width = 0;
  387.         hasChanged = true;
  388.         autoRepaint();
  389.     }
  391.     public synchronized void setSamples(int i, ChartSample achartsample[])
  392.     {
  393.         chartData.setSamples(i, achartsample);
  394.         hasChanged = true;
  395.         if(isValueLabelsOn(i) && getLabelAngle("valueLabelAngle") != 0)
  396.             angledLabelCache.clear();
  397.         labelSizeCache.clear();
  398.         autoRepaint();
  399.     }
  401.     public synchronized ChartSample[] getSamples(int i)
  402.     {
  403.         return chartData.getSamples(i);
  404.     }
  406.     protected abstract void renderData(Graphics g, Rectangle rectangle, Rectangle rectangle1);
  408.     public double getMinValue(int i)
  409.     {
  410.         return chartData.getMinValue(i);
  411.     }
  413.     public String toString()
  414.     {
  415.         return getTitle();
  416.     }
  418.     public void setGridLine(int i, double d)
  419.     {
  420.         if(i >= maxGridLineCount || i < 0)
  421.             throw new IllegalArgumentException("Illegal vertical grid line index: " + i);
  422.         if(gridLines == null)
  423.         {
  424.             gridLines = new double[i + 1];
  425.             for(int j = 0; j < gridLines.length; j++)
  426.                 gridLines[j] = -2147483648D;
  428.         }
  429.         if(i >= gridLines.length)
  430.         {
  431.             double ad[] = new double[i + 1];
  432.             System.arraycopy(gridLines, 0, ad, 0, gridLines.length);
  433.             for(int k = gridLines.length; k < ad.length - 1; k++)
  434.                 ad[k] = -2147483648D;
  436.             gridLines = ad;
  437.         }
  438.         gridLines[i] = d;
  439.         hasChanged = true;
  440.         autoRepaint();
  441.     }
  443.     public double getGridLine(int i)
  444.     {
  445.         if(gridLines == null || i >= gridLines.length)
  446.             return -2147483648D;
  447.         else
  448.             return gridLines[i];
  449.     }
  451.     public void setChartData(ChartData chartdata)
  452.     {
  453.         chartData = chartdata;
  454.         checkDataIntegrity();
  455.         autoRepaint();
  456.     }
  458.     public ChartData getChartData()
  459.     {
  460.         return chartData;
  461.     }
  463.     public boolean isRangeLabelsOn()
  464.     {
  465.         return rangeLabelsOn;
  466.     }
  468.     public void setValueLabelsOn(boolean flag)
  469.     {
  470.         setValueLabelsOn(-1, flag);
  471.     }
  473.     public void setValueLabelsOn(int i, boolean flag)
  474.     {
  475.         if(i >= 0 && i < valueLabelsOn.length)
  476.             valueLabelsOn[i] = flag;
  477.         else
  478.         if(i == -1)
  479.         {
  480.             for(int j = 0; j < valueLabelsOn.length; j++)
  481.                 valueLabelsOn[j] = flag;
  483.         }
  484.         hasChanged = true;
  485.         autoRepaint();
  486.     }
  488.     public synchronized void setRelativeRange(double d)
  489.     {
  490.         setRelativeRangeIndex(0, d);
  491.     }
  493.     public synchronized void setRelativeRange(double d, double d1)
  494.     {
  495.         setRelativeRange(0, d, d1);
  496.     }
  498.     public synchronized void setRelativeRange(int i, double d, double d1)
  499.     {
  500.         i = Math.min(rangeOn.length - 1, Math.max(0, i));
  501.         double d2 = getHighestValue(i);
  502.         double d3 = getLowestValue(i);
  503.         if(i == 0)
  504.         {
  505.             for(Enumeration enumeration = targetsValue.elements(); enumeration.hasMoreElements();)
  506.                 d2 = Math.max(((Double)enumeration.nextElement()).doubleValue(), d2);
  508.         }
  509.         if(d2 > 0.0D)
  510.         {
  511.             d1 = Math.abs(d1);
  512.             double d4 = d2 * Math.abs(d);
  513.             if(d1 % 1.0D == 0.0D)
  514.             {
  515.                 if(d4 % d1 == 0.0D)
  516.                     setRange(i, d4);
  517.                 else
  518.                     setRange(i, (d4 - d4 % d1) + d1);
  519.             } else
  520.             {
  521.                 double d5;
  522.                 for(d5 = 0.0D; d5 < d4; d5 += d1);
  523.                 setRange(i, d5);
  524.             }
  525.         } else
  526.         if(d2 == 0.0D && d3 == 0.0D)
  527.             setRange(i, 100D);
  528.         else
  529.             setRange(i, 0.0D);
  530.     }
  532.     public void setFont(String s, Font font)
  533.     {
  534.         if(s == null || s.trim().length() < 1)
  535.             return;
  536.         s = s.trim().toLowerCase();
  537.         if(font != null)
  538.             labelFonts.put(s, font);
  539.         else
  540.             labelFonts.remove(s);
  541.         labelSizeCache.clear();
  542.         hasChanged = true;
  543.         autoRepaint();
  544.     }
  546.     public Font getFont(String s)
  547.     {
  548.         if(s == null)
  549.             getFont();
  550.         Font font = (Font)labelFonts.get(s.trim().toLowerCase());
  551.         if(font != null)
  552.             return font;
  553.         else
  554.             return getFont();
  555.     }
  557.     public synchronized void setSeriesLabels(String as[])
  558.     {
  559.         chartData.setSeriesLabels(as);
  560.         hasChanged = true;
  561.         autoRepaint();
  562.     }
  564.     public synchronized String[] getSeriesLabels()
  565.     {
  566.         return chartData.getSeriesLabels();
  567.     }
  569.     /**
  570.      * @deprecated Method getFloatRange is deprecated
  571.      */
  573.     public synchronized double getFloatRange()
  574.     {
  575.         return getRange(0);
  576.     }
  578.     private void adjustRange(Chart chart, int i, double d, double d1)
  579.     {
  580.         if(d != 0.0D)
  581.         {
  582.             double d2 = chart.lowerRange[i] + d * (chart.upperRange[i] - chart.lowerRange[i]);
  583.             if(d2 > chart.currentLowerRange[i])
  584.                 chart.currentUpperRange[i] = d2;
  585.             chart.currentUpperRange[i] = Math.min(chart.currentUpperRange[i], chart.upperRange[i]);
  586.         }
  587.         if(d1 != 0.0D)
  588.         {
  589.             double d3 = chart.lowerRange[i] + d1 * (chart.upperRange[i] - chart.lowerRange[i]);
  590.             if(d3 < chart.currentUpperRange[i])
  591.                 chart.currentLowerRange[i] = d3;
  592.             chart.currentLowerRange[i] = Math.max(chart.currentLowerRange[i], chart.lowerRange[i]);
  593.         }
  594.     }
  596.     protected abstract void render(Graphics g);
  598.     void render(Graphics g, boolean flag)
  599.     {
  600.     }
  602.     public boolean isValueLabelsOn()
  603.     {
  604.         return isValueLabelsOn(-1);
  605.     }
  607.     public void setRangeOn(int i, boolean flag)
  608.     {
  609.         rangeOn[Math.min(1, Math.max(0, i))] = flag;
  610.         hasChanged = true;
  611.         autoRepaint();
  612.     }
  614.     public boolean isValueLabelsOn(int i)
  615.     {
  616.         if(i >= 0 && i < valueLabelsOn.length)
  617.             return valueLabelsOn[i];
  618.         if(i == -1)
  619.         {
  620.             for(int j = 0; j < valueLabelsOn.length; j++)
  621.                 if(!valueLabelsOn[j])
  622.                     return false;
  624.             return true;
  625.         } else
  626.         {
  627.             return false;
  628.         }
  629.     }
  631.     public void setSelection(int i, int j, boolean flag)
  632.     {
  633.         setSelection(i, j, flag, false);
  634.     }
  636.     private void setSelection(int i, int j, boolean flag, boolean flag1)
  637.     {
  638.         chartData.setSelection(i, j, flag, flag1);
  639.         lastSelectedSample = -1;
  640.         lastSelectedSeries = -1;
  641.         for(int k = 0; k < legendSelection.length; k++)
  642.             legendSelection[k] = false;
  644.         if(j == -1 && i == -1)
  645.         {
  646.             if(selectedSample != null)
  647.             {
  648.                 notifyListeners(this, 2, selectedSample);
  649.                 selectedSample = null;
  650.             }
  651.         } else
  652.         if(j == -1 && i != -1)
  653.         {
  654.             ChartSample chartsample = new ChartSample(j);
  655.             chartsample.setSeries(i);
  656.             if(legendLabels != null && i < legendLabels.length && legendLabels[i] != null)
  657.                 chartsample.setLabel(legendLabels[i]);
  658.             else
  659.             if(i >= 0 && i < getSeriesCount())
  660.                 chartsample.setLabel(getSeriesLabel(i));
  661.             if(flag)
  662.             {
  663.                 lastSelectedSeries = i;
  664.                 if((selectedSample == null || chartsample.getSeries() != selectedSample.getSeries()) && selectedSample != null)
  665.                     notifyListeners(this, 2, selectedSample);
  666.                 notifyListeners(this, 1, chartsample);
  667.                 selectedSample = chartsample;
  668.             } else
  669.             {
  670.                 notifyListeners(this, 2, chartsample);
  671.                 if(chartsample == selectedSample)
  672.                     selectedSample = null;
  673.             }
  674.         } else
  675.         if(j != -1 && i != -1)
  676.         {
  677.             ChartSample chartsample1 = getSample(i, j);
  678.             if(flag)
  679.             {
  680.                 lastSelectedSample = j;
  681.                 lastSelectedSeries = i;
  682.                 if(selectedSample != null && chartsample1 != selectedSample)
  683.                     notifyListeners(this, 2, selectedSample);
  684.                 notifyListeners(this, 1, chartsample1);
  685.                 selectedSample = chartsample1;
  686.             } else
  687.             {
  688.                 notifyListeners(this, 2, chartsample1);
  689.                 if(chartsample1 == selectedSample)
  690.                     selectedSample = null;
  691.             }
  692.         }
  693.         if(getSeriesCount() > 1 || multiSeriesOn)
  694.         {
  695.             if(i >= 0 && i < legendSelection.length)
  696.                 legendSelection[i] = flag;
  697.         } else
  698.         if(j >= 0 && j < legendSelection.length)
  699.             legendSelection[j] = flag;
  700.         if(j == -1)
  701.         {
  702.             for(int l = 0; l < overlayCharts.size(); l++)
  703.             {
  704.                 Chart chart = (Chart)overlayCharts.elementAt(l);
  705.                 if(chart != null)
  706.                     chart.setSelection(i, j, flag, flag1);
  707.             }
  709.         }
  710.         hasChanged = true;
  711.         autoRepaint();
  712.     }
  714.     int getValuePosition(int i, double d, Rectangle rectangle)
  715.     {
  716.         i = Math.min(upperRange.length - 1, Math.max(0, i));
  717.         int j = 0;
  718.         int k = 0;
  719.         if(gridAlignment == 1)
  720.         {
  721.             if(currentUpperRange[i] - currentLowerRange[i] != 0.0D)
  722.                 j = (int)((double)rectangle.height * (currentUpperRange[i] / (currentUpperRange[i] - currentLowerRange[i])));
  723.             k = rectangle.y + j;
  724.         } else
  725.         {
  726.             if(currentUpperRange[i] - currentLowerRange[i] != 0.0D)
  727.                 j = (int)((double)rectangle.width * (currentUpperRange[i] / (currentUpperRange[i] - currentLowerRange[i])));
  728.             k = (rectangle.x + rectangle.width) - j;
  729.         }
  730.         int l = 0;
  731.         if(currentUpperRange[i] - currentLowerRange[i] != 0.0D)
  732.             if(gridAlignment == 1)
  733.                 l = (int)((double)k - (double)rectangle.height * (d / (currentUpperRange[i] - currentLowerRange[i])));
  734.             else
  735.                 l = (int)((double)k + (double)rectangle.width * (d / (currentUpperRange[i] - currentLowerRange[i])));
  736.         return l;
  737.     }
  739.     public final void print(Graphics g)
  740.     {
  741.         Dimension dimension = getSize();
  742.         g.setColor(getBackground());
  743.         g.fillRect(0, 0, dimension.width, dimension.height);
  744.         g.setColor(getForeground());
  745.         hasChanged = true;
  746.         render(g, printAsBitmap);
  747.         
  748.         //g.setColor(Color.red);
  749.         //g.setFont(new Font("Dialog", 1, 18));
  750.         //g.drawString("演示版不支持打印，请购买正版！",10,30);
  751.         //c2.paint(g, dimension);
  752.     }
  754.     public void setChartBackground(Color color)
  755.     {
  756.         chartBackground = color;
  757.         hasChanged = true;
  758.         autoRepaint();
  759.     }
  761.     public Color getChartBackground()
  762.     {
  763.         return chartBackground;
  764.     }
  766.     public void setRangeColor(int i, Color color)
  767.     {
  768.         rangeColor[Math.min(1, Math.max(0, i))] = color == null ? chartForeground : color;
  769.         hasChanged = true;
  770.         autoRepaint();
  771.     }
  773.     public Color getRangeColor(int i)
  774.     {
  775.         i = Math.min(1, Math.max(0, i));
  776.         if(rangeColor[i] != null)
  777.             return rangeColor[i];
  778.         else
  779.             return chartForeground;
  780.     }
  782.     public synchronized void setSeriesLabelColor(int i, Color color)
  783.     {
  784.         try
  785.         {
  786.             seriesLabelColors[i] = color;
  787.             hasChanged = true;
  788.             autoRepaint();
  789.         }
  790.         catch(IndexOutOfBoundsException _ex)
  791.         {
  792.             throw new IllegalArgumentException("Invalid series index: " + i);
  793.         }
  794.     }
  796.     public Color getSeriesLabelColor(int i)
  797.     {
  798.         try
  799.         {
  800.             return seriesLabelColors[i];
  801.         }
  802.         catch(IndexOutOfBoundsException _ex)
  803.         {
  804.             throw new IllegalArgumentException("Invalid series index: " + i);
  805.         }
  806.     }
  808.     public synchronized ChartSample getSample(Object obj)
  809.     {
  810.         return chartData.getSample(obj);
  811.     }
  813.     public synchronized int appendSample(int i, ChartSample chartsample, boolean flag)
  814.     {
  815.         int j = chartData.appendSample(i, chartsample, flag);
  816.         checkDataIntegrity();
  817.         hasChanged = true;
  818.         if(isValueLabelsOn(i) && getLabelAngle("valueLabelAngle") != 0)
  819.             angledLabelCache.clear();
  820.         autoRepaint();
  821.         return j;
  822.     }
  824.     public synchronized void setSample(int i, int j, ChartSample chartsample)
  825.     {
  826.         chartData.setSample(i, j, chartsample);
  827.         hasChanged = true;
  828.         if(isValueLabelsOn(i) && getLabelAngle("valueLabelAngle") != 0)
  829.             angledLabelCache.clear();
  830.         autoRepaint();
  831.     }
  833.     public void setLabel(String s, String s1)
  834.     {
  835.         if(s != null && s.length() > 0)
  836.         {
  837.             s = s.toLowerCase().trim();
  838.             if(s1 != null && s1.length() > 0)
  839.                 labels.put(s, s1);
  840.             else
  841.                 labels.remove(s);
  842.             hasChanged = true;
  843.             if(getLabelAngle(s + "Angle") != 0)
  844.                 angledLabelCache.clear();
  845.             autoRepaint();
  846.         }
  847.     }
  849.     public String getLabel(String s)
  850.     {
  851.         if(s != null)
  852.         {
  853.             s = s.toLowerCase().trim();
  854.             return (String)labels.get(s);
  855.         } else
  856.         {
  857.             return null;
  858.         }
  859.     }
  861.     public synchronized ChartSample getSample(int i, int j)
  862.     {
  863.         return chartData.getSample(i, j);
  864.     }
  866.     public void setValueLinesColor(Color color)
  867.     {
  868.         valueLinesColor = color;
  869.         if(valueLinesColor == null)
  870.             valueLinesColor = Color.lightGray;
  871.         hasChanged = true;
  872.         autoRepaint();
  873.     }
  875.     public Color getValueLinesColor()
  876.     {
  877.         return valueLinesColor;
  878.     }
  880.     String getTargetLabel(String s)
  881.     {
  882.         String s1 = "";
  883.         int i = ((Integer)targetsStyle.get(s)).intValue();
  884.         double d = ((Double)targetsValue.get(s)).doubleValue();
  885.         String s2 = formatNumber(d, rangeDecimalCount[0]);
  886.         if(getLabel("rangeLabelPrefix") != null)
  887.             s2 = getLabel("rangeLabelPrefix") + s2;
  888.         if(getLabel("rangeLabelPostfix") != null)
  889.             s2 += getLabel("rangeLabelPostfix");
  890.         switch(i)
  891.         {
  892.         default:
  893.             break;
  895.         case 0: // ''
  896.             s1 = "";
  897.             break;
  899.         case 1: // '01'
  900.             s1 = s;
  901.             break;
  903.         case 2: // '02'
  904.             s1 = s2;
  905.             break;
  907.         case 3: // '03'
  908.             if(rangePosition[0] == 0)
  909.                 s1 = s + " " + s2;
  910.             else
  911.                 s1 = s2 + " " + s;
  912.             break;
  913.         }
  914.         return s1;
  915.     }
  917.     public void setLegendColor(int i, Color color)
  918.     {
  919.         if(legendColors == null)
  920.             legendColors = new Color[i + 1];
  921.         if(i >= legendColors.length)
  922.         {
  923.             Color acolor[] = new Color[i + 1];
  924.             System.arraycopy(legendColors, 0, acolor, 0, legendColors.length);
  925.             legendColors = acolor;
  926.         }
  927.         legendColors[i] = color;
  928.         hasChanged = true;
  929.         autoRepaint();
  930.     }
  932.     public Color getLegendColor(int i)
  933.     {
  934.         if(legendColors == null || i >= legendColors.length)
  935.             return getSampleColor(i);
  936.         else
  937.             return legendColors[i];
  938.     }
  940.     public void setRangeAdjusted(int i, int j)
  941.     {
  942.         i = Math.min(rangeAdjusterOn.length - 1, Math.max(0, i));
  943.         j = Math.min(2, Math.max(0, j));
  944.         rangeAdjusted[i] = j;
  945.     }
  947.     public int getRangeAdjusted(int i)
  948.     {
  949.         i = Math.min(rangeAdjusterOn.length - 1, Math.max(0, i));
  950.         return rangeAdjusted[i];
  951.     }
  953.     protected void processEvent(AWTEvent awtevent)
  954.     {
  955.         if(depth3d > -1)
  956.         {
  957.             depth3dPoint.x = depth3d;
  958.             depth3dPoint.y = -depth3d;
  959.         }
  960.         if((awtevent instanceof MouseEvent) && (rangeAdjusterOn[0] || rangeAdjusterOn[1] || sampleScrollerOn))
  961.             handleAdjusters(awtevent);
  962.         switch(awtevent.getID())
  963.         {
  964.         default:
  965.             break;
  967.         case 501: 
  968.             /*if(c2.copyright)
  969.             {
  970.                 c2.copyright = false;
  971.             } else
  972.             {
  973.                 int i = ((MouseEvent)awtevent).getX();
  974.                 int k = ((MouseEvent)awtevent).getY();
  975.                 Dimension dimension = getSize();
  976.                 if(i > 0 && i < 11 && k > dimension.height - 11 && k < dimension.height)
  977.                     c2.copyright = true;
  978.             }
  979.             repaint();
  980.             */
  981.             break;
  983.         case 502: 
  984.             int j = ((MouseEvent)awtevent).getX();
  985.             int l = ((MouseEvent)awtevent).getY();
  986.             ChartSample chartsample = checkSelection(new Point(j, l));
  987.             if(chartsample != null)
  988.             {
  989.                 int i1 = chartsample.getSeries();
  990.                 if(i1 >= 0)
  991.                 {
  992.                     setSelection(i1, chartsample.getIndex(), true, true);
  993.                     repaint();
  994.                 }
  995.                 break;
  996.             }
  997.             if(selectedSample != null)
  998.             {
  999.                 setSelection(-1, -1, false, true);
  1000.                 repaint();
  1001.             }
  1002.             break;
  1004.         case 101: // 'e'
  1005.             if(offscreen != null)
  1006.                 offscreen.flush();
  1007.             if(!externalGraphicsOn)
  1008.                 offscreen = null;
  1009.             hasChanged = true;
  1010.             repaint();
  1011.             break;
  1012.         }
  1013.         super.processEvent(awtevent);
  1014.     }
  1016.     public double getMaxValue(int i)
  1017.     {
  1018.         return chartData.getMaxValue(i);
  1019.     }
  1021.     double getHighestValue(int i)
  1022.     {
  1023.         i = Math.min(rangeOn.length - 1, Math.max(0, i));
  1024.         int j = getSeriesCount();
  1025.         double d = 0.0D;
  1026.         for(int k = 0; k < j; k++)
  1027.             if(getSeriesRange(k) == i)
  1028.                 d = Math.max(getMaxValue(k), d);
  1030.         for(int l = 0; l < overlayCharts.size(); l++)
  1031.         {
  1032.             Chart chart = (Chart)overlayCharts.elementAt(l);
  1033.             if(chart != null && !chart.chartType.equals("pie"))
  1034.             {
  1035.                 for(int i1 = 0; i1 < chart.getSeriesCount(); i1++)
  1036.                     if(chart.getSeriesRange(i1) == i)
  1037.                         d = Math.max(chart.getMaxValue(i1), d);
  1039.             }
  1040.         }
  1042.         return d;
  1043.     }
  1045.     public final void update(Graphics g)
  1046.     {
  1047.         paint(g);
  1048.     }
  1050.     private void adjustRangeSlide(Chart chart, int i, double d)
  1051.     {
  1052.         double d1 = d * (chart.upperRange[i] - chart.lowerRange[i]);
  1053.         d1 = gridAlignment != 1 ? -d1 : d1;
  1054.         if(d1 >= 0.0D)
  1055.             d1 = Math.min(chart.upperRange[i] - chart.currentUpperRange[i], d1);
  1056.         else
  1057.         if(chart.currentLowerRange[i] + d1 < chart.lowerRange[i])
  1058.             d1 = chart.lowerRange[i] - chart.currentLowerRange[i];
  1059.         chart.currentUpperRange[i] += d1;
  1060.         chart.currentLowerRange[i] += d1;
  1061.     }
  1063.     public void setTitle(String s)
  1064.     {
  1065.         if(chartTitle != null)
  1066.         {
  1067.             Long long1 = new Long(chartTitle.hashCode() + getFont("titleFont").hashCode());
  1068.             labelSizeCache.remove(long1);
  1069.         }
  1070.         chartTitle = s;
  1071.         hasChanged = true;
  1072.         autoRepaint();
  1073.     }
  1075.     public String getTitle()
  1076.     {
  1077.         return chartTitle;
  1078.     }
  1080.     public void removeOverlayChart(int i)
  1081.     {
  1082.         if(i >= 0 && i < overlayCharts.size())
  1083.         {
  1084.             overlayCharts.removeElementAt(i);
  1085.             hasChanged = true;
  1086.             autoRepaint();
  1087.         } else
  1088.         {
  1089.             throw new IllegalArgumentException("invalid overlay index: " + i);
  1090.         }
  1091.     }
  1093.     private void transform(double d, double d1, double d2, double d3, double ad[])
  1094.     {
  1095.         ad[0] = d * d2 + d1 * d3;
  1096.         ad[1] = d * d3 - d1 * d2;
  1097.     }
  1099.     public void addItemListener(ItemListener itemlistener)
  1100.     {
  1101.         if(itemlistener != null)
  1102.             listeners.addElement(itemlistener);
  1103.     }
  1105.     public synchronized void setSampleValues(int i, double ad[])
  1106.     {
  1107.         chartData.setSampleValues(i, ad);
  1108.         hasChanged = true;
  1109.         if(isValueLabelsOn(i) && getLabelAngle("valueLabelAngle") != 0)
  1110.             angledLabelCache.clear();
  1111.         labelSizeCache.clear();
  1112.         autoRepaint();
  1113.     }
  1115.     public synchronized double[] getSampleValues(int i)
  1116.     {
  1117.         return chartData.getSampleValues(i);
  1118.     }
  1120.     private void getAngledBounds(double d, double d1, Rectangle rectangle, double ad[])
  1121.     {
  1122.         double d2 = (1.0D / 0.0D);
  1123.         double d3 = (1.0D / 0.0D);
  1124.         double d4 = (-1.0D / 0.0D);
  1125.         double d5 = (-1.0D / 0.0D);
  1126.         int i = 0;
  1127.         do
  1128.         {
  1129.             int j = 0;
  1130.             do
  1131.             {
  1132.                 transform(d, d1, rectangle.x + j * rectangle.width, rectangle.y + i * rectangle.height, ad);
  1133.                 d2 = Math.min(d2, ad[0]);
  1134.                 d3 = Math.min(d3, ad[1]);
  1135.                 d4 = Math.max(d4, ad[0]);
  1136.                 d5 = Math.max(d5, ad[1]);
  1137.             } while(++j <= 1);
  1138.         } while(++i <= 1);
  1139.         rectangle.x = (int)Math.floor(d2);
  1140.         rectangle.y = (int)Math.floor(d3);
  1141.         rectangle.width = ((int)Math.ceil(d4) - rectangle.x) + 1;
  1142.         rectangle.height = ((int)Math.ceil(d5) - rectangle.y) + 1;
  1143.     }
  1145.     public void setGridLineColors(Color acolor[])
  1146.     {
  1147.         gridLineColors = acolor;
  1148.         hasChanged = true;
  1149.         autoRepaint();
  1150.     }
  1152.     public Color[] getGridLineColors()
  1153.     {
  1154.         return gridLineColors;
  1155.     }
  1157.     public void setRangeAdjusterPosition(int i, int j)
  1158.     {
  1159.         i = Math.min(rangeAdjusterPosition.length - 1, Math.max(0, i));
  1160.         rangeAdjusterPosition[i] = Math.min(1, Math.max(0, j));
  1161.     }
  1163.     public int getRangeAdjusterPosition(int i)
  1164.     {
  1165.         i = Math.min(rangeAdjusterPosition.length - 1, Math.max(0, i));
  1166.         return rangeAdjusterPosition[i];
  1167.     }
  1169.     public void setTitleOn(boolean flag)
  1170.     {
  1171.         chartTitleOn = flag;
  1172.         hasChanged = true;
  1173.         autoRepaint();
  1174.     }
  1176.     public boolean isAutomaticRepaintOn()
  1177.     {
  1178.         return automaticRepaintOn;
  1179.     }
  1181.     public boolean isOverlayChartOn(int i)
  1182.     {
  1183.         Chart chart = getOverlayChart(i);
  1184.         if(chart != null)
  1185.             return chart.overlayChartOn;
  1186.         else
  1187.             return false;
  1188.     }
  1190.     public void reset()
  1191.     {
  1192.         automaticRepaintOn = true;
  1193.         chartTitle = null;
  1194.         chartTitleOn = false;
  1195.         sampleDecimalCount = new int[getSeriesCount()];
  1196.         legendOn = false;
  1197.         legendPosition = 1;
  1198.         display3dOn = false;
  1199.         chartBackground = Color.white;
  1200.         chartForeground = Color.black;
  1201.         setForeground(Color.black);
  1202.         setBackground(new Color(231, 221, 231));
  1203.         labelFonts.clear();
  1204.         labels.clear();
  1205.         legendLabels = null;
  1206.         graphInsets.top = graphInsets.bottom = graphInsets.left = graphInsets.right = -1;
  1207.         preferredSize.setSize(300, 200);
  1208.         lastSelectedSample = -1;
  1209.         lastSelectedSeries = -1;
  1210.         setFont(new Font("Arial", 0, 11));
  1211.         setFont("titleFont", new Font("Arial", 1, 14));
  1212.         setSampleColors(null);
  1213.         seriesRange = new int[getSeriesCount()];
  1214.         valueLabelsOn = new boolean[getSeriesCount()];
  1215.         barLabelStyle = 0;
  1216.         overlayChartOn = true;
  1217.         servletModeOn = false;
  1218.         externalGraphicsOn = false;
  1219.         floatingOnLegendOn = true;
  1220.         maxValueLineCount = 0x7fffffff;
  1221.         maxGridLineCount = 1000;
  1222.         leftSampleAxisRange = 0.0D;
  1223.         rightSampleAxisRange = 100D;
  1224.         valueLinesOn = false;
  1225.         valueLinesColor = Color.lightGray;
  1226.         rangeLabelsOn = true;
  1227.         rangeOn[0] = true;
  1228.         rangeOn[1] = false;
  1229.         rangeDecimalCount[0] = 0;
  1230.         rangeDecimalCount[1] = 0;
  1231.         sampleLabelsOn = false;
  1232.         targetsLabel.clear();
  1233.         targetsValue.clear();
  1234.         targetsColor.clear();
  1235.         targetsStyle.clear();
  1236.         gridAlignment = 1;
  1237.         rangeAdjusterOn[0] = false;
  1238.         rangeAdjusterOn[1] = false;
  1239.         sampleScrollerOn = false;
  1240.         setSize(300, 200);
  1241.         upperRange[0] = 100D;
  1242.         upperRange[1] = 100D;
  1243.         lowerRange[0] = 0.0D;
  1244.         lowerRange[1] = 0.0D;
  1245.         currentUpperRange[0] = 100D;
  1246.         currentUpperRange[1] = 100D;
  1247.         currentLowerRange[0] = 0.0D;
  1248.         currentLowerRange[1] = 0.0D;
  1249.         rangeAdjusterPosition[0] = 1;
  1250.         rangeAdjusterPosition[1] = 1;
  1251.         adjusterIndex = -1;
  1252.         rangePosition[0] = 0;
  1253.         rangePosition[1] = 1;
  1254.         rangeAdjusted[0] = 0;
  1255.         rangeAdjusted[1] = 1;
  1256.         gridLines = null;
  1257.         defaultGridLines = null;
  1258.         defaultGridLinesColor = Color.lightGray;
  1259.         gridLineColors = null;
  1260.         leftSampleAxisRange = 0.0D;
  1261.         rightSampleAxisRange = 100D;
  1262.         images = new Hashtable();
  1263.         imageTracker = new MediaTracker(this);
  1264.     }
  1266.     public void setMaxValueLineCount(int i)
  1267.     {
  1268.         if(i > -1)
  1269.             maxValueLineCount = i;
  1270.         else
  1271.             maxValueLineCount = 0x7fffffff;
  1272.         hasChanged = true;
  1273.         autoRepaint();
  1274.     }
  1276.     public int getMaxValueLineCount()
  1277.     {
  1278.         if(maxValueLineCount != 0x7fffffff)
  1279.             return maxValueLineCount;
  1280.         else
  1281.             return -1;
  1282.     }
  1284.     public synchronized void setSeriesCount(int i)
  1285.     {
  1286.         chartData.setSeriesCount(i);
  1287.         checkDataIntegrity();
  1288.         hasChanged = true;
  1289.         autoRepaint();
  1290.     }
  1292.     public synchronized int getSeriesCount()
  1293.     {
  1294.         return chartData.getSeriesCount();
  1295.     }
  1297.     public void setSampleColors(Color acolor[])
  1298.     {
  1299.         if(acolor != null)
  1300.         {
  1301.             sampleColors = acolor;
  1302.         } else
  1303.         {
  1304.             sampleColors = new Color[DEFAULT_SAMPLE_COLORS.length];
  1305.             System.arraycopy(DEFAULT_SAMPLE_COLORS, 0, sampleColors, 0, sampleColors.length);
  1306.         }
  1307.         hasChanged = true;
  1308.         autoRepaint();
  1309.     }
  1311.     public Color[] getSampleColors()
  1312.     {
  1313.         return sampleColors;
  1314.     }
  1316.     protected ChartSample checkSelection(Point point)
  1317.     {
  1318.         if(legendBounds == null || !legendOn)
  1319.             return null;
  1320.         ChartSample chartsample = null;
  1321.         int i = getSeriesCount();
  1322.         int j = getSampleCount();
  1323.         if(j > 0 && i > 0)
  1324.         {
  1325.             for(int k = 0; k < legendBounds.length; k++)
  1326.             {
  1327.                 if(legendBounds[k] == null || !legendBounds[k].contains(point))
  1328.                     continue;
  1329.                 if(i > 1 || chartType.equals("line") || multiSeriesOn)
  1330.                 {
  1331.                     chartsample = new ChartSample(-1);
  1332.                     chartsample.setSeries(k);
  1333.                 } else
  1334.                 {
  1335.                     chartsample = getSample(0, k);
  1336.                 }
  1337.                 break;
  1338.             }
  1340.         }
  1341.         return chartsample;
  1342.     }
  1344.     public void setFloatingOnLegendOn(boolean flag)
  1345.     {
  1346.         floatingOnLegendOn = flag;
  1347.         hasChanged = true;
  1348.         autoRepaint();
  1349.     }
  1351.     Dimension getImageSize(String s)
  1352.     {
  1353.         Dimension dimension = new Dimension(0, 0);
  1354.         if(s != null)
  1355.         {
  1356.             Image image = (Image)images.get(s);
  1357.             if(image != null)
  1358.             {
  1359.                 dimension.width = image.getWidth(this);
  1360.                 dimension.height = image.getHeight(this);
  1361.             }
  1362.         }
  1363.         return dimension;
  1364.     }
  1366.     Dimension getLabelSize(String s, Font font)
  1367.     {
  1368.         if(s == null)
  1369.             return new Dimension(0, 0);
  1370.         if(font == null)
  1371.             font = new Font("Dialog", 0, 12);
  1372.         Long long1 = new Long(s.hashCode() + font.hashCode());
  1373.         Dimension dimension = (Dimension)labelSizeCache.get(long1);
  1374.         if(dimension == null)
  1375.         {
  1376.             FontMetrics fontmetrics = getFontMetrics(font);
  1377.             dimension = new Dimension();
  1378.             if(s != null)
  1379.             {
  1380.                 for(StringTokenizer stringtokenizer = new StringTokenizer(s, "n"); stringtokenizer.hasMoreElements();)
  1381.                 {
  1382.                     String s1 = (String)stringtokenizer.nextElement();
  1383.                     dimension.height += fontmetrics.getMaxAscent() + 1;
  1384.                     if(s1 != null)
  1385.                         dimension.width = Math.max(dimension.width, fontmetrics.stringWidth(s1));
  1386.                 }
  1388.             }
  1389.             dimension.height = Math.max(dimension.height, fontmetrics.getMaxAscent());
  1390.             if(!servletModeOn)
  1391.                 labelSizeCache.put(long1, dimension);
  1392.         }
  1393.         return dimension;
  1394.     }
  1396.     Dimension getAngledLabelSize(Dimension dimension, int i)
  1397.     {
  1398.         if(i == 90 || i == 270)
  1399.             return new Dimension(dimension.height, dimension.width);
  1400.         if(i > 0 && i < 360)
  1401.         {
  1402.             double d = Math.sin((double)i * 0.017453292519943295D);
  1403.             double d1 = Math.cos((double)i * 0.017453292519943295D);
  1404.             int j = (int)(Math.abs((double)dimension.width * d1) + Math.abs((double)dimension.height * d) + 0.5D);
  1405.             int k = (int)(Math.abs((double)dimension.width * d) + Math.abs((double)dimension.height * d1) + 0.5D);
  1406.             return new Dimension(j, k);
  1407.         } else
  1408.         {
  1409.             return dimension;
  1410.         }
  1411.     }
  1413.     public synchronized void setSampleLabel(int i, String s)
  1414.     {
  1415.         String s1 = getSampleLabel(i);
  1416.         chartData.setSampleLabel(i, s);
  1417.         hasChanged = true;
  1418.         if(sampleLabelsOn && (getLabelAngle("sampleLabelAngle") != 0 || getLabelAngle("barLabelAngle") != 0))
  1419.             angledLabelCache.clear();
  1420.         if(s1 != null)
  1421.         {
  1422.             Long long1 = new Long(s1.hashCode() + getFont("sampleLabelFont").hashCode());
  1423.             labelSizeCache.remove(long1);
  1424.             long1 = new Long(s1.hashCode() + getFont("barLabelFont").hashCode());
  1425.             labelSizeCache.remove(long1);
  1426.         }
  1427.         autoRepaint();
  1428.     }
  1430.     public synchronized String getSampleLabel(int i)
  1431.     {
  1432.         return chartData.getSampleLabel(i);
  1433.     }
  1435.     public void setRangeAdjusterOn(int i, boolean flag)
  1436.     {
  1437.         i = Math.min(rangeAdjusterOn.length - 1, Math.max(0, i));
  1438.         rangeAdjusterOn[i] = flag;
  1439.         if(!flag)
  1440.         {
  1441.             int j = rangeAdjusted[i];
  1442.             if(i == 0 && j == 2)
  1443.                 j = 0;
  1444.             else
  1445.             if(i == 1 && j == 2)
  1446.                 j = 1;
  1447.             setCurrentRange(i, getRange(j));
  1448.             setCurrentLowerRange(i, getLowerRange(j));
  1449.         }
  1450.         hasChanged = true;
  1451.         autoRepaint();
  1452.     }
  1454.     public boolean isSampleScrollerOn()
  1455.     {
  1456.         return sampleScrollerOn;
  1457.     }
  1459.     protected synchronized void checkDataIntegrity()
  1460.     {
  1461.         int i = chartData.getSeriesCount();
  1462.         if(i != seriesLabelColors.length)
  1463.         {
  1464.             hasChanged = true;
  1465.             Color acolor[] = new Color[i];
  1466.             int j = Math.min(i, seriesLabelColors.length);
  1467.             System.arraycopy(seriesLabelColors, 0, acolor, 0, j);
  1468.             seriesLabelColors = acolor;
  1469.             int ai[] = new int[i];
  1470.             System.arraycopy(seriesRange, 0, ai, 0, Math.min(seriesRange.length, ai.length));
  1471.             seriesRange = ai;
  1472.             int ai1[] = new int[i];
  1473.             System.arraycopy(sampleDecimalCount, 0, ai1, 0, Math.min(sampleDecimalCount.length, ai1.length));
  1474.             sampleDecimalCount = ai1;
  1475.             boolean aflag1[] = new boolean[i];
  1476.             System.arraycopy(valueLabelsOn, 0, aflag1, 0, Math.min(valueLabelsOn.length, aflag1.length));
  1477.             valueLabelsOn = aflag1;
  1478.         }
  1479.         String as[] = getLegendLabels();
  1480.         if(legendSelection.length != as.length)
  1481.         {
  1482.             boolean aflag[] = new boolean[as.length];
  1483.             System.arraycopy(legendSelection, 0, aflag, 0, Math.min(legendSelection.length, aflag.length));
  1484.             legendSelection = aflag;
  1485.         }
  1486.         int k = chartData.getSampleCount();
  1487.         if(k != sampleLabelColors.length)
  1488.         {
  1489.             hasChanged = true;
  1490.             Color acolor1[] = new Color[k];
  1491.             int l = Math.min(k, sampleLabelColors.length);
  1492.             System.arraycopy(sampleLabelColors, 0, acolor1, 0, l);
  1493.             sampleLabelColors = acolor1;
  1494.         }
  1495.     }
  1497.     /**
  1498.      * @deprecated Method setRangeAdjusterOn is deprecated
  1499.      */
  1501.     public void setRangeAdjusterOn(boolean flag)
  1502.     {
  1503.         setRangeAdjusterOn(0, flag);
  1504.     }
  1506.     public void setPreferredSize(int i, int j)
  1507.     {
  1508.         preferredSize.width = i;
  1509.         preferredSize.height = j;
  1510.     }
  1512.     public Dimension getPreferredSize()
  1513.     {
  1514.         return new Dimension(preferredSize);
  1515.     }
  1517.     public Dimension getMinimumSize()
  1518.     {
  1519.         return new Dimension(100, 70);
  1520.     }
  1522.     private void handleAdjusters(AWTEvent awtevent)
  1523.     {
  1524.         boolean flag = false;
  1525.         boolean flag1 = false;
  1526.         boolean flag2 = false;
  1527.         boolean flag3 = false;
  1528.         boolean flag4 = false;
  1529.         boolean flag5 = false;
  1530.         insideLeftButton = false;
  1531.         insideRightButton = false;
  1532.         int i = -1;
  1533.         int j = ((MouseEvent)awtevent).getX();
  1534.         int k = ((MouseEvent)awtevent).getY();
  1535.         if(gridAlignment == 1)
  1536.         {
  1537.             flag = j >= rangeAdjusterBounds[0].x && j <= rangeAdjusterBounds[0].x + rangeAdjusterBounds[0].width;
  1538.             flag = flag && k >= rangeAdjusterBounds[0].y - 3 && k <= rangeAdjusterBounds[0].y + rangeAdjusterBounds[0].height + 1;
  1539.             flag1 = k >= rangeAdjusterBounds[0].y - 1 && k <= rangeAdjusterBounds[0].y + 3;
  1540.             flag2 = k >= (rangeAdjusterBounds[0].y + rangeAdjusterBounds[0].height) - 3 && k <= rangeAdjusterBounds[0].y + rangeAdjusterBounds[0].height + 1;
  1541.             i = !flag && !flag1 && !flag2 ? -1 : 0;
  1542.             if(rangeAdjusterOn[1] && !flag)
  1543.             {
  1544.                 flag = j >= rangeAdjusterBounds[1].x && j <= rangeAdjusterBounds[1].x + rangeAdjusterBounds[1].width;
  1545.                 flag = flag && k >= rangeAdjusterBounds[1].y - 3 && k <= rangeAdjusterBounds[1].y + rangeAdjusterBounds[1].height + 1;
  1546.                 flag1 = k >= rangeAdjusterBounds[1].y - 1 && k <= rangeAdjusterBounds[1].y + 3;
  1547.                 flag2 = k >= (rangeAdjusterBounds[1].y + rangeAdjusterBounds[1].height) - 3 && k <= rangeAdjusterBounds[1].y + rangeAdjusterBounds[1].height + 1;
  1548.                 i = !flag && !flag1 && !flag2 ? -1 : 1;
  1549.             }
  1550.         } else
  1551.         {
  1552.             flag = k >= rangeAdjusterBounds[0].y && k <= rangeAdjusterBounds[0].y + rangeAdjusterBounds[0].height;
  1553.             flag = flag && j >= rangeAdjusterBounds[0].x - 1 && j <= rangeAdjusterBounds[0].x + rangeAdjusterBounds[0].width + 1;
  1554.             flag2 = j >= rangeAdjusterBounds[0].x - 1 && j <= rangeAdjusterBounds[0].x + 2;
  1555.             flag1 = j >= (rangeAdjusterBounds[0].x + rangeAdjusterBounds[0].width) - 3 && j <= rangeAdjusterBounds[0].x + rangeAdjusterBounds[0].width + 1;
  1556.             i = !flag && !flag1 && !flag2 ? -1 : 0;
  1557.             if(rangeAdjusterOn[1] && !flag)
  1558.             {
  1559.                 flag = k >= rangeAdjusterBounds[1].y && k <= rangeAdjusterBounds[1].y + rangeAdjusterBounds[1].height;
  1560.                 flag = flag && j >= rangeAdjusterBounds[1].x - 1 && j <= rangeAdjusterBounds[1].x + rangeAdjusterBounds[1].width + 1;
  1561.                 flag2 = j >= rangeAdjusterBounds[1].x - 1 && j <= rangeAdjusterBounds[1].x + 2;
  1562.                 flag1 = j >= (rangeAdjusterBounds[1].x + rangeAdjusterBounds[1].width) - 3 && j <= rangeAdjusterBounds[1].x + rangeAdjusterBounds[1].width + 1;
  1563.                 i = !flag && !flag1 && !flag2 ? -1 : 1;
  1564.             }
  1565.         }
  1566.         if(!flag)
  1567.             if(gridAlignment == 1)
  1568.             {
  1569.                 int l = sampleScrollerBounds.x;
  1570.                 int j1 = sampleScrollerBounds.x + sampleScrollerBounds.width;
  1571.                 flag3 = k >= sampleScrollerBounds.y && k <= sampleScrollerBounds.y + sampleScrollerBounds.height;
  1572.                 flag3 = flag3 && j >= l - 1 && j <= j1 + 1;
  1573.                 insideLeftButton = flag3 && j >= l && j <= l + 8;
  1574.                 insideRightButton = flag3 && j >= j1 - 8 && j <= j1;
  1575.                 flag4 = flag3 && j >= leftAdjusterPos && j <= leftAdjusterPos + 2;
  1576.                 flag5 = flag3 && j >= rightAdjusterPos - 2 && j <= rightAdjusterPos;
  1577.                 flag3 = flag3 && j > leftAdjusterPos + 2 && j < rightAdjusterPos - 2;
  1578.             } else
  1579.             {
  1580.                 int i1 = sampleScrollerBounds.y;
  1581.                 int k1 = sampleScrollerBounds.y + sampleScrollerBounds.height;
  1582.                 flag3 = j >= sampleScrollerBounds.x && j <= sampleScrollerBounds.x + sampleScrollerBounds.width;
  1583.                 flag3 = flag3 && k >= i1 - 1 && k <= k1 + 1;
  1584.                 insideLeftButton = flag3 && k >= i1 && k <= i1 + 8;
  1585.                 insideRightButton = flag3 && k >= k1 - 8 && k <= k1;
  1586.                 flag4 = flag3 && k >= leftAdjusterPos && k <= leftAdjusterPos + 2;
  1587.                 flag5 = flag3 && k >= rightAdjusterPos - 2 && k <= rightAdjusterPos;
  1588.                 flag3 = flag3 && k > leftAdjusterPos + 2 && k < rightAdjusterPos - 2;
  1589.             }
  1590.         switch(awtevent.getID())
  1591.         {
  1592.         case 504: 
  1593.         case 505: 
  1594.         default:
  1595.             break;
  1597.         case 503: 
  1598.             if((flag1 || flag2) && flag)
  1599.             {
  1600.                 setCursor(gridAlignment != 1 ? RESIZE_HOR_CURSOR : RESIZE_CURSOR);
  1601.                 break;
  1602.             }
  1603.             if(flag)
  1604.             {
  1605.                 setCursor(MOVE_CURSOR);
  1606.                 break;
  1607.             }
  1608.             if(flag4 || flag5)
  1609.             {
  1610.                 setCursor(gridAlignment != 1 ? RESIZE_CURSOR : RESIZE_HOR_CURSOR);
  1611.                 break;
  1612.             }
  1613.             if(flag3)
  1614.                 setCursor(MOVE_CURSOR);
  1615.             else
  1616.                 setCursor(DEFAULT_CURSOR);
  1617.             break;
  1619.         case 501: 
  1620.             adjustingUpper = flag1 && flag;
  1621.             adjustingLower = flag2 && flag;
  1622.             slidingAdjuster = flag && !flag1 && !flag2;
  1623.             adjusterIndex = i;
  1624.             leftPushed = insideLeftButton;
  1625.             rightPushed = insideRightButton;
  1626.             adjustingLeft = flag4;
  1627.             adjustingRight = flag5;
  1628.             slidingScroller = flag3 && !flag4 && !flag5;
  1629.             lastAdjusterClick = gridAlignment != 1 ? j : k;
  1630.             lastScrollerClick = gridAlignment != 1 ? k : j;
  1631.             long l1 = System.currentTimeMillis();
  1632.             int i2 = getSampleCount();
  1633.             if(insideLeftButton)
  1634.             {
  1635.                 double d = (double)(chartDataBounds.width / i2) / (double)chartDataBounds.width;
  1636.                 if(gridAlignment == 0)
  1637.                     d = (double)(chartDataBounds.height / i2) / (double)chartDataBounds.height;
  1638.                 d = Math.min(d, leftScrollerFactor);
  1639.                 leftScrollerFactor -= d;
  1640.                 rightScrollerFactor += d;
  1641.                 if(scrollerThread == null)
  1642.                 {
  1643.                     scrollerThread = new Thread(this);
  1644.                     scrollerThread.start();
  1645.                 }
  1646.             } else
  1647.             if(insideRightButton)
  1648.             {
  1649.                 double d1 = (double)(chartDataBounds.width / i2) / (double)chartDataBounds.width;
  1650.                 if(gridAlignment == 0)
  1651.                     d1 = (double)(chartDataBounds.height / i2) / (double)chartDataBounds.height;
  1652.                 d1 = Math.min(d1, rightScrollerFactor);
  1653.                 leftScrollerFactor += d1;
  1654.                 rightScrollerFactor -= d1;
  1655.                 if(scrollerThread == null)
  1656.                 {
  1657.                     scrollerThread = new Thread(this);
  1658.                     scrollerThread.start();
  1659.                 }
  1660.             } else
  1661.             if(flag3 && !insideLeftButton && !insideRightButton)
  1662.             {
  1663.                 if(l1 - lastClickTime < 350L)
  1664.                 {
  1665.                     leftScrollerFactor = 0.0D;
  1666.                     rightScrollerFactor = 0.0D;
  1667.                 }
  1668.             } else
  1669.             if(flag && !flag1 && !flag2 && l1 - lastClickTime < 350L)
  1670.             {
  1671.                 int j2 = 0;
  1672.                 do
  1673.                 {
  1674.                     int l3 = rangeAdjusted[adjusterIndex] <= 1 ? rangeAdjusted[adjusterIndex] : j2;
  1675.                     currentUpperRange[l3] = upperRange[l3];
  1676.                     currentLowerRange[l3] = lowerRange[l3];
  1677.                     for(int i4 = 0; i4 < overlayCharts.size(); i4++)
  1678.                     {
  1679.                         Chart chart = (Chart)overlayCharts.elementAt(i4);
  1680.                         if(chart != null)
  1681.                         {
  1682.                             chart.currentUpperRange[l3] = chart.upperRange[l3];
  1683.                             chart.currentLowerRange[l3] = chart.lowerRange[l3];
  1684.                         }
  1685.                     }
  1687.                 } while(++j2 < 2);
  1688.             }
  1689.             lastClickTime = l1;
  1690.             hasChanged = true;
  1691.             repaint();
  1692.             break;
  1694.         case 506: 
  1695.             int k2 = ((MouseEvent)awtevent).getY();
  1696.             if(gridAlignment == 0)
  1697.                 k2 = ((MouseEvent)awtevent).getX();
  1698.             Rectangle rectangle = currentBounds;
  1699.             double d2 = 0.0D;
  1700.             if(adjustingUpper)
  1701.             {
  1702.                 double d3;
  1703.                 if(gridAlignment == 1)
  1704.                 {
  1705.                     setCursor(RESIZE_CURSOR);
  1706.                     k2 -= rectangle.y;
  1707.                     if(display3dOn && rangeAdjusterPosition[adjusterIndex] == 0)
  1708.                         k2 += depth3dPoint.y;
  1709.                     d3 = 1.0D - (double)k2 / (double)rectangle.height;
  1710.                 } else
  1711.                 {
  1712.                     setCursor(RESIZE_HOR_CURSOR);
  1713.                     k2 -= rectangle.x;
  1714.                     if(display3dOn && rangeAdjusterPosition[adjusterIndex] == 0)
  1715.                         k2 += depth3dPoint.x;
  1716.                     d3 = (double)k2 / (double)rectangle.width;
  1717.                 }
  1718.                 if(rangeAdjusted[adjusterIndex] == 2)
  1719.                 {
  1720.                     int j4 = 0;
  1721.                     do
  1722.                     {
  1723.                         adjustRange(this, j4, d3, 0.0D);
  1724.                         for(int l6 = 0; l6 < overlayCharts.size(); l6++)
  1725.                             adjustRange((Chart)overlayCharts.elementAt(l6), j4, d3, 0.0D);
  1727.                     } while(++j4 < 2);
  1728.                 } else
  1729.                 {
  1730.                     adjustRange(this, rangeAdjusted[adjusterIndex], d3, 0.0D);
  1731.                     for(int k4 = 0; k4 < overlayCharts.size(); k4++)
  1732.                         adjustRange((Chart)overlayCharts.elementAt(k4), rangeAdjusted[adjusterIndex], d3, 0.0D);
  1734.                 }
  1735.             } else
  1736.             if(adjustingLower)
  1737.             {
  1738.                 double d4;
  1739.                 if(gridAlignment == 1)
  1740.                 {
  1741.                     setCursor(RESIZE_CURSOR);
  1742.                     k2 -= rectangle.y;
  1743.                     if(display3dOn && rangeAdjusterPosition[adjusterIndex] == 0)
  1744.                         k2 += depth3dPoint.y;
  1745.                     d4 = 1.0D - (double)k2 / (double)rectangle.height;
  1746.                 } else
  1747.                 {
  1748.                     setCursor(RESIZE_HOR_CURSOR);
  1749.                     k2 -= rectangle.x;
  1750.                     if(display3dOn && rangeAdjusterPosition[adjusterIndex] == 0)
  1751.                         k2 += depth3dPoint.x;
  1752.                     d4 = (double)k2 / (double)rectangle.width;
  1753.                 }
  1754.                 if(rangeAdjusted[adjusterIndex] == 2)
  1755.                 {
  1756.                     int l4 = 0;
  1757.                     do
  1758.                     {
  1759.                         adjustRange(this, l4, 0.0D, d4);
  1760.                         for(int i7 = 0; i7 < overlayCharts.size(); i7++)
  1761.                             adjustRange((Chart)overlayCharts.elementAt(i7), l4, 0.0D, d4);
  1763.                     } while(++l4 < 2);
  1764.                 } else
  1765.                 {
  1766.                     adjustRange(this, rangeAdjusted[adjusterIndex], 0.0D, d4);
  1767.                     for(int i5 = 0; i5 < overlayCharts.size(); i5++)
  1768.                         adjustRange((Chart)overlayCharts.elementAt(i5), rangeAdjusted[adjusterIndex], 0.0D, d4);
  1770.                 }
  1771.             } else
  1772.             if(slidingAdjuster)
  1773.             {
  1774.                 setCursor(MOVE_CURSOR);
  1775.                 int j5 = lastAdjusterClick - k2;
  1776.                 double d5;
  1777.                 if(gridAlignment == 1)
  1778.                     d5 = (double)j5 / (double)rectangle.height;
  1779.                 else
  1780.                     d5 = (double)j5 / (double)rectangle.width;
  1781.                 if(rangeAdjusted[adjusterIndex] == 2)
  1782.                 {
  1783.                     int j7 = 0;
  1784.                     do
  1785.                     {
  1786.                         adjustRangeSlide(this, j7, d5);
  1787.                         for(int l7 = 0; l7 < overlayCharts.size(); l7++)
  1788.                             adjustRangeSlide((Chart)overlayCharts.elementAt(l7), j7, d5);
  1790.                     } while(++j7 < 2);
  1791.                 } else
  1792.                 {
  1793.                     adjustRangeSlide(this, rangeAdjusted[adjusterIndex], d5);
  1794.                     for(int k7 = 0; k7 < overlayCharts.size(); k7++)
  1795.                         adjustRangeSlide((Chart)overlayCharts.elementAt(k7), rangeAdjusted[adjusterIndex], d5);
  1797.                 }
  1798.                 lastAdjusterClick = k2;
  1799.             } else
  1800.             if(adjustingLeft)
  1801.             {
  1802.                 if(gridAlignment == 1)
  1803.                 {
  1804.                     int k5 = sampleScrollerBounds.x + 8;
  1805.                     int l2 = Math.max(((MouseEvent)awtevent).getX(), k5);
  1806.                     l2 = Math.min(l2, rightAdjusterPos - 8);
  1807.                     leftScrollerFactor = (double)(l2 - k5) / (double)sampleScrollerSpace;
  1808.                 } else
  1809.                 {
  1810.                     int l5 = sampleScrollerBounds.y + 8;
  1811.                     int i3 = Math.max(((MouseEvent)awtevent).getY(), l5);
  1812.                     i3 = Math.min(i3, rightAdjusterPos - 8);
  1813.                     leftScrollerFactor = (double)(i3 - l5) / (double)sampleScrollerSpace;
  1814.                 }
  1815.             } else
  1816.             if(adjustingRight)
  1817.             {
  1818.                 if(gridAlignment == 1)
  1819.                 {
  1820.                     int i6 = sampleScrollerBounds.x + 8 + sampleScrollerSpace;
  1821.                     int j3 = Math.min(((MouseEvent)awtevent).getX(), i6);
  1822.                     j3 = Math.max(j3, leftAdjusterPos + 6);
  1823.                     rightScrollerFactor = (double)(i6 - j3) / (double)sampleScrollerSpace;
  1824.                 } else
  1825.                 {
  1826.                     int j6 = sampleScrollerBounds.y + 8 + sampleScrollerSpace;
  1827.                     int k3 = Math.min(((MouseEvent)awtevent).getY(), j6);
  1828.                     k3 = Math.max(k3, leftAdjusterPos + 6);
  1829.                     rightScrollerFactor = (double)(j6 - k3) / (double)sampleScrollerSpace;
  1830.                 }
  1831.             } else
  1832.             if(slidingScroller)
  1833.             {
  1834.                 int k6 = gridAlignment != 1 ? k - lastScrollerClick : j - lastScrollerClick;
  1835.                 double d6 = (double)k6 / (double)sampleScrollerSpace;
  1836.                 if(k6 > 0)
  1837.                     d6 = Math.min(d6, rightScrollerFactor);
  1838.                 else
  1839.                     d6 = -Math.min(-d6, leftScrollerFactor);
  1840.                 leftScrollerFactor += d6;
  1841.                 rightScrollerFactor -= d6;
  1842.                 lastScrollerClick = gridAlignment != 1 ? k : j;
  1843.             }
  1844.             hasChanged = true;
  1845.             repaint();
  1846.             break;
  1848.         case 502: 
  1849.             adjustingUpper = adjustingLower = slidingAdjuster = false;
  1850.             adjusterIndex = -1;
  1851.             leftPushed = rightPushed = false;
  1852.             adjustingLeft = adjustingRight = slidingScroller = false;
  1853.             if(scrollerThread != null)
  1854.             {
  1855.                 scrollerThread.stop();
  1856.                 scrollerThread = null;
  1857.             }
  1858.             hasChanged = true;
  1859.             repaint();
  1860.             break;
  1861.         }
  1862.     }
  1864.     void notifyListeners(Chart chart, int i, Object obj)
  1865.     {
  1866.         if(listeners != null)
  1867.         {
  1868.             ItemEvent itemevent = new ItemEvent(chart, 701, obj, i);
  1869.             for(Enumeration enumeration = listeners.elements(); enumeration.hasMoreElements(); ((ItemListener)enumeration.nextElement()).itemStateChanged(itemevent));
  1870.         }
  1871.     }
  1873.     public static final int HORIZONTAL = 0;
  1874.     public static final int VERTICAL = 1;
  1875.     public static final int LEFT = 0;
  1876.     public static final int RIGHT = 1;
  1877.     public static final int TOP = 2;
  1878.     public static final int BOTTOM = 3;
  1879.     public static final int TARGET_LINE_NO_LABEL = 0;
  1880.     public static final int TARGET_LINE_ID_LABEL = 1;
  1881.     public static final int TARGET_LINE_VALUE_LABEL = 2;
  1882.     public static final int TARGET_LINE_ID_AND_VALUE_LABEL = 3;
  1883.     static final int BELOW = 0;
  1884.     static final int FLOATING = 1;
  1885.     static final int BELOW_AND_FLOATING = 2;
  1886.     private static final int X_AXIS = 0;
  1887.     private static final int Y_AXIS = 1;
  1888.     protected ChartData chartData;
  1889.     protected Vector overlayCharts;
  1890.     private Color sampleColors[];
  1891.     private Color sampleLabelColors[];
  1892.     private Color seriesLabelColors[];
  1893.     private String chartTitle;
  1894.     private boolean chartTitleOn;
  1895.     private int sampleDecimalCount[];
  1896.     private boolean legendOn;
  1897.     private int legendPosition;
  1898.     private boolean valueLabelsOn[];
  1899.     private boolean display3dOn;
  1900.     private Color chartBackground;
  1901.     private Color chartForeground;
  1902.     private Hashtable labels;
  1903.     private Hashtable labelFonts;
  1904.     private Hashtable labelAngles;
  1905.     String legendLabels[];
  1906.     private Color legendColors[];
  1907.     private String legendImages[];
  1908.     private boolean automaticRepaintOn;
  1909.     private Insets graphInsets;
  1910.     private Dimension preferredSize;
  1911.     int lastSelectedSample;
  1912.     int lastSelectedSeries;
  1913.     boolean multiSeriesOn;
  1914.     int barLabelStyle;
  1915.     private boolean printAsBitmap;
  1916.     Hashtable images;
  1917.     private boolean overlayChartOn;
  1918.     private boolean servletModeOn;
  1919.     private boolean floatingOnLegendOn;
  1920.     boolean rangeOn[];
  1921.     double upperRange[];
  1922.     double lowerRange[];
  1923.     double currentUpperRange[];
  1924.     double currentLowerRange[];
  1925.     double leftSampleAxisRange;
  1926.     double rightSampleAxisRange;
  1927.     int rangePosition[];
  1928.     Color rangeColor[];
  1929.     int seriesRange[];
  1930.     boolean valueLinesOn;
  1931.     int maxValueLineCount;
  1932.     Color valueLinesColor;
  1933.     int maxGridLineCount;
  1934.     double gridLines[];
  1935.     double defaultGridLines[];
  1936.     Color defaultGridLinesColor;
  1937.     Color gridLineColors[];
  1938.     boolean rangeLabelsOn;
  1939.     int rangeDecimalCount[];
  1940.     boolean sampleLabelsOn;
  1941.     Hashtable targetsLabel;
  1942.     Hashtable targetsValue;
  1943.     Hashtable targetsColor;
  1944.     Hashtable targetsStyle;
  1945.     int zeroLine[];
  1946.     Point depth3dPoint;
  1947.     int depth3d;
  1948.     int gridAlignment;
  1949.     static final double STEPS[] = {
  1950.         1.0D, 2D, 2.5D, 5D
  1951.     };
  1952.     static final float ANGLE = 1.25F;
  1953.     static final float DEPTH = 0.75F;
  1954.     Rectangle currentBounds;
  1955.     String barLabels[];
  1956.     boolean rangeAdjusterOn[];
  1957.     int rangeAdjusterPosition[];
  1958.     int rangeAdjusted[];
  1959.     boolean adjustingUpper;
  1960.     boolean adjustingLower;
  1961.     boolean slidingAdjuster;
  1962.     int adjusterIndex;
  1963.     int lastAdjusterClick;
  1964.     Rectangle rangeAdjusterBounds[];
  1965.     static Cursor RESIZE_CURSOR;
  1966.     static Cursor RESIZE_HOR_CURSOR;
  1967.     static Cursor MOVE_CURSOR;
  1968.     static Cursor DEFAULT_CURSOR;
  1969.     boolean sampleScrollerOn;
  1970.     boolean leftPushed;
  1971.     boolean rightPushed;
  1972.     boolean adjustingLeft;
  1973.     boolean adjustingRight;
  1974.     boolean slidingScroller;
  1975.     boolean insideLeftButton;
  1976.     boolean insideRightButton;
  1977.     int lastScrollerClick;
  1978.     double leftScrollerFactor;
  1979.     double rightScrollerFactor;
  1980.     int leftAdjusterPos;
  1981.     int rightAdjusterPos;
  1982.     int sampleScrollerSpace;
  1983.     Thread scrollerThread;
  1984.     Rectangle sampleScrollerBounds;
  1985.     Rectangle chartDataBounds;
  1986.     String chartType;
  1987.     Chart parentChart;
  1988.     private ChartSample selectedSample;
  1989.     Rectangle legendBounds[];
  1990.     boolean legendSelection[];
  1991.     private Vector listeners;
  1992.     private NumberFormat numberFormatter;
  1993.     boolean hasChanged;
  1994.     Rectangle legend;
  1995.     private long lastClickTime;
  1996.     private Image rotateImage;
  1997.     private Hashtable angledLabelCache;
  1998.     private Hashtable labelSizeCache;
  1999.     double valueLines[];
  2000.     Image offscreen;
  2001.     Graphics og;
  2002.     private long lastRenderTime;
  2003.     //private Chart2 c2;
  2004.     private static final int DOUBLE_CLICK_TIME = 350;
  2005.     MediaTracker imageTracker;
  2006.     boolean externalGraphicsOn;
  2007.     private static Color DEFAULT_SAMPLE_COLORS[] = {
  2008.         new Color(132, 130, 255), new Color(132, 32, 99), new Color(255, 255, 198), new Color(165, 227, 231), new Color(99, 0, 132), new Color(255, 130, 132), new Color(0, 130, 198), new Color(198, 195, 255), new Color(0, 0, 132), new Color(255, 0, 255), 
  2009.         new Color(255, 255, 0), new Color(0, 255, 255), new Color(132, 0, 132), new Color(132, 0, 0), new Color(0, 130, 132), new Color(0, 0, 255), new Color(0, 207, 255), new Color(107, 255, 255), new Color(206, 255, 206), new Color(255, 255, 156)
  2010.     };
  2012. }