[FIXED] is it possible to make a percentage of a linear gradient in javafx?

Issue

Consider the following linear gradient, 'A'. Normally, if you specify that brush as the background of a rectangle, it fills the entire area with the entire gradient, regardless of the size. (See 'B').

We're trying to say 'For this particular control, only utilize the first xx% of the brush for the fill' so we can achieve a percentage-based gradient fill, like in 'C'.

Solution

There are many ways to solve this problem. I present three example solutions:

1. Using a fixed width gradient. <- this is what I recommend.
2. Using a clip.
3. Using an interpolator.

All presented solutions take a simplistic approach of a constant size. If you wanted a dynamic size, you could implement that with appropriate listeners or bindings on the underlying rectangle width and height to update relevant clip or gradient settings.

Using a fixed width gradient

The gradient is defined in fixed co-ordinates rather than proportional co-ordinates (the stops are still proportional). The rectangle itself has a width which is a percentage of the overall width, and the linear gradient is defined for the entire width. Any portion of the gradient which does not fit on the rectangle is simply not displayed, giving the desired result.

LinearGradient gradient = new LinearGradient(
        0, 0, W, 0,
        false,
        CycleMethod.NO_CYCLE,
        new Stop(0, Color.LAWNGREEN),
        new Stop(.5, Color.YELLOW),
        new Stop(1, Color.ORANGERED)
);

return new Rectangle(W * visiblePortion, H, gradient);

Using a clip

Here, we apply a clip to a rectangle that has a gradient, so only a portion of the rectangle is visible.

Rectangle rect = new Rectangle(W, H);
rect.setStyle("-fx-fill: linear-gradient(to right, lawngreen, yellow, orangered);");

Rectangle clip = new Rectangle(W * visiblePortion, H);
rect.setClip(clip);

The example defines the gradient using css, but you could define it in Java code using the LinearGradient API if you prefer.

Using an interpolator

If you want to do a proportional gradient without the clip in the required style, you need to adjust the colors and stops used in the gradient to match the desired percentage display (using an algorithm you create for the calculation).

It is simple enough for a two-color smooth gradient, a general solution is difficult because gradient definitions with multiple stops get complicated. I only provide a solution for a two-color smooth gradient here.

The implementation uses the Color.interpolate() function (as Color implements Interpolatable) to calculate the stop colors for the gradients.

The image looks different from the clip based solution, as the clip based solution used a more complex 3 stop gradient, and this solution just uses a simple two color gradient.

The key to this implementation is the gradient definition using the interpolator:

LinearGradient gradient = new LinearGradient(
        0, 0, 1, 0,
        true,
        CycleMethod.NO_CYCLE,
        new Stop(0, Color.GREEN),
        new Stop(1, Color.GREEN.interpolate(Color.RED, visiblePortion))
);
return new Rectangle(W * visiblePortion, H, gradient);

Using a progress bar

The images look a lot like a progress bar. If appropriate you could investigate styling a progress bar. I won't provide a solution for a gradient styled progress bar here. If that is what you want, ask a new question specifically about that.

Sample Application

import javafx.application.Application;
import javafx.geometry.*;
import javafx.geometry.Insets;
import javafx.scene.*;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.scene.paint.*;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

import java.util.function.Function;

public class GradientDemo extends Application {
    private static final double W = 500;
    private static final double H = 10;
    private static final double STEP = 0.2;

    @Override
    public void start(Stage stage) {
        final VBox layout = new VBox(10);
        layout.setAlignment(Pos.TOP_LEFT);
        layout.setPadding(new Insets(10));

        addGradients(layout, "fixedWidthTriColorGradient", this::fixedWidthTriColorGradient);
        addGradients(layout, "clippedTriColorGradient", this::clippedTriColorGradient);
        addGradients(layout, "interpolatedTwoColorGradient", this::interpolatedTwoColorGradient);

        stage.setScene(new Scene(layout));
        stage.show();
    }

    private void addGradients(
            VBox layout,
            String gradientName,
            Function<Double, Node> gradientFactory
    ) {
        Label label = new Label(gradientName);
        label.setPadding(new Insets(5, 0, 0, 0));
        layout.getChildren().addAll(
                label
        );
        for (double f = STEP; f <= 1.0; f += STEP) {
            layout.getChildren().addAll(gradientFactory.apply(f));
        }
    }

    public Rectangle fixedWidthTriColorGradient(double visiblePortion) {
        LinearGradient gradient = new LinearGradient(
                0, 0, W, 0,
                false,
                CycleMethod.NO_CYCLE,
                new Stop(0, Color.LAWNGREEN),
                new Stop(.5, Color.YELLOW),
                new Stop(1, Color.ORANGERED)
        );

        return new Rectangle(W * visiblePortion, H, gradient);
    }

    public Rectangle clippedTriColorGradient(double visiblePortion) {
        Rectangle rect = new Rectangle(W, H);
        rect.setStyle("-fx-fill: linear-gradient(to right, lawngreen, yellow, orangered);");

        Rectangle clip = new Rectangle(W * visiblePortion, H);
        rect.setClip(clip);

        return rect;
    }

    public Rectangle interpolatedTwoColorGradient(double visiblePortion) {
        LinearGradient gradient = new LinearGradient(
                0, 0, 1, 0,
                true,
                CycleMethod.NO_CYCLE,
                new Stop(0, Color.GREEN),
                new Stop(1, Color.GREEN.interpolate(Color.RED, visiblePortion))
        );

        return new Rectangle(W * visiblePortion, H, gradient);
    }

    public static void main(String[] args) {
        launch(args);
    }
}

Answered By - jewelsea