src/third_party/WebKit/Source/platform/fonts/harfbuzz/HarfBuzzShaper.h

   1 /*
   2  * Copyright (C) 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef HarfBuzzShaper_h
  32 #define HarfBuzzShaper_h
  33
  34 #include "hb.h"
  35 #include "platform/fonts/GlyphBuffer.h"
  36 #include "platform/geometry/FloatPoint.h"
  37 #include "platform/text/TextRun.h"
  38 #include "wtf/HashSet.h"
  39 #include "wtf/OwnPtr.h"
  40 #include "wtf/PassOwnPtr.h"
  41 #include "wtf/unicode/CharacterNames.h"
  42 #include "wtf/Vector.h"
  43
  44 namespace WebCore {
  45
  46 class Font;
  47 class SimpleFontData;
  48
  49 class HarfBuzzShaper FINAL {
  50 public:
  51     enum NormalizeMode {
  52         DoNotNormalizeMirrorChars,
  53         NormalizeMirrorChars
  54     };
  55
  56     HarfBuzzShaper(const Font*, const TextRun&);
  57
  58     void setDrawRange(int from, int to);
  59     bool shape(GlyphBuffer* = 0);
  60     FloatPoint adjustStartPoint(const FloatPoint&);
  61     float totalWidth() { return m_totalWidth; }
  62     int offsetForPosition(float targetX);
  63     FloatRect selectionRect(const FloatPoint&, int height, int from, int to);
  64
  65 private:
  66     class HarfBuzzRun {
  67     public:
  68         HarfBuzzRun(const HarfBuzzRun&);
  69         ~HarfBuzzRun();
  70
  71         static PassOwnPtr<HarfBuzzRun> create(const SimpleFontData* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction, hb_script_t script)
  72         {
  73             return adoptPtr(new HarfBuzzRun(fontData, startIndex, numCharacters, direction, script));
  74         }
  75
  76         void applyShapeResult(hb_buffer_t*);
  77         void copyShapeResultAndGlyphPositions(const HarfBuzzRun&);
  78         void setGlyphAndPositions(unsigned index, uint16_t glyphId, float advance, float offsetX, float offsetY);
  79         void setWidth(float width) { m_width = width; }
  80
  81         int characterIndexForXPosition(float targetX);
  82         float xPositionForOffset(unsigned offset);
  83
  84         const SimpleFontData* fontData() { return m_fontData; }
  85         unsigned startIndex() const { return m_startIndex; }
  86         unsigned numCharacters() const { return m_numCharacters; }
  87         unsigned numGlyphs() const { return m_numGlyphs; }
  88         uint16_t* glyphs() { return &m_glyphs[0]; }
  89         float* advances() { return &m_advances[0]; }
  90         FloatPoint* offsets() { return &m_offsets[0]; }
  91         bool hasGlyphToCharacterIndexes() const
  92         {
  93             return m_glyphToCharacterIndexes.size() > 0;
  94         }
  95         uint16_t* glyphToCharacterIndexes()
  96         {
  97             return &m_glyphToCharacterIndexes[0];
  98         }
  99         float width() { return m_width; }
 100         bool rtl() { return m_direction == RTL; }
 101         hb_script_t script() { return m_script; }
 102
 103     private:
 104         HarfBuzzRun(const SimpleFontData*, unsigned startIndex, unsigned numCharacters, TextDirection, hb_script_t);
 105
 106         const SimpleFontData* m_fontData;
 107         unsigned m_startIndex;
 108         size_t m_numCharacters;
 109         unsigned m_numGlyphs;
 110         TextDirection m_direction;
 111         hb_script_t m_script;
 112         Vector<uint16_t, 256> m_glyphs;
 113         Vector<float, 256> m_advances;
 114         Vector<uint16_t, 256> m_glyphToCharacterIndexes;
 115         Vector<FloatPoint, 256> m_offsets;
 116         float m_width;
 117     };
 118
 119     void setNormalizedBuffer(NormalizeMode = DoNotNormalizeMirrorChars);
 120
 121     bool isWordEnd(unsigned);
 122     int determineWordBreakSpacing();
 123     // setPadding sets a number of pixels to be distributed across the TextRun.
 124     // WebKit uses this to justify text.
 125     void setPadding(int);
 126
 127     // In complex text word-spacing affects each line-break, space (U+0020) and non-breaking space (U+00A0).
 128     static bool isCodepointSpace(UChar c) { return c == ' ' || c == noBreakSpace || c == '\n'; }
 129
 130     void setFontFeatures();
 131
 132     bool createHarfBuzzRuns();
 133     bool shapeHarfBuzzRuns();
 134     bool fillGlyphBuffer(GlyphBuffer*);
 135     void fillGlyphBufferFromHarfBuzzRun(GlyphBuffer*, HarfBuzzRun*, FloatPoint& firstOffsetOfNextRun);
 136     void setGlyphPositionsForHarfBuzzRun(HarfBuzzRun*, hb_buffer_t*);
 137     void addHarfBuzzRun(unsigned startCharacter, unsigned endCharacter, const SimpleFontData*, UScriptCode);
 138
 139     GlyphBufferAdvance createGlyphBufferAdvance(float, float);
 140
 141     const Font* m_font;
 142     OwnPtr<UChar[]> m_normalizedBuffer;
 143     unsigned m_normalizedBufferLength;
 144     const TextRun& m_run;
 145
 146     float m_wordSpacingAdjustment; // Delta adjustment (pixels) for each word break.
 147     float m_padding; // Pixels to be distributed over the line at word breaks.
 148     float m_padPerWordBreak; // Pixels to be added to each word break.
 149     float m_padError; // m_padPerWordBreak might have a fractional component. Since we only add a whole number of padding pixels at each word break we accumulate error. This is the number of pixels that we are behind so far.
 150     float m_letterSpacing; // Pixels to be added after each glyph.
 151
 152     Vector<hb_feature_t, 4> m_features;
 153     Vector<OwnPtr<HarfBuzzRun>, 16> m_harfBuzzRuns;
 154
 155     FloatPoint m_startOffset;
 156
 157     int m_fromIndex;
 158     int m_toIndex;
 159
 160     float m_totalWidth;
 161
 162     friend struct CachedShapingResults;
 163 };
 164
 165 } // namespace WebCore
 166
 167 #endif // HarfBuzzShaper_h