iOS
UIColor

UIColor बनाना

कई तरीके हैं जिनसे आप एक UIColor बना सकते हैं:

तीव्र

• पूर्वनिर्धारित रंगों में से एक का उपयोग करना:

  let redColor = UIColor.redColor()
  let blueColor: UIColor = .blueColor()
  
  // In Swift 3, the "Color()" suffix is removed:
  let redColor = UIColor.red
  let blueColor: UIColor = .blue
  

  यदि कंपाइलर को पहले से पता है कि वेरिएबल UIColor का एक उदाहरण है, तो आप टाइप को एक साथ छोड़ सकते हैं:

  let view = UIView()
  view.backgroundColor = .yellowColor()
  

• ग्रेस्केल मूल्य और अल्फा का उपयोग करना:

  let grayscaleColor = UIColor(white: 0.5, alpha: 1.0)
  

• ह्यू, संतृप्ति, चमक और अल्फा का उपयोग करना:

  let hsbColor = UIColor(
      hue: 0.4,
      saturation: 0.3,
      brightness: 0.7,
      alpha: 1.0
  )
  

• RGBA मानों का उपयोग करना:

  let rgbColor = UIColor(
      red: 30.0 / 255, 
      green: 70.0 / 255, 
      blue: 200.0 / 255, 
      alpha: 1.0
  )
  

• एक पैटर्न छवि का उपयोग करना:

  let patternColor = UIColor(patternImage: UIImage(named: "myImage")!)
  

उद्देश्य सी

• पूर्वनिर्धारित रंगों में से एक का उपयोग करना:

  UIColor *redColor = [UIColor redColor];
  

• ग्रेस्केल मूल्य और अल्फा का उपयोग करना:

  UIColor *grayscaleColor = [UIColor colorWithWhite: 0.5 alpha: 1.0];
  

• ह्यू, संतृप्ति, चमक और अल्फा का उपयोग करना:

  UIColor *hsbColor = [UIColor
      colorWithHue: 0.4
      saturation: 0.3
      brightness: 0.7
      alpha: 1.0
  ];
  

• RGBA मानों का उपयोग करना:

  UIColor *rgbColor = [UIColor
      colorWithRed: 30.0 / 255.0
      green: 70.0 / 255.0
      blue: 200.0 / 255.0 
      alpha: 1.0
  ];
  

• एक पैटर्न छवि का उपयोग करना:

  UIColor *pattenColor = [UIColor colorWithPatternImage:[UIImage imageNamed:@"myImage.png"]];
  

अनजाने तरीके

UIColor पर विभिन्न प्रकार के अनिर्दिष्ट तरीके हैं जो वैकल्पिक रंगों या कार्यक्षमता को उजागर करते हैं। इन्हें UIColor निजी हेडर फ़ाइल में पाया जा सकता है। मैं दो निजी तरीकों, styleString() और _systemDestructiveTintColor() के उपयोग का दस्तावेजीकरण styleString() ।

styleString

IOS 2.0 के बाद से UIColor पर एक निजी इंस्टेंस मेथड है, जिसे styleString कहा जाता है जो RGB RGB या RGBA स्ट्रिंग प्रतिनिधित्व करता है, यहां तक कि whiteColor बाहर whiteColor कलर जैसे रंग भी।

उद्देश्य सी:

@interface UIColor (Private)

- (NSString *)styleString;

@end

// ...

[[UIColor whiteColor] styleString]; // rgb(255,255,255)
[[UIColor redColor] styleString]; // rgb(255,0,0)
[[UIColor lightTextColor] styleString]; // rgba(255,255,255,0.600000)

स्विफ्ट में आप इंटरफ़ेस को उजागर करने के लिए एक ब्रिजिंग हेडर का उपयोग कर सकते हैं। शुद्ध स्विफ्ट के साथ, आपको निजी विधि के साथ एक @objc प्रोटोकॉल बनाना होगा, और प्रोटोकॉल के साथ unsafeBitCast UIColor :

@objc protocol  UIColorPrivate {
    func styleString() -> String
}

let white = UIColor.whiteColor()
let red = UIColor.redColor()
let lightTextColor = UIColor.lightTextColor()

let whitePrivate = unsafeBitCast(white, UIColorPrivate.self)
let redPrivate = unsafeBitCast(red, UIColorPrivate.self)
let lightTextColorPrivate = unsafeBitCast(lightTextColor, UIColorPrivate.self)

whitePrivate.styleString() // rgb(255,255,255)
redPrivate.styleString() // rgb(255,0,0)
lightTextColorPrivate.styleString() // rgba(255,255,255,0.600000)

_systemDestructiveTintColor()

UIColor पर एक _systemDestructiveTintColor वर्ग विधि है, जिसे _systemDestructiveTintColor कहा जाता है, जो विनाशकारी सिस्टम बटन द्वारा उपयोग किए गए लाल रंग को लौटाएगा:

let red = UIColor.performSelector("_systemDestructiveTintColor").takeUnretainedValue()

यह एक अप्रबंधित वस्तु देता है, जिसे आपको .takeUnretainedValue() पर कॉल करना होगा, क्योंकि रंग का स्वामित्व हमारी स्वयं की वस्तु पर स्थानांतरित नहीं किया गया है।

किसी भी अनिर्दिष्ट एपीआई के साथ, आपको इस पद्धति का उपयोग करने की कोशिश करते समय सावधानी बरतनी चाहिए:

if UIColor.respondsToSelector("_systemDestructiveTintColor") {
    if let red = UIColor.performSelector("_systemDestructiveTintColor").takeUnretainedValue() as? UIColor {
        // use the color
    }
}

या किसी प्रोटोकॉल का उपयोग करके:

@objc protocol UIColorPrivateStatic {
    func _systemDestructiveTintColor() -> UIColor
}

let privateClass = UIColor.self as! UIColorPrivateStatic
privateClass._systemDestructiveTintColor() // UIDeviceRGBColorSpace 1 0.231373 0.188235 1

अल्फा घटक के साथ रंग

आप init(red:_,green:_,blue:_,alpha:_) initializer का उपयोग कर एक नया बनाने के बिना एक निश्चित UIColor लिए अस्पष्टता सेट कर सकते हैं।

तीव्र

let colorWithAlpha = UIColor.redColor().colorWithAlphaComponent(0.1)

स्विफ्ट 3

//In Swift Latest Version
_ colorWithAlpha = UIColor.red.withAlphaComponent(0.1)

उद्देश्य सी

UIColor * colorWithAlpha = [[UIColor redColor] colorWithAlphaComponent:0.1];

उपयोगकर्ता परिभाषित विशेषताएँ CGColor डेटाटाइप लागू करें

डिफ़ॉल्ट रूप से, इंटरफ़ेस बिल्डर CGColor डेटाटाइप को स्वीकार नहीं करता है, इसलिए इंटरफ़ेस बिल्डर में उपयोगकर्ता परिभाषित विशेषताओं का उपयोग करके CGColor जोड़ने की अनुमति देता है; कोई इस तरह से एक्सटेंशन का उपयोग करना चाहता है:

स्विफ्ट एक्सटेंशन:

extension CALayer {
    func borderUIColor() -> UIColor? {
        return borderColor != nil ? UIColor(CGColor: borderColor!) : nil
    }
    
    func setBorderUIColor(color: UIColor) {
        borderColor = color.CGColor
    }
}

नए उपयोगकर्ता परिभाषित विशेषता (बॉर्डर यूक्लोर) को समस्याओं के बिना पहचाना और लागू किया जाएगा।

हेक्साडेसिमल संख्या या स्ट्रिंग से एक UIColor बनाना

आप एक हेक्साडेसिमल संख्या या स्ट्रिंग, जैसे 0xff00cc, "# FFFFF" से एक UIColor बना सकते हैं

तीव्र

इंट वैल्यू

extension UIColor {
    convenience init(hex: Int, alpha: CGFloat = 1.0) {
        let r = CGFloat((hex >> 16) & 0xff) / 255
        let g = CGFloat((hex >> 08) & 0xff) / 255
        let b = CGFloat((hex >> 00) & 0xff) / 255
        self.init(red: r, green: g, blue: b, alpha: alpha)
    }
}

उदाहरण:

let color = UIColor(hex: 0xff00cc, alpha: 1.0)

ध्यान दें कि alpha लिए 1.0 का डिफ़ॉल्ट मान प्रदान किया गया है, इसलिए इसका उपयोग निम्नानुसार किया जा सकता है:

let color = UIColor(hex: 0xff00cc)

स्ट्रिंग मान

extension UIColor {
    convenience init(hexCode: String) {
        let hex = hexCode.stringByTrimmingCharactersInSet(NSCharacterSet.alphanumericCharacterSet().invertedSet)
        var int = UInt32()
        NSScanner(string: hex).scanHexInt(&int)
        let a, r, g, b: UInt32

        switch hex.characters.count {
        case 3:
            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6:
            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
        case 8:
            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            (a, r, g, b) = (1, 1, 1, 0)
        }
    
        self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
    }
}

उदाहरण उपयोग:

अल्फा के साथ हेक्स

let color = UIColor("#80FFFFFF")

कोई अल्फा के साथ हेक्स ( color अल्फा 1.0 के बराबर होगा)

let color = UIColor("#FFFFFF")
let color = UIColor("#FFF")

उद्देश्य सी

इंट वैल्यू

@interface UIColor (Hex)
+ (UIColor *)colorWithHex:(NSUInteger)hex alpha:(CGFloat)alpha;
@end

@implementation UIColor (Hex)
+ (UIColor *)colorWithHex:(NSUInteger)hex alpha:(CGFloat)alpha {
    return [UIColor colorWithRed:((CGFloat)((hex & 0xFF0000) >> 16))/255.0
                           green:((CGFloat)((hex & 0xFF00) >> 8))/255.0
                            blue:((CGFloat)(hex & 0xFF))/255.0
                           alpha:alpha];
}
@end

उदाहरण:

UIColor *color = [UIColor colorWithHex:0xff00cc alpha:1.0];

स्ट्रिंग मान

- (UIColor*) hex:(NSString*)hexCode {
    
    NSString *noHashString = [hexCode stringByReplacingOccurrencesOfString:@"#" withString:@""];
    NSScanner *scanner = [NSScanner scannerWithString:noHashString];
    [scanner setCharactersToBeSkipped:[NSCharacterSet symbolCharacterSet]];
    
    unsigned hex;
    if (![scanner scanHexInt:&hex]) return nil;
    int a;
    int r;
    int g;
    int b;

    switch (noHashString.length) {
        case 3:
            a = 255;
            r = (hex >> 8) * 17;
            g = ((hex >> 4) & 0xF) * 17;
            b = ((hex >> 0) & 0xF) * 17;
            break;
        case 6:
            a = 255;
            r = (hex >> 16);
            g = (hex >> 8) & 0xFF;
            b = (hex) & 0xFF;
            break;
        case 8:
            a = (hex >> 24);
            r = (hex >> 16) & 0xFF;
            g = (hex >> 8) & 0xFF;
            b = (hex) & 0xFF;
            break;
            
        default:
            a = 255.0;
            r = 255.0;
            b = 255.0;
            g = 255.0;
            break;
    }

    return [UIColor colorWithRed:r / 255.0f green:g / 255.0f blue:b / 255.0f alpha:a / 255];
}

उदाहरण उपयोग:

अल्फा के साथ हेक्स

UIColor* color = [self hex:@"#80FFFFFF"];

कोई अल्फा के साथ हेक्स ( color अल्फा 1 बराबर होगा)

UIColor* color = [self hex:@"#FFFFFF"];
UIColor* color = [self hex:@"#FFF"];

UIColor से रंग की चमक समायोजित

नीचे दिए गए कोड का उदाहरण आपको उस रंग का एक समायोजित संस्करण देगा जहां एक उच्च प्रतिशत उज्जवल होगा और एक कम प्रतिशत गहरा होगा।

उद्देश्य सी

+ (UIColor *)adjustedColorForColor:(UIColor *)c : (double)percent
{
    if (percent < 0) percent = 0;
    
    CGFloat r, g, b, a;
    if ([c getRed:&r green:&g blue:&b alpha:&a])
        return [UIColor colorWithRed:MAX(r * percent, 0.0)
                               green:MAX(g * percent, 0.0)
                                blue:MAX(b * percent, 0.0)
                               alpha:a];
    return nil;
}

तीव्र

func adjustedColorForColor( c: UIColor, var percent: CGFloat) -> UIColor {
    if percent < 0 {
        percent = 0
    }

    var r,g,b,a: CGFloat
    r = 0.0
    g = 0.0
    b = 0.0
    a = 0.0

    if c.getRed(&r, green: &g, blue: &b, alpha: &a) {
        return UIColor(red: max(r * percent, 0.0), green: max(g * percent, 0.0), blue: max(b * percent, 0.0), alpha: a)
    }

    return UIColor()
}

छवि पैटर्न से UIColor

आप UIColor(patternImage:_) विधि का उपयोग करके एक छवि पैटर्न का उपयोग करके एक UIColor ऑब्जेक्ट बना सकते हैं।

btn.backgroundColor = UIColor(patternImage: UIImage(named: "image")!)

किसी दिए गए UIColor का हल्का और गहरा शेड

नीचे दिए गए कोड का उदाहरण दिखाता है कि आप किसी दिए गए रंग का हल्का और गहरा छाया कैसे प्राप्त कर सकते हैं, गतिशील विषयों वाले अनुप्रयोगों में उपयोगी है

गहरे रंग के लिए

+ (UIColor *)darkerColorForColor:(UIColor *)c
{
    CGFloat r, g, b, a;
    if ([c getRed:&r green:&g blue:&b alpha:&a])
        return [UIColor colorWithRed:MAX(r - 0.2, 0.0)
                               green:MAX(g - 0.2, 0.0)
                                blue:MAX(b - 0.2, 0.0)
                               alpha:a];
    return nil;
}

हल्का रंग के लिए

+ (UIColor *)lighterColorForColor:(UIColor *)c
{
    CGFloat r, g, b, a;
    if ([c getRed:&r green:&g blue:&b alpha:&a])
        return [UIColor colorWithRed:MIN(r + 0.2, 1.0)
                               green:MIN(g + 0.2, 1.0)
                                blue:MIN(b + 0.2, 1.0)
                               alpha:a];
    return nil;
}

दिए गए रंग पर विचार करते हुए नीचे दिए गए दृश्य अंतर देखें [UIColor orangeColor]