Définir une police par défaut pour toute l'application iOS?
Je souhaite utiliser une police personnalisée pour tout ce qui affiche du texte dans mon application, des étiquettes, des vues de texte, etc.
Est-il possible de définir la police par défaut (les étiquettes utilisent par défaut SystemFont) pour l'ensemble de l'application?
Cela semble être possible dans iOS 5 en utilisant le proxy UIAppearance.
[[UILabel appearance] setFont:[UIFont fontWithName:@"YourFontName" size:17.0]];
Cela définira la police de manière à correspondre à votre police personnalisée pour toutes les étiquettes UIL de votre application. Vous devrez le répéter pour chaque contrôle (UIButton, UILabel, etc.).
N'oubliez pas que vous devez mettre la valeur UIAppFonts dans votre info.plist et inclure le nom de la police que vous incluez.
Swift 4.1
Sur la base de la réponse de Fábio Oliveira ( https://stackoverflow.com/a/23042694/2082851 ), je fabrique mon propre Swift 4.
En bref, cette extension échange les fonctions par défaut init(coder:), systemFont(ofSize:), boldSystemFont(ofSize:), italicSystemFont(ofSize:) avec mes méthodes personnalisées.
Notez que ce n'est pas complètement implémenté, mais vous pouvez échanger plus de méthodes basées sur mon implémentation.
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()
}
...
}
Il existe également une autre solution qui consistera à remplacer systemFont.
Il suffit de créer une catégorie
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
Ceci remplacera l'implémentation par défaut et la plupart des contrôleurs UIControls utilisent systemFont.
Si vous utilisez Swift, vous pouvez créer une extension UILabel:
extension UILabel {
var substituteFontName : String {
get { return self.font.fontName }
set { self.font = UIFont(name: newValue, size: self.font.pointSize) }
}
}
Et ensuite, où vous faites votre apparition en remplaçant le mandataire:
UILabel.appearance().substituteFontName = applicationFont
Il existe un code Objective-C équivalent utilisant UI_APPEARANCE_SELECTOR sur une propriété portant le nom substituteFontName.
Une addition
Dans le cas où vous voudriez définir des polices en gras et des polices ordinaires séparément:
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)
}
}
}
}
Ensuite, pour vos mandataires UIAppearance:
UILabel.appearance().substituteFontName = applicationFont
UILabel.appearance().substituteFontNameBold = applicationFontBold
Remarque: si vous constatez que la substitution en gras ne fonctionne pas, il est possible que le nom de police par défaut ne contienne pas "Moyen". Changez cette chaîne pour une autre correspondance si nécessaire (merci à Mason dans les commentaires ci-dessous).
Développer à partir de Hugues BR réponse mais en utilisant la méthode swizzling je suis arrivé à une solution qui est en train de changer avec succès toutes les polices pour une police souhaitée dans mon application.
Une approche avec type dynamique devrait être ce que vous devriez rechercher sur iOS 7. La solution suivante n'utilise pas le type dynamique.
Remarques:
- le code ci-dessous, dans son état actuel, n'a jamais été soumis à l'approbation de Apple;
- il existe une version plus courte de celle-ci qui a passé la soumission Apple, c'est-à-dire sans la substitution
- initWithCoder:. Cependant, cela ne couvrira pas tous les cas; - le code suivant est présent dans une classe que j'utilise pour définir le style de mon application, qui est inclus dans ma classe AppDelegate, et donc disponible partout et pour toutes les instances de UIFont;
- J'utilise Zapfino ici simplement pour rendre les modifications beaucoup plus visibles;
- toute amélioration apportée à ce code est la bienvenue.
Cette solution utilise deux méthodes différentes pour obtenir le résultat final. La première consiste à remplacer les méthodes de la classe UIFont + systemFontWithSize: et les mêmes méthodes que celles qui utilisent mes alternatives (ici, j'utilise "Zapfino" pour ne laisser aucun doute sur le fait que le remplacement a été effectué avec succès).
L'autre méthode consiste à surcharger la méthode - initWithCoder: sur UIFont pour remplacer toute occurrence de CTFontRegularUsage et similaire par mes alternatives .. .. Cette dernière méthode était nécessaire car j'ai constaté que les objets UILabel encodés dans des fichiers NIB ne vérifient pas les méthodes + systemFontWithSize: récupère leur police système et les encode en tant qu'objets UICTFontDescriptor . J'ai essayé de remplacer - awakeAfterUsingCoder:, mais d'une manière ou d'une autre, il était appelé pour chaque objet encodé de mon storyboard et provoquait des plantages. Remplacer - awakeFromNib ne me permettrait pas de lire l'objet NSCoder.
#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
Pour compléter La réponse de Sandy Chapman , voici une solution en Objective-C (placez cette catégorie partout où vous souhaitez changer UILabelAppearance):
@implementation UILabel (FontOverride)
- (void)setSubstituteFontName:(NSString *)name UI_APPEARANCE_SELECTOR {
self.font = [UIFont fontWithName:name size:self.font.pointSize];
}
@end
Le fichier d'interface devrait avoir cette méthode déclarée publiquement être utilisé ultérieurement à des endroits tels que votre délégué d'application:
@interface UILabel (FontOverride)
- (void)setSubstituteFontName:(NSString *)name UI_APPEARANCE_SELECTOR;
@end
Ensuite, vous pouvez changer la Appearance avec:
[[UILabel appearance] setSubstituteFontName:@"SourceSansPro-Light"];
Je l'ai publié comme une nouvelle réponse et non comme un commentaire car je n'ai pas assez de réputation.
COMMENTAIRE POUR Swift 3.0 ET Swift AVERTISSEMENT
Vous pouvez supprimer le message d'avertissement en ligne:
let initCoderMethod = class_getInstanceMethod(self, Selector("initWithCoder:"))
En le remplaçant par:
let initCoderMethod = class_getInstanceMethod(self, #selector(UIFontDescriptor.init(coder:)))
Pour Swift 4
Toutes les réponses ci-dessus sont correctes, mais j’ai fait de manière légèrement différente c’est en fonction de la taille de l’appareil . defaultFontSize , il s’agit de la taille de la police iphone plus et vous pouvez la modifier en fonction de vos besoins.
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)!
}
}
}
J'ai ajouté un nom de police, pour plus d'informations, vous pouvez ajouter le nom et le type de police ici.
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"
}
Cette classe concerne le détecteur de périphérique afin de fournir la taille de police appropriée en fonction du périphérique.
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
}
}
}
Comment utiliser. J'espère que ça va aider.
//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)
Le type de police doit toujours être défini en code et en nib/storyboard.
Pour le code, tout comme Hugues BR a dit , le faire en catégorie peut résoudre le problème.
Pour le nib/storyboard, nous pouvons utiliser Method Swizzling awakeFromNib pour changer le type de police puisque l'élément d'interface utilisateur de nib/storyboard l'appelle toujours avant son affichage à l'écran.
Je suppose que vous connaissez Aspects C'est une bibliothèque pour la programmation AOP, basée sur Method Swizzling . Nous créons une catégorie pour UILabel, UIButton, UITextView afin de l'implémenter.
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
C'est tout, vous pouvez modifier HelveticaNeue-light en une macro portant le nom de votre police.
Probablement pas, vous aurez probablement la police pour définir vous-même la police, mais vous pouvez faciliter le processus en centralisant la source des types de police. Par exemple, le délégué de l'application ou une autre classe commune dispose-t-il d'une méthode qui renvoie police, et tout ce qui doit définir la police peut appeler cette méthode, ce qui vous aidera au cas où vous auriez besoin de changer de police, de la changer à un endroit plutôt que partout où vous définissez les polices ... Une autre alternative peut être de créer des sous les éléments de votre interface utilisateur qui définissent automatiquement la police, mais cela risque d’être excessif.
Aucune de ces solutions ne fonctionne de manière universelle dans l'application. Une des choses que j’ai trouvée pour aider à gérer les polices dans Xcode est d’ouvrir le Storyboard en tant que code source (Ctrl-clic sur le storyboard dans le navigateur de fichiers> "Ouvrir en tant que>> Source"), puis de rechercher/remplacer.
NUI est une alternative au proxy UIAppearance. Il vous permet de contrôler la police (et de nombreux autres attributs) d'un grand nombre de types d'élément d'interface utilisateur dans votre application en modifiant simplement une feuille de style, qui peut être réutilisée dans plusieurs applications.
Après avoir ajouté une classe NUILabel à vos étiquettes, vous pouvez facilement contrôler leur police dans la feuille de style:
LabelFontName String Helvetica
Si vous avez des étiquettes avec différentes tailles de police, vous pouvez contrôler leur taille à l'aide des classes Label, LargeLabel et SmallLabel de NUI, ou même créer rapidement vos propres classes.
J'ai créé ma propre conversion de typographie pour Swift 4 après avoir examiné quelques articles, elle couvre la plupart des cas, tels que:
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)
}
}
}
Enfin, appelez la méthode created à Appdelegate comme suit:
class AppDelegate: UIResponder, UIApplicationDelegate {
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey : Any]? = nil) -> Bool {
UIFont.overrideDefaultTypography()
return true
}
}
J'utilise comme ce type de classe de polices dans Swift. Utilisation de la classe d’extension de police.
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 )!
}
}
Pour Xamarin.iOS dans la fonction FinishedLaunching() de AppDelegate, mettez le code comme suit: -
UILabel.Appearance.Font= UIFont.FromName("Lato-Regular", 14);
définir la police pour l’application entière et ajouter la clé 'UIAppFonts' sur Info.plist, le chemin doit être celui où se trouve votre fichier de police .ttf.
<key>UIAppFonts</key>
<array>
<string>fonts/Lato-Regular.ttf</string>
</array>