A string atribuída com fontes personalizadas no storyboard não carrega corretamente

Estamos usando fontes personalizadas em nosso projeto. Funciona bem no Xcode 5. No Xcode 6, funciona em texto simples, string atribuída no código. Mas todas as sequências atribuídas definidas no storyboard revertem para Helvetica quando executadas no simulador ou dispositivo, embora pareçam bem no storyboard.

Não tenho certeza se é um bug do Xcode 6 ou iOS 8 SDK, ou a forma de usar fontes personalizadas foi alterada no Xcode 6 / iOS 8?

A solução para mim foi usar uma IBDesignableclasse:

import UIKit

@IBDesignable class TIFAttributedLabel: UILabel {

    @IBInspectable var fontSize: CGFloat = 13.0

    @IBInspectable var fontFamily: String = "DIN Light"

    override func awakeFromNib() {
        var attrString = NSMutableAttributedString(attributedString: self.attributedText)
        attrString.addAttribute(NSFontAttributeName, value: UIFont(name: self.fontFamily, size: self.fontSize)!, range: NSMakeRange(0, attrString.length))
        self.attributedText = attrString
    }
}

Fornecendo isso no Interface Builder:

Você pode configurar sua string de atribuição como faz normalmente, mas terá que configurar seu tamanho de fonte e família de fonte mais uma vez nas novas propriedades disponíveis.

Como o Interface Builder está trabalhando com a fonte personalizada por padrão, isso resulta em um o que você vê é o que obtém , o que eu prefiro ao criar aplicativos.

Nota

O motivo pelo qual estou usando isso em vez de apenas a versão simples é que estou definindo propriedades no rótulo atribuído, como o espaçamento de linha, que não estão disponíveis ao usar o estilo simples.

A resposta mais simples que funcionou é arrastar as fontes para o FontBook. Se as fontes estão em seu projeto, mas não no FontBook do seu computador, o IB às vezes tem problemas para encontrá-las. Estranho, mas funcionou para mim em várias ocasiões.

Você pode adicionar fontes personalizadas ao livro de fontes.

Passo 1 : Clique em gerenciar fontes. Ele abre o livro de fontes.

Passo 2 : Clique em mais e adicione suas fontes.

Da próxima vez, quando você clicar na fonte com o texto atribuído, a fonte recém-adicionada também aparecerá na lista. Mas certifique-se de que sua fonte personalizada foi adicionada aos recursos info.plist e bundle.

Graças a este tópico, cheguei a esta solução:

private let fontMapping = [
    "HelveticaNeue-Medium": "ITCAvantGardePro-Md",
    "HelveticaNeue": "ITCAvantGardePro-Bk",
    "HelveticaNeue-Bold": "ITCAvantGardePro-Demi",
]

func switchFontFamily(string: NSAttributedString) -> NSAttributedString {
    var result = NSMutableAttributedString(attributedString: string)
    string.enumerateAttribute(NSFontAttributeName, inRange: NSRange(location: 0, length: string.length), options: nil) { (font, range, _) in
        if let font = font as? UIFont {
            result.removeAttribute(NSFontAttributeName, range: range)
            result.addAttribute(NSFontAttributeName, value: UIFont(name: fontMapping[font.fontName]!, size: font.pointSize)!, range: range)
        }
    }
    return result
}

Minha solução é meio que uma solução alternativa. A solução real é a apple consertar o Interface Builder.

Com ele, você pode marcar todo o texto em negrito e itálico no construtor de interface usando uma fonte do sistema e, em tempo de execução, renderizar sua fonte personalizada. Pode não ser ideal em todos os casos.

 NSMutableAttributedString* ApplyCustomFont(NSAttributedString *attributedText,
                     UIFont* boldFont,
                     UIFont* italicFont,
                     UIFont* boldItalicFont,
                     UIFont* regularFont)
{

    NSMutableAttributedString *attrib = [[NSMutableAttributedString alloc] initWithAttributedString:attributedText];
    [attrib beginEditing];
    [attrib enumerateAttribute:NSFontAttributeName inRange:NSMakeRange(0, attrib.length) options:0
                    usingBlock:^(id value, NSRange range, BOOL *stop)
    {
        if (value)
        {
            UIFont *oldFont = (UIFont *)value;
            NSLog(@"%@",oldFont.fontName);

            [attrib removeAttribute:NSFontAttributeName range:range];

            if([oldFont.fontName rangeOfString:@"BoldItalic"].location != NSNotFound && boldItalicFont != nil)
                [attrib addAttribute:NSFontAttributeName value:boldItalicFont range:range];
            else if([oldFont.fontName rangeOfString:@"Italic"].location != NSNotFound && italicFont != nil)
                [attrib addAttribute:NSFontAttributeName value:italicFont range:range];
            else if([oldFont.fontName rangeOfString:@"Bold"].location != NSNotFound && boldFont != nil)
                [attrib addAttribute:NSFontAttributeName value:boldFont range:range];
            else if(regularFont != nil)
                [attrib addAttribute:NSFontAttributeName value:regularFont range:range];
        }
    }];
    [attrib endEditing];

    return attrib;
}

Inspirado por esta postagem

Tenho lutado com este bug: UILabel é exibido corretamente em IB com fonte personalizada, mas não é exibido corretamente no dispositivo ou simulador (a fonte está incluída no projeto e é usada em UILabels simples).

Finalmente encontrei o Attributed String Creator na App Store (Mac). Gera código a ser colocado em seu aplicativo no local apropriado. Fantástico. Eu não sou o criador, apenas um usuário feliz.

Encontrou o mesmo problema: a fonte do atributo definida para TextView no storyboard não funcionou em tempo de execução com o XCode 6.1 e iOS 8 SDK.

Foi assim que resolvi esse problema, pode ser uma solução alternativa para você:

1. abra o inspetor de atributos de sua visualização de texto, altere o texto para "Simples"

2. clique na cruz para excluir o "wC hR" (vermelho abaixo)

   

3. mude o texto para "Atribuído", e então você pode definir a fonte e o tamanho do seu texto.

4. corra para verificar se funciona

Encontrou o mesmo problema: o atributo fonte para UILabel no storyboard não funcionou em tempo de execução. Usar este UIFont + IBCustomFonts.m funciona para mim https://github.com/deni2s/IBCustomFonts

Tente isso vai funcionar

No meu caso, quando tento definir "Tecnologia Silversky" como texto atribuído para rótulo do construtor de interface, não é mostrado quando executo no simulador, mas é mostrado no construtor de interface. Então eu usei um truque que fiz a fonte Silversky com 1 pixel maior que o texto Tecnologia.

O texto do atributo tem problemas com o mesmo tamanho de fonte, então altere o tamanho de 1 palavra neste que funcione comigo.

Pode ser que seja um bug do xcode, mas esse truque funciona para mim.

O mesmo problema.

Resolvido: basta marcar Selecionável em TextView. Sem isso, tenho uma fonte padrão do sistema.

Clique duas vezes e instale a fonte no sistema. Vai funcionar (Xcode 8.2)

A solução @Hamidptb funciona, certifique-se de obter o nome correto da fonte (depois de adicioná-la ao Catálogo de Fontes)

• Abra o aplicativo Catálogo de Fontes, navegue até sua fonte e pressione Command + I. O nome PostScript é o nome da fonte que você deseja usar aqui:

  UILabel.appearance (). Font = UIFont (nome: " PostScriptName ", tamanho: 17)

Eu estava tentando obter células tableView com texto com vários parágrafos. As strings atribuídas pareciam ser uma forma de obter espaço extra entre os parágrafos (algo um pouco mais bonito do que fazer duas alimentações de linha na string). Me deparei com este e outros posts quando descobri que as configurações de IB não se aplicavam no tempo de execução quando você queria colocar um texto diferente na célula.

A principal coisa que eu fiz foi adicionar uma extensão a String (usando Swift) para criar uma string atribuída com certas características. O exemplo aqui usa a fonte Marker Felt, pois é facilmente distinguível da Helvetica. O exemplo também mostra um pouco mais de espaçamento entre os parágrafos para torná-los mais distintos uns dos outros.

extension String {
func toMarkerFelt() -> NSAttributedString {
    var style = NSMutableParagraphStyle()
    style.paragraphSpacing = 5.0
    let markerFontAttributes : [NSObject : AnyObject]? = [
        NSFontAttributeName : UIFont(name: "Marker Felt", size: 14.0)!,
        NSParagraphStyleAttributeName: style,
        NSForegroundColorAttributeName : UIColor.blackColor()
    ]
    let s = NSAttributedString(string: self, attributes: markerFontAttributes)
    return s
    }
}

Então, em meu tableViewCell personalizado, você envia o texto que deseja e ele o converte em uma string atribuída no UILabel.

//  MarkerFeltCell.swift
class MarkerFeltCell: UITableViewCell {
@IBOutlet weak var myLabel: UILabel!
func configureCellWithString(inputString : String) {
    myLabel.attributedText = inputString.toMarkerFelt()
}}

No controlador de visualização com tableView, você deve registrar sua célula em viewDidLoad () - usei uma ponta, então algo como:

let cellName = "MarkerFeltCell"
tableView.registerNib(UINib(nibName: cellName, bundle: nil), forCellReuseIdentifier: cellName)

Para fazer com que a célula descubra a altura que deve ter, faça um protótipo de célula que é usado para obter informações de tamanho e nunca é adicionado ao tableView. Então, nas variáveis ​​do seu controlador de visualização:

var prototypeSummaryCell : MarkerFeltCell? = nil

Então em (provavelmente substituir - dependendo do seu controlador de visualização) heightForRowAtIndexPath:

override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
        // ...
    if xib == "MarkerFeltCell" {
            if prototypeCell == nil {
                prototypeCell = tableView.dequeueReusableCellWithIdentifier(xib) as? MarkerFeltCell
            }
            let width : CGFloat = tableView.bounds.width
            let height : CGFloat = prototypeCell!.bounds.height
            prototypeCell?.bounds = CGRect(x: 0, y: 0, width: width, height: height)
            configureCell(prototypeCell!, atIndexPath: indexPath)
            prototypeSummaryCell?.layoutIfNeeded()
            let size = prototypeSummaryCell!.contentView.systemLayoutSizeFittingSize(UILayoutFittingCompressedSize)
            let nextHeight : CGFloat = ceil(size.height + 1.0)
            return nextHeight
    } else {  // ...

No código acima, o prototypeCell será preenchido na primeira vez que for necessário. O prototypeCell é então usado para descobrir a altura da célula após passar pelo processo de dimensionamento automático. Você precisará arredondar a altura com a função ceil (). Eu também adicionei algum fator de fudge extra.

O bit de código final é como você configura o texto para a célula. Para este exemplo, simplesmente:

func configureCell(cell :UITableViewCell, atIndexPath indexPath: NSIndexPath) {
    if let realCell = cell as? MarkerFeltCell  {
        realCell.configureCellWithString("Multi-line string.\nLine 2.\nLine 3.")    // Use \n to separate lines
    }
}

Além disso, aqui está uma foto do bico. Fixou o rótulo nas bordas da célula (com a margem desejada), mas usou uma restrição "Maior que ou igual", com uma prioridade menor que "Obrigatório" para a restrição inferior.

Defina a fonte do rótulo como Atribuída. A fonte real do IB não importava.

O resultado neste caso:

No caso de string atribuída, você pode adicionar uma fonte personalizada na lista de fontes como - Clique no ícone da fonte para exibir a seguinte caixa de diálogo. Na caixa de diálogo seguinte, você pode adicionar sua própria categoria ou uma existente para a fonte personalizada. caixa de diálogo de fonte atribuída

Depois de clicar em Gerenciar Fontes, ele abre a seguinte caixa de diálogo, selecione a categoria em que você criou ou já existe. Clique no sinal + para adicionar a fonte na categoria. Gerenciar caixa de diálogo de fonte

que tem uma solução simples e rápida e isso funciona no meu caso. essa solução é adicionar uma linha de código na função didFinishLaunchingWithOptions no arquivo AppDelegate.swift:

para textViews :

UITextView.appearance().font = UIFont(name: "IranSans", size: 17)

para etiquetas :

UILabel.appearance().font = UIFont(name: "IranSans", size: 17)

e para o resto do UiView como este dois ☝️

Para qualquer pessoa que aplique fontes personalizadas a strings atribuídas no código: tente configurá-las em viewDidLayoutSubviews. O meu erro foi fazer dentro viewDidLoad, não vai ser aplicado lá.