L'intuition
Modifier.a().b().c() se lit comme si on définissait trois propriétés
indépendantes sur un composable, mais ce n'est pas ce qui se passe.
- Chaque modifier englobe tout ce qui vient après lui dans la chaîne.
- L'ordre change ce que chaque modifier perçoit comme son entrée : taille disponible, contenu, zone tactile.
- Les mêmes modifiers dans un ordre différent produisent des pixels et un comportement différents.
L'entrée s'écoule vers le bas de la chaîne : a décide de ce avec quoi
b peut travailler, b décide de ce que c obtient, et ainsi de suite.
Les résultats remontent ensuite : la taille et l'apparence propres de a
dépendent de ce que deviennent finalement b, c et le contenu.
Échangez a et b, et vous échangez qui décide pour qui.
Exemple classique : padding vs background
// padding englobe background : l'espace disponible se réduit d'abord, puis
// background peint dans ce qui reste. Aucun rouge visible dans l'espace du padding.
Modifier.padding(16.dp).background(Color.Red)
// background englobe padding : background peint d'abord la taille complète, puis
// padding ne fait que repousser le contenu vers l'intérieur. Le rouge remplit toute la zone.
Modifier.background(Color.Red).padding(16.dp)Même forme, mêmes deux modifiers, ordre différent, résultat différent, car on ne définit pas des propriétés, on imbrique des wrappers.
Même logique, autres paires
clickable().padding()vspadding().clickable(): le ripple et la zone tactile correspondent à la taille qu'avait le nœud au moment oùclickablea été inséré dans la chaîne. Placezclickableavantpaddinget la zone de padding devient cliquable aussi ; placez-le après et elle ne l'est pas.- L'ordre de dessin suit la même règle : l'ordre des modifiers dans la
chaîne est aussi l'ordre de dessin, c'est pourquoi
.background().padding()et.padding().background()ont un rendu différent, à la fois en disposition et en ordre de peinture.
Où l'ordre n'a pas d'importance
La règle est « l'ordre d'enveloppement change le comportement », pas « l'ordre d'enveloppement change toujours le comportement ». Quelques paires commutent réellement, et il est utile de savoir lesquelles pour ne pas remettre en question un ordre qui n'a jamais été le problème.
clip() + size(). clip() ne déplace ni ne redimensionne rien ;
c'est une pure restriction des limites de dessin sur ce qui est imbriqué
à l'intérieur. L'associer à size() est un cas où l'ordre n'a pas
vraiment d'importance, puisque clip() hérite simplement de la taille qui
se retrouve à l'intérieur dans les deux cas :
// size à l'extérieur, clip à l'intérieur : size impose 100dp à tout ce qui est
// imbriqué à l'intérieur (y compris clip), donc les limites de clip finissent aussi à 100dp.
Modifier.size(100.dp).clip(CircleShape)
// clip à l'extérieur, size à l'intérieur : clip n'a pas de taille propre, il
// laisse simplement passer les contraintes intactes, donc size impose
// quand même 100dp, et les limites de clip restent 100dp.
Modifier.clip(CircleShape).size(100.dp)Les deux produisent le même cercle. clip() ne devient sensible à l'ordre
que lorsqu'il est associé à un modifier qui dessine quelque chose lui-même,
comme border() ou background().
Empiler deux modifiers du même type. padding() réduit les contraintes
d'une quantité fixe, et l'addition commute, donc deux appels padding()
empilés aboutissent toujours au même décalage total quel que soit l'ordre :
Modifier.padding(start = 8.dp).padding(top = 4.dp)
Modifier.padding(top = 4.dp).padding(start = 8.dp)
// même résultat dans les deux cas : 8dp de marge depuis le bord de départ, 4dp depuis le hautMême logique pour alpha() : chaque appel multiplie l'opacité actuelle,
et la multiplication commute aussi, donc alpha(0.5f).alpha(0.8f) et
alpha(0.8f).alpha(0.5f) aboutissent tous les deux à une opacité finale
de 0.4.
Chaque fois que l'« enveloppement » effectué par un modifier n'est qu'une
opération associative/commutative (addition de marges, multiplication
d'opacité), l'ordre cesse d'avoir de l'importance, de la même manière que
2 + 3 == 3 + 2 dans le Callout ci-dessous.
Ce sont les modifiers qui consomment la taille, le contenu ou les limites
de dessin (background, clip, clickable) pour lesquels l'ordre est
déterminant.
Le fondamental
C'est de la composition de fonctions : Modifier.a().b() se comporte
comme a(b(x)). La composition de fonctions dépend de l'ordre : f(g(x))
n'est généralement pas identique à g(f(x)), de la même manière que
2 + 3 et 3 + 2 sont identiques mais que x / 2 et 2 / x ne le sont
pas.
De manière équivalente, c'est le pattern decorator : chaque decorator enveloppe l'objet qu'on lui transmet, et l'ordre d'enveloppement change le comportement parce que chaque couche ne voit que ce qui est à l'intérieur d'elle, pas ce qui est à l'extérieur.
Ailleurs : même fondamental, framework différent
- Les intercepteurs OkHttp : la chaîne d'intercepteurs s'exécute dans l'ordre d'enregistrement, et chaque intercepteur enveloppe le suivant. Un intercepteur de logging placé avant un intercepteur de retry ne voit que la première tentative ; placé après, il voit chaque tentative rejouée. Le même mécanisme « l'ordre des wrappers change ce que chaque couche peut observer ».
transformen CSS :transform: translate(50px) rotate(45deg)vsrotate(45deg) translate(50px)donne des résultats différents, parce que chaque fonction de transformation opère dans l'espace de coordonnées laissé par celle qui la précède.- Les view modifiers de SwiftUI : l'analogue le plus proche de tous.
Chaque modifier retourne un nouveau type
Viewenveloppant, donc.padding().background()vs.background().padding()est le piège identique, et.clipShape()placé avant ou après.background()/.overlay()reproduit le même bug de coins arrondis. - Les widgets Flutter : encore plus littéral, puisque Flutter écrit
directement l'arbre de wrappers sans syntaxe de chaînage par-dessus.
ClipRRect(child: Container(color: ...))vsContainer(color: ..., child: ClipRRect(...))est l'exemple clip/background, simplement formulé comme des constructeurs imbriqués plutôt que des appels chaînés. - WPF/XAML :
<Border Padding="16"><Border Background="Red"/></Border>vs l'imbrication inversée se comporte de la même manière, car les éléments XAML sont littéralement des objets imbriqués, même mécanisme que CSS, simplement écrit comme du markup.
Où cela piège vraiment les gens
Ce ne sont pas des exemples inventés, ce sont des rapports de bugs que les gens déposent réellement.
Le fond d'une carte arrondie apparaît carré aux coins
Le coupable habituel : la surcharge simple background(color) ne fait
que peindre un rectangle, elle n'a aucune idée des formes. Elle ne sort
arrondie que si elle est imbriquée à l'intérieur d'un clip() :
// clip à l'extérieur, background à l'intérieur : la peinture carrée est imbriquée
// à l'intérieur de clip, donc elle est découpée selon la forme arrondie. Les coins correspondent.
Modifier.clip(RoundedCornerShape(12.dp))
.background(Color.Gray)
// background à l'extérieur, clip à l'intérieur : background peint son carré complet
// avant que clip (imbriqué à l'intérieur) ne s'exécute, donc les coins ne sont jamais
// découpés, même si clip est bien présent dans la chaîne.
Modifier.background(Color.Gray)
.clip(RoundedCornerShape(12.dp))(border(width, color, shape) n'a pas ce problème : il prend une forme
explicite et dessine toujours son trait le long de celle-ci, donc l'ordre
du clip ne l'affecte pas. Ce sont spécifiquement les modifiers sans forme
comme background(color) brut, ou un contenu brut comme une Image, qui
dépendent du bon positionnement d'un clip() externe.)
Le ripple dépasse d'une carte clickable arrondie sous forme carrée
Même cause profonde : le ripple de clickable() est dessiné comme faisant
partie de son propre nœud, donc il n'est découpé que si clip() englobe
autour de clickable(), pas l'inverse :
// clip à l'extérieur, clickable à l'intérieur : le ripple est imbriqué à l'intérieur de
// clip, il est donc découpé selon la forme arrondie.
Modifier.clip(RoundedCornerShape(12.dp)).clickable { }
// clickable à l'extérieur, clip à l'intérieur : le ripple se dessine au niveau du
// propre nœud de clickable, qui se trouve à l'extérieur de clip dans la chaîne, donc il
// ignore complètement les coins arrondis.
Modifier.clickable { }.clip(RoundedCornerShape(12.dp))L'ordre de padding() + border() change l'emplacement de la bordure
Pas seulement le contenu :
// border à l'extérieur, padding à l'intérieur : border se dessine sur les limites
// complètes de fillMaxWidth ; padding, imbriqué à l'intérieur, ne fait que repousser
// le contenu vers l'intérieur. La bordure se trouve à fleur du bord de son conteneur.
Modifier.fillMaxWidth().border(1.dp, Color.Gray).padding(16.dp)
// padding à l'extérieur, border à l'intérieur : padding réduit l'espace avant même
// que border ne s'exécute, donc les propres limites de border sont déjà réduites.
// La bordure se trouve à 16dp du bord.
Modifier.fillMaxWidth().padding(16.dp).border(1.dp, Color.Gray)Le modèle mental à utiliser réellement
Arrêtez de demander « quelles propriétés suis-je en train de définir ». Demandez plutôt : « qu'est-ce que ce modifier perçoit comme son entrée : taille, contenu, zone tactile, en fonction de ce qui se trouve à sa gauche dans la chaîne ? » Cette question suffit à prédire le résultat à chaque fois.



