| /* |
| * Copyright (c) 2006, 2007, 2008, 2009, Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| // A wrapper around Uniscribe that provides a reasonable API. |
| |
| #ifndef UniscribeHelper_h |
| #define UniscribeHelper_h |
| |
| #include <windows.h> |
| #include <usp10.h> |
| #include <map> |
| |
| #include <unicode/uchar.h> |
| #include <wtf/Vector.h> |
| |
| class UniscribeTest_TooBig_Test; // A gunit test for UniscribeHelper. |
| |
| namespace WebCore { |
| |
| class FontFeatureSettings; |
| class GraphicsContext; |
| |
| const unsigned cUniscribeHelperStackRuns = 8; |
| const unsigned cUniscribeHelperStackChars = 32; |
| const unsigned cUniscribeHelperFeatures = 4; |
| |
| // This object should be safe to create & destroy frequently, as long as the |
| // caller preserves the script_cache when possible (this data may be slow to |
| // compute). |
| // |
| // This object is "kind of large" (~1K) because it reserves a lot of space for |
| // working with to avoid expensive heap operations. Therefore, not only should |
| // you not worry about creating and destroying it, you should try to not keep |
| // them around. |
| class UniscribeHelper { |
| public: |
| // Initializes this Uniscribe run with the text pointed to by |run| with |
| // |length|. The input is NOT null terminated. |
| // |
| // The is_rtl flag should be set if the input script is RTL. It is assumed |
| // that the caller has already divided up the input text (using ICU, for |
| // example) into runs of the same direction of script. This avoids |
| // disagreements between the caller and Uniscribe later (see FillItems). |
| // |
| // A script cache should be provided by the caller that is initialized to |
| // NULL. When the caller is done with the cache (it may be stored between |
| // runs as long as it is used consistently with the same HFONT), it should |
| // call ScriptFreeCache(). |
| UniscribeHelper(const UChar* input, |
| int inputLength, |
| bool isRtl, |
| HFONT, |
| SCRIPT_CACHE*, |
| SCRIPT_FONTPROPERTIES*, |
| WORD); |
| |
| virtual ~UniscribeHelper(); |
| |
| // Sets Uniscribe's directional override flag. False by default. |
| bool directionalOverride() const |
| { |
| return m_directionalOverride; |
| } |
| void setDirectionalOverride(bool override) |
| { |
| m_directionalOverride = override; |
| } |
| |
| // Set's Uniscribe's no-ligate override flag. False by default. |
| bool inhibitLigate() const |
| { |
| return m_inhibitLigate; |
| } |
| void setInhibitLigate(bool inhibit) |
| { |
| m_inhibitLigate = inhibit; |
| } |
| |
| // Set letter spacing. We will try to insert this much space between |
| // graphemes (one or more glyphs perceived as a single unit by ordinary |
| // users of a script). Positive values increase letter spacing, negative |
| // values decrease it. 0 by default. |
| int letterSpacing() const |
| { |
| return m_letterSpacing; |
| } |
| void setLetterSpacing(int letterSpacing) |
| { |
| m_letterSpacing = letterSpacing; |
| } |
| |
| // Set the width of a standard space character. We use this to normalize |
| // space widths. Windows will make spaces after Hindi characters larger than |
| // other spaces. A space_width of 0 means to use the default space width. |
| // |
| // Must be set before Init() is called. |
| int spaceWidth() const |
| { |
| return m_spaceWidth; |
| } |
| void setSpaceWidth(int spaceWidth) |
| { |
| m_spaceWidth = spaceWidth; |
| } |
| |
| // Set word spacing. We will try to insert this much extra space between |
| // each word in the input (beyond whatever whitespace character separates |
| // words). Positive values lead to increased letter spacing, negative values |
| // decrease it. 0 by default. |
| // |
| // Must be set before Init() is called. |
| int wordSpacing() const |
| { |
| return m_wordSpacing; |
| } |
| void setWordSpacing(int wordSpacing) |
| { |
| m_wordSpacing = wordSpacing; |
| } |
| |
| void setAscent(int ascent) |
| { |
| m_ascent = ascent; |
| } |
| |
| // When set to true, this class is used only to look up glyph |
| // indices for a range of Unicode characters without glyph placement. |
| // By default, it's false. This should be set to true when this |
| // class is used for glyph index look-up for non-BMP characters |
| // in GlyphPageNodeChromiumWin.cpp. |
| void setDisableFontFallback(bool disableFontFallback) |
| { |
| m_disableFontFallback = true; |
| } |
| |
| // Set TEXTRANGE_PROPERTIES structure which contains |
| // OpenType feature records generated from FontFeatureSettings. |
| void setRangeProperties(const FontFeatureSettings*); |
| |
| // You must call this after setting any options but before doing any |
| // other calls like asking for widths or drawing. |
| void init() |
| { |
| initWithOptionalLengthProtection(true); |
| } |
| |
| // Returns the total width in pixels of the text run. |
| int width() const; |
| |
| // Call to justify the text, with the amount of space that should be ADDED |
| // to get the desired width that the column should be justified to. |
| // Normally, spaces are inserted, but for Arabic there will be kashidas |
| // (extra strokes) inserted instead. |
| // |
| // This function MUST be called AFTER Init(). |
| void justify(int additionalSpace); |
| |
| // Computes the given character offset into a pixel offset of the beginning |
| // of that character. |
| int characterToX(int offset) const; |
| |
| // Converts the given pixel X position into a logical character offset into |
| // the run. For positions appearing before the first character, this will |
| // return -1. |
| int xToCharacter(int x) const; |
| |
| // Draws the given characters to (x, y) in the given DC. The font will be |
| // handled by this function, but the font color and other attributes should |
| // be pre-set. |
| // |
| // The y position is the upper left corner, NOT the baseline. |
| void draw(GraphicsContext* graphicsContext, HDC dc, int x, int y, int from, |
| int to); |
| |
| // Returns the first glyph assigned to the character at the given offset. |
| // This function is used to retrieve glyph information when Uniscribe is |
| // being used to generate glyphs for non-complex, non-BMP (above U+FFFF) |
| // characters. These characters are not otherwise special and have no |
| // complex shaping rules, so we don't otherwise need Uniscribe, except |
| // Uniscribe is the only way to get glyphs for non-BMP characters. |
| // |
| // Returns 0 if there is no glyph for the given character. |
| WORD firstGlyphForCharacter(int charOffset) const; |
| |
| protected: |
| // Backend for init. The flag allows the unit test to specify whether we |
| // should fail early for very long strings like normal, or try to pass the |
| // long string to Uniscribe. The latter provides a way to force failure of |
| // shaping. |
| void initWithOptionalLengthProtection(bool lengthProtection); |
| |
| // Tries to preload the font when the it is not accessible. |
| // This is the default implementation and it does not do anything. |
| virtual void tryToPreloadFont(HFONT) {} |
| |
| private: |
| friend class UniscribeTest_TooBig_Test; |
| |
| // An array corresponding to each item in runs_ containing information |
| // on each of the glyphs that were generated. Like runs_, this is in |
| // reading order. However, for rtl text, the characters within each |
| // item will be reversed. |
| struct Shaping { |
| Shaping() |
| : m_prePadding(0) |
| , m_hfont(NULL) |
| , m_scriptCache(NULL) |
| , m_ascentOffset(0) |
| , m_spaceGlyph(0) |
| { |
| m_abc.abcA = 0; |
| m_abc.abcB = 0; |
| m_abc.abcC = 0; |
| } |
| |
| // Returns the number of glyphs (which will be drawn to the screen) |
| // in this run. |
| int glyphLength() const |
| { |
| return static_cast<int>(m_glyphs.size()); |
| } |
| |
| // Returns the number of characters (that we started with) in this run. |
| int charLength() const |
| { |
| return static_cast<int>(m_logs.size()); |
| } |
| |
| // Returns the advance array that should be used when measuring glyphs. |
| // The returned pointer will indicate an array with glyph_length() |
| // elements and the advance that should be used for each one. This is |
| // either the real advance, or the justified advances if there is one, |
| // and is the array we want to use for measurement. |
| const int* effectiveAdvances() const |
| { |
| if (m_advance.size() == 0) |
| return 0; |
| if (m_justify.size() == 0) |
| return &m_advance[0]; |
| return &m_justify[0]; |
| } |
| |
| // This is the advance amount of space that we have added to the |
| // beginning of the run. It is like the ABC's |A| advance but one that |
| // we create and must handle internally whenever computing with pixel |
| // offsets. |
| int m_prePadding; |
| |
| // Glyph indices in the font used to display this item. These indices |
| // are in screen order. |
| Vector<WORD, cUniscribeHelperStackChars> m_glyphs; |
| |
| // For each input character, this tells us the first glyph index it |
| // generated. This is the only array with size of the input chars. |
| // |
| // All offsets are from the beginning of this run. Multiple characters |
| // can generate one glyph, in which case there will be adjacent |
| // duplicates in this list. One character can also generate multiple |
| // glyphs, in which case there will be skipped indices in this list. |
| Vector<WORD, cUniscribeHelperStackChars> m_logs; |
| |
| // Flags and such for each glyph. |
| Vector<SCRIPT_VISATTR, cUniscribeHelperStackChars> m_visualAttributes; |
| |
| // Horizontal advances for each glyph listed above, this is basically |
| // how wide each glyph is. |
| Vector<int, cUniscribeHelperStackChars> m_advance; |
| |
| // This contains glyph offsets, from the nominal position of a glyph. |
| // It is used to adjust the positions of multiple combining characters |
| // around/above/below base characters in a context-sensitive manner so |
| // that they don't bump against each other and the base character. |
| Vector<GOFFSET, cUniscribeHelperStackChars> m_offsets; |
| |
| // Filled by a call to Justify, this is empty for nonjustified text. |
| // If nonempty, this contains the array of justify characters for each |
| // character as returned by ScriptJustify. |
| // |
| // This is the same as the advance array, but with extra space added |
| // for some characters. The difference between a glyph's |justify| |
| // width and it's |advance| width is the extra space added. |
| Vector<int, cUniscribeHelperStackChars> m_justify; |
| |
| // Sizing information for this run. This treats the entire run as a |
| // character with a preceeding advance, width, and ending advance. The |
| // B width is the sum of the |advance| array, and the A and C widths |
| // are any extra spacing applied to each end. |
| // |
| // It is unclear from the documentation what this actually means. From |
| // experimentation, it seems that the sum of the character advances is |
| // always the sum of the ABC values, and I'm not sure what you're |
| // supposed to do with the ABC values. |
| ABC m_abc; |
| |
| // Pointers to windows font data used to render this run. |
| HFONT m_hfont; |
| SCRIPT_CACHE* m_scriptCache; |
| |
| // Ascent offset between the ascent of the primary font |
| // and that of the fallback font. The offset needs to be applied, |
| // when drawing a string, to align multiple runs rendered with |
| // different fonts. |
| int m_ascentOffset; |
| |
| WORD m_spaceGlyph; |
| }; |
| |
| // Computes the runs_ array from the text run. |
| void fillRuns(); |
| |
| // Computes the shapes_ array given an runs_ array already filled in. |
| void fillShapes(); |
| |
| // Fills in the screen_order_ array (see below). |
| void fillScreenOrder(); |
| |
| // Called to update the glyph positions based on the current spacing |
| // options that are set. |
| void applySpacing(); |
| |
| // Normalizes all advances for spaces to the same width. This keeps windows |
| // from making spaces after Hindi characters larger, which is then |
| // inconsistent with our meaure of the width since WebKit doesn't include |
| // spaces in text-runs sent to uniscribe unless white-space:pre. |
| void adjustSpaceAdvances(); |
| |
| // Returns the total width of a single item. |
| int advanceForItem(int) const; |
| |
| bool containsMissingGlyphs(const Shaping&, |
| const SCRIPT_ITEM&, |
| const SCRIPT_FONTPROPERTIES*) const; |
| |
| // Shapes a run (pointed to by |input|) using |hfont| first. |
| // Tries a series of fonts specified retrieved with NextWinFontData |
| // and finally a font covering characters in |*input|. A string pointed |
| // by |input| comes from ScriptItemize and is supposed to contain |
| // characters belonging to a single script aside from characters common to |
| // all scripts (e.g. space). |
| bool shape(const UChar* input, int itemLength, int numGlyphs, SCRIPT_ITEM& run, OPENTYPE_TAG, Shaping&); |
| |
| // Gets Windows font data for the next best font to try in the list |
| // of fonts. When there's no more font available, returns false |
| // without touching any of out params. Need to call ResetFontIndex |
| // to start scanning of the font list from the beginning. |
| virtual bool nextWinFontData(HFONT*, SCRIPT_CACHE**, SCRIPT_FONTPROPERTIES**, int* ascent) |
| { |
| return false; |
| } |
| |
| // Resets the font index to the first in the list of fonts to try after the |
| // primaryFont turns out not to work. With fontIndex reset, |
| // NextWinFontData scans fallback fonts from the beginning. |
| virtual void resetFontIndex() {} |
| |
| // If m_cachedDC is 0, creates one that is compatible with the screen DC. |
| void EnsureCachedDCCreated(); |
| |
| // The input data for this run of Uniscribe. See the constructor. |
| const UChar* m_input; |
| const int m_inputLength; |
| const bool m_isRtl; |
| |
| // Windows font data for the primary font. In a sense, m_logfont and m_style |
| // are redundant because m_hfont contains all the information. However, |
| // invoking GetObject, everytime we need the height and the style, is rather |
| // expensive so that we cache them. Would it be better to add getter and |
| // (virtual) setter for the height and the style of the primary font, |
| // instead of m_logfont? Then, a derived class ctor can set m_ascent, |
| // m_height and m_style if they're known. Getters for them would have to |
| // 'infer' their values from m_hfont ONLY when they're not set. |
| HFONT m_hfont; |
| // We cache the DC to use with ScriptShape/ScriptPlace. |
| static HDC m_cachedDC; |
| SCRIPT_CACHE* m_scriptCache; |
| SCRIPT_FONTPROPERTIES* m_fontProperties; |
| int m_ascent; |
| LOGFONT m_logfont; |
| int m_style; |
| WORD m_spaceGlyph; |
| |
| // Options, see the getters/setters above. |
| bool m_directionalOverride; |
| bool m_inhibitLigate; |
| int m_letterSpacing; |
| int m_spaceWidth; |
| int m_wordSpacing; |
| bool m_disableFontFallback; |
| |
| // Uniscribe breaks the text into Runs. These are one length of text that is |
| // in one script and one direction. This array is in reading order. |
| Vector<SCRIPT_ITEM, cUniscribeHelperStackRuns> m_runs; |
| |
| Vector<Shaping, cUniscribeHelperStackRuns> m_shapes; |
| Vector<OPENTYPE_TAG, cUniscribeHelperStackRuns> m_scriptTags; |
| |
| // This is a mapping between reading order and screen order for the items. |
| // Uniscribe's items array are in reading order. For right-to-left text, |
| // or mixed (although WebKit's |TextRun| should really be only one |
| // direction), this makes it very difficult to compute character offsets |
| // and positions. This list is in screen order from left to right, and |
| // gives the index into the |m_runs| and |m_shapes| arrays of each |
| // subsequent item. |
| Vector<int, cUniscribeHelperStackRuns> m_screenOrder; |
| |
| // This contains Uniscribe's OpenType feature settings. This structure |
| // is filled by using WebKit's |FontFeatureSettings|. |
| TEXTRANGE_PROPERTIES m_rangeProperties; |
| Vector<OPENTYPE_FEATURE_RECORD, cUniscribeHelperFeatures> m_featureRecords; |
| }; |
| |
| } // namespace WebCore |
| |
| #endif // UniscribeHelper_h |