SvgIcon.java

  1. package swingtree.style;

  3. import com.github.weisj.jsvg.SVGDocument;
  4. import com.github.weisj.jsvg.parser.LoaderContext;
  5. import com.github.weisj.jsvg.parser.SVGLoader;
  6. import com.github.weisj.jsvg.view.FloatSize;
  7. import com.github.weisj.jsvg.view.ViewBox;
  8. import org.jspecify.annotations.Nullable;
  9. import org.slf4j.Logger;
  10. import swingtree.UI;
  11. import swingtree.layout.Size;

  13. import javax.swing.ImageIcon;
  14. import javax.swing.JComponent;
  15. import javax.swing.border.Border;
  16. import java.awt.*;
  17. import java.awt.geom.AffineTransform;
  18. import java.awt.image.BufferedImage;
  19. import java.io.InputStream;
  20. import java.net.URL;
  21. import java.util.Objects;
  22. import java.util.Optional;

  24. /**
  25.  *   A specialized {@link ImageIcon} subclass that allows you to use SVG based icon images in your GUI.
  26.  *   This in essence just a wrapper around the <a href="https://github.com/weisJ/jsvg">JSVG library</a>,
  27.  *   which renders SVG images using the Java2D graphics API.
  28.  *   <p>
  29.  *   You may use this like a regular {@link ImageIcon}, but have to keep in mind that SVG documents
  30.  *   do not really have a fixed size, meaning that the {@link #getIconWidth()} and {@link #getIconHeight()}
  31.  *   on a freshly loaded {@link SvgIcon} will return -1 which causes the icon to be rendered according to the
  32.  *   width and height of the component it is rendered into (see {@link #paintIcon(Component, java.awt.Graphics, int, int)}).
  33.  *   <p>
  34.  *   If you want to render the icon with a fixed size, you can use the {@link #withIconWidth(int)} and
  35.  *   {@link #withIconHeight(int)} or {@link #withIconSize(int, int)} methods to create a new {@link SvgIcon}
  36.  *   with the given width and height.
  37.  *   <p>
  38.  *   An {@link SvgIcon} with an undefined width or height will also be using the {@link UI.FitComponent}
  39.  *   and {@link UI.Placement} policies to determine how the icon should be placed and sized within a component.
  40.  *   Use the {@link #withFitComponent(UI.FitComponent)} and {@link #withPreferredPlacement(UI.Placement)}
  41.  *   methods to create a new {@link SvgIcon} with the given policies and use the {@link #getFitComponent()}
  42.  *   and {@link #getPreferredPlacement()} methods to retrieve the current policies
  43.  *   (Not that these will not have any effect if the width and height are both defined).
  44.  *   <p>
  45.  *   <b>Also note that the direct use of this class and it's API is discouraged in favour of simply
  46.  *   calling the {@link UI#findIcon(String)} or {@link UI#findSvgIcon(String)} methods, which
  47.  *   will automatically load and cache all of the icons for you.</b>
  48.  */
  49. public final class SvgIcon extends ImageIcon
  50. {
  51.     private static final Logger log = org.slf4j.LoggerFactory.getLogger(SvgIcon.class);
  52.     private static final UI.FitComponent DEFAULT_FIT_COMPONENT = UI.FitComponent.MIN_DIM;
  53.     private static final UI.Placement    DEFAULT_PLACEMENT     = UI.Placement.UNDEFINED;
  54.     private static final int             NO_SIZE               = -1;
  55.     private static final Insets          ZERO_INSETS           = new Insets(0,0,0,0);


  58.     private final @Nullable SVGDocument _svgDocument;
  59.     private final Size                  _size;
  60.     private final UI.FitComponent       _fitComponent;
  61.     private final UI.Placement          _preferredPlacement;

  63.     private @Nullable BufferedImage _cache = null;


  66.     private SvgIcon(
  67.         @Nullable SVGDocument svgDocument, // nullable
  68.         Size                  size,
  69.         UI.FitComponent       fitComponent,
  70.         UI.Placement          preferredPlacement
  71.     ) {
  72.         super();
  73.         _svgDocument        = svgDocument;
  74.         _size               = Objects.requireNonNull(size);
  75.         _fitComponent       = Objects.requireNonNull(fitComponent);
  76.         _preferredPlacement = Objects.requireNonNull(preferredPlacement);
  77.     }

  79.     /**
  80.      * @param path The path to the SVG document.
  81.      */
  82.     public SvgIcon( String path ) {
  83.         this(_loadSvgDocument(SvgIcon.class.getResource(path)), Size.unknown(), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  84.     }

  86.     /**
  87.      * @param svgUrl The URL to the SVG document.
  88.      */
  89.     public SvgIcon( URL svgUrl ) {
  90.         this(_loadSvgDocument(svgUrl), Size.unknown(), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  91.     }

  93.     /**
  94.      * @param stream The input stream supplying the text data of the SVG document.
  95.      */
  96.     public SvgIcon( InputStream stream ) {
  97.         this(_loadSvgDocument(stream), Size.unknown(), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  98.     }

  100.     /**
  101.      * @param svgDocument The already loaded SVG document, which will be used to render the icon.
  102.      */
  103.     public SvgIcon( SVGDocument svgDocument ) {
  104.         this(svgDocument, Size.unknown(), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  105.     }

  107.     /**
  108.      * @param path The path to the SVG document.
  109.      * @param size The size of the icon in the form of a {@link Dimension}.
  110.      */
  111.     public SvgIcon( String path, Dimension size ) {
  112.         this(_loadSvgDocument(SvgIcon.class.getResource(path)), Size.of(size), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  113.     }

  115.     /**
  116.      * @param svgUrl The URL to the SVG document.
  117.      * @param size The size of the icon in the form of a {@link Dimension}.
  118.      */
  119.     public SvgIcon( URL svgUrl, Dimension size ) {
  120.         this(_loadSvgDocument(svgUrl), Size.of(size), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  121.     }

  123.     /**
  124.      * @param stream The input stream supplying the text data of the SVG document.
  125.      * @param size The size of the icon in the form of a {@link Dimension}.
  126.      */
  127.     public SvgIcon( InputStream stream, Dimension size ) {
  128.         this(_loadSvgDocument(stream), Size.of(size), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  129.     }

  131.     /**
  132.      * @param svgDocument The already loaded SVG document, which will be used to render the icon.
  133.      * @param size The size of the icon in the form of a {@link Dimension}.
  134.      */
  135.     public SvgIcon( SVGDocument svgDocument, Dimension size ) {
  136.         this(svgDocument, Size.of(size), DEFAULT_FIT_COMPONENT, DEFAULT_PLACEMENT);
  137.     }


  140.     private static @Nullable SVGDocument _loadSvgDocument( URL svgUrl ) {
  141.         SVGDocument tempSVGDocument = null;
  142.         try {
  143.             SVGLoader loader = new SVGLoader();
  144.             tempSVGDocument = loader.load(svgUrl);
  145.         } catch (Exception e) {
  146.             log.error("Failed to load SVG document from URL: " + svgUrl, e);
  147.         }
  148.         return tempSVGDocument;
  149.     }

  151.     private static @Nullable SVGDocument _loadSvgDocument( InputStream stream ) {
  152.         SVGDocument tempSVGDocument = null;
  153.         try {
  154.             SVGLoader loader = new SVGLoader();
  155.             tempSVGDocument = loader.load(stream, null, LoaderContext.createDefault());
  156.         } catch (Exception e) {
  157.             log.error("Failed to load SVG document from stream: " + stream, e);
  158.         }
  159.         return tempSVGDocument;
  160.     }

  162.     /**
  163.      *  Exposes the width of the icon, or -1 if the icon should be rendered according
  164.      *  to the width of a given component or the width of the SVG document itself.
  165.      *  (...or other policies such as {@link swingtree.UI.FitComponent} and {@link swingtree.UI.Placement}).<br>
  166.      *  <b>
  167.      *      Note that the returned width is dynamically scaled according to
  168.      *      the current {@link swingtree.UI#scale()} value.
  169.      *      This is to ensure that the icon is rendered at the correct size
  170.      *      according to the current DPI settings.
  171.      *      If you want the unscaled width, use {@link #getBaseWidth()}.
  172.      *  </b>
  173.      * @return The width of the icon, or -1 if the icon should be rendered according
  174.      *         to the width of a given component or the width of the SVG document itself.
  175.      */
  176.     @Override
  177.     public int getIconWidth() {
  178.         Size adjustedSize = _sizeWithAspectRatioCorrection(_size);
  179.         return adjustedSize.width().map(UI::scale).map(Math::round).orElse(NO_SIZE);
  180.     }

  182.     /**
  183.      *  Creates an updated {@link SvgIcon} with the given width returned by {@link #getIconWidth()}.
  184.      *
  185.      * @param newWidth The width of the icon, or -1 if the icon should be rendered according
  186.      *              to the width of a given component or the width of the SVG document itself.
  187.      * @return A new {@link SvgIcon} with the given width.
  188.      *        If the width is -1, the icon will be rendered according to the width of a given component
  189.      *        or the width of the SVG document itself.
  190.      */
  191.     public SvgIcon withIconWidth( int newWidth ) {
  192.         int width = _size.width().map(Math::round).orElse(NO_SIZE);
  193.         if ( newWidth == width )
  194.             return this;
  195.         return new SvgIcon(_svgDocument, _size.withWidth(newWidth), _fitComponent, _preferredPlacement);
  196.     }

  198.     /**
  199.      *  Exposes the height of the icon, or -1 if the icon should be rendered according
  200.      *  to the height of a given component or the height of the SVG document itself.
  201.      *  (...or other policies such as {@link swingtree.UI.FitComponent} and {@link swingtree.UI.Placement}).<br>
  202.      *  <b>
  203.      *      Note that the returned height is dynamically scaled according to
  204.      *      the current {@link swingtree.UI#scale()} value.
  205.      *      This is to ensure that the icon is rendered at the correct size
  206.      *      according to the current DPI settings.
  207.      *      If you want the unscaled height, use {@link #getBaseHeight()}.
  208.      *  </b>
  209.      *
  210.      * @return A new {@link SvgIcon} with the given width and height.
  211.      *        If the width or height is -1, the icon will be rendered according to the width or height of a given component
  212.      *        or the width or height of the SVG document itself.
  213.      */
  214.     @Override
  215.     public int getIconHeight() {
  216.         Size adjustedSize = _sizeWithAspectRatioCorrection(_size);
  217.         return adjustedSize.height().map(UI::scale).map(Math::round).orElse(NO_SIZE);
  218.     }

  220.     /**
  221.      *  Exposes the fixed width defined for the icon, which is the width
  222.      *  that was set when the icon was created or updated using the
  223.      *  {@link #withIconWidth(int)} method.<br>
  224.      *  <b>
  225.      *      Note that this width is not scaled according to the current {@link swingtree.UI#scale()} value.
  226.      *      If you want a scaled width, that is more suitable for rendering the icon,
  227.      *      use the {@link #getIconWidth()} method.
  228.      *  </b>
  229.      *
  230.      * @return The width of the icon without scaling.
  231.      */
  232.     public int getBaseWidth() {
  233.         return _size.width().map(Math::round).orElse(NO_SIZE);
  234.     }

  236.     /**
  237.      *  Exposes the fixed height defined for the icon, which is the height
  238.      *  that was set when the icon was created or updated using the
  239.      *  {@link #withIconHeight(int)} method.<br>
  240.      *  <b>
  241.      *      Note that this height is not scaled according to the current {@link swingtree.UI#scale()} value.
  242.      *      If you want a scaled height, that is more suitable for rendering the icon,
  243.      *      use the {@link #getIconHeight()} method.
  244.      *  </b>
  245.      *
  246.      * @return The height of the icon without scaling.
  247.      */
  248.     public int getBaseHeight() {
  249.         return _size.height().map(Math::round).orElse(NO_SIZE);
  250.     }

  252.     /**
  253.      *  Creates an updated {@link SvgIcon} with the supplied integer used
  254.      *  as the icon height, which you can retrieve using {@link #getIconHeight()}.
  255.      *  If the height is -1, the icon will be rendered according to the height of a given component
  256.      *  or the height of the SVG document itself.
  257.      *  (...or other policies such as {@link swingtree.UI.FitComponent} and {@link swingtree.UI.Placement}).
  258.      *
  259.      * @param height The height of the icon, or -1 if the icon should be rendered according
  260.      *               to the height of a given component or the height of the SVG document itself.
  261.      * @return A new {@link SvgIcon} with the given height.
  262.      *        If the height is -1, the icon will be rendered according to the height of a given component
  263.      *        or the height of the SVG document itself.
  264.      */
  265.     public SvgIcon withIconHeight( int height ) {
  266.         int currentHeight = _size.height().map(Math::round).orElse(NO_SIZE);
  267.         if ( height == currentHeight )
  268.             return this;
  269.         return new SvgIcon(_svgDocument, _size.withHeight(height), _fitComponent, _preferredPlacement);
  270.     }

  272.     /**
  273.      *  Creates an updated {@link SvgIcon} with the given width and height.
  274.      *  Dimensions smaller than 0 are considered "undefined".
  275.      *  When the icon is being rendered then these will be determined according to the
  276.      *  aspect ratio of the SVG document, the {@link swingtree.UI.FitComponent} / {@link swingtree.UI.Placement}
  277.      *  policies or the size of the component the SVG is rendered into.
  278.      *
  279.      * @param newWidth The width of the icon, or -1 if the icon should be rendered according
  280.      *              to the width of a given component or the width of the SVG document itself.
  281.      * @param newHeight The height of the icon, or -1 if the icon should be rendered according
  282.      *               to the height of a given component or the height of the SVG document itself.
  283.      * @return A new {@link SvgIcon} with the given width and height.
  284.      *        If the width or height is -1, the icon will be rendered according to the width or height of a given component
  285.      *        or the width or height of the SVG document itself.
  286.      */
  287.     public SvgIcon withIconSize( int newWidth, int newHeight ) {
  288.         newWidth  = newWidth  < 0 ? NO_SIZE : newWidth;
  289.         newHeight = newHeight < 0 ? NO_SIZE : newHeight;
  290.         int width  = _size.width().map(Math::round).orElse(NO_SIZE);
  291.         int height = _size.height().map(Math::round).orElse(NO_SIZE);
  292.         if ( newWidth == width && newHeight == height )
  293.             return this;
  294.         return new SvgIcon(_svgDocument, Size.of(newWidth, newHeight), _fitComponent, _preferredPlacement);
  295.     }

  297.     /**
  298.      *  Allows you to create an updated {@link SvgIcon} with the given size
  299.      *  in the form of a {@link Size} object containing the width and height.
  300.      *  If the width or height is -1, the icon will be rendered according to the
  301.      *  width or height of a given component, the width or height of the SVG document
  302.      *  and the {@link swingtree.UI.FitComponent} / {@link swingtree.UI.Placement} policies.
  303.      *
  304.      * @param size The size of the icon in the form of a {@link Size}.
  305.      * @return A new {@link SvgIcon} with the given width and height.
  306.      */
  307.     public SvgIcon withIconSize( Size size ) {
  308.         return withIconSize(
  309.                     size.width().map(Math::round).orElse(NO_SIZE),
  310.                     size.height().map(Math::round).orElse(NO_SIZE)
  311.                 );
  312.     }

  314.     /**
  315.      *  Determines the size of the icon (both width and height) using the provided width
  316.      *  and the aspect ratio of the SVG document.
  317.      *  If the width is -1, the icon will lose its fixed width and will
  318.      *  be rendered according to the width of a given component.
  319.      *  <p>
  320.      *  For example, if the SVG document has an aspect ratio of 2:1, and the width is 200,
  321.      *  then the height will be 100.
  322.      *  <p>
  323.      *  Also see {@link #withIconSizeFromHeight(int)}.
  324.      *
  325.      * @param newWidth The width of the icon, or -1 if the icon should be rendered according
  326.      *              to the width of a given component or the width of the SVG document itself.
  327.      * @return A new {@link SvgIcon} with the given width and a logical height that is
  328.      *         determined by the aspect ratio of the SVG document.
  329.      */
  330.     public SvgIcon withIconSizeFromWidth( int newWidth ) {
  331.         if ( newWidth < 0 )
  332.             return this.withIconSize(NO_SIZE, NO_SIZE);

  334.         Size adjustedSize = _sizeWithAspectRatioCorrection(Size.unknown().withWidth(newWidth));
  335.         return new SvgIcon(_svgDocument, adjustedSize, _fitComponent, _preferredPlacement);
  336.     }

  338.     /**
  339.      *  Determines the size of the icon (both width and height) using the provided height
  340.      *  and the aspect ratio of the SVG document.
  341.      *  If the height is -1, the icon will lose its fixed height and will
  342.      *  be rendered according to the height of a given component.
  343.      *  <p>
  344.      *  For example, if the SVG document has an aspect ratio of 2:1, and the height is 100,
  345.      *  then the width will be 200.
  346.      *  <p>
  347.      *  Also see {@link #withIconSizeFromWidth(int)}.
  348.      *
  349.      * @param newHeight The height of the icon, or -1 if the icon should be rendered according
  350.      *               to the height of a given component or the height of the SVG document itself.
  351.      * @return A new {@link SvgIcon} with the given height and a logical width that is
  352.      *         determined by the aspect ratio of the SVG document.
  353.      */
  354.     public SvgIcon withIconSizeFromHeight( int newHeight ) {
  355.         if ( newHeight < 0 )
  356.             return this.withIconSize(NO_SIZE, NO_SIZE);

  358.         Size adjustedSize = _sizeWithAspectRatioCorrection(Size.unknown().withHeight(newHeight));
  359.         return new SvgIcon(_svgDocument, adjustedSize, _fitComponent, _preferredPlacement);
  360.     }

  362.     /**
  363.      *  The underlying SVG document contains a size object, which
  364.      *  is the width and height of the root SVG element inside the document.
  365.      *
  366.      * @return The size of the SVG document in the form of a {@link Size},
  367.      *         a subclass of {@link java.awt.geom.Dimension2D}.
  368.      */
  369.     public Size getSvgSize() {
  370.         if ( _svgDocument == null )
  371.             return Size.unknown();
  372.         FloatSize svgSize = _svgDocument.size();
  373.         return Size.of(svgSize.width, svgSize.height);
  374.     }

  376.     /**
  377.      *  Allows you to access the underlying {@link SVGDocument} that is used to render the icon.
  378.      *
  379.      * @return The underlying {@link SVGDocument} that is used to render the icon.
  380.      */
  381.     public @Nullable SVGDocument getSvgDocument() {
  382.         return _svgDocument;
  383.     }

  385.     /**
  386.      *  Allows you to access the {@link UI.FitComponent} policy, which
  387.      *  determines if and how the icon should be fitted
  388.      *  onto a component when rendered through the
  389.      *  {@link #paintIcon(Component, java.awt.Graphics, int, int, int, int)} method.<br>
  390.      *  The following fit modes are available:
  391.      *  <ul>
  392.      *      <li>{@link UI.FitComponent#NO} -
  393.      *      The image will not be scaled to fit the inner component area.
  394.      *      </li>
  395.      *      <li>{@link UI.FitComponent#WIDTH} -
  396.      *      The image will be scaled to fit the inner component width.
  397.      *      </li>
  398.      *      <li>{@link UI.FitComponent#HEIGHT} -
  399.      *      The image will be scaled to fit the inner component height.
  400.      *      </li>
  401.      *      <li>{@link UI.FitComponent#WIDTH_AND_HEIGHT} -
  402.      *      The image will be scaled to fit both the component width and height.
  403.      *      </li>
  404.      *      <li>{@link UI.FitComponent#MAX_DIM} -
  405.      *      The image will be scaled to fit the larger of the two dimensions of the inner component area.
  406.      *      </li>
  407.      *      <li>{@link UI.FitComponent#MIN_DIM} -
  408.      *      The image will be scaled to fit the smaller of the two dimensions of the inner component area.
  409.      *      </li>
  410.      *  </ul>
  411.      *  See {@link #withFitComponent(UI.FitComponent)} if you want to create a new {@link SvgIcon}
  412.      *  with an updated fit policy.
  413.      *
  414.      * @return The {@link UI.FitComponent} that determines if and how the icon should be fitted into a
  415.      *         any given component (see {@link #paintIcon(Component, java.awt.Graphics, int, int, int, int)}).
  416.      */
  417.     public UI.FitComponent getFitComponent() { return _fitComponent; }

  419.     /**
  420.      *  There are different kinds of strategies to fit an SVG icon onto the component.
  421.      *  These strategies are identified using the {@link UI.FitComponent} enum
  422.      *  which defines the following fit modes:
  423.      *  <ul>
  424.      *      <li>{@link UI.FitComponent#NO} -
  425.      *          The image will not be scaled to fit the inner component area.
  426.      *      </li>
  427.      *      <li>{@link UI.FitComponent#WIDTH} -
  428.      *          The image will be scaled to fit the inner component width.
  429.      *      </li>
  430.      *      <li>{@link UI.FitComponent#HEIGHT} -
  431.      *          The image will be scaled to fit the inner component height.
  432.      *      </li>
  433.      *      <li>{@link UI.FitComponent#WIDTH_AND_HEIGHT} -
  434.      *          The image will be scaled to fit both the component width and height.
  435.      *      </li>
  436.      *      <li>{@link UI.FitComponent#MAX_DIM} -
  437.      *          The image will be scaled to fit the larger
  438.      *          of the two dimension of the inner component area.
  439.      *      </li>
  440.      *      <li>{@link UI.FitComponent#MIN_DIM} -
  441.      *          The image will be scaled to fit the smaller
  442.      *          of the two dimension of the inner component area.
  443.      *      </li>
  444.      *  </ul>
  445.      * @param fit The {@link UI.FitComponent} that determines if and how the icon should be fitted into a
  446.      *            any given component (see {@link #paintIcon(Component, java.awt.Graphics, int, int, int, int)}).
  447.      * @return A new {@link SvgIcon} with the given {@link UI.FitComponent} policy.
  448.      */
  449.     public SvgIcon withFitComponent( UI.FitComponent fit ) {
  450.         Objects.requireNonNull(fit);
  451.         if ( fit == _fitComponent )
  452.             return this;
  453.         return new SvgIcon(_svgDocument, _size, fit, _preferredPlacement);
  454.     }

  456.     /**
  457.      *  The preferred placement policy determines where the icon
  458.      *  should be placed within a component when rendered through the
  459.      *  {@link #paintIcon(Component, java.awt.Graphics, int, int, int, int)} method.
  460.      *
  461.      * @return The {@link UI.Placement} that determines where the icon should be placed within a component
  462.      *         (see {@link #paintIcon(Component, java.awt.Graphics, int, int, int, int)}).
  463.      */
  464.     public UI.Placement getPreferredPlacement() { return _preferredPlacement; }

  466.     /**
  467.      *  Allows you to get an updated {@link SvgIcon} with the given {@link UI.Placement} policy
  468.      *  which determines where the icon should be placed within a component
  469.      *  when rendered through the {@link #paintIcon(Component, java.awt.Graphics, int, int, int, int)} method.
  470.      *
  471.      * @param placement The {@link UI.Placement} that determines where the icon should be placed within a component
  472.      *                  (see {@link #paintIcon(Component, java.awt.Graphics, int, int, int, int)}).
  473.      * @return A new {@link SvgIcon} with the given {@link UI.Placement} policy.
  474.      */
  475.     public SvgIcon withPreferredPlacement( UI.Placement placement ) {
  476.         Objects.requireNonNull(placement);
  477.         if ( placement == _preferredPlacement )
  478.             return this;
  479.         return new SvgIcon(_svgDocument, _size, _fitComponent, placement);
  480.     }

  482.     /**
  483.      *  Creates a new {@link Image} from the SVG document.
  484.      * @return A new {@link Image} where the SVG document has been rendered into.
  485.      */
  486.     @Override
  487.     public Image getImage() {

  489.         if ( _cache != null )
  490.             return _cache;

  492.         int width  = getIconWidth();
  493.         int height = getIconHeight();

  495.         if ( _svgDocument != null ) {
  496.             if (width < 0)
  497.                 width = (int) UI.scale(_svgDocument.size().width);
  498.             if (height < 0)
  499.                 height = (int) UI.scale(_svgDocument.size().height);
  500.         }

  502.         // We create a new buffered image, render into it, and then return it.
  503.         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
  504.         if ( _svgDocument != null )
  505.             _svgDocument.render(
  506.                     null,
  507.                     image.createGraphics(),
  508.                     new ViewBox(0, 0, width, height)
  509.                 );

  511.         return image;
  512.     }

  514.     /**
  515.      *  We don't support this. An SVG document is not really an image, it's a vector graphic.
  516.      *  Extending {@link ImageIcon} is just for compatibility reasons...
  517.      */
  518.     @Override
  519.     public void setImage( Image image ) {
  520.         // We don't support this.
  521.     }

  523.     /**
  524.      * @param c The component to render the icon into.
  525.      * @param g the graphics context
  526.      * @param x the X coordinate of the icon's top-left corner
  527.      * @param y the Y coordinate of the icon's top-left corner
  528.      */
  529.     @Override
  530.     public synchronized void paintIcon( java.awt.Component c, java.awt.Graphics g, int x, int y )
  531.     {
  532.         if ( _svgDocument == null )
  533.             return;

  535.         int scaledWidth  = getIconWidth();
  536.         int scaledHeight = getIconHeight();

  538.         UI.Placement preferredPlacement = _preferredPlacement;

  540.         if ( preferredPlacement == UI.Placement.UNDEFINED && c instanceof JComponent )
  541.             preferredPlacement = ComponentExtension.from((JComponent) c).preferredIconPlacement();

  543.         Insets insets = ZERO_INSETS;

  545.         if ( c != null ) {
  546.             /*
  547.                 If the component exists we want to account for its (border) insets.
  548.                 This is to avoid the icon colliding with the component border
  549.                 and also to make sure the icon is centered properly.
  550.             */
  551.             insets = Optional.ofNullable( c instanceof JComponent ? ((JComponent)c).getBorder() : null )
  552.                                 .map( b -> {
  553.                                     try {
  554.                                         return _determineInsetsForBorder(b, c);
  555.                                     } catch (Exception e) {
  556.                                         return ZERO_INSETS;
  557.                                     }
  558.                                 })
  559.                                 .orElse(ZERO_INSETS);

  561.             if ( scaledWidth < 0 )
  562.                 x = insets.left;

  564.             if ( scaledHeight < 0 )
  565.                 y = insets.top;
  566.         }

  568.         int width  = Math.max( scaledWidth,  c == null ? NO_SIZE : c.getWidth()  );
  569.         int height = Math.max( scaledHeight, c == null ? NO_SIZE : c.getHeight() );

  571.         width  = scaledWidth  >= 0 ? scaledWidth  : width  - insets.right  - insets.left;
  572.         height = scaledHeight >= 0 ? scaledHeight : height - insets.bottom - insets.top ;

  574.         if ( width  <= 0 ) {
  575.             int smaller = (int) Math.floor( width / 2.0 );
  576.             int larger  = (int) Math.ceil(  width / 2.0 );
  577.             x += smaller;
  578.             width = ( larger - smaller );
  579.         }
  580.         if ( height <= 0 ) {
  581.             int smaller = (int) Math.floor( height / 2.0 );
  582.             int larger  = (int) Math.ceil(  height / 2.0 );
  583.             y += smaller;
  584.             height = ( larger - smaller );
  585.         }

  587.         if ( scaledWidth > 0 && scaledHeight > 0 ) {
  588.             if ( _cache != null && _cache.getWidth() == width && _cache.getHeight() == height )
  589.                 g.drawImage(_cache, x, y, width, height, null);
  590.             else {
  591.                 _cache = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
  592.                 paintIcon(c, _cache.getGraphics(), 0, 0, width, height);
  593.                 g.drawImage(_cache, x, y, width, height, null);
  594.             }
  595.         }
  596.         else
  597.             _paintIcon( c, g, x, y, width, height, preferredPlacement );
  598.     }

  600.     private Insets _determineInsetsForBorder( Border b, Component c )
  601.     {
  602.         if ( b == null )
  603.             return ZERO_INSETS;

  605.         if ( b instanceof StyleAndAnimationBorder )
  606.             return ((StyleAndAnimationBorder<?>)b).getFullPaddingInsets();

  608.         // Compound border
  609.         if ( b instanceof javax.swing.border.CompoundBorder ) {
  610.             javax.swing.border.CompoundBorder cb = (javax.swing.border.CompoundBorder) b;
  611.             return cb.getOutsideBorder().getBorderInsets(c);
  612.         }

  614.         try {
  615.             return b.getBorderInsets(c);
  616.         } catch (Exception e) {
  617.             // Ignore
  618.         }
  619.         return ZERO_INSETS;
  620.     }

  622.     void paintIcon(
  623.             final @Nullable Component c,
  624.             final java.awt.Graphics g,
  625.             int x,
  626.             int y,
  627.             int width,
  628.             int height
  629.     ) {
  630.         _paintIcon( c, g, x, y, width, height, _preferredPlacement );
  631.     }

  633.     private void _paintIcon(
  634.         final @Nullable Component c,
  635.         final java.awt.Graphics g,
  636.         int x,
  637.         int y,
  638.         int width,
  639.         int height,
  640.         UI.Placement preferredPlacement
  641.     ) {
  642.         if ( _svgDocument == null )
  643.             return;

  645.         int scaledWidth  = getIconWidth();
  646.         int scaledHeight = getIconHeight();

  648.         width  = ( width  < 0 ? scaledWidth  : width  );
  649.         height = ( height < 0 ? scaledHeight : height );

  651.         Graphics2D g2d = (Graphics2D) g.create();

  653.         FloatSize svgSize = _svgDocument.size();
  654.         float svgRefWidth  = ( svgSize.width  > svgSize.height ? 1f : svgSize.width  / svgSize.height );
  655.         float svgRefHeight = ( svgSize.height > svgSize.width  ? 1f : svgSize.height / svgSize.width  );
  656.         float imgRefWidth  = (     width      >=   height      ? 1f : (float) width  /   height       );
  657.         float imgRefHeight = (     height     >=   width       ? 1f : (float) height /   width        );

  659.         float scaleX = imgRefWidth  / svgRefWidth;
  660.         float scaleY = imgRefHeight / svgRefHeight;

  662.         if ( _fitComponent == UI.FitComponent.MIN_DIM || _fitComponent == UI.FitComponent.MAX_DIM ) {
  663.             if ( width < height )
  664.                 scaleX = 1f;
  665.             if ( height < width )
  666.                 scaleY = 1f;
  667.         }

  669.         if ( _fitComponent == UI.FitComponent.WIDTH )
  670.             scaleX = 1f;

  672.         if ( _fitComponent == UI.FitComponent.HEIGHT )
  673.             scaleY = 1f;

  675.         ViewBox viewBox = new ViewBox(x, y, width, height);
  676.         float boxX      = viewBox.x  / scaleX;
  677.         float boxY      = viewBox.y  / scaleY;
  678.         float boxWidth  = viewBox.width  / scaleX;
  679.         float boxHeight = viewBox.height / scaleY;
  680.         if ( _fitComponent == UI.FitComponent.MAX_DIM ) {
  681.             // We now want to make sure that the
  682.             if ( boxWidth < boxHeight ) {
  683.                 // We find the scale factor of the heights between the two rectangles:
  684.                 float scaleHeight = ( viewBox.height / svgSize.height );
  685.                 // We now want to scale the view box so that both have the same heights:
  686.                 float newWidth  = svgSize.width  * scaleHeight;
  687.                 float newHeight = svgSize.height * scaleHeight;
  688.                 float newX = viewBox.x + (viewBox.width - newWidth) / 2f;
  689.                 float newY = viewBox.y;
  690.                 viewBox = new ViewBox(newX, newY, newWidth, newHeight);
  691.             } else {
  692.                 // We find the scale factor of the widths between the two rectangles:
  693.                 float scaleWidth = ( viewBox.width / svgSize.width );
  694.                 // We now want to scale the view box so that both have the same widths:
  695.                 float newWidth  = svgSize.width  * scaleWidth;
  696.                 float newHeight = svgSize.height * scaleWidth;
  697.                 float newX = viewBox.x;
  698.                 float newY = viewBox.y + (viewBox.height - newHeight) / 2f;
  699.                 viewBox = new ViewBox(newX, newY, newWidth, newHeight);
  700.             }
  701.         }
  702.         else
  703.             viewBox = new ViewBox(boxX, boxY, boxWidth, boxHeight);

  705.         if ( _fitComponent == UI.FitComponent.NO ) {
  706.             width   = scaledWidth  >= 0 ? scaledWidth  : (int) svgSize.width;
  707.             height  = scaledHeight >= 0 ? scaledHeight : (int) svgSize.height;
  708.             viewBox = new ViewBox( x, y, width, height );
  709.         }

  711.         // Let's check if the view box exists:
  712.         if ( viewBox.width <= 0 || viewBox.height <= 0 )
  713.             return;

  715.         // Also let's check if the view box has valid values:
  716.         if ( Float.isNaN(viewBox.x) || Float.isNaN(viewBox.y) || Float.isNaN(viewBox.width) || Float.isNaN(viewBox.height) )
  717.             return;

  719.         // Let's make sure the view box has the correct dimension ratio:
  720.         float viewBoxRatio = _svgDocument.size().width / _svgDocument.size().height;
  721.         float boxRatio     =      viewBox.width        /      viewBox.height;
  722.         if ( boxRatio > viewBoxRatio ) {
  723.             // The view box is too wide, we need to make it narrower:
  724.             float newWidth = viewBox.height * viewBoxRatio;
  725.             viewBox = new ViewBox( viewBox.x + (viewBox.width - newWidth) / 2f, viewBox.y, newWidth, viewBox.height );
  726.         }
  727.         if ( boxRatio < viewBoxRatio ) {
  728.             // The view box is too tall, we need to make it shorter:
  729.             float newHeight = viewBox.width / viewBoxRatio;
  730.             viewBox = new ViewBox( viewBox.x, viewBox.y + (viewBox.height - newHeight) / 2f, viewBox.width, newHeight );
  731.         }

  733.         /*
  734.             Before we do the actual rendering we first check if there
  735.             is a preferred placement that is not the center.
  736.             If that is the case we move the view box accordingly.
  737.          */
  738.         if ( preferredPlacement != UI.Placement.UNDEFINED && preferredPlacement != UI.Placement.CENTER ) {
  739.             // First we correct if the component area is smaller than the view box:
  740.             width += (int) Math.max(0, ( viewBox.x + viewBox.width ) - ( x + width ) );
  741.             width += (int) Math.max(0, x - viewBox.x );
  742.             x = (int) Math.min(x, viewBox.x);
  743.             height += (int) Math.max(0, ( viewBox.y + viewBox.height ) - ( y + height ) );
  744.             height += (int) Math.max(0, y - viewBox.y );
  745.             y = (int) Math.min(y, viewBox.y);

  747.             switch ( preferredPlacement ) {
  748.                 case TOP_LEFT:
  749.                     viewBox = new ViewBox( x, y, viewBox.width, viewBox.height );
  750.                     break;
  751.                 case TOP_RIGHT:
  752.                     viewBox = new ViewBox( x + width - viewBox.width, y, viewBox.width, viewBox.height );
  753.                     break;
  754.                 case BOTTOM_LEFT:
  755.                     viewBox = new ViewBox( x, y + height - viewBox.height, viewBox.width, viewBox.height );
  756.                     break;
  757.                 case BOTTOM_RIGHT:
  758.                     viewBox = new ViewBox( x + width - viewBox.width, y + height - viewBox.height, viewBox.width, viewBox.height );
  759.                     break;
  760.                 case TOP:
  761.                     viewBox = new ViewBox( x + (width - viewBox.width) / 2f, y, viewBox.width, viewBox.height );
  762.                     break;
  763.                 case BOTTOM:
  764.                     viewBox = new ViewBox( x + (width - viewBox.width) / 2f, y + height - viewBox.height, viewBox.width, viewBox.height );
  765.                     break;
  766.                 case LEFT:
  767.                     viewBox = new ViewBox( x, y + (height - viewBox.height) / 2f, viewBox.width, viewBox.height );
  768.                     break;
  769.                 case RIGHT:
  770.                     viewBox = new ViewBox( x + width - viewBox.width, y + (height - viewBox.height) / 2f, viewBox.width, viewBox.height );
  771.                     break;
  772.                 default:
  773.                     log.warn("Unknown preferred placement: " + preferredPlacement);
  774.             }
  775.         }

  777.         // Now onto the actual rendering:

  779.         boolean doAntiAliasing  = StyleEngine.IS_ANTIALIASING_ENABLED();
  780.         boolean wasAntiAliasing = g2d.getRenderingHint( java.awt.RenderingHints.KEY_ANTIALIASING ) == java.awt.RenderingHints.VALUE_ANTIALIAS_ON;
  781.         if ( doAntiAliasing && !wasAntiAliasing )
  782.             g2d.setRenderingHint( java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON );

  784.         boolean needsScaling = ( scaleX != 1 || scaleY != 1 );
  785.         AffineTransform oldTransform = g2d.getTransform();

  787.         if ( needsScaling ) {
  788.             AffineTransform newTransform = new AffineTransform(oldTransform);
  789.             newTransform.scale(scaleX, scaleY);
  790.             g2d.setTransform(newTransform);
  791.         }

  793.         try {
  794.             // We also have to scale x and y, this is because the SVGDocument does not
  795.             // account for the scale of the transform with respect to the view box!
  796.             _svgDocument.render((JComponent) c, g2d, viewBox);
  797.         } catch (Exception e) {
  798.             log.warn("Failed to render SVG document.", e);
  799.         }

  801.         if ( needsScaling )
  802.             g2d.setTransform(oldTransform); // back to the previous scaling!

  804.         if ( doAntiAliasing && !wasAntiAliasing )
  805.             g2d.setRenderingHint( java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_OFF );
  806.     }

  808.     @Override
  809.     public int hashCode() {
  810.         return Objects.hash(_svgDocument, _size, _fitComponent, _preferredPlacement);
  811.     }

  813.     @Override
  814.     public boolean equals( Object obj ) {
  815.         if ( obj == null ) return false;
  816.         if ( obj == this ) return true;
  817.         if ( obj.getClass() != getClass() ) return false;
  818.         SvgIcon rhs = (SvgIcon) obj;
  819.         return Objects.equals(_size,               rhs._size)        &&
  820.                Objects.equals(_svgDocument,        rhs._svgDocument)  &&
  821.                Objects.equals(_fitComponent,       rhs._fitComponent) &&
  822.                Objects.equals(_preferredPlacement, rhs._preferredPlacement);
  823.     }

  825.     @Override
  826.     public String toString() {
  827.         int width  = _size.width().map(Math::round).orElse(NO_SIZE);
  828.         int height = _size.height().map(Math::round).orElse(NO_SIZE);
  829.         String typeName           = getClass().getSimpleName();
  830.         String widthAsStr              = width  < 0 ? "?" : String.valueOf(width);
  831.         String heightAsStr             = height < 0 ? "?" : String.valueOf(height);
  832.         String fitComponent       = _fitComponent.toString();
  833.         String preferredPlacement = _preferredPlacement.toString();
  834.         String svgDocument        = Optional.ofNullable(_svgDocument)
  835.                                             .map(it -> {
  836.                                                 String docClass = it.getClass().getSimpleName();
  837.                                                 FloatSize size = it.size();
  838.                                                 return docClass + "[width=" + size.width + ", height=" + size.height + "]";
  839.                                             })
  840.                                             .orElse("?");
  841.         return typeName + "[" +
  842.                     "width=" + widthAsStr + ", " +
  843.                     "height=" + heightAsStr + ", " +
  844.                     "fitComponent=" + fitComponent + ", " +
  845.                     "preferredPlacement=" + preferredPlacement + ", " +
  846.                     "doc=" + svgDocument +
  847.                 "]";
  848.     }

  850.     private Size _sizeWithAspectRatioCorrection( Size size ) {
  851.         if ( _svgDocument == null )
  852.             return size;
  853.         if ( size.hasPositiveWidth() && size.hasPositiveHeight() )
  854.             return size;
  855.         if ( size.equals(Size.unknown()) )
  856.             return size;

  858.         /*
  859.             The client code has only specified one of the dimensions
  860.             and the other dimension is unknown.

  862.             This means they want the icon to have a somewhat fixed size,
  863.             but they want the other dimension to be determined by the
  864.             aspect ratio of the SVG document.

  866.             So we try to calculate the missing dimension here:
  867.         */
  868.         return _aspectRatio().map( aspectRatio -> {
  869.                     // Now the two cases:
  870.                     if ( size.hasPositiveWidth() ) {
  871.                         // The width is known, calculate the height:
  872.                         double width = size.width().map(Number::doubleValue).orElse(1d);
  873.                         return size.withHeight((int) Math.ceil(width / aspectRatio));
  874.                     } else {
  875.                         // The height is known, calculate the width:
  876.                         double height = size.height().map(Number::doubleValue).orElse(1d);
  877.                         return size.withWidth((int) Math.ceil(height * aspectRatio));
  878.                     }
  879.                 })
  880.                 .orElse(size);
  881.     }

  883.     private Optional<Double> _aspectRatio() {
  884.         if ( _svgDocument == null )
  885.             return Optional.empty();

  887.         double aspectRatio1 = 0;
  888.         double aspectRatio2 = 0;

  890.         ViewBox viewBox = _svgDocument.viewBox();
  891.         if ( viewBox.width > 0 && viewBox.height > 0 )
  892.             aspectRatio1 = viewBox.width / viewBox.height;

  894.         FloatSize svgSize = _svgDocument.size();
  895.         if ( svgSize.width > 0 && svgSize.height > 0 )
  896.             aspectRatio2 = svgSize.width / svgSize.height;

  898.         // We prefer the "svgSize" aspect ratio over the "viewBox" aspect ratio:
  899.         double aspectRatio = aspectRatio2 > 0 ? aspectRatio2 : aspectRatio1;

  901.         if ( aspectRatio == 0 )
  902.             return Optional.empty();
  903.         else
  904.             return Optional.of(aspectRatio);
  905.     }

  907. }
Created with JaCoCo 0.8.11.202310140853