dockwrapper.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

        List constraints = dockPanel.getConstraints(getChildren());
        boolean canResize = DockConstraint.canResize(constraints);
        if (resizable && !canResize) {
            makeNotResizable();
        }
        if (!resizable && canResize) {
            makeResizable();
        }
    }

    /** Determine if this can occlude */
    public boolean canOcclude() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canOcclude(constraints);
    }

    /** Determine if this can tab */
    public boolean canTab() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canTab(constraints);
    }

    /** Determine if this can close */
    public boolean canClose() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canClose(constraints);
    }

    /** Determine if this can internalFrame */
    public boolean canInternalFrame() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canInternalFrame(constraints);
    }

    /** Determine if this can externalFrame */
    public boolean canExternalFrame() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canExternalFrame(constraints);
    }

    /** Determine if this can dockNorth */
    public boolean canDockNorth() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canDockNorth(constraints);
    }

    /** Determine if this can dockSouth */
    public boolean canDockSouth() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canDockSouth(constraints);
    }

    /** Determine if this can dockEast */
    public boolean canDockEast() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canDockEast(constraints);
    }

    /** Determine if this can dockWest */
    public boolean canDockWest() {
        List constraints = dockPanel.getConstraints(getChildren());
        return DockConstraint.canDockWest(constraints);
    }

    //State Methods:
    ////////////////

    public void makeExternalFrame() {
        freeWrapper();
        state = EXTERNAL;
    }

    protected void removeExternalFrame() {
        state = UNDEF;
    }

    public void makeInternalFrame() {
        freeWrapper();
        state = INTERNAL;
    }

    protected void removeInternalFrame() {
        state = UNDEF;
    }

    public void makeDockNorth() {
        makeDock(DOCK_NORTH);
    }

    protected void removeDockNorth() {
        removeDock();
    }

    public void makeDockSouth() {
        makeDock(DOCK_SOUTH);
    }

    protected void removeDockSouth() {
        removeDock();
    }

    public void makeDockEast() {
        makeDock(DOCK_EAST);
    }

    protected void removeDockEast() {
        removeDock();
    }

    public void makeDockWest() {
        makeDock(DOCK_WEST);
    }

    protected void removeDockWest() {
        removeDock();
    }

    protected void makeDock(int state) {
        freeWrapper();
        this.state = state;
        dockPanel.addDockWrapper(this);
        orientToolbars();
    }

    protected void orientToolbars() {
        for (Iterator iter = getChildren().iterator(); iter.hasNext();) {
            JComponent child = (JComponent) iter.next();
            if (!(child instanceof JToolBar)) {
                continue;
            }
            JToolBar t = (JToolBar) child;
            switch (state) {
            case DOCK_NORTH:
            case DOCK_SOUTH:
                t.setOrientation(JToolBar.HORIZONTAL);
                break;
            case DOCK_EAST:
            case DOCK_WEST:
                t.setOrientation(JToolBar.VERTICAL);
                break;
            }
        }
    }

    protected void removeDock() {
        dockPanel.removeDockWrapper(this);
        this.state = UNDEF;
    }

    protected void setState(int state) {
        switch (state) {
        case INTERNAL:
            makeInternalFrame();
            break;
        case EXTERNAL:
            makeExternalFrame();
            break;
        case DOCK_NORTH:
            makeDockNorth();
            break;
        case DOCK_SOUTH:
            makeDockSouth();
            break;
        case DOCK_WEST:
            makeDockWest();
            break;
        case DOCK_EAST:
            makeDockEast();
            break;
        }
    }

    //Docking up Methods:
    /////////////////////

    public void freeWrapper() {
        switch (state) {
        case INTERNAL:
            removeInternalFrame();
            break;
        case EXTERNAL:
            removeExternalFrame();
            break;
        case DOCK_NORTH:
            removeDockNorth();
            break;
        case DOCK_SOUTH:
            removeDockSouth();
            break;
        case DOCK_WEST:
            removeDockWest();
            break;
        case DOCK_EAST:
            removeDockEast();
            break;
        }
    }

    /** Attempt to remove the given wrapper from us */
    public boolean freeWrapper(DockWrapper w) {
        if (dockedWrappers.remove(w)) {
            w.freeWrapper();
            return true;
        }
        for (Iterator iter = dockedWrappers.iterator(); iter.hasNext();) {
            DockWrapper dw = (DockWrapper) iter.next();
            if (dw.freeWrapper(w)) {
                return true;
            }
        }
        return false;
    }

    public boolean hasDockedWrappers() {
        return getDockedWrappers().size() >= 0;
    }

    public List getDockedWrappers() {
        return dockedWrappers;
    }

    public DockWrapper getDockedWrapper(int idx) {
        return (DockWrapper) dockedWrappers.get(idx);
    }

    public void dock(DockWrapper w) {
        dock(w, -1);
    }

    public void dock(DockWrapper w, int i) {
        w.setState(state);
        int idx = getDockedWrapperIndexForTabbing();
        if (idx != -1 && w.canTab()) {
            getDockedWrapper(idx).tab(w);
        } else {
            if (i == -1) {
                dockedWrappers.add(w);
            } else {
                dockedWrappers.set(i, w);
            }
        }
    }

    /**
     * Recursively determine if another wrapper is docked on this one.
     */
    public boolean isDockedOnRecurse(DockWrapper w) {
        if (this.equals(w)) {
            return true;
        }
        for (Iterator iter = dockedWrappers.iterator(); iter.hasNext();) {
            DockWrapper dw = (DockWrapper) iter.next();
            if (dw.isDockedOnRecurse(w)) {
                return true;
            }
        }
        return false;
    }

    public void setPreferredHeight(int i) {
        Dimension d = getPreferredSize();
        d.height = i;
        setPreferredSize(d);
    }

    public void setPreferredWidth(int i) {
        Dimension d = getPreferredSize();
        d.width = i;
        setPreferredSize(d);
    }

    //Nested Classes:
    /////////////////

    protected class MouseHandler extends MouseInputAdapter {
        int resizeLoc = UNDEF;
        int pressedVal = 0;

        public void mousePressed(MouseEvent e) {
            resizeLoc = inBorder(e.getX(), e.getY());
            switch (resizeLoc) {
            case DOCK_NORTH:
            case DOCK_SOUTH:
                pressedVal = e.getY();
                break;
            case DOCK_EAST:
            case DOCK_WEST:
                pressedVal = e.getX();
                break;
            }
        }

        public void mouseReleased(MouseEvent e) {
            Dimension d = getSize();
            switch (resizeLoc) {
            case DOCK_NORTH:
                d.height += pressedVal - e.getY();
                setPreferredSize(d);
                revalidate();
                break;
            case DOCK_SOUTH:
                d.height -= pressedVal - e.getY();
                setPreferredSize(d);
                revalidate();
                break;
            case DOCK_EAST:
                d.width -= pressedVal - e.getX();
                setPreferredSize(d);
                revalidate();
                break;
            case DOCK_WEST:
                d.width += pressedVal - e.getX();
                setPreferredSize(d);
                revalidate();
                break;
            }
        }

        public void mouseMoved(MouseEvent e) {
            int loc = inBorder(e.getX(), e.getY());
            switch (loc) {
            case DOCK_NORTH:
                setCursor(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));
                break;
            case DOCK_SOUTH:
                setCursor(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));
                break;
            case DOCK_EAST:
                setCursor(Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));
                break;
            case DOCK_WEST:
                setCursor(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));
                break;
            default:
                setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
            }
        }

        public void mouseExited(MouseEvent e) {
            setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
        }
    }
}