Les couleurs¶
Color¶
La structure Color permet de représenter une couleur.
Dans la mesure du possible, évitez de coder en dur les couleurs dans votre code. Ceci rend plus difficile la gestion des modes Apparence Claire vs Apparence Sombre.
Couleurs prédéfinies¶
La structure Color propose des propriétés de classe pour définir des couleurs standard :
- Color.black
- Color.blue
- Color.gray
- Color.green
- Color.orange
- Color.pink
- Color.purple
- Color.red
- Color.white
- Color.yellow

Les couleurs peuvent être utilisées dans des méthodes qui attendent en paramètre une structure Color.
Rôles ou statuts¶
La structure Color propose également des propriétés de classe pour choisir une couleur par son statut ou son rôle plutôt que par son nom :
- Color.accentColor (par défaut : bleu)
- Color.clear (blanc en mode Apparence Claire ou noir en mode Apparence Sombre)
- Color.primary (noir en mode Apparence Claire ou blanc en mode Apparence Sombre)
- Color.secondary (noir avec transparence en mode Apparence Claire ou blanc avec transparence en mode Apparence Sombre))

Mode Apparence Claire vs mode Apparence Sombre¶
Le propriétaire d'un iPhone peut choisir d'afficher les applications en mode Apparence Claire, en mode Apparence Sombre ou en mode automatique.
Puisque c'est l'utilisateur qui contrôle le mode d'affichage, l'application que vous développez doit pouvoir fonctionner dans les deux modes.
Dans cette fiche :
- Coder en fonction des deux modes
- Problème des couleurs codées en dur
- Ajustement automatique des couleurs
- Ajuster la couleur selon le mode
- Tester les deux modes
- Configuration dans le canevas
- Configuration dans le simulateur
- Configuration sur iPhone
Coder en fonction des deux modes¶
Vous devez toujours avoir les deux modes en tête quand vous codez.
Problème des couleurs codées en dur¶
Prenons le cas suivant : le développer a choisi de coder en dur les couleurs à utiliser.
S'il a spécifié que la couleur doit être noir et que le fond devient noir lors du changement de mode, le texte ne sera plus visible.
Pour voir le résultat de ce code en mode clair et en mode sombre, cliquez sur l'icône Variants (en forme de damier) au bas de la zone du canevas puis choisissez Color Scheme Variants.

Ajustement automatique des couleurs¶
Il faut privilégier l'utilisation des propriétés de classe .primary, .secondary, etc. pour identifier les couleurs.
Il est également intéressant de définir nos propres couleurs personnalisées en mode clair et en mode sombre.
Dans l'exemple qui suit, la couleur messageBienvenue est différente selon que l'écran est sombre ou clair.


Ajuster la couleur selon le mode¶
Dans certains contextes, il peut être judicieux de choisir nous-mêmes la couleur selon le mode.
struct ContentView: View {
@Environment(\.colorScheme) var colorScheme
var body: some View {
...
ZStack {
Rectangle()
.fill(Color.primary)
Text("Hello, world!")
.foregroundColor(colorScheme == .light ? .white : .black)
.padding()
}
...
}
}

Tester les deux modes¶
Pour éviter les mauvaises surprises quand l'usager passe d'un mode à l'autre, il faut tester l'application dans les deux modes.
Configuration dans le canevas¶
Le canevas permet de voir rapidement l'apparence en mode clair et en mode sombre.
Les détails des configurations possibles sont donnés sur la fiche « Prévisualiser dans différentes modes/orientations ».
Configuration dans le simulateur¶
Pour tester le tout dans le simulateur de Xcode, lancez le simulateur puis rendez-vous dans Réglages / Dévelopeur puis cochez Appearence sombre.

Configuration sur iPhone¶
Le choix entre le mode Apparence Claire ou Apparence Sombre peut être réalisé sur le iPhone : Réglages / Affichage et luminosité puis cochez Claire ou Sombre.

Configurer la couleur d'accent¶
La couleur d'accent d'une application peut être modifiée.
Pour la configurer, cliquez sur Assets.xcassets dans la zone de gauche.
Dans la zone centrale, cliquez sur AccentColor.
Juste à sa droite, un carré vous permet de choisir la couleur qui correspondra à AccentColor.
Cliquez sur ce carré et définissez ses paramètres dans l'éditeur de propriétés à droite.
Note : si l'éditeur de propriétés n'apparaît pas, cliquez sur l'icône Hide or show the Inspectors dans le coin supérieur droit de l'écran.

Au besoin, cliquez sur Show Color Panel afin de sélectionner la couleur dans une roue de couleurs.

Par défaut, il n'y a qu'une couleur d'accent. Il est possible de définir une couleur différente pour le mode sombre ou pour le mode clair à l'aide de la liste déroulante Appearances.

Sans rien changer à votre code, les vue qui utilisent Color.accentColor seront désormais de la nouvelle couleur.

Pâlir une couleur¶
A l'aide de l'opacité, il est possible d'obtenir une couleur plus pâle en mode Clair ou plus foncée en mode Sombre.
VStack(spacing: 0) {
ZStack {
Rectangle()
.fill(Color.blue)
Text("Color.blue")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.9)
Text("Color.blue, opacité 0.9")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.8)
Text("Color.blue, opacité 0.8")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.7)
Text("Color.blue, opacité 0.7")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.6)
Text("Color.blue, opacité 0.6")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.5)
Text("Color.blue, opacité 0.5")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.4)
Text("Color.blue, opacité 0.4")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.3)
Text("Color.blue, opacité 0.3")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.2)
Text("Color.blue, opacité 0.2")
}
ZStack {
Rectangle()
.fill(Color.blue)
.opacity(0.1)
Text("Color.blue, opacité 0.1")
}
}

ou, en mode Sombre :

Couleurs RGB¶
Vous avez la possibilité de spécifier la couleur de votre choix à l'aide de codes RGB. Mais attention : cette couleur ne s'ajustera jamais au mode Sombre ou Clair. Assurez-vous de bien tester votre application dans ces deux modes.
Si vous choisissez tout de même de poursuivre avec cette technique, vous devez spécifier un nombre situé entre 0 et 1 pour indiquer le pourcentage de rouge, de vert puis de bleu.
Par exemple, pour obtenir du brun à l'aide du code RGB 137 68 18, vous devrez diviser chaque nombre par 255 et les utiliser dans le constructeur de Color :
Définir vos propres couleurs personnalisées¶
Dans une application SwiftUI, vous pouvez définir vos propres couleurs personnalisées. Ceci facilitera la maintenance du code en plus de permettre de spécifier la nuance de couleur à utiliser en mode clair et en mode sombre.
Pour créer une couleur personnalisée, cliquez sur le + au bas de la zone centrale qui liste les ressources du projet puis sélectionnez Color Set.

Donnez un nom à la nouvelle couleur.
Le nom doit être sémantique, c'est-à-dire qu'il identifie le contexte plutôt que la couleur (ex : sousTitre plutôt que grisPale).
Il n'y a pas de norme officielle pour nommer les couleurs personnalisées mais les bonnes pratiques recommandent d'utiliser la casse Pascal, c'est-à-dire un nom qui débute par une majuscule, avec une majuscule au début de chaque mot suivant.
Spécifiez ensuite la couleur à utiliser à l'aide de l'éditeur de propriétés. Il faut spécifier une couleur pour chacun des modes présentés.

Et pour utiliser cette couleur, deux syntaxes sont possibles.
Avec cette première option, le nom doit débuter par une minuscule même s'il a été défini en casse Pascal.
Ceci est dû à une génération automatique d'un membre statique basé sur le nom de la couleur. Ce membre est toujours en casse chameau (débute par une minuscule et majuscule au début de chaque mot suivant).
Avec cette deuxième option, le nom doit respecter la casse utilisée lors de la création de la couleur personnalisée.
Modifier la couleur d'une image par programmation¶
SwiftUI permet de modifier les couleurs d'une image par programmation grâce à différentes méthodes qui permettent de jouer sur les profils colorimétriques d'une image, par exemple :
- .renderingMode() (pour remplir complètement une image à l'aide d'une couleur)
- .brightness()
- .saturation()
- .contrast()
- .opacity()
- .colorMultiply()
- .hueRotation()
- .colorInvert()
- .colorMultiply()
Voici quelques exemples visuels.
Dans les impressions d'écrans, les images de gauches sont originales et celles de droites ont été ajustées par programmation.
struct ContentView: View {
var body: some View {
VStack {
Text(".renderingMode")
HStack {
Image("avril")
.resizable()
.scaledToFit()
Image("avril")
.renderingMode(.template)
.resizable()
.scaledToFit()
.foregroundColor(.blue)
}
Text(".brightness")
.padding(.top)
HStack {
Image("fond")
.resizable()
.scaledToFit()
Image("fond")
.resizable()
.scaledToFit()
.brightness(0.2)
}
Text(".saturation et .contrast")
.padding(.top)
HStack {
Image("coucher_soleil")
.resizable()
.scaledToFit()
Image("coucher_soleil")
.resizable()
.scaledToFit()
.saturation(1.5)
.contrast(1.9)
}
}
.padding()
}
}

Si vous travaillez avec une image dont les traits principaux sont en noir, voici une astuce pour transformer les traits noirs dans la couleur de votre choix.
HStack {
Image("oiseau")
.resizable()
.scaledToFit()
Image("oiseau")
.resizable()
.scaledToFit()
.colorInvert() // colorMultiply n’a aucun effet sur le noir. En inversant les couleurs, le fond devient noir (et reste donc inchangé), tandis que les traits, devenus blancs, seront affectés par le filtre
.colorMultiply(Color(red: 0, green: 1, blue: 1)) // laisser à 0 la couleur désirée au final car tout sera inversé
.colorInvert() // le noir redevient blanc et les traits prennent la couleur qui était à 0
}

Si vous avez en main une image colorée (clipart ou photo), il est possible d'utiliser .hueRotation() pour décaler toutes les couleurs de l'image le long du cercle chromatique.
HStack {
Image("ballon_plage")
.resizable()
.scaledToFit()
Image("ballon_plage")
.resizable()
.scaledToFit()
.hueRotation(.degrees(150)) // tester différentes valeurs jusqu'à l'obtention du rendu désiré
}
