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