1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Android.Graphics;
using AApplication = Android.App.Application;
using Xamarin.Forms.Internals;
namespace Xamarin.Forms.Platform.Android
{
public static class FontExtensions
{
static readonly Dictionary<Tuple<string, FontAttributes>, Typeface> Typefaces = new Dictionary<Tuple<string, FontAttributes>, Typeface>();
// We don't create and cache a Regex object here because we may not ever need it, and creating Regexes is surprisingly expensive (especially on older hardware)
// Instead, we'll use the static Regex.IsMatch below, which will create and cache the regex internally as needed. It's the equivalent of Lazy<Regex> with less code.
// See https://msdn.microsoft.com/en-us/library/sdx2bds0(v=vs.110).aspx#Anchor_2
const string LoadFromAssetsRegex = @"\w+\.((ttf)|(otf))\#\w*";
static Typeface s_defaultTypeface;
public static float ToScaledPixel(this Font self)
{
if (self.IsDefault)
return 14;
if (self.UseNamedSize)
{
switch (self.NamedSize)
{
case NamedSize.Micro:
return 10;
case NamedSize.Small:
return 12;
case NamedSize.Default:
case NamedSize.Medium:
return 14;
case NamedSize.Large:
return 18;
}
}
return (float)self.FontSize;
}
public static Typeface ToTypeface(this Font self)
{
if (self.IsDefault)
return s_defaultTypeface ?? (s_defaultTypeface = Typeface.Default);
var key = new Tuple<string, FontAttributes>(self.FontFamily, self.FontAttributes);
Typeface result;
if (Typefaces.TryGetValue(key, out result))
return result;
if (self.FontFamily == null)
{
var style = ToTypefaceStyle(self.FontAttributes);
result = Typeface.Create(Typeface.Default, style);
}
else if (Regex.IsMatch(self.FontFamily, LoadFromAssetsRegex))
{
result = Typeface.CreateFromAsset(AApplication.Context.Assets, FontNameToFontFile(self.FontFamily));
}
else
{
var style = ToTypefaceStyle(self.FontAttributes);
result = Typeface.Create(self.FontFamily, style);
}
return (Typefaces[key] = result);
}
internal static bool IsDefault(this IFontElement self)
{
return self.FontFamily == null && self.FontSize == Device.GetNamedSize(NamedSize.Default, typeof(Label), true) && self.FontAttributes == FontAttributes.None;
}
internal static Typeface ToTypeface(this IFontElement self)
{
if (self.IsDefault())
return s_defaultTypeface ?? (s_defaultTypeface = Typeface.Default);
var key = new Tuple<string, FontAttributes>(self.FontFamily, self.FontAttributes);
Typeface result;
if (Typefaces.TryGetValue(key, out result))
return result;
if (self.FontFamily == null)
{
var style = ToTypefaceStyle(self.FontAttributes);
result = Typeface.Create(Typeface.Default, style);
}
else if (Regex.IsMatch(self.FontFamily, LoadFromAssetsRegex))
{
result = Typeface.CreateFromAsset(AApplication.Context.Assets, FontNameToFontFile(self.FontFamily));
}
else
{
var style = ToTypefaceStyle(self.FontAttributes);
result = Typeface.Create(self.FontFamily, style);
}
return (Typefaces[key] = result);
}
public static TypefaceStyle ToTypefaceStyle(FontAttributes attrs)
{
var style = TypefaceStyle.Normal;
if ((attrs & (FontAttributes.Bold | FontAttributes.Italic)) == (FontAttributes.Bold | FontAttributes.Italic))
style = TypefaceStyle.BoldItalic;
else if ((attrs & FontAttributes.Bold) != 0)
style = TypefaceStyle.Bold;
else if ((attrs & FontAttributes.Italic) != 0)
style = TypefaceStyle.Italic;
return style;
}
static string FontNameToFontFile(string fontFamily)
{
int hashtagIndex = fontFamily.IndexOf('#');
if (hashtagIndex >= 0)
return fontFamily.Substring(0, hashtagIndex);
throw new InvalidOperationException($"Can't parse the {nameof(fontFamily)} {fontFamily}");
}
}
}
|
