decodeGradient static method

Gradient? decodeGradient(dynamic value, { bool validate = true, })

Decodes the given value into a Gradient. If the value is null then null will be returned.

When the value is not null, this expects a type attribute of one of the following values:

• linear
• radial
• sweep

The expected JSON will depend on the specified type and are each described below:

Type: linear

{
  "begin": "<Alignment>",
  "colors": "<Color[]>",
  "end": "<Alignment>",
  "stops": "<double[]>",
  "tileMode": "<TileMode>",
  "transform": "<GradientTransform>",
  "type": "linear"
}

Type: radial

{
  "center": "<Alignment>",
  "colors": "<Color[]>",
  "focal": "<Alignment>",
  "focalRadius": "<double>",
  "radius": "<double>",
  "stops": "<double[]>",
  "tileMode": "<TileMode>",
  "transform": "<GradientTransform>",
  "type": "radial"
}

Type: sweep

{
  "center": "<Alignment>",
  "colors": "<Color[]>",
  "endAngle": "<double>",
  "startAngle": "<double>",
  "stops": "<double[]>",
  "tileMode": "<TileMode>",
  "transform": "<GradientTransform>",
  "type": "sweep"
}

See also:

• decodeAlignment
• decodeGradientTransform
• decodeTileMode

Implementation

static Gradient? decodeGradient(
  dynamic value, {
  bool validate = true,
}) {
  Gradient? result;
  if (value is Gradient) {
    result = value;
  } else {
    assert(value == null || value['type'] is String);
    _checkSupported(
      'Gradient',
      [
        'linear',
        'radial',
        'sweep',
      ],
      value == null ? null : value['type'],
    );

    if (value != null) {
      assert(SchemaValidator.validate(
        schemaId: '$_baseSchemaUrl/gradient',
        value: value,
        validate: validate,
      ));
      final type = value['type'];

      switch (type) {
        case 'linear':
          result = LinearGradient(
            begin: decodeAlignment(
                  value['begin'],
                  validate: false,
                ) ??
                Alignment.centerLeft,
            colors: _decodeStringList<Color>(
              value['colors'],
              (value) {
                final color = decodeColor(
                  value,
                  validate: false,
                );

                return color!;
              },
            )!,
            end: decodeAlignment(
                  value['end'],
                  validate: false,
                ) ??
                Alignment.centerRight,
            stops: _decodeDynamicList<double>(
              value['stops'],
              (value) => JsonClass.maybeParseDouble(value)!,
            ),
            tileMode: decodeTileMode(
                  value['tileMode'],
                  validate: false,
                ) ??
                TileMode.clamp,
            transform: decodeGradientTransform(
              value['transform'],
              validate: false,
            ),
          );
          break;
        case 'radial':
          result = RadialGradient(
            center: decodeAlignment(
                  value['center'],
                  validate: false,
                ) ??
                Alignment.center,
            colors: _decodeStringList<Color>(
              value['colors'],
              (value) => decodeColor(
                value,
                validate: false,
              )!,
            )!,
            focal: decodeAlignment(
              value['focal'],
              validate: false,
            ),
            focalRadius:
                JsonClass.maybeParseDouble(value['focalRadius'], 0.0)!,
            radius: JsonClass.maybeParseDouble(value['radius'], 0.5)!,
            stops: _decodeDynamicList<double>(
              value['stops'],
              (value) => JsonClass.maybeParseDouble(value)!,
            ),
            tileMode: decodeTileMode(
                  value['tileMode'],
                  validate: false,
                ) ??
                TileMode.clamp,
            transform: decodeGradientTransform(
              value['transform'],
              validate: false,
            ),
          );
          break;
        case 'sweep':
          result = SweepGradient(
            center: decodeAlignment(
                  value['center'],
                  validate: false,
                ) ??
                Alignment.center,
            colors: _decodeStringList<Color>(
              value['colors'],
              (value) => decodeColor(
                value,
                validate: false,
              )!,
            )!,
            endAngle: JsonClass.maybeParseDouble(
              value['endAngle'],
              math.pi * 2,
            )!,
            startAngle: JsonClass.maybeParseDouble(
              value['startAngle'],
              0.0,
            )!,
            stops: _decodeDynamicList<double>(
              value['stops'],
              (value) => JsonClass.maybeParseDouble(value)!,
            ),
            tileMode: decodeTileMode(
                  value['tileMode'],
                  validate: false,
                ) ??
                TileMode.clamp,
            transform: decodeGradientTransform(
              value['transform'],
              validate: false,
            ),
          );
          break;
      }
    }
  }

  return result;
}