// handle children
for (Element childComponent : design.children()) {
Attributes attr = childComponent.attributes();
- DesignSynchronizable newChild = designContext
- .createChild(childComponent);
+ Component newChild = designContext.createChild(childComponent);
StringBuilder css = new StringBuilder();
if (attr.hasKey(ATTR_TOP)) {
css.append("top:").append(attr.get(ATTR_TOP)).append(";");
// handle children
Element designElement = design;
for (Component child : this) {
- DesignSynchronizable childComponent = (DesignSynchronizable) child;
- Element childNode = designContext.createNode(childComponent);
+ Element childNode = designContext.createNode(child);
designElement.appendChild(childNode);
- childComponent.synchronizeToDesign(childNode, designContext);
+ child.synchronizeToDesign(childNode, designContext);
// handle position
ComponentPosition position = getPosition(child);
writePositionAttribute(childNode, ATTR_TOP, position.getTopUnits()
*/
@SuppressWarnings("serial")
public abstract class AbstractComponent extends AbstractClientConnector
- implements DesignSynchronizable {
+ implements Component {
/* Private members */
* (non-Javadoc)
*
* @see
- * com.vaadin.ui.DesignSynchronizable#synchronizeFromDesign(org.jsoup.nodes
- * .Element, com.vaadin.ui.declarative.DesignContext)
+ * com.vaadin.ui.Component#synchronizeFromDesign(org.jsoup.nodes.Element,
+ * com.vaadin.ui.declarative.DesignContext)
*/
@Override
public void synchronizeFromDesign(Element design,
* the default instance of the class for fetching the default
* values
*/
- private void writeSize(Attributes attributes,
- DesignSynchronizable defaultInstance) {
+ private void writeSize(Attributes attributes, Component defaultInstance) {
if (hasEqualSize(defaultInstance)) {
// we have default values -> ignore
return;
/*
* (non-Javadoc)
*
- * @see
- * com.vaadin.ui.DesignSynchronizable#synchronizeToDesign(org.jsoup.nodes
- * .Element, com.vaadin.ui.declarative.DesignContext)
+ * @see com.vaadin.ui.Component#synchronizeToDesign(org.jsoup.nodes.Element,
+ * com.vaadin.ui.declarative.DesignContext)
*/
@Override
public void synchronizeToDesign(Element design, DesignContext designContext) {
import org.jsoup.nodes.Attributes;
import org.jsoup.nodes.Element;
-import org.jsoup.nodes.Node;
import com.vaadin.event.LayoutEvents.LayoutClickEvent;
import com.vaadin.event.LayoutEvents.LayoutClickListener;
setMargin(def.getMargin().getBitMask() != 0);
}
// handle children
- for (Node childComponent : design.childNodes()) {
- if (childComponent instanceof Element) {
- Attributes attr = childComponent.attributes();
- DesignSynchronizable newChild = designContext
- .createChild((Element) childComponent);
- addComponent(newChild);
- // handle alignment
- int bitMask = 0;
- if (attr.hasKey(":middle")) {
- bitMask += AlignmentInfo.Bits.ALIGNMENT_VERTICAL_CENTER;
- } else if (attr.hasKey(":bottom")) {
- bitMask += AlignmentInfo.Bits.ALIGNMENT_BOTTOM;
- } else {
- bitMask += AlignmentInfo.Bits.ALIGNMENT_TOP;
- }
- if (attr.hasKey(":center")) {
- bitMask += AlignmentInfo.Bits.ALIGNMENT_HORIZONTAL_CENTER;
- } else if (attr.hasKey(":right")) {
- bitMask += AlignmentInfo.Bits.ALIGNMENT_RIGHT;
- } else {
- bitMask += AlignmentInfo.Bits.ALIGNMENT_LEFT;
- }
- setComponentAlignment(newChild, new Alignment(bitMask));
- // handle expand ratio
- if (attr.hasKey(":expand")) {
- String value = attr.get(":expand");
- if (value.length() > 0) {
- try {
- float ratio = Float.valueOf(value);
- setExpandRatio(newChild, ratio);
- } catch (NumberFormatException nfe) {
- getLogger().info(
- "Failed to parse expand ratio " + value);
- }
- } else {
- setExpandRatio(newChild, 1.0f);
+ for (Element childComponent : design.children()) {
+ Attributes attr = childComponent.attributes();
+ Component newChild = designContext.createChild(childComponent);
+ addComponent(newChild);
+ // handle alignment
+ int bitMask = 0;
+ if (attr.hasKey(":middle")) {
+ bitMask += AlignmentInfo.Bits.ALIGNMENT_VERTICAL_CENTER;
+ } else if (attr.hasKey(":bottom")) {
+ bitMask += AlignmentInfo.Bits.ALIGNMENT_BOTTOM;
+ } else {
+ bitMask += AlignmentInfo.Bits.ALIGNMENT_TOP;
+ }
+ if (attr.hasKey(":center")) {
+ bitMask += AlignmentInfo.Bits.ALIGNMENT_HORIZONTAL_CENTER;
+ } else if (attr.hasKey(":right")) {
+ bitMask += AlignmentInfo.Bits.ALIGNMENT_RIGHT;
+ } else {
+ bitMask += AlignmentInfo.Bits.ALIGNMENT_LEFT;
+ }
+ setComponentAlignment(newChild, new Alignment(bitMask));
+ // handle expand ratio
+ if (attr.hasKey(":expand")) {
+ String value = attr.get(":expand");
+ if (value.length() > 0) {
+ try {
+ float ratio = Float.valueOf(value);
+ setExpandRatio(newChild, ratio);
+ } catch (NumberFormatException nfe) {
+ getLogger().info(
+ "Failed to parse expand ratio " + value);
}
+ } else {
+ setExpandRatio(newChild, 1.0f);
}
}
}
// handle children
Element designElement = design;
for (Component child : this) {
- DesignSynchronizable childComponent = (DesignSynchronizable) child;
- Element childNode = designContext.createNode(childComponent);
+ Element childNode = designContext.createNode(child);
designElement.appendChild(childNode);
// handle alignment
Alignment alignment = getComponentAlignment(child);
+ " can have only one child component.");
} else if (childCount == 1) {
Element childElement = design.children().get(0);
- DesignSynchronizable newChild = designContext
- .createChild(childElement);
+ Component newChild = designContext.createChild(childElement);
setContent(newChild);
} else {
setContent(null);
// synchronize default attributes (also clears children and attributes)
super.synchronizeToDesign(design, designContext);
// handle child component
- DesignSynchronizable child = (DesignSynchronizable) getContent();
+ Component child = getContent();
if (child != null) {
Element childNode = designContext.createNode(child);
design.appendChild(childNode);
* (non-Javadoc)
*
* @see
- * com.vaadin.ui.DesignSynchronizable#synchronizeFromDesign(org.jsoup.nodes
+ * com.vaadin.ui.AbstractComponent#synchronizeFromDesign(org.jsoup.nodes
* .Element, com.vaadin.ui.declarative.DesignContext)
*/
@Override
* (non-Javadoc)
*
* @see
- * com.vaadin.ui.DesignSynchronizable#synchronizeToDesign(org.jsoup.nodes
- * .Element, com.vaadin.ui.declarative.DesignContext)
+ * com.vaadin.ui.AbstractComponent#synchronizeToDesign(org.jsoup.nodes.Element
+ * , com.vaadin.ui.declarative.DesignContext)
*/
@Override
public void synchronizeToDesign(Element design, DesignContext designContext) {
import java.io.Serializable;
import java.util.Locale;
+import org.jsoup.nodes.Element;
+
import com.vaadin.event.ConnectorEvent;
import com.vaadin.event.ConnectorEventListener;
import com.vaadin.event.FieldEvents;
import com.vaadin.server.Resource;
import com.vaadin.server.Sizeable;
import com.vaadin.server.VariableOwner;
+import com.vaadin.ui.declarative.DesignContext;
/**
* {@code Component} is the top-level interface that is and must be implemented
*/
public String getDescription();
+ /* Declarative support */
+
+ /**
+ * Update the component state based on the given design. The component is
+ * responsible not only for updating itself but also ensuring that its
+ * children update their state based on the design.
+ * <p>
+ * This method must not modify the design.
+ *
+ * @since 7.4
+ * @param design
+ * The design as HTML to obtain the state from
+ * @param designContext
+ * The DesignContext instance used for parsing the design
+ */
+ public void synchronizeFromDesign(Element design,
+ DesignContext designContext);
+
+ /**
+ * Update the given design based on the component state. The component is
+ * responsible not only for updating itself but also for ensuring its
+ * children update themselves in the correct position in the design. The
+ * caller of this method should not assume that contents of the
+ * <code>design</code> parameter are presented.
+ * <p>
+ * This method must not modify the component state.
+ *
+ * @since 7.4
+ * @param design
+ * The design as HTML to update with the current state
+ * @param designContext
+ */
+ public void synchronizeToDesign(Element design, DesignContext designContext);
+
/* Component event framework */
/**
removeAllComponents();
// handle children
for (Element childComponent : design.children()) {
- DesignSynchronizable newChild = designContext
- .createChild(childComponent);
+ Component newChild = designContext.createChild(childComponent);
addComponent(newChild);
}
}
// handle children
Element designElement = design;
for (Component child : this) {
- DesignSynchronizable childComponent = (DesignSynchronizable) child;
- Element childNode = designContext.createNode(childComponent);
+ Element childNode = designContext.createNode(child);
designElement.appendChild(childNode);
}
}
+++ /dev/null
-/*
- * Copyright 2000-2014 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 org.jsoup.nodes.Element;
-
-import com.vaadin.ui.declarative.DesignContext;
-
-/**
- * Interface to be implemented by all the components that can be read from or
- * written to HTML design representation. TODO: add reference to VisualDesigner
- *
- * @since 7.4
- *
- * @author Vaadin Ltd
- */
-public interface DesignSynchronizable extends Component {
-
- /**
- * Update the component state based on the given design. The component is
- * responsible not only for updating itself but also ensuring that its
- * children update their state based on the design.
- * <p>
- * This method must not modify the design.
- *
- * @since 7.4
- * @param design
- * The design as HTML to obtain the state from
- * @param designContext
- * The DesignContext instance used for parsing the design
- */
- public void synchronizeFromDesign(Element design,
- DesignContext designContext);
-
- /**
- * Update the given design based on the component state. The component is
- * responsible not only for updating itself but also for ensuring its
- * children update themselves in the correct position in the design. The
- * caller of this method should not assume that contents of the
- * <code>design</code> parameter are presented.
- * <p>
- * This method must not modify the component state.
- *
- * @since 7.4
- * @param design
- * The design as HTML to update with the current state
- * @param designContext
- */
- public void synchronizeToDesign(Element design, DesignContext designContext);
-}
* (non-Javadoc)
*
* @see
- * com.vaadin.ui.DesignSynchronizable#synchronizeFromDesign(org.jsoup.nodes
+ * com.vaadin.ui.AbstractComponent#synchronizeFromDesign(org.jsoup.nodes
* .Element, com.vaadin.ui.declarative.DesignContext)
*/
@Override
* (non-Javadoc)
*
* @see
- * com.vaadin.ui.DesignSynchronizable#synchronizeToDesign(org.jsoup.nodes
- * .Element, com.vaadin.ui.declarative.DesignContext)
+ * com.vaadin.ui.AbstractComponent#synchronizeToDesign(org.jsoup.nodes.Element
+ * , com.vaadin.ui.declarative.DesignContext)
*/
@Override
public void synchronizeToDesign(Element design, DesignContext designContext) {
}
// create the component that is in tab content
Element content = tabElement.child(0);
- DesignSynchronizable child = designContext.createChild(content);
+ Component child = designContext.createChild(content);
Tab tab = this.addTab(child);
tab.setVisible(DesignAttributeHandler.readAttribute("visible", attr,
tab.isVisible(), Boolean.class));
// create element for tab
Element tabElement = design.appendElement("tab");
// add tab content
- tabElement.appendChild(designContext
- .createNode((DesignSynchronizable) tab.getComponent()));
+ tabElement.appendChild(designContext.createNode(tab.getComponent()));
Attributes attr = tabElement.attributes();
// write attributes
DesignAttributeHandler.writeAttribute("visible", attr, tab.isVisible(),
import com.vaadin.server.Resource;
import com.vaadin.server.ThemeResource;
import com.vaadin.shared.util.SharedUtil;
-import com.vaadin.ui.DesignSynchronizable;
+import com.vaadin.ui.Component;
/**
* Default attribute handler implementation used when parsing designs to
* values
* @return true on success
*/
- public static boolean readAttribute(DesignSynchronizable component,
- String attribute, Attributes attributes,
- DesignSynchronizable defaultInstance) {
+ public static boolean readAttribute(Component component, String attribute,
+ Attributes attributes, Component defaultInstance) {
String value = null;
if (component == null || attribute == null || attributes == null
|| defaultInstance == null) {
* @param defaultInstance
* the default instance for comparing default values
*/
- public static void writeAttribute(DesignSynchronizable component,
- String attribute, Attributes attr,
- DesignSynchronizable defaultInstance) {
+ public static void writeAttribute(Component component, String attribute,
+ Attributes attr, Component defaultInstance) {
Method getter = findGetterForAttribute(component.getClass(), attribute);
if (getter == null) {
getLogger().warning(
import org.jsoup.nodes.Node;
import com.vaadin.ui.Component;
-import com.vaadin.ui.DesignSynchronizable;
/**
* This class contains contextual information that is collected when a component
.synchronizedMap(new HashMap<Class<?>, Object>());
// The root component of the component hierarchy
- private DesignSynchronizable componentRoot = null;
+ private Component componentRoot = null;
// Attribute names for global id and caption and the prefix name for a local
// id
public static final String ID_ATTRIBUTE = "id";
public static final String CAPTION_ATTRIBUTE = "caption";
public static final String LOCAL_ID_ATTRIBUTE = "_id";
// Mappings from ids to components. Modified when synchronizing from design.
- private Map<String, DesignSynchronizable> idToComponent = new HashMap<String, DesignSynchronizable>();
- private Map<String, DesignSynchronizable> localIdToComponent = new HashMap<String, DesignSynchronizable>();
- private Map<String, DesignSynchronizable> captionToComponent = new HashMap<String, DesignSynchronizable>();
+ private Map<String, Component> idToComponent = new HashMap<String, Component>();
+ private Map<String, Component> localIdToComponent = new HashMap<String, Component>();
+ private Map<String, Component> captionToComponent = new HashMap<String, Component>();
// Mapping from components to local ids. Accessed when synchronizing to
// design. Modified when synchronizing from design.
- private Map<DesignSynchronizable, String> componentToLocalId = new HashMap<DesignSynchronizable, String>();
+ private Map<Component, String> componentToLocalId = new HashMap<Component, String>();
private Document doc; // required for calling createElement(String)
// namespace mappings
private Map<String, String> packageToPrefix = new HashMap<String, String>();
* The local id of the component
* @return a component whose local id equals localId
*/
- public DesignSynchronizable getComponentByLocalId(String localId) {
+ public Component getComponentByLocalId(String localId) {
return localIdToComponent.get(localId);
}
* The global id of the component
* @return a component whose global id equals globalId
*/
- public DesignSynchronizable getComponentById(String globalId) {
+ public Component getComponentById(String globalId) {
return idToComponent.get(globalId);
}
* The caption of the component
* @return a component whose caption equals the caption given as a parameter
*/
- public DesignSynchronizable getComponentByCaption(String caption) {
+ public Component getComponentByCaption(String caption) {
return captionToComponent.get(caption);
}
* @return true, if there already was a global id mapping from the string to
* some component.
*/
- private boolean mapId(String globalId, DesignSynchronizable component) {
- DesignSynchronizable oldComponent = idToComponent.get(globalId);
+ private boolean mapId(String globalId, Component component) {
+ Component oldComponent = idToComponent.get(globalId);
if (oldComponent != null && !oldComponent.equals(component)) {
oldComponent.setId(null);
}
* some component or from the component to some string. Otherwise
* returns false.
*/
- private boolean mapLocalId(String localId, DesignSynchronizable component) {
+ private boolean mapLocalId(String localId, Component component) {
return twoWayMap(localId, component, localIdToComponent,
componentToLocalId);
}
* @return true, if there already was a caption mapping from the string to
* some component.
*/
- private boolean mapCaption(String caption, DesignSynchronizable component) {
+ private boolean mapCaption(String caption, Component component) {
return captionToComponent.put(caption, component) != null;
}
* rooted at the returned Node.
*
* @param childComponent
- * A component implementing the DesignSynchronizable interface.
+ * The component with state that is synchronized in to the node
* @return An html tree node corresponding to the given component. The tag
* name of the created node is derived from the class name of
* childComponent.
*/
- public Element createNode(DesignSynchronizable childComponent) {
+ public Element createNode(Component childComponent) {
Class<?> componentClass = childComponent.getClass();
String packageName = componentClass.getPackage().getName();
String prefix = packageToPrefix.get(packageName);
}
/**
- * Creates a DesignSynchronizable object corresponding to the given html
- * node. Also calls synchronizeFromDesign() for the created node, in effect
- * creating the entire component hierarchy rooted at the returned component.
+ * Creates a Component corresponding to the given html node. Also calls
+ * synchronizeFromDesign() for the created node, in effect creating the
+ * entire component hierarchy rooted at the returned component.
*
* @param componentDesign
* The html tree node containing the description of the component
* to be created.
- * @return a DesignSynchronizable object corresponding to componentDesign
+ * @return a Component corresponding to componentDesign
*/
- public DesignSynchronizable createChild(Element componentDesign) {
+ public Component createChild(Element componentDesign) {
// Create the component.
- DesignSynchronizable component = instantiateComponent(componentDesign);
+ Component component = instantiateComponent(componentDesign);
synchronizeAndRegister(component, componentDesign);
fireComponentCreatedEvent(componentToLocalId.get(component), component);
return component;
* @param componentDesign
* The html tree node containing the description of the component
*/
- public void synchronizeAndRegister(DesignSynchronizable component,
+ public void synchronizeAndRegister(Component component,
Element componentDesign) {
component.synchronizeFromDesign(componentDesign, this);
// Get the ids and the caption of the component and store them in the
}
/**
- * Creates a DesignSynchronizable component corresponding to the given node.
- * Does not set the attributes for the created object.
+ * Creates a Component corresponding to the given node. Does not set the
+ * attributes for the created object.
*
* @param node
* a node of an html tree
- * @return a DesignSynchronizable object corresponding to node, with no
- * attributes set.
+ * @return a Component corresponding to node, with no attributes set.
*/
- private DesignSynchronizable instantiateComponent(Node node) {
+ private Component instantiateComponent(Node node) {
// Extract the package and class names.
String qualifiedClassName = tagNameToClassName(node);
try {
- Class<? extends DesignSynchronizable> componentClass = resolveComponentClass(qualifiedClassName);
- DesignSynchronizable newComponent = componentClass.newInstance();
+ Class<? extends Component> componentClass = resolveComponentClass(qualifiedClassName);
+ Component newComponent = componentClass.newInstance();
return newComponent;
} catch (Exception e) {
throw new DesignException("No component class could be found for "
}
@SuppressWarnings("unchecked")
- private Class<? extends DesignSynchronizable> resolveComponentClass(
+ private Class<? extends Component> resolveComponentClass(
String qualifiedClassName) throws ClassNotFoundException {
Class<?> componentClass = null;
componentClass = Class.forName(qualifiedClassName);
- // Check that we're dealing with a DesignSynchronizable component.
- if (isDesignSynchronizable(componentClass)) {
- return (Class<? extends DesignSynchronizable>) componentClass;
+ // Check that we're dealing with a Component.
+ if (isComponent(componentClass)) {
+ return (Class<? extends Component>) componentClass;
} else {
throw new IllegalArgumentException(String.format(
"Resolved class %s is not a %s.", componentClass.getName(),
* @return {@code true} if the given {@link Class} is a {@link Component},
* {@code false} otherwise.
*/
- private static boolean isDesignSynchronizable(Class<?> componentClass) {
+ private static boolean isComponent(Class<?> componentClass) {
if (componentClass != null) {
- return DesignSynchronizable.class.isAssignableFrom(componentClass);
+ return Component.class.isAssignableFrom(componentClass);
} else {
return false;
}
*
* @return
*/
- public DesignSynchronizable getComponentRoot() {
+ public Component getComponentRoot() {
return componentRoot;
}
/**
* Sets the root component of a created component hierarchy.
*/
- public void setComponentRoot(DesignSynchronizable componentRoot) {
+ public void setComponentRoot(Component componentRoot) {
this.componentRoot = componentRoot;
}
* @param component
* the component that was created
*/
- private void fireComponentCreatedEvent(String localId,
- DesignSynchronizable component) {
+ private void fireComponentCreatedEvent(String localId, Component component) {
ComponentCreatedEvent event = new ComponentCreatedEvent(localId,
component);
for (ComponentCreationListener listener : listeners) {
*/
public class ComponentCreatedEvent implements Serializable {
private String localId;
- private DesignSynchronizable component;
+ private Component component;
private DesignContext context;
/**
* @param component
* the created component
*/
- private ComponentCreatedEvent(String localId,
- DesignSynchronizable component) {
+ private ComponentCreatedEvent(String localId, Component component) {
this.localId = localId;
this.component = component;
context = DesignContext.this;
*
* @return the component
*/
- public DesignSynchronizable getComponent() {
+ public Component getComponent() {
return component;
}
}
import org.jsoup.parser.Parser;
import org.jsoup.select.Elements;
-import com.vaadin.ui.DesignSynchronizable;
+import com.vaadin.ui.Component;
import com.vaadin.ui.declarative.DesignContext.ComponentCreatedEvent;
import com.vaadin.ui.declarative.DesignContext.ComponentCreationListener;
* object returned by this method.
* @throws IOException
*/
- public static DesignContext parse(InputStream html,
- DesignSynchronizable rootInstance) {
+ public static DesignContext parse(InputStream html, Component rootInstance) {
Document doc;
try {
doc = Jsoup.parse(html, "UTF-8", "", Parser.htmlParser());
* object returned by this method.
* @throws IOException
*/
- public static DesignContext parse(String html,
- DesignSynchronizable rootInstance) {
+ public static DesignContext parse(String html, Component rootInstance) {
Document doc = Jsoup.parse(html);
return parse(doc, rootInstance);
}
* optional component root instance with some member fields. The
* type must match the type of the root element in the design.
* The member fields whose type is assignable from
- * {@link DesignSynchronizable} are set when parsing the
- * component tree
+ * {@link Component} are set when parsing the component tree
*
*/
- private static DesignContext parse(Document doc,
- DesignSynchronizable componentRoot) {
+ private static DesignContext parse(Document doc, Component componentRoot) {
DesignContext designContext = new DesignContext(doc);
designContext.getPrefixes(doc);
// No special handling for a document without a body element - should be
// Append the design under <body> in the html tree. createNode
// creates the entire component hierarchy rooted at the
// given root node.
- DesignSynchronizable root = designContext.getComponentRoot();
+ Component root = designContext.getComponentRoot();
Node rootNode = designContext.createNode(root);
body.appendChild(rootNode);
return doc;
import org.junit.Test;
import com.vaadin.ui.Button;
-import com.vaadin.ui.DesignSynchronizable;
+import com.vaadin.ui.Component;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.NativeButton;
* component hierarchy rooted at context.getComponentRoot().
*/
private void checkHierarchy(DesignContext context) {
- DesignSynchronizable root = context.getComponentRoot();
+ Component root = context.getComponentRoot();
VerticalLayout vlayout = (VerticalLayout) root;
int numComponents = vlayout.getComponentCount();
assertEquals("Wrong number of child components", 3, numComponents);
import com.vaadin.ui.AbsoluteLayout;
import com.vaadin.ui.AbsoluteLayout.ComponentPosition;
import com.vaadin.ui.Component;
-import com.vaadin.ui.DesignSynchronizable;
import com.vaadin.ui.declarative.DesignContext;
/**
private AbsoluteLayout createLayout() {
DesignContext ctx = new DesignContext();
Element design = createDesign();
- DesignSynchronizable child = ctx.createChild(design);
+ Component child = ctx.createChild(design);
return (AbsoluteLayout) child;
}
import org.jsoup.parser.Tag;
import com.vaadin.ui.Alignment;
-import com.vaadin.ui.DesignSynchronizable;
+import com.vaadin.ui.Component;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.ui.declarative.DesignContext;
String... alignments) {
DesignContext ctx = new DesignContext();
Element design = createDesign(expandRatio, margin, alignments);
- DesignSynchronizable child = ctx.createChild(design);
+ Component child = ctx.createChild(design);
return (VerticalLayout) child;
}
import org.jsoup.nodes.Element;
import org.jsoup.parser.Tag;
+import com.vaadin.ui.Component;
import com.vaadin.ui.CssLayout;
-import com.vaadin.ui.DesignSynchronizable;
import com.vaadin.ui.declarative.DesignContext;
/**
private CssLayout createLayout() {
DesignContext ctx = new DesignContext();
Element design = createDesign();
- DesignSynchronizable child = ctx.createChild(design);
+ Component child = ctx.createChild(design);
return (CssLayout) child;
}
projects / vaadin-framework.git / commitdiff