Font metrics, version 1

Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 160 matching lines @@
 #if ENABLE(SVG_FONTS)
     if (TextRun::RenderingContext* renderingContext = run.renderingContext())
         return renderingContext->floatWidthUsingSVGFont(*this, run, charsConsumed, glyphId);
 #endif
 
     charsConsumed = run.length();
     glyphId = 0;
     return width(run);
 }
 
-FloatRect Font::selectionRectForText(const TextRun& run, const FloatPoint& point, int h, int from, int to) const
+FloatRect Font::selectionRectForText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
     to = (to == -1 ? run.length() : to);
 
     CodePath codePathToUse = codePath(run);
     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
     if (codePathToUse != ComplexPath && fontDescription().typesettingFeatures() && (from || to != run.length()))
         codePathToUse = ComplexPath;
 
     if (codePathToUse != ComplexPath)
-        return selectionRectForSimpleText(run, point, h, from, to);
+        return selectionRectForSimpleText(run, point, h, from, to, accountForGlyphBounds);
 
     return selectionRectForComplexText(run, point, h, from, to);
 }
 
 int Font::offsetForPosition(const TextRun& run, float x, bool includePartialGlyphs) const
 {
     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
     if (codePath(run) != ComplexPath && !fontDescription().typesettingFeatures())
         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
 
@@ skipping 546 matching lines @@
     if (glyphOverflow) {
         glyphOverflow->top = max<int>(glyphOverflow->top, ceilf(-it.minGlyphBoundingBoxY()) - (glyphOverflow->computeBounds ? 0 : fontMetrics().ascent()));
         glyphOverflow->bottom = max<int>(glyphOverflow->bottom, ceilf(it.maxGlyphBoundingBoxY()) - (glyphOverflow->computeBounds ? 0 : fontMetrics().descent()));
         glyphOverflow->left = ceilf(it.firstGlyphOverflow());
         glyphOverflow->right = ceilf(it.lastGlyphOverflow());
     }
 
     return it.m_runWidthSoFar;
 }
 
-FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FloatPoint& point, int h, int from, int to) const
+FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
     GlyphBuffer glyphBuffer;
-    WidthIterator it(this, run);
+    WidthIterator it(this, run, 0, accountForGlyphBounds);
     it.advance(from, &glyphBuffer);
     float beforeWidth = it.m_runWidthSoFar;
     it.advance(to, &glyphBuffer);
     float afterWidth = it.m_runWidthSoFar;
 
     // Using roundf() rather than ceilf() for the right edge as a compromise to
     // ensure correct caret positioning.
     // Use LayoutUnit::epsilon() to ensure that values that cannot be stored as
     // an integer are floored to n and not n-1 due to floating point imprecision.
     if (run.rtl()) {
         it.advance(run.length(), &glyphBuffer);
         float totalWidth = it.m_runWidthSoFar;
         float pixelAlignedX = floorf(point.x() + totalWidth - afterWidth + LayoutUnit::epsilon());
-        return FloatRect(pixelAlignedX, point.y(),
-            roundf(point.x() + totalWidth - beforeWidth) - pixelAlignedX, h);
+        return FloatRect(pixelAlignedX, accountForGlyphBounds ? it.minGlyphBoundingBoxY() : point.y(),
+            roundf(point.x() + totalWidth - beforeWidth) - pixelAlignedX,
+            accountForGlyphBounds ? it.maxGlyphBoundingBoxY() - it.minGlyphBoundingBoxY() : h);
     }
 
     float pixelAlignedX = floorf(point.x() + beforeWidth + LayoutUnit::epsilon());
-    return FloatRect(pixelAlignedX, point.y(),
-        roundf(point.x() + afterWidth) - pixelAlignedX, h);
+    return FloatRect(pixelAlignedX, accountForGlyphBounds ? it.minGlyphBoundingBoxY() : point.y(),
+        roundf(point.x() + afterWidth) - pixelAlignedX,
+        accountForGlyphBounds ? it.maxGlyphBoundingBoxY() - it.minGlyphBoundingBoxY() : h);
 }
 
 int Font::offsetForPositionForSimpleText(const TextRun& run, float x, bool includePartialGlyphs) const
 {
     float delta = x;
 
     WidthIterator it(this, run);
     GlyphBuffer localGlyphBuffer;
     unsigned offset;
     if (run.rtl()) {
@@ skipping 26 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 }