Benutzerdefinierte Schriftgröße in Xcode 6-Größenklassen funktionieren mit benutzerdefinierten Schriftarten nicht ordnungsgemäß

Xcode 6 hat eine neue Funktion in den Schriftart und Schriftgrößen in UILabel, UITextFieldund UIButtonautomatisch auf der Grundlage der Größenklasse der aktuellen Gerätekonfiguration direkt im Storyboard festgelegt werden können. Sie können beispielsweise festlegen UILabel, dass die Schriftgröße 12 für Konfigurationen mit "beliebiger Breite und kompakter Höhe" (z. B. bei iPhones im Querformat) und die Größe 18 für Konfigurationen mit "normaler Breite und normaler Höhe" (z. B. auf iPads ) verwendet wird. Weitere Informationen finden Sie hier:

developer.apple.com/size_class

Dies ist theoretisch eine großartige Funktion, da es möglicherweise unnötig wird, programmgesteuert unterschiedliche Schriftarten für UI-Funktionen basierend auf der Gerätekonfiguration festzulegen. Im Moment habe ich einen bedingten Code, der die Schriftarten basierend auf dem Gerätetyp festlegt, aber das bedeutet natürlich, dass ich die Schriftarten überall in der App programmgesteuert festlegen muss. Ich war anfangs sehr aufgeregt über diese Funktion, aber ich stellte fest, dass es ein ernstes Problem der tatsächlichen Nutzung für mich gibt (möglicherweise ein Fehler). Beachten Sie, dass ich gegen SDK 8 baue und ein Mindestbereitstellungsziel für iOS 8 festlege. Dies hat also nichts mit der Kompatibilität mit alten Versionen von iOS zu tun.

Das Problem ist folgendes: Wenn ich unterschiedliche Schriftgrößen für unterschiedliche Größenklassen einstelle und die von iOS bereitgestellte Schriftart "System" verwende , funktioniert alles wie erwartet, und die Schriftgrößen ändern sich je nach Größenklasse. Wenn ich eine von meiner Anwendung bereitgestellte benutzerdefinierte Schriftart verwende (ja, ich habe sie in meinem Anwendungspaket korrekt eingerichtet, da sie programmgesteuert funktioniert) und die benutzerdefinierte Schriftart auf eine Beschriftung in einem XCode 6-Storyboard setze , funktioniert dies ebenfalls wie erwartet. Wenn ich jedoch versuche, verschiedene Größen der benutzerdefinierten Schriftart für verschiedene Größenklassen im Storyboard zu verwenden, funktioniert dies plötzlich nicht mehr. Der einzige Unterschied in der Konfiguration ist die von mir gewählte Schriftart (eine benutzerdefinierte im Vergleich zur Systemschriftart). Stattdessen werden alle Schriftarten auf dem angezeigtGerät und Simulator als Standardsystemschriftart in der Standardgröße , unabhängig von der Größenklasse (und ich habe über den Debugger überprüft, dass die Systemschriftart die im Storyboard angegebene ersetzt). Grundsätzlich scheint die Größenklassenfunktion für benutzerdefinierte Schriftarten nicht zu funktionieren. Interessanterweise werden die benutzerdefinierten Schriftarten im XCode 6-Bereich "Vorschau" für den Ansichts-Controller tatsächlich angezeigt und passen die Größe richtig an: Sie funktionieren nur dann nicht mehr, wenn sie auf dem tatsächlichen iOS-System ausgeführt werden (was mich glauben lässt, dass ich sie richtig konfiguriere). .

Ich habe mehrere verschiedene benutzerdefinierte Schriftarten ausprobiert und es scheint für keine von ihnen zu funktionieren, aber es funktioniert immer, wenn ich stattdessen "System" verwende.

Wie auch immer, hat jemand anderes dieses Problem in Xcode 6 gesehen ?

Irgendwelche Ideen, ob dies ein Fehler in iOS 8, Xcode oder so ist

Mache ich falsch

Die einzige Problemumgehung, die ich gefunden habe, besteht darin, die Schriftarten weiterhin programmgesteuert festzulegen, wie ich es für etwa drei Versionen von iOS getan habe, da dies funktioniert.

Aber ich würde gerne in der Lage sein, diese Funktion zu verwenden, wenn ich sie mit benutzerdefinierten Schriftarten zum Laufen bringen könnte. Die Verwendung der Systemschriftart ist für unser Design nicht akzeptabel.

ZUSÄTZLICHE INFORMATIONEN: Ab Xcode 8.0 ist der Fehler behoben.

Schnelle Lösung:

1) Legen Sie Schriftarten als System für Größenklassen fest

2) Unterklasse UILabel und überschreibe die Methode "layoutSubviews" wie folgt:

- (void)layoutSubviews
{
  [super layoutSubviews];

   // Implement font logic depending on screen size
    if ([self.font.fontName rangeOfString:@"bold" options:NSCaseInsensitiveSearch].location == NSNotFound) {
        NSLog(@"font is not bold");
        self.font = [UIFont fontWithName:@"Custom regular Font" size:self.font.pointSize];
    } else {
        NSLog(@"font is bold");
        self.font = [UIFont fontWithName:@"Custom bold Font" size:self.font.pointSize];
    }

}

Übrigens ist es eine sehr praktische Technik für ikonische Schriftarten

Nachdem ich alles ausprobiert hatte, entschied ich mich schließlich für eine Kombination der oben genannten Lösungen. Verwenden von Xcode 7.2, Swift 2.

import UIKit

class LabelDeviceClass : UILabel {

    @IBInspectable var iPhoneSize:CGFloat = 0 {
        didSet {
            if isPhone() {
                overrideFontSize(iPhoneSize)
            }
        }
    }

    @IBInspectable var iPadSize:CGFloat = 0 {
        didSet {
            if isPad() {
                overrideFontSize(iPadSize)
            }
        }
    }

    func isPhone() -> Bool {
        // return UIDevice.currentDevice().userInterfaceIdiom == .Phone
        return !isPad()
    }

    func isPad() -> Bool {
        // return UIDevice.currentDevice().userInterfaceIdiom == .Pad
        switch (UIScreen.mainScreen().traitCollection.horizontalSizeClass, UIScreen.mainScreen().traitCollection.verticalSizeClass) {
        case (.Regular, .Regular):
            return true
        default:
            return false
        }
    }

    func overrideFontSize(fontSize:CGFloat){
        let currentFontName = self.font.fontName
        if let calculatedFont = UIFont(name: currentFontName, size: fontSize) {
            self.font = calculatedFont
        }
    }

}

• @IBInspectable Mit dieser Option können Sie die Schriftgröße im Storyboard festlegen
• Es wird ein didSetBeobachter verwendet, um die Fallstricke von layoutSubviews()(Endlosschleife für awakeFromNib()Zeilenhöhen in der dynamischen Tabellenansicht) und (siehe Kommentar von @ cocoaNoob) zu vermeiden.
• Es werden Größenklassen anstelle der Gerätesprache verwendet, in der Hoffnung, diese letztendlich mit zu verwenden @IBDesignable
• Funktioniert leider @IBDesignablenicht mit traitCollectiondiesem anderen Stapelartikel
• Die Anweisung zum Wechseln der Merkmalssammlung wird UIScreen.mainScreen()nicht selfgemäß diesem Stapelartikel ausgeführt

Problemumgehung für UILabel: Behalten Sie für alle Größenklassen die gleiche Schriftgröße bei, ändern Sie jedoch stattdessen die Beschriftungshöhe in jeder Größenklasse entsprechend. Auf Ihrem Etikett muss Autoshrink aktiviert sein. In meinem Fall hat es gut funktioniert.

Dieser (und andere mit Xcode - Größenklassen zusammenhängende) Fehler verursachte mir in letzter Zeit ernsthaften Kummer, als ich eine riesige Storyboard-Datei durchgehen musste, um Dinge wegzuhacken.

Für alle anderen in dieser Position möchte ich zusätzlich zu @ razor28s Antwort etwas hinzufügen, um die Schmerzen zu lindern.

Verwenden IBInspectableSie in der Header-Datei Ihrer benutzerdefinierten Unterklasse für Ihre Laufzeitattribute. Dadurch werden diese Attribute über den "Attributes Inspector" visuell direkt über der Standardposition für die Schriftarteinstellungen zugänglich.

Anwendungsbeispiel:

@interface MyCustomLabel : UILabel

    @property (nonatomic) IBInspectable NSString *fontType;
    @property (nonatomic) IBInspectable CGFloat iphoneFontSize;
    @property (nonatomic) IBInspectable CGFloat ipadFontSize;

@end

Dies wird diese Ausgabe sehr hilfreich erzeugen:

Ein zusätzlicher Vorteil ist, dass wir jetzt die Laufzeitattribute nicht mehr manuell für jedes Etikett hinzufügen müssen. Dies ist das, was ich dem beabsichtigten Verhalten von XCode am nächsten kommen kann. Hoffentlich ist mit iOS 9 in diesem Sommer eine richtige Lösung auf dem Weg.

Ähnliche Lösung wie bei @ razor28, aber ich denke etwas universeller. Funktioniert auch gut mit älteren iOS-Versionen

https://gist.github.com/softmaxsg/8a3ce30331f9f07f023e

Der Fehler ist in XCode 7.0 GM weiterhin gültig.

Die Lösung von Razor28 verursacht in einigen Fällen Endlosschleifen. Meine Erfahrung war mit der Verwendung in Verbindung mit SwipeView .

Stattdessen schlage ich vor, dass Sie:

1) Unterklasse UILabel und überschreiben setFont:

- (void)setFont:(UIFont *)font
{
    font = [UIFont fontWithName:(@"Montserrat") size:font.pointSize];
    [super setFont:font];
}

2) Legen Sie die benutzerdefinierte Klasse Ihrer UILabels fest und legen Sie dann die Schriftgrößenklassen mithilfe der Systemschrift fest

Das Problem besteht weiterhin darin, dass Sie die Funktion nicht zum Festlegen von Schriftarten für verschiedene Größenklassen im Interface Builder verwenden können.

Stellen Sie einfach die Schriftart basierend auf dem gewünschten Gerät wie folgt ein:

if (Your Device is iPAd) //For iPad
{
   [yourLabel setFont:[UIFont fontWithName:@"FontName" size:FontSize]]; 
}
else  //For Other Devices then iPad
{
   [yourLabel setFont:[UIFont fontWithName:@"FontName" size:FontSize]]; 
}

Dies funktioniert perfekt auf allen Geräten.

Nichts davon hat bei mir funktioniert, aber das hat funktioniert. Sie müssen auch die Systemschriftart in IB verwenden

#import <UIKit/UIKit.h>

@interface UILabelEx : UILabel


@end

#import "UILabelEx.h"
#import "Constants.h"

@implementation UILabelEx

- (void) traitCollectionDidChange: (UITraitCollection *) previousTraitCollection {
    [super traitCollectionDidChange: previousTraitCollection];

    self.font = [UIFont fontWithName:APP_FONT size:self.font.pointSize];   
}
@end

Immer noch keine unterschriebene richtige Antwort. Dieser Code funktioniert gut für mich. Sie müssen zuerst die Schriftgröße für Größenklassen im Interface Builder deaktivieren. In IB können Sie eine benutzerdefinierte Schriftart verwenden.

- (void) traitCollectionDidChange: (UITraitCollection *) previousTraitCollection {
    [super traitCollectionDidChange: previousTraitCollection];

    if ((self.traitCollection.verticalSizeClass != previousTraitCollection.verticalSizeClass)
        || self.traitCollection.horizontalSizeClass != previousTraitCollection.horizontalSizeClass) {

         self.textField.font = [UIFont fontWithName:textField.font.fontName size:17.f];

    }
}

Eine Kombination einiger der oben genannten späteren Antworten war hilfreich. So habe ich den IB-Fehler über eine Swift UILabel-Erweiterung behoben:

import UIKit

// This extension is only required as a work-around to an interface builder bug in XCode 7.3.1
// When custom fonts are set per size class, they are reset to a small system font
// In order for this extension to work, you must set the fonts in IB to System
// We are switching any instances of ".SFUIDisplay-Bold" to "MuseoSans-700" and ".SFUIDisplay-Regular" to "MuseoSans-300" and keeping the same point size as specified in IB

extension UILabel {
    override public func traitCollectionDidChange(previousTraitCollection: UITraitCollection?) {
        super.traitCollectionDidChange(previousTraitCollection)

        if ((traitCollection.verticalSizeClass != previousTraitCollection?.verticalSizeClass) || traitCollection.horizontalSizeClass != previousTraitCollection?.horizontalSizeClass) {
            //let oldFontName = "\(font.fontName)-\(font.pointSize)"

            if (font.fontName == systemFontRegular) {
                font = UIFont(name: customFontRegular, size: (font?.pointSize)!)
                //xlog.debug("Old font: \(oldFontName) -> new Font: \(font.fontName) - \(font.pointSize)")
            }
            else if (font.fontName == systemFontBold) {
                font = UIFont(name: customFontBold, size: (font?.pointSize)!)
                //xlog.debug("Old font: \(oldFontName) -> new Font: \(font.fontName) - \(font.pointSize)")
            }
        }
    }
}

Ich benutze Swift, XCode 6.4. Das habe ich also getan

import Foundation
import UIKit

    @IBDesignable class ExUILabel: UILabel {

        @IBInspectable var fontName: String = "Default-Font" {
            didSet {
                self.font = UIFont(name: fontName, size:self.font.pointSize)
            }
        }

        override func layoutSubviews() {
            super.layoutSubviews()
            self.font = UIFont(name: fontName, size:self.font.pointSize)
        }
    }

1. Gehe zu Designer -> Identitätsinspektor -> Setze die Klasse auf ExUILabel

2. Gehen Sie dann im Designer zum Attributinspektor und legen Sie den Schriftartnamen fest.

Ich habe mir eine noch schnellere Lösung ausgedacht (ich gehe davon aus, dass Sie immer Ihre einzige benutzerdefinierte Schriftart verwenden).

Erstellen Sie eine Kategorie für UILabel und fügen Sie sie mithilfe eines fehlerhaften Storyboards mit Größenklassen und dedizierten Schriftarteneinstellungen für verschiedene Klassen in Dateien ein:

@implementation UILabel (FontFixForSizeClassesAppleBug)

- (void)layoutSubviews
{
    [super layoutSubviews];
    if([[UIFont systemFontOfSize:10].familyName isEqualToString:self.font.familyName]) {
        //workaround for interface builder size classes bug which ignores custom font if various classes defined for label: http://stackoverflow.com/questions/26166737/custom-font-sizing-in-xcode6-size-classes-not-working-properly-w-custom-fonts
        self.font = [UIFont fontWithName:@"YOUR_CUSTOM_FONT_NAME" size:self.font.pointSize];
    }
}

@end

Verwenden Sie einfach Ihre benutzerdefinierten Schriftarten im Storyboard. Wenn ein fehlerhafter Interpreter stattdessen eine Systemschrift verwendet, wird diese Kategorie in Ihre benutzerdefinierte Schriftart umgeschaltet.

Ich hatte das gleiche Problem und fand eine nicht wirklich klare, aber gute Lösung!

1. Zuerst legen Sie die erforderliche Schriftgröße im Storyboard mit dem Systemschriftnamen fest.
2. Dann weisen Sie diesem Label ein Tag von 100 bis 110 zu (oder mehr, aber 10 war mir in einem View Controller immer genug).
3. Fügen Sie diesen Code dann in die Quelldatei Ihres VC ein und vergessen Sie nicht, den Schriftnamen zu ändern. Code in schnell.

override func viewDidLayoutSubviews() {
    for i in 100...110 {
        if let label = view.viewWithTag(i) as? UILabel {
            label.font = UIFont(name: "RotondaC-Bold", size: label.font.pointSize)
        }
    }
}

• Fügen Sie von der Anwendung bereitgestellte Schriftarten zu Ihrer App .plist hinzu
• Fügen Sie Ihre .ttf-Datei zu Element 0 hinzu
• benutze es [UIFont fontWithName: "example.ttf" Größe: 10]