chart.java

一个完整的

    {
        externalGraphicsOn = true;
        offscreen = image;
        og = g;
        hasChanged = true;
        autoRepaint();
    }

    public void setOverlayChart(int i, Chart chart)
    {
        if(chart != null)
        {
            int j = overlayCharts.size();
            if(i >= 0 && i <= j)
            {
                if(i == j)
                    overlayCharts.addElement(chart);
                else
                    overlayCharts.setElementAt(chart, i);
                chart.setRange(0, getRange(0));
                chart.setRange(1, getRange(1));
                chart.setLowerRange(0, getLowerRange(0));
                chart.setLowerRange(1, getLowerRange(1));
                hasChanged = true;
                autoRepaint();
            } else
            {
                throw new IllegalArgumentException("Invalid index for overlay chart: " + i);
            }
        }
    }

    public Chart getOverlayChart(int i)
    {
        if(i >= 0 && i < overlayCharts.size())
            return (Chart)overlayCharts.elementAt(i);
        else
            return null;
    }

    public boolean isDefaultGridLinesOn()
    {
        return defaultGridLines != null;
    }

    public void setLegendImage(int i, String s)
    {
        if(i >= 0 && i < 1000)
        {
            if(legendImages == null)
                legendImages = new String[i + 1];
            if(i >= legendImages.length)
            {
                String as[] = new String[i + 1];
                System.arraycopy(legendImages, 0, as, 0, legendImages.length);
                legendImages = as;
            }
            legendImages[i] = s;
            hasChanged = true;
            autoRepaint();
        }
    }

    public String getLegendImage(int i)
    {
        if(legendImages != null && i >= 0 && i < legendImages.length)
            return legendImages[i];
        else
            return null;
    }

    public void removeExternalGraphics()
    {
        externalGraphicsOn = false;
        hasChanged = true;
        autoRepaint();
    }

    int getRangeWidth(int i, boolean flag)
    {
        i = Math.min(rangeOn.length - 1, Math.max(0, i));
        FontMetrics fontmetrics = getFontMetrics(getFont("rangeLabelFont"));
        int j = 0;
        if(rangeOn[i] && (i == 0 && rangeLabelsOn || i > 0))
        {
            int k = getRangeDecimalCount(i);
            String s = formatNumber(upperRange[i], k);
            if(i == 0 && rangeLabelsOn)
            {
                String s2 = getLabel("rangeLabelPrefix");
                String s4 = getLabel("rangeLabelPostfix");
                s += s2 == null ? "" : s2;
                s += s4 == null ? "" : s4;
            }
            j = fontmetrics.stringWidth(s);
            s = formatNumber(lowerRange[i], k);
            if(i == 0 && rangeLabelsOn)
            {
                String s3 = getLabel("rangeLabelPrefix");
                String s5 = getLabel("rangeLabelPostfix");
                s += s3 == null ? "" : s3;
                s += s5 == null ? "" : s5;
            }
            j = Math.max(fontmetrics.stringWidth(s), j);
        }
        if(flag && i == 0)
        {
            for(Enumeration enumeration = targetsLabel.keys(); enumeration.hasMoreElements();)
            {
                String s1 = getTargetLabel((String)enumeration.nextElement());
                if(s1 != null)
                    j = Math.max(fontmetrics.stringWidth(s1), j);
            }

        }
        byte byte0 = ((byte)(!rangeAdjusterOn[i] || rangeAdjusterPosition[i] != rangePosition[i] ? 0 : 6));
        return j + 4 + byte0;
    }

    public void removeItemListener(ItemListener itemlistener)
    {
        if(itemlistener != null && listeners != null)
            listeners.removeElement(itemlistener);
    }

    public void setGridLines(double ad[])
    {
        gridLines = ad;
        hasChanged = true;
        autoRepaint();
    }

    public double[] getGridLines()
    {
        return gridLines;
    }

    public void setAutomaticRepaintOn(boolean flag)
    {
        automaticRepaintOn = flag;
    }

    public void setOverlayChartOn(int i, boolean flag)
    {
        Chart chart = getOverlayChart(i);
        if(chart != null)
            chart.overlayChartOn = flag;
        hasChanged = true;
        autoRepaint();
    }

    public abstract Rectangle getGraphBounds();

    Rectangle getGraphBounds(String as[])
    {
        if(as == null)
            throw new IllegalArgumentException("Labels is NULL");
        Dimension dimension = getSize();
        Rectangle rectangle = new Rectangle(10, 10, dimension.width - 20, dimension.height - 20);
        FontMetrics fontmetrics = getFontMetrics(getFont("legendFont"));
        fontmetrics.getHeight();
        Dimension dimension1 = null;
        if(chartTitleOn)
        {
            dimension1 = getLabelSize(chartTitle, getFont("titleFont"));
            rectangle.y += dimension1.height;
            rectangle.height -= dimension1.height;
        }
        if(legendOn)
        {
            getSampleCount();
            getSeriesCount();
            Font font = getFont("legendFont");
            FontMetrics fontmetrics1 = getFontMetrics(font);
            legend.width = 0;
            legend.height = 0;
            byte byte0 = 6;
            for(int i = 0; i < as.length; i++)
            {
                Dimension dimension2 = getLabelSize(as[i], font);
                Dimension dimension3 = getImageSize(getLegendImage(i));
                if(legendPosition == 1 || legendPosition == 0)
                {
                    dimension3.width = Math.max(dimension3.width, byte0);
                    legend.width = Math.max(legend.width, dimension2.width + dimension3.width + byte0 + 2);
                    legend.height += Math.max(Math.max(dimension3.height, dimension2.height), byte0 + 6) + 2;
                } else
                {
                    legend.height = Math.max(Math.max(legend.height, dimension2.height), dimension3.height + 1);
                    dimension3.width = Math.max(dimension3.width, byte0);
                    legend.width += dimension3.width + byte0 + dimension2.width;
                    if(i < as.length - 1)
                        legend.width += byte0 + 2;
                }
            }

            switch(legendPosition)
            {
            case 1: // '\001'
            default:
                legend.x = dimension.width - legend.width - 3;
                legend.y = (dimension.height / 2 - legend.height / 2) + fontmetrics1.getDescent();
                rectangle.width -= legend.width;
                break;

            case 0: // '\0'
                legend.x = 6;
                legend.y = (dimension.height / 2 - legend.height / 2) + fontmetrics1.getDescent();
                rectangle.x += legend.width;
                rectangle.width -= legend.width;
                break;

            case 2: // '\002'
                legend.x = dimension.width / 2 - legend.width / 2;
                legend.y = dimension1 == null ? 9 : dimension1.height + 9;
                rectangle.y += legend.height + fontmetrics1.getDescent();
                rectangle.height -= legend.height + fontmetrics1.getDescent();
                break;

            case 3: // '\003'
                legend.x = dimension.width / 2 - legend.width / 2;
                legend.y = dimension.height - legend.height - 2;
                rectangle.height -= legend.height + 4;
                break;
            }
        }
        if(sampleScrollerOn)
            if(gridAlignment == 1)
            {
                rectangle.height -= 10;
            } else
            {
                rectangle.width -= 10;
                rectangle.x += 10;
            }
        return rectangle;
    }

    public void run()
    {
        try
        {
            Thread.sleep(250L);
        }
        catch(InterruptedException _ex) { }
        double d = (double)(chartDataBounds.width / getSampleCount()) / (double)chartDataBounds.width;
        do
        {
            if(insideLeftButton)
            {
                d = Math.min(d, leftScrollerFactor);
                leftScrollerFactor -= d;
                rightScrollerFactor += d;
                hasChanged = true;
                repaint();
            }
            if(insideRightButton)
            {
                d = Math.min(d, rightScrollerFactor);
                leftScrollerFactor += d;
                rightScrollerFactor -= d;
                hasChanged = true;
                repaint();
            }
            try
            {
                Thread.sleep(35L);
            }
            catch(InterruptedException _ex) { }
        } while(true);
    }

    synchronized void paintLegend(Graphics g, Rectangle rectangle, String as[])
    {
        if(g == null || rectangle == null || as == null)
            return;
        if(legendBounds == null || legendBounds.length != as.length)
        {
            legendBounds = new Rectangle[as.length];
            for(int i = 0; i < legendBounds.length; i++)
                legendBounds[i] = new Rectangle();

        }
        byte byte0 = 6;
        int j = legend.y;
        int k = legend.x;
        int l = k + byte0;
        int i1 = legend.y;
        for(int k1 = 0; k1 < as.length; k1++)
        {
            Dimension dimension = getImageSize(getLegendImage(k1));
            l = Math.max(l, k + byte0 + dimension.width);
        }

        if(l == k + byte0)
            l += byte0;
        int l1 = getSampleCount();
        int i2 = getSeriesCount();
        Font font = getFont("legendFont");
        g.setFont(font);
        FontMetrics fontmetrics = g.getFontMetrics();
        for(int j2 = 0; j2 < as.length; j2++)
        {
            String s = getLegendImage(j2);
            Dimension dimension1 = getImageSize(s);
            if(legendPosition == 2 || legendPosition == 3)
                j = legend.y + (legend.height - (dimension1.height <= 0 ? 6 : dimension1.height)) / 2;
            if(s != null && dimension1.width > 0 && dimension1.height > 0)
            {
                Image image = (Image)images.get(s);
                if(image != null)
                    if(legendPosition == 1 || legendPosition == 0)
                    {
                        int k2 = dimension1.width >= byte0 ? k : ((k + byte0 / 2) - dimension1.width / 2) + 1;
                        int l2 = dimension1.height >= byte0 ? j : ((j + byte0 / 2) - dimension1.height / 2) + 1;
                        g.drawImage(image, k2, l2, this);
                    } else
                    {
                        g.drawImage(image, k, j, this);
                    }
            } else
            {
                Color color = getLegendColor(j2);
                if(color != null)
                    g.setColor(color);
                g.fillRect(k, j, byte0, byte0);
                g.setColor(Color.black);
                g.drawRect(k, j, byte0, byte0);
            }
            g.setColor(getForeground());
            if(i2 == 1 && j2 < l1)
            {
                Color color1 = getSampleLabelColor(j2);
                if(color1 != null)
                    g.setColor(color1);
            } else
            if(i2 > 1 && j2 < i2)
            {
                Color color2 = getSeriesLabelColor(j2);
                if(color2 != null)
                    g.setColor(color2);
            }
            Dimension dimension2 = getLabelSize(as[j2], font);
            dimension1.width = Math.max(dimension1.width, byte0);
            dimension1.height = Math.max(dimension1.height, byte0);
            int j1 = (j + dimension1.height / 2 + fontmetrics.getMaxAscent() / 2) - 1;
            if(legendPosition == 2 || legendPosition == 3)
            {
                l = k + dimension1.width + byte0;
                j1 = (legend.y + (legend.height - dimension2.height) / 2 + dimension2.height) - 2;
            }
            paintLabel(g, as[j2], l, j1, dimension2, -1, 0);
            Rectangle rectangle1 = legendBounds[j2];
            rectangle1.x = k - 3;
            rectangle1.y = Math.min(j1 - fontmetrics.getAscent(), j - 3);
            rectangle1.width = ((dimension2.width + l) - k) + 6;
            rectangle1.height = Math.max(dimension1.height + 5, dimension2.height + 1);
            rectangle1.height = Math.max(rectangle1.height, byte0 + 7);
            if(j2 >= 0 && j2 < legendSelection.length && legendSelection[j2])
            {
                g.setColor(getForeground());
                g.drawRect(rectangle1.x, rectangle1.y, rectangle1.width, rectangle1.height);
            }
            if(legendPosition == 0 || legendPosition == 1)
            {