public static NSFont CreateFont(FontFamilyHandler familyHandler, float size, NSFontTraitMask traits, int weight = 5)
{
var font = NSFontManager.SharedFontManager.FontWithFamily(familyHandler.MacName, traits, weight, size);
if (font == null)
{
if (traits.HasFlag(NSFontTraitMask.Italic))
{
// fake italics by transforming the font
const float kRotationForItalicText = 14.0f;
var fontTransform = new NSAffineTransform();
fontTransform.Scale(size);
var italicTransform = new NSAffineTransform();
italicTransform.TransformStruct = Matrix.FromSkew(0, kRotationForItalicText).ToCG();
fontTransform.AppendTransform(italicTransform);
traits &= ~NSFontTraitMask.Italic;
font = NSFontManager.SharedFontManager.FontWithFamily(familyHandler.MacName, traits, 5, size);
if (font != null)
{
font = NSFont.FromDescription(font.FontDescriptor, fontTransform);
}
}
}
return(font);
}
public override NSFont ConvertFont(NSFont fontObj, NSFontTraitMask trait)
{
// be a little less conservative when converting fonts to use the name when translating to italics.
// e.g. 'Klavika Medium' translates to 'Klavika Italic' if adding italic trait, instead of
// 'Klavika Medium Italic'.
if (trait == NSFontTraitMask.Italic || trait == NSFontTraitMask.Unitalic)
{
var oldName = (string)FontTypefaceHandler.GetName(fontObj.Handle);
const string italicSuffix = " Italic";
string newName = null;
if (trait == NSFontTraitMask.Italic)
{
newName = oldName + italicSuffix;
}
else if (oldName.EndsWith(italicSuffix, StringComparison.OrdinalIgnoreCase))
{
newName = oldName.Substring(0, oldName.Length - italicSuffix.Length);
}
if (newName != null)
{
foreach (var descriptor in AvailableMembersOfFontFamily(fontObj.FamilyName))
{
var fontName = (string)Messaging.GetNSObject <NSString>(descriptor.ValueAt(1));
if (string.Equals(fontName, newName, StringComparison.OrdinalIgnoreCase))
{
var postScriptName = (string)Messaging.GetNSObject <NSString>(descriptor.ValueAt(0));
return(NSFont.FromFontName(postScriptName, fontObj.PointSize));
}
}
}
}
return(base.ConvertFont(fontObj, trait));
}
public FontTypefaceHandler(NSArray descriptor)
{
PostScriptName = (string)Messaging.GetNSObject <NSString>(descriptor.ValueAt(0));
_name = (string)Messaging.GetNSObject <NSString>(descriptor.ValueAt(1));
Weight = Messaging.GetNSObject <NSNumber>(descriptor.ValueAt(2))?.Int32Value ?? 1;
Traits = (NSFontTraitMask)(Messaging.GetNSObject <NSNumber>(descriptor.ValueAt(3))?.Int32Value ?? 0);
}
public static NSFontTraitMask ToNSFontTraitMask(this FontStyle fontStyle)
{
NSFontTraitMask mask = (NSFontTraitMask)0;
if (fontStyle.HasFlag(FontStyle.Bold))
{
mask = mask.SetFlags(NSFontTraitMask.Bold);
}
if (fontStyle.HasFlag(FontStyle.Italic))
{
mask = mask.SetFlags(NSFontTraitMask.Italic);
}
if (fontStyle.HasFlag(FontStyle.Regular))
{
}
if (fontStyle.HasFlag(FontStyle.Strikeout))
{
}
if (fontStyle.HasFlag(FontStyle.Underline))
{
}
return(mask);
}
public FontTypefaceHandler(string postScriptName, string name, NSFontTraitMask traits, int weight)
{
PostScriptName = postScriptName;
this._name = name;
Weight = weight;
Traits = traits;
}
public static string ToDesignerString(this NSFontTraitMask mask)
{
if (mask.HasFlag(NSFontTraitMask.Bold))
{
return(string.Format("{0}.{1}", nameof(NSFontTraitMask), nameof(NSFontTraitMask.Bold)));
}
return("default(NSFontTraitMask)");
//return string.Format("{0}.{1}", nameof(NSFontTraitMask), mask.ToString());
}
public static FontData FromFamily(string family, NSFontTraitMask traits, int weight, float size)
{
var font = NSFontManager.SharedFontManager.FontWithFamily (family, traits, weight, size);
var gentraits = NSFontManager.SharedFontManager.TraitsOfFont (font);
// NSFontManager may loose the traits, restore them here
if (traits > 0 && gentraits == 0)
font = NSFontManager.SharedFontManager.ConvertFont (font, traits);
return FromFont (font);
}
public void Create(FontFamily family, float size, FontStyle style)
{
#if OSX
string familyString;
switch (family)
{
case FontFamily.Monospace: familyString = "Courier New"; break;
default:
case FontFamily.Sans: familyString = "Helvetica"; break;
case FontFamily.Serif: familyString = "Times"; break;
}
bold = (style & FontStyle.Bold) != 0;
NSFontTraitMask traits = (bold) ? NSFontTraitMask.Bold : NSFontTraitMask.Unbold;
italic = (style & FontStyle.Italic) != 0;
traits |= (italic) ? NSFontTraitMask.Italic : NSFontTraitMask.Unitalic;
var font = NSFontManager.SharedFontManager.FontWithFamily(familyString, traits, 3, size * FONT_SIZE_FACTOR);
if (font == null || font.Handle == IntPtr.Zero)
{
throw new Exception(string.Format("Could not allocate font with family {0}, traits {1}, size {2}", familyString, traits, size));
}
#elif IOS
string suffix = string.Empty;
string italicString = "Italic";
var familyString = new StringBuilder();
switch (family)
{
case FontFamily.Monospace: familyString.Append("CourierNewPS"); suffix = "MT"; break;
default:
case FontFamily.Sans: familyString.Append("Helvetica"); italicString = "Oblique"; break;
case FontFamily.Serif: familyString.Append("TimesNewRomanPS"); suffix = "MT"; break;
}
bold = (style & FontStyle.Bold) != 0;
italic = (style & FontStyle.Italic) != 0;
if (bold || italic)
{
familyString.Append("-");
}
if (bold)
{
familyString.Append("Bold");
}
if (italic)
{
familyString.Append(italicString);
}
familyString.Append(suffix);
var font = UIFont.FromName(familyString.ToString(), size);
#endif
Control = font;
}
public FontTypefaceHandler(NSFont font, NSFontTraitMask?traits = null)
{
_font = font;
var descriptor = font.FontDescriptor;
PostScriptName = descriptor.PostscriptName;
var manager = NSFontManager.SharedFontManager;
Weight = (int)manager.WeightOfFont(font);
Traits = traits ?? manager.TraitsOfFont(font);
}
public static FontData FromFamily(string family, NSFontTraitMask traits, int weight, float size)
{
var font = NSFontManager.SharedFontManager.FontWithFamily(family, traits, weight, size);
var gentraits = NSFontManager.SharedFontManager.TraitsOfFont(font);
// NSFontManager may loose the traits, restore them here
if (traits > 0 && gentraits == 0)
{
font = NSFontManager.SharedFontManager.ConvertFont(font, traits);
}
return(FromFont(font));
}
static NSFont NSFontWithFamily(string name, NSFontTraitMask traits, int weight, float size)
{
if (NSThread.Current.IsMainThread)
{
return(NSFontManager.SharedFontManager.FontWithFamily(name, traits, weight, size));
}
NSFont font = null;
NSThread.MainThread.InvokeOnMainThread(() => { font = NSFontManager.SharedFontManager.FontWithFamily(name, traits, weight, size); });
return(font);
}
bool HasFontAttribute(NSFontTraitMask traitMask)
{
NSRange effectiveRange;
var attrib = Control.SelectedRange.Length == 0 ? Control.TypingAttributes : Control.TextStorage.GetAttributes((nnuint)Math.Min(Control.SelectedRange.Location, Control.TextStorage.Length - 1), out effectiveRange, Control.SelectedRange);
NSObject value;
if (attrib.TryGetValue(NSStringAttributeKey.Font, out value))
{
var font = value as NSFont;
if (font != null)
{
var traits = NSFontManager.SharedFontManager.TraitsOfFont(font);
return(traits.HasFlag(traitMask));
}
}
return(false);
}
public static NSFont ToNSFont(this FigmaTypeStyle style)
{
string family = style.fontFamily;
if (family == "SF UI Text")
{
family = ".SF NS Text";
}
else if (family == "SF Mono")
{
family = ".SF NS Display";
}
else
{
Console.WriteLine("FONT: {0} - {1}", family, style.fontPostScriptName);
}
var font = NSFont.FromFontName(family, style.fontSize);
var w = ToAppKitFontWeight(style.fontWeight);
NSFontTraitMask traits = default(NSFontTraitMask);
if (style.fontPostScriptName != null && style.fontPostScriptName.EndsWith("-Bold"))
{
traits = NSFontTraitMask.Bold;
}
else
{
}
//if (font != null)
//{
// var w = NSFontManager.SharedFontManager.WeightOfFont(font);
// var traits = NSFontManager.SharedFontManager.TraitsOfFont(font);
//}
font = NSFontManager.SharedFontManager.FontWithFamily(family, traits, w, style.fontSize);
//var font = NSFont.FromFontName(".SF NS Text", 12);
if (font == null)
{
Console.WriteLine($"[ERROR] Font not found :{family}");
font = NSFont.LabelFontOfSize(style.fontSize);
}
return(font);
}
public static FontStyle ToEto(this NSFontTraitMask traits)
{
var style = FontStyle.None;
if (traits.HasFlag(NSFontTraitMask.Bold))
{
style |= FontStyle.Bold;
}
if (traits.HasFlag(NSFontTraitMask.Italic))
{
style |= FontStyle.Italic;
}
//if (traits.HasFlag (NSFontTraitMask.Condensed))
// style |= FontStyle.Condensed;
//if (traits.HasFlag (NSFontTraitMask.Narrow))
// style |= FontStyle.Light;
return(style);
}
public void Create(FontFamily family, float size, FontStyle style, FontDecoration decoration)
{
this.style = style;
this.family = family;
this.decoration = decoration;
#if OSX
var familyHandler = (FontFamilyHandler)family.Handler;
NSFontTraitMask traits = style.ToNS() & familyHandler.TraitMask;
var font = NSFontManager.SharedFontManager.FontWithFamily(familyHandler.MacName, traits, 5, size);
if (font == null || font.Handle == IntPtr.Zero)
{
throw new ArgumentOutOfRangeException(string.Empty, string.Format("Could not allocate font with family {0}, traits {1}, size {2}", family.Name, traits, size));
}
#elif IOS
string suffix = string.Empty;
var familyHandler = (FontFamilyHandler)family.Handler;
var font = familyHandler.CreateFont(size, style);
/*
* var familyString = new StringBuilder();
* switch (family)
* {
* case FontFamily.Monospace: familyString.Append ("CourierNewPS"); suffix = "MT"; break;
* default:
* case FontFamily.Sans: familyString.Append ("Helvetica"); italicString = "Oblique"; break;
* case FontFamily.Serif: familyString.Append ("TimesNewRomanPS"); suffix = "MT"; break;
* }
* bold = (style & FontStyle.Bold) != 0;
* italic = (style & FontStyle.Italic) != 0;
*
* if (bold || italic) familyString.Append ("-");
* if (bold) familyString.Append ("Bold");
* if (italic) familyString.Append (italicString);
*
* familyString.Append (suffix);
* var font = UIFont.FromName (familyString.ToString (), size);
*/
#endif
Control = font;
}
private bool canToggleTrait(NSFont font, NSFontTraitMask trait)
{
NSFont testFont = null;
if ((NSFontTraitMask)((int)font.FontDescriptor.SymbolicTraits & (int)trait) == trait)
{
testFont = NSFontManager.SharedFontManager.ConvertFontToNotHaveTrait(arcView.Font, trait);
}
else
{
testFont = NSFontManager.SharedFontManager.ConvertFont(arcView.Font, trait);
}
if (testFont != null)
{
if ((NSFontTraitMask)(testFont.FontDescriptor.SymbolicTraits ^ font.FontDescriptor.SymbolicTraits) == trait)
{
return(true);
}
}
return(false);
}
private bool canToggleTrait (NSFont font, NSFontTraitMask trait)
{
NSFont testFont = null;
if ((NSFontTraitMask)((int)font.FontDescriptor.SymbolicTraits & (int)trait) == trait) {
testFont = NSFontManager.SharedFontManager.ConvertFontToNotHaveTrait (arcView.Font, trait);
} else {
testFont = NSFontManager.SharedFontManager.ConvertFont (arcView.Font, trait);
}
if (testFont != null) {
if ((NSFontTraitMask)(testFont.FontDescriptor.SymbolicTraits ^ font.FontDescriptor.SymbolicTraits) == trait) {
return true;
}
}
return false;
}
public static NSFont ToUIFont(this Font self)
{
float fontSize = (float)self.FontSize;
if (self.UseNamedSize)
{
switch (self.NamedSize)
{
case NamedSize.Micro:
fontSize = 12f;
break;
case NamedSize.Small:
fontSize = 14f;
break;
case NamedSize.Medium:
fontSize = 17f;
break;
case NamedSize.Large:
fontSize = 22f;
break;
default:
fontSize = 17f;
break;
}
}
bool isBold = ((Enum)self.FontAttributes).HasFlag((Enum)FontAttributes.Bold);
bool isItalic = ((Enum)self.FontAttributes).HasFlag((Enum)FontAttributes.Italic);
int fontWeight = 0;
NSFontTraitMask mask = 0;
if (isBold)
{
mask = mask | NSFontTraitMask.Bold;
}
if (isItalic)
{
mask = mask | NSFontTraitMask.Italic;
}
String fontFamily;
if (string.IsNullOrWhiteSpace(self.FontFamily))
{
fontFamily = "Verdana"; // Default OS X font
}
else
{
fontFamily = self.FontFamily;
}
try
{
var font = NSFontManager.SharedFontManager.FontWithFamily(
fontFamily, mask, fontWeight, fontSize);
return(font);
}
catch
{
}
return(NSFont.SystemFontOfSize((nfloat)fontSize));
}
public static NSFont CreateFont(FontFamilyHandler familyHandler, float size, NSFontTraitMask traits, int weight = 5)
{
return(CreateFont(familyHandler.MacName, size, traits, weight));
}
public static NSFont GetFont(
this ResourceDictionary resourceDictionary,
bool respectScale = true)
{
NSFontDescriptor fontDescriptor = null;
nfloat fontSize = 0;
switch (resourceDictionary[TypefaceId])
{
case NSFontDescriptor fd:
fontDescriptor = fd;
break;
case NSFont rdFont:
fontDescriptor = rdFont.FontDescriptor;
fontSize = rdFont.PointSize;
break;
case string fontName:
fontDescriptor = NSFontWorkarounds
.FromFontName(fontName, 0)
.FontDescriptor;
break;
}
switch (resourceDictionary[FontRenderingSizeId])
{
case double d:
fontSize = (nfloat)d;
break;
case float f:
fontSize = f;
break;
case nfloat nf:
fontSize = nf;
break;
case int i:
fontSize = i;
break;
}
if (fontSize <= 0)
{
fontSize = NSFont.SystemFontSize;
}
if (respectScale && resourceDictionary[FontRenderingScaleId] is double scale)
{
fontSize *= (nfloat)scale;
}
var font = fontDescriptor == null
? NSFontWorkarounds.UserFixedPitchFontOfSize(fontSize)
: NSFontWorkarounds.FromDescriptor(fontDescriptor, fontSize);
NSFontTraitMask convertFontTraits = 0;
if (resourceDictionary.Contains(IsBoldId) &&
resourceDictionary[IsBoldId] is bool isBold &&
isBold)
{
convertFontTraits |= NSFontTraitMask.Bold;
}
if (resourceDictionary.Contains(IsItalicId) &&
resourceDictionary[IsItalicId] is bool isItalic &&
isItalic)
{
convertFontTraits |= NSFontTraitMask.Italic;
}
if (convertFontTraits != 0)
{
font = NSFontManager.SharedFontManager.ConvertFontWorkaround(
font,
convertFontTraits);
}
return(font);
}
NSFont UpdateFontTrait(NSFont font, NSFontTraitMask traitMask, NSFontTraitMask traitUnmask, bool enabled)
{
var traits = enabled ? traitMask : traitUnmask;
return(NSFontManager.SharedFontManager.ConvertFont(font, traits));
}
void SetFontAttribute(NSRange range, NSFontTraitMask traitMask, NSFontTraitMask traitUnmask, bool enabled)
{
SetFontAttribute(range, enabled, f => UpdateFontTrait(f, traitMask, traitUnmask, enabled));
}
void SetSelectedFontAttribute(NSFontTraitMask traitMask, NSFontTraitMask traitUnmask, bool enabled)
{
SetSelectedFontAttribute(enabled, f => UpdateFontTrait(f, traitMask, traitUnmask, enabled));
}
