2011-09-09 23:50:21 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
* vim: set ts=2 sw=2 et tw=78:
|
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Steve Clark <buster@netscape.com>
|
|
|
|
* Håkan Waara <hwaara@chello.se>
|
|
|
|
* Dan Rosen <dr@netscape.com>
|
|
|
|
* Daniel Glazman <glazman@netscape.com>
|
|
|
|
* Mats Palmgren <matspal@gmail.com>
|
|
|
|
* Mihai Sucan <mihai.sucan@gmail.com>
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK *****
|
|
|
|
*
|
|
|
|
* This Original Code has been modified by IBM Corporation.
|
|
|
|
* Modifications made by IBM described herein are
|
|
|
|
* Copyright (c) International Business Machines
|
|
|
|
* Corporation, 2000
|
|
|
|
*
|
|
|
|
* Modifications to Mozilla code or documentation
|
|
|
|
* identified per MPL Section 3.3
|
|
|
|
*
|
|
|
|
* Date Modified by Description of modification
|
|
|
|
* 05/03/2000 IBM Corp. Observer events for reflow states
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* a presentation of a document, part 2 */
|
|
|
|
|
|
|
|
#ifndef nsPresShell_h_
|
|
|
|
#define nsPresShell_h_
|
|
|
|
|
|
|
|
#include "nsIPresShell.h"
|
|
|
|
#include "nsStubDocumentObserver.h"
|
|
|
|
#include "nsISelectionController.h"
|
|
|
|
#include "nsIObserver.h"
|
|
|
|
#include "nsWeakReference.h"
|
|
|
|
#include "nsCRT.h"
|
|
|
|
#include "nsAutoPtr.h"
|
|
|
|
#include "nsIWidget.h"
|
|
|
|
#include "nsStyleSet.h"
|
|
|
|
#include "nsPresArena.h"
|
|
|
|
#include "nsFrameSelection.h"
|
|
|
|
#include "nsGUIEvent.h"
|
|
|
|
#include "nsContentUtils.h"
|
2011-09-14 01:32:07 +04:00
|
|
|
#include "nsRefreshDriver.h"
|
2011-09-09 23:50:21 +04:00
|
|
|
|
2012-01-10 18:19:54 +04:00
|
|
|
class nsRange;
|
2011-09-09 23:50:21 +04:00
|
|
|
class nsIDragService;
|
|
|
|
class nsCSSStyleSheet;
|
|
|
|
|
|
|
|
struct RangePaintInfo;
|
|
|
|
struct nsCallbackEventRequest;
|
|
|
|
#ifdef MOZ_REFLOW_PERF
|
|
|
|
class ReflowCountMgr;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
class nsPresShellEventCB;
|
|
|
|
class nsAutoCauseReflowNotifier;
|
|
|
|
|
2011-11-21 21:53:20 +04:00
|
|
|
class PresShell : public nsIPresShell,
|
2011-09-09 23:50:21 +04:00
|
|
|
public nsStubDocumentObserver,
|
|
|
|
public nsISelectionController, public nsIObserver,
|
|
|
|
public nsSupportsWeakReference
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
PresShell();
|
|
|
|
|
|
|
|
NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
|
|
|
|
|
|
|
|
// nsISupports
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
// nsIPresShell
|
|
|
|
virtual NS_HIDDEN_(nsresult) Init(nsIDocument* aDocument,
|
|
|
|
nsPresContext* aPresContext,
|
|
|
|
nsIViewManager* aViewManager,
|
|
|
|
nsStyleSet* aStyleSet,
|
|
|
|
nsCompatibility aCompatMode);
|
|
|
|
virtual NS_HIDDEN_(void) Destroy();
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(nsresult) SetPreferenceStyleRules(bool aForceReflow);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
NS_IMETHOD GetSelection(SelectionType aType, nsISelection** aSelection);
|
|
|
|
virtual nsISelection* GetCurrentSelection(SelectionType aType);
|
|
|
|
|
|
|
|
NS_IMETHOD SetDisplaySelection(PRInt16 aToggle);
|
|
|
|
NS_IMETHOD GetDisplaySelection(PRInt16 *aToggle);
|
|
|
|
NS_IMETHOD ScrollSelectionIntoView(SelectionType aType, SelectionRegion aRegion,
|
|
|
|
PRInt16 aFlags);
|
|
|
|
NS_IMETHOD RepaintSelection(SelectionType aType);
|
|
|
|
|
|
|
|
virtual NS_HIDDEN_(void) BeginObservingDocument();
|
|
|
|
virtual NS_HIDDEN_(void) EndObservingDocument();
|
|
|
|
virtual NS_HIDDEN_(nsresult) InitialReflow(nscoord aWidth, nscoord aHeight);
|
|
|
|
virtual NS_HIDDEN_(nsresult) ResizeReflow(nscoord aWidth, nscoord aHeight);
|
|
|
|
virtual NS_HIDDEN_(nsresult) ResizeReflowOverride(nscoord aWidth, nscoord aHeight);
|
|
|
|
virtual NS_HIDDEN_(void) StyleChangeReflow();
|
|
|
|
virtual NS_HIDDEN_(nsIPageSequenceFrame*) GetPageSequenceFrame() const;
|
|
|
|
virtual NS_HIDDEN_(nsIFrame*) GetRealPrimaryFrameFor(nsIContent* aContent) const;
|
|
|
|
|
|
|
|
virtual NS_HIDDEN_(nsIFrame*) GetPlaceholderFrameFor(nsIFrame* aFrame) const;
|
|
|
|
virtual NS_HIDDEN_(void) FrameNeedsReflow(nsIFrame *aFrame, IntrinsicDirty aIntrinsicDirty,
|
|
|
|
nsFrameState aBitToAdd);
|
|
|
|
virtual NS_HIDDEN_(void) FrameNeedsToContinueReflow(nsIFrame *aFrame);
|
|
|
|
virtual NS_HIDDEN_(void) CancelAllPendingReflows();
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(bool) IsSafeToFlush() const;
|
2011-09-09 23:50:21 +04:00
|
|
|
virtual NS_HIDDEN_(void) FlushPendingNotifications(mozFlushType aType);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Recreates the frames for a node
|
|
|
|
*/
|
|
|
|
virtual NS_HIDDEN_(nsresult) RecreateFramesFor(nsIContent* aContent);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Post a callback that should be handled after reflow has finished.
|
|
|
|
*/
|
|
|
|
virtual NS_HIDDEN_(nsresult) PostReflowCallback(nsIReflowCallback* aCallback);
|
|
|
|
virtual NS_HIDDEN_(void) CancelReflowCallback(nsIReflowCallback* aCallback);
|
|
|
|
|
|
|
|
virtual NS_HIDDEN_(void) ClearFrameRefs(nsIFrame* aFrame);
|
|
|
|
virtual NS_HIDDEN_(already_AddRefed<nsRenderingContext>) GetReferenceRenderingContext();
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(nsresult) GoToAnchor(const nsAString& aAnchorName, bool aScroll);
|
2011-09-09 23:50:21 +04:00
|
|
|
virtual NS_HIDDEN_(nsresult) ScrollToAnchor();
|
|
|
|
|
|
|
|
virtual NS_HIDDEN_(nsresult) ScrollContentIntoView(nsIContent* aContent,
|
2012-03-20 06:09:50 +04:00
|
|
|
ScrollAxis aVertical,
|
|
|
|
ScrollAxis aHorizontal,
|
2011-09-09 23:50:21 +04:00
|
|
|
PRUint32 aFlags);
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual bool ScrollFrameRectIntoView(nsIFrame* aFrame,
|
2012-03-20 06:09:50 +04:00
|
|
|
const nsRect& aRect,
|
|
|
|
ScrollAxis aVertical,
|
|
|
|
ScrollAxis aHorizontal,
|
|
|
|
PRUint32 aFlags);
|
2011-09-09 23:50:21 +04:00
|
|
|
virtual nsRectVisibility GetRectVisibility(nsIFrame *aFrame,
|
|
|
|
const nsRect &aRect,
|
|
|
|
nscoord aMinTwips) const;
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(void) SetIgnoreFrameDestruction(bool aIgnore);
|
2011-09-09 23:50:21 +04:00
|
|
|
virtual NS_HIDDEN_(void) NotifyDestroyingFrame(nsIFrame* aFrame);
|
|
|
|
|
|
|
|
virtual NS_HIDDEN_(nsresult) GetLinkLocation(nsIDOMNode* aNode, nsAString& aLocationString) const;
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(nsresult) CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState, bool aLeavingPage);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
virtual NS_HIDDEN_(void) UnsuppressPainting();
|
|
|
|
|
|
|
|
virtual nsresult GetAgentStyleSheets(nsCOMArray<nsIStyleSheet>& aSheets);
|
|
|
|
virtual nsresult SetAgentStyleSheets(const nsCOMArray<nsIStyleSheet>& aSheets);
|
|
|
|
|
|
|
|
virtual nsresult AddOverrideStyleSheet(nsIStyleSheet *aSheet);
|
|
|
|
virtual nsresult RemoveOverrideStyleSheet(nsIStyleSheet *aSheet);
|
|
|
|
|
|
|
|
virtual NS_HIDDEN_(nsresult) HandleEventWithTarget(nsEvent* aEvent, nsIFrame* aFrame,
|
|
|
|
nsIContent* aContent,
|
|
|
|
nsEventStatus* aStatus);
|
|
|
|
virtual NS_HIDDEN_(nsIFrame*) GetEventTargetFrame();
|
|
|
|
virtual NS_HIDDEN_(already_AddRefed<nsIContent>) GetEventTargetContent(nsEvent* aEvent);
|
|
|
|
|
|
|
|
|
|
|
|
virtual nsresult ReconstructFrames(void);
|
|
|
|
virtual void Freeze();
|
|
|
|
virtual void Thaw();
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual void FireOrClearDelayedEvents(bool aFireEvents);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
virtual nsIFrame* GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt);
|
|
|
|
|
|
|
|
virtual NS_HIDDEN_(nsresult) RenderDocument(const nsRect& aRect, PRUint32 aFlags,
|
|
|
|
nscolor aBackgroundColor,
|
|
|
|
gfxContext* aThebesContext);
|
|
|
|
|
|
|
|
virtual already_AddRefed<gfxASurface> RenderNode(nsIDOMNode* aNode,
|
|
|
|
nsIntRegion* aRegion,
|
|
|
|
nsIntPoint& aPoint,
|
|
|
|
nsIntRect* aScreenRect);
|
|
|
|
|
|
|
|
virtual already_AddRefed<gfxASurface> RenderSelection(nsISelection* aSelection,
|
|
|
|
nsIntPoint& aPoint,
|
|
|
|
nsIntRect* aScreenRect);
|
|
|
|
|
|
|
|
virtual already_AddRefed<nsPIDOMWindow> GetRootWindow();
|
|
|
|
|
|
|
|
virtual LayerManager* GetLayerManager();
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual void SetIgnoreViewportScrolling(bool aIgnore);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
virtual void SetDisplayPort(const nsRect& aDisplayPort);
|
|
|
|
|
|
|
|
virtual nsresult SetResolution(float aXResolution, float aYResolution);
|
|
|
|
|
|
|
|
//nsIViewObserver interface
|
|
|
|
|
2011-11-21 21:53:20 +04:00
|
|
|
virtual void Paint(nsIView* aViewToPaint, nsIWidget* aWidget,
|
|
|
|
const nsRegion& aDirtyRegion, const nsIntRegion& aIntDirtyRegion,
|
2012-01-28 07:36:23 +04:00
|
|
|
bool aWillSendDidPaint);
|
2011-11-21 21:53:20 +04:00
|
|
|
virtual nsresult HandleEvent(nsIFrame* aFrame,
|
|
|
|
nsGUIEvent* aEvent,
|
|
|
|
bool aDontRetargetEvents,
|
|
|
|
nsEventStatus* aEventStatus);
|
2011-09-09 23:50:21 +04:00
|
|
|
virtual NS_HIDDEN_(nsresult) HandleDOMEventWithTarget(nsIContent* aTargetContent,
|
|
|
|
nsEvent* aEvent,
|
|
|
|
nsEventStatus* aStatus);
|
|
|
|
virtual NS_HIDDEN_(nsresult) HandleDOMEventWithTarget(nsIContent* aTargetContent,
|
|
|
|
nsIDOMEvent* aEvent,
|
|
|
|
nsEventStatus* aStatus);
|
2011-11-21 21:53:20 +04:00
|
|
|
virtual bool ShouldIgnoreInvalidation();
|
|
|
|
virtual void WillPaint(bool aWillSendDidPaint);
|
|
|
|
virtual void DidPaint();
|
2011-12-24 07:52:22 +04:00
|
|
|
virtual void ScheduleViewManagerFlush();
|
2011-11-21 21:53:20 +04:00
|
|
|
virtual void DispatchSynthMouseMove(nsGUIEvent *aEvent, bool aFlushOnHoverChange);
|
|
|
|
virtual void ClearMouseCaptureOnView(nsIView* aView);
|
|
|
|
virtual bool IsVisible();
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
// caret handling
|
|
|
|
virtual NS_HIDDEN_(already_AddRefed<nsCaret>) GetCaret() const;
|
|
|
|
virtual NS_HIDDEN_(void) MaybeInvalidateCaretPosition();
|
2011-09-29 10:19:26 +04:00
|
|
|
NS_IMETHOD SetCaretEnabled(bool aInEnable);
|
|
|
|
NS_IMETHOD SetCaretReadOnly(bool aReadOnly);
|
|
|
|
NS_IMETHOD GetCaretEnabled(bool *aOutEnabled);
|
|
|
|
NS_IMETHOD SetCaretVisibilityDuringSelection(bool aVisibility);
|
|
|
|
NS_IMETHOD GetCaretVisible(bool *_retval);
|
2011-09-09 23:50:21 +04:00
|
|
|
virtual void SetCaret(nsCaret *aNewCaret);
|
|
|
|
virtual void RestoreCaret();
|
|
|
|
|
|
|
|
NS_IMETHOD SetSelectionFlags(PRInt16 aInEnable);
|
|
|
|
NS_IMETHOD GetSelectionFlags(PRInt16 *aOutEnable);
|
|
|
|
|
|
|
|
// nsISelectionController
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
NS_IMETHOD CharacterMove(bool aForward, bool aExtend);
|
2011-09-09 23:50:21 +04:00
|
|
|
NS_IMETHOD CharacterExtendForDelete();
|
|
|
|
NS_IMETHOD CharacterExtendForBackspace();
|
2011-09-29 10:19:26 +04:00
|
|
|
NS_IMETHOD WordMove(bool aForward, bool aExtend);
|
|
|
|
NS_IMETHOD WordExtendForDelete(bool aForward);
|
|
|
|
NS_IMETHOD LineMove(bool aForward, bool aExtend);
|
|
|
|
NS_IMETHOD IntraLineMove(bool aForward, bool aExtend);
|
|
|
|
NS_IMETHOD PageMove(bool aForward, bool aExtend);
|
|
|
|
NS_IMETHOD ScrollPage(bool aForward);
|
|
|
|
NS_IMETHOD ScrollLine(bool aForward);
|
2012-01-06 01:33:41 +04:00
|
|
|
NS_IMETHOD ScrollCharacter(bool aRight);
|
2011-09-29 10:19:26 +04:00
|
|
|
NS_IMETHOD CompleteScroll(bool aForward);
|
|
|
|
NS_IMETHOD CompleteMove(bool aForward, bool aExtend);
|
2011-09-09 23:50:21 +04:00
|
|
|
NS_IMETHOD SelectAll();
|
2011-09-29 10:19:26 +04:00
|
|
|
NS_IMETHOD CheckVisibility(nsIDOMNode *node, PRInt16 startOffset, PRInt16 EndOffset, bool *_retval);
|
2012-01-25 11:50:05 +04:00
|
|
|
virtual nsresult CheckVisibilityContent(nsIContent* aNode, PRInt16 aStartOffset,
|
|
|
|
PRInt16 aEndOffset, bool* aRetval);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
// nsIDocumentObserver
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_BEGINUPDATE
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_ENDUPDATE
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_BEGINLOAD
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_ENDLOAD
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_CONTENTSTATECHANGED
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_DOCUMENTSTATESCHANGED
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETADDED
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETREMOVED
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETAPPLICABLESTATECHANGED
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_STYLERULECHANGED
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_STYLERULEADDED
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_STYLERULEREMOVED
|
|
|
|
|
|
|
|
// nsIMutationObserver
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTEWILLCHANGE
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
|
|
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
|
|
|
|
|
|
|
|
NS_DECL_NSIOBSERVER
|
|
|
|
|
|
|
|
#ifdef MOZ_REFLOW_PERF
|
|
|
|
virtual NS_HIDDEN_(void) DumpReflows();
|
|
|
|
virtual NS_HIDDEN_(void) CountReflows(const char * aName, nsIFrame * aFrame);
|
|
|
|
virtual NS_HIDDEN_(void) PaintCount(const char * aName,
|
|
|
|
nsRenderingContext* aRenderingContext,
|
|
|
|
nsPresContext* aPresContext,
|
|
|
|
nsIFrame * aFrame,
|
|
|
|
const nsPoint& aOffset,
|
|
|
|
PRUint32 aColor);
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(void) SetPaintFrameCount(bool aOn);
|
|
|
|
virtual bool IsPaintingFrameCounts();
|
2011-09-09 23:50:21 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
virtual void ListStyleContexts(nsIFrame *aRootFrame, FILE *out,
|
|
|
|
PRInt32 aIndent = 0);
|
|
|
|
|
|
|
|
virtual void ListStyleSheets(FILE *out, PRInt32 aIndent = 0);
|
|
|
|
virtual void VerifyStyleTree();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
static PRLogModuleInfo* gLog;
|
|
|
|
#endif
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(void) DisableNonTestMouseEvents(bool aDisable);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
virtual void UpdateCanvasBackground();
|
|
|
|
|
|
|
|
virtual nsresult AddCanvasBackgroundColorItem(nsDisplayListBuilder& aBuilder,
|
|
|
|
nsDisplayList& aList,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
const nsRect& aBounds,
|
|
|
|
nscolor aBackstopColor,
|
|
|
|
PRUint32 aFlags);
|
|
|
|
|
|
|
|
virtual nsresult AddPrintPreviewBackgroundItem(nsDisplayListBuilder& aBuilder,
|
|
|
|
nsDisplayList& aList,
|
|
|
|
nsIFrame* aFrame,
|
|
|
|
const nsRect& aBounds);
|
|
|
|
|
|
|
|
virtual nscolor ComputeBackstopColor(nsIView* aDisplayRoot);
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual NS_HIDDEN_(nsresult) SetIsActive(bool aIsActive);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual bool GetIsViewportOverridden() { return mViewportOverridden; }
|
2011-09-09 23:50:21 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual bool IsLayoutFlushObserver()
|
2011-09-09 23:50:21 +04:00
|
|
|
{
|
|
|
|
return GetPresContext()->RefreshDriver()->
|
|
|
|
IsLayoutFlushObserver(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual ~PresShell();
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
void HandlePostedReflowCallbacks(bool aInterruptible);
|
2011-09-09 23:50:21 +04:00
|
|
|
void CancelPostedReflowCallbacks();
|
|
|
|
|
|
|
|
void UnsuppressAndInvalidate();
|
|
|
|
|
|
|
|
void WillCauseReflow() {
|
|
|
|
nsContentUtils::AddScriptBlocker();
|
|
|
|
++mChangeNestCount;
|
|
|
|
}
|
|
|
|
nsresult DidCauseReflow();
|
|
|
|
friend class nsAutoCauseReflowNotifier;
|
|
|
|
|
2011-12-17 04:24:11 +04:00
|
|
|
bool TouchesAreEqual(nsIDOMTouch *aTouch1, nsIDOMTouch *aTouch2);
|
|
|
|
void DispatchTouchEvent(nsEvent *aEvent,
|
|
|
|
nsEventStatus* aStatus,
|
|
|
|
nsPresShellEventCB* aEventCB,
|
|
|
|
bool aTouchIsNew);
|
|
|
|
|
2011-09-09 23:50:21 +04:00
|
|
|
void WillDoReflow();
|
2011-09-29 10:19:26 +04:00
|
|
|
void DidDoReflow(bool aInterruptible);
|
2011-09-09 23:50:21 +04:00
|
|
|
// ProcessReflowCommands returns whether we processed all our dirty roots
|
|
|
|
// without interruptions.
|
2011-09-29 10:19:26 +04:00
|
|
|
bool ProcessReflowCommands(bool aInterruptible);
|
2011-09-09 23:50:21 +04:00
|
|
|
// MaybeScheduleReflow checks if posting a reflow is needed, then checks if
|
|
|
|
// the last reflow was interrupted. In the interrupted case ScheduleReflow is
|
|
|
|
// called off a timer, otherwise it is called directly.
|
|
|
|
void MaybeScheduleReflow();
|
|
|
|
// Actually schedules a reflow. This should only be called by
|
|
|
|
// MaybeScheduleReflow and the reflow timer ScheduleReflowOffTimer
|
|
|
|
// sets up.
|
|
|
|
void ScheduleReflow();
|
|
|
|
|
|
|
|
// Reflow regardless of whether the override bit has been set.
|
|
|
|
nsresult ResizeReflowIgnoreOverride(nscoord aWidth, nscoord aHeight);
|
|
|
|
|
|
|
|
// DoReflow returns whether the reflow finished without interruption
|
2011-09-29 10:19:26 +04:00
|
|
|
bool DoReflow(nsIFrame* aFrame, bool aInterruptible);
|
2011-09-09 23:50:21 +04:00
|
|
|
#ifdef DEBUG
|
|
|
|
void DoVerifyReflow();
|
|
|
|
void VerifyHasDirtyRootAncestor(nsIFrame* aFrame);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Helper for ScrollContentIntoView
|
|
|
|
void DoScrollContentIntoView(nsIContent* aContent,
|
2012-03-20 06:09:50 +04:00
|
|
|
ScrollAxis aVertical,
|
|
|
|
ScrollAxis aHorizontal,
|
2011-09-09 23:50:21 +04:00
|
|
|
PRUint32 aFlags);
|
|
|
|
|
|
|
|
friend struct AutoRenderingStateSaveRestore;
|
|
|
|
friend struct RenderingState;
|
|
|
|
|
|
|
|
struct RenderingState {
|
|
|
|
RenderingState(PresShell* aPresShell)
|
|
|
|
: mRenderFlags(aPresShell->mRenderFlags)
|
|
|
|
, mXResolution(aPresShell->mXResolution)
|
|
|
|
, mYResolution(aPresShell->mYResolution)
|
|
|
|
{ }
|
|
|
|
PRUint32 mRenderFlags;
|
|
|
|
float mXResolution;
|
|
|
|
float mYResolution;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct AutoSaveRestoreRenderingState {
|
|
|
|
AutoSaveRestoreRenderingState(PresShell* aPresShell)
|
|
|
|
: mPresShell(aPresShell)
|
|
|
|
, mOldState(aPresShell)
|
|
|
|
{}
|
|
|
|
|
|
|
|
~AutoSaveRestoreRenderingState()
|
|
|
|
{
|
|
|
|
mPresShell->mRenderFlags = mOldState.mRenderFlags;
|
|
|
|
mPresShell->mXResolution = mOldState.mXResolution;
|
|
|
|
mPresShell->mYResolution = mOldState.mYResolution;
|
|
|
|
}
|
|
|
|
|
|
|
|
PresShell* mPresShell;
|
|
|
|
RenderingState mOldState;
|
|
|
|
};
|
|
|
|
|
|
|
|
void SetRenderingState(const RenderingState& aState);
|
|
|
|
|
|
|
|
friend class nsPresShellEventCB;
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mCaretEnabled;
|
2011-09-09 23:50:21 +04:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
nsStyleSet* CloneStyleSet(nsStyleSet* aSet);
|
2011-09-29 10:19:26 +04:00
|
|
|
bool VerifyIncrementalReflow();
|
|
|
|
bool mInVerifyReflow;
|
2011-09-09 23:50:21 +04:00
|
|
|
void ShowEventTargetDebug();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* methods that manage rules that are used to implement the associated preferences
|
|
|
|
* - initially created for bugs 31816, 20760, 22963
|
|
|
|
*/
|
|
|
|
nsresult ClearPreferenceStyleRules(void);
|
|
|
|
nsresult CreatePreferenceStyleSheet(void);
|
|
|
|
nsresult SetPrefLinkRules(void);
|
|
|
|
nsresult SetPrefFocusRules(void);
|
|
|
|
nsresult SetPrefNoScriptRule();
|
|
|
|
nsresult SetPrefNoFramesRule(void);
|
|
|
|
|
|
|
|
// methods for painting a range to an offscreen buffer
|
|
|
|
|
|
|
|
// given a display list, clip the items within the list to
|
|
|
|
// the range
|
|
|
|
nsRect ClipListToRange(nsDisplayListBuilder *aBuilder,
|
|
|
|
nsDisplayList* aList,
|
2012-01-10 18:19:54 +04:00
|
|
|
nsRange* aRange);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
// create a RangePaintInfo for the range aRange containing the
|
|
|
|
// display list needed to paint the range to a surface
|
|
|
|
RangePaintInfo* CreateRangePaintInfo(nsIDOMRange* aRange,
|
|
|
|
nsRect& aSurfaceRect,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aForPrimarySelection);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Paint the items to a new surface and return it.
|
|
|
|
*
|
|
|
|
* aSelection - selection being painted, if any
|
|
|
|
* aRegion - clip region, if any
|
|
|
|
* aArea - area that the surface occupies, relative to the root frame
|
|
|
|
* aPoint - reference point, typically the mouse position
|
|
|
|
* aScreenRect - [out] set to the area of the screen the painted area should
|
|
|
|
* be displayed at
|
|
|
|
*/
|
|
|
|
already_AddRefed<gfxASurface>
|
|
|
|
PaintRangePaintInfo(nsTArray<nsAutoPtr<RangePaintInfo> >* aItems,
|
|
|
|
nsISelection* aSelection,
|
|
|
|
nsIntRegion* aRegion,
|
|
|
|
nsRect aArea,
|
|
|
|
nsIntPoint& aPoint,
|
|
|
|
nsIntRect* aScreenRect);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Methods to handle changes to user and UA sheet lists that we get
|
|
|
|
* notified about.
|
|
|
|
*/
|
|
|
|
void AddUserSheet(nsISupports* aSheet);
|
|
|
|
void AddAgentSheet(nsISupports* aSheet);
|
|
|
|
void RemoveSheet(nsStyleSet::sheetType aType, nsISupports* aSheet);
|
|
|
|
|
|
|
|
// Hide a view if it is a popup
|
|
|
|
void HideViewIfPopup(nsIView* aView);
|
|
|
|
|
|
|
|
// Utility method to restore the root scrollframe state
|
|
|
|
void RestoreRootScrollPosition();
|
|
|
|
|
|
|
|
void MaybeReleaseCapturingContent()
|
|
|
|
{
|
|
|
|
nsRefPtr<nsFrameSelection> frameSelection = FrameSelection();
|
|
|
|
if (frameSelection) {
|
2011-10-17 18:59:28 +04:00
|
|
|
frameSelection->SetMouseDownState(false);
|
2011-09-09 23:50:21 +04:00
|
|
|
}
|
|
|
|
if (gCaptureInfo.mContent &&
|
2011-10-18 14:53:36 +04:00
|
|
|
gCaptureInfo.mContent->OwnerDoc() == mDocument) {
|
2011-09-09 23:50:21 +04:00
|
|
|
SetCapturingContent(nsnull, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-21 21:53:20 +04:00
|
|
|
nsresult HandleRetargetedEvent(nsEvent* aEvent, nsEventStatus* aStatus, nsIContent* aTarget)
|
2011-09-09 23:50:21 +04:00
|
|
|
{
|
|
|
|
PushCurrentEventInfo(nsnull, nsnull);
|
|
|
|
mCurrentEventContent = aTarget;
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
if (GetCurrentEventFrame()) {
|
2011-11-21 21:53:20 +04:00
|
|
|
rv = HandleEventInternal(aEvent, aStatus);
|
2011-09-09 23:50:21 +04:00
|
|
|
}
|
|
|
|
PopCurrentEventInfo();
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRefPtr<nsCSSStyleSheet> mPrefStyleSheet; // mStyleSet owns it but we
|
|
|
|
// maintain a ref, may be null
|
|
|
|
#ifdef DEBUG
|
|
|
|
PRUint32 mUpdateCount;
|
|
|
|
#endif
|
|
|
|
// reflow roots that need to be reflowed, as both a queue and a hashtable
|
|
|
|
nsTArray<nsIFrame*> mDirtyRoots;
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mDocumentLoading;
|
2011-09-09 23:50:21 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mIgnoreFrameDestruction;
|
|
|
|
bool mHaveShutDown;
|
2011-09-09 23:50:21 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mViewportOverridden;
|
2011-09-09 23:50:21 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mLastRootReflowHadUnconstrainedHeight;
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
// This is used to protect ourselves from triggering reflow while in the
|
|
|
|
// middle of frame construction and the like... it really shouldn't be
|
|
|
|
// needed, one hopes, but it is for now.
|
|
|
|
PRUint32 mChangeNestCount;
|
|
|
|
|
|
|
|
nsIFrame* mCurrentEventFrame;
|
|
|
|
nsCOMPtr<nsIContent> mCurrentEventContent;
|
|
|
|
nsTArray<nsIFrame*> mCurrentEventFrameStack;
|
|
|
|
nsCOMArray<nsIContent> mCurrentEventContentStack;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> mLastAnchorScrolledTo;
|
|
|
|
nscoord mLastAnchorScrollPositionY;
|
|
|
|
nsRefPtr<nsCaret> mCaret;
|
|
|
|
nsRefPtr<nsCaret> mOriginalCaret;
|
|
|
|
nsCOMPtr<nsIDragService> mDragService;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
// The reflow root under which we're currently reflowing. Null when
|
|
|
|
// not in reflow.
|
|
|
|
nsIFrame* mCurrentReflowRoot;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Set of frames that we should mark with NS_FRAME_HAS_DIRTY_CHILDREN after
|
|
|
|
// we finish reflowing mCurrentReflowRoot.
|
|
|
|
nsTHashtable< nsPtrHashKey<nsIFrame> > mFramesToDirty;
|
|
|
|
|
|
|
|
// Information needed to properly handle scrolling content into view if the
|
|
|
|
// pre-scroll reflow flush can be interrupted. mContentToScrollTo is
|
|
|
|
// non-null between the initial scroll attempt and the first time we finish
|
|
|
|
// processing all our dirty roots. mContentScrollVPosition and
|
|
|
|
// mContentScrollHPosition are only used when it's non-null.
|
|
|
|
nsCOMPtr<nsIContent> mContentToScrollTo;
|
2012-03-20 06:09:50 +04:00
|
|
|
ScrollAxis mContentScrollVAxis;
|
|
|
|
ScrollAxis mContentScrollHAxis;
|
2011-09-09 23:50:21 +04:00
|
|
|
PRUint32 mContentToScrollToFlags;
|
|
|
|
|
|
|
|
class nsDelayedEvent
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
virtual ~nsDelayedEvent() {};
|
|
|
|
virtual void Dispatch(PresShell* aShell) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
class nsDelayedInputEvent : public nsDelayedEvent
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
virtual void Dispatch(PresShell* aShell)
|
|
|
|
{
|
|
|
|
if (mEvent && mEvent->widget) {
|
|
|
|
nsCOMPtr<nsIWidget> w = mEvent->widget;
|
|
|
|
nsEventStatus status;
|
|
|
|
w->DispatchEvent(mEvent, status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void Init(nsInputEvent* aEvent)
|
|
|
|
{
|
|
|
|
mEvent->time = aEvent->time;
|
|
|
|
mEvent->refPoint = aEvent->refPoint;
|
2012-04-25 07:00:02 +04:00
|
|
|
mEvent->modifiers = aEvent->modifiers;
|
2011-09-09 23:50:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsDelayedInputEvent()
|
|
|
|
: nsDelayedEvent(), mEvent(nsnull) {}
|
|
|
|
|
|
|
|
nsInputEvent* mEvent;
|
|
|
|
};
|
|
|
|
|
|
|
|
class nsDelayedMouseEvent : public nsDelayedInputEvent
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsDelayedMouseEvent(nsMouseEvent* aEvent) : nsDelayedInputEvent()
|
|
|
|
{
|
|
|
|
mEvent = new nsMouseEvent(NS_IS_TRUSTED_EVENT(aEvent),
|
|
|
|
aEvent->message,
|
|
|
|
aEvent->widget,
|
|
|
|
aEvent->reason,
|
|
|
|
aEvent->context);
|
|
|
|
Init(aEvent);
|
|
|
|
static_cast<nsMouseEvent*>(mEvent)->clickCount = aEvent->clickCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~nsDelayedMouseEvent()
|
|
|
|
{
|
|
|
|
delete static_cast<nsMouseEvent*>(mEvent);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class nsDelayedKeyEvent : public nsDelayedInputEvent
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsDelayedKeyEvent(nsKeyEvent* aEvent) : nsDelayedInputEvent()
|
|
|
|
{
|
|
|
|
mEvent = new nsKeyEvent(NS_IS_TRUSTED_EVENT(aEvent),
|
|
|
|
aEvent->message,
|
|
|
|
aEvent->widget);
|
|
|
|
Init(aEvent);
|
|
|
|
static_cast<nsKeyEvent*>(mEvent)->keyCode = aEvent->keyCode;
|
|
|
|
static_cast<nsKeyEvent*>(mEvent)->charCode = aEvent->charCode;
|
|
|
|
static_cast<nsKeyEvent*>(mEvent)->alternativeCharCodes =
|
|
|
|
aEvent->alternativeCharCodes;
|
|
|
|
static_cast<nsKeyEvent*>(mEvent)->isChar = aEvent->isChar;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~nsDelayedKeyEvent()
|
|
|
|
{
|
|
|
|
delete static_cast<nsKeyEvent*>(mEvent);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mNoDelayedMouseEvents;
|
|
|
|
bool mNoDelayedKeyEvents;
|
2011-09-09 23:50:21 +04:00
|
|
|
nsTArray<nsAutoPtr<nsDelayedEvent> > mDelayedEvents;
|
|
|
|
|
|
|
|
nsCallbackEventRequest* mFirstCallbackEventRequest;
|
|
|
|
nsCallbackEventRequest* mLastCallbackEventRequest;
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mIsDocumentGone; // We've been disconnected from the document.
|
2011-09-09 23:50:21 +04:00
|
|
|
// We will refuse to paint the document until either
|
|
|
|
// (a) our timer fires or (b) all frames are constructed.
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mShouldUnsuppressPainting; // Indicates that it is safe to unlock painting once all pending
|
2011-09-09 23:50:21 +04:00
|
|
|
// reflows have been processed.
|
|
|
|
nsCOMPtr<nsITimer> mPaintSuppressionTimer; // This timer controls painting suppression. Until it fires
|
|
|
|
// or all frames are constructed, we won't paint anything but
|
|
|
|
// our <body> background and scrollbars.
|
|
|
|
#define PAINTLOCK_EVENT_DELAY 250 // 250ms. This is actually
|
|
|
|
// pref-controlled, but we use this
|
|
|
|
// value if we fail to get the pref
|
|
|
|
// for any reason.
|
|
|
|
|
|
|
|
static void sPaintSuppressionCallback(nsITimer* aTimer, void* aPresShell); // A callback for the timer.
|
|
|
|
|
|
|
|
// At least on Win32 and Mac after interupting a reflow we need to post
|
|
|
|
// the resume reflow event off a timer to avoid event starvation because
|
|
|
|
// posted messages are processed before other messages when the modal
|
|
|
|
// moving/sizing loop is running, see bug 491700 for details.
|
|
|
|
nsCOMPtr<nsITimer> mReflowContinueTimer;
|
|
|
|
static void sReflowContinueCallback(nsITimer* aTimer, void* aPresShell);
|
2011-09-29 10:19:26 +04:00
|
|
|
bool ScheduleReflowOffTimer();
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
#ifdef MOZ_REFLOW_PERF
|
|
|
|
ReflowCountMgr * mReflowCountMgr;
|
|
|
|
#endif
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool sDisableNonTestMouseEvents;
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
private:
|
|
|
|
|
2012-04-27 01:40:05 +04:00
|
|
|
|
|
|
|
#ifdef ANDROID
|
|
|
|
nsIDocument* GetTouchEventTargetDocument();
|
|
|
|
#endif
|
2011-09-29 10:19:26 +04:00
|
|
|
bool InZombieDocument(nsIContent *aContent);
|
2011-09-09 23:50:21 +04:00
|
|
|
already_AddRefed<nsIPresShell> GetParentPresShell();
|
|
|
|
nsresult RetargetEventToParent(nsGUIEvent* aEvent,
|
|
|
|
nsEventStatus* aEventStatus);
|
|
|
|
|
|
|
|
//helper funcs for event handling
|
|
|
|
protected:
|
|
|
|
//protected because nsPresShellEventCB needs this.
|
|
|
|
nsIFrame* GetCurrentEventFrame();
|
|
|
|
private:
|
|
|
|
void PushCurrentEventInfo(nsIFrame* aFrame, nsIContent* aContent);
|
|
|
|
void PopCurrentEventInfo();
|
2011-11-21 21:53:20 +04:00
|
|
|
nsresult HandleEventInternal(nsEvent* aEvent, nsEventStatus *aStatus);
|
|
|
|
nsresult HandlePositionedEvent(nsIFrame* aTargetFrame,
|
2011-09-09 23:50:21 +04:00
|
|
|
nsGUIEvent* aEvent,
|
|
|
|
nsEventStatus* aEventStatus);
|
|
|
|
// This returns the focused DOM window under our top level window.
|
|
|
|
// I.e., when we are deactive, this returns the *last* focused DOM window.
|
|
|
|
already_AddRefed<nsPIDOMWindow> GetFocusedDOMWindowInOurWindow();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This and the next two helper methods are used to target and position the
|
|
|
|
* context menu when the keyboard shortcut is used to open it.
|
|
|
|
*
|
|
|
|
* If another menu is open, the context menu is opened relative to the
|
|
|
|
* active menuitem within the menu, or the menu itself if no item is active.
|
|
|
|
* Otherwise, if the caret is visible, the menu is opened near the caret.
|
|
|
|
* Otherwise, if a selectable list such as a listbox is focused, the
|
|
|
|
* current item within the menu is opened relative to this item.
|
|
|
|
* Otherwise, the context menu is opened at the topleft corner of the
|
|
|
|
* view.
|
|
|
|
*
|
|
|
|
* Returns true if the context menu event should fire and false if it should
|
|
|
|
* not.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
bool AdjustContextMenuKeyEvent(nsMouseEvent* aEvent);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
//
|
2011-09-29 10:19:26 +04:00
|
|
|
bool PrepareToUseCaretPosition(nsIWidget* aEventWidget, nsIntPoint& aTargetPt);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
// Get the selected item and coordinates in device pixels relative to root
|
|
|
|
// document's root view for element, first ensuring the element is onscreen
|
|
|
|
void GetCurrentItemAndPositionForElement(nsIDOMElement *aCurrentEl,
|
|
|
|
nsIContent **aTargetToUse,
|
|
|
|
nsIntPoint& aTargetPt,
|
|
|
|
nsIWidget *aRootWidget);
|
|
|
|
|
|
|
|
void FireResizeEvent();
|
|
|
|
void FireBeforeResizeEvent();
|
|
|
|
static void AsyncResizeEventCallback(nsITimer* aTimer, void* aPresShell);
|
|
|
|
nsRevocableEventPtr<nsRunnableMethod<PresShell> > mResizeEvent;
|
|
|
|
nsCOMPtr<nsITimer> mAsyncResizeEventTimer;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mAsyncResizeTimerIsActive;
|
|
|
|
bool mInResize;
|
2011-09-09 23:50:21 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual void SynthesizeMouseMove(bool aFromScroll);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
// Check if aEvent is a mouse event and record the mouse location for later
|
|
|
|
// synth mouse moves.
|
|
|
|
void RecordMouseLocation(nsGUIEvent* aEvent);
|
|
|
|
// This is used for synthetic mouse events that are sent when what is under
|
|
|
|
// the mouse pointer may have changed without the mouse moving (eg scrolling,
|
|
|
|
// change to the document contents).
|
|
|
|
// It is set only on a presshell for a root document, this value represents
|
|
|
|
// the last observed location of the mouse relative to that root document. It
|
|
|
|
// is set to (NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) if the mouse isn't
|
|
|
|
// over our window or there is no last observed mouse location for some
|
|
|
|
// reason.
|
|
|
|
nsPoint mMouseLocation;
|
2012-01-10 09:23:29 +04:00
|
|
|
class nsSynthMouseMoveEvent : public nsARefreshObserver {
|
2011-09-09 23:50:21 +04:00
|
|
|
public:
|
2011-09-29 10:19:26 +04:00
|
|
|
nsSynthMouseMoveEvent(PresShell* aPresShell, bool aFromScroll)
|
2011-09-09 23:50:21 +04:00
|
|
|
: mPresShell(aPresShell), mFromScroll(aFromScroll) {
|
|
|
|
NS_ASSERTION(mPresShell, "null parameter");
|
|
|
|
}
|
2012-01-10 09:23:29 +04:00
|
|
|
~nsSynthMouseMoveEvent() {
|
|
|
|
Revoke();
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_INLINE_DECL_REFCOUNTING(nsSynthMouseMoveEvent)
|
|
|
|
|
|
|
|
void Revoke() {
|
|
|
|
if (mPresShell) {
|
|
|
|
mPresShell->GetPresContext()->RefreshDriver()->
|
|
|
|
RemoveRefreshObserver(this, Flush_Display);
|
|
|
|
mPresShell = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
virtual void WillRefresh(mozilla::TimeStamp aTime) {
|
2011-09-09 23:50:21 +04:00
|
|
|
if (mPresShell)
|
|
|
|
mPresShell->ProcessSynthMouseMoveEvent(mFromScroll);
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
PresShell* mPresShell;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mFromScroll;
|
2011-09-09 23:50:21 +04:00
|
|
|
};
|
|
|
|
nsRevocableEventPtr<nsSynthMouseMoveEvent> mSynthMouseMoveEvent;
|
2011-09-29 10:19:26 +04:00
|
|
|
void ProcessSynthMouseMoveEvent(bool aFromScroll);
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
PresShell* GetRootPresShell();
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
2012-02-21 19:10:11 +04:00
|
|
|
void SizeOfIncludingThis(nsMallocSizeOfFun aMallocSizeOf,
|
|
|
|
size_t *aArenasSize,
|
|
|
|
size_t *aStyleSetsSize,
|
2012-05-08 00:09:11 +04:00
|
|
|
size_t *aTextRunsSize,
|
|
|
|
size_t *aPresContextSize) const;
|
2012-02-21 19:10:11 +04:00
|
|
|
size_t SizeOfTextRuns(nsMallocSizeOfFun aMallocSizeOf) const;
|
2011-09-09 23:50:21 +04:00
|
|
|
|
|
|
|
protected:
|
|
|
|
void QueryIsActive();
|
|
|
|
nsresult UpdateImageLockingState();
|
|
|
|
|
|
|
|
private:
|
|
|
|
nscolor GetDefaultBackgroundColorToDraw();
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif /* !defined(nsPresShell_h_) */
|