chart.java

一个完整的

                    {
                        g.drawLine(l1, j1, l1 - 3, j1);
                        i2 = l1 - i1 - 4;
                        if(rangeAdjusterOn[0] && rangeAdjusterPosition[0] == 0 || rangeAdjusterOn[1] && rangeAdjusterPosition[1] == 0)
                            i2 -= 6;
                    } else
                    {
                        g.drawLine(l1 + rectangle.width, j1, l1 + rectangle.width + 2, j1);
                        i2 = rectangle.x + rectangle.width + 5;
                        if(rangeAdjusterOn[0] && rangeAdjusterPosition[0] == 1 || rangeAdjusterOn[1] && rangeAdjusterPosition[1] == 1)
                            i2 += 7;
                    }
                    int j2 = ((j1 + k) - fontmetrics.getAscent()) + 1;
                    g.drawString(s, i2, j2);
                }
            }
        } else
        {
            String s1 = formatNumber(currentUpperRange[i], rangeDecimalCount[i]);
            String s2 = formatNumber(currentLowerRange[i], rangeDecimalCount[i]);
            int k1 = (int)(d == 0.0D && j != 1 ? zeroLine[i] : Math.round((double)rectangle.x + d1 * (double)rectangle.width));
            boolean flag4 = k1 >= rectangle.x && k1 <= rectangle.x + rectangle.width;
            boolean flag5 = k1 - i1 / 2 > rectangle.x + fontmetrics.stringWidth(s2) / 2;
            flag5 &= k1 + i1 / 2 < (rectangle.x + rectangle.width) - fontmetrics.stringWidth(s1) / 2;
            flag5 |= j == 1 && k1 > rectangle.x && k1 < rectangle.x + rectangle.width;
            flag5 |= j == 0 && d == 0.0D;
            if(flag4 && (flag5 || flag1) || j == 0 && (d == currentLowerRange[i] || d == currentUpperRange[i]))
            {
                if(flag)
                {
                    g.setColor(color);
                    g.drawLine(k1, rectangle.y + 1, k1, (rectangle.y + rectangle.height) - 1);
                    if(display3dOn)
                        g.drawLine(k1, rectangle.y + rectangle.height, k1 - depth3dPoint.x, (rectangle.y + rectangle.height) - depth3dPoint.y);
                }
                if(s != null)
                {
                    int k2 = rectangle.y - (!display3dOn || rangePosition[i] != 0 ? 0 : depth3dPoint.y);
                    k1 -= !display3dOn || rangePosition[i] != 0 ? 0 : depth3dPoint.x;
                    g.setColor(color1);
                    int l2 = k1 - i1 / 2;
                    int i3 = 0;
                    if(rangePosition[i] == 0)
                    {
                        g.drawLine(k1, k2 + rectangle.height, k1, k2 + rectangle.height + 3);
                        i3 = k2 + rectangle.height + fontmetrics.getHeight();
                        if(rangeAdjusterOn[0] && rangeAdjusterPosition[0] == 0 || rangeAdjusterOn[1] && rangeAdjusterPosition[1] == 0)
                            i3 += 7;
                        if(flag1)
                            i3 += fontmetrics.getHeight();
                    } else
                    {
                        g.drawLine(k1, k2, k1, k2 - 3);
                        i3 = k2 - 5;
                        if(rangeAdjusterOn[0] && rangeAdjusterPosition[0] == 1 || rangeAdjusterOn[1] && rangeAdjusterPosition[1] == 1)
                            i3 -= 6;
                        if(flag1)
                            i3 -= fontmetrics.getHeight();
                    }
                    g.setColor(color1);
                    g.drawString(s, l2, i3);
                }
            }
        }
    }

    public synchronized void setLowerRelativeRange(double d)
    {
        setLowerRelativeRangeIndex(0, d);
    }

    public synchronized void setLowerRelativeRange(double d, double d1)
    {
        setLowerRelativeRange(0, d, d1);
    }

    public synchronized void setLowerRelativeRange(int i, double d, double d1)
    {
        i = Math.min(rangeOn.length - 1, Math.max(0, i));
        double d2 = getLowestValue(i);
        if(i == 0)
        {
            for(Enumeration enumeration = targetsValue.elements(); enumeration.hasMoreElements();)
                d2 = Math.min(((Double)enumeration.nextElement()).doubleValue(), d2);

        }
        if(d2 < 0.0D)
        {
            d1 = Math.abs(d1);
            double d3 = d2 * Math.abs(d);
            if(d1 % 1.0D == 0.0D)
            {
                if(d3 % d1 == 0.0D)
                    setLowerRange(i, d3);
                else
                    setLowerRange(i, d3 - d3 % d1 - d1);
            } else
            {
                double d4;
                for(d4 = 0.0D; d4 > d3; d4 -= d1);
                setLowerRange(i, d4);
            }
        } else
        {
            setLowerRange(i, 0.0D);
        }
    }

    public void setCurrentRange(int i, double d)
    {
        i = Math.min(upperRange.length - 1, Math.max(0, i));
        int j = rangeAdjusted[i];
        if(i == 0 && j == 2)
            j = 0;
        else
        if(i == 1 && j == 2)
            j = 1;
        d = Math.min(upperRange[j], d);
        d = Math.max(currentLowerRange[j], d);
        currentUpperRange[j] = d;
        hasChanged = true;
        autoRepaint();
    }

    public double getCurrentRange(int i)
    {
        i = Math.min(currentUpperRange.length - 1, Math.max(0, i));
        return currentUpperRange[i];
    }

    public void setValueLinesOn(boolean flag)
    {
        valueLinesOn = flag;
        hasChanged = true;
        autoRepaint();
    }

    public void setSampleAxisRange(double d, double d1)
    {
        if(d >= d1)
        {
            throw new IllegalArgumentException("Min is more or equal than max: " + d + ", " + d1);
        } else
        {
            leftSampleAxisRange = d;
            rightSampleAxisRange = d1;
            hasChanged = true;
            autoRepaint();
            return;
        }
    }

    public void setGraphInsets(int i, int j, int k, int l)
    {
        graphInsets.top = i;
        graphInsets.left = j;
        graphInsets.bottom = k;
        graphInsets.right = l;
        hasChanged = true;
        autoRepaint();
    }

    public Insets getGraphInsets()
    {
        return graphInsets;
    }

    public synchronized void setSampleLabels(String as[])
    {
        chartData.setSampleLabels(as);
        hasChanged = true;
        if(sampleLabelsOn && (getLabelAngle("sampleLabelAngle") != 0 || getLabelAngle("barLabelAngle") != 0))
            angledLabelCache.clear();
        labelSizeCache.clear();
        autoRepaint();
    }

    public synchronized String[] getSampleLabels()
    {
        return chartData.getSampleLabels();
    }

    public Image getImage(String s)
    {
        return (Image)images.get(s);
    }

    /**
     * @deprecated Method getFloatLowerRange is deprecated
     */

    public synchronized double getFloatLowerRange()
    {
        return getLowerRange(0);
    }

    /**
     * @deprecated Method setCurrentRange is deprecated
     */

    public void setCurrentRange(double d)
    {
        setCurrentRange(0, d);
    }

    /**
     * @deprecated Method getCurrentRange is deprecated
     */

    public double getCurrentRange()
    {
        return getCurrentRange(0);
    }

    public Image getImage(int i, int j)
    {
        i = Math.max(1, i);
        j = Math.max(1, j);
        Dimension dimension = getSize();
        Image image = createImage(i, j);
        if(image != null)
        {
            Graphics g = image.getGraphics();
            if(g != null)
            {
                offscreen = null;
                setSize(i, j);
                paint(g);
            }
        }
        setSize(dimension.width, dimension.height);
        return image;
    }

    private void paintRangeAdjuster(Graphics g, Rectangle rectangle, int i)
    {
        i = Math.min(1, Math.max(0, i));
        if(!rangeAdjusterOn[i])
            return;
        int j = rangeAdjusted[i];
        if(i == 0 && j == 2)
            j = 0;
        else
        if(i == 1 && j == 2)
            j = 1;
        if(gridAlignment == 1)
        {
            int k = 0;
            int i1 = rectangle.y;
            if(rangeAdjusterPosition[i] == 0)
            {
                k = rectangle.x - 5 - (display3dOn ? depth3dPoint.x : 0);
                i1 -= display3dOn ? depth3dPoint.y : 0;
            } else
            {
                k = rectangle.x + rectangle.width + 5;
            }
            g.setColor(getBackground().darker());
            g.drawLine(k, i1, k, i1 + rectangle.height);
            g.setColor(getBackground().brighter());
            g.drawLine(k + 1, i1, k + 1, i1 + rectangle.height);
            double d = 0.0D;
            double d2 = 0.0D;
            if(upperRange[j] - lowerRange[j] != 0.0D)
            {
                d = (currentUpperRange[j] - lowerRange[j]) / (upperRange[j] - lowerRange[j]);
                d2 = (currentLowerRange[j] - lowerRange[j]) / (upperRange[j] - lowerRange[j]);
            }
            int k1 = (int)Math.round((double)(i1 + rectangle.height) - d * (double)rectangle.height);
            int i2 = (int)Math.round((double)(i1 + rectangle.height) - d2 * (double)rectangle.height);
            rangeAdjusterBounds[i].setBounds(k - 3, k1, 7, i2 - k1);
            paintBox(g, Color.lightGray, k - 3, k1, 6, i2 - k1, false);
            g.setColor(Color.gray);
            g.drawLine(k - 2, k1 + 2, k + 2, k1 + 2);
            g.setColor(Color.white);
            g.drawLine(k - 2, i2 - 2, k + 2, i2 - 2);
        } else
        {
            int l = 0;
            int j1 = rectangle.x;
            if(rangeAdjusterPosition[i] == 0)
            {
                l = (rectangle.y + rectangle.height + 5) - (display3dOn ? depth3dPoint.y : 0);
                j1 -= display3dOn ? depth3dPoint.x : 0;
            } else
            {
                l = rectangle.y - 5;
            }
            g.setColor(getBackground().darker());
            g.drawLine(j1, l, j1 + rectangle.width, l);
            g.setColor(getBackground().brighter());
            g.drawLine(j1, l + 1, j1 + rectangle.width, l + 1);
            double d1 = 0.0D;
            double d3 = 0.0D;
            if(upperRange[j] - lowerRange[j] != 0.0D)
            {
                d1 = (currentUpperRange[j] - lowerRange[j]) / (upperRange[j] - lowerRange[j]);
                d3 = (currentLowerRange[j] - lowerRange[j]) / (upperRange[j] - lowerRange[j]);
            }
            int l1 = (int)Math.round((double)j1 + d3 * (double)rectangle.width);
            int j2 = (int)Math.round((double)j1 + d1 * (double)rectangle.width);
            rangeAdjusterBounds[i].setBounds(l1, l - 3, j2 - l1, 7);
            paintBox(g, Color.lightGray, l1, l - 3, j2 - l1, 6, false);
            g.setColor(Color.gray);
            g.drawLine(l1 + 2, l - 2, l1 + 2, l + 2);
            g.setColor(Color.white);
            g.drawLine(j2 - 2, l - 2, j2 - 2, l + 2);
        }
    }

    private void paintBox(Graphics g, Color color, int i, int j, int k, int l, boolean flag)
    {
        g.setColor(color);
        g.fillRect(i, j, k, l);
        g.setColor(flag ? color.darker() : Color.white);
        g.drawLine(i, j, i + k, j);
        g.drawLine(i, j + 1, i, j + l);
        g.setColor(flag ? Color.white : color.darker());
        g.drawLine(i + 1, j + l, i + k, j + l);
        g.drawLine(i + k, j + 1, i + k, j + l);
    }

    void paintTitle(Graphics g, Dimension dimension)
    {
        if(chartTitleOn && chartTitle != null)
        {
            Font font = getFont("titleFont");
            g.setFont(font);
            FontMetrics fontmetrics = g.getFontMetrics();
            Dimension dimension1 = getLabelSize(chartTitle, font);
            int i = dimension.width / 2 - dimension1.width / 2;
            int j = fontmetrics.getMaxAscent() + 2;
            g.setColor(getForeground());
            paintLabel(g, chartTitle, i, j, dimension1, 2, 0);
        }
    }

    public boolean isRangeOn(int i)
    {
        return rangeOn[Math.min(1, Math.max(0, i))];
    }

    public void set3DModeOn(boolean flag)
    {
        display3dOn = flag;
        hasChanged = true;
        autoRepaint();
    }

    void setServletModeOn(boolean flag)
    {
        servletModeOn = flag;
    }

    public Chart(int i)
    {
        this(1, i);
    }

    public Chart(int i, int j)
    {
        chartData = new ChartData(i, j);
        sample