590 lines
19 KiB
C++
590 lines
19 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.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
#include "nsCOMPtr.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsIPresContext.h"
|
|
#include "nsIStyleContext.h"
|
|
#include "nsIReflowCommand.h"
|
|
#include "nsIDeviceContext.h"
|
|
#include "nsPageFrame.h"
|
|
#include "nsViewsCID.h"
|
|
#include "nsIView.h"
|
|
#include "nsIViewManager.h"
|
|
#include "nsHTMLContainerFrame.h"
|
|
#include "nsHTMLIIDs.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsIScrollableView.h"
|
|
#include "nsWidgetsCID.h"
|
|
#include "nsIAreaFrame.h"
|
|
#include "nsScrollPortFrame.h"
|
|
#include "nsLayoutAtoms.h"
|
|
#include "nsIWebShell.h"
|
|
#include "nsIBox.h"
|
|
|
|
static NS_DEFINE_IID(kIWebShellIID, NS_IWEB_SHELL_IID);
|
|
|
|
static NS_DEFINE_IID(kWidgetCID, NS_CHILD_CID);
|
|
static NS_DEFINE_IID(kScrollingViewCID, NS_SCROLLING_VIEW_CID);
|
|
static NS_DEFINE_IID(kViewCID, NS_VIEW_CID);
|
|
|
|
static NS_DEFINE_IID(kIViewIID, NS_IVIEW_IID);
|
|
static NS_DEFINE_IID(kScrollViewIID, NS_ISCROLLABLEVIEW_IID);
|
|
static NS_DEFINE_IID(kAreaFrameIID, NS_IAREAFRAME_IID);
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
nsresult
|
|
NS_NewScrollPortFrame(nsIFrame** aNewFrame)
|
|
{
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
if (nsnull == aNewFrame) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
nsScrollPortFrame* it = new nsScrollPortFrame;
|
|
if (nsnull == it) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
*aNewFrame = it;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsScrollPortFrame::nsScrollPortFrame()
|
|
{
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::Init(nsIPresContext& aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParent,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame* aPrevInFlow)
|
|
{
|
|
nsresult rv = nsHTMLContainerFrame::Init(aPresContext, aContent,
|
|
aParent, aStyleContext,
|
|
aPrevInFlow);
|
|
|
|
// Create the scrolling view
|
|
CreateScrollingView(aPresContext);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::SetInitialChildList(nsIPresContext& aPresContext,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aChildList)
|
|
{
|
|
nsresult rv = nsHTMLContainerFrame::SetInitialChildList(aPresContext, aListName,
|
|
aChildList);
|
|
nsIFrame* frame = mFrames.FirstChild();
|
|
|
|
// There must be one and only one child frame
|
|
if (!frame) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
} else if (mFrames.GetLength() > 1) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
#ifdef NS_DEBUG
|
|
// Verify that the scrolled frame has a view
|
|
nsIView* scrolledView;
|
|
frame->GetView(&scrolledView);
|
|
NS_ASSERTION(nsnull != scrolledView, "no view");
|
|
#endif
|
|
|
|
// We need to allow the view's position to be different than the
|
|
// frame's position
|
|
nsFrameState state;
|
|
frame->GetFrameState(&state);
|
|
state &= ~NS_FRAME_SYNC_FRAME_AND_VIEW;
|
|
frame->SetFrameState(state);
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::AppendFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
// Only one child frame allowed
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::InsertFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
// Only one child frame allowed
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::RemoveFrame(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
// Scroll frame doesn't support incremental changes
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::DidReflow(nsIPresContext& aPresContext,
|
|
nsDidReflowStatus aStatus)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (NS_FRAME_REFLOW_FINISHED == aStatus) {
|
|
// Let the default nsFrame implementation clear the state flags
|
|
// and size and position our view
|
|
rv = nsFrame::DidReflow(aPresContext, aStatus);
|
|
|
|
// Send the DidReflow notification to the scrolled frame's view
|
|
nsIFrame* frame = mFrames.FirstChild();
|
|
nsIHTMLReflow* htmlReflow;
|
|
|
|
frame->QueryInterface(kIHTMLReflowIID, (void**)&htmlReflow);
|
|
htmlReflow->DidReflow(aPresContext, aStatus);
|
|
|
|
// Size the scrolled frame's view. Leave its position alone
|
|
nsSize size;
|
|
nsRect bounds;
|
|
nsIViewManager* vm;
|
|
nsIView* scrolledView;
|
|
|
|
frame->GetSize(size);
|
|
frame->GetView(&scrolledView);
|
|
scrolledView->GetBounds(bounds);
|
|
|
|
// only resize the view if things changed.
|
|
if (bounds.width != size.width || bounds.height != size.height) {
|
|
scrolledView->GetViewManager(vm);
|
|
vm->ResizeView(scrolledView, size.width, size.height);
|
|
NS_RELEASE(vm);
|
|
|
|
|
|
// Have the scrolling view layout
|
|
nsIScrollableView* scrollingView;
|
|
nsIView* view;
|
|
GetView(&view);
|
|
if (NS_SUCCEEDED(view->QueryInterface(kScrollViewIID, (void**)&scrollingView))) {
|
|
scrollingView->ComputeScrollOffsets(PR_TRUE);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsScrollPortFrame::CreateScrollingViewWidget(nsIView* aView, const nsStylePosition* aPosition)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
// If it's fixed positioned, then create a widget
|
|
if (NS_STYLE_POSITION_FIXED == aPosition->mPosition) {
|
|
rv = aView->CreateWidget(kWidgetCID);
|
|
}
|
|
|
|
return(rv);
|
|
}
|
|
|
|
nsresult
|
|
nsScrollPortFrame::GetScrollingParentView(nsIFrame* aParent, nsIView** aParentView)
|
|
{
|
|
nsresult rv = aParent->GetView(aParentView);
|
|
NS_ASSERTION(aParentView, "GetParentWithView failed");
|
|
return(rv);
|
|
}
|
|
|
|
nsresult
|
|
nsScrollPortFrame::CreateScrollingView(nsIPresContext& aPresContext)
|
|
{
|
|
nsIView* view;
|
|
|
|
//Get parent frame
|
|
nsIFrame* parent;
|
|
GetParentWithView(&parent);
|
|
NS_ASSERTION(parent, "GetParentWithView failed");
|
|
|
|
// Get parent view
|
|
nsIView* parentView = nsnull;
|
|
GetScrollingParentView(parent, &parentView);
|
|
|
|
// Get the view manager
|
|
nsIViewManager* viewManager;
|
|
parentView->GetViewManager(viewManager);
|
|
|
|
// Create the scrolling view
|
|
nsresult rv = nsComponentManager::CreateInstance(kScrollingViewCID,
|
|
nsnull,
|
|
kIViewIID,
|
|
(void **)&view);
|
|
|
|
|
|
|
|
if (NS_OK == rv) {
|
|
const nsStylePosition* position = (const nsStylePosition*)
|
|
mStyleContext->GetStyleData(eStyleStruct_Position);
|
|
const nsStyleColor* color = (const nsStyleColor*)
|
|
mStyleContext->GetStyleData(eStyleStruct_Color);
|
|
const nsStyleSpacing* spacing = (const nsStyleSpacing*)
|
|
mStyleContext->GetStyleData(eStyleStruct_Spacing);
|
|
const nsStyleDisplay* display = (const nsStyleDisplay*)
|
|
mStyleContext->GetStyleData(eStyleStruct_Display);
|
|
|
|
// Get the z-index
|
|
PRInt32 zIndex = 0;
|
|
|
|
if (eStyleUnit_Integer == position->mZIndex.GetUnit()) {
|
|
zIndex = position->mZIndex.GetIntValue();
|
|
}
|
|
|
|
// Initialize the scrolling view
|
|
view->Init(viewManager, mRect, parentView, nsnull, display->mVisible ?
|
|
nsViewVisibility_kShow : nsViewVisibility_kHide);
|
|
|
|
// Insert the view into the view hierarchy
|
|
viewManager->InsertChild(parentView, view, zIndex);
|
|
|
|
// Set the view's opacity
|
|
viewManager->SetViewOpacity(view, color->mOpacity);
|
|
|
|
// Because we only paint the border and we don't paint a background,
|
|
// inform the view manager that we have transparent content
|
|
viewManager->SetViewContentTransparency(view, PR_TRUE);
|
|
|
|
// If it's fixed positioned, then create a widget too
|
|
CreateScrollingViewWidget(view, position);
|
|
|
|
// Get the nsIScrollableView interface
|
|
nsIScrollableView* scrollingView;
|
|
view->QueryInterface(kScrollViewIID, (void**)&scrollingView);
|
|
|
|
scrollingView->SetScrollPreference(nsScrollPreference_kNeverScroll);
|
|
|
|
// Have the scrolling view create its internal widgets
|
|
scrollingView->CreateScrollControls();
|
|
|
|
// Set the scrolling view's insets to whatever our border is
|
|
nsMargin border;
|
|
if (!spacing->GetBorder(border)) {
|
|
NS_NOTYETIMPLEMENTED("percentage border");
|
|
border.SizeTo(0, 0, 0, 0);
|
|
}
|
|
scrollingView->SetControlInsets(border);
|
|
|
|
// Remember our view
|
|
SetView(view);
|
|
}
|
|
|
|
NS_RELEASE(viewManager);
|
|
return rv;
|
|
}
|
|
|
|
|
|
// Calculate the total amount of space needed for the child frame,
|
|
// including its child frames that stick outside its bounds and any
|
|
// absolutely positioned child frames.
|
|
// Updates the width/height members of the reflow metrics
|
|
nsresult
|
|
nsScrollPortFrame::CalculateChildTotalSize(nsIFrame* aKidFrame,
|
|
nsHTMLReflowMetrics& aKidReflowMetrics)
|
|
{
|
|
// If the frame has child frames that stick outside its bounds, then take
|
|
// them into account, too
|
|
nsFrameState kidState;
|
|
aKidFrame->GetFrameState(&kidState);
|
|
if (NS_FRAME_OUTSIDE_CHILDREN & kidState) {
|
|
aKidReflowMetrics.width = aKidReflowMetrics.mCombinedArea.width;
|
|
aKidReflowMetrics.height = aKidReflowMetrics.mCombinedArea.height;
|
|
}
|
|
|
|
// If it's an area frame, then get the total size which includes the
|
|
// space taken up by absolutely positioned child elements
|
|
nsIAreaFrame* areaFrame;
|
|
if (NS_SUCCEEDED(aKidFrame->QueryInterface(kAreaFrameIID, (void**)&areaFrame))) {
|
|
nscoord xMost, yMost;
|
|
|
|
areaFrame->GetPositionedInfo(xMost, yMost);
|
|
if (xMost > aKidReflowMetrics.width) {
|
|
aKidReflowMetrics.width = xMost;
|
|
}
|
|
if (yMost > aKidReflowMetrics.height) {
|
|
aKidReflowMetrics.height = yMost;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::Reflow(nsIPresContext& aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
NS_FRAME_TRACE_MSG(NS_FRAME_TRACE_CALLS,
|
|
("enter nsScrollPortFrame::Reflow: maxSize=%d,%d",
|
|
aReflowState.availableWidth,
|
|
aReflowState.availableHeight));
|
|
|
|
nsIFrame* kidFrame = mFrames.FirstChild();
|
|
nsIFrame* targetFrame;
|
|
nsIFrame* nextFrame;
|
|
|
|
// Special handling for incremental reflow
|
|
if (eReflowReason_Incremental == aReflowState.reason) {
|
|
// See whether we're the target of the reflow command
|
|
aReflowState.reflowCommand->GetTarget(targetFrame);
|
|
if (this == targetFrame) {
|
|
nsIReflowCommand::ReflowType type;
|
|
|
|
// The only type of reflow command we expect to get is a style
|
|
// change reflow command
|
|
aReflowState.reflowCommand->GetType(type);
|
|
NS_ASSERTION(nsIReflowCommand::StyleChanged == type, "unexpected reflow type");
|
|
|
|
// Make a copy of the reflow state (with a different reflow reason) and
|
|
// then recurse
|
|
nsHTMLReflowState reflowState(aReflowState);
|
|
reflowState.reason = eReflowReason_StyleChange;
|
|
reflowState.reflowCommand = nsnull;
|
|
return Reflow(aPresContext, aDesiredSize, reflowState, aStatus);
|
|
}
|
|
|
|
// Get the next frame in the reflow chain, and verify that it's our
|
|
// child frame
|
|
aReflowState.reflowCommand->GetNext(nextFrame);
|
|
NS_ASSERTION(nextFrame == kidFrame, "unexpected reflow command next-frame");
|
|
}
|
|
|
|
// Reflow the child and get its desired size. Let it be as high as it
|
|
// wants
|
|
|
|
nscoord theHeight;
|
|
nsIBox* box;
|
|
nsresult result = kidFrame->QueryInterface(kIBoxIID, (void**)&box);
|
|
if (NS_SUCCEEDED(result))
|
|
theHeight = aReflowState.mComputedHeight;
|
|
else
|
|
theHeight = NS_INTRINSICSIZE;
|
|
|
|
nsSize kidReflowSize(aReflowState.availableWidth, theHeight);
|
|
nsHTMLReflowState kidReflowState(aPresContext, aReflowState,
|
|
kidFrame, kidReflowSize);
|
|
nsHTMLReflowMetrics kidDesiredSize(aDesiredSize.maxElementSize);
|
|
|
|
/*
|
|
if (mIncremental) {
|
|
kidReflowState.reason = eReflowReason_Incremental;
|
|
mIncremental = PR_FALSE;
|
|
}
|
|
*/
|
|
|
|
kidReflowState.mComputedWidth = aReflowState.mComputedWidth;
|
|
|
|
// if the computed width is not intrinsic make sure we subtract out the child's borders.
|
|
// if (kidReflowState.mComputedWidth != NS_INTRINSICSIZE)
|
|
// kidReflowState.mComputedWidth -= aReflowState.mComputedBorderPadding.left + aReflowState.mComputedBorderPadding.right;
|
|
|
|
|
|
kidReflowState.mComputedHeight = theHeight;
|
|
|
|
//if (kidReflowState.mComputedHeight != NS_INTRINSICSIZE)
|
|
// kidReflowState.mComputedHeight -= aReflowState.mComputedBorderPadding.left + aReflowState.mComputedBorderPadding.right;
|
|
|
|
ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowState,
|
|
aStatus);
|
|
|
|
NS_ASSERTION(NS_FRAME_IS_COMPLETE(aStatus), "bad status");
|
|
CalculateChildTotalSize(kidFrame, kidDesiredSize);
|
|
|
|
|
|
// Place and size the child.
|
|
nscoord x = aReflowState.mComputedBorderPadding.left;
|
|
nscoord y = aReflowState.mComputedBorderPadding.top;
|
|
|
|
// Compute our desired size
|
|
if (aReflowState.mComputedWidth == NS_INTRINSICSIZE)
|
|
aDesiredSize.width = kidDesiredSize.width;
|
|
else
|
|
aDesiredSize.width = aReflowState.mComputedWidth;
|
|
|
|
if (aDesiredSize.width > kidDesiredSize.width)
|
|
kidDesiredSize.width = aDesiredSize.width;
|
|
|
|
aDesiredSize.width += aReflowState.mComputedBorderPadding.left + aReflowState.mComputedBorderPadding.right;
|
|
|
|
// Compute our desired size
|
|
if (aReflowState.mComputedHeight == NS_INTRINSICSIZE)
|
|
aDesiredSize.height = kidDesiredSize.height;
|
|
else
|
|
aDesiredSize.height = aReflowState.mComputedHeight;
|
|
|
|
if (aDesiredSize.height > kidDesiredSize.height)
|
|
kidDesiredSize.height = aDesiredSize.height;
|
|
|
|
aDesiredSize.height += aReflowState.mComputedBorderPadding.top + aReflowState.mComputedBorderPadding.bottom;
|
|
|
|
nsRect rect(x, y, kidDesiredSize.width, kidDesiredSize.height);
|
|
kidFrame->SetRect(rect);
|
|
|
|
if (nsnull != aDesiredSize.maxElementSize) {
|
|
nscoord maxWidth = aDesiredSize.maxElementSize->width;
|
|
maxWidth += aReflowState.mComputedBorderPadding.left + aReflowState.mComputedBorderPadding.right;
|
|
nscoord maxHeight = aDesiredSize.maxElementSize->height;
|
|
maxHeight += aReflowState.mComputedBorderPadding.top + aReflowState.mComputedBorderPadding.bottom;
|
|
aDesiredSize.maxElementSize->width = maxWidth;
|
|
aDesiredSize.maxElementSize->height = maxHeight;
|
|
}
|
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
|
aDesiredSize.descent = 0;
|
|
|
|
NS_FRAME_TRACE_MSG(NS_FRAME_TRACE_CALLS,
|
|
("exit nsScrollPortFrame::Reflow: status=%d width=%d height=%d",
|
|
aStatus, aDesiredSize.width, aDesiredSize.height));
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::Paint(nsIPresContext& aPresContext,
|
|
nsIRenderingContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsFramePaintLayer aWhichLayer)
|
|
{
|
|
if (NS_FRAME_PAINT_LAYER_BACKGROUND == aWhichLayer) {
|
|
// Only paint the border and background if we're visible
|
|
const nsStyleDisplay* display = (const nsStyleDisplay*)
|
|
mStyleContext->GetStyleData(eStyleStruct_Display);
|
|
|
|
if (display->mVisible) {
|
|
// Paint our border only (no background)
|
|
const nsStyleSpacing* spacing = (const nsStyleSpacing*)
|
|
mStyleContext->GetStyleData(eStyleStruct_Spacing);
|
|
|
|
nsRect rect(0, 0, mRect.width, mRect.height);
|
|
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
|
|
aDirtyRect, rect, *spacing, mStyleContext, 0);
|
|
}
|
|
}
|
|
|
|
// Paint our children
|
|
return nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
aWhichLayer);
|
|
}
|
|
|
|
PRIntn
|
|
nsScrollPortFrame::GetSkipSides() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::GetFrameType(nsIAtom** aType) const
|
|
{
|
|
NS_PRECONDITION(nsnull != aType, "null OUT parameter pointer");
|
|
*aType = nsLayoutAtoms::scrollFrame;
|
|
NS_ADDREF(*aType);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::GetFrameName(nsString& aResult) const
|
|
{
|
|
return MakeFrameName("Scroll", aResult);
|
|
}
|
|
|
|
/*
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::GetBoxInfo(nsIPresContext& aPresContext, const nsHTMLReflowState& aReflowState, nsBoxInfo& aSize)
|
|
{
|
|
nsresult rv;
|
|
nsIBox ibox = nsnull;
|
|
rv = mScrollAreaFrame->QueryInterface(nsIBox::GetIID(), (void**)&ibox))
|
|
ibox->GetBoxInfo(aPresContext, aReflowState, aSize);
|
|
NS_ASSERTION(NS_SUCCEEDED(rv),"Scrollport must implement box!!");
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
{
|
|
if (NULL == aInstancePtr) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
*aInstancePtr = NULL;
|
|
|
|
if (aIID.Equals(kIBoxIID)) {
|
|
*aInstancePtr = (void*)(nsIBox*) this;
|
|
NS_ADDREF_THIS();
|
|
return NS_OK;
|
|
}
|
|
|
|
return nsHTMLContainerFrame::QueryInterface(aIID, aInstancePtr);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsScrollPortFrame::Dirty(const nsHTMLReflowState& aReflowState, nsIFrame*& incrementalChild)
|
|
{
|
|
mIncrementalChild = PR_FALSE;
|
|
incrementalChild = nsnull;
|
|
|
|
nsIFrame* frame;
|
|
aReflowState.reflowCommand->GetNext(frame);
|
|
|
|
nscoord count = 0;
|
|
nsIFrame* childFrame = mFrames.FirstChild();
|
|
|
|
nsIBox* ibox;
|
|
if (NS_SUCCEEDED(childFrame->QueryInterface(nsIBox::GetIID(), (void**)&ibox)) && ibox)
|
|
ibox->Dirty(aReflowState, incrementalChild);
|
|
else
|
|
incrementalChild = frame;
|
|
|
|
// if we found a leaf. Then mark it as being incremental. So when we
|
|
// flow it we will flow it incrementally
|
|
if (incrementalChild == childFrame)
|
|
mIncrementalChild = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP_(nsrefcnt)
|
|
nsScrollPortFrame::AddRef(void)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP_(nsrefcnt)
|
|
nsScrollPortFrame::Release(void)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
*/
|
|
|