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,
      ));
      var type = value['type'];

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

                return color!;
              },
            )!,
            end: decodeAlignment(
                  value['end'],
                  validate: false,
                ) ??
                Alignment.centerRight,
            stops: _decodeDynamicList<double>(
              value['stops'],
              (value) => JsonClass.parseDouble(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)!,
            )!,
            focal: decodeAlignment(
              value['focal'],
              validate: false,
            ),
            focalRadius: JsonClass.parseDouble(value['focalRadius'], 0.0)!,
            radius: JsonClass.parseDouble(value['radius'], 0.5)!,
            stops: _decodeDynamicList<double>(
              value['stops'],
              (value) => JsonClass.parseDouble(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)!,
            )!,
            endAngle: JsonClass.parseDouble(
              value['endAngle'],
              math.pi * 2,
            )!,
            startAngle: JsonClass.parseDouble(
              value['startAngle'],
              0.0,
            )!,
            stops: _decodeDynamicList<double>(
              value['stops'],
              (value) => JsonClass.parseDouble(value)!,
            ),
            tileMode: decodeTileMode(
                  value['tileMode'],
                  validate: false,
                ) ??
                TileMode.clamp,
            transform: decodeGradientTransform(
              value['transform'],
              validate: false,
            ),
          );
          break;
      }
    }
  }

  return result;
}