Barre d'outils flottante

La barre d'outils flottante s'affiche au-dessus du contenu du corps. Il est préférable de l'utiliser pour les actions contextuelles pertinentes pour le contenu du corps ou la page spécifique.

Vous pouvez positionner une barre d'outils flottante n'importe où sur l'écran pour qu'elle flotte au-dessus du reste du contenu, ce qui offre un emplacement polyvalent et de l'espace pour plusieurs actions.

Utiliser la barre d'outils flottante

  • Les barres d'outils flottantes affichent les commandes pertinentes pour la page actuelle.
  • Les barres d'outils flottantes peuvent servir de commandes de navigation entre les pages associées d'une hiérarchie de produits.
  • Si d'autres actions sont nécessaires, utilisez un menu à développer.
  • Le conteneur de la barre d'outils flottante doit rester entièrement visible à l'écran.
  • Choisissez les actions les plus importantes à afficher par défaut à l'écran.

Mise en page et couleurs

Les barres d'outils flottantes peuvent être horizontales (HorizontalFloatingToolbar) ou verticales (VerticalFloatingToolbar), et peuvent utiliser des jeux de couleurs standards ou vifs de FloatingToolbarDefaults.

Barre d'outils flottante horizontale du thème clair  Barre d'outils flottante verticale du thème clair 
Figure 1. Barres d'outils flottantes horizontales et verticales

Barre d'outils flottante avec un FAB

Utilisez un bouton d'action flottant (FAB) pour l'action prioritaire dans la vue ou pour compléter les commandes de la barre d'outils.

Barre d'outils flottante horizontale avec thème clair et bouton d'action flottant  Barre d'outils flottante verticale avec thème clair et bouton d'action flottant 
Figure 2. Barres d'outils flottantes avec bouton d'action flottant.

Exemples

Barre d'outils flottante horizontale extensible

Appliquez Modifier.floatingToolbarVerticalNestedScroll à un conteneur à défilement pour que HorizontalFloatingToolbar réduise automatiquement ses actions de début et de fin lorsque l'utilisateur fait défiler l'écran vers le bas, et les développe lorsqu'il fait défiler l'écran vers le haut :

@Composable
fun ExpandableHorizontalFloatingToolbarSample() {
    var expanded by rememberSaveable { mutableStateOf(true) }
    Scaffold { innerPadding ->
        Box(Modifier.padding(innerPadding)) {
            HorizontalFloatingToolbar(
                modifier =
                    Modifier.align(Alignment.BottomCenter)
                        .offset(y = -FloatingToolbarDefaults.ScreenOffset)
                        .zIndex(1f),
                expanded = expanded,
                leadingContent = {
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Edit), contentDescription = "Edit")
                    }
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Favorite), contentDescription = "Favorite")
                    }
                },
                trailingContent = {
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Share), contentDescription = "Share")
                    }
                },
                content = {
                    FilledIconButton(
                        modifier = Modifier.width(64.dp),
                        onClick = { /* doSomething() */ },
                    ) {
                        Icon(painter = rememberVectorPainter(AppIcons.Add), contentDescription = "Add")
                    }
                },
            )
            // ...
        }
    }
}

Barre d'outils flottante verticale extensible

Utilisez VerticalFloatingToolbar ancré sur le côté de l'écran lorsque l'espace de mise en page vertical convient à la hiérarchie de votre écran. Comme la variante horizontale, elle peut être développée et réduite en réponse à des gestes de défilement :

@Composable
fun ExpandableVerticalFloatingToolbarSample() {
    var expanded by rememberSaveable { mutableStateOf(true) }
    Scaffold { innerPadding ->
        Box(Modifier.padding(innerPadding)) {
            VerticalFloatingToolbar(
                modifier =
                    Modifier.align(Alignment.CenterEnd)
                        .offset(x = -FloatingToolbarDefaults.ScreenOffset)
                        .zIndex(1f),
                expanded = expanded,
                leadingContent = {
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Edit), contentDescription = "Edit")
                    }
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Favorite), contentDescription = "Favorite")
                    }
                },
                trailingContent = {
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Share), contentDescription = "Share")
                    }
                },
                content = {
                    FilledIconButton(
                        modifier = Modifier.height(64.dp),
                        onClick = { /* doSomething() */ },
                    ) {
                        Icon(painter = rememberVectorPainter(AppIcons.Add), contentDescription = "Add")
                    }
                },
            )
            // ...
        }
    }
}

Barre d'outils flottante à faire défiler

Pour faire glisser l'intégralité de la barre d'outils flottante hors de l'écran lors du défilement plutôt que de réduire ses éléments, transmettez FloatingToolbarDefaults.exitAlwaysScrollBehavior à Modifier.nestedScroll et au paramètre scrollBehavior de la barre d'outils :

@Composable
fun ScrollableHorizontalFloatingToolbarSample() {
    val exitAlwaysScrollBehavior =
        FloatingToolbarDefaults.exitAlwaysScrollBehavior(
            exitDirection = FloatingToolbarExitDirection.Bottom
        )
    Scaffold(modifier = Modifier.nestedScroll(exitAlwaysScrollBehavior)) { innerPadding ->
        Box(Modifier.padding(innerPadding)) {
            HorizontalFloatingToolbar(
                modifier =
                    Modifier.align(Alignment.BottomCenter)
                        .offset(y = -FloatingToolbarDefaults.ScreenOffset)
                        .zIndex(1f),
                expanded = true,
                leadingContent = {
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Edit), contentDescription = "Edit")
                    }
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Favorite), contentDescription = "Favorite")
                    }
                },
                trailingContent = {
                    IconButton(onClick = { /* doSomething() */ }) {
                        Icon(painter = rememberVectorPainter(AppIcons.Share), contentDescription = "Share")
                    }
                },
                content = {
                    FilledIconButton(
                        modifier = Modifier.width(64.dp),
                        onClick = { /* doSomething() */ },
                    ) {
                        Icon(painter = rememberVectorPainter(AppIcons.Add), contentDescription = "Add")
                    }
                },
                scrollBehavior = exitAlwaysScrollBehavior,
            )
            // ...
        }
    }
}