mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-05 08:35:26 +00:00
99666eed8c
the printing of headers and footers. Printing of selection is implemented by the frames figuring out if they are in the selection and painting if they or not they they don't paint. This also only allows the printing of the first page of selections, alothough it is well documented where this is implemeted so it can be removed. Bugs 63426, 31218, 61075 r=dcone,kmcclusk,erik,buster sr=waterson
471 lines
21 KiB
C++
471 lines
21 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape 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/NPL/
|
|
*
|
|
* 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 Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
|
*/
|
|
#ifndef nsFrame_h___
|
|
#define nsFrame_h___
|
|
|
|
#include "nsIFrame.h"
|
|
#include "nsRect.h"
|
|
#include "nsString.h"
|
|
#include "prlog.h"
|
|
#ifdef NS_DEBUG
|
|
#include "nsIFrameDebug.h"
|
|
#endif
|
|
|
|
#include "nsIPresShell.h"
|
|
#include "nsIReflowCommand.h"
|
|
#include "nsIFrameSelection.h"
|
|
|
|
/**
|
|
* nsFrame logging constants. We redefine the nspr
|
|
* PRLogModuleInfo.level field to be a bitfield. Each bit controls a
|
|
* specific type of logging. Each logging operation has associated
|
|
* inline methods defined below.
|
|
*/
|
|
#define NS_FRAME_TRACE_CALLS 0x1
|
|
#define NS_FRAME_TRACE_PUSH_PULL 0x2
|
|
#define NS_FRAME_TRACE_CHILD_REFLOW 0x4
|
|
#define NS_FRAME_TRACE_NEW_FRAMES 0x8
|
|
|
|
#define NS_FRAME_LOG_TEST(_lm,_bit) (PRIntn((_lm)->level) & (_bit))
|
|
|
|
#ifdef NS_DEBUG
|
|
#define NS_FRAME_LOG(_bit,_args) \
|
|
PR_BEGIN_MACRO \
|
|
if (NS_FRAME_LOG_TEST(nsIFrameDebug::GetLogModuleInfo(),_bit)) { \
|
|
PR_LogPrint _args; \
|
|
} \
|
|
PR_END_MACRO
|
|
#else
|
|
#define NS_FRAME_LOG(_bit,_args)
|
|
#endif
|
|
|
|
// XXX Need to rework this so that logging is free when it's off
|
|
#ifdef NS_DEBUG
|
|
#define NS_FRAME_TRACE_IN(_method) Trace(_method, PR_TRUE)
|
|
|
|
#define NS_FRAME_TRACE_OUT(_method) Trace(_method, PR_FALSE)
|
|
|
|
// XXX remove me
|
|
#define NS_FRAME_TRACE_MSG(_bit,_args) \
|
|
PR_BEGIN_MACRO \
|
|
if (NS_FRAME_LOG_TEST(nsIFrameDebug::GetLogModuleInfo(),_bit)) { \
|
|
TraceMsg _args; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define NS_FRAME_TRACE(_bit,_args) \
|
|
PR_BEGIN_MACRO \
|
|
if (NS_FRAME_LOG_TEST(nsIFrameDebug::GetLogModuleInfo(),_bit)) { \
|
|
TraceMsg _args; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define NS_FRAME_TRACE_REFLOW_IN(_method) Trace(_method, PR_TRUE)
|
|
|
|
#define NS_FRAME_TRACE_REFLOW_OUT(_method, _status) \
|
|
Trace(_method, PR_FALSE, _status)
|
|
|
|
#else
|
|
#define NS_FRAME_TRACE(_bits,_args)
|
|
#define NS_FRAME_TRACE_IN(_method)
|
|
#define NS_FRAME_TRACE_OUT(_method)
|
|
#define NS_FRAME_TRACE_MSG(_bits,_args)
|
|
#define NS_FRAME_TRACE_REFLOW_IN(_method)
|
|
#define NS_FRAME_TRACE_REFLOW_OUT(_method, _status)
|
|
#endif
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* Implementation of a simple frame that's not splittable and has no
|
|
* child frames.
|
|
*
|
|
* Sets the NS_FRAME_SYNCHRONIZE_FRAME_AND_VIEW bit, so the default
|
|
* behavior is to keep the frame and view position and size in sync.
|
|
*/
|
|
class nsFrame : public nsIFrame
|
|
#ifdef NS_DEBUG
|
|
, public nsIFrameDebug
|
|
#endif
|
|
{
|
|
public:
|
|
/**
|
|
* Create a new "empty" frame that maps a given piece of content into a
|
|
* 0,0 area.
|
|
*/
|
|
friend nsresult NS_NewEmptyFrame(nsIPresShell* aShell, nsIFrame** aInstancePtrResult);
|
|
|
|
// Overloaded new operator. Initializes the memory to 0 and relies on an arena
|
|
// (which comes from the presShell) to perform the allocation.
|
|
void* operator new(size_t sz, nsIPresShell* aPresShell);
|
|
|
|
// Overridden to prevent the global delete from being called, since the memory
|
|
// came out of an nsIArena instead of the global delete operator's heap.
|
|
// XXX Would like to make this private some day, but our UNIX compilers can't
|
|
// deal with it.
|
|
void operator delete(void* aPtr, size_t sz);
|
|
|
|
private:
|
|
// The normal operator new is disallowed on nsFrames.
|
|
#if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95))
|
|
void* operator new(size_t sz) throw () { return nsnull; };
|
|
#else
|
|
void* operator new(size_t sz) { return nsnull; };
|
|
#endif
|
|
|
|
public:
|
|
|
|
// nsISupports
|
|
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
|
|
|
|
// nsIFrame
|
|
NS_IMETHOD Init(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParent,
|
|
nsIStyleContext* aContext,
|
|
nsIFrame* asPrevInFlow);
|
|
NS_IMETHOD SetInitialChildList(nsIPresContext* aPresContext,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aChildList);
|
|
NS_IMETHOD AppendFrames(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aFrameList);
|
|
NS_IMETHOD InsertFrames(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList);
|
|
NS_IMETHOD RemoveFrame(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame);
|
|
NS_IMETHOD ReplaceFrame(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame,
|
|
nsIFrame* aNewFrame);
|
|
NS_IMETHOD Destroy(nsIPresContext* aPresContext);
|
|
NS_IMETHOD GetContent(nsIContent** aContent) const;
|
|
NS_IMETHOD GetStyleContext(nsIStyleContext** aStyleContext) const;
|
|
NS_IMETHOD SetStyleContext(nsIPresContext* aPresContext,
|
|
nsIStyleContext* aContext);
|
|
NS_IMETHOD GetStyleData(nsStyleStructID aSID,
|
|
const nsStyleStruct*& aStyleStruct) const;
|
|
NS_IMETHOD GetAdditionalStyleContext(PRInt32 aIndex,
|
|
nsIStyleContext** aStyleContext) const;
|
|
NS_IMETHOD SetAdditionalStyleContext(PRInt32 aIndex,
|
|
nsIStyleContext* aStyleContext);
|
|
NS_IMETHOD GetParent(nsIFrame** aParent) const;
|
|
NS_IMETHOD SetParent(const nsIFrame* aParent);
|
|
NS_IMETHOD GetRect(nsRect& aRect) const;
|
|
NS_IMETHOD GetOrigin(nsPoint& aPoint) const;
|
|
NS_IMETHOD GetSize(nsSize& aSize) const;
|
|
NS_IMETHOD SetRect(nsIPresContext* aPresContext, const nsRect& aRect);
|
|
NS_IMETHOD MoveTo(nsIPresContext* aPresContext, nscoord aX, nscoord aY);
|
|
NS_IMETHOD SizeTo(nsIPresContext* aPresContext, nscoord aWidth, nscoord aHeight);
|
|
NS_IMETHOD GetAdditionalChildListName(PRInt32 aIndex, nsIAtom** aListName) const;
|
|
NS_IMETHOD FirstChild(nsIPresContext* aPresContext,
|
|
nsIAtom* aListName,
|
|
nsIFrame** aFirstChild) const;
|
|
NS_IMETHOD Paint(nsIPresContext* aPresContext,
|
|
nsIRenderingContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsFramePaintLayer aWhichLayer);
|
|
NS_IMETHOD HandleEvent(nsIPresContext* aPresContext,
|
|
nsGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus);
|
|
NS_IMETHOD GetContentForEvent(nsIPresContext* aPresContext,
|
|
nsEvent* aEvent,
|
|
nsIContent** aContent);
|
|
NS_IMETHOD GetCursor(nsIPresContext* aPresContext,
|
|
nsPoint& aPoint,
|
|
PRInt32& aCursor);
|
|
NS_IMETHOD GetFrameForPoint(nsIPresContext* aPresContext,
|
|
const nsPoint& aPoint,
|
|
nsFramePaintLayer aWhichLayer,
|
|
nsIFrame** aFrame);
|
|
|
|
NS_IMETHOD GetPointFromOffset(nsIPresContext* inPresContext,
|
|
nsIRenderingContext* inRendContext,
|
|
PRInt32 inOffset,
|
|
nsPoint* outPoint);
|
|
|
|
NS_IMETHOD GetChildFrameContainingOffset(PRInt32 inContentOffset,
|
|
PRBool inHint,
|
|
PRInt32* outFrameContentOffset,
|
|
nsIFrame* *outChildFrame);
|
|
|
|
static nsresult GetNextPrevLineFromeBlockFrame(nsIPresContext* aPresContext,
|
|
nsPeekOffsetStruct *aPos,
|
|
nsIFrame *aBlockFrame,
|
|
PRInt32 aLineStart,
|
|
PRInt8 aOutSideLimit
|
|
);
|
|
|
|
NS_IMETHOD GetFrameState(nsFrameState* aResult);
|
|
NS_IMETHOD SetFrameState(nsFrameState aNewState);
|
|
|
|
NS_IMETHOD ContentChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aChild,
|
|
nsISupports* aSubContent);
|
|
NS_IMETHOD AttributeChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aChild,
|
|
PRInt32 aNameSpaceID,
|
|
nsIAtom* aAttribute,
|
|
PRInt32 aHint);
|
|
NS_IMETHOD ContentStateChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aChild,
|
|
PRInt32 aHint);
|
|
NS_IMETHOD IsSplittable(nsSplittableType& aIsSplittable) const;
|
|
NS_IMETHOD GetPrevInFlow(nsIFrame** aPrevInFlow) const;
|
|
NS_IMETHOD SetPrevInFlow(nsIFrame*);
|
|
NS_IMETHOD GetNextInFlow(nsIFrame** aNextInFlow) const;
|
|
NS_IMETHOD SetNextInFlow(nsIFrame*);
|
|
NS_IMETHOD GetView(nsIPresContext* aPresContext, nsIView** aView) const;
|
|
NS_IMETHOD SetView(nsIPresContext* aPresContext, nsIView* aView);
|
|
NS_IMETHOD GetParentWithView(nsIPresContext* aPresContext, nsIFrame** aParent) const;
|
|
NS_IMETHOD GetOffsetFromView(nsIPresContext* aPresContext, nsPoint& aOffset, nsIView** aView) const;
|
|
NS_IMETHOD GetWindow(nsIPresContext* aPresContext, nsIWidget**) const;
|
|
NS_IMETHOD GetFrameType(nsIAtom** aType) const;
|
|
NS_IMETHOD IsPercentageBase(PRBool& aBase) const;
|
|
NS_IMETHOD GetNextSibling(nsIFrame** aNextSibling) const;
|
|
NS_IMETHOD SetNextSibling(nsIFrame* aNextSibling);
|
|
NS_IMETHOD Scrolled(nsIView *aView);
|
|
#ifdef NS_DEBUG
|
|
NS_IMETHOD List(nsIPresContext* aPresContext, FILE* out, PRInt32 aIndent) const;
|
|
NS_IMETHOD GetFrameName(nsString& aResult) const;
|
|
NS_IMETHOD DumpRegressionData(nsIPresContext* aPresContext, FILE* out, PRInt32 aIndent, PRBool aIncludeStyleData);
|
|
NS_IMETHOD SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const;
|
|
NS_IMETHOD VerifyTree() const;
|
|
#endif
|
|
|
|
NS_IMETHOD SetSelected(nsIPresContext* aPresContext, nsIDOMRange *aRange,PRBool aSelected, nsSpread aSpread);
|
|
NS_IMETHOD GetSelected(PRBool *aSelected) const;
|
|
NS_IMETHOD IsSelectable(PRBool* aIsSelectable, PRUint8* aSelectStyle) const;
|
|
|
|
NS_IMETHOD GetSelectionController(nsIPresContext *aPresContext, nsISelectionController **aSelCon);
|
|
NS_IMETHOD PeekOffset(nsIPresContext* aPresContext, nsPeekOffsetStruct *aPos) ;
|
|
NS_IMETHOD CheckVisibility(nsIPresContext* aContext, PRInt32 aStartIndex, PRInt32 aEndIndex, PRBool aRecurse, PRBool *aFinished, PRBool *_retval);
|
|
|
|
NS_IMETHOD PeekOffsetParagraph(nsIPresContext* aPresContext,
|
|
nsPeekOffsetStruct *aPos);
|
|
NS_IMETHOD GetOffsets(PRInt32 &aStart, PRInt32 &aEnd) const;
|
|
NS_IMETHOD ReflowDirtyChild(nsIPresShell* aPresShell, nsIFrame* aChild);
|
|
|
|
NS_IMETHOD GetParentStyleContextProvider(nsIPresContext* aPresContext,
|
|
nsIFrame** aProviderFrame,
|
|
nsContextProviderRelationship& aRelationship);
|
|
|
|
// Check Style Visibility and mState for Selection (when printing)
|
|
NS_IMETHOD IsVisibleForPainting(nsIPresContext * aPresContext,
|
|
nsIRenderingContext& aRenderingContext,
|
|
PRBool aCheckVis,
|
|
PRBool* aIsVisible);
|
|
|
|
// nsIHTMLReflow
|
|
NS_IMETHOD WillReflow(nsIPresContext* aPresContext);
|
|
NS_IMETHOD Reflow(nsIPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus);
|
|
NS_IMETHOD DidReflow(nsIPresContext* aPresContext,
|
|
nsDidReflowStatus aStatus);
|
|
NS_IMETHOD CanContinueTextRun(PRBool& aContinueTextRun) const;
|
|
NS_IMETHOD AdjustFrameSize(nscoord aExtraSpace, nscoord& aUsedSpace);
|
|
NS_IMETHOD TrimTrailingWhiteSpace(nsIPresContext* aPresContext,
|
|
nsIRenderingContext& aRC,
|
|
nscoord& aDeltaWidth);
|
|
|
|
// Selection Methods
|
|
// XXX Doc me... (in nsIFrame.h puhleeze)
|
|
// XXX If these are selection specific, then the name should imply selection
|
|
// rather than generic event processing, e.g., SelectionHandlePress...
|
|
NS_IMETHOD HandlePress(nsIPresContext* aPresContext,
|
|
nsGUIEvent * aEvent,
|
|
nsEventStatus* aEventStatus);
|
|
|
|
NS_IMETHOD HandleMultiplePress(nsIPresContext* aPresContext,
|
|
nsGUIEvent * aEvent,
|
|
nsEventStatus* aEventStatus);
|
|
|
|
NS_IMETHOD HandleDrag(nsIPresContext* aPresContext,
|
|
nsGUIEvent * aEvent,
|
|
nsEventStatus* aEventStatus);
|
|
|
|
NS_IMETHOD HandleRelease(nsIPresContext* aPresContext,
|
|
nsGUIEvent * aEvent,
|
|
nsEventStatus* aEventStatus);
|
|
|
|
NS_IMETHOD GetContentAndOffsetsFromPoint(nsIPresContext* aCX,
|
|
const nsPoint& aPoint,
|
|
nsIContent ** aNewContent,
|
|
PRInt32& aContentOffset,
|
|
PRInt32& aContentOffsetEnd,
|
|
PRBool& aBeginFrameContent);
|
|
NS_IMETHOD PeekBackwardAndForward(nsSelectionAmount aAmountBack,
|
|
nsSelectionAmount aAmountForward,
|
|
PRInt32 aStartPos,
|
|
nsIPresContext* aPresContext,
|
|
PRBool aJumpLines);
|
|
|
|
|
|
//--------------------------------------------------
|
|
// Additional methods
|
|
|
|
// Invalidate part of the frame by asking the view manager to repaint.
|
|
// aDamageRect is in the frame's local coordinate space
|
|
void Invalidate(nsIPresContext* aPresContext,
|
|
const nsRect& aDamageRect,
|
|
PRBool aImmediate = PR_FALSE) const;
|
|
|
|
// Helper function to return the index in parent of the frame's content
|
|
// object. Returns -1 on error or if the frame doesn't have a content object
|
|
static PRInt32 ContentIndexInContainer(const nsIFrame* aFrame);
|
|
|
|
// Helper function that tests if the frame tree is too deep; if it
|
|
// is it marks the frame as "unflowable" and zeros out the metrics
|
|
// and returns PR_TRUE. Otherwise, the frame is unmarked
|
|
// "unflowable" and the metrics are not touched and PR_FALSE is
|
|
// returned.
|
|
PRBool IsFrameTreeTooDeep(const nsHTMLReflowState& aReflowState,
|
|
nsHTMLReflowMetrics& aMetrics);
|
|
|
|
virtual nsresult GetClosestViewForFrame(nsIPresContext* aPresContext,
|
|
nsIFrame *aFrame,
|
|
nsIView **aView);
|
|
|
|
static nsresult CreateAndPostReflowCommand(nsIPresShell* aPresShell,
|
|
nsIFrame* aTargetFrame,
|
|
nsIReflowCommand::ReflowType aReflowType,
|
|
nsIFrame* aChildFrame,
|
|
nsIAtom* aAttribute,
|
|
nsIAtom* aListName);
|
|
|
|
//Mouse Capturing code used by the frames to tell the view to capture all the following events
|
|
NS_IMETHOD CaptureMouse(nsIPresContext* aPresContext, PRBool aGrabMouseEvents);
|
|
PRBool IsMouseCaptured(nsIPresContext* aPresContext);
|
|
|
|
#ifdef NS_DEBUG
|
|
/**
|
|
* Tracing method that writes a method enter/exit routine to the
|
|
* nspr log using the nsIFrame log module. The tracing is only
|
|
* done when the NS_FRAME_TRACE_CALLS bit is set in the log module's
|
|
* level field.
|
|
*/
|
|
void Trace(const char* aMethod, PRBool aEnter);
|
|
void Trace(const char* aMethod, PRBool aEnter, nsReflowStatus aStatus);
|
|
void TraceMsg(const char* fmt, ...);
|
|
|
|
// Helper function that verifies that each frame in the list has the
|
|
// NS_FRAME_IS_DIRTY bit set
|
|
static void VerifyDirtyBitSet(nsIFrame* aFrameList);
|
|
|
|
void ListTag(FILE* out) const {
|
|
ListTag(out, (nsIFrame*)this);
|
|
}
|
|
|
|
static void ListTag(FILE* out, nsIFrame* aFrame) {
|
|
nsAutoString tmp;
|
|
nsIFrameDebug* frameDebug;
|
|
|
|
if (NS_SUCCEEDED(aFrame->QueryInterface(NS_GET_IID(nsIFrameDebug), (void**)&frameDebug))) {
|
|
frameDebug->GetFrameName(tmp);
|
|
}
|
|
fputs(tmp, out);
|
|
fprintf(out, "@%p", aFrame);
|
|
}
|
|
|
|
static void IndentBy(FILE* out, PRInt32 aIndent) {
|
|
while (--aIndent >= 0) fputs(" ", out);
|
|
}
|
|
|
|
/**
|
|
* Dump out the "base classes" regression data. This should dump
|
|
* out the interior data, not the "frame" XML container. And it
|
|
* should call the base classes same named method before doing
|
|
* anything specific in a derived class. This means that derived
|
|
* classes need not override DumpRegressionData unless they need
|
|
* some custom behavior that requires changing how the outer "frame"
|
|
* XML container is dumped.
|
|
*/
|
|
virtual void DumpBaseRegressionData(nsIPresContext* aPresContext, FILE* out, PRInt32 aIndent, PRBool aIncludeStyleData);
|
|
|
|
nsresult MakeFrameName(const char* aKind, nsString& aResult) const;
|
|
#endif
|
|
|
|
protected:
|
|
// Protected constructor and destructor
|
|
nsFrame();
|
|
virtual ~nsFrame();
|
|
|
|
PRInt16 DisplaySelection(nsIPresContext* aPresContext, PRBool isOkToTurnOn = PR_FALSE);
|
|
|
|
//this will modify aPos and return the next frame ect.
|
|
NS_IMETHOD GetFrameFromDirection(nsIPresContext* aPresContext, nsPeekOffsetStruct *aPos);
|
|
|
|
// Style post processing hook
|
|
NS_IMETHOD DidSetStyleContext(nsIPresContext* aPresContext);
|
|
|
|
//return the line number of the aFrame
|
|
static PRInt32 GetLineNumber(nsIFrame *aFrame);
|
|
//given a frame five me the first/last leaf available
|
|
static void GetLastLeaf(nsIPresContext* aPresContext, nsIFrame **aFrame);
|
|
static void GetFirstLeaf(nsIPresContext* aPresContext, nsIFrame **aFrame);
|
|
|
|
// Test if we are selecting a table object:
|
|
// Most table/cell selection requires that Ctrl (Cmd on Mac) key is down
|
|
// during a mouse click or drag. Exception is using Shift+click when
|
|
// already in "table/cell selection mode" to extend a block selection
|
|
// Get the parent content node and offset of the frame
|
|
// of the enclosing cell or table (if not inside a cell)
|
|
// aTarget tells us what table element to select (currently only cell and table supported)
|
|
// (enums for this are defined in nsIFrame.h)
|
|
NS_IMETHOD GetDataForTableSelection(nsIFrameSelection *aFrameSelection, nsMouseEvent *aMouseEvent,
|
|
nsIContent **aParentContent, PRInt32 *aContentOffset, PRInt32 *aTarget);
|
|
|
|
static void XMLQuote(nsString& aString);
|
|
|
|
virtual PRBool ParentDisablesSelection() const;
|
|
|
|
// Set the overflow clip rect into the rendering-context. Used for block-level
|
|
// elements and replaced elements that have 'overflow' set to 'hidden'. This
|
|
// member function assumes that the caller has checked that the clip property
|
|
// applies to its situation.
|
|
void SetOverflowClipRect(nsIRenderingContext& aRenderingContext);
|
|
|
|
nsRect mRect;
|
|
nsIContent* mContent;
|
|
nsIStyleContext* mStyleContext;
|
|
nsIFrame* mParent;
|
|
nsIFrame* mNextSibling; // singly linked list of frames
|
|
nsFrameState mState;
|
|
|
|
protected:
|
|
NS_IMETHOD_(nsrefcnt) AddRef(void);
|
|
NS_IMETHOD_(nsrefcnt) Release(void);
|
|
};
|
|
|
|
#endif /* nsFrame_h___ */
|