imgscrollpane.java

jpeg2000算法实现

        // Now redo the layout
        doLayout();
    }

    /**
     * Scrolls to the specified position within the image. Specifying a
     * position outside of the legal scrolling bounds of the image will scroll
     * to the closest legal position. This is a convenience method which
     * interfaces with the Adjustable objects which represent the state of the
     * scrollbars.
     *
     * @param x the x position to scroll to 
     *
     * @param y the y position to scroll to 
     * */
    public synchronized void setScrollPosition(int x, int y) {
        hsbar.setValueI(x);
        vsbar.setValueI(y);
        // Check if we need to repaint
        x = hsbar.getValue(); // get the actual value for check
        y = vsbar.getValue(); // get the actual value for check
        if (imgDisplay.lastUpdateOffset != null &&
            imgDisplay.lastUpdateOffset.x == x &&
            imgDisplay.lastUpdateOffset.y == y) {
            return; // No change
        }
        // New value changes from last drawn => repaint
        imgDisplay.repaint();
    }

    /**
     * Scrolls to the specified position within the image. Specifying a
     * position outside of the legal scrolling bounds of the image will scroll
     * to the closest legal position. This is a convenience method which
     * interfaces with the Adjustable objects which represent the state of the
     * scrollbars.
     *
     * @param p the position to scroll to 
     * */
    public synchronized void setScrollPosition(Point p) {
        setScrollPosition(p.x,p.y);
    }

    /**
     * Returns the current x,y position within the child which is displayed at
     * the 0,0 location of the scrolled panel's view port. This is a
     * convenience method which interfaces with the adjustable objects which
     * represent the state of the scrollbars.
     *
     * @return the coordinate position for the current scroll position
     * */
    public Point getScrollPosition() {
        return new Point(hsbar.getValue(),vsbar.getValue());
    }

    /**
     * Returns the current size of the image scroll pane's view port. This is
     * the size of the image display area. If this component has not been
     * layed out yet the value is not defined.
     *
     * @return The size of the image display area
     * */
    public Dimension getViewportSize() {
        return imgDisplay.getSize();
    }

    /**
     * Sets if the scrolling is to be done by copying and redrawing of damaged
     * parts of the displayed image. Otherwise it is done by redrawing the
     * entire displayed image. In general copy scrolling is faster and
     * produces less annoying effects. See the class description.
     *
     * @param v If true scrolling will be done by copying.
     * */
    public synchronized void setCopyScroll(boolean v) {
        copyScroll = v;
    }
     
    /**
     * Returns true if the scrolling is done by copying.
     *
     * @return If the copy is done by scrolling
     * */
    public synchronized boolean getCopyScroll() {
        return copyScroll;
    }

    /**
     * Causes this container to lay out its components. Most programs should
     * not call this method directly, but should invoke the validate method
     * instead.
     * */
    public synchronized void doLayout() {
        // Let's see if we should include the scrollbars or not
        if (sbType == SCROLLBARS_AS_NEEDED && imgDisplay.calcDim()) {
            Dimension sz = getSize();
            Dimension imsz = imgDisplay.getPreferredSize();

            if (sz.width>=imsz.width+2*INTERNAL_GAP) {
                if (sz.height>=imsz.height+2*INTERNAL_GAP) {
                    // We don't need scrollbars
                    hsbar.setVisible(false);
                    vsbar.setVisible(false);
                }
                else {
                    // We need at least the vertical one, check again for the
                    // horizontal.
                    vsbar.setVisible(true);
                    if (sz.width >=
                        imsz.width+3*INTERNAL_GAP+SCROLLBAR_THICKNESS) {
                        hsbar.setVisible(false);
                    }
                    else {
                        hsbar.setVisible(true);
                    }
                }
            }
            else {
                // We need at least the horizontal, check for the vertical
                // one.
                hsbar.setVisible(true);
                if (sz.height >=
                    imsz.height+3*INTERNAL_GAP+SCROLLBAR_THICKNESS) {
                    vsbar.setVisible(false);
                }
                else {
                    vsbar.setVisible(true);
                }
            }
        }
        // Indicate that we are erasing the image (the doLayout() will erase)
        imgDisplay.erase = true;
        // Now do the layout
        super.doLayout();
        // Trick the lower scrollbar: if both scrollbars are showing then
        // shorten the horizontal one so that the traditional empty square
        // appears at the lower right corner. This is probably not the best
        // solution but it works.
        if (hsbar.isVisible() && vsbar.isVisible()) {
            Rectangle b = hsbar.getBounds();
            if (b.width > SCROLLBAR_THICKNESS+INTERNAL_GAP) {
                b.width -= SCROLLBAR_THICKNESS+INTERNAL_GAP;
            }
            hsbar.setBounds(b);
        }
        // We need to calculate the scrollbars with the possibly new size
        setScrollbars();
    }

    /**
     * Adds the specified focus listener to receive focus events from this
     * component. It is added to the image and scrollbar areas.
     *
     * @param l the focus listener
     * */
    public synchronized void addFocusListener(FocusListener l) {
        super.addFocusListener(l);
        imgDisplay.addFocusListener(l);
        hsbar.addFocusListener(l);
        vsbar.addFocusListener(l);
    }

    /**
     * Removes the specified focus listener so that it no longer receives
     * focus events from this component.
     *
     * @param l the focus listener
     * */
    public synchronized void removeFocusListener(FocusListener l) {
        super.removeFocusListener(l);
        imgDisplay.removeFocusListener(l);
        hsbar.removeFocusListener(l);
        vsbar.removeFocusListener(l);
    }
        
    /**
     * Adds the specified key listener to receive key events from this
     * component. It is added to the image and scrollbar areas.
     *
     * @param l the key listener
     * */
    public synchronized void addKeyListener(KeyListener l) {
        super.addKeyListener(l);
        imgDisplay.addKeyListener(l);
        hsbar.addKeyListener(l);
        vsbar.addKeyListener(l);
    }

    /**
     * Removes the specified key listener so that it no longer receives key
     * events from this component.
     *
     * @param l the key listener
     * */
    public synchronized void removeKeyListener(KeyListener l) {
        super.removeKeyListener(l);
        imgDisplay.removeKeyListener(l);
        hsbar.removeKeyListener(l);
        vsbar.removeKeyListener(l);
    }

    /**
     * Adds the specified mouse listener to receive mouse events from this
     * component. It is actually added to the image area only and not to the
     * scrollbar areas.
     *
     * @param l the mouse listener
     * */
    public synchronized void addMouseListener(MouseListener l) {
        super.addMouseListener(l);
        imgDisplay.addMouseListener(l);
    }

    /**
     * Removes the specified mouse listener so that it no longer receives
     * mouse events from this component.
     *
     * @param l the mouse listener
     * */
    public synchronized void removeMouseListener(MouseListener l) {
        super.removeMouseListener(l);
        imgDisplay.removeMouseListener(l);
    }

    /**
     * Adds the specified mouse motion listener to receive mouse motion events
     * from this component. It is actually added to the image area only and
     * not to the scrollbar areas.
     *
     * @param l the mouse motion listener
     * */
    public synchronized void addMouseMotionListener(MouseMotionListener l) {
        super.addMouseMotionListener(l);
        imgDisplay.addMouseMotionListener(l);
    }

    /**
     * Removes the specified mouse motion listener so that it no longer
     * receives mouse motion events from this component.
     *
     * @param l the mouse motion listener
     * */
    public synchronized void removeMouseMotionListener(MouseMotionListener l) {
        super.removeMouseMotionListener(l);
        imgDisplay.removeMouseMotionListener(l);
    }
    /**
     * Sets the background color of this component. It sets the background of
     * the 3 areas (image and scrollbars) plus the container itself.
     *
     * @param c The color to become background color for this component
     * */
    public synchronized void setBackground(Color c) {
        super.setBackground(c);
        imgDisplay.setBackground(c);
        hsbar.setBackground(c);
        vsbar.setBackground(c);
    }

    /**
     * Set the cursor image to a predefined cursor. It sets the cursor of the
     * image area and this container to the specified one. It does not set the 
     * cursor of the scrollbars.
     *
     * @param cursor One of the constants defined by the Cursor class.
     * */
    public synchronized void setCursor(Cursor cursor) {
        super.setCursor(cursor);
        imgDisplay.setCursor(cursor);
    }

    /**
     * Enables or disables this component, depending on the value of the
     * parameter b. An enabled component can respond to user input and
     * generate events. Components are enabled initially by default.
     *
     * @param b If true, this component is enabled; otherwise this component
     * is disabled.
     * */
    public synchronized void setEnabled(boolean b) {
        super.setEnabled(b);
        imgDisplay.setEnabled(b);
        hsbar.setEnabled(b);
        vsbar.setEnabled(b);
    }

    /**
     * Sets the foreground color of this component. It sets the foreground of
     * the 3 areas (image display and scrollbars) plus this contaioner's
     * foreground.
     *
     * @param c The color to become this component's foreground color.
     * */
    public synchronized void setForeground(Color c) {
        super.setForeground(c);
        imgDisplay.setForeground(c);
        hsbar.setForeground(c);
        vsbar.setForeground(c);
    }

   /**
     * Throws an IllegalArgumentException since no components can be added to
     * this container.
     * */
    public Component add(Component comp) {
        throw new IllegalArgumentException();
    }

    /**
     * Throws an IllegalArgumentException since no components can be added to
     * this container.
     * */
    public Component add(String name,Component comp) {
        throw new IllegalArgumentException();
    }

    /**
     * Throws an IllegalArgumentException since no components can be added to
     * this container.
     * */
    public Component add(Component comp, int index) {
        throw new IllegalArgumentException();
    }

    /**
     * Throws an IllegalArgumentException since no components can be added to
     * this container.
     * */
    public void add(Component comp, Object constraints) {
        throw new IllegalArgumentException();
    }

    /**
     * Throws an IllegalArgumentException since no components can be added to
     * this container.
     * */
    public void add(Component comp, Object constraints, int index) {
        throw new IllegalArgumentException();
    }

    /**
     * Throws an IllegalArgumentException since the components should never be 
     * removed from this container.
     * */
    public void remove(int index) {
        throw new IllegalArgumentException();
    }

    /**
     * Throws an IllegalArgumentException since the components should never be 
     * removed from this container.