/*
* Copyright 2000-2016 Vaadin Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.vaadin.ui;
import java.util.Collections;
import java.util.Iterator;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import com.vaadin.server.ComponentSizeValidator;
import com.vaadin.server.VaadinService;
import com.vaadin.server.VaadinSession;
import com.vaadin.shared.Registration;
import com.vaadin.shared.ui.AbstractSingleComponentContainerState;
import com.vaadin.ui.declarative.DesignContext;
import com.vaadin.ui.declarative.DesignException;
/**
* Abstract base class for component containers that have only one child
* component.
*
* For component containers that support multiple children, inherit
* {@link AbstractComponentContainer} instead of this class.
*
* @since 7.0
*/
public abstract class AbstractSingleComponentContainer extends AbstractComponent
implements SingleComponentContainer {
private Component content;
@Override
public int getComponentCount() {
return (content != null) ? 1 : 0;
}
@Override
public Iterator<Component> iterator() {
if (content != null) {
return Collections.singletonList(content).iterator();
} else {
return Collections.<Component> emptyList().iterator();
}
}
/* documented in interface */
@Override
public Registration addComponentAttachListener(
ComponentAttachListener listener) {
return addListener(ComponentAttachEvent.class, listener,
ComponentAttachListener.attachMethod);
}
/* documented in interface */
@Override
@Deprecated
public void removeComponentAttachListener(
ComponentAttachListener listener) {
removeListener(ComponentAttachEvent.class, listener,
ComponentAttachListener.attachMethod);
}
/* documented in interface */
@Override
public Registration addComponentDetachListener(
ComponentDetachListener listener) {
return addListener(ComponentDetachEvent.class, listener,
ComponentDetachListener.detachMethod);
}
/* documented in interface */
@Override
@Deprecated
public void removeComponentDetachListener(
ComponentDetachListener listener) {
removeListener(ComponentDetachEvent.class, listener,
ComponentDetachListener.detachMethod);
}
/**
* Fires the component attached event. This is called by the
* {@link #setContent(Component)} method after the component has been set as
* the content.
*
* @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 is called by the
* {@link #setContent(Component)} method after the content component has
* been replaced by other content.
*
* @param component
* the component that has been removed from this container.
*/
protected void fireComponentDetachEvent(Component component) {
fireEvent(new ComponentDetachEvent(this, component));
}
@Override
public Component getContent() {
return content;
}
/**
* Sets the content of this container. The content is a component that
* serves as the outermost item of the visual contents.
*
* The content must always be set, either with a constructor parameter or by
* calling this method.
*
* Previous versions of Vaadin used a {@link VerticalLayout} with margins
* enabled as the default content but that is no longer the case.
*
* @param content
* a component (typically a layout) to use as content
*/
@Override
public void setContent(Component content) {
// Make sure we're not adding the component inside it's own content
if (isOrHasAncestor(content)) {
throw new IllegalArgumentException(
"Component cannot be added inside it's own content");
}
Component oldContent = getContent();
if (oldContent == content) {
// do not set the same content twice
return;
}
if (oldContent != null && equals(oldContent.getParent())) {
oldContent.setParent(null);
fireComponentDetachEvent(oldContent);
}
this.content = content;
if (content != null) {
removeFromParent(content);
content.setParent(this);
fireComponentAttachEvent(content);
}
markAsDirty();
}
/**
* Utility method for removing a component from its parent (if possible).
*
* @param content
* component to remove
*/
// TODO move utility method elsewhere?
public static void removeFromParent(Component content)
throws IllegalArgumentException {
// Verify the appropriate session is locked
UI parentUI = content.getUI();
if (parentUI != null) {
VaadinSession parentSession = parentUI.getSession();
if (parentSession != null && !parentSession.hasLock()) {
String message = "Cannot remove from parent when the session is not locked.";
if (VaadinService.isOtherSessionLocked(parentSession)) {
message += " Furthermore, there is another locked session, indicating that the component might be about to be moved from one session to another.";
}
throw new IllegalStateException(message);
}
}
HasComponents parent = content.getParent();
if (parent instanceof ComponentContainer) {
// If the component already has a parent, try to remove it
ComponentContainer oldParent = (ComponentContainer) parent;
oldParent.removeComponent(content);
} else if (parent instanceof SingleComponentContainer) {
SingleComponentContainer oldParent = (SingleComponentContainer) parent;
if (oldParent.getContent() == content) {
oldParent.setContent(null);
}
} else if (parent != null) {
throw new IllegalArgumentException(
"Content is already attached to another parent");
}
}
// the setHeight()/setWidth() methods duplicated and simplified from
// AbstractComponentContainer
@Override
public void setWidth(float width, Unit unit) {
/*
* child tree repaints may be needed, due to our fall back support for
* invalid relative sizes
*/
boolean dirtyChild = false;
boolean childrenMayBecomeUndefined = false;
if (getWidth() == SIZE_UNDEFINED && width != SIZE_UNDEFINED) {
// children currently in invalid state may need repaint
dirtyChild = getInvalidSizedChild(false);
} else if ((width == SIZE_UNDEFINED && getWidth() != SIZE_UNDEFINED)
|| (unit == Unit.PERCENTAGE
&& getWidthUnits() != Unit.PERCENTAGE
&& !ComponentSizeValidator
.parentCanDefineWidth(this))) {
/*
* relative width children may get to invalid state if width becomes
* invalid. Width may also become invalid if units become percentage
* due to the fallback support
*/
childrenMayBecomeUndefined = true;
dirtyChild = getInvalidSizedChild(false);
}
super.setWidth(width, unit);
repaintChangedChildTree(dirtyChild, childrenMayBecomeUndefined, false);
}
private void repaintChangedChildTree(boolean invalidChild,
boolean childrenMayBecomeUndefined, boolean vertical) {
if (getContent() == null) {
return;
}
boolean needRepaint = false;
if (childrenMayBecomeUndefined) {
// if became invalid now
needRepaint = !invalidChild && getInvalidSizedChild(vertical);
} else if (invalidChild) {
// if not still invalid
needRepaint = !getInvalidSizedChild(vertical);
}
if (needRepaint) {
getContent().markAsDirtyRecursive();
}
}
private boolean getInvalidSizedChild(final boolean vertical) {
Component content = getContent();
if (content == null) {
return false;
}
if (vertical) {
return !ComponentSizeValidator.checkHeights(content);
} else {
return !ComponentSizeValidator.checkWidths(content);
}
}
@Override
public void setHeight(float height, Unit unit) {
/*
* child tree repaints may be needed, due to our fall back support for
* invalid relative sizes
*/
boolean dirtyChild = false;
boolean childrenMayBecomeUndefined = false;
if (getHeight() == SIZE_UNDEFINED && height != SIZE_UNDEFINED) {
// children currently in invalid state may need repaint
dirtyChild = getInvalidSizedChild(true);
} else if ((height == SIZE_UNDEFINED && getHeight() != SIZE_UNDEFINED)
|| (unit == Unit.PERCENTAGE
&& getHeightUnits() != Unit.PERCENTAGE
&& !ComponentSizeValidator
.parentCanDefineHeight(this))) {
/*
* relative height children may get to invalid state if height
* becomes invalid. Height may also become invalid if units become
* percentage due to the fallback support.
*/
childrenMayBecomeUndefined = true;
dirtyChild = getInvalidSizedChild(true);
}
super.setHeight(height, unit);
repaintChangedChildTree(dirtyChild, childrenMayBecomeUndefined, true);
}
/*
* (non-Javadoc)
*
* @see com.vaadin.ui.AbstractComponent#readDesign(org.jsoup.nodes .Element,
* com.vaadin.ui.declarative.DesignContext)
*/
@Override
public void readDesign(Element design, DesignContext designContext) {
// process default attributes
super.readDesign(design, designContext);
readDesignChildren(design.children(), designContext);
}
/**
* Reads the content component from the list of child elements of a design.
* The list must be empty or contain a single element; if the design
* contains multiple child elements, a DesignException is thrown. This
* method should be overridden by subclasses whose design may contain
* non-content child elements.
*
* @since 7.5.0
*
* @param children
* the child elements of the design that is being read
* @param context
* the DesignContext instance used to parse the design
*
* @throws DesignException
* if there are multiple child elements
* @throws DesignException
* if a child element could not be parsed as a Component
*/
protected void readDesignChildren(Elements children,
DesignContext context) {
if (children.size() > 1) {
throw new DesignException(
"The container of type " + getClass().toString()
+ " can have only one child component.");
} else if (children.size() == 1) {
setContent(context.readDesign(children.first()));
}
}
/*
* (non-Javadoc)
*
* @see com.vaadin.ui.AbstractComponent#writeDesign(org.jsoup.nodes.Element
* , com.vaadin.ui.declarative.DesignContext)
*/
@Override
public void writeDesign(Element design, DesignContext designContext) {
// write default attributes (also clears children and attributes)
super.writeDesign(design, designContext);
AbstractSingleComponentContainer def = designContext
.getDefaultInstance(this);
if (!designContext.shouldWriteChildren(this, def)) {
return;
}
// handle child component
Component child = getContent();
if (child != null) {
Element childNode = designContext.createElement(child);
design.appendChild(childNode);
}
}
@Override
protected AbstractSingleComponentContainerState getState() {
return (AbstractSingleComponentContainerState) super.getState();
}
@Override
protected AbstractSingleComponentContainerState getState(
boolean markAsDirty) {
return (AbstractSingleComponentContainerState) super.getState(
markAsDirty);
}
}