I'm using the following code to make a font bold in an attributed string. This used to work fine but in iOS 13 it's giving me a bold Times font instead of the system font. I'm aware I can use -boldSystemFontOfSize: but I'm doing it this way to that I can make any font bold. I only see the problem with attributes strings.
UIFont *font = [UIFont systemFontOfSize:18];
UIFontDescriptor *fontDescriptor = [UIFontDescriptor fontDescriptorWithName:font.fontName size:font.pointSize];
UIFontDescriptor *styleDescriptor = [fontDescriptor fontDescriptorWithSymbolicTraits:[fontDescriptor symbolicTraits] | UIFontDescriptorTraitBold];
UIFont *boldFont = [UIFont fontWithDescriptor:styleDescriptor size:font.pointSize];
The problem is
fontDescriptorWithName:font.fontName
In iOS 13 it is forbidden to try to refer to a system font by name.
To go from a font to a font descriptor, just ask for the font’s fontDescriptor.
https://developer.apple.com/documentation/uikit/uifont/1619037-fontdescriptor
Thus the standard pattern is (Swift but I’m sure you can translate)
let f = UIFont(...
let desc = f.fontDescriptor
let desc2 = desc.withSymbolicTraits(.traitBold)
let f2 = UIFont(descriptor: desc2!, size: 0)
Related
I am creating UILabel, for the label i can set the font name as HelveticaNeue Regular, Light, UltraLight etc, But i unable to set the font name as HelveticaNeue Thin, it is not working as expected. I did like,
label.font = [UIFont fontWithName:#"HelveticaNeue-Thin" size:16];
Also i have searched on Google didnt got any solution. How to fix this issue? Thanks.
This font is bundled with iOS 7, so if you're targeting iOS 7 and above your
label.font = [UIFont fontWithName:#"HelveticaNeue-Thin" size:16.0f];
will work.
However if you are targeting iOS 6.1 and below you'll need to embed the font
Updated answer to support swift
let font = UIFont(name: "HelveticaNeue-Thin", size: 16.0)!
UIFontDescriptor *helveticaNeueFamily =
[UIFontDescriptor fontDescriptorWithFontAttributes:
#{ UIFontDescriptorFamilyAttribute: #"Helvetica Neue" }];
NSArray *matches =
[helveticaNeueFamily matchingFontDescriptorsWithMandatoryKeys: nil];
The matchingFontDescriptorsWithMandatoryKeys: method as shown returns an array of font descriptors for all the Helvetica Neue fonts on the system, such as HelveticaNeue, HelveticaNeue-Medium, HelveticaNeue-Light, HelveticaNeue-Thin, and so on.
You can modify the fonts returned by preferredFontForTextStyle: by applying symbolic traits, such as bold, italic, expanded, and condensed. You can use font descriptors to modify particular traits, as shown in Listing 9-2.
referenced by apple
or
this font you can't apply directly.
so you can customize your font
How to use custom fonts in iPhone SDK?
This has worked for me. Write this code below your label declarations.
It sets all the UILabel under a function with same font.
[[UILabel appearance]setFont:[UIFont fontWithName:#"HelveticaNeue-Thin" size:32.0f]];
To set font to particular UILabel use this code :
[labelName setFont:[UIFont fontWithName:#"HelveticaNeue-Thin" size:15.0f]];
Can anybody please explain how can we make any font family font, bold or unbold + Italic or Non Italic + Underlined or Non underLined. Everywhere I got the method that make the changes but on system font. I even tried giving 2 attributes to NSAttributed string
1. Bold
2. A font family from list of supported font family
But it didnt work. Thanks in Advance.
try this
UIFontDescriptor *fontDescriptor = [[UIFontDescriptor alloc] init];
UIFontDescriptor *fontDescriptorForHelveticaNeue = [fontDescriptor fontDescriptorWithFamily:#"Helvetica Neue"];
UIFontDescriptor *symbolicFontDescriptor = [fontDescriptorForHelveticaNeue fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitBold];
UIFontDescriptor *symbolicFontDescriptor1 = [fontDescriptorForHelveticaNeue fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitMonoSpace];
NSString *text = #"iOS 7";
if(some condition){
CGSize fontSize = [text sizeWithAttributes:#{NSFontAttributeName:[UIFont fontWithDescriptor:symbolicFontDescriptor size:17.0f]}];
}
else{
CGSize fontSize = [text sizeWithAttributes:#{NSFontAttributeName:[UIFont fontWithDescriptor:symbolicFontDescriptor1 size:17.0f]}];
}
You can't do it with a few lines of code. A normal font and its bold version are completely separated (ie they're like two unrelated fonts), and if you have a look at iosfonts, the naming is not consistent. Some fonts don't have bold version, and some have several bold versions!
A solution (that requires a bit of effort, but surely works): create a list of pairs of font names, like this
{"ArialHebrew", "ArialHebrew-Bold"},
{"AvenirNext-Regular", "AvenirNext-Bold"},
...
And populate the list of fonts with the regular version (the left one). If the user desires to make it bold, then switch to the bold version (the right one).
My recommendation is to limit the number of choices for user (as iOS always does): you don't need to copy the whole list from iosfonts! just some popular ones are enough.
This may not be sufficiently generic for your purses, but maybe it'll help someone else
+ (UIFont *)whateverInvertedBoldnessFontFromFont:(UIFont *)font pointSize:(CGFloat)pointSize
{
NSString *customFontFamilyName = #"Whatever";
NSString *ibFontName = font.fontName;
NSString *customFontStyle = nil;
if ([ibFontName rangeOfString:#"Bold"].location != NSNotFound) {
customFontStyle = #"Regular";
}
else {
customFontStyle = #"Bold";
}
UIFont *customFont = [UIFont fontWithName:[NSString stringWithFormat:#"%#-%#", customFontFamilyName, customFontStyle] size:pointSize];
return customFont;
}
unfortunately this is quite fragile and works reliably when the source and destination
font families are known
If you want to set it programmatically, you must check with the font supported by xCode (iOS).
and if you want to do bold to any font then you have to use :
UIFont* boldFont = [UIFont boldSystemFontOfSize:[UIFont systemFontSize]];
[myLabel setFont:boldFont];
where myLabel is your label name.
If I have a UIFont object, is it possible to convert it to bold? I don't know the font name, I just have a UIFont object. What I want is a function like
UIFont *boldFontFromFont(UIFont *input)
{
return [input derivedFontWithFontWeight:UIFontWeightBold];
}
How can I change the code so that it works. (The code above does not work, I just made it up to illustrate the point.)
Thanks in advance.
iOS 7 introduces a new UIFontDescriptor class, which makes it a lot easier:
UIFont *font = [UIFont fontWithName:#"Helvetica Neue" size:12];
NSLog(#"plain font: %#", font.fontName); // “HelveticaNeue”
UIFont *boldFont = [UIFont fontWithDescriptor:[[font fontDescriptor] fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitBold] size:font.pointSize];
NSLog(#"bold version: %#", boldFont.fontName); // “HelveticaNeue-Bold”
UIFont *italicFont = [UIFont fontWithDescriptor:[[font fontDescriptor] fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitItalic] size:font.pointSize];
NSLog(#"italic version: %#", italicFont.fontName); // “HelveticaNeue-Italic”
UIFont *boldItalicFont = [UIFont fontWithDescriptor:[[font fontDescriptor] fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitBold | UIFontDescriptorTraitItalic] size:font.pointSize];
NSLog(#"bold & italic version: %#", boldItalicFont.fontName); // “HelveticaNeue-BoldItalic”
For people who got here looking for a Cocoa (macOS) equivalent, UIFontDescriptor comes from NSFontDescriptor, available since 10.3.
And if you are looking for the swift implementation:
let normalFont = UIFont(name: "FONT_NAME", size: CGFloat(20))!
let boldFont = UIFont(descriptor: normalFont.fontDescriptor.withSymbolicTraits(.traitBold)!, size: normalFont.pointSize)
Hope this helps! Cheers!
To get a bold font you need to pass a specific name of the font from a font family. You can get a font family name from a given font, then list all fonts from this family. In general, a bold font will contain "bold" in its name, but the format isn't strict and there could be variations like "Helvetica-BoldOblique", for example. You can start from this code:
- (UIFont *)boldFontFromFont:(UIFont *)font
{
NSString *familyName = [font familyName];
NSArray *fontNames = [UIFont fontNamesForFamilyName:familyName];
for (NSString *fontName in fontNames)
{
if ([fontName rangeOfString:#"bold" options:NSCaseInsensitiveSearch].location != NSNotFound)
{
UIFont *boldFont = [UIFont fontWithName:fontName size:font.pointSize];
return boldFont;
}
}
return nil;
}
This is a very old thread but someone may be interested in how to do this in Swift 5 nowadays.
Easy like this:
var font: UIFont = UIFont.systemFont(ofSize: 18)
if let newDescriptor = font.fontDescriptor.withSymbolicTraits(.traitBold) {
font = UIFont(descriptor: newDescriptor, size: font.pointSize)
}
Attempting to derive the bold/italic font using font or family names no longer works correctly since iOS 7, due to the cryptic font family name of the system font. Below is a simple extension to derive the bold/italic font using the UIFontDescriptor class.
+(UIFont *) font:(UIFont *)font bold:(BOOL)bold italic:(BOOL)italic
{
NSUInteger traits = 0;
if (bold)
{
traits |= UIFontDescriptorTraitBold;
}
if (italic)
{
traits |= UIFontDescriptorTraitItalic;
}
return [UIFont fontWithDescriptor:[[font fontDescriptor] fontDescriptorWithSymbolicTraits:traits] size:font.pointSize];
}
You can either use
[UIFont boldSystemFontOfSize:12].
If you are using custom fonts you have to use the name directly
[UIFont fontWithName:#"Helvetica-Bold" size:17.0].
You can look up the possible font names with
[UIFont fontNamesForFamilyName:#"American Typewriter"].
In this Post: https://stackoverflow.com/a/15388946/436818 Ben M has an idea how to get the bold version dynamically. But extend the method to be sure to get the bold version (if it exists) because there are other bold versions like CondensedBold too.
Since this question pops up when you search for bold UIFonts in Swift, here's a fresh answer:
extension UIFont {
/// Returns a new font in the same family with the given symbolic traits,
/// or `nil` if none found in the system.
func withSymbolicTraits(_ traits: UIFontDescriptor.SymbolicTraits) -> UIFont? {
guard let descriptorWithTraits = fontDescriptor.withSymbolicTraits(traits)
else { return nil }
return UIFont(descriptor: descriptorWithTraits, size: 0)
}
}
Example:
myFont.withSymbolicTraits(.taitBold) // returns the bold version of myFont
Nobody posted a solution which:
is for Swift
is an extension for UIFont
doesn't do force unwraps
uses the same point size as source font
and only does what is asked in the question (create bold UIFont based on existing UIFont)
so I'm doing it:
import UIKit
extension UIFont {
func boldFont() -> UIFont? {
guard let boldDescriptor = fontDescriptor.withSymbolicTraits(.traitBold) else {
return nil
}
return UIFont(descriptor: boldDescriptor, size: pointSize)
}
}
Feel free to copy-and-paste!
On iOS, I load a custom font in my project by adding its file name (an .otf file) to the info.plist file and then using this line of code:
UIFont myFont * = [UIFont fontWithName:titleFontName size:titleFontSize];
I obtain the font that I can use in UILabels and UITextViews.
How could I obtain that this font is displayed only in small caps? If I use it in Photoshop, it's possible to turn on the small caps switch to have all words typeset in small caps (and so, I conclude that there is nothing missing with the font). How could I obtain a similar effect on iOS?
Converting my strings to uppercase is not a viable option for other reasons.
Further information : the font has only one member in its family, as I could understand by using the following code, there is no standalone small caps member in the family.
for (NSString * familyName in [UIFont familyNames]) {
NSLog(#"---------------- %# ---------------", familyName);
for (NSString * fontName in[UIFont fontNamesForFamilyName:familyName] )
NSLog(#"- %#", fontName);
}
Small caps are enabled in the font through an open type feature. In iOS 7 we can use a font descriptor to access open type features and enable small caps.
This question goes into how to turn on small caps using core text, but the same can be done for UIFonts and UIKit views just as easily. You'll need to create a UIFontDescriptor and set the UIFontDescriptorFeatureSettingsAttribute to an array of dictionaries for the features you want to enable.
Each font feature dictionary contains a key and value to specify the feature type, and a key and value for the feature selector. Depending on the font you're using, you'll need to find the correct values corresponding to small caps. You can find these in the array that the commented section logs.
UIFont Category
This category will generate a UIFont object with small caps enabled. You'll need to add the correct font name.
#import "UIFont+SmallCaps.h"
#import <CoreText/CoreText.h>
#implementation UIFont (SmallCaps)
+ (UIFont *) applicationSmallCapsFontWithSize:(CGFloat) size {
/*
// Use this to log all of the properties for a particular font
UIFont *font = [UIFont fontWithName: fontName size: fontSize];
CFArrayRef fontProperties = CTFontCopyFeatures ( ( __bridge CTFontRef ) font ) ;
NSLog(#"properties = %#", fontProperties);
*/
NSArray *fontFeatureSettings = #[ #{ UIFontFeatureTypeIdentifierKey: #(kLowerCaseType),
UIFontFeatureSelectorIdentifierKey : #(kLowerCaseSmallCapsSelector) } ];
NSDictionary *fontAttributes = #{ UIFontDescriptorFeatureSettingsAttribute: fontFeatureSettings ,
UIFontDescriptorNameAttribute: FONT_NAME } ;
UIFontDescriptor *fontDescriptor = [ [UIFontDescriptor alloc] initWithFontAttributes: fontAttributes ];
return [UIFont fontWithDescriptor:fontDescriptor size:size];
}
#end
Extension for UIFont in Swift:
extension UIFont {
func smallCaps() -> UIFont {
let settings = [[UIFontFeatureTypeIdentifierKey: kLowerCaseType, UIFontFeatureSelectorIdentifierKey: kLowerCaseSmallCapsSelector]]
let attributes: [String: AnyObject] = [UIFontDescriptorFeatureSettingsAttribute: settings, UIFontDescriptorNameAttribute: fontName]
return UIFont(descriptor: UIFontDescriptor(fontAttributes: attributes), size: pointSize)
}
}
Usage:
label.font = UIFont(name: "SourceSansPro-Regular", size: 12)?.smallCaps()
Example:
macOS version:
extension NSFont {
func smallCaps() -> NSFont? {
let settings = [[NSFontFeatureTypeIdentifierKey: kLowerCaseType, NSFontFeatureSelectorIdentifierKey: kLowerCaseSmallCapsSelector]]
let attributes: [String: AnyObject] = [NSFontFeatureSettingsAttribute: settings as AnyObject, NSFontNameAttribute: fontName as AnyObject]
return NSFont(descriptor: NSFontDescriptor(fontAttributes: attributes), size: pointSize)
}
}
IMPORTANT:
not every font works with it, It's dependent on whether those characters are included in the font or not as #Anthony Mattox said.
remember to set the string as: Example, not EXAMPLE.
settings are Array<NDSictionary>, not NSDictonary.
Having a UILabel with any font, how can I find out if it is already bold? Or how can I make it bold? In CSS, I have a font-weight attribute. I would like to have something similar.
Everything I found out so far is that you have to set the proper font name. However, this is unreliable. The bold version of Cochin is Cochin-Bold, but the bold version of ArialMT is not ArialMT-Bold but Arial-BoldMT, so it obviously does not suffice to append -Bold. (The bold version of a custom font could also have a totally different name).
What I can do is finding all fonts for the family of my given font.
__block UIFont *font = myLabel.font;
[[UIFont fontNamesForFamilyName:font.familyName] enumerateObjectsUsingBlock:^(NSString *fontName, NSUInteger idx, BOOL *stop) {
if ([fontName rangeOfString:#"bold" options:NSCaseInsensitiveSearch].location != NSNotFound) {
font = [UIFont fontWithName:fontName size:font.pointSize];
*stop = YES;
}
}];
myLabel.font = font;
But this does not work reliably. I can easily get a BoldItalic version. I could improve my check to avoid this, but it is not really a good solution.
Maybe CoreText can help here?
Maybe CoreText can help here?
CoreText uses its own font system, CTFont. If you're using that, you can do what you want:
CTFontRef font = CTFontCreateWithName((__bridge CFStringRef)name, size, NULL);
CTFontRef boldFont = CTFontCreateCopyWithSymbolicTraits(font, 0.0, NULL, kCTFontBoldTrait, kCTFontBoldTrait);
I suppose you could then get the name of the derived bold font:
CFStringRef boldName = CTFontCopyPostScriptName(boldFont);
...and use it to create a new UIFont:
UIFont *ret = [UIFont fontWithName:(NSString *)boldName size:size];
I don't know how quick this would be, but you could do it on app launch then cache the names.
Introduced with iOS 7, UIFontDescriptor is the tool for doing this.
To find out if the font is already bold, get the UIFontDescriptor of your font (via UIFont's fontDescriptor property), then call symbolicTraits, and inspect the resulting bitmask for UIFontDescriptorTraitBold.
Likewise, to find a bold version, take the font descriptor for the original font, and call - fontDescriptorWithSymbolicTraits:. You can then turn it back into a UIFont by calling + [UIFont fontWithDescriptor:size:].
UIFontDescriptorSymbolicTraits symbolically describes stylistic aspects of a font. The upper 16 bits is used to describe appearance of the font whereas the lower 16 bits for typeface. The font appearance information represented by the upper 16 bits can be used for stylistic font matching.
Swift 3
extension UIFont {
convenience init?(name: String, size: CGFloat, symbolicTraits: UIFontDescriptorSymbolicTraits) {
guard let descriptor = UIFontDescriptor(name: name, size: size).withSymbolicTraits(symbolicTraits) else { return nil }
self.init(descriptor: descriptor, size: size)
}
}