panscrollzoomdemo.java

这是一个segy数据显示程序

        //   int ht = (int) zoomButton.getPreferredSize().getHeight();
        //   scrollBar.setPreferredSize(new Dimension(0, ht));
        this.scrollBar.setModel(new DefaultBoundedRangeModel());

        toolbar.add(this.scrollBar);

        this.zoomOutButton.setEnabled(false);
        this.fitButton.setEnabled(false);
        this.scrollBar.setEnabled(false);

        toolbar.setFloatable(false);
        return toolbar;
    }

    /**
     * Prepares a button.
     * 
     * @param button  the button.
     * @param actionKey  the action key.
     * @param buttonLabelText  the button label.
     * @param toolTipText  the tooltip text.
     */
    private void prepareButton(final AbstractButton button,
                               final String actionKey,
                               final String buttonLabelText,
                               final String toolTipText) {
        // todo
        // as this action is empty and the button text is
        // redefined later, it can be safely removed ...
//        Action action = new AbstractAction(actionKey) {
//            public void actionPerformed(ActionEvent evt) {
//                // ignored
//            }
//        };
//        button.addActionListener(action);
        button.setActionCommand(actionKey);
        button.setText(buttonLabelText);
        button.setToolTipText(toolTipText);
        button.addActionListener(this);
    }

    /**
     * Sets the pan mode.
     * 
     * @param val  a boolean.
     */
    private void setPanMode(final boolean val) {

        this.chartPanel.setHorizontalZoom(!val);
        // chartPanel.setHorizontalAxisTrace(! val);
        this.chartPanel.setVerticalZoom(!val);
        // chartPanel.setVerticalAxisTrace(! val);

        if (val) {
            this.chartPanel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        }
        else {
            this.chartPanel.setCursor(Cursor.getDefaultCursor());
        }
    }

    /**
     * Handles an action event.
     * 
     * @param evt
     *            the event.
     */
    public void actionPerformed(final ActionEvent evt) {
        try {
            final String acmd = evt.getActionCommand();

            if (acmd.equals(ACTION_CMD_ZOOM_BOX)) {
                setPanMode(false);
            } 
            else if (acmd.equals(ACTION_CMD_PAN)) {
                setPanMode(true);
            } 
            else if (acmd.equals(ACTION_CMD_ZOOM_IN)) {
                final ChartRenderingInfo info = this.chartPanel.getChartRenderingInfo();
                final Rectangle2D rect = info.getPlotInfo().getDataArea();
                zoomBoth(rect.getCenterX(), rect.getCenterY(), ZOOM_FACTOR);
            } 
            else if (acmd.equals(ACTION_CMD_ZOOM_OUT)) {
                final ChartRenderingInfo info = this.chartPanel.getChartRenderingInfo();
                final Rectangle2D rect = info.getPlotInfo().getDataArea();
                zoomBoth(rect.getCenterX(), rect.getCenterY(), 1 / ZOOM_FACTOR);
            } 
            else if (acmd.equals(ACTION_CMD_ZOOM_TO_FIT)) {

                // X-axis (has no fixed borders)
                this.chartPanel.autoRangeHorizontal();

                // Y-Axes) (autoRangeVertical
                // not useful because of fixed borders
                final Plot plot = this.chartPanel.getChart().getPlot();
                if (plot instanceof ValueAxisPlot) {

                    final XYPlot vvPlot = (XYPlot) plot;
                    ValueAxis axis = vvPlot.getRangeAxis();
                    if (axis != null) {
                        axis.setLowerBound(this.primYMinMax[0]);
                        axis.setUpperBound(this.primYMinMax[1]);
                    }
                    if (plot instanceof XYPlot) {
                        final XYPlot xyPlot = (XYPlot) plot;
                        axis = xyPlot.getRangeAxis(1);
                        if (axis != null) {
                            axis.setLowerBound(this.secondYMinMax[0]);
                            axis.setUpperBound(this.secondYMinMax[1]);
                        }
                    }
                }
            }
        } 
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Handles a {@link ChangeEvent} (in this case, coming from the scrollbar).
     * 
     * @param event  the event.
     */
    public void stateChanged(final ChangeEvent event) {
        try {
            final Object src = event.getSource();
            final BoundedRangeModel scrollBarModel = this.scrollBar.getModel();
            if (src == scrollBarModel) {
                final int val = scrollBarModel.getValue();
                final int ext = scrollBarModel.getExtent();

                final Plot plot = this.chartPanel.getChart().getPlot();
                if (plot instanceof XYPlot) {
                    final XYPlot hvp = (XYPlot) plot;
                    final ValueAxis axis = hvp.getDomainAxis();

                    // avoid problems
                    this.chartPanel.getChart().removeChangeListener(this);

                    axis.setRange(val / this.scrollFactor, (val + ext) / this.scrollFactor);

                    // restore chart listener
                    this.chartPanel.getChart().addChangeListener(this);
                }
            }
        } 
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Handles a {@link ChartChangeEvent}.
     * 
     * @param event  the event.
     */
    public void chartChanged(final ChartChangeEvent event) {
        try {
            if (event.getChart() == null) {
                return;
            }  

            final BoundedRangeModel scrollBarModel = this.scrollBar.getModel();
            if (scrollBarModel == null) {
                return;
            }

            boolean chartIsZoomed = false;

            final Plot plot = event.getChart().getPlot();
            if (plot instanceof XYPlot) {
                final XYPlot hvp = (XYPlot) plot;
                final ValueAxis xAxis = hvp.getDomainAxis();
                final Range xAxisRange = xAxis.getRange();

                // avoid recursion
                scrollBarModel.removeChangeListener(this);

                final int low = (int) (xAxisRange.getLowerBound() * this.scrollFactor);
                scrollBarModel.setValue(low);
                final int ext = (int) (xAxisRange.getUpperBound() * this.scrollFactor - low);
                scrollBarModel.setExtent(ext);

                // restore
                scrollBarModel.addChangeListener(this);

                // check if zoomed horizontally
                //Range hdr = hvp.getHorizontalDataRange(xAxis);
                final Range hdr = hvp.getDataRange(xAxis);

                final double len = hdr == null ? 0 : hdr.getLength();
                chartIsZoomed |= xAxisRange.getLength() < len;
            }

            if (!chartIsZoomed && plot instanceof XYPlot) {
                // check if zoomed vertically
                final XYPlot vvp = (XYPlot) plot;
                ValueAxis yAxis = vvp.getRangeAxis();
                if (yAxis != null) {
                    chartIsZoomed = yAxis.getLowerBound() > this.primYMinMax[0]
                        || yAxis.getUpperBound() < this.primYMinMax[1];

                    // right y-axis
                    if (!chartIsZoomed && plot instanceof XYPlot) {
                        final XYPlot xyPlot = (XYPlot) plot;
                        yAxis = xyPlot.getRangeAxis(1);
                        if (yAxis != null) {
                            chartIsZoomed = yAxis.getLowerBound() > this.secondYMinMax[0]
                                || yAxis.getUpperBound() < this.secondYMinMax[1];
                        }
                    }
                }
            }

            // enable "zoom-out-buttons" if chart is zoomed
            // otherwise disable them
            this.panButton.setEnabled(chartIsZoomed);
            this.zoomOutButton.setEnabled(chartIsZoomed);
            this.fitButton.setEnabled(chartIsZoomed);
            this.scrollBar.setEnabled(chartIsZoomed);
            if (!chartIsZoomed) {
                setPanMode(false);
                this.zoomButton.setSelected(true);
            }
        } 
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Mouse[Motion]Listeners for pan

    /**
     * Handles a mouse pressed event (to start panning).
     * 
     * @param event  the event.
     */
    public void mousePressed(final MouseEvent event) {
        try {
            if (this.panButton.isSelected()
                || this.panButton.isEnabled()
                && SwingUtilities.isRightMouseButton(event)) {
                final Rectangle2D dataArea = this.chartPanel.getScaledDataArea();
                final Point2D point = event.getPoint();
                if (dataArea.contains(point)) {
                    setPanMode(true);
                    this.panStartPoint = point;
                }
            }
        } 
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Handles a mouse released event (stops panning).
     * 
     * @param event  the event.
     */
    public void mouseReleased(final MouseEvent event) {
        try {
            this.panStartPoint = null; // stop panning
            if (!this.panButton.isSelected()) {
                setPanMode(false);
            }
        } 
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Handles a mouse dragged event to perform panning.
     * 
     * @param event  the event.
     */
    public void mouseDragged(final MouseEvent event) {
        try {
            if (this.panStartPoint != null) {
                final Rectangle2D scaledDataArea = this.chartPanel.getScaledDataArea();

                this.panStartPoint = RefineryUtilities.getPointInRectangle(
                    this.panStartPoint.getX(),
                    this.panStartPoint.getY(),
                    scaledDataArea
                );
                final Point2D panEndPoint = RefineryUtilities.getPointInRectangle(
                    event.getX(), event.getY(), scaledDataArea
                );

                // horizontal pan

                final Plot plot = this.chartPanel.getChart().getPlot();
                if (plot instanceof XYPlot) {
                    final XYPlot hvp = (XYPlot) plot;
                    final ValueAxis xAxis = hvp.getDomainAxis();

                    if (xAxis != null) {
                        final double translatedStartPoint = xAxis.java2DToValue(
                            (float) this.panStartPoint.getX(),
                            scaledDataArea,
                            hvp.getDomainAxisEdge()
                        );
                        final double translatedEndPoint = xAxis.java2DToValue(
                            (float) panEndPoint.getX(),
                            scaledDataArea,
                            hvp.getDomainAxisEdge()
                        );
                        final double dX = translatedStartPoint - translatedEndPoint;

                        final double oldMin = xAxis.getLowerBound();
                        final double newMin = oldMin + dX;

                        final double oldMax = xAxis.getUpperBound();
                        final double newMax = oldMax + dX;

                        // do not pan out of range
                        if (newMin >= hvp.getDataRange(xAxis).getLowerBound()