Définir une police par défaut pour l'ensemble de l'application iOS?

Il semble être possible dans iOS 5 utilisation de l'UIAppearance proxy.

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

Qui permettra de définir la police de caractères à ce que votre police personnalisée est pour tous les UILabels dans votre application. Vous aurez besoin de la répéter pour chaque contrôle (UIButton, UILabel, etc.).

Rappelez-vous, vous aurez besoin de mettre la UIAppFonts valeur de votre info.plist et inclure le nom de la police que vous êtes, y compris.

Il y a aussi une autre solution qui sera à 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

Ce sera de remplacer la valeur par défaut de la mise en œuvre et la plupart des UIControls utilisation systemFont.

Développement de Hugues BR réponse, mais l'aide de la méthode swizzling j'en suis arrivé à une solution qui est réussi à changer toutes les polices de caractères d'une police souhaitée dans mon application.

Une approche de Type Dynamique devrait être ce que vous devriez regarder pour sur iOS 7. La solution suivante est de ne pas utiliser de Type Dynamique.

Notes:

• le code ci-dessous, présenté dans son état, n'a jamais été soumise à l'approbation d'Apple;
• il existe une version plus courte de ce qui passait à Apple de soumission, qui est sans - initWithCoder: remplacer. Toutefois à ne pas couvrir 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 par mon AppDelegate classe donc être disponible partout et à tous les UIFont instances;
• Je suis en utilisant Zapfino ici juste pour faire les modifications beaucoup plus visible;
• toute amélioration que vous pouvez trouver à ce code est la bienvenue.

Cette solution utilise deux méthodes différentes pour obtenir le résultat final. La première est de remplacer le UIFont les méthodes de la classe + systemFontWithSize: et même avec ceux qui utilisent mes alternatives (j'utilise ici "Zapfino" pour ne laisser aucun doute que le remplacement a été couronnée de succès).

L'autre méthode consiste à substituer - initWithCoder: méthode sur UIFont pour remplacer toutes les occurrences de CTFontRegularUsage et similaires par ma alternatives.
Cette dernière méthode a été nécessaire, car j'ai trouvé que UILabel objets encodés en PLUME fichiers ne cochez pas la + systemFontWithSize: méthodes pour obtenir leur système de police et, au lieu de coder comme UICTFontDescriptor objets.
J'ai essayé de remplacer - awakeAfterUsingCoder: mais de toute façon il a été appelé pour chaque codé objet dans mon storyboard et provoquant des plantages. Primordial - awakeFromNib ne me permet pas de lire les NSCoder objet.

#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

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

Aucune de ces solutions ne fonctionne universellement dans toute l'application. Une chose que j'ai trouvé pour l'aider à gérer les polices de caractères dans Xcode est l'ouverture de la table de montage séquentiel comme le code Source (ctrl-cliquez sur le storyboard dans les Fichiers navigator > "Ouvrir en tant que" > "Source"), et ensuite de faire un rechercher-remplacer.

J'ai créé ma propre conversion de la typographie pour Swift 4 après l'examen de quelques postes, il 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 appel à créé méthode à Appdelegate comme suivant:

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

NUI est une alternative à la UIAppearance proxy. Il vous donne le contrôle sur la police (et de nombreux autres attributs) d'un grand nombre d'élément de l'INTERFACE utilisateur types tout au long de votre application en modifiant simplement une feuille de style, qui peut être réutilisée dans de multiples applications.

Après l'ajout d'un NUILabel de la classe à vos étiquettes, vous pouvez facilement le contrôle de la police dans la feuille de style:

LabelFontName    String    Helvetica

Si vous avez des étiquettes avec des tailles de police différentes, vous pouvez contrôler leurs tailles NUI à l'aide de l'Étiquette, LargeLabel, et SmallLabel classes, ou même de créer rapidement vos propres classes.

Pour Xamarin.iOS à l'intérieur de AppDelegate de FinishedLaunching() mettre le code comme ceci :-

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

définir la police pour l'ensemble de l'application et Ajouter " UIAppFonts la touche Info.plist , le chemin doit être le chemin où le fichier de police .ttf est situé .Pour moi, il était à l'intérieur de polices dans le dossier mon projet.

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

Nous avons atteint le même dans Swift -Xcode 7.2 utilisation de la Vue Parent de Contrôleur et de l'Enfant-vue-contrôleur (Héritage).

Fichier - Nouveau - Cocoa Touch classe - 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)
}
}    

Aider un enfant à la vue des contrôleurs et de s'associer avec un StoryBoard, VC, ajouter un textLabel.

    import UIKit
class FontTestController: ParentViewController {
@IBOutlet var testLabel: UILabel!
override func viewDidLoad() {
super.viewDidLoad()
testLabel.font =  appFont
testLabel.textColor = appUIColor
}

OU personnaliser un UILabel Classe(Sous-classification de la méthode) et d'associer des étiquettes requises pour elle.

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

Remarque: la Police et La couleur déclarée Parent VC sont mis en œuvre dans CustomFontLabel . L'avantage est que nous pouvons modifier les propriétés de uilabel/tout afficher tous ensemble dans certains de simples changements dans Parent VC.

2) "pour" boucle UIView pour les sous-vues. Il fonctionne uniquement sur un particulier de 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)    
}               
}       
}