1 /* 2 * Copyright (C) 2000 Lars Knoll (knoll (at) kde.org) 3 * (C) 2000 Antti Koivisto (koivisto (at) kde.org) 4 * (C) 2000 Dirk Mueller (mueller (at) kde.org) 5 * Copyright (C) 2003, 2006, 2007, 2011 Apple Inc. All rights reserved. 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Library General Public 9 * License as published by the Free Software Foundation; either 10 * version 2 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Library General Public License for more details. 16 * 17 * You should have received a copy of the GNU Library General Public License 18 * along with this library; see the file COPYING.LIB. If not, write to 19 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 20 * Boston, MA 02110-1301, USA. 21 * 22 */ 23 24 #ifndef TextRun_h 25 #define TextRun_h 26 27 #include "core/platform/graphics/FloatRect.h" 28 #include "core/platform/text/TextDirection.h" 29 #include "wtf/RefCounted.h" 30 #include "wtf/text/WTFString.h" 31 32 namespace WebCore { 33 34 class FloatPoint; 35 class Font; 36 class GraphicsContext; 37 class GlyphBuffer; 38 class SimpleFontData; 39 struct GlyphData; 40 struct WidthIterator; 41 42 class TextRun { 43 WTF_MAKE_FAST_ALLOCATED; 44 public: 45 enum ExpansionBehaviorFlags { 46 ForbidTrailingExpansion = 0 << 0, 47 AllowTrailingExpansion = 1 << 0, 48 ForbidLeadingExpansion = 0 << 1, 49 AllowLeadingExpansion = 1 << 1, 50 }; 51 52 typedef unsigned ExpansionBehavior; 53 54 enum RoundingHackFlags { 55 NoRounding = 0, 56 RunRounding = 1 << 0, 57 WordRounding = 1 << 1, 58 }; 59 60 typedef unsigned RoundingHacks; 61 62 TextRun(const LChar* c, unsigned len, float xpos = 0, float expansion = 0, ExpansionBehavior expansionBehavior = AllowTrailingExpansion | ForbidLeadingExpansion, TextDirection direction = LTR, bool directionalOverride = false, bool characterScanForCodePath = true, RoundingHacks roundingHacks = RunRounding | WordRounding) 63 : m_charactersLength(len) 64 , m_len(len) 65 , m_xpos(xpos) 66 , m_horizontalGlyphStretch(1) 67 , m_expansion(expansion) 68 , m_expansionBehavior(expansionBehavior) 69 , m_is8Bit(true) 70 , m_allowTabs(false) 71 , m_direction(direction) 72 , m_directionalOverride(directionalOverride) 73 , m_characterScanForCodePath(characterScanForCodePath) 74 , m_applyRunRounding((roundingHacks & RunRounding) && s_allowsRoundingHacks) 75 , m_applyWordRounding((roundingHacks & WordRounding) && s_allowsRoundingHacks) 76 , m_disableSpacing(false) 77 , m_tabSize(0) 78 { 79 m_data.characters8 = c; 80 } 81 82 TextRun(const UChar* c, unsigned len, float xpos = 0, float expansion = 0, ExpansionBehavior expansionBehavior = AllowTrailingExpansion | ForbidLeadingExpansion, TextDirection direction = LTR, bool directionalOverride = false, bool characterScanForCodePath = true, RoundingHacks roundingHacks = RunRounding | WordRounding) 83 : m_charactersLength(len) 84 , m_len(len) 85 , m_xpos(xpos) 86 , m_horizontalGlyphStretch(1) 87 , m_expansion(expansion) 88 , m_expansionBehavior(expansionBehavior) 89 , m_is8Bit(false) 90 , m_allowTabs(false) 91 , m_direction(direction) 92 , m_directionalOverride(directionalOverride) 93 , m_characterScanForCodePath(characterScanForCodePath) 94 , m_applyRunRounding((roundingHacks & RunRounding) && s_allowsRoundingHacks) 95 , m_applyWordRounding((roundingHacks & WordRounding) && s_allowsRoundingHacks) 96 , m_disableSpacing(false) 97 , m_tabSize(0) 98 { 99 m_data.characters16 = c; 100 } 101 102 TextRun(const String& string, float xpos = 0, float expansion = 0, ExpansionBehavior expansionBehavior = AllowTrailingExpansion | ForbidLeadingExpansion, TextDirection direction = LTR, bool directionalOverride = false, bool characterScanForCodePath = true, RoundingHacks roundingHacks = RunRounding | WordRounding) 103 : m_charactersLength(string.length()) 104 , m_len(string.length()) 105 , m_xpos(xpos) 106 , m_horizontalGlyphStretch(1) 107 , m_expansion(expansion) 108 , m_expansionBehavior(expansionBehavior) 109 , m_allowTabs(false) 110 , m_direction(direction) 111 , m_directionalOverride(directionalOverride) 112 , m_characterScanForCodePath(characterScanForCodePath) 113 , m_applyRunRounding((roundingHacks & RunRounding) && s_allowsRoundingHacks) 114 , m_applyWordRounding((roundingHacks & WordRounding) && s_allowsRoundingHacks) 115 , m_disableSpacing(false) 116 , m_tabSize(0) 117 { 118 if (!m_charactersLength) { 119 m_is8Bit = true; 120 m_data.characters8 = 0; 121 } else if (string.is8Bit()) { 122 m_data.characters8 = string.characters8(); 123 m_is8Bit = true; 124 } else { 125 m_data.characters16 = string.characters16(); 126 m_is8Bit = false; 127 } 128 } 129 130 TextRun(const StringView& string, float xpos = 0, float expansion = 0, ExpansionBehavior expansionBehavior = AllowTrailingExpansion | ForbidLeadingExpansion, TextDirection direction = LTR, bool directionalOverride = false, bool characterScanForCodePath = true, RoundingHacks roundingHacks = RunRounding | WordRounding) 131 : m_charactersLength(string.length()) 132 , m_len(string.length()) 133 , m_xpos(xpos) 134 , m_horizontalGlyphStretch(1) 135 , m_expansion(expansion) 136 , m_expansionBehavior(expansionBehavior) 137 , m_allowTabs(false) 138 , m_direction(direction) 139 , m_directionalOverride(directionalOverride) 140 , m_characterScanForCodePath(characterScanForCodePath) 141 , m_applyRunRounding((roundingHacks & RunRounding) && s_allowsRoundingHacks) 142 , m_applyWordRounding((roundingHacks & WordRounding) && s_allowsRoundingHacks) 143 , m_disableSpacing(false) 144 , m_tabSize(0) 145 { 146 if (!m_charactersLength) { 147 m_is8Bit = true; 148 m_data.characters8 = 0; 149 } else if (string.is8Bit()) { 150 m_data.characters8 = string.characters8(); 151 m_is8Bit = true; 152 } else { 153 m_data.characters16 = string.characters16(); 154 m_is8Bit = false; 155 } 156 } 157 158 TextRun subRun(unsigned startOffset, unsigned length) const 159 { 160 ASSERT(startOffset < m_len); 161 162 TextRun result = *this; 163 164 if (is8Bit()) { 165 result.setText(data8(startOffset), length); 166 return result; 167 } 168 result.setText(data16(startOffset), length); 169 return result; 170 } 171 172 UChar operator[](unsigned i) const { ASSERT_WITH_SECURITY_IMPLICATION(i < m_len); return is8Bit() ? m_data.characters8[i] :m_data.characters16[i]; } 173 const LChar* data8(unsigned i) const { ASSERT_WITH_SECURITY_IMPLICATION(i < m_len); ASSERT(is8Bit()); return &m_data.characters8[i]; } 174 const UChar* data16(unsigned i) const { ASSERT_WITH_SECURITY_IMPLICATION(i < m_len); ASSERT(!is8Bit()); return &m_data.characters16[i]; } 175 176 const LChar* characters8() const { ASSERT(is8Bit()); return m_data.characters8; } 177 const UChar* characters16() const { ASSERT(!is8Bit()); return m_data.characters16; } 178 179 bool is8Bit() const { return m_is8Bit; } 180 int length() const { return m_len; } 181 int charactersLength() const { return m_charactersLength; } 182 183 void setText(const LChar* c, unsigned len) { m_data.characters8 = c; m_len = len; m_is8Bit = true;} 184 void setText(const UChar* c, unsigned len) { m_data.characters16 = c; m_len = len; m_is8Bit = false;} 185 void setText(const String&); 186 void setCharactersLength(unsigned charactersLength) { m_charactersLength = charactersLength; } 187 188 float horizontalGlyphStretch() const { return m_horizontalGlyphStretch; } 189 void setHorizontalGlyphStretch(float scale) { m_horizontalGlyphStretch = scale; } 190 191 bool allowTabs() const { return m_allowTabs; } 192 unsigned tabSize() const { return m_tabSize; } 193 void setTabSize(bool, unsigned); 194 195 float xPos() const { return m_xpos; } 196 void setXPos(float xPos) { m_xpos = xPos; } 197 float expansion() const { return m_expansion; } 198 bool allowsLeadingExpansion() const { return m_expansionBehavior & AllowLeadingExpansion; } 199 bool allowsTrailingExpansion() const { return m_expansionBehavior & AllowTrailingExpansion; } 200 TextDirection direction() const { return static_cast<TextDirection>(m_direction); } 201 bool rtl() const { return m_direction == RTL; } 202 bool ltr() const { return m_direction == LTR; } 203 bool directionalOverride() const { return m_directionalOverride; } 204 bool characterScanForCodePath() const { return m_characterScanForCodePath; } 205 bool applyRunRounding() const { return m_applyRunRounding; } 206 bool applyWordRounding() const { return m_applyWordRounding; } 207 bool spacingDisabled() const { return m_disableSpacing; } 208 209 void disableSpacing() { m_disableSpacing = true; } 210 void disableRoundingHacks() { m_applyRunRounding = m_applyWordRounding = false; } 211 void setDirection(TextDirection direction) { m_direction = direction; } 212 void setDirectionalOverride(bool override) { m_directionalOverride = override; } 213 void setCharacterScanForCodePath(bool scan) { m_characterScanForCodePath = scan; } 214 215 class RenderingContext : public RefCounted<RenderingContext> { 216 public: 217 virtual ~RenderingContext() { } 218 219 virtual GlyphData glyphDataForCharacter(const Font&, const TextRun&, WidthIterator&, UChar32 character, bool mirror, int currentCharacter, unsigned& advanceLength) = 0; 220 virtual void drawSVGGlyphs(GraphicsContext*, const TextRun&, const SimpleFontData*, const GlyphBuffer&, int from, int to, const FloatPoint&) const = 0; 221 virtual float floatWidthUsingSVGFont(const Font&, const TextRun&, int& charsConsumed, String& glyphName) const = 0; 222 }; 223 224 RenderingContext* renderingContext() const { return m_renderingContext.get(); } 225 void setRenderingContext(PassRefPtr<RenderingContext> context) { m_renderingContext = context; } 226 227 static void setAllowsRoundingHacks(bool); 228 static bool allowsRoundingHacks(); 229 230 private: 231 static bool s_allowsRoundingHacks; 232 233 union { 234 const LChar* characters8; 235 const UChar* characters16; 236 } m_data; 237 unsigned m_charactersLength; // Marks the end of the characters buffer. Default equals to m_len. 238 unsigned m_len; 239 240 // m_xpos is the x position relative to the left start of the text line, not relative to the left 241 // start of the containing block. In the case of right alignment or center alignment, left start of 242 // the text line is not the same as left start of the containing block. 243 float m_xpos; 244 float m_horizontalGlyphStretch; 245 246 float m_expansion; 247 ExpansionBehavior m_expansionBehavior : 2; 248 unsigned m_is8Bit : 1; 249 unsigned m_allowTabs : 1; 250 unsigned m_direction : 1; 251 unsigned m_directionalOverride : 1; // Was this direction set by an override character. 252 unsigned m_characterScanForCodePath : 1; 253 unsigned m_applyRunRounding : 1; 254 unsigned m_applyWordRounding : 1; 255 unsigned m_disableSpacing : 1; 256 unsigned m_tabSize; 257 RefPtr<RenderingContext> m_renderingContext; 258 }; 259 260 inline void TextRun::setTabSize(bool allow, unsigned size) 261 { 262 m_allowTabs = allow; 263 m_tabSize = size; 264 } 265 266 // Container for parameters needed to paint TextRun. 267 struct TextRunPaintInfo { 268 explicit TextRunPaintInfo(const TextRun& r) 269 : run(r) 270 , from(0) 271 , to(r.length()) 272 { 273 } 274 275 const TextRun& run; 276 int from; 277 int to; 278 FloatRect bounds; 279 }; 280 281 } 282 #endif 283