Jak kontrolować odstępy między wierszami w UILabel


273

Czy jest możliwe zmniejszenie odstępu między tekstem, gdy jest on umieszczony w wielu wierszach UILabel? Możemy ustawić ramkę, rozmiar czcionki i liczbę linii. Chcę zmniejszyć odstęp między dwiema liniami w tej etykiecie.



2
Czy mogę zasugerować, aby zaakceptować jedną z poprawnych odpowiedzi na iOS 6.0 i nowsze? Aktualnie akceptowana odpowiedź jest nieaktualna.
Mark Amery

Dla każdej linii użyj nowej UILabel, a następnie umieść wszystkie etykiety w StackView. Wreszcie wyregulować spacingod StackView. Pamiętaj, aby układać je pionowo.
Honey,

Zobacz poniższy link do rozwiązania w Swift 2. stackoverflow.com/a/39158698/6602495
Sneha

Zobacz stackoverflow.com/a/44325650/342794, aby uzyskać informacje na temat ulepszenia scenorysu i innych szczegółów.
lal

Odpowiedzi:


261

Pomyślałem o dodaniu czegoś nowego do tej odpowiedzi, więc nie czuję się tak źle ... Oto szybka odpowiedź:

import Cocoa

let paragraphStyle = NSMutableParagraphStyle()
paragraphStyle.lineSpacing = 40

let attrString = NSMutableAttributedString(string: "Swift Answer")
attrString.addAttribute(.paragraphStyle, value:paragraphStyle, range:NSMakeRange(0, attrString.length))

var tableViewCell = NSTableCellView()
tableViewCell.textField.attributedStringValue = attrString

„Krótka odpowiedź: nie możesz. Aby zmienić odstępy między wierszami tekstu, musisz podklasować UILabel i rzucić własny drawTextInRect lub utworzyć wiele etykiet.”

Zobacz: Ustaw odstępy między wierszami UILabel


To jest naprawdę stara odpowiedź, a inni dodali już nowy i lepszy sposób na poradzenie sobie z tym .. Zobacz aktualne odpowiedzi poniżej.


23
Od iOS 6.0 możesz go kontrolować za pomocą NSAttributedString(dostępnego również we właściwościach UILable w kreatorze interfejsów Xcode).
ǝʞɾɾǝʞ

13
Co ciekawe, tak blisko, jak mogę powiedzieć, możesz dodać dodatkowe odstępy między liniami, ale nie zmniejszać go za NSParagraphStylepomocą NSAttributedString. (Być może będę musiał przeprowadzić więcej testów innych modyfikowalnych właściwości, ale ta lineSpacingwłaściwość pozwala tylko na jej zwiększenie).
livingtech 12.09.2013

zobacz moją odpowiedź, aby zobaczyć sposób korzystania z NSAttributString
d.ennis

2
@livingtech To jest denerwujące i uważam, że masz rację. Czy znalazłeś jakieś obejścia?
Dom Vinyard

7
Aby wyjaśnić coś w tym wątku. Jeśli chcesz zmniejszyć odstępy między wierszami, ustaw wysokość wiersza na 1,0, a następnie ustaw wartość LineLeHeightMultiple na niższą wartość <1,0, na przykład: [paragraphStyle setLineHeightMultiple: 0,8] lub paragraphStyle.lineHeightMultiple = 0,8
niedziela,

401

W Xcode 6 możesz to zrobić w serii ujęć:

wprowadź opis zdjęcia tutaj


1
Wykorzystaj więcej zalet scenorysu!
Allen,

22
@PaperThick ma ten sam problem w 6.1.1. „Harlem wstrząsa” przez kilka minut. Nie wie, jak to naprawić :) Xcode Shaking
Anton Gaenko

8
Czy istnieje sposób ustawienia niestandardowych czcionek w ten sposób? Nie mogę zmienić tej helvetica neue na żadną inną czcionkę.
Marcos Curvello,

2
Jeśli włączysz opcję „Atrybut”, a następnie otworzysz plik jako kod źródłowy, możesz ręcznie edytować „lineHeightMultiple”, a zatem ominąć błąd Harlem Shake
ED-209

2
@azdev dla każdego, kto wciąż na to patrzy, coraz dłużej drżę w Xcode 7.3, ale myślę, że jest to pierwsza wersja, w której nie było problemu
LulzCow

103

Począwszy od iOS 6 możesz ustawić przypisany ciąg do UILabel. Sprawdź następujące:

NSMutableAttributedString *attributedString = [[NSMutableAttributedString alloc] initWithString:label.text];
NSMutableParagraphStyle *paragraphStyle = [[NSMutableParagraphStyle alloc] init];
paragraphStyle.lineSpacing = spacing;
[attributedString addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:NSMakeRange(0, label.text.length)];

label.attributedText = attributedString;

1
attributedStringMusi być NSMutableAttributedString(NIE NSAttributedString)
Mike S

14
Pierwszym kodem linii powinien byćNSMutableAttributedString *attributedString = [NSMutableAttributedString alloc]initWithString:@"sample text"];
Allen

lineSpacingNieruchomość z NSMutableParagraphStylenigdy nie jest ujemny, więc wysokość linii nie może być zredukowana z tym podejściem. Aby odpowiedzieć na pytanie, musisz użyć innej właściwości, patrz @ d.ennis odpowiedź.
Theo

81

Przedstawione tutaj rozwiązania nie działały dla mnie. Znalazłem nieco inny sposób na zrobienie tego za pomocą NSAttributeString dla iOS 6:

myLabel.numberOfLines = 0; 
NSString* string = @"String with line one. \n Line two. \n Line three.";
NSMutableParagraphStyle *style  = [[NSMutableParagraphStyle alloc] init];
style.minimumLineHeight = 30.f;
style.maximumLineHeight = 30.f;
NSDictionary *attributtes = @{NSParagraphStyleAttributeName : style,};
myLabel.attributedText = [[NSAttributedString alloc] initWithString:string
                                                         attributes:attributtes];   
[myLabel sizeToFit];

1
Wysokość linii zależy od wielkości czcionki. Odstępy między wierszami to po prostu odstępy między wierszami. Możesz zacząć działać, ustawiając minimalną / maksymalną wysokość linii, ale to tylko dlatego, że bieżące rozmiary czcionek, których używasz, nie są większe niż granice wysokości linii. Zgodnie z dokumentacją: „... glify i grafika przekraczające tę wysokość będą nakładały się na sąsiednie linie ... Chociaż ten limit dotyczy samej linii, odstępy między liniami zwiększają przestrzeń między sąsiadującymi liniami”.
Ari Braginsky

+1, jeśli chcesz zmniejszyć odstępy między liniami, to właśnie chcesz zrobić. Rzeczywiste odstępy między wierszami to domyślnie 0, dlatego ludzie zgłaszają, że możesz je tylko zwiększyć. Problem ze zbyt dużymi odstępami wynika z faktu, że wysokość linii jest zbyt duża, dlatego wykona to zadanie w 99% przypadków.
lawicko

1
To jedyna odpowiedź, jaką mogłem znaleźć, która korzysta z rzeczywistej wartości wysokości linii (zamiast stosunku) wspólnej dla aplikacji do projektowania, takich jak Photoshop, Sketch, CSS itp.
Albert Bori

35

Stworzyłem to proste rozszerzenie, które działa dla mnie bardzo dobrze:

extension UILabel {
    func setLineHeight(lineHeight: CGFloat) {
        let paragraphStyle = NSMutableParagraphStyle()
        paragraphStyle.lineSpacing = 1.0
        paragraphStyle.lineHeightMultiple = lineHeight
        paragraphStyle.alignment = self.textAlignment

        let attrString = NSMutableAttributedString()
        if (self.attributedText != nil) {
            attrString.append( self.attributedText!)
        } else {
            attrString.append( NSMutableAttributedString(string: self.text!))
            attrString.addAttribute(NSAttributedStringKey.font, value: self.font, range: NSMakeRange(0, attrString.length))
        }
        attrString.addAttribute(NSAttributedStringKey.paragraphStyle, value:paragraphStyle, range:NSMakeRange(0, attrString.length))
        self.attributedText = attrString
    }
}

Skopiuj to do pliku, abyś mógł użyć go w ten sposób

myLabel.setLineHeight(0.7)

pamiętaj, jeśli robisz to, gdy używasz Storyboard dla tej etykiety, a następnie ustaw linie etykiety na 0
Honey

Dlaczego po prostu nie ustawisz bezpośrednio lineSpacingi zapomnisz o ustawieniu lineHeightMultiple?
Honey,

Ponieważ kluczem do zmniejszenia wysokości linii jest „lineHeightMultiple”, brak odstępu między wierszami
Agustin Meriles

powiedz, że chcesz, aby wysokość twojej linii wynosiła 1,4, dlaczego nie możesz po prostu napisać .lineSpacing = 1.4i zapomnieć o .lineHeightMultiple...
Honey

Hah! Próbowałem i nie działałem, ale zastanawiam się, dlaczego nie widzę tutaj innych odpowiedzi, które nie używają twojego mechanizmu, to znaczy, że po prostu ustawiają odstęp liniowy. Zobacz zaakceptowaną odpowiedź ...
Honey,

33

Z interfejsu Builder (Storyboard / XIB):

wprowadź opis zdjęcia tutaj

Programowo:

SWift 4

Korzystanie z rozszerzenia etykiety

extension UILabel {

    // Pass value for any one of both parameters and see result
    func setLineSpacing(lineSpacing: CGFloat = 0.0, lineHeightMultiple: CGFloat = 0.0) {

        guard let labelText = self.text else { return }

        let paragraphStyle = NSMutableParagraphStyle()
        paragraphStyle.lineSpacing = lineSpacing
        paragraphStyle.lineHeightMultiple = lineHeightMultiple

        let attributedString:NSMutableAttributedString
        if let labelattributedText = self.attributedText {
            attributedString = NSMutableAttributedString(attributedString: labelattributedText)
        } else {
            attributedString = NSMutableAttributedString(string: labelText)
        }

        // Line spacing attribute
        attributedString.addAttribute(NSAttributedStringKey.paragraphStyle, value:paragraphStyle, range:NSMakeRange(0, attributedString.length))

        self.attributedText = attributedString
    }
}

Teraz zadzwoń do funkcji rozszerzenia

let label = UILabel()
let stringValue = "How to\ncontrol\nthe\nline spacing\nin UILabel"

// Pass value for any one argument - lineSpacing or lineHeightMultiple
label.setLineSpacing(lineSpacing: 2.0) .  // try values 1.0 to 5.0

// or try lineHeightMultiple
//label.setLineSpacing(lineHeightMultiple = 2.0) // try values 0.5 to 2.0

Lub za pomocą instancji etykiety (wystarczy skopiować i wykonać ten kod, aby zobaczyć wynik)

let label = UILabel()
let stringValue = "How to\ncontrol\nthe\nline spacing\nin UILabel"
let attrString = NSMutableAttributedString(string: stringValue)
var style = NSMutableParagraphStyle()
style.lineSpacing = 24 // change line spacing between paragraph like 36 or 48
style.minimumLineHeight = 20 // change line spacing between each line like 30 or 40

// Line spacing attribute
attrString.addAttribute(NSAttributedStringKey.paragraphStyle, value: style, range: NSRange(location: 0, length: stringValue.characters.count))

// Character spacing attribute
attrString.addAttribute(NSAttributedStringKey.kern, value: 2, range: NSMakeRange(0, attrString.length))

label.attributedText = attrString

Szybki 3

let label = UILabel()
let stringValue = "How to\ncontrol\nthe\nline spacing\nin UILabel"
let attrString = NSMutableAttributedString(string: stringValue)
var style = NSMutableParagraphStyle()
style.lineSpacing = 24 // change line spacing between paragraph like 36 or 48
style.minimumLineHeight = 20 // change line spacing between each line like 30 or 40
attrString.addAttribute(NSParagraphStyleAttributeName, value: style, range: NSRange(location: 0, length: stringValue.characters.count))
label.attributedText = attrString

2
Dodaj wiersz „paragraphStyle.alignment = self.textAlignment”, aby zachować oryginalne wyrównanie. W przeciwnym razie tekst zostanie wyrównany do lewej.
Nithin Michael,

Dla każdego, kto traci elipsę na dużych tekstach, użyj: paragraphStyle.lineBreakMode = .byTruncatingTail
christostsang



11

W Swift i jako funkcja, inspirowana DarkDust

// Usage: setTextWithLineSpacing(myEpicUILabel,text:"Hello",lineSpacing:20)
func setTextWithLineSpacing(label:UILabel,text:String,lineSpacing:CGFloat)
{
    let paragraphStyle = NSMutableParagraphStyle()
    paragraphStyle.lineSpacing = lineSpacing

    let attrString = NSMutableAttributedString(string: text)
    attrString.addAttribute(NSAttributedString.Key.paragraphStyle, value:paragraphStyle, range:NSMakeRange(0, attrString.length))

    label.attributedText = attrString
}

7

Zgodnie z odpowiedzią @ Mike'a kluczowe jest zmniejszenie lineHeightMultiple. Przykład poniżej, działa dobrze dla mnie:

    NSString* text = label.text;
    CGFloat textWidth = [text sizeWithAttributes:@{NSFontAttributeName: label.font}].width;
    if (textWidth > label.frame.size.width) {
        NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
        paragraph.alignment = NSTextAlignmentCenter;
        paragraph.lineSpacing = 1.0f;
        paragraph.lineHeightMultiple = 0.75;     // Reduce this value !!!
        NSMutableAttributedString* attrText = [[NSMutableAttributedString alloc] initWithString:text];
        [attrText addAttribute:NSParagraphStyleAttributeName value:paragraph range:NSMakeRange(0, text.length)];
        label.attributedText = attrText;
    }

6

SWIFT 3 przydatne rozszerzenie do łatwiejszego ustawiania odstępu między wierszami :)

extension UILabel
{
    func setLineHeight(lineHeight: CGFloat)
    {
        let text = self.text
        if let text = text 
        {

            let attributeString = NSMutableAttributedString(string: text)
            let style = NSMutableParagraphStyle()

           style.lineSpacing = lineHeight
           attributeString.addAttribute(NSParagraphStyleAttributeName,
                                        value: style,
                                        range: NSMakeRange(0, text.characters.count))

           self.attributedText = attributeString
        }
    }
}

5

Znalazłem sposób, w jaki możesz ustawić rzeczywistą wysokość linii (a nie czynnik), a nawet renderuje na żywo w Konstruktorze interfejsów . Postępuj zgodnie z instrukcjami poniżej. Kod jest napisany w Swift 4 .


Krok # 1: Utwórz plik o nazwie DesignableLabel.swifti wstaw następujący kod:

import UIKit

@IBDesignable
class DesignableLabel: UILabel {
    @IBInspectable var lineHeight: CGFloat = 20 {
        didSet {
            let paragraphStyle = NSMutableParagraphStyle()
            paragraphStyle.minimumLineHeight = lineHeight
            paragraphStyle.maximumLineHeight = lineHeight
            paragraphStyle.alignment = self.textAlignment

            let attrString = NSMutableAttributedString(string: text!)
            attrString.addAttribute(NSAttributedStringKey.font, value: font, range: NSRange(location: 0, length: attrString.length))
            attrString.addAttribute(NSAttributedStringKey.paragraphStyle, value: paragraphStyle, range: NSRange(location: 0, length: attrString.length))
            attributedText = attrString
        }
    }
}

Krok # 2: Umieść a UILabelw Storyboard / XIB i ustaw jego klasę na DesignableLabel. Poczekaj na kompilację projektu (kompilacja musi się powieść!).

Określanie klasy na UILabel


Krok 3: Teraz powinieneś zobaczyć nową właściwość w panelu właściwości o nazwie „Wysokość linii”. Wystarczy ustawić wartość, która ci się podoba i powinieneś natychmiast zobaczyć wyniki!

Ustaw wysokość linii we właściwościach


2

Oto podklasa UILabel, która ustawia lineHeightMultiplei upewnia się, że wewnętrzna wysokość jest wystarczająco duża, aby nie odcinać tekstu.

@IBDesignable
class Label: UILabel {
    override var intrinsicContentSize: CGSize {
        var size = super.intrinsicContentSize
        let padding = (1.0 - lineHeightMultiple) * font.pointSize
        size.height += padding
        return size
    }

    override var text: String? {
        didSet {
            updateAttributedText()
        }
    }

    @IBInspectable var lineHeightMultiple: CGFloat = 1.0 {
        didSet {
            updateAttributedText()
        }
    }

    private func updateAttributedText() {
        let paragraphStyle = NSMutableParagraphStyle()
        paragraphStyle.lineHeightMultiple = lineHeightMultiple
        attributedText = NSAttributedString(string: text ?? "", attributes: [
            .font: font,
            .paragraphStyle: paragraphStyle,
            .foregroundColor: textColor
        ])
        invalidateIntrinsicContentSize()
    }
}

dodatkowe dopełnienie musi być (lineHeightMultiple - 1.0) * font.pointSize, prawda?
Pavel Alexeev

Powyższy kod wydaje się dla mnie działać. Ale może masz rację. Próbowałeś swojej zmiany? @PavelAlexeev
phatmann

Nie, trzymam się lineSpacing zamiast lineHeightMultiple :)
Pavel Alexeev

1

W Swift 2.0 ...

Dodaj rozszerzenie:

extension UIView {
    func attributesWithLineHeight(font: String, color: UIColor, fontSize: CGFloat, kern: Double, lineHeightMultiple: CGFloat) -> [String: NSObject] {
        let titleParagraphStyle = NSMutableParagraphStyle()
        titleParagraphStyle.lineHeightMultiple = lineHeightMultiple

        let attribute = [
            NSForegroundColorAttributeName: color,
            NSKernAttributeName: kern,
            NSFontAttributeName : UIFont(name: font, size: fontSize)!,
            NSParagraphStyleAttributeName: titleParagraphStyle
        ]
        return attribute
    }
}

Teraz ustaw swój UILabel jako atrybut atrybutu Tekst:

self.label.attributedText = NSMutableAttributedString(string: "SwiftExample", attributes: attributesWithLineHeight("SourceSans-Regular", color: UIColor.whiteColor(), fontSize: 20, kern: 2.0, lineHeightMultiple: 0.5))    

Oczywiście dodałem kilka parametrów, których możesz nie potrzebować. Pobaw się - możesz przepisać metodę - szukałem tego na wielu różnych odpowiedziach, więc pomyślałem, że opublikuję całe rozszerzenie, na wypadek, gdyby pomogło to komuś ...


1

Swift3 - W rozszerzeniu UITextView lub UILabel dodaj tę funkcję:

Dodałem trochę kodu, aby zachować bieżący przypisany tekst, jeśli już używasz przypisanych ciągów w widoku (zamiast ich nadpisywania).

func setLineHeight(_ lineHeight: CGFloat) {
    guard let text = self.text, let font = self.font else { return }

    let paragraphStyle = NSMutableParagraphStyle()
    paragraphStyle.lineSpacing = 1.0
    paragraphStyle.lineHeightMultiple = lineHeight
    paragraphStyle.alignment = self.textAlignment

    var attrString:NSMutableAttributedString
    if let attributed = self.attributedText {
        attrString = NSMutableAttributedString(attributedString: attributed)
    } else {
        attrString = NSMutableAttributedString(string: text)
        attrString.addAttribute(NSFontAttributeName, value: font, range: NSMakeRange(0, attrString.length))
    }
    attrString.addAttribute(NSParagraphStyleAttributeName, value:paragraphStyle, range:NSMakeRange(0, attrString.length))
    self.attributedText = attrString
}

1

Inna odpowiedź ... Jeśli przekazujesz ciąg programowo, musisz przekazać przypisany ciąg zamiast zwykłego ciągu i zmienić jego styl. (IOS10)

NSMutableAttributedString * attrString = [[NSMutableAttributedString alloc] initWithString:@"Your \nregular \nstring"];
NSMutableParagraphStyle *style = [[NSMutableParagraphStyle alloc] init];
[style setLineSpacing:4];
[attrString addAttribute:NSParagraphStyleAttributeName
                   value:style
                   range:NSMakeRange(0, attrString.length)];
_label.attributedText = attrString;

1

Rozszerzenie Swift 3:

    import UIKit

extension UILabel {
    func setTextWithLineSpacing(text: String, lineHeightMultiply: CGFloat = 1.3) {
        let paragraphStyle = NSMutableParagraphStyle()
        paragraphStyle.lineHeightMultiple = lineHeightMultiply
        paragraphStyle.alignment = .center
        let attributedString = NSMutableAttributedString(string: text)
        attributedString.addAttribute(NSParagraphStyleAttributeName, value: paragraphStyle, range: NSRange(location: 0, length: attributedString.length))
        self.attributedText = attributedString
    }
}

1

To powinno pomóc. Następnie możesz przypisać etykietę do tej klasy niestandardowej w serii ujęć i użyć jej parametrów bezpośrednio w właściwościach:

open class SpacingLabel : UILabel {

    @IBInspectable open var lineHeight:CGFloat = 1 {
        didSet {
            let paragraphStyle = NSMutableParagraphStyle()
            paragraphStyle.lineSpacing = 1.0
            paragraphStyle.lineHeightMultiple = self.lineHeight
            paragraphStyle.alignment = self.textAlignment

            let attrString = NSMutableAttributedString(string: self.text!)
            attrString.addAttribute(NSAttributedStringKey.font, value: self.font, range: NSMakeRange(0, attrString.length))
            attrString.addAttribute(NSAttributedStringKey.paragraphStyle, value:paragraphStyle, range:NSMakeRange(0, attrString.length))
            self.attributedText = attrString
        }
    } 
}

To powinno pomóc. Następnie możesz przypisać etykietę do tej klasy niestandardowej w serii ujęć i użyć jej parametrów bezpośrednio w właściwościach.
Russell Warwick

proszę nie umieszczać treści związanych z odpowiedzią w komentarzach. twoja odpowiedź powinna być pomocna bez konieczności czytania komentarzy
Neuron

1

Rozszerzenie etykiety Swift 4. Tworzenie NSMutableAttributString przed przekazaniem do funkcji, na wypadek, gdyby dla przypisanego tekstu wymagane były dodatkowe atrybuty.

extension UILabel {

    func setLineHeightMultiple(to height: CGFloat, withAttributedText attributedText: NSMutableAttributedString) {

        let paragraphStyle = NSMutableParagraphStyle()
        paragraphStyle.lineSpacing = 1.0
        paragraphStyle.lineHeightMultiple = height
        paragraphStyle.alignment = textAlignment

        attributedText.addAttribute(.paragraphStyle, value: paragraphStyle, range: NSRange(location: 0, length: attributedText.length - 1))

        self.attributedText = attributedText
    }
}

0

Ten kod działał dla mnie (na pewno iOS 7 i iOS 8).

_label.numberOfLines=2;
_label.textColor=[UIColor whiteColor];

NSMutableParagraphStyle *paragraphStyle = [[NSMutableParagraphStyle alloc] init];
paragraphStyle.lineHeightMultiple=0.5;
paragraphStyle.alignment = NSTextAlignmentCenter;
paragraphStyle.lineSpacing = 1.0;

NSDictionary *nameAttributes=@{
                               NSParagraphStyleAttributeName : paragraphStyle,
                               NSBaselineOffsetAttributeName:@2.0
                               };


NSAttributedString *string=[[NSAttributedString alloc] initWithString:@"22m\nago" attributes:nameAttributes];
_label.attributedText=string;

0

Oto moje rozwiązanie szybko. Podklasa powinna działać zarówno w przypadku atrybutu atrybutText i text, jak i znaków CharacterSpacing + lineSpacing. Zachowuje odstępy, jeśli ustawiony jest nowy ciąg znaków lub atrybut atrybutowany.

open class UHBCustomLabel : UILabel {
    @IBInspectable open var characterSpacing:CGFloat = 1 {
        didSet {
            updateWithSpacing()
        }

    }
    @IBInspectable open var lines_spacing:CGFloat = -1 {
        didSet {
            updateWithSpacing()
        }

    }
    open override var text: String? {
        set {
            super.text = newValue
            updateWithSpacing()
        }
        get {
            return super.text
        }
    }
    open override var attributedText: NSAttributedString? {
        set {
            super.attributedText = newValue
            updateWithSpacing() 
        }
        get {
            return super.attributedText
        }
    }
    func updateWithSpacing() {
        let attributedString = self.attributedText == nil ? NSMutableAttributedString(string: self.text ?? "") : NSMutableAttributedString(attributedString: attributedText!)
        attributedString.addAttribute(NSKernAttributeName, value: self.characterSpacing, range: NSRange(location: 0, length: attributedString.length))
        if lines_spacing >= 0 {
            let paragraphStyle = NSMutableParagraphStyle()
            paragraphStyle.lineSpacing = lines_spacing
            paragraphStyle.alignment = textAlignment
            attributedString.addAttribute(NSParagraphStyleAttributeName, value:paragraphStyle, range:NSMakeRange(0, attributedString.length))
        }
        super.attributedText = attributedString
    }
}

-5

Jako szybkie, brudne, inteligentne i proste obejście:

W przypadku etykiet UILabel, które nie mają wielu linii, można zamiast tego użyć stosu widoków.

  1. Dla każdej linii napisz nową etykietę.
  2. Osadź je w StackView. (Wybierz obie etykiety -> Edytor -> Osadź w -> StackView
  3. Dostosuj SpacingStackView do żądanej kwoty

Pamiętaj, aby ułożyć je pionowo . To rozwiązanie działa również w przypadku niestandardowych czcionek.

wprowadź opis zdjęcia tutaj


FWIW to okropne, ale wykonalne rozwiązanie. Dlatego trzymam to.
Honey

Widziałem też zasadę, że deweloper iOS używa widoków stosu do tworzenia wykresów. Widoki stosu są bardzo potężne
Honey
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.