StyleConf.java

  1. package swingtree.style;

  3. import com.google.errorprone.annotations.Immutable;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import swingtree.UI;
  7. import swingtree.api.Configurator;
  8. import swingtree.api.Painter;

  10. import java.awt.*;
  11. import java.util.List;
  12. import java.util.*;
  13. import java.util.stream.Collectors;

  15. /**
  16.  *  An immutable config container with cloning based update methods designed
  17.  *  for functional {@link javax.swing.JComponent} styling.
  18.  *  The styling in SwingTree is completely functional, meaning that changing a property
  19.  *  of a {@link StyleConf} instance will always return a new {@link StyleConf} instance with the
  20.  *  updated property.
  21.  *  <p>
  22.  *  Consider the following example demonstrating how a {@link javax.swing.JPanel} is styled through the SwingTree
  23.  *  style API, which consists of a functional {@link swingtree.api.Styler} lambda that processes a
  24.  *  {@link ComponentStyleDelegate} instance that internally assembles a {@link StyleConf} object:
  25.  *  <pre>{@code
  26.  *  panel(FILL)
  27.  *  .withStyle( it -> it
  28.  *      .foundationColor(new Color(26,191,230))
  29.  *      .backgroundColor(new Color(255,255,255))
  30.  *      .paddingTop(30)
  31.  *      .paddingLeft(35)
  32.  *      .paddingRight(35)
  33.  *      .paddingBottom(30)
  34.  *      .borderRadius(25, 25)
  35.  *      .borderWidth(3)
  36.  *      .borderColor(new Color(0,102,255))
  37.  *      .shadowColor(new Color(64,64,64))
  38.  *      .shadowBlurRadius(6)
  39.  *      .shadowSpreadRadius(5)
  40.  *      .shadowInset(false)
  41.  *  )
  42.  *  }</pre>
  43.  *
  44.  *  This design is inspired by the CSS styling language and the use of immutable objects
  45.  *  is a key feature of the SwingTree API which makes it possible to safely compose
  46.  *  {@link swingtree.api.Styler} lambdas into a complex style pipeline
  47.  *  without having to worry about side effects.
  48.  *  See {@link swingtree.style.StyleSheet} for more information about
  49.  *  how this composition of styles is achieved in practice.
  50.  */
  51. @Immutable
  52. @SuppressWarnings("ReferenceEquality")
  53. public final class StyleConf
  54. {
  55.     private static final StyleConf _NONE = new StyleConf(
  56.                                             LayoutConf.none(),
  57.                                             BorderConf.none(),
  58.                                             BaseConf.none(),
  59.                                             FontConf.none(),
  60.                                             DimensionalityConf.none(),
  61.                                             StyleConfLayers.empty(),
  62.                                             NamedConfigs.empty()
  63.                                         );
  64.     private static final Logger log = LoggerFactory.getLogger(StyleConf.class);

  66.     /**
  67.      *  Exposes the "null object" pattern for {@link StyleConf} instances.
  68.      *  So the constant returned by this method is the default instance
  69.      *  that represents the absence of a style.
  70.      *
  71.      * @return The default style instance, representing the absence of a style.
  72.      */
  73.     public static StyleConf none() { return _NONE; }

  75.     static StyleConf of(
  76.         LayoutConf layout,
  77.         BorderConf border,
  78.         BaseConf base,
  79.         FontConf font,
  80.         DimensionalityConf dimensionality,
  81.         StyleConfLayers layers,
  82.         NamedConfigs<String> properties
  83.     ) {
  84.         if (
  85.             layout         == _NONE._layout &&
  86.             border         == _NONE._border &&
  87.             base           == _NONE._base &&
  88.             font           == _NONE._font &&
  89.             dimensionality == _NONE._dimensionality &&
  90.             layers         == _NONE._layers &&
  91.             properties     == _NONE._properties
  92.         )
  93.             return _NONE;
  94.         else
  95.             return new StyleConf(layout, border, base, font, dimensionality, layers, properties);
  96.     }


  99.     private final LayoutConf           _layout;
  100.     private final BorderConf           _border;
  101.     private final BaseConf             _base;
  102.     private final FontConf             _font;
  103.     private final DimensionalityConf   _dimensionality;
  104.     private final StyleConfLayers      _layers;
  105.     private final NamedConfigs<String> _properties;


  108.     private StyleConf(
  109.         LayoutConf           layout,
  110.         BorderConf           border,
  111.         BaseConf             base,
  112.         FontConf             font,
  113.         DimensionalityConf   dimensionality,
  114.         StyleConfLayers      layers,
  115.         NamedConfigs<String> properties
  116.     ) {
  117.         _layout         = Objects.requireNonNull(layout);
  118.         _border         = Objects.requireNonNull(border);
  119.         _base           = Objects.requireNonNull(base);
  120.         _font           = Objects.requireNonNull(font);
  121.         _dimensionality = Objects.requireNonNull(dimensionality);
  122.         _layers         = Objects.requireNonNull(layers);
  123.         _properties     = Objects.requireNonNull(properties);
  124.     }

  126.     public Optional<Object> layoutConstraint() { return _layout.constraint(); }

  128.     public LayoutConf layout() { return _layout; }

  130.     Outline padding() { return _border.padding(); }

  132.     Outline margin() { return _border.margin(); }

  134.     BorderConf border() { return _border; }

  136.     BaseConf base() { return _base; }

  138.     DimensionalityConf dimensionality() { return _dimensionality; }

  140.     StyleConfLayers layers() { return _layers; }

  142.     StyleConfLayer layer(UI.Layer layer ) { return _layers.get(layer); }

  144.     /**
  145.      *  Exposes the default shadow style configuration object.
  146.      * @return The default shadow style.
  147.      */
  148.     public ShadowConf shadow() {
  149.         ShadowConf found =
  150.                         _layers.get(ShadowConf.DEFAULT_LAYER)
  151.                         .shadows()
  152.                         .get(StyleUtil.DEFAULT_KEY);

  154.         return found != null ? found : ShadowConf.none();
  155.     }

  157.     /**
  158.      *  Internally, a style configuration consists of a set of layers defined by the {@link UI.Layer} enum.
  159.      *  Using this method you can retrieve all shadow styles for a particular layer
  160.      *  and with the provided name.
  161.      *
  162.      * @param layer The layer to retrieve the shadow style from.
  163.      * @param shadowName The name of the shadow style to retrieve.
  164.      * @return The shadow style with the provided name.
  165.      */
  166.     public ShadowConf shadow( UI.Layer layer, String shadowName ) {
  167.         Objects.requireNonNull(shadowName);
  168.         StyleConfLayer layerConf = _layers.get(layer);
  169.         NamedConfigs<ShadowConf> shadows = layerConf.shadows();
  170.         ShadowConf found = shadows.get(shadowName);
  171.         return found != null ? found : ShadowConf.none();
  172.     }

  174.     /**
  175.      *  Internally, a style configuration consists of a set of layers defined by the {@link UI.Layer} enum.
  176.      *  You can retrieve all shadow styles for a specific layer by calling this method.
  177.      *
  178.      * @return An unmodifiable list of all shadow styles sorted by their names in ascending alphabetical order.
  179.      */
  180.     List<ShadowConf> shadows( UI.Layer layer ) {
  181.         return Collections.unmodifiableList(
  182.                         _layers.get(layer)
  183.                         .shadows()
  184.                         .namedStyles()
  185.                         .stream()
  186.                         .sorted(Comparator.comparing(NamedConf::name))
  187.                         .map(NamedConf::style)
  188.                         .collect(Collectors.toList())
  189.                     );
  190.     }

  192.     NamedConfigs<ShadowConf> shadowsMap(UI.Layer layer) {
  193.         return _layers.get(layer).shadows();
  194.     }

  196.     boolean hasVisibleShadows(UI.Layer layer) {
  197.         return _layers.get(layer)
  198.                 .shadows()
  199.                 .stylesStream()
  200.                 .anyMatch(s -> s.color().isPresent() && s.color().get().getAlpha() > 0 );
  201.     }

  203.     public FontConf font() { return _font; }

  205.     /**
  206.      *  Returns a new {@link StyleConf} instance with the given layout constraint.
  207.      * @return An unmodifiable list of painters sorted by their names in ascending alphabetical order.
  208.      */
  209.     List<PainterConf> painters( UI.Layer layer ) {
  210.         return Collections.unmodifiableList(
  211.                             new ArrayList<>(_layers.get(layer)
  212.                                 .painters()
  213.                                 .sortedByNames()
  214.                             )
  215.                         );
  216.     }

  218.     StyleConf painter(UI.Layer layer, UI.ComponentArea area, String painterName, Painter painter ) {
  219.         Objects.requireNonNull(painterName);
  220.         Objects.requireNonNull(painter);
  221.         // We clone the painter map:
  222.         NamedConfigs<PainterConf> newPainters = _layers.get(layer)
  223.                                                     .painters()
  224.                                                     .withNamedStyle(
  225.                                                         painterName, // Existing painters are overwritten if they have the same name.
  226.                                                         PainterConf.of(painter, area)
  227.                                                     ); 
  228.         return _withPainters(layer, newPainters);
  229.     }

  231.     boolean hasPaintersOnLayer(UI.Layer layer ) {
  232.         return _layers.get(layer).painters().stylesStream().anyMatch(p -> !Painter.none().equals(p.painter()));
  233.     }

  235.     boolean hasImagesOnLayer(UI.Layer layer ) {
  236.         return _layers.get(layer).images().stylesStream().anyMatch(i -> i.image().isPresent() || i.primer().isPresent());
  237.     }

  239.     List<GradientConf> gradients( UI.Layer layer ) {
  240.         return _layers.get(layer).gradients().sortedByNames();
  241.     }

  243.     boolean hasCustomGradients() {
  244.         boolean hasCustomGradients = false;
  245.         for ( UI.Layer layer : UI.Layer.values() ) {
  246.             if ( hasCustomGradients(layer) ) {
  247.                 hasCustomGradients = true;
  248.                 break;
  249.             }
  250.         }
  251.         return hasCustomGradients;
  252.     }

  254.     boolean hasCustomGradients( UI.Layer layer ) {
  255.         NamedConfigs<GradientConf> gradients = _layers.get(layer).gradients();
  256.         return !( gradients.size() == 1 && GradientConf.none().equals(gradients.get(StyleUtil.DEFAULT_KEY)) );
  257.     }

  259.     boolean hasVisibleGradientsOnLayer( UI.Layer layer ) {
  260.         List<GradientConf> gradients = gradients(layer);
  261.         if ( gradients.isEmpty() ) return false;
  262.         return gradients.stream().anyMatch( s -> s.colors().length > 0 );
  263.     }

  265.     List<NoiseConf> noises( UI.Layer layer ) {
  266.         return _layers.get(layer).noises().sortedByNames();
  267.     }

  269.     boolean hasVisibleNoisesOnLayer( UI.Layer layer ) {
  270.         List<NoiseConf> noises = noises(layer);
  271.         if ( noises.isEmpty() ) return false;
  272.         return noises.stream().anyMatch( s -> !s.equals(NoiseConf.none()) );
  273.     }

  275.     List<UI.ComponentArea> gradientCoveredAreas() {
  276.         return gradientCoveredAreas(UI.Layer.values());
  277.     }

  279.     List<UI.ComponentArea> gradientCoveredAreas( UI.Layer... layers ) {
  280.         return Arrays.stream(layers)
  281.                 .map(_layers::get)
  282.                 .map(StyleConfLayer::gradients)
  283.                 .flatMap( g -> g
  284.                     .stylesStream()
  285.                     .map( grad -> grad.isOpaque() ? grad.area() : null )
  286.                     .filter(Objects::nonNull)
  287.                 )
  288.                 .distinct()
  289.                 .collect(Collectors.toList());
  290.     }

  292.     List<UI.ComponentArea> noiseCoveredAreas() {
  293.         return noiseCoveredAreas(UI.Layer.values());
  294.     }

  296.     List<UI.ComponentArea> noiseCoveredAreas( UI.Layer... layers ) {
  297.         return Arrays.stream(layers)
  298.                 .map(_layers::get)
  299.                 .map(StyleConfLayer::noises)
  300.                 .flatMap( n -> n
  301.                     .stylesStream()
  302.                     .map( noise -> noise.isOpaque() ? noise.area() : null )
  303.                     .filter(Objects::nonNull)
  304.                 )
  305.                 .distinct()
  306.                 .collect(Collectors.toList());
  307.     }

  309.     List<UI.ComponentArea> noiseAndGradientCoveredAreas() {
  310.         List<UI.ComponentArea> areas = new ArrayList<>(gradientCoveredAreas());
  311.         areas.addAll(noiseCoveredAreas());
  312.         return areas;
  313.     }

  315.     public StyleConf foundationColor( Color color ) { return _withBase(base().foundationColor(color)); }

  317.     public StyleConf backgroundColor( Color color ) { return _withBase(base().backgroundColor(color)); }

  319.     StyleConf _withLayout( LayoutConf layout ) {
  320.         if ( layout == _layout )
  321.             return this;

  323.         return StyleConf.of(layout, _border, _base, _font, _dimensionality, _layers, _properties);
  324.     }

  326.     StyleConf _withBorder( BorderConf border ) {
  327.         if ( border == _border )
  328.             return this;

  330.         return StyleConf.of(_layout, border, _base, _font, _dimensionality, _layers, _properties);
  331.     }

  333.     StyleConf _withBase( BaseConf background ) {
  334.         if ( background == _base )
  335.             return this;

  337.         return StyleConf.of(_layout, _border, background, _font, _dimensionality, _layers, _properties);
  338.     }

  340.     StyleConf _withFont( FontConf font ) {
  341.         if ( font == _font )
  342.             return this;

  344.         return StyleConf.of(_layout, _border, _base, font, _dimensionality, _layers, _properties);
  345.     }

  347.     StyleConf _withDimensionality( DimensionalityConf dimensionality ) {
  348.         if ( dimensionality == _dimensionality )
  349.             return this;

  351.         return StyleConf.of(_layout, _border, _base, _font, dimensionality, _layers, _properties);
  352.     }

  354.     StyleConf _withShadow( UI.Layer layer, NamedConfigs<ShadowConf> shadows ) {
  355.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, _layers.with(layer, _layers.get(layer).withShadows(shadows)), _properties);
  356.     }

  358.     StyleConf _withProperties( NamedConfigs<String> properties ) {
  359.         if ( properties == _properties )
  360.             return this;

  362.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, _layers, properties);
  363.     }

  365.     StyleConf _withShadow( UI.Layer layer, Configurator<ShadowConf> styler ) {
  366.         // A new map is created where all the styler is applied to all the values:
  367.         NamedConfigs<ShadowConf> styledShadows = _layers.get(layer).shadows().mapStyles(styler);
  368.         return _withShadow(layer, styledShadows);
  369.     }

  371.     StyleConf _withShadow( Configurator<ShadowConf> styler ) {
  372.         return _withLayers(_layers.map( layer -> layer.withShadows(layer.shadows().mapStyles(styler)) ));
  373.     }

  375.     StyleConf _withGradients( UI.Layer layer, NamedConfigs<GradientConf> shades ) {
  376.         Objects.requireNonNull(shades);
  377.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, _layers.with(layer, _layers.get(layer).withGradients(shades)), _properties);
  378.     }

  380.     StyleConf _withNoises( UI.Layer layer, NamedConfigs<NoiseConf> noises ) {
  381.         Objects.requireNonNull(noises);
  382.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, _layers.with(layer, _layers.get(layer).withNoises(noises)), _properties);
  383.     }

  385.     StyleConf _withImages( UI.Layer layer, NamedConfigs<ImageConf> images ) {
  386.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, _layers.with(layer, _layers.get(layer).withImages(images)), _properties);
  387.     }

  389.     StyleConf _withTexts( UI.Layer layer, NamedConfigs<TextConf> texts ) {
  390.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, _layers.with(layer, _layers.get(layer).withTexts(texts)), _properties);
  391.     }

  393.     StyleConf _withLayers( StyleConfLayers layers ) {
  394.         if ( layers == _layers )
  395.             return this;

  397.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, layers, _properties);
  398.     }

  400.     StyleConf _withPainters( UI.Layer layer, NamedConfigs<PainterConf> painters ) {
  401.         Objects.requireNonNull(painters);
  402.         return StyleConf.of(_layout, _border, _base, _font, _dimensionality, _layers.with(layer, _layers.get(layer).withPainters(painters)), _properties);
  403.     }

  405.     StyleConf property( String key, String value ) {
  406.         Objects.requireNonNull(key);
  407.         Objects.requireNonNull(value);
  408.         return _withProperties(_properties.withNamedStyle(key, value));
  409.     }

  411.     List<NamedConf<String>> properties() {
  412.         return _properties.namedStyles()
  413.                             .stream()
  414.                             .sorted(Comparator.comparing(NamedConf::name))
  415.                             .collect(Collectors.toList());
  416.     }

  418.     StyleConf gradient( UI.Layer layer, String shadeName, Configurator<GradientConf> styler ) {
  419.         Objects.requireNonNull(shadeName);
  420.         Objects.requireNonNull(styler);
  421.         GradientConf gradConf = _layers.get(layer).gradients().find(shadeName).orElse(GradientConf.none());
  422.         // We clone the shadow map:
  423.         try {
  424.             gradConf = styler.configure(gradConf);
  425.         } catch (Exception e) {
  426.             log.error("Failed to configure gradient '{}' for layer '{}'", shadeName, layer, e);
  427.         }
  428.         NamedConfigs<GradientConf> newShadows = _layers.get(layer).gradients().withNamedStyle(shadeName, gradConf);
  429.         return _withGradients(layer, newShadows);
  430.     }

  432.     GradientConf gradient( UI.Layer layer, String gradName ) {
  433.         Objects.requireNonNull(gradName);
  434.         StyleConfLayer layerConf = _layers.get(layer);
  435.         NamedConfigs<GradientConf> gradients = layerConf.gradients();
  436.         GradientConf found = gradients.get(gradName);
  437.         return found != null ? found : GradientConf.none();
  438.     }

  440.     StyleConf noise( UI.Layer layer, String noiseName, Configurator<NoiseConf> styler ) {
  441.         Objects.requireNonNull(noiseName);
  442.         Objects.requireNonNull(styler);
  443.         NoiseConf noise = _layers.get(layer).noises().find(noiseName).orElse(NoiseConf.none());
  444.         try {
  445.             noise = styler.configure(noise);
  446.         } catch (Exception e) {
  447.             log.error("Failed to configure noise '{}' for layer '{}'", noiseName, layer, e);
  448.         }
  449.         // We clone the noise map:
  450.         NamedConfigs<NoiseConf> newNoises = _layers.get(layer).noises().withNamedStyle(noiseName, noise);
  451.         return _withNoises(layer, newNoises);
  452.     }

  454.     StyleConf images(UI.Layer layer, String imageName, Configurator<ImageConf> styler ) {
  455.         Objects.requireNonNull(imageName);
  456.         Objects.requireNonNull(styler);
  457.         ImageConf ground = _layers.get(layer).images().find(imageName).orElse(ImageConf.none());
  458.         try {
  459.             ground = styler.configure(ground);
  460.         } catch (Exception e) {
  461.             log.error("Failed to configure image '{}' for layer '{}'", imageName, layer, e);
  462.         }
  463.         // We clone the ground map:
  464.         NamedConfigs<ImageConf> newImages = _layers.get(layer).images().withNamedStyle(imageName, ground);
  465.         return _withImages( layer, newImages );
  466.     }

  468.     List<ImageConf> images( UI.Layer layer ) {
  469.         return _layers.get(layer).images().sortedByNames();
  470.     }

  472.     StyleConf text(UI.Layer layer, String textName, Configurator<TextConf> styler ) {
  473.         Objects.requireNonNull(textName);
  474.         Objects.requireNonNull(styler);
  475.         TextConf text = _layers.get(layer).texts().find(textName).orElse(TextConf.none());
  476.         try {
  477.             text = styler.configure(text);
  478.         } catch (Exception e) {
  479.             log.error("Failed to configure text '{}' for layer '{}'", textName, layer, e);
  480.         }
  481.         // We clone the text map:
  482.         NamedConfigs<TextConf> newTexts = _layers.get(layer).texts().withNamedStyle(textName, text);
  483.         return _withTexts( layer, newTexts );
  484.     }

  486.     StyleConf text( Configurator<TextConf> styler ) {
  487.         return _withLayers(_layers.map( layer -> layer.withTexts(layer.texts().mapStyles(styler)) ));
  488.     }

  490.     List<TextConf> texts( UI.Layer layer ) {
  491.         return _layers.get(layer).texts().sortedByNames();
  492.     }

  494.     StyleConf scale( double scale ) {
  495.         return StyleConf.of(
  496.                     _layout,
  497.                     _border._scale(scale),
  498.                     _base, // Just colors and the cursor
  499.                     _font._scale(scale),
  500.                     _dimensionality._scale(scale),
  501.                     _layers._scale(scale),
  502.                     _properties
  503.                 );
  504.     }

  506.     StyleConf simplified() {
  507.         return _withBase(_base.simplified())
  508.                ._withBorder(_border.simplified())
  509.                ._withDimensionality(_dimensionality.simplified())
  510.                ._withLayers(_layers.simplified());
  511.     }

  513.     StyleConf correctedForRounding() {
  514.         return _withBorder(_border.correctedForRounding());
  515.     }

  517.     boolean hasEqualLayoutAs( StyleConf otherStyle ) {
  518.         return Objects.equals(_layout, otherStyle._layout);
  519.     }

  521.     boolean hasEqualMarginAndPaddingAs( StyleConf otherStyle ) {
  522.         return Objects.equals(_border.margin(), otherStyle._border.margin()) &&
  523.                Objects.equals(_border.padding(), otherStyle._border.padding());
  524.     }

  526.     boolean hasEqualBorderAs( StyleConf otherStyle ) {
  527.         return Objects.equals(_border, otherStyle._border);
  528.     }

  530.     boolean hasEqualBaseAs( StyleConf otherStyle ) {
  531.         return Objects.equals(_base, otherStyle._base);
  532.     }

  534.     boolean hasEqualFontAs( StyleConf otherStyle ) {
  535.         return Objects.equals(_font, otherStyle._font);
  536.     }

  538.     boolean hasEqualDimensionalityAs( StyleConf otherStyle ) {
  539.         return Objects.equals(_dimensionality, otherStyle._dimensionality);
  540.     }

  542.     boolean hasEqualFilterAs( StyleConf otherStyle ) {
  543.         return _layers.filter().equals(otherStyle._layers.filter());
  544.     }

  546.     boolean hasEqualShadowsAs( StyleConf otherStyle ) {
  547.         boolean allLayersAreEqual = true;
  548.         for ( UI.Layer layer : UI.Layer.values() ) {
  549.             if ( !hasEqualShadowsAs(layer, otherStyle) ) {
  550.                 allLayersAreEqual = false;
  551.                 break;
  552.             }
  553.         }
  554.         return allLayersAreEqual;
  555.     }

  557.     boolean hasEqualShadowsAs( UI.Layer layer, StyleConf otherStyle ) {
  558.         StyleConfLayer thisLayer = _layers.get(layer);
  559.         StyleConfLayer otherLayer = otherStyle._layers.get(layer);
  560.         if ( thisLayer == null && otherLayer == null )
  561.             return true;
  562.         if ( thisLayer == null || otherLayer == null )
  563.             return false;
  564.         return thisLayer.hasEqualShadowsAs(otherLayer);
  565.     }

  567.     boolean hasEqualPaintersAs( StyleConf otherStyle ) {
  568.         boolean allLayersAreEqual = true;
  569.         for ( UI.Layer layer : UI.Layer.values() ) {
  570.             if ( !hasEqualPaintersAs(layer, otherStyle) ) {
  571.                 allLayersAreEqual = false;
  572.                 break;
  573.             }
  574.         }
  575.         return allLayersAreEqual;
  576.     }

  578.     boolean hasEqualPaintersAs( UI.Layer layer, StyleConf otherStyle ) {
  579.         StyleConfLayer thisLayer = _layers.get(layer);
  580.         StyleConfLayer otherLayer = otherStyle._layers.get(layer);
  581.         if ( thisLayer == null && otherLayer == null )
  582.             return true;
  583.         if ( thisLayer == null || otherLayer == null )
  584.             return false;
  585.         return thisLayer.hasEqualPaintersAs(otherLayer);
  586.     }

  588.     boolean hasEqualGradientsAs( StyleConf otherStyle ) {
  589.         boolean allLayersAreEqual = true;
  590.         for ( UI.Layer layer : UI.Layer.values() ) {
  591.             if ( !hasEqualGradientsAs(layer, otherStyle) ) {
  592.                 allLayersAreEqual = false;
  593.                 break;
  594.             }
  595.         }
  596.         return allLayersAreEqual;
  597.     }

  599.     boolean hasEqualGradientsAs( UI.Layer layer, StyleConf otherStyle ) {
  600.         StyleConfLayer thisLayer = _layers.get(layer);
  601.         StyleConfLayer otherLayer = otherStyle._layers.get(layer);
  602.         if ( thisLayer == null && otherLayer == null )
  603.             return true;
  604.         if ( thisLayer == null || otherLayer == null )
  605.             return false;
  606.         return thisLayer.hasEqualGradientsAs(otherLayer);
  607.     }

  609.     boolean hasEqualNoisesAs( StyleConf otherStyle ) {
  610.         boolean allLayersAreEqual = true;
  611.         for ( UI.Layer layer : UI.Layer.values() ) {
  612.             if ( !hasEqualNoisesAs(layer, otherStyle) ) {
  613.                 allLayersAreEqual = false;
  614.                 break;
  615.             }
  616.         }
  617.         return allLayersAreEqual;
  618.     }

  620.     boolean hasEqualNoisesAs( UI.Layer layer, StyleConf otherStyle ) {
  621.         StyleConfLayer thisLayer = _layers.get(layer);
  622.         StyleConfLayer otherLayer = otherStyle._layers.get(layer);
  623.         if ( thisLayer == null && otherLayer == null )
  624.             return true;
  625.         if ( thisLayer == null || otherLayer == null )
  626.             return false;
  627.         return thisLayer.hasEqualNoisesAs(otherLayer);
  628.     }

  630.     boolean hasEqualImagesAs(StyleConf otherStyle ) {
  631.         boolean allLayersAreEqual = true;
  632.         for ( UI.Layer layer : UI.Layer.values() ) {
  633.             if ( !hasEqualImagesAs(layer, otherStyle) ) {
  634.                 allLayersAreEqual = false;
  635.                 break;
  636.             }
  637.         }
  638.         return allLayersAreEqual;
  639.     }

  641.     boolean hasEqualImagesAs( UI.Layer layer, StyleConf otherStyle ) {
  642.         StyleConfLayer thisLayer = _layers.get(layer);
  643.         StyleConfLayer otherLayer = otherStyle._layers.get(layer);
  644.         if ( thisLayer == null && otherLayer == null )
  645.             return true;
  646.         if ( thisLayer == null || otherLayer == null )
  647.             return false;
  648.         return thisLayer.hasEqualImagesAs(otherLayer);
  649.     }

  651.     boolean hasEqualTextsAs( StyleConf otherStyle ) {
  652.         boolean allLayersAreEqual = true;
  653.         for ( UI.Layer layer : UI.Layer.values() ) {
  654.             if ( !hasEqualTextsAs(layer, otherStyle) ) {
  655.                 allLayersAreEqual = false;
  656.                 break;
  657.             }
  658.         }
  659.         return allLayersAreEqual;
  660.     }

  662.     boolean hasEqualTextsAs( UI.Layer layer, StyleConf otherStyle ) {
  663.         StyleConfLayer thisLayer = _layers.get(layer);
  664.         StyleConfLayer otherLayer = otherStyle._layers.get(layer);
  665.         if ( thisLayer == null && otherLayer == null )
  666.             return true;
  667.         if ( thisLayer == null || otherLayer == null )
  668.             return false;
  669.         return thisLayer.hasEqualTextsAs(otherLayer);
  670.     }

  672.     boolean hasEqualPropertiesAs( StyleConf otherStyle ) {
  673.         return Objects.equals(_properties, otherStyle._properties);
  674.     }

  676.     @Override
  677.     public int hashCode() {
  678.         return Objects.hash(
  679.                     _layout, _border, _base, _font, _dimensionality, _layers, _properties
  680.                 );
  681.     }

  683.     @Override
  684.     public boolean equals( Object obj ) {
  685.         if ( obj == this ) return true;
  686.         if ( obj == null ) return false;
  687.         if ( !(obj instanceof StyleConf) ) return false;
  688.         StyleConf other = (StyleConf) obj;
  689.         return hasEqualLayoutAs(other)         &&
  690.                hasEqualBorderAs(other)         &&
  691.                hasEqualBaseAs(other)           &&
  692.                hasEqualFontAs(other)           &&
  693.                hasEqualDimensionalityAs(other) &&
  694.                hasEqualFilterAs(other)         &&
  695.                hasEqualShadowsAs(other)        &&
  696.                hasEqualPaintersAs(other)       &&
  697.                hasEqualGradientsAs(other)      &&
  698.                hasEqualNoisesAs(other)         &&
  699.                hasEqualImagesAs(other)         &&
  700.                hasEqualTextsAs(other)          &&
  701.                hasEqualPropertiesAs(other);
  702.     }

  704.     @Override
  705.     public String toString() {
  706.         String propertiesString = _properties.toString(StyleUtil.DEFAULT_KEY, "properties");

  708.         return this.getClass().getSimpleName() + "[" +
  709.                     _layout          + ", " +
  710.                     _border          + ", " +
  711.                     _base            + ", " +
  712.                     _font            + ", " +
  713.                     _dimensionality  + ", " +
  714.                     _layers          + ", " +
  715.                     propertiesString +
  716.                 "]";
  717.     }

  719. }
Created with JaCoCo 0.8.11.202310140853