// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include #include "base/gfx/uniscribe.h" #include "base/gfx/font_utils.h" #include "base/logging.h" namespace gfx { // This function is used to see where word spacing should be applied inside // runs. Note that this must match Font::treatAsSpace so we all agree where // and how much space this is, so we don't want to do more general Unicode // "is this a word break" thing. static bool TreatAsSpace(wchar_t c) { return c == ' ' || c == '\t' || c == '\n' || c == 0x00A0; } // SCRIPT_FONTPROPERTIES contains glyph indices for default, invalid // and blank glyphs. Just because ScriptShape succeeds does not mean // that a text run is rendered correctly. Some characters may be rendered // with default/invalid/blank glyphs. Therefore, we need to check if the glyph // array returned by ScriptShape contains any of those glyphs to make // sure that the text run is rendered successfully. static bool ContainsMissingGlyphs(WORD *glyphs, int length, SCRIPT_FONTPROPERTIES* properties) { for (int i = 0; i < length; ++i) { if (glyphs[i] == properties->wgDefault || (glyphs[i] == properties->wgInvalid && glyphs[i] != properties->wgBlank)) return true; } return false; } // HFONT is the 'incarnation' of 'everything' about font, but it's an opaque // handle and we can't directly query it to make a new HFONT sharing // its characteristics (height, style, etc) except for family name. // This function uses GetObject to convert HFONT back to LOGFONT, // resets the fields of LOGFONT and calculates style to use later // for the creation of a font identical to HFONT other than family name. static void SetLogFontAndStyle(HFONT hfont, LOGFONT *logfont, int *style) { DCHECK(hfont && logfont); if (!hfont || !logfont) return; GetObject(hfont, sizeof(LOGFONT), logfont); // We reset these fields to values appropriate for CreateFontIndirect. // while keeping lfHeight, which is the most important value in creating // a new font similar to hfont. logfont->lfWidth = 0; logfont->lfEscapement = 0; logfont->lfOrientation = 0; logfont->lfCharSet = DEFAULT_CHARSET; logfont->lfOutPrecision = OUT_TT_ONLY_PRECIS; logfont->lfQuality = DEFAULT_QUALITY; // Honor user's desktop settings. logfont->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE; if (style) *style = gfx::GetStyleFromLogfont(logfont); } UniscribeState::UniscribeState(const wchar_t* input, int input_length, bool is_rtl, HFONT hfont, SCRIPT_CACHE* script_cache, SCRIPT_FONTPROPERTIES* font_properties) : input_(input), input_length_(input_length), is_rtl_(is_rtl), hfont_(hfont), script_cache_(script_cache), font_properties_(font_properties), directional_override_(false), inhibit_ligate_(false), letter_spacing_(0), space_width_(0), word_spacing_(0), ascent_(0) { logfont_.lfFaceName[0] = 0; } UniscribeState::~UniscribeState() { } void UniscribeState::InitWithOptionalLengthProtection(bool length_protection) { // We cap the input length and just don't do anything. We'll allocate a lot // of things of the size of the number of characters, so the allocated memory // will be several times the input length. Plus shaping such a large buffer // may be a form of denial of service. No legitimate text should be this long. // It also appears that Uniscribe flatly rejects very long strings, so we // don't lose anything by doing this. // // The input length protection may be disabled by the unit tests to cause // an error condition. static const int kMaxInputLength = 65535; if (input_length_ == 0 || (length_protection && input_length_ > kMaxInputLength)) return; FillRuns(); FillShapes(); FillScreenOrder(); } int UniscribeState::Width() const { int width = 0; for (int item_index = 0; item_index < static_cast(runs_->size()); item_index++) { width += AdvanceForItem(item_index); } return width; } void UniscribeState::Justify(int additional_space) { // Count the total number of glyphs we have so we know how big to make the // buffers below. int total_glyphs = 0; for (size_t run = 0; run < runs_->size(); run++) { int run_idx = screen_order_[run]; total_glyphs += static_cast(shapes_[run_idx].glyph_length()); } if (total_glyphs == 0) return; // Nothing to do. // We make one big buffer in screen order of all the glyphs we are drawing // across runs so that the justification function will adjust evenly across // all glyphs. StackVector visattr; visattr->resize(total_glyphs); StackVector advances; advances->resize(total_glyphs); StackVector justify; justify->resize(total_glyphs); // Build the packed input. int dest_index = 0; for (size_t run = 0; run < runs_->size(); run++) { int run_idx = screen_order_[run]; const Shaping& shaping = shapes_[run_idx]; for (int i = 0; i < shaping.glyph_length(); i++, dest_index++) { memcpy(&visattr[dest_index], &shaping.visattr[i], sizeof(SCRIPT_VISATTR)); advances[dest_index] = shaping.advance[i]; } } // The documentation for ScriptJustify is wrong, the parameter is the space // to add and not the width of the column you want. const int min_kashida = 1; // How do we decide what this should be? ScriptJustify(&visattr[0], &advances[0], total_glyphs, additional_space, min_kashida, &justify[0]); // Now we have to unpack the justification amounts back into the runs so // the glyph indices match. int global_glyph_index = 0; for (size_t run = 0; run < runs_->size(); run++) { int run_idx = screen_order_[run]; Shaping& shaping = shapes_[run_idx]; shaping.justify->resize(shaping.glyph_length()); for (int i = 0; i < shaping.glyph_length(); i++, global_glyph_index++) shaping.justify[i] = justify[global_glyph_index]; } } int UniscribeState::CharacterToX(int offset) const { HRESULT hr; DCHECK(offset <= input_length_); // Our algorithm is to traverse the items in screen order from left to // right, adding in each item's screen width until we find the item with // the requested character in it. int width = 0; for (size_t screen_idx = 0; screen_idx < runs_->size(); screen_idx++) { // Compute the length of this run. int item_idx = screen_order_[screen_idx]; const SCRIPT_ITEM& item = runs_[item_idx]; const Shaping& shaping = shapes_[item_idx]; int item_length = shaping.char_length(); if (offset >= item.iCharPos && offset <= item.iCharPos + item_length) { // Character offset is in this run. int char_len = offset - item.iCharPos; int cur_x = 0; hr = ScriptCPtoX(char_len, FALSE, item_length, shaping.glyph_length(), &shaping.logs[0], &shaping.visattr[0], shaping.effective_advances(), &item.a, &cur_x); if (FAILED(hr)) return 0; width += cur_x + shaping.pre_padding; DCHECK(width >= 0); return width; } // Move to the next item. width += AdvanceForItem(item_idx); } DCHECK(width >= 0); return width; } int UniscribeState::XToCharacter(int x) const { // We iterate in screen order until we find the item with the given pixel // position in it. When we find that guy, we ask Uniscribe for the // character index. HRESULT hr; for (size_t screen_idx = 0; screen_idx < runs_->size(); screen_idx++) { int item_idx = screen_order_[screen_idx]; int advance_for_item = AdvanceForItem(item_idx); // Note that the run may be empty if shaping failed, so we want to skip // over it. const Shaping& shaping = shapes_[item_idx]; int item_length = shaping.char_length(); if (x <= advance_for_item && item_length > 0) { // The requested offset is within this item. const SCRIPT_ITEM& item = runs_[item_idx]; // Account for the leading space we've added to this run that Uniscribe // doesn't know about. x -= shaping.pre_padding; int char_x = 0; int trailing; hr = ScriptXtoCP(x, item_length, shaping.glyph_length(), &shaping.logs[0], &shaping.visattr[0], shaping.effective_advances(), &item.a, &char_x, &trailing); // The character offset is within the item. We need to add the item's // offset to transform it into the space of the TextRun return char_x + item.iCharPos; } // The offset is beyond this item, account for its length and move on. x -= advance_for_item; } // Error condition, we don't know what to do if we don't have that X // position in any of our items. return 0; } void UniscribeState::Draw(HDC dc, int x, int y, int from, int to) { HGDIOBJ old_font = 0; int cur_x = x; bool first_run = true; for (size_t screen_idx = 0; screen_idx < runs_->size(); screen_idx++) { int item_idx = screen_order_[screen_idx]; const SCRIPT_ITEM& item = runs_[item_idx]; const Shaping& shaping = shapes_[item_idx]; // Character offsets within this run. THESE MAY NOT BE IN RANGE and may // be negative, etc. The code below handles this. int from_char = from - item.iCharPos; int to_char = to - item.iCharPos; // See if we need to draw any characters in this item. if (shaping.char_length() == 0 || from_char >= shaping.char_length() || to_char <= 0) { // No chars in this item to display. cur_x += AdvanceForItem(item_idx); continue; } // Compute the starting glyph within this span. |from| and |to| are // global offsets that may intersect arbitrarily with our local run. int from_glyph, after_glyph; if (item.a.fRTL) { // To compute the first glyph when going RTL, we use |to|. if (to_char >= shaping.char_length()) { // The end of the text is after (to the left) of us. from_glyph = 0; } else { // Since |to| is exclusive, the first character we draw on the left // is actually the one right before (to the right) of |to|. from_glyph = shaping.logs[to_char - 1]; } // The last glyph is actually the first character in the range. if (from_char <= 0) { // The first character to draw is before (to the right) of this span, // so draw all the way to the end. after_glyph = shaping.glyph_length(); } else { // We want to draw everything up until the character to the right of // |from|. To the right is - 1, so we look that up (remember our // character could be more than one glyph, so we can't look up our // glyph and add one). after_glyph = shaping.logs[from_char - 1]; } } else { // Easy case, everybody agrees about directions. We only need to handle // boundary conditions to get a range inclusive at the beginning, and // exclusive at the ending. We have to do some computation to see the // glyph one past the end. from_glyph = shaping.logs[from_char < 0 ? 0 : from_char]; if (to_char >= shaping.char_length()) after_glyph = shaping.glyph_length(); else after_glyph = shaping.logs[to_char]; } // Account for the characters that were skipped in this run. When // WebKit asks us to draw a subset of the run, it actually tells us // to draw at the X offset of the beginning of the run, since it // doesn't know the internal position of any of our characters. const int* effective_advances = shaping.effective_advances(); int inner_offset = 0; for (int i = 0; i < from_glyph; i++) inner_offset += effective_advances[i]; // Actually draw the glyphs we found. int glyph_count = after_glyph - from_glyph; if (from_glyph >= 0 && glyph_count > 0) { // Account for the preceeding space we need to add to this run. We don't // need to count for the following space because that will be counted // in AdvanceForItem below when we move to the next run. inner_offset += shaping.pre_padding; // Pass NULL in when there is no justification. const int* justify = shaping.justify->empty() ? NULL : &shaping.justify[from_glyph]; if (first_run) { old_font = SelectObject(dc, shaping.hfont_); first_run = false; } else { SelectObject(dc, shaping.hfont_); } // TODO(brettw) bug 698452: if a half a character is selected, // we should set up a clip rect so we draw the half of the glyph // correctly. // Fonts with different ascents can be used to render different runs. // 'Across-runs' y-coordinate correction needs to be adjusted // for each font. HRESULT hr = S_FALSE; for (int executions = 0; executions < 2; ++executions) { hr = ScriptTextOut(dc, shaping.script_cache_, cur_x + inner_offset, y - shaping.ascent_offset_, 0, NULL, &item.a, NULL, 0, &shaping.glyphs[from_glyph], glyph_count, &shaping.advance[from_glyph], justify, &shaping.offsets[from_glyph]); if (S_OK != hr && 0 == executions) { // If this ScriptTextOut is called from the renderer it might fail // because the sandbox is preventing it from opening the font files. // If we are running in the renderer, TryToPreloadFont is overridden // to ask the browser to preload the font for us so we can access it. TryToPreloadFont(shaping.hfont_); continue; } break; } DCHECK(S_OK == hr); } cur_x += AdvanceForItem(item_idx); } if (old_font) SelectObject(dc, old_font); } WORD UniscribeState::FirstGlyphForCharacter(int char_offset) const { // Find the run for the given character. for (int i = 0; i < static_cast(runs_->size()); i++) { int first_char = runs_[i].iCharPos; const Shaping& shaping = shapes_[i]; int local_offset = char_offset - first_char; if (local_offset >= 0 && local_offset < shaping.char_length()) { // The character is in this run, return the first glyph for it (should // generally be the only glyph). It seems Uniscribe gives glyph 0 for // empty, which is what we want to return in the "missing" case. size_t glyph_index = shaping.logs[local_offset]; if (glyph_index >= shaping.glyphs->size()) { // The glyph should be in this run, but the run has too few actual // characters. This can happen when shaping the run fails, in which // case, we should have no data in the logs at all. DCHECK(shaping.glyphs->empty()); return 0; } return shaping.glyphs[glyph_index]; } } return 0; } void UniscribeState::FillRuns() { HRESULT hr; runs_->resize(UNISCRIBE_STATE_STACK_RUNS); SCRIPT_STATE input_state; input_state.uBidiLevel = is_rtl_; input_state.fOverrideDirection = directional_override_; input_state.fInhibitSymSwap = false; input_state.fCharShape = false; // Not implemented in Uniscribe input_state.fDigitSubstitute = false; // Do we want this for Arabic? input_state.fInhibitLigate = inhibit_ligate_; input_state.fDisplayZWG = false; // Don't draw control characters. input_state.fArabicNumContext = is_rtl_; // Do we want this for Arabic? input_state.fGcpClusters = false; input_state.fReserved = 0; input_state.fEngineReserved = 0; // The psControl argument to ScriptItemize should be non-NULL for RTL text, // per http://msdn.microsoft.com/en-us/library/ms776532.aspx . So use a // SCRIPT_CONTROL that is set to all zeros. Zero as a locale ID means the // neutral locale per http://msdn.microsoft.com/en-us/library/ms776294.aspx . static SCRIPT_CONTROL input_control = {0, // uDefaultLanguage :16; 0, // fContextDigits :1; 0, // fInvertPreBoundDir :1; 0, // fInvertPostBoundDir :1; 0, // fLinkStringBefore :1; 0, // fLinkStringAfter :1; 0, // fNeutralOverride :1; 0, // fNumericOverride :1; 0, // fLegacyBidiClass :1; 0, // fMergeNeutralItems :1; 0};// fReserved :7; // Calling ScriptApplyDigitSubstitution( NULL, &input_control, &input_state) // here would be appropriate if we wanted to set the language ID, and get // local digit substitution behavior. For now, don't do it. while (true) { int num_items = 0; // Ideally, we would have a way to know the runs before and after this // one, and put them into the control parameter of ScriptItemize. This // would allow us to shape characters properly that cross style // boundaries (WebKit bug 6148). // // We tell ScriptItemize that the output list of items is one smaller // than it actually is. According to Mozilla bug 366643, if there is // not enough room in the array on pre-SP2 systems, ScriptItemize will // write one past the end of the buffer. // // ScriptItemize is very strange. It will often require a much larger // ITEM buffer internally than it will give us as output. For example, // it will say a 16-item buffer is not big enough, and will write // interesting numbers into all those items. But when we give it a 32 // item buffer and it succeeds, it only has one item output. // // It seems to be doing at least two passes, the first where it puts a // lot of intermediate data into our items, and the second where it // collates them. hr = ScriptItemize(input_, input_length_, static_cast(runs_->size()) - 1, &input_control, &input_state, &runs_[0], &num_items); if (SUCCEEDED(hr)) { runs_->resize(num_items); break; } if (hr != E_OUTOFMEMORY) { // Some kind of unexpected error. runs_->resize(0); break; } // There was not enough items for it to write into, expand. runs_->resize(runs_->size() * 2); } // Fix up the directions of the items so they're what WebKit thinks // they are. WebKit (and we assume any other caller) always knows what // direction it wants things to be in, and will only give us runs that are in // the same direction. Sometimes, Uniscibe disagrees, for example, if you // have embedded ASCII punctuation in an Arabic string, WebKit will // (correctly) know that is should still be rendered RTL, but Uniscibe might // think LTR is better. // // TODO(brettw) bug 747235: // This workaround fixes the bug but causes spacing problems in other cases. // WebKit sometimes gives us a big run that includes ASCII and Arabic, and // this forcing direction makes those cases incorrect. This seems to happen // during layout only, so it ends up that spacing is incorrect (because being // the wrong direction changes ligatures and stuff). // //for (size_t i = 0; i < runs_->size(); i++) // runs_[i].a.fRTL = is_rtl_; } bool UniscribeState::Shape(const wchar_t* input, int item_length, int num_glyphs, SCRIPT_ITEM& run, Shaping& shaping) { HFONT hfont = hfont_; SCRIPT_CACHE* script_cache = script_cache_; SCRIPT_FONTPROPERTIES* font_properties = font_properties_; int ascent = ascent_; HDC temp_dc = NULL; HGDIOBJ old_font = 0; HRESULT hr; bool lastFallbackTried = false; bool result; int generated_glyphs = 0; // In case HFONT passed in ctor cannot render this run, we have to scan // other fonts from the beginning of the font list. ResetFontIndex(); // Compute shapes. while (true) { shaping.logs->resize(item_length); shaping.glyphs->resize(num_glyphs); shaping.visattr->resize(num_glyphs); // Firefox sets SCRIPT_ANALYSIS.SCRIPT_STATE.fDisplayZWG to true // here. Is that what we want? It will display control characters. hr = ScriptShape(temp_dc, script_cache, input, item_length, num_glyphs, &run.a, &shaping.glyphs[0], &shaping.logs[0], &shaping.visattr[0], &generated_glyphs); if (hr == E_PENDING) { // Allocate the DC. temp_dc = GetDC(NULL); old_font = SelectObject(temp_dc, hfont); continue; } else if (hr == E_OUTOFMEMORY) { num_glyphs *= 2; continue; } else if (SUCCEEDED(hr) && (lastFallbackTried || !ContainsMissingGlyphs(&shaping.glyphs[0], generated_glyphs, font_properties))) { break; } // The current font can't render this run. clear DC and try // next font. if (temp_dc) { SelectObject(temp_dc, old_font); ReleaseDC(NULL, temp_dc); temp_dc = NULL; } if (NextWinFontData(&hfont, &script_cache, &font_properties, &ascent)) { // The primary font does not support this run. Try next font. // In case of web page rendering, they come from fonts specified in // CSS stylesheets. continue; } else if (!lastFallbackTried) { lastFallbackTried = true; // Generate a last fallback font based on the script of // a character to draw while inheriting size and styles // from the primary font if (!logfont_.lfFaceName[0]) SetLogFontAndStyle(hfont_, &logfont_, &style_); // TODO(jungshik): generic type should come from webkit for // UniscribeStateTextRun (a derived class used in webkit). const wchar_t *family = GetFallbackFamily(input, item_length, GENERIC_FAMILY_STANDARD, NULL, NULL); bool font_ok = GetDerivedFontData(family, style_, &logfont_, &ascent, &hfont, &script_cache); if (!font_ok) { // If this GetDerivedFontData is called from the renderer it might fail // because the sandbox is preventing it from opening the font files. // If we are running in the renderer, TryToPreloadFont is overridden to // ask the browser to preload the font for us so we can access it. TryToPreloadFont(hfont); // Try again. font_ok = GetDerivedFontData(family, style_, &logfont_, &ascent, &hfont, &script_cache); DCHECK(font_ok); } // TODO(jungshik) : Currently GetDerivedHFont always returns a // a valid HFONT, but in the future, I may change it to return 0. DCHECK(hfont); // We don't need a font_properties for the last resort fallback font // because we don't have anything more to try and are forced to // accept empty glyph boxes. If we tried a series of fonts as // 'last-resort fallback', we'd need it, but currently, we don't. continue; } else if (hr == USP_E_SCRIPT_NOT_IN_FONT) { run.a.eScript = SCRIPT_UNDEFINED; continue; } else if (FAILED(hr)) { // Error shaping. generated_glyphs = 0; result = false; goto cleanup; } } // Sets Windows font data for this run to those corresponding to // a font supporting this run. we don't need to store font_properties // because it's not used elsewhere. shaping.hfont_ = hfont; shaping.script_cache_ = script_cache; // The ascent of a font for this run can be different from // that of the primary font so that we need to keep track of // the difference per run and take that into account when calling // ScriptTextOut in |Draw|. Otherwise, different runs rendered by // different fonts would not be aligned vertically. shaping.ascent_offset_ = ascent_ ? ascent - ascent_ : 0; result = true; cleanup: shaping.glyphs->resize(generated_glyphs); shaping.visattr->resize(generated_glyphs); shaping.advance->resize(generated_glyphs); shaping.offsets->resize(generated_glyphs); if (temp_dc) { SelectObject(temp_dc, old_font); ReleaseDC(NULL, temp_dc); } // On failure, our logs don't mean anything, so zero those out. if (!result) shaping.logs->clear(); return result; } void UniscribeState::FillShapes() { shapes_->resize(runs_->size()); for (size_t i = 0; i < runs_->size(); i++) { int start_item = runs_[i].iCharPos; int item_length = input_length_ - start_item; if (i < runs_->size() - 1) item_length = runs_[i + 1].iCharPos - start_item; int num_glyphs; if (item_length < UNISCRIBE_STATE_STACK_CHARS) { // We'll start our buffer sizes with the current stack space available // in our buffers if the current input fits. As long as it // doesn't expand past that we'll save a lot of time mallocing. num_glyphs = UNISCRIBE_STATE_STACK_CHARS; } else { // When the input doesn't fit, give up with the stack since it will // almost surely not be enough room (unless the input actually shrinks, // which is unlikely) and just start with the length recommended by // the Uniscribe documentation as a "usually fits" size. num_glyphs = item_length * 3 / 2 + 16; } // Convert a string to a glyph string trying the primary font, // fonts in the fallback list and then script-specific last resort font. Shaping& shaping = shapes_[i]; if (!Shape(&input_[start_item], item_length, num_glyphs, runs_[i], shaping)) continue; // Compute placements. Note that offsets is documented incorrectly // and is actually an array. // DC that we lazily create if Uniscribe commands us to. // (this does not happen often because script_cache is already // updated when calling ScriptShape). HDC temp_dc = NULL; HGDIOBJ old_font = NULL; HRESULT hr; while (true) { shaping.pre_padding = 0; hr = ScriptPlace(temp_dc, shaping.script_cache_, &shaping.glyphs[0], static_cast(shaping.glyphs->size()), &shaping.visattr[0], &runs_[i].a, &shaping.advance[0], &shaping.offsets[0], &shaping.abc); if (hr != E_PENDING) break; // Allocate the DC and run the loop again. temp_dc = GetDC(NULL); old_font = SelectObject(temp_dc, shaping.hfont_); } if (FAILED(hr)) { // Some error we don't know how to handle. Nuke all of our data // since we can't deal with partially valid data later. runs_->clear(); shapes_->clear(); screen_order_->clear(); } if (temp_dc) { SelectObject(temp_dc, old_font); ReleaseDC(NULL, temp_dc); } } AdjustSpaceAdvances(); if (letter_spacing_ != 0 || word_spacing_ != 0) ApplySpacing(); } void UniscribeState::FillScreenOrder() { screen_order_->resize(runs_->size()); // We assume that the input has only one text direction in it. // TODO(brettw) are we sure we want to keep this restriction? if (is_rtl_) { for (int i = 0; i < static_cast(screen_order_->size()); i++) screen_order_[static_cast(screen_order_->size()) - i - 1] = i; } else { for (int i = 0; i < static_cast(screen_order_->size()); i++) screen_order_[i] = i; } } void UniscribeState::AdjustSpaceAdvances() { if (space_width_ == 0) return; int space_width_without_letter_spacing = space_width_ - letter_spacing_; // This mostly matches what WebKit's UniscribeController::shapeAndPlaceItem. for (size_t run = 0; run < runs_->size(); run++) { Shaping& shaping = shapes_[run]; for (int i = 0; i < shaping.char_length(); i++) { if (!TreatAsSpace(input_[runs_[run].iCharPos + i])) continue; int glyph_index = shaping.logs[i]; int current_advance = shaping.advance[glyph_index]; // Don't give zero-width spaces a width. if (!current_advance) continue; // current_advance does not include additional letter-spacing, but // space_width does. Here we find out how off we are from the correct // width for the space not including letter-spacing, then just subtract // that diff. int diff = current_advance - space_width_without_letter_spacing; // The shaping can consist of a run of text, so only subtract the // difference in the width of the glyph. shaping.advance[glyph_index] -= diff; shaping.abc.abcB -= diff; } } } void UniscribeState::ApplySpacing() { for (size_t run = 0; run < runs_->size(); run++) { Shaping& shaping = shapes_[run]; bool is_rtl = runs_[run].a.fRTL; if (letter_spacing_ != 0) { // RTL text gets padded to the left of each character. We increment the // run's advance to make this happen. This will be balanced out by NOT // adding additional advance to the last glyph in the run. if (is_rtl) shaping.pre_padding += letter_spacing_; // Go through all the glyphs in this run and increase the "advance" to // account for letter spacing. We adjust letter spacing only on cluster // boundaries. // // This works for most scripts, but may have problems with some indic // scripts. This behavior is better than Firefox or IE for Hebrew. for (int i = 0; i < shaping.glyph_length(); i++) { if (shaping.visattr[i].fClusterStart) { // Ick, we need to assign the extra space so that the glyph comes // first, then is followed by the space. This is opposite for RTL. if (is_rtl) { if (i != shaping.glyph_length() - 1) { // All but the last character just get the spacing applied to // their advance. The last character doesn't get anything, shaping.advance[i] += letter_spacing_; shaping.abc.abcB += letter_spacing_; } } else { // LTR case is easier, we just add to the advance. shaping.advance[i] += letter_spacing_; shaping.abc.abcB += letter_spacing_; } } } } // Go through all the characters to find whitespace and insert the extra // wordspacing amount for the glyphs they correspond to. if (word_spacing_ != 0) { for (int i = 0; i < shaping.char_length(); i++) { if (!TreatAsSpace(input_[runs_[run].iCharPos + i])) continue; // The char in question is a word separator... int glyph_index = shaping.logs[i]; // Spaces will not have a glyph in Uniscribe, it will just add // additional advance to the character to the left of the space. The // space's corresponding glyph will be the character following it in // reading order. if (is_rtl) { // In RTL, the glyph to the left of the space is the same as the // first glyph of the following character, so we can just increment // it. shaping.advance[glyph_index] += word_spacing_; shaping.abc.abcB += word_spacing_; } else { // LTR is actually more complex here, we apply it to the previous // character if there is one, otherwise we have to apply it to the // leading space of the run. if (glyph_index == 0) { shaping.pre_padding += word_spacing_; } else { shaping.advance[glyph_index - 1] += word_spacing_; shaping.abc.abcB += word_spacing_; } } } } // word_spacing_ != 0 // Loop for next run... } } // The advance is the ABC width of the run int UniscribeState::AdvanceForItem(int item_index) const { int accum = 0; const Shaping& shaping = shapes_[item_index]; if (shaping.justify->empty()) { // Easy case with no justification, the width is just the ABC width of t // the run. (The ABC width is the sum of the advances). return shaping.abc.abcA + shaping.abc.abcB + shaping.abc.abcC + shaping.pre_padding; } // With justification, we use the justified amounts instead. The // justification array contains both the advance and the extra space // added for justification, so is the width we want. int justification = 0; for (size_t i = 0; i < shaping.justify->size(); i++) justification += shaping.justify[i]; return shaping.pre_padding + justification; } } // namespace gfx