Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 19:35:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 276100 GetOriginToView has unused PresContext argument p=bugmail@q1n.org r+sr=dbaron

Browse Source
This commit is contained in:
neil%parkwaycc.co.uk 2005-01-01 17:26:29 +00:00
parent f1b28c03f8
commit 74e2aa375a
67 changed files with 161 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
layout/base/nsPresShell.cpp
View File

@ -5704,21 +5704,21 @@ PresShell::HandleEvent(nsIView *aView,
nsPoint originOffset;
nsIView *view = nsnull;
frame->GetOriginToViewOffset(mPresContext, originOffset, &view);
frame->GetOriginToViewOffset(originOffset, &view);
NS_ASSERTION(view == aView, "view != aView");
if (view == aView)
eventPoint -= originOffset;
rv = frame->GetFrameForPoint(mPresContext, eventPoint,
rv = frame->GetFrameForPoint(eventPoint,
NS_FRAME_PAINT_LAYER_FOREGROUND,
&mCurrentEventFrame);
if (NS_FAILED(rv)) {
rv = frame->GetFrameForPoint(mPresContext, eventPoint,
rv = frame->GetFrameForPoint(eventPoint,
NS_FRAME_PAINT_LAYER_FLOATS,
&mCurrentEventFrame);
if (NS_FAILED(rv)) {
rv = frame->GetFrameForPoint(mPresContext, eventPoint,
rv = frame->GetFrameForPoint(eventPoint,
NS_FRAME_PAINT_LAYER_BACKGROUND,
&mCurrentEventFrame);
if (NS_FAILED (rv)) {

8
layout/forms/nsFieldSetFrame.cpp
View File

@ -102,8 +102,7 @@ public:
nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
virtual nsIAtom* GetType() const;
@ -662,13 +661,12 @@ nsFieldSetFrame::ReplaceFrame(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsFieldSetFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsFieldSetFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
}
#ifdef ACCESSIBILITY

5
layout/forms/nsFileControlFrame.cpp
View File

@ -567,8 +567,7 @@ nsFileControlFrame::AttributeChanged(nsIContent* aChild,
}
NS_IMETHODIMP
nsFileControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsFileControlFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -579,7 +578,7 @@ nsFileControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
return NS_OK;
}
} else {
return nsAreaFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsAreaFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}
#endif
return NS_ERROR_FAILURE;

2
layout/forms/nsFileControlFrame.h
View File

@ -97,7 +97,7 @@ public:
NS_IMETHOD GetFrameName(nsAString& aResult) const;
#endif
NS_IMETHOD SetSuggestedSize(nscoord aWidth, nscoord aHeight) { return NS_OK; };
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD AttributeChanged(nsIContent* aChild,
PRInt32 aNameSpaceID,
nsIAtom* aAttribute,

9
layout/forms/nsFormControlFrame.cpp
View File

@ -433,22 +433,21 @@ nsFormControlFrame::Paint(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsFormControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsFormControlFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
nsresult rv = NS_ERROR_FAILURE;
if (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND) {
rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
rv = nsLeafFrame::GetFrameForPoint(aPoint,
NS_FRAME_PAINT_LAYER_FOREGROUND, aFrame);
if (NS_SUCCEEDED(rv))
return NS_OK;
rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
rv = nsLeafFrame::GetFrameForPoint(aPoint,
NS_FRAME_PAINT_LAYER_FLOATS, aFrame);
if (NS_SUCCEEDED(rv))
return NS_OK;
rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
rv = nsLeafFrame::GetFrameForPoint(aPoint,
NS_FRAME_PAINT_LAYER_BACKGROUND, aFrame);
}
return rv;

3
layout/forms/nsFormControlFrame.h
View File

@ -114,8 +114,7 @@ public:
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags = 0);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

3
layout/forms/nsHTMLButtonControlFrame.cpp
View File

@ -285,8 +285,7 @@ nsHTMLButtonControlFrame::HandleEvent(nsPresContext* aPresContext,
NS_IMETHODIMP
nsHTMLButtonControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsHTMLButtonControlFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{

2
layout/forms/nsHTMLButtonControlFrame.h
View File

@ -85,7 +85,7 @@ public:
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD SetInitialChildList(nsPresContext* aPresContext,
nsIAtom* aListName,

5
layout/forms/nsSelectsAreaFrame.cpp
View File

@ -103,8 +103,7 @@ nsSelectsAreaFrame::IsOptionElementFrame(nsIFrame *aFrame)
//---------------------------------------------------------
NS_IMETHODIMP
nsSelectsAreaFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsSelectsAreaFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -115,7 +114,7 @@ nsSelectsAreaFrame::GetFrameForPoint(nsPresContext* aPresContext,
return NS_ERROR_FAILURE;
}
nsresult result = nsAreaFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
nsresult result = nsAreaFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
if (result == NS_OK) {
nsIFrame* selectedFrame = *aFrame;

2
layout/forms/nsSelectsAreaFrame.h
View File

@ -54,7 +54,7 @@ public:
// nsISupports
//NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,

9
layout/forms/nsTextControlFrame.cpp
View File

@ -2080,22 +2080,21 @@ nsTextControlFrame::Paint(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsTextControlFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTextControlFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
nsresult rv = NS_ERROR_FAILURE;
if (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND) {
rv = nsStackFrame::GetFrameForPoint(aPresContext, aPoint,
rv = nsStackFrame::GetFrameForPoint(aPoint,
NS_FRAME_PAINT_LAYER_FOREGROUND, aFrame);
if (NS_SUCCEEDED(rv))
return NS_OK;
rv = nsStackFrame::GetFrameForPoint(aPresContext, aPoint,
rv = nsStackFrame::GetFrameForPoint(aPoint,
NS_FRAME_PAINT_LAYER_FLOATS, aFrame);
if (NS_SUCCEEDED(rv))
return NS_OK;
rv = nsStackFrame::GetFrameForPoint(aPresContext, aPoint,
rv = nsStackFrame::GetFrameForPoint(aPoint,
NS_FRAME_PAINT_LAYER_BACKGROUND, aFrame);
}
return rv;

3
layout/forms/nsTextControlFrame.h
View File

@ -91,8 +91,7 @@ public:
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags = 0);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

46
layout/generic/nsBlockFrame.cpp
View File

@ -6386,14 +6386,14 @@ nsLineBox* nsBlockFrame::GetFirstLineContaining(nscoord y) {
static inline void
GetFrameFromLine(const nsRect& aLineArea, const nsPoint& aTmp,
nsBlockFrame::line_iterator& aLine, nsPresContext* aPresContext,
nsBlockFrame::line_iterator& aLine,
nsFramePaintLayer aWhichLayer, nsIFrame** aFrame) {
if (aLineArea.Contains(aTmp)) {
nsIFrame* kid = aLine->mFirstChild;
PRInt32 n = aLine->GetChildCount();
while (--n >= 0) {
nsIFrame *hit;
nsresult rv = kid->GetFrameForPoint(aPresContext, aTmp, aWhichLayer, &hit);
nsresult rv = kid->GetFrameForPoint(aTmp, aWhichLayer, &hit);
if (NS_SUCCEEDED(rv) && hit) {
*aFrame = hit;
@ -6406,16 +6406,15 @@ GetFrameFromLine(const nsRect& aLineArea, const nsPoint& aTmp,
// Optimized function that uses line combined areas to skip lines
// we know can't contain the point
nsresult
nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsBlockFrame::GetFrameForPointUsing(const nsPoint& aPoint,
nsIAtom* aList,
nsFramePaintLayer aWhichLayer,
PRBool aConsiderSelf,
nsIFrame** aFrame)
{
if (aList) {
return nsContainerFrame::GetFrameForPointUsing(aPresContext,
aPoint, aList, aWhichLayer, aConsiderSelf, aFrame);
return nsContainerFrame::GetFrameForPointUsing(aPoint,
aList, aWhichLayer, aConsiderSelf, aFrame);
}
PRBool inThisFrame = mRect.Contains(aPoint);
@ -6429,7 +6428,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
nsPoint originOffset;
nsIView *view = nsnull;
nsresult rv = GetOriginToViewOffset(aPresContext, originOffset, &view);
nsresult rv = GetOriginToViewOffset(originOffset, &view);
if (NS_SUCCEEDED(rv) && view)
tmp += originOffset;
@ -6449,7 +6448,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
if (lineArea.y > tmp.y) {
break;
}
GetFrameFromLine(lineArea, tmp, line, aPresContext, aWhichLayer, aFrame);
GetFrameFromLine(lineArea, tmp, line, aWhichLayer, aFrame);
}
}
} else {
@ -6469,7 +6468,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
lastY = lineArea.y;
lastYMost = lineArea.YMost();
GetFrameFromLine(lineArea, tmp, line, aPresContext, aWhichLayer, aFrame);
GetFrameFromLine(lineArea, tmp, line, aWhichLayer, aFrame);
}
lineCount++;
}
@ -6494,8 +6493,7 @@ nsBlockFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsBlockFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -6503,12 +6501,16 @@ nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
switch (aWhichLayer) {
case NS_FRAME_PAINT_LAYER_FOREGROUND:
rv = GetFrameForPointUsing(aPresContext, aPoint, nsnull, NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE, aFrame);
rv = GetFrameForPointUsing(aPoint, nsnull,
NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE,
aFrame);
if (NS_OK == rv) {
return NS_OK;
}
if (nsnull != mBullet) {
rv = GetFrameForPointUsing(aPresContext, aPoint, nsLayoutAtoms::bulletList, NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE, aFrame);
rv = GetFrameForPointUsing(aPoint, nsLayoutAtoms::bulletList,
NS_FRAME_PAINT_LAYER_FOREGROUND, PR_FALSE,
aFrame);
}
return rv;
break;
@ -6516,16 +6518,16 @@ nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
case NS_FRAME_PAINT_LAYER_FLOATS:
// we painted our floats before our children, and thus
// we should check floats within children first
rv = GetFrameForPointUsing(aPresContext, aPoint, nsnull, NS_FRAME_PAINT_LAYER_FLOATS, PR_FALSE, aFrame);
rv = GetFrameForPointUsing(aPoint, nsnull,
NS_FRAME_PAINT_LAYER_FLOATS, PR_FALSE,
aFrame);
if (NS_OK == rv) {
return NS_OK;
}
if (mFloats.NotEmpty()) {
return GetFrameForPointUsing(aPresContext, aPoint,
nsLayoutAtoms::floatList,
NS_FRAME_PAINT_LAYER_ALL,
PR_FALSE, aFrame);
return GetFrameForPointUsing(aPoint, nsLayoutAtoms::floatList,
NS_FRAME_PAINT_LAYER_ALL, PR_FALSE,
aFrame);
} else {
return NS_ERROR_FAILURE;
}
@ -6533,9 +6535,9 @@ nsBlockFrame::GetFrameForPoint(nsPresContext* aPresContext,
case NS_FRAME_PAINT_LAYER_BACKGROUND:
// we're a block, so PR_TRUE for consider self
return GetFrameForPointUsing(aPresContext, aPoint, nsnull,
NS_FRAME_PAINT_LAYER_BACKGROUND,
PR_TRUE, aFrame);
return GetFrameForPointUsing(aPoint, nsnull,
NS_FRAME_PAINT_LAYER_BACKGROUND, PR_TRUE,
aFrame);
break;
}
// we shouldn't get here

5
layout/generic/nsBlockFrame.h
View File

@ -179,13 +179,12 @@ public:
// are non-decreasing.
void SetupLineCursor();
nsresult GetFrameForPointUsing(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsresult GetFrameForPointUsing(const nsPoint& aPoint,
nsIAtom* aList,
nsFramePaintLayer aWhichLayer,
PRBool aConsiderSelf,
nsIFrame** aFrame);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);

21
layout/generic/nsContainerFrame.cpp
View File

@ -317,17 +317,15 @@ nsContainerFrame::PaintChild(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsContainerFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsContainerFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND), aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND), aFrame);
}
nsresult
nsContainerFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsContainerFrame::GetFrameForPointUsing(const nsPoint& aPoint,
nsIAtom* aList,
nsFramePaintLayer aWhichLayer,
PRBool aConsiderSelf,
@ -348,7 +346,7 @@ nsContainerFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
nsPoint originOffset;
nsIView *view = nsnull;
nsresult rv = GetOriginToViewOffset(aPresContext, originOffset, &view);
nsresult rv = GetOriginToViewOffset(originOffset, &view);
if (NS_SUCCEEDED(rv) && view)
tmp += originOffset;
@ -356,18 +354,15 @@ nsContainerFrame::GetFrameForPointUsing(nsPresContext* aPresContext,
while (kid) {
if (aWhichLayer == NS_FRAME_PAINT_LAYER_ALL) {
// Check all layers on this kid before moving on to the next one
rv = kid->GetFrameForPoint(aPresContext, tmp,
NS_FRAME_PAINT_LAYER_FOREGROUND, &hit);
rv = kid->GetFrameForPoint(tmp, NS_FRAME_PAINT_LAYER_FOREGROUND, &hit);
if (NS_FAILED(rv) || !hit) {
rv = kid->GetFrameForPoint(aPresContext, tmp,
NS_FRAME_PAINT_LAYER_FLOATS, &hit);
rv = kid->GetFrameForPoint(tmp, NS_FRAME_PAINT_LAYER_FLOATS, &hit);
if (NS_FAILED(rv) || !hit) {
rv = kid->GetFrameForPoint(aPresContext, tmp,
NS_FRAME_PAINT_LAYER_BACKGROUND, &hit);
rv = kid->GetFrameForPoint(tmp, NS_FRAME_PAINT_LAYER_BACKGROUND, &hit);
}
}
} else {
rv = kid->GetFrameForPoint(aPresContext, tmp, aWhichLayer, &hit);
rv = kid->GetFrameForPoint(tmp, aWhichLayer, &hit);
}
if (NS_SUCCEEDED(rv) && hit) {

6
layout/generic/nsContainerFrame.h
View File

@ -70,8 +70,7 @@ public:
const nsRect& aDirtyRect,
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags = 0);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
NS_IMETHOD ReplaceFrame(nsPresContext* aPresContext,
@ -188,8 +187,7 @@ protected:
nsContainerFrame();
~nsContainerFrame();
nsresult GetFrameForPointUsing(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsresult GetFrameForPointUsing(const nsPoint& aPoint,
nsIAtom* aList,
nsFramePaintLayer aWhichLayer,
PRBool aConsiderSelf,

7
layout/generic/nsFrame.cpp
View File

@ -2041,8 +2041,7 @@ nsFrame::GetCursor(const nsPoint& aPoint,
}
NS_IMETHODIMP
nsFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -2368,11 +2367,9 @@ NS_IMETHODIMP nsFrame::GetOffsetFromView(nsPoint& aOffset,
// not a descendant of the frame's parent view (ex: scrolling popup menu),
// the offset returned will be (0,0).
NS_IMETHODIMP nsFrame::GetOriginToViewOffset(nsPresContext* aPresContext,
nsPoint& aOffset,
NS_IMETHODIMP nsFrame::GetOriginToViewOffset(nsPoint& aOffset,
nsIView** aView) const
{
NS_ENSURE_ARG_POINTER(aPresContext);
nsresult rv = NS_OK;
aOffset.MoveTo(0,0);

5
layout/generic/nsFrame.h
View File

@ -208,8 +208,7 @@ public:
nsIContent** aContent);
NS_IMETHOD GetCursor(const nsPoint& aPoint,
nsIFrame::Cursor& aCursor);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
@ -242,7 +241,7 @@ public:
virtual nsIFrame* GetNextInFlow() const;
NS_IMETHOD SetNextInFlow(nsIFrame*);
NS_IMETHOD GetOffsetFromView(nsPoint& aOffset, nsIView** aView) const;
NS_IMETHOD GetOriginToViewOffset(nsPresContext *aPresContext, nsPoint& aOffset, nsIView **aView) const;
NS_IMETHOD GetOriginToViewOffset(nsPoint& aOffset, nsIView **aView) const;
virtual nsIAtom* GetType() const;
virtual PRBool IsContainingBlock() const;
#ifdef NS_DEBUG

11
layout/generic/nsFrameSetFrame.cpp
View File

@ -134,8 +134,7 @@ public:
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
@ -842,8 +841,7 @@ nsHTMLFramesetFrame::GetCursor(const nsPoint& aPoint,
}
NS_IMETHODIMP
nsHTMLFramesetFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsHTMLFramesetFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -852,7 +850,7 @@ nsHTMLFramesetFrame::GetFrameForPoint(nsPresContext* aPresContext,
*aFrame = this;
return NS_OK;
} else {
return nsContainerFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsContainerFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}
}
@ -1762,8 +1760,7 @@ nsHTMLFramesetBorderFrame::HandleEvent(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsHTMLFramesetBorderFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsHTMLFramesetBorderFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{

3
layout/generic/nsFrameSetFrame.h
View File

@ -135,8 +135,7 @@ public:
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

8
layout/generic/nsHTMLFrame.cpp
View File

@ -118,8 +118,7 @@ public:
NS_IMETHOD HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
virtual PRBool IsContainingBlock() const { return PR_TRUE; }
@ -630,13 +629,12 @@ CanvasFrame::HandleEvent(nsPresContext* aPresContext,
}
NS_IMETHODIMP
CanvasFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
CanvasFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
}
nsIAtom*

6
layout/generic/nsIFrame.h
View File

@ -769,8 +769,7 @@ public:
* recieve the events. A successful return value indicates that a
* point was found.
*/
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame) = 0;
@ -1029,8 +1028,7 @@ public:
* aView is optional, that is, you may pass null if you are not interested
* in getting a pointer to the view.
*/
NS_IMETHOD GetOriginToViewOffset(nsPresContext* aPresContext,
nsPoint& aOffset,
NS_IMETHOD GetOriginToViewOffset(nsPoint& aOffset,
nsIView** aView) const = 0;
/**

5
layout/generic/nsViewportFrame.cpp
View File

@ -89,13 +89,12 @@ ViewportFrame::SetInitialChildList(nsPresContext* aPresContext,
}
NS_IMETHODIMP
ViewportFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
ViewportFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer,
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer,
(aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
}

3
layout/generic/nsViewportFrame.h
View File

@ -71,8 +71,7 @@ public:
nsIAtom* aListName,
nsIFrame* aChildList);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

7
layout/mathml/base/src/nsMathMLmactionFrame.cpp
View File

@ -254,17 +254,16 @@ nsMathMLmactionFrame::SetInitialChildList(nsPresContext* aPresContext,
// Return the selected frame ...
NS_IMETHODIMP
nsMathMLmactionFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsMathMLmactionFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
nsIFrame* childFrame = GetSelectedFrame();
if (childFrame) {
nsPoint pt(aPoint.x - mRect.x, aPoint.y - mRect.y);
return childFrame->GetFrameForPoint(aPresContext, pt, aWhichLayer, aFrame);
return childFrame->GetFrameForPoint(pt, aWhichLayer, aFrame);
}
return nsFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}
// Only paint the selected child...

3
layout/mathml/base/src/nsMathMLmactionFrame.h
View File

@ -73,8 +73,7 @@ public:
nsIFrame* aChildList);
NS_IMETHOD
GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

17
layout/svg/base/src/nsSVGForeignObjectFrame.cpp
View File

@ -524,23 +524,24 @@ nsSVGForeignObjectFrame::GetFrameForPoint(float x, float y, nsIFrame** hit)
{
*hit = nsnull;
nsPresContext *presContext = GetPresContext();
nsPoint p( (nscoord)(x*GetTwipsPerPx()),
(nscoord)(y*GetTwipsPerPx()));
nsresult rv;
rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(presContext, p,
NS_FRAME_PAINT_LAYER_FOREGROUND, hit);
rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(p,
NS_FRAME_PAINT_LAYER_FOREGROUND,
hit);
if (NS_SUCCEEDED(rv) && *hit) return rv;
rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(presContext, p,
NS_FRAME_PAINT_LAYER_FLOATS, hit);
rv = nsSVGForeignObjectFrameBase::GetFrameForPoint(p,
NS_FRAME_PAINT_LAYER_FLOATS,
hit);
if (NS_SUCCEEDED(rv) && *hit) return rv;
return nsSVGForeignObjectFrameBase::GetFrameForPoint(presContext, p,
NS_FRAME_PAINT_LAYER_BACKGROUND, hit);
return nsSVGForeignObjectFrameBase::GetFrameForPoint(p,
NS_FRAME_PAINT_LAYER_BACKGROUND,
hit);
}
NS_IMETHODIMP_(already_AddRefed<nsISVGRendererRegion>)

6
layout/svg/base/src/nsSVGOuterSVGFrame.cpp
View File

@ -210,8 +210,7 @@ public:
nsIAtom* aAttribute,
PRInt32 aModType);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
@ -709,8 +708,7 @@ nsSVGOuterSVGFrame::AttributeChanged(nsIContent* aChild,
nsresult
nsSVGOuterSVGFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsSVGOuterSVGFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{

5
layout/tables/nsTableCellFrame.cpp
View File

@ -461,13 +461,12 @@ nsTableCellFrame::Paint(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsTableCellFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTableCellFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
}
//null range means the whole thing

3
layout/tables/nsTableCellFrame.h
View File

@ -137,8 +137,7 @@ public:
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags = 0);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

3
layout/tables/nsTableColFrame.cpp
View File

@ -145,8 +145,7 @@ nsTableColFrame::Paint(nsPresContext* aPresContext,
// override, since we want to act like a block
NS_IMETHODIMP
nsTableColFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTableColFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{

3
layout/tables/nsTableColFrame.h
View File

@ -120,8 +120,7 @@ public:
// column groups don't paint their own background -- the cells do
virtual PRBool CanPaintBackground() { return PR_FALSE; }
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/tables/nsTableColGroupFrame.cpp
View File

@ -342,13 +342,12 @@ nsTableColGroupFrame::GetSkipSides() const
}
NS_IMETHODIMP
nsTableColGroupFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTableColGroupFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
}
NS_METHOD nsTableColGroupFrame::Reflow(nsPresContext* aPresContext,

3
layout/tables/nsTableColGroupFrame.h
View File

@ -155,8 +155,7 @@ public:
/** @see nsIFrame::GetFrameForPoint
*/
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/tables/nsTableFrame.cpp
View File

@ -1457,13 +1457,12 @@ nsTableFrame::Paint(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsTableFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTableFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, (aWhichLayer == NS_FRAME_PAINT_LAYER_BACKGROUND), aFrame);
}

3
layout/tables/nsTableFrame.h
View File

@ -341,8 +341,7 @@ public:
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

7
layout/tables/nsTableOuterFrame.cpp
View File

@ -353,8 +353,7 @@ nsTableOuterFrame::Paint(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsTableOuterFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTableOuterFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -362,14 +361,14 @@ nsTableOuterFrame::GetFrameForPoint(nsPresContext* aPresContext,
// caption frames live in a different list which we need to check separately
if (mCaptionFrame) {
rv = GetFrameForPointUsing(aPresContext, aPoint, nsLayoutAtoms::captionList, aWhichLayer, PR_FALSE, aFrame);
rv = GetFrameForPointUsing(aPoint, nsLayoutAtoms::captionList, aWhichLayer, PR_FALSE, aFrame);
if (NS_OK == rv) {
return NS_OK;
}
}
// This frame should never get events (it contains the margins of the
// table), so always pass |PR_FALSE| for |aConsiderSelf|.
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
}
NS_IMETHODIMP nsTableOuterFrame::SetSelected(nsPresContext* aPresContext,

3
layout/tables/nsTableOuterFrame.h
View File

@ -140,8 +140,7 @@ public:
// the outer table does not paint its entire background if it has margins and/or captions
virtual PRBool CanPaintBackground() { return PR_FALSE; }
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/tables/nsTableRowFrame.cpp
View File

@ -595,8 +595,7 @@ nsTableRowFrame::GetSkipSides() const
* sufficient. We have to ask the row if it has a child that contains the point.
*/
NS_IMETHODIMP
nsTableRowFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTableRowFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -620,7 +619,7 @@ nsTableRowFrame::GetFrameForPoint(nsPresContext* aPresContext,
*aFrame = nsnull;
tmp.MoveTo(aPoint.x - mRect.x, aPoint.y - mRect.y);
while (nsnull != kid) {
nsresult rv = kid->GetFrameForPoint(aPresContext, tmp, aWhichLayer, &hit);
nsresult rv = kid->GetFrameForPoint(tmp, aWhichLayer, &hit);
if (NS_SUCCEEDED(rv) && hit) {
*aFrame = hit;

3
layout/tables/nsTableRowFrame.h
View File

@ -107,8 +107,7 @@ public:
// rows don't paint their own background -- the cells do
virtual PRBool CanPaintBackground() { return PR_FALSE; }
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/tables/nsTableRowGroupFrame.cpp
View File

@ -248,13 +248,12 @@ nsTableRowGroupFrame::GetSkipSides() const
NS_IMETHODIMP
nsTableRowGroupFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTableRowGroupFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return GetFrameForPointUsing(aPresContext, aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
return GetFrameForPointUsing(aPoint, nsnull, aWhichLayer, PR_FALSE, aFrame);
}
// Position and size aKidFrame and update our reflow state. The origin of

2
layout/tables/nsTableRowGroupFrame.h
View File

@ -152,7 +152,7 @@ public:
* Return PR_TRUE if a frame containing the point is found.
* @see nsContainerFrame::GetFrameForPoint
*/
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint, nsFramePaintLayer aWhichLayer, nsIFrame** aFrame);
/** calls Reflow for all of its child rows.
* Rows are all set to the same width and stacked vertically.

12
layout/xul/base/src/nsBoxFrame.cpp
View File

@ -1738,8 +1738,7 @@ nsBoxFrame::GetDebug(PRBool& aDebug)
#endif
NS_IMETHODIMP
nsBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsBoxFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -1752,7 +1751,7 @@ nsBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
nsIView* view = nsnull;
nsPoint originOffset;
GetOriginToViewOffset(aPresContext, originOffset, &view);
GetOriginToViewOffset(originOffset, &view);
#ifdef DEBUG_LAYOUT
// get the debug frame.
@ -1783,7 +1782,7 @@ nsBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
nsIBox* kid = nsnull;
GetChildBox(&kid);
while (nsnull != kid) {
GetFrameForPointChild(aPresContext, tmp, aWhichLayer, kid, hit != nsnull, &hit);
GetFrameForPointChild(tmp, aWhichLayer, kid, hit != nsnull, &hit);
kid->GetNextBox(&kid);
}
if (hit)
@ -1803,8 +1802,7 @@ nsBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
}
/* virtual */ nsresult
nsBoxFrame::GetFrameForPointChild(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsBoxFrame::GetFrameForPointChild(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame* aChild,
PRBool aCheckMouseThrough,
@ -1812,7 +1810,7 @@ nsBoxFrame::GetFrameForPointChild(nsPresContext* aPresContext,
{
nsIFrame *hit = nsnull;
nsresult rv =
aChild->GetFrameForPoint(aPresContext, aPoint, aWhichLayer, &hit);
aChild->GetFrameForPoint(aPoint, aWhichLayer, &hit);
if (NS_SUCCEEDED(rv) && hit) {
rv = NS_ERROR_FAILURE;

6
layout/xul/base/src/nsBoxFrame.h
View File

@ -123,8 +123,7 @@ public:
// ----- public methods -------
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
@ -258,8 +257,7 @@ protected:
nsresult RegUnregAccessKey(nsPresContext* aPresContext,
PRBool aDoReg);
void FireDOMEvent(nsPresContext *aPresContext, const nsAString& aDOMEventName);
virtual nsresult GetFrameForPointChild(nsPresContext* aPresContext,
const nsPoint& aPoint,
virtual nsresult GetFrameForPointChild(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame* aChild,
PRBool aCheckMouseThrough,

5
layout/xul/base/src/nsButtonBoxFrame.cpp
View File

@ -86,13 +86,12 @@ nsButtonBoxFrame::GetMouseThrough(PRBool& aMouseThrough)
return NS_OK;
}
NS_IMETHODIMP nsButtonBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHODIMP nsButtonBoxFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// override, since we don't want children to get events
return nsFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}
NS_IMETHODIMP

3
layout/xul/base/src/nsButtonBoxFrame.h
View File

@ -47,8 +47,7 @@ public:
nsButtonBoxFrame(nsIPresShell* aPresShell);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

6
layout/xul/base/src/nsDeckFrame.cpp
View File

@ -241,8 +241,7 @@ nsDeckFrame::Paint(nsPresContext* aPresContext,
NS_IMETHODIMP
nsDeckFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsDeckFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -256,8 +255,7 @@ nsDeckFrame::GetFrameForPoint(nsPresContext* aPresContext,
if (selectedBox) {
nsPoint tmp(aPoint.x - mRect.x, aPoint.y - mRect.y);
if (NS_SUCCEEDED(selectedBox->GetFrameForPoint(aPresContext, tmp,
aWhichLayer, aFrame)))
if (NS_SUCCEEDED(selectedBox->GetFrameForPoint(tmp, aWhichLayer, aFrame)))
return NS_OK;
}

3
layout/xul/base/src/nsDeckFrame.h
View File

@ -70,8 +70,7 @@ public:
PRUint32 aFlags = 0);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

3
layout/xul/base/src/nsLeafBoxFrame.cpp
View File

@ -185,8 +185,7 @@ nsLeafBoxFrame::GetMouseThrough(PRBool& aMouseThrough)
}
NS_IMETHODIMP
nsLeafBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsLeafBoxFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{

3
layout/xul/base/src/nsLeafBoxFrame.h
View File

@ -82,8 +82,7 @@ public:
nsStyleContext* aContext,
nsIFrame* asPrevInFlow);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/xul/base/src/nsListItemFrame.cpp
View File

@ -80,15 +80,14 @@ nsListItemFrame::GetPrefSize(nsBoxLayoutState& aState, nsSize& aSize)
}
NS_IMETHODIMP
nsListItemFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsListItemFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
nsAutoString value;
mContent->GetAttr(kNameSpaceID_None, nsXULAtoms::allowevents, value);
if (value.EqualsLiteral("true")) {
return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}
else if (mRect.Contains(aPoint)) {
if (GetStyleVisibility()->IsVisible()) {

3
layout/xul/base/src/nsListItemFrame.h
View File

@ -57,8 +57,7 @@ public:
// overridden so that children of listitems don't handle mouse events,
// unless allowevents="true" is specified on the listitem
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/xul/base/src/nsMenuFrame.cpp
View File

@ -341,12 +341,11 @@ nsMenuFrame::Destroy(nsPresContext* aPresContext)
// Called to prevent events from going to anything inside the menu.
NS_IMETHODIMP
nsMenuFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsMenuFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
nsresult result = nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
nsresult result = nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
if (NS_FAILED(result) || *aFrame == this) {
return result;
}

3
layout/xul/base/src/nsMenuFrame.h
View File

@ -108,8 +108,7 @@ public:
NS_IMETHOD Destroy(nsPresContext* aPresContext);
// Overridden to prevent events from ever going to children of the menu.
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

7
layout/xul/base/src/nsMenuPopupFrame.cpp
View File

@ -1167,7 +1167,7 @@ nsMenuPopupFrame::SyncViewWithFrame(nsPresContext* aPresContext,
// Now that we've positioned the view, sync up the frame's origin.
nsPoint frameOrigin = GetPosition();
nsPoint offsetToView;
GetOriginToViewOffset(aPresContext, offsetToView, nsnull);
GetOriginToViewOffset(offsetToView, nsnull);
frameOrigin -= offsetToView;
nsBoxFrame::SetPosition(frameOrigin);
@ -2049,12 +2049,11 @@ nsMenuPopupFrame::Destroy(nsPresContext* aPresContext)
}
NS_IMETHODIMP
nsMenuPopupFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsMenuPopupFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}

3
layout/xul/base/src/nsMenuPopupFrame.h
View File

@ -133,8 +133,7 @@ public:
NS_IMETHOD Destroy(nsPresContext* aPresContext);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

8
layout/xul/base/src/nsRootBoxFrame.cpp
View File

@ -102,8 +102,7 @@ public:
NS_IMETHOD HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
@ -259,13 +258,12 @@ nsRootBoxFrame::HandleEvent(nsPresContext* aPresContext,
}
NS_IMETHODIMP
nsRootBoxFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsRootBoxFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// this should act like a block, so we need to override
return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}
nsIAtom*

5
layout/xul/base/src/nsSliderFrame.cpp
View File

@ -714,8 +714,7 @@ nsSliderFrame::SetCurrentPosition(nsIContent* scrollbar, nsIFrame* aThumbFrame,
}
NS_IMETHODIMP nsSliderFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHODIMP nsSliderFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -728,7 +727,7 @@ NS_IMETHODIMP nsSliderFrame::GetFrameForPoint(nsPresContext* aPresContext,
return NS_OK;
}
if (NS_SUCCEEDED(nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame)))
if (NS_SUCCEEDED(nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame)))
return NS_OK;
// always return us (if visible)

3
layout/xul/base/src/nsSliderFrame.h
View File

@ -185,8 +185,7 @@ public:
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/xul/base/src/nsSplitterFrame.cpp
View File

@ -444,8 +444,7 @@ nsSplitterFrame::HandleRelease(nsPresContext* aPresContext,
return NS_OK;
}
NS_IMETHODIMP nsSplitterFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHODIMP nsSplitterFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -457,7 +456,7 @@ NS_IMETHODIMP nsSplitterFrame::GetFrameForPoint(nsPresContext* aPresContext,
return NS_OK;
}
nsresult rv = nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
nsresult rv = nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
if (NS_FAILED(rv) &&
aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND &&

3
layout/xul/base/src/nsSplitterFrame.h
View File

@ -103,8 +103,7 @@ public:
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

13
layout/xul/base/src/nsStackFrame.cpp
View File

@ -89,21 +89,18 @@ nsStackFrame::nsStackFrame(nsIPresShell* aPresShell, nsIBoxLayout* aLayoutManage
NS_IMETHODIMP
nsStackFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsStackFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
if (aWhichLayer != NS_FRAME_PAINT_LAYER_BACKGROUND)
return NS_ERROR_FAILURE;
return nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer,
aFrame);
return nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}
/* virtual */ nsresult
nsStackFrame::GetFrameForPointChild(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsStackFrame::GetFrameForPointChild(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame* aChild,
PRBool aCheckMouseThrough,
@ -112,12 +109,12 @@ nsStackFrame::GetFrameForPointChild(nsPresContext* aPresContext,
if (aWhichLayer != NS_FRAME_PAINT_LAYER_BACKGROUND)
return NS_ERROR_FAILURE;
nsresult rv = nsBoxFrame::GetFrameForPointChild(aPresContext, aPoint,
nsresult rv = nsBoxFrame::GetFrameForPointChild(aPoint,
NS_FRAME_PAINT_LAYER_FOREGROUND,
aChild, aCheckMouseThrough, aFrame);
if (NS_SUCCEEDED(rv))
return rv;
return nsBoxFrame::GetFrameForPointChild(aPresContext, aPoint,
return nsBoxFrame::GetFrameForPointChild(aPoint,
NS_FRAME_PAINT_LAYER_BACKGROUND,
aChild, aCheckMouseThrough, aFrame);
}

6
layout/xul/base/src/nsStackFrame.h
View File

@ -75,15 +75,13 @@ public:
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags = 0);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);
protected:
virtual nsresult GetFrameForPointChild(nsPresContext* aPresContext,
const nsPoint& aPoint,
virtual nsresult GetFrameForPointChild(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame* aChild,
PRBool aCheckMouseThrough,

5
layout/xul/base/src/nsTitleBarFrame.cpp
View File

@ -103,13 +103,12 @@ nsTitleBarFrame::GetMouseThrough(PRBool& aMouseThrough)
return NS_OK;
}
NS_IMETHODIMP nsTitleBarFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHODIMP nsTitleBarFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
// override, since we don't want children to get events
return nsFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
return nsFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
}

3
layout/xul/base/src/nsTitleBarFrame.h
View File

@ -54,8 +54,7 @@ public:
nsStyleContext* aContext,
nsIFrame* asPrevInFlow);
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);

5
layout/xul/base/src/tree/src/nsTreeColFrame.cpp
View File

@ -125,8 +125,7 @@ nsTreeColFrame::Destroy(nsPresContext* aPresContext)
}
NS_IMETHODIMP
nsTreeColFrame::GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
nsTreeColFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame)
{
@ -160,7 +159,7 @@ nsTreeColFrame::GetFrameForPoint(nsPresContext* aPresContext,
}
}
nsresult result = nsBoxFrame::GetFrameForPoint(aPresContext, aPoint, aWhichLayer, aFrame);
nsresult result = nsBoxFrame::GetFrameForPoint(aPoint, aWhichLayer, aFrame);
if (result == NS_OK) {
nsIContent* content = (*aFrame)->GetContent();
if (content) {

3
layout/xul/base/src/tree/src/nsTreeColFrame.h
View File

@ -58,8 +58,7 @@ public:
NS_IMETHOD Destroy(nsPresContext* aPresContext);
// Overridden to capture events.
NS_IMETHOD GetFrameForPoint(nsPresContext* aPresContext,
const nsPoint& aPoint,
NS_IMETHOD GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer,
nsIFrame** aFrame);