Comment puis-je utiliser UIColorFromRGB dans Swift?

En Objective-C, nous utilisons ce code pour définir des codes de couleur RVB pour les vues:

#define UIColorFromRGB(rgbValue)        
[UIColor colorWithRed:((float)((rgbValue & 0xFF0000) >> 16))/255.0 green:((float)((rgbValue & 0xFF00) >> 8))/255.0 blue:((float)(rgbValue & 0xFF))/255.0 alpha:1.0]

view.backgroundColor=UIColorFromRGB(0x209624);

Comment puis-je utiliser cela dans Swift?

Voici une version Swift de cette fonction (pour obtenir une représentation UIColor d'une UIntvaleur):

func UIColorFromRGB(rgbValue: UInt) -> UIColor {
    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

view.backgroundColor = UIColorFromRGB(0x209624)

Je voulais mettre

cell.backgroundColor = UIColor.colorWithRed(125/255.0, green: 125/255.0, blue: 125/255.0, alpha: 1.0)  

mais cela n'a pas fonctionné.

J'ai donc utilisé:
Pour Swift

cell.backgroundColor = UIColor(red: 0.5, green: 0.5, blue: 0.5, alpha: 1.0)  

C'est donc la solution de contournement que j'ai trouvée.

J'ai beaucoup aimé la réponse de Nate Cook mais je voulais quelque chose d'un peu plus idiomatique. Je pense que c'est un très bon cas d'utilisation pour un initialiseur pratique via une extension personnalisée.

// UIColorExtensions.swift
import Foundation
import UIKit

extension UIColor {
    convenience init(rgb: UInt) {
        self.init(
            red: CGFloat((rgb & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgb & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgb & 0x0000FF) / 255.0,
            alpha: CGFloat(1.0)
        )
    }
}

Cela peut maintenant être utilisé comme ceci:

view.backgroundColor = UIColor(rgb: 0x209624)

Je ne recommanderais que monkey patcher les classes UIKit comme celle-ci dans votre propre code client, pas dans les bibliothèques.

myLabel.backgroundColor = UIColor(red: 50.0/255, green: 150.0/255, blue: 65.0/255, alpha: 1.0)

Le moyen le plus simple d'ajouter de la couleur par programme consiste à utiliser ColorLiteral .

Ajoutez simplement la propriété ColorLiteral comme indiqué dans l'exemple, Xcode vous proposera une liste complète de couleurs que vous pouvez choisir. L'avantage de le faire est un code moindre, ajouter des valeurs HEX ou RVB . Vous obtiendrez également les couleurs récemment utilisées du storyboard.

Exemple: self.view.backgroundColor = ColorLiteral

Si vous partez d'une chaîne (non hexadécimale), il s'agit d'une fonction qui prend une chaîne hexadécimale et renvoie un UIColor.
(Vous pouvez saisir des chaînes hexadécimales au format: #ffffffou ffffff)

Usage:

var color1 = hexStringToUIColor("#d3d3d3")

Swift 4:

func hexStringToUIColor (hex:String) -> UIColor {
    var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

    if (cString.hasPrefix("#")) {
        cString.remove(at: cString.startIndex)
    }

    if ((cString.count) != 6) {
        return UIColor.gray
    }

    var rgbValue:UInt32 = 0
    Scanner(string: cString).scanHexInt32(&rgbValue)

    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

Swift 3:

func hexStringToUIColor (hex:String) -> UIColor {
    var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

    if (cString.hasPrefix("#")) {
        cString.remove(at: cString.startIndex)
    }

    if ((cString.characters.count) != 6) {
        return UIColor.gray
    }

    var rgbValue:UInt32 = 0
    Scanner(string: cString).scanHexInt32(&rgbValue)

    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

Swift 2:

func hexStringToUIColor (hex:String) -> UIColor {
    var cString:String = hex.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet() as NSCharacterSet).uppercaseString

    if (cString.hasPrefix("#")) {
      cString = cString.substringFromIndex(cString.startIndex.advancedBy(1))
    }

    if ((cString.characters.count) != 6) {
      return UIColor.grayColor()
    }

    var rgbValue:UInt32 = 0
    NSScanner(string: cString).scanHexInt(&rgbValue)

    return UIColor(
        red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
        green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
        blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
        alpha: CGFloat(1.0)
    )
}

Source: arshad / gist: de147c42d7b3063ef7bc

Pour Xcode 9 , utilisez UIColoravec des valeurs RVB.

shareBtn.backgroundColor = UIColor( red: CGFloat(92/255.0), green: CGFloat(203/255.0), blue: CGFloat(207/255.0), alpha: CGFloat(1.0) )

Aperçu:

Consultez la documentation Apple supplémentaire sur UIColor .

UIColorFromRGB dans Swift 4

button.layer.backgroundColor = UIColor(red: 112.0/255, green: 86.0/255, blue: 164.0/255, alpha: 1.0).cgColor

J'ai utilisé ce qui suit dans Swift.

let appRedColor = UIColor(red: 200.0/255.0, green: 16.0/255.0, blue: 46.0/255.0, alpha: 1.0)
let appSilverColor = UIColor(red: 236.0/255.0, green: 236.0/255.0, blue: 236.0/255.0, alpha: 1.0)
let appWhiteColor = UIColor(red: 255.0/255.0, green: 255.0/255.0, blue: 255.0/255.0, alpha: 1.0)
let appNavyColor = UIColor(red: 19.0/255.0, green: 41.0/255.0, blue: 75.0/255.0, alpha: 1.0)

solution pour le format argb:

//  UIColorExtensions.swift
import UIKit
extension UIColor {

    convenience init(argb: UInt) {
        self.init(
            red: CGFloat((argb & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((argb & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(argb & 0x0000FF) / 255.0,
            alpha: CGFloat((argb & 0xFF000000) >> 24) / 255.0
        )
    }
}

usage:

var clearColor: UIColor = UIColor.init(argb: 0x00000000)
var redColor: UIColor = UIColor.init(argb: 0xFFFF0000)

Cela a fonctionné pour moi rapidement. Essaye ça

bottomBorder.borderColor = UIColor (red: 255.0/255.0, green: 215.0/255.0, blue: 60/255.0, alpha: 1.0).CGColor

ajout d'une option swift 3:

cell.layer.borderColor = UIColor (red: 192.0/255.0, green: 192.0/255.0, blue: 197/255.0, alpha: 1.0).cgColor

Vous ne pouvez pas utiliser de macros complexes comme #define UIColorFromRGB(rgbValue)dans Swift. Le remplacement de la macro simple dans swift est des constantes globales comme

let FADE_ANIMATION_DURATION = 0.35

Cependant, les macros complexes qui acceptent les paramètres ne sont pas prises en charge par swift. vous pouvez utiliser des fonctions à la place

Les macros complexes sont utilisées en C et Objective-C mais n'ont pas d'équivalent en Swift. Les macros complexes sont des macros qui ne définissent pas de constantes, y compris les macros de type fonction entre parenthèses. Vous utilisez des macros complexes en C et Objective-C pour éviter les contraintes de vérification de type ou pour éviter de retaper de grandes quantités de code standard. Cependant, les macros peuvent rendre le débogage et la refactorisation difficiles. Dans Swift, vous pouvez utiliser des fonctions et des génériques pour obtenir les mêmes résultats sans aucun compromis. Par conséquent, les macros complexes qui se trouvent dans les fichiers source C et Objective-C ne sont pas mises à disposition de votre code Swift.

Extrait de l' utilisation de Swift avec du cacao et de l'objectif C

Vérifiez la réponse @Nate Cooks pour la version Swift de cette fonction à utiliser ici

Vous pouvez utiliser ceci:

//The color RGB #85CC4B
let newColor = UIColor(red: CGFloat(0x85)/255
                      ,green: CGFloat(0xCC)/255
                      ,blue: CGFloat(0x4B)/255
                      ,alpha: 1.0)

La réponse de Nate Cook est absolument correcte. Juste pour plus de flexibilité, je garde les fonctions suivantes dans mon pack:

func getUIColorFromRGBThreeIntegers(red: Int, green: Int, blue: Int) -> UIColor {
    return UIColor(red: CGFloat(Float(red) / 255.0),
        green: CGFloat(Float(green) / 255.0),
        blue: CGFloat(Float(blue) / 255.0),
        alpha: CGFloat(1.0))
}

func getUIColorFromRGBHexValue(value: Int) -> UIColor {
    return getUIColorFromRGBThreeIntegers(red: (value & 0xFF0000) >> 16,
        green: (value & 0x00FF00) >> 8,
        blue: value & 0x0000FF)
}

func getUIColorFromRGBString(value: String) -> UIColor {
    let str = value.lowercased().replacingOccurrences(of: "#", with: "").
        replacingOccurrences(of: "0x", with: "");
        return getUIColorFromRGBHexValue(value: Int(str, radix: 16)!);
}

Et voici comment je les utilise:

// All three of them are identical:
let myColor1 = getUIColorFromRGBHexValue(value: 0xd5a637)
let myColor2 = getUIColorFromRGBString(value: "#D5A637")
let myColor3 = getUIColorFromRGBThreeIntegers(red: 213, green: 166, blue: 55)

J'espère que cela aidera. Tout est testé avec Swift 3 / Xcode 8.

C'est une belle extension pour UIColor. Vous pouvez utiliser des valeurs d'énumération (hexadécimal, chaîne) et des valeurs de chaîne directes lorsque vous créez des objets UIColor.

L'extension que nous méritons https://github.com/ioramashvili/UsefulExtensions/blob/master/Extensions.playground/Pages/UIColor.xcplaygroundpage/Contents.swift

Je peux voir que cela a déjà été répondu, mais j'espère toujours qu'une doublure aidera mieux.

import UIKit

let requiredColor = UIColor(red: CGFloat((rgbValue & 0xFF0000) >> 16)/255, 
                            green: CGFloat((rgbValue & 0x00FF00) >> 8)/255, 
                            blue: CGFloat(rgbValue & 0x0000FF)/255, alpha :1)

Mise à jour:: Modifications effectuées selon l'exemple expliqué par l'auteur de la question pour fournir des valeurs hexadécimales

Dans Swift3, si vous commencez avec une couleur que vous avez déjà choisie, vous pouvez obtenir la valeur RVB en ligne ( http://imagecolorpicker.com ) et utiliser ces valeurs définies comme UIColor. Cette solution les implémente en arrière-plan:

    @IBAction func blueBackground(_ sender: Any) {
        let blueColor = UIColor(red: CGFloat(160/255), green: CGFloat(183.0/255), blue: CGFloat(227.0/255), alpha: 1)
        view.backgroundColor = blueColor

@Vadym l'a mentionné ci-dessus dans les commentaires et il est important de définir le CGFloat avec un seul point décimal

import Cocoa
class ViewController: NSViewController{
     override func viewDidLoad() {
            super.viewDidLoad()
    self.view.wantsLayer = true
    self.view.layer?.backgroundColor = NSColor(hexString: "#4d9b48").cgColor

}
extension NSColor {

            convenience init(hexString: String, alpha: CGFloat = 1.0) {
                  let hexString: String = hexString.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
                  let scanner = Scanner(string: hexString)
                  if (hexString.hasPrefix("#")) {
                      scanner.scanLocation = 1
                  }
                  var color: UInt32 = 0
                  scanner.scanHexInt32(&color)
                  let mask = 0x000000FF
                  let r = Int(color >> 16) & mask
                  let g = Int(color >> 8) & mask
                  let b = Int(color) & mask
                  let red   = CGFloat(r) / 255.0
                  let green = CGFloat(g) / 255.0
                  let blue  = CGFloat(b) / 255.0
                  self.init(red:red, green:green, blue:blue, alpha:alpha)
              }
              func toHexString() -> String {
                  var r:CGFloat = 0
                  var g:CGFloat = 0
                  var b:CGFloat = 0
                  var a:CGFloat = 0
                  getRed(&r, green: &g, blue: &b, alpha: &a)
                  let rgb:Int = (Int)(r*255)<<16 | (Int)(g*255)<<8 | (Int)(b*255)<<0
                  return String(format:"#%06x", rgb)

            }
        }

Cela peut être fait simplement en utilisant cette initialisation

view.backgroundColor = UIColor(hex: "067AB5")