एक UILabel में स्थान / पैडिंग जोड़ना


187

मेरे पास एक UILabelजगह है जहां मैं ऊपर और नीचे में जगह जोड़ना चाहता हूं। कम से कम ऊंचाई के साथ मैं इसे करने के लिए संशोधित किया है:

यहां छवि विवरण दर्ज करें

संपादित करें: यह करने के लिए मैंने प्रयोग किया है:

  override func drawTextInRect(rect: CGRect) {
        var insets: UIEdgeInsets = UIEdgeInsets(top: 0.0, left: 10.0, bottom: 0.0, right: 10.0)
        super.drawTextInRect(UIEdgeInsetsInsetRect(rect, insets))

    } 

लेकिन मुझे एक अलग विधि ढूंढनी है क्योंकि अगर मैं दो से अधिक पंक्तियाँ लिखता हूँ तो समस्या समान है:

यहां छवि विवरण दर्ज करें



हमने आखिरकार सभी गतिशील मामलों में, ठीक से यह पता लगाने का प्रयास किया कि यूआईबेल के लिए एक पूर्ण ड्रॉप-इन प्रतिस्थापन के रूप में फिर से लेआउट या किसी अन्य मुद्दों की आवश्यकता नहीं है। ओफ़्फ़। stackoverflow.com/a/58876988/294884
फेटी

जवाबों:


121

यदि आप इसे तोड़-फोड़ के बिना, UILabel के साथ रहना चाहते हैं, तो मुंडी ने आपको एक स्पष्ट समाधान दिया है।

यदि वैकल्पिक रूप से, आप एक UIView के साथ UILabel को लपेटने से बचने के लिए तैयार होंगे, तो आप UIEDgeInsets (पैडिंग) या उपक्लास UILabel का उपयोग UIEDgeInsets का समर्थन करने में सक्षम करने के लिए UITextView का उपयोग कर सकते हैं।

UITextView का उपयोग करने से केवल इनसेट (OBJ-C) प्रदान करना होगा:

textView.textContainerInset = UIEdgeInsetsMake(10, 0, 10, 0);

वैकल्पिक, यदि आप UILabel को उप-वर्ग करते हैं, तो इस दृष्टिकोण का एक उदाहरण drawTextInRect मेथड
(OBJ-C) होगा।

- (void)drawTextInRect:(CGRect)uiLabelRect {
    UIEdgeInsets myLabelInsets = {10, 0, 10, 0};
    [super drawTextInRect:UIEdgeInsetsInsetRect(uiLabelRect, myLabelInsets)];
}

आप अतिरिक्त रूप से TOP, LEFT, BOTTOM और RIGHT के लिए अपने नए उप-वर्ग वाले UABabel को इनसेट चर के साथ प्रदान कर सकते हैं।

एक उदाहरण कोड हो सकता है:

Inh (OBJ-C)

float topInset, leftInset,bottomInset, rightInset;

इनम (OBJ-C)

- (void)drawTextInRect:(CGRect)uiLabelRect {
    [super drawTextInRect:UIEdgeInsetsInsetRect(uiLabelRect, UIEdgeInsetsMake(topInset,leftInset,bottomInset,rightInset))];
}

EDIT # 1:

मैंने जो देखा है, उससे लगता है कि जब आप इसे उप-वर्ग करते हैं तो आपको UILabel के आंतरिक नियंत्रण को ओवरराइड करना होगा।

तो आपको आंतरिक नियंत्रण को ओवरराइड करना चाहिए जैसे:

- (CGSize) intrinsicContentSize {
    CGSize intrinsicSuperViewContentSize = [super intrinsicContentSize] ;
    intrinsicSuperViewContentSize.height += topInset + bottomInset ;
    intrinsicSuperViewContentSize.width += leftInset + rightInset ;
    return intrinsicSuperViewContentSize ;
}

और व्यक्तिगत रूप से संपादित करने के बजाय, अपने इनसेट्स को संपादित करने के लिए निम्न विधि जोड़ें:

- (void) setContentEdgeInsets:(UIEdgeInsets)edgeInsets {
    topInset = edgeInsets.top;
    leftInset = edgeInsets.left;
    rightInset = edgeInsets.right; 
    bottomInset = edgeInsets.bottom;
    [self invalidateIntrinsicContentSize] ;
}

यह एज यूलेट्स से मेल खाने के लिए आपके यूआईलेबेल के आकार को अपडेट करेगा और आपके द्वारा उल्लिखित बहुस्तरीय आवश्यकता को कवर करेगा।

# 2 संपादित करें

थोड़ी खोज करने के बाद मैंने इस जिस्ट को IPInsetLabel के साथ पाया है । यदि उन समाधानों में से कोई भी काम नहीं करता है तो आप इसे आज़मा सकते हैं।

# 3 संपादित करें

इस मामले को लेकर भी कुछ ऐसा ही सवाल (डुप्लिकेट) था।
उपलब्ध समाधानों की पूरी सूची के लिए, इस उत्तर को देखें: UILabel टेक्स्ट मार्जिन


क्षमा करें, लेकिन मैंने उपयोग किया है: `ओवरराइड func drawTextInRect (रेक्ट: CGRect) {var insets: UIEdgeInsets = UIEdgeInsets (शीर्ष: 0.0, बाएँ: 10.0, नीचे, 0.0, दाएं: 10.0) super.drawTextInRect (UIEdgeInsetsInsetRect) ))} `यह काम नहीं करता है क्योंकि परिणाम समान है, गतिशील रूप से काम नहीं करते ..
Annachiara

क्या आपने यूआईलैब के बजाय UITextView के साथ प्रयास किया? या क्या आपको वास्तव में एक यूबिल का उपयोग करने की आवश्यकता है?
nunofmendes

@Annachiara मेरे द्वारा किए गए संपादन की जाँच करें। देखें कि क्या यह काम करता है।
nunofmendes

ठीक। क्या इसने टेक्स्टव्यू का काम किया? Swift में नहीं लिखने के लिए क्षमा करें, लेकिन मैं अभी भी Obj-C मोड में हूं। उस कोड के साथ मेरा लक्ष्य आपको किसी निष्कर्ष पर पहुंचने में मदद करना था। आशा है कि यह किया है।
nunofmendes

1
TextView और कुछ स्टोरीबोर्ड सेटिंग्स और self.textview.textContainerInset = UIEdgeInsetsMake (0, 10, 10, 10) का उपयोग करना; यह अंत में काम करता है! धन्यवाद !
अन्नाचिरा

208

मैंने स्विफ्ट 4.2 पर इसके साथ प्रयास किया है , उम्मीद है कि यह आपके लिए काम करेगा!

@IBDesignable class PaddingLabel: UILabel {

    @IBInspectable var topInset: CGFloat = 5.0
    @IBInspectable var bottomInset: CGFloat = 5.0
    @IBInspectable var leftInset: CGFloat = 7.0
    @IBInspectable var rightInset: CGFloat = 7.0

    override func drawText(in rect: CGRect) {
        let insets = UIEdgeInsets(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
        super.drawText(in: rect.inset(by: insets))
    }

    override var intrinsicContentSize: CGSize {
        let size = super.intrinsicContentSize
        return CGSize(width: size.width + leftInset + rightInset,
                      height: size.height + topInset + bottomInset)
    }   

    override var bounds: CGRect {
        didSet {
            // ensures this works within stack views if multi-line
            preferredMaxLayoutWidth = bounds.width - (leftInset + rightInset)
        }
    } 
}

या आप यहां पर कोकोपोड्स का उपयोग कर सकते हैं https://github.com/levantAJ/PaddingLabel

pod 'PaddingLabel', '1.2'

यहां छवि विवरण दर्ज करें


6
उलीबेल की चौड़ाई नहीं बदल रही है, जिससे पाठ "..." हो जाएगा
neobie

1
@ ताई ले, साझा करने के लिए धन्यवाद, मैंने इसका उपयोग टेबलव्यू में किया है, मुझे नहीं पता कि इसका पाठ ट्रिमिंग क्यों है, जैसे। छात्र
स्टूडेन्ट

1
@ शायद आप का उपयोग करने के लिए हैmin
ielyamani

4
चेतावनी का एक शब्द यहाँ। मैं इस समाधान का उपयोग एक यूआईबेल उपवर्ग में कर रहा हूं। एक ऊर्ध्वाधर UIStackView में, बहुस्तरीय मोड में इन लेबलों का उपयोग करते समय, एक समस्या होती है। कभी-कभी लेबल सही ढंग से लेबल को आकार दिए बिना पाठ को लपेटने लगता है - इसलिए एक शब्द या 2 स्ट्रिंग के अंत से गायब हो जाता है। मेरे पास अभी कोई हल नहीं है। अगर मैं एक बनाऊं तो मैं इसे यहां लिखूंगा। मैंने इस मुद्दे पर घंटों प्रहार किया, यह साबित करने से पहले कि यहां था।
डैरेन ब्लैक

1
उन स्थितियों में इसे काम करने के लिए, आपको "सेटबाउंड्स" को ओवरराइड करने और स्वयं को सेट करने की आवश्यकता है। ब्रेड की चौड़ाई के लिए सेल्फ्रेडरेडमैक्सलैटआउट के साथ, अपने बाएं और दाएं
इनसेट्स को घटाएं

82

स्विफ्ट 3

import UIKit

class PaddingLabel: UILabel {

   @IBInspectable var topInset: CGFloat = 5.0
   @IBInspectable var bottomInset: CGFloat = 5.0
   @IBInspectable var leftInset: CGFloat = 5.0
   @IBInspectable var rightInset: CGFloat = 5.0

   override func drawText(in rect: CGRect) {
      let insets = UIEdgeInsets(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
      super.drawText(in: UIEdgeInsetsInsetRect(rect, insets))
   }

   override var intrinsicContentSize: CGSize {
      get {
         var contentSize = super.intrinsicContentSize
         contentSize.height += topInset + bottomInset
         contentSize.width += leftInset + rightInset
         return contentSize
      }
   }
}

बस थोड़ी सी टिप्पणी: इस वर्ग को पहचान निरीक्षक (कस्टम वर्ग) में लेबल करने के लिए सेट करें और लेबल पैडिंग नामक विशेषता निरीक्षक में नई विशेषता का उपयोग करें। 5 पैडिंग के नीचे भी प्रभावहीन है
इमान काज़मायनी

3
यह हमेशा मल्टीलाइन लेबल के साथ सही ढंग से काम नहीं करता है, क्योंकि जब लेबल इसकी ऊंचाई की गणना करता है, तो यह शून्य पैडिंग मानता है।
फुकुओ

76

आप इसे आईबी से ठीक से कर सकते हैं:

  1. टेक्स्ट को एट्रिब्यूट में बदलें

पाठ को जिम्मेदार ठहराया

  1. "..." के साथ ड्रॉपडाउन सूची पर जाएं

यहां छवि विवरण दर्ज करें

  1. आप लाइनों, पैराग्राफ और पाठ परिवर्तन इंडेंट फर्स्ट लाइन या कुछ भी आप चाहते हैं के लिए कुछ गद्दी गुण देखेंगे

यहां छवि विवरण दर्ज करें

  1. परिणाम की जाँच करें

यहां छवि विवरण दर्ज करें


1
अपने स्टोरीबोर्ड में मैं टेक्स्ट परिवर्तन देख सकता हूं लेकिन जब मैं ऐप चलाता हूं। पाठ परिवर्तन नहीं दिखाता ... T_T .. मेरा लेबल एक कस्टम सेल के अंदर है, क्या कोई समस्या है?
ए। ट्रेजो

1
@ A.Trejo हो सकता है कि आपका कस्टम सेल रन टाइम पर लेबल प्रॉपर्टी सेट कर दे।
पियरे-यवेस गुइलेट

1
स्टोरीबोर्ड पर परिवर्तन दिखाई दे सकते हैं लेकिन जब आप ऐप चलाते हैं तो कोई बदलाव नहीं होता है।
रिंझ

4
यह तब लागू नहीं होता है जब आप प्रोग्राम को पाठ सेट करते हैं।
निज

1
इसका जवाब नहीं है। आपके पास केवल पहली पंक्ति के इंडेंट पर नियंत्रण है, सभी दिशाओं में पैडिंग नहीं है।
रोममेक्स

49

स्विफ्ट 4

समाधान का उपयोग करने के लिए आसान, परियोजना में सभी UILabel बच्चे के लिए उपलब्ध है।

उदाहरण:

let label = UILabel()
    label.<Do something>
    label.padding = UIEdgeInsets(top: 0, left: 16, bottom: 0, right: 0)

उइलाबेल एक्सटेंशन

import UIKit

extension UILabel {
    private struct AssociatedKeys {
        static var padding = UIEdgeInsets()
    }

    public var padding: UIEdgeInsets? {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.padding) as? UIEdgeInsets
        }
        set {
            if let newValue = newValue {
                objc_setAssociatedObject(self, &AssociatedKeys.padding, newValue as UIEdgeInsets?, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            }
        }
    }

    override open func draw(_ rect: CGRect) {
        if let insets = padding {
            self.drawText(in: rect.inset(by: insets))
        } else {
            self.drawText(in: rect)
        }
    }

    override open var intrinsicContentSize: CGSize {
        guard let text = self.text else { return super.intrinsicContentSize }

        var contentSize = super.intrinsicContentSize
        var textWidth: CGFloat = frame.size.width
        var insetsHeight: CGFloat = 0.0
        var insetsWidth: CGFloat = 0.0

        if let insets = padding {
            insetsWidth += insets.left + insets.right
            insetsHeight += insets.top + insets.bottom
            textWidth -= insetsWidth
        }

        let newSize = text.boundingRect(with: CGSize(width: textWidth, height: CGFloat.greatestFiniteMagnitude),
                                        options: NSStringDrawingOptions.usesLineFragmentOrigin,
                                        attributes: [NSAttributedString.Key.font: self.font], context: nil)

        contentSize.height = ceil(newSize.size.height) + insetsHeight
        contentSize.width = ceil(newSize.size.width) + insetsWidth

        return contentSize
    }
}

1
कृपया अपना उत्तर संक्षेप में बताएं, और केवल कोड को पोस्ट न करें।
lmiguelvargasf

4
आपका एक्सटेंशन numberOfLines 0 मूल्य को रद्द
एंटोनी Bodart

यह बहुत अच्छा है, लेकिन Im कई लाइनों के साथ समस्या है, यहां तक ​​कि मैंने सोचा कि मैं लाइनों की संख्या 2 या 0 पर छोड़ दूं, यह हमेशा एक दिखाता है। आप जानते हैं कि इसे कैसे हल किया जाए?
निकोलस पलासियोस

1
@AntoineBodart आपने नंबरऑफलाइन की समस्या को हल करने का प्रबंधन किया था?
निकोलस पलासियोस

@ AntoineBodart, @Mago निकोलस पलासियोस - हल किया गया था!
ईवगेन पॉडकोरटोव

47

बस UIViewएक पर्यवेक्षण के रूप में उपयोग करें और ऑटो लेआउट के साथ लेबल के लिए एक निश्चित मार्जिन को परिभाषित करें।


1
drawTextInRect केवल 1 पंक्ति के लिए काम करता है, intrinsicContentSizeक्षैतिज पैडिंग के साथ काम नहीं करता है। UIView के अंदर UILabel
लपेटने

8
यदि आप IB में हैं, तो मेनू संपादक को याद करने का समय आ गया है -> एंबेड इन -> दृश्य। बस अपने UILabel पहले का चयन करें :)
ग्राहम पर्क

46

बस एक UIButton का उपयोग करें, जो पहले से ही बनाया गया है। सभी अतिरिक्त बटन सुविधाओं को बंद करें और आपके पास एक लेबल है जिसे आप किनारे पर स्थापित कर सकते हैं।

let button = UIButton()
button.contentEdgeInsets = UIEdgeInsets(top: 5, left: 5, bottom: 5, right: 5)
button.setTitle("title", for: .normal)
button.tintColor = .white // this will be the textColor
button.isUserInteractionEnabled = false

2
हे यह एक महान टिप है! कोई एक्सटेंशन की आवश्यकता नहीं है! :
फेलिप फेर्री

2
isUserInteractionEnabled = falseइसे निष्क्रिय करना सेटिंग आसान है।
mxcl

महान टिप ... मैं इसके बजाय एक विस्तार के लिए जा रहा हूँ।
रोस

1
अच्छा टिप, बड़े लाभ के साथ कि यह इंटरफ़ेस बिल्डर में भी किया जा सकता है
एली

1
उपवर्ग और आदि के बिना सबसे अच्छा समाधान
MeGaPk

16

स्टोरीबोर्ड के बिना:

class PaddingLabel: UILabel {

    var topInset: CGFloat
    var bottomInset: CGFloat
    var leftInset: CGFloat
    var rightInset: CGFloat

    required init(withInsets top: CGFloat, _ bottom: CGFloat,_ left: CGFloat,_ right: CGFloat) {
        self.topInset = top
        self.bottomInset = bottom
        self.leftInset = left
        self.rightInset = right
        super.init(frame: CGRect.zero)
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override func drawText(in rect: CGRect) {
        let insets = UIEdgeInsets(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
        super.drawText(in: UIEdgeInsetsInsetRect(rect, insets))
    }

    override var intrinsicContentSize: CGSize {
        get {
            var contentSize = super.intrinsicContentSize
            contentSize.height += topInset + bottomInset
            contentSize.width += leftInset + rightInset
            return contentSize
        }
    }
}

उपयोग:

let label = PaddingLabel(8, 8, 16, 16)
label.font = .boldSystemFont(ofSize: 16)
label.text = "Hello World"
label.backgroundColor = .black
label.textColor = .white
label.textAlignment = .center
label.layer.cornerRadius = 8
label.clipsToBounds = true
label.sizeToFit()

view.addSubview(label)

परिणाम:


काम करता है, लेकिन क्या आप जानते हैं कि यह कई लाइनों को कैसे स्वीकार करता है? बस "पैडिंगलैबेल के साथ परिवर्तन (withInsets: 8, 8, 16, 16)"
कैमिलो ऑर्टगॉन

15

पैडिंग ए UILabel, पूर्ण समाधान। 2020 के लिए अद्यतन किया गया।

यह पता चला है कि वहाँ तीन चीजें हैं जो किया जाना चाहिए।

1. नए छोटे आकार के साथ textRect # forBounds कॉल करना चाहिए

2. नए छोटे आकार के साथ drawText को ओवरराइड करना चाहिए

3. यदि एक गतिशील रूप से आकार की सेल, को आंतरिक रूप से समायोजित करना चाहिए

नीचे दिए गए विशिष्ट उदाहरण में, टेक्स्ट यूनिट एक टेबल व्यू, स्टैक व्यू या इसी तरह के निर्माण में है, जो इसे एक निश्चित चौड़ाई देता है । उदाहरण में हम 60,20,20,24 की पैडिंग चाहते हैं।

इस प्रकार, हम "मौजूदा" इंट्रेंसिक कॉन्टेंटसाइज लेते हैं और वास्तव में ऊंचाई में 80 जोड़ते हैं

दोहराना ...

आपको सचमुच इंजन द्वारा "अब तक की गणना की गई ऊंचाई" प्राप्त करना होगा, और उस मूल्य को बदलना होगा

मुझे लगता है कि प्रक्रिया भ्रामक है, लेकिन, यह है कि यह कैसे काम करता है। मेरे लिए, Apple को "प्रारंभिक ऊंचाई गणना" जैसी किसी चीज़ का नाम उजागर करना चाहिए।

दूसरी बात यह है कि हमें वास्तव में textRect # forBounds call का उपयोग अपने नए छोटे आकार के साथ करना है

तो textRect # forBounds में हम पहले आकार को छोटा बनाते हैं और फिर सुपर कहते हैं।

चेतावनी! आप चाहिए सुपर फोन के बाद , पहले नहीं!

यदि आप इस पृष्ठ पर सभी प्रयासों और चर्चा की सावधानीपूर्वक जांच करते हैं, तो यह सटीक समस्या है। ध्यान दें कि कुछ समाधान "लगभग काम करने लगते हैं" लेकिन फिर कोई व्यक्ति रिपोर्ट करेगा कि कुछ स्थितियों में यह काम नहीं करेगा। यह वास्तव में सटीक कारण है - भ्रामक रूप से आपको "सुपर बाद में कॉल करना चाहिए", इससे पहले नहीं।

इसलिए, यदि आप इसे "गलत क्रम में" सुपर कहते हैं, तो यह आमतौर पर काम करता है, लेकिन कुछ विशिष्ट पाठ लंबाई के लिए नहीं

यहां "गलत तरीके से सुपर पहले करने" का एक सटीक दृश्य उदाहरण है:

यहां छवि विवरण दर्ज करें

ध्यान दें कि 60,20,20,24 मार्जिन सही हैं लेकिन आकार की गणना वास्तव में गलत है, क्योंकि यह textRect # forBounds में "सुपर फर्स्ट" पैटर्न के साथ किया गया था।

फिक्स्ड:

ध्यान दें कि केवल अब textRect # forBounds इंजन जानता है कि गणना ठीक से कैसे करें :

यहां छवि विवरण दर्ज करें

आखिरकार!

फिर, इस उदाहरण में यूआईबेल का उपयोग उस विशिष्ट स्थिति में किया जा रहा है जहां चौड़ाई तय की गई है। अत: आंतरिकसंबंध में हमें अपनी इच्छित समग्र अतिरिक्त ऊंचाई को "जोड़ना" होगा। (आपको चौड़ाई में किसी भी तरह से "जोड़ने" की आवश्यकता नहीं है, यह तय होने के साथ ही व्यर्थ होगा।)

फिर TextRect # फोरबाउंड्स में आपको ऑटोलैयट द्वारा "अब तक सुझाई गई सीमा" मिलती है, आप अपने मार्जिन को घटाते हैं, और उसके बाद ही textRect # forBounds इंजन को फिर से कॉल करते हैं, जो कि सुपर में कहना है, जो आपको एक परिणाम देगा।

अंत में और बस ड्रा में आप निश्चित रूप से उसी छोटे बॉक्स में आकर्षित करते हैं।

ओह!

let UIEI = UIEdgeInsets(top: 60, left: 20, bottom: 20, right: 24) // as desired

override var intrinsicContentSize:CGSize {
    numberOfLines = 0       // don't forget!
    var s = super.intrinsicContentSize
    s.height = s.height + UIEI.top + UIEI.bottom
    s.width = s.width + UIEI.left + UIEI.right
    return s
}

override func drawText(in rect:CGRect) {
    let r = rect.inset(by: UIEI)
    super.drawText(in: r)
}

override func textRect(forBounds bounds:CGRect,
                           limitedToNumberOfLines n:Int) -> CGRect {
    let b = bounds
    let tr = b.inset(by: UIEI)
    let ctr = super.textRect(forBounds: tr, limitedToNumberOfLines: 0)
    // that line of code MUST be LAST in this function, NOT first
    return ctr
}

एक बार फिर। ध्यान दें कि इस और अन्य QA के उत्तर जो "लगभग" सही हैं ऊपर की पहली छवि में समस्या है - "सुपर गलत जगह पर है" । आपको इंट्रेंसिक कॉन्टेंटसाइज में बड़े आकार को मजबूर करना होगा और फिर टेक्स्ट # फॉर्बाउंड में आपको पहले-पहले की सीमा को छोटा करना होगा और फिर सुपर कॉल करना होगा।

सारांश: आपको textRect # forBounds में " सुपर लास्ट " कॉल करना होगा

यही रहस्य है।

ध्यान दें कि आपको आवश्यकता नहीं है और इसके अतिरिक्त अमान्य, sizeThatFits, needLayout या किसी अन्य मजबूर कॉल को कॉल करने की आवश्यकता नहीं है। एक सही समाधान सामान्य ऑटोलैयूट ड्रॉ चक्र में ठीक से काम करना चाहिए।


सुझाव:

यदि आप मोनोपेस फोंट के साथ काम कर रहे हैं, तो यहां एक शानदार टिप दी गई है: https://stackoverflow.com/a/59813420/46444


11

स्विफ्ट 4+

class EdgeInsetLabel: UILabel {
    var textInsets = UIEdgeInsets.zero {
        didSet { invalidateIntrinsicContentSize() }
    }

    override func textRect(forBounds bounds: CGRect, limitedToNumberOfLines numberOfLines: Int) -> CGRect {
        let textRect = super.textRect(forBounds: bounds, limitedToNumberOfLines: numberOfLines)
        let invertedInsets = UIEdgeInsets(top: -textInsets.top,
                                          left: -textInsets.left,
                                          bottom: -textInsets.bottom,
                                          right: -textInsets.right)
        return textRect.inset(by: invertedInsets)
    }

    override func drawText(in rect: CGRect) {
        super.drawText(in: rect.inset(by: textInsets))
    } 
}

उपयोग:

let label = EdgeInsetLabel()
label.textInsets = UIEdgeInsets(top: 2, left: 6, bottom: 2, right: 6)

WAIT - वास्तव में एक समस्या है जो मुझे कुछ मामलों में इसके साथ मिली। पहले यह सबसे सही उत्तर था। मैंने नीचे सही उत्तर दिया है।
फटी

मैंने अपने जवाब में एक छवि शामिल की है जिसमें समस्या दिखाई दे रही है
फेटी

9

कार्यान्वयन उदाहरण के साथ स्विफ्ट 3 कोड

class UIMarginLabel: UILabel {

    var topInset:       CGFloat = 0
    var rightInset:     CGFloat = 0
    var bottomInset:    CGFloat = 0
    var leftInset:      CGFloat = 0

    override func drawText(in rect: CGRect) {
        let insets: UIEdgeInsets = UIEdgeInsets(top: self.topInset, left: self.leftInset, bottom: self.bottomInset, right: self.rightInset)
        self.setNeedsLayout()
        return super.drawText(in: UIEdgeInsetsInsetRect(rect, insets))
    }
}

class LabelVC: UIViewController {

    //Outlets
    @IBOutlet weak var labelWithMargin: UIMarginLabel!

    override func viewDidLoad() {
        super.viewDidLoad()

        //Label settings.
        labelWithMargin.leftInset = 10
        view.layoutIfNeeded()
    }
}

स्टोरीबोर्ड लेबल ऑब्जेक्ट में वर्ग नाम UIMarginLabel जोड़ना न भूलें। हैप्पी कोडिंग!


8

के अनुसार स्विफ्ट 4.2 (Xcode 10 बीटा 6) "UIEdgeInsetsInsetRect" बहिष्कृत किया जा रहा। मैंने इसे अधिक उपयोगी बनाने के लिए कक्षा को सार्वजनिक भी घोषित किया है।

public class UIPaddedLabel: UILabel {

    @IBInspectable var topInset: CGFloat = 5.0
    @IBInspectable var bottomInset: CGFloat = 5.0
    @IBInspectable var leftInset: CGFloat = 7.0
    @IBInspectable var rightInset: CGFloat = 7.0

    public override func drawText(in rect: CGRect) {
        let insets = UIEdgeInsets.init(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
        super.drawText(in: rect.inset(by: insets))
    }

    public override var intrinsicContentSize: CGSize {
        let size = super.intrinsicContentSize
        return CGSize(width: size.width + leftInset + rightInset,
                      height: size.height + topInset + bottomInset)
    }

    public override func sizeToFit() {
        super.sizeThatFits(intrinsicContentSize)
    }
}

यह अच्छा काम करता है। लेकिन मैं इसे एक कलेक्शन व्यू के अंदर इस्तेमाल करने की कोशिश करता हूं और यह फिर से उपयोग के बाद अच्छी तरह से आकार नहीं लेता है (आकार के बाद की घटना और लेआउटआईएफ़एनडेड)। किसी भी आईडी का आकार कैसे बदलना है?
बोगी

1
मैंने आकार बदलने के लिए अद्यतन किया था () यह पुन: प्रयोज्य दृश्य के साथ काम करने के लिए
बोगी

sizeToFit()सार्वजनिक रूप से होना चाहिए: "ओवरराइडिंग इंस्टेंस मेथड को उसके
एनक्लोजिंग

7

मैंने स्वीकृत उत्तर में थोड़ा संपादन किया। एक समस्या है जब leftInsetऔर rightInsetवृद्धि, पाठ का एक हिस्सा गायब हो जाएगा, बी / सी लेबल की चौड़ाई संकीर्ण हो जाएगी, लेकिन ऊंचाई आंकड़ा के रूप में नहीं बढ़ती है:

गलत आंतरिक सामग्री आकार के साथ पैडिंग लेबल

इस समस्या को हल करने के लिए आपको पाठ की ऊँचाई की गणना निम्नानुसार करनी होगी:

@IBDesignable class PaddingLabel: UILabel {

  @IBInspectable var topInset: CGFloat = 20.0
  @IBInspectable var bottomInset: CGFloat = 20.0
  @IBInspectable var leftInset: CGFloat = 20.0
  @IBInspectable var rightInset: CGFloat = 20.0

  override func drawTextInRect(rect: CGRect) {
    let insets = UIEdgeInsets(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
    super.drawTextInRect(UIEdgeInsetsInsetRect(rect, insets))
  }

  override func intrinsicContentSize() -> CGSize {
    var intrinsicSuperViewContentSize = super.intrinsicContentSize()

    let textWidth = frame.size.width - (self.leftInset + self.rightInset)
    let newSize = self.text!.boundingRectWithSize(CGSizeMake(textWidth, CGFloat.max), options: NSStringDrawingOptions.UsesLineFragmentOrigin, attributes: [NSFontAttributeName: self.font], context: nil)
    intrinsicSuperViewContentSize.height = ceil(newSize.size.height) + self.topInset + self.bottomInset

    return intrinsicSuperViewContentSize
  }
}

और परिणाम:

सही आंतरिक सामग्री आकार के साथ पैडिंग लेबल

मुझे उम्मीद है कि मेरी तरह कुछ लोग भी उसी स्थिति में मदद करेंगे।


2
यदि आप स्विफ्ट 3.0 का उपयोग करने की योजना बनाते हैं , तो आपको फ़ंक्शन नामों को बदलना होगा, क्योंकि नई ऐप्पल भाषा पूरी तरह से पिछली फ़ंक परिभाषा को तोड़ देती है। तो, override func drawTextInRect(rect: CGRect)हो जाता है override func drawText(in rect: CGRect)और override func intrinsicContentSize() -> CGSizeहो जाता है override var intrinsicContentSize : CGSize का आनंद लें!
20

दुर्भाग्य से मैंने यह काम नहीं किया। मैंने हमारे कोड स्विफ्ट 5 override var intrinsicContentSize: CGSize { // .. return intrinsicSuperViewContentSize }
नज़्मुल हसन

7

उपवर्ग के बिना एक और विकल्प होगा:

  1. लेबल सेट करें text
  2. sizeToFit()
  3. फिर पैडिंग अनुकरण करने के लिए लेबल की ऊंचाई को थोड़ा बढ़ाएं

    label.text = "someText"
    label.textAlignment = .center    
    label.sizeToFit()  
    label.frame = CGRect( x: label.frame.x, y: label.frame.y,width:  label.frame.width + 20,height: label.frame.height + 8)

हैरानी की बात है, यह सब मुझे जरूरत थी, बस थोड़ा संशोधित करने के लिए: label.frame = CGRect( x: label.frame.origin.x - 10, y: label.frame.origin.y - 4, width: label.frame.width + 20,height: label.frame.height + 8)-10 और -4 केंद्रीकरण के लिए
Mofe Ejegi

6

स्विफ्ट 3, iOS10 समाधान:

open class UIInsetLabel: UILabel {

    open var insets : UIEdgeInsets = UIEdgeInsets() {
        didSet {
            super.invalidateIntrinsicContentSize()
        }
    }

    open override var intrinsicContentSize: CGSize {
        var size = super.intrinsicContentSize
        size.width += insets.left + insets.right
        size.height += insets.top + insets.bottom
        return size
    }

    override open func drawText(in rect: CGRect) {
        return super.drawText(in: UIEdgeInsetsInsetRect(rect, insets))
    }
}

6

बस ऑटोलयूट का उपयोग करें:

let paddedWidth = myLabel.intrinsicContentSize.width + 2 * padding
myLabel.widthAnchor.constraint(equalToConstant: paddedWidth).isActive = true

किया हुआ।


आप ऊंचाई के साथ भी ऐसा कर सकते हैं।
ShadeToD

6

स्विफ्ट 3 में

सबसे अच्छा और सरल तरीका

class UILabelPadded: UILabel {
     override func drawText(in rect: CGRect) {
     let insets = UIEdgeInsets.init(top: 0, left: 5, bottom: 0, right: 5)
     super.drawText(in: UIEdgeInsetsInsetRect(rect, insets))
    }

}

4

उपक्लास उइलाबेल। (फाइल-न्यू-फाइल- कोकोआटाउटक्लास-यूआईलेबेल का उपवर्ग)।

//  sampleLabel.swift

import UIKit

class sampleLabel: UILabel {

 let topInset = CGFloat(5.0), bottomInset = CGFloat(5.0), leftInset = CGFloat(8.0), rightInset = CGFloat(8.0)

 override func drawTextInRect(rect: CGRect) {

  let insets: UIEdgeInsets = UIEdgeInsets(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
  super.drawTextInRect(UIEdgeInsetsInsetRect(rect, insets))

 }
 override func intrinsicContentSize() -> CGSize {
  var intrinsicSuperViewContentSize = super.intrinsicContentSize()
  intrinsicSuperViewContentSize.height += topInset + bottomInset
  intrinsicSuperViewContentSize.width += leftInset + rightInset
  return intrinsicSuperViewContentSize
 }
}

ViewController पर:

override func viewDidLoad() {
  super.viewDidLoad()

  let labelName = sampleLabel(frame: CGRectMake(0, 100, 300, 25))
  labelName.text = "Sample Label"
  labelName.backgroundColor =  UIColor.grayColor()

  labelName.textColor = UIColor.redColor()
  labelName.shadowColor = UIColor.blackColor()
  labelName.font = UIFont(name: "HelveticaNeue", size: CGFloat(22))
  self.view.addSubview(labelName)
 }

या लेबल के वर्ग के रूप में स्टोरीबोर्ड पर कस्टम यूआईलेबेल वर्ग।


यदि आप उन हार्डकोड मानों को वर्ग गुणों में बदलते हैं, तो मैं वोट करूंगा, मैं पहले से ही इस कोड का उपयोग कर रहा हूं।
जुआन बोईरो

@ जुआन: drawTextInRect, UILabel की एक डिफ़ॉल्ट श्रेणी की संपत्ति है जिसे हम कोड का उपयोग करके ओवरराइड करने में असमर्थ हैं। UILabel को उप-वर्ग करने और आवश्यक फ़्रेम परिवर्तन जोड़ने के लिए सबसे अच्छा अभ्यास। किसी भी तरह, यह विरासत सुविधा के रूप में सुविधाजनक है।
एजी

यह सही है, हालांकि स्विफ्ट 3 के रूप में कम से कम, intrinsicContentSize एक फ़ंक्शन नहीं है, बल्कि एक संपत्ति है, इसलिए "ओवरराइड फंक intrinsicContentSize" के बजाय "var intrinsicContentSize: CGFloat {}" को ओवरराइड करना चाहिए, बस एक नोट।
जॉय

4

अन्य उत्तरों की तरह लेकिन एक बग को ठीक करें। जब label.widthऑटो लेआउट द्वारा नियंत्रित किया जाता है, तो कभी-कभी पाठ को काट दिया जाएगा।

@IBDesignable
class InsetLabel: UILabel {

    @IBInspectable var topInset: CGFloat = 4.0
    @IBInspectable var leftInset: CGFloat = 4.0
    @IBInspectable var bottomInset: CGFloat = 4.0
    @IBInspectable var rightInset: CGFloat = 4.0

    var insets: UIEdgeInsets {
        get {
            return UIEdgeInsets.init(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
        }
        set {
            topInset = newValue.top
            leftInset = newValue.left
            bottomInset = newValue.bottom
            rightInset = newValue.right
        }
    }

    override func sizeThatFits(_ size: CGSize) -> CGSize {
        var adjSize = super.sizeThatFits(size)
        adjSize.width += leftInset + rightInset
        adjSize.height += topInset + bottomInset
        return adjSize
    }

    override var intrinsicContentSize: CGSize {
        let systemContentSize = super.intrinsicContentSize
        let adjustSize = CGSize(width: systemContentSize.width + leftInset + rightInset, height: systemContentSize.height + topInset +  bottomInset) 
        if adjustSize.width > preferredMaxLayoutWidth && preferredMaxLayoutWidth != 0 {
            let constraintSize = CGSize(width: bounds.width - (leftInset + rightInset), height: .greatestFiniteMagnitude)
            let newSize = super.sizeThatFits(constraintSize)
            return CGSize(width: systemContentSize.width, height: ceil(newSize.height) + topInset + bottomInset)
        } else {
            return adjustSize
        }
    }

    override func drawText(in rect: CGRect) {
        super.drawText(in: rect.inset(by: insets))
    }
}

2

आसान पैडिंग (स्विफ्ट 3.0, एल्विन जॉर्ज उत्तर):

  class NewLabel: UILabel {

        override func textRect(forBounds bounds: CGRect, limitedToNumberOfLines numberOfLines: Int) -> CGRect {
                return self.bounds.insetBy(dx: CGFloat(15.0), dy: CGFloat(15.0))
        }

        override func draw(_ rect: CGRect) {
                super.drawText(in: self.bounds.insetBy(dx: CGFloat(5.0), dy: CGFloat(5.0)))
        }

  }

2

मुंडी के उत्तर पर विस्तार।

यानी एक लेबल को एम्बेड करना UIViewऔर ऑटो लेआउट के माध्यम से पैडिंग को लागू करना। उदाहरण:

एक गद्देदार UILabel की तरह दिखता है

अवलोकन:

1) एक UIView("पैनल" ) बनाएं , और इसकी उपस्थिति निर्धारित करें।

2) एक बनाएँ UILabelऔर पैनल में जोड़ें।

3) पैडिंग को लागू करने के लिए बाधाओं को जोड़ें।

4) पैनल को अपने दृश्य पदानुक्रम में जोड़ें, फिर पैनल को स्थिति दें।

विवरण:

1) पैनल व्यू बनाएं।

let panel = UIView()
panel.backgroundColor = .green
panel.layer.cornerRadius = 12

2) लेबल बनाएं, इसे सबव्यू के रूप में पैनल में जोड़ें।

let label = UILabel()
panel.addSubview(label)

3) लेबल और पैनल के किनारों के बीच की बाधाओं को जोड़ें। यह पैनल को लेबल से दूरी बनाए रखने के लिए मजबूर करता है। "पैडिंग"

संपादकीय: हाथ से यह सब करना अति-कठिन, क्रियात्मक और त्रुटि-प्रवण है। मेरा सुझाव है कि आप जीथब से एक ऑटो लेआउट रैपर चुनें या एक स्वयं लिखें

label.panel.translatesAutoresizingMaskIntoConstraints = false
label.topAnchor.constraint(equalTo: panel.topAnchor,
    constant: vPadding).isActive = true
label.bottomAnchor.constraint(equalTo: panel.bottomAnchor,
    constant: -vPadding).isActive = true
label.leadingAnchor.constraint(equalTo: panel.leadingAnchor,
    constant: hPadding).isActive = true
label.trailingAnchor.constraint(equalTo: panel.trailingAnchor,
    constant: -hPadding).isActive = true

label.textAlignment = .center

4) पैनल को अपने दृश्य पदानुक्रम में जोड़ें और फिर स्थिति की कमी जोड़ें। उदाहरण के चित्र में जैसा कि एक TableViewCell के दाहिने हाथ को गले लगाते हैं।

नोट: आपको केवल स्थितिगत बाधाओं को जोड़ने की आवश्यकता है, न कि आयामी बाधाओं: ऑटो लेआउट intrinsicContentSizeलेबल के दोनों और पहले जोड़े गए बाधाओं के आधार पर लेआउट को हल करेगा ।

hostView.addSubview(panel)
panel.translatesAutoresizingMaskIntoConstraints = false
panel.trailingAnchor.constraint(equalTo: hostView.trailingAnchor,
    constant: -16).isActive = true
panel.centerYAnchor.constraint(equalTo: hostView.centerYAnchor).isActive = true

2

यदि आप पेडिंग लगाते समय टेक्स्ट ट्रिमिंग की समस्या का सामना कर रहे हैं तो इस कोड का उपयोग करें।

@IBDesignable class PaddingLabel: UILabel {

    @IBInspectable var topInset: CGFloat = 5.0
    @IBInspectable var bottomInset: CGFloat = 5.0
    @IBInspectable var leftInset: CGFloat = 5.0
    @IBInspectable var rightInset: CGFloat = 5.0

    override func drawText(in rect: CGRect) {
        let insets = UIEdgeInsets.init(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
        super.drawText(in: UIEdgeInsetsInsetRect(rect, insets))
    }

    override var intrinsicContentSize: CGSize {
        var intrinsicSuperViewContentSize = super.intrinsicContentSize
        let textWidth = frame.size.width - (self.leftInset + self.rightInset)
        let newSize = self.text!.boundingRect(with: CGSize(textWidth, CGFloat.greatestFiniteMagnitude), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSFontAttributeName: self.font], context: nil)
        intrinsicSuperViewContentSize.height = ceil(newSize.size.height) + self.topInset + self.bottomInset
        return intrinsicSuperViewContentSize
    }
}

extension CGSize{
    init(_ width:CGFloat,_ height:CGFloat) {
        self.init(width:width,height:height)
    }
}

पोस्ट करने के लिए धन्यवाद, मैं एक समाधान के लिए देख रहा हूँ पैडिंग + ट्रिमिंग। यह मुझे लगता है कि आपका समाधान लेबल .numberOfLines = 0 को तोड़ता है जिसकी मुझे आवश्यकता है। कोई वर्कअराउंड?
डॉन

1

अन्य उत्तरों के समान है, लेकिन डेडिक सेटअप करने के लिए फंक क्लास के साथ:

class UILabelExtendedView: UILabel
{
    var topInset: CGFloat = 4.0
    var bottomInset: CGFloat = 4.0
    var leftInset: CGFloat = 8.0
    var rightInset: CGFloat = 8.0

    override func drawText(in rect: CGRect)
    {
        let insets: UIEdgeInsets = UIEdgeInsets(top: topInset, left: leftInset, bottom: bottomInset, right: rightInset)
        super.drawText(in: UIEdgeInsetsInsetRect(rect, insets))
    }

    override public var intrinsicContentSize: CGSize
    {
        var contentSize = super.intrinsicContentSize
        contentSize.height += topInset + bottomInset
        contentSize.width += leftInset + rightInset
        return contentSize
    }

    func setPadding(top: CGFloat, left: CGFloat, bottom: CGFloat, right: CGFloat){
        self.topInset = top
        self.bottomInset = bottom
        self.leftInset = left
        self.rightInset = right
        let insets: UIEdgeInsets = UIEdgeInsets(top: top, left: left, bottom: bottom, right: right)
        super.drawText(in: UIEdgeInsetsInsetRect(self.frame, insets))
    }
}

1

एक व्यावहारिक समाधान मुख्य ऊंचाई के रूप में एक ही ऊंचाई और रंग के रिक्त लेबल को जोड़ना है। मुख्य लेबल के लिए अग्रणी / अनुगामी स्थान को शून्य पर सेट करें, ऊर्ध्वाधर केंद्रों को संरेखित करें, और चौड़ाई को अपना वांछित मार्जिन बनाएं।


1

यदि आप TextRect के चारों ओर 2px पैडिंग जोड़ना चाहते हैं, तो बस यह करें:

let insets = UIEdgeInsets(top: -2, left: -2, bottom: -2, right: -2)
label.frame = UIEdgeInsetsInsetRect(textRect, insets)

TextRect क्या है? लेबल फ्रेम?
गुस्तावो बायोची कोस्टा

1

यदि आप स्टोरीबोर्ड में एक @IBInspectable / @IBDesignable UILabel का उपयोग करना चाहते हैं या नहीं करना चाहते हैं (मुझे लगता है कि वे वैसे भी बहुत धीमी गति से प्रदान किए जाते हैं), तो यह 4 अलग CGGloats के बजाय UIEdgeInsets का उपयोग करने के लिए क्लीनर है।

स्विफ्ट 4.2 के लिए कोड उदाहरण:

class UIPaddedLabel: UILabel {
    var padding = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)

    public override func drawText(in rect: CGRect) {
        super.drawText(in: rect.inset(by: padding))
    }

    public override var intrinsicContentSize: CGSize {
        let size = super.intrinsicContentSize
        return CGSize(width: size.width + padding.left + padding.right,
                      height: size.height + padding.top + padding.bottom)
    }
}

1

उद्देश्य सी

ताई ले के आधार पर वहाँ एक आईबी डिजाइन के अंदर की सुविधा को लागू करता है, यहाँ उद्देश्य-सी संस्करण लागू करता है।

इसे YourLabel.h में डालें

@interface YourLabel : UILabel

@property IBInspectable CGFloat topInset;
@property IBInspectable CGFloat bottomInset;
@property IBInspectable CGFloat leftInset;
@property IBInspectable CGFloat rightInset;

@end

और यह YourLabel.m में जाएगा

IB_DESIGNABLE

@implementation YourLabel

#pragma mark - Super

- (instancetype)initWithCoder:(NSCoder *)aDecoder {
    self = [super initWithCoder:aDecoder];
    if (self) {
        self.topInset = 0;
        self.bottomInset = 0;
        self.leftInset = 0;
        self.rightInset = 0;
    }
    return self;
}

- (void)drawTextInRect:(CGRect)rect {
    UIEdgeInsets insets = UIEdgeInsetsMake(self.topInset, self.leftInset, self.bottomInset, self.rightInset);
    [super drawTextInRect:UIEdgeInsetsInsetRect(rect, insets)];
}

- (CGSize)intrinsicContentSize {

    CGSize size = [super intrinsicContentSize];
    return CGSizeMake(size.width + self.leftInset + self.rightInset,
                      size.height + self.topInset + self.bottomInset);
}

@end

XIB या स्टोरीबोर्ड के अंदर वर्ग को निर्दिष्ट करने के बाद आप अपने येलबेल इनसेट्स को सीधे इंटरफ़ेस बिल्डर में संशोधित कर सकते हैं, इनसेट्स का डिफ़ॉल्ट मान शून्य हो रहा है।


0

आसान तरीका

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        self.view.addSubview(makeLabel("my title",x: 0, y: 100, w: 320, h: 30))
    }

    func makeLabel(title:String, x:CGFloat, y:CGFloat, w:CGFloat, h:CGFloat)->UILabel{
        var myLabel : UILabel = UILabel(frame: CGRectMake(x,y,w,h))
        myLabel.textAlignment = NSTextAlignment.Right

        // inser last char to right
        var titlePlus1char = "\(title)1"
        myLabel.text = titlePlus1char
        var titleSize:Int = count(titlePlus1char)-1

        myLabel.textColor = UIColor(red:1.0, green:1.0,blue:1.0,alpha:1.0)
        myLabel.backgroundColor = UIColor(red: 214/255, green: 167/255, blue: 0/255,alpha:1.0)


        // create myMutable String
        var myMutableString = NSMutableAttributedString()

        // create myMutable font
        myMutableString = NSMutableAttributedString(string: titlePlus1char, attributes: [NSFontAttributeName:UIFont(name: "HelveticaNeue", size: 20)!])

        // set margin size
        myMutableString.addAttribute(NSFontAttributeName, value: UIFont(name: "HelveticaNeue", size: 10)!, range: NSRange(location: titleSize,length: 1))

        // set last char to alpha 0
        myMutableString.addAttribute(NSForegroundColorAttributeName, value: UIColor(red:1.0, green:1.0,blue:1.0,alpha:0), range: NSRange(location: titleSize,length: 1))

        myLabel.attributedText = myMutableString

        return myLabel
    }


    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

}

0

आसान गद्दी:

import UIKit

    class NewLabel: UILabel {

        override func textRectForBounds(bounds: CGRect, limitedToNumberOfLines numberOfLines: Int) -> CGRect {

            return CGRectInset(self.bounds, CGFloat(15.0), CGFloat(15.0))
        }

        override func drawRect(rect: CGRect) {

            super.drawTextInRect(CGRectInset(self.bounds,CGFloat(5.0), CGFloat(5.0)))
        }

    }

निचले पृष्ठ पर 3.0 संस्करण
ओडेमोलिएन्स

0

स्विफ्ट 4+

let paragraphStyle = NSMutableParagraphStyle()
paragraphStyle.firstLineHeadIndent = 10

// Swift 4.2++
label.attributedText = NSAttributedString(string: "Your text", attributes: [NSAttributedString.Key.paragraphStyle: paragraphStyle])

// Swift 4.1--
label.attributedText = NSAttributedString(string: "Your text", attributes: [NSAttributedStringKey.paragraphStyle: paragraphStyle])
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.