REGRESSION (r168095): 1-pixel gap between adjacent selection inlines
[WebKit-https.git] / Source / WebCore / platform / graphics / Font.h
1 /*
2  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
3  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
6  * Copyright (C) 2008 Holger Hans Peter Freyther
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #ifndef Font_h
26 #define Font_h
27
28 #include "DashArray.h"
29 #include "FontDescription.h"
30 #include "FontGlyphs.h"
31 #include "Path.h"
32 #include "SimpleFontData.h"
33 #include "TextDirection.h"
34 #include "TypesettingFeatures.h"
35 #include <wtf/HashMap.h>
36 #include <wtf/HashSet.h>
37 #include <wtf/unicode/CharacterNames.h>
38
39 // "X11/X.h" defines Complex to 0 and conflicts
40 // with Complex value in CodePath enum.
41 #ifdef Complex
42 #undef Complex
43 #endif
44
45 namespace WebCore {
46
47 class FloatPoint;
48 class FloatRect;
49 class FontData;
50 class FontMetrics;
51 class FontPlatformData;
52 class FontSelector;
53 class GlyphBuffer;
54 class GraphicsContext;
55 class LayoutRect;
56 class RenderText;
57 class TextLayout;
58 class TextRun;
59
60 struct GlyphData;
61
62 struct GlyphOverflow {
63     GlyphOverflow()
64         : left(0)
65         , right(0)
66         , top(0)
67         , bottom(0)
68         , computeBounds(false)
69     {
70     }
71
72     int left;
73     int right;
74     int top;
75     int bottom;
76     bool computeBounds;
77 };
78
79 class GlyphToPathTranslator {
80 public:
81     virtual bool containsMorePaths() = 0;
82     virtual Path nextPath() = 0;
83     virtual ~GlyphToPathTranslator() { }
84 };
85
86 class Font {
87 public:
88     Font();
89     Font(const FontDescription&, float letterSpacing, float wordSpacing);
90     // This constructor is only used if the platform wants to start with a native font.
91     Font(const FontPlatformData&, bool isPrinting, FontSmoothingMode = AutoSmoothing);
92
93     // FIXME: We should make this constructor platform-independent.
94 #if PLATFORM(IOS)
95     Font(const FontPlatformData&, PassRefPtr<FontSelector>);
96 #endif
97     ~Font();
98
99     Font(const Font&);
100     Font& operator=(const Font&);
101
102     bool operator==(const Font& other) const;
103     bool operator!=(const Font& other) const { return !(*this == other); }
104
105     const FontDescription& fontDescription() const { return m_fontDescription; }
106
107     int pixelSize() const { return fontDescription().computedPixelSize(); }
108     float size() const { return fontDescription().computedSize(); }
109
110     void update(PassRefPtr<FontSelector>) const;
111
112     enum CustomFontNotReadyAction { DoNotPaintIfFontNotReady, UseFallbackIfFontNotReady };
113     float drawText(GraphicsContext*, const TextRun&, const FloatPoint&, int from = 0, int to = -1, CustomFontNotReadyAction = DoNotPaintIfFontNotReady) const;
114     void drawGlyphs(GraphicsContext*, const SimpleFontData*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&) const;
115     void drawEmphasisMarks(GraphicsContext*, const TextRun&, const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1) const;
116
117     DashArray dashesForIntersectionsWithRect(const TextRun&, const FloatPoint& textOrigin, const FloatRect& lineExtents) const;
118
119     float width(const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
120     float width(const TextRun&, int& charsConsumed, String& glyphName) const;
121
122     PassOwnPtr<TextLayout> createLayout(RenderText*, float xPos, bool collapseWhiteSpace) const;
123     static void deleteLayout(TextLayout*);
124     static float width(TextLayout&, unsigned from, unsigned len, HashSet<const SimpleFontData*>* fallbackFonts = 0);
125
126     int offsetForPosition(const TextRun&, float position, bool includePartialGlyphs) const;
127     void adjustSelectionRectForText(const TextRun&, LayoutRect& selectionRect, int from = 0, int to = -1) const;
128
129     bool isSmallCaps() const { return m_fontDescription.smallCaps(); }
130
131     float wordSpacing() const { return m_wordSpacing; }
132     float letterSpacing() const { return m_letterSpacing; }
133     void setWordSpacing(float s) { m_wordSpacing = s; }
134     void setLetterSpacing(float s) { m_letterSpacing = s; }
135     bool isFixedPitch() const;
136     bool isPrinterFont() const { return m_fontDescription.usePrinterFont(); }
137     bool isSVGFont() const { return primaryFont()->isSVGFont(); }
138     
139     FontRenderingMode renderingMode() const { return m_fontDescription.renderingMode(); }
140
141     TypesettingFeatures typesettingFeatures() const { return static_cast<TypesettingFeatures>(m_typesettingFeatures); }
142
143     const AtomicString& firstFamily() const { return m_fontDescription.firstFamily(); }
144     unsigned familyCount() const { return m_fontDescription.familyCount(); }
145     const AtomicString& familyAt(unsigned i) const { return m_fontDescription.familyAt(i); }
146
147     FontItalic italic() const { return m_fontDescription.italic(); }
148     FontWeight weight() const { return m_fontDescription.weight(); }
149     FontWidthVariant widthVariant() const { return m_fontDescription.widthVariant(); }
150
151     bool isPlatformFont() const { return m_glyphs->isForPlatformFont(); }
152
153     const FontMetrics& fontMetrics() const { return primaryFont()->fontMetrics(); }
154     float spaceWidth() const { return primaryFont()->spaceWidth() + m_letterSpacing; }
155     float tabWidth(const SimpleFontData&, unsigned tabSize, float position) const;
156     float tabWidth(unsigned tabSize, float position) const { return tabWidth(*primaryFont(), tabSize, position); }
157     bool hasValidAverageCharWidth() const;
158     bool fastAverageCharWidthIfAvailable(float &width) const; // returns true on success
159
160     int emphasisMarkAscent(const AtomicString&) const;
161     int emphasisMarkDescent(const AtomicString&) const;
162     int emphasisMarkHeight(const AtomicString&) const;
163
164     const SimpleFontData* primaryFont() const;
165     const FontData* fontDataAt(unsigned) const;
166     GlyphData glyphDataForCharacter(UChar32 c, bool mirror, FontDataVariant variant = AutoVariant) const
167     {
168         return glyphDataAndPageForCharacter(c, mirror, variant).first;
169     }
170 #if PLATFORM(COCOA)
171     const SimpleFontData* fontDataForCombiningCharacterSequence(const UChar*, size_t length, FontDataVariant) const;
172 #endif
173     std::pair<GlyphData, GlyphPage*> glyphDataAndPageForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
174     {
175         return m_glyphs->glyphDataAndPageForCharacter(m_fontDescription, c, mirror, variant);
176     }
177     bool primaryFontHasGlyphForCharacter(UChar32) const;
178
179     static bool isCJKIdeograph(UChar32);
180     static bool isCJKIdeographOrSymbol(UChar32);
181
182     static unsigned expansionOpportunityCount(const LChar*, size_t length, TextDirection, bool& isAfterExpansion);
183     static unsigned expansionOpportunityCount(const UChar*, size_t length, TextDirection, bool& isAfterExpansion);
184
185     static void setShouldUseSmoothing(bool);
186     static bool shouldUseSmoothing();
187
188     enum CodePath { Auto, Simple, Complex, SimpleWithGlyphOverflow };
189     CodePath codePath(const TextRun&) const;
190     static CodePath characterRangeCodePath(const LChar*, unsigned) { return Simple; }
191     static CodePath characterRangeCodePath(const UChar*, unsigned len);
192
193     bool primaryFontDataIsSystemFont() const;
194
195 private:
196     enum ForTextEmphasisOrNot { NotForTextEmphasis, ForTextEmphasis };
197
198     // Returns the initial in-stream advance.
199     float getGlyphsAndAdvancesForSimpleText(const TextRun&, int from, int to, GlyphBuffer&, ForTextEmphasisOrNot = NotForTextEmphasis) const;
200     float drawSimpleText(GraphicsContext*, const TextRun&, const FloatPoint&, int from, int to) const;
201     void drawEmphasisMarksForSimpleText(GraphicsContext*, const TextRun&, const AtomicString& mark, const FloatPoint&, int from, int to) const;
202     void drawGlyphBuffer(GraphicsContext*, const TextRun&, const GlyphBuffer&, FloatPoint&) const;
203     void drawEmphasisMarks(GraphicsContext*, const TextRun&, const GlyphBuffer&, const AtomicString&, const FloatPoint&) const;
204     float floatWidthForSimpleText(const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
205     int offsetForPositionForSimpleText(const TextRun&, float position, bool includePartialGlyphs) const;
206     void adjustSelectionRectForSimpleText(const TextRun&, LayoutRect& selectionRect, int from, int to) const;
207
208     bool getEmphasisMarkGlyphData(const AtomicString&, GlyphData&) const;
209
210     static bool canReturnFallbackFontsForComplexText();
211     static bool canExpandAroundIdeographsInComplexText();
212
213     // Returns the initial in-stream advance.
214     float getGlyphsAndAdvancesForComplexText(const TextRun&, int from, int to, GlyphBuffer&, ForTextEmphasisOrNot = NotForTextEmphasis) const;
215     float drawComplexText(GraphicsContext*, const TextRun&, const FloatPoint&, int from, int to) const;
216     void drawEmphasisMarksForComplexText(GraphicsContext*, const TextRun&, const AtomicString& mark, const FloatPoint&, int from, int to) const;
217     float floatWidthForComplexText(const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
218     int offsetForPositionForComplexText(const TextRun&, float position, bool includePartialGlyphs) const;
219     void adjustSelectionRectForComplexText(const TextRun&, LayoutRect& selectionRect, int from, int to) const;
220
221     friend struct WidthIterator;
222     friend class SVGTextRunRenderingContext;
223
224 public:
225 #if ENABLE(IOS_TEXT_AUTOSIZING)
226     bool equalForTextAutoSizing(const Font& other) const
227     {
228         return m_fontDescription.equalForTextAutoSizing(other.m_fontDescription)
229             && m_letterSpacing == other.m_letterSpacing
230             && m_wordSpacing == other.m_wordSpacing;
231     }
232 #endif
233
234     // Useful for debugging the different font rendering code paths.
235     static void setCodePath(CodePath);
236     static CodePath codePath();
237     static CodePath s_codePath;
238
239     static void setDefaultTypesettingFeatures(TypesettingFeatures);
240     static TypesettingFeatures defaultTypesettingFeatures();
241
242     static const uint8_t s_roundingHackCharacterTable[256];
243     static bool isRoundingHackCharacter(UChar32 c)
244     {
245         return !(c & ~0xFF) && s_roundingHackCharacterTable[c];
246     }
247
248     FontSelector* fontSelector() const;
249     static bool treatAsSpace(UChar c) { return c == ' ' || c == '\t' || c == '\n' || c == noBreakSpace; }
250     static bool treatAsZeroWidthSpace(UChar c) { return treatAsZeroWidthSpaceInComplexScript(c) || c == 0x200c || c == 0x200d; }
251     static bool treatAsZeroWidthSpaceInComplexScript(UChar c) { return c < 0x20 || (c >= 0x7F && c < 0xA0) || c == softHyphen || c == zeroWidthSpace || (c >= 0x200e && c <= 0x200f) || (c >= 0x202a && c <= 0x202e) || c == zeroWidthNoBreakSpace || c == objectReplacementCharacter; }
252     static bool canReceiveTextEmphasis(UChar32 c);
253
254     static inline UChar normalizeSpaces(UChar character)
255     {
256         if (treatAsSpace(character))
257             return space;
258
259         if (treatAsZeroWidthSpace(character))
260             return zeroWidthSpace;
261
262         return character;
263     }
264
265     static String normalizeSpaces(const LChar*, unsigned length);
266     static String normalizeSpaces(const UChar*, unsigned length);
267
268     bool useBackslashAsYenSymbol() const { return m_useBackslashAsYenSymbol; }
269     FontGlyphs* glyphs() const { return m_glyphs.get(); }
270
271 private:
272     bool loadingCustomFonts() const
273     {
274         return m_glyphs && m_glyphs->loadingCustomFonts();
275     }
276
277     TypesettingFeatures computeTypesettingFeatures() const
278     {
279         TextRenderingMode textRenderingMode = m_fontDescription.textRenderingMode();
280         TypesettingFeatures features = s_defaultTypesettingFeatures;
281
282         switch (textRenderingMode) {
283         case AutoTextRendering:
284             break;
285         case OptimizeSpeed:
286             features &= ~(Kerning | Ligatures);
287             break;
288         case GeometricPrecision:
289         case OptimizeLegibility:
290             features |= Kerning | Ligatures;
291             break;
292         }
293
294         switch (m_fontDescription.kerning()) {
295         case FontDescription::NoneKerning:
296             features &= ~Kerning;
297             break;
298         case FontDescription::NormalKerning:
299             features |= Kerning;
300             break;
301         case FontDescription::AutoKerning:
302             break;
303         }
304
305         switch (m_fontDescription.commonLigaturesState()) {
306         case FontDescription::DisabledLigaturesState:
307             features &= ~Ligatures;
308             break;
309         case FontDescription::EnabledLigaturesState:
310             features |= Ligatures;
311             break;
312         case FontDescription::NormalLigaturesState:
313             break;
314         }
315
316         return features;
317     }
318
319     static TypesettingFeatures s_defaultTypesettingFeatures;
320
321     FontDescription m_fontDescription;
322     mutable RefPtr<FontGlyphs> m_glyphs;
323     float m_letterSpacing;
324     float m_wordSpacing;
325     mutable bool m_useBackslashAsYenSymbol;
326     mutable unsigned m_typesettingFeatures : 2; // (TypesettingFeatures) Caches values computed from m_fontDescription.
327 };
328
329 void invalidateFontGlyphsCache();
330 void pruneUnreferencedEntriesFromFontGlyphsCache();
331 void clearWidthCaches();
332
333 inline Font::~Font()
334 {
335 }
336
337 inline const SimpleFontData* Font::primaryFont() const
338 {
339     ASSERT(m_glyphs);
340     return m_glyphs->primarySimpleFontData(m_fontDescription);
341 }
342
343 inline const FontData* Font::fontDataAt(unsigned index) const
344 {
345     ASSERT(m_glyphs);
346     return m_glyphs->realizeFontDataAt(m_fontDescription, index);
347 }
348
349 inline bool Font::isFixedPitch() const
350 {
351     ASSERT(m_glyphs);
352     return m_glyphs->isFixedPitch(m_fontDescription);
353 }
354
355 inline FontSelector* Font::fontSelector() const
356 {
357     return m_glyphs ? m_glyphs->fontSelector() : 0;
358 }
359
360 inline float Font::tabWidth(const SimpleFontData& fontData, unsigned tabSize, float position) const
361 {
362     if (!tabSize)
363         return letterSpacing();
364     float tabWidth = tabSize * fontData.spaceWidth() + letterSpacing();
365     return tabWidth - fmodf(position, tabWidth);
366 }
367
368 }
369
370 namespace WTF {
371
372 template <> void deleteOwnedPtr<WebCore::TextLayout>(WebCore::TextLayout*);
373
374 }
375
376 #endif