iphone - ¿Cómo establecer el tamaño de fuente para llenar la altura de UILabel?
objective-c ios (18)
He visto un montón de ejemplos para cambiar el tamaño de un UILabel.
Esto es lo que me gustaría hacer: cambiar el tamaño de la fuente para que el texto sea lo más grande posible dentro de la nueva altura.
¿Alguna pista?
Ampliando la respuesta de @Joe Blow, aquí está la categoría UILabel+FitToHeight Objective-C que le permite importar y alternar fácilmente un adjustsFontSizeToFitHeight tal como usted ya puede adjustsFontSizeToFitWidth .
UILabel + FitToHeight.h
#import <UIKit/UIKit.h>
@interface UILabel (FitToHeight)
@property (nonatomic, assign) BOOL adjustsFontSizeToFitHeight;
@end
UILabel + FitToHeight.m
#import "UILabel+FitToHeight.h"
#import <objc/runtime.h>
@implementation UILabel (FitToHeight)
-(BOOL)adjustsFontSizeToFitHeight {
NSNumber *number = objc_getAssociatedObject(self, @selector(adjustsFontSizeToFitHeight));
return [number boolValue];
}
-(void)setAdjustsFontSizeToFitHeight:(BOOL)adjustsFontSizeToFitHeight {
NSNumber *number = [NSNumber numberWithBool:adjustsFontSizeToFitHeight];
objc_setAssociatedObject(self, @selector(adjustsFontSizeToFitHeight), number, OBJC_ASSOCIATION_ASSIGN);
}
-(UIFont *)fontToFitHeight {
float desiredHeight = [self frame].size.height;
float guess;
float guessHeight;
guess = [[self font] pointSize];
guessHeight = [self sizeIf:guess];
if(guessHeight == desiredHeight) {
return [[self font] fontWithSize:guess];
}
int attempts = 4;
while(attempts > 0) {
guess = guess * (desiredHeight / guessHeight);
guessHeight = [self sizeIf:guess];
if(guessHeight == desiredHeight) {
return [[self font] fontWithSize:guess];
}
attempts--;
}
return [[self font] fontWithSize:guess];
}
-(float)sizeIf:(float)sizeToTry {
CGSize size = [[self text] sizeWithAttributes:@{ NSFontAttributeName : [[self font] fontWithSize:sizeToTry] }];
return size.height;
}
-(void)layoutSubviews {
[super layoutSubviews];
if([self adjustsFontSizeToFitHeight]) {
[self setFont:[self fontToFitHeight]];
}
}
Importa como lo harías con cualquier otra categoría ...
#import "UILabel+FitToHeight.h"
y usar de la siguiente manera ...
UILabel *titleLabel = [[UILabel alloc] init];
[titleLabel setAdjustsFontSizeToFitHeight:YES];
[titleLabel setAdjustsFontSizeToFitWidth:YES];
Vale la pena señalar que esto todavía funciona con [titleLabel setAdjustsFontSizeToFitWidth:YES]; por lo que el uso de los dos en conjunción es completamente posible.
Así es como lo hice, ya que la respuesta de DGund no me funcionó, se ajustaba al ancho, pero quería que se ajustara a la altura.
+ (UIFont *)findAdaptiveFontWithName:(NSString *)fontName forUILabelSize:(CGSize)labelSize withMinimumSize:(NSInteger)minSize
{
UIFont *tempFont = nil;
NSString *testString = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
NSInteger tempMin = minSize;
NSInteger tempMax = 256;
NSInteger mid = 0;
NSInteger difference = 0;
while (tempMin <= tempMax) {
mid = tempMin + (tempMax - tempMin) / 2;
tempFont = [UIFont fontWithName:fontName size:mid];
difference = labelSize.height - [testString sizeWithFont:tempFont].height;
if (mid == tempMin || mid == tempMax) {
if (difference < 0) {
return [UIFont fontWithName:fontName size:(mid - 1)];
}
return [UIFont fontWithName:fontName size:mid];
}
if (difference < 0) {
tempMax = mid - 1;
} else if (difference > 0) {
tempMin = mid + 1;
} else {
return [UIFont fontWithName:fontName size:mid];
}
}
return [UIFont fontWithName:fontName size:mid];
}
Esto tomará un nombre de fuente, un tamaño (no tiene que ser un UILabel, en teoría, pero siempre lo usé con un UILabel), y un tamaño mínimo (también podría usar un tamaño máximo, simplemente reemplace el 256 con el parámetro de tamaño máximo). Básicamente, esto probará cada tamaño de fuente entre el tamaño de fuente mínimo y máximo y devolverá el que se encuentre a la altura deseada o justo debajo de ella.
El uso es autoexplicativo, pero se ve así:
self.myLabel.font = [self findAdaptiveFontWithName:@"HelveticaNeue-UltraLight" forUILabelSize:self.myLabel.frame.size withMinimumSize:30];
También puedes hacer de esta una categoría de método de clase en UIFont (que es lo que hice).
EDITAR: En la sugerencia, eliminé el bucle for y dediqué un poco de tiempo a hacerlo más eficiente con una rutina de búsqueda binaria. Hice varias comprobaciones para estar absolutamente seguro de que la fuente terminará de encajar dentro de la etiqueta. En las pruebas iniciales parece funcionar.
Basándome en la gran respuesta de @ Conaaando, lo he actualizado a una versión con los parámetros de IBDesignable incluidos, lo que hace posible editarlo en todo el constructor de Interfaz:
Y el código:
//
// TIFFitToHeightLabel.swift
//
import Foundation
import UIKit
@IBDesignable class TIFFitToHeightLabel: UILabel {
@IBInspectable var minFontSize:CGFloat = 12 {
didSet {
font = fontToFitHeight()
}
}
@IBInspectable var maxFontSize:CGFloat = 30 {
didSet {
font = fontToFitHeight()
}
}
override func layoutSubviews() {
super.layoutSubviews()
font = fontToFitHeight()
}
// Returns an UIFont that fits the new label''s height.
private func fontToFitHeight() -> UIFont {
var minFontSize: CGFloat = self.minFontSize
var maxFontSize: CGFloat = self.maxFontSize
var fontSizeAverage: CGFloat = 0
var textAndLabelHeightDiff: CGFloat = 0
while (minFontSize <= maxFontSize) {
fontSizeAverage = minFontSize + (maxFontSize - minFontSize) / 2
if let labelText: NSString = text {
let labelHeight = frame.size.height
let testStringHeight = labelText.sizeWithAttributes(
[NSFontAttributeName: font.fontWithSize(fontSizeAverage)]
).height
textAndLabelHeightDiff = labelHeight - testStringHeight
if (fontSizeAverage == minFontSize || fontSizeAverage == maxFontSize) {
if (textAndLabelHeightDiff < 0) {
return font.fontWithSize(fontSizeAverage - 1)
}
return font.fontWithSize(fontSizeAverage)
}
if (textAndLabelHeightDiff < 0) {
maxFontSize = fontSizeAverage - 1
} else if (textAndLabelHeightDiff > 0) {
minFontSize = fontSizeAverage + 1
} else {
return font.fontWithSize(fontSizeAverage)
}
}
}
return font.fontWithSize(fontSizeAverage)
}
}
Buenas noticias,
¡Realizar una búsqueda binaria es completamente innecesario!
Solo necesita iterar (un par de veces) utilizando una búsqueda de relación.
guess = guess * ( desiredHeight / guessHeight )
Aquí hay una solución completa de IBDesignable .
Nota: cuando trabaje con diseñadores o tipógrafos, deberá configurar el seguimiento / estiramiento de las fuentes. (Es absurdo que Apple no incluya esto). StyledLabel también incluye seguimiento / estiramiento.
StyledLabel.swift
Establece el seguimiento, el estiramiento Y el tamaño del punto para que coincida con la altura del marco de la vista en todos los dispositivos.
En el guión gráfico: simplemente haga el marco de la UILabel, la altura que desea que tenga el texto: ¡fin de la historia!
// the call fontToFitHeight FINDS THE POINT SIZE TO "FILL TO HEIGHT".
// Just use autolayout to make the frame THE ACTUAL HEIGHT
// you want the type ON ANY DEVICE
// ADDITIONALLY you can set:
// the tracking (that''s the overall amount of space between all letters)
// and streching (actually squeeze or stretch the letters horizontally)
// Note: tracking and stretching IS SHOWN IN STORYBOARD LIVE
// WTT crazyrems http://.com/a/37300130/294884
import UIKit
@IBDesignable
class StyledLabel: UILabel
{
@IBInspectable var tracking:CGFloat = 0.8
// values between about 0.7 to 1.3. one means normal.
@IBInspectable var stretching:CGFloat = -0.1
// values between about -.5 to .5. zero means normal.
override func awakeFromNib()
{
tweak()
}
override func prepareForInterfaceBuilder()
{
tweak()
}
override func layoutSubviews()
{
super.layoutSubviews()
font = fontToFitHeight()
}
private func fontToFitHeight() -> UIFont
{
/* Apple have failed to include a basic thing needed in handling text: fitting the text to the height. Here''s the simplest and fastest way to do that:
guess = guess * ( desiredHeight / guessHeight )
That''s really all there is to it. The rest of the code in this routine is safeguards. Further, the routine iterates a couple of times, which is harmless, to take care of any theoretical bizarre nonlinear sizing issues with strange typefaces. */
guard text?.characters.count > 0 else { return font }
let desiredHeight:CGFloat = frame.size.height
guard desiredHeight>1 else { return font }
var guess:CGFloat
var guessHeight:CGFloat
print("searching for... ", desiredHeight)
guess = font.pointSize
if (guess>1&&guess<1000) { guess = 50 }
guessHeight = sizeIf(guess)
if (guessHeight==desiredHeight)
{
print("fluke, exact match within float math limits, up front")
return font.fontWithSize(guess)
}
var iterations:Int = 4
/* It is incredibly unlikely you would need more than four iterations, "two" would rarely be needed. You could imagine some very strange glyph handling where the relationship is non-linear (or something weird): That is the only theoretical reason you''d ever need more than one or two iterations. Note that when you watch the output of the iterations, you''ll sometimes/often see same or identical values for the result: this is correct and expected in a float iteration. */
while(iterations>0)
{
guess = guess * ( desiredHeight / guessHeight )
guessHeight = sizeIf(guess)
if (guessHeight==desiredHeight)
{
print("unbelievable fluke, exact match within float math limits while iterating")
return font.fontWithSize(guess)
}
iterations -= 1
}
print("done. Shame Apple doesn''t do this for us!")
return font.fontWithSize(guess)
}
private func sizeIf(pointSizeToTry:CGFloat)->(CGFloat)
{
let s:CGFloat = text!.sizeWithAttributes(
[NSFontAttributeName: font.fontWithSize(pointSizeToTry)] )
.height
print("guessing .. ", pointSizeToTry, " .. " , s)
return s
}
private func tweak()
{
let ats = NSMutableAttributedString(string: self.text!)
let rg = NSRange(location: 0, length: self.text!.characters.count)
ats.addAttribute(
NSKernAttributeName, value:CGFloat(tracking), range:rg )
ats.addAttribute(
NSExpansionAttributeName, value:CGFloat(stretching), range:rg )
self.attributedText = ats
}
}
Esto toma mucho de la respuesta de Joel Fischer. Su respuesta solo tiene en cuenta la altura de la etiqueta. También hice algunos cambios para tener en cuenta el ancho de la etiqueta (dada una cadena de entrada), que quería:
typedef enum
{
kDimensionHeight,
kDimensionWidth,
} DimensionType;
@implementation UIFont (AdaptiveFont)
+ (UIFont *)_adaptiveFontWithName:(NSString *)fontName minSize:(NSInteger)minSize labelDimension:(CGFloat)labelDimension testString:(NSString *)testString dimension:(DimensionType)dimension
{
UIFont *tempFont = nil;
NSInteger tempMin = minSize;
NSInteger tempMax = 256;
NSInteger mid = 0;
NSInteger difference = 0;
CGFloat testStringDimension = 0.0;
while (tempMin <= tempMax) {
@autoreleasepool {
mid = tempMin + (tempMax - tempMin) / 2;
tempFont = [UIFont fontWithName:fontName size:mid];
// determine dimension to test
if (dimension == kDimensionHeight) {
testStringDimension = [testString sizeWithFont:tempFont].height;
} else {
testStringDimension = [testString sizeWithFont:tempFont].width;
}
difference = labelDimension - testStringDimension;
if (mid == tempMin || mid == tempMax) {
if (difference < 0) {
return [UIFont fontWithName:fontName size:(mid - 1)];
}
return [UIFont fontWithName:fontName size:mid];
}
if (difference < 0) {
tempMax = mid - 1;
} else if (difference > 0) {
tempMin = mid + 1;
} else {
return [UIFont fontWithName:fontName size:mid];
}
}
}
return [UIFont fontWithName:fontName size:mid];
}
+ (UIFont *)adaptiveFontWithName:(NSString *)fontName minSize:(NSInteger)minSize labelSize:(CGSize)labelSize string:(NSString *)string
{
UIFont *adaptiveFont = nil;
NSString *testString = nil;
// get font, given a max height
testString = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
UIFont *fontConstrainingHeight = [UIFont _adaptiveFontWithName:fontName minSize:minSize labelDimension:labelSize.height testString:testString dimension:kDimensionHeight];
CGSize boundsConstrainingHeight = [string sizeWithFont:fontConstrainingHeight];
CGSize boundsConstrainingWidth = CGSizeZero;
// if WIDTH is fine (while constraining HEIGHT), return that font
if (boundsConstrainingHeight.width <= labelSize.width) {
adaptiveFont = fontConstrainingHeight;
} else {
// get font, given a max width
// i.e., fontConstrainingWidth
testString = string;
adaptiveFont = [UIFont _adaptiveFontWithName:fontName minSize:minSize labelDimension:labelSize.width testString:testString dimension:kDimensionWidth];
// TEST comparison
boundsConstrainingWidth = [string sizeWithFont:adaptiveFont];
}
return adaptiveFont;
}
Hay una manera mucho más sencilla de hacerlo. Simplemente calcule el punto por píxel de la pantalla y multiplíquelo a la altura de su etiqueta, y obtendrá el tamaño de fuente deseado.
Aquí hay métodos personalizados para esto. Elige lo que quieras.
TIPO 1. Versión de línea única codificada.
- (CGFloat) fontSizeFromHeight:(CGFloat)height
{
return ceilf(height * (10.0 / [@"Tg" sizeWithAttributes:@{NSFontAttributeName:[UIFont systemFontOfSize:10.0]}].height));
}
TIPO 2. Versión más limpia:
- (CGFloat)fontSizeFromHeight:(CGFloat)height
{
static CGFloat const testFontSize = 12.0;
static NSString * const testText = @"TestString";
UIFont *testFont = [UIFont systemFontOfSize:testFontSize];
CGFloat pixelHeight = [testText sizeWithAttributes:@{NSFontAttributeName:testFont}].height;
CGFloat pointPerPixel = testFontSize / pixelHeight;
CGFloat desiredFontSize = ceilf(height * pointPerPixel);
return desiredFontSize;
}
Ejemplos de uso:
myLabel.font = [UIFont systemFontOfSize:[self fontSizeFromHeight:myLabel.frame.size.height]];
myLabel.font = [myLabel.font fontWithSize:[self fontSizeFromHeight:myLabel.frame.size.height]];
Hay una solución más simple. Solo agregue las líneas debajo y, mágicamente, la etiqueta ajusta su tamaño de fuente para que se ajuste a la altura de la etiqueta también:
SWIFT 3:
label.minimumScaleFactor = 0.1 //or whatever suits your need
label.adjustsFontSizeToFitWidth = true
label.lineBreakMode = .byClipping
label.numberOfLines = 0
Hice una macro para hacer esto por ti.
///Scales FontSize up (or down) until the text fits within the height of the label, will not auto-update, must be called any time text is updated. Label Frame must be set prior to calling
#define scaleFontSizeToFillHeight(__label) {/
__label.font = [UIFont fontWithName:__label.font.fontName size:__label.frame.size.height*2.0f];/
UIFont *__currentFont = __label.font;/
CGFloat __originalFontSize = __currentFont.pointSize;/
CGSize __currentSize = [__label.text sizeWithAttributes:@{NSFontAttributeName : __currentFont}];/
while (__currentSize.height > __label.frame.size.height && __currentFont.pointSize > (__originalFontSize * __label.minimumScaleFactor)) {/
__currentFont = [__currentFont fontWithSize:__currentFont.pointSize - 1];/
__currentSize = [__label.text sizeWithAttributes:@{NSFontAttributeName : __currentFont}];/
}/
__label.font = __currentFont;/
}
Mis disculpas, si me he perdido algo aquí en todo el texto.
Seguí las sugerencias de @Crazyrems para unir automáticamente la fuente de la etiqueta. Esto escala la fuente según el ancho como otros han observado.
Luego simplemente puse ''Líneas'' a 0 en la sección de fuentes de UILabel de Xcode. En el código, debería ser numberOfLines . Eso es todo.
El crédito es para @Mikrasya, quien insinuó esta solución en uno de los comentarios anteriores.
Probado en Xcode 7.3 y iOS 9.3.2.
Para UILabels que redimensionan proporcionalmente para dispositivos más grandes / pequeños:
La solución más efectiva para mí ha sido establecer el tamaño de la fuente en una proporción de la altura de la etiqueta +/- un factor de ajuste. Suponiendo el uso de restricciones de diseño automático, la posición es y el centro vertical alineado con la parte inferior de la supervisión, multiplicado por una proporción. De manera similar en IB, restringe el ancho de la etiqueta a una proporción del ancho de la pantalla.
Opcionalmente, puede bloquear la relación altura / anchura de la etiqueta con una restricción de aspecto, sin embargo, esto puede causar recorte si no hace bien el cálculo del tamaño de punto de la fuente. La única razón para bloquear la relación de aspecto es si las posiciones de otros controles / vistas son relativas a esta etiqueta. Sin embargo, recomiendo encarecidamente colocar dichos controles / vistas en relación con la altura / anchura de la vista de supervisión para que no dependan de esta etiqueta.
Entiendo que esto no es exactamente una solución encapsulada, pero siempre me ha causado la menor cantidad de dolor. La única otra solución que se acercó fue el uso de while bucles, sin embargo, en mi caso no pude lidiar con los retrasos que impusieron en cada llamada al sistema de actualización / diseño.
Para adaptar el texto a la altura de mi etiqueta, he adaptado el método Joel a Swift.
func optimisedfindAdaptiveFontWithName(fontName:String, label:UILabel!, minSize:CGFloat,maxSize:CGFloat) -> UIFont!
{
var tempFont:UIFont
var tempHeight:CGFloat
var tempMax:CGFloat = maxSize
var tempMin:CGFloat = minSize
while (ceil(tempMin) != ceil(tempMax)){
let testedSize = (tempMax + tempMin) / 2
tempFont = UIFont(name:fontName, size:testedSize)
let attributedString = NSAttributedString(string: label.text!, attributes: [NSFontAttributeName : tempFont])
let textFrame = attributedString.boundingRectWithSize(CGSize(width: label.bounds.size.width, height: CGFloat.max), options: NSStringDrawingOptions.UsesLineFragmentOrigin , context: nil)
let difference = label.frame.height - textFrame.height
println("/(tempMin)-/(tempMax) - tested : /(testedSize) --> difference : /(difference)")
if(difference > 0){
tempMin = testedSize
}else{
tempMax = testedSize
}
}
//returning the size -1 (to have enought space right and left)
return UIFont(name: fontName, size: tempMin - 1)
}
y lo uso de esta manera:
myLabel.font = optimisedfindAdaptiveFontWithName("Helvetica", label: myLabel, minSize: 10, maxSize: 38)
println("/(myLabel.font)")
Perdóname si me equivoco, pero todo lo que se menciona aquí es innecesario. Configure su fuente otra vez justo después del cambio con un nuevo tamaño de fuente de su etiqueta.height
También puede buscar una comparación condicional entre estos valores (yourLabel.height y fontSize) para evitar actualizaciones innecesarias.
Todo lo que necesitas hacer es:
[yourLabel setFont:[UIFont fontWithName:@"*your fontname*" size:yourLabel.frame.size.height]];
Sí, vaya al creador de interfaces (su archivo .xib) y vaya a la tercera pestaña de la derecha en el inspector de atributos y puede configurar el tamaño de la fuente allí.
Tuve el mismo problema y, gracias a este hilo y al algoritmo de Joel, pude solucionarlo. :-)
A continuación se muestra mi código en Swift. Estoy en iOS 8 + Autolayout.
Problema:
- Gastos de entrada de usuario:
- Cuando los usuarios tocan el botón ''verificar'', aparece un menú desde la parte inferior, que empuja todo a la parte superior de la pantalla (contraer cosas, incluida la etiqueta):
Después de la corrección:
Que es exactamente lo que el diseñador tenía en mente ... :)
Sub-clasifiqué UILabel y layoutSubviews . Luego, cada vez que la UILabel cambia su tamaño, se recalcula el tamaño de la fuente:
//
// LabelWithAdaptiveTextHeight.swift
// 123
//
// Created by https://github.com/backslash-f on 12/19/14.
//
/*
Designed with single-line UILabels in mind, this subclass ''resizes'' the label''s text (it changes the label''s font size)
everytime its size (frame) is changed. This ''fits'' the text to the new height, avoiding undesired text cropping.
Kudos to this thread: bit.ly/setFontSizeToFillUILabelHeight
*/
import Foundation
import UIKit
class LabelWithAdaptiveTextHeight: UILabel {
override func layoutSubviews() {
super.layoutSubviews()
font = fontToFitHeight()
}
// Returns an UIFont that fits the new label''s height.
private func fontToFitHeight() -> UIFont {
var minFontSize: CGFloat = DISPLAY_FONT_MINIMUM // CGFloat 18
var maxFontSize: CGFloat = DISPLAY_FONT_BIG // CGFloat 67
var fontSizeAverage: CGFloat = 0
var textAndLabelHeightDiff: CGFloat = 0
while (minFontSize <= maxFontSize) {
fontSizeAverage = minFontSize + (maxFontSize - minFontSize) / 2
// Abort if text happens to be nil
guard text?.characters.count > 0 else {
break
}
if let labelText: NSString = text {
let labelHeight = frame.size.height
let testStringHeight = labelText.sizeWithAttributes(
[NSFontAttributeName: font.fontWithSize(fontSizeAverage)]
).height
textAndLabelHeightDiff = labelHeight - testStringHeight
if (fontSizeAverage == minFontSize || fontSizeAverage == maxFontSize) {
if (textAndLabelHeightDiff < 0) {
return font.fontWithSize(fontSizeAverage - 1)
}
return font.fontWithSize(fontSizeAverage)
}
if (textAndLabelHeightDiff < 0) {
maxFontSize = fontSizeAverage - 1
} else if (textAndLabelHeightDiff > 0) {
minFontSize = fontSizeAverage + 1
} else {
return font.fontWithSize(fontSizeAverage)
}
}
}
return font.fontWithSize(fontSizeAverage)
}
}
Una línea llamada en viewWillAppear hace el truco:
testLabel.font = testLabel.font.fontWithSize(testLabel.frame.height * 2/3)
En el guión gráfico, establezco todas las alturas de mis etiquetas en relación con la altura total de la vista, y esto permite que el tamaño de fuente aumente dinámicamente con ellas.
Observe que el tamaño de fuente es en realidad 2/3 del alto de la etiqueta. Si la fuente que está utilizando tiene colas que se sumergen debajo de la línea (como en y, g, q, p, o j), tendrá que hacer que el tamaño de la fuente sea una proporción de la altura de la etiqueta para que esas colas no estén cortadas. apagado. 2/3 funciona bien para Helvetica Neue, pero pruebe otras proporciones dependiendo de la fuente que esté usando. Para fuentes sin colas, números o texto con mayúsculas, una relación 1: 1 puede ser suficiente.
Edición: ¡Comprueba la excelente respuesta de Joel Fischer para obtener el tamaño correcto mediante programación!
Puede configurar la fuente para que rellene automáticamente el tamaño de una etiqueta y, opcionalmente, no ir por debajo de un tamaño de fuente mínimo. Simplemente configure adjustsFontSizeToFitWidth en YES. Echa un vistazo a la referencia de clase UILabel si necesitas más información.
Aunque el valor booleano se denomina "ajustaFontSizeToFitWidth", realmente significa el tamaño más grande para la altura de la etiqueta, que permanecerá en una línea de la etiqueta (o en la cantidad que especifique).
Variación SWIFT:
Me las arreglé para hacerlo con una extensión. Funciona bien, el tamaño de fuente mínimo es 5. Resto 10 de la altura, así que también dejo un "margen", pero puede eliminarlo o modificarlo.
extension UILabel {
//Finds and sets a font size that matches the height of the frame.
//Use in case the font size is epic huge and you need to resize it.
func resizeToFitHeight(){
var currentfontSize = font.pointSize
let minFontsize = CGFloat(5)
let constrainedSize = CGSizeMake(frame.width, CGFloat.max)
while (currentfontSize >= minFontsize){
let newFont = font.fontWithSize(currentfontSize)
let attributedText: NSAttributedString = NSAttributedString(string: text!, attributes: [NSFontAttributeName: newFont])
let rect: CGRect = attributedText.boundingRectWithSize(constrainedSize, options: .UsesLineFragmentOrigin, context: nil)
let size: CGSize = rect.size
if (size.height < frame.height - 10) {
font = newFont
break;
}
currentfontSize--
}
//In case the text is too long, we still show something... ;)
if (currentfontSize == minFontsize){
font = font.fontWithSize(currentfontSize)
}
}
}