src/third_party/WebKit/Source/platform/fonts/mac/FontComplexTextMac.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 2008, 2009 Apple 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
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include "config.h"
  26 #include "platform/fonts/Font.h"
  27
  28 #include "platform/fonts/Character.h"
  29 #include "platform/fonts/FontFallbackList.h"
  30 #include "platform/fonts/GlyphBuffer.h"
  31 #include "platform/fonts/SimpleFontData.h"
  32 #include "platform/fonts/harfbuzz/HarfBuzzShaper.h"
  33 #include "platform/fonts/mac/ComplexTextController.h"
  34 #include "platform/geometry/IntRect.h"
  35 #include "platform/graphics/GraphicsContext.h"
  36 #include "platform/text/TextRun.h"
  37 #include "wtf/MathExtras.h"
  38
  39 using namespace std;
  40
  41 namespace WebCore {
  42
  43 static bool preferHarfBuzz(const Font* font)
  44 {
  45     const FontDescription& description = font->fontDescription();
  46     return description.featureSettings() && description.featureSettings()->size() > 0;
  47 }
  48
  49 FloatRect Font::selectionRectForComplexText(const TextRun& run, const FloatPoint& point, int h,
  50                                             int from, int to) const
  51 {
  52     if (preferHarfBuzz(this)) {
  53         HarfBuzzShaper shaper(this, run);
  54         if (shaper.shape())
  55             return shaper.selectionRect(point, h, from, to);
  56     }
  57     ComplexTextController controller(this, run);
  58     controller.advance(from);
  59     float beforeWidth = controller.runWidthSoFar();
  60     controller.advance(to);
  61     float afterWidth = controller.runWidthSoFar();
  62
  63     // Using roundf() rather than ceilf() for the right edge as a compromise to ensure correct caret positioning
  64     if (run.rtl()) {
  65         float totalWidth = controller.totalWidth();
  66         return FloatRect(floorf(point.x() + totalWidth - afterWidth), point.y(), roundf(point.x() + totalWidth - beforeWidth) - floorf(point.x() + totalWidth - afterWidth), h);
  67     }
  68
  69     return FloatRect(floorf(point.x() + beforeWidth), point.y(), roundf(point.x() + afterWidth) - floorf(point.x() + beforeWidth), h);
  70 }
  71
  72 float Font::getGlyphsAndAdvancesForComplexText(const TextRun& run, int from, int to, GlyphBuffer& glyphBuffer, ForTextEmphasisOrNot forTextEmphasis) const
  73 {
  74     float initialAdvance;
  75
  76     ComplexTextController controller(this, run, false, 0, forTextEmphasis);
  77     controller.advance(from);
  78     float beforeWidth = controller.runWidthSoFar();
  79     controller.advance(to, &glyphBuffer);
  80
  81     if (glyphBuffer.isEmpty())
  82         return 0;
  83
  84     float afterWidth = controller.runWidthSoFar();
  85
  86     if (run.rtl()) {
  87         initialAdvance = controller.totalWidth() + controller.finalRoundingWidth() - afterWidth;
  88         glyphBuffer.reverse(0, glyphBuffer.size());
  89     } else
  90         initialAdvance = beforeWidth;
  91
  92     return initialAdvance;
  93 }
  94
  95 void Font::drawComplexText(GraphicsContext* context, const TextRunPaintInfo& runInfo, const FloatPoint& point) const
  96 {
  97     if (preferHarfBuzz(this)) {
  98         GlyphBuffer glyphBuffer;
  99         HarfBuzzShaper shaper(this, runInfo.run);
 100         shaper.setDrawRange(runInfo.from, runInfo.to);
 101         if (shaper.shape(&glyphBuffer)) {
 102             drawGlyphBuffer(context, runInfo, glyphBuffer, point);
 103             return;
 104         }
 105     }
 106     // This glyph buffer holds our glyphs + advances + font data for each glyph.
 107     GlyphBuffer glyphBuffer;
 108
 109     float startX = point.x() + getGlyphsAndAdvancesForComplexText(runInfo.run, runInfo.from, runInfo.to, glyphBuffer);
 110
 111     // We couldn't generate any glyphs for the run.  Give up.
 112     if (glyphBuffer.isEmpty())
 113         return;
 114
 115     // Draw the glyph buffer now at the starting point returned in startX.
 116     FloatPoint startPoint(startX, point.y());
 117     drawGlyphBuffer(context, runInfo, glyphBuffer, startPoint);
 118 }
 119
 120 void Font::drawEmphasisMarksForComplexText(GraphicsContext* context, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point) const
 121 {
 122     GlyphBuffer glyphBuffer;
 123     float initialAdvance = getGlyphsAndAdvancesForComplexText(runInfo.run, runInfo.from, runInfo.to, glyphBuffer, ForTextEmphasis);
 124
 125     if (glyphBuffer.isEmpty())
 126         return;
 127
 128     drawEmphasisMarks(context, runInfo, glyphBuffer, mark, FloatPoint(point.x() + initialAdvance, point.y()));
 129 }
 130
 131 float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 132 {
 133     if (preferHarfBuzz(this)) {
 134         HarfBuzzShaper shaper(this, run);
 135         if (shaper.shape())
 136             return shaper.totalWidth();
 137     }
 138     ComplexTextController controller(this, run, true, fallbackFonts);
 139     if (glyphOverflow) {
 140         glyphOverflow->top = max<int>(glyphOverflow->top, ceilf(-controller.minGlyphBoundingBoxY()) - (glyphOverflow->computeBounds ? 0 : fontMetrics().ascent()));
 141         glyphOverflow->bottom = max<int>(glyphOverflow->bottom, ceilf(controller.maxGlyphBoundingBoxY()) - (glyphOverflow->computeBounds ? 0 : fontMetrics().descent()));
 142         glyphOverflow->left = max<int>(0, ceilf(-controller.minGlyphBoundingBoxX()));
 143         glyphOverflow->right = max<int>(0, ceilf(controller.maxGlyphBoundingBoxX() - controller.totalWidth()));
 144     }
 145     return controller.totalWidth();
 146 }
 147
 148 int Font::offsetForPositionForComplexText(const TextRun& run, float x, bool includePartialGlyphs) const
 149 {
 150     if (preferHarfBuzz(this)) {
 151         HarfBuzzShaper shaper(this, run);
 152         if (shaper.shape())
 153             return shaper.offsetForPosition(x);
 154     }
 155     ComplexTextController controller(this, run);
 156     return controller.offsetForPosition(x, includePartialGlyphs);
 157 }
 158
 159 const SimpleFontData* Font::fontDataForCombiningCharacterSequence(const UChar* characters, size_t length, FontDataVariant variant) const
 160 {
 161     UChar32 baseCharacter;
 162     size_t baseCharacterLength = 0;
 163     U16_NEXT(characters, baseCharacterLength, length, baseCharacter);
 164
 165     GlyphData baseCharacterGlyphData = glyphDataForCharacter(baseCharacter, false, variant);
 166
 167     if (!baseCharacterGlyphData.glyph)
 168         return 0;
 169
 170     if (length == baseCharacterLength)
 171         return baseCharacterGlyphData.fontData;
 172
 173     bool triedBaseCharacterFontData = false;
 174
 175     unsigned i = 0;
 176     for (const FontData* fontData = fontDataAt(0); fontData; fontData = fontDataAt(++i)) {
 177         const SimpleFontData* simpleFontData = fontData->fontDataForCharacter(baseCharacter);
 178         if (variant == NormalVariant) {
 179             if (simpleFontData->platformData().orientation() == Vertical) {
 180                 if (Character::isCJKIdeographOrSymbol(baseCharacter) && !simpleFontData->hasVerticalGlyphs()) {
 181                     variant = BrokenIdeographVariant;
 182                     simpleFontData = simpleFontData->brokenIdeographFontData().get();
 183                 } else if (m_fontDescription.nonCJKGlyphOrientation() == NonCJKGlyphOrientationVerticalRight) {
 184                     SimpleFontData* verticalRightFontData = simpleFontData->verticalRightOrientationFontData().get();
 185                     Glyph verticalRightGlyph = verticalRightFontData->glyphForCharacter(baseCharacter);
 186                     if (verticalRightGlyph == baseCharacterGlyphData.glyph)
 187                         simpleFontData = verticalRightFontData;
 188                 } else {
 189                     SimpleFontData* uprightFontData = simpleFontData->uprightOrientationFontData().get();
 190                     Glyph uprightGlyph = uprightFontData->glyphForCharacter(baseCharacter);
 191                     if (uprightGlyph != baseCharacterGlyphData.glyph)
 192                         simpleFontData = uprightFontData;
 193                 }
 194             }
 195         } else {
 196             if (const SimpleFontData* variantFontData = simpleFontData->variantFontData(m_fontDescription, variant).get())
 197                 simpleFontData = variantFontData;
 198         }
 199
 200         if (simpleFontData == baseCharacterGlyphData.fontData)
 201             triedBaseCharacterFontData = true;
 202
 203         if (simpleFontData->canRenderCombiningCharacterSequence(characters, length))
 204             return simpleFontData;
 205     }
 206
 207     if (!triedBaseCharacterFontData && baseCharacterGlyphData.fontData && baseCharacterGlyphData.fontData->canRenderCombiningCharacterSequence(characters, length))
 208         return baseCharacterGlyphData.fontData;
 209
 210     return SimpleFontData::systemFallback();
 211 }
 212
 213 } // namespace WebCore