Mam niestandardową czcionkę, której chcę używać do wszystkiego, co wyświetla tekst w mojej aplikacji, etykiety, widoki tekstu itp.

Czy istnieje sposób na ustawienie domyślnej czcionki (etykiety domyślnie używają czcionek SystemFont) dla całej aplikacji?

Wydaje się, że jest to możliwe w iOS 5 przy użyciu proxy UIAppearance.

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

Spowoduje to ustawienie czcionki na dowolną niestandardową czcionkę dla wszystkich etykiet UIL w Twojej aplikacji. Będziesz musiał powtórzyć to dla każdej kontrolki (UIButton, UILabel itp.).

Pamiętaj, że musisz umieścić wartość UIAppFonts w swoim info.plist i podać nazwę dołączonej czcionki.

Szybki 5

Bazując na odpowiedzi Fábio Oliveiry ( https://stackoverflow.com/a/23042694/2082851 ), tworzę własny szybki 4.

W skrócie, to wymiana domyślne rozszerzenie funkcji init(coder:), systemFont(ofSize:), boldSystemFont(ofSize:), italicSystemFont(ofSize:)z moich metod niestandardowych.

Zauważ, że nie jest w pełni zaimplementowany, ale możesz wymienić więcej metod na podstawie mojej implementacji.

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 {
    static var isOverrided: Bool = false

    @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, !isOverrided else { return }

        // Avoid method swizzling run twice and revert to original initialize function
        isOverrided = true

        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()
    }
    ...
}

Jest też inne rozwiązanie, które będzie polegało na nadpisaniu systemFont.

Po prostu utwórz kategorię

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

Spowoduje to zastąpienie domyślnej implementacji i większość kontrolek UIControl używa systemFont.

Jeśli używasz języka Swift, możesz utworzyć rozszerzenie UILabel:

extension UILabel {

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

}

A potem, gdzie robisz swój wygląd proxy:

UILabel.appearance().substituteFontName = applicationFont

Istnieje równoważny kod Objective-C używający UI_APPEARANCE_SELECTORwłaściwości o nazwie substituteFontName.

Dodanie

W przypadku, gdy chcesz osobno ustawić pogrubione i zwykłe czcionki:

extension UILabel {

    @objc 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)
            }
        }
    }

    @objc 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)
            }
        }
    }
}

Następnie dla serwerów proxy UIAppearance:

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

Uwaga: jeśli stwierdzisz, że pogrubienie nie działa, możliwe, że domyślna nazwa czcionki nie zawiera słowa „Medium”. W razie potrzeby wyłącz ten ciąg na inny mecz (dzięki Masonowi w komentarzach poniżej).

Opracowując z odpowiedzi Hugues BR, ale używając swizzling metody, doszedłem do rozwiązania, które z powodzeniem zmienia wszystkie czcionki na żądaną czcionkę w mojej aplikacji.

Podejście z typem dynamicznym powinno być tym, czego powinieneś szukać w systemie iOS 7. Poniższe rozwiązanie nie używa typu dynamicznego.

Uwagi:

• poniższy kod, w przedstawionym stanie, nigdy nie został przedłożony do zatwierdzenia przez Apple;
• istnieje jego krótsza wersja, która przeszła przez zgłoszenie Apple, czyli bez - initWithCoder:nadpisania. Jednak to nie obejmie wszystkich przypadków;
• następujący kod jest obecny w klasie, której używam do ustawiania stylu mojej aplikacji, która jest zawarta w mojej klasie AppDelegate, dzięki czemu jest dostępna wszędzie i dla wszystkich instancji UIFont;
• Używam Zapfino tylko po to, aby zmiany były bardziej widoczne;
• wszelkie ulepszenia tego kodu są mile widziane.

To rozwiązanie wykorzystuje dwie różne metody uzyskania efektu końcowego. Pierwszym jest nadpisanie metod klasy UIFont + systemFontWithSize:i podobnych metodami używającymi moich alternatyw (tutaj używam "Zapfino", aby nie mieć wątpliwości, że zamiana się powiodła).

Inną metodą jest zastąpienie - initWithCoder:metody w UIFont w celu zastąpienia dowolnego wystąpienia CTFontRegularUsagei podobnych przez moje alternatywy. Ta ostatnia metoda była konieczna, ponieważ odkryłem, że UILabelobiekty zakodowane w plikach NIB nie sprawdzają + systemFontWithSize:metod, aby uzyskać czcionkę systemową, a zamiast tego kodują je jako UICTFontDescriptorobiekty. Próbowałem to przesłonić, - awakeAfterUsingCoder:ale w jakiś sposób było to wywoływane dla każdego zakodowanego obiektu w mojej planszy i powodowało awarie. Zastępowanie - awakeFromNibnie pozwala mi odczytać NSCoderobiektu.

#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

Aby uzupełnić odpowiedź Sandy Chapman , oto rozwiązanie w Objective-C (umieść tę kategorię w dowolnym miejscu, w którym chcesz zmienić UILabel Appearance):

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

Plik interfejsu powinien mieć tę metodę zadeklarowaną publicznie do późniejszego użycia z miejsc takich jak delegat aplikacji:

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

Następnie możesz zmienić za Appearancepomocą:

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

KOMENTARZ DLA SWIFT 3.0 I SWIFT WARNING

Możesz usunąć ostrzeżenie w linii:

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

Zamieniając go na:

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

Dla Swift 5

Wszystkie powyższe odpowiedzi są poprawne, ale zrobiłem to w trochę inny sposób, w zależności od rozmiaru urządzenia . Tutaj, w klasie ATFontManager, ustawiłem domyślny rozmiar czcionki, który jest zdefiniowany na górze klasy jako defaultFontSize , jest to rozmiar czcionki iphone plus i możesz go zmienić zgodnie z wymaganiami.

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 - 5)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 5)!
            
        case .iPhone5:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 3)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 3)!
            
        case .iPhone6AndIphone7, .iPhoneUnknownSmallSize:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize - 2)!
            }
            return UIFont(name: fontN, size: defaultFontSize - 2)!
            
        case .iPhone6PAndIPhone7P, .iPhoneUnknownBigSize:
            
            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!
        case .iPhoneX, .iPhoneXsMax:
            
            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? defaultFontSize)!
          
        case .iPadMini:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 2)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 2)!
            
        case .iPadPro10Inch:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 4)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 4)!
            
        case .iPadPro:
            if let fontSize = iPhone7PlusFontSize{
                return UIFont(name: fontN, size: fontSize + 6)!
            }
            return UIFont(name: fontN, size: defaultFontSize + 6)!
            
        case .iPadUnknownSmallSize:
            
            return UIFont(name: fontN, size: defaultFontSize + 2)!
            
        case .iPadUnknownBigSize:
            
            return UIFont(name: fontN, size: defaultFontSize + 4)!
            
        default:
            
            return UIFont(name: fontN, size: iPhone7PlusFontSize ?? 16)!
        }
    }
}
     

Dodałem nazwę czcionki, aby uzyskać więcej, możesz dodać nazwę czcionki i wpisać tutaj.

   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"
    }

Ta klasa odnosi się do detektora urządzeń w celu zapewnienia odpowiedniego rozmiaru czcionki w zależności od urządzenia.

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
        }
    }
}

Jak używać. Mam nadzieję, że to pomoże.

//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)

Żadne z tych rozwiązań nie działa uniwersalnie w całej aplikacji. Jedną z rzeczy, które pomogły mi w zarządzaniu czcionkami w Xcode, jest otwarcie Storyboard jako kodu źródłowego (Control-click storyboard w nawigatorze plików> „Open as”> „Source”), a następnie wykonanie funkcji „znajdź i zamień”.

Typ czcionki zawsze należy ustawić w kodzie i końcówce / scenorysie.

Ponieważ kod, tak jak powiedział Hugues BR , zrób to w kategorii może rozwiązać problem.

W przypadku końcówki / storyboardu możemy metodą Swizzling awakeFromNib zmienić typ czcionki, ponieważ element interfejsu użytkownika z końcówki / serii ujęć zawsze wywołuje ją przed wyświetleniem na ekranie.

Przypuszczam, że znasz Aspects . To biblioteka do programowania AOP, oparta na Method Swizzling. Tworzymy kategorię dla UILabel, UIButton, UITextView, aby ją zaimplementować.

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

To wszystko, możesz zmienić HelveticaNeue-light na makro z nazwą swojej czcionki.

Stworzyłem własną konwersję typografii dla Swift 4 po przejrzeniu kilku postów, obejmuje ona większość przypadków, takich jak:

1. Dodaj czcionki do struktury projektu i do pliku .plist (o tej samej nazwie):

<key>UIAppFonts</key>
<array>
    <string>Typo-Light.ttf</string>
    <string>Typo-Regular.ttf</string>
    <string>Typo-Semibold.ttf</string>
    <string>Typo-LightItalic.ttf</string>
</array>

Następnie

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)
        }
    }
}

Na koniec wywołaj utworzoną metodę Appdelegatejak dalej:

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

        UIFont.overrideDefaultTypography()
        return true
    }
}

Prawdopodobnie nie, prawdopodobnie sam ustawisz czcionkę na swojej kontrolce, ale możesz ułatwić ten proces, scentralizując miejsce, z którego pobierasz typy czcionek, na przykład delegat aplikacji lub inna wspólna klasa ma metodę, która zwraca czcionka i wszystko, co potrzebne do ustawienia czcionki, może wywołać tę metodę, co pomoże w przypadku konieczności zmiany czcionki, należy ją zmienić w jednym miejscu, a nie wszędzie tam, gdzie ustawisz czcionki ... Inną alternatywą może być utworzenie podklas elementy interfejsu użytkownika, które automatycznie ustawią czcionkę, ale może to być przesada.

NUI jest alternatywą dla proxy UIAppearance. Zapewnia kontrolę nad czcionką (i wieloma innymi atrybutami) dużej liczby typów elementów interfejsu użytkownika w całej aplikacji, po prostu modyfikując arkusz stylów, który można ponownie wykorzystać w wielu aplikacjach.

Po dodaniu NUILabelklasy do etykiet możesz łatwo kontrolować ich czcionkę w arkuszu stylów:

LabelFontName    String    Helvetica

Jeśli masz etykiety z różnymi rozmiarami czcionek, możesz kontrolować ich rozmiary za pomocą klas NUI Label, LargeLabel i SmallLabel, a nawet szybko utworzyć własne klasy.

Szybko używam tego typu klasy czcionek. Korzystanie z klasy rozszerzenia czcionki.

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 )!
    }
}

Dla Xamarin.iOS wewnątrz AppDelegate FinishedLaunching()umieścić kod w następujący sposób: -

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

ustaw czcionkę dla całej aplikacji i dodaj UIAppFontsklawisz ' ' na Info.plist, ścieżka powinna być ścieżką, w której znajduje się plik czcionki .ttf, dla mnie był to folder 'fonts' w moim projekcie.

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

Jak wspomniał @Randall, UIApperanceproxy iOS 5.0+ można wykorzystać do dostosowania wyglądu wszystkich instancji klasy, czytaj więcej .

Automatyczne uzupełnianie Xcodes nie pokazuje wszystkich dostępnych właściwości i może spowodować błąd, ale możesz go po prostu wpisać i skompilować.

UILabel.apperance().font = UIFont.systemFont(ofSize: 17, weight: .regular)

Osiągnęliśmy to samo w Swift -Xcode 7.2 przy użyciu kontrolera widoku rodzica i kontrolera widoku dziecka (dziedziczenie).

Plik - Nowy - Klasa Cocoa Touch - ParentViewController.

    import UIKit
    import Foundation

    class ParentViewController: UIViewController {

        var appUIColor:UIColor = UIColor.redColor()
        var appFont:UIFont = UIFont(name: "Copperplate", size: 20)!

        override func viewDidLoad() {
            super.viewDidLoad()
        }
        func addStatusBar()
        {
            let view = UIView(frame:
                CGRect(x: 0.0, y: 0.0, width: UIScreen.mainScreen().bounds.size.width, height: 20.0)
            )
            view.backgroundColor = appUIColor
            self.view.addSubview(view)
        }
    }    

Utwórz kontrolery widoku podrzędnego i skojarz je z StoryBoard VC, dodaj textLabel.

    import UIKit

    class FontTestController: ParentViewController {
        @IBOutlet var testLabel: UILabel!

        override func viewDidLoad() {
            super.viewDidLoad()
            testLabel.font =  appFont
            testLabel.textColor = appUIColor
        }

LUB Utwórz niestandardową klasę UILabel (metoda podklasy) i skojarz z nią wymagane etykiety.

import Foundation
import UIKit

class CustomFontLabel: UILabel {
    required init(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)!
        backgroundColor = ParentViewController().appUIColor
        font = ParentViewController().appFont
        textColor = UIColor.blackColor()
    }
}

Uwaga: Czcionka i kolor zadeklarowane w nadrzędnym VC są zaimplementowane w CustomFontLabel. Zaletą jest to, że możemy razem zmieniać właściwości uilabel / dowolnego widoku za pomocą kilku prostych zmian w Parent VC.

2) „for” zapętlający się UIView dla widoków podrzędnych. Działa tylko na określonym VC.

    override func viewWillLayoutSubviews() {
            for view in self.view.subviews  {
                if view.isKindOfClass(UITextField) {
                UITextField.appearance().font =  UIFont(name: "Copperplate", size: 20)
                }
                if view.isKindOfClass(UILabel) {
                    UILabel.appearance().font =  UIFont(name: "Copperplate", size: 20)    
                }               
            }       
        }