Material Range Slider no Flutter

O que é? Por que você usaria? Como aplicar o tema?

Material RangeSlider no Flutter

O range slider, um componente altamente personalizável para selecionar um intervalo de valores, foi lançado no Flutter 1.7. Este artigo explica o que é um range slider, por que você pode usá-lo e como usar o Material Theming para personalizar o comportamento e a aparência do Flutter RangeSlider.e

Nota: para saber sobre as atualizações dos widgets Slider e RangeSlider, veja O que há de novo no widget Slider?

Por que Range Slider?

Um componente de slider pode oferecer uma seleção única ou múltipla, em uma trilha discreta ou contínua. Diferente dos sliders de seleção única, que predefinem um valor mínimo ou máximo e permitem ajustar a seleção em apenas uma direção, os range sliders têm dois pontos de seleção que permitem um ajuste flexível dos valores mínimo e máximo. Essa flexibilidade torna o componente útil quando o usuário quer controlar um intervalo específico, como ao indicar faixas de preço ou um período de tempo.

Estrutura e implementação

O RangeSlider é composto por 5 partes:

  1. Uma trilha sobre a qual os thumbs deslizam.

  2. Marcas de escala na trilha quando o RangeSlider é discreto.

  3. 2 thumbs (ou knobs) que indicam os valores mínimo e máximo do intervalo.

  4. Indicadores de valor que mostram os rótulos dos valores dos thumbs quando os rótulos são definidos e o showValueIndicator corresponde ao tipo do slider.

  5. Overlays que aparecem sobre os thumbs quando são pressionados.

Precisávamos que o RangeSlider tivesse animações ricas. Isso inclui as animações disparadas pela interação, para as posições do thumb, além das animações internas do overlay e dos indicadores de valor. No Flutter, fazemos isso transformando o componente RangeSlider em um StatefulWidget, que armazena os controladores de animação como estado.

Os valores reais do range slider são armazenados como estado no widget pai. Os valores são atualizados chamando setState() dentro do callback onChange() do RangeSlider. Em outras palavras, para ter um range slider interativo, o próprio widget RangeSlider precisa ser criado dentro de um StatefulWidget.

dart
RangeValues _values = RangeValues(0.3, 0.7);
​
RangeSlider(
  values: _values,
  onChanged: (RangeValues values) {
    setState(() {
      _values = values;
    });
  },
);

O objeto State do RangeSlider constrói um LeafRenderObjectWidget. Tudo é pintado no seu RenderBox interno, que também trata a entrada de toque.

Tratando a entrada de toque

Se você tem curiosidade sobre como o RangeSlider implementa a entrada de toque, continue lendo! Um aspecto interessante do RangeSlider é que ele é um dos únicos widgets prontos para uso do Flutter que utiliza um GestureArenaTeam. A próxima seção mostra como personalizar a entrada de toque.

Se você não tem interesse em espiar por baixo do capô, pode pular esta seção à vontade.

Para garantir que o RangeSlider consiga lidar com toques e arrastes e funcionar corretamente dentro de scroll views, tab bar views e outros widgets que tratam gestos, um GestureArenaTeam é usado. Um GestureArenaTeam permite que um gesto dentro de um grupo de gestos seja escolhido corretamente ao “vencer”.

Primeiro, o reconhecedor de arraste é adicionado ao time, seguido pelo reconhecedor de toque. Não há capitão do time, então o reconhecedor de arraste vence, já que foi o primeiro adicionado ao time, assim que quaisquer outros reconhecedores saírem da arena. Por outro lado, se o toque puder vencer diretamente, como quando o slider está dentro de uma lista com rolagem vertical e o usuário toca e levanta o dedo imediatamente, então o reconhecedor de toque vence.

Os eventos de toque e arraste resultam em uma de 3 interações possíveis:

  • Arrastar onStart ou tocar onTapDown →_startInteraction

  • Arrastar onUpdate →_handleDragUpdate

  • Arrastar onEnd ou onCancel e tocar onEnd ou onCancel → _endInteraction

No início da interação, uma das primeiras coisas a determinar é qual thumb deve ser selecionado para mover. O RangeSlider faz isso usando uma função temável que recebe propriedades como o valor do toque e o deslocamento do arraste, e retorna uma escolha de thumb: Thumb.start, Thumb.end ou null para nenhuma seleção.

O seletor de thumb padrão primeiro tenta encontrar o thumb mais próximo em _startInteraction. Se um thumb for selecionado, a posição dele é atualizada imediatamente para o valor do toque. Mas se o valor do toque estiver entre os thumbs, porém fora das áreas de toque de ambos, não há seleção. Além disso, se os thumbs estiverem próximos o suficiente e o toque estiver nas duas áreas de toque, nenhum thumb é selecionado. Nesse caso, um thumb só é selecionado quando há um movimento diferente de zero (deslocamento do arraste). Então o thumb da esquerda é selecionado para movimento negativo, e o thumb da direita para movimento positivo. Esse é o único cenário em que a interação de fato começa na primeira etapa _handleDragUpdate. Em ambos os casos, um callback especial, onChangeStart(), emite os valores iniciais dessa interação.

Quando os thumbs estão mais distantes um do outro, tocar na trilha interna não seleciona nenhum thumb:

Quando os thumbs estão mais próximos um do outro, o deslocamento do arraste é usado para determinar a seleção do thumb:

Implementação do seletor de thumb padrão com o comportamento descrito acima:

dart
 static final RangeThumbSelector _defaultRangeThumbSelector = (
      TextDirection textDirection,
      RangeValues values,
      double tapValue,
      Size thumbSize,
      Size trackSize,
      double dx, // drag displacement
    ) {
    final double touchRadius = math.max(thumbSize.width, RangeSlider._minTouchTargetWidth) / 2;
​
    final bool inStartTouchTarget = (tapValue - values.start).abs() * trackSize.width < touchRadius;
​
    final bool inEndTouchTarget = (tapValue - values.end).abs() * trackSize.width < touchRadius;
​
​
    if (inStartTouchTarget && inEndTouchTarget) {
      bool towardsStart;
      bool towardsEnd;
      switch (textDirection) {
        case TextDirection.ltr:
          towardsStart = dx < 0;
          towardsEnd = dx > 0;
          break;
        case TextDirection.rtl:
          towardsStart = dx > 0;
          towardsEnd = dx < 0;
          break;
      }
      if (towardsStart)
        return Thumb.start;
      if (towardsEnd)
        return Thumb.end;
    } else {
      if (tapValue < values.start || inStartTouchTarget)
        return Thumb.start;
      if (tapValue > values.end || inEndTouchTarget)
        return Thumb.end;
    }
    return null;
  };

Depois que um thumb é selecionado, todas as atualizações futuras do arraste são usadas para determinar as novas posições do thumb. A animação do overlay começa no thumb selecionado, e as animações dos indicadores de valor começam nos dois thumbs. À medida que o usuário arrasta o thumb selecionado, o range slider emite um novo conjunto de valores com a posição atualizada, e esses valores são então passados de volta ao range slider para atualizar a posição correspondente.

A última etapa é _endInteraction. Assim que o gesto de toque ou arraste é levantado, as animações do overlay e dos indicadores de valor que foram iniciadas na primeira etapa são revertidas. Um callback especial, onChangeEnd(), também emite os valores finais.

Seleção personalizada de entrada de toque

Na seção anterior, você viu o código do comportamento padrão de seleção de thumb do Material. Mas e se você quiser algo diferente? O código a seguir mostra como escrever um seletor de thumb que sempre seleciona o thumb mais próximo, independentemente da parte da trilha que for tocada.

Implementação de um seletor de thumb personalizado que sempre encontra o thumb mais próximo:

dart
 static final RangeThumbSelector _customRangeThumbSelector = (
    TextDirection textDirection,
    RangeValues values,
    double tapValue,
    Size thumbSize,
    Size trackSize,
    double dx,
  ) {
    final double start = (tapValue - values.start).abs();
    final double end = (tapValue - values.end).abs();
    return start < end ? Thumb.start : Thumb.end;
  };

Depois de ter esse thumb personalizado, você pode defini-lo no tema global do app:

dart
theme: ThemeData(
  sliderTheme: SliderThemeData(
    thumbSelector: _customRangeThumbSelector,
  ),
  // ...
),

Ou ele pode ser definido em uma instância específica do slider usando o SliderTheme:

dart
SliderTheme(
  data: SliderThemeData(
    thumbSelector: _customRangeThumbSelector,
    // ...
  ),
  child: RangeSlider(
    // ...
  ),
),

Controlando as posições permitidas dos thumbs

Acima, você viu como usar o SliderThemeData para personalizar como os thumbs são selecionados. Esta seção mostra como limitar as posições para as quais os thumbs podem ser arrastados ou definidos. Há 2 formas de controlar as posições permitidas dos thumbs. Isso pode ser feito por valor ou por espaço. Controlar por valor pode ser útil, por exemplo, se você tiver um seletor de preço. Digamos que os preços permitidos fiquem entre $0 e $100, mas você queira que o intervalo tenha pelo menos $20 de distância. Assim, o intervalo [$30, $50] seria permitido, mas o intervalo [$33, $34] não. Basta ajustar a função onChanged da seguinte forma:

dart
RangeSlider(
  values: _values,
  min: 0,
  max: 100,
  onChanged: (RangeValues values) {
    setState(() {
      if (values.end - values.start >= 20) {
        _values = values;
      } else {
        if (_values.start == values.start) {
          _values = RangeValues(_values.start, _values.start + 20);
        } else {
          _values = RangeValues(_values.end - 20, _values.end);
        }
      }
    });
  }
);

Se for necessário apenas restringir os thumbs por questão de aparência, a propriedade minThumbSeparation pode ser usada para limitar o número de pixels lógicos que separam os 2 thumbs. O thumb superior padrão desenha um contorno branco ao redor de si para melhor contraste entre os thumbs. Aqui está uma comparação lado a lado mostrando o valor padrão de 8 contra um valor personalizado de 24

Desenhando formas

Além de tratar a entrada de toque, o RenderBox também é responsável por desenhar os RangeSlider. Ele desenha os componentes do RangeSlider nesta ordem:

  1. Trilha

  2. Overlays

  3. Marcas de escala (se discreto)

  4. Indicadores de valor (se visíveis)

  5. Thumbs

Isso pode ser importante saber ao desenhar formas personalizadas. Todas as implementações de forma são abstraídas do método RenderBox.paint() por meio de 5 classes abstratas separadas, o que torna a pintura ou renderização do RangeSlider totalmente personalizável e temável, já que as classes existem no objeto SliderThemeData.

Na próxima seção, mostraremos como substituir as formas padrão por formas personalizadas.

Usando formas personalizadas

Assim como no Slider único, todas as formas que compõem um slider podem ser personalizadas no RangeSlider. Veja este clipe como exemplo de como um Slider do Material foi personalizado.

Isso é feito passando implementações personalizadas das classes de forma abstratas para o SliderThemeData. Isso aproveita a classe RangeSliderThumbShape para fornecer thumbs personalizados com aparências diferentes, dependendo do lado em que estão.

A forma de thumb personalizada para range pode ser implementada assim:

dart
class _CustomRangeThumbShape extends RangeSliderThumbShape {
  static const double _thumbSize = 4.0;
​
  @override
  Size getPreferredSize(bool isEnabled, bool isDiscrete) => _thumbSize;
​
  @override
  void paint(
    PaintingContext context,
    Offset center, {
    @required Animation<double> activationAnimation,
    @required Animation<double> enableAnimation,
    bool isDiscrete = false,
    bool isEnabled = false,
    bool isOnTop,
    @required SliderThemeData sliderTheme,
    TextDirection textDirection,
    Thumb thumb,
  }) {
    final Canvas canvas = context.canvas;
​
    Path thumbPath;
    switch (textDirection) {
      case TextDirection.rtl:
        switch (thumb) {
          case Thumb.start:
            thumbPath = _rightTriangle(_thumbSize, center);
            break;
          case Thumb.end:
            thumbPath = _leftTriangle(_thumbSize, center);
            break;
        }
        break;
      case TextDirection.ltr:
        switch (thumb) {
          case Thumb.start:
            thumbPath = _leftTriangle(_thumbSize, center);
            break;
          case Thumb.end:
            thumbPath = _rightTriangle(_thumbSize, center);
            break;
        }
        break;
    }
    canvas.drawPath(thumbPath, Paint()..color = sliderTheme.thumbColor);
  }
}
​
Path _rightTriangle(double size, Offset thumbCenter, {bool invert = false}) {
  final Path thumbPath = Path();
  final double halfSize = size / 2.0;
  final double sign = invert ? -1.0 : 1.0;
  thumbPath.moveTo(thumbCenter.dx + halfSize * sign, thumbCenter.dy);
  thumbPath.lineTo(thumbCenter.dx - halfSize * sign, thumbCenter.dy - size);
  thumbPath.lineTo(thumbCenter.dx - halfSize * sign, thumbCenter.dy + size);
  thumbPath.close();
  return thumbPath;
}
​
Path _leftTriangle(double size, Offset thumbCenter) => _rightTriangle(size, thumbCenter, invert: true);

Em seguida, a forma de thumb personalizada para range pode ser definida em um SliderThemeData:

dart
SliderTheme(
  data: SliderThemeData(
    rangeThumbShape: _CustomRangeThumbShape(),
    // ...
  ),
  child: RangeSlider(
    // ...
  ),
),

Considerações finais

O range slider do Material é um componente que foi solicitado pela comunidade. Ele funciona pronto para uso e também é personalizável para atender às necessidades do seu app. O comportamento e a aparência visual podem ser alterados no tema, no nível global, ou em cada instância individualmente.

O código completo de todos os trechos incluídos neste artigo, junto com mais exemplos, pode ser encontrado na galeria do Material no GitHub e na biblioteca Material no GitHub.

Agradecimentos especiais a Shams Zakhour, Liam Spradlin, Barbara Eldredge, Cortney Cassidy e Will Larche.

Mais do Flutter