Package com.vaadin.ui

Class Composite

    • Constructor Detail

      • Composite

        public Composite​(AbstractComponent compositionRoot)
        Constructs a new composite containing the given component.
        Parameters:
        compositionRoot - the root of the composition component tree. It must not be null.

    • Method Detail

      • getCompositionRoot

        protected Component getCompositionRoot()
        Returns the composition root.
        Returns:
        the Component Composition root.

      • setCompositionRoot

        protected void setCompositionRoot​(Component compositionRoot)
        Sets the component contained in the composite.

        You must set the composition root to a non-null value before the component can be used. It cannot be changed.

        Parameters:
        compositionRoot - the root of the composition component tree.

      • iterator

        public Iterator<Component> iterator()
        Description copied from interface: HasComponents
        Gets an iterator to the collection of contained components. Using this iterator it is possible to step through all components contained in this container.

        The iterator is typically unmodifiable, and calls to Iterator.remove() throw an exception.

        Specified by:
        iterator in interface HasComponents
        Specified by:
        iterator in interface Iterable<Component>
        Returns:
        the component iterator.

      • getState

        protected CompositeState getState()
        Description copied from class: AbstractComponent
        Returns the shared state bean with information to be sent from the server to the client. Subclasses should override this method and set any relevant fields of the state returned by super.getState().
        Overrides:
        getState in class AbstractComponent
        Returns:
        updated component shared state

      • beforeClientResponse

        public void beforeClientResponse​(boolean initial)
        Description copied from interface: ClientConnector
        Called before the shared state and RPC invocations are sent to the client. Gives the connector an opportunity to set computed/dynamic state values or to invoke last minute RPC methods depending on other component features.
        Specified by:
        beforeClientResponse in interface ClientConnector
        Overrides:
        beforeClientResponse in class AbstractComponent
        Parameters:
        initial - true if the client-side connector will be created and initialized after this method has been invoked. false if there is already an initialized client-side connector.

      • getStyleName

        public String getStyleName()
        Description copied from interface: Component
        Gets all user-defined CSS style names of a component. If the component has multiple style names defined, the return string is a space-separated list of style names. Built-in style names defined in Vaadin or GWT are not returned.

        The style names are returned only in the basic form in which they were added; each user-defined style name shows as two CSS style class names in the rendered HTML: one as it was given and one prefixed with the component-specific style name. Only the former is returned.

        Specified by:
        getStyleName in interface Component
        Overrides:
        getStyleName in class AbstractComponent
        Returns:
        the style name or a space-separated list of user-defined style names of the component
        See Also:
        Component.setStyleName(String), Component.addStyleName(String), Component.removeStyleName(String)

      • setStyleName

        public void setStyleName​(String style)
        Description copied from interface: Component
        Sets one or more user-defined style names of the component, replacing any previous user-defined styles. Multiple styles can be specified as a space-separated list of style names. The style names must be valid CSS class names and should not conflict with any built-in style names in Vaadin or GWT. 
         Label label = new Label("This text has a lot of style");
 label.setStyleName("myonestyle myotherstyle");

        Each style name will occur in two versions: one as specified and one that is prefixed with the style name of the component. For example, if you have a Button component and give it "mystyle" style, the component will have both "mystyle" and "v-button-mystyle" styles. You could then style the component either with: 

         .myonestyle {background: blue;}

        or 

         .v-button-myonestyle {background: blue;}

        It is normally a good practice to use addStyleName() rather than this setter, as different software abstraction layers can then add their own styles without accidentally removing those defined in other layers.

        Specified by:
        setStyleName in interface Component
        Overrides:
        setStyleName in class AbstractComponent
        Parameters:
        style - the new style or styles of the component as a space-separated list
        See Also:
        Component.getStyleName(), Component.addStyleName(String), Component.removeStyleName(String)

      • addStyleName

        public void addStyleName​(String style)
        Description copied from interface: Component
        Adds one or more style names to this component. Multiple styles can be specified as a space-separated list of style names. The style name will be rendered as a HTML class name, which can be used in a CSS definition. 
         Label label = new Label("This text has style");
 label.addStyleName("mystyle");

        Each style name will occur in two versions: one as specified and one that is prefixed with the style name of the component. For example, if you have a Button component and give it "mystyle" style, the component will have both "mystyle" and "v-button-mystyle" styles. You could then style the component either with: 

         .mystyle {font-style: italic;}

        or 

         .v-button-mystyle {font-style: italic;}
        Specified by:
        addStyleName in interface Component
        Overrides:
        addStyleName in class AbstractComponent
        Parameters:
        style - the new style to be added to the component
        See Also:
        Component.getStyleName(), Component.setStyleName(String), Component.removeStyleName(String)

      • setPrimaryStyleName

        public void setPrimaryStyleName​(String style)
        Description copied from interface: Component
        Changes the primary style name of the component.

        The primary style name identifies the component when applying the CSS theme to the Component. By changing the style name all CSS rules targeted for that style name will no longer apply, and might result in the component not working as intended.

        To preserve the original style of the component when changing to a new primary style you should make your new primary style inherit the old primary style using the SASS @include directive. See more in the SASS tutorials.

        Specified by:
        setPrimaryStyleName in interface Component
        Overrides:
        setPrimaryStyleName in class AbstractComponent
        Parameters:
        style - The new primary style name

      • setEnabled

        public void setEnabled​(boolean enabled)
        Description copied from interface: Component
        Enables or disables the component. The user can not interact with disabled components, which are shown with a style that indicates the status, usually shaded in light gray color. Components are enabled by default. 
         Button enabled = new Button("Enabled");
 enabled.setEnabled(true); // The default
 layout.addComponent(enabled);

 Button disabled = new Button("Disabled");
 disabled.setEnabled(false);
 layout.addComponent(disabled);
        Specified by:
        setEnabled in interface Component
        Overrides:
        setEnabled in class AbstractComponent
        Parameters:
        enabled - a boolean value specifying if the component should be enabled or not

      • isEnabled

        public boolean isEnabled()
        Description copied from interface: Component
        Tests whether the component is enabled or not. A user can not interact with disabled components. Disabled components are rendered in a style that indicates the status, usually in gray color. Children of a disabled component are also disabled. Components are enabled by default.

        As a security feature, all updates for disabled components are blocked on the server-side.

        Note that this method only returns the status of the component and does not take parents into account. Even though this method returns true the component can be disabled to the user if a parent is disabled.

        Specified by:
        isEnabled in interface Component
        Overrides:
        isEnabled in class AbstractComponent
        Returns:
        true if the component and its parent are enabled, false otherwise.
        See Also:
        VariableOwner.isEnabled()

      • getWidth

        public float getWidth()
        Description copied from interface: Sizeable
        Gets the width of the object. Negative number implies unspecified size (terminal is free to set the size).
        Specified by:
        getWidth in interface Sizeable
        Overrides:
        getWidth in class AbstractComponent
        Returns:
        width of the object in units specified by widthUnits property.

      • getHeight

        public float getHeight()
        Description copied from interface: Sizeable
        Gets the height of the object. Negative number implies unspecified size (terminal is free to set the size).
        Specified by:
        getHeight in interface Sizeable
        Overrides:
        getHeight in class AbstractComponent
        Returns:
        height of the object in units specified by heightUnits property.

      • setHeight

        public void setHeight​(String height)
        Description copied from interface: Sizeable
        Sets the height of the component using String presentation. String presentation is similar to what is used in Cascading Style Sheets. Size can be length or percentage of available size. The empty string ("") or null will unset the height and set the units to pixels. See CSS specification for more details.
        Specified by:
        setHeight in interface Sizeable
        Overrides:
        setHeight in class AbstractComponent
        Parameters:
        height - in CSS style string representation

      • setWidth

        public void setWidth​(float width,
                     Sizeable.Unit unit)
        Description copied from interface: Sizeable
        Sets the width of the object. Negative number implies unspecified size (terminal is free to set the size).
        Specified by:
        setWidth in interface Sizeable
        Overrides:
        setWidth in class AbstractComponent
        Parameters:
        width - the width of the object.
        unit - the unit used for the width.

      • setHeight

        public void setHeight​(float height,
                      Sizeable.Unit unit)
        Description copied from interface: Sizeable
        Sets the height of the object. Negative number implies unspecified size (terminal is free to set the size).
        Specified by:
        setHeight in interface Sizeable
        Overrides:
        setHeight in class AbstractComponent
        Parameters:
        height - the height of the object.
        unit - the unit used for the width.

      • setWidth

        public void setWidth​(String width)
        Description copied from interface: Sizeable
        Sets the width of the component using String presentation. String presentation is similar to what is used in Cascading Style Sheets. Size can be length or percentage of available size. The empty string ("") or null will unset the width and set the units to pixels. See CSS specification for more details.
        Specified by:
        setWidth in interface Sizeable
        Overrides:
        setWidth in class AbstractComponent
        Parameters:
        width - in CSS style string representation, null or empty string to reset

      • setId

        public void setId​(String id)
        Description copied from interface: Component
        Adds an unique id for component that is used in the client-side for testing purposes. Keeping identifiers unique is the responsibility of the programmer.
        Specified by:
        setId in interface Component
        Overrides:
        setId in class AbstractComponent
        Parameters:
        id - An alphanumeric id

      • setCaption

        public void setCaption​(String caption)
        Description copied from interface: Component
        Sets the caption of the component.

        A caption is an explanatory textual label accompanying a user interface component, usually shown above, left of, or inside the component. Icon (see setIcon() is closely related to caption and is usually displayed horizontally before or after it, depending on the component and the containing layout.

        The caption can usually also be given as the first parameter to a constructor, though some components do not support it. 

         RichTextArea area = new RichTextArea();
 area.setCaption("You can edit stuff here");
 area.setValue("<h1>Helpful Heading</h1>"
         + "<p>All this is for you to edit.</p>");

        The contents of a caption are automatically quoted, so no raw HTML can be rendered in a caption. The validity of the used character encoding, usually UTF-8, is not checked.

        The caption of a component is, by default, managed and displayed by the layout component or component container in which the component is placed. For example, the VerticalLayout component shows the captions left-aligned above the contained components, while the FormLayout component shows the captions on the left side of the vertically laid components, with the captions and their associated components left-aligned in their own columns. The CustomComponent does not manage the caption of its composition root, so if the root component has a caption, it will not be rendered. Some components, such as Button and Panel, manage the caption themselves and display it inside the component.

        Specified by:
        setCaption in interface Component
        Overrides:
        setCaption in class AbstractComponent
        Parameters:
        caption - the new caption for the component. If the caption is null, no caption is shown and it does not normally take any space

      • setCaptionAsHtml

        public void setCaptionAsHtml​(boolean captionAsHtml)
        Description copied from class: AbstractComponent
        Sets whether the caption is rendered as HTML.

        If set to true, the captions are rendered in the browser as HTML and the developer is responsible for ensuring no harmful HTML is used. If set to false, the caption is rendered in the browser as plain text.

        The default is false, i.e. to render that caption as plain text.

        Overrides:
        setCaptionAsHtml in class AbstractComponent
        Parameters:
        captionAsHtml - true if the captions are rendered as HTML, false if rendered as plain text

      • isCaptionAsHtml

        public boolean isCaptionAsHtml()
        Description copied from class: AbstractComponent
        Checks whether captions are rendered as HTML

        The default is false, i.e. to render that caption as plain text.

        Overrides:
        isCaptionAsHtml in class AbstractComponent
        Returns:
        true if the captions are rendered as HTML, false if rendered as plain text

      • getDescription

        public String getDescription()
        Description copied from interface: Component

        Gets the components description, used in tooltips and can be displayed directly in certain other components such as forms. The description can be used to briefly describe the state of the component to the user. The description string may contain certain XML tags:

        Tag Description Example
        <b> bold bold text
        <i> italic italic text
        <u> underlined underlined text
        <br> linebreak N/A
        <ul>
        <li>item1
        <li>item1
        </ul>        		 item list
        • item1
        • item2

        These tags may be nested.

        Specified by:
        getDescription in interface Component
        Overrides:
        getDescription in class AbstractComponent
        Returns:
        component's description String

      • setDescription

        public void setDescription​(String description,
                           ContentMode mode)
        Description copied from class: AbstractComponent
        Sets the component's description using given content mode. See AbstractComponent.getDescription() for more information on what the description is.

        If the content mode is ContentMode.HTML the description is displayed as HTML in tooltips or directly in certain components so care should be taken to avoid creating the possibility for HTML injection and possibly XSS vulnerabilities.

        Overrides:
        setDescription in class AbstractComponent
        Parameters:
        description - the new description string for the component.
        mode - the content mode for the description

      • getErrorMessage

        public ErrorMessage getErrorMessage()
        Description copied from class: AbstractComponent
        Gets the error message for this component.
        Overrides:
        getErrorMessage in class AbstractComponent
        Returns:
        ErrorMessage containing the description of the error state of the component or null, if the component contains no errors. Extending classes should override this method if they support other error message types such as validation errors or buffering errors. The returned error message contains information about all the errors.

      • setComponentError

        public void setComponentError​(ErrorMessage componentError)
        Description copied from class: AbstractComponent
        Sets the component's error message. The message may contain certain XML tags, for more information see ErrorMessage.
        Overrides:
        setComponentError in class AbstractComponent
        Parameters:
        componentError - the new ErrorMessage of the component.