gfx/src/nsFontMetrics.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsFontMetrics.h"
   7 #include "nsBoundingMetrics.h"
   8 #include "nsRenderingContext.h"
   9 #include "nsDeviceContext.h"
  10 #include "nsStyleConsts.h"
  11 #include <algorithm>
  12
  13 namespace {
  14
  15 class AutoTextRun {
  16 public:
  17     AutoTextRun(nsFontMetrics* aMetrics, nsRenderingContext* aRC,
  18                 const char* aString, int32_t aLength)
  19     {
  20         mTextRun = aMetrics->GetThebesFontGroup()->MakeTextRun(
  21             reinterpret_cast<const uint8_t*>(aString), aLength,
  22             aRC->ThebesContext(),
  23             aMetrics->AppUnitsPerDevPixel(),
  24             ComputeFlags(aMetrics));
  25     }
  26
  27     AutoTextRun(nsFontMetrics* aMetrics, nsRenderingContext* aRC,
  28                 const PRUnichar* aString, int32_t aLength)
  29     {
  30         mTextRun = aMetrics->GetThebesFontGroup()->MakeTextRun(
  31             aString, aLength,
  32             aRC->ThebesContext(),
  33             aMetrics->AppUnitsPerDevPixel(),
  34             ComputeFlags(aMetrics));
  35     }
  36
  37     gfxTextRun *get() { return mTextRun; }
  38     gfxTextRun *operator->() { return mTextRun; }
  39
  40 private:
  41     static uint32_t ComputeFlags(nsFontMetrics* aMetrics) {
  42         uint32_t flags = 0;
  43         if (aMetrics->GetTextRunRTL()) {
  44             flags |= gfxTextRunFactory::TEXT_IS_RTL;
  45         }
  46         return flags;
  47     }
  48
  49     nsAutoPtr<gfxTextRun> mTextRun;
  50 };
  51
  52 class StubPropertyProvider : public gfxTextRun::PropertyProvider {
  53 public:
  54     virtual void GetHyphenationBreaks(uint32_t aStart, uint32_t aLength,
  55                                       bool* aBreakBefore) {
  56         NS_ERROR("This shouldn't be called because we never call BreakAndMeasureText");
  57     }
  58     virtual int8_t GetHyphensOption() {
  59         NS_ERROR("This shouldn't be called because we never call BreakAndMeasureText");
  60         return NS_STYLE_HYPHENS_NONE;
  61     }
  62     virtual gfxFloat GetHyphenWidth() {
  63         NS_ERROR("This shouldn't be called because we never enable hyphens");
  64         return 0;
  65     }
  66     virtual void GetSpacing(uint32_t aStart, uint32_t aLength,
  67                             Spacing* aSpacing) {
  68         NS_ERROR("This shouldn't be called because we never enable spacing");
  69     }
  70 };
  71
  72 } // anon namespace
  73
  74 nsFontMetrics::nsFontMetrics()
  75     : mDeviceContext(nullptr), mP2A(0), mTextRunRTL(false)
  76 {
  77 }
  78
  79 nsFontMetrics::~nsFontMetrics()
  80 {
  81     if (mDeviceContext)
  82         mDeviceContext->FontMetricsDeleted(this);
  83 }
  84
  85 nsresult
  86 nsFontMetrics::Init(const nsFont& aFont, nsIAtom* aLanguage,
  87                     nsDeviceContext *aContext,
  88                     gfxUserFontSet *aUserFontSet)
  89 {
  90     NS_ABORT_IF_FALSE(mP2A == 0, "already initialized");
  91
  92     mFont = aFont;
  93     mLanguage = aLanguage;
  94     mDeviceContext = aContext;
  95     mP2A = mDeviceContext->AppUnitsPerDevPixel();
  96
  97     gfxFontStyle style(aFont.style,
  98                        aFont.weight,
  99                        aFont.stretch,
 100                        gfxFloat(aFont.size) / mP2A,
 101                        aLanguage,
 102                        aFont.sizeAdjust,
 103                        aFont.systemFont,
 104                        mDeviceContext->IsPrinterSurface(),
 105                        aFont.languageOverride);
 106
 107     aFont.AddFontFeaturesToStyle(&style);
 108
 109     mFontGroup = gfxPlatform::GetPlatform()->
 110         CreateFontGroup(aFont.name, &style, aUserFontSet);
 111     if (mFontGroup->FontListLength() < 1)
 112         return NS_ERROR_UNEXPECTED;
 113
 114     return NS_OK;
 115 }
 116
 117 void
 118 nsFontMetrics::Destroy()
 119 {
 120     mDeviceContext = nullptr;
 121 }
 122
 123 // XXXTODO get rid of this macro
 124 #define ROUND_TO_TWIPS(x) (nscoord)floor(((x) * mP2A) + 0.5)
 125 #define CEIL_TO_TWIPS(x) (nscoord)ceil((x) * mP2A)
 126
 127 const gfxFont::Metrics& nsFontMetrics::GetMetrics() const
 128 {
 129     return mFontGroup->GetFontAt(0)->GetMetrics();
 130 }
 131
 132 nscoord
 133 nsFontMetrics::XHeight()
 134 {
 135     return ROUND_TO_TWIPS(GetMetrics().xHeight);
 136 }
 137
 138 nscoord
 139 nsFontMetrics::SuperscriptOffset()
 140 {
 141     return ROUND_TO_TWIPS(GetMetrics().superscriptOffset);
 142 }
 143
 144 nscoord
 145 nsFontMetrics::SubscriptOffset()
 146 {
 147     return ROUND_TO_TWIPS(GetMetrics().subscriptOffset);
 148 }
 149
 150 void
 151 nsFontMetrics::GetStrikeout(nscoord& aOffset, nscoord& aSize)
 152 {
 153     aOffset = ROUND_TO_TWIPS(GetMetrics().strikeoutOffset);
 154     aSize = ROUND_TO_TWIPS(GetMetrics().strikeoutSize);
 155 }
 156
 157 void
 158 nsFontMetrics::GetUnderline(nscoord& aOffset, nscoord& aSize)
 159 {
 160     aOffset = ROUND_TO_TWIPS(mFontGroup->GetUnderlineOffset());
 161     aSize = ROUND_TO_TWIPS(GetMetrics().underlineSize);
 162 }
 163
 164 // GetMaxAscent/GetMaxDescent/GetMaxHeight must contain the
 165 // text-decoration lines drawable area. See bug 421353.
 166 // BE CAREFUL for rounding each values. The logic MUST be same as
 167 // nsCSSRendering::GetTextDecorationRectInternal's.
 168
 169 static gfxFloat ComputeMaxDescent(const gfxFont::Metrics& aMetrics,
 170                                   gfxFontGroup* aFontGroup)
 171 {
 172     gfxFloat offset = floor(-aFontGroup->GetUnderlineOffset() + 0.5);
 173     gfxFloat size = NS_round(aMetrics.underlineSize);
 174     gfxFloat minDescent = floor(offset + size + 0.5);
 175     return std::max(minDescent, aMetrics.maxDescent);
 176 }
 177
 178 static gfxFloat ComputeMaxAscent(const gfxFont::Metrics& aMetrics)
 179 {
 180     return floor(aMetrics.maxAscent + 0.5);
 181 }
 182
 183 nscoord
 184 nsFontMetrics::InternalLeading()
 185 {
 186     return ROUND_TO_TWIPS(GetMetrics().internalLeading);
 187 }
 188
 189 nscoord
 190 nsFontMetrics::ExternalLeading()
 191 {
 192     return ROUND_TO_TWIPS(GetMetrics().externalLeading);
 193 }
 194
 195 nscoord
 196 nsFontMetrics::EmHeight()
 197 {
 198     return ROUND_TO_TWIPS(GetMetrics().emHeight);
 199 }
 200
 201 nscoord
 202 nsFontMetrics::EmAscent()
 203 {
 204     return ROUND_TO_TWIPS(GetMetrics().emAscent);
 205 }
 206
 207 nscoord
 208 nsFontMetrics::EmDescent()
 209 {
 210     return ROUND_TO_TWIPS(GetMetrics().emDescent);
 211 }
 212
 213 nscoord
 214 nsFontMetrics::MaxHeight()
 215 {
 216     return CEIL_TO_TWIPS(ComputeMaxAscent(GetMetrics())) +
 217         CEIL_TO_TWIPS(ComputeMaxDescent(GetMetrics(), mFontGroup));
 218 }
 219
 220 nscoord
 221 nsFontMetrics::MaxAscent()
 222 {
 223     return CEIL_TO_TWIPS(ComputeMaxAscent(GetMetrics()));
 224 }
 225
 226 nscoord
 227 nsFontMetrics::MaxDescent()
 228 {
 229     return CEIL_TO_TWIPS(ComputeMaxDescent(GetMetrics(), mFontGroup));
 230 }
 231
 232 nscoord
 233 nsFontMetrics::MaxAdvance()
 234 {
 235     return CEIL_TO_TWIPS(GetMetrics().maxAdvance);
 236 }
 237
 238 nscoord
 239 nsFontMetrics::AveCharWidth()
 240 {
 241     // Use CEIL instead of ROUND for consistency with GetMaxAdvance
 242     return CEIL_TO_TWIPS(GetMetrics().aveCharWidth);
 243 }
 244
 245 nscoord
 246 nsFontMetrics::SpaceWidth()
 247 {
 248     return CEIL_TO_TWIPS(GetMetrics().spaceWidth);
 249 }
 250
 251 int32_t
 252 nsFontMetrics::GetMaxStringLength()
 253 {
 254     const gfxFont::Metrics& m = GetMetrics();
 255     const double x = 32767.0 / m.maxAdvance;
 256     int32_t len = (int32_t)floor(x);
 257     return std::max(1, len);
 258 }
 259
 260 nscoord
 261 nsFontMetrics::GetWidth(const char* aString, uint32_t aLength,
 262                         nsRenderingContext *aContext)
 263 {
 264     if (aLength == 0)
 265         return 0;
 266
 267     if (aLength == 1 && aString[0] == ' ')
 268         return SpaceWidth();
 269
 270     StubPropertyProvider provider;
 271     AutoTextRun textRun(this, aContext, aString, aLength);
 272     return textRun.get() ?
 273         NSToCoordRound(textRun->GetAdvanceWidth(0, aLength, &provider)) : 0;
 274 }
 275
 276 nscoord
 277 nsFontMetrics::GetWidth(const PRUnichar* aString, uint32_t aLength,
 278                         nsRenderingContext *aContext)
 279 {
 280     if (aLength == 0)
 281         return 0;
 282
 283     if (aLength == 1 && aString[0] == ' ')
 284         return SpaceWidth();
 285
 286     StubPropertyProvider provider;
 287     AutoTextRun textRun(this, aContext, aString, aLength);
 288     return textRun.get() ?
 289         NSToCoordRound(textRun->GetAdvanceWidth(0, aLength, &provider)) : 0;
 290 }
 291
 292 // Draw a string using this font handle on the surface passed in.
 293 void
 294 nsFontMetrics::DrawString(const char *aString, uint32_t aLength,
 295                           nscoord aX, nscoord aY,
 296                           nsRenderingContext *aContext)
 297 {
 298     if (aLength == 0)
 299         return;
 300
 301     StubPropertyProvider provider;
 302     AutoTextRun textRun(this, aContext, aString, aLength);
 303     if (!textRun.get()) {
 304         return;
 305     }
 306     gfxPoint pt(aX, aY);
 307     if (mTextRunRTL) {
 308         pt.x += textRun->GetAdvanceWidth(0, aLength, &provider);
 309     }
 310     textRun->Draw(aContext->ThebesContext(), pt, gfxFont::GLYPH_FILL, 0, aLength,
 311                   &provider, nullptr, nullptr);
 312 }
 313
 314 void
 315 nsFontMetrics::DrawString(const PRUnichar* aString, uint32_t aLength,
 316                           nscoord aX, nscoord aY,
 317                           nsRenderingContext *aContext,
 318                           nsRenderingContext *aTextRunConstructionContext)
 319 {
 320     if (aLength == 0)
 321         return;
 322
 323     StubPropertyProvider provider;
 324     AutoTextRun textRun(this, aTextRunConstructionContext, aString, aLength);
 325     if (!textRun.get()) {
 326         return;
 327     }
 328     gfxPoint pt(aX, aY);
 329     if (mTextRunRTL) {
 330         pt.x += textRun->GetAdvanceWidth(0, aLength, &provider);
 331     }
 332     textRun->Draw(aContext->ThebesContext(), pt, gfxFont::GLYPH_FILL, 0, aLength,
 333                   &provider, nullptr, nullptr);
 334 }
 335
 336 static nsBoundingMetrics
 337 GetTextBoundingMetrics(nsFontMetrics* aMetrics, const PRUnichar *aString, uint32_t aLength,
 338                        nsRenderingContext *aContext, gfxFont::BoundingBoxType aType)
 339 {
 340     if (aLength == 0)
 341         return nsBoundingMetrics();
 342
 343     StubPropertyProvider provider;
 344     AutoTextRun textRun(aMetrics, aContext, aString, aLength);
 345     nsBoundingMetrics m;
 346     if (textRun.get()) {
 347         gfxTextRun::Metrics theMetrics =
 348             textRun->MeasureText(0, aLength,
 349                                  aType,
 350                                  aContext->ThebesContext(), &provider);
 351
 352         m.leftBearing  = NSToCoordFloor( theMetrics.mBoundingBox.X());
 353         m.rightBearing = NSToCoordCeil(  theMetrics.mBoundingBox.XMost());
 354         m.ascent       = NSToCoordCeil( -theMetrics.mBoundingBox.Y());
 355         m.descent      = NSToCoordCeil(  theMetrics.mBoundingBox.YMost());
 356         m.width        = NSToCoordRound( theMetrics.mAdvanceWidth);
 357     }
 358     return m;
 359 }
 360
 361 nsBoundingMetrics
 362 nsFontMetrics::GetBoundingMetrics(const PRUnichar *aString, uint32_t aLength,
 363                                   nsRenderingContext *aContext)
 364 {
 365   return GetTextBoundingMetrics(this, aString, aLength, aContext, gfxFont::TIGHT_HINTED_OUTLINE_EXTENTS);
 366
 367 }
 368
 369 nsBoundingMetrics
 370 nsFontMetrics::GetInkBoundsForVisualOverflow(const PRUnichar *aString, uint32_t aLength,
 371                                              nsRenderingContext *aContext)
 372 {
 373   return GetTextBoundingMetrics(this, aString, aLength, aContext, gfxFont::LOOSE_INK_EXTENTS);
 374 }
 375