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

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

OA系统

开发平台：

Java

LineChart.java：源码内容
  1. // Decompiled by DJ v2.9.9.60 Copyright 2000 Atanas Neshkov  Date: 2002-12-03 18:42:54
  2. // Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
  3. // Decompiler options: packimports(3) 
  4. // Source File Name:   LineChart.java
  6. package cn.com.fcsoft.chart;
  8. import java.awt.*;
  9. import java.awt.event.MouseEvent;
  10. import java.io.PrintStream;
  11. import java.util.*;
  13. // Referenced classes of package com.objectplanet.chart:
  14. //            Chart, ChartSample, PieChart
  16. public class LineChart extends Chart
  17. {
  19.     public void setSampleHighlightStyle(int i, int j, int k)
  20.     {
  21.         sampleHighlightSize[i] = Math.max(0, k);
  22.         sampleHighlightStyle[i] = j;
  23.         super.hasChanged = true;
  24.         autoRepaint();
  25.     }
  27.     public int getSampleHighlightStyle(int i)
  28.     {
  29.         try
  30.         {
  31.             return sampleHighlightStyle[i];
  32.         }
  33.         catch(IndexOutOfBoundsException _ex)
  34.         {
  35.             throw new IllegalArgumentException("Invalid series: " + i);
  36.         }
  37.     }
  39.     public boolean isSampleLabelsOn()
  40.     {
  41.         return super.sampleLabelsOn;
  42.     }
  44.     public void setAutoLabelSpacingOn(boolean flag)
  45.     {
  46.         autoLabelSpacingOn = flag;
  47.         super.hasChanged = true;
  48.         autoRepaint();
  49.     }
  51.     public void setStackedOn(boolean flag)
  52.     {
  53.         stackedOn = flag;
  54.         super.hasChanged = true;
  55.         autoRepaint();
  56.     }
  58.     public void setConnectedLinesOn(int i, boolean flag)
  59.     {
  60.         if(i >= 0 && i < connectedLinesOn.length)
  61.             connectedLinesOn[i] = flag;
  62.         else
  63.         if(i == -1)
  64.         {
  65.             for(int j = 0; j < connectedLinesOn.length; j++)
  66.                 connectedLinesOn[j] = flag;
  68.         }
  69.         super.hasChanged = true;
  70.         autoRepaint();
  71.     }
  73.     protected void processEvent(AWTEvent awtevent)
  74.     {
  75.         switch(awtevent.getID())
  76.         {
  77.         case 504: 
  78.         default:
  79.             break;
  81.         case 505: 
  82.             selectedSample = -1;
  83.             selectedSeries = -1;
  84.             repaint();
  85.             break;
  87.         case 503: 
  88.         case 506: 
  89.             MouseEvent mouseevent = (MouseEvent)awtevent;
  90.             boolean flag = isValueLabelsOn() && valueLabelStyle == 2;
  91.             flag |= super.sampleLabelsOn && sampleLabelStyle == 2;
  92.             flag |= seriesLabelsOn;
  93.             if(!flag)
  94.                 break;
  95.             mousePosition.x = mouseevent.getX();
  96.             mousePosition.y = mouseevent.getY();
  97.             ChartSample chartsample = super.checkSelection(mousePosition);
  98.             if(chartsample != null)
  99.             {
  100.                 mousePosition.x = -1;
  101.                 mousePosition.y = -1;
  102.             } else
  103.             {
  104.                 chartsample = checkSelection(mousePosition);
  105.             }
  106.             if(chartsample != null)
  107.             {
  108.                 if(chartsample.getIndex() != selectedSample || chartsample.getSeries() != selectedSeries)
  109.                 {
  110.                     selectedSample = chartsample.getIndex();
  111.                     selectedSeries = chartsample.getSeries();
  112.                     repaint();
  113.                 }
  114.                 break;
  115.             }
  116.             boolean flag1 = selectedSample != -1 || selectedSeries != -1;
  117.             selectedSample = -1;
  118.             selectedSeries = -1;
  119.             if(flag1)
  120.                 repaint();
  121.             break;
  122.         }
  123.         super.processEvent(awtevent);
  124.     }
  126.     public String[] getLegendLabels()
  127.     {
  128.         if(super.legendLabels != null)
  129.             return super.legendLabels;
  130.         else
  131.             return getSeriesLabels();
  132.     }
  134.     private void paintSampleLabels(Graphics g, Rectangle rectangle, Rectangle rectangle1)
  135.     {
  136.         String as[] = getSampleLabels();
  137.         if(as == null)
  138.             return;
  139.         Font font = getFont("sampleLabelFont");
  140.         g.setFont(font);
  141.         FontMetrics fontmetrics = g.getFontMetrics();
  142.         int i = getSampleCount();
  143.         double d = rectangle1.width;
  144.         if(i > 1)
  145.             d = (float)rectangle1.width / (float)(i - 1);
  146.         int j = rectangle1.y + rectangle1.height;
  147.         double d1 = rectangle1.x;
  148.         int k = rectangle.x;
  149.         int l = rectangle.x + rectangle.width;
  150.         if(is3DModeOn())
  151.         {
  152.             j -= super.depth3dPoint.y;
  153.             d1 -= super.depth3dPoint.x;
  154.             k -= super.depth3dPoint.x;
  155.             l -= super.depth3dPoint.x;
  156.         }
  157.         if(super.sampleScrollerOn)
  158.             j += 10;
  159.         Color color = getChartForeground();
  160.         int i1 = getLabelAngle("sampleLabelAngle");
  161.         double d2 = 0.0D;
  162.         for(int j1 = 0; j1 < as.length; j1++)
  163.         {
  164.             if(as[j1] != null && as[j1].length() > 0 && d1 >= (double)k && d1 <= (double)(l + 1))
  165.             {
  166.                 Color color1 = getSampleLabelColor(j1);
  167.                 if(color1 == null)
  168.                     color1 = getForeground();
  169.                 String s = as[j1];
  170.                 Dimension dimension = getLabelSize(s, font);
  171.                 Dimension dimension1 = getAngledLabelSize(dimension, i1);
  172.                 int k1 = j + 8;
  173.                 if(i1 % 180 == 0)
  174.                     k1 += fontmetrics.getMaxAscent() - 4;
  175.                 double d3 = 0.0D;
  176.                 if(i1 % 180 == 0)
  177.                     d3 = d1 - (double)(dimension1.width / 2);
  178.                 else
  179.                 if(i1 % 360 > 90 && i1 % 360 < 180 || i1 % 360 > 270)
  180.                     d3 = (d1 - (double)dimension1.width) + (double)(fontmetrics.getAscent() / 2);
  181.                 else
  182.                     d3 = d1 - (double)(fontmetrics.getAscent() / 2);
  183.                 g.setColor(color);
  184.                 if(autoLabelSpacingOn)
  185.                 {
  186.                     if(s != null && s.trim().length() > 0 && (d3 > d2 || j1 == 0))
  187.                     {
  188.                         g.drawLine((int)Math.round(d1), j, (int)Math.round(d1), j + 3);
  189.                         g.setColor(color1);
  190.                         paintLabel(g, s, (int)Math.round(d3), k1, dimension, 0, i1);
  191.                         d2 = d3 + (double)dimension1.width;
  192.                     }
  193.                 } else
  194.                 if(s != null && s.trim().length() > 0)
  195.                 {
  196.                     g.drawLine((int)Math.round(d1), j, (int)Math.round(d1), j + 3);
  197.                     g.setColor(color1);
  198.                     paintLabel(g, s, (int)Math.round(d3), k1, dimension, 0, i1);
  199.                 }
  200.             }
  201.             d1 += d;
  202.         }
  204.     }
  206.     public void setSampleLabelStyle(int i)
  207.     {
  208.         sampleLabelStyle = i;
  209.         super.hasChanged = true;
  210.         autoRepaint();
  211.     }
  213.     public int getSampleLabelStyle()
  214.     {
  215.         return sampleLabelStyle;
  216.     }
  218.     public void setSeriesLineOn(boolean flag)
  219.     {
  220.         for(int i = 0; i < seriesLinesOn.length; i++)
  221.             seriesLinesOn[i] = flag;
  223.         super.hasChanged = true;
  224.         autoRepaint();
  225.     }
  227.     public void setSeriesLineOn(int i, boolean flag)
  228.     {
  229.         seriesLinesOn[i] = flag;
  230.         super.hasChanged = true;
  231.         autoRepaint();
  232.     }
  234.     private void paintSampleHighlight(Graphics g, int i, int j, int k, Color color)
  235.     {
  236.         java.awt.Shape shape = g.getClip();
  237.         g.setClip(0, 0, 32767, 32767);
  238.         String s = getLegendImage(i);
  239.         Dimension dimension = getImageSize(s);
  240.         if(s != null && dimension.width > 0 && dimension.height > 0)
  241.         {
  242.             Image image = (Image)super.images.get(s);
  243.             if(image != null)
  244.                 g.drawImage(image, j - dimension.width / 2, k - dimension.height / 2, this);
  245.         } else
  246.         {
  247.             int l = 6;
  248.             if(i >= 0 && i < sampleHighlightSize.length)
  249.                 l = sampleHighlightSize[i];
  250.             int i1 = 0;
  251.             if(i >= 0 && i < sampleHighlightStyle.length)
  252.                 i1 = sampleHighlightStyle[i];
  253.             Color color1 = getChartBackground();
  254.             g.setColor(color);
  255.             switch(i1)
  256.             {
  257.             default:
  258.                 break;
  260.             case 0: // ''
  261.                 g.drawOval(j - l / 2, k - l / 2, l, l);
  262.                 break;
  264.             case 2: // '02'
  265.                 g.fillOval(j - l / 2, k - l / 2, l + 1, l + 1);
  266.                 break;
  268.             case 1: // '01'
  269.                 g.setColor(color1);
  270.                 g.fillOval(j - l / 2, k - l / 2, l + 1, l + 1);
  271.                 g.setColor(color);
  272.                 g.drawOval(j - l / 2, k - l / 2, l, l);
  273.                 break;
  275.             case 3: // '03'
  276.                 g.drawRect(j - l / 2, k - l / 2, l, l);
  277.                 break;
  279.             case 5: // '05'
  280.                 g.fillRect(j - l / 2, k - l / 2, l + 1, l + 1);
  281.                 break;
  283.             case 4: // '04'
  284.                 g.setColor(color1);
  285.                 g.fillRect(j - l / 2, k - l / 2, l + 1, l + 1);
  286.                 g.setColor(color);
  287.                 g.drawRect(j - l / 2, k - l / 2, l, l);
  288.                 break;
  290.             case 6: // '06'
  291.             case 7: // '07'
  292.             case 8: // 'b'
  293.                 int ai[] = new int[4];
  294.                 ai[0] = ai[2] = j;
  295.                 ai[1] = j + l / 2;
  296.                 ai[3] = j - l / 2;
  297.                 int ai1[] = new int[4];
  298.                 ai1[0] = k - l / 2;
  299.                 ai1[2] = k + l / 2;
  300.                 ai1[1] = ai1[3] = k;
  301.                 if(i1 == 7)
  302.                 {
  303.                     g.setColor(color1);
  304.                     g.fillPolygon(ai, ai1, 4);
  305.                 } else
  306.                 if(i1 == 8)
  307.                 {
  308.                     g.setColor(color);
  309.                     g.fillPolygon(ai, ai1, 4);
  310.                 }
  311.                 g.setColor(color);
  312.                 g.drawPolygon(ai, ai1, 4);
  313.                 break;
  314.             }
  315.         }
  316.         g.setClip(shape);
  317.     }
  319.     double getHighestValue(int i)
  320.     {
  321.         if(stackedOn)
  322.             return getMaxValue(-2);
  323.         else
  324.             return super.getHighestValue(i);
  325.     }
  327.     public double getMaxValue(int i)
  328.     {
  329.         if(i >= -1 || !stackedOn)
  330.             return super.getMaxValue(i);
  331.         double d = 0.0D;
  332.         int j = getSampleCount();
  333.         int k = getSeriesCount();
  334.         for(int l = 0; l < j; l++)
  335.         {
  336.             double d1 = 0.0D;
  337.             for(int i1 = 0; i1 < k; i1++)
  338.             {
  339.                 ChartSample chartsample = getSample(i1, l);
  340.                 if(chartsample != null && chartsample.value != null && !chartsample.value.isNaN() && chartsample.value.doubleValue() > 0.0D)
  341.                     d1 += chartsample.value.doubleValue();
  342.             }
  344.             d = Math.max(d, d1);
  345.         }
  347.         return d;
  348.     }
  350.     protected void calculateChartData(Rectangle rectangle, Rectangle rectangle1)
  351.     {
  352.         calculateZeroLines(rectangle);
  353.         if(is3DModeOn())
  354.             if(super.depth3d > -1)
  355.             {
  356.                 super.depth3dPoint.x = super.depth3d;
  357.                 super.depth3dPoint.y = -super.depth3d;
  358.             } else
  359.             {
  360.                 int i = Math.max(getSampleCount(), 20);
  361.                 int j = getSeriesCount();
  362.                 if(j > 1 && !stackedOn)
  363.                 {
  364.                     i /= j;
  365.                     i = Math.max(i, 4);
  366.                 }
  367.                 double d = (double)rectangle.width / (double)i;
  368.                 super.depth3dPoint.x = (int)Math.round(d * 1.25D);
  369.                 super.depth3dPoint.y = (int)Math.round(-d / 1.25D);
  370.             }
  371.     }
  373.     private void paintFloatingLabels(Graphics g, Rectangle rectangle)
  374.     {
  375.         boolean flag = isValueLabelsOn(-1) && valueLabelStyle == 2;
  376.         flag |= super.sampleLabelsOn && sampleLabelStyle == 2;
  377.         flag |= seriesLabelsOn;
  378.         if(flag)
  379.         {
  380.             Font font = getFont("floatingLabelFont");
  381.             g.setFont(font);
  382.             FontMetrics fontmetrics = g.getFontMetrics();
  383.             if(selectedSample >= 0 && selectedSeries >= 0)
  384.             {
  385.                 ChartSample chartsample = getSample(selectedSeries, selectedSample);
  386.                 if(chartsample != null && chartsample.value != null && !chartsample.value.isNaN())
  387.                 {
  388.                     String s = constructFloatingLabel(selectedSeries, selectedSample, seriesLabelsOn);
  389.                     paintFloatingLabel(g, rectangle, selectedSeries, selectedSample, s, font, fontmetrics);
  390.                 }
  391.             } else
  392.             if(selectedSeries >= 0 && isFloatingOnLegendOn())
  393.             {
  394.                 int i = getSampleCount();
  395.                 for(int j = 0; j < i; j++)
  396.                 {
  397.                     ChartSample chartsample1 = getSample(selectedSeries, j);
  398.                     if(chartsample1 != null && chartsample1.value != null && !chartsample1.value.isNaN())
  399.                     {
  400.                         String s1 = constructFloatingLabel(selectedSeries, j, false);
  401.                         paintFloatingLabel(g, rectangle, selectedSeries, j, s1, font, fontmetrics);
  402.                     }
  403.                 }
  405.             }
  406.         }
  407.     }
  409.     public boolean isSeriesLineOn(int i)
  410.     {
  411.         return seriesLinesOn[i];
  412.     }
  414.     public void setSampleLabelsOn(boolean flag)
  415.     {
  416.         super.sampleLabelsOn = flag;
  417.         super.hasChanged = true;
  418.         autoRepaint();
  419.     }
  421.     public boolean isSeriesLabelsOn()
  422.     {
  423.         return seriesLabelsOn;
  424.     }
  426.     /**
  427.      * @deprecated Method setLineWidth is deprecated
  428.      */
  430.     public void setLineWidth(int i)
  431.     {
  432.         setLineWidth(-1, i);
  433.     }
  435.     public void setLineWidth(int i, int j)
  436.     {
  437.         if(i >= 0 && i < lineWidth.length)
  438.             lineWidth[i] = j;
  439.         else
  440.         if(i < 0)
  441.         {
  442.             for(int k = 0; k < lineWidth.length; k++)
  443.                 lineWidth[k] = j;
  445.         }
  446.         super.hasChanged = true;
  447.         autoRepaint();
  448.     }
  450.     /**
  451.      * @deprecated Method getLineWidth is deprecated
  452.      */
  454.     public int getLineWidth()
  455.     {
  456.         return getLineWidth(0);
  457.     }
  459.     public int getLineWidth(int i)
  460.     {
  461.         if(i >= 0 && i < lineWidth.length)
  462.             return lineWidth[i];
  463.         else
  464.             return lineWidth[0];
  465.     }
  467.     public void setValueLabelStyle(int i)
  468.     {
  469.         valueLabelStyle = i;
  470.         super.hasChanged = true;
  471.         autoRepaint();
  472.     }
  474.     public int getValueLabelStyle()
  475.     {
  476.         return valueLabelStyle;
  477.     }
  479.     public boolean isSampleHighlightOn(int i, int j)
  480.     {
  481.         try
  482.         {
  483.             return sampleHighlightOn[i][j];
  484.         }
  485.         catch(IndexOutOfBoundsException _ex)
  486.         {
  487.             throw new IllegalArgumentException("Invalid series or index: " + i + ", " + j);
  488.         }
  489.     }
  491.     public ChartSample checkSelection(Point point)
  492.     {
  493.         if(point == null)
  494.             return null;
  495.         ChartSample chartsample = null;
  496.         getSeriesCount();
  497.         if(isLegendOn() && super.legendBounds != null)
  498.         {
  499.             for(int i = 0; i < super.legendBounds.length; i++)
  500.             {
  501.                 if(super.legendBounds[i] == null || !super.legendBounds[i].contains(point))
  502.                     continue;
  503.                 chartsample = new ChartSample(-1);
  504.                 chartsample.setSeries(i);
  505.                 break;
  506.             }
  508.         }
  509.         if(chartsample == null && samplePosition != null)
  510.         {
  511.             byte byte0 = 3;
  512.             for(int j = 0; j < samplePosition.length; j++)
  513.             {
  514.                 Point apoint[] = samplePosition[j];
  515.                 if(apoint != null)
  516.                 {
  517.                     for(int k = 0; k < apoint.length; k++)
  518.                         if(apoint[k] != null)
  519.                         {
  520.                             Point point1 = new Point(apoint[k]);
  521.                             if(is3DModeOn())
  522.                             {
  523.                                 point1.x -= super.depth3dPoint.x;
  524.                                 if(!stackedOn)
  525.                                 {
  526.                                     double d = (double)super.depth3dPoint.x / (double)getSeriesCount();
  527.                                     int l = (int)Math.round(d * (double)j);
  528.                                     point1.x += l;
  529.                                 }
  530.                             }
  531.                             boolean flag = point.x >= point1.x - byte0 && point.x <= point1.x + byte0;
  532.                             flag &= point.y >= point1.y - byte0 && point.y <= point1.y + byte0;
  533.                             if(flag)
  534.                                 return getSample(j, k);
  535.                         }
  537.                 }
  538.             }
  540.         }
  541.         return chartsample;
  542.     }
  544.     protected void renderData(Graphics g, Rectangle rectangle, Rectangle rectangle1)
  545.     {
  546.         paintLines(g, rectangle, rectangle1);
  547.     }
  549.     public void reset()
  550.     {
  551.         super.reset();
  552.         valueLabelStyle = 0;
  553.         autoLabelSpacingOn = false;
  554.         super.multiSeriesOn = true;
  555.         selectedSample = -1;
  556.         selectedSeries = -1;
  557.         super.hasChanged = true;
  558.     }
  560.     public void setSampleColors(Color acolor[])
  561.     {
  562.         super.setSampleColors(acolor);
  563.         if(acolor == null)
  564.             setSampleColor(2, new Color(132, 255, 198));
  565.         super.hasChanged = true;
  566.         autoRepaint();
  567.     }
  569.     public LineChart()
  570.     {
  571.         this(1, 5, 100D);
  572.     }
  574.     public LineChart(int i, int j, double d)
  575.     {
  576.         this(i, j, d, 0.0D);
  577.     }
  579.     public LineChart(int i, int j, double d, double d1)
  580.     {
  581.         super(j);
  582.         super.chartType = "line";
  583.         super.multiSeriesOn = true;
  584.         sampleHighlightOn = new boolean[i][j];
  585.         sampleHighlightStyle = new int[i];
  586.         sampleHighlightSize = new int[i];
  587.         seriesLinesOn = new boolean[i];
  588.         lineWidth = new int[i];
  589.         for(int k = 0; k < sampleHighlightSize.length; k++)
  590.         {
  591.             sampleHighlightSize[k] = 6;
  592.             seriesLinesOn[k] = true;
  593.             lineWidth[k] = 2;
  594.         }
  596.         connectedLinesOn = new boolean[i];
  597.         samplePosition = new Point[i][j];
  598.         for(int l = 0; l < samplePosition.length; l++)
  599.         {
  600.             for(int i1 = 0; i1 < samplePosition[l].length; i1++)
  601.                 samplePosition[l][i1] = new Point();
  603.         }
  605.         mousePosition = new Point();
  606.         setAutomaticRepaintOn(false);
  607.         setSeriesCount(i);
  608.         setRange(0, d);
  609.         setLowerRange(0, d1);
  610.         setSampleColors(null);
  611.         setAutomaticRepaintOn(true);
  612.         selectedSample = -1;
  613.         selectedSeries = -1;
  614.         lastSelectedLine = -1;
  615.     }
  617.     private void paintLine(Graphics g, int i, Rectangle rectangle, Rectangle rectangle1, Color color, boolean flag)
  618.     {
  619.         int j = getSeriesCount();
  620.         if(i < 0 || i >= j)
  621.             throw new IllegalArgumentException("Invalid series: " + i);
  622.         if(flag)
  623.             lastSelectedLine = i;
  624.         ChartSample achartsample[] = getSamples(i);
  625.         if(achartsample == null || achartsample.length == 0)
  626.             return;
  627.         double d = rectangle1.width;
  628.         if(achartsample.length - 1 > 0)
  629.             d = (double)(rectangle1.width - 1) / (double)(achartsample.length - 1);
  630.         Color color1 = !stackedOn && !flag ? color : color.darker();
  631.         boolean flag1 = is3DModeOn();
  632.         Graphics g1 = g;
  633.         if(flag1)
  634.             g1.setClip((rectangle.x - super.depth3dPoint.x) + 1, rectangle.y + 1, (rectangle.width + super.depth3dPoint.x) - 1, rectangle.height - super.depth3dPoint.y - 1);
  635.         else
  636.             g1.setClip(rectangle.x + 1, rectangle.y, rectangle.width - 1, rectangle.height + 1);
  637.         double d1 = rectangle1.x + 1;
  638.         int ai[] = new int[4];
  639.         int ai1[] = new int[4];
  640.         boolean flag2 = false;
  641.         double d2 = d1;
  642.         double d3 = calculateYPos(i, 0, rectangle1);
  643.         for(int k = 0; k < achartsample.length - 1; k++)
  644.         {
  645.             boolean flag3 = achartsample[k] != null && achartsample[k].value != null && !achartsample[k].value.isNaN();
  646.             boolean flag4 = achartsample[k + 1] != null && achartsample[k + 1].value != null && !achartsample[k + 1].value.isNaN();
  647.             if(flag3)
  648.             {
  649.                 d2 = d1;
  650.                 d3 = calculateYPos(i, k, rectangle1);
  651.                 flag2 = true;
  652.             }
  653.             boolean flag5 = flag3 && flag4;
  654.             flag5 |= flag4 && connectedLinesOn[i];
  655.             if(flag5 && flag2)
  656.             {
  657.                 if(connectedLinesOn[i])
  658.                 {
  659.                     ai[0] = (int)d2;
  660.                     ai1[0] = (int)d3;
  661.                 } else
  662.                 {
  663.                     ai[0] = (int)d1;
  664.                     ai1[0] = calculateYPos(i, k, rectangle1);
  665.                 }
  666.                 ai[1] = (int)(d1 + d);
  667.                 ai1[1] = calculateYPos(i, k + 1, rectangle1);
  668.                 if(flag1)
  669.                 {
  670.                     ai[0] -= super.depth3dPoint.x;
  671.                     ai[1] -= super.depth3dPoint.x;
  672.                     ai[2] -= super.depth3dPoint.x;
  673.                     ai[3] -= super.depth3dPoint.x;
  674.                     if(!stackedOn)
  675.                     {
  676.                         double d4 = (double)super.depth3dPoint.x / (double)j;
  677.                         int i2 = (int)Math.round(d4 * (double)i);
  678.                         ai[0] += i2;
  679.                         ai[1] += i2;
  680.                         ai[2] += i2;
  681.                         ai[3] += i2;
  682.                     }
  683.                 }
  684.                 if(stackedOn)
  685.                 {
  686.                     ai[2] = ai[1];
  687.                     ai1[2] = calculateYPos(i - 1, k + 1, rectangle1);
  688.                     ai[3] = ai[0];
  689.                     ai1[3] = calculateYPos(i - 1, k, rectangle1);
  690.                 }
  691.                 boolean flag7 = false;
  692.                 int l1 = rectangle.x - (flag1 ? super.depth3dPoint.x * 2 : 0);
  693.                 int j2 = rectangle.x + rectangle.width;
  694.                 flag7 |= ai[0] >= l1 && ai[0] <= j2;
  695.                 flag7 |= ai[1] >= l1 && ai[1] <= j2;
  696.                 flag7 |= ai[0] <= l1 && ai[1] >= j2;
  697.                 if(flag7)
  698.                 {
  699.                     ai[0] = Math.max(ai[0], -10000);
  700.                     ai[1] = Math.max(ai[1], -10000);
  701.                     ai[0] = Math.min(ai[0], 11000);
  702.                     ai[1] = Math.min(ai[1], 11000);
  703.                     ai1[0] = Math.max(ai1[0], -10000);
  704.                     ai1[1] = Math.max(ai1[1], -10000);
  705.                     ai1[0] = Math.min(ai1[0], 11000);
  706.                     ai1[1] = Math.min(ai1[1], 11000);
  707.                     if(seriesLinesOn[i])
  708.                         if(flag1 && stackedOn)
  709.                         {
  710.                             boolean flag8 = i == j - 1;
  711.                             boolean flag9 = k == achartsample.length - 2;
  712.                             if(k < achartsample.length - 2)
  713.                             {
  714.                                 flag9 |= achartsample[k + 2] == null || achartsample[k + 2].value == null || achartsample[k + 2].value.isNaN();
  715.                                 flag9 &= !connectedLinesOn[i];
  716.                             }
  717.                             paint3DLine(g1, ai[0], ai1[0], ai[1], ai1[1], ai1[2], color1, flag8, flag9);
  718.                         } else
  719.                         if(flag1)
  720.                             paint3DLine(g1, ai[0], ai1[0], ai[1], ai1[1], ai1[2], color1, true, false);
  721.                     if(stackedOn && seriesLinesOn[i])
  722.                     {
  723.                         g1.setColor(flag ? color.darker() : color);
  724.                         g1.fillPolygon(ai, ai1, 4);
  725.                         g1.setColor(color.darker());
  726.                         g1.drawLine(ai[1], ai1[1], ai[2], ai1[2]);
  727.                     }
  728.                     g1.setColor(color);
  729.                     if(flag1 && stackedOn)
  730.                         g1.setColor(color.darker().darker());
  731.                     else
  732.                     if(flag1 || stackedOn)
  733.                         g1.setColor(color.darker());
  734.                     if(seriesLinesOn[i] || flag)
  735.                     {
  736.                         g1.drawLine(ai[0], ai1[0], ai[1], ai1[1]);
  737.                         if(!flag1 && !stackedOn && lineWidth[i] > 1 && (seriesLinesOn[i] || flag))
  738.                         {
  739.                             double d5 = 0.0D;
  740.                             if(ai[1] - ai[0] != 0)
  741.                                 d5 = Math.abs((double)(ai1[1] - ai1[0]) / (double)(ai[1] - ai[0]));
  742.                             int k2 = 1;
  743.                             for(int i3 = 2; i3 <= lineWidth[i]; i3++)
  744.                             {
  745.                                 int j3 = (i3 / 2) * k2;
  746.                                 if(d5 <= 1.0D)
  747.                                     g1.drawLine(ai[0], ai1[0] + j3, ai[1], ai1[1] + j3);
  748.                                 else
  749.                                     g1.drawLine(ai[0] - j3, ai1[0], ai[1] - j3, ai1[1]);
  750.                                 k2 = -k2;
  751.                             }
  753.                         }
  754.                     }
  755.                     if(flag && seriesLinesOn[i] && !flag1 && !stackedOn)
  756.                     {
  757.                         double d6 = 0.0D;
  758.                         if(ai[1] - ai[0] != 0)
  759.                             d6 = Math.abs((double)(ai1[1] - ai1[0]) / (double)(ai[1] - ai[0]));
  760.                         int l2 = lineWidth[i] / 2 + 1;
  761.                         g1.setColor(color.darker().darker());
  762.                         if(d6 <= 1.0D)
  763.                             g1.drawLine(ai[0], ai1[0] + l2, ai[1], ai1[1] + l2);
  764.                         else
  765.                             g1.drawLine(ai[0] - l2, ai1[0], ai[1] - l2, ai1[1]);
  766.                     }
  767.                 }
  768.             }
  769.             d1 += d;
  770.         }
  772.         if(!flag1)
  773.         {
  774.             d1 = rectangle1.x + 1;
  775.             for(int l = 0; l < achartsample.length; l++)
  776.             {
  777.                 ChartSample chartsample = achartsample[l];
  778.                 if(chartsample != null && chartsample.value != null && !chartsample.value.isNaN() && sampleHighlightOn[i][l])
  779.                 {
  780.                     int k1 = calculateYPos(i, l, rectangle1);
  781.                     boolean flag6 = k1 >= rectangle.y && k1 <= rectangle.y + rectangle.height && d1 >= (double)rectangle.x && d1 <= (double)(rectangle.x + rectangle.width + 1);
  782.                     if(flag6)
  783.                         paintSampleHighlight(g, i, (int)Math.round(d1), k1, color);
  784.                 }
  785.                 d1 += d;
  786.             }
  788.         }
  789.         d1 = rectangle1.x + 1;
  790.         for(int i1 = 0; i1 < achartsample.length; i1++)
  791.         {
  792.             int j1 = calculateYPos(i, i1, rectangle1);
  793.             if(samplePosition != null && i < samplePosition.length && samplePosition[i] != null && i1 < samplePosition[i].length && samplePosition[i][i1] != null)
  794.             {
  795.                 samplePosition[i][i1].x = (int)Math.round(d1);
  796.                 samplePosition[i][i1].y = Math.round(j1);
  797.             }
  798.             d1 += d;
  799.         }
  801.         g.setClip(0, 0, 32767, 32767);
  802.     }
  804.     public boolean isAutoLabelSpacingOn()
  805.     {
  806.         return autoLabelSpacingOn;
  807.     }
  809.     public boolean isStackedOn()
  810.     {
  811.         return stackedOn;
  812.     }
  814.     public boolean isConnectedLinesOn(int i)
  815.     {
  816.         if(i >= 0 && i < connectedLinesOn.length)
  817.             return connectedLinesOn[i];
  818.         if(i == -1)
  819.         {
  820.             boolean flag = false;
  821.             for(int j = 0; j < connectedLinesOn.length; j++)
  822.                 if(connectedLinesOn[j])
  823.                     flag = true;
  825.             return flag;
  826.         } else
  827.         {
  828.             return false;
  829.         }
  830.     }
  832.     public void setLegendImage(int i, String s)
  833.     {
  834.         if(i >= 0 && i < 1000)
  835.         {
  836.             super.setLegendImage(i, s);
  837.             if(highlightImages == null)
  838.                 highlightImages = new String[i + 1];
  839.             if(i >= highlightImages.length)
  840.             {
  841.                 String as[] = new String[i + 1];
  842.                 System.arraycopy(highlightImages, 0, as, 0, highlightImages.length);
  843.                 highlightImages = as;
  844.             }
  845.             highlightImages[i] = s;
  846.             super.hasChanged = true;
  847.             autoRepaint();
  848.         }
  849.     }
  851.     private String constructFloatingLabel(int i, int j, boolean flag)
  852.     {
  853.         if(i < 0 || i >= getSeriesCount() || j < 0 || j >= getSampleCount())
  854.             return "";
  855.         String s = "";
  856.         if(flag)
  857.         {
  858.             String s1 = getSeriesLabel(i);
  859.             if(s1 != null)
  860.             {
  861.                 s += s1;
  862.                 if(!s1.endsWith("n") && super.sampleLabelsOn && sampleLabelStyle == 2 && getSampleLabel(j) != null)
  863.                     s += " : ";
  864.             }
  865.         }
  866.         if(super.sampleLabelsOn && sampleLabelStyle == 2 && getSampleLabel(j) != null)
  867.             s += getSampleLabel(j);
  868.         if(isValueLabelsOn() && valueLabelStyle == 2)
  869.         {
  870.             String s2 = getLabel("valueLabelPrefix_" + i);
  871.             if(s2 == null)
  872.                 s2 = getLabel("valueLabelPrefix");
  873.             String s3 = getLabel("valueLabelPostfix_" + i);
  874.             if(s3 == null)
  875.                 s3 = getLabel("valueLabelPostfix");
  876.             if(s.length() > 0)
  877.             {
  878.                 String s4 = formatNumber(getSampleValue(i, j), getSampleDecimalCount(i));
  879.                 s4 = s2 == null ? s4 : s2 + s4;
  880.                 s4 = s3 == null ? s4 : s4 + s3;
  881.                 if(s.endsWith("n"))
  882.                     s += s4;
  883.                 else
  884.                     s = s + " : " + s4;
  885.             } else
  886.             {
  887.                 s = formatNumber(getSampleValue(i, j), getSampleDecimalCount(i));
  888.                 s = s2 == null ? s : s2 + s;
  889.                 s = s3 == null ? s : s + s3;
  890.             }
  891.         }
  892.         return s;
  893.     }
  895.     private int calculateYPos(int i, int j, Rectangle rectangle)
  896.     {
  897.         double d = 0.0D;
  898.         if(i >= 0 && stackedOn)
  899.         {
  900.             for(int k = 0; k <= i; k++)
  901.                 d += getSampleValue(k, j);
  903.         } else
  904.         if(i >= 0)
  905.             d = getSampleValue(i, j);
  906.         int l = getSeriesRange(i);
  907.         double d1 = 0.0D;
  908.         if(super.currentUpperRange[l] - super.currentLowerRange[l] != 0.0D)
  909.             d1 = (d - super.currentLowerRange[l]) / (super.currentUpperRange[l] - super.currentLowerRange[l]);
  910.         int i1 = (rectangle.y + rectangle.height) - (int)(d1 * (double)rectangle.height);
  911.         boolean flag = is3DModeOn();
  912.         if(flag && stackedOn)
  913.             i1 -= super.depth3dPoint.y;
  914.         else
  915.         if(flag)
  916.         {
  917.             i1 -= super.depth3dPoint.y;
  918.             double d2 = ((double)super.depth3dPoint.y / (double)getSeriesCount()) * (double)i;
  919.             i1 += (int)Math.round(d2);
  920.         }
  921.         return i1;
  922.     }
  924.     private void paintValueLabels(Graphics g, Rectangle rectangle, Rectangle rectangle1, int i, boolean flag)
  925.     {
  926.         if(valueLabelStyle == 2)
  927.             return;
  928.         Font font = getFont("valueLabelFont");
  929.         g.setFont(font);
  930.         FontMetrics fontmetrics = g.getFontMetrics();
  931.         int j = fontmetrics.getAscent();
  932.         int k = getSampleDecimalCount(i);
  933.         int l = getSampleCount();
  934.         int i1 = getSeriesCount();
  935.         int j1 = getLabelAngle("valueLabelAngle");
  936.         getSize();
  937.         double d = rectangle1.x;
  938.         double d1 = rectangle1.width;
  939.         if(l > 2)
  940.             d1 = (double)rectangle1.width / (double)(l - 1);
  941.         double d2 = super.depth3dPoint.x;
  942.         boolean flag1 = is3DModeOn();
  943.         if(flag1)
  944.         {
  945.             d -= super.depth3dPoint.x;
  946.             double d3 = ((double)super.depth3dPoint.x / (double)i1) * (double)i;
  947.             d += d3;
  948.         }
  949.         g.setColor(getChartForeground());
  950.         String s = getLabel("valueLabelPrefix_" + i);
  951.         if(s == null)
  952.             s = getLabel("valueLabelPrefix");
  953.         String s1 = getLabel("valueLabelPostfix_" + i);
  954.         if(s1 == null)
  955.             s1 = getLabel("valueLabelPostfix");
  956.         ChartSample achartsample[] = getSamples(i);
  957.         for(int k1 = 0; k1 < achartsample.length; k1++)
  958.         {
  959.             if(!flag && (achartsample[k1] == null || achartsample[k1].value == null || achartsample[k1].value.isNaN()))
  960.             {
  961.                 d += d1;
  962.                 continue;
  963.             }
  964.             double d4 = 0.0D;
  965.             if(flag)
  966.             {
  967.                 boolean flag2 = false;
  968.                 for(int l1 = 0; l1 < i1; l1++)
  969.                 {
  970.                     ChartSample chartsample = getSample(l1, k1);
  971.                     if(chartsample != null && chartsample.value != null && !chartsample.value.isNaN())
  972.                     {
  973.                         d4 += chartsample.value.doubleValue();
  974.                         flag2 = true;
  975.                     }
  976.                 }
  978.                 if(!flag2)
  979.                 {
  980.                     d += d1;
  981.                     continue;
  982.                 }
  983.             } else
  984.             {
  985.                 d4 = achartsample[k1].getFloatValue();
  986.             }
  987.             String s2 = formatNumber(d4, k);
  988.             s2 = s == null ? s2 : s + s2;
  989.             s2 = s1 == null ? s2 : s2 + s1;
  990.             Dimension dimension = getLabelSize(s2, font);
  991.             Dimension dimension1 = getAngledLabelSize(dimension, j1);
  992.             int i2 = (int)Math.round(d - (double)(dimension1.width / 2)) + 1;
  993.             if(valueLabelStyle == 0)
  994.             {
  995.                 if(flag1)
  996.                     i2 = Math.max((rectangle1.x - super.depth3dPoint.x) + 2, i2);
  997.                 else
  998.                     i2 = Math.max(rectangle1.x + 2, i2);
  999.                 i2 = Math.min(i2, (rectangle.x + rectangle.width) - dimension1.width - 1);
  1000.             }
  1001.             if(j1 % 360 > 90 && j1 % 360 < 180 || j1 % 360 > 270)
  1002.                 i2 = (int)(d - (double)(fontmetrics.getAscent() / 2));
  1003.             int j2 = calculateYPos(i, k1, rectangle1) - 1;
  1004.             int k2 = j2;
  1005.             if(j1 % 180 != 0)
  1006.                 k2 -= dimension1.height + 1;
  1007.             if(valueLabelStyle == 1)
  1008.             {
  1009.                 if(j1 % 180 == 0)
  1010.                     k2 += j / 2;
  1011.                 else
  1012.                     k2 = j2 - dimension1.height / 2;
  1013.             } else
  1014.             if(!stackedOn)
  1015.             {
  1016.                 double d5 = k1 <= 0 || achartsample[k1 - 1] == null ? d4 : achartsample[k1 - 1].getFloatValue();
  1017.                 double d7 = k1 >= achartsample.length - 1 || achartsample[k1 + 1] == null ? d4 : achartsample[k1 + 1].getFloatValue();
  1018.                 double d9 = (d4 - d5) / d1;
  1019.                 double d10 = (d7 - d4) / d1;
  1020.                 if(d9 < d10)
  1021.                 {
  1022.                     if(j1 % 180 == 0)
  1023.                         k2 += j;
  1024.                     else
  1025.                         k2 += dimension1.height + 4;
  1026.                     if(j1 % 360 > 90 && j1 % 360 < 180 || j1 % 360 > 270)
  1027.                         i2 = (int)((d - (double)dimension1.width) + (double)(fontmetrics.getAscent() / 2));
  1028.                 } else
  1029.                 if(flag1)
  1030.                 {
  1031.                     double d11 = (double)super.depth3dPoint.x / (double)i1;
  1032.                     i2 = (int)((double)i2 + d11);
  1033.                     d11 = (double)super.depth3dPoint.y / (double)i1;
  1034.                     k2 = (int)((double)k2 + d11);
  1035.                 }
  1036.                 try
  1037.                 {
  1038.                     boolean flag4 = sampleHighlightOn[i][k1];
  1039.                     int l2 = sampleHighlightSize[i];
  1040.                     if(flag4 && d9 < d10)
  1041.                         k2 += l2 / 2;
  1042.                     else
  1043.                     if(flag4)
  1044.                         k2 -= l2 / 2;
  1045.                 }
  1046.                 catch(IndexOutOfBoundsException indexoutofboundsexception)
  1047.                 {
  1048.                     System.out.println("Internal error with value labels");
  1049.                     indexoutofboundsexception.printStackTrace();
  1050.                 }
  1051.             }
  1052.             boolean flag3 = true;
  1053.             if(flag1)
  1054.             {
  1055.                 if(j2 <= k2)
  1056.                 {
  1057.                     flag3 = j2 >= rectangle.y - 2 && j2 <= (rectangle.y + rectangle.height + 2) - super.depth3dPoint.y && d >= (double)(rectangle.x - 2 - super.depth3dPoint.x) && d <= (double)(rectangle.x + rectangle.width + 2);
  1058.                 } else
  1059.                 {
  1060.                     double d6 = (double)super.depth3dPoint.x / (double)i1;
  1061.                     double d8 = (double)super.depth3dPoint.y / (double)i1;
  1062.                     flag3 = (double)j2 >= (double)rectangle.y - d8 - 2D && (double)j2 <= (double)((rectangle.y + rectangle.height) - super.depth3dPoint.y) - d8 && d >= (double)(rectangle.x - super.depth3dPoint.x) - d6 - 2D && d <= ((double)(rectangle.x + rectangle.width) - d6) + 2D;
  1063.                 }
  1064.             } else
  1065.             {
  1066.                 flag3 = j2 >= rectangle.y - 2 && j2 <= rectangle.y + rectangle.height + 2 && d >= (double)(rectangle.x - 4) && d <= (double)(rectangle.x + rectangle.width + 2);
  1067.             }
  1068.             if(flag3)
  1069.                 paintLabel(g, s2, i2, k2, dimension, 0, j1);
  1070.             d += d1;
  1071.         }
  1073.     }
  1075.     public void render(Graphics g)
  1076.     {
  1077.         render(g, !isServletModeOn());
  1078.     }
  1080.     void render(Graphics g, boolean flag)
  1081.     {
  1082.         Dimension dimension = getSize();
  1083.         Rectangle rectangle = getGraphBounds();
  1084.         Rectangle rectangle1 = getDataBounds(rectangle);
  1085.         calculateChartData(rectangle, rectangle1);
  1086.         for(int i = 0; i < super.overlayCharts.size(); i++)
  1087.         {
  1088.             Chart chart = (Chart)super.overlayCharts.elementAt(i);
  1089.             if(chart != null)
  1090.             {
  1091.                 Rectangle rectangle2 = new Rectangle(rectangle);
  1092.                 Rectangle rectangle4 = new Rectangle(rectangle1);
  1093.                 if(is3DModeOn())
  1094.                 {
  1095.                     rectangle2.x -= super.depth3dPoint.x;
  1096.                     rectangle2.y -= super.depth3dPoint.y;
  1097.                     rectangle4.x -= super.depth3dPoint.x;
  1098.                     rectangle4.y -= super.depth3dPoint.y;
  1099.                 }
  1100.                 chart.calculateChartData(rectangle2, rectangle4);
  1101.             }
  1102.         }
  1104.         if(flag && super.offscreen == null)
  1105.         {
  1106.             super.offscreen = createImage(Math.max(1, dimension.width), Math.max(1, dimension.height));
  1107.             super.hasChanged = true;
  1108.         }
  1109.         if(!flag || super.hasChanged || super.offscreen == null)
  1110.         {
  1111.             if(!super.externalGraphicsOn && !flag)
  1112.                 super.og = g;
  1113.             else
  1114.             if(flag || super.externalGraphicsOn)
  1115.             {
  1116.                 if(!super.externalGraphicsOn && super.offscreen != null)
  1117.                     super.og = super.offscreen.getGraphics();
  1118.                 super.og.setColor(getBackground());
  1119.                 super.og.fillRect(0, 0, dimension.width, dimension.height);
  1120.             }
  1121.             paintGrid(super.og, rectangle);
  1122.             paintTitle(super.og, dimension);
  1123.             if(super.sampleLabelsOn && sampleLabelStyle != 2)
  1124.                 paintSampleLabels(super.og, rectangle, rectangle1);
  1125.             if(isLegendOn())
  1126.                 paintLegend(super.og, rectangle, getLegendLabels());
  1127.             renderData(super.og, rectangle, rectangle1);
  1128.             for(int j = 0; j < super.overlayCharts.size(); j++)
  1129.             {
  1130.                 Chart chart1 = (Chart)super.overlayCharts.elementAt(j);
  1131.                 if(chart1 != null && isOverlayChartOn(j))
  1132.                 {
  1133.                     Rectangle rectangle3 = new Rectangle(rectangle);
  1134.                     Rectangle rectangle5 = new Rectangle(rectangle1);
  1135.                     rectangle3.x -= super.depth3dPoint.x;
  1136.                     rectangle3.y -= super.depth3dPoint.y;
  1137.                     rectangle5.x -= super.depth3dPoint.x;
  1138.                     rectangle5.y -= super.depth3dPoint.y;
  1139.                     if((chart1 instanceof LineChart) || (chart1 instanceof PieChart))
  1140.                         chart1.renderData(super.og, rectangle3, rectangle5);
  1141.                     else
  1142.                         chart1.renderData(super.og, rectangle, rectangle1);
  1143.                 }
  1144.             }
  1146.             if(is3DModeOn())
  1147.             {
  1148.                 for(int k = super.rangeOn.length - 1; k >= 0; k--)
  1149.                     paint3DZeroDivider(super.og, rectangle, k);
  1151.                 if(isRangeOn(1))
  1152.                     paint3DEdges(super.og, rectangle);
  1153.             }
  1154.             if(!super.externalGraphicsOn && super.og != g)
  1155.                 super.og.dispose();
  1156.             super.hasChanged = false;
  1157.         }
  1158.         if((flag || super.externalGraphicsOn) && super.offscreen != null)
  1159.             g.drawImage(super.offscreen, 0, 0, this);
  1160.         paintFloatingLabels(g, rectangle);
  1161.     }
  1163.     private void paintLines(Graphics g, Rectangle rectangle, Rectangle rectangle1)
  1164.     {
  1165.         int i = getSeriesCount();
  1166.         if(i > 0)
  1167.         {
  1168.             for(int j = i - 1; j >= 0; j--)
  1169.             {
  1170.                 int i1 = getSeriesRange(j);
  1171.                 if(super.currentUpperRange[i1] != super.currentLowerRange[i1])
  1172.                     paintLine(g, j, rectangle, rectangle1, getSampleColor(j), isSelected(j, -1));
  1173.             }
  1175.             if(!is3DModeOn() && lastSelectedLine >= 0)
  1176.             {
  1177.                 int k = lastSelectedLine;
  1178.                 paintLine(g, k, rectangle, rectangle1, getSampleColor(k), isSelected(k, -1));
  1179.             }
  1180.             if(stackedOn)
  1181.             {
  1182.                 if(isValueLabelsOn(0))
  1183.                     paintValueLabels(g, rectangle, rectangle1, i - 1, true);
  1184.             } else
  1185.             {
  1186.                 for(int l = i - 1; l >= 0; l--)
  1187.                     if(isValueLabelsOn(l))
  1188.                         paintValueLabels(g, rectangle, rectangle1, l, false);
  1190.             }
  1191.         }
  1192.     }
  1194.     public int getValuePosition(double d)
  1195.     {
  1196.         return getValuePosition(0, d, getGraphBounds());
  1197.     }
  1199.     public void setSeriesLabelsOn(boolean flag)
  1200.     {
  1201.         seriesLabelsOn = flag;
  1202.         super.hasChanged = true;
  1203.         autoRepaint();
  1204.     }
  1206.     public void setSampleHighlightOn(boolean flag)
  1207.     {
  1208.         for(int i = 0; i < sampleHighlightOn.length; i++)
  1209.         {
  1210.             for(int j = 0; j < sampleHighlightOn[i].length; j++)
  1211.                 sampleHighlightOn[i][j] = flag;
  1213.         }
  1215.         super.hasChanged = true;
  1216.         autoRepaint();
  1217.     }
  1219.     public void setSampleHighlightOn(int i, boolean flag)
  1220.     {
  1221.         try
  1222.         {
  1223.             for(int j = 0; j < sampleHighlightOn[i].length; j++)
  1224.                 sampleHighlightOn[i][j] = flag;
  1226.         }
  1227.         catch(IndexOutOfBoundsException _ex)
  1228.         {
  1229.             throw new IllegalArgumentException("Invalid series: " + i);
  1230.         }
  1231.         super.hasChanged = true;
  1232.         autoRepaint();
  1233.     }
  1235.     public void setSampleHighlightOn(int i, int j, boolean flag)
  1236.     {
  1237.         try
  1238.         {
  1239.             sampleHighlightOn[i][j] = flag;
  1240.         }
  1241.         catch(IndexOutOfBoundsException _ex)
  1242.         {
  1243.             throw new IllegalArgumentException("Invalid series or index: " + i + ", " + j);
  1244.         }
  1245.         super.hasChanged = true;
  1246.         autoRepaint();
  1247.     }
  1249.     public int getSampleHighlightSize(int i)
  1250.     {
  1251.         try
  1252.         {
  1253.             return sampleHighlightSize[i];
  1254.         }
  1255.         catch(IndexOutOfBoundsException _ex)
  1256.         {
  1257.             throw new IllegalArgumentException("Invalid series: " + i);
  1258.         }
  1259.     }
  1261.     protected void checkDataIntegrity()
  1262.     {
  1263.         super.checkDataIntegrity();
  1264.         int i = getSeriesCount();
  1265.         int j = getSampleCount();
  1266.         int k = sampleHighlightOn.length;
  1267.         int l = k <= 0 ? 0 : sampleHighlightOn[0].length;
  1268.         if(i != k || j != l)
  1269.         {
  1270.             boolean aflag[][] = new boolean[i][j];
  1271.             for(int j1 = 0; j1 < i; j1++)
  1272.             {
  1273.                 for(int l1 = 0; l1 < j; l1++)
  1274.                     if(j1 < k && l1 < l)
  1275.                         aflag[j1][l1] = sampleHighlightOn[j1][l1];
  1277.             }
  1279.             sampleHighlightOn = aflag;
  1280.             int ai[] = new int[i];
  1281.             int ai1[] = new int[i];
  1282.             boolean aflag1[] = new boolean[i];
  1283.             boolean aflag2[] = new boolean[i];
  1284.             int ai2[] = new int[i];
  1285.             for(int i2 = 0; i2 < i; i2++)
  1286.                 if(i2 < k)
  1287.                 {
  1288.                     ai[i2] = sampleHighlightStyle[i2];
  1289.                     ai1[i2] = sampleHighlightSize[i2];
  1290.                     aflag1[i2] = seriesLinesOn[i2];
  1291.                     aflag2[i2] = connectedLinesOn[i2];
  1292.                     ai2[i2] = lineWidth[i2];
  1293.                 } else
  1294.                 {
  1295.                     ai1[i2] = 6;
  1296.                     aflag1[i2] = true;
  1297.                     ai2[i2] = 2;
  1298.                 }
  1300.             sampleHighlightStyle = ai;
  1301.             sampleHighlightSize = ai1;
  1302.             seriesLinesOn = aflag1;
  1303.             connectedLinesOn = aflag2;
  1304.             lineWidth = ai2;
  1305.         }
  1306.         samplePosition = new Point[i][j];
  1307.         for(int i1 = 0; i1 < samplePosition.length; i1++)
  1308.         {
  1309.             for(int k1 = 0; k1 < samplePosition[i1].length; k1++)
  1310.                 samplePosition[i1][k1] = new Point();
  1312.         }
  1314.         if(lastSelectedLine >= i)
  1315.             lastSelectedLine = -1;
  1316.     }
  1318.     public Rectangle getGraphBounds()
  1319.     {
  1320.         if(!super.hasChanged && super.currentBounds != null)
  1321.             return super.currentBounds;
  1322.         Rectangle rectangle = super.getGraphBounds(getLegendLabels());
  1323.         Dimension dimension = getSize();
  1324.         int i = rectangle.x;
  1325.         int j = dimension.width - rectangle.width - rectangle.x;
  1326.         int k = rectangle.y;
  1327.         int l = dimension.height - rectangle.height - rectangle.y;
  1328.         for(int i1 = 0; i1 < super.rangeAdjusterOn.length; i1++)
  1329.             if(super.rangeAdjusterOn[i1])
  1330.                 if(super.rangeAdjusterPosition[i1] == 0)
  1331.                     i += 6;
  1332.                 else
  1333.                     j += 6;
  1335.         if(super.sampleLabelsOn && getSampleCount() > 0 && sampleLabelStyle != 2)
  1336.         {
  1337.             Font font = getFont("sampleLabelFont");
  1338.             FontMetrics fontmetrics = getFontMetrics(font);
  1339.             int k1 = 0;
  1340.             int j2 = getLabelAngle("sampleLabelAngle");
  1341.             String as[] = getSampleLabels();
  1342.             for(int k3 = 0; k3 < as.length; k3++)
  1343.             {
  1344.                 Dimension dimension2 = getLabelSize(as[k3], font);
  1345.                 Dimension dimension5 = getAngledLabelSize(dimension2, j2);
  1346.                 k1 = Math.max(dimension5.height, k1);
  1347.             }
  1349.             l += k1 + 3;
  1350.             if(j2 % 180 == 0)
  1351.                 l -= fontmetrics.getMaxDescent();
  1352.             String s4 = getSampleLabel(getSampleCount() - 1);
  1353.             int j4 = 0;
  1354.             if(s4 != null)
  1355.             {
  1356.                 Dimension dimension6 = getLabelSize(s4, font);
  1357.                 Dimension dimension8 = getAngledLabelSize(dimension6, j2);
  1358.                 j4 = dimension8.width / 2 - 5;
  1359.             }
  1360.             int i5 = 0;
  1361.             if(isLegendOn() && getLegendPosition() == 1)
  1362.                 i5 = super.legend.width;
  1363.             if(j4 > i5)
  1364.                 j += j4 - i5;
  1365.         }
  1366.         boolean flag = false;
  1367.         for(int j1 = 0; j1 < super.rangeOn.length; j1++)
  1368.             flag = super.rangeOn[j1] ? true : flag;
  1370.         if(flag || super.rangeLabelsOn || super.targetsLabel.size() > 0)
  1371.         {
  1372.             FontMetrics fontmetrics1 = getFontMetrics(getFont("rangeLabelFont"));
  1373.             String s1 = getLabel("rangeLabelPrefix");
  1374.             String s2 = getLabel("rangeLabelPostfix");
  1375.             int l2 = 0;
  1376.             int l3 = 0;
  1377.             for(Enumeration enumeration = super.targetsLabel.keys(); enumeration.hasMoreElements();)
  1378.             {
  1379.                 String s5 = (String)enumeration.nextElement();
  1380.                 String s8 = getTargetLabel(s5);
  1381.                 if(s8 != null && s8.length() > 0)
  1382.                     if(super.rangePosition[0] == 0)
  1383.                         l2 = Math.max(l2, fontmetrics1.stringWidth(s8));
  1384.                     else
  1385.                         l3 = Math.max(l3, fontmetrics1.stringWidth(s8));
  1386.             }
  1388.             if(super.rangeLabelsOn && super.rangeOn[0])
  1389.             {
  1390.                 int k4 = getRangeDecimalCount(0);
  1391.                 String s6 = formatNumber(super.upperRange[0], k4);
  1392.                 String s9 = formatNumber(super.lowerRange[0], k4);
  1393.                 s6 = s1 == null ? s6 : s1 + s6;
  1394.                 s9 = s1 == null ? s9 : s1 + s9;
  1395.                 s6 = s2 == null ? s6 : s6 + s2;
  1396.                 s9 = s2 == null ? s9 : s9 + s2;
  1397.                 if(super.rangePosition[0] == 0)
  1398.                 {
  1399.                     l2 = Math.max(l2, fontmetrics1.stringWidth(s6));
  1400.                     l2 = Math.max(l2, fontmetrics1.stringWidth(s9));
  1401.                 } else
  1402.                 {
  1403.                     l3 = Math.max(l3, fontmetrics1.stringWidth(s6));
  1404.                     l3 = Math.max(l3, fontmetrics1.stringWidth(s9));
  1405.                 }
  1406.             }
  1407.             if(super.rangeOn[1])
  1408.             {
  1409.                 int l4 = getRangeDecimalCount(1);
  1410.                 String s7 = formatNumber(super.upperRange[1], l4);
  1411.                 String s10 = formatNumber(super.lowerRange[1], l4);
  1412.                 if(super.rangePosition[1] == 0)
  1413.                 {
  1414.                     l2 = Math.max(l2, fontmetrics1.stringWidth(s7));
  1415.                     l2 = Math.max(l2, fontmetrics1.stringWidth(s10));
  1416.                 } else
  1417.                 {
  1418.                     l3 = Math.max(l3, fontmetrics1.stringWidth(s7));
  1419.                     l3 = Math.max(l3, fontmetrics1.stringWidth(s10));
  1420.                 }
  1421.             }
  1422.             i += l2 + 2;
  1423.             j += l3 <= 0 ? 0 : l3 + 2;
  1424.         }
  1425.         String s = getLabel("sampleAxisLabel");
  1426.         if(s != null)
  1427.         {
  1428.             Font font1 = getFont("sampleAxisLabelFont");
  1429.             FontMetrics fontmetrics2 = getFontMetrics(font1);
  1430.             int i3 = getLabelAngle("sampleAxisLabelAngle");
  1431.             Dimension dimension1 = getLabelSize(s, font1);
  1432.             Dimension dimension3 = getAngledLabelSize(dimension1, i3);
  1433.             l += dimension3.height + 3;
  1434.             if(i3 % 180 == 0)
  1435.                 l -= fontmetrics2.getDescent();
  1436.         }
  1437.         int l1 = 0;
  1438.         do
  1439.         {
  1440.             String s3 = l1 != 0 ? getLabel("rangeAxisLabel_2") : getLabel("rangeAxisLabel");
  1441.             if(s3 != null)
  1442.             {
  1443.                 Font font2 = getFont("rangeAxisLabelFont");
  1444.                 getFontMetrics(font2);
  1445.                 int i4 = l1 != 0 ? getLabelAngle("rangeAxisLabelAngle_2") : getLabelAngle("rangeAxisLabelAngle");
  1446.                 Dimension dimension4 = getLabelSize(s3, font2);
  1447.                 Dimension dimension7 = getAngledLabelSize(dimension4, i4);
  1448.                 if(super.rangePosition[l1] == 0)
  1449.                     i += dimension7.width + 20;
  1450.                 else
  1451.                     j += dimension7.width + 20;
  1452.             }
  1453.         } while(++l1 < 2);
  1454.         if(is3DModeOn())
  1455.             if(super.depth3d > -1)
  1456.             {
  1457.                 i += super.depth3dPoint.x;
  1458.                 l -= super.depth3dPoint.y;
  1459.             } else
  1460.             {
  1461.                 int i2 = Math.max(20, getSampleCount());
  1462.                 int k2 = getSeriesCount();
  1463.                 if(k2 > 1 && !stackedOn)
  1464.                 {
  1465.                     i2 /= k2;
  1466.                     i2 = Math.max(i2, 4);
  1467.                 }
  1468.                 int j3 = (int)(((float)rectangle.width * 1.25F) / ((float)i2 + 1.25F));
  1469.                 i += j3;
  1470.                 rectangle.width = dimension.width - i - j;
  1471.                 double d = rectangle.width / i2;
  1472.                 l += (int)Math.round(d / 1.25D);
  1473.             }
  1474.         Insets insets = getGraphInsets();
  1475.         if(insets != null)
  1476.         {
  1477.             k = insets.top != -1 ? insets.top : k;
  1478.             i = insets.left != -1 ? insets.left : i;
  1479.             l = insets.bottom != -1 ? insets.bottom : l;
  1480.             j = insets.right != -1 ? insets.right : j;
  1481.         }
  1482.         rectangle.x = i;
  1483.         rectangle.width = dimension.width - i - j - 1;
  1484.         rectangle.y = k;
  1485.         rectangle.height = dimension.height - k - l - 1;
  1486.         super.currentBounds = rectangle;
  1487.         return rectangle;
  1488.     }
  1490.     private void paint3DLine(Graphics g, int i, int j, int k, int l, int i1, Color color, 
  1491.             boolean flag, boolean flag1)
  1492.     {
  1493.         int ai[] = new int[4];
  1494.         int ai1[] = new int[4];
  1495.         int j1 = stackedOn ? 1 : Math.max(1, getSeriesCount());
  1496.         int k1 = (int)Math.round((double)super.depth3dPoint.x / (double)j1);
  1497.         int l1 = (int)Math.round((double)super.depth3dPoint.y / (double)j1);
  1498.         ai[0] = i;
  1499.         ai1[0] = j;
  1500.         ai[1] = i + k1;
  1501.         ai1[1] = j + l1;
  1502.         ai[2] = ai[1] + (k - i);
  1503.         ai1[2] = l + l1;
  1504.         ai[3] = k;
  1505.         ai1[3] = l;
  1506.         Color color1 = color.darker();
  1507.         if(flag)
  1508.         {
  1509.             double d = 0.0D;
  1510.             if(ai[1] - ai[0] != 0)
  1511.                 d = (double)(j - l) / (double)(k - i);
  1512.             if(d > 0.68999999999999995D)
  1513.                 g.setColor(color1);
  1514.             else
  1515.                 g.setColor(color);
  1516.             g.fillPolygon(ai, ai1, 4);
  1517.             g.setColor(color1);
  1518.             g.drawLine(ai[0], ai1[0], ai[1], ai1[1]);
  1519.             g.drawLine(ai[1], ai1[1], ai[2], ai1[2]);
  1520.             g.drawLine(ai[2], ai1[2], ai[3], ai1[3]);
  1521.         }
  1522.         if(flag1)
  1523.         {
  1524.             ai[0] = ai[3];
  1525.             ai1[0] = ai1[3];
  1526.             ai[1] = ai[2];
  1527.             ai1[1] = ai1[2];
  1528.             ai[2] = ai[2];
  1529.             ai1[2] = i1 + l1;
  1530.             ai[3] = ai[0];
  1531.             ai1[3] = i1;
  1532.             g.setColor(color);
  1533.             g.fillPolygon(ai, ai1, 4);
  1534.             g.setColor(color1);
  1535.             g.drawLine(ai[0], ai1[0], ai[1], ai1[1]);
  1536.             g.drawLine(ai[1], ai1[1], ai[2], ai1[2]);
  1537.             g.drawLine(ai[2], ai1[2], ai[3], ai1[3]);
  1538.             g.drawLine(ai[3], ai1[3], ai[0], ai1[0]);
  1539.         }
  1540.     }
  1542.     private void paint3DZeroDivider(Graphics g, Rectangle rectangle, int i)
  1543.     {
  1544.         i = Math.min(super.rangeOn.length - 1, Math.max(0, i));
  1545.         if(super.rangeOn[i])
  1546.         {
  1547.             int j = Math.max(super.zeroLine[i], rectangle.y);
  1548.             j = Math.min(j, rectangle.y + rectangle.height);
  1549.             int k = rectangle.x - super.depth3dPoint.x;
  1550.             int l = j - super.depth3dPoint.y;
  1551.             g.setColor(i != 0 ? getRangeColor(i) : getChartForeground());
  1552.             g.drawLine(k, l, k + rectangle.width, l);
  1553.             g.drawLine(k + rectangle.width, l, rectangle.x + rectangle.width, j);
  1554.         }
  1555.     }
  1557.     private void paintFloatingLabel(Graphics g, Rectangle rectangle, int i, int j, String s, Font font, FontMetrics fontmetrics)
  1558.     {
  1559.         if(i < 0 || i >= getSeriesCount() || j < 0 || j >= getSampleCount())
  1560.             return;
  1561.         Point point = null;
  1562.         if(samplePosition != null && i < samplePosition.length && samplePosition[i] != null && j <= samplePosition[i].length)
  1563.             point = samplePosition[i][j];
  1564.         if(point == null)
  1565.             return;
  1566.         int k = 0;
  1567.         if(is3DModeOn())
  1568.             if(stackedOn)
  1569.             {
  1570.                 k = -super.depth3d;
  1571.             } else
  1572.             {
  1573.                 double d = (double)super.depth3dPoint.x / (double)getSeriesCount();
  1574.                 k = (int)Math.round(d * (double)i) - super.depth3dPoint.x;
  1575.             }
  1576.         if(point.x < rectangle.x || point.x > (rectangle.x + rectangle.width) - k)
  1577.             return;
  1578.         if(point.y < rectangle.y || point.y > (is3DModeOn() ? (rectangle.y + rectangle.height) - super.depth3dPoint.y : rectangle.y + rectangle.height))
  1579.         {
  1580.             return;
  1581.         } else
  1582.         {
  1583.             Dimension dimension = getLabelSize(s, font);
  1584.             int l = (point.x - dimension.width / 2) + k;
  1585.             int i1 = ((point.y - dimension.height) + fontmetrics.getAscent()) - 3;
  1586.             Dimension dimension1 = getSize();
  1587.             l = Math.max(l, 3);
  1588.             l = Math.min(l, dimension1.width - dimension.width - 3);
  1589.             i1 = Math.max(i1, fontmetrics.getAscent());
  1590.             i1 = Math.min(i1, ((dimension1.height - dimension.height) + fontmetrics.getAscent()) - 1);
  1591.             int j1 = fontmetrics.getHeight();
  1592.             int k1 = fontmetrics.getDescent();
  1593.             g.setColor(new Color(255, 255, 231));
  1594.             g.fillRect(l - 2, ((i1 - j1) + k1 * 2) - 2, dimension.width + 5, dimension.height);
  1595.             g.setColor(getChartForeground());
  1596.             g.setColor(getSampleColor(i).darker());
  1597.             g.drawRect(l - 3, ((i1 - j1) + k1 * 2) - 3, dimension.width + 5, dimension.height);
  1598.             g.setColor(Color.black);
  1599.             paintLabel(g, s, l, i1, dimension, 0, 0);
  1600.             return;
  1601.         }
  1602.     }
  1604.     public void setSampleHighlightStyle(int i, int j)
  1605.     {
  1606.         for(int k = 0; k < sampleHighlightStyle.length; k++)
  1607.             setSampleHighlightStyle(k, i, j);
  1609.     }
  1611.     public static final int SAMPLE_HIGHLIGHT_CIRCLE = 0;
  1612.     public static final int SAMPLE_HIGHLIGHT_CIRCLE_OPAQUE = 1;
  1613.     public static final int SAMPLE_HIGHLIGHT_CIRCLE_FILLED = 2;
  1614.     public static final int SAMPLE_HIGHLIGHT_SQUARE = 3;
  1615.     public static final int SAMPLE_HIGHLIGHT_SQUARE_OPAQUE = 4;
  1616.     public static final int SAMPLE_HIGHLIGHT_SQUARE_FILLED = 5;
  1617.     public static final int SAMPLE_HIGHLIGHT_DIAMOND = 6;
  1618.     public static final int SAMPLE_HIGHLIGHT_DIAMOND_OPAQUE = 7;
  1619.     public static final int SAMPLE_HIGHLIGHT_DIAMOND_FILLED = 8;
  1620.     public static final int VALUE_LABELS_OUTSIDE_POINT = 0;
  1621.     public static final int VALUE_LABELS_AT_POINT = 1;
  1622.     public static final int FLOATING = 2;
  1623.     public static final int BELOW = 3;
  1624.     private int valueLabelStyle;
  1625.     private int sampleLabelStyle;
  1626.     private boolean seriesLabelsOn;
  1627.     private boolean autoLabelSpacingOn;
  1628.     private int lineWidth[];
  1629.     private boolean stackedOn;
  1630.     private boolean sampleHighlightOn[][];
  1631.     private int sampleHighlightStyle[];
  1632.     private int sampleHighlightSize[];
  1633.     private boolean seriesLinesOn[];
  1634.     private boolean connectedLinesOn[];
  1635.     private String highlightImages[];
  1636.     private Point samplePosition[][];
  1637.     private int selectedSeries;
  1638.     private int selectedSample;
  1639.     private Point mousePosition;
  1640.     private int lastSelectedLine;
  1641. }