Package com.vaadin.flow.component

Class ComponentUtil

java.lang.Object
com.vaadin.flow.component.ComponentUtil
public class ComponentUtil extends Object
Utility methods for Component.
Since:
1.0
Author:
Vaadin Ltd

  • Method Details

    • findComponents

      public static void findComponents(Element element, Consumer<Component> componentConsumer)
      Finds the first component instance in each Element subtree by traversing the Element tree starting from the given element.
      Parameters:
      element - the element to start scanning from
      componentConsumer - a consumer which is called for each found component

    • getParentUsingComposite

      public static Component getParentUsingComposite(Composite<?> composite, Component component)
      Gets the parent of the given component, which is inside the given composite.

      This method is meant for internal use only.

      Parameters:
      composite - the composite containing the component
      component - the component to get the parent for, must be inside the composite or a nested composite
      Returns:
      the parent of the component, never null

    • getInnermostComponent

      public static Component getInnermostComponent(Composite<?> composite)
      Returns the innermost component from a Composite chain, i.e. the first content which is not a Composite.
      Parameters:
      composite - a composite in the chain
      Returns:
      the innermost component

    • isCompositeContent

      public static boolean isCompositeContent(Composite<?> composite, Component component)
      Checks if the given component is inside a Composite chain, i.e. it is a composite in the chain or the content of the innermost Composite.
      Parameters:
      composite - the first composite
      component - the component to look for
      Returns:
      true if the component is inside the composite chain, false otherwise

    • findParentComponent

      public static Optional<Component> findParentComponent(Element element)
      Finds the first component by traversing upwards in the element hierarchy, starting from the given element.
      Parameters:
      element - the element from which to begin the search
      Returns:
      optional of the component, empty if no component is found

    • getInnermostComponent

      public static Component getInnermostComponent(Element element)
      Gets the innermost mapped component for the element.

      This returns Element.getComponent() if something else than a Composite is mapped to the element. If a Composite is mapped to the element, finds the innermost content of the Composite chain.

      Parameters:
      element - the element which is mapped to a component
      Returns:
      the innermost component mapped to the element

    • onComponentAttach

      public static void onComponentAttach(Component component, boolean initialAttach)
      Handles triggering the onAttach method and firing the AttachEvent for the given component when it has been attached to a UI.
      Parameters:
      component - the component attached to a UI
      initialAttach - indicates if this is the first time the component (element) has been attached

    • onComponentDetach

      public static void onComponentDetach(Component component)
      Handles triggering the onDetach method and firing the DetachEvent for the given component right before it is detached from a UI.
      Parameters:
      component - the component detached from a UI

    • addListener

      public static <T extends ComponentEvent<?>> Registration addListener(Component component, Class<T> eventType, ComponentEventListener<T> listener)
      Adds a listener for an event of the given type to the component.
      Type Parameters:
      T - the component event type
      Parameters:
      component - the component to add the listener
      eventType - the component event type, not null
      listener - the listener to add, not null
      Returns:
      a handle that can be used for removing the listener

    • addListener

      public static <T extends ComponentEvent<?>> Registration addListener(Component component, Class<T> eventType, ComponentEventListener<T> listener, Consumer<DomListenerRegistration> domListenerConsumer)
      Adds a listener for an event of the given type to the component, and customizes the corresponding DOM event listener with the given consumer. This allows overriding eg. the debounce settings defined in the DomEvent annotation.

      Note that customizing the DOM event listener works only for event types which are annotated with DomEvent. Use addListener(Component, Class, ComponentEventListener) for other listeners, or if you don't need to customize the DOM listener.

      Type Parameters:
      T - the event type
      Parameters:
      component - the component to add the listener
      eventType - the event type for which to call the listener, must be annotated with DomEvent
      listener - the listener to call when the event occurs, not null
      domListenerConsumer - a consumer to customize the behavior of the DOM event listener, not null
      Returns:
      a handle that can be used for removing the listener
      Throws:
      IllegalArgumentException - if the event type is not annotated with DomEvent

    • hasEventListener

      public static <T extends ComponentEvent<?>> boolean hasEventListener(Component component, Class<? extends T> eventType)
      Check if the component has at least one registered listener of the given event type.
      Parameters:
      component - the component to which the listener(s) are registered.
      eventType - the event type for which the listener(s) are registered.
      Returns:
      a boolean indicating whether at least one listener registered to the component for the given event type.

    • getListeners

      public static Collection<?> getListeners(Component component, Class<? extends ComponentEvent> eventType)
      Returns all listeners that match or extend the given event type.
      Parameters:
      eventType - the component event type
      Returns:
      A collection with all registered listeners for a given event type. Empty if no listeners are found.

    • fireEvent

      public static <T extends Component> void fireEvent(T component, ComponentEvent<? extends T> componentEvent)
      Dispatches the event to all listeners registered for the event type.
      Type Parameters:
      T - the type of the component
      Parameters:
      component - the component for which to fire events
      componentEvent - the event to fire
      See Also:

    • componentFromElement

      public static <T extends Component> T componentFromElement(Element element, Class<T> componentType, boolean mapComponent)
      Creates a new component instance using the given element, maps the component to the element and optionally maps the element to the component (if mapComponent is true).

      This is a helper method for Element#as and Component#from.

      Type Parameters:
      T - the component type
      Parameters:
      element - the element
      componentType - the component type
      mapComponent - true to also map the element to the component, false to only map the component to the element
      Returns:
      a new component instance of the given type
      See Also:

    • getSynchronizedProperties

      public static Collection<ComponentMetaData.SynchronizedPropertyInfo> getSynchronizedProperties(Class<? extends Component> componentClass)
      Gets the synchronized property infos of the properties that are defined declaratively for the given class with their RPC update mode.
      Parameters:
      componentClass - the component class to check
      Returns:
      the synchronized property infos of the properties defined declaratively for the class

    • getSynchronizedPropertyEvents

      public static Stream<String> getSynchronizedPropertyEvents(Class<? extends Component> componentClass)
      Gets the name of the synchronized property event defined declaratively for the given class.
      Parameters:
      componentClass - the component class to check
      Returns:
      the synchronized property events defined declaratively for the class

    • getDependencies

      public static ComponentMetaData.DependencyInfo getDependencies(VaadinService service, Class<? extends Component> componentClass)
      Gets the dependencies for the given class, defined using annotations ( JavaScript, StyleSheet and Uses).
      Parameters:
      service - the service to use for resolving dependencies
      componentClass - the component class to check
      Returns:
      the dependencies for the given class

    • setData

      public static void setData(Component component, String key, Object value)
      Stores a arbitrary value for the given component.
      Parameters:
      component - the component for which to set the data
      key - the key with which the instance can be retrieved, not null
      value - the data to set, or null to remove data previously set with the same key
      See Also:

    • setData

      public static <T> void setData(Component component, Class<T> type, T value)
      Stores an instance of a specific type for the given component.
      Type Parameters:
      T - the data instance type
      Parameters:
      component - the component for which to set the data
      type - the type of the data to set, not null
      value - the data instance to set, or null to remove data previously set with the same type
      See Also:

    • getData

      public static Object getData(Component component, String key)
      Gets a data instance with the given key, or null if no data has been set for that key.
      Parameters:
      component - the component from which to get the data
      key - the data key
      Returns:
      the data instance, or null if no instance has been set using the given key
      See Also:

    • getData

      public static <T> T getData(Component component, Class<T> type)
      Gets a data instance with the given type, or null if there is no such instance.
      Type Parameters:
      T - the data instance type
      Parameters:
      component - the component from which to get the data
      type - the data type
      Returns:
      the data instance, or null if no instance has been set using the given type
      See Also:

    • getRouter

      public static Router getRouter(HasElement component)
      Gets the router instance for the given component. Falls back to the router for the currently active VaadinService if the component is not attached.
      Parameters:
      component - component for which the requested router instance serves navigation
      Returns:
      a router instance
      Throws:
      IllegalStateException - if no router instance is available