gecko/layout/generic/nsCanvasFrame.h

234 lines
8.3 KiB
C
Raw Normal View History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** 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):
*
* 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 ***** */
/* rendering object that goes directly inside the document's scrollbars */
#ifndef nsCanvasFrame_h___
#define nsCanvasFrame_h___
#include "nsHTMLContainerFrame.h"
#include "nsIScrollPositionListener.h"
#include "nsAbsoluteContainingBlock.h"
#include "nsDisplayList.h"
#include "nsGkAtoms.h"
class nsPresContext;
class nsRenderingContext;
class nsEvent;
/**
* Root frame class.
*
* The root frame is the parent frame for the document element's frame.
* It only supports having a single child frame which must be an area
* frame
*/
class nsCanvasFrame : public nsHTMLContainerFrame,
public nsIScrollPositionListener
{
public:
nsCanvasFrame(nsStyleContext* aContext)
: nsHTMLContainerFrame(aContext),
mDoPaintFocus(PR_FALSE),
mAddedScrollPositionListener(PR_FALSE),
mAbsoluteContainer(kAbsoluteList) {}
NS_DECL_QUERYFRAME_TARGET(nsCanvasFrame)
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
virtual void DestroyFrom(nsIFrame* aDestructRoot);
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList);
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList);
NS_IMETHOD InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList);
NS_IMETHOD RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame);
virtual nsFrameList GetChildList(ChildListID aListID) const;
virtual void GetChildLists(nsTArray<ChildList>* aLists) const;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext);
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext);
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
virtual PRBool IsContainingBlock() const { return PR_TRUE; }
virtual PRBool IsFrameOfType(PRUint32 aFlags) const
{
return nsHTMLContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eCanContainOverflowContainers));
}
/** SetHasFocus tells the CanvasFrame to draw with focus ring
* @param aHasFocus PR_TRUE to show focus ring, PR_FALSE to hide it
*/
NS_IMETHOD SetHasFocus(PRBool aHasFocus);
NS_IMETHOD BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists);
void PaintFocus(nsRenderingContext& aRenderingContext, nsPoint aPt);
// nsIScrollPositionListener
virtual void ScrollPositionWillChange(nscoord aX, nscoord aY);
virtual void ScrollPositionDidChange(nscoord aX, nscoord aY) {}
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::canvasFrame
*/
virtual nsIAtom* GetType() const;
virtual nsresult StealFrame(nsPresContext* aPresContext,
nsIFrame* aChild,
PRBool aForceNormal)
{
NS_ASSERTION(!aForceNormal, "No-one should be passing this in here");
// nsCanvasFrame keeps overflow container continuations of its child
// frame in main child list
nsresult rv = nsContainerFrame::StealFrame(aPresContext, aChild, PR_TRUE);
if (NS_FAILED(rv)) {
rv = nsContainerFrame::StealFrame(aPresContext, aChild);
}
return rv;
}
#ifdef DEBUG
NS_IMETHOD GetFrameName(nsAString& aResult) const;
#endif
NS_IMETHOD GetContentForEvent(nsPresContext* aPresContext,
nsEvent* aEvent,
nsIContent** aContent);
nsRect CanvasArea() const;
protected:
virtual PRIntn GetSkipSides() const;
// Data members
PRPackedBool mDoPaintFocus;
PRPackedBool mAddedScrollPositionListener;
nsAbsoluteContainingBlock mAbsoluteContainer;
};
/**
* Override nsDisplayBackground methods so that we pass aBGClipRect to
* PaintBackground, covering the whole overflow area.
* We can also paint an "extra background color" behind the normal
* background.
*/
class nsDisplayCanvasBackground : public nsDisplayBackground {
public:
nsDisplayCanvasBackground(nsDisplayListBuilder* aBuilder, nsIFrame *aFrame)
: nsDisplayBackground(aBuilder, aFrame)
{
mExtraBackgroundColor = NS_RGBA(0,0,0,0);
}
virtual PRBool ComputeVisibility(nsDisplayListBuilder* aBuilder,
nsRegion* aVisibleRegion,
const nsRect& aAllowVisibleRegionExpansion)
{
return NS_GET_A(mExtraBackgroundColor) > 0 ||
nsDisplayBackground::ComputeVisibility(aBuilder, aVisibleRegion,
aAllowVisibleRegionExpansion);
}
virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
PRBool* aForceTransparentSurface = nsnull)
{
if (aForceTransparentSurface) {
*aForceTransparentSurface = PR_FALSE;
}
if (NS_GET_A(mExtraBackgroundColor) == 255)
return nsRegion(GetBounds(aBuilder));
return nsDisplayBackground::GetOpaqueRegion(aBuilder);
}
virtual PRBool IsUniform(nsDisplayListBuilder* aBuilder, nscolor* aColor)
{
nscolor background;
if (!nsDisplayBackground::IsUniform(aBuilder, &background))
return PR_FALSE;
NS_ASSERTION(background == NS_RGBA(0,0,0,0),
"The nsDisplayBackground for a canvas frame doesn't paint "
"its background color normally");
*aColor = mExtraBackgroundColor;
return PR_TRUE;
}
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder)
{
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsRect r = frame->CanvasArea() + ToReferenceFrame();
if (mSnappingEnabled) {
nscoord appUnitsPerDevPixel = frame->PresContext()->AppUnitsPerDevPixel();
r = r.ToNearestPixels(appUnitsPerDevPixel).ToAppUnits(appUnitsPerDevPixel);
}
return r;
}
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames)
{
// We need to override so we don't consider border-radius.
aOutFrames->AppendElement(mFrame);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
nsRenderingContext* aCtx);
void SetExtraBackgroundColor(nscolor aColor)
{
mExtraBackgroundColor = aColor;
}
NS_DISPLAY_DECL_NAME("CanvasBackground", TYPE_CANVAS_BACKGROUND)
private:
nscolor mExtraBackgroundColor;
};
#endif /* nsCanvasFrame_h___ */