web-dev-qa-db-fra.com

Définition de la police BOLD sur iOS UILabel

J'ai déjà affecté une police personnalisée de 'Helvetica' de taille 14 pour le texte dans UILabel avec Interface Builder.

J'utilise la même étiquette à plusieurs endroits, mais je dois parfois afficher le texte en gras.

Est-il possible de spécifier simplement de mettre en gras la police existante au lieu de recréer l'intégralité de UIFont? C'est ce que je fais maintenant:

myLabel.font = [UIFont fontWithName:@"Helvetica Neue" size:14];
iosobjective-cfontsuifont
54
tech_human

UPDATE:
À partir d’iOS 8, il n’est plus nécessaire de jouer avec les noms de police. Voir plutôt les réponses plus récentes qui utilisent UIFontDescriptorSymbolicTraits: ici et ici .

myLabel.font = [UIFont fontWithName:@"Helvetica-Bold" size:14];

Si vous souhaitez le définir par programme, vous devez vérifier si le type en gras est pris en charge ou non dans iOS. Normalement, Gras ou Italique aura le format NomPolice-Gras, NomPolice-Italique, NomPolice-BoldItalic.

Maintenant, écrivez une fonction audacieuse

-(void)boldFontForLabel:(UILabel *)label{
    UIFont *currentFont = label.font;
    UIFont *newFont = [UIFont fontWithName:[NSString stringWithFormat:@"%@-Bold",currentFont.fontName] size:currentFont.pointSize];
    label.font = newFont;
}

Alors appelle ça

[self boldFontForLabel:yourLabel];
83
LE SANG

C'est une affaire de poisson de jouer avec les noms de police. Et supposément, vous avez une police italique et vous voulez le mettre en gras - en ajoutant simplement @"-Bold" au nom ne fonctionne pas. Il y a beaucoup plus élégant moyen:

- (UIFont *)boldFontWithFont:(UIFont *)font
{
    UIFontDescriptor * fontD = [font.fontDescriptor
                fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitBold];
    return [UIFont fontWithDescriptor:fontD size:0];
}

size:0 signifie "conserver la taille telle qu'elle est dans le descripteur". Vous pourriez trouver utile trait UIFontDescriptorTraitItalic si vous avez besoin d’une police italique

Dans Swift, il serait bien d’écrire une simple extension:

extension UIFont {

    func withTraits(traits:UIFontDescriptorSymbolicTraits...) -> UIFont {
        let descriptor = self.fontDescriptor().fontDescriptorWithSymbolicTraits(UIFontDescriptorSymbolicTraits(traits))
        return UIFont(descriptor: descriptor, size: 0)
    }

    func bold() -> UIFont {
        return withTraits(.TraitBold)
    }

    func italic() -> UIFont {
        return withTraits(.TraitItalic)
    }

    func boldItalic() -> UIFont {
        return withTraits(.TraitBold, .TraitItalic)
    }

}

Ensuite, vous pouvez l'utiliser de cette façon:

myLabel.font = myLabel.font.boldItalic()

myLabel.font = myLabel.font.bold()

myLabel.font = myLabel.font.withTraits(.TraitCondensed, .TraitBold, .TraitItalic)
103
Maksymilian Wojakowski
UIFont* boldFont = [UIFont boldSystemFontOfSize:[UIFont systemFontSize]];
[myLabel setFont:boldFont];
33
thatzprem

Étendre this answer, en Swift:

extension UIFont {
    func bold() -> UIFont {
        let descriptor = self.fontDescriptor().fontDescriptorWithSymbolicTraits(UIFontDescriptorSymbolicTraits.TraitBold)
        return UIFont(descriptor: descriptor, size: 0)
    }
}
6
cscott530

Nous avons juste besoin du bon nom de police. Je trouve que iOSFonts.com est la ressource la plus utile pour savoir exactement quel nom utiliser.

Vous pouvez définir Gras + ITALIQUE en utilisant FONT NAME "Arial-BoldItalicMT"

Cela fonctionne dans tous les cas:

[myLabel setFont:[UIFont fontWithName:@"Arial-BoldItalicMT" size:17]];
5
Jasmeet

J'ai mien un peu différemment avec Swift

var boldHelveticaFont = UIFont(name: "Helvetica Neue", size: 40)?.fontDescriptor().fontDescriptorWithSymbolicTraits(UIFontDescriptorSymbolicTraits.TraitBold)
self.InstructionsTextView.font = UIFont(descriptor: boldHelveticaFont!, size: 40)
4
RyanPliske

pour "rapides" essayer.

cet exemple de contrôleur affichera 4 étiquettes avec toutes les variantes.

import UIKit

class ViewController: UIViewController {


    var labl: UILabel?
    var labl2: UILabel?
    var labl3: UILabel?
    var labl4: UILabel?

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

        let font = UIFont.systemFontOfSize(32)
        labl = UILabel(frame: CGRectMake(20,20,400, 45))
        labl!.text = "Attention:"
        labl!.font = font

        labl2 = UILabel(frame: CGRectMake(20,60,400, 45))
        labl2!.text = "Attention:"
        labl2!.font = bold(font)

        labl3 = UILabel(frame: CGRectMake(20,100,400, 45))
        labl3!.text = "Attention:"
        labl3!.font = italic(font)

        labl4 = UILabel(frame: CGRectMake(20,140,400, 45))
        labl4!.text = "Attention:"
        labl4!.font = boldAndItalic(font)



        self.view.addSubview(labl!)
        self.view.addSubview(labl2!)
        self.view.addSubview(labl3!)
        self.view.addSubview(labl4!)


    }

    // Nice to write an extension...
    func bold(font: UIFont) -> UIFont {
        let descriptor = font.fontDescriptor().fontDescriptorWithSymbolicTraits([.TraitBold])
        return UIFont(descriptor: descriptor, size: 0)
    }

    func boldAndItalic(font: UIFont) -> UIFont {
        let descriptor = font.fontDescriptor().fontDescriptorWithSymbolicTraits([.TraitBold, .TraitItalic])
        return UIFont(descriptor: descriptor, size: 0)
    }

    func italic(font: UIFont) -> UIFont {
        let descriptor = font.fontDescriptor().fontDescriptorWithSymbolicTraits([.TraitItalic])
        return UIFont(descriptor: descriptor, size: 0)
    }
}

wulld serait sympa d’écrire une extension pour la classe UIFont.

1
ingconti

Vous n'avez probablement pas besoin d'une "extension" en tant que telle, si vous le souhaitez pour des polices personnalisées ...

Ajoutez simplement une fonction (similaire à certaines des méthodes ci-dessus) que vous pouvez appeler de n’importe où (c'est-à-dire sans classe), puis vous pourrez enhardir les mots dans n'importe quelle chaîne, à de nombreuses reprises en appelant simplement ONE LINE de code:

Pour aller dans un fichier tel que constants.Swift:

import Foundation
import UIKit

func addBoldText(fullString: NSString, boldPartOfString: NSString, font: UIFont!, boldFont: UIFont!) -> NSAttributedString {
   let nonBoldFontAttribute = [NSFontAttributeName:font!]
   let boldFontAttribute = [NSFontAttributeName:boldFont]
   let boldString = NSMutableAttributedString(string: fullString as String, attributes:nonBoldFontAttribute)
   boldString.addAttributes(boldFontAttribute, range: fullString.rangeOfString(boldPartOfString as String))
   return boldString
}

Ensuite, vous pouvez simplement appeler cette ligne de code pour n’importe quel UILabel:

self.UILabel.attributedText = addBoldText("Check again in 30 DAYS to find more friends", boldPartOfString: "30 DAYS", font: normalFont!, boldFont: boldSearchFont!)


//Mark: Albeit that you've had to define these somewhere:

let normalFont = UIFont(name: "INSERT FONT NAME", size: 15)
let boldFont = UIFont(name: "INSERT BOLD FONT", size: 15)
0
David West

Ma contribution avec une extension pour UILabel mise à jour pour Swift 4:

extension UILabel{
    func bold() -> UILabel {
        if let descriptor = self.font.fontDescriptor.withSymbolicTraits(UIFontDescriptor.SymbolicTraits.traitBold){
            self.font = UIFont(descriptor: descriptor, size: 0)
        }
        return self
    }
}

Appelez simplement .bold () comme ça:

let myLabel = UILabel()
myLabel.bold()
0
Kevin ABRIOUX