vaadin-framework/src/com/itmill/toolkit/ui/AbstractComponentContainer.java

/* 
@ITMillApache2LicenseForJavaFiles@
 */

package com.itmill.toolkit.ui;

import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.LinkedList;

/**
 * Extension to {@link AbstractComponent} that defines the default
 * implementation for the methods in {@link ComponentContainer}. Basic UI
 * components that need to contain other components inherit this class to easily
 * qualify as a component container.
 * 
 * @author IT Mill Ltd
 * @version
 * @VERSION@
 * @since 3.0
 */
public abstract class AbstractComponentContainer extends AbstractComponent
        implements ComponentContainer {

    /**
     * Constructs a new component container.
     */
    public AbstractComponentContainer() {
        super();
    }

    /**
     * Removes all components from the container. This should probably be
     * re-implemented in extending classes for a more powerful implementation.
     */
    public void removeAllComponents() {
        final LinkedList l = new LinkedList();

        // Adds all components
        for (final Iterator i = getComponentIterator(); i.hasNext();) {
            l.add(i.next());
        }

        // Removes all component
        for (final Iterator i = l.iterator(); i.hasNext();) {
            removeComponent((Component) i.next());
        }
    }

    /*
     * Moves all components from an another container into this container. Don't
     * add a JavaDoc comment here, we use the default documentation from
     * implemented interface.
     */
    public void moveComponentsFrom(ComponentContainer source) {
        final LinkedList components = new LinkedList();
        for (final Iterator i = source.getComponentIterator(); i.hasNext();) {
            components.add(i.next());
        }

        for (final Iterator i = components.iterator(); i.hasNext();) {
            final Component c = (Component) i.next();
            source.removeComponent(c);
            addComponent(c);
        }
    }

    /**
     * Notifies all contained components that the container is attached to a
     * window.
     * 
     * @see com.itmill.toolkit.ui.Component#attach()
     */
    public void attach() {
        super.attach();

        for (final Iterator i = getComponentIterator(); i.hasNext();) {
            ((Component) i.next()).attach();
        }
    }

    /**
     * Notifies all contained components that the container is detached from a
     * window.
     * 
     * @see com.itmill.toolkit.ui.Component#detach()
     */
    public void detach() {
        super.detach();

        for (final Iterator i = getComponentIterator(); i.hasNext();) {
            ((Component) i.next()).detach();
        }
    }

    /* Events */

    private static final Method COMPONENT_ATTACHED_METHOD;

    private static final Method COMPONENT_DETACHED_METHOD;

    static {
        try {
            COMPONENT_ATTACHED_METHOD = ComponentAttachListener.class
                    .getDeclaredMethod("componentAttachedToContainer",
                            new Class[] { ComponentAttachEvent.class });
            COMPONENT_DETACHED_METHOD = ComponentDetachListener.class
                    .getDeclaredMethod("componentDetachedFromContainer",
                            new Class[] { ComponentDetachEvent.class });
        } catch (final java.lang.NoSuchMethodException e) {
            // This should never happen
            throw new java.lang.RuntimeException(
                    "Internal error finding methods in AbstractComponentContainer");
        }
    }

    /* documented in interface */
    public void addListener(ComponentAttachListener listener) {
        addListener(ComponentContainer.ComponentAttachEvent.class, listener,
                COMPONENT_ATTACHED_METHOD);
    }

    /* documented in interface */
    public void addListener(ComponentDetachListener listener) {
        addListener(ComponentContainer.ComponentDetachEvent.class, listener,
                COMPONENT_DETACHED_METHOD);
    }

    /* documented in interface */
    public void removeListener(ComponentAttachListener listener) {
        removeListener(ComponentContainer.ComponentAttachEvent.class, listener,
                COMPONENT_ATTACHED_METHOD);
    }

    /* documented in interface */
    public void removeListener(ComponentDetachListener listener) {
        removeListener(ComponentContainer.ComponentDetachEvent.class, listener,
                COMPONENT_DETACHED_METHOD);
    }

    /**
     * Fires the component attached event. This should be called by the
     * addComponent methods after the component have been added to this
     * container.
     * 
     * @param component
     *            the component that has been added to this container.
     */
    protected void fireComponentAttachEvent(Component component) {
        fireEvent(new ComponentAttachEvent(this, component));
    }

    /**
     * Fires the component detached event. This should be called by the
     * removeComponent methods after the component have been removed from this
     * container.
     * 
     * @param component
     *            the component that has been removed from this container.
     */
    protected void fireComponentDetachEvent(Component component) {
        fireEvent(new ComponentDetachEvent(this, component));
    }

    /**
     * This only implements the events and component parent calls. The extending
     * classes must implement component list maintenance and call this method
     * after component list maintenance.
     * 
     * @see com.itmill.toolkit.ui.ComponentContainer#addComponent(Component)
     */
    public void addComponent(Component c) {
        if (c instanceof ComponentContainer) {
            // Make sure we're not adding the component inside it's own content
            for (Component parent = this; parent != null; parent = parent
                    .getParent()) {
                if (parent == c) {
                    throw new IllegalArgumentException(
                            "Component cannot be added inside it's own content");
                }
            }
        }

        if (c.getParent() != null) {
            // If the component already has a parent, try to remove it
            ComponentContainer oldParent = (ComponentContainer) c.getParent();
            oldParent.removeComponent(c);

        }

        c.setParent(this);
        fireComponentAttachEvent(c);
    }

    /**
     * This only implements the events and component parent calls. The extending
     * classes must implement component list maintenance and call this method
     * before component list maintenance.
     * 
     * @see com.itmill.toolkit.ui.ComponentContainer#removeComponent(Component)
     */
    public void removeComponent(Component c) {
        if (c.getParent() == this) {
            c.setParent(null);
            fireComponentDetachEvent(c);
        }
    }

    public void setEnabled(boolean enabled) {
        super.setEnabled(enabled);

        updateComponentDisabledState(!enabled);
    }

    public void setDisabledByContainer(boolean disabledByContainer) {
        super.setDisabledByContainer(disabledByContainer);

        updateComponentDisabledState(disabledByContainer);
    }

    private void updateComponentDisabledState(boolean disabled) {
        // Update the disabledByContainer state for all subcomponents
        for (Iterator i = getComponentIterator(); i.hasNext();) {
            Component c = (Component) i.next();
            if (c instanceof AbstractComponent) {
                ((AbstractComponent) c).setDisabledByContainer(disabled);
            }
        }

    }

}