Groupes de boutons

Les groupes de boutons organisent les boutons et ajoutent des interactions entre eux en appliquant des modifications coordonnées de forme, de mouvement et de largeur aux boutons et aux boutons d'icône. Il existe deux variantes de groupes de boutons :

  1. Groupe de boutons standards : ajoute une interaction entre les boutons adjacents afin qu'ils réagissent les uns aux autres lorsqu'ils sont enfoncés.
  2. Groupe de boutons connectés : regroupe les boutons d'activation pour permettre aux utilisateurs de sélectionner des options, de changer de vue ou de trier des éléments sur une page.
Groupes de boutons standards à gauche et groupes de boutons connectés à droite.
Figure 1. Groupes de boutons standards (1, à gauche) et groupes de boutons connectés (2, à droite).

Utiliser des groupes de boutons

  • Applique une transformation de forme lorsque l'utilisateur appuie sur des boutons ou les sélectionne.
  • Les groupes de boutons connectés remplacent les boutons segmentés.
  • Fonctionne avec toutes les tailles de boutons : très petit (XS), petit (S), moyen (M), grand (L) et très grand (XL).
  • Compatible avec les modèles à sélection unique, à sélection multiple et à sélection obligatoire.
Groupes de boutons contenant des boutons de différentes formes et tailles.
Figure 2. Groupes de boutons contenant des boutons de différentes formes et tailles.

Groupe de boutons standards

Utilisez le composable ButtonGroup pour placer des boutons dans une séquence horizontale qui développe l'élément sélectionné, compresse les éléments voisins et déplace les éléments supplémentaires dans un menu à développer lorsque l'espace est limité. Les groupes de boutons doivent rester sur une seule ligne plutôt que de passer à la ligne suivante.

L'extrait de code suivant montre comment implémenter un groupe de boutons standards avec un indicateur de menu à développer :

@Composable
fun ButtonGroupSample() {
    val numButtons = 10
    ButtonGroup(
        overflowIndicator = { menuState ->
            ButtonGroupDefaults.OverflowIndicator(menuState = menuState)
        }
    ) {
        for (i in 0 until numButtons) {
            clickableItem(onClick = {}, label = "$i")
        }
    }
}

Groupe de boutons connectés

Utilisez des groupes de boutons connectés pour les modèles à sélection unique ou multiple créés avec des composables ToggleButton et des formes connectées ButtonGroupDefaults.

Comportement du groupe de boutons connectés.
Figure 3. Comportement du groupe de boutons connectés responsifs.

Sélection individuelle

Utilisez un groupe de boutons connectés à sélection unique lorsque l'utilisateur choisit une option parmi un ensemble d'options mutuellement exclusives. L'extrait de code suivant implémente un groupe de boutons connectés à sélection unique à l'aide de ToggleButton et Role.RadioButton :

@Composable
fun SingleSelectConnectedButtonGroupSample() {
    val options = listOf("Work", "Restaurant", "Coffee", "Search", "Home")
    val unCheckedIcons =
        listOf(
            AppIcons.Work,
            AppIcons.Restaurant,
            AppIcons.Coffee,
            AppIcons.Search,
            AppIcons.Home,
        )
    val checkedIcons =
        listOf(
            AppIcons.WorkFilled,
            AppIcons.Restaurant,
            AppIcons.CoffeeFilled,
            AppIcons.Search,
            AppIcons.HomeFilled,
        )
    var selectedIndex by remember { mutableIntStateOf(0) }

    FlexBox(
        modifier = Modifier.padding(horizontal = 8.dp).fillMaxWidth(),
        config = {
            direction(FlexDirection.Row)
            wrap(FlexWrap.Wrap)
            columnGap(ButtonGroupDefaults.ConnectedSpaceBetween)
            rowGap(2.dp)
        },
    ) {
        options.forEachIndexed { index, label ->
            ToggleButton(
                checked = selectedIndex == index,
                onCheckedChange = { selectedIndex = index },
                shapes =
                    when (index) {
                        0 -> ButtonGroupDefaults.connectedLeadingButtonShapes()
                        options.lastIndex -> ButtonGroupDefaults.connectedTrailingButtonShapes()
                        else -> ButtonGroupDefaults.connectedMiddleButtonShapes()
                    },
                modifier = Modifier.semantics { role = Role.RadioButton },
            ) {
                Icon(
                    painter =
                        rememberVectorPainter(
                            if (selectedIndex == index) checkedIcons[index] else unCheckedIcons[index]
                        ),
                    contentDescription = null,
                )
                Spacer(Modifier.size(ToggleButtonDefaults.IconSpacing))
                Text(label)
            }
        }
    }
}

Sélection multiple

Utilisez un groupe de boutons connectés à sélection multiple lorsque l'utilisateur peut activer ou désactiver zéro ou plusieurs options indépendamment. L'extrait de code suivant implémente un groupe de boutons connectés à sélection multiple à l'aide de ToggleButton et mutableStateListOf :

@Composable
fun MultiSelectConnectedButtonGroupSample() {
    val options = listOf("Work", "Restaurant", "Coffee", "Search", "Home")
    val unCheckedIcons =
        listOf(
            AppIcons.Work,
            AppIcons.Restaurant,
            AppIcons.Coffee,
            AppIcons.Search,
            AppIcons.Home,
        )
    val checkedIcons =
        listOf(
            AppIcons.WorkFilled,
            AppIcons.Restaurant,
            AppIcons.CoffeeFilled,
            AppIcons.Search,
            AppIcons.HomeFilled,
        )
    val checked = remember { mutableStateListOf(false, false, false, false, false) }

    FlexBox(
        modifier = Modifier.padding(horizontal = 8.dp).fillMaxWidth(),
        config = {
            direction(FlexDirection.Row)
            wrap(FlexWrap.Wrap)
            columnGap(ButtonGroupDefaults.ConnectedSpaceBetween)
            rowGap(2.dp)
        },
    ) {
        options.forEachIndexed { index, label ->
            ToggleButton(
                checked = checked[index],
                onCheckedChange = { checked[index] = it },
                shapes =
                    when (index) {
                        0 -> ButtonGroupDefaults.connectedLeadingButtonShapes()
                        options.lastIndex -> ButtonGroupDefaults.connectedTrailingButtonShapes()
                        else -> ButtonGroupDefaults.connectedMiddleButtonShapes()
                    },
            ) {
                Icon(
                    painter =
                        rememberVectorPainter(
                            if (checked[index]) checkedIcons[index] else unCheckedIcons[index]
                        ),
                    contentDescription = null,
                )
                Spacer(Modifier.size(ToggleButtonDefaults.IconSpacing))
                Text(label)
            }
        }
    }
}