ios - san - letra cursiva iphone instagram

Diferentes tamaños de fuente iOS en una clase de tamaño único para diferentes dispositivos

Question

En iOS 8, podemos diseñar un diseño de interfaz de usuario diferente para cada clase de tamaño. El problema al que me enfrento es que he diseñado un diseño para Ancho Compacto y Altura Regular (clase de tamaño para todos los iPhones en retrato) pero quiero mantener el tamaño de fuente de las etiquetas más pequeñas para dispositivos de 3.5 y 4 pulgadas (iPhone 4 y 5 ), luego relativamente más grande para dispositivos de 4.7 pulgadas (iPhone 6) y más grande para dispositivos de 5.5 pulgadas (iPhone 6 Plus). He buscado pero no puedo encontrar una solución para establecer diferentes tamaños de fuente para diferentes dispositivos dentro de la misma clase de tamaño.

Answer 1

Así es como lo hice. Está escrito en Swift 4 :)

enum DeviceSize {
    case big, medium, small
}

protocol Fontadjustable {

    var devicetype: DeviceSize { get }

    func adjustFontSizeForDevice()
}

extension UILabel: Fontadjustable {

    var devicetype: DeviceSize {
        switch UIScreen.main.nativeBounds.height {
        case 1136:
            return .small
        case 1334:
            return .medium
        case 2208:
            return .big
        case 2436:
            return .big
        default:
            return .big
        }
    }

    func adjustFontSizeForDevice() {
        switch self.devicetype {
        case .small:
            self.font = font.withSize(font.pointSize)
        case .medium:
            self.font = font.withSize(font.pointSize + 5)
        case .big:
            self.font = font.withSize(font.pointSize + 10)
        }
    }
}

USO: myawesomeLabel.adjustFontSizeForDevice()

Answer 2

Crea como esto,

#define VIEWHEIGHT       ([[UIScreen mainScreen] bounds].size.height)
#define VIEWWIDTH        ([[UIScreen mainScreen] bounds].size.width)
#define FONTNAME_LIGHT   @"AppleSDGothicNeo-Regular"
#define FONTNAME_BOLD    @"AppleSDGothicNeo-Bold"
#define LFONT_16         [UIFont fontWithName:FONTNAME_LIGHT size:16]

después de eso, cuando desee cambiar la fuente de la etiqueta, podemos escribir un sencillo conmutador

switch ((VIEWHEIGHT == 568)?1:((VIEWHEIGHT == 667)?2:3)) {
    case 1:{
        boldFont = BFONT_16;
    }
        break;
    case 2:{
        privacyFont = LFONT_18;
        boldFont = BFONT_18;
    }
        break;
    default:{
        privacyFont = LFONT_20;
        boldFont = BFONT_20;
    }
        break;
}

Swift Version

func isPhoneDevice() -> Bool {
    return UIDevice.current.userInterfaceIdiom == .phone
}

func isDeviceiPad() -> Bool {
    return UIDevice.current.userInterfaceIdiom == .pad
}

func isPadProDevice() -> Bool {
    let SCREEN_WIDTH = Float(UIScreen.main.bounds.size.width)
    let SCREEN_HEIGHT = Float(UIScreen.main.bounds.size.height)
    let SCREEN_MAX_LENGTH: Float = fmax(SCREEN_WIDTH, SCREEN_HEIGHT)

    return UIDevice.current.userInterfaceIdiom == .pad && SCREEN_MAX_LENGTH == 1366.0
}

func isPhoneXandXSDevice() -> Bool {
    let SCREEN_WIDTH = CGFloat(UIScreen.main.bounds.size.width)
    let SCREEN_HEIGHT = CGFloat(UIScreen.main.bounds.size.height)
    let SCREEN_MAX_LENGTH: CGFloat = fmax(SCREEN_WIDTH, SCREEN_HEIGHT)

    return UIDevice.current.userInterfaceIdiom == .phone && SCREEN_MAX_LENGTH == 812.0
}

func isPhoneXSMaxandXRDevice() -> Bool {
    let SCREEN_WIDTH = CGFloat(UIScreen.main.bounds.size.width)
    let SCREEN_HEIGHT = CGFloat(UIScreen.main.bounds.size.height)
    let SCREEN_MAX_LENGTH: CGFloat = fmax(SCREEN_WIDTH, SCREEN_HEIGHT)

    return UIDevice.current.userInterfaceIdiom == .phone && SCREEN_MAX_LENGTH == 896.0
}

Answer 3

Dos caminos:

1) Haga manualmente un método en el delegado de aplicaciones, comparta su objeto y llame al método.

p.ej :

    var device = UIDevice.currentDevice().model

    if (device == "iPhone" || device == "iPhone Simulator" || device == "iPod touch")
        {
            labelboarder.frame = CGRectMake(0,self.usernameTF.frame.height-10, self.usernameTF.frame.width, 1)
            labelboarder1.frame = CGRectMake(0,self.usernameTF.frame.height-10, self.usernameTF.frame.width,1)
        }
    else
        {
            labelboarder.frame = CGRectMake(0,self.usernameTF.frame.height, 500, 1)
            labelboarder1.frame = CGRectMake(0,self.usernameTF.frame.height, 500,1)
        }

2) En cada elemento de la IU, vaya al inspector de atributos, declare una fuente.

(Hay un signo + visible a la izquierda del campo Tamaño de fuente. Haga clic en él, seleccione la clase de tamaño coincidente y declare el tamaño de fuente).

La segunda opción es conveniente para mí. ¡Feliz codificación!

Answer 4

En lugar de escribir código para todas y cada una de las etiquetas, simplemente extienda su clase de etiqueta con Su clase de etiqueta personalizada como se muestra a continuación y se escalará automáticamente según el factor de escala de la resolución del dispositivo:

#define  SCALE_FACTOR_H ( [UIScreen mainScreen].bounds.size.height / 568 )


CustomLabel.h

#import <UIKit/UIKit.h>

@interface CustomLabel : UILabel

@end


CustomLabel.m
#import "CustomLabel.h"

@implementation CustomLabel

/*
// Only override drawRect: if you perform custom drawing.
// An empty implementation adversely affects performance during animation.
- (void)drawRect:(CGRect)rect {
    // Drawing code
}
*/
- (id)initWithCoder:(NSCoder *)aDecoder {
    if( (self = [super initWithCoder:aDecoder]) ){
        [self layoutIfNeeded];
        [self configurefont];
    }
    return self;
}

- (void) configurefont {
    CGFloat newFontSize = (self.font.pointSize * SCALE_FACTOR_H);
    self.font = [UIFont fontWithName:self.font.fontName size:newFontSize];
}
@end

Answer 5

Lo estoy manejando en un proyecto en Swift 3+ utilizando una clase UILabel Custom , una extensión UILabel y una extensión UIDevice como solución genérica.

Extensión de UIDevice para obtener screenType :

public extension UIDevice {

    var iPhone: Bool {
        return UIDevice().userInterfaceIdiom == .phone
    }

    enum ScreenType: String {
        case iPhone4
        case iPhone5
        case iPhone6
        case iPhone6Plus
        case iPhoneX
        case Unknown
    }

    var screenType: ScreenType {
        guard iPhone else { return .Unknown}
        switch UIScreen.main.nativeBounds.height {
        case 960:
            return .iPhone4
        case 1136:
            return .iPhone5
        case 1334:
            return .iPhone6
        case 2208:
            return .iPhone6Plus
        case 2436:
            return .iPhoneX
        default:
            return .Unknown
        }
    }

}

A continuación se encuentra la extensión UILabel que usa screenType para ajustar el tamaño de la fuente. adjustsFontSizeToFitDevice método adjustsFontSizeToFitDevice podría agregarse en la clase personalizada de UILabel , pero lo puse en la extensión de UILabel para hacerlo accesible desde todos los tipos de instancias de UILabel.

La constante "2" utilizada en el método de adjustsFontSizeToFitDevice se puede cambiar a cualquier número deseado. Mi lógica es considerar el iPhone 6/7/8 como resolución predeterminada y proporcionar el tamaño de fuente adecuado (en el Guión gráfico ) a cada etiqueta para esa resolución. Luego, estoy sumando 2 puntos para iPhone X y iPhone 6/7/8 Plus, mientras que resta 2 puntos para iPhone 4/5.

extension UILabel {

    func adjustsFontSizeToFitDevice() {

        switch UIDevice().screenType {
        case .iPhone4, .iPhone5:
            font = font.withSize(font.pointSize - 2)
            break
        case .iPhone6Plus, .iPhoneX:
            font = font.withSize(font.pointSize + 2)
            break
        default:
            font = font.withSize(font.pointSize)
        }
    }

}

Finalmente, una clase personalizada de UILabel para aplicar el ajuste de fuente a todas las etiquetas que están MyCustomLabel de MyCustomLabel .

class MyCustomLabel: UILabel {

    // MARK: - Life Cycle Methods

    override func awakeFromNib() {
        super.awakeFromNib()

        adjustsFontSizeToFitDevice()
    }

}

Uso: En Storyboard , asigne una MyCustomLabel todas aquellas instancias de UILabel de MyCustomLabel cuyo tamaño de fuente debe ajustarse según el tamaño del dispositivo.

Answer 6

Edit : ya no recomiendo esto Este enfoque no se adapta bien cuando salen nuevos dispositivos. Utilice una combinación de tamaños de fuente dinámicos y fuentes de tamaño específicas para cada clase.

Supongamos que sale un nuevo modelo de iPhone, si está utilizando Auto Layout y Clases de tamaño, no tiene que corregir todas las restricciones manualmente para que su aplicación sea compatible con este nuevo dispositivo. Sin embargo, aún puede establecer el tamaño de fuente de la UILabel usando el siguiente código:

if UIScreen.mainScreen().bounds.size.height == 480 {
    // iPhone 4
    label.font = label.font.fontWithSize(20)     
} else if UIScreen.mainScreen().bounds.size.height == 568 {
    // IPhone 5
    label.font = label.font.fontWithSize(20)
} else if UIScreen.mainScreen().bounds.size.width == 375 {
    // iPhone 6
    label.font = label.font.fontWithSize(20)
} else if UIScreen.mainScreen().bounds.size.width == 414 {
    // iPhone 6+
    label.font = label.font.fontWithSize(20)
} else if UIScreen.mainScreen().bounds.size.width == 768 {
    // iPad
    label.font = label.font.fontWithSize(20)
}

Answer 7

Puede lograr el efecto deseado de la siguiente manera.

Usage : lugar de usar 14 como tamaño de fuente , puede usar 14.fontSize , cambiará según el dispositivo, depende de su valor delta.

No es necesario agregar condiciones en ningún lugar del código. Sólo una vez como a continuación.

Uso: UIFont.font_medium(12.fontSize)

Extensión de UIFont:

extension UIFont {    
    class func font_medium(_ size : CGFloat) -> UIFont {
        return UIFont(name: "EncodeSans-Medium", size: size)!;
    }    
}

Extensión de UIDevice:

extension UIDevice {
    enum DeviceTypes {
        case iPhone4_4s
        case iPhone5_5s
        case iPhone6_6s
        case iPhone6p_6ps
        case after_iPhone6p_6ps
    }

    static var deviceType : DeviceTypes {
        switch UIScreen.main.height {
        case 480.0:
            return .iPhone4_4s
        case 568.0:
            return .iPhone5_5s
        case 667.0:
            return .iPhone6_6s
        case 736.0:
            return .iPhone6p_6ps
        default:
            return .after_iPhone6p_6ps
        }
    }
}

Extensión de int:

extension Int{

    var fontSize : CGFloat {

        var deltaSize : CGFloat = 0;
        switch (UIDevice.deviceType) {
        case .iPhone4_4s,
             .iPhone5_5s :
            deltaSize = -1;
        case .iPhone6_6s :
            deltaSize = 2;
        case .iPhone6p_6ps :
            deltaSize = 2;
        default:
            deltaSize = 0;
        }

        let selfValue = self;
        return CGFloat(selfValue) + deltaSize;
    }
}