gfx/src/nsDeviceContext.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set sw=2 ts=2 expandtab: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsDeviceContext.h"
   8 #include <algorithm>  // for max
   9 #include "gfxContext.h"
  10 #include "gfxImageSurface.h"  // for gfxImageSurface
  11 #include "gfxPoint.h"         // for gfxSize
  12 #include "gfxTextRun.h"       // for gfxFontGroup
  13 #include "mozilla/LookAndFeel.h"
  14 #include "mozilla/gfx/PathHelpers.h"
  15 #include "mozilla/gfx/PrintTarget.h"
  16 #include "mozilla/Preferences.h"  // for Preferences
  17 #include "mozilla/Services.h"     // for GetObserverService
  18 #include "mozilla/StaticPrefs_layout.h"
  19 #include "mozilla/mozalloc.h"       // for operator new
  20 #include "mozilla/widget/Screen.h"  // for Screen
  21 #include "nsCRT.h"                  // for nsCRT
  22 #include "nsDebug.h"                // for NS_ASSERTION, etc
  23 #include "nsFont.h"                 // for nsFont
  24 #include "nsFontCache.h"            // for nsFontCache
  25 #include "nsFontMetrics.h"          // for nsFontMetrics
  26 #include "nsAtom.h"                 // for nsAtom, NS_Atomize
  27 #include "nsID.h"
  28 #include "nsIDeviceContextSpec.h"   // for nsIDeviceContextSpec
  29 #include "nsLanguageAtomService.h"  // for nsLanguageAtomService
  30 #include "nsIObserver.h"            // for nsIObserver, etc
  31 #include "nsIObserverService.h"     // for nsIObserverService
  32 #include "nsISupportsImpl.h"        // for MOZ_COUNT_CTOR, etc
  33 #include "nsISupportsUtils.h"       // for NS_ADDREF, NS_RELEASE
  34 #include "nsIWidget.h"              // for nsIWidget, NS_NATIVE_WINDOW
  35 #include "nsRect.h"                 // for nsRect
  36 #include "nsServiceManagerUtils.h"  // for do_GetService
  37 #include "nsString.h"               // for nsDependentString
  38 #include "nsTArray.h"               // for nsTArray, nsTArray_Impl
  39 #include "nsThreadUtils.h"          // for NS_IsMainThread
  40 #include "mozilla/gfx/Logging.h"
  41 #include "mozilla/widget/ScreenManager.h"  // for ScreenManager
  42
  43 using namespace mozilla;
  44 using namespace mozilla::gfx;
  45 using mozilla::widget::ScreenManager;
  46
  47 nsDeviceContext::nsDeviceContext()
  48     : mWidth(0),
  49       mHeight(0),
  50       mAppUnitsPerDevPixel(-1),
  51       mAppUnitsPerDevPixelAtUnitFullZoom(-1),
  52       mAppUnitsPerPhysicalInch(-1),
  53       mFullZoom(1.0f),
  54       mPrintingScale(1.0f),
  55       mPrintingTranslate(gfxPoint(0, 0)),
  56       mIsCurrentlyPrintingDoc(false) {
  57   MOZ_ASSERT(NS_IsMainThread(), "nsDeviceContext created off main thread");
  58 }
  59
  60 nsDeviceContext::~nsDeviceContext() = default;
  61
  62 void nsDeviceContext::SetDPI() {
  63   float dpi;
  64
  65   // Use the printing DC to determine DPI values, if we have one.
  66   if (mDeviceContextSpec) {
  67     dpi = mDeviceContextSpec->GetDPI();
  68     mPrintingScale = mDeviceContextSpec->GetPrintingScale();
  69     mPrintingTranslate = mDeviceContextSpec->GetPrintingTranslate();
  70     mAppUnitsPerDevPixelAtUnitFullZoom =
  71         NS_lround((AppUnitsPerCSSPixel() * 96) / dpi);
  72   } else {
  73     // A value of -1 means use the maximum of 96 and the system DPI.
  74     // A value of 0 means use the system DPI. A positive value is used as the
  75     // DPI. This sets the physical size of a device pixel and thus controls the
  76     // interpretation of physical units.
  77     int32_t prefDPI = StaticPrefs::layout_css_dpi();
  78     if (prefDPI > 0) {
  79       dpi = prefDPI;
  80     } else if (mWidget) {
  81       dpi = mWidget->GetDPI();
  82       MOZ_ASSERT(dpi > 0);
  83       if (prefDPI < 0) {
  84         dpi = std::max(96.0f, dpi);
  85       }
  86     } else {
  87       dpi = 96.0f;
  88     }
  89
  90     CSSToLayoutDeviceScale scale =
  91         mWidget ? mWidget->GetDefaultScale() : CSSToLayoutDeviceScale(1.0);
  92     MOZ_ASSERT(scale.scale > 0.0);
  93     mAppUnitsPerDevPixelAtUnitFullZoom =
  94         std::max(1, NS_lround(AppUnitsPerCSSPixel() / scale.scale));
  95   }
  96
  97   NS_ASSERTION(dpi != -1.0, "no dpi set");
  98
  99   mAppUnitsPerPhysicalInch =
 100       NS_lround(dpi * mAppUnitsPerDevPixelAtUnitFullZoom);
 101   UpdateAppUnitsForFullZoom();
 102 }
 103
 104 void nsDeviceContext::Init(nsIWidget* aWidget) {
 105   if (mIsInitialized && mWidget == aWidget) {
 106     return;
 107   }
 108
 109   // We can't assert |!mIsInitialized| here since EndSwapDocShellsForDocument
 110   // re-initializes nsDeviceContext objects.  We can only assert in
 111   // InitForPrinting (below).
 112   mIsInitialized = true;
 113
 114   mWidget = aWidget;
 115   SetDPI();
 116 }
 117
 118 // XXX This is only for printing. We should make that obvious in the name.
 119 already_AddRefed<gfxContext> nsDeviceContext::CreateRenderingContext() {
 120   return CreateRenderingContextCommon(/* not a reference context */ false);
 121 }
 122
 123 already_AddRefed<gfxContext>
 124 nsDeviceContext::CreateReferenceRenderingContext() {
 125   return CreateRenderingContextCommon(/* a reference context */ true);
 126 }
 127
 128 already_AddRefed<gfxContext> nsDeviceContext::CreateRenderingContextCommon(
 129     bool aWantReferenceContext) {
 130   MOZ_ASSERT(IsPrinterContext());
 131   MOZ_ASSERT(mWidth > 0 && mHeight > 0);
 132
 133   if (NS_WARN_IF(!mPrintTarget)) {
 134     // Printing canceled already.
 135     return nullptr;
 136   }
 137
 138   RefPtr<gfx::DrawTarget> dt;
 139   if (aWantReferenceContext) {
 140     dt = mPrintTarget->GetReferenceDrawTarget();
 141   } else {
 142     // This will be null if printing a page from the parent process.
 143     RefPtr<DrawEventRecorder> recorder;
 144     mDeviceContextSpec->GetDrawEventRecorder(getter_AddRefs(recorder));
 145     dt = mPrintTarget->MakeDrawTarget(gfx::IntSize(mWidth, mHeight), recorder);
 146   }
 147
 148   if (!dt || !dt->IsValid()) {
 149     gfxCriticalNote << "Failed to create draw target in device context sized "
 150                     << mWidth << "x" << mHeight << " and pointer "
 151                     << hexa(mPrintTarget);
 152     return nullptr;
 153   }
 154
 155   dt->AddUserData(&sDisablePixelSnapping, (void*)0x1, nullptr);
 156
 157   RefPtr<gfxContext> pContext = gfxContext::CreateOrNull(dt);
 158   MOZ_ASSERT(pContext);  // already checked draw target above
 159
 160   gfxMatrix transform;
 161   transform.PreTranslate(mPrintingTranslate);
 162   transform.PreScale(mPrintingScale, mPrintingScale);
 163   pContext->SetMatrixDouble(transform);
 164   return pContext.forget();
 165 }
 166
 167 uint32_t nsDeviceContext::GetDepth() {
 168   RefPtr<widget::Screen> screen = FindScreen();
 169   if (!screen) {
 170     ScreenManager& screenManager = ScreenManager::GetSingleton();
 171     screen = screenManager.GetPrimaryScreen();
 172     MOZ_ASSERT(screen);
 173   }
 174   int32_t depth = 0;
 175   screen->GetColorDepth(&depth);
 176   return uint32_t(depth);
 177 }
 178
 179 dom::ScreenColorGamut nsDeviceContext::GetColorGamut() {
 180   RefPtr<widget::Screen> screen = FindScreen();
 181   if (!screen) {
 182     auto& screenManager = ScreenManager::GetSingleton();
 183     screen = screenManager.GetPrimaryScreen();
 184     MOZ_ASSERT(screen);
 185   }
 186   dom::ScreenColorGamut colorGamut;
 187   screen->GetColorGamut(&colorGamut);
 188   return colorGamut;
 189 }
 190
 191 hal::ScreenOrientation nsDeviceContext::GetScreenOrientationType() {
 192   RefPtr<widget::Screen> screen = FindScreen();
 193   if (!screen) {
 194     auto& screenManager = ScreenManager::GetSingleton();
 195     screen = screenManager.GetPrimaryScreen();
 196     MOZ_ASSERT(screen);
 197   }
 198   return screen->GetOrientationType();
 199 }
 200
 201 uint16_t nsDeviceContext::GetScreenOrientationAngle() {
 202   RefPtr<widget::Screen> screen = FindScreen();
 203   if (!screen) {
 204     auto& screenManager = ScreenManager::GetSingleton();
 205     screen = screenManager.GetPrimaryScreen();
 206     MOZ_ASSERT(screen);
 207   }
 208   return screen->GetOrientationAngle();
 209 }
 210
 211 nsresult nsDeviceContext::GetDeviceSurfaceDimensions(nscoord& aWidth,
 212                                                      nscoord& aHeight) {
 213   if (IsPrinterContext()) {
 214     aWidth = mWidth;
 215     aHeight = mHeight;
 216   } else {
 217     nsRect area;
 218     ComputeFullAreaUsingScreen(&area);
 219     aWidth = area.Width();
 220     aHeight = area.Height();
 221   }
 222
 223   return NS_OK;
 224 }
 225
 226 nsresult nsDeviceContext::GetRect(nsRect& aRect) {
 227   if (IsPrinterContext()) {
 228     aRect.SetRect(0, 0, mWidth, mHeight);
 229   } else
 230     ComputeFullAreaUsingScreen(&aRect);
 231
 232   return NS_OK;
 233 }
 234
 235 nsresult nsDeviceContext::GetClientRect(nsRect& aRect) {
 236   if (IsPrinterContext()) {
 237     aRect.SetRect(0, 0, mWidth, mHeight);
 238   } else
 239     ComputeClientRectUsingScreen(&aRect);
 240
 241   return NS_OK;
 242 }
 243
 244 nsresult nsDeviceContext::InitForPrinting(nsIDeviceContextSpec* aDevice) {
 245   NS_ENSURE_ARG_POINTER(aDevice);
 246
 247   MOZ_ASSERT(!mIsInitialized,
 248              "Only initialize once, immediately after construction");
 249
 250   // We don't set mIsInitialized here. The Init() call below does that.
 251
 252   mPrintTarget = aDevice->MakePrintTarget();
 253   if (!mPrintTarget) {
 254     return NS_ERROR_FAILURE;
 255   }
 256
 257   mDeviceContextSpec = aDevice;
 258
 259   Init(nullptr);
 260
 261   if (!CalcPrintingSize()) {
 262     return NS_ERROR_FAILURE;
 263   }
 264
 265   return NS_OK;
 266 }
 267
 268 nsresult nsDeviceContext::BeginDocument(const nsAString& aTitle,
 269                                         const nsAString& aPrintToFileName,
 270                                         int32_t aStartPage, int32_t aEndPage) {
 271   MOZ_DIAGNOSTIC_ASSERT(!mIsCurrentlyPrintingDoc,
 272                         "Mismatched BeginDocument/EndDocument calls");
 273
 274   nsresult rv = mPrintTarget->BeginPrinting(aTitle, aPrintToFileName,
 275                                             aStartPage, aEndPage);
 276
 277   if (NS_SUCCEEDED(rv)) {
 278     if (mDeviceContextSpec) {
 279       rv = mDeviceContextSpec->BeginDocument(aTitle, aPrintToFileName,
 280                                              aStartPage, aEndPage);
 281     }
 282     mIsCurrentlyPrintingDoc = true;
 283   }
 284
 285   // Warn about any failure (except user cancelling):
 286   NS_WARNING_ASSERTION(NS_SUCCEEDED(rv) || rv == NS_ERROR_ABORT,
 287                        "nsDeviceContext::BeginDocument failed");
 288
 289   return rv;
 290 }
 291
 292 RefPtr<PrintEndDocumentPromise> nsDeviceContext::EndDocument() {
 293   MOZ_DIAGNOSTIC_ASSERT(mIsCurrentlyPrintingDoc,
 294                         "Mismatched BeginDocument/EndDocument calls");
 295   MOZ_DIAGNOSTIC_ASSERT(mPrintTarget);
 296
 297   mIsCurrentlyPrintingDoc = false;
 298
 299   if (mPrintTarget) {
 300     auto result = mPrintTarget->EndPrinting();
 301     if (NS_FAILED(result)) {
 302       return PrintEndDocumentPromise::CreateAndReject(NS_ERROR_NOT_AVAILABLE,
 303                                                       __func__);
 304     }
 305     mPrintTarget->Finish();
 306     mPrintTarget = nullptr;
 307   }
 308
 309   if (mDeviceContextSpec) {
 310     return mDeviceContextSpec->EndDocument();
 311   }
 312
 313   return PrintEndDocumentPromise::CreateAndResolve(true, __func__);
 314 }
 315
 316 nsresult nsDeviceContext::AbortDocument() {
 317   MOZ_DIAGNOSTIC_ASSERT(mIsCurrentlyPrintingDoc,
 318                         "Mismatched BeginDocument/EndDocument calls");
 319
 320   nsresult rv = mPrintTarget->AbortPrinting();
 321   mIsCurrentlyPrintingDoc = false;
 322
 323   if (mDeviceContextSpec) {
 324     Unused << mDeviceContextSpec->EndDocument();
 325   }
 326
 327   mPrintTarget = nullptr;
 328
 329   return rv;
 330 }
 331
 332 nsresult nsDeviceContext::BeginPage() {
 333   MOZ_DIAGNOSTIC_ASSERT(!mIsCurrentlyPrintingDoc || mPrintTarget,
 334                         "What nulled out our print target while printing?");
 335   if (mDeviceContextSpec) {
 336     MOZ_TRY(mDeviceContextSpec->BeginPage());
 337   }
 338   if (mPrintTarget) {
 339     MOZ_TRY(mPrintTarget->BeginPage());
 340   }
 341   return NS_OK;
 342 }
 343
 344 nsresult nsDeviceContext::EndPage() {
 345   MOZ_DIAGNOSTIC_ASSERT(!mIsCurrentlyPrintingDoc || mPrintTarget,
 346                         "What nulled out our print target while printing?");
 347   if (mPrintTarget) {
 348     MOZ_TRY(mPrintTarget->EndPage());
 349   }
 350   if (mDeviceContextSpec) {
 351     MOZ_TRY(mDeviceContextSpec->EndPage());
 352   }
 353   return NS_OK;
 354 }
 355
 356 void nsDeviceContext::ComputeClientRectUsingScreen(nsRect* outRect) {
 357   // we always need to recompute the clientRect
 358   // because the window may have moved onto a different screen. In the single
 359   // monitor case, we only need to do the computation if we haven't done it
 360   // once already, and remember that we have because we're assured it won't
 361   // change.
 362   if (RefPtr<widget::Screen> screen = FindScreen()) {
 363     *outRect = LayoutDeviceIntRect::ToAppUnits(screen->GetAvailRect(),
 364                                                AppUnitsPerDevPixel());
 365   }
 366 }
 367
 368 void nsDeviceContext::ComputeFullAreaUsingScreen(nsRect* outRect) {
 369   // if we have more than one screen, we always need to recompute the clientRect
 370   // because the window may have moved onto a different screen. In the single
 371   // monitor case, we only need to do the computation if we haven't done it
 372   // once already, and remember that we have because we're assured it won't
 373   // change.
 374   if (RefPtr<widget::Screen> screen = FindScreen()) {
 375     *outRect = LayoutDeviceIntRect::ToAppUnits(screen->GetRect(),
 376                                                AppUnitsPerDevPixel());
 377     mWidth = outRect->Width();
 378     mHeight = outRect->Height();
 379   }
 380 }
 381
 382 //
 383 // FindScreen
 384 //
 385 // Determines which screen intersects the largest area of the given surface.
 386 //
 387 already_AddRefed<widget::Screen> nsDeviceContext::FindScreen() {
 388   if (!mWidget) {
 389     return nullptr;
 390   }
 391
 392   CheckDPIChange();
 393
 394   if (RefPtr<widget::Screen> screen = mWidget->GetWidgetScreen()) {
 395     return screen.forget();
 396   }
 397
 398   ScreenManager& screenManager = ScreenManager::GetSingleton();
 399   return screenManager.GetPrimaryScreen();
 400 }
 401
 402 bool nsDeviceContext::CalcPrintingSize() {
 403   gfxSize size(mPrintTarget->GetSize());
 404   // For printing, CSS inches and physical inches are identical
 405   // so it doesn't matter which we use here
 406   mWidth = NSToCoordRound(size.width * AppUnitsPerPhysicalInch() /
 407                           POINTS_PER_INCH_FLOAT);
 408   mHeight = NSToCoordRound(size.height * AppUnitsPerPhysicalInch() /
 409                            POINTS_PER_INCH_FLOAT);
 410
 411   return (mWidth > 0 && mHeight > 0);
 412 }
 413
 414 bool nsDeviceContext::CheckDPIChange() {
 415   int32_t oldDevPixels = mAppUnitsPerDevPixelAtUnitFullZoom;
 416   int32_t oldInches = mAppUnitsPerPhysicalInch;
 417
 418   SetDPI();
 419
 420   return oldDevPixels != mAppUnitsPerDevPixelAtUnitFullZoom ||
 421          oldInches != mAppUnitsPerPhysicalInch;
 422 }
 423
 424 bool nsDeviceContext::SetFullZoom(float aScale) {
 425   if (aScale <= 0) {
 426     MOZ_ASSERT_UNREACHABLE("Invalid full zoom value");
 427     return false;
 428   }
 429   int32_t oldAppUnitsPerDevPixel = mAppUnitsPerDevPixel;
 430   mFullZoom = aScale;
 431   UpdateAppUnitsForFullZoom();
 432   return oldAppUnitsPerDevPixel != mAppUnitsPerDevPixel;
 433 }
 434
 435 static int32_t ApplyFullZoom(int32_t aUnzoomedAppUnits, float aFullZoom) {
 436   if (aFullZoom == 1.0f) {
 437     return aUnzoomedAppUnits;
 438   }
 439   return std::max(1, NSToIntRound(float(aUnzoomedAppUnits) / aFullZoom));
 440 }
 441
 442 int32_t nsDeviceContext::AppUnitsPerDevPixelInTopLevelChromePage() const {
 443   // The only zoom that applies to chrome pages is the system zoom, if any.
 444   return ApplyFullZoom(mAppUnitsPerDevPixelAtUnitFullZoom,
 445                        LookAndFeel::SystemZoomSettings().mFullZoom);
 446 }
 447
 448 void nsDeviceContext::UpdateAppUnitsForFullZoom() {
 449   mAppUnitsPerDevPixel =
 450       ApplyFullZoom(mAppUnitsPerDevPixelAtUnitFullZoom, mFullZoom);
 451   // adjust mFullZoom to reflect appunit rounding
 452   mFullZoom = float(mAppUnitsPerDevPixelAtUnitFullZoom) / mAppUnitsPerDevPixel;
 453 }
 454
 455 DesktopToLayoutDeviceScale nsDeviceContext::GetDesktopToDeviceScale() {
 456   if (RefPtr<widget::Screen> screen = FindScreen()) {
 457     return screen->GetDesktopToLayoutDeviceScale();
 458   }
 459   return DesktopToLayoutDeviceScale(1.0);
 460 }