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
SlidereRangeSlider, 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:
Uma trilha sobre a qual os thumbs deslizam.
Marcas de escala na trilha quando o
RangeSlideré discreto.2 thumbs (ou knobs) que indicam os valores mínimo e máximo do intervalo.
-
Indicadores de valor que mostram os rótulos dos valores dos thumbs quando os rótulos são definidos e o
showValueIndicatorcorresponde ao tipo do slider. 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.
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
onStartou tocaronTapDown→_startInteractionArrastar
onUpdate→_handleDragUpdate-
Arrastar
onEndouonCancele tocaronEndouonCancel→_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:
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:
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:
theme: ThemeData(
sliderTheme: SliderThemeData(
thumbSelector: _customRangeThumbSelector,
),
// ...
),
Ou ele pode ser definido em uma instância específica do slider usando o SliderTheme:
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:

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:
Trilha
Overlays
Marcas de escala (se discreto)
Indicadores de valor (se visíveis)
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:
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:
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.