container.java.svn-base

来自「j2me设计的界面包」· SVN-BASE 代码 · 共 759 行 · 第 1/2 页

    public void revalidate() {
        setShouldCalcPreferredSize(true);
        Form root = getComponentForm();
        if (root != null) {
            root.layoutContainer();
            root.repaint();
        } else {
            layoutContainer();
            repaint();
        }
    }

    /**
     * @inheritDoc
     */
    public void paint(Graphics g) {
        layoutContainer();
        g.translate(getX(), getY());
        Enumeration enums = components.elements();
        while (enums.hasMoreElements()) {
            Component cmp = (Component) enums.nextElement();
            cmp.paintInternal(g);
        }

        g.translate(-getX(), -getY());
    }

    void paintIntersecting(Graphics g, Component cmp, Rectangle bounds, boolean above) {
        
        if (layout.isOverlapSupported() && components.contains(cmp)) {
            int indexOfComponent = components.indexOf(cmp);
            int startIndex;
            int endIndex;
            if (above) {
                startIndex = indexOfComponent + 1;
                endIndex = components.size();
            } else {
                startIndex = 0;
                endIndex = indexOfComponent;
            }

            for (int i = startIndex; i < endIndex; i++) {
                Component cmp2 = (Component) components.elementAt(i);
                Rectangle rect = new Rectangle(cmp2.getBounds());
                rect.setX(cmp2.getAbsoluteX());
                rect.setY(cmp2.getAbsoluteY());

                if (rect.intersects(bounds)) {
                    cmp2.paintInternal(g, false);
                }
            }
        }
    }

    /**
     * Performs the layout of the container if a layout is necessary
     */
    public void layoutContainer() {
        //will compute the container + components and will layout the components.
        if (shouldLayout) {
            shouldLayout = false;
            doLayout();
        }

    }

    /**
     * Lays out the container
     */
    void doLayout() {
        layout.layoutContainer(this);
        int count = getComponentCount();
        for (int i = 0; i <
                count; i++) {
            Component c = getComponentAt(i);
            if (c instanceof Container) {
                ((Container) c).doLayout();
            }

        }
    }

    /**
     * Returns the number of components
     * 
     * @return the Component count
     */
    public int getComponentCount() {
        return components.size();
    }

    /**
     * Returns the Component at a given index
     * 
     * @param index of the Component you wish to get
     * @return a Component
     * @throws ArrayIndexOutOfBoundsException if an invalid index was given.
     */
    public Component getComponentAt(
            int index) {
        return (Component) components.elementAt(index);
    }

    /**
     * Returns the Component index in the Container
     * 
     * @param cmp the component to search for
     * @return the Component index in the Container or -1 if not found
     */
    public int getComponentIndex(Component cmp) {
        int count = getComponentCount();
        for (int i = 0; i <
                count; i++) {
            Component c = getComponentAt(i);
            if (c.equals(cmp)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * Returns true if the given component is within the hierarchy of this container
     *
     * @param cmp a Component to check
     * @return true if this Component contains in this Container
     */
    public boolean contains(Component cmp) {
        boolean found = false;
        int count = getComponentCount();
        for (int i = 0; i < count; i++) {
            Component c = getComponentAt(i);
            if (c.equals(cmp)) {
                return true;
            }

            if (c instanceof Container) {
                found = ((Container) c).contains(cmp);
                if (found) {
                    return true;
                }

            }
        }
        return false;
    }

    /**
     * Makes sure the component is visible in the scroll if this container is 
     * scrollable
     * 
     * @param c the component that will be scrolling for visibility
     */
    protected void scrollComponentToVisible(Component c) {
        if (isScrollable()) {
            if (c != null) {
                if (c.getParent() != null) {
                    // special case for the first component to allow the user to scroll all the 
                    // way to the top
                    Form f = getComponentForm();
                    if (f != null && f.getFocusPosition(c) == 0) {
                        scrollRectToVisible(new Rectangle(0, 0, c.getX() + c.getWidth(), c.getY() + c.getHeight()), c);
                        return;
                    }
                }
                scrollRectToVisible(c.getBounds(), c);
            }
        }

    }

    /**
     * Returns a Component that exists in the given x, y coordinates by traversing
     * component objects and invoking contains
     * 
     * @param x absolute screen location
     * @param y absolute screen location
     * @return a Component if found, null otherwise
     * @see Component#contains
     */
    public Component getComponentAt(int x, int y) {
        int count = getComponentCount();
        for (int i = count - 1; i >= 0; i--) {
            Component cmp = getComponentAt(i);
            if (cmp.contains(x, y)) {
                if (cmp instanceof Container) {
                    return ((Container) cmp).getComponentAt(x, y);
                }
                return cmp;
            }

        }
        return null;
    }

    /**
     * @inheritDoc
     */
    public void pointerPressed(int x, int y) {
        if (!isDragActivated()) {
            Component cmp = getComponentAt(x, y);
            if (cmp != null) {
                cmp.pointerPressed(x, y);
            }
        }
    }

    /**
     * @inheritDoc
     */
    public void pointerReleased(int x, int y) {
        if (isDragActivated()) {
            super.pointerReleased(x, y);
            return;
        }
        Component cmp = getComponentAt(x, y);
        if (cmp != null) {
            cmp.pointerReleased(x, y);
        }

    }

    /**
     * @inheritDoc
     */
    protected Dimension calcPreferredSize() {
        Dimension d = layout.getPreferredSize(this);
        return d;
    }

//    /**
//     * @inheritDoc
//     */
//    public boolean isFocusable() {
//        return false;
//    }
    /**
     * @inheritDoc
     */
    protected String paramString() {
        String className = layout.getClass().getName();
        String layoutStr = className.substring(className.lastIndexOf('.') + 1);
        return super.paramString() + ", layout = " + layoutStr +
                ", scrollableX = " + scrollableX +
                ", scrollableY = " + scrollableY +
                ", components = " + getComponentsNames();
    }

    /**
     * Return the conatainer components objects as list of Strings
     * @return the conatainer components objects as list of Strings
     */
    private String getComponentsNames() {
        String ret = "[";
        Enumeration enums = components.elements();
        while (enums.hasMoreElements()) {
            String className = enums.nextElement().getClass().getName();
            ret += className.substring(className.lastIndexOf('.') + 1) + ", ";
        }

        return ret.substring(0, ret.length() - 2) + "]";
    }

    /**
     * @inheritDoc
     */
    public void refreshTheme() {
        super.refreshTheme();
        Enumeration enums = components.elements();
        while (enums.hasMoreElements()) {
            Component cmp = (Component) enums.nextElement();
            cmp.refreshTheme();
        }
    }

    /**
     * @inheritDoc
     */
    public boolean isScrollableX() {
        return scrollableX && getPreferredW() > getWidth();
    }

    /**
     * @inheritDoc
     */
    public boolean isScrollableY() {
        return scrollableY && getPreferredH() > getHeight();
    }

    /**
     * Sets whether the component should/could scroll on the X axis
     * 
     * @param scrollableX whether the component should/could scroll on the X axis
     */
    public void setScrollableX(boolean scrollableX) {
        this.scrollableX = scrollableX;
    }

    /**
     * Sets whether the component should/could scroll on the Y axis
     * 
     * @param scrollableY whether the component should/could scroll on the Y axis
     */
    public void setScrollableY(boolean scrollableY) {
        this.scrollableY = scrollableY;
    }

    /**
     * The equivalent of calling both setScrollableY and setScrollableX
     * 
     * @param scrollable whether the component should/could scroll on the 
     * X and Y axis
     */
    public void setScrollable(boolean scrollable) {
        setScrollableX(scrollable);
        setScrollableY(scrollable);
    }

    /**
     * @inheritDoc
     */
    public void setCellRenderer(boolean cellRenderer) {
        if (isCellRenderer() != cellRenderer) {
            super.setCellRenderer(cellRenderer);
            int size = getComponentCount();
            for (int iter = 0; iter <
                    size; iter++) {
                getComponentAt(iter).setCellRenderer(cellRenderer);
            }
        }
    }

    /**
     * @inheritDoc
     */
    protected String getUIID() {
        return "Container";
    }
}

class Anim implements Animation {

    private Transition t;
    private Component current;
    private Component next;
    private boolean started = false;
    private Container thisContainer;

    public Anim(Container thisContainer, Component current, Component next, Transition t) {
        this.t = t;
        this.next = next;
        this.current = current;
        this.thisContainer = thisContainer;
    }

    public boolean animate() {
        if (!started) {
            t.init(current, next);
            t.initTransition();
            started = true;
        }
        boolean notFinished = t.animate();
        if (!notFinished) {
            next.setParent(null);
            thisContainer.replace(current, next);
            //release the events blocking
            Display.getInstance().blockEvents(false);
            t.cleanup();
            thisContainer.getComponentForm().deregisterAnimated(this);
        }
        return notFinished;
    }

    public void paint(Graphics g) {
        t.paint(g);
    }
}