Solução Parcial

Uma solução é criar sua própria StyleConverterimplementação e citar a lista de cores no CSS. Ao citar a lista de cores, o conversor receberá o valor como uma única string, que poderá ser processada da maneira que você desejar. Infelizmente, uma desvantagem significativa dessa abordagem é que as variáveis ​​(ou seja, as cores pesquisadas) não serão resolvidas e não há como resolvê-las dentro de um conversor de estilo.

Pode haver uma abordagem melhor. Se houver, espero que outra pessoa publique uma resposta.

Exemplo

Este exemplo só é capaz de analisar Color, não qualquer Paint. É por isso que esta é apenas uma "solução parcial", embora deva ser possível modificá-la para analisar gradientes e padrões de imagem de forma semelhante ao seu funcionamento nativo (o que não é necessariamente uma modificação trivial). Em outras palavras, deve ser possível tornar essa abordagem tão flexível quanto propriedades como -fx-background-color, embora sem que nenhuma variável seja resolvida.

Main.java

package com.example;

import java.util.Arrays;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class Main extends Application {

  private static final String STYLESHEET =
      """
      .colors-region {
        -fx-colors: 'red,blue,green';
      }
      """;

  @Override
  public void start(Stage primaryStage) {
    var region = new ColorsRegion();
    region.colorsProperty().subscribe(val -> System.out.println(Arrays.toString(val)));

    var scene = new Scene(region, 500, 300);
    scene.getStylesheets().add("data:text/css," + STYLESHEET);

    primaryStage.setScene(scene);
    primaryStage.show();
  }
}

ColorSequenceConverter.java

package com.example;

import java.util.stream.Stream;
import javafx.css.ParsedValue;
import javafx.css.StyleConverter;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;

public class ColorSequenceConverter extends StyleConverter<String, Color[]> {

  @Override
  public Color[] convert(ParsedValue<String, Color[]> value, Font font) {
    var string = value.getValue();
    return Stream.of(string.split(",")).map(Color::web).toArray(Color[]::new);
  }
}

ColorsRegion.java

package com.example;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javafx.beans.property.ObjectProperty;
import javafx.css.CssMetaData;
import javafx.css.SimpleStyleableObjectProperty;
import javafx.css.StyleableObjectProperty;
import javafx.css.StyleableProperty;
import javafx.geometry.HPos;
import javafx.geometry.VPos;
import javafx.scene.layout.Background;
import javafx.scene.layout.Region;
import javafx.scene.paint.Color;

public class ColorsRegion extends Region {

  public ColorsRegion() {
    getStyleClass().add("colors-region");
  }

  @Override
  protected void layoutChildren() {
    if (getChildren().isEmpty()) return;

    double x = getInsets().getLeft();
    double y = getInsets().getTop();
    double w = getWidth() - getInsets().getRight() - x;
    double h = getHeight() - getInsets().getBottom() - y;

    double ry = y;
    double rh = h / getChildren().size();

    for (var child : getChildren()) {
      layoutInArea(child, x, ry, w, rh, -1, HPos.CENTER, VPos.CENTER);
      ry += rh;
    }
  }

  private void updateRegions() {
    getChildren().clear();

    var colors = getColors();
    if (colors != null) {
      for (var color : colors) {
        var region = new Region();
        region.setBackground(Background.fill(color));
        getChildren().add(region);
      }
    }
  }

  /* **************************************************************************
   *                                                                          *
   * Properties                                                               *
   *                                                                          *
   ****************************************************************************/

  // -- colors property

  private final StyleableObjectProperty<Color[]> colors =
      new SimpleStyleableObjectProperty<>(Css.COLORS, this, "colors") {
        @Override
        protected void invalidated() {
          updateRegions();
        }
      };

  public final void setColors(Color[] colors) {
    this.colors.set(colors);
  }

  public final Color[] getColors() {
    return colors.get();
  }

  public final ObjectProperty<Color[]> colorsProperty() {
    return colors;
  }

  /* **************************************************************************
   *                                                                          *
   * CSS Handling                                                             *
   *                                                                          *
   ****************************************************************************/

  public static List<CssMetaData<?, ?>> getClassCssMetaData() {
    return Css.META_DATA;
  }

  @Override
  public List<CssMetaData<?, ?>> getCssMetaData() {
    return getClassCssMetaData();
  }

  private static class Css {

    private static final CssMetaData<ColorsRegion, Color[]> COLORS =
        new CssMetaData<>("-fx-colors", new ColorSequenceConverter()) {

          @Override
          public boolean isSettable(ColorsRegion styleable) {
            return !styleable.colors.isBound();
          }

          @Override
          public StyleableProperty<Color[]> getStyleableProperty(ColorsRegion styleable) {
            return styleable.colors;
          }
        };

    private static final List<CssMetaData<?, ?>> META_DATA;

    static {
      var regionMetadata = Region.getClassCssMetaData();
      var metadata = new ArrayList<CssMetaData<?, ?>>(regionMetadata.size() + 1);
      metadata.addAll(Region.getClassCssMetaData());
      metadata.add(COLORS);
      META_DATA = Collections.unmodifiableList(metadata);
    }
  }
}

Por que sua tentativa falhou

A StyleConverteré responsável por pegar a ParsedValuee convertê-lo para o tipo usado pela propriedade JavaFX. Mas a ParsedValuerepresenta o valor como já foi analisado pelo analisador CSS. Em outras palavras, o valor já foi analisado em um objeto intermediário. Além disso, a ParsedValuepode ter seu próprio StyleConverterconversor associado a ele. Esse conversor, se não me engano, sempre tem precedência sobre aquele associado ao . de uma propriedade estilizável CssMetaData.

Não é possível personalizar em qual objeto intermediário o valor é analisado e qual conversor, se houver, está associado ao valor analisado. O comportamento é codificado no parser . Examinando o código vinculado, você pode ver o que está dando errado na sua tentativa.

• Sua propriedade CSS, -jfc-default-paint-sequence, não é uma das propriedades especialmente tratadas.

• O valor da sua propriedade não é um número, duração, hash, função ou URL. Também não é uma constante conhecida ou uma variável previamente estabelecida. Isso significa que o valor é tratado como uma simples string/cor possível. No entanto, apenas o primeiro "termo" é considerado neste caso . No seu exemplo, o primeiro "termo" é red. Todos os outros "termos" (as outras cores) são ignorados.

• O primeiro "termo" do valor do seu exemplo é red, que pode ser analisado em a Color(especificamente; não em qualquer Painttipo). Portanto, o valor é analisado em a Colore retornado encapsulado em um único ParsedValue<Color, Color> . Isso ParsedValuenão tem StyleConverter.

• O PaintConverter.SequenceConverterespera um ParsedValue<ParsedValue<?, Paint>[], Paint[]>. Então, a ClassCastExceptionocorre ao tentar obter o valor de ParsedValueporque ele espera um , ParsedValue<?, Paint>[]mas em vez disso obtém um Color.

Como esse comportamento é fixo no código, infelizmente você não pode alterá-lo. Nesse caso, não faria muita diferença se o analisador manipulasse matrizes de tintas, mas isso não acontece (curiosamente, o analisador manipula matrizes de números para tamanhos).

Agora, se o valor não puder ser analisado em a Color, você obterá a ParsedValue<String, String>sem StyleConverter. É disso que a "solução parcial" acima se aproveita. Ao colocar o valor entre aspas, o analisador CSS trata tudo como um único "termo". Esse "termo" não pode ser analisado em uma cor. Isso faz com que os metadados CSS StyleConvertertenham basicamente controle total sobre como o valor é analisado.