it-swarm.com.de

Festlegen einer Standardschriftart für die gesamte iOS-App?

Ich habe eine benutzerdefinierte Schriftart, die ich für alles verwenden möchte, in dem Text in meiner App angezeigt wird, Beschriftungen, Textansichten usw. 

Gibt es eine Möglichkeit, die Standardschriftart (Standardetiketten verwenden SystemFont) für die gesamte App festzulegen?

132
Sam Jarman

Es scheint in iOS 5 mit dem UIAppearance-Proxy möglich zu sein.

 [[UILabel appearance] setFont:[UIFont fontWithName:@"YourFontName" size:17.0]];

Dadurch wird die Schriftart so eingestellt, dass sie für alle UILabels in Ihrer App die benutzerdefinierte Schriftart ist. Sie müssen es für jedes Steuerelement (UIButton, UILabel usw.) wiederholen. 

Denken Sie daran, dass Sie den UIAppFonts-Wert in Ihre info.plist eingeben und den Namen der von Ihnen hinzugefügten Schriftart angeben müssen.

156
Randall

Schnell 4.1

Basierend auf der Antwort von Fábio Oliveira ( https://stackoverflow.com/a/23042694/2082851 ), erstelle ich meine eigene Swift 4.

Kurz gesagt, diese Erweiterung tauscht die Standardfunktionen init(coder:), systemFont(ofSize:), boldSystemFont(ofSize:), italicSystemFont(ofSize:) mit meinen benutzerdefinierten Methoden aus.

Beachten Sie, dass es nicht vollständig implementiert ist, Sie können jedoch basierend auf meiner Implementierung weitere Methoden austauschen.

import UIKit

struct AppFontName {
    static let regular = "CourierNewPSMT"
    static let bold = "CourierNewPS-BoldMT"
    static let italic = "CourierNewPS-ItalicMT"
}

extension UIFontDescriptor.AttributeName {
    static let nsctFontUIUsage = UIFontDescriptor.AttributeName(rawValue: "NSCTFontUIUsageAttribute")
}

extension UIFont {

    @objc class func mySystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: AppFontName.regular, size: size)!
    }

    @objc class func myBoldSystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: AppFontName.bold, size: size)!
    }

    @objc class func myItalicSystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: AppFontName.italic, size: size)!
    }

    @objc convenience init(myCoder aDecoder: NSCoder) {
        guard
            let fontDescriptor = aDecoder.decodeObject(forKey: "UIFontDescriptor") as? UIFontDescriptor,
            let fontAttribute = fontDescriptor.fontAttributes[.nsctFontUIUsage] as? String else {
                self.init(myCoder: aDecoder)
                return
        }
        var fontName = ""
        switch fontAttribute {
        case "CTFontRegularUsage":
            fontName = AppFontName.regular
        case "CTFontEmphasizedUsage", "CTFontBoldUsage":
            fontName = AppFontName.bold
        case "CTFontObliqueUsage":
            fontName = AppFontName.italic
        default:
            fontName = AppFontName.regular
        }
        self.init(name: fontName, size: fontDescriptor.pointSize)!
    }

    class func overrideInitialize() {
        guard self == UIFont.self else { return }

        if let systemFontMethod = class_getClassMethod(self, #selector(systemFont(ofSize:))),
            let mySystemFontMethod = class_getClassMethod(self, #selector(mySystemFont(ofSize:))) {
            method_exchangeImplementations(systemFontMethod, mySystemFontMethod)
        }

        if let boldSystemFontMethod = class_getClassMethod(self, #selector(boldSystemFont(ofSize:))),
            let myBoldSystemFontMethod = class_getClassMethod(self, #selector(myBoldSystemFont(ofSize:))) {
            method_exchangeImplementations(boldSystemFontMethod, myBoldSystemFontMethod)
        }

        if let italicSystemFontMethod = class_getClassMethod(self, #selector(italicSystemFont(ofSize:))),
            let myItalicSystemFontMethod = class_getClassMethod(self, #selector(myItalicSystemFont(ofSize:))) {
            method_exchangeImplementations(italicSystemFontMethod, myItalicSystemFontMethod)
        }

        if let initCoderMethod = class_getInstanceMethod(self, #selector(UIFontDescriptor.init(coder:))), // Trick to get over the lack of UIFont.init(coder:))
            let myInitCoderMethod = class_getInstanceMethod(self, #selector(UIFont.init(myCoder:))) {
            method_exchangeImplementations(initCoderMethod, myInitCoderMethod)
        }
    }
}


class AppDelegate: UIResponder, UIApplicationDelegate {
    // Avoid warning of Swift
    // Method 'initialize()' defines Objective-C class method 'initialize', which is not guaranteed to be invoked by Swift and will be disallowed in future versions
    override init() {
        super.init()
        UIFont.overrideInitialize()
    }
    ...
}
78
nahung89

Es gibt auch eine andere Lösung, die systemFont überschreiben wird.

Erstellen Sie einfach eine Kategorie

UIFont + SystemFontOverride.h

#import <UIKit/UIKit.h>

@interface UIFont (SystemFontOverride)
@end

UIFont + SystemFontOverride.m

@implementation UIFont (SystemFontOverride)

#pragma clang diagnostic Push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"

+ (UIFont *)boldSystemFontOfSize:(CGFloat)fontSize {
    return [UIFont fontWithName:@"fontName" size:fontSize];
}

+ (UIFont *)systemFontOfSize:(CGFloat)fontSize {
    return [UIFont fontWithName:@"fontName" size:fontSize];
}

#pragma clang diagnostic pop

@end

Dies ersetzt die Standardimplementierung, und die meisten UIControls verwenden systemFont.

74
Hugues BR

Wenn Sie Swift verwenden, können Sie eine UILabel-Erweiterung erstellen:

extension UILabel {

    var substituteFontName : String {
        get { return self.font.fontName }
        set { self.font = UIFont(name: newValue, size: self.font.pointSize) }
    }

}

Und dann, wo du dein Aussehen machst:

UILabel.appearance().substituteFontName = applicationFont

Es gibt äquivalenten Objective-C-Code, der UI_APPEARANCE_SELECTOR für eine Eigenschaft mit dem Namen substituteFontName verwendet.

Zusatz

Für den Fall, dass Sie Fett- und reguläre Schriftarten separat einstellen möchten:

extension UILabel {

    var substituteFontName : String {
        get { return self.font.fontName }
        set { 
            if self.font.fontName.range(of:"Medium") == nil { 
                self.font = UIFont(name: newValue, size: self.font.pointSize)
            }
        }
    }

    var substituteFontNameBold : String {
        get { return self.font.fontName }
        set { 
            if self.font.fontName.range(of:"Medium") != nil { 
                self.font = UIFont(name: newValue, size: self.font.pointSize)
            }
        }
    }
}

Dann für Ihre UIAppearance-Proxies:

UILabel.appearance().substituteFontName = applicationFont
UILabel.appearance().substituteFontNameBold = applicationFontBold

Hinweis: Wenn Sie feststellen, dass die fette Ersetzung nicht funktioniert, ist es möglich, dass der Name der Standardschriftart nicht "Medium" enthält. Wechseln Sie die Zeichenfolge nach Bedarf für ein weiteres Spiel aus (Dank an Mason in den Kommentaren unten).

58
Sandy Chapman

Entwickeln von Hugues BR-Antworten, aber Verwenden der Methode "Swizzling". Ich bin zu einer Lösung gekommen, bei der alle Schriftarten erfolgreich in die gewünschte Schriftart in meiner App geändert werden.

Ein Ansatz mit Dynamic Type sollte unter iOS 7 aussehen. Die folgende Lösung verwendet Dynamic Type nicht.


Anmerkungen:  

  • der nachstehende Code wurde in der vorliegenden Form niemals der Genehmigung von Apple unterzogen.
  • es gibt eine kürzere Version, die die Apple-Übergabe bestanden hat, dh ohne die - initWithCoder:-Überschreibung. Das gilt jedoch nicht für alle Fälle.
  • der folgende Code ist in einer Klasse enthalten, mit der ich den Stil meiner App festlegte, der in meiner AppDelegate-Klasse enthalten ist und somit überall und für alle UIFont-Instanzen verfügbar ist.
  • Ich verwende hier Zapfino, nur um die Änderungen deutlich sichtbar zu machen.
  • jegliche Verbesserung dieses Codes ist willkommen.

Diese Lösung verwendet zwei verschiedene Methoden, um das Endergebnis zu erzielen. Die erste besteht darin, die UIFont-Klassenmethoden + systemFontWithSize: und ähnliche Methoden zu überschreiben, die meine Alternativen verwenden (hier verwende ich "Zapfino", um keinen Zweifel an dem Erfolg zu haben).

Die andere Methode besteht darin, die - initWithCoder:-Methode auf UIFont zu überschreiben, um jedes Vorkommen von CTFontRegularUsage und ähnlichen durch meine Alternativen zu ersetzen .. Diese letzte Methode war notwendig, da ich festgestellt habe, dass in NIB-Dateien codierte UILabel-Objekte die + systemFontWithSize:-Methoden nicht prüfen Holen Sie sich die Systemschriftart und kodieren Sie sie stattdessen als UICTFontDescriptor objects . Ich habe versucht, - awakeAfterUsingCoder: zu überschreiben, aber irgendwie wurde es für jedes verschlüsselte Objekt in meinem Storyboard aufgerufen und Abstürze verursacht. Das Überschreiben von - awakeFromNib würde es mir nicht erlauben, das NSCoder-Objekt zu lesen.

#import <objc/runtime.h>

NSString *const FORegularFontName = @"Zapfino";
NSString *const FOBoldFontName = @"Zapfino";
NSString *const FOItalicFontName = @"Zapfino";

#pragma mark - UIFont category
@implementation UIFont (CustomFonts)

#pragma clang diagnostic Push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
+ (void)replaceClassSelector:(SEL)originalSelector withSelector:(SEL)modifiedSelector {
    Method originalMethod = class_getClassMethod(self, originalSelector);
    Method modifiedMethod = class_getClassMethod(self, modifiedSelector);
    method_exchangeImplementations(originalMethod, modifiedMethod);
}

+ (void)replaceInstanceSelector:(SEL)originalSelector withSelector:(SEL)modifiedSelector {
    Method originalDecoderMethod = class_getInstanceMethod(self, originalSelector);
    Method modifiedDecoderMethod = class_getInstanceMethod(self, modifiedSelector);
    method_exchangeImplementations(originalDecoderMethod, modifiedDecoderMethod);
}

+ (UIFont *)regularFontWithSize:(CGFloat)size
{
    return [UIFont fontWithName:FORegularFontName size:size];
}

+ (UIFont *)boldFontWithSize:(CGFloat)size
{
    return [UIFont fontWithName:FOBoldFontName size:size];
}

+ (UIFont *)italicFontOfSize:(CGFloat)fontSize
{
    return [UIFont fontWithName:FOItalicFontName size:fontSize];
}

- (id)initCustomWithCoder:(NSCoder *)aDecoder {
    BOOL result = [aDecoder containsValueForKey:@"UIFontDescriptor"];

    if (result) {
        UIFontDescriptor *descriptor = [aDecoder decodeObjectForKey:@"UIFontDescriptor"];

        NSString *fontName;
        if ([descriptor.fontAttributes[@"NSCTFontUIUsageAttribute"] isEqualToString:@"CTFontRegularUsage"]) {
            fontName = FORegularFontName;
        }
        else if ([descriptor.fontAttributes[@"NSCTFontUIUsageAttribute"] isEqualToString:@"CTFontEmphasizedUsage"]) {
            fontName = FOBoldFontName;
        }
        else if ([descriptor.fontAttributes[@"NSCTFontUIUsageAttribute"] isEqualToString:@"CTFontObliqueUsage"]) {
            fontName = FOItalicFontName;
        }
        else {
            fontName = descriptor.fontAttributes[@"NSFontNameAttribute"];
        }

        return [UIFont fontWithName:fontName size:descriptor.pointSize];
    }

    self = [self initCustomWithCoder:aDecoder];

    return self;
}

+ (void)load
{
    [self replaceClassSelector:@selector(systemFontOfSize:) withSelector:@selector(regularFontWithSize:)];
    [self replaceClassSelector:@selector(boldSystemFontOfSize:) withSelector:@selector(boldFontWithSize:)];
    [self replaceClassSelector:@selector(italicSystemFontOfSize:) withSelector:@selector(italicFontOfSize:)];

    [self replaceInstanceSelector:@selector(initWithCoder:) withSelector:@selector(initCustomWithCoder:)];
}
#pragma clang diagnostic pop

@end
22
Fábio Oliveira

Um die Sandy Chapmans Antwort zu vervollständigen, finden Sie hier eine Lösung in Objective-C (fügen Sie diese category an einer beliebigen Stelle UILabelAppearance ein):

@implementation UILabel (FontOverride)
- (void)setSubstituteFontName:(NSString *)name UI_APPEARANCE_SELECTOR {
    self.font = [UIFont fontWithName:name size:self.font.pointSize];
}
@end

In der Schnittstellendatei sollte diese Methode öffentlich deklariert werden, damit sie später von Orten wie Ihrem App-Delegaten verwendet werden kann:

@interface UILabel (FontOverride)
  - (void)setSubstituteFontName:(NSString *)name UI_APPEARANCE_SELECTOR;
@end

Dann können Sie die Appearance ändern mit:

[[UILabel appearance] setSubstituteFontName:@"SourceSansPro-Light"];
13
Damien Debin

Ich habe es als neue Antwort veröffentlicht und nicht als Kommentar, weil ich nicht genug Ansehen habe.

KOMMENTAR FÜR SWIFT 3.0 UND SWIFT WARNUNG  

Sie können die Warnmeldung in der Zeile entfernen:

let initCoderMethod = class_getInstanceMethod(self, Selector("initWithCoder:"))

Ersetzen Sie es durch:

let initCoderMethod = class_getInstanceMethod(self, #selector(UIFontDescriptor.init(coder:)))
4
ucotta

Für Swift 4

Alle obigen Antworten sind korrekt, aber ich habe auf wenig unterschiedliche Weise gemacht, dass je nach Gerätegröße . Hier in der Klasse ATFontManager habe ich eine Standardschriftgröße erstellt, die als oberste Klasse definiert ist defaultFontSize , dies ist die Schriftgröße von iphone plus, und Sie können sie entsprechend Ihren Anforderungen ändern.

     class ATFontManager: UIFont{

    class func setFont( _ iPhone7PlusFontSize: CGFloat? = nil,andFontName fontN : String = FontName.HelveticaNeue) -> UIFont{

        let defaultFontSize : CGFloat = 16

        switch ATDeviceDetector().screenType {

        case .iPhone4:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 3)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 6)!

        case .iPhone5:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 2)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 3)!

        case .iPhone6AndIphone7:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 1)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 1)!

        case .iPhone6PAndIPhone7P:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!
        case .iPhoneX:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!

        case .iPhoneOrIPadSmallSizeUnknown:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!

        case .iPadMini:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 4)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 4)!

        case .iPadPro10Inch:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 5)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 5)!

        case .iPadPro:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 6)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 6)!

        case .iPadUnknown:

            return UIFont(name: fontN, size: defaultFontSize + 3)!

        default:

            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? 15)!
        }
    }
}

Ich habe einen bestimmten Namen für die Schriftart hinzugefügt. Für weitere Informationen können Sie den Namen und die Art der Schriftart hier eingeben.

   enum FontName : String {
        case HelveticaNeue = "HelveticaNeue"
        case HelveticaNeueUltraLight = "HelveticaNeue-UltraLight"
        case HelveticaNeueBold = "HelveticaNeue-Bold"
        case HelveticaNeueBoldItalic = "HelveticaNeue-BoldItalic"
        case HelveticaNeueMedium = "HelveticaNeue-Medium"
        case AvenirBlack = "Avenir-Black"
        case ArialBoldMT = "Arial-BoldMT"
        case HoeflerTextBlack = "HoeflerText-Black"
        case AMCAPEternal = "AMCAPEternal"
    }

Diese Klasse bezieht sich auf den Gerätedetektor, um die für das Gerät geeignete Schriftgröße bereitzustellen. 

class ATDeviceDetector {

    var iPhone: Bool {

        return UIDevice().userInterfaceIdiom == .phone
    }

    var ipad : Bool{

        return UIDevice().userInterfaceIdiom == .pad
    }

    let isRetina = UIScreen.main.scale >= 2.0


    enum ScreenType: String {

        case iPhone4
        case iPhone5
        case iPhone6AndIphone7
        case iPhone6PAndIPhone7P
        case iPhoneX

        case iPadMini
        case iPadPro
        case iPadPro10Inch

        case iPhoneOrIPadSmallSizeUnknown
        case iPadUnknown
        case unknown
    }


    struct ScreenSize{

        static let SCREEN_WIDTH         = UIScreen.main.bounds.size.width
        static let SCREEN_HEIGHT        = UIScreen.main.bounds.size.height
        static let SCREEN_MAX_LENGTH    = max(ScreenSize.SCREEN_WIDTH,ScreenSize.SCREEN_HEIGHT)
        static let SCREEN_MIN_LENGTH    = min(ScreenSize.SCREEN_WIDTH,ScreenSize.SCREEN_HEIGHT)
    }


    var screenType: ScreenType {

        switch ScreenSize.SCREEN_MAX_LENGTH {

        case 0..<568.0:
            return .iPhone4
        case 568.0:
            return .iPhone5
        case 667.0:
            return .iPhone6AndIphone7
        case 736.0:
            return .iPhone6PAndIPhone7P
        case 812.0:
            return .iPhoneX
        case 568.0..<812.0:
            return .iPhoneOrIPadSmallSizeUnknown
        case 1112.0:
            return .iPadPro10Inch
        case 1024.0:
            return .iPadMini
        case 1366.0:
            return .iPadPro
        case 812.0..<1366.0:
            return .iPadUnknown
        default:
            return .unknown
        }
    }
}

Wie benutzt man. Ich hoffe es hilft.

//for default 
label.font = ATFontManager.setFont()

//if you want to provide as your demand. Here **iPhone7PlusFontSize** variable is denoted as font size for *iphone 7plus and iphone 6 plus*, and it **ATFontManager** class automatically handle.
label.font = ATFontManager.setFont(iPhone7PlusFontSize: 15, andFontName: FontName.HelveticaNeue.rawValue)
3
Amrit Tiwari

Der Schrifttyp muss immer in Code und Feder/Storyboard festgelegt werden.

Für den Code, genau wie sagte Hugues BR , kann er das Problem in Kategorien lösen.

Für das Schreibfedern/Storyboard können Sie die Methode mit dem ZeichensatzwakeFromNib verwenden, um den Schriftarttyp zu ändern, da das UI-Element vom Schreibfederbereich/Storyboard immer vor dem Anzeigen auf dem Bildschirm aufgerufen wird. 

Ich nehme an, Sie wissen Aspekte . Es ist eine Bibliothek für AOP-Programmierung, basierend auf Method Swizzling . Wir erstellen eine Kategorie für UILabel, UIButton, UITextView, um sie zu implementieren.

UILabel:

#import "UILabel+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UILabel (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UILabel* instance = [aspectInfo instance];
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:instance.font.pointSize];
        instance.font = font;
    }error:nil];
}

@end

UIButton: 

#import "UIButton+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UIButton (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UIButton* instance = [aspectInfo instance];
        UILabel* label = instance.titleLabel;
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:label.font.pointSize];
        instance.titleLabel.font = font;
    }error:nil];
}

@end

UITextField:

#import "UITextField+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UITextField (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UITextField* instance = [aspectInfo instance];
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:instance.font.pointSize];
        instance.font = font;
    }error:nil];
}

@end

UITextView:

#import "UITextView+OverrideBaseFont.h"
#import "Aspects.h"

@implementation UITextView (OverrideBaseFont)

+ (void)load {
    [[self class]aspect_hookSelector:@selector(awakeFromNib) withOptions:AspectPositionAfter usingBlock:^(id<AspectInfo> aspectInfo) {
        UITextView* instance = [aspectInfo instance];
        UIFont* font = [UIFont fontWithName:@"HelveticaNeue-light" size:instance.font.pointSize];
        instance.font = font;
    }error:nil];
}

@end

Das ist alles, Sie können HelveticaNeue-light in ein Makro mit Ihrem Schriftartnamen umwandeln.

3
Peng Xiaofeng

Wahrscheinlich nicht, Sie haben wahrscheinlich die Einstellung der Schriftart auf Ihrem Steuerelement selbst festgelegt, aber Sie können den Prozess vereinfachen, indem Sie zentralisieren, wo Sie die Schriftarttypen abrufen. Beispielsweise haben der App-Delegat oder eine andere übliche Klasse eine Methode, die die zurückgibt Schriftart und alles, was die Schriftart festlegen muss, kann diese Methode aufrufen. Dies ist hilfreich, wenn Sie die Schriftart ändern möchten. Sie können sie an einer Stelle ändern, anstatt die Schriftarten festzulegen. Eine andere Alternative können Subklassen sein Ihre Benutzeroberflächenelemente, die die Schriftart automatisch festlegen, aber das könnte übertrieben sein.

2
Daniel

Keine dieser Lösungen funktioniert überall in der App. Eine Sache, die ich beim Verwalten der Schriftarten in Xcode gefunden habe, ist das Öffnen des Storyboards als Quellcode (Klicken Sie bei gedrückter Strg-Taste im Datei-Navigator> "Öffnen als"> "Quelle") und dann Suchen und Ersetzen.

2
Gingi

NUI ist eine Alternative zum UIAppearance-Proxy. Sie haben die Möglichkeit, die Schriftart (und viele andere Attribute) einer großen Anzahl von UI-Elementtypen in Ihrer Anwendung zu steuern, indem Sie einfach ein Stylesheet ändern, das in mehreren Anwendungen verwendet werden kann.

Nachdem Sie Ihren Beschriftungen eine NUILabel-Klasse hinzugefügt haben, können Sie deren Schriftart im Stylesheet problemlos steuern:

LabelFontName    String    Helvetica

Wenn Sie Etiketten mit unterschiedlichen Schriftgrößen haben, können Sie deren Größe mit den Label-, LargeLabel- und SmallLabel-Klassen von NUI steuern oder sogar schnell eigene Klassen erstellen.

1
Tom

Ich habe meine eigene Konvertierung von Typografie für Swift 4 erstellt.

struct Resources {

    struct Fonts {
        //struct is extended in Fonts
    }
}

extension Resources.Fonts {

    enum Weight: String {
        case light = "Typo-Light"
        case regular = "Typo-Regular"
        case semibold = "Typo-Semibold"
        case italic = "Typo-LightItalic"
    }
}

extension UIFontDescriptor.AttributeName {
    static let nsctFontUIUsage = UIFontDescriptor.AttributeName(rawValue: "NSCTFontUIUsageAttribute")
}

extension UIFont {

    @objc class func mySystemFont(ofSize: CGFloat, weight: UIFont.Weight) -> UIFont {
        switch weight {
        case .semibold, .bold, .heavy, .black:
            return UIFont(name: Resources.Fonts.Weight.semibold.rawValue, size: ofSize)!

        case .medium, .regular:
            return UIFont(name: Resources.Fonts.Weight.regular.rawValue, size: ofSize)!

        default:
            return UIFont(name: Resources.Fonts.Weight.light.rawValue, size: ofSize)!
        }
    }

    @objc class func mySystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: Resources.Fonts.Weight.light.rawValue, size: size)!
    }

    @objc class func myBoldSystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: Resources.Fonts.Weight.semibold.rawValue, size: size)!
    }

    @objc class func myItalicSystemFont(ofSize size: CGFloat) -> UIFont {
        return UIFont(name: Resources.Fonts.Weight.italic.rawValue, size: size)!
    }

    @objc convenience init(myCoder aDecoder: NSCoder) {
        guard
            let fontDescriptor = aDecoder.decodeObject(forKey: "UIFontDescriptor") as? UIFontDescriptor,
            let fontAttribute = fontDescriptor.fontAttributes[.nsctFontUIUsage] as? String else {
                self.init(myCoder: aDecoder)
                return
        }
        var fontName = ""
        switch fontAttribute {
        case "CTFontRegularUsage", "CTFontMediumUsage":
            fontName = Resources.Fonts.Weight.regular.rawValue
        case "CTFontEmphasizedUsage", "CTFontBoldUsage", "CTFontSemiboldUsage","CTFontHeavyUsage", "CTFontBlackUsage":
            fontName = Resources.Fonts.Weight.semibold.rawValue
        case "CTFontObliqueUsage":
            fontName = Resources.Fonts.Weight.italic.rawValue
        default:
            fontName = Resources.Fonts.Weight.light.rawValue
        }
        self.init(name: fontName, size: fontDescriptor.pointSize)!
    }

    class func overrideDefaultTypography() {
        guard self == UIFont.self else { return }

        if let systemFontMethodWithWeight = class_getClassMethod(self, #selector(systemFont(ofSize: weight:))),
            let mySystemFontMethodWithWeight = class_getClassMethod(self, #selector(mySystemFont(ofSize: weight:))) {
            method_exchangeImplementations(systemFontMethodWithWeight, mySystemFontMethodWithWeight)
        }

        if let systemFontMethod = class_getClassMethod(self, #selector(systemFont(ofSize:))),
            let mySystemFontMethod = class_getClassMethod(self, #selector(mySystemFont(ofSize:))) {
            method_exchangeImplementations(systemFontMethod, mySystemFontMethod)
        }

        if let boldSystemFontMethod = class_getClassMethod(self, #selector(boldSystemFont(ofSize:))),
            let myBoldSystemFontMethod = class_getClassMethod(self, #selector(myBoldSystemFont(ofSize:))) {
            method_exchangeImplementations(boldSystemFontMethod, myBoldSystemFontMethod)
        }

        if let italicSystemFontMethod = class_getClassMethod(self, #selector(italicSystemFont(ofSize:))),
            let myItalicSystemFontMethod = class_getClassMethod(self, #selector(myItalicSystemFont(ofSize:))) {
            method_exchangeImplementations(italicSystemFontMethod, myItalicSystemFontMethod)
        }

        if let initCoderMethod = class_getInstanceMethod(self, #selector(UIFontDescriptor.init(coder:))),
            let myInitCoderMethod = class_getInstanceMethod(self, #selector(UIFont.init(myCoder:))) {
            method_exchangeImplementations(initCoderMethod, myInitCoderMethod)
        }
    }
}

Zum Schluss rufen Sie die erstellte Methode bei Appdelegate wie folgt auf:

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey : Any]? = nil) -> Bool {

        UIFont.overrideDefaultTypography()
        return true
    }
}
1

Ich verwende diese Art von Schriftklasse in Swift. Verwenden der Schriftarterweiterungsklasse.

enum FontName: String {

  case regular      = "Roboto-Regular"

}

//MARK: - Set Font Size
enum FontSize: CGFloat {
    case size = 10

}
extension UIFont {

    //MARK: - Bold Font
  class var regularFont10: UIFont {
        return UIFont(name: FontName.regular.rawValue, size:FontSize.size.rawValue )!
    }
}
0
Karthickkck

Für Xamarin.iOS in AppDelegates FinishedLaunching() Code wie folgt eingeben: - 

UILabel.Appearance.Font= UIFont.FromName("Lato-Regular", 14);

wenn Sie die Schriftart für die gesamte Anwendung festlegen und in Info.plist die Taste "UIAppFonts" hinzufügen, sollte der Pfad der Pfad sein, in dem sich Ihre Schriftartdatei .ttf befindet. Für mich befand sich diese Datei im Ordner "fonts" in meinem Projekt.

<key>UIAppFonts</key>
    <array>
        <string>fonts/Lato-Regular.ttf</string>
    </array>
0
Annu