1 /*
2 * Copyright (c) 2008, 2009, Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 * * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include "config.h"
32 #include "platform/fonts/SimpleFontData.h"
33
34 #include <unicode/normlzr.h>
35 #include "SkPaint.h"
36 #include "SkPath.h"
37 #include "SkTypeface.h"
38 #include "SkTypes.h"
39 #include "platform/fonts/FontDescription.h"
40 #include "platform/fonts/VDMXParser.h"
41 #include "platform/geometry/FloatRect.h"
42 #include "wtf/unicode/Unicode.h"
43
44 #if OS(WIN)
45 #include "platform/win/HWndDC.h"
46 #endif
47
48 namespace WebCore {
49
50 // This is the largest VDMX table which we'll try to load and parse.
51 static const size_t maxVDMXTableSize = 1024 * 1024; // 1 MB
52
platformInit()53 void SimpleFontData::platformInit()
54 {
55 if (!m_platformData.size()) {
56 m_fontMetrics.reset();
57 m_avgCharWidth = 0;
58 m_maxCharWidth = 0;
59 return;
60 }
61
62 SkPaint paint;
63 SkPaint::FontMetrics metrics;
64
65 m_platformData.setupPaint(&paint);
66 paint.getFontMetrics(&metrics);
67 SkTypeface* face = paint.getTypeface();
68 ASSERT(face);
69
70 static const uint32_t vdmxTag = SkSetFourByteTag('V', 'D', 'M', 'X');
71 int pixelSize = m_platformData.size() + 0.5;
72 int vdmxAscent, vdmxDescent;
73 bool isVDMXValid = false;
74
75 size_t vdmxSize = face->getTableSize(vdmxTag);
76 if (vdmxSize && vdmxSize < maxVDMXTableSize) {
77 uint8_t* vdmxTable = (uint8_t*) fastMalloc(vdmxSize);
78 if (vdmxTable
79 && face->getTableData(vdmxTag, 0, vdmxSize, vdmxTable) == vdmxSize
80 && parseVDMX(&vdmxAscent, &vdmxDescent, vdmxTable, vdmxSize, pixelSize))
81 isVDMXValid = true;
82 fastFree(vdmxTable);
83 }
84
85 float ascent;
86 float descent;
87
88 // Beware those who step here: This code is designed to match Win32 font
89 // metrics *exactly* (except the adjustment of ascent/descent on Linux/Android).
90 if (isVDMXValid) {
91 ascent = vdmxAscent;
92 descent = -vdmxDescent;
93 } else {
94 ascent = SkScalarRound(-metrics.fAscent);
95 descent = SkScalarRound(metrics.fDescent);
96 #if OS(LINUX) || OS(ANDROID)
97 // When subpixel positioning is enabled, if the descent is rounded down, the descent part
98 // of the glyph may be truncated when displayed in a 'overflow: hidden' container.
99 // To avoid that, borrow 1 unit from the ascent when possible.
100 // FIXME: This can be removed if sub-pixel ascent/descent is supported.
101 if (platformData().fontRenderStyle().useSubpixelPositioning && descent < SkScalarToFloat(metrics.fDescent) && ascent >= 1) {
102 ++descent;
103 --ascent;
104 }
105 #endif
106 }
107
108 m_fontMetrics.setAscent(ascent);
109 m_fontMetrics.setDescent(descent);
110
111 float xHeight;
112 if (metrics.fXHeight) {
113 xHeight = metrics.fXHeight;
114 m_fontMetrics.setXHeight(xHeight);
115 } else {
116 xHeight = ascent * 0.56; // Best guess from Windows font metrics.
117 m_fontMetrics.setXHeight(xHeight);
118 m_fontMetrics.setHasXHeight(false);
119 }
120
121 float lineGap = SkScalarToFloat(metrics.fLeading);
122 m_fontMetrics.setLineGap(lineGap);
123 m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
124
125 if (platformData().orientation() == Vertical && !isTextOrientationFallback()) {
126 static const uint32_t vheaTag = SkSetFourByteTag('v', 'h', 'e', 'a');
127 static const uint32_t vorgTag = SkSetFourByteTag('V', 'O', 'R', 'G');
128 size_t vheaSize = face->getTableSize(vheaTag);
129 size_t vorgSize = face->getTableSize(vorgTag);
130 if ((vheaSize > 0) || (vorgSize > 0))
131 m_hasVerticalGlyphs = true;
132 }
133
134 // In WebKit/WebCore/platform/graphics/SimpleFontData.cpp, m_spaceWidth is
135 // calculated for us, but we need to calculate m_maxCharWidth and
136 // m_avgCharWidth in order for text entry widgets to be sized correctly.
137 #if OS(WIN)
138 m_maxCharWidth = SkScalarRound(metrics.fMaxCharWidth);
139 #else
140 // FIXME: This seems incorrect and should probably use fMaxCharWidth as
141 // the code path above.
142 SkScalar xRange = metrics.fXMax - metrics.fXMin;
143 m_maxCharWidth = SkScalarRound(xRange * SkScalarRound(m_platformData.size()));
144 #endif
145
146 if (metrics.fAvgCharWidth)
147 m_avgCharWidth = SkScalarRound(metrics.fAvgCharWidth);
148 else {
149 m_avgCharWidth = xHeight;
150
151 GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
152
153 if (glyphPageZero) {
154 static const UChar32 xChar = 'x';
155 const Glyph xGlyph = glyphPageZero->glyphForCharacter(xChar);
156
157 if (xGlyph) {
158 // In widthForGlyph(), xGlyph will be compared with
159 // m_zeroWidthSpaceGlyph, which isn't initialized yet here.
160 // Initialize it with zero to make sure widthForGlyph() returns
161 // the right width.
162 m_zeroWidthSpaceGlyph = 0;
163 m_avgCharWidth = widthForGlyph(xGlyph);
164 }
165 }
166 }
167
168 if (int unitsPerEm = face->getUnitsPerEm())
169 m_fontMetrics.setUnitsPerEm(unitsPerEm);
170 }
171
platformCharWidthInit()172 void SimpleFontData::platformCharWidthInit()
173 {
174 // charwidths are set in platformInit.
175 }
176
platformDestroy()177 void SimpleFontData::platformDestroy()
178 {
179 }
180
platformCreateScaledFontData(const FontDescription & fontDescription,float scaleFactor) const181 PassRefPtr<SimpleFontData> SimpleFontData::platformCreateScaledFontData(const FontDescription& fontDescription, float scaleFactor) const
182 {
183 const float scaledSize = lroundf(fontDescription.computedSize() * scaleFactor);
184 return SimpleFontData::create(FontPlatformData(m_platformData, scaledSize), isCustomFont() ? CustomFontData::create(false) : 0);
185 }
186
containsCharacters(const UChar * characters,int length) const187 bool SimpleFontData::containsCharacters(const UChar* characters, int length) const
188 {
189 SkPaint paint;
190 static const unsigned maxBufferCount = 64;
191 uint16_t glyphs[maxBufferCount];
192
193 m_platformData.setupPaint(&paint);
194 paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
195
196 while (length > 0) {
197 int n = SkMin32(length, SK_ARRAY_COUNT(glyphs));
198
199 // textToGlyphs takes a byte count so we double the character count.
200 int count = paint.textToGlyphs(characters, n * 2, glyphs);
201 for (int i = 0; i < count; i++) {
202 if (!glyphs[i])
203 return false; // missing glyph
204 }
205
206 characters += n;
207 length -= n;
208 }
209
210 return true;
211 }
212
determinePitch()213 void SimpleFontData::determinePitch()
214 {
215 m_treatAsFixedPitch = platformData().isFixedPitch();
216 }
217
getSkiaBoundsForGlyph(SkPaint & paint,Glyph glyph,SkRect & bounds)218 static inline void getSkiaBoundsForGlyph(SkPaint& paint, Glyph glyph, SkRect& bounds)
219 {
220 paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
221
222 SkPath path;
223 paint.getTextPath(&glyph, sizeof(glyph), 0, 0, &path);
224 bounds = path.getBounds();
225
226 // FIXME(eae): getBounds currently returns an empty rect for bitmap
227 // fonts so fall back on the old behavior. Once fixed in Skia this
228 // fallback can go away.
229 if (bounds.isEmpty())
230 paint.measureText(&glyph, 2, &bounds);
231
232 if (!paint.isSubpixelText()) {
233 SkIRect ir;
234 bounds.round(&ir);
235 bounds.set(ir);
236 }
237 }
238
platformBoundsForGlyph(Glyph glyph) const239 FloatRect SimpleFontData::platformBoundsForGlyph(Glyph glyph) const
240 {
241 if (!m_platformData.size())
242 return FloatRect();
243
244 SkASSERT(sizeof(glyph) == 2); // compile-time assert
245
246 SkPaint paint;
247 m_platformData.setupPaint(&paint);
248
249 SkRect bounds;
250 getSkiaBoundsForGlyph(paint, glyph, bounds);
251 return FloatRect(bounds);
252 }
253
platformWidthForGlyph(Glyph glyph) const254 float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
255 {
256 if (!m_platformData.size())
257 return 0;
258
259 SkASSERT(sizeof(glyph) == 2); // compile-time assert
260
261 SkPaint paint;
262
263 m_platformData.setupPaint(&paint);
264
265 paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
266 SkScalar width = paint.measureText(&glyph, 2);
267 if (!paint.isSubpixelText())
268 width = SkScalarRound(width);
269 return SkScalarToFloat(width);
270 }
271
272 #if USE(HARFBUZZ)
canRenderCombiningCharacterSequence(const UChar * characters,size_t length) const273 bool SimpleFontData::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
274 {
275 if (!m_combiningCharacterSequenceSupport)
276 m_combiningCharacterSequenceSupport = adoptPtr(new HashMap<String, bool>);
277
278 WTF::HashMap<String, bool>::AddResult addResult = m_combiningCharacterSequenceSupport->add(String(characters, length), false);
279 if (!addResult.isNewEntry)
280 return addResult.iterator->value;
281
282 UErrorCode error = U_ZERO_ERROR;
283 Vector<UChar, 4> normalizedCharacters(length);
284 int32_t normalizedLength = unorm_normalize(characters, length, UNORM_NFC, UNORM_UNICODE_3_2, &normalizedCharacters[0], length, &error);
285 // Can't render if we have an error or no composition occurred.
286 if (U_FAILURE(error) || (static_cast<size_t>(normalizedLength) == length))
287 return false;
288
289 SkPaint paint;
290 m_platformData.setupPaint(&paint);
291 paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
292 if (paint.textToGlyphs(&normalizedCharacters[0], normalizedLength * 2, 0)) {
293 addResult.iterator->value = true;
294 return true;
295 }
296 return false;
297 }
298 #endif
299
300 } // namespace WebCore
301