How do I get the font name from an otf or ttf file?

Question

I have used a custom font in my previous app.

The file name was "ProximaNova-Regular.otf" and to load the font I just used...

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

This worked perfectly.

Now in this new app I have three font files...

Dude_Willie.otf
Impact
handsean.ttf

But I'm not sure how to load these.

I have tried

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

But this just falls back to using Helvetica.

How can I find what name to use?

Answer 1

Right click on the TTF -> Get Info

"Full Name" is what you're looking for.

That's what worked for me with TTFs.

Edit:

I just used a font that had a different name from the "Full Name" in Get Info.

For the compilation of this answer, If the quick check above doesn't work, run this code in your project:

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

And search for the correct name of the font you want to use.

Swift 3.0 code:

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

Answer 2

Follow these four easy steps to add and use a new font in your iOS app:

• Add your_new_font.ttf or your_new_font.otf to your Xcode project
• In your project's info.plist, add a new entry for your_new_font.ttf or your_new_font.otf to the UIAppFonts array (plain text for this one is 'Fonts provided by application')
• At this point, I recommend adding this temporary chunk of debug code to dump all fonts that are accessible by your app, including your newly added your_new_font:

//Swift

    for family: String in UIFont.familyNames {
        print("\(family)")
        for names: String in UIFont.fontNames(forFamilyName: family) {
            print("== \(names)")
        }
    }

//Objective-c

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

• In the debug output, look for your new font's 'family' and 'font' name. Pass whatever is displayed as the 'font' name corresponding to your new font family (there could be more than one 'font' associated with your new font 'family') to UIFont *myNewFont = [UIFont fontWithName:@"font_name_from_debug_output" size:20] and you should be in business!

Answer 3

• Install the font
• Open Font Book app on your Mac
• Select the font and click on 'info' button
• The name you're looking for is PostScript name
  • MacOS: View -> Show Font Info

Answer 4

To use fonts in iOS, you have to load the font based on the font's FULL NAME (PostScript Name), which is sometimes (and usually is) different from the font's actual FILE NAME .

Imagine yourself renaming the Font file "Arial-regular.ttf" to be "foo.ttf". The font contained inside the font file you just renamed is still "Arial-regular".

There are some good programmatic ways to get the font name already on this thread, but I have a different approach using the command line.

If you are on a Mac or Linux, simply run this script from the command line in the directory where you have your custom fonts (uses the fc-scan utility from fontconfig which is probaly already installed, but if not you can install it via homebrew: brew install fontconfig ):

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

Here is a screenshot of the above command running on my ~/Library/Fonts directory:

The script above will run through all the .ttf and .otf files in the current directory, then print out the PostScript Name for each font which you can use to reference the font file in XCode or elsewhere.

If you want to get fancy with some additional information (PostScriptName, Filename) and some color coding, you can run this alternative script:

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

This is a bit faster than copy-pasting code inside of your AppDelegate.m file to print out the names every time you want to add a new font file, which is the popular method, and it's also faster than opening the Font in FontBook to inspect the PostScript Name.

USEFUL TIP: If you alias the above script in your terminal so that all you need to do is type a single command to get all the PostScript font names for all the files in the current directory (my function is called fontnames so all I have to do is type fontnames at the terminal inside the directory with fonts in it, and the PostScript names will be printed automatically, then you will save time in your development workflow and have this handy script ready to use when you need it.

Hope this helps!

Answer 5

If you want to find the font name for a given font file programmatically:

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
}

Replace with your own throwable Error objects as required.

Answer 6

You want to know how to get name go for this :-

  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]);
        }
  }

hope it helps you...

Answer 7

Swift 4.0+ solution

    for fontFamilyName in UIFont.familyNames {
        print("family: \(fontFamilyName)\n")

        for fontName in UIFont.fontNames(forFamilyName: fontFamilyName) {
            print("font: \(fontName)")
        }
    }

Will output:

family: Apple SD Gothic Neo

font: AppleSDGothicNeo-Thin

font: AppleSDGothicNeo-Light

Answer 8

Swift 3.0

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

Answer 9

After you've added your fonts to your project/app, add this code (probably just in app delegate didFinishLaunchingWithOptions method) in order to print out all the available fonts for your app. From with-in that list you should be able to identify the font you're after. Don't forget to remove the unnecessary code after.

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

Answer 10

You can also use otfinfo --info arial.ttf to get the name from command line. The postscript name is the one you need to pass to the UIFont constructor.

Answer 11

Swift 1.2:

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

Answer 12

Another "quick, practical" hack that doesn't involve scanning through all the default fonts that exist on either the emulator or device is to use the font for something in your storyboard . Then if you edit the storyboard with a text editor (open as source code ), you can see the fonts used with "internal" names if you search for the "customFonts" tag:

<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 13

Log familyNames of font file and then access the fonts:

// You can log all font family names suing **fontNamesForFamilyName**

NSLog(@" font name %@", [UIFont fontNamesForFamilyName:@"the file name"]);

Hope it helps you.

Answer 14

List font names and families for macOS with Swift 4.1 :

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

Answer 15

Swift 4.0 Supported

This is only one line code for print all font family and it's font's names

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