1 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* ***** BEGIN LICENSE BLOCK *****
3 : * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4 : *
5 : * The contents of this file are subject to the Mozilla Public License Version
6 : * 1.1 (the "License"); you may not use this file except in compliance with
7 : * the License. You may obtain a copy of the License at
8 : * http://www.mozilla.org/MPL/
9 : *
10 : * Software distributed under the License is distributed on an "AS IS" basis,
11 : * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 : * for the specific language governing rights and limitations under the
13 : * License.
14 : *
15 : * The Original Code is mozilla.org code.
16 : *
17 : * The Initial Developer of the Original Code is
18 : * Netscape Communications Corporation.
19 : * Portions created by the Initial Developer are Copyright (C) 1998
20 : * the Initial Developer. All Rights Reserved.
21 : *
22 : * Contributor(s):
23 : * L. David Baron <dbaron@dbaron.org>, Mozilla Corporation
24 : *
25 : * Alternatively, the contents of this file may be used under the terms of
26 : * either of the GNU General Public License Version 2 or later (the "GPL"),
27 : * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
28 : * in which case the provisions of the GPL or the LGPL are applicable instead
29 : * of those above. If you wish to allow use of your version of this file only
30 : * under the terms of either the GPL or the LGPL, and not to allow others to
31 : * use your version of this file under the terms of the MPL, indicate your
32 : * decision by deleting the provisions above and replace them with the notice
33 : * and other provisions required by the GPL or the LGPL. If you do not delete
34 : * the provisions above, a recipient may use your version of this file under
35 : * the terms of any one of the MPL, the GPL or the LGPL.
36 : *
37 : * ***** END LICENSE BLOCK ***** */
38 :
39 : /* a presentation of a document, part 1 */
40 :
41 : #ifndef nsPresContext_h___
42 : #define nsPresContext_h___
43 :
44 : #include "nsISupports.h"
45 : #include "nsColor.h"
46 : #include "nsCoord.h"
47 : #include "nsAString.h"
48 : #include "nsCOMPtr.h"
49 : #include "nsIPresShell.h"
50 : #include "nsRect.h"
51 : #include "nsDeviceContext.h"
52 : #include "nsFont.h"
53 : #include "nsIWeakReference.h"
54 : #include "nsITheme.h"
55 : #include "nsILanguageAtomService.h"
56 : #include "nsIObserver.h"
57 : #include "nsITimer.h"
58 : #include "nsCRT.h"
59 : #include "nsIPrintSettings.h"
60 : #include "FramePropertyTable.h"
61 : #include "nsGkAtoms.h"
62 : #include "nsIDocument.h"
63 : #include "nsRefPtrHashtable.h"
64 : #include "nsCycleCollectionParticipant.h"
65 : #include "nsChangeHint.h"
66 : // This also pulls in gfxTypes.h, which we cannot include directly.
67 : #include "gfxRect.h"
68 : #include "nsRegion.h"
69 : #include "nsTArray.h"
70 : #include "nsAutoPtr.h"
71 : #include "nsThreadUtils.h"
72 : #include "nsIWidget.h"
73 : #include "mozilla/TimeStamp.h"
74 : #include "nsIContent.h"
75 : #include "prclist.h"
76 :
77 : class nsImageLoader;
78 : #ifdef IBMBIDI
79 : class nsBidiPresUtils;
80 : #endif // IBMBIDI
81 :
82 : struct nsRect;
83 :
84 : class imgIRequest;
85 :
86 : class nsFontMetrics;
87 : class nsIFrame;
88 : class nsFrameManager;
89 : class nsILinkHandler;
90 : class nsStyleContext;
91 : class nsIAtom;
92 : class nsEventStateManager;
93 : class nsIURI;
94 : class nsICSSPseudoComparator;
95 : class nsIAtom;
96 : struct nsStyleBackground;
97 : struct nsStyleBorder;
98 : class nsIRunnable;
99 : class gfxUserFontSet;
100 : class nsUserFontSet;
101 : struct nsFontFaceRuleContainer;
102 : class nsObjectFrame;
103 : class nsTransitionManager;
104 : class nsAnimationManager;
105 : class nsRefreshDriver;
106 : class imgIContainer;
107 : class nsIDOMMediaQueryList;
108 :
109 : #ifdef MOZ_REFLOW_PERF
110 : class nsRenderingContext;
111 : #endif
112 :
113 : // supported values for cached bool types
114 : enum nsPresContext_CachedBoolPrefType {
115 : kPresContext_UseDocumentColors = 1,
116 : kPresContext_UseDocumentFonts,
117 : kPresContext_UnderlineLinks
118 : };
119 :
120 : // supported values for cached integer pref types
121 : enum nsPresContext_CachedIntPrefType {
122 : kPresContext_ScrollbarSide = 1,
123 : kPresContext_BidiDirection
124 : };
125 :
126 : // IDs for the default variable and fixed fonts (not to be changed, see nsFont.h)
127 : // To be used for Get/SetDefaultFont(). The other IDs in nsFont.h are also supported.
128 : const PRUint8 kPresContext_DefaultVariableFont_ID = 0x00; // kGenericFont_moz_variable
129 : const PRUint8 kPresContext_DefaultFixedFont_ID = 0x01; // kGenericFont_moz_fixed
130 :
131 : #ifdef DEBUG
132 : struct nsAutoLayoutPhase;
133 :
134 : enum nsLayoutPhase {
135 : eLayoutPhase_Paint,
136 : eLayoutPhase_Reflow,
137 : eLayoutPhase_FrameC,
138 : eLayoutPhase_COUNT
139 : };
140 : #endif
141 :
142 : class nsInvalidateRequestList {
143 : public:
144 0 : struct Request {
145 : nsRect mRect;
146 : PRUint32 mFlags;
147 : };
148 :
149 : nsTArray<Request> mRequests;
150 : };
151 :
152 : /* Used by nsPresContext::HasAuthorSpecifiedRules */
153 : #define NS_AUTHOR_SPECIFIED_BACKGROUND (1 << 0)
154 : #define NS_AUTHOR_SPECIFIED_BORDER (1 << 1)
155 : #define NS_AUTHOR_SPECIFIED_PADDING (1 << 2)
156 :
157 : class nsRootPresContext;
158 :
159 : // An interface for presentation contexts. Presentation contexts are
160 : // objects that provide an outer context for a presentation shell.
161 :
162 : class nsPresContext : public nsIObserver {
163 : public:
164 : typedef mozilla::FramePropertyTable FramePropertyTable;
165 :
166 : NS_DECL_CYCLE_COLLECTING_ISUPPORTS
167 : NS_DECL_NSIOBSERVER
168 0 : NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
169 : NS_DECL_CYCLE_COLLECTION_CLASS(nsPresContext)
170 :
171 : enum nsPresContextType {
172 : eContext_Galley, // unpaginated screen presentation
173 : eContext_PrintPreview, // paginated screen presentation
174 : eContext_Print, // paginated printer presentation
175 : eContext_PageLayout // paginated & editable.
176 : };
177 :
178 : nsPresContext(nsIDocument* aDocument, nsPresContextType aType) NS_HIDDEN;
179 :
180 : /**
181 : * Initialize the presentation context from a particular device.
182 : */
183 : NS_HIDDEN_(nsresult) Init(nsDeviceContext* aDeviceContext);
184 :
185 : /**
186 : * Set the presentation shell that this context is bound to.
187 : * A presentation context may only be bound to a single shell.
188 : */
189 : NS_HIDDEN_(void) SetShell(nsIPresShell* aShell);
190 :
191 :
192 0 : NS_HIDDEN_(nsPresContextType) Type() const { return mType; }
193 :
194 : /**
195 : * Get the PresentationShell that this context is bound to.
196 : */
197 0 : nsIPresShell* PresShell() const
198 : {
199 0 : NS_ASSERTION(mShell, "Null pres shell");
200 0 : return mShell;
201 : }
202 :
203 0 : nsIPresShell* GetPresShell() const { return mShell; }
204 :
205 : /**
206 : * Return the presentation context for the root of the view manager
207 : * hierarchy that contains this presentation context, or nsnull if it can't
208 : * be found (e.g. it's detached).
209 : */
210 : nsRootPresContext* GetRootPresContext();
211 : virtual bool IsRoot() { return false; }
212 :
213 0 : nsIDocument* Document() const
214 : {
215 0 : NS_ASSERTION(!mShell || !mShell->GetDocument() ||
216 : mShell->GetDocument() == mDocument,
217 : "nsPresContext doesn't have the same document as nsPresShell!");
218 0 : return mDocument;
219 : }
220 :
221 : #ifdef _IMPL_NS_LAYOUT
222 0 : nsStyleSet* StyleSet() { return GetPresShell()->StyleSet(); }
223 :
224 0 : nsFrameManager* FrameManager()
225 0 : { return GetPresShell()->FrameManager(); }
226 :
227 : nsTransitionManager* TransitionManager() { return mTransitionManager; }
228 : nsAnimationManager* AnimationManager() { return mAnimationManager; }
229 :
230 0 : nsRefreshDriver* RefreshDriver() { return mRefreshDriver; }
231 : #endif
232 :
233 : /**
234 : * Rebuilds all style data by throwing out the old rule tree and
235 : * building a new one, and additionally applying aExtraHint (which
236 : * must not contain nsChangeHint_ReconstructFrame) to the root frame.
237 : * Also rebuild the user font set.
238 : */
239 : void RebuildAllStyleData(nsChangeHint aExtraHint);
240 : /**
241 : * Just like RebuildAllStyleData, except (1) asynchronous and (2) it
242 : * doesn't rebuild the user font set.
243 : */
244 : void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint);
245 :
246 : void MediaFeatureValuesChanged(bool aCallerWillRebuildStyleData);
247 : void PostMediaFeatureValuesChangedEvent();
248 : NS_HIDDEN_(void) HandleMediaFeatureValuesChangedEvent();
249 : void FlushPendingMediaFeatureValuesChanged() {
250 : if (mPendingMediaFeatureValuesChanged)
251 : MediaFeatureValuesChanged(false);
252 : }
253 :
254 : /**
255 : * Support for window.matchMedia()
256 : */
257 : void MatchMedia(const nsAString& aMediaQueryList,
258 : nsIDOMMediaQueryList** aResult);
259 :
260 : /**
261 : * Access compatibility mode for this context. This is the same as
262 : * our document's compatibility mode.
263 : */
264 0 : nsCompatibility CompatibilityMode() const {
265 0 : return Document()->GetCompatibilityMode();
266 : }
267 : /**
268 : * Notify the context that the document's compatibility mode has changed
269 : */
270 : NS_HIDDEN_(void) CompatibilityModeChanged();
271 :
272 : /**
273 : * Access the image animation mode for this context
274 : */
275 0 : PRUint16 ImageAnimationMode() const { return mImageAnimationMode; }
276 : virtual NS_HIDDEN_(void) SetImageAnimationModeExternal(PRUint16 aMode);
277 : NS_HIDDEN_(void) SetImageAnimationModeInternal(PRUint16 aMode);
278 : #ifdef _IMPL_NS_LAYOUT
279 0 : void SetImageAnimationMode(PRUint16 aMode)
280 0 : { SetImageAnimationModeInternal(aMode); }
281 : #else
282 0 : void SetImageAnimationMode(PRUint16 aMode)
283 0 : { SetImageAnimationModeExternal(aMode); }
284 : #endif
285 :
286 : /**
287 : * Get medium of presentation
288 : */
289 : nsIAtom* Medium() { return mMedium; }
290 :
291 : void* AllocateFromShell(size_t aSize)
292 : {
293 : if (mShell)
294 : return mShell->AllocateMisc(aSize);
295 : return nsnull;
296 : }
297 :
298 : void FreeToShell(size_t aSize, void* aFreeChunk)
299 : {
300 : NS_ASSERTION(mShell, "freeing after shutdown");
301 : if (mShell)
302 : mShell->FreeMisc(aSize, aFreeChunk);
303 : }
304 :
305 : /**
306 : * Get the default font for the given language and generic font ID.
307 : * If aLanguage is nsnull, the document's language is used.
308 : *
309 : * This object is read-only, you must copy the font to modify it.
310 : *
311 : * When aFontID is kPresContext_DefaultVariableFontID or
312 : * kPresContext_DefaultFixedFontID (which equals
313 : * kGenericFont_moz_fixed, which is used for the -moz-fixed generic),
314 : * the nsFont returned has its name as a CSS generic family (serif or
315 : * sans-serif for the former, monospace for the latter), and its size
316 : * as the default font size for variable or fixed fonts for the
317 : * language group.
318 : *
319 : * For aFontID corresponding to a CSS Generic, the nsFont returned has
320 : * its name set to that generic font's name, and its size set to
321 : * the user's preference for font size for that generic and the
322 : * given language.
323 : */
324 : NS_HIDDEN_(const nsFont*) GetDefaultFont(PRUint8 aFontID,
325 : nsIAtom *aLanguage) const;
326 :
327 : /** Get a cached boolean pref, by its type */
328 : // * - initially created for bugs 31816, 20760, 22963
329 0 : bool GetCachedBoolPref(nsPresContext_CachedBoolPrefType aPrefType) const
330 : {
331 : // If called with a constant parameter, the compiler should optimize
332 : // this switch statement away.
333 0 : switch (aPrefType) {
334 : case kPresContext_UseDocumentFonts:
335 0 : return mUseDocumentFonts;
336 : case kPresContext_UseDocumentColors:
337 0 : return mUseDocumentColors;
338 : case kPresContext_UnderlineLinks:
339 0 : return mUnderlineLinks;
340 : default:
341 0 : NS_ERROR("Invalid arg passed to GetCachedBoolPref");
342 : }
343 :
344 0 : return false;
345 : }
346 :
347 : /** Get a cached integer pref, by its type */
348 : // * - initially created for bugs 30910, 61883, 74186, 84398
349 : PRInt32 GetCachedIntPref(nsPresContext_CachedIntPrefType aPrefType) const
350 : {
351 : // If called with a constant parameter, the compiler should optimize
352 : // this switch statement away.
353 : switch (aPrefType) {
354 : case kPresContext_ScrollbarSide:
355 : return mPrefScrollbarSide;
356 : case kPresContext_BidiDirection:
357 : return mPrefBidiDirection;
358 : default:
359 : NS_ERROR("invalid arg passed to GetCachedIntPref");
360 : }
361 :
362 : return false;
363 : }
364 :
365 : /**
366 : * Get the default colors
367 : */
368 : const nscolor DefaultColor() const { return mDefaultColor; }
369 0 : const nscolor DefaultBackgroundColor() const { return mBackgroundColor; }
370 : const nscolor DefaultLinkColor() const { return mLinkColor; }
371 : const nscolor DefaultActiveLinkColor() const { return mActiveLinkColor; }
372 : const nscolor DefaultVisitedLinkColor() const { return mVisitedLinkColor; }
373 : const nscolor FocusBackgroundColor() const { return mFocusBackgroundColor; }
374 : const nscolor FocusTextColor() const { return mFocusTextColor; }
375 :
376 : /**
377 : * Body text color, for use in quirks mode only.
378 : */
379 : const nscolor BodyTextColor() const { return mBodyTextColor; }
380 : void SetBodyTextColor(nscolor aColor) { mBodyTextColor = aColor; }
381 :
382 : bool GetUseFocusColors() const { return mUseFocusColors; }
383 : PRUint8 FocusRingWidth() const { return mFocusRingWidth; }
384 : bool GetFocusRingOnAnything() const { return mFocusRingOnAnything; }
385 : PRUint8 GetFocusRingStyle() const { return mFocusRingStyle; }
386 :
387 : /**
388 : * The types of image load types that the pres context needs image
389 : * loaders to track invalidation for.
390 : */
391 : enum ImageLoadType {
392 : BACKGROUND_IMAGE,
393 : BORDER_IMAGE,
394 : IMAGE_LOAD_TYPE_COUNT
395 : };
396 :
397 : /**
398 : * Set the list of image loaders that track invalidation for a
399 : * specific frame and type of image. This list will replace any
400 : * previous list for that frame and image type (and null will remove
401 : * any previous list).
402 : */
403 : NS_HIDDEN_(void) SetImageLoaders(nsIFrame* aTargetFrame,
404 : ImageLoadType aType,
405 : nsImageLoader* aImageLoaders);
406 :
407 : /**
408 : * Make an appropriate SetImageLoaders call (including potentially
409 : * with null aImageLoaders) given that aFrame draws its background
410 : * based on aStyleBackground.
411 : */
412 : NS_HIDDEN_(void) SetupBackgroundImageLoaders(nsIFrame* aFrame,
413 : const nsStyleBackground*
414 : aStyleBackground);
415 :
416 : /**
417 : * Make an appropriate SetImageLoaders call (including potentially
418 : * with null aImageLoaders) given that aFrame draws its border
419 : * based on aStyleBorder.
420 : */
421 : NS_HIDDEN_(void) SetupBorderImageLoaders(nsIFrame* aFrame,
422 : const nsStyleBorder* aStyleBorder);
423 :
424 : /**
425 : * This method is called when a frame is being destroyed to
426 : * ensure that the image loads get disassociated from the prescontext
427 : */
428 : NS_HIDDEN_(void) StopImagesFor(nsIFrame* aTargetFrame);
429 :
430 : NS_HIDDEN_(void) SetContainer(nsISupports* aContainer);
431 :
432 : virtual NS_HIDDEN_(already_AddRefed<nsISupports>) GetContainerExternal() const;
433 : NS_HIDDEN_(already_AddRefed<nsISupports>) GetContainerInternal() const;
434 : #ifdef _IMPL_NS_LAYOUT
435 0 : already_AddRefed<nsISupports> GetContainer() const
436 0 : { return GetContainerInternal(); }
437 : #else
438 0 : already_AddRefed<nsISupports> GetContainer() const
439 0 : { return GetContainerExternal(); }
440 : #endif
441 :
442 : // XXX this are going to be replaced with set/get container
443 0 : void SetLinkHandler(nsILinkHandler* aHandler) { mLinkHandler = aHandler; }
444 0 : nsILinkHandler* GetLinkHandler() { return mLinkHandler; }
445 :
446 : /**
447 : * Get the visible area associated with this presentation context.
448 : * This is the size of the visible area that is used for
449 : * presenting the document. The returned value is in the standard
450 : * nscoord units (as scaled by the device context).
451 : */
452 0 : nsRect GetVisibleArea() { return mVisibleArea; }
453 :
454 : /**
455 : * Set the currently visible area. The units for r are standard
456 : * nscoord units (as scaled by the device context).
457 : */
458 0 : void SetVisibleArea(const nsRect& r) {
459 0 : if (!r.IsEqualEdges(mVisibleArea)) {
460 0 : mVisibleArea = r;
461 : // Visible area does not affect media queries when paginated.
462 0 : if (!IsPaginated() && HasCachedStyleData())
463 0 : PostMediaFeatureValuesChangedEvent();
464 : }
465 0 : }
466 :
467 : /**
468 : * Return true if this presentation context is a paginated
469 : * context.
470 : */
471 0 : bool IsPaginated() const { return mPaginated; }
472 :
473 : /**
474 : * Sets whether the presentation context can scroll for a paginated
475 : * context.
476 : */
477 : NS_HIDDEN_(void) SetPaginatedScrolling(bool aResult);
478 :
479 : /**
480 : * Return true if this presentation context can scroll for paginated
481 : * context.
482 : */
483 : bool HasPaginatedScrolling() const { return mCanPaginatedScroll; }
484 :
485 : /**
486 : * Get/set the size of a page
487 : */
488 : nsSize GetPageSize() { return mPageSize; }
489 0 : void SetPageSize(nsSize aSize) { mPageSize = aSize; }
490 :
491 : /**
492 : * Get/set whether this document should be treated as having real pages
493 : * XXX This raises the obvious question of why a document that isn't a page
494 : * is paginated; there isn't a good reason except history
495 : */
496 0 : bool IsRootPaginatedDocument() { return mIsRootPaginatedDocument; }
497 0 : void SetIsRootPaginatedDocument(bool aIsRootPaginatedDocument)
498 0 : { mIsRootPaginatedDocument = aIsRootPaginatedDocument; }
499 :
500 : /**
501 : * Get/set the print scaling level; used by nsPageFrame to scale up
502 : * pages. Set safe to call before reflow, get guaranteed to be set
503 : * properly after reflow.
504 : */
505 :
506 : float GetPageScale() { return mPageScale; }
507 0 : void SetPageScale(float aScale) { mPageScale = aScale; }
508 :
509 : /**
510 : * Get/set the scaling facor to use when rendering the pages for print preview.
511 : * Only safe to get after print preview set up; safe to set anytime.
512 : * This is a scaling factor for the display of the print preview. It
513 : * does not affect layout. It only affects the size of the onscreen pages
514 : * in print preview.
515 : * XXX Temporary: see http://wiki.mozilla.org/Gecko:PrintPreview
516 : */
517 : float GetPrintPreviewScale() { return mPPScale; }
518 0 : void SetPrintPreviewScale(float aScale) { mPPScale = aScale; }
519 :
520 0 : nsDeviceContext* DeviceContext() { return mDeviceContext; }
521 0 : nsEventStateManager* EventStateManager() { return mEventManager; }
522 0 : nsIAtom* GetLanguageFromCharset() { return mLanguage; }
523 :
524 0 : float TextZoom() { return mTextZoom; }
525 0 : void SetTextZoom(float aZoom) {
526 0 : if (aZoom == mTextZoom)
527 0 : return;
528 :
529 0 : mTextZoom = aZoom;
530 0 : if (HasCachedStyleData()) {
531 : // Media queries could have changed, since we changed the meaning
532 : // of 'em' units in them.
533 0 : MediaFeatureValuesChanged(true);
534 0 : RebuildAllStyleData(NS_STYLE_HINT_REFLOW);
535 : }
536 : }
537 :
538 : /**
539 : * Get the minimum font size for the specified language. If aLanguage
540 : * is nsnull, then the document's language is used.
541 : */
542 0 : PRInt32 MinFontSize(nsIAtom *aLanguage) const {
543 0 : const LangGroupFontPrefs *prefs = GetFontPrefsForLang(aLanguage);
544 0 : return NS_MAX(mMinFontSize, prefs->mMinimumFontSize);
545 : }
546 :
547 0 : void SetMinFontSize(PRInt32 aMinFontSize) {
548 0 : if (aMinFontSize == mMinFontSize)
549 0 : return;
550 :
551 0 : mMinFontSize = aMinFontSize;
552 0 : if (HasCachedStyleData()) {
553 : // Media queries could have changed, since we changed the meaning
554 : // of 'em' units in them.
555 0 : MediaFeatureValuesChanged(true);
556 0 : RebuildAllStyleData(NS_STYLE_HINT_REFLOW);
557 : }
558 : }
559 :
560 0 : float GetFullZoom() { return mFullZoom; }
561 : void SetFullZoom(float aZoom);
562 :
563 : nscoord GetAutoQualityMinFontSize() {
564 : return DevPixelsToAppUnits(mAutoQualityMinFontSizePixelsPref);
565 : }
566 :
567 0 : static PRInt32 AppUnitsPerCSSPixel() { return nsDeviceContext::AppUnitsPerCSSPixel(); }
568 0 : PRUint32 AppUnitsPerDevPixel() const { return mDeviceContext->AppUnitsPerDevPixel(); }
569 : static PRInt32 AppUnitsPerCSSInch() { return nsDeviceContext::AppUnitsPerCSSInch(); }
570 :
571 0 : static nscoord CSSPixelsToAppUnits(PRInt32 aPixels)
572 : { return NSIntPixelsToAppUnits(aPixels,
573 0 : nsDeviceContext::AppUnitsPerCSSPixel()); }
574 :
575 0 : static nscoord CSSPixelsToAppUnits(float aPixels)
576 : { return NSFloatPixelsToAppUnits(aPixels,
577 0 : float(nsDeviceContext::AppUnitsPerCSSPixel())); }
578 :
579 0 : static PRInt32 AppUnitsToIntCSSPixels(nscoord aAppUnits)
580 : { return NSAppUnitsToIntPixels(aAppUnits,
581 0 : float(nsDeviceContext::AppUnitsPerCSSPixel())); }
582 :
583 0 : static float AppUnitsToFloatCSSPixels(nscoord aAppUnits)
584 : { return NSAppUnitsToFloatPixels(aAppUnits,
585 0 : float(nsDeviceContext::AppUnitsPerCSSPixel())); }
586 :
587 0 : nscoord DevPixelsToAppUnits(PRInt32 aPixels) const
588 : { return NSIntPixelsToAppUnits(aPixels,
589 0 : mDeviceContext->AppUnitsPerDevPixel()); }
590 :
591 0 : PRInt32 AppUnitsToDevPixels(nscoord aAppUnits) const
592 : { return NSAppUnitsToIntPixels(aAppUnits,
593 0 : float(mDeviceContext->AppUnitsPerDevPixel())); }
594 :
595 0 : PRInt32 CSSPixelsToDevPixels(PRInt32 aPixels)
596 0 : { return AppUnitsToDevPixels(CSSPixelsToAppUnits(aPixels)); }
597 :
598 0 : float CSSPixelsToDevPixels(float aPixels)
599 : {
600 : return NSAppUnitsToFloatPixels(CSSPixelsToAppUnits(aPixels),
601 0 : float(mDeviceContext->AppUnitsPerDevPixel()));
602 : }
603 :
604 0 : PRInt32 DevPixelsToIntCSSPixels(PRInt32 aPixels)
605 0 : { return AppUnitsToIntCSSPixels(DevPixelsToAppUnits(aPixels)); }
606 :
607 : float DevPixelsToFloatCSSPixels(PRInt32 aPixels)
608 : { return AppUnitsToFloatCSSPixels(DevPixelsToAppUnits(aPixels)); }
609 :
610 : // If there is a remainder, it is rounded to nearest app units.
611 : nscoord GfxUnitsToAppUnits(gfxFloat aGfxUnits) const
612 : { return mDeviceContext->GfxUnitsToAppUnits(aGfxUnits); }
613 :
614 0 : gfxFloat AppUnitsToGfxUnits(nscoord aAppUnits) const
615 0 : { return mDeviceContext->AppUnitsToGfxUnits(aAppUnits); }
616 :
617 0 : gfxRect AppUnitsToGfxUnits(const nsRect& aAppRect) const
618 : { return gfxRect(AppUnitsToGfxUnits(aAppRect.x),
619 : AppUnitsToGfxUnits(aAppRect.y),
620 : AppUnitsToGfxUnits(aAppRect.width),
621 0 : AppUnitsToGfxUnits(aAppRect.height)); }
622 :
623 0 : static nscoord CSSTwipsToAppUnits(float aTwips)
624 : { return NSToCoordRoundWithClamp(
625 0 : nsDeviceContext::AppUnitsPerCSSInch() * NS_TWIPS_TO_INCHES(aTwips)); }
626 :
627 : // Margin-specific version, since they often need TwipsToAppUnits
628 0 : static nsMargin CSSTwipsToAppUnits(const nsIntMargin &marginInTwips)
629 : { return nsMargin(CSSTwipsToAppUnits(float(marginInTwips.left)),
630 : CSSTwipsToAppUnits(float(marginInTwips.top)),
631 : CSSTwipsToAppUnits(float(marginInTwips.right)),
632 0 : CSSTwipsToAppUnits(float(marginInTwips.bottom))); }
633 :
634 : static nscoord CSSPointsToAppUnits(float aPoints)
635 : { return NSToCoordRound(aPoints * nsDeviceContext::AppUnitsPerCSSInch() /
636 : POINTS_PER_INCH_FLOAT); }
637 :
638 : nscoord RoundAppUnitsToNearestDevPixels(nscoord aAppUnits) const
639 : { return DevPixelsToAppUnits(AppUnitsToDevPixels(aAppUnits)); }
640 :
641 : struct ScrollbarStyles {
642 : // Always one of NS_STYLE_OVERFLOW_SCROLL, NS_STYLE_OVERFLOW_HIDDEN,
643 : // or NS_STYLE_OVERFLOW_AUTO.
644 : PRUint8 mHorizontal, mVertical;
645 0 : ScrollbarStyles(PRUint8 h, PRUint8 v) : mHorizontal(h), mVertical(v) {}
646 : ScrollbarStyles() {}
647 : bool operator==(const ScrollbarStyles& aStyles) const {
648 : return aStyles.mHorizontal == mHorizontal && aStyles.mVertical == mVertical;
649 : }
650 : bool operator!=(const ScrollbarStyles& aStyles) const {
651 : return aStyles.mHorizontal != mHorizontal || aStyles.mVertical != mVertical;
652 : }
653 : };
654 : void SetViewportOverflowOverride(PRUint8 aX, PRUint8 aY)
655 : {
656 : mViewportStyleOverflow.mHorizontal = aX;
657 : mViewportStyleOverflow.mVertical = aY;
658 : }
659 : ScrollbarStyles GetViewportOverflowOverride()
660 : {
661 : return mViewportStyleOverflow;
662 : }
663 :
664 : /**
665 : * Set and get methods for controlling the background drawing
666 : */
667 : bool GetBackgroundImageDraw() const { return mDrawImageBackground; }
668 0 : void SetBackgroundImageDraw(bool aCanDraw)
669 : {
670 0 : mDrawImageBackground = aCanDraw;
671 0 : }
672 :
673 : bool GetBackgroundColorDraw() const { return mDrawColorBackground; }
674 0 : void SetBackgroundColorDraw(bool aCanDraw)
675 : {
676 0 : mDrawColorBackground = aCanDraw;
677 0 : }
678 :
679 : #ifdef IBMBIDI
680 : /**
681 : * Check if bidi enabled (set depending on the presence of RTL
682 : * characters or when default directionality is RTL).
683 : * If enabled, we should apply the Unicode Bidi Algorithm
684 : *
685 : * @lina 07/12/2000
686 : */
687 : virtual bool BidiEnabledExternal() const { return BidiEnabledInternal(); }
688 : bool BidiEnabledInternal() const { return Document()->GetBidiEnabled(); }
689 : #ifdef _IMPL_NS_LAYOUT
690 : bool BidiEnabled() const { return BidiEnabledInternal(); }
691 : #else
692 0 : bool BidiEnabled() const { return BidiEnabledExternal(); }
693 : #endif
694 :
695 : /**
696 : * Set bidi enabled. This means we should apply the Unicode Bidi Algorithm
697 : *
698 : * @lina 07/12/2000
699 : */
700 : NS_HIDDEN_(void) SetBidiEnabled() const;
701 :
702 : /**
703 : * Set visual or implicit mode into the pres context.
704 : *
705 : * Visual directionality is a presentation method that displays text
706 : * as if it were a uni-directional, according to the primary display
707 : * direction only.
708 : *
709 : * Implicit directionality is a presentation method in which the
710 : * direction is determined by the Bidi algorithm according to the
711 : * category of the characters and the category of the adjacent
712 : * characters, and according to their primary direction.
713 : *
714 : * @lina 05/02/2000
715 : */
716 : void SetVisualMode(bool aIsVisual)
717 : {
718 : mIsVisual = aIsVisual;
719 : }
720 :
721 : /**
722 : * Check whether the content should be treated as visual.
723 : *
724 : * @lina 05/02/2000
725 : */
726 : bool IsVisualMode() const { return mIsVisual; }
727 :
728 : //Mohamed
729 :
730 : /**
731 : * Set the Bidi options for the presentation context
732 : */
733 : NS_HIDDEN_(void) SetBidi(PRUint32 aBidiOptions,
734 : bool aForceRestyle = false);
735 :
736 : /**
737 : * Get the Bidi options for the presentation context
738 : * Not inline so consumers of nsPresContext are not forced to
739 : * include nsIDocument.
740 : */
741 : NS_HIDDEN_(PRUint32) GetBidi() const;
742 : #endif // IBMBIDI
743 :
744 : /**
745 : * Render only Selection
746 : */
747 0 : void SetIsRenderingOnlySelection(bool aResult)
748 : {
749 0 : mIsRenderingOnlySelection = aResult;
750 0 : }
751 :
752 : bool IsRenderingOnlySelection() const { return mIsRenderingOnlySelection; }
753 :
754 : NS_HIDDEN_(bool) IsTopLevelWindowInactive();
755 :
756 : /*
757 : * Obtain a native them for rendering our widgets (both form controls and html)
758 : */
759 : NS_HIDDEN_(nsITheme*) GetTheme();
760 :
761 : /*
762 : * Notify the pres context that the theme has changed. An internal switch
763 : * means it's one of our Mozilla themes that changed (e.g., Modern to Classic).
764 : * Otherwise, the OS is telling us that the native theme for the platform
765 : * has changed.
766 : */
767 : NS_HIDDEN_(void) ThemeChanged();
768 :
769 : /*
770 : * Notify the pres context that a system color has changed
771 : */
772 : NS_HIDDEN_(void) SysColorChanged();
773 :
774 : /** Printing methods below should only be used for Medium() == print **/
775 : NS_HIDDEN_(void) SetPrintSettings(nsIPrintSettings *aPrintSettings);
776 :
777 : nsIPrintSettings* GetPrintSettings() { return mPrintSettings; }
778 :
779 : /* Accessor for table of frame properties */
780 0 : FramePropertyTable* PropertyTable() { return &mPropertyTable; }
781 :
782 : /* Helper function that ensures that this prescontext is shown in its
783 : docshell if it's the most recent prescontext for the docshell. Returns
784 : whether the prescontext is now being shown.
785 : */
786 : NS_HIDDEN_(bool) EnsureVisible();
787 :
788 : #ifdef MOZ_REFLOW_PERF
789 : NS_HIDDEN_(void) CountReflows(const char * aName,
790 : nsIFrame * aFrame);
791 : #endif
792 :
793 : /**
794 : * This table maps border-width enums 'thin', 'medium', 'thick'
795 : * to actual nscoord values.
796 : */
797 : const nscoord* GetBorderWidthTable() { return mBorderWidthTable; }
798 :
799 0 : bool IsDynamic() { return (mType == eContext_PageLayout || mType == eContext_Galley); }
800 : bool IsScreen() { return (mMedium == nsGkAtoms::screen ||
801 : mType == eContext_PageLayout ||
802 : mType == eContext_PrintPreview); }
803 :
804 : // Is this presentation in a chrome docshell?
805 0 : bool IsChrome() const
806 : {
807 0 : return mIsChromeIsCached ? mIsChrome : IsChromeSlow();
808 : }
809 :
810 : virtual void InvalidateIsChromeCacheExternal();
811 : void InvalidateIsChromeCacheInternal() { mIsChromeIsCached = false; }
812 : #ifdef _IMPL_NS_LAYOUT
813 : void InvalidateIsChromeCache()
814 : { InvalidateIsChromeCacheInternal(); }
815 : #else
816 0 : void InvalidateIsChromeCache()
817 0 : { InvalidateIsChromeCacheExternal(); }
818 : #endif
819 :
820 : // Public API for native theme code to get style internals.
821 : virtual bool HasAuthorSpecifiedRules(nsIFrame *aFrame, PRUint32 ruleTypeMask) const;
822 :
823 : // Is it OK to let the page specify colors and backgrounds?
824 0 : bool UseDocumentColors() const {
825 0 : return GetCachedBoolPref(kPresContext_UseDocumentColors) || IsChrome();
826 : }
827 :
828 : bool SupressingResizeReflow() const { return mSupressResizeReflow; }
829 :
830 : virtual NS_HIDDEN_(gfxUserFontSet*) GetUserFontSetExternal();
831 : NS_HIDDEN_(gfxUserFontSet*) GetUserFontSetInternal();
832 : #ifdef _IMPL_NS_LAYOUT
833 0 : gfxUserFontSet* GetUserFontSet() { return GetUserFontSetInternal(); }
834 : #else
835 0 : gfxUserFontSet* GetUserFontSet() { return GetUserFontSetExternal(); }
836 : #endif
837 :
838 : void FlushUserFontSet();
839 : void RebuildUserFontSet(); // asynchronously
840 :
841 : // Should be called whenever the set of fonts available in the user
842 : // font set changes (e.g., because a new font loads, or because the
843 : // user font set is changed and fonts become unavailable).
844 : void UserFontSetUpdated();
845 :
846 : // Ensure that it is safe to hand out CSS rules outside the layout
847 : // engine by ensuring that all CSS style sheets have unique inners
848 : // and, if necessary, synchronously rebuilding all style data.
849 : // Returns true on success and false on failure (not safe).
850 : bool EnsureSafeToHandOutCSSRules();
851 :
852 : void NotifyInvalidation(const nsRect& aRect, PRUint32 aFlags);
853 : void NotifyDidPaintForSubtree();
854 : void FireDOMPaintEvent();
855 :
856 0 : bool IsDOMPaintEventPending() {
857 0 : return !mInvalidateRequests.mRequests.IsEmpty();
858 : }
859 0 : void ClearMozAfterPaintEvents() {
860 0 : mInvalidateRequests.mRequests.Clear();
861 0 : }
862 :
863 0 : bool IsProcessingRestyles() const {
864 0 : return mProcessingRestyles;
865 : }
866 :
867 : void SetProcessingRestyles(bool aProcessing) {
868 : NS_ASSERTION(aProcessing != bool(mProcessingRestyles),
869 : "should never nest");
870 : mProcessingRestyles = aProcessing;
871 : }
872 :
873 0 : bool IsProcessingAnimationStyleChange() const {
874 0 : return mProcessingAnimationStyleChange;
875 : }
876 :
877 : void SetProcessingAnimationStyleChange(bool aProcessing) {
878 : NS_ASSERTION(aProcessing != bool(mProcessingAnimationStyleChange),
879 : "should never nest");
880 : mProcessingAnimationStyleChange = aProcessing;
881 : }
882 :
883 : /**
884 : * Notify the prescontext that the presshell is about to reflow a reflow root.
885 : * The single argument indicates whether this reflow should be interruptible.
886 : * If aInterruptible is false then CheckForInterrupt and HasPendingInterrupt
887 : * will always return false. If aInterruptible is true then CheckForInterrupt
888 : * will return true when a pending event is detected. This is for use by the
889 : * presshell only. Reflow code wanting to prevent interrupts should use
890 : * InterruptPreventer.
891 : */
892 : void ReflowStarted(bool aInterruptible);
893 :
894 : /**
895 : * A class that can be used to temporarily disable reflow interruption.
896 : */
897 : class InterruptPreventer;
898 : friend class InterruptPreventer;
899 : class NS_STACK_CLASS InterruptPreventer {
900 : public:
901 : InterruptPreventer(nsPresContext* aCtx) :
902 : mCtx(aCtx),
903 : mInterruptsEnabled(aCtx->mInterruptsEnabled),
904 : mHasPendingInterrupt(aCtx->mHasPendingInterrupt)
905 : {
906 : mCtx->mInterruptsEnabled = false;
907 : mCtx->mHasPendingInterrupt = false;
908 : }
909 : ~InterruptPreventer() {
910 : mCtx->mInterruptsEnabled = mInterruptsEnabled;
911 : mCtx->mHasPendingInterrupt = mHasPendingInterrupt;
912 : }
913 :
914 : private:
915 : nsPresContext* mCtx;
916 : bool mInterruptsEnabled;
917 : bool mHasPendingInterrupt;
918 : };
919 :
920 : /**
921 : * Check for interrupts. This may return true if a pending event is
922 : * detected. Once it has returned true, it will keep returning true
923 : * until ReflowStarted is called. In all cases where this returns true,
924 : * the passed-in frame (which should be the frame whose reflow will be
925 : * interrupted if true is returned) will be passed to
926 : * nsIPresShell::FrameNeedsToContinueReflow.
927 : */
928 : bool CheckForInterrupt(nsIFrame* aFrame);
929 : /**
930 : * Returns true if CheckForInterrupt has returned true since the last
931 : * ReflowStarted call. Cannot itself trigger an interrupt check.
932 : */
933 0 : bool HasPendingInterrupt() { return mHasPendingInterrupt; }
934 :
935 : /**
936 : * If we have a presshell, and if the given content's current
937 : * document is the same as our presshell's document, return the
938 : * content's primary frame. Otherwise, return null. Only use this
939 : * if you care about which presshell the primary frame is in.
940 : */
941 0 : nsIFrame* GetPrimaryFrameFor(nsIContent* aContent) {
942 0 : NS_PRECONDITION(aContent, "Don't do that");
943 0 : if (GetPresShell() &&
944 0 : GetPresShell()->GetDocument() == aContent->GetCurrentDoc()) {
945 0 : return aContent->GetPrimaryFrame();
946 : }
947 0 : return nsnull;
948 : }
949 :
950 : void NotifyDestroyingFrame(nsIFrame* aFrame)
951 : {
952 : PropertyTable()->DeleteAllFor(aFrame);
953 : }
954 : inline void ForgetUpdatePluginGeometryFrame(nsIFrame* aFrame);
955 :
956 : void DestroyImageLoaders();
957 :
958 : bool GetContainsUpdatePluginGeometryFrame()
959 : {
960 : return mContainsUpdatePluginGeometryFrame;
961 : }
962 :
963 : void SetContainsUpdatePluginGeometryFrame(bool aValue)
964 : {
965 : mContainsUpdatePluginGeometryFrame = aValue;
966 : }
967 :
968 : bool MayHaveFixedBackgroundFrames() { return mMayHaveFixedBackgroundFrames; }
969 : void SetHasFixedBackgroundFrame() { mMayHaveFixedBackgroundFrames = true; }
970 :
971 : virtual size_t SizeOfExcludingThis(nsMallocSizeOfFun aMallocSizeOf) const;
972 : virtual size_t SizeOfIncludingThis(nsMallocSizeOfFun aMallocSizeOf) const {
973 : return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
974 : }
975 :
976 : bool IsRootContentDocument();
977 :
978 : protected:
979 : friend class nsRunnableMethod<nsPresContext>;
980 : NS_HIDDEN_(void) ThemeChangedInternal();
981 : NS_HIDDEN_(void) SysColorChangedInternal();
982 :
983 : NS_HIDDEN_(void) SetImgAnimations(nsIContent *aParent, PRUint16 aMode);
984 : NS_HIDDEN_(void) SetSMILAnimations(nsIDocument *aDoc, PRUint16 aNewMode,
985 : PRUint16 aOldMode);
986 : NS_HIDDEN_(void) GetDocumentColorPreferences();
987 :
988 : NS_HIDDEN_(void) PreferenceChanged(const char* aPrefName);
989 : static NS_HIDDEN_(int) PrefChangedCallback(const char*, void*);
990 :
991 : NS_HIDDEN_(void) UpdateAfterPreferencesChanged();
992 : static NS_HIDDEN_(void) PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
993 :
994 : NS_HIDDEN_(void) GetUserPreferences();
995 :
996 : // Allow nsAutoPtr<LangGroupFontPrefs> dtor to access this protected struct's
997 : // dtor:
998 : struct LangGroupFontPrefs;
999 : friend class nsAutoPtr<LangGroupFontPrefs>;
1000 : struct LangGroupFontPrefs {
1001 : // Font sizes default to zero; they will be set in GetFontPreferences
1002 : LangGroupFontPrefs()
1003 : : mLangGroup(nsnull)
1004 : , mMinimumFontSize(0)
1005 : , mDefaultVariableFont("serif", NS_FONT_STYLE_NORMAL, NS_FONT_VARIANT_NORMAL,
1006 : NS_FONT_WEIGHT_NORMAL, NS_FONT_STRETCH_NORMAL, 0, 0)
1007 : , mDefaultFixedFont("monospace", NS_FONT_STYLE_NORMAL,
1008 : NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
1009 : NS_FONT_STRETCH_NORMAL, 0, 0)
1010 : , mDefaultSerifFont("serif", NS_FONT_STYLE_NORMAL, NS_FONT_VARIANT_NORMAL,
1011 : NS_FONT_WEIGHT_NORMAL, NS_FONT_STRETCH_NORMAL, 0, 0)
1012 : , mDefaultSansSerifFont("sans-serif", NS_FONT_STYLE_NORMAL,
1013 : NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
1014 : NS_FONT_STRETCH_NORMAL, 0, 0)
1015 : , mDefaultMonospaceFont("monospace", NS_FONT_STYLE_NORMAL,
1016 : NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
1017 : NS_FONT_STRETCH_NORMAL, 0, 0)
1018 : , mDefaultCursiveFont("cursive", NS_FONT_STYLE_NORMAL,
1019 : NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
1020 : NS_FONT_STRETCH_NORMAL, 0, 0)
1021 : , mDefaultFantasyFont("fantasy", NS_FONT_STYLE_NORMAL,
1022 : NS_FONT_VARIANT_NORMAL, NS_FONT_WEIGHT_NORMAL,
1023 : NS_FONT_STRETCH_NORMAL, 0, 0)
1024 : {}
1025 :
1026 : size_t SizeOfExcludingThis(nsMallocSizeOfFun aMallocSizeOf) const {
1027 : size_t n = 0;
1028 : LangGroupFontPrefs *curr = mNext;
1029 : while (curr) {
1030 : n += aMallocSizeOf(curr);
1031 :
1032 : // Measurement of the following members may be added later if DMD finds
1033 : // it is worthwhile:
1034 : // - mLangGroup
1035 : // - mDefault*Font
1036 :
1037 : curr = curr->mNext;
1038 : }
1039 : return n;
1040 : }
1041 :
1042 : nsCOMPtr<nsIAtom> mLangGroup;
1043 : nscoord mMinimumFontSize;
1044 : nsFont mDefaultVariableFont;
1045 : nsFont mDefaultFixedFont;
1046 : nsFont mDefaultSerifFont;
1047 : nsFont mDefaultSansSerifFont;
1048 : nsFont mDefaultMonospaceFont;
1049 : nsFont mDefaultCursiveFont;
1050 : nsFont mDefaultFantasyFont;
1051 : nsAutoPtr<LangGroupFontPrefs> mNext;
1052 : };
1053 :
1054 : /**
1055 : * Fetch the user's font preferences for the given aLanguage's
1056 : * langugage group.
1057 : */
1058 : const LangGroupFontPrefs* GetFontPrefsForLang(nsIAtom *aLanguage) const;
1059 :
1060 : void ResetCachedFontPrefs() {
1061 : // Throw away any other LangGroupFontPrefs objects:
1062 : mLangGroupFontPrefs.mNext = nsnull;
1063 :
1064 : // Make GetFontPreferences reinitialize mLangGroupFontPrefs:
1065 : mLangGroupFontPrefs.mLangGroup = nsnull;
1066 : }
1067 :
1068 : NS_HIDDEN_(void) UpdateCharSet(const nsCString& aCharSet);
1069 :
1070 : public:
1071 : void DoChangeCharSet(const nsCString& aCharSet);
1072 :
1073 : protected:
1074 : void InvalidateThebesLayers();
1075 : void AppUnitsPerDevPixelChanged();
1076 :
1077 : bool MayHavePaintEventListener();
1078 :
1079 : void HandleRebuildUserFontSet() {
1080 : mPostedFlushUserFontSet = false;
1081 : FlushUserFontSet();
1082 : }
1083 :
1084 : bool HavePendingInputEvent();
1085 :
1086 : // Can't be inline because we can't include nsStyleSet.h.
1087 : bool HasCachedStyleData();
1088 :
1089 : bool IsChromeSlow() const;
1090 :
1091 : // IMPORTANT: The ownership implicit in the following member variables
1092 : // has been explicitly checked. If you add any members to this class,
1093 : // please make the ownership explicit (pinkerton, scc).
1094 :
1095 : nsPresContextType mType;
1096 : nsIPresShell* mShell; // [WEAK]
1097 : nsCOMPtr<nsIDocument> mDocument;
1098 : nsDeviceContext* mDeviceContext; // [STRONG] could be weak, but
1099 : // better safe than sorry.
1100 : // Cannot reintroduce cycles
1101 : // since there is no dependency
1102 : // from gfx back to layout.
1103 : nsEventStateManager* mEventManager; // [STRONG]
1104 : nsRefPtr<nsRefreshDriver> mRefreshDriver;
1105 : nsRefPtr<nsTransitionManager> mTransitionManager;
1106 : nsRefPtr<nsAnimationManager> mAnimationManager;
1107 : nsIAtom* mMedium; // initialized by subclass ctors;
1108 : // weak pointer to static atom
1109 :
1110 : nsILinkHandler* mLinkHandler; // [WEAK]
1111 :
1112 : // Formerly mLangGroup; moving from charset-oriented langGroup to
1113 : // maintaining actual language settings everywhere (see bug 524107).
1114 : // This may in fact hold a langGroup such as x-western rather than
1115 : // a specific language, however (e.g, if it is inferred from the
1116 : // charset rather than explicitly specified as a lang attribute).
1117 : nsIAtom* mLanguage; // [STRONG]
1118 :
1119 : public:
1120 : // The following are public member variables so that we can use them
1121 : // with mozilla::AutoToggle or mozilla::AutoRestore.
1122 :
1123 : // The frame that is the container for font size inflation for the
1124 : // reflow or intrinsic width computation currently happening. If this
1125 : // frame is null, then font inflation should not be performed.
1126 : nsIFrame* mCurrentInflationContainer; // [WEAK]
1127 :
1128 : // The content-rect width of mCurrentInflationContainer. If
1129 : // mCurrentInflationContainer is currently in reflow, this is its new
1130 : // width, which is not yet set on its rect.
1131 : nscoord mCurrentInflationContainerWidth;
1132 :
1133 : protected:
1134 :
1135 : nsRefPtrHashtable<nsVoidPtrHashKey, nsImageLoader>
1136 : mImageLoaders[IMAGE_LOAD_TYPE_COUNT];
1137 :
1138 : nsWeakPtr mContainer;
1139 :
1140 : PRCList mDOMMediaQueryLists;
1141 :
1142 : PRInt32 mMinFontSize; // Min font size, defaults to 0
1143 : float mTextZoom; // Text zoom, defaults to 1.0
1144 : float mFullZoom; // Page zoom, defaults to 1.0
1145 :
1146 : PRInt32 mCurAppUnitsPerDevPixel;
1147 : PRInt32 mAutoQualityMinFontSizePixelsPref;
1148 :
1149 : nsCOMPtr<nsITheme> mTheme;
1150 : nsCOMPtr<nsILanguageAtomService> mLangService;
1151 : nsCOMPtr<nsIPrintSettings> mPrintSettings;
1152 : nsCOMPtr<nsITimer> mPrefChangedTimer;
1153 :
1154 : FramePropertyTable mPropertyTable;
1155 :
1156 : nsInvalidateRequestList mInvalidateRequests;
1157 :
1158 : // container for per-context fonts (downloadable, SVG, etc.)
1159 : nsUserFontSet* mUserFontSet;
1160 :
1161 : nsRect mVisibleArea;
1162 : nsSize mPageSize;
1163 : float mPageScale;
1164 : float mPPScale;
1165 :
1166 : nscolor mDefaultColor;
1167 : nscolor mBackgroundColor;
1168 :
1169 : nscolor mLinkColor;
1170 : nscolor mActiveLinkColor;
1171 : nscolor mVisitedLinkColor;
1172 :
1173 : nscolor mFocusBackgroundColor;
1174 : nscolor mFocusTextColor;
1175 :
1176 : nscolor mBodyTextColor;
1177 :
1178 : ScrollbarStyles mViewportStyleOverflow;
1179 : PRUint8 mFocusRingWidth;
1180 :
1181 : PRUint16 mImageAnimationMode;
1182 : PRUint16 mImageAnimationModePref;
1183 :
1184 : LangGroupFontPrefs mLangGroupFontPrefs;
1185 :
1186 : nscoord mBorderWidthTable[3];
1187 :
1188 : PRUint32 mInterruptChecksToSkip;
1189 :
1190 : mozilla::TimeStamp mReflowStartTime;
1191 :
1192 : unsigned mHasPendingInterrupt : 1;
1193 : unsigned mInterruptsEnabled : 1;
1194 : unsigned mUseDocumentFonts : 1;
1195 : unsigned mUseDocumentColors : 1;
1196 : unsigned mUnderlineLinks : 1;
1197 : unsigned mSendAfterPaintToContent : 1;
1198 : unsigned mUseFocusColors : 1;
1199 : unsigned mFocusRingOnAnything : 1;
1200 : unsigned mFocusRingStyle : 1;
1201 : unsigned mDrawImageBackground : 1;
1202 : unsigned mDrawColorBackground : 1;
1203 : unsigned mNeverAnimate : 1;
1204 : unsigned mIsRenderingOnlySelection : 1;
1205 : unsigned mPaginated : 1;
1206 : unsigned mCanPaginatedScroll : 1;
1207 : unsigned mDoScaledTwips : 1;
1208 : unsigned mEnableJapaneseTransform : 1;
1209 : unsigned mIsRootPaginatedDocument : 1;
1210 : unsigned mPrefBidiDirection : 1;
1211 : unsigned mPrefScrollbarSide : 2;
1212 : unsigned mPendingSysColorChanged : 1;
1213 : unsigned mPendingThemeChanged : 1;
1214 : unsigned mPendingMediaFeatureValuesChanged : 1;
1215 : unsigned mPrefChangePendingNeedsReflow : 1;
1216 : unsigned mMayHaveFixedBackgroundFrames : 1;
1217 :
1218 : // Is the current mUserFontSet valid?
1219 : unsigned mUserFontSetDirty : 1;
1220 : // Has GetUserFontSet() been called?
1221 : unsigned mGetUserFontSetCalled : 1;
1222 : // Do we currently have an event posted to call FlushUserFontSet?
1223 : unsigned mPostedFlushUserFontSet : 1;
1224 :
1225 : // resize reflow is suppressed when the only change has been to zoom
1226 : // the document rather than to change the document's dimensions
1227 : unsigned mSupressResizeReflow : 1;
1228 :
1229 : unsigned mIsVisual : 1;
1230 :
1231 : unsigned mProcessingRestyles : 1;
1232 : unsigned mProcessingAnimationStyleChange : 1;
1233 :
1234 : unsigned mContainsUpdatePluginGeometryFrame : 1;
1235 : unsigned mFireAfterPaintEvents : 1;
1236 :
1237 : // Cache whether we are chrome or not because it is expensive.
1238 : // mIsChromeIsCached tells us if mIsChrome is valid or we need to get the
1239 : // value the slow way.
1240 : mutable unsigned mIsChromeIsCached : 1;
1241 : mutable unsigned mIsChrome : 1;
1242 :
1243 : #ifdef DEBUG
1244 : bool mInitialized;
1245 : #endif
1246 :
1247 :
1248 : protected:
1249 :
1250 : virtual ~nsPresContext() NS_HIDDEN;
1251 :
1252 : // these are private, use the list in nsFont.h if you want a public list
1253 : enum {
1254 : eDefaultFont_Variable,
1255 : eDefaultFont_Fixed,
1256 : eDefaultFont_Serif,
1257 : eDefaultFont_SansSerif,
1258 : eDefaultFont_Monospace,
1259 : eDefaultFont_Cursive,
1260 : eDefaultFont_Fantasy,
1261 : eDefaultFont_COUNT
1262 : };
1263 :
1264 : #ifdef DEBUG
1265 : private:
1266 : friend struct nsAutoLayoutPhase;
1267 : PRUint32 mLayoutPhaseCount[eLayoutPhase_COUNT];
1268 : public:
1269 : PRUint32 LayoutPhaseCount(nsLayoutPhase aPhase) {
1270 : return mLayoutPhaseCount[aPhase];
1271 : }
1272 : #endif
1273 :
1274 : };
1275 :
1276 : class nsRootPresContext : public nsPresContext {
1277 : public:
1278 : nsRootPresContext(nsIDocument* aDocument, nsPresContextType aType) NS_HIDDEN;
1279 : virtual ~nsRootPresContext();
1280 :
1281 : /**
1282 : * Ensure that NotifyDidPaintForSubtree is eventually called on this
1283 : * object after a timeout.
1284 : */
1285 : void EnsureEventualDidPaintEvent();
1286 :
1287 : void CancelDidPaintTimer()
1288 : {
1289 : if (mNotifyDidPaintTimer) {
1290 : mNotifyDidPaintTimer->Cancel();
1291 : mNotifyDidPaintTimer = nsnull;
1292 : }
1293 : }
1294 :
1295 : /**
1296 : * Registers a plugin to receive geometry updates (position and clip
1297 : * region) so it can update its widget.
1298 : * Callers must call UnregisterPluginForGeometryUpdates before
1299 : * the aPlugin frame is destroyed.
1300 : */
1301 : void RegisterPluginForGeometryUpdates(nsObjectFrame* aPlugin);
1302 : /**
1303 : * Stops a plugin receiving geometry updates (position and clip
1304 : * region). If the plugin was not already registered, this does
1305 : * nothing.
1306 : */
1307 : void UnregisterPluginForGeometryUpdates(nsObjectFrame* aPlugin);
1308 :
1309 : /**
1310 : * Iterate through all plugins that are registered for geometry updates
1311 : * and update their position and clip region to match the current frame
1312 : * tree.
1313 : */
1314 : void UpdatePluginGeometry();
1315 :
1316 : /**
1317 : * Iterate through all plugins that are registered for geometry updates
1318 : * and compute their position and clip region according to the
1319 : * current frame tree. Only frames at or under aChangedRoot can have
1320 : * changed their geometry. The computed positions and clip regions are
1321 : * appended to aConfigurations.
1322 : */
1323 : void GetPluginGeometryUpdates(nsIFrame* aChangedRoot,
1324 : nsTArray<nsIWidget::Configuration>* aConfigurations);
1325 :
1326 : /**
1327 : * When all geometry updates have been applied, call this function
1328 : * in case the nsObjectFrames have work to do after the widgets
1329 : * have been updated.
1330 : */
1331 : void DidApplyPluginGeometryUpdates();
1332 :
1333 : virtual bool IsRoot() { return true; }
1334 :
1335 : /**
1336 : * Call this after reflow and scrolling to ensure that the geometry
1337 : * of any windowed plugins is updated. aFrame is the root of the
1338 : * frame subtree whose geometry has changed.
1339 : */
1340 : void RequestUpdatePluginGeometry(nsIFrame* aFrame);
1341 :
1342 : /**
1343 : * Call this when a frame is being destroyed and
1344 : * mContainsUpdatePluginGeometryFrame is set in the frame's prescontext.
1345 : */
1346 : void RootForgetUpdatePluginGeometryFrame(nsIFrame* aFrame);
1347 :
1348 : /**
1349 : * Call this when a document is going to no longer be valid for plugin updates
1350 : * (say by going into the bfcache). If mContainsUpdatePluginGeometryFrame is
1351 : * set in the prescontext then it will be cleared along with
1352 : * mUpdatePluginGeometryForFrame.
1353 : */
1354 : void RootForgetUpdatePluginGeometryFrameForPresContext(nsPresContext* aPresContext);
1355 :
1356 : /**
1357 : * Increment DOM-modification generation counter to indicate that
1358 : * the DOM has changed in a way that might lead to style changes/
1359 : * reflows/frame creation and destruction.
1360 : */
1361 : void IncrementDOMGeneration() { mDOMGeneration++; }
1362 :
1363 : /**
1364 : * Get the current DOM generation counter.
1365 : */
1366 : PRUint32 GetDOMGeneration() { return mDOMGeneration; }
1367 :
1368 : /**
1369 : * Add a runnable that will get called before the next paint. They will get
1370 : * run eventually even if painting doesn't happen. They might run well before
1371 : * painting happens.
1372 : */
1373 : void AddWillPaintObserver(nsIRunnable* aRunnable);
1374 :
1375 : /**
1376 : * Run all runnables that need to get called before the next paint.
1377 : */
1378 : void FlushWillPaintObservers();
1379 :
1380 : virtual size_t SizeOfExcludingThis(nsMallocSizeOfFun aMallocSizeOf) const MOZ_OVERRIDE;
1381 :
1382 : protected:
1383 : class RunWillPaintObservers : public nsRunnable {
1384 : public:
1385 : RunWillPaintObservers(nsRootPresContext* aPresContext) : mPresContext(aPresContext) {}
1386 : void Revoke() { mPresContext = nsnull; }
1387 : NS_IMETHOD Run()
1388 : {
1389 : if (mPresContext) {
1390 : mPresContext->FlushWillPaintObservers();
1391 : }
1392 : return NS_OK;
1393 : }
1394 : nsRootPresContext* mPresContext;
1395 : };
1396 :
1397 : friend class nsPresContext;
1398 : void CancelUpdatePluginGeometryTimer()
1399 : {
1400 : if (mUpdatePluginGeometryTimer) {
1401 : mUpdatePluginGeometryTimer->Cancel();
1402 : mUpdatePluginGeometryTimer = nsnull;
1403 : }
1404 : }
1405 :
1406 : nsCOMPtr<nsITimer> mNotifyDidPaintTimer;
1407 : nsCOMPtr<nsITimer> mUpdatePluginGeometryTimer;
1408 : nsTHashtable<nsPtrHashKey<nsObjectFrame> > mRegisteredPlugins;
1409 : // if mNeedsToUpdatePluginGeometry is set, then this is the frame to
1410 : // use as the root of the subtree to search for plugin updates, or
1411 : // null to use the root frame of this prescontext
1412 : nsTArray<nsCOMPtr<nsIRunnable> > mWillPaintObservers;
1413 : nsRevocableEventPtr<RunWillPaintObservers> mWillPaintFallbackEvent;
1414 : nsIFrame* mUpdatePluginGeometryForFrame;
1415 : PRUint32 mDOMGeneration;
1416 : bool mNeedsToUpdatePluginGeometry;
1417 : };
1418 :
1419 : inline void
1420 : nsPresContext::ForgetUpdatePluginGeometryFrame(nsIFrame* aFrame)
1421 : {
1422 : if (mContainsUpdatePluginGeometryFrame) {
1423 : nsRootPresContext* rootPC = GetRootPresContext();
1424 : if (rootPC) {
1425 : rootPC->RootForgetUpdatePluginGeometryFrame(aFrame);
1426 : }
1427 : }
1428 : }
1429 :
1430 : #ifdef MOZ_REFLOW_PERF
1431 :
1432 : #define DO_GLOBAL_REFLOW_COUNT(_name) \
1433 : aPresContext->CountReflows((_name), (nsIFrame*)this);
1434 : #else
1435 : #define DO_GLOBAL_REFLOW_COUNT(_name)
1436 : #endif // MOZ_REFLOW_PERF
1437 :
1438 : #endif /* nsPresContext_h___ */
|