/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* a presentation of a document, part 1 */

#ifndef nsPresContext_h___

#define nsPresContext_h___

#include "mozilla/Attributes.h"

#include "mozilla/MediaFeatureChange.h"

#include "mozilla/NotNull.h"

#include "mozilla/UniquePtr.h"

#include "mozilla/WeakPtr.h"

#include "nsColor.h"

#include "nsCoord.h"

#include "nsCOMPtr.h"

#include "nsIPresShell.h"

#include "nsIPresShellInlines.h"

#include "nsRect.h"

#include "nsStringFwd.h"

#include "nsFont.h"

#include "gfxFontConstants.h"

#include "nsAtom.h"

#include "nsITimer.h"

#include "nsCRT.h"

#include "nsIWidgetListener.h"

#include "nsLanguageAtomService.h"

#include "nsGkAtoms.h"

#include "nsCycleCollectionParticipant.h"

#include "nsChangeHint.h"

#include <algorithm>

#include "gfxTypes.h"

#include "gfxRect.h"

#include "nsTArray.h"

#include "nsAutoPtr.h"

#include "mozilla/MemoryReporting.h"

#include "mozilla/TimeStamp.h"

#include "mozilla/AppUnits.h"

#include "prclist.h"

#include "nsThreadUtils.h"

#include "ScrollbarStyles.h"

#include "nsIMessageManager.h"

#include "mozilla/RestyleLogging.h"

#include "Units.h"

#include "prenv.h"

#include "mozilla/StaticPresData.h"

#include "mozilla/StyleBackendType.h"

class nsBidi;

class nsIPrintSettings;

class nsDocShell;

class nsIDocShell;

class nsIDocument;

class nsITheme;

class nsIContent;

class nsIFrame;

class nsFrameManager;

class nsILinkHandler;

class nsAtom;

class nsIRunnable;

class gfxFontFeatureValueSet;

class gfxUserFontEntry;

class gfxUserFontSet;

class gfxTextPerfMetrics;

class nsCSSFontFeatureValuesRule;

class nsPluginFrame;

class nsTransitionManager;

class nsAnimationManager;

class nsRefreshDriver;

class nsIWidget;

class nsDeviceContext;

class gfxMissingFontRecorder;

namespace mozilla {

class AnimationEventDispatcher;

class EffectCompositor;

class Encoding;

class EventStateManager;

class CounterStyleManager;

class RestyleManager;

namespace layers {

class ContainerLayer;

class LayerManager;

}  // namespace layers

namespace dom {

class Element;

}  // namespace dom

}  // namespace mozilla

// supported values for cached bool types

enum nsPresContext_CachedBoolPrefType {

  kPresContext_UseDocumentFonts = 1,

  kPresContext_UnderlineLinks

};

// supported values for cached integer pref types

enum nsPresContext_CachedIntPrefType {

  kPresContext_ScrollbarSide = 1,

  kPresContext_BidiDirection

};

// IDs for the default variable and fixed fonts (not to be changed, see

// nsFont.h) To be used for Get/SetDefaultFont(). The other IDs in nsFont.h are

// also supported.

const uint8_t kPresContext_DefaultVariableFont_ID =

    0x00;  // kGenericFont_moz_variable

const uint8_t kPresContext_DefaultFixedFont_ID =

    0x01;  // kGenericFont_moz_fixed

#ifdef DEBUG

struct nsAutoLayoutPhase;

enum nsLayoutPhase {

  eLayoutPhase_Paint,

  eLayoutPhase_DisplayListBuilding,  // sometimes a subset of the paint phase

  eLayoutPhase_Reflow,

  eLayoutPhase_FrameC,

  eLayoutPhase_COUNT

};

#endif

/* Used by nsPresContext::HasAuthorSpecifiedRules */

#define NS_AUTHOR_SPECIFIED_BACKGROUND (1 << 0)

#define NS_AUTHOR_SPECIFIED_BORDER (1 << 1)

#define NS_AUTHOR_SPECIFIED_PADDING (1 << 2)

class nsRootPresContext;

// An interface for presentation contexts. Presentation contexts are

// objects that provide an outer context for a presentation shell.

class nsPresContext : public nsISupports,

                      public mozilla::SupportsWeakPtr<nsPresContext> {

 public:

  using Encoding = mozilla::Encoding;

  template <typename T>

  using NotNull = mozilla::NotNull<T>;

  typedef mozilla::LangGroupFontPrefs LangGroupFontPrefs;

  typedef mozilla::ScrollbarStyles ScrollbarStyles;

  typedef mozilla::StaticPresData StaticPresData;

  NS_DECL_CYCLE_COLLECTING_ISUPPORTS

  NS_DECL_CYCLE_COLLECTION_CLASS(nsPresContext)

  MOZ_DECLARE_WEAKREFERENCE_TYPENAME(nsPresContext)

  enum nsPresContextType {

    eContext_Galley,        // unpaginated screen presentation

    eContext_PrintPreview,  // paginated screen presentation

    eContext_Print,         // paginated printer presentation

    eContext_PageLayout     // paginated & editable.

  };

  nsPresContext(nsIDocument* aDocument, nsPresContextType aType);

  /**

   * Initialize the presentation context from a particular device.

   */

  nsresult Init(nsDeviceContext* aDeviceContext);

  /**

   * Set and detach presentation shell that this context is bound to.

   * A presentation context may only be bound to a single shell.

   */

  void AttachShell(nsIPresShell* aShell,

                   mozilla::StyleBackendType aBackendType);

  void DetachShell();

  nsPresContextType Type() const { return mType; }

  /**

   * Get the PresentationShell that this context is bound to.

   */

  nsIPresShell* PresShell() const {

    NS_ASSERTION(mShell, "Null pres shell");

    return mShell;

  }

  nsIPresShell* GetPresShell() const { return mShell; }

  void DispatchCharSetChange(NotNull<const Encoding*> aCharSet);

  /**

   * Returns the parent prescontext for this one. Returns null if this is a

   * root.

   */

  nsPresContext* GetParentPresContext();

  /**

   * Returns the prescontext of the toplevel content document that contains

   * this presentation, or null if there isn't one.

   */

  nsPresContext* GetToplevelContentDocumentPresContext();

  /**

   * Returns the nearest widget for the root frame of this.

   *

   * @param aOffset     If non-null the offset from the origin of the root

   *                    frame's view to the widget's origin (usually positive)

   *                    expressed in appunits of this will be returned in

   *                    aOffset.

   */

  nsIWidget* GetNearestWidget(nsPoint* aOffset = nullptr);

  /**

   * Returns the root widget for this.

   * Note that the widget is a mediater with IME.

   */

  nsIWidget* GetRootWidget();

  /**

   * Return the presentation context for the root of the view manager

   * hierarchy that contains this presentation context, or nullptr if it can't

   * be found (e.g. it's detached).

   */

  nsRootPresContext* GetRootPresContext();

  virtual bool IsRoot() { return false; }

  nsIDocument* Document() const {

    NS_ASSERTION(

        !mShell || !mShell->GetDocument() || mShell->GetDocument() == mDocument,

        "nsPresContext doesn't have the same document as nsPresShell!");

    return mDocument;

  }

  mozilla::StyleSetHandle StyleSet() const {

    return GetPresShell()->StyleSet();

  }

  bool HasPendingMediaQueryUpdates() const {

    return !!mPendingMediaFeatureValuesChange;

  }

  nsCSSFrameConstructor* FrameConstructor() {

    return PresShell()->FrameConstructor();

  }

  mozilla::AnimationEventDispatcher* AnimationEventDispatcher() {

    return mAnimationEventDispatcher;

  }

  mozilla::EffectCompositor* EffectCompositor() { return mEffectCompositor; }

  nsTransitionManager* TransitionManager() { return mTransitionManager; }

  nsAnimationManager* AnimationManager() { return mAnimationManager; }

  const nsAnimationManager* AnimationManager() const {

    return mAnimationManager;

  }

  nsRefreshDriver* RefreshDriver() { return mRefreshDriver; }

  mozilla::RestyleManager* RestyleManager() {

    MOZ_ASSERT(mRestyleManager);

    return mRestyleManager;

  }

  mozilla::CounterStyleManager* CounterStyleManager() const {

    return mCounterStyleManager;

  }

  /**

   * Rebuilds all style data by throwing out the old rule tree and

   * building a new one, and additionally applying aExtraHint (which

   * must not contain nsChangeHint_ReconstructFrame) to the root frame.

   * For aRestyleHint, see RestyleManager::RebuildAllStyleData.

   * Also rebuild the user font set and counter style manager.

   */

  void RebuildAllStyleData(nsChangeHint aExtraHint, nsRestyleHint aRestyleHint);

  /**

   * Just like RebuildAllStyleData, except (1) asynchronous and (2) it

   * doesn't rebuild the user font set.

   */

  void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint,

                                    nsRestyleHint aRestyleHint);

  /**

   * Handle changes in the values of media features (used in media

   * queries).

   *

   * There are three sensible values to use for aRestyleHint:

   *  * nsRestyleHint(0) to rebuild style data, with rerunning of

   *    selector matching, only if media features have changed

   *  * eRestyle_ForceDescendants to force rebuilding of style data (but

   *    still only rerun selector matching if media query results have

   *    changed).  (RebuildAllStyleData always adds

   *    eRestyle_ForceDescendants internally, so here we're only using

   *    it to distinguish from nsRestyleHint(0) whether we need to call

   *    RebuildAllStyleData at all.)

   *  * eRestyle_Subtree to force rebuilding of style data with

   *    rerunning of selector matching

   *

   * For aChangeHint, see RestyleManager::RebuildAllStyleData.  (Passing

   * a nonzero aChangeHint forces rebuilding style data even if

   * nsRestyleHint(0) is passed.)

   */

  void MediaFeatureValuesChanged(const mozilla::MediaFeatureChange& aChange) {

    if (mShell) {

      mShell->EnsureStyleFlush();

    }

    if (!mPendingMediaFeatureValuesChange) {

      mPendingMediaFeatureValuesChange.emplace(aChange);

      return;

    }

    *mPendingMediaFeatureValuesChange |= aChange;

  }

  void FlushPendingMediaFeatureValuesChanged();

  /**

   * Calls MediaFeatureValuesChanged for this pres context and all descendant

   * subdocuments that have a pres context. This should be used for media

   * features that must be updated in all subdocuments e.g. display-mode.

   */

  void MediaFeatureValuesChangedAllDocuments(

      const mozilla::MediaFeatureChange&);

  /**

   * Updates the size mode on all remote children and recursively notifies this

   * document and all subdocuments (including remote children) that a media

   * feature value has changed.

   */

  void SizeModeChanged(nsSizeMode aSizeMode);

  /**

   * Access compatibility mode for this context.  This is the same as

   * our document's compatibility mode.

   */

  nsCompatibility CompatibilityMode() const;

  /**

   * Notify the context that the document's compatibility mode has changed

   */

  void CompatibilityModeChanged();

  /**

   * Access the image animation mode for this context

   */

  uint16_t ImageAnimationMode() const { return mImageAnimationMode; }

  void SetImageAnimationMode(uint16_t aMode);

  /**

   * Get medium of presentation

   */

  nsAtom* Medium() {

    if (!mIsEmulatingMedia) return mMedium;

    return mMediaEmulated;

  }

  /*

   * Render the document as if being viewed on a device with the specified

   * media type.

   */

  void EmulateMedium(const nsAString& aMediaType);

  /*

   * Restore the viewer's natural medium

   */

  void StopEmulatingMedium();

  /**

   * Get the default font for the given language and generic font ID.

   * If aLanguage is nullptr, the document's language is used.

   *

   * See the comment in StaticPresData::GetDefaultFont.

   */

  const nsFont* GetDefaultFont(uint8_t aFontID, nsAtom* aLanguage,

                               bool* aNeedsToCache = nullptr) const {

    nsAtom* lang = aLanguage ? aLanguage : mLanguage.get();

    const LangGroupFontPrefs* prefs = GetFontPrefsForLang(lang, aNeedsToCache);

    if (aNeedsToCache && *aNeedsToCache) {

      return nullptr;

    }

    return StaticPresData::Get()->GetDefaultFontHelper(aFontID, lang, prefs);

  }

  void ForceCacheLang(nsAtom* aLanguage);

  void CacheAllLangs();

  /** Get a cached boolean pref, by its type */

  // *  - initially created for bugs 31816, 20760, 22963

  bool GetCachedBoolPref(nsPresContext_CachedBoolPrefType aPrefType) const {

    // If called with a constant parameter, the compiler should optimize

    // this switch statement away.

    switch (aPrefType) {

      case kPresContext_UseDocumentFonts:

        return mUseDocumentFonts;

      case kPresContext_UnderlineLinks:

        return mUnderlineLinks;

      default:

        NS_ERROR("Invalid arg passed to GetCachedBoolPref");

    }

    return false;

  }

  /** Get a cached integer pref, by its type */

  // *  - initially created for bugs 30910, 61883, 74186, 84398

  int32_t GetCachedIntPref(nsPresContext_CachedIntPrefType aPrefType) const {

    // If called with a constant parameter, the compiler should optimize

    // this switch statement away.

    switch (aPrefType) {

      case kPresContext_ScrollbarSide:

        return mPrefScrollbarSide;

      case kPresContext_BidiDirection:

        return mPrefBidiDirection;

      default:

        NS_ERROR("invalid arg passed to GetCachedIntPref");

    }

    return false;

  }

  /**

   * Get the default colors

   */

  nscolor DefaultColor() const { return mDefaultColor; }

  nscolor DefaultBackgroundColor() const { return mBackgroundColor; }

  nscolor DefaultLinkColor() const { return mLinkColor; }

  nscolor DefaultActiveLinkColor() const { return mActiveLinkColor; }

  nscolor DefaultVisitedLinkColor() const { return mVisitedLinkColor; }

  nscolor FocusBackgroundColor() const { return mFocusBackgroundColor; }

  nscolor FocusTextColor() const { return mFocusTextColor; }

  /**

   * Body text color, for use in quirks mode only.

   */

  nscolor BodyTextColor() const { return mBodyTextColor; }

  void SetBodyTextColor(nscolor aColor) { mBodyTextColor = aColor; }

  bool GetUseFocusColors() const { return mUseFocusColors; }

  uint8_t FocusRingWidth() const { return mFocusRingWidth; }

  bool GetFocusRingOnAnything() const { return mFocusRingOnAnything; }

  uint8_t GetFocusRingStyle() const { return mFocusRingStyle; }

  void SetContainer(nsIDocShell* aContainer);

  nsISupports* GetContainerWeak() const;

  nsIDocShell* GetDocShell() const;

  // XXX this are going to be replaced with set/get container

  void SetLinkHandler(nsILinkHandler* aHandler) { mLinkHandler = aHandler; }

  nsILinkHandler* GetLinkHandler() { return mLinkHandler; }

  /**

   * Detach this pres context - i.e. cancel relevant timers,

   * SetLinkHandler(null), SetContainer(null) etc.

   * Only to be used by the DocumentViewer.

   */

  virtual void Detach();

  /**

   * Get the visible area associated with this presentation context.

   * This is the size of the visible area that is used for

   * presenting the document. The returned value is in the standard

   * nscoord units (as scaled by the device context).

   */

  nsRect GetVisibleArea() const { return mVisibleArea; }

  /**

   * Set the currently visible area. The units for r are standard

   * nscoord units (as scaled by the device context).

   */

  void SetVisibleArea(const nsRect& r) {

    if (!r.IsEqualEdges(mVisibleArea)) {

      mVisibleArea = r;

      // Visible area does not affect media queries when paginated.

      if (!IsPaginated()) {

        MediaFeatureValuesChanged(

            {mozilla::MediaFeatureChangeReason::ViewportChange});

      }

    }

  }

  bool ShouldFireResizeEvent() const {

    return !mLastResizeEventVisibleArea.IsEqualEdges(mVisibleArea);

  }

  void WillFireResizeEvent() { mLastResizeEventVisibleArea = mVisibleArea; }

  /**

   * Return true if this presentation context is a paginated

   * context.

   */

  bool IsPaginated() const { return mPaginated; }

  /**

   * Sets whether the presentation context can scroll for a paginated

   * context.

   */

  void SetPaginatedScrolling(bool aResult);

  /**

   * Return true if this presentation context can scroll for paginated

   * context.

   */

  bool HasPaginatedScrolling() const { return mCanPaginatedScroll; }

  /**

   * Get/set the size of a page

   */

  nsSize GetPageSize() { return mPageSize; }

  void SetPageSize(nsSize aSize) { mPageSize = aSize; }

  /**

   * Get/set whether this document should be treated as having real pages

   * XXX This raises the obvious question of why a document that isn't a page

   *     is paginated; there isn't a good reason except history

   */

  bool IsRootPaginatedDocument() { return mIsRootPaginatedDocument; }

  void SetIsRootPaginatedDocument(bool aIsRootPaginatedDocument) {

    mIsRootPaginatedDocument = aIsRootPaginatedDocument;

  }

  /**

   * Get/set the print scaling level; used by nsPageFrame to scale up

   * pages.  Set safe to call before reflow, get guaranteed to be set

   * properly after reflow.

   */

  float GetPageScale() { return mPageScale; }

  void SetPageScale(float aScale) { mPageScale = aScale; }

  /**

   * Get/set the scaling facor to use when rendering the pages for print

   * preview. Only safe to get after print preview set up; safe to set anytime.

   * This is a scaling factor for the display of the print preview.  It

   * does not affect layout.  It only affects the size of the onscreen pages

   * in print preview.

   * XXX Temporary: see http://wiki.mozilla.org/Gecko:PrintPreview

   */

  float GetPrintPreviewScale() { return mPPScale; }

  void SetPrintPreviewScale(float aScale) { mPPScale = aScale; }

  nsDeviceContext* DeviceContext() const { return mDeviceContext; }

  mozilla::EventStateManager* EventStateManager() { return mEventManager; }

  nsAtom* GetLanguageFromCharset() const { return mLanguage; }

  already_AddRefed<nsAtom> GetContentLanguage() const;

  /**

   * Get/set a text zoom factor that is applied on top of the normal text zoom

   * set by the front-end/user.

   */

  float GetSystemFontScale() const { return mSystemFontScale; }

  void SetSystemFontScale(float aFontScale) {

    MOZ_ASSERT(aFontScale > 0.0f, "invalid font scale");

    if (aFontScale == mSystemFontScale || IsPrintingOrPrintPreview()) {

      return;

    }

    mSystemFontScale = aFontScale;

    UpdateEffectiveTextZoom();

  }

  /**

   * Get/set the text zoom factor in use.

   * This value should be used if you're interested in the pure text zoom value

   * controlled by the front-end, e.g. when transferring zoom levels to a new

   * document.

   * Code that wants to use this value for layouting and rendering purposes

   * should consider using EffectiveTextZoom() instead, so as to take the system

   * font scale into account as well.

   */

  float TextZoom() const { return mTextZoom; }

  void SetTextZoom(float aZoom) {

    MOZ_ASSERT(aZoom > 0.0f, "invalid zoom factor");

    if (aZoom == mTextZoom) return;

    mTextZoom = aZoom;

    UpdateEffectiveTextZoom();

  }

 protected:

  void UpdateEffectiveTextZoom();

 public:

  /**

   * Corresponds to the product of text zoom and system font scale, limited

   * by zoom.maxPercent and minPercent.

   * As the system font scale is automatically set by the PresShell, code that

   * e.g. wants to transfer zoom levels to a new document should use TextZoom()

   * instead, which corresponds to the text zoom level that was actually set by

   * the front-end/user.

   */

  float EffectiveTextZoom() const { return mEffectiveTextZoom; }

  /**

   * Get the minimum font size for the specified language. If aLanguage

   * is nullptr, then the document's language is used.  This combines

   * the language-specific global preference with the per-presentation

   * base minimum font size.

   */

  int32_t MinFontSize(nsAtom* aLanguage, bool* aNeedsToCache = nullptr) const {

    const LangGroupFontPrefs* prefs =

        GetFontPrefsForLang(aLanguage, aNeedsToCache);

    if (aNeedsToCache && *aNeedsToCache) {

      return 0;

    }

    return std::max(mBaseMinFontSize, prefs->mMinimumFontSize);

  }

  /**

   * Get the per-presentation base minimum font size.  This size is

   * independent of the language-specific global preference.

   */

  int32_t BaseMinFontSize() const { return mBaseMinFontSize; }

  /**

   * Set the per-presentation base minimum font size.  This size is

   * independent of the language-specific global preference.

   */

  void SetBaseMinFontSize(int32_t aMinFontSize) {

    if (aMinFontSize == mBaseMinFontSize) {

      return;

    }

    mBaseMinFontSize = aMinFontSize;

    // Media queries could have changed, since we changed the meaning

    // of 'em' units in them.

    MediaFeatureValuesChanged(

        {eRestyle_ForceDescendants, NS_STYLE_HINT_REFLOW,

         mozilla::MediaFeatureChangeReason::MinFontSizeChange});

  }

  float GetFullZoom() { return mFullZoom; }

  /**

   * Device full zoom differs from full zoom because it gets the zoom from

   * the device context, which may be using a different zoom due to rounding

   * of app units to device pixels.

   */

  float GetDeviceFullZoom();

  void SetFullZoom(float aZoom);

  float GetOverrideDPPX() { return mOverrideDPPX; }

  void SetOverrideDPPX(float aDPPX);

  nscoord GetAutoQualityMinFontSize() {

    return DevPixelsToAppUnits(mAutoQualityMinFontSizePixelsPref);

  }

  /**

   * Return the device's screen size in inches, for font size

   * inflation.

   *

   * If |aChanged| is non-null, then aChanged is filled in with whether

   * the screen size value has changed since either:

   *  a. the last time the function was called with non-null aChanged, or

   *  b. the first time the function was called.

   */

  gfxSize ScreenSizeInchesForFontInflation(bool* aChanged = nullptr);

  static int32_t AppUnitsPerCSSPixel() {

    return mozilla::AppUnitsPerCSSPixel();

  }

  int32_t AppUnitsPerDevPixel() const;

  static int32_t AppUnitsPerCSSInch() { return mozilla::AppUnitsPerCSSInch(); }

  static nscoord CSSPixelsToAppUnits(int32_t aPixels) {

    return NSToCoordRoundWithClamp(float(aPixels) *

                                   float(AppUnitsPerCSSPixel()));

  }

  static nscoord CSSPixelsToAppUnits(float aPixels) {

    return NSToCoordRoundWithClamp(aPixels * float(AppUnitsPerCSSPixel()));

  }

  static int32_t AppUnitsToIntCSSPixels(nscoord aAppUnits) {

    return NSAppUnitsToIntPixels(aAppUnits, float(AppUnitsPerCSSPixel()));

  }

  static float AppUnitsToFloatCSSPixels(nscoord aAppUnits) {

    return NSAppUnitsToFloatPixels(aAppUnits, float(AppUnitsPerCSSPixel()));

  }

  static double AppUnitsToDoubleCSSPixels(nscoord aAppUnits) {

    return NSAppUnitsToDoublePixels(aAppUnits, double(AppUnitsPerCSSPixel()));

  }

  nscoord DevPixelsToAppUnits(int32_t aPixels) const {

    return NSIntPixelsToAppUnits(aPixels, AppUnitsPerDevPixel());

  }

  int32_t AppUnitsToDevPixels(nscoord aAppUnits) const {

    return NSAppUnitsToIntPixels(aAppUnits, float(AppUnitsPerDevPixel()));

  }

  float AppUnitsToFloatDevPixels(nscoord aAppUnits) {

    return aAppUnits / float(AppUnitsPerDevPixel());

  }

  int32_t CSSPixelsToDevPixels(int32_t aPixels) {

    return AppUnitsToDevPixels(CSSPixelsToAppUnits(aPixels));

  }

  float CSSPixelsToDevPixels(float aPixels) {

    return NSAppUnitsToFloatPixels(CSSPixelsToAppUnits(aPixels),

                                   float(AppUnitsPerDevPixel()));

  }

  int32_t DevPixelsToIntCSSPixels(int32_t aPixels) {

    return AppUnitsToIntCSSPixels(DevPixelsToAppUnits(aPixels));

  }

  float DevPixelsToFloatCSSPixels(int32_t aPixels) {

    return AppUnitsToFloatCSSPixels(DevPixelsToAppUnits(aPixels));

  }

  mozilla::CSSToLayoutDeviceScale CSSToDevPixelScale() const {

    return mozilla::CSSToLayoutDeviceScale(float(AppUnitsPerCSSPixel()) /

                                           float(AppUnitsPerDevPixel()));

  }

  // If there is a remainder, it is rounded to nearest app units.

  nscoord GfxUnitsToAppUnits(gfxFloat aGfxUnits) const;

  gfxFloat AppUnitsToGfxUnits(nscoord aAppUnits) const;

  gfxRect AppUnitsToGfxUnits(const nsRect& aAppRect) const {

    return gfxRect(AppUnitsToGfxUnits(aAppRect.x),

                   AppUnitsToGfxUnits(aAppRect.y),

                   AppUnitsToGfxUnits(aAppRect.Width()),

                   AppUnitsToGfxUnits(aAppRect.Height()));

  }

  static nscoord CSSTwipsToAppUnits(float aTwips) {

    return NSToCoordRoundWithClamp(mozilla::AppUnitsPerCSSInch() *

                                   NS_TWIPS_TO_INCHES(aTwips));

  }

  // Margin-specific version, since they often need TwipsToAppUnits

  static nsMargin CSSTwipsToAppUnits(const nsIntMargin& marginInTwips) {

    return nsMargin(CSSTwipsToAppUnits(float(marginInTwips.top)),

                    CSSTwipsToAppUnits(float(marginInTwips.right)),

                    CSSTwipsToAppUnits(float(marginInTwips.bottom)),

                    CSSTwipsToAppUnits(float(marginInTwips.left)));

  }

  static nscoord CSSPointsToAppUnits(float aPoints) {

    return NSToCoordRound(aPoints * mozilla::AppUnitsPerCSSInch() /

                          POINTS_PER_INCH_FLOAT);

  }

  nscoord PhysicalMillimetersToAppUnits(float aMM) const;

  nscoord RoundAppUnitsToNearestDevPixels(nscoord aAppUnits) const {

    return DevPixelsToAppUnits(AppUnitsToDevPixels(aAppUnits));

  }

  /**

   * This checks the root element and the HTML BODY, if any, for an "overflow"

   * property that should be applied to the viewport. If one is found then we

   * return the element that we took the overflow from (which should then be

   * treated as "overflow: visible"), and we store the overflow style here.

   * If the document is in fullscreen, and the fullscreen element is not the

   * root, the scrollbar of viewport will be suppressed.

   * @return if scroll was propagated from some content node, the content node

   *         it was propagated from.

   */

  mozilla::dom::Element* UpdateViewportScrollbarStylesOverride();

  /**

   * Returns the cached result from the last call to

   * UpdateViewportScrollbarStylesOverride() -- i.e. return the node

   * whose scrollbar styles we have propagated to the viewport (or nullptr if

   * there is no such node).

   */

  mozilla::dom::Element* GetViewportScrollbarStylesOverrideElement() const {

    return mViewportScrollbarOverrideElement;

  }

  const ScrollbarStyles& GetViewportScrollbarStylesOverride() const {

    return mViewportStyleScrollbar;

  }

  /**

   * Check whether the given element would propagate its scrollbar styles to the

   * viewport in non-paginated mode.  Must only be called if IsPaginated().

   */

  bool ElementWouldPropagateScrollbarStyles(mozilla::dom::Element* aElement);

  /**

   * Set and get methods for controlling the background drawing

   */

  bool GetBackgroundImageDraw() const { return mDrawImageBackground; }

  void SetBackgroundImageDraw(bool aCanDraw) {

    mDrawImageBackground = aCanDraw;

  }

  bool GetBackgroundColorDraw() const { return mDrawColorBackground; }

  void SetBackgroundColorDraw(bool aCanDraw) {

    mDrawColorBackground = aCanDraw;

  }

  /**

   *  Check if bidi enabled (set depending on the presence of RTL

   *  characters or when default directionality is RTL).

   *  If enabled, we should apply the Unicode Bidi Algorithm

   *

   *  @lina 07/12/2000

   */

  bool BidiEnabled() const;

  /**

   *  Set bidi enabled. This means we should apply the Unicode Bidi Algorithm

   *

   *  @lina 07/12/2000

   */

  void SetBidiEnabled() const;

  /**

   *  Set visual or implicit mode into the pres context.

   *

   *  Visual directionality is a presentation method that displays text

   *  as if it were a uni-directional, according to the primary display

   *  direction only.

   *

   *  Implicit directionality is a presentation method in which the

   *  direction is determined by the Bidi algorithm according to the

   *  category of the characters and the category of the adjacent

   *  characters, and according to their primary direction.

   *

   *  @lina 05/02/2000

   */

  void SetVisualMode(bool aIsVisual) { mIsVisual = aIsVisual; }

  /**

   *  Check whether the content should be treated as visual.

   *

   *  @lina 05/02/2000

   */

  bool IsVisualMode() const { return mIsVisual; }

  enum class InteractionType : uint32_t {

    eClickInteraction,

    eKeyInteraction,

    eMouseMoveInteraction,

    eScrollInteraction

  };

  void RecordInteractionTime(InteractionType aType,

                             const mozilla::TimeStamp& aTimeStamp);

  void DisableInteractionTimeRecording() { mInteractionTimeEnabled = false; }

  // Mohamed

  /**

   * Set the Bidi options for the presentation context

   */

  void SetBidi(uint32_t aBidiOptions);

  /**

   * Get the Bidi options for the presentation context

   * Not inline so consumers of nsPresContext are not forced to

   * include nsIDocument.

   */

  uint32_t GetBidi() const;

  /**

   * Render only Selection

   */

  void SetIsRenderingOnlySelection(bool aResult) {

    mIsRenderingOnlySelection = aResult;

  }

  bool IsRenderingOnlySelection() const { return mIsRenderingOnlySelection; }

  bool IsTopLevelWindowInactive();

  /*

   * Obtain a native them for rendering our widgets (both form controls and

   * html)

   */

  nsITheme* GetTheme();