Package swingtree

Class AbstractDelegate<C extends JComponent>

java.lang.Object
swingtree.AbstractDelegate<C>
Type Parameters:
C - The type of the component that is delegated.
Direct Known Subclasses:
ComponentDelegate, SplitButtonDelegate, SplitItemDelegate
public class AbstractDelegate<C extends JComponent> extends Object
Extensions of this class delegate a component as well as provide useful methods for trying the tree of the components in which the delegated component is contained.
Instances of this class are passed to various user event Action handlers. You can use this to change the state of the component, schedule animations for the component or query the tree of the components.

  • Method Summary

    Modifier and Type
    Method
    Description
    protected final C
    _component()
     
    protected final boolean
    _isUndefinedColor(Color color)
    Checks if the given color is the undefined color constant with respect to regular object identity instead of value equality.
    protected final boolean
    _isUndefinedFont(Font font)
    Checks if the given font is the undefined font constant with respect to regular object identity instead of value equality.
    protected final List<JComponent>
    _siblingsSource()
    A library internal utility method that exposes the sibling components of the delegated component.
    final AnimationDispatcher
    animateFor(double duration, TimeUnit unit)
    Exposes access the animation builder API, where you can define the conditions under which the animation should be executed and then dispatch the animation to the EDT through the AnimationDispatcher.go(Animation) method.
    final void
    animateFor(double duration, TimeUnit unit, Animation animation)
    Use this to schedule and run the provided animation to be executed on the EDT.
    final AnimationDispatcher
    animateFor(LifeTime lifeTime)
    Exposes access the animation builder API, where you can define the conditions under which the animation should be executed and then dispatch the animation to the EDT through the AnimationDispatcher.go(Animation) method.
    final void
    animateFor(LifeTime lifeTime, Animation animation)
    Use this to schedule and run the provided animation to be executed on the EDT.
    final void
    animateStyleFor(double duration, TimeUnit unit, AnimatedStyler<C> styler)
    A common use case is to animate the style of a component when a user event occurs.
    final void
    animateStyleFor(LifeTime lifetime, AnimatedStyler<C> styler)
    A common use case is to animate the style of a component when a user event occurs.
    final <T extends JComponent>
    OptionalUI<T>
    find(Class<T> type, Enum<?> id)
    Use this to query the UI's component tree and find any JComponent of a particular type and id (the name of the component).
    final <T extends JComponent>
    OptionalUI<T>
    find(Class<T> type, String id)
    Use this to query the UI's component tree and find any JComponent of a particular type and id (the name of the component).
    final <T extends JComponent>
    OptionalUI<T>
    find(Class<T> type, Predicate<T> predicate)
    Use this to query the UI's component tree and find any JComponent based on a specific type and a predicate which is used to test if a particular component in the tree is the one you are looking for.
    final <T extends JComponent>
    List<T>
    findAll(Class<T> type, Predicate<T> predicate)
    Use this to query the UI's component tree and find all JComponents based on a specific type and a predicate which is used to test if a particular component in the tree is the one you are looking for.
    final <T extends JComponent>
    List<T>
    findAllByGroup(Class<T> type, Enum<?> group)
    Use this to query the UI's component tree and find all JComponents of a particular type and also that belong to a particular style group.
    final <T extends JComponent>
    List<T>
    findAllByGroup(Class<T> type, String group)
    Use this to query the UI's component tree and find all JComponents of a particular type and also that belong to a particular style group.
    final List<JComponent>
    findAllByGroup(Enum<?> group)
    Use this to query the UI's component tree and find all JComponents that belong to a particular style group.
    final List<JComponent>
    findAllByGroup(String group)
    Use this to query the UI's component tree and find all JComponents that belong to a particular style group.
    final C
    get()
    This is a delegate to the underlying component, but not every method of the component is delegated.
    final Color
    getBackground()
    As a delegate to the underlying component, you can use this method to conveniently get the background color of the component.
    final Border
    getBorder()
    As a delegate to the underlying component, you can use this method to conveniently get the border of the component.
    final Bounds
    getBounds()
    As a delegate to the underlying component, you can use this method to conveniently get the bounds of the component in the form of an immutable Bounds value object.
    final Cursor
    getCursor()
    As a delegate to the underlying component, you can use this method to conveniently get the Cursor of the component.
    final Font
    getFont()
    As a delegate to the underlying component, you can use this method to conveniently get the font of the component.
    final Color
    getForeground()
    As a delegate to the underlying component, you can use this method to conveniently get the foreground color of the component.
    final int
    getHeight()
    Exposes the height of the component in "developer pixel" pixel.
    final Position
    getLocation()
    This method allows you to access the location of the delegated component r elative to its parent in "developer pixel space" instead of "component pixel space".
    final Size
    getMaxSize()
    Exposes the maximum size of the component in DPI agnostic "developer pixels" which are computed by dividing the already scaled maximum width and height of the component in "component pixels" by the UI.scale() factor.
    The maximum size of a component is used by the layout manager to determine the size of the component.
    final Size
    getMinSize()
    Exposes the minimum size of the component in DPI agnostic "developer pixels" which are computed by dividing the already scaled minimum component width and height in "component pixels" by the UI.scale() factor.
    The minimum size is used by the layout manager to determine the size of the component.
    final Container
    getParent()
    This is a component delegate API, which means that it represents the API of a wrapped component.
    final Size
    getPrefSize()
    Exposes the preferred size of the component in DPI agnostic "developer pixels" which are computed by dividing the already scaled preferred component width and height in "component pixels" by the UI.scale() factor.
    The preferred size is used by the layout manager to determine the size of the component.
    final Size
    getSize()
    Exposes the size of the delegated component in "developer pixel".
    final String
    getTooltip()
    Exposes the tooltip String of the component or an empty String if the component does not have a tooltip.
    final int
    getWidth()
    Exposes the width of the underlying component in "developer pixel".
    final int
    getX()
    Allows you to access the x-coordinate of the delegated component relative to its parent, and scaled to "developer pixel space" instead of "component pixel space". This means that even if your component and its placement was upscaled for a particular high DPI environment for example, then you will still receive a consistent coordinate.
    final int
    getY()
    Allows you to access the y-coordinate of the delegated component relative to its parent, and scaled to "developer pixel space" instead of "component pixel space". This means that even if your component and its placement was upscaled for a particular high DPI environment for example, then you will still receive a consistent coordinate.
    final boolean
    isEnabled()
    As a delegate to the underlying component, you can use this method to conveniently check if the component is enabled.
    final boolean
    isOpaque()
    As a delegate to the underlying component, you can use this method to conveniently check if the component is opaque.
    final boolean
    isVisible()
    As a delegate to the underlying component, you can use this method to conveniently check if the component is visible.
    final void
    paint(AnimationStatus status, Painter painter)
    A common use case is to render something on top of the UI.ComponentArea.BODY of the component using the Graphics2D instance of the component.
    final void
    paint(UI.ComponentArea area, AnimationStatus status, Painter painter)
    A common use case is to render something on top of the component using the Graphics2D instance of the component.
    final void
    paint(UI.ComponentArea area, UI.Layer layer, AnimationStatus status, Painter painter)
    A common use case is to render something on top of the component using the Graphics2D instance used by the component to render itself.
    final void
    paint(UI.Layer layer, AnimationStatus status, Painter painter)
    A common use case is to render something on top of the UI.ComponentArea.BODY of the component using the Graphics2D instance of the component.
    final void
    parentDelegate(sprouts.Action<AbstractDelegate<JComponent>> action)
    Use this method to delegate to the parent of the component.
    final AbstractDelegate<C>
    setBackground(Color color)
    As a delegate to the underlying component, you can use this method to conveniently set the background color of the component.
    final AbstractDelegate<C>
    setBackgroundColor(double r, double g, double b)
    As a delegate to the underlying component, you can use this method to conveniently set the background color of the component.
    final AbstractDelegate<C>
    setBackgroundColor(double r, double g, double b, double a)
    As a delegate to the underlying component, you can use this method to conveniently set the background color of the component.
    final AbstractDelegate<C>
    setBackgroundColor(int r, int g, int b)
    As a delegate to the underlying component, you can use this method to conveniently set the background color of the component.
    final AbstractDelegate<C>
    setBackgroundColor(int r, int g, int b, int a)
    As a delegate to the underlying component, you can use this method to conveniently set the background color of the component.
    final AbstractDelegate<C>
    setBorder(Border border)
    As a delegate to the underlying component, you can use this method to conveniently set the border of the component.
    final AbstractDelegate<C>
    setBounds(int x, int y, int width, int height)
    Allows you to specify new bounds for the delegated component in "developer pixel space" and then have them scaled and set as "component pixel size", which may be scaled for hgigh DPI environments by the UI.scale() factor.
    final AbstractDelegate<C>
    setBounds(Rectangle bounds)
    As a delegate to the underlying component, you can use this method to conveniently set the bounds of the component.
    final AbstractDelegate<C>
    setBounds(Bounds bounds)
    Delegates to the Component.setBounds(int, int, int, int) method of the underlying component.
    final AbstractDelegate<C>
    setCursor(Cursor cursor)
    As a delegate to the underlying component, you can use this method to conveniently set the Cursor of the component.
    final AbstractDelegate<C>
    setCursor(UI.Cursor cursor)
    As a delegate to the underlying component, you can use this method to conveniently set the UI.Cursor of the component.
    final AbstractDelegate<C>
    setEnabled(boolean enabled)
    As a delegate to the underlying component, you can use this method to conveniently enable or disable the component.
    final AbstractDelegate<C>
    setFont(Font font)
    As a delegate to the underlying component, you can use this method to conveniently set the font of the component.
    final AbstractDelegate<C>
    setForeground(Color color)
    As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component.
    final AbstractDelegate<C>
    setForegroundColor(double r, double g, double b)
    As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component.
    final AbstractDelegate<C>
    setForegroundColor(double r, double g, double b, double a)
    As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component.
    final AbstractDelegate<C>
    setForegroundColor(int r, int g, int b)
    As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component.
    final AbstractDelegate<C>
    setForegroundColor(int r, int g, int b, int a)
    As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component.
    final AbstractDelegate<C>
    setHeight(int height)
    You can use this method to set the height of the delegated component in "developer pixel".
    final AbstractDelegate<C>
    setMaxHeight(int height)
    Takes a new maximum height for the component in "developer pixel" and applies it as "component pixels".
    final AbstractDelegate<C>
    setMaxSize(int width, int height)
    As a delegate to the underlying component, you can use this method to conveniently set the maximum size of the component in "developer pixel".
    final AbstractDelegate<C>
    setMaxSize(Dimension size)
    Deprecated.
    final AbstractDelegate<C>
    setMaxSize(Size size)
    As a delegate to the underlying component, you can use this method to conveniently set the maximum size of the component.
    final AbstractDelegate<C>
    setMaxWidth(int width)
    As a delegate to the underlying component, you can use this method to conveniently set the maximum width of the component in "developer pixel".
    final AbstractDelegate<C>
    setMinHeight(int height)
    As a delegate to the underlying component, you can use this method to conveniently set the minimum height of the component.
    final AbstractDelegate<C>
    setMinSize(int width, int height)
    This method allows you to set the minimum size of the delegated component in "developer pixels" instead of "component pixels".
    final AbstractDelegate<C>
    setMinSize(Dimension size)
    Deprecated.
    Use setMinSize(Size) instead!
    final AbstractDelegate<C>
    setMinSize(Size size)
    As a delegate to the underlying component, you can use this method to conveniently set the minimum size of the component in developer pixel size.
    final AbstractDelegate<C>
    setMinWidth(int width)
    As a delegate to the underlying component, you can use this method to conveniently set the minimum width of the component.
    final AbstractDelegate<C>
    setPrefHeight(int height)
    Allows you to set the preferred height of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale().
    final AbstractDelegate<C>
    setPrefSize(int width, int height)
    Allows you to set the preferred width and height of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale().
    final AbstractDelegate<C>
    setPrefSize(Dimension size)
    Deprecated.
    Use setPrefSize(Size) instead of this method.
    final AbstractDelegate<C>
    setPrefSize(Size size)
    Allows you to set the preferred size of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale().
    final AbstractDelegate<C>
    setPrefWidth(int width)
    Allows you to set the preferred width of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale().
    final AbstractDelegate<C>
    setSize(int width, int height)
    Takes two new width and height for the component in "developer pixel" and applies it as "component pixels".
    final AbstractDelegate<C>
    setSize(Dimension size)
    Deprecated.
    Use setSize(Size) instead of this method!
    final AbstractDelegate<C>
    setSize(Size size)
    Takes a new Size for the component in "developer pixel" and applies it as "component pixels".
    final AbstractDelegate<C>
    setTooltip(String text)
    As a delegate to the underlying component, you can use this method to conveniently set the tooltip of the component.
    final AbstractDelegate<C>
    setVisible(boolean visible)
    As a delegate to the underlying component, you can use this method to conveniently enable or disable the component.
    final AbstractDelegate<C>
    setWidth(int width)
    Takes a new width for the underlying component in "developer pixel" and applies it as "component pixels".
    Optional<Shape>
    shapeOf(UI.ComponentArea area)
    You can use this method to access a specific UI.ComponentArea of the component, which is useful if you do custom painting.
    final void
    style(AnimationStatus state, Styler<C> styler)
    A common use case is to style the component based on the current animation state.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Method Details

    • _isUndefinedFont

      protected final boolean _isUndefinedFont(Font font)
      Checks if the given font is the undefined font constant with respect to regular object identity instead of value equality. This is a deliberate design choice to allow the user to use the UI.Font.UNDEFINED constant instead of null as a placeholder for the absence of a font.
      Parameters:
      font - The font to check.
      Returns:
      true if the font is the undefined font constant, false otherwise.

    • _isUndefinedColor

      protected final boolean _isUndefinedColor(Color color)
      Checks if the given color is the undefined color constant with respect to regular object identity instead of value equality. This is a deliberate design choice to allow the user to use the UI.Color.UNDEFINED constant instead of null as a placeholder for the absence of a color.
      Parameters:
      color - The color to check.
      Returns:
      true if the color is the undefined color constant, false otherwise.

    • _component

      protected final C _component()

    • _siblingsSource

      protected final List<JComponent> _siblingsSource()
      A library internal utility method that exposes the sibling components of the delegated component.
      Returns:
      A list of sibling components.

    • get

      public final C get()
      This is a delegate to the underlying component, but not every method of the component is delegated. This method allows you to access the underlying component directly.

      Note that this method expects that the accessing thread is the event dispatch thread, not the application thread. If you want to access the component from the application thread, you should use
      UI.run(() -> delegate.component()).

      Returns:
      The underlying component.
      Throws:
      IllegalStateException - If the accessing thread is not the event dispatch thread.

    • getX

      public final int getX()
      Allows you to access the x-coordinate of the delegated component relative to its parent, and scaled to "developer pixel space" instead of "component pixel space". This means that even if your component and its placement was upscaled for a particular high DPI environment for example, then you will still receive a consistent coordinate.
      Returns:
      The x-coordinate of the component relative to its parent and in "developer pixel space" (without DPI aware scaling applied).

    • getY

      public final int getY()
      Allows you to access the y-coordinate of the delegated component relative to its parent, and scaled to "developer pixel space" instead of "component pixel space". This means that even if your component and its placement was upscaled for a particular high DPI environment for example, then you will still receive a consistent coordinate.
      Returns:
      The y-coordinate of the component relative to its parent and in "developer pixel space" (without DPI aware scaling applied).

    • getLocation

      public final Position getLocation()
      This method allows you to access the location of the delegated component r elative to its parent in "developer pixel space" instead of "component pixel space". It returns an immutable Position object holding both x and y components which are equal to the values available through getX() and getY().
      Returns:
      The location of the component relative to its parent in "developer pixel space" (without DPI scaling applied).

    • getParent

      public final Container getParent()
      This is a component delegate API, which means that it represents the API of a wrapped component. So this method allows you to access the parent of the underlying component. In essence, this is a delegate to Component.getParent().
      Returns:
      The parent Container of the underlying component.
      Throws:
      IllegalStateException - If the accessing thread is not the event dispatch thread.

    • setBackground

      public final AbstractDelegate<C> setBackground(Color color)
      As a delegate to the underlying component, you can use this method to conveniently set the background color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setBackground(Color) for more information.

      Parameters:
      color - The color that should be used to paint the background of the component. If this parameter is null then this component will inherit the background color of its parent.
      Returns:
      The delegate itself.

    • setBackgroundColor

      public final AbstractDelegate<C> setBackgroundColor(double r, double g, double b)
      As a delegate to the underlying component, you can use this method to conveniently set the background color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setBackground(Color) for more information.

      Parameters:
      r - The red component of the color as a double between 0 and 1.
      g - The green component of the color as a double between 0 and 1.
      b - The blue component of the color as a double between 0 and 1.
      Returns:
      The delegate itself.

    • setBackgroundColor

      public final AbstractDelegate<C> setBackgroundColor(double r, double g, double b, double a)
      As a delegate to the underlying component, you can use this method to conveniently set the background color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setBackground(Color) for more information.

      Parameters:
      r - The red component of the color as a double between 0 and 1.
      g - The green component of the color as a double between 0 and 1.
      b - The blue component of the color as a double between 0 and 1.
      a - The alpha component of the color as a double between 0 and 1.
      Returns:
      The delegate itself.

    • setBackgroundColor

      public final AbstractDelegate<C> setBackgroundColor(int r, int g, int b)
      As a delegate to the underlying component, you can use this method to conveniently set the background color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setBackground(Color) for more information.

      Parameters:
      r - The red component of the color as an integer between 0 and 255.
      g - The green component of the color as an integer between 0 and 255.
      b - The blue component of the color as an integer between 0 and 255.
      Returns:
      The delegate itself.

    • setBackgroundColor

      public final AbstractDelegate<C> setBackgroundColor(int r, int g, int b, int a)
      As a delegate to the underlying component, you can use this method to conveniently set the background color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setBackground(Color) for more information.

      Parameters:
      r - The red component of the color as an integer between 0 and 255.
      g - The green component of the color as an integer between 0 and 255.
      b - The blue component of the color as an integer between 0 and 255.
      a - The alpha component of the color as an integer between 0 and 255.
      Returns:
      The delegate itself.

    • getBackground

      public final Color getBackground()
      As a delegate to the underlying component, you can use this method to conveniently get the background color of the component.

      See Component.getBackground() for more information.

      Returns:
      The background color of the component, or UI.Color.UNDEFINED if the component does not have a background color (i.e. Component.getBackground() returns null). The return value will never be null.

    • setForeground

      public final AbstractDelegate<C> setForeground(Color color)
      As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setForeground(Color) for more information.

      Parameters:
      color - The color that should be used to paint the foreground of the component. If this parameter is null then this component will inherit the foreground color of its parent.
      Returns:
      The delegate itself.

    • getForeground

      public final Color getForeground()
      As a delegate to the underlying component, you can use this method to conveniently get the foreground color of the component.

      See Component.getForeground() for more information.

      Returns:
      The foreground color of the component, or UI.Color.UNDEFINED if the component does not have a foreground color (i.e. Component.getForeground() returns null). The return value will never be null.

    • setForegroundColor

      public final AbstractDelegate<C> setForegroundColor(double r, double g, double b)
      As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setForeground(Color) for more information.

      Parameters:
      r - The red component of the color as a double between 0 and 1.
      g - The green component of the color as a double between 0 and 1.
      b - The blue component of the color as a double between 0 and 1.
      Returns:
      The delegate itself.

    • setForegroundColor

      public final AbstractDelegate<C> setForegroundColor(double r, double g, double b, double a)
      As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setForeground(Color) for more information.

      Parameters:
      r - The red component of the color as a double between 0 and 1.
      g - The green component of the color as a double between 0 and 1.
      b - The blue component of the color as a double between 0 and 1.
      a - The alpha component of the color as a double between 0 and 1.
      Returns:
      The delegate itself.

    • setForegroundColor

      public final AbstractDelegate<C> setForegroundColor(int r, int g, int b)
      As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setForeground(Color) for more information.

      Parameters:
      r - The red component of the color as an integer between 0 and 255.
      g - The green component of the color as an integer between 0 and 255.
      b - The blue component of the color as an integer between 0 and 255.
      Returns:
      The delegate itself.

    • setForegroundColor

      public final AbstractDelegate<C> setForegroundColor(int r, int g, int b, int a)
      As a delegate to the underlying component, you can use this method to conveniently set the foreground color of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setForeground(Color) for more information.

      Parameters:
      r - The red component of the color as an integer between 0 and 255.
      g - The green component of the color as an integer between 0 and 255.
      b - The blue component of the color as an integer between 0 and 255.
      a - The alpha component of the color as an integer between 0 and 255.
      Returns:
      The delegate itself.

    • setFont

      public final AbstractDelegate<C> setFont(Font font)
      As a delegate to the underlying component, you can use this method to conveniently set the font of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setFont(Font) for more information.

      Parameters:
      font - The font that should be used to paint the text of the component. If this parameter is UI.Font.UNDEFINED then this component will inherit the font of its parent. Null is not allowed.
      Returns:
      The delegate itself.

    • getFont

      public final Font getFont()
      As a delegate to the underlying component, you can use this method to conveniently get the font of the component.

      See Component.getFont() for more information.

      Returns:
      The font of the component.

    • setBorder

      public final AbstractDelegate<C> setBorder(Border border)
      As a delegate to the underlying component, you can use this method to conveniently set the border of the component. This method returns the delegate itself, so you can chain calls to this method.

      Note that this method is a delegate to JComponent.setBorder(Border).

      Parameters:
      border - The border that should be used to paint the border of the component. If this parameter is null then this component will inherit the border of its parent.
      Returns:
      The delegate itself.

    • getBorder

      public final Border getBorder()
      As a delegate to the underlying component, you can use this method to conveniently get the border of the component.

      Note that this method is a delegate to JComponent.getBorder().

      Returns:
      The border of the component.

    • setBounds

      public final AbstractDelegate<C> setBounds(int x, int y, int width, int height)
      Allows you to specify new bounds for the delegated component in "developer pixel space" and then have them scaled and set as "component pixel size", which may be scaled for hgigh DPI environments by the UI.scale() factor. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setBounds(int, int, int, int) for more information.

      Parameters:
      x - The x coordinate of the new location of the component. This is relative to the component's parent.
      y - The y coordinate of the new location of the component. This is relative to the component's parent.
      width - The new width of the component.
      height - The new height of the component.
      Returns:
      The delegate itself, so you can chain calls to this method.

    • setBounds

      public final AbstractDelegate<C> setBounds(Bounds bounds)
      Delegates to the Component.setBounds(int, int, int, int) method of the underlying component. The bounds consist of a location and a size which are relative to the component's parent. Important: The supplied bounds are interpreted as "being in developer pixel space" without any scaling factor applied to it. And so this method will scale the bounds to DPI aware "component pixel space" by multiplying by UI.scale().
      Parameters:
      bounds - The new bounds of the component. This is relative to the component's parent.
      Returns:
      The delegate itself, so you can chain calls to this method.

    • setBounds

      public final AbstractDelegate<C> setBounds(Rectangle bounds)
      As a delegate to the underlying component, you can use this method to conveniently set the bounds of the component. This method returns the delegate itself, so you can chain calls to this method.

      See Component.setBounds(Rectangle) for more information.

      Important: The supplied Rectangle is interpreted as "being in developer pixel space" without any scaling factor applied to it. And so this method will scale the bounds to DPI aware "component pixel space" by multiplying by UI.scale().
      Parameters:
      bounds - The new bounds of the component. This is relative to the component's parent.
      Returns:
      The delegate itself, so you can chain calls to this method.

    • getBounds

      public final Bounds getBounds()
      As a delegate to the underlying component, you can use this method to conveniently get the bounds of the component in the form of an immutable Bounds value object. The bounds consist of a location and a size which are relative to the component's parent.

      See Component.getBounds() for more information.

      Important: The returned Rectangle is scaled to "developer pixel space" and not necessarily in "component pixel space".
      Returns:
      The bounds of the component in scaling agnostic "developer pixel space". This is relative to the component's parent.

    • shapeOf

      public Optional<Shape> shapeOf(UI.ComponentArea area)
      You can use this method to access a specific UI.ComponentArea of the component, which is useful if you do custom painting. This method returns an Optional value, which means that the component area may not be present. The UI.ComponentArea.BORDER for example, may not be present in case of there not being a border width defined through UIForAnySwing.withStyle(Styler).

      See ComponentExtension.getComponentArea(UI.ComponentArea) for more information.

      Parameters:
      area - The component area to access.
      Returns:
      An optional value that contains the component area if it is present.

    • setPrefSize

      @Deprecated public final AbstractDelegate<C> setPrefSize(Dimension size)
      Deprecated.
      Use setPrefSize(Size) instead of this method.
      Allows you to set the preferred size of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale(). This method returns the delegate itself, so you can chain calls to this method. The preferred size is used by the layout manager to determine the size of the component.

      See Component.setPreferredSize(Dimension) for more information.

      Parameters:
      size - The preferred size of the component.
      Returns:
      The delegate itself.

    • setPrefSize

      public final AbstractDelegate<C> setPrefSize(Size size)
      Allows you to set the preferred size of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale(). This method returns the delegate itself, so you can chain calls to this method. The preferred size is used by the layout manager to determine the size of the component.

      See Component.setPreferredSize(Dimension) for more information.

      Also note that the supplied size is treated as being measured in "developer pixel size", which are defined as pixels without the UI scaling factor applied to them.
      This method will scale the supplied size automatically for you, and therefore you as a developer may define dimensions in your GUI code consistently, without sacrificing dynamic DPI scaling.
      Parameters:
      size - The preferred size of the component in developer pixel size.
      Returns:
      The delegate itself.

    • setPrefSize

      public final AbstractDelegate<C> setPrefSize(int width, int height)
      Allows you to set the preferred width and height of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale(). This method returns the delegate itself, so you can chain calls to this method. The preferred size is used by the layout manager to determine the size of the component.

      See Component.setPreferredSize(Dimension) for more information.

      Also note that the supplied size is treated as being measured in "developer pixel size", which are defined as pixels without the UI scaling factor applied to them.
      This method will scale the supplied width and height automatically for you, and therefore you as a developer may define dimensions in your GUI code consistently, without sacrificing dynamic DPI scaling.
      Parameters:
      width - The preferred width of the component in developer pixels (not scaled for high DPI).
      height - The preferred height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setPrefWidth

      public final AbstractDelegate<C> setPrefWidth(int width)
      Allows you to set the preferred width of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale(). This method returns the delegate itself, so you can chain calls to this method. The preferred size is used by the layout manager to determine the size of the component.

      See Component.setPreferredSize(Dimension) for more information.

      Parameters:
      width - The preferred width of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setPrefHeight

      public final AbstractDelegate<C> setPrefHeight(int height)
      Allows you to set the preferred height of the component in DPI agnostic "developer pixels", which are automatically converted to DPI aware "component pixels" using UI.scale(). This method returns the delegate itself, so you can chain calls to this method. The preferred size is used by the layout manager to determine the size of the component.

      See Component.setPreferredSize(Dimension) for more information.

      Parameters:
      height - The preferred height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • getPrefSize

      public final Size getPrefSize()
      Exposes the preferred size of the component in DPI agnostic "developer pixels" which are computed by dividing the already scaled preferred component width and height in "component pixels" by the UI.scale() factor.
      The preferred size is used by the layout manager to determine the size of the component.

      See Component.getPreferredSize() for more information.

      Returns:
      The preferred size of the component scaled to "developer pixel size".

    • setMinSize

      @Deprecated public final AbstractDelegate<C> setMinSize(Dimension size)
      Deprecated.
      Use setMinSize(Size) instead!
      As a delegate to the underlying component, you can use this method to conveniently set the minimum size of the component. This method returns the delegate itself, so you can chain calls to this method. The minimum size is used by the layout manager to determine the size of the component.

      See Component.setMinimumSize(Dimension) for more information.

      Parameters:
      size - The minimum size of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setMinSize

      public final AbstractDelegate<C> setMinSize(Size size)
      As a delegate to the underlying component, you can use this method to conveniently set the minimum size of the component in developer pixel size. This method returns the delegate itself, so you can chain calls to this method. The minimum size is used by the layout manager to determine the size of the component.

      See Component.setMinimumSize(Dimension) for more information about the meaning of this property.

      Also note that the supplied size is treated as being measured in "developer pixel size", which are defined as pixels without the UI scaling factor applied to them.
      This method will scale the supplied size automatically for you, and therefore you as a developer may define dimensions in your GUI code consistently, without sacrificing dynamic DPI scaling.
      Parameters:
      size - The minimum size of the component in developer pixel size, or Size.unknown() to set the minimum size to being "undefined"/"null".
      Returns:
      The delegate itself.
      Throws:
      NullPointerException - if the supplied size is null.

    • setMinSize

      public final AbstractDelegate<C> setMinSize(int width, int height)
      This method allows you to set the minimum size of the delegated component in "developer pixels" instead of "component pixels". The dimension you supply to this method will be scale to "component pixels" for you, so you don't have to rely on component pixel space in your code (which varies depending on the UI.scale()). This method returns the delegate itself, so you can chain calls to this method. The minimum size is used by the layout manager to determine the size of the component.

      See Component.setMinimumSize(Dimension) for more information.

      Parameters:
      width - The minimum width of the component in developer pixels (not scaled for high DPI).
      height - The minimum height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setMinWidth

      public final AbstractDelegate<C> setMinWidth(int width)
      As a delegate to the underlying component, you can use this method to conveniently set the minimum width of the component. This method returns the delegate itself, so you can chain calls to this method. The minimum size is used by the layout manager to determine the size of the component.

      See Component.setMinimumSize(Dimension) for more information.

      Parameters:
      width - The minimum width of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setMinHeight

      public final AbstractDelegate<C> setMinHeight(int height)
      As a delegate to the underlying component, you can use this method to conveniently set the minimum height of the component. This method returns the delegate itself, so you can chain calls to this method. The minimum size is used by the layout manager to determine the size of the component.

      See Component.setMinimumSize(Dimension) for more information.

      Parameters:
      height - The minimum height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • getMinSize

      public final Size getMinSize()
      Exposes the minimum size of the component in DPI agnostic "developer pixels" which are computed by dividing the already scaled minimum component width and height in "component pixels" by the UI.scale() factor.
      The minimum size is used by the layout manager to determine the size of the component.

      See Component.getMinimumSize() for more information.

      Returns:
      The minimum size of the component.

    • setMaxSize

      @Deprecated public final AbstractDelegate<C> setMaxSize(Dimension size)
      Deprecated.
      As a delegate to the underlying component, you can use this method to conveniently set the maximum size of the component. This method returns the delegate itself, so you can chain calls to this method. The maximum size is used by the layout manager to determine the size of the component.

      See Component.setMaximumSize(Dimension) for more information.

      Parameters:
      size - The maximum size of the component.
      Returns:
      The delegate itself.

    • setMaxSize

      public final AbstractDelegate<C> setMaxSize(Size size)
      As a delegate to the underlying component, you can use this method to conveniently set the maximum size of the component. This method returns the delegate itself, so you can chain calls to this method. The maximum size is used by the layout manager to determine the size of the component.

      See Component.setMaximumSize(Dimension) for more information.

      Also note that the supplied size is treated as being measured in "developer pixel size", which are defined as pixels without the UI scaling factor applied to them.
      This method will scale the supplied size automatically for you, and therefore you as a developer may define dimensions in your GUI code consistently, without sacrificing dynamic DPI scaling.
      Parameters:
      size - The maximum size of the component in developer pixel size, or Size.unknown() to set the maximum size to being "undefined"/"null".
      Returns:
      The delegate itself.
      Throws:
      NullPointerException - if the supplied size is null.

    • setMaxSize

      public final AbstractDelegate<C> setMaxSize(int width, int height)
      As a delegate to the underlying component, you can use this method to conveniently set the maximum size of the component in "developer pixel". This method returns the delegate itself, so you can chain calls to this method. The maximum size is used by the layout manager to determine the size of the component.

      See Component.setMaximumSize(Dimension) for more information.

      Also note that the supplied size is treated as being measured in "developer pixel size", which are defined as pixels without the UI scaling factor applied to them.
      This method will scale the supplied size automatically for you, and therefore you as a developer may define dimensions in your GUI code consistently, without sacrificing dynamic DPI scaling.
      Parameters:
      width - The maximum width of the component in developer pixels (not scaled for high DPI).
      height - The maximum height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setMaxWidth

      public final AbstractDelegate<C> setMaxWidth(int width)
      As a delegate to the underlying component, you can use this method to conveniently set the maximum width of the component in "developer pixel". This method returns the delegate itself, so you can chain calls to this method. The maximum size is used by the layout manager to determine the size of the component.

      See Component.setMaximumSize(Dimension) for more information.

      Also note that the supplied width is treated as being measured in "developer pixel size", which are defined as pixels without the UI scaling factor applied to them.
      This method will scale the supplied width automatically for you, and therefore you as a developer may define dimensions in your GUI code consistently, without sacrificing dynamic DPI scaling.
      Parameters:
      width - The maximum width of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setMaxHeight

      public final AbstractDelegate<C> setMaxHeight(int height)
      Takes a new maximum height for the component in "developer pixel" and applies it as "component pixels". This means that the supplied height will be scaled to dynamic "component pixels" through multiplication with the UI.scale() factor.
      This method returns the delegate itself, so you can chain calls to this method. The maximum size is used by the layout manager to determine the size of the component.

      See Component.setMaximumSize(Dimension) for more information.

      Also note that the supplied height is treated as being measured in "developer pixel size", which are defined as pixels without the UI scaling factor applied to them.
      This method will scale the supplied height automatically for you, and therefore you as a developer may define dimensions in your GUI code consistently, without sacrificing dynamic DPI scaling.
      Parameters:
      height - The maximum height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • getMaxSize

      public final Size getMaxSize()
      Exposes the maximum size of the component in DPI agnostic "developer pixels" which are computed by dividing the already scaled maximum width and height of the component in "component pixels" by the UI.scale() factor.
      The maximum size of a component is used by the layout manager to determine the size of the component.

      See Component.getMaximumSize() for more information.

      Returns:
      The maximum size of the component in "developer pixels".

    • setSize

      @Deprecated public final AbstractDelegate<C> setSize(Dimension size)
      Deprecated.
      Use setSize(Size) instead of this method!
      You can use this method to set the size of the component in "developer pixel", meaning that the supplied dimensions will be scaled to dynamic "component pixels" using the UI.scale() factor.
      This method returns the delegate itself, so you can chain calls to this method. The size is used by the layout manager to determine the size of the component.

      See Component.setSize(Dimension) for more information.

      Parameters:
      size - The size of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setSize

      public final AbstractDelegate<C> setSize(Size size)
      Takes a new Size for the component in "developer pixel" and applies it as "component pixels". This means that the supplied dimensions will be scaled to dynamic "component pixels" through multiplication with the UI.scale() factor.
      This method returns the delegate itself, so you can chain calls to this method. The size is used by the layout manager to determine the size of the component.

      See Component.setSize(Dimension) for more information.

      Parameters:
      size - The size of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setSize

      public final AbstractDelegate<C> setSize(int width, int height)
      Takes two new width and height for the component in "developer pixel" and applies it as "component pixels". This means that the supplied dimensions will be scaled to dynamic "component pixels" through multiplication with the UI.scale() factor.
      This method returns the delegate itself, so you can chain calls to this method. The size is used by the layout manager to determine the size of the component.

      See Component.setSize(Dimension) for more information.

      Parameters:
      width - The width of the component in developer pixels (not scaled for high DPI).
      height - The height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setWidth

      public final AbstractDelegate<C> setWidth(int width)
      Takes a new width for the underlying component in "developer pixel" and applies it as "component pixels". This means that the supplied width will be scaled to dynamic "component pixels" through multiplication with the UI.scale() factor.
      This method returns the delegate itself, so you can chain calls to this method. The regular size of a component is typically managed and set by the layout manager of a component. So you may not want to set this in most cases...

      See Component.setSize(Dimension) for more information.

      Parameters:
      width - The width of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • setHeight

      public final AbstractDelegate<C> setHeight(int height)
      You can use this method to set the height of the delegated component in "developer pixel". The value you pass to this method will be scaled by UI.scale(int) and then set. This method returns the delegate itself, so you can chain calls to this method. The size is used by the layout manager to determine the size of the component.

      See Component.setSize(Dimension) for more information.

      Parameters:
      height - The height of the component in developer pixels (not scaled for high DPI).
      Returns:
      The delegate itself.

    • getSize

      public final Size getSize()
      Exposes the size of the delegated component in "developer pixel". Theis property is typically managed and set by the layout manager.

      See Component.getSize() for more information.

      Returns:
      The size of the component.

    • getWidth

      public final int getWidth()
      Exposes the width of the underlying component in "developer pixel". Theis property is typically managed and set by the layout manager.

      See Component.getSize() for more information.

      Returns:
      The width of the component in developer pixels (not scaled for high DPI).

    • getHeight

      public final int getHeight()
      Exposes the height of the component in "developer pixel" pixel. Theis property is typically managed and set by the layout manager.

      See Component.getSize() for more information.

      Returns:
      The height of the component in developer pixels (not scaled for high DPI).

    • setCursor

      public final AbstractDelegate<C> setCursor(UI.Cursor cursor)
      As a delegate to the underlying component, you can use this method to conveniently set the UI.Cursor of the component.
      Parameters:
      cursor - The UI.Cursor which should be set.
      Returns:
      The delegate itself.
      Throws:
      NullPointerException - if the supplied enum instance is null!

    • setCursor

      public final AbstractDelegate<C> setCursor(Cursor cursor)
      As a delegate to the underlying component, you can use this method to conveniently set the Cursor of the component.
      Parameters:
      cursor - The Cursor which should be set.
      Returns:
      The delegate itself.

    • getCursor

      public final Cursor getCursor()
      As a delegate to the underlying component, you can use this method to conveniently get the Cursor of the component.
      Returns:
      The Cursor of the component.

    • setTooltip

      public final AbstractDelegate<C> setTooltip(String text)
      As a delegate to the underlying component, you can use this method to conveniently set the tooltip of the component. This method returns the delegate itself, so you can chain calls to this method.

      See JComponent.setToolTipText(String) for more information.

      Parameters:
      text - The tooltip text.
      Returns:
      The delegate itself.
      Throws:
      NullPointerException - If the text is null, use an empty string to model the absence of a tooltip.

    • getTooltip

      public final String getTooltip()
      Exposes the tooltip String of the component or an empty String if the component does not have a tooltip. Note that this method will never return null.

      See JComponent.getToolTipText() for more information.

      Returns:
      The tooltip text or an empty String if this component does not have a tooltip, but null is never returned!

    • setEnabled

      public final AbstractDelegate<C> setEnabled(boolean enabled)
      As a delegate to the underlying component, you can use this method to conveniently enable or disable the component. This method returns the delegate itself, so you can chain calls to this method.

      See JComponent.setEnabled(boolean) for more information.

      Parameters:
      enabled - True if the component should be enabled, false otherwise.
      Returns:
      The delegate itself.

    • isEnabled

      public final boolean isEnabled()
      As a delegate to the underlying component, you can use this method to conveniently check if the component is enabled.

      See Component.isEnabled() for more information.

      Returns:
      True if the component is enabled, false otherwise.

    • setVisible

      public final AbstractDelegate<C> setVisible(boolean visible)
      As a delegate to the underlying component, you can use this method to conveniently enable or disable the component. This method returns the delegate itself, so you can chain calls to this method.

      See JComponent.setVisible(boolean) for more information.

      Parameters:
      visible - True if the component should be visible, false otherwise.
      Returns:
      The delegate itself.

    • isVisible

      public final boolean isVisible()
      As a delegate to the underlying component, you can use this method to conveniently check if the component is visible.

      See Component.isVisible() for more information.

      Returns:
      True if the component is visible, false otherwise.

    • isOpaque

      public final boolean isOpaque()
      As a delegate to the underlying component, you can use this method to conveniently check if the component is opaque.

      See JComponent.isOpaque() for more information.

      Returns:
      True if the component is opaque, false otherwise.

    • find

      public final <T extends JComponent> OptionalUI<T> find(Class<T> type, String id)
      Use this to query the UI's component tree and find any JComponent of a particular type and id (the name of the component).
      Type Parameters:
      T - The type parameter of the component which should be found.
      Parameters:
      type - The JComponent type which should be found in the swing tree.
      id - The ide of the JComponent which should be found in the swing tree.
      Returns:
      An Optional instance which may or may not contain the requested component.

    • find

      public final <T extends JComponent> OptionalUI<T> find(Class<T> type, Enum<?> id)
      Use this to query the UI's component tree and find any JComponent of a particular type and id (the name of the component).
      Type Parameters:
      T - The type parameter of the component which should be found.
      Parameters:
      type - The JComponent type which should be found in the swing tree.
      id - The ide of the JComponent which should be found in the swing tree.
      Returns:
      An Optional instance which may or may not contain the requested component.

    • find

      public final <T extends JComponent> OptionalUI<T> find(Class<T> type, Predicate<T> predicate)
      Use this to query the UI's component tree and find any JComponent based on a specific type and a predicate which is used to test if a particular component in the tree is the one you are looking for.
      Type Parameters:
      T - The type parameter of the component which should be found.
      Parameters:
      type - The JComponent type which should be found in the swing tree.
      predicate - The predicate which should be used to test the JComponent.
      Returns:
      An Optional instance which may or may not contain the requested component.

    • findAll

      public final <T extends JComponent> List<T> findAll(Class<T> type, Predicate<T> predicate)
      Use this to query the UI's component tree and find all JComponents based on a specific type and a predicate which is used to test if a particular component in the tree is the one you are looking for.
      Type Parameters:
      T - The type parameter of the component which should be found.
      Parameters:
      type - The JComponent type which should be found in the swing tree.
      predicate - The predicate which should be used to test the JComponent.
      Returns:
      A list of JComponent instances which match the given type and predicate.

    • findAllByGroup

      public final <T extends JComponent> List<T> findAllByGroup(Class<T> type, String group)
      Use this to query the UI's component tree and find all JComponents of a particular type and also that belong to a particular style group.
      Type Parameters:
      T - The type parameter of the component which should be found.
      Parameters:
      type - The JComponent type which should be found in the swing tree.
      group - The style group which should be used to test the JComponent.
      Returns:
      A list of JComponent instances which match the given type and group.

    • findAllByGroup

      public final List<JComponent> findAllByGroup(String group)
      Use this to query the UI's component tree and find all JComponents that belong to a particular style group.
      Parameters:
      group - The style group which should be used to check if a particular JComponent belongs to it.
      Returns:
      A list of JComponent instances which all have the given style group.
      Throws:
      NullPointerException - If the group is null.

    • findAllByGroup

      public final <T extends JComponent> List<T> findAllByGroup(Class<T> type, Enum<?> group)
      Use this to query the UI's component tree and find all JComponents of a particular type and also that belong to a particular style group.
      Type Parameters:
      T - The type parameter of the component which should be found.
      Parameters:
      type - The JComponent type which should be found in the swing tree.
      group - The style group which should be used to test the JComponent.
      Returns:
      A list of JComponent instances which match the given type and predicate.

    • findAllByGroup

      public final List<JComponent> findAllByGroup(Enum<?> group)
      Use this to query the UI's component tree and find all JComponents that belong to a particular style group.
      Parameters:
      group - The style group which should be used to check if a particular JComponent belongs to it.
      Returns:
      A list of JComponent instances which all have the given style group.

    • paint

      public final void paint(AnimationStatus status, Painter painter)
      A common use case is to render something on top of the UI.ComponentArea.BODY of the component using the Graphics2D instance of the component. This method allows you to attach a paint task to the component, which the EDT will process in the next repaint event cycle, and remove when the animation expires. This ensures that custom rendering is not erased by a potential repaint of the component after a user event.

      Here is an example of how to use this method as part of a fancy button animation: 

      
      UI.button("Click me").withPrefSize(400, 400)
      .onMouseClick( it -> it.animateFor(2, TimeUnit.SECONDS, status -> {
          double r = 300 * status.progress();
          double x = it.mouseX() - r / 2;
          double y = it.mouseY() - r / 2;
          it.paint(status, g -> {
              g.setColor(new Color(1f, 1f, 0f, (float) (1 - status.progress())));
              g.fillOval((int) x, (int) y, (int) r, (int) r);
          });
      }))
      You may also be interested in doing style animations, if so, maybe consider taking a look at UIForAnySwing.withTransitoryStyle(sprouts.Observable, LifeTime, AnimatedStyler) to see how to do event based styling animations and UIForAnySwing.withTransitionalStyle(Val, LifeTime, AnimatedStyler) to see how to do 2 state switch based styling animations.
      Parameters:
      status - The current animation progress status, which is important so that the rendering can be synchronized with the animation.
      painter - The rendering task which should be executed on the EDT at the end of the current event cycle.

    • paint

      public final void paint(UI.ComponentArea area, AnimationStatus status, Painter painter)
      A common use case is to render something on top of the component using the Graphics2D instance of the component. This method allows you to attach a paint task to the component, which the EDT will process in the next repaint event cycle, and remove when the animation expires. This ensures that custom rendering is not erased by a potential repaint of the component after a user event.
      Additionally, you can specify the area of the component which should be painted.

      Here is an example of how to use this method as part of a button animation: 

      
      UI.button("Click me").withPrefSize(400, 400)
      .onMouseClick( it -> it.animateFor(2, TimeUnit.SECONDS, status -> {
          double r = 300 * status.progress();
          double x = it.mouseX() - r / 2;
          double y = it.mouseY() - r / 2;
          it.paint(UI.ComponentArea.BORDER, state, g -> {
              g.setColor(new Color(1f, 1f, 0f, (float) (1 - status.progress())));
              g.fillOval((int) x, (int) y, (int) r, (int) r);
          });
      }))
      You may also be interested in doing style animations, if so, maybe consider taking a look at UIForAnySwing.withTransitoryStyle(sprouts.Observable, LifeTime, AnimatedStyler) to see how to do event based styling animations and UIForAnySwing.withTransitionalStyle(Val, LifeTime, AnimatedStyler) to see how to do 2 state switch based styling animations.
      Parameters:
      area - The area of the component which should be painted.
      status - The current animation progress status, which needs to be provided so that the rendering can be synchronized with the animation.
      painter - The rendering task which should be executed on the EDT at the end of the current event cycle.

    • paint

      public final void paint(UI.Layer layer, AnimationStatus status, Painter painter)
      A common use case is to render something on top of the UI.ComponentArea.BODY of the component using the Graphics2D instance of the component. This method allows you to attach a paint task to the component, which the EDT will process in the next repaint event cycle, and remove when the animation expires. This ensures that custom rendering is not erased by a potential repaint of the component after a user event.

      Here is an example of how to use this method as part of a fancy button animation: 

      
      UI.button("Click me").withPrefSize(400, 400)
      .onMouseClick( it -> it.animateFor(2, TimeUnit.SECONDS, status -> {
          double r = 300 * status.progress();
          double x = it.mouseX() - r / 2;
          double y = it.mouseY() - r / 2;
          it.paint(UI.Layer.CONTENT, status, g -> {
              g.setColor(new Color(1f, 1f, 0f, (float) (1 - status.progress())));
              g.fillOval((int) x, (int) y, (int) r, (int) r);
          });
      }))
      You may also be interested in doing style animations, if so, maybe consider taking a look at UIForAnySwing.withTransitoryStyle(sprouts.Observable, LifeTime, AnimatedStyler) to see how to do event based styling animations and UIForAnySwing.withTransitionalStyle(Val, LifeTime, AnimatedStyler) to see how to do 2 state switch based styling animations.
      Parameters:
      layer - The layer of the component which should be painted on.
      status - The current animation progress status, which is important so that the rendering can be synchronized with the animation.
      painter - The rendering task which should be executed on the EDT at the end of the current event cycle.

    • paint

      public final void paint(UI.ComponentArea area, UI.Layer layer, AnimationStatus status, Painter painter)
      A common use case is to render something on top of the component using the Graphics2D instance used by the component to render itself. This method allows you to attach a paint task to the component, which the EDT will process in the next repaint event cycle, and remove when the animation expires. This ensures that custom rendering is not erased by a potential repaint of the component after a user event.
      Additionally, you can specify the area of the component which should be painted as well as a layer onto which the painter should paint.

      Here is an example of how to use this method as part of a button animation: 

      
      UI.button("Click me").withPrefSize(400, 400)
      .onMouseClick( it -> it.animateFor(2, TimeUnit.SECONDS, status -> {
          double r = 300 * status.progress();
          double x = it.mouseX() - r / 2;
          double y = it.mouseY() - r / 2;
          it.paint(UI.ComponentArea.BODY, UI.Layer.CONTENT, state, g -> {
              g.setColor(new Color(1f, 1f, 0f, (float) (1 - status.progress())));
              g.fillOval((int) x, (int) y, (int) r, (int) r);
          });
      }))
      You may also be interested in doing style animations, if so, maybe consider taking a look at UIForAnySwing.withTransitoryStyle(sprouts.Observable, LifeTime, AnimatedStyler) to see how to do event based styling animations and UIForAnySwing.withTransitionalStyle(Val, LifeTime, AnimatedStyler) to see how to do 2 state switch based styling animations.
      Parameters:
      area - The area of the component which should be painted.
      layer - The layer of the component which should be painted.
      status - The current animation progress status, which needs to be provided so that the rendering can be synchronized with the animation.
      painter - An implementation of a simple functional interface receiving a Graphics2D instance for doing paint operations...

    • parentDelegate

      public final void parentDelegate(sprouts.Action<AbstractDelegate<JComponent>> action)
      Use this method to delegate to the parent of the component. This is useful if you want to apply a style or animation to the parent of a component which just received an event, like a mouse click event.

      Here is an example demonstrating how to apply a style to the parent of a component when it is clicked: 

      
      UI.button("Click me").withPrefSize(400, 400)
      .onMouseClick( it -> it
          .parentDelegate( parent -> parent
              .style( style -> style
                  .borderWidth(6)
                  .borderColor(Color.RED)
                  .borderRadius(60)
              )
          )
      )

      And here another more advanced example demonstrating how to do animated painting on the parent of a component that is being dragged away: 
      
  label("Drag me away")
  .withDragAway( conf -> conf
      .onDragStart( it -> {
          it.parentDelegate( parent -> parent
              .animateFor(1, TimeUnit.SECONDS, status -> {
                  double r = 320 * status.fadeOut();
                  double x = it.getEvent().getDragOrigin().getX() - r / 2;
                  double y = it.getEvent().getDragOrigin().getY() - r / 2;
                  parent.paint(status, g -> {
                      g.setColor(new Color(0f, 1f, 1f, (float) status.fadeIn()));
                      g.fillOval((int) x, (int) y, (int) r, (int) r);
                  });
              })
          );
      })
  )
      The paint method draws a circle around the drag origin of the drag event which gets smaller and more opaque as the animation progresses for a duration of 1 second.

      You may also be interested in doing style animations, if so, maybe consider taking a look at UIForAnySwing.withTransitoryStyle(sprouts.Observable, LifeTime, AnimatedStyler) to see how to do event based styling animations and UIForAnySwing.withTransitionalStyle(Val, LifeTime, AnimatedStyler) to see how to do 2 state switch based styling animations.

      Parameters:
      action - The action which should be executed on the delegate of the parent component.

    • animateStyleFor

      public final void animateStyleFor(double duration, TimeUnit unit, AnimatedStyler<C> styler)
      A common use case is to animate the style of a component when a user event occurs. This method allows you to dispatch a styling animation to the EDT which will cause the component style to updated repeatedly until the animation expires. Because animation styles are applied last, it is guaranteed not to be overwritten by other Styler lambdas. Note that the provided styling will be removed automatically when the animation expires, so no manual cleanup is required.

      Here is an example of how to use this method as part of a fancy styling animation: 

      
    UI.button("Click me").withPrefSize(400, 400)
    .onMouseClick( it -> it.animateStyleFor(2, TimeUnit.SECONDS, (state, style) ->
        .borderWidthAt(UI.Edge.BOTTOM, (int)(6 * state.progress()) )
        .borderColor( new Color(0f, 1f, 1f, (float) (1 - state.progress())) )
        .borderRadius( (int)(60 * state.progress()) )
    ))
      You can achieve the same effect using animateFor(LifeTime, Animation) and style(AnimationStatus, Styler) as follows: 
      
    UI.button("Click me").withPrefSize(400, 400)
    .onMouseClick( it -> it.animateFor(2, TimeUnit.SECONDS, status -> {
        it.style(status, style -> style
            // This is the same as the animateStyleFor() method above!
        );
    }))
      Also see animateStyleFor(LifeTime, AnimatedStyler) for a version of this method which uses a LifeTime instead of a duration. If you are interested in doing more advanced style animations, consider taking a look at UIForAnySwing.withTransitoryStyle(sprouts.Observable, LifeTime, AnimatedStyler) to see how to do event based styling animations and UIForAnySwing.withTransitionalStyle(Val, LifeTime, AnimatedStyler) to see how to do 2 state switch based styling animations.
      Parameters:
      duration - The duration of the animation.
      unit - The time unit of the duration.
      styler - The styling animation task which should be executed on the EDT at the end of the current event cycle. It receives both the current animation state and the ComponentStyleDelegate for which you can define the style properties.

    • animateStyleFor

      public final void animateStyleFor(LifeTime lifetime, AnimatedStyler<C> styler)
      A common use case is to animate the style of a component when a user event occurs. This method allows you to dispatch a styling animation to the EDT which will cause the component style to updated repeatedly until the animation expires. Because animation styles are applied last, it is guaranteed not to be overwritten by other Styler lambdas. Note that the provided styling will be removed automatically when the animation expires, so no manual cleanup is required.

      Here is an example of how to use this method as part of a fancy styling animation: 

      
    UI.button("Click me").withPrefSize(400, 400)
    .onMouseClick( it -> it.animateStyleFor(UI.lifetime(2, TimeUnit.SECONDS), (state, style) ->
        .borderWidthAt(UI.Edge.BOTTOM, (int)(6 * state.progress()) )
        .borderColor( new Color(0f, 1f, 1f, (float) (1 - state.progress())) )
        .borderRadius( (int)(60 * state.progress()) )
    ))
      Not that the effect of this method can also be modelled using animateFor(LifeTime, Animation) and style(AnimationStatus, Styler) as follows: 
      
    UI.button("Click me").withPrefSize(400, 400)
    .onMouseClick( it -> it.animateFor(UI.lifetime(2, TimeUnit.SECONDS), status -> {
        it.style(status, style -> style
            // This is the same as the animateStyleFor() method above!
        );
    }))
      Also see animateStyleFor(double, TimeUnit, AnimatedStyler) for a version of this method which uses a LifeTime instead of a duration. If you are interested in doing more advanced style animations, consider taking a look at UIForAnySwing.withTransitoryStyle(sprouts.Observable, LifeTime, AnimatedStyler) to see how to do event based styling animations and UIForAnySwing.withTransitionalStyle(Val, LifeTime, AnimatedStyler) to see how to do 2 state switch based styling animations.
      Parameters:
      lifetime - The lifetime of the animation. The animation will be removed automatically when the lifetime expires.
      styler - The styling animation task which should be executed on the EDT at the end of the current event cycle. It receives both the current animation state and the ComponentStyleDelegate for which you can define the style properties.

    • style

      public final void style(AnimationStatus state, Styler<C> styler)
      A common use case is to style the component based on the current animation state. This method allows you to dispatch a styling task to the EDT which will be executed before the next component repaint. Because animation styles are applied last, it is guaranteed not to be overwritten by other styles. The provided styling will be removed when the animation expires.

      Here is an example of how to use this method as part of a fancy styling animation: 

      
      UI.button("Click me").withPrefSize(400, 400)
      .onMouseClick( it -> it.animateFor(2, TimeUnit.SECONDS, status -> {
          it.style(status, style -> style
              .borderWidth((int)(10 * status.progress()))
              .borderColor(new Color(1f, 1f, 0f, (float) (1 - status.progress())))
              .borderRadius((int)(100 * status.progress()))
          );
      }))
      Parameters:
      state - The current animation state, which is important so that the styling can be synchronized with the animation.
      styler - The styling task which should be executed on the EDT at the end of the current event cycle.

    • animateFor

      public final AnimationDispatcher animateFor(double duration, TimeUnit unit)
      Exposes access the animation builder API, where you can define the conditions under which the animation should be executed and then dispatch the animation to the EDT through the AnimationDispatcher.go(Animation) method.
      Parameters:
      duration - The duration of the animation.
      unit - The time unit of the duration.
      Returns:
      An AnimationDispatcher instance which can be used to define how the animation should be executed.

    • animateFor

      public final AnimationDispatcher animateFor(LifeTime lifeTime)
      Exposes access the animation builder API, where you can define the conditions under which the animation should be executed and then dispatch the animation to the EDT through the AnimationDispatcher.go(Animation) method.
      Parameters:
      lifeTime - The lifetime of the animation.
      Returns:
      An AnimationDispatcher instance which can be used to define how the animation should be executed.

    • animateFor

      public final void animateFor(LifeTime lifeTime, Animation animation)
      Use this to schedule and run the provided animation to be executed on the EDT. A single animation iteration may be executed multiple times for the given duration in order to achieve a smooth transition.
      Here an example of how to use this method on a "Save" button: 
      
  UI.button("Save").withPrefSize(400, 400)
  .onMouseClick( it -> it
    .animateFor(
      UI.lifetime(1, TimeUnit.SECONDS)
      .startingIn( 0.5, TimeUnit.SECONDS )
    )
    .go( myAnimation )
  )
      Parameters:
      lifeTime - The lifetime of the animation.
      animation - The animation that should be executed.

    • animateFor

      public final void animateFor(double duration, TimeUnit unit, Animation animation)
      Use this to schedule and run the provided animation to be executed on the EDT. A single animation iteration may be executed multiple times for the given duration in order to achieve a smooth transition.
      Parameters:
      duration - The duration of the animation.
      unit - The time unit of the duration.
      animation - The animation that should be executed.