| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/gfx/render_text_harfbuzz.h" | |
| 6 | |
| 7 #include <limits> | |
| 8 #include <map> | |
| 9 | |
| 10 #include "base/i18n/bidi_line_iterator.h" | |
| 11 #include "base/i18n/break_iterator.h" | |
| 12 #include "base/i18n/char_iterator.h" | |
| 13 #include "base/lazy_instance.h" | |
| 14 #include "third_party/harfbuzz-ng/src/hb.h" | |
| 15 #include "third_party/icu/source/common/unicode/ubidi.h" | |
| 16 #include "third_party/skia/include/core/SkColor.h" | |
| 17 #include "third_party/skia/include/core/SkTypeface.h" | |
| 18 #include "ui/gfx/canvas.h" | |
| 19 #include "ui/gfx/font_fallback.h" | |
| 20 #include "ui/gfx/font_render_params.h" | |
| 21 #include "ui/gfx/utf16_indexing.h" | |
| 22 | |
| 23 #if defined(OS_WIN) | |
| 24 #include "ui/gfx/font_fallback_win.h" | |
| 25 #endif | |
| 26 | |
| 27 namespace gfx { | |
| 28 | |
| 29 namespace { | |
| 30 | |
| 31 // Text length limit. Longer strings are slow and not fully tested. | |
| 32 const size_t kMaxTextLength = 10000; | |
| 33 | |
| 34 // The maximum number of scripts a Unicode character can belong to. This value | |
| 35 // is arbitrarily chosen to be a good limit because it is unlikely for a single | |
| 36 // character to belong to more scripts. | |
| 37 const size_t kMaxScripts = 5; | |
| 38 | |
| 39 // Maps from code points to glyph indices in a font. | |
| 40 typedef std::map<uint32_t, uint16_t> GlyphCache; | |
| 41 | |
| 42 // Font data provider for HarfBuzz using Skia. Copied from Blink. | |
| 43 // TODO(ckocagil): Eliminate the duplication. http://crbug.com/368375 | |
| 44 struct FontData { | |
| 45 FontData(GlyphCache* glyph_cache) : glyph_cache_(glyph_cache) {} | |
| 46 | |
| 47 SkPaint paint_; | |
| 48 GlyphCache* glyph_cache_; | |
| 49 }; | |
| 50 | |
| 51 hb_position_t SkiaScalarToHarfBuzzPosition(SkScalar value) { | |
| 52 return SkScalarToFixed(value); | |
| 53 } | |
| 54 | |
| 55 // Deletes the object at the given pointer after casting it to the given type. | |
| 56 template<typename Type> | |
| 57 void DeleteByType(void* data) { | |
| 58 Type* typed_data = reinterpret_cast<Type*>(data); | |
| 59 delete typed_data; | |
| 60 } | |
| 61 | |
| 62 template<typename Type> | |
| 63 void DeleteArrayByType(void* data) { | |
| 64 Type* typed_data = reinterpret_cast<Type*>(data); | |
| 65 delete[] typed_data; | |
| 66 } | |
| 67 | |
| 68 // Outputs the |width| and |extents| of the glyph with index |codepoint| in | |
| 69 // |paint|'s font. | |
| 70 void GetGlyphWidthAndExtents(SkPaint* paint, | |
| 71 hb_codepoint_t codepoint, | |
| 72 hb_position_t* width, | |
| 73 hb_glyph_extents_t* extents) { | |
| 74 DCHECK_LE(codepoint, 0xFFFFU); | |
| 75 paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); | |
| 76 | |
| 77 SkScalar sk_width; | |
| 78 SkRect sk_bounds; | |
| 79 uint16_t glyph = codepoint; | |
| 80 | |
| 81 paint->getTextWidths(&glyph, sizeof(glyph), &sk_width, &sk_bounds); | |
| 82 if (width) | |
| 83 *width = SkiaScalarToHarfBuzzPosition(sk_width); | |
| 84 if (extents) { | |
| 85 // Invert y-axis because Skia is y-grows-down but we set up HarfBuzz to be | |
| 86 // y-grows-up. | |
| 87 extents->x_bearing = SkiaScalarToHarfBuzzPosition(sk_bounds.fLeft); | |
| 88 extents->y_bearing = SkiaScalarToHarfBuzzPosition(-sk_bounds.fTop); | |
| 89 extents->width = SkiaScalarToHarfBuzzPosition(sk_bounds.width()); | |
| 90 extents->height = SkiaScalarToHarfBuzzPosition(-sk_bounds.height()); | |
| 91 } | |
| 92 } | |
| 93 | |
| 94 // Writes the |glyph| index for the given |unicode| code point. Returns whether | |
| 95 // the glyph exists, i.e. it is not a missing glyph. | |
| 96 hb_bool_t GetGlyph(hb_font_t* font, | |
| 97 void* data, | |
| 98 hb_codepoint_t unicode, | |
| 99 hb_codepoint_t variation_selector, | |
| 100 hb_codepoint_t* glyph, | |
| 101 void* user_data) { | |
| 102 FontData* font_data = reinterpret_cast<FontData*>(data); | |
| 103 GlyphCache* cache = font_data->glyph_cache_; | |
| 104 | |
| 105 bool exists = cache->count(unicode) != 0; | |
| 106 if (!exists) { | |
| 107 SkPaint* paint = &font_data->paint_; | |
| 108 paint->setTextEncoding(SkPaint::kUTF32_TextEncoding); | |
| 109 paint->textToGlyphs(&unicode, sizeof(hb_codepoint_t), &(*cache)[unicode]); | |
| 110 } | |
| 111 *glyph = (*cache)[unicode]; | |
| 112 return !!*glyph; | |
| 113 } | |
| 114 | |
| 115 // Returns the horizontal advance value of the |glyph|. | |
| 116 hb_position_t GetGlyphHorizontalAdvance(hb_font_t* font, | |
| 117 void* data, | |
| 118 hb_codepoint_t glyph, | |
| 119 void* user_data) { | |
| 120 FontData* font_data = reinterpret_cast<FontData*>(data); | |
| 121 hb_position_t advance = 0; | |
| 122 | |
| 123 GetGlyphWidthAndExtents(&font_data->paint_, glyph, &advance, 0); | |
| 124 return advance; | |
| 125 } | |
| 126 | |
| 127 hb_bool_t GetGlyphHorizontalOrigin(hb_font_t* font, | |
| 128 void* data, | |
| 129 hb_codepoint_t glyph, | |
| 130 hb_position_t* x, | |
| 131 hb_position_t* y, | |
| 132 void* user_data) { | |
| 133 // Just return true, like the HarfBuzz-FreeType implementation. | |
| 134 return true; | |
| 135 } | |
| 136 | |
| 137 hb_position_t GetGlyphKerning(FontData* font_data, | |
| 138 hb_codepoint_t first_glyph, | |
| 139 hb_codepoint_t second_glyph) { | |
| 140 SkTypeface* typeface = font_data->paint_.getTypeface(); | |
| 141 const uint16_t glyphs[2] = { static_cast<uint16_t>(first_glyph), | |
| 142 static_cast<uint16_t>(second_glyph) }; | |
| 143 int32_t kerning_adjustments[1] = { 0 }; | |
| 144 | |
| 145 if (!typeface->getKerningPairAdjustments(glyphs, 2, kerning_adjustments)) | |
| 146 return 0; | |
| 147 | |
| 148 SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm()); | |
| 149 SkScalar size = font_data->paint_.getTextSize(); | |
| 150 return SkiaScalarToHarfBuzzPosition( | |
| 151 SkScalarMulDiv(SkIntToScalar(kerning_adjustments[0]), size, upm)); | |
| 152 } | |
| 153 | |
| 154 hb_position_t GetGlyphHorizontalKerning(hb_font_t* font, | |
| 155 void* data, | |
| 156 hb_codepoint_t left_glyph, | |
| 157 hb_codepoint_t right_glyph, | |
| 158 void* user_data) { | |
| 159 FontData* font_data = reinterpret_cast<FontData*>(data); | |
| 160 if (font_data->paint_.isVerticalText()) { | |
| 161 // We don't support cross-stream kerning. | |
| 162 return 0; | |
| 163 } | |
| 164 | |
| 165 return GetGlyphKerning(font_data, left_glyph, right_glyph); | |
| 166 } | |
| 167 | |
| 168 hb_position_t GetGlyphVerticalKerning(hb_font_t* font, | |
| 169 void* data, | |
| 170 hb_codepoint_t top_glyph, | |
| 171 hb_codepoint_t bottom_glyph, | |
| 172 void* user_data) { | |
| 173 FontData* font_data = reinterpret_cast<FontData*>(data); | |
| 174 if (!font_data->paint_.isVerticalText()) { | |
| 175 // We don't support cross-stream kerning. | |
| 176 return 0; | |
| 177 } | |
| 178 | |
| 179 return GetGlyphKerning(font_data, top_glyph, bottom_glyph); | |
| 180 } | |
| 181 | |
| 182 // Writes the |extents| of |glyph|. | |
| 183 hb_bool_t GetGlyphExtents(hb_font_t* font, | |
| 184 void* data, | |
| 185 hb_codepoint_t glyph, | |
| 186 hb_glyph_extents_t* extents, | |
| 187 void* user_data) { | |
| 188 FontData* font_data = reinterpret_cast<FontData*>(data); | |
| 189 | |
| 190 GetGlyphWidthAndExtents(&font_data->paint_, glyph, 0, extents); | |
| 191 return true; | |
| 192 } | |
| 193 | |
| 194 class FontFuncs { | |
| 195 public: | |
| 196 FontFuncs() : font_funcs_(hb_font_funcs_create()) { | |
| 197 hb_font_funcs_set_glyph_func(font_funcs_, GetGlyph, 0, 0); | |
| 198 hb_font_funcs_set_glyph_h_advance_func( | |
| 199 font_funcs_, GetGlyphHorizontalAdvance, 0, 0); | |
| 200 hb_font_funcs_set_glyph_h_kerning_func( | |
| 201 font_funcs_, GetGlyphHorizontalKerning, 0, 0); | |
| 202 hb_font_funcs_set_glyph_h_origin_func( | |
| 203 font_funcs_, GetGlyphHorizontalOrigin, 0, 0); | |
| 204 hb_font_funcs_set_glyph_v_kerning_func( | |
| 205 font_funcs_, GetGlyphVerticalKerning, 0, 0); | |
| 206 hb_font_funcs_set_glyph_extents_func( | |
| 207 font_funcs_, GetGlyphExtents, 0, 0); | |
| 208 hb_font_funcs_make_immutable(font_funcs_); | |
| 209 } | |
| 210 | |
| 211 ~FontFuncs() { | |
| 212 hb_font_funcs_destroy(font_funcs_); | |
| 213 } | |
| 214 | |
| 215 hb_font_funcs_t* get() { return font_funcs_; } | |
| 216 | |
| 217 private: | |
| 218 hb_font_funcs_t* font_funcs_; | |
| 219 | |
| 220 DISALLOW_COPY_AND_ASSIGN(FontFuncs); | |
| 221 }; | |
| 222 | |
| 223 base::LazyInstance<FontFuncs>::Leaky g_font_funcs = LAZY_INSTANCE_INITIALIZER; | |
| 224 | |
| 225 // Returns the raw data of the font table |tag|. | |
| 226 hb_blob_t* GetFontTable(hb_face_t* face, hb_tag_t tag, void* user_data) { | |
| 227 SkTypeface* typeface = reinterpret_cast<SkTypeface*>(user_data); | |
| 228 | |
| 229 const size_t table_size = typeface->getTableSize(tag); | |
| 230 if (!table_size) | |
| 231 return 0; | |
| 232 | |
| 233 scoped_ptr<char[]> buffer(new char[table_size]); | |
| 234 if (!buffer) | |
| 235 return 0; | |
| 236 size_t actual_size = typeface->getTableData(tag, 0, table_size, buffer.get()); | |
| 237 if (table_size != actual_size) | |
| 238 return 0; | |
| 239 | |
| 240 char* buffer_raw = buffer.release(); | |
| 241 return hb_blob_create(buffer_raw, table_size, HB_MEMORY_MODE_WRITABLE, | |
| 242 buffer_raw, DeleteArrayByType<char>); | |
| 243 } | |
| 244 | |
| 245 void UnrefSkTypeface(void* data) { | |
| 246 SkTypeface* skia_face = reinterpret_cast<SkTypeface*>(data); | |
| 247 SkSafeUnref(skia_face); | |
| 248 } | |
| 249 | |
| 250 // Wrapper class for a HarfBuzz face created from a given Skia face. | |
| 251 class HarfBuzzFace { | |
| 252 public: | |
| 253 HarfBuzzFace() : face_(NULL) {} | |
| 254 | |
| 255 ~HarfBuzzFace() { | |
| 256 if (face_) | |
| 257 hb_face_destroy(face_); | |
| 258 } | |
| 259 | |
| 260 void Init(SkTypeface* skia_face) { | |
| 261 SkSafeRef(skia_face); | |
| 262 face_ = hb_face_create_for_tables(GetFontTable, skia_face, UnrefSkTypeface); | |
| 263 DCHECK(face_); | |
| 264 } | |
| 265 | |
| 266 hb_face_t* get() { | |
| 267 return face_; | |
| 268 } | |
| 269 | |
| 270 private: | |
| 271 hb_face_t* face_; | |
| 272 }; | |
| 273 | |
| 274 // Creates a HarfBuzz font from the given Skia face and text size. | |
| 275 hb_font_t* CreateHarfBuzzFont(SkTypeface* skia_face, | |
| 276 int text_size, | |
| 277 const FontRenderParams& params, | |
| 278 bool background_is_transparent) { | |
| 279 typedef std::pair<HarfBuzzFace, GlyphCache> FaceCache; | |
| 280 | |
| 281 // TODO(ckocagil): This shouldn't grow indefinitely. Maybe use base::MRUCache? | |
| 282 static std::map<SkFontID, FaceCache> face_caches; | |
| 283 | |
| 284 FaceCache* face_cache = &face_caches[skia_face->uniqueID()]; | |
| 285 if (face_cache->first.get() == NULL) | |
| 286 face_cache->first.Init(skia_face); | |
| 287 | |
| 288 hb_font_t* harfbuzz_font = hb_font_create(face_cache->first.get()); | |
| 289 const int scale = SkScalarToFixed(text_size); | |
| 290 hb_font_set_scale(harfbuzz_font, scale, scale); | |
| 291 FontData* hb_font_data = new FontData(&face_cache->second); | |
| 292 hb_font_data->paint_.setTypeface(skia_face); | |
| 293 hb_font_data->paint_.setTextSize(text_size); | |
| 294 // TODO(ckocagil): Do we need to update these params later? | |
| 295 internal::ApplyRenderParams(params, background_is_transparent, | |
| 296 &hb_font_data->paint_); | |
| 297 hb_font_set_funcs(harfbuzz_font, g_font_funcs.Get().get(), hb_font_data, | |
| 298 DeleteByType<FontData>); | |
| 299 hb_font_make_immutable(harfbuzz_font); | |
| 300 return harfbuzz_font; | |
| 301 } | |
| 302 | |
| 303 // Returns true if characters of |block_code| may trigger font fallback. | |
| 304 bool IsUnusualBlockCode(UBlockCode block_code) { | |
| 305 return block_code == UBLOCK_GEOMETRIC_SHAPES || | |
| 306 block_code == UBLOCK_MISCELLANEOUS_SYMBOLS; | |
| 307 } | |
| 308 | |
| 309 bool IsBracket(UChar32 character) { | |
| 310 static const char kBrackets[] = { '(', ')', '{', '}', '<', '>', }; | |
| 311 static const char* kBracketsEnd = kBrackets + arraysize(kBrackets); | |
| 312 return std::find(kBrackets, kBracketsEnd, character) != kBracketsEnd; | |
| 313 } | |
| 314 | |
| 315 // Returns the boundary between a special and a regular character. Special | |
| 316 // characters are brackets or characters that satisfy |IsUnusualBlockCode|. | |
| 317 size_t FindRunBreakingCharacter(const base::string16& text, | |
| 318 size_t run_start, | |
| 319 size_t run_break) { | |
| 320 const int32 run_length = static_cast<int32>(run_break - run_start); | |
| 321 base::i18n::UTF16CharIterator iter(text.c_str() + run_start, run_length); | |
| 322 const UChar32 first_char = iter.get(); | |
| 323 const UBlockCode first_block = ublock_getCode(first_char); | |
| 324 const bool first_block_unusual = IsUnusualBlockCode(first_block); | |
| 325 const bool first_bracket = IsBracket(first_char); | |
| 326 | |
| 327 while (iter.Advance() && iter.array_pos() < run_length) { | |
| 328 const UChar32 current_char = iter.get(); | |
| 329 const UBlockCode current_block = ublock_getCode(current_char); | |
| 330 const bool block_break = current_block != first_block && | |
| 331 (first_block_unusual || IsUnusualBlockCode(current_block)); | |
| 332 if (block_break || first_bracket != IsBracket(current_char)) | |
| 333 return run_start + iter.array_pos(); | |
| 334 } | |
| 335 return run_break; | |
| 336 } | |
| 337 | |
| 338 // If the given scripts match, returns the one that isn't USCRIPT_COMMON or | |
| 339 // USCRIPT_INHERITED, i.e. the more specific one. Otherwise returns | |
| 340 // USCRIPT_INVALID_CODE. | |
| 341 UScriptCode ScriptIntersect(UScriptCode first, UScriptCode second) { | |
| 342 if (first == second || | |
| 343 (second > USCRIPT_INVALID_CODE && second <= USCRIPT_INHERITED)) { | |
| 344 return first; | |
| 345 } | |
| 346 if (first > USCRIPT_INVALID_CODE && first <= USCRIPT_INHERITED) | |
| 347 return second; | |
| 348 return USCRIPT_INVALID_CODE; | |
| 349 } | |
| 350 | |
| 351 // Writes the script and the script extensions of the character with the | |
| 352 // Unicode |codepoint|. Returns the number of written scripts. | |
| 353 int GetScriptExtensions(UChar32 codepoint, UScriptCode* scripts) { | |
| 354 UErrorCode icu_error = U_ZERO_ERROR; | |
| 355 // ICU documentation incorrectly states that the result of | |
| 356 // |uscript_getScriptExtensions| will contain the regular script property. | |
| 357 // Write the character's script property to the first element. | |
| 358 scripts[0] = uscript_getScript(codepoint, &icu_error); | |
| 359 if (U_FAILURE(icu_error)) | |
| 360 return 0; | |
| 361 // Fill the rest of |scripts| with the extensions. | |
| 362 int count = uscript_getScriptExtensions(codepoint, scripts + 1, | |
| 363 kMaxScripts - 1, &icu_error); | |
| 364 if (U_FAILURE(icu_error)) | |
| 365 count = 0; | |
| 366 return count + 1; | |
| 367 } | |
| 368 | |
| 369 // Intersects the script extensions set of |codepoint| with |result| and writes | |
| 370 // to |result|, reading and updating |result_size|. | |
| 371 void ScriptSetIntersect(UChar32 codepoint, | |
| 372 UScriptCode* result, | |
| 373 size_t* result_size) { | |
| 374 UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE }; | |
| 375 int count = GetScriptExtensions(codepoint, scripts); | |
| 376 | |
| 377 size_t out_size = 0; | |
| 378 | |
| 379 for (size_t i = 0; i < *result_size; ++i) { | |
| 380 for (int j = 0; j < count; ++j) { | |
| 381 UScriptCode intersection = ScriptIntersect(result[i], scripts[j]); | |
| 382 if (intersection != USCRIPT_INVALID_CODE) { | |
| 383 result[out_size++] = intersection; | |
| 384 break; | |
| 385 } | |
| 386 } | |
| 387 } | |
| 388 | |
| 389 *result_size = out_size; | |
| 390 } | |
| 391 | |
| 392 // Find the longest sequence of characters from 0 and up to |length| that | |
| 393 // have at least one common UScriptCode value. Writes the common script value to | |
| 394 // |script| and returns the length of the sequence. Takes the characters' script | |
| 395 // extensions into account. http://www.unicode.org/reports/tr24/#ScriptX | |
| 396 // | |
| 397 // Consider 3 characters with the script values {Kana}, {Hira, Kana}, {Kana}. | |
| 398 // Without script extensions only the first script in each set would be taken | |
| 399 // into account, resulting in 3 runs where 1 would be enough. | |
| 400 // TODO(ckocagil): Write a unit test for the case above. | |
| 401 int ScriptInterval(const base::string16& text, | |
| 402 size_t start, | |
| 403 size_t length, | |
| 404 UScriptCode* script) { | |
| 405 DCHECK_GT(length, 0U); | |
| 406 | |
| 407 UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE }; | |
| 408 | |
| 409 base::i18n::UTF16CharIterator char_iterator(text.c_str() + start, length); | |
| 410 size_t scripts_size = GetScriptExtensions(char_iterator.get(), scripts); | |
| 411 *script = scripts[0]; | |
| 412 | |
| 413 while (char_iterator.Advance()) { | |
| 414 ScriptSetIntersect(char_iterator.get(), scripts, &scripts_size); | |
| 415 if (scripts_size == 0U) | |
| 416 return char_iterator.array_pos(); | |
| 417 *script = scripts[0]; | |
| 418 } | |
| 419 | |
| 420 return length; | |
| 421 } | |
| 422 | |
| 423 // A port of hb_icu_script_to_script because harfbuzz on CrOS is built without | |
| 424 // hb-icu. See http://crbug.com/356929 | |
| 425 inline hb_script_t ICUScriptToHBScript(UScriptCode script) { | |
| 426 if (script == USCRIPT_INVALID_CODE) | |
| 427 return HB_SCRIPT_INVALID; | |
| 428 return hb_script_from_string(uscript_getShortName(script), -1); | |
| 429 } | |
| 430 | |
| 431 // Helper template function for |TextRunHarfBuzz::GetClusterAt()|. |Iterator| | |
| 432 // can be a forward or reverse iterator type depending on the text direction. | |
| 433 template <class Iterator> | |
| 434 void GetClusterAtImpl(size_t pos, | |
| 435 Range range, | |
| 436 Iterator elements_begin, | |
| 437 Iterator elements_end, | |
| 438 bool reversed, | |
| 439 Range* chars, | |
| 440 Range* glyphs) { | |
| 441 Iterator element = std::upper_bound(elements_begin, elements_end, pos); | |
| 442 chars->set_end(element == elements_end ? range.end() : *element); | |
| 443 glyphs->set_end(reversed ? elements_end - element : element - elements_begin); | |
| 444 | |
| 445 DCHECK(element != elements_begin); | |
| 446 while (--element != elements_begin && *element == *(element - 1)); | |
| 447 chars->set_start(*element); | |
| 448 glyphs->set_start( | |
| 449 reversed ? elements_end - element : element - elements_begin); | |
| 450 if (reversed) | |
| 451 *glyphs = Range(glyphs->end(), glyphs->start()); | |
| 452 | |
| 453 DCHECK(!chars->is_reversed()); | |
| 454 DCHECK(!chars->is_empty()); | |
| 455 DCHECK(!glyphs->is_reversed()); | |
| 456 DCHECK(!glyphs->is_empty()); | |
| 457 } | |
| 458 | |
| 459 } // namespace | |
| 460 | |
| 461 namespace internal { | |
| 462 | |
| 463 TextRunHarfBuzz::TextRunHarfBuzz() | |
| 464 : width(0.0f), | |
| 465 preceding_run_widths(0.0f), | |
| 466 is_rtl(false), | |
| 467 level(0), | |
| 468 script(USCRIPT_INVALID_CODE), | |
| 469 glyph_count(static_cast<size_t>(-1)), | |
| 470 font_size(0), | |
| 471 font_style(0), | |
| 472 strike(false), | |
| 473 diagonal_strike(false), | |
| 474 underline(false) {} | |
| 475 | |
| 476 TextRunHarfBuzz::~TextRunHarfBuzz() {} | |
| 477 | |
| 478 void TextRunHarfBuzz::GetClusterAt(size_t pos, | |
| 479 Range* chars, | |
| 480 Range* glyphs) const { | |
| 481 DCHECK(range.Contains(Range(pos, pos + 1))); | |
| 482 DCHECK(chars); | |
| 483 DCHECK(glyphs); | |
| 484 | |
| 485 if (glyph_count == 0) { | |
| 486 *chars = range; | |
| 487 *glyphs = Range(); | |
| 488 return; | |
| 489 } | |
| 490 | |
| 491 if (is_rtl) { | |
| 492 GetClusterAtImpl(pos, range, glyph_to_char.rbegin(), glyph_to_char.rend(), | |
| 493 true, chars, glyphs); | |
| 494 return; | |
| 495 } | |
| 496 | |
| 497 GetClusterAtImpl(pos, range, glyph_to_char.begin(), glyph_to_char.end(), | |
| 498 false, chars, glyphs); | |
| 499 } | |
| 500 | |
| 501 Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& char_range) const { | |
| 502 DCHECK(range.Contains(char_range)); | |
| 503 DCHECK(!char_range.is_reversed()); | |
| 504 DCHECK(!char_range.is_empty()); | |
| 505 | |
| 506 Range start_glyphs; | |
| 507 Range end_glyphs; | |
| 508 Range temp_range; | |
| 509 GetClusterAt(char_range.start(), &temp_range, &start_glyphs); | |
| 510 GetClusterAt(char_range.end() - 1, &temp_range, &end_glyphs); | |
| 511 | |
| 512 return is_rtl ? Range(end_glyphs.start(), start_glyphs.end()) : | |
| 513 Range(start_glyphs.start(), end_glyphs.end()); | |
| 514 } | |
| 515 | |
| 516 size_t TextRunHarfBuzz::CountMissingGlyphs() const { | |
| 517 static const int kMissingGlyphId = 0; | |
| 518 size_t missing = 0; | |
| 519 for (size_t i = 0; i < glyph_count; ++i) | |
| 520 missing += (glyphs[i] == kMissingGlyphId) ? 1 : 0; | |
| 521 return missing; | |
| 522 } | |
| 523 | |
| 524 Range TextRunHarfBuzz::GetGraphemeBounds( | |
| 525 base::i18n::BreakIterator* grapheme_iterator, | |
| 526 size_t text_index) { | |
| 527 DCHECK_LT(text_index, range.end()); | |
| 528 // TODO(msw): Support floating point grapheme bounds. | |
| 529 const int preceding_run_widths_int = SkScalarRoundToInt(preceding_run_widths); | |
| 530 if (glyph_count == 0) | |
| 531 return Range(preceding_run_widths_int, preceding_run_widths_int + width); | |
| 532 | |
| 533 Range chars; | |
| 534 Range glyphs; | |
| 535 GetClusterAt(text_index, &chars, &glyphs); | |
| 536 const int cluster_begin_x = SkScalarRoundToInt(positions[glyphs.start()].x()); | |
| 537 const int cluster_end_x = glyphs.end() < glyph_count ? | |
| 538 SkScalarRoundToInt(positions[glyphs.end()].x()) : width; | |
| 539 | |
| 540 // A cluster consists of a number of code points and corresponds to a number | |
| 541 // of glyphs that should be drawn together. A cluster can contain multiple | |
| 542 // graphemes. In order to place the cursor at a grapheme boundary inside the | |
| 543 // cluster, we simply divide the cluster width by the number of graphemes. | |
| 544 if (chars.length() > 1 && grapheme_iterator) { | |
| 545 int before = 0; | |
| 546 int total = 0; | |
| 547 for (size_t i = chars.start(); i < chars.end(); ++i) { | |
| 548 if (grapheme_iterator->IsGraphemeBoundary(i)) { | |
| 549 if (i < text_index) | |
| 550 ++before; | |
| 551 ++total; | |
| 552 } | |
| 553 } | |
| 554 DCHECK_GT(total, 0); | |
| 555 if (total > 1) { | |
| 556 if (is_rtl) | |
| 557 before = total - before - 1; | |
| 558 DCHECK_GE(before, 0); | |
| 559 DCHECK_LT(before, total); | |
| 560 const int cluster_width = cluster_end_x - cluster_begin_x; | |
| 561 const int grapheme_begin_x = cluster_begin_x + static_cast<int>(0.5f + | |
| 562 cluster_width * before / static_cast<float>(total)); | |
| 563 const int grapheme_end_x = cluster_begin_x + static_cast<int>(0.5f + | |
| 564 cluster_width * (before + 1) / static_cast<float>(total)); | |
| 565 return Range(preceding_run_widths_int + grapheme_begin_x, | |
| 566 preceding_run_widths_int + grapheme_end_x); | |
| 567 } | |
| 568 } | |
| 569 | |
| 570 return Range(preceding_run_widths_int + cluster_begin_x, | |
| 571 preceding_run_widths_int + cluster_end_x); | |
| 572 } | |
| 573 | |
| 574 } // namespace internal | |
| 575 | |
| 576 RenderTextHarfBuzz::RenderTextHarfBuzz() | |
| 577 : RenderText(), | |
| 578 needs_layout_(false) { | |
| 579 set_truncate_length(kMaxTextLength); | |
| 580 } | |
| 581 | |
| 582 RenderTextHarfBuzz::~RenderTextHarfBuzz() {} | |
| 583 | |
| 584 Size RenderTextHarfBuzz::GetStringSize() { | |
| 585 const SizeF size_f = GetStringSizeF(); | |
| 586 return Size(std::ceil(size_f.width()), size_f.height()); | |
| 587 } | |
| 588 | |
| 589 SizeF RenderTextHarfBuzz::GetStringSizeF() { | |
| 590 EnsureLayout(); | |
| 591 return lines()[0].size; | |
| 592 } | |
| 593 | |
| 594 SelectionModel RenderTextHarfBuzz::FindCursorPosition(const Point& point) { | |
| 595 EnsureLayout(); | |
| 596 | |
| 597 int x = ToTextPoint(point).x(); | |
| 598 int offset = 0; | |
| 599 size_t run_index = GetRunContainingXCoord(x, &offset); | |
| 600 if (run_index >= runs_.size()) | |
| 601 return EdgeSelectionModel((x < 0) ? CURSOR_LEFT : CURSOR_RIGHT); | |
| 602 const internal::TextRunHarfBuzz& run = *runs_[run_index]; | |
| 603 | |
| 604 for (size_t i = 0; i < run.glyph_count; ++i) { | |
| 605 const SkScalar end = | |
| 606 i + 1 == run.glyph_count ? run.width : run.positions[i + 1].x(); | |
| 607 const SkScalar middle = (end + run.positions[i].x()) / 2; | |
| 608 | |
| 609 if (offset < middle) { | |
| 610 return SelectionModel(LayoutIndexToTextIndex( | |
| 611 run.glyph_to_char[i] + (run.is_rtl ? 1 : 0)), | |
| 612 (run.is_rtl ? CURSOR_BACKWARD : CURSOR_FORWARD)); | |
| 613 } | |
| 614 if (offset < end) { | |
| 615 return SelectionModel(LayoutIndexToTextIndex( | |
| 616 run.glyph_to_char[i] + (run.is_rtl ? 0 : 1)), | |
| 617 (run.is_rtl ? CURSOR_FORWARD : CURSOR_BACKWARD)); | |
| 618 } | |
| 619 } | |
| 620 return EdgeSelectionModel(CURSOR_RIGHT); | |
| 621 } | |
| 622 | |
| 623 std::vector<RenderText::FontSpan> RenderTextHarfBuzz::GetFontSpansForTesting() { | |
| 624 EnsureLayout(); | |
| 625 | |
| 626 std::vector<RenderText::FontSpan> spans; | |
| 627 for (size_t i = 0; i < runs_.size(); ++i) { | |
| 628 SkString family_name; | |
| 629 runs_[i]->skia_face->getFamilyName(&family_name); | |
| 630 Font font(family_name.c_str(), runs_[i]->font_size); | |
| 631 spans.push_back(RenderText::FontSpan(font, | |
| 632 Range(LayoutIndexToTextIndex(runs_[i]->range.start()), | |
| 633 LayoutIndexToTextIndex(runs_[i]->range.end())))); | |
| 634 } | |
| 635 | |
| 636 return spans; | |
| 637 } | |
| 638 | |
| 639 Range RenderTextHarfBuzz::GetGlyphBounds(size_t index) { | |
| 640 EnsureLayout(); | |
| 641 const size_t run_index = | |
| 642 GetRunContainingCaret(SelectionModel(index, CURSOR_FORWARD)); | |
| 643 // Return edge bounds if the index is invalid or beyond the layout text size. | |
| 644 if (run_index >= runs_.size()) | |
| 645 return Range(GetStringSize().width()); | |
| 646 const size_t layout_index = TextIndexToLayoutIndex(index); | |
| 647 internal::TextRunHarfBuzz* run = runs_[run_index]; | |
| 648 Range bounds = run->GetGraphemeBounds(grapheme_iterator_.get(), layout_index); | |
| 649 return run->is_rtl ? Range(bounds.end(), bounds.start()) : bounds; | |
| 650 } | |
| 651 | |
| 652 int RenderTextHarfBuzz::GetLayoutTextBaseline() { | |
| 653 EnsureLayout(); | |
| 654 return lines()[0].baseline; | |
| 655 } | |
| 656 | |
| 657 SelectionModel RenderTextHarfBuzz::AdjacentCharSelectionModel( | |
| 658 const SelectionModel& selection, | |
| 659 VisualCursorDirection direction) { | |
| 660 DCHECK(!needs_layout_); | |
| 661 internal::TextRunHarfBuzz* run; | |
| 662 size_t run_index = GetRunContainingCaret(selection); | |
| 663 if (run_index >= runs_.size()) { | |
| 664 // The cursor is not in any run: we're at the visual and logical edge. | |
| 665 SelectionModel edge = EdgeSelectionModel(direction); | |
| 666 if (edge.caret_pos() == selection.caret_pos()) | |
| 667 return edge; | |
| 668 int visual_index = (direction == CURSOR_RIGHT) ? 0 : runs_.size() - 1; | |
| 669 run = runs_[visual_to_logical_[visual_index]]; | |
| 670 } else { | |
| 671 // If the cursor is moving within the current run, just move it by one | |
| 672 // grapheme in the appropriate direction. | |
| 673 run = runs_[run_index]; | |
| 674 size_t caret = selection.caret_pos(); | |
| 675 bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT); | |
| 676 if (forward_motion) { | |
| 677 if (caret < LayoutIndexToTextIndex(run->range.end())) { | |
| 678 caret = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD); | |
| 679 return SelectionModel(caret, CURSOR_BACKWARD); | |
| 680 } | |
| 681 } else { | |
| 682 if (caret > LayoutIndexToTextIndex(run->range.start())) { | |
| 683 caret = IndexOfAdjacentGrapheme(caret, CURSOR_BACKWARD); | |
| 684 return SelectionModel(caret, CURSOR_FORWARD); | |
| 685 } | |
| 686 } | |
| 687 // The cursor is at the edge of a run; move to the visually adjacent run. | |
| 688 int visual_index = logical_to_visual_[run_index]; | |
| 689 visual_index += (direction == CURSOR_LEFT) ? -1 : 1; | |
| 690 if (visual_index < 0 || visual_index >= static_cast<int>(runs_.size())) | |
| 691 return EdgeSelectionModel(direction); | |
| 692 run = runs_[visual_to_logical_[visual_index]]; | |
| 693 } | |
| 694 bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT); | |
| 695 return forward_motion ? FirstSelectionModelInsideRun(run) : | |
| 696 LastSelectionModelInsideRun(run); | |
| 697 } | |
| 698 | |
| 699 SelectionModel RenderTextHarfBuzz::AdjacentWordSelectionModel( | |
| 700 const SelectionModel& selection, | |
| 701 VisualCursorDirection direction) { | |
| 702 if (obscured()) | |
| 703 return EdgeSelectionModel(direction); | |
| 704 | |
| 705 base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD); | |
| 706 bool success = iter.Init(); | |
| 707 DCHECK(success); | |
| 708 if (!success) | |
| 709 return selection; | |
| 710 | |
| 711 // Match OS specific word break behavior. | |
| 712 #if defined(OS_WIN) | |
| 713 size_t pos; | |
| 714 if (direction == CURSOR_RIGHT) { | |
| 715 pos = std::min(selection.caret_pos() + 1, text().length()); | |
| 716 while (iter.Advance()) { | |
| 717 pos = iter.pos(); | |
| 718 if (iter.IsWord() && pos > selection.caret_pos()) | |
| 719 break; | |
| 720 } | |
| 721 } else { // direction == CURSOR_LEFT | |
| 722 // Notes: We always iterate words from the beginning. | |
| 723 // This is probably fast enough for our usage, but we may | |
| 724 // want to modify WordIterator so that it can start from the | |
| 725 // middle of string and advance backwards. | |
| 726 pos = std::max<int>(selection.caret_pos() - 1, 0); | |
| 727 while (iter.Advance()) { | |
| 728 if (iter.IsWord()) { | |
| 729 size_t begin = iter.pos() - iter.GetString().length(); | |
| 730 if (begin == selection.caret_pos()) { | |
| 731 // The cursor is at the beginning of a word. | |
| 732 // Move to previous word. | |
| 733 break; | |
| 734 } else if (iter.pos() >= selection.caret_pos()) { | |
| 735 // The cursor is in the middle or at the end of a word. | |
| 736 // Move to the top of current word. | |
| 737 pos = begin; | |
| 738 break; | |
| 739 } | |
| 740 pos = iter.pos() - iter.GetString().length(); | |
| 741 } | |
| 742 } | |
| 743 } | |
| 744 return SelectionModel(pos, CURSOR_FORWARD); | |
| 745 #else | |
| 746 SelectionModel cur(selection); | |
| 747 for (;;) { | |
| 748 cur = AdjacentCharSelectionModel(cur, direction); | |
| 749 size_t run = GetRunContainingCaret(cur); | |
| 750 if (run == runs_.size()) | |
| 751 break; | |
| 752 const bool is_forward = runs_[run]->is_rtl == (direction == CURSOR_LEFT); | |
| 753 size_t cursor = cur.caret_pos(); | |
| 754 if (is_forward ? iter.IsEndOfWord(cursor) : iter.IsStartOfWord(cursor)) | |
| 755 break; | |
| 756 } | |
| 757 return cur; | |
| 758 #endif | |
| 759 } | |
| 760 | |
| 761 std::vector<Rect> RenderTextHarfBuzz::GetSubstringBounds(const Range& range) { | |
| 762 DCHECK(!needs_layout_); | |
| 763 DCHECK(Range(0, text().length()).Contains(range)); | |
| 764 Range layout_range(TextIndexToLayoutIndex(range.start()), | |
| 765 TextIndexToLayoutIndex(range.end())); | |
| 766 DCHECK(Range(0, GetLayoutText().length()).Contains(layout_range)); | |
| 767 | |
| 768 std::vector<Rect> rects; | |
| 769 if (layout_range.is_empty()) | |
| 770 return rects; | |
| 771 std::vector<Range> bounds; | |
| 772 | |
| 773 // Add a Range for each run/selection intersection. | |
| 774 for (size_t i = 0; i < runs_.size(); ++i) { | |
| 775 internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]]; | |
| 776 Range intersection = run->range.Intersect(layout_range); | |
| 777 if (!intersection.IsValid()) | |
| 778 continue; | |
| 779 DCHECK(!intersection.is_reversed()); | |
| 780 const Range leftmost_character_x = run->GetGraphemeBounds( | |
| 781 grapheme_iterator_.get(), | |
| 782 run->is_rtl ? intersection.end() - 1 : intersection.start()); | |
| 783 const Range rightmost_character_x = run->GetGraphemeBounds( | |
| 784 grapheme_iterator_.get(), | |
| 785 run->is_rtl ? intersection.start() : intersection.end() - 1); | |
| 786 Range range_x(leftmost_character_x.start(), rightmost_character_x.end()); | |
| 787 DCHECK(!range_x.is_reversed()); | |
| 788 if (range_x.is_empty()) | |
| 789 continue; | |
| 790 | |
| 791 // Union this with the last range if they're adjacent. | |
| 792 DCHECK(bounds.empty() || bounds.back().GetMax() <= range_x.GetMin()); | |
| 793 if (!bounds.empty() && bounds.back().GetMax() == range_x.GetMin()) { | |
| 794 range_x = Range(bounds.back().GetMin(), range_x.GetMax()); | |
| 795 bounds.pop_back(); | |
| 796 } | |
| 797 bounds.push_back(range_x); | |
| 798 } | |
| 799 for (size_t i = 0; i < bounds.size(); ++i) { | |
| 800 std::vector<Rect> current_rects = TextBoundsToViewBounds(bounds[i]); | |
| 801 rects.insert(rects.end(), current_rects.begin(), current_rects.end()); | |
| 802 } | |
| 803 return rects; | |
| 804 } | |
| 805 | |
| 806 size_t RenderTextHarfBuzz::TextIndexToLayoutIndex(size_t index) const { | |
| 807 DCHECK_LE(index, text().length()); | |
| 808 ptrdiff_t i = obscured() ? UTF16IndexToOffset(text(), 0, index) : index; | |
| 809 CHECK_GE(i, 0); | |
| 810 // Clamp layout indices to the length of the text actually used for layout. | |
| 811 return std::min<size_t>(GetLayoutText().length(), i); | |
| 812 } | |
| 813 | |
| 814 size_t RenderTextHarfBuzz::LayoutIndexToTextIndex(size_t index) const { | |
| 815 if (!obscured()) | |
| 816 return index; | |
| 817 | |
| 818 DCHECK_LE(index, GetLayoutText().length()); | |
| 819 const size_t text_index = UTF16OffsetToIndex(text(), 0, index); | |
| 820 DCHECK_LE(text_index, text().length()); | |
| 821 return text_index; | |
| 822 } | |
| 823 | |
| 824 bool RenderTextHarfBuzz::IsValidCursorIndex(size_t index) { | |
| 825 if (index == 0 || index == text().length()) | |
| 826 return true; | |
| 827 if (!IsValidLogicalIndex(index)) | |
| 828 return false; | |
| 829 EnsureLayout(); | |
| 830 return !grapheme_iterator_ || grapheme_iterator_->IsGraphemeBoundary(index); | |
| 831 } | |
| 832 | |
| 833 void RenderTextHarfBuzz::ResetLayout() { | |
| 834 needs_layout_ = true; | |
| 835 } | |
| 836 | |
| 837 void RenderTextHarfBuzz::EnsureLayout() { | |
| 838 if (needs_layout_) { | |
| 839 runs_.clear(); | |
| 840 grapheme_iterator_.reset(); | |
| 841 | |
| 842 if (!GetLayoutText().empty()) { | |
| 843 grapheme_iterator_.reset(new base::i18n::BreakIterator(GetLayoutText(), | |
| 844 base::i18n::BreakIterator::BREAK_CHARACTER)); | |
| 845 if (!grapheme_iterator_->Init()) | |
| 846 grapheme_iterator_.reset(); | |
| 847 | |
| 848 ItemizeText(); | |
| 849 | |
| 850 for (size_t i = 0; i < runs_.size(); ++i) | |
| 851 ShapeRun(runs_[i]); | |
| 852 | |
| 853 // Precalculate run width information. | |
| 854 float preceding_run_widths = 0.0f; | |
| 855 for (size_t i = 0; i < runs_.size(); ++i) { | |
| 856 internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]]; | |
| 857 run->preceding_run_widths = preceding_run_widths; | |
| 858 preceding_run_widths += run->width; | |
| 859 } | |
| 860 } | |
| 861 | |
| 862 needs_layout_ = false; | |
| 863 std::vector<internal::Line> empty_lines; | |
| 864 set_lines(&empty_lines); | |
| 865 } | |
| 866 | |
| 867 if (lines().empty()) { | |
| 868 std::vector<internal::Line> lines; | |
| 869 lines.push_back(internal::Line()); | |
| 870 lines[0].baseline = font_list().GetBaseline(); | |
| 871 lines[0].size.set_height(font_list().GetHeight()); | |
| 872 | |
| 873 int current_x = 0; | |
| 874 SkPaint paint; | |
| 875 | |
| 876 for (size_t i = 0; i < runs_.size(); ++i) { | |
| 877 const internal::TextRunHarfBuzz& run = *runs_[visual_to_logical_[i]]; | |
| 878 internal::LineSegment segment; | |
| 879 segment.x_range = Range(current_x, current_x + run.width); | |
| 880 segment.char_range = run.range; | |
| 881 segment.run = i; | |
| 882 lines[0].segments.push_back(segment); | |
| 883 | |
| 884 paint.setTypeface(run.skia_face.get()); | |
| 885 paint.setTextSize(run.font_size); | |
| 886 SkPaint::FontMetrics metrics; | |
| 887 paint.getFontMetrics(&metrics); | |
| 888 | |
| 889 lines[0].size.set_width(lines[0].size.width() + run.width); | |
| 890 lines[0].size.set_height(std::max(lines[0].size.height(), | |
| 891 metrics.fDescent - metrics.fAscent)); | |
| 892 lines[0].baseline = std::max(lines[0].baseline, | |
| 893 SkScalarRoundToInt(-metrics.fAscent)); | |
| 894 } | |
| 895 | |
| 896 set_lines(&lines); | |
| 897 } | |
| 898 } | |
| 899 | |
| 900 void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) { | |
| 901 DCHECK(!needs_layout_); | |
| 902 internal::SkiaTextRenderer renderer(canvas); | |
| 903 ApplyFadeEffects(&renderer); | |
| 904 ApplyTextShadows(&renderer); | |
| 905 ApplyCompositionAndSelectionStyles(); | |
| 906 | |
| 907 int current_x = 0; | |
| 908 const Vector2d line_offset = GetLineOffset(0); | |
| 909 for (size_t i = 0; i < runs_.size(); ++i) { | |
| 910 const internal::TextRunHarfBuzz& run = *runs_[visual_to_logical_[i]]; | |
| 911 renderer.SetTypeface(run.skia_face.get()); | |
| 912 renderer.SetTextSize(run.font_size); | |
| 913 renderer.SetFontRenderParams(run.render_params, | |
| 914 background_is_transparent()); | |
| 915 | |
| 916 Vector2d origin = line_offset + Vector2d(current_x, lines()[0].baseline); | |
| 917 scoped_ptr<SkPoint[]> positions(new SkPoint[run.glyph_count]); | |
| 918 for (size_t j = 0; j < run.glyph_count; ++j) { | |
| 919 positions[j] = run.positions[j]; | |
| 920 positions[j].offset(SkIntToScalar(origin.x()), SkIntToScalar(origin.y())); | |
| 921 } | |
| 922 | |
| 923 for (BreakList<SkColor>::const_iterator it = | |
| 924 colors().GetBreak(run.range.start()); | |
| 925 it != colors().breaks().end() && it->first < run.range.end(); | |
| 926 ++it) { | |
| 927 const Range intersection = colors().GetRange(it).Intersect(run.range); | |
| 928 const Range colored_glyphs = run.CharRangeToGlyphRange(intersection); | |
| 929 // The range may be empty if a portion of a multi-character grapheme is | |
| 930 // selected, yielding two colors for a single glyph. For now, this just | |
| 931 // paints the glyph with a single style, but it should paint it twice, | |
| 932 // clipped according to selection bounds. See http://crbug.com/366786 | |
| 933 if (colored_glyphs.is_empty()) | |
| 934 continue; | |
| 935 | |
| 936 renderer.SetForegroundColor(it->second); | |
| 937 renderer.DrawPosText(&positions[colored_glyphs.start()], | |
| 938 &run.glyphs[colored_glyphs.start()], | |
| 939 colored_glyphs.length()); | |
| 940 int width = (colored_glyphs.end() == run.glyph_count ? run.width : | |
| 941 run.positions[colored_glyphs.end()].x()) - | |
| 942 run.positions[colored_glyphs.start()].x(); | |
| 943 renderer.DrawDecorations(origin.x(), origin.y(), width, run.underline, | |
| 944 run.strike, run.diagonal_strike); | |
| 945 } | |
| 946 | |
| 947 current_x += run.width; | |
| 948 } | |
| 949 | |
| 950 renderer.EndDiagonalStrike(); | |
| 951 | |
| 952 UndoCompositionAndSelectionStyles(); | |
| 953 } | |
| 954 | |
| 955 size_t RenderTextHarfBuzz::GetRunContainingCaret( | |
| 956 const SelectionModel& caret) const { | |
| 957 DCHECK(!needs_layout_); | |
| 958 size_t layout_position = TextIndexToLayoutIndex(caret.caret_pos()); | |
| 959 LogicalCursorDirection affinity = caret.caret_affinity(); | |
| 960 for (size_t run = 0; run < runs_.size(); ++run) { | |
| 961 if (RangeContainsCaret(runs_[run]->range, layout_position, affinity)) | |
| 962 return run; | |
| 963 } | |
| 964 return runs_.size(); | |
| 965 } | |
| 966 | |
| 967 size_t RenderTextHarfBuzz::GetRunContainingXCoord(int x, int* offset) const { | |
| 968 DCHECK(!needs_layout_); | |
| 969 if (x < 0) | |
| 970 return runs_.size(); | |
| 971 // Find the text run containing the argument point (assumed already offset). | |
| 972 int current_x = 0; | |
| 973 for (size_t i = 0; i < runs_.size(); ++i) { | |
| 974 size_t run = visual_to_logical_[i]; | |
| 975 current_x += runs_[run]->width; | |
| 976 if (x < current_x) { | |
| 977 *offset = x - (current_x - runs_[run]->width); | |
| 978 return run; | |
| 979 } | |
| 980 } | |
| 981 return runs_.size(); | |
| 982 } | |
| 983 | |
| 984 SelectionModel RenderTextHarfBuzz::FirstSelectionModelInsideRun( | |
| 985 const internal::TextRunHarfBuzz* run) { | |
| 986 size_t position = LayoutIndexToTextIndex(run->range.start()); | |
| 987 position = IndexOfAdjacentGrapheme(position, CURSOR_FORWARD); | |
| 988 return SelectionModel(position, CURSOR_BACKWARD); | |
| 989 } | |
| 990 | |
| 991 SelectionModel RenderTextHarfBuzz::LastSelectionModelInsideRun( | |
| 992 const internal::TextRunHarfBuzz* run) { | |
| 993 size_t position = LayoutIndexToTextIndex(run->range.end()); | |
| 994 position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD); | |
| 995 return SelectionModel(position, CURSOR_FORWARD); | |
| 996 } | |
| 997 | |
| 998 void RenderTextHarfBuzz::ItemizeText() { | |
| 999 const base::string16& text = GetLayoutText(); | |
| 1000 const bool is_text_rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT; | |
| 1001 DCHECK_NE(0U, text.length()); | |
| 1002 | |
| 1003 // If ICU fails to itemize the text, we create a run that spans the entire | |
| 1004 // text. This is needed because leaving the runs set empty causes some clients | |
| 1005 // to misbehave since they expect non-zero text metrics from a non-empty text. | |
| 1006 base::i18n::BiDiLineIterator bidi_iterator; | |
| 1007 if (!bidi_iterator.Open(text, is_text_rtl, false)) { | |
| 1008 internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz; | |
| 1009 run->range = Range(0, text.length()); | |
| 1010 runs_.push_back(run); | |
| 1011 visual_to_logical_ = logical_to_visual_ = std::vector<int32_t>(1, 0); | |
| 1012 return; | |
| 1013 } | |
| 1014 | |
| 1015 // Temporarily apply composition underlines and selection colors. | |
| 1016 ApplyCompositionAndSelectionStyles(); | |
| 1017 | |
| 1018 // Build the list of runs from the script items and ranged styles. Use an | |
| 1019 // empty color BreakList to avoid breaking runs at color boundaries. | |
| 1020 BreakList<SkColor> empty_colors; | |
| 1021 empty_colors.SetMax(text.length()); | |
| 1022 internal::StyleIterator style(empty_colors, styles()); | |
| 1023 | |
| 1024 for (size_t run_break = 0; run_break < text.length();) { | |
| 1025 internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz; | |
| 1026 run->range.set_start(run_break); | |
| 1027 run->font_style = (style.style(BOLD) ? Font::BOLD : 0) | | |
| 1028 (style.style(ITALIC) ? Font::ITALIC : 0); | |
| 1029 run->strike = style.style(STRIKE); | |
| 1030 run->diagonal_strike = style.style(DIAGONAL_STRIKE); | |
| 1031 run->underline = style.style(UNDERLINE); | |
| 1032 | |
| 1033 int32 script_item_break = 0; | |
| 1034 bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level); | |
| 1035 // Odd BiDi embedding levels correspond to RTL runs. | |
| 1036 run->is_rtl = (run->level % 2) == 1; | |
| 1037 // Find the length and script of this script run. | |
| 1038 script_item_break = ScriptInterval(text, run_break, | |
| 1039 script_item_break - run_break, &run->script) + run_break; | |
| 1040 | |
| 1041 // Find the next break and advance the iterators as needed. | |
| 1042 run_break = std::min(static_cast<size_t>(script_item_break), | |
| 1043 TextIndexToLayoutIndex(style.GetRange().end())); | |
| 1044 | |
| 1045 // Break runs at certain characters that need to be rendered separately to | |
| 1046 // prevent either an unusual character from forcing a fallback font on the | |
| 1047 // entire run, or brackets from being affected by a fallback font. | |
| 1048 // http://crbug.com/278913, http://crbug.com/396776 | |
| 1049 if (run_break > run->range.start()) | |
| 1050 run_break = FindRunBreakingCharacter(text, run->range.start(), run_break); | |
| 1051 | |
| 1052 DCHECK(IsValidCodePointIndex(text, run_break)); | |
| 1053 style.UpdatePosition(LayoutIndexToTextIndex(run_break)); | |
| 1054 run->range.set_end(run_break); | |
| 1055 | |
| 1056 runs_.push_back(run); | |
| 1057 } | |
| 1058 | |
| 1059 // Undo the temporarily applied composition underlines and selection colors. | |
| 1060 UndoCompositionAndSelectionStyles(); | |
| 1061 | |
| 1062 const size_t num_runs = runs_.size(); | |
| 1063 std::vector<UBiDiLevel> levels(num_runs); | |
| 1064 for (size_t i = 0; i < num_runs; ++i) | |
| 1065 levels[i] = runs_[i]->level; | |
| 1066 visual_to_logical_.resize(num_runs); | |
| 1067 ubidi_reorderVisual(&levels[0], num_runs, &visual_to_logical_[0]); | |
| 1068 logical_to_visual_.resize(num_runs); | |
| 1069 ubidi_reorderLogical(&levels[0], num_runs, &logical_to_visual_[0]); | |
| 1070 } | |
| 1071 | |
| 1072 void RenderTextHarfBuzz::ShapeRun(internal::TextRunHarfBuzz* run) { | |
| 1073 const Font& primary_font = font_list().GetPrimaryFont(); | |
| 1074 const std::string primary_font_name = primary_font.GetFontName(); | |
| 1075 run->font_size = primary_font.GetFontSize(); | |
| 1076 | |
| 1077 size_t best_font_missing = std::numeric_limits<size_t>::max(); | |
| 1078 std::string best_font; | |
| 1079 std::string current_font; | |
| 1080 | |
| 1081 // Try shaping with |primary_font|. | |
| 1082 if (ShapeRunWithFont(run, primary_font_name)) { | |
| 1083 current_font = primary_font_name; | |
| 1084 size_t current_missing = run->CountMissingGlyphs(); | |
| 1085 if (current_missing == 0) | |
| 1086 return; | |
| 1087 if (current_missing < best_font_missing) { | |
| 1088 best_font_missing = current_missing; | |
| 1089 best_font = current_font; | |
| 1090 } | |
| 1091 } | |
| 1092 | |
| 1093 #if defined(OS_WIN) | |
| 1094 Font uniscribe_font; | |
| 1095 const base::char16* run_text = &(GetLayoutText()[run->range.start()]); | |
| 1096 if (GetUniscribeFallbackFont(primary_font, run_text, run->range.length(), | |
| 1097 &uniscribe_font) && | |
| 1098 ShapeRunWithFont(run, uniscribe_font.GetFontName())) { | |
| 1099 current_font = uniscribe_font.GetFontName(); | |
| 1100 size_t current_missing = run->CountMissingGlyphs(); | |
| 1101 if (current_missing == 0) | |
| 1102 return; | |
| 1103 if (current_missing < best_font_missing) { | |
| 1104 best_font_missing = current_missing; | |
| 1105 best_font = current_font; | |
| 1106 } | |
| 1107 } | |
| 1108 #endif | |
| 1109 | |
| 1110 // Try shaping with the fonts in the fallback list except the first, which is | |
| 1111 // |primary_font|. | |
| 1112 std::vector<std::string> fonts = GetFallbackFontFamilies(primary_font_name); | |
| 1113 for (size_t i = 1; i < fonts.size(); ++i) { | |
| 1114 if (!ShapeRunWithFont(run, fonts[i])) | |
| 1115 continue; | |
| 1116 current_font = fonts[i]; | |
| 1117 size_t current_missing = run->CountMissingGlyphs(); | |
| 1118 if (current_missing == 0) | |
| 1119 return; | |
| 1120 if (current_missing < best_font_missing) { | |
| 1121 best_font_missing = current_missing; | |
| 1122 best_font = current_font; | |
| 1123 } | |
| 1124 } | |
| 1125 | |
| 1126 if (!best_font.empty() && | |
| 1127 (best_font == current_font || ShapeRunWithFont(run, best_font))) { | |
| 1128 return; | |
| 1129 } | |
| 1130 | |
| 1131 run->glyph_count = 0; | |
| 1132 run->width = 0.0f; | |
| 1133 } | |
| 1134 | |
| 1135 bool RenderTextHarfBuzz::ShapeRunWithFont(internal::TextRunHarfBuzz* run, | |
| 1136 const std::string& font_family) { | |
| 1137 const base::string16& text = GetLayoutText(); | |
| 1138 skia::RefPtr<SkTypeface> skia_face = | |
| 1139 internal::CreateSkiaTypeface(font_family, run->font_style); | |
| 1140 if (skia_face == NULL) | |
| 1141 return false; | |
| 1142 run->skia_face = skia_face; | |
| 1143 FontRenderParamsQuery query(false); | |
| 1144 query.families.push_back(font_family); | |
| 1145 query.pixel_size = run->font_size; | |
| 1146 query.style = run->font_style; | |
| 1147 run->render_params = GetFontRenderParams(query, NULL); | |
| 1148 hb_font_t* harfbuzz_font = CreateHarfBuzzFont(run->skia_face.get(), | |
| 1149 run->font_size, run->render_params, background_is_transparent()); | |
| 1150 | |
| 1151 // Create a HarfBuzz buffer and add the string to be shaped. The HarfBuzz | |
| 1152 // buffer holds our text, run information to be used by the shaping engine, | |
| 1153 // and the resulting glyph data. | |
| 1154 hb_buffer_t* buffer = hb_buffer_create(); | |
| 1155 hb_buffer_add_utf16(buffer, reinterpret_cast<const uint16*>(text.c_str()), | |
| 1156 text.length(), run->range.start(), run->range.length()); | |
| 1157 hb_buffer_set_script(buffer, ICUScriptToHBScript(run->script)); | |
| 1158 hb_buffer_set_direction(buffer, | |
| 1159 run->is_rtl ? HB_DIRECTION_RTL : HB_DIRECTION_LTR); | |
| 1160 // TODO(ckocagil): Should we determine the actual language? | |
| 1161 hb_buffer_set_language(buffer, hb_language_get_default()); | |
| 1162 | |
| 1163 // Shape the text. | |
| 1164 hb_shape(harfbuzz_font, buffer, NULL, 0); | |
| 1165 | |
| 1166 // Populate the run fields with the resulting glyph data in the buffer. | |
| 1167 unsigned int glyph_count = 0; | |
| 1168 hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &glyph_count); | |
| 1169 run->glyph_count = glyph_count; | |
| 1170 hb_glyph_position_t* hb_positions = | |
| 1171 hb_buffer_get_glyph_positions(buffer, NULL); | |
| 1172 run->glyphs.reset(new uint16[run->glyph_count]); | |
| 1173 run->glyph_to_char.resize(run->glyph_count); | |
| 1174 run->positions.reset(new SkPoint[run->glyph_count]); | |
| 1175 run->width = 0.0f; | |
| 1176 for (size_t i = 0; i < run->glyph_count; ++i) { | |
| 1177 run->glyphs[i] = infos[i].codepoint; | |
| 1178 run->glyph_to_char[i] = infos[i].cluster; | |
| 1179 const int x_offset = SkFixedToScalar(hb_positions[i].x_offset); | |
| 1180 const int y_offset = SkFixedToScalar(hb_positions[i].y_offset); | |
| 1181 run->positions[i].set(run->width + x_offset, -y_offset); | |
| 1182 run->width += SkFixedToScalar(hb_positions[i].x_advance); | |
| 1183 #if defined(OS_LINUX) | |
| 1184 // Match Pango's glyph rounding logic on Linux. | |
| 1185 if (!run->render_params.subpixel_positioning) | |
| 1186 run->width = std::floor(run->width + 0.5f); | |
| 1187 #endif | |
| 1188 } | |
| 1189 | |
| 1190 hb_buffer_destroy(buffer); | |
| 1191 hb_font_destroy(harfbuzz_font); | |
| 1192 return true; | |
| 1193 } | |
| 1194 | |
| 1195 } // namespace gfx | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 854713003:
More old files deletion. (Closed)
Base URL: https://github.com/domokit/mojo.git@master