ios - significado - ttf fonts

¿Cómo obtengo el nombre de la fuente de un archivo otf o ttf?

Question

He utilizado una fuente personalizada en mi aplicación anterior.

El nombre del archivo era "ProximaNova-Regular.otf" y para cargar la fuente que acabo de usar ...

[UIFont fontWithName:@"ProximaNova-Regular" size:20];

Esto funcionó perfectamente.

Ahora en esta nueva aplicación tengo tres archivos de fuentes ...

Dude_Willie.otf
Impact
handsean.ttf

Pero no estoy seguro de cómo cargar estos.

Yo he tratado

[UIFont fontWithName:<the file name> size:20];

Pero esto solo se remonta a usar Helvetica.

¿Cómo puedo encontrar qué nombre usar?

Answer 1

Después de haber agregado sus fuentes a su proyecto / aplicación, agregue este código (probablemente solo en la aplicación delegado del método didFinishLaunchingWithOptions) para imprimir todas las fuentes disponibles para su aplicación. Desde dentro de esa lista, debería poder identificar la fuente que está buscando. No te olvides de eliminar el código innecesario después.

for (NSString *fontFamilyName in [UIFont familyNames]) {
for (NSString *fontName in [UIFont fontNamesForFamilyName:fontFamilyName]) {
NSLog(@"Family: %@ Font: %@", fontFamilyName, fontName);
}
}

Answer 2

Haga clic derecho en el TTF -> Obtener información

"Nombre completo" es lo que estás buscando.

Eso es lo que me funcionó con TTFs.

Editar:

Acabo de usar una fuente que tenía un nombre diferente al "Nombre completo" en Obtener información.

Para la compilación de esta respuesta, si la comprobación rápida anterior no funciona, ejecute este código en su proyecto:

for (NSString *fontFamilyName in [UIFont familyNames]) {
for (NSString *fontName in [UIFont fontNamesForFamilyName:fontFamilyName]) {
NSLog(@"Family: %@ Font: %@", fontFamilyName, fontName);
}
}

Y busque el nombre correcto de la fuente que desea utilizar.

Código Swift 3.0:

for fontFamilyName in UIFont.familyNames{
for fontName in UIFont.fontNames(forFamilyName: fontFamilyName){
print("Family: /(fontFamilyName) Font: /(fontName)")
}
}

Answer 3

Lista de nombres de fuentes y familias para macOS con Swift 4.1 :

NSFontManager.shared.availableFonts.map { print($0) }
NSFontManager.shared.availableFontFamilies.map { print($0) }

Answer 4

Otro truco "rápido y práctico" que no implica escanear a través de todas las fuentes predeterminadas que existen en el emulador o dispositivo es usar la fuente para algo en su guión gráfico. Luego, si edita el guión gráfico con un editor de texto, puede ver las fuentes utilizadas con nombres "internos" si busca la etiqueta "customFonts":

<customFonts key="customFonts">
<array key="Linotype - AvenirNextLTPro-Bold.otf">
<string>AvenirNextLTPro-Bold</string>
</array>
<array key="Linotype - AvenirNextLTPro-Regular.otf">
<string>AvenirNextLTPro-Regular</string>
</array>
<array key="TradeGothicLTPro-BdCn20.otf">
<string>TradeGothicLTPro-BdCn20</string>
</array>
</customFonts>

Answer 5

Quieres saber cómo conseguir el nombre ve por esto: -

 NSArray *familyNames = [[NSArray alloc] initWithArray:[UIFont familyNames]];
for (NSInteger indFamily=0; indFamily<[familyNames count]; ++indFamily)
{
NSLog(@"Family name: %@", [familyNames objectAtIndex:indFamily]);
NSArray *fontNames = [[NSArray alloc] initWithArray:
[UIFont fontNamesForFamilyName:[familyNames objectAtIndex:indFamily]]];
for (NSInteger indFont=0; indFont<[fontNames count]; ++indFont)
{
NSLog(@" Font name: %@", [fontNames objectAtIndex:indFont]);
}
}

Espero que te ayude ...

Answer 6

Registre los nombres de familia del archivo de fuente y luego acceda a las fuentes:

// You can log all font family names suing **fontNamesForFamilyName**
NSLog(@" font name %@", [UIFont fontNamesForFamilyName:@"the file name"]);

Espero que te ayude.

Answer 7

Si desea buscar el nombre de fuente para un archivo de fuente determinado mediante programación:

import Foundation
func loadFontName(for file: URL) throws -> String {
let data = try Data(contentsOf: file)
guard let provider = CGDataProvider(data: data as CFData) else {
throw Error("Could not create data provider")
}
guard let font = CGFont(provider) else {
throw Error("Could not load font")
}
guard let name = font.postScriptName else {
throw Error("Could not get font name from font file")
}
return name as String
}

Reemplace con sus propios objetos de Error , como sea necesario.

Answer 8

Siga estos cuatro sencillos pasos para agregar y usar una nueva fuente en su aplicación iOS:

• Agregue your_new_font.ttf o your_new_font.otf a su proyecto Xcode
• En info.plist de su proyecto, agregue una nueva entrada para su_new_font.ttf o su_new_font.otf a la matriz UIAppFonts (el texto sin formato para esta es ''Fuentes proporcionadas por la aplicación'')
• En este punto, recomiendo agregar este trozo temporal de código de depuración para volcar todas las fuentes a las que puede acceder su aplicación, incluido su your_new_font recién agregado:

for(NSString *fontfamilyname in [UIFont familyNames])
{
NSLog(@"family:''%@''",fontfamilyname);
for(NSString *fontName in [UIFont fontNamesForFamilyName:fontfamilyname])
{
NSLog(@"/tfont:''%@''",fontName);
}
NSLog(@"-------------");
}

• En la salida de depuración, busque el nombre ''familia'' y ''fuente'' de su nueva fuente. Pase lo que se muestra como el nombre de ''fuente'' correspondiente a su nueva familia de fuentes (podría haber más de una ''fuente'' asociada con su nueva fuente ''familia'') a UIFont *myNewFont = [UIFont fontWithName:@"font_name_from_debug_output" size:20] y deberías estar en el negocio!

Answer 9

Solución Swift 4.0+

 for fontFamilyName in UIFont.familyNames {
print("family: /(fontFamilyName)/n")
for fontName in UIFont.fontNames(forFamilyName: fontFamilyName) {
print("font: /(fontName)")
}
}

Saldrá:

familia: Apple SD Gothic Neo

Fuente: AppleSDGothicNeo-Thin

Fuente: AppleSDGothicNeo-Light

Answer 10

Swift 1.2:

 for familyName in UIFont.familyNames() {
for fontName in UIFont.fontNamesForFamilyName(familyName as! String) {
println("/(familyName) : /(fontName)")
}
}

Answer 11

Swift 3.0

for familyName in UIFont.familyNames {
for fontName in UIFont.fontNames(forFamilyName: familyName ) {
print("/(familyName) : /(fontName)")
}
}

Answer 12

También puede usar otfinfo --info arial.ttf para obtener el nombre desde la línea de comandos. El nombre de la posdata es el que debe pasar al constructor UIFont.

Answer 13

Para usar las fuentes en iOS, debe cargar la fuente según el NOMBRE COMPLETO (Nombre de PostScript), que a veces es (y generalmente es) diferente del NOMBRE DE ARCHIVO real de la fuente.

Imagínate a ti mismo cambiando el nombre del archivo de fuente "Arial-regular.ttf" para que sea "foo.ttf". La fuente contenida dentro del archivo de fuente que acaba de renombrar sigue siendo "Arial-regular".

Hay algunas buenas maneras programáticas de obtener el nombre de la fuente ya en este hilo, pero tengo un enfoque diferente utilizando la línea de comandos.

Si está en una Mac o Linux, simplemente ejecute este script desde la línea de comandos en el directorio donde tiene sus fuentes personalizadas (usa la utilidad fc-scan de fontconfig que probablemente ya está instalada, pero si no, puede instalarla a través de homebrew : brew install fontconfig ):

for file in "$arg"*.{ttf,otf}; do fc-scan --format "%{postscriptname}/n" $file; done

Aquí hay una captura de pantalla del comando anterior que se ejecuta en mi directorio ~/Library/Fonts :

La secuencia de comandos anterior se ejecutará a través de todos los archivos .ttf y .otf en el directorio actual, luego imprimirá el Nombre PostScript para cada fuente que puede usar para hacer referencia al archivo de fuente en XCode o en otro lugar.

Si desea obtener un poco de fantasía con información adicional (PostScriptName, Filename) y algunos códigos de colores, puede ejecutar este script alternativo:

for file in "$arg"*.{ttf,otf}; do
postscriptname=$(fc-scan --format "%{postscriptname}/n" $file);
printf "/033[36m PostScript Name:/033[0m %s /e[90m(%s)/033[0m/n" "$postscriptname" "$file";
done

Esto es un poco más rápido que copiar y pegar código dentro de su archivo AppDelegate.m para imprimir los nombres cada vez que quiera agregar un nuevo archivo de fuente, que es el método más popular, y también es más rápido que abrir la Fuente en FontBook para inspeccionar el nombre de PostScript.

CONSEJO ÚTIL: Si crea un alias del script anterior en su terminal, de modo que todo lo que necesita hacer es escribir un solo comando para obtener todos los nombres de fuente PostScript para todos los archivos en el directorio actual (mi función se llama fontnames por lo que todo lo que tengo que hacer es Escriba sus fontnames de fontnames en el terminal dentro del directorio con las fuentes, y los nombres de PostScript se imprimirán automáticamente, así ahorrará tiempo en su flujo de trabajo de desarrollo y tendrá este práctico script listo para usar cuando lo necesite.

¡Espero que esto ayude!

Answer 14

Swift 4.0 Compatible

Este es solo un código de línea para imprimir toda la familia de fuentes y sus nombres

override func viewDidLoad() {
super.viewDidLoad()
//Main line of code
UIFont.familyNames.sorted().forEach({ print($0); UIFont.fontNames(forFamilyName: $0 as String).forEach({print($0)})})
}

Answer 15

• Instala la fuente
• Abre la aplicación Font Book en tu Mac
• Seleccione la fuente y haga clic en el botón ''información''
• El nombre que está buscando es el nombre PostScript