2001-09-29 00:14:13 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 18:30:37 +04:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1999-08-20 02:16:23 +04:00
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* 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/
|
1999-08-20 02:16:23 +04:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* 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.
|
1999-08-20 02:16:23 +04:00
|
|
|
*
|
1999-11-06 06:40:37 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-29 00:14:13 +04:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:40:37 +03:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* Contributor(s):
|
2004-04-18 18:30:37 +04:00
|
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
2001-09-29 00:14:13 +04:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 18:30:37 +04:00
|
|
|
* 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"),
|
2001-09-29 00:14:13 +04:00
|
|
|
* 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
|
2004-04-18 18:30:37 +04:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-29 00:14:13 +04:00
|
|
|
* 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
|
2004-04-18 18:30:37 +04:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-29 00:14:13 +04:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1999-08-20 02:16:23 +04:00
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
#include "nsHTMLParts.h"
|
2004-08-01 03:15:21 +04:00
|
|
|
#include "nsPresContext.h"
|
2005-02-08 03:59:52 +03:00
|
|
|
#include "nsReflowType.h"
|
1999-08-20 02:16:23 +04:00
|
|
|
#include "nsIDeviceContext.h"
|
|
|
|
#include "nsPageFrame.h"
|
|
|
|
#include "nsViewsCID.h"
|
2000-01-25 09:35:27 +03:00
|
|
|
#include "nsIServiceManager.h"
|
1999-08-20 02:16:23 +04:00
|
|
|
#include "nsIView.h"
|
2004-05-05 06:32:27 +04:00
|
|
|
#include "nsIScrollableView.h"
|
2004-09-05 03:03:04 +04:00
|
|
|
#include "nsIScrollable.h"
|
1999-08-20 02:16:23 +04:00
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsHTMLContainerFrame.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsGfxScrollFrame.h"
|
|
|
|
#include "nsLayoutAtoms.h"
|
|
|
|
#include "nsXULAtoms.h"
|
|
|
|
#include "nsHTMLAtoms.h"
|
|
|
|
#include "nsINameSpaceManager.h"
|
|
|
|
#include "nsISupportsArray.h"
|
|
|
|
#include "nsIDocument.h"
|
|
|
|
#include "nsIFontMetrics.h"
|
1999-10-12 04:16:06 +04:00
|
|
|
#include "nsIDocumentObserver.h"
|
|
|
|
#include "nsIDocument.h"
|
2000-03-31 11:02:06 +04:00
|
|
|
#include "nsBoxLayoutState.h"
|
2000-05-10 17:13:39 +04:00
|
|
|
#include "nsINodeInfo.h"
|
2000-07-14 03:00:59 +04:00
|
|
|
#include "nsIScrollbarFrame.h"
|
|
|
|
#include "nsIScrollbarMediator.h"
|
2002-07-27 00:57:24 +04:00
|
|
|
#include "nsITextControlFrame.h"
|
2004-09-04 07:17:18 +04:00
|
|
|
#include "nsIDOMHTMLTextAreaElement.h"
|
2004-06-25 16:26:02 +04:00
|
|
|
#include "nsNodeInfoManager.h"
|
2002-01-23 05:53:02 +03:00
|
|
|
#include "nsIURI.h"
|
2002-06-21 01:47:59 +04:00
|
|
|
#include "nsGUIEvent.h"
|
2004-06-25 16:26:02 +04:00
|
|
|
#include "nsContentCreatorFunctions.h"
|
2004-09-13 06:10:29 +04:00
|
|
|
#include "nsISupportsPrimitives.h"
|
2004-09-22 10:33:36 +04:00
|
|
|
#include "nsIPresShell.h"
|
2005-01-28 01:52:53 +03:00
|
|
|
#include "nsAutoPtr.h"
|
|
|
|
#include "nsPresState.h"
|
2004-09-01 18:58:34 +04:00
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
#include "nsIAccessibilityService.h"
|
|
|
|
#endif
|
1999-08-20 02:16:23 +04:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
2004-06-18 06:08:19 +04:00
|
|
|
//----------nsHTMLScrollFrame-------------------------------------------
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
NS_NewHTMLScrollFrame(nsIPresShell* aPresShell, nsIFrame** aNewFrame, PRBool aIsRoot)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
|
|
if (nsnull == aNewFrame) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
nsHTMLScrollFrame* it = new (aPresShell) nsHTMLScrollFrame(aPresShell, aIsRoot);
|
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
*aNewFrame = it;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsHTMLScrollFrame::nsHTMLScrollFrame(nsIPresShell* aShell, PRBool aIsRoot)
|
|
|
|
: nsBoxFrame(aShell, aIsRoot),
|
|
|
|
mInner(this)
|
|
|
|
{
|
|
|
|
SetLayoutManager(nsnull);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the view that we are scrolling within the scrolling view.
|
|
|
|
* @result child view
|
|
|
|
*/
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIFrame* nsHTMLScrollFrame::GetScrolledFrame() const
|
2004-06-18 06:08:19 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
return mInner.GetScrolledFrame();
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIScrollableView* nsHTMLScrollFrame::GetScrollableView()
|
2004-06-18 06:08:19 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
return mInner.GetScrollableView();
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
nsPoint nsHTMLScrollFrame::GetScrollPosition() const
|
2004-06-18 06:08:19 +04:00
|
|
|
{
|
|
|
|
nsIScrollableView* s = mInner.GetScrollableView();
|
2004-09-06 06:44:43 +04:00
|
|
|
nsPoint scrollPosition;
|
|
|
|
s->GetScrollPosition(scrollPosition.x, scrollPosition.y);
|
|
|
|
return scrollPosition;
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
void nsHTMLScrollFrame::ScrollTo(nsPoint aScrollPosition, PRUint32 aFlags)
|
2004-06-18 06:08:19 +04:00
|
|
|
{
|
|
|
|
nsIScrollableView* s = mInner.GetScrollableView();
|
2004-09-06 06:44:43 +04:00
|
|
|
s->ScrollTo(aScrollPosition.x, aScrollPosition.y, aFlags);
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsGfxScrollFrameInner::ScrollbarStyles
|
|
|
|
nsHTMLScrollFrame::GetScrollbarStyles() const {
|
|
|
|
return mInner.GetScrollbarStylesFromFrame();
|
|
|
|
}
|
|
|
|
|
|
|
|
nsMargin nsHTMLScrollFrame::GetDesiredScrollbarSizes(nsBoxLayoutState* aState) {
|
|
|
|
nsMargin result(0, 0, 0, 0);
|
|
|
|
|
|
|
|
if (mInner.mHScrollbarBox) {
|
|
|
|
nsSize size;
|
|
|
|
mInner.mHScrollbarBox->GetPrefSize(*aState, size);
|
|
|
|
#ifdef IBMBIDI
|
|
|
|
if (GetStyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL)
|
|
|
|
result.left = size.width;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
result.right = size.width;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mInner.mVScrollbarBox) {
|
|
|
|
nsSize size;
|
|
|
|
mInner.mVScrollbarBox->GetPrefSize(*aState, size);
|
|
|
|
// We don't currently support any scripts that would require a scrollbar
|
|
|
|
// at the top. (Are there any?)
|
|
|
|
result.bottom = size.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
void nsHTMLScrollFrame::SetScrollbarVisibility(PRBool aVerticalVisible, PRBool aHorizontalVisible)
|
2004-09-04 07:49:25 +04:00
|
|
|
{
|
|
|
|
mInner.mNeverHasVerticalScrollbar = !aVerticalVisible;
|
|
|
|
mInner.mNeverHasHorizontalScrollbar = !aHorizontalVisible;
|
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIBox* nsHTMLScrollFrame::GetScrollbarBox(PRBool aVertical)
|
2004-06-18 06:08:19 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
return aVertical ? mInner.mVScrollbarBox : mInner.mHScrollbarBox;
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2004-08-01 03:15:21 +04:00
|
|
|
nsHTMLScrollFrame::CreateAnonymousContent(nsPresContext* aPresContext,
|
2004-06-18 06:08:19 +04:00
|
|
|
nsISupportsArray& aAnonymousChildren)
|
|
|
|
{
|
|
|
|
mInner.CreateAnonymousContent(aAnonymousChildren);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2004-08-01 03:15:21 +04:00
|
|
|
nsHTMLScrollFrame::Destroy(nsPresContext* aPresContext)
|
2004-06-18 06:08:19 +04:00
|
|
|
{
|
|
|
|
nsIScrollableView *view = mInner.GetScrollableView();
|
|
|
|
NS_ASSERTION(view, "unexpected null pointer");
|
|
|
|
if (view)
|
|
|
|
view->RemoveScrollPositionListener(&mInner);
|
|
|
|
return nsBoxFrame::Destroy(aPresContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-03-31 07:40:12 +04:00
|
|
|
nsHTMLScrollFrame::
|
|
|
|
SetInitialChildList(nsPresContext* aPresContext,
|
2004-06-18 06:08:19 +04:00
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aChildList)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::SetInitialChildList(aPresContext, aListName,
|
|
|
|
aChildList);
|
2005-03-31 07:40:12 +04:00
|
|
|
mInner.CreateScrollableView();
|
2004-06-18 06:08:19 +04:00
|
|
|
mInner.ReloadChildFrames();
|
|
|
|
|
|
|
|
// listen for scroll events.
|
|
|
|
mInner.GetScrollableView()->AddScrollPositionListener(&mInner);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsHTMLScrollFrame::AppendFrames(nsIAtom* aListName,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::AppendFrames(aListName, aFrameList);
|
2004-06-18 06:08:19 +04:00
|
|
|
mInner.ReloadChildFrames();
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsHTMLScrollFrame::InsertFrames(nsIAtom* aListName,
|
|
|
|
nsIFrame* aPrevFrame,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::InsertFrames(aListName, aPrevFrame, aFrameList);
|
2004-06-18 06:08:19 +04:00
|
|
|
mInner.ReloadChildFrames();
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsHTMLScrollFrame::RemoveFrame(nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::RemoveFrame(aListName, aOldFrame);
|
2004-06-18 06:08:19 +04:00
|
|
|
mInner.ReloadChildFrames();
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsHTMLScrollFrame::ReplaceFrame(nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame,
|
|
|
|
nsIFrame* aNewFrame)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
|
2004-06-18 06:08:19 +04:00
|
|
|
mInner.ReloadChildFrames();
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLScrollFrame::GetPadding(nsMargin& aMargin)
|
|
|
|
{
|
|
|
|
aMargin.SizeTo(0,0,0,0);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRIntn
|
|
|
|
nsHTMLScrollFrame::GetSkipSides() const
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIAtom*
|
|
|
|
nsHTMLScrollFrame::GetType() const
|
|
|
|
{
|
|
|
|
return nsLayoutAtoms::scrollFrame;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLScrollFrame::GetAscent(nsBoxLayoutState& aState, nscoord& aAscent)
|
|
|
|
{
|
|
|
|
aAscent = 0;
|
2005-03-31 07:40:12 +04:00
|
|
|
if (!mInner.mScrolledFrame)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsresult rv = mInner.mScrolledFrame->GetAscent(aState, aAscent);
|
2004-06-18 06:08:19 +04:00
|
|
|
nsMargin m(0,0,0,0);
|
|
|
|
GetBorderAndPadding(m);
|
|
|
|
aAscent += m.top;
|
|
|
|
GetMargin(m);
|
|
|
|
aAscent += m.top;
|
|
|
|
GetInset(m);
|
|
|
|
aAscent += m.top;
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLScrollFrame::GetPrefSize(nsBoxLayoutState& aState, nsSize& aSize)
|
|
|
|
{
|
2004-06-19 13:07:47 +04:00
|
|
|
#ifdef DEBUG_LAYOUT
|
2004-06-18 06:08:19 +04:00
|
|
|
PropagateDebug(aState);
|
2004-06-19 13:07:47 +04:00
|
|
|
#endif
|
2004-06-18 06:08:19 +04:00
|
|
|
|
|
|
|
nsGfxScrollFrameInner::ScrollbarStyles styles = GetScrollbarStyles();
|
|
|
|
|
|
|
|
nsSize vSize(0,0);
|
|
|
|
if (mInner.mVScrollbarBox &&
|
|
|
|
styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {
|
|
|
|
mInner.mVScrollbarBox->GetPrefSize(aState, vSize);
|
|
|
|
nsBox::AddMargin(mInner.mVScrollbarBox, vSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsSize hSize(0,0);
|
|
|
|
if (mInner.mHScrollbarBox &&
|
|
|
|
styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {
|
|
|
|
mInner.mHScrollbarBox->GetPrefSize(aState, hSize);
|
|
|
|
nsBox::AddMargin(mInner.mHScrollbarBox, hSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If one of the width and height is constrained,
|
|
|
|
// do smarter preferred size checking in case the scrolled frame is a block.
|
|
|
|
//
|
|
|
|
// Details: We're going to pass our width (or height) constraint
|
|
|
|
// down to nsBoxToBlockAdaptor. Then when we call
|
2005-03-31 07:40:12 +04:00
|
|
|
// mScrolledFrame->GetPrefSize below, it will reflow the scrolled
|
2004-06-18 06:08:19 +04:00
|
|
|
// block with this width (or height) constraint, and report the resulting
|
|
|
|
// height (or width) of the block. So if possible we'll be sized exactly to the
|
|
|
|
// height (or width) of the block, which is what we want because 'overflow'
|
|
|
|
// should not affect sizing...
|
|
|
|
|
|
|
|
// Push current constraint. We'll restore it when we're done.
|
2004-06-22 06:55:04 +04:00
|
|
|
nsSize oldConstrainedSize = aState.ScrolledBlockSizeConstraint();
|
2004-06-18 06:08:19 +04:00
|
|
|
|
|
|
|
const nsHTMLReflowState* HTMLState = aState.GetReflowState();
|
|
|
|
// This stores the computed width and height, if available.
|
|
|
|
nsSize computedSize(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
|
|
|
|
// This stores the maximum width and height we can be, if available.
|
|
|
|
// This is what we use to constrain the block reflow.
|
|
|
|
nsSize computedMax(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
|
|
|
|
if (HTMLState != nsnull) {
|
|
|
|
computedSize = nsSize(HTMLState->mComputedWidth, HTMLState->mComputedHeight);
|
|
|
|
// If we know the computed size, then that's the effective maximum
|
|
|
|
computedMax = computedSize;
|
|
|
|
// One could imagine using other constraints in computedMax, but it doesn't
|
|
|
|
// really work. See bug 237622.
|
|
|
|
|
|
|
|
// Pass a constraint to the block if we have at least one constraint
|
|
|
|
// and our size is not fixed
|
|
|
|
if (((computedSize.width == NS_INTRINSICSIZE)
|
|
|
|
|| (computedSize.height == NS_INTRINSICSIZE))
|
|
|
|
&& (computedMax.width != NS_INTRINSICSIZE
|
|
|
|
|| computedMax.height != NS_INTRINSICSIZE)) {
|
|
|
|
// adjust constraints in case we have scrollbars
|
|
|
|
if (computedMax.width != NS_INTRINSICSIZE) {
|
|
|
|
computedMax.width = PR_MAX(0, computedMax.width - vSize.width);
|
|
|
|
}
|
|
|
|
if (computedMax.height != NS_INTRINSICSIZE) {
|
|
|
|
computedMax.height = PR_MAX(0, computedMax.height - hSize.height);
|
|
|
|
}
|
|
|
|
// For now, constrained height seems to just confuse things because
|
|
|
|
// various places in the block code assume constrained height => printing.
|
|
|
|
// Disable height constraint.
|
|
|
|
aState.SetScrolledBlockSizeConstraint(nsSize(computedMax.width, NS_INTRINSICSIZE));
|
|
|
|
} else {
|
|
|
|
aState.SetScrolledBlockSizeConstraint(nsSize(-1,-1));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
aState.SetScrolledBlockSizeConstraint(nsSize(-1,-1));
|
|
|
|
}
|
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
nsresult rv = mInner.mScrolledFrame->GetPrefSize(aState, aSize);
|
2004-06-18 06:08:19 +04:00
|
|
|
|
|
|
|
// Restore old constraint.
|
|
|
|
aState.SetScrolledBlockSizeConstraint(oldConstrainedSize);
|
|
|
|
|
|
|
|
// If our height is not constrained, and we will need a horizontal
|
|
|
|
// scrollbar, then add space for the scrollbar to our desired height.
|
|
|
|
if (computedSize.height == NS_INTRINSICSIZE
|
|
|
|
&& computedMax.width != NS_INTRINSICSIZE
|
|
|
|
&& aSize.width > computedMax.width
|
|
|
|
&& mInner.mHScrollbarBox
|
|
|
|
&& styles.mHorizontal == NS_STYLE_OVERFLOW_AUTO) {
|
|
|
|
// Add height of horizontal scrollbar which will be needed
|
|
|
|
mInner.mHScrollbarBox->GetPrefSize(aState, hSize);
|
|
|
|
nsBox::AddMargin(mInner.mHScrollbarBox, hSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If our width is not constrained, and we will need a vertical
|
|
|
|
// scrollbar, then add space for the scrollbar to our desired width.
|
|
|
|
if (computedSize.width == NS_INTRINSICSIZE
|
|
|
|
&& computedMax.height != NS_INTRINSICSIZE
|
|
|
|
&& aSize.height > computedMax.height
|
|
|
|
&& mInner.mVScrollbarBox
|
|
|
|
&& styles.mVertical == NS_STYLE_OVERFLOW_AUTO) {
|
|
|
|
// Add width of vertical scrollbar which will be needed
|
|
|
|
mInner.mVScrollbarBox->GetPrefSize(aState, vSize);
|
|
|
|
nsBox::AddMargin(mInner.mVScrollbarBox, vSize);
|
|
|
|
}
|
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
// Scrolled frames don't have their own margins
|
2004-06-18 06:08:19 +04:00
|
|
|
|
|
|
|
aSize.width += vSize.width;
|
|
|
|
aSize.height += hSize.height;
|
|
|
|
|
|
|
|
AddBorderAndPadding(aSize);
|
|
|
|
AddInset(aSize);
|
|
|
|
nsIBox::AddCSSPrefSize(aState, this, aSize);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLScrollFrame::GetMinSize(nsBoxLayoutState& aState, nsSize& aSize)
|
|
|
|
{
|
2004-06-19 13:07:47 +04:00
|
|
|
#ifdef DEBUG_LAYOUT
|
2004-06-18 06:08:19 +04:00
|
|
|
PropagateDebug(aState);
|
2004-06-19 13:07:47 +04:00
|
|
|
#endif
|
2004-06-18 06:08:19 +04:00
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
aSize = mInner.mScrolledFrame->GetMinSizeForScrollArea(aState);
|
2004-06-18 06:08:19 +04:00
|
|
|
|
|
|
|
nsGfxScrollFrameInner::ScrollbarStyles styles = GetScrollbarStyles();
|
|
|
|
|
|
|
|
if (mInner.mVScrollbarBox &&
|
|
|
|
styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {
|
|
|
|
nsSize vSize(0,0);
|
|
|
|
mInner.mVScrollbarBox->GetMinSize(aState, vSize);
|
|
|
|
AddMargin(mInner.mVScrollbarBox, vSize);
|
|
|
|
aSize.width += vSize.width;
|
|
|
|
if (aSize.height < vSize.height)
|
|
|
|
aSize.height = vSize.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mInner.mHScrollbarBox &&
|
|
|
|
styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {
|
|
|
|
nsSize hSize(0,0);
|
|
|
|
mInner.mHScrollbarBox->GetMinSize(aState, hSize);
|
|
|
|
AddMargin(mInner.mHScrollbarBox, hSize);
|
|
|
|
aSize.height += hSize.height;
|
|
|
|
if (aSize.width < hSize.width)
|
|
|
|
aSize.width = hSize.width;
|
|
|
|
}
|
|
|
|
|
|
|
|
AddBorderAndPadding(aSize);
|
|
|
|
AddInset(aSize);
|
|
|
|
nsIBox::AddCSSMinSize(aState, this, aSize);
|
2005-03-31 07:40:12 +04:00
|
|
|
return NS_OK;
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLScrollFrame::GetMaxSize(nsBoxLayoutState& aState, nsSize& aSize)
|
|
|
|
{
|
2004-06-19 13:07:47 +04:00
|
|
|
#ifdef DEBUG_LAYOUT
|
2004-06-18 06:08:19 +04:00
|
|
|
PropagateDebug(aState);
|
2004-06-19 13:07:47 +04:00
|
|
|
#endif
|
2004-06-18 06:08:19 +04:00
|
|
|
|
|
|
|
aSize.width = NS_INTRINSICSIZE;
|
|
|
|
aSize.height = NS_INTRINSICSIZE;
|
|
|
|
|
|
|
|
AddBorderAndPadding(aSize);
|
|
|
|
AddInset(aSize);
|
|
|
|
nsIBox::AddCSSMaxSize(aState, this, aSize);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2004-08-01 03:15:21 +04:00
|
|
|
nsHTMLScrollFrame::Reflow(nsPresContext* aPresContext,
|
2004-06-18 06:08:19 +04:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
|
|
|
DO_GLOBAL_REFLOW_COUNT("nsHTMLScrollFrame", aReflowState.reason);
|
|
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
|
|
|
|
|
|
|
// if there is a max element request then set it to -1 so we can see if it gets set
|
|
|
|
if (aDesiredSize.mComputeMEW)
|
|
|
|
{
|
|
|
|
aDesiredSize.mMaxElementWidth = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult rv = nsBoxFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
|
|
|
|
|
|
|
|
if (aDesiredSize.mComputeMEW)
|
|
|
|
{
|
2004-10-29 21:36:58 +04:00
|
|
|
nsStyleUnit widthUnit = GetStylePosition()->mWidth.GetUnit();
|
|
|
|
if (widthUnit == eStyleUnit_Percent || widthUnit == eStyleUnit_Auto) {
|
|
|
|
nsMargin border = aReflowState.mComputedBorderPadding;
|
|
|
|
aDesiredSize.mMaxElementWidth = border.right + border.left;
|
2004-06-18 06:08:19 +04:00
|
|
|
mInner.mMaxElementWidth = aDesiredSize.mMaxElementWidth;
|
2004-10-29 21:36:58 +04:00
|
|
|
} else {
|
|
|
|
// if not set then use the cached size. If set then set it.
|
|
|
|
if (aDesiredSize.mMaxElementWidth == -1)
|
|
|
|
aDesiredSize.mMaxElementWidth = mInner.mMaxElementWidth;
|
|
|
|
else
|
|
|
|
mInner.mMaxElementWidth = aDesiredSize.mMaxElementWidth;
|
|
|
|
}
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP_(nsrefcnt)
|
|
|
|
nsHTMLScrollFrame::AddRef(void)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP_(nsrefcnt)
|
|
|
|
nsHTMLScrollFrame::Release(void)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLScrollFrame::GetFrameName(nsAString& aResult) const
|
|
|
|
{
|
|
|
|
return MakeFrameName(NS_LITERAL_STRING("HTMLScroll"), aResult);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-09-01 18:58:34 +04:00
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
NS_IMETHODIMP nsHTMLScrollFrame::GetAccessible(nsIAccessible** aAccessible)
|
|
|
|
{
|
|
|
|
*aAccessible = nsnull;
|
|
|
|
if (!IsFocusable()) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
// Focusable via CSS, so needs to be in accessibility hierarchy
|
|
|
|
nsCOMPtr<nsIAccessibilityService> accService = do_GetService("@mozilla.org/accessibilityService;1");
|
|
|
|
|
|
|
|
if (accService) {
|
|
|
|
return accService->CreateHTMLGenericAccessible(NS_STATIC_CAST(nsIFrame*, this), aAccessible);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
void
|
|
|
|
nsHTMLScrollFrame::CurPosAttributeChanged(nsIContent* aChild,
|
2004-06-18 06:08:19 +04:00
|
|
|
PRInt32 aModType)
|
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
mInner.CurPosAttributeChanged(aChild, aModType);
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsHTMLScrollFrame::DoLayout(nsBoxLayoutState& aState)
|
|
|
|
{
|
2004-06-22 06:55:04 +04:00
|
|
|
PRUint32 flags = aState.LayoutFlags();
|
|
|
|
nsresult rv = mInner.Layout(aState);
|
|
|
|
aState.SetLayoutFlags(flags);
|
2004-06-18 06:08:19 +04:00
|
|
|
|
2004-06-22 06:55:04 +04:00
|
|
|
nsBox::DoLayout(aState);
|
|
|
|
return rv;
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsHTMLScrollFrame::GetContentOf(nsIContent** aContent)
|
|
|
|
{
|
|
|
|
*aContent = GetContent();
|
|
|
|
NS_IF_ADDREF(*aContent);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsHTMLScrollFrame)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIAnonymousContentCreator)
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIFrameDebug)
|
|
|
|
#endif
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIScrollableFrame)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIScrollableViewProvider)
|
2004-09-13 06:10:29 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIStatefulFrame)
|
2004-06-18 06:08:19 +04:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsBoxFrame)
|
|
|
|
|
|
|
|
//----------nsXULScrollFrame-------------------------------------------
|
|
|
|
|
1999-08-20 02:16:23 +04:00
|
|
|
nsresult
|
2004-06-18 06:08:19 +04:00
|
|
|
NS_NewXULScrollFrame(nsIPresShell* aPresShell, nsIFrame** aNewFrame, PRBool aIsRoot)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
|
|
if (nsnull == aNewFrame) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame* it = new (aPresShell) nsXULScrollFrame(aPresShell, aIsRoot);
|
1999-08-20 02:16:23 +04:00
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
*aNewFrame = it;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::nsXULScrollFrame(nsIPresShell* aShell, PRBool aIsRoot)
|
2004-05-05 06:32:27 +04:00
|
|
|
: nsBoxFrame(aShell, aIsRoot),
|
|
|
|
mInner(this)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2000-03-31 11:02:06 +04:00
|
|
|
SetLayoutManager(nsnull);
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
1999-12-07 06:36:05 +03:00
|
|
|
/**
|
|
|
|
* Get the view that we are scrolling within the scrolling view.
|
|
|
|
* @result child view
|
|
|
|
*/
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIFrame* nsXULScrollFrame::GetScrolledFrame() const
|
1999-12-07 06:36:05 +03:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
return mInner.GetScrolledFrame();
|
1999-12-07 06:36:05 +03:00
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIScrollableView* nsXULScrollFrame::GetScrollableView()
|
2000-07-27 10:57:32 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
return mInner.GetScrollableView();
|
2000-07-27 10:57:32 +04:00
|
|
|
}
|
2000-05-14 03:00:53 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
nsPoint nsXULScrollFrame::GetScrollPosition() const
|
2000-05-15 08:12:31 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIScrollableView* s = mInner.GetScrollableView();
|
|
|
|
nsPoint scrollPosition;
|
|
|
|
s->GetScrollPosition(scrollPosition.x, scrollPosition.y);
|
|
|
|
return scrollPosition;
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
void nsXULScrollFrame::ScrollTo(nsPoint aScrollPosition, PRUint32 aFlags)
|
2000-05-15 08:12:31 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIScrollableView* s = mInner.GetScrollableView();
|
|
|
|
s->ScrollTo(aScrollPosition.x, aScrollPosition.y, aFlags);
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
nsGfxScrollFrameInner::ScrollbarStyles
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetScrollbarStyles() const {
|
2004-05-05 06:32:27 +04:00
|
|
|
return mInner.GetScrollbarStylesFromFrame();
|
|
|
|
}
|
|
|
|
|
2004-06-18 06:08:19 +04:00
|
|
|
nsMargin nsXULScrollFrame::GetDesiredScrollbarSizes(nsBoxLayoutState* aState) {
|
2004-01-09 22:21:20 +03:00
|
|
|
nsMargin result(0, 0, 0, 0);
|
2003-04-22 05:33:14 +04:00
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
if (mInner.mHScrollbarBox) {
|
2004-01-09 22:21:20 +03:00
|
|
|
nsSize size;
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mHScrollbarBox->GetPrefSize(*aState, size);
|
2004-01-09 22:21:20 +03:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
if (GetStyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL)
|
|
|
|
result.left = size.width;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
result.right = size.width;
|
2001-12-18 01:51:39 +03:00
|
|
|
}
|
2000-05-15 08:12:31 +04:00
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
if (mInner.mVScrollbarBox) {
|
2004-01-09 22:21:20 +03:00
|
|
|
nsSize size;
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mVScrollbarBox->GetPrefSize(*aState, size);
|
2004-01-09 22:21:20 +03:00
|
|
|
// We don't currently support any scripts that would require a scrollbar
|
|
|
|
// at the top. (Are there any?)
|
|
|
|
result.bottom = size.height;
|
2001-12-18 01:51:39 +03:00
|
|
|
}
|
2000-05-15 08:12:31 +04:00
|
|
|
|
2004-01-09 22:21:20 +03:00
|
|
|
return result;
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
void nsXULScrollFrame::SetScrollbarVisibility(PRBool aVerticalVisible, PRBool aHorizontalVisible)
|
2004-09-04 07:49:25 +04:00
|
|
|
{
|
|
|
|
mInner.mNeverHasVerticalScrollbar = !aVerticalVisible;
|
|
|
|
mInner.mNeverHasHorizontalScrollbar = !aHorizontalVisible;
|
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
nsIBox* nsXULScrollFrame::GetScrollbarBox(PRBool aVertical)
|
2000-06-07 03:14:11 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
return aVertical ? mInner.mVScrollbarBox : mInner.mHScrollbarBox;
|
2000-06-07 03:14:11 +04:00
|
|
|
}
|
2000-05-14 03:00:53 +04:00
|
|
|
|
1999-08-20 02:16:23 +04:00
|
|
|
NS_IMETHODIMP
|
2004-08-01 03:15:21 +04:00
|
|
|
nsXULScrollFrame::CreateAnonymousContent(nsPresContext* aPresContext,
|
2000-01-22 04:16:50 +03:00
|
|
|
nsISupportsArray& aAnonymousChildren)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.CreateAnonymousContent(aAnonymousChildren);
|
1999-08-20 02:16:23 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2004-08-01 03:15:21 +04:00
|
|
|
nsXULScrollFrame::Destroy(nsPresContext* aPresContext)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2004-05-05 06:32:27 +04:00
|
|
|
nsIScrollableView *view = mInner.GetScrollableView();
|
2002-07-09 08:30:28 +04:00
|
|
|
NS_ASSERTION(view, "unexpected null pointer");
|
|
|
|
if (view)
|
2004-05-05 06:32:27 +04:00
|
|
|
view->RemoveScrollPositionListener(&mInner);
|
2000-03-31 11:02:06 +04:00
|
|
|
return nsBoxFrame::Destroy(aPresContext);
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2004-08-01 03:15:21 +04:00
|
|
|
nsXULScrollFrame::SetInitialChildList(nsPresContext* aPresContext,
|
1999-08-20 02:16:23 +04:00
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aChildList)
|
|
|
|
{
|
2000-03-31 11:02:06 +04:00
|
|
|
nsresult rv = nsBoxFrame::SetInitialChildList(aPresContext, aListName,
|
1999-08-20 02:16:23 +04:00
|
|
|
aChildList);
|
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
mInner.CreateScrollableView();
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.ReloadChildFrames();
|
1999-08-20 02:16:23 +04:00
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
// listen for scroll events.
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.GetScrollableView()->AddScrollPositionListener(&mInner);
|
1999-08-20 02:16:23 +04:00
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
return rv;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
|
1999-08-20 02:16:23 +04:00
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsXULScrollFrame::AppendFrames(nsIAtom* aListName,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::AppendFrames(aListName, aFrameList);
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.ReloadChildFrames();
|
2003-04-09 00:50:57 +04:00
|
|
|
return rv;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsXULScrollFrame::InsertFrames(nsIAtom* aListName,
|
|
|
|
nsIFrame* aPrevFrame,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::InsertFrames(aListName, aPrevFrame, aFrameList);
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.ReloadChildFrames();
|
2003-04-09 00:50:57 +04:00
|
|
|
return rv;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsXULScrollFrame::RemoveFrame(nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::RemoveFrame(aListName, aOldFrame);
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.ReloadChildFrames();
|
2003-04-09 00:50:57 +04:00
|
|
|
return rv;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2005-02-07 04:58:25 +03:00
|
|
|
nsXULScrollFrame::ReplaceFrame(nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame,
|
|
|
|
nsIFrame* aNewFrame)
|
|
|
|
{
|
|
|
|
nsresult rv = nsBoxFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.ReloadChildFrames();
|
2003-04-09 00:50:57 +04:00
|
|
|
return rv;
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
1999-08-20 02:16:23 +04:00
|
|
|
NS_IMETHODIMP
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetPadding(nsMargin& aMargin)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2000-03-31 11:02:06 +04:00
|
|
|
aMargin.SizeTo(0,0,0,0);
|
|
|
|
return NS_OK;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
PRIntn
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetSkipSides() const
|
2000-03-31 11:02:06 +04:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2003-10-31 23:19:18 +03:00
|
|
|
nsIAtom*
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetType() const
|
2000-03-31 11:02:06 +04:00
|
|
|
{
|
2003-10-31 23:19:18 +03:00
|
|
|
return nsLayoutAtoms::scrollFrame;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
NS_IMETHODIMP
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetAscent(nsBoxLayoutState& aState, nscoord& aAscent)
|
2000-05-15 08:12:31 +04:00
|
|
|
{
|
|
|
|
aAscent = 0;
|
2005-03-31 07:40:12 +04:00
|
|
|
if (!mInner.mScrolledFrame)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
nsresult rv = mInner.mScrolledFrame->GetAscent(aState, aAscent);
|
2000-05-15 08:12:31 +04:00
|
|
|
nsMargin m(0,0,0,0);
|
|
|
|
GetBorderAndPadding(m);
|
|
|
|
aAscent += m.top;
|
|
|
|
GetMargin(m);
|
|
|
|
aAscent += m.top;
|
|
|
|
GetInset(m);
|
|
|
|
aAscent += m.top;
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
NS_IMETHODIMP
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetPrefSize(nsBoxLayoutState& aState, nsSize& aSize)
|
1999-10-12 04:16:06 +04:00
|
|
|
{
|
2004-06-19 13:07:47 +04:00
|
|
|
#ifdef DEBUG_LAYOUT
|
2000-03-31 11:02:06 +04:00
|
|
|
PropagateDebug(aState);
|
2004-06-19 13:07:47 +04:00
|
|
|
#endif
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
nsGfxScrollFrameInner::ScrollbarStyles styles = GetScrollbarStyles();
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2002-10-01 05:23:47 +04:00
|
|
|
nsSize vSize(0,0);
|
2004-05-05 06:32:27 +04:00
|
|
|
if (mInner.mVScrollbarBox &&
|
2003-05-22 05:46:13 +04:00
|
|
|
styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mVScrollbarBox->GetPrefSize(aState, vSize);
|
|
|
|
nsBox::AddMargin(mInner.mVScrollbarBox, vSize);
|
2000-03-31 11:02:06 +04:00
|
|
|
}
|
|
|
|
|
2002-10-01 05:23:47 +04:00
|
|
|
nsSize hSize(0,0);
|
2004-05-05 06:32:27 +04:00
|
|
|
if (mInner.mHScrollbarBox &&
|
2003-05-22 05:46:13 +04:00
|
|
|
styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mHScrollbarBox->GetPrefSize(aState, hSize);
|
|
|
|
nsBox::AddMargin(mInner.mHScrollbarBox, hSize);
|
2002-10-01 05:23:47 +04:00
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2004-03-13 05:51:16 +03:00
|
|
|
// If one of the width and height is constrained,
|
2002-10-01 05:23:47 +04:00
|
|
|
// do smarter preferred size checking in case the scrolled frame is a block.
|
2004-03-13 05:51:16 +03:00
|
|
|
//
|
|
|
|
// Details: We're going to pass our width (or height) constraint
|
|
|
|
// down to nsBoxToBlockAdaptor. Then when we call
|
2005-03-31 07:40:12 +04:00
|
|
|
// mScrolledFrame->GetPrefSize below, it will reflow the scrolled
|
2004-03-13 05:51:16 +03:00
|
|
|
// block with this width (or height) constraint, and report the resulting
|
|
|
|
// height (or width) of the block. So if possible we'll be sized exactly to the
|
|
|
|
// height (or width) of the block, which is what we want because 'overflow'
|
|
|
|
// should not affect sizing...
|
|
|
|
|
|
|
|
// Push current constraint. We'll restore it when we're done.
|
2004-06-22 06:55:04 +04:00
|
|
|
nsSize oldConstrainedSize = aState.ScrolledBlockSizeConstraint();
|
2004-03-13 05:51:16 +03:00
|
|
|
|
2002-10-02 02:53:43 +04:00
|
|
|
const nsHTMLReflowState* HTMLState = aState.GetReflowState();
|
2004-03-13 05:51:16 +03:00
|
|
|
// This stores the computed width and height, if available.
|
2002-10-02 02:53:43 +04:00
|
|
|
nsSize computedSize(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
|
2004-03-13 05:51:16 +03:00
|
|
|
// This stores the maximum width and height we can be, if available.
|
|
|
|
// This is what we use to constrain the block reflow.
|
|
|
|
nsSize computedMax(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
|
2002-10-02 02:53:43 +04:00
|
|
|
if (HTMLState != nsnull) {
|
2004-03-13 05:51:16 +03:00
|
|
|
computedSize = nsSize(HTMLState->mComputedWidth, HTMLState->mComputedHeight);
|
|
|
|
// If we know the computed size, then that's the effective maximum
|
|
|
|
computedMax = computedSize;
|
2004-03-27 05:44:26 +03:00
|
|
|
// One could imagine using other constraints in computedMax, but it doesn't
|
|
|
|
// really work. See bug 237622.
|
|
|
|
|
2004-03-13 05:51:16 +03:00
|
|
|
// Pass a constraint to the block if we have at least one constraint
|
|
|
|
// and our size is not fixed
|
|
|
|
if (((computedSize.width == NS_INTRINSICSIZE)
|
|
|
|
|| (computedSize.height == NS_INTRINSICSIZE))
|
|
|
|
&& (computedMax.width != NS_INTRINSICSIZE
|
|
|
|
|| computedMax.height != NS_INTRINSICSIZE)) {
|
2002-10-02 02:53:43 +04:00
|
|
|
// adjust constraints in case we have scrollbars
|
2004-03-13 05:51:16 +03:00
|
|
|
if (computedMax.width != NS_INTRINSICSIZE) {
|
|
|
|
computedMax.width = PR_MAX(0, computedMax.width - vSize.width);
|
2002-10-02 02:53:43 +04:00
|
|
|
}
|
2004-03-13 05:51:16 +03:00
|
|
|
if (computedMax.height != NS_INTRINSICSIZE) {
|
|
|
|
computedMax.height = PR_MAX(0, computedMax.height - hSize.height);
|
2002-10-02 02:53:43 +04:00
|
|
|
}
|
2004-03-13 05:51:16 +03:00
|
|
|
// For now, constrained height seems to just confuse things because
|
|
|
|
// various places in the block code assume constrained height => printing.
|
|
|
|
// Disable height constraint.
|
|
|
|
aState.SetScrolledBlockSizeConstraint(nsSize(computedMax.width, NS_INTRINSICSIZE));
|
2002-10-02 02:53:43 +04:00
|
|
|
} else {
|
|
|
|
aState.SetScrolledBlockSizeConstraint(nsSize(-1,-1));
|
2002-10-01 05:23:47 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
aState.SetScrolledBlockSizeConstraint(nsSize(-1,-1));
|
2000-03-31 11:02:06 +04:00
|
|
|
}
|
2002-10-02 02:53:43 +04:00
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
nsresult rv = mInner.mScrolledFrame->GetPrefSize(aState, aSize);
|
2004-03-13 05:51:16 +03:00
|
|
|
|
|
|
|
// Restore old constraint.
|
2002-10-01 05:23:47 +04:00
|
|
|
aState.SetScrolledBlockSizeConstraint(oldConstrainedSize);
|
|
|
|
|
2004-03-13 05:51:16 +03:00
|
|
|
// If our height is not constrained, and we will need a horizontal
|
|
|
|
// scrollbar, then add space for the scrollbar to our desired height.
|
2003-05-22 05:46:13 +04:00
|
|
|
if (computedSize.height == NS_INTRINSICSIZE
|
2004-03-13 05:51:16 +03:00
|
|
|
&& computedMax.width != NS_INTRINSICSIZE
|
|
|
|
&& aSize.width > computedMax.width
|
2004-05-05 06:32:27 +04:00
|
|
|
&& mInner.mHScrollbarBox
|
2003-05-22 05:46:13 +04:00
|
|
|
&& styles.mHorizontal == NS_STYLE_OVERFLOW_AUTO) {
|
|
|
|
// Add height of horizontal scrollbar which will be needed
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mHScrollbarBox->GetPrefSize(aState, hSize);
|
|
|
|
nsBox::AddMargin(mInner.mHScrollbarBox, hSize);
|
2003-05-22 05:46:13 +04:00
|
|
|
}
|
|
|
|
|
2004-03-13 05:51:16 +03:00
|
|
|
// If our width is not constrained, and we will need a vertical
|
|
|
|
// scrollbar, then add space for the scrollbar to our desired width.
|
2003-05-22 05:46:13 +04:00
|
|
|
if (computedSize.width == NS_INTRINSICSIZE
|
2004-03-13 05:51:16 +03:00
|
|
|
&& computedMax.height != NS_INTRINSICSIZE
|
|
|
|
&& aSize.height > computedMax.height
|
2004-05-05 06:32:27 +04:00
|
|
|
&& mInner.mVScrollbarBox
|
2003-05-22 05:46:13 +04:00
|
|
|
&& styles.mVertical == NS_STYLE_OVERFLOW_AUTO) {
|
|
|
|
// Add width of vertical scrollbar which will be needed
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mVScrollbarBox->GetPrefSize(aState, vSize);
|
|
|
|
nsBox::AddMargin(mInner.mVScrollbarBox, vSize);
|
2002-10-01 05:23:47 +04:00
|
|
|
}
|
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
// scrolled frames don't have their own margins
|
2002-10-01 05:23:47 +04:00
|
|
|
|
|
|
|
aSize.width += vSize.width;
|
|
|
|
aSize.height += hSize.height;
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
AddBorderAndPadding(aSize);
|
|
|
|
AddInset(aSize);
|
|
|
|
nsIBox::AddCSSPrefSize(aState, this, aSize);
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
return rv;
|
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
NS_IMETHODIMP
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetMinSize(nsBoxLayoutState& aState, nsSize& aSize)
|
2000-03-31 11:02:06 +04:00
|
|
|
{
|
2004-06-19 13:07:47 +04:00
|
|
|
#ifdef DEBUG_LAYOUT
|
2000-03-31 11:02:06 +04:00
|
|
|
PropagateDebug(aState);
|
2004-06-19 13:07:47 +04:00
|
|
|
#endif
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
aSize = mInner.mScrolledFrame->GetMinSizeForScrollArea(aState);
|
2003-05-22 05:46:13 +04:00
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
nsGfxScrollFrameInner::ScrollbarStyles styles = GetScrollbarStyles();
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
if (mInner.mVScrollbarBox &&
|
2003-05-22 05:46:13 +04:00
|
|
|
styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {
|
2000-03-31 11:02:06 +04:00
|
|
|
nsSize vSize(0,0);
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mVScrollbarBox->GetMinSize(aState, vSize);
|
|
|
|
AddMargin(mInner.mVScrollbarBox, vSize);
|
2000-03-31 11:02:06 +04:00
|
|
|
aSize.width += vSize.width;
|
|
|
|
if (aSize.height < vSize.height)
|
|
|
|
aSize.height = vSize.height;
|
|
|
|
}
|
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
if (mInner.mHScrollbarBox &&
|
2003-05-22 05:46:13 +04:00
|
|
|
styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {
|
2000-03-31 11:02:06 +04:00
|
|
|
nsSize hSize(0,0);
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mHScrollbarBox->GetMinSize(aState, hSize);
|
|
|
|
AddMargin(mInner.mHScrollbarBox, hSize);
|
2000-03-31 11:02:06 +04:00
|
|
|
aSize.height += hSize.height;
|
|
|
|
if (aSize.width < hSize.width)
|
|
|
|
aSize.width = hSize.width;
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
AddBorderAndPadding(aSize);
|
|
|
|
AddInset(aSize);
|
|
|
|
nsIBox::AddCSSMinSize(aState, this, aSize);
|
2005-03-31 07:40:12 +04:00
|
|
|
return NS_OK;
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
1999-11-18 22:40:52 +03:00
|
|
|
NS_IMETHODIMP
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetMaxSize(nsBoxLayoutState& aState, nsSize& aSize)
|
1999-11-18 22:40:52 +03:00
|
|
|
{
|
2004-06-19 13:07:47 +04:00
|
|
|
#ifdef DEBUG_LAYOUT
|
2000-03-31 11:02:06 +04:00
|
|
|
PropagateDebug(aState);
|
2004-06-19 13:07:47 +04:00
|
|
|
#endif
|
2000-03-31 11:02:06 +04:00
|
|
|
|
|
|
|
aSize.width = NS_INTRINSICSIZE;
|
|
|
|
aSize.height = NS_INTRINSICSIZE;
|
1999-11-18 22:40:52 +03:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
AddBorderAndPadding(aSize);
|
|
|
|
AddInset(aSize);
|
|
|
|
nsIBox::AddCSSMaxSize(aState, this, aSize);
|
|
|
|
return NS_OK;
|
1999-11-18 22:40:52 +03:00
|
|
|
}
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2000-04-05 04:19:00 +04:00
|
|
|
NS_IMETHODIMP
|
2004-08-01 03:15:21 +04:00
|
|
|
nsXULScrollFrame::Reflow(nsPresContext* aPresContext,
|
2000-04-05 04:19:00 +04:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
2004-06-18 06:08:19 +04:00
|
|
|
DO_GLOBAL_REFLOW_COUNT("nsXULScrollFrame", aReflowState.reason);
|
2001-11-14 16:40:03 +03:00
|
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
2000-05-02 06:28:41 +04:00
|
|
|
|
|
|
|
// if there is a max element request then set it to -1 so we can see if it gets set
|
2003-01-09 17:26:32 +03:00
|
|
|
if (aDesiredSize.mComputeMEW)
|
2000-05-02 06:28:41 +04:00
|
|
|
{
|
2003-01-09 17:26:32 +03:00
|
|
|
aDesiredSize.mMaxElementWidth = -1;
|
2000-05-02 06:28:41 +04:00
|
|
|
}
|
|
|
|
|
2000-04-05 04:19:00 +04:00
|
|
|
nsresult rv = nsBoxFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
|
|
|
|
|
2003-01-09 17:26:32 +03:00
|
|
|
if (aDesiredSize.mComputeMEW)
|
2000-04-05 04:19:00 +04:00
|
|
|
{
|
2004-10-29 21:36:58 +04:00
|
|
|
nsStyleUnit widthUnit = GetStylePosition()->mWidth.GetUnit();
|
|
|
|
if (widthUnit == eStyleUnit_Percent || widthUnit == eStyleUnit_Auto) {
|
|
|
|
nsMargin border = aReflowState.mComputedBorderPadding;
|
|
|
|
aDesiredSize.mMaxElementWidth = border.right + border.left;
|
2004-05-05 06:32:27 +04:00
|
|
|
mInner.mMaxElementWidth = aDesiredSize.mMaxElementWidth;
|
2004-10-29 21:36:58 +04:00
|
|
|
} else {
|
|
|
|
// if not set then use the cached size. If set then set it.
|
|
|
|
if (aDesiredSize.mMaxElementWidth == -1)
|
|
|
|
aDesiredSize.mMaxElementWidth = mInner.mMaxElementWidth;
|
|
|
|
else
|
|
|
|
mInner.mMaxElementWidth = aDesiredSize.mMaxElementWidth;
|
|
|
|
}
|
2000-05-02 06:28:41 +04:00
|
|
|
}
|
|
|
|
|
2002-05-29 02:50:43 +04:00
|
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
|
2000-04-05 04:19:00 +04:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
NS_IMETHODIMP_(nsrefcnt)
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::AddRef(void)
|
1999-10-12 04:16:06 +04:00
|
|
|
{
|
2000-03-31 11:02:06 +04:00
|
|
|
return NS_OK;
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
NS_IMETHODIMP_(nsrefcnt)
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::Release(void)
|
1999-10-12 04:16:06 +04:00
|
|
|
{
|
2000-03-31 11:02:06 +04:00
|
|
|
return NS_OK;
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
1999-11-02 01:12:45 +03:00
|
|
|
#ifdef NS_DEBUG
|
1999-10-12 04:16:06 +04:00
|
|
|
NS_IMETHODIMP
|
2004-06-18 06:08:19 +04:00
|
|
|
nsXULScrollFrame::GetFrameName(nsAString& aResult) const
|
1999-10-12 04:16:06 +04:00
|
|
|
{
|
2004-06-18 06:08:19 +04:00
|
|
|
return MakeFrameName(NS_LITERAL_STRING("XULScroll"), aResult);
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
1999-11-02 01:12:45 +03:00
|
|
|
#endif
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
void nsXULScrollFrame::CurPosAttributeChanged(nsIContent* aChild, PRInt32 aModType)
|
2004-06-18 06:08:19 +04:00
|
|
|
{
|
2004-09-06 06:44:43 +04:00
|
|
|
mInner.CurPosAttributeChanged(aChild, aModType);
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULScrollFrame::DoLayout(nsBoxLayoutState& aState)
|
|
|
|
{
|
2004-06-22 06:55:04 +04:00
|
|
|
PRUint32 flags = aState.LayoutFlags();
|
|
|
|
nsresult rv = mInner.Layout(aState);
|
|
|
|
aState.SetLayoutFlags(flags);
|
2004-06-18 06:08:19 +04:00
|
|
|
|
2004-06-22 06:55:04 +04:00
|
|
|
nsBox::DoLayout(aState);
|
|
|
|
return rv;
|
2004-06-18 06:08:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsXULScrollFrame::GetContentOf(nsIContent** aContent)
|
|
|
|
{
|
|
|
|
*aContent = GetContent();
|
|
|
|
NS_IF_ADDREF(*aContent);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsXULScrollFrame)
|
2000-03-31 11:02:06 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIAnonymousContentCreator)
|
|
|
|
#ifdef NS_DEBUG
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIFrameDebug)
|
|
|
|
#endif
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIScrollableFrame)
|
2003-04-09 00:50:57 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIScrollableViewProvider)
|
2004-09-13 06:10:29 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIStatefulFrame)
|
2000-03-31 11:02:06 +04:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsBoxFrame)
|
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
|
|
|
|
|
|
|
|
//-------------------- Inner ----------------------
|
|
|
|
|
2004-06-18 06:08:19 +04:00
|
|
|
nsGfxScrollFrameInner::nsGfxScrollFrameInner(nsBoxFrame* aOuter)
|
2005-03-31 07:40:12 +04:00
|
|
|
: mScrollableView(nsnull),
|
|
|
|
mHScrollbarBox(nsnull),
|
2003-11-21 13:45:24 +03:00
|
|
|
mVScrollbarBox(nsnull),
|
2005-03-31 07:40:12 +04:00
|
|
|
mScrolledFrame(nsnull),
|
2003-11-21 13:45:24 +03:00
|
|
|
mScrollCornerBox(nsnull),
|
|
|
|
mOnePixel(20),
|
2004-01-06 02:56:00 +03:00
|
|
|
mOuter(aOuter),
|
|
|
|
mMaxElementWidth(0),
|
2004-09-13 06:10:29 +04:00
|
|
|
mRestoreRect(-1, -1, -1, -1),
|
|
|
|
mLastPos(-1, -1),
|
2004-01-06 02:56:00 +03:00
|
|
|
mLastDir(-1),
|
2004-09-04 07:17:18 +04:00
|
|
|
mNeverHasVerticalScrollbar(PR_FALSE),
|
|
|
|
mNeverHasHorizontalScrollbar(PR_FALSE),
|
2003-11-21 13:45:24 +03:00
|
|
|
mHasVerticalScrollbar(PR_FALSE),
|
2004-01-06 02:56:00 +03:00
|
|
|
mHasHorizontalScrollbar(PR_FALSE),
|
2004-05-05 06:32:27 +04:00
|
|
|
mViewInitiatedScroll(PR_FALSE),
|
2004-09-13 06:10:29 +04:00
|
|
|
mFrameInitiatedScroll(PR_FALSE),
|
2005-03-31 07:40:12 +04:00
|
|
|
mDidHistoryRestore(PR_FALSE),
|
|
|
|
mHorizontalOverflow(PR_FALSE),
|
|
|
|
mVerticalOverflow(PR_FALSE)
|
2004-05-05 06:32:27 +04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP_(nsrefcnt) nsGfxScrollFrameInner::AddRef(void)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP_(nsrefcnt) nsGfxScrollFrameInner::Release(void)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2004-05-05 08:38:12 +04:00
|
|
|
NS_IMPL_QUERY_INTERFACE1(nsGfxScrollFrameInner, nsIScrollPositionListener)
|
2004-05-05 06:32:27 +04:00
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
PRBool
|
|
|
|
nsGfxScrollFrameInner::NeedsClipWidget() const
|
|
|
|
{
|
|
|
|
// Scrollports contained in form controls (e.g., listboxes) don't get
|
|
|
|
// widgets.
|
|
|
|
for (nsIFrame* parentFrame = mOuter->GetParent(); parentFrame;
|
|
|
|
parentFrame = parentFrame->GetParent()) {
|
|
|
|
nsIFormControlFrame* fcFrame;
|
|
|
|
if ((NS_SUCCEEDED(parentFrame->QueryInterface(NS_GET_IID(nsIFormControlFrame), (void**)&fcFrame)))) {
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Scrollports that don't ever show associated scrollbars don't get
|
|
|
|
// widgets, because they will seldom actually be scrolled.
|
|
|
|
nsIScrollableFrame *scrollableFrame;
|
|
|
|
CallQueryInterface(mOuter, &scrollableFrame);
|
|
|
|
ScrollbarStyles scrollbars = scrollableFrame->GetScrollbarStyles();
|
|
|
|
if ((scrollbars.mHorizontal == NS_STYLE_OVERFLOW_HIDDEN
|
|
|
|
|| scrollbars.mHorizontal == NS_STYLE_OVERFLOW_VISIBLE)
|
|
|
|
&& (scrollbars.mVertical == NS_STYLE_OVERFLOW_HIDDEN
|
|
|
|
|| scrollbars.mVertical == NS_STYLE_OVERFLOW_VISIBLE)) {
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsGfxScrollFrameInner::GetChildContentAndOffsetsFromPoint(nsPresContext* aCX,
|
|
|
|
const nsPoint& aPoint,
|
|
|
|
nsIContent ** aNewContent,
|
|
|
|
PRInt32& aContentOffset,
|
|
|
|
PRInt32& aContentOffsetEnd,
|
|
|
|
PRBool& aBeginFrameContent)
|
|
|
|
{
|
|
|
|
// We need to overrride this to ensure that scrollbars are ignored
|
|
|
|
|
|
|
|
// Since we definitely have a view, aPoint is relative to this frame's view. We
|
|
|
|
// need to make it relative to the scrolled frame.
|
|
|
|
nsPoint point = aPoint - mScrollableView->View()->GetOffsetTo(mOuter->GetView());
|
|
|
|
|
|
|
|
return mScrolledFrame->GetContentAndOffsetsFromPoint(aCX, point, aNewContent,
|
|
|
|
aContentOffset, aContentOffsetEnd,
|
|
|
|
aBeginFrameContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::CreateScrollableView()
|
|
|
|
{
|
|
|
|
nsIView* outerView = mOuter->GetView();
|
|
|
|
NS_ASSERTION(outerView, "scrollframes must have views");
|
|
|
|
nsIViewManager* viewManager = outerView->GetViewManager();
|
|
|
|
mScrollableView = viewManager->CreateScrollableView(mOuter->GetRect(), outerView);
|
|
|
|
if (!mScrollableView)
|
|
|
|
return;
|
|
|
|
|
|
|
|
nsIView* view = mScrollableView->View();
|
|
|
|
|
|
|
|
// Insert the view into the view hierarchy
|
|
|
|
viewManager->InsertChild(outerView, view, nsnull, PR_TRUE);
|
|
|
|
|
|
|
|
// Have the scrolling view create its internal widgets
|
|
|
|
if (NeedsClipWidget()) {
|
|
|
|
mScrollableView->CreateScrollControls();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-05 03:03:04 +04:00
|
|
|
static void HandleScrollPref(nsIScrollable *aScrollable, PRInt32 aOrientation,
|
|
|
|
PRUint8& aValue)
|
|
|
|
{
|
|
|
|
PRInt32 pref;
|
|
|
|
aScrollable->GetDefaultScrollbarPreferences(aOrientation, &pref);
|
|
|
|
switch (pref) {
|
|
|
|
case nsIScrollable::Scrollbar_Auto:
|
|
|
|
// leave |aValue| untouched
|
|
|
|
break;
|
|
|
|
case nsIScrollable::Scrollbar_Never:
|
|
|
|
aValue = NS_STYLE_OVERFLOW_HIDDEN;
|
|
|
|
break;
|
|
|
|
case nsIScrollable::Scrollbar_Always:
|
|
|
|
aValue = NS_STYLE_OVERFLOW_SCROLL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
nsGfxScrollFrameInner::ScrollbarStyles
|
|
|
|
nsGfxScrollFrameInner::GetScrollbarStylesFromFrame() const
|
|
|
|
{
|
2004-09-05 03:03:04 +04:00
|
|
|
ScrollbarStyles result;
|
2004-05-05 06:32:27 +04:00
|
|
|
nsIFrame* parent = mOuter->GetParent();
|
|
|
|
if (parent && parent->GetType() == nsLayoutAtoms::viewportFrame &&
|
|
|
|
// Make sure we're actually the root scrollframe
|
|
|
|
parent->GetFirstChild(nsnull) ==
|
|
|
|
NS_STATIC_CAST(const nsIFrame*, mOuter)) {
|
2004-09-05 03:03:04 +04:00
|
|
|
nsPresContext *presContext = mOuter->GetPresContext();
|
2004-09-05 04:04:04 +04:00
|
|
|
result = presContext->GetViewportOverflowOverride();
|
2004-09-05 03:03:04 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsISupports> container = presContext->GetContainer();
|
2004-09-29 05:46:55 +04:00
|
|
|
if (container) {
|
|
|
|
nsCOMPtr<nsIScrollable> scrollable = do_QueryInterface(container);
|
|
|
|
HandleScrollPref(scrollable, nsIScrollable::ScrollOrientation_X,
|
|
|
|
result.mHorizontal);
|
|
|
|
HandleScrollPref(scrollable, nsIScrollable::ScrollOrientation_Y,
|
|
|
|
result.mVertical);
|
|
|
|
}
|
2004-05-05 06:32:27 +04:00
|
|
|
} else {
|
2004-09-05 04:04:04 +04:00
|
|
|
const nsStyleDisplay *disp = mOuter->GetStyleDisplay();
|
|
|
|
result.mHorizontal = disp->mOverflowX;
|
|
|
|
result.mVertical = disp->mOverflowY;
|
2004-05-05 06:32:27 +04:00
|
|
|
}
|
|
|
|
|
2004-09-05 03:03:04 +04:00
|
|
|
NS_ASSERTION(result.mHorizontal != NS_STYLE_OVERFLOW_VISIBLE &&
|
|
|
|
result.mHorizontal != NS_STYLE_OVERFLOW_CLIP &&
|
|
|
|
result.mVertical != NS_STYLE_OVERFLOW_VISIBLE &&
|
|
|
|
result.mVertical != NS_STYLE_OVERFLOW_CLIP,
|
|
|
|
"scrollbars should not have been created");
|
|
|
|
return result;
|
2004-08-27 05:26:55 +04:00
|
|
|
}
|
|
|
|
|
2004-09-13 06:10:29 +04:00
|
|
|
/**
|
|
|
|
* this code is resposible for restoring the scroll position back to some
|
|
|
|
* saved positon. if the user has not moved the scroll position manually
|
|
|
|
* we keep scrolling down until we get to our orignally position. keep in
|
|
|
|
* mind that content could incrementally be coming in. we only want to stop
|
|
|
|
* when we reach our new position.
|
|
|
|
*/
|
2004-07-24 01:39:47 +04:00
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::ScrollToRestoredPosition()
|
|
|
|
{
|
2004-09-13 06:10:29 +04:00
|
|
|
nsIScrollableView* scrollingView = GetScrollableView();
|
|
|
|
if (!scrollingView) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (mRestoreRect.y == -1 || mLastPos.x == -1 || mLastPos.y == -1) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// make sure our scroll position did not change for where we last put
|
|
|
|
// it. if it does then the user must have moved it, and we no longer
|
|
|
|
// need to restore.
|
|
|
|
nscoord x = 0;
|
|
|
|
nscoord y = 0;
|
|
|
|
scrollingView->GetScrollPosition(x, y);
|
|
|
|
|
|
|
|
// if we didn't move, we still need to restore
|
|
|
|
if (x == mLastPos.x && y == mLastPos.y) {
|
|
|
|
nsRect childRect(0, 0, 0, 0);
|
|
|
|
nsIView* child = nsnull;
|
|
|
|
nsresult rv = scrollingView->GetScrolledView(child);
|
|
|
|
if (NS_SUCCEEDED(rv) && child)
|
|
|
|
childRect = child->GetBounds();
|
|
|
|
|
|
|
|
PRInt32 cx, cy, x, y;
|
|
|
|
scrollingView->GetScrollPosition(cx,cy);
|
|
|
|
|
|
|
|
x = (int)
|
|
|
|
(((float)childRect.width / mRestoreRect.width) * mRestoreRect.x);
|
|
|
|
y = (int)
|
|
|
|
(((float)childRect.height / mRestoreRect.height) * mRestoreRect.y);
|
|
|
|
|
|
|
|
// if our position is greater than the scroll position, scroll.
|
|
|
|
// remember that we could be incrementally loading so we may enter
|
|
|
|
// and scroll many times.
|
|
|
|
if (y > cy || x > cx) {
|
|
|
|
scrollingView->ScrollTo(x, y, 0);
|
|
|
|
// scrollpostion goes from twips to pixels. this fixes any roundoff
|
|
|
|
// problems.
|
|
|
|
scrollingView->GetScrollPosition(mLastPos.x, mLastPos.y);
|
|
|
|
} else {
|
|
|
|
// if we reached the position then stop
|
|
|
|
mRestoreRect.y = -1;
|
|
|
|
mLastPos.x = -1;
|
|
|
|
mLastPos.y = -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// user moved the position, so we won't need to restore
|
|
|
|
mLastPos.x = -1;
|
|
|
|
mLastPos.y = -1;
|
|
|
|
}
|
2004-07-24 01:39:47 +04:00
|
|
|
}
|
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::PostScrollPortEvent(PRBool aOverflow, nsScrollPortEvent::orientType aType)
|
|
|
|
{
|
|
|
|
nsScrollPortEvent* event = new nsScrollPortEvent(aOverflow ?
|
|
|
|
NS_SCROLLPORT_OVERFLOW :
|
|
|
|
NS_SCROLLPORT_UNDERFLOW);
|
|
|
|
event->orient = aType;
|
|
|
|
mOuter->GetPresContext()->PresShell()->PostDOMEvent(mOuter->GetContent(), event);
|
|
|
|
}
|
|
|
|
|
2004-07-24 01:39:47 +04:00
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::ReloadChildFrames()
|
2004-05-05 06:32:27 +04:00
|
|
|
{
|
2005-03-31 07:40:12 +04:00
|
|
|
mScrolledFrame = nsnull;
|
2004-05-05 06:32:27 +04:00
|
|
|
mHScrollbarBox = nsnull;
|
|
|
|
mVScrollbarBox = nsnull;
|
|
|
|
mScrollCornerBox = nsnull;
|
|
|
|
|
|
|
|
nsIFrame* frame = mOuter->GetFirstChild(nsnull);
|
|
|
|
while (frame) {
|
2005-03-31 07:40:12 +04:00
|
|
|
nsIContent* content = frame->GetContent();
|
|
|
|
if (content == mOuter->GetContent()) {
|
|
|
|
NS_ASSERTION(!mScrolledFrame, "Already found the scrolled frame");
|
|
|
|
mScrolledFrame = frame;
|
|
|
|
} else {
|
|
|
|
nsAutoString value;
|
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == content->GetAttr(kNameSpaceID_None,
|
|
|
|
nsXULAtoms::orient, value)) {
|
|
|
|
// probably a scrollbar then
|
|
|
|
if (value.LowerCaseEqualsLiteral("horizontal")) {
|
|
|
|
NS_ASSERTION(!mHScrollbarBox, "Found multiple horizontal scrollbars?");
|
|
|
|
mHScrollbarBox = frame;
|
|
|
|
} else {
|
|
|
|
NS_ASSERTION(!mVScrollbarBox, "Found multiple vertical scrollbars?");
|
|
|
|
mVScrollbarBox = frame;
|
2004-05-05 06:32:27 +04:00
|
|
|
}
|
2005-03-31 07:40:12 +04:00
|
|
|
} else {
|
|
|
|
// probably a scrollcorner
|
|
|
|
NS_ASSERTION(!mScrollCornerBox, "Found multiple scrollcorners");
|
|
|
|
mScrollCornerBox = frame;
|
2004-05-05 06:32:27 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
frame = frame->GetNextSibling();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::CreateAnonymousContent(nsISupportsArray& aAnonymousChildren)
|
|
|
|
{
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* presContext = mOuter->GetPresContext();
|
2004-05-05 06:32:27 +04:00
|
|
|
nsIFrame* parent = mOuter->GetParent();
|
|
|
|
|
|
|
|
// Don't create scrollbars if we're printing/print previewing
|
|
|
|
// Get rid of this code when printing moves to its own presentation
|
|
|
|
if (presContext->IsPaginated()) {
|
|
|
|
// allow scrollbars if this is the child of the viewport, because
|
|
|
|
// we must be the scrollbars for the print preview window
|
|
|
|
if (!parent || parent->GetType() != nsLayoutAtoms::viewportFrame) {
|
2004-09-04 07:17:18 +04:00
|
|
|
mNeverHasVerticalScrollbar = mNeverHasHorizontalScrollbar = PR_TRUE;
|
2004-05-05 06:32:27 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-04 03:57:42 +04:00
|
|
|
nsIScrollableFrame *scrollable;
|
|
|
|
CallQueryInterface(mOuter, &scrollable);
|
2004-08-27 05:26:55 +04:00
|
|
|
|
2004-09-04 03:57:42 +04:00
|
|
|
ScrollbarStyles styles = scrollable->GetScrollbarStyles();
|
|
|
|
PRBool canHaveHorizontal = styles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN;
|
|
|
|
PRBool canHaveVertical = styles.mVertical != NS_STYLE_OVERFLOW_HIDDEN;
|
|
|
|
if (!canHaveHorizontal && !canHaveVertical)
|
|
|
|
// Nothing to do.
|
2004-05-05 06:32:27 +04:00
|
|
|
return;
|
2004-06-25 16:26:02 +04:00
|
|
|
|
2004-09-04 07:17:18 +04:00
|
|
|
// The anonymous <div> used by <inputs> never gets scrollbars.
|
|
|
|
nsCOMPtr<nsITextControlFrame> textFrame(do_QueryInterface(parent));
|
|
|
|
if (textFrame) {
|
|
|
|
// Make sure we are not a text area.
|
|
|
|
nsCOMPtr<nsIDOMHTMLTextAreaElement> textAreaElement(do_QueryInterface(parent->GetContent()));
|
|
|
|
if (!textAreaElement) {
|
|
|
|
mNeverHasVerticalScrollbar = mNeverHasHorizontalScrollbar = PR_TRUE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-04 03:57:42 +04:00
|
|
|
nsNodeInfoManager *nodeInfoManager =
|
|
|
|
presContext->GetDocument()->NodeInfoManager();
|
2004-05-05 06:32:27 +04:00
|
|
|
nsCOMPtr<nsINodeInfo> nodeInfo;
|
|
|
|
nodeInfoManager->GetNodeInfo(nsXULAtoms::scrollbar, nsnull,
|
|
|
|
kNameSpaceID_XUL, getter_AddRefs(nodeInfo));
|
|
|
|
|
2004-06-25 16:26:02 +04:00
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
if (canHaveHorizontal) {
|
2004-06-25 20:38:43 +04:00
|
|
|
NS_NewElement(getter_AddRefs(content), kNameSpaceID_XUL, nodeInfo);
|
2004-05-05 06:32:27 +04:00
|
|
|
content->SetAttr(kNameSpaceID_None, nsXULAtoms::orient,
|
|
|
|
NS_LITERAL_STRING("horizontal"), PR_FALSE);
|
|
|
|
aAnonymousChildren.AppendElement(content);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (canHaveVertical) {
|
2004-06-25 20:38:43 +04:00
|
|
|
NS_NewElement(getter_AddRefs(content), kNameSpaceID_XUL, nodeInfo);
|
2004-05-05 06:32:27 +04:00
|
|
|
content->SetAttr(kNameSpaceID_None, nsXULAtoms::orient,
|
|
|
|
NS_LITERAL_STRING("vertical"), PR_FALSE);
|
|
|
|
aAnonymousChildren.AppendElement(content);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (canHaveHorizontal && canHaveVertical) {
|
|
|
|
nodeInfoManager->GetNodeInfo(nsXULAtoms::scrollcorner, nsnull,
|
|
|
|
kNameSpaceID_XUL, getter_AddRefs(nodeInfo));
|
2004-06-25 20:38:43 +04:00
|
|
|
NS_NewElement(getter_AddRefs(content), kNameSpaceID_XUL, nodeInfo);
|
2004-05-05 06:32:27 +04:00
|
|
|
aAnonymousChildren.AppendElement(content);
|
|
|
|
}
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
1999-10-15 08:29:30 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsGfxScrollFrameInner::ScrollPositionWillChange(nsIScrollableView* aScrollable, nscoord aX, nscoord aY)
|
|
|
|
{
|
|
|
|
// Do nothing.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2003-04-05 15:41:19 +04:00
|
|
|
/**
|
|
|
|
* Called when someone (external or this frame) moves the scroll area.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::InternalScrollPositionDidChange(nscoord aX, nscoord aY)
|
|
|
|
{
|
|
|
|
if (mVScrollbarBox)
|
|
|
|
SetAttribute(mVScrollbarBox, nsXULAtoms::curpos, aY);
|
|
|
|
|
|
|
|
if (mHScrollbarBox)
|
|
|
|
SetAttribute(mHScrollbarBox, nsXULAtoms::curpos, aX);
|
|
|
|
}
|
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
/**
|
|
|
|
* Called if something externally moves the scroll area
|
|
|
|
* This can happen if the user pages up down or uses arrow keys
|
|
|
|
* So what we need to do up adjust the scrollbars to match.
|
|
|
|
*/
|
|
|
|
NS_IMETHODIMP
|
1999-10-15 08:29:30 +04:00
|
|
|
nsGfxScrollFrameInner::ScrollPositionDidChange(nsIScrollableView* aScrollable, nscoord aX, nscoord aY)
|
1999-10-12 04:16:06 +04:00
|
|
|
{
|
2003-04-05 15:41:19 +04:00
|
|
|
NS_ASSERTION(!mViewInitiatedScroll, "Cannot reenter ScrollPositionDidChange");
|
|
|
|
|
|
|
|
mViewInitiatedScroll = PR_TRUE;
|
|
|
|
|
|
|
|
InternalScrollPositionDidChange(aX, aY);
|
|
|
|
|
|
|
|
mViewInitiatedScroll = PR_FALSE;
|
|
|
|
|
|
|
|
return NS_OK;
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
void nsGfxScrollFrameInner::CurPosAttributeChanged(nsIContent* aContent, PRInt32 aModType)
|
1999-10-12 04:16:06 +04:00
|
|
|
{
|
2003-05-22 05:46:13 +04:00
|
|
|
NS_ASSERTION(aContent, "aContent must not be null");
|
|
|
|
|
2003-04-05 15:41:19 +04:00
|
|
|
// Attribute changes on the scrollbars happen in one of three ways:
|
|
|
|
// 1) The scrollbar changed the attribute in response to some user event
|
|
|
|
// 2) We changed the attribute in response to a ScrollPositionDidChange
|
|
|
|
// callback from the scrolling view
|
|
|
|
// 3) We changed the attribute to adjust the scrollbars for the start
|
|
|
|
// of a smooth scroll operation
|
|
|
|
//
|
|
|
|
// In case 2), we don't need to scroll the view because the scrolling
|
|
|
|
// has already happened. In case 3) we don't need to scroll because
|
|
|
|
// we're just adjusting the scrollbars back to the correct setting
|
|
|
|
// for the view.
|
|
|
|
//
|
|
|
|
// We used to detect this case implicitly because we'd compare the
|
|
|
|
// scrollbar attributes with the view's current scroll position and
|
|
|
|
// bail out if they were equal. But that approach is fragile; it can
|
|
|
|
// fail when, for example, the view scrolls horizontally and
|
|
|
|
// vertically simultaneously; we'll get here when only the vertical
|
|
|
|
// attribute has been set, so the attributes and the view scroll
|
|
|
|
// position don't yet agree, and we'd tell the view to scroll to the
|
|
|
|
// new vertical position and the old horizontal position! Even worse
|
|
|
|
// things could happen when smooth scrolling got involved ... crashes
|
|
|
|
// and other terrors.
|
2004-09-06 06:44:43 +04:00
|
|
|
if (mViewInitiatedScroll || mFrameInitiatedScroll) return;
|
2003-04-05 15:41:19 +04:00
|
|
|
|
2004-09-28 22:37:50 +04:00
|
|
|
nsIContent* vcontent = mVScrollbarBox ? mVScrollbarBox->GetContent() : nsnull;
|
|
|
|
nsIContent* hcontent = mHScrollbarBox ? mHScrollbarBox->GetContent() : nsnull;
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
if (hcontent == aContent || vcontent == aContent)
|
|
|
|
{
|
|
|
|
nscoord x = 0;
|
|
|
|
nscoord y = 0;
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
nsAutoString value;
|
|
|
|
if (hcontent && NS_CONTENT_ATTR_HAS_VALUE == hcontent->GetAttr(kNameSpaceID_None, nsXULAtoms::curpos, value))
|
|
|
|
{
|
|
|
|
PRInt32 error;
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
// convert it to an integer
|
|
|
|
x = value.ToInteger(&error);
|
|
|
|
}
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
if (vcontent && NS_CONTENT_ATTR_HAS_VALUE == vcontent->GetAttr(kNameSpaceID_None, nsXULAtoms::curpos, value))
|
|
|
|
{
|
|
|
|
PRInt32 error;
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
// convert it to an integer
|
|
|
|
y = value.ToInteger(&error);
|
|
|
|
}
|
1999-10-12 04:16:06 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
// Make sure the scrollbars indeed moved before firing the event.
|
|
|
|
// I think it is OK to prevent the call to ScrollbarChanged()
|
|
|
|
// if we didn't actually move. The following check is the first
|
|
|
|
// thing ScrollbarChanged() does anyway, before deciding to move
|
|
|
|
// the scrollbars.
|
|
|
|
nscoord curPosX=0, curPosY=0;
|
|
|
|
nsIScrollableView* s = GetScrollableView();
|
|
|
|
if (s) {
|
|
|
|
s->GetScrollPosition(curPosX, curPosY);
|
|
|
|
if ((x*mOnePixel) == curPosX && (y*mOnePixel) == curPosY)
|
|
|
|
return;
|
|
|
|
|
|
|
|
PRBool isSmooth = aContent->HasAttr(kNameSpaceID_None, nsXULAtoms::smooth);
|
2002-09-26 01:29:33 +04:00
|
|
|
|
2004-09-06 06:44:43 +04:00
|
|
|
if (isSmooth) {
|
|
|
|
// Make sure an attribute-setting callback occurs even if the view didn't actually move yet
|
|
|
|
// We need to make sure other listeners see that the scroll position is not (yet)
|
|
|
|
// what they thought it was.
|
|
|
|
s->GetScrollPosition(curPosX, curPosY);
|
|
|
|
|
|
|
|
NS_ASSERTION(!mFrameInitiatedScroll, "Unexpected reentry");
|
|
|
|
// Make sure we don't do anything in when the view calls us back for this
|
|
|
|
// scroll operation.
|
|
|
|
mFrameInitiatedScroll = PR_TRUE;
|
|
|
|
InternalScrollPositionDidChange(curPosX, curPosY);
|
|
|
|
mFrameInitiatedScroll = PR_FALSE;
|
|
|
|
}
|
|
|
|
ScrollbarChanged(mOuter->GetPresContext(), x*mOnePixel, y*mOnePixel, isSmooth ? NS_VMREFRESH_SMOOTHSCROLL : 0);
|
|
|
|
|
|
|
|
// Fire the onScroll event now that we have scrolled
|
|
|
|
nsIPresShell *presShell = mOuter->GetPresContext()->GetPresShell();
|
|
|
|
if (presShell) {
|
|
|
|
nsScrollbarEvent event(NS_SCROLL_EVENT);
|
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
|
|
// note if hcontent is non-null then hframe must be non-null.
|
|
|
|
// likewise for vcontent and vframe. Thus targetFrame will always
|
|
|
|
// be non-null in here.
|
|
|
|
nsIFrame* targetFrame =
|
2004-09-28 22:37:50 +04:00
|
|
|
hcontent == aContent ? mHScrollbarBox : mVScrollbarBox;
|
2004-09-06 06:44:43 +04:00
|
|
|
presShell->HandleEventWithTarget(&event, targetFrame,
|
|
|
|
aContent,
|
|
|
|
NS_EVENT_FLAG_INIT, &status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
PRBool
|
|
|
|
nsGfxScrollFrameInner::AddHorizontalScrollbar(nsBoxLayoutState& aState, nsRect& aScrollAreaSize, PRBool aOnTop)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2001-12-18 01:51:39 +03:00
|
|
|
if (!mHScrollbarBox)
|
|
|
|
return PR_TRUE;
|
|
|
|
|
2001-04-12 03:04:11 +04:00
|
|
|
#ifdef IBMBIDI
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleVisibility* vis = mOuter->GetStyleVisibility();
|
2001-12-18 01:51:39 +03:00
|
|
|
|
2004-01-06 02:56:00 +03:00
|
|
|
// Scroll the view horizontally if:
|
|
|
|
// 1) We are creating the scrollbar for the first time and the
|
|
|
|
// horizontal scroll position of the view is 0 or
|
|
|
|
// 2) The display direction is changed
|
|
|
|
PRBool needScroll;
|
|
|
|
if (mLastDir == -1) {
|
|
|
|
// Creating the scrollbar the first time
|
|
|
|
nscoord curPosX = 0, curPosY = 0;
|
2004-05-05 06:32:27 +04:00
|
|
|
nsIScrollableView* s = GetScrollableView();
|
2004-01-06 02:56:00 +03:00
|
|
|
if (s) {
|
|
|
|
s->GetScrollPosition(curPosX, curPosY);
|
|
|
|
}
|
|
|
|
needScroll = (curPosX == 0);
|
|
|
|
} else {
|
|
|
|
needScroll = (mLastDir != vis->mDirection);
|
|
|
|
}
|
|
|
|
if (needScroll) {
|
2001-12-18 01:51:39 +03:00
|
|
|
SetAttribute(mHScrollbarBox, nsXULAtoms::curpos,
|
|
|
|
(NS_STYLE_DIRECTION_LTR == vis->mDirection) ? 0 : 0x7FFFFFFF);
|
2001-04-12 03:04:11 +04:00
|
|
|
}
|
2004-01-06 02:56:00 +03:00
|
|
|
mLastDir = vis->mDirection;
|
2001-04-12 03:04:11 +04:00
|
|
|
#endif // IBMBIDI
|
2001-12-18 01:51:39 +03:00
|
|
|
|
|
|
|
return AddRemoveScrollbar(aState, aScrollAreaSize, aOnTop, PR_TRUE, PR_TRUE);
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
nsGfxScrollFrameInner::AddVerticalScrollbar(nsBoxLayoutState& aState, nsRect& aScrollAreaSize, PRBool aOnRight)
|
|
|
|
{
|
2001-12-18 01:51:39 +03:00
|
|
|
if (!mVScrollbarBox)
|
|
|
|
return PR_TRUE;
|
|
|
|
|
|
|
|
return AddRemoveScrollbar(aState, aScrollAreaSize, aOnRight, PR_FALSE, PR_TRUE);
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
void
|
2000-05-15 08:12:31 +04:00
|
|
|
nsGfxScrollFrameInner::RemoveHorizontalScrollbar(nsBoxLayoutState& aState, nsRect& aScrollAreaSize, PRBool aOnTop)
|
|
|
|
{
|
2004-03-11 02:52:01 +03:00
|
|
|
// removing a scrollbar should always fit
|
|
|
|
#ifdef DEBUG
|
|
|
|
PRBool result =
|
|
|
|
#endif
|
|
|
|
AddRemoveScrollbar(aState, aScrollAreaSize, aOnTop, PR_TRUE, PR_FALSE);
|
|
|
|
NS_ASSERTION(result, "Removing horizontal scrollbar failed to fit??");
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
void
|
2000-05-15 08:12:31 +04:00
|
|
|
nsGfxScrollFrameInner::RemoveVerticalScrollbar(nsBoxLayoutState& aState, nsRect& aScrollAreaSize, PRBool aOnRight)
|
|
|
|
{
|
2004-03-11 02:52:01 +03:00
|
|
|
// removing a scrollbar should always fit
|
|
|
|
#ifdef DEBUG
|
|
|
|
PRBool result =
|
|
|
|
#endif
|
|
|
|
AddRemoveScrollbar(aState, aScrollAreaSize, aOnRight, PR_FALSE, PR_FALSE);
|
|
|
|
NS_ASSERTION(result, "Removing vertical scrollbar failed to fit??");
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
nsGfxScrollFrameInner::AddRemoveScrollbar(nsBoxLayoutState& aState, nsRect& aScrollAreaSize, PRBool aOnTop, PRBool aHorizontal, PRBool aAdd)
|
|
|
|
{
|
|
|
|
if (aHorizontal) {
|
2004-09-04 07:17:18 +04:00
|
|
|
if (mNeverHasHorizontalScrollbar || !mHScrollbarBox)
|
2000-05-15 08:12:31 +04:00
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
nsSize hSize;
|
|
|
|
mHScrollbarBox->GetPrefSize(aState, hSize);
|
|
|
|
nsBox::AddMargin(mHScrollbarBox, hSize);
|
|
|
|
|
2004-01-09 22:21:20 +03:00
|
|
|
SetScrollbarVisibility(mHScrollbarBox, aAdd);
|
2000-05-15 08:12:31 +04:00
|
|
|
|
2001-12-15 02:13:08 +03:00
|
|
|
PRBool hasHorizontalScrollbar;
|
|
|
|
PRBool fit = AddRemoveScrollbar(hasHorizontalScrollbar, aScrollAreaSize.y, aScrollAreaSize.height, hSize.height, aOnTop, aAdd);
|
|
|
|
mHasHorizontalScrollbar = hasHorizontalScrollbar; // because mHasHorizontalScrollbar is a PRPackedBool
|
2000-05-15 08:12:31 +04:00
|
|
|
if (!fit)
|
|
|
|
SetScrollbarVisibility(mHScrollbarBox, !aAdd);
|
|
|
|
|
|
|
|
return fit;
|
|
|
|
} else {
|
2004-09-04 07:17:18 +04:00
|
|
|
if (mNeverHasVerticalScrollbar || !mVScrollbarBox)
|
2000-05-15 08:12:31 +04:00
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
nsSize vSize;
|
|
|
|
mVScrollbarBox->GetPrefSize(aState, vSize);
|
2004-01-09 22:21:20 +03:00
|
|
|
nsBox::AddMargin(mVScrollbarBox, vSize);
|
2000-05-15 08:12:31 +04:00
|
|
|
|
2004-01-09 22:21:20 +03:00
|
|
|
SetScrollbarVisibility(mVScrollbarBox, aAdd);
|
2000-05-15 08:12:31 +04:00
|
|
|
|
2001-12-15 02:13:08 +03:00
|
|
|
PRBool hasVerticalScrollbar;
|
|
|
|
PRBool fit = AddRemoveScrollbar(hasVerticalScrollbar, aScrollAreaSize.x, aScrollAreaSize.width, vSize.width, aOnTop, aAdd);
|
|
|
|
mHasVerticalScrollbar = hasVerticalScrollbar; // because mHasVerticalScrollbar is a PRPackedBool
|
2000-05-15 08:12:31 +04:00
|
|
|
if (!fit)
|
|
|
|
SetScrollbarVisibility(mVScrollbarBox, !aAdd);
|
|
|
|
|
|
|
|
return fit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
nsGfxScrollFrameInner::AddRemoveScrollbar(PRBool& aHasScrollbar, nscoord& aXY, nscoord& aSize, nscoord aSbSize, PRBool aRightOrBottom, PRBool aAdd)
|
|
|
|
{
|
1999-10-12 04:16:06 +04:00
|
|
|
nscoord size = aSize;
|
2004-09-27 23:21:41 +04:00
|
|
|
nscoord xy = aXY;
|
1999-10-12 04:16:06 +04:00
|
|
|
|
|
|
|
if (size != NS_INTRINSICSIZE) {
|
2000-04-03 10:26:38 +04:00
|
|
|
if (aAdd) {
|
1999-10-12 04:16:06 +04:00
|
|
|
size -= aSbSize;
|
2000-05-15 08:12:31 +04:00
|
|
|
if (!aRightOrBottom && size >= 0)
|
2004-09-27 23:21:41 +04:00
|
|
|
xy += aSbSize;
|
2000-04-03 10:26:38 +04:00
|
|
|
} else {
|
1999-10-12 04:16:06 +04:00
|
|
|
size += aSbSize;
|
2000-04-03 10:26:38 +04:00
|
|
|
if (!aRightOrBottom)
|
2004-09-27 23:21:41 +04:00
|
|
|
xy -= aSbSize;
|
2000-04-03 10:26:38 +04:00
|
|
|
}
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
// not enough room? Yes? Return true.
|
2004-09-27 23:21:41 +04:00
|
|
|
if (size >= 0) {
|
1999-10-12 04:16:06 +04:00
|
|
|
aHasScrollbar = aAdd;
|
|
|
|
aSize = size;
|
2004-09-27 23:21:41 +04:00
|
|
|
aXY = xy;
|
2000-05-15 08:12:31 +04:00
|
|
|
return PR_TRUE;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
2002-08-21 12:56:58 +04:00
|
|
|
aHasScrollbar = PR_FALSE;
|
2000-05-15 08:12:31 +04:00
|
|
|
return PR_FALSE;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2000-03-31 11:02:06 +04:00
|
|
|
nsGfxScrollFrameInner::LayoutBox(nsBoxLayoutState& aState, nsIBox* aBox, const nsRect& aRect)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2000-03-31 11:02:06 +04:00
|
|
|
return mOuter->LayoutChildAt(aState, aBox, aRect);
|
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2002-01-23 05:53:02 +03:00
|
|
|
/**
|
|
|
|
* When reflowing a HTML document where the content model is being created
|
|
|
|
* The nsGfxScrollFrame will get an Initial reflow when the body is opened by the content sink.
|
|
|
|
* But there isn't enough content to really reflow very much of the document
|
|
|
|
* so it never needs to do layout for the scrollbars
|
|
|
|
*
|
|
|
|
* So later other reflows happen and these are Incremental reflows, and then the scrollbars
|
|
|
|
* get reflowed. The important point here is that when they reflowed the ReflowState inside the
|
|
|
|
* BoxLayoutState contains an "Incremental" reason and never a "Initial" reason.
|
|
|
|
*
|
|
|
|
* When it reflows for Print Preview, the content model is already full constructed and it lays
|
|
|
|
* out the entire document at that time. When it returns back here it discovers it needs scrollbars
|
|
|
|
* and this is a problem because the ReflowState inside the BoxLayoutState still has a "Initial"
|
|
|
|
* reason and if it does a Layout it is essentially asking everything to reflow yet again with
|
|
|
|
* an "Initial" reason. This causes a lot of problems especially for tables.
|
|
|
|
*
|
|
|
|
* The solution for this is to change the ReflowState's reason from Initial to Resize and let
|
|
|
|
* all the frames do what is necessary for a resize refow. Now, we only need to do this when
|
|
|
|
* it is doing PrintPreview and we need only do it for HTML documents and NOT chrome.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::AdjustReflowStateForPrintPreview(nsBoxLayoutState& aState, PRBool& aSetBack)
|
|
|
|
{
|
|
|
|
aSetBack = PR_FALSE;
|
|
|
|
PRBool isChrome;
|
|
|
|
PRBool isInitialPP = nsBoxFrame::IsInitialReflowForPrintPreview(aState, isChrome);
|
|
|
|
if (isInitialPP && !isChrome) {
|
|
|
|
// I know you shouldn't, but we cast away the "const" here
|
|
|
|
nsHTMLReflowState* reflowState = (nsHTMLReflowState*)aState.GetReflowState();
|
|
|
|
reflowState->reason = eReflowReason_Resize;
|
|
|
|
aSetBack = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets reflow state back to Initial when we are done.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::AdjustReflowStateBack(nsBoxLayoutState& aState, PRBool aSetBack)
|
|
|
|
{
|
|
|
|
// I know you shouldn't, but we cast away the "const" here
|
|
|
|
nsHTMLReflowState* reflowState = (nsHTMLReflowState*)aState.GetReflowState();
|
|
|
|
if (aSetBack && reflowState->reason == eReflowReason_Resize) {
|
|
|
|
reflowState->reason = eReflowReason_Initial;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::LayoutScrollArea(nsBoxLayoutState& aState, const nsRect& aRect)
|
|
|
|
{
|
|
|
|
nsIView* scrollView = mScrollableView->View();
|
|
|
|
nsIViewManager* vm = scrollView->GetViewManager();
|
|
|
|
vm->MoveViewTo(scrollView, aRect.x, aRect.y);
|
|
|
|
vm->ResizeView(scrollView, nsRect(nsPoint(0, 0), aRect.Size()), PR_TRUE);
|
|
|
|
|
|
|
|
PRUint32 oldflags = aState.LayoutFlags();
|
|
|
|
// set the origin of childRect to (0,0) even though we might have borders or
|
|
|
|
// a left-hand-side scrollbar. We're going to account for that by positioning the
|
|
|
|
// anonymous mScrollableView.
|
|
|
|
nsRect childRect = nsRect(nsPoint(0, 0), aRect.Size());
|
|
|
|
PRBool isBoxWrapped = mScrolledFrame->IsBoxWrapped();
|
|
|
|
|
|
|
|
// see if our child is html. If it is then
|
|
|
|
// never include the overflow. The child will be the size
|
|
|
|
// given but its view will include the overflow size.
|
|
|
|
if (isBoxWrapped)
|
|
|
|
mScrolledFrame->SetIncludeOverflow(PR_FALSE);
|
|
|
|
|
|
|
|
PRInt32 flags = NS_FRAME_NO_MOVE_VIEW;
|
|
|
|
|
|
|
|
// if the child is not a box, then we can't use
|
|
|
|
// min size. the child technically can get as small as it wants
|
|
|
|
// to.
|
|
|
|
if (!isBoxWrapped) {
|
|
|
|
nsSize min(0,0);
|
|
|
|
mScrolledFrame->GetMinSize(aState, min);
|
|
|
|
|
|
|
|
if (min.height > childRect.height)
|
|
|
|
childRect.height = min.height;
|
|
|
|
|
|
|
|
if (min.width > childRect.width)
|
|
|
|
childRect.width = min.width;
|
|
|
|
} else {
|
|
|
|
// don't size the view if our child isn't a box
|
|
|
|
flags |= NS_FRAME_NO_SIZE_VIEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
aState.SetLayoutFlags(flags);
|
|
|
|
mScrolledFrame->SetBounds(aState, childRect);
|
|
|
|
mScrolledFrame->Layout(aState);
|
|
|
|
|
|
|
|
childRect = mScrolledFrame->GetRect();
|
|
|
|
|
|
|
|
// now size the view to the size including our overflow.
|
|
|
|
if (isBoxWrapped) {
|
|
|
|
nsSize overflow(0,0);
|
|
|
|
mScrolledFrame->GetOverflow(overflow);
|
|
|
|
childRect.width = overflow.width;
|
|
|
|
childRect.height = overflow.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (childRect.width < aRect.width || childRect.height < aRect.height)
|
|
|
|
{
|
|
|
|
childRect.width = PR_MAX(childRect.width, aRect.width);
|
|
|
|
childRect.height = PR_MAX(childRect.height, aRect.height);
|
|
|
|
|
|
|
|
// remove overflow area when we update the bounds,
|
|
|
|
// because we've already accounted for it
|
|
|
|
mScrolledFrame->SetBounds(aState, childRect, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
aState.SetLayoutFlags(oldflags);
|
|
|
|
|
|
|
|
if (isBoxWrapped) {
|
|
|
|
nsRect r(0, 0, childRect.width, childRect.height);
|
|
|
|
nsContainerFrame::SyncFrameViewAfterReflow(mScrolledFrame->GetPresContext(), mScrolledFrame,
|
|
|
|
mScrolledFrame->GetView(), &r, NS_FRAME_NO_MOVE_VIEW);
|
|
|
|
}
|
|
|
|
|
|
|
|
mScrollableView->ComputeScrollOffsets(PR_TRUE);
|
|
|
|
|
|
|
|
childRect = mScrolledFrame->GetRect();
|
|
|
|
|
|
|
|
// first see what changed
|
|
|
|
PRBool vertChanged = PR_FALSE;
|
|
|
|
PRBool horizChanged = PR_FALSE;
|
|
|
|
|
|
|
|
if (mVerticalOverflow && childRect.height <= aRect.height) {
|
|
|
|
mVerticalOverflow = PR_FALSE;
|
|
|
|
vertChanged = PR_TRUE;
|
|
|
|
} else if (childRect.height > aRect.height) {
|
|
|
|
// XXX we fire an event every time we reflow with overflowing height. Do
|
|
|
|
// we really need to?
|
|
|
|
if (!mVerticalOverflow) {
|
|
|
|
mVerticalOverflow = PR_TRUE;
|
|
|
|
}
|
|
|
|
vertChanged = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mHorizontalOverflow && childRect.width <= aRect.width) {
|
|
|
|
mHorizontalOverflow = PR_FALSE;
|
|
|
|
horizChanged = PR_TRUE;
|
|
|
|
} else if (childRect.width > aRect.width) {
|
|
|
|
// XXX we fire an event every time we reflow with overflowing width. Do
|
|
|
|
// we really need to?
|
|
|
|
if (!mHorizontalOverflow) {
|
|
|
|
mHorizontalOverflow = PR_TRUE;
|
|
|
|
}
|
|
|
|
horizChanged = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if either changed
|
|
|
|
if (vertChanged || horizChanged)
|
|
|
|
{
|
|
|
|
// are there 2 events or 1?
|
|
|
|
if (vertChanged && horizChanged) {
|
|
|
|
if (mVerticalOverflow == mHorizontalOverflow)
|
|
|
|
{
|
|
|
|
// both either overflowed or underflowed. 1 event
|
|
|
|
PostScrollPortEvent(mVerticalOverflow, nsScrollPortEvent::both);
|
|
|
|
} else {
|
|
|
|
// one overflowed and one underflowed
|
|
|
|
PostScrollPortEvent(mVerticalOverflow, nsScrollPortEvent::vertical);
|
|
|
|
PostScrollPortEvent(mHorizontalOverflow, nsScrollPortEvent::horizontal);
|
|
|
|
}
|
|
|
|
} else if (vertChanged) // only one changed either vert or horiz
|
|
|
|
PostScrollPortEvent(mVerticalOverflow, nsScrollPortEvent::vertical);
|
|
|
|
else
|
|
|
|
PostScrollPortEvent(mHorizontalOverflow, nsScrollPortEvent::horizontal);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-08-20 02:16:23 +04:00
|
|
|
/**
|
|
|
|
* Reflow the scroll area if it needs it and return its size. Also determine if the reflow will
|
|
|
|
* cause any of the scrollbars to need to be reflowed.
|
|
|
|
*/
|
2000-03-31 11:02:06 +04:00
|
|
|
nsresult
|
|
|
|
nsGfxScrollFrameInner::Layout(nsBoxLayoutState& aState)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2000-04-03 10:26:38 +04:00
|
|
|
//TODO make bidi code set these from preferences
|
|
|
|
|
|
|
|
// if true places the vertical scrollbar on the right false puts it on the left.
|
|
|
|
PRBool scrollBarRight = PR_TRUE;
|
|
|
|
|
|
|
|
// if true places the horizontal scrollbar on the bottom false puts it on the top.
|
|
|
|
PRBool scrollBarBottom = PR_TRUE;
|
|
|
|
|
2001-04-12 03:04:11 +04:00
|
|
|
#ifdef IBMBIDI
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleVisibility* vis = mOuter->GetStyleVisibility();
|
2001-06-01 02:19:43 +04:00
|
|
|
|
2001-04-12 03:04:11 +04:00
|
|
|
//
|
|
|
|
// Direction Style from this->GetStyleData()
|
2001-06-01 02:19:43 +04:00
|
|
|
// now in (vis->mDirection)
|
2001-04-12 03:04:11 +04:00
|
|
|
// ------------------
|
|
|
|
// NS_STYLE_DIRECTION_LTR : LTR or Default
|
|
|
|
// NS_STYLE_DIRECTION_RTL
|
|
|
|
// NS_STYLE_DIRECTION_INHERIT
|
|
|
|
//
|
|
|
|
|
2001-06-01 02:19:43 +04:00
|
|
|
if (vis->mDirection == NS_STYLE_DIRECTION_RTL){
|
2001-04-12 03:04:11 +04:00
|
|
|
// if true places the vertical scrollbar on the right false puts it on the left.
|
|
|
|
scrollBarRight = PR_FALSE;
|
|
|
|
|
|
|
|
// if true places the horizontal scrollbar on the bottom false puts it on the top.
|
|
|
|
scrollBarBottom = PR_TRUE;
|
|
|
|
}
|
|
|
|
nsHTMLReflowState* reflowState = (nsHTMLReflowState*)aState.GetReflowState();
|
|
|
|
#endif // IBMBIDI
|
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
// get the content rect
|
|
|
|
nsRect clientRect(0,0,0,0);
|
|
|
|
mOuter->GetClientRect(clientRect);
|
|
|
|
|
|
|
|
// the scroll area size starts off as big as our content area
|
|
|
|
nsRect scrollAreaRect(clientRect);
|
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
/**************
|
|
|
|
Our basic strategy here is to first try laying out the content with
|
|
|
|
the scrollbars in their current state. We're hoping that that will
|
|
|
|
just "work"; the content will overflow wherever there's a scrollbar
|
|
|
|
already visible. If that does work, then there's no need to lay out
|
|
|
|
the scrollarea. Otherwise we fix up the scrollbars; first we add a
|
|
|
|
vertical one to scroll the content if necessary, or remove it if
|
|
|
|
it's not needed. Then we reflow the content if the scrollbar
|
|
|
|
changed. Then we add a horizontal scrollbar if necessary (or
|
|
|
|
remove if not needed), and if that changed, we reflow the content
|
|
|
|
again. At this point, any scrollbars that are needed to scroll the
|
|
|
|
content have been added.
|
|
|
|
|
|
|
|
In the second phase we check to see if any scrollbars are too small
|
|
|
|
to display, and if so, we remove them. We check the horizontal
|
|
|
|
scrollbar first; removing it might make room for the vertical
|
|
|
|
scrollbar, and if we have room for just one scrollbar we'll save
|
|
|
|
the vertical one.
|
|
|
|
|
|
|
|
Finally we position and size the scrollbars and scrollcorner (the
|
|
|
|
square that is needed in the corner of the window when two
|
|
|
|
scrollbars are visible), and reflow any fixed position views
|
|
|
|
(if we're the viewport and we added or removed a scrollbar).
|
|
|
|
**************/
|
|
|
|
|
2004-09-04 03:57:42 +04:00
|
|
|
nsIScrollableFrame *scrollableFrame;
|
|
|
|
CallQueryInterface(mOuter, &scrollableFrame);
|
2004-06-18 06:08:19 +04:00
|
|
|
ScrollbarStyles styles = scrollableFrame->GetScrollbarStyles();
|
2003-05-22 05:46:13 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
// Look at our style do we always have vertical or horizontal scrollbars?
|
2003-05-22 05:46:13 +04:00
|
|
|
if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL)
|
2000-03-31 11:02:06 +04:00
|
|
|
mHasHorizontalScrollbar = PR_TRUE;
|
2003-05-22 05:46:13 +04:00
|
|
|
if (styles.mVertical == NS_STYLE_OVERFLOW_SCROLL)
|
2000-03-31 11:02:06 +04:00
|
|
|
mHasVerticalScrollbar = PR_TRUE;
|
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
if (mHasHorizontalScrollbar)
|
|
|
|
AddHorizontalScrollbar(aState, scrollAreaRect, scrollBarBottom);
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
if (mHasVerticalScrollbar)
|
|
|
|
AddVerticalScrollbar(aState, scrollAreaRect, scrollBarRight);
|
|
|
|
|
2005-03-31 07:40:12 +04:00
|
|
|
nsRect oldScrollAreaBounds = mScrollableView->View()->GetBounds();
|
1) implememted box reflow coelescing.
2) implemented gfx scrollbars for list boxes
3) fixed progess meter to be an animated gif
4) fixed bugs 23521, 24721, 19114, 20546, 24385, 24457, 23156, 20226, 22543
-r hyatt, troy, rod
2000-02-10 01:02:40 +03:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
// layout our the scroll area
|
2005-03-31 07:40:12 +04:00
|
|
|
LayoutScrollArea(aState, scrollAreaRect);
|
2000-03-31 11:02:06 +04:00
|
|
|
|
|
|
|
// now look at the content area and see if we need scrollbars or not
|
|
|
|
PRBool needsLayout = PR_FALSE;
|
|
|
|
nsSize scrolledContentSize(0,0);
|
|
|
|
|
|
|
|
// if we have 'auto' scrollbars look at the vertical case
|
2003-05-22 05:46:13 +04:00
|
|
|
if (styles.mVertical != NS_STYLE_OVERFLOW_SCROLL) {
|
2000-03-31 11:02:06 +04:00
|
|
|
// get the area frame is the scrollarea
|
2004-09-29 06:08:51 +04:00
|
|
|
scrolledContentSize = GetScrolledSize();
|
2000-03-31 11:02:06 +04:00
|
|
|
|
|
|
|
// There are two cases to consider
|
|
|
|
if (scrolledContentSize.height <= scrollAreaRect.height
|
2003-05-22 05:46:13 +04:00
|
|
|
|| styles.mVertical != NS_STYLE_OVERFLOW_AUTO) {
|
2000-03-31 11:02:06 +04:00
|
|
|
if (mHasVerticalScrollbar) {
|
|
|
|
// We left room for the vertical scrollbar, but it's not needed;
|
|
|
|
// remove it.
|
2004-03-11 02:52:01 +03:00
|
|
|
RemoveVerticalScrollbar(aState, scrollAreaRect, scrollBarRight);
|
|
|
|
needsLayout = PR_TRUE;
|
|
|
|
SetAttribute(mVScrollbarBox, nsXULAtoms::curpos, 0);
|
2000-03-31 11:02:06 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!mHasVerticalScrollbar) {
|
|
|
|
// We didn't leave room for the vertical scrollbar, but it turns
|
|
|
|
// out we needed it
|
2000-05-15 08:12:31 +04:00
|
|
|
if (AddVerticalScrollbar(aState, scrollAreaRect, scrollBarRight))
|
2000-03-31 11:02:06 +04:00
|
|
|
needsLayout = PR_TRUE;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
2000-03-31 11:02:06 +04:00
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
// ok layout at the right size
|
|
|
|
if (needsLayout) {
|
|
|
|
nsBoxLayoutState resizeState(aState);
|
|
|
|
resizeState.SetLayoutReason(nsBoxLayoutState::Resize);
|
2002-01-23 05:53:02 +03:00
|
|
|
PRBool setBack;
|
|
|
|
AdjustReflowStateForPrintPreview(aState, setBack);
|
2005-03-31 07:40:12 +04:00
|
|
|
LayoutScrollArea(resizeState, scrollAreaRect);
|
2002-01-23 05:53:02 +03:00
|
|
|
AdjustReflowStateBack(aState, setBack);
|
2000-05-15 08:12:31 +04:00
|
|
|
needsLayout = PR_FALSE;
|
2000-03-31 11:02:06 +04:00
|
|
|
}
|
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
// if scrollbars are auto look at the horizontal case
|
2003-05-22 05:46:13 +04:00
|
|
|
if (styles.mHorizontal != NS_STYLE_OVERFLOW_SCROLL)
|
2000-03-31 11:02:06 +04:00
|
|
|
{
|
|
|
|
// get the area frame is the scrollarea
|
2004-09-29 06:08:51 +04:00
|
|
|
scrolledContentSize = GetScrolledSize();
|
2000-03-31 11:02:06 +04:00
|
|
|
|
|
|
|
// if the child is wider that the scroll area
|
|
|
|
// and we don't have a scrollbar add one.
|
|
|
|
if (scrolledContentSize.width > scrollAreaRect.width
|
2003-05-22 05:46:13 +04:00
|
|
|
&& styles.mHorizontal == NS_STYLE_OVERFLOW_AUTO) {
|
2000-03-31 11:02:06 +04:00
|
|
|
|
|
|
|
if (!mHasHorizontalScrollbar) {
|
2000-05-15 08:12:31 +04:00
|
|
|
// no scrollbar?
|
|
|
|
if (AddHorizontalScrollbar(aState, scrollAreaRect, scrollBarBottom))
|
2000-03-31 11:02:06 +04:00
|
|
|
needsLayout = PR_TRUE;
|
2000-05-15 08:12:31 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
// if we added a horizonal scrollbar and we did not have a vertical
|
|
|
|
// there is a chance that by adding the horizonal scrollbar we will
|
|
|
|
// suddenly need a vertical scrollbar. Is a special case but its
|
|
|
|
// important.
|
2000-04-27 01:01:57 +04:00
|
|
|
//if (!mHasVerticalScrollbar && scrolledContentSize.height > scrollAreaRect.height - sbSize.height)
|
2000-10-29 02:17:53 +04:00
|
|
|
// printf("****Gfx Scrollbar Special case hit!!*****\n");
|
2000-04-03 10:26:38 +04:00
|
|
|
|
1) implememted box reflow coelescing.
2) implemented gfx scrollbars for list boxes
3) fixed progess meter to be an animated gif
4) fixed bugs 23521, 24721, 19114, 20546, 24385, 24457, 23156, 20226, 22543
-r hyatt, troy, rod
2000-02-10 01:02:40 +03:00
|
|
|
}
|
2001-04-12 03:04:11 +04:00
|
|
|
#ifdef IBMBIDI
|
2004-09-28 22:37:50 +04:00
|
|
|
const nsStyleVisibility* ourVis = mOuter->GetStyleVisibility();
|
2001-06-01 02:19:43 +04:00
|
|
|
|
|
|
|
if (NS_STYLE_DIRECTION_RTL == ourVis->mDirection) {
|
2004-06-18 06:08:19 +04:00
|
|
|
nsCOMPtr<nsITextControlFrame> textControl =
|
|
|
|
do_QueryInterface(mOuter->GetParent());
|
2001-04-12 03:04:11 +04:00
|
|
|
if (textControl) {
|
|
|
|
needsLayout = PR_TRUE;
|
|
|
|
reflowState->mRightEdge = scrolledContentSize.width;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // IBMBIDI
|
2000-03-31 11:02:06 +04:00
|
|
|
} else {
|
|
|
|
// if the area is smaller or equal to and we have a scrollbar then
|
|
|
|
// remove it.
|
1) implememted box reflow coelescing.
2) implemented gfx scrollbars for list boxes
3) fixed progess meter to be an animated gif
4) fixed bugs 23521, 24721, 19114, 20546, 24385, 24457, 23156, 20226, 22543
-r hyatt, troy, rod
2000-02-10 01:02:40 +03:00
|
|
|
if (mHasHorizontalScrollbar) {
|
2004-03-11 02:52:01 +03:00
|
|
|
RemoveHorizontalScrollbar(aState, scrollAreaRect, scrollBarBottom);
|
|
|
|
needsLayout = PR_TRUE;
|
|
|
|
SetAttribute(mHScrollbarBox, nsXULAtoms::curpos, 0);
|
2000-03-31 11:02:06 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
// we only need to set the rect. The inner child stays the same size.
|
|
|
|
if (needsLayout) {
|
|
|
|
nsBoxLayoutState resizeState(aState);
|
|
|
|
resizeState.SetLayoutReason(nsBoxLayoutState::Resize);
|
2002-01-23 05:53:02 +03:00
|
|
|
PRBool setBack;
|
|
|
|
AdjustReflowStateForPrintPreview(aState, setBack);
|
2005-03-31 07:40:12 +04:00
|
|
|
LayoutScrollArea(resizeState, scrollAreaRect);
|
2002-01-23 05:53:02 +03:00
|
|
|
AdjustReflowStateBack(aState, setBack);
|
2000-05-15 08:12:31 +04:00
|
|
|
needsLayout = PR_FALSE;
|
2001-04-12 03:04:11 +04:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
reflowState->mRightEdge = NS_UNCONSTRAINEDSIZE;
|
|
|
|
#endif // IBMBIDI
|
1999-11-19 18:33:29 +03:00
|
|
|
}
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-09-29 06:08:51 +04:00
|
|
|
scrolledContentSize = GetScrolledSize();
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* presContext = aState.PresContext();
|
2004-07-29 23:41:39 +04:00
|
|
|
mOnePixel = presContext->IntScaledPixelsToTwips(1);
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleFont* font = mOuter->GetStyleFont();
|
2000-03-31 11:02:06 +04:00
|
|
|
const nsFont& f = font->mFont;
|
2004-07-29 23:41:39 +04:00
|
|
|
nsCOMPtr<nsIFontMetrics> fm = presContext->GetMetricsFor(f);
|
2000-03-31 11:02:06 +04:00
|
|
|
nscoord fontHeight = 1;
|
2001-05-15 07:12:08 +04:00
|
|
|
NS_ASSERTION(fm,"FontMetrics is null assuming fontHeight == 1");
|
|
|
|
if (fm)
|
|
|
|
fm->GetHeight(fontHeight);
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
// get the preferred size of the scrollbars
|
|
|
|
nsSize hSize(0,0);
|
|
|
|
nsSize vSize(0,0);
|
|
|
|
nsSize hMinSize(0,0);
|
|
|
|
nsSize vMinSize(0,0);
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
if (mHScrollbarBox && mHasHorizontalScrollbar) {
|
2000-08-04 02:42:36 +04:00
|
|
|
mHScrollbarBox->GetPrefSize(aState, hSize);
|
2004-03-11 02:52:01 +03:00
|
|
|
mHScrollbarBox->GetMinSize(aState, hMinSize);
|
|
|
|
nsBox::AddMargin(mHScrollbarBox, hSize);
|
|
|
|
nsBox::AddMargin(mHScrollbarBox, hMinSize);
|
|
|
|
}
|
|
|
|
if (mVScrollbarBox && mHasVerticalScrollbar) {
|
2000-08-04 02:42:36 +04:00
|
|
|
mVScrollbarBox->GetPrefSize(aState, vSize);
|
2004-03-11 02:52:01 +03:00
|
|
|
mVScrollbarBox->GetMinSize(aState, vMinSize);
|
|
|
|
nsBox::AddMargin(mVScrollbarBox, vSize);
|
|
|
|
nsBox::AddMargin(mVScrollbarBox, vMinSize);
|
|
|
|
}
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
// Disable scrollbars that are too small
|
|
|
|
// Disable horizontal scrollbar first. If we have to disable only one
|
|
|
|
// scrollbar, we'd rather keep the vertical scrollbar.
|
2004-03-12 06:35:53 +03:00
|
|
|
// Note that we always give horizontal scrollbars their preferred height,
|
|
|
|
// never their min-height. So check that there's room for the preferred height.
|
2004-03-11 02:52:01 +03:00
|
|
|
if (mHasHorizontalScrollbar &&
|
|
|
|
(hMinSize.width > clientRect.width - vSize.width
|
2004-03-12 06:35:53 +03:00
|
|
|
|| hSize.height > clientRect.height)) {
|
2004-03-11 02:52:01 +03:00
|
|
|
RemoveHorizontalScrollbar(aState, scrollAreaRect, scrollBarBottom);
|
|
|
|
needsLayout = PR_TRUE;
|
|
|
|
SetAttribute(mHScrollbarBox, nsXULAtoms::curpos, 0);
|
|
|
|
// set the scrollbar to zero height to make it go away
|
|
|
|
hSize.height = 0;
|
|
|
|
hMinSize.height = 0;
|
|
|
|
}
|
|
|
|
// Now disable vertical scrollbar if necessary
|
|
|
|
if (mHasVerticalScrollbar &&
|
|
|
|
(vMinSize.height > clientRect.height - hSize.height
|
2004-03-12 06:35:53 +03:00
|
|
|
|| vSize.width > clientRect.width)) {
|
2004-03-11 02:52:01 +03:00
|
|
|
RemoveVerticalScrollbar(aState, scrollAreaRect, scrollBarRight);
|
|
|
|
needsLayout = PR_TRUE;
|
|
|
|
SetAttribute(mVScrollbarBox, nsXULAtoms::curpos, 0);
|
|
|
|
// set the scrollbar to zero width to make it go away
|
|
|
|
vSize.width = 0;
|
|
|
|
vMinSize.width = 0;
|
2000-04-25 11:10:48 +04:00
|
|
|
}
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
nscoord maxX = scrolledContentSize.width - scrollAreaRect.width;
|
|
|
|
nscoord maxY = scrolledContentSize.height - scrollAreaRect.height;
|
2000-04-03 10:26:38 +04:00
|
|
|
|
2004-05-05 06:32:27 +04:00
|
|
|
nsIScrollableView* scrollable = GetScrollableView();
|
2004-03-11 02:52:01 +03:00
|
|
|
scrollable->SetLineHeight(fontHeight);
|
2000-03-31 11:02:06 +04:00
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
if (mVScrollbarBox) {
|
2004-09-22 10:33:36 +04:00
|
|
|
SetScrollbarEnabled(mVScrollbarBox, maxY);
|
2000-04-25 11:10:48 +04:00
|
|
|
SetAttribute(mVScrollbarBox, nsXULAtoms::maxpos, maxY);
|
|
|
|
SetAttribute(mVScrollbarBox, nsXULAtoms::pageincrement, nscoord(scrollAreaRect.height - fontHeight));
|
2002-09-19 02:38:23 +04:00
|
|
|
SetAttribute(mVScrollbarBox, nsXULAtoms::increment, fontHeight);
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
nsRect vRect(scrollAreaRect);
|
|
|
|
vRect.width = vSize.width;
|
|
|
|
vRect.x = scrollBarRight ? scrollAreaRect.XMost() : clientRect.x;
|
|
|
|
nsMargin margin;
|
|
|
|
mVScrollbarBox->GetMargin(margin);
|
|
|
|
vRect.Deflate(margin);
|
2000-08-04 02:42:36 +04:00
|
|
|
LayoutBox(aState, mVScrollbarBox, vRect);
|
|
|
|
}
|
2004-03-11 02:52:01 +03:00
|
|
|
|
|
|
|
if (mHScrollbarBox) {
|
2004-09-22 10:33:36 +04:00
|
|
|
SetScrollbarEnabled(mHScrollbarBox, maxX);
|
2000-04-25 11:10:48 +04:00
|
|
|
SetAttribute(mHScrollbarBox, nsXULAtoms::maxpos, maxX);
|
|
|
|
SetAttribute(mHScrollbarBox, nsXULAtoms::pageincrement, nscoord(float(scrollAreaRect.width)*0.8));
|
2002-09-20 18:50:43 +04:00
|
|
|
SetAttribute(mHScrollbarBox, nsXULAtoms::increment, 10*mOnePixel);
|
2000-04-25 11:10:48 +04:00
|
|
|
|
2004-03-11 02:52:01 +03:00
|
|
|
nsRect hRect(scrollAreaRect);
|
|
|
|
hRect.height = hSize.height;
|
|
|
|
hRect.y = scrollBarBottom ? scrollAreaRect.YMost() : clientRect.y;
|
|
|
|
nsMargin margin;
|
|
|
|
mHScrollbarBox->GetMargin(margin);
|
|
|
|
hRect.Deflate(margin);
|
2000-08-04 02:42:36 +04:00
|
|
|
LayoutBox(aState, mHScrollbarBox, hRect);
|
2000-04-25 11:10:48 +04:00
|
|
|
}
|
2000-05-15 08:12:31 +04:00
|
|
|
|
|
|
|
// we only need to set the rect. The inner child stays the same size.
|
|
|
|
if (needsLayout) {
|
|
|
|
nsBoxLayoutState resizeState(aState);
|
|
|
|
resizeState.SetLayoutReason(nsBoxLayoutState::Resize);
|
2005-03-31 07:40:12 +04:00
|
|
|
LayoutScrollArea(resizeState, scrollAreaRect);
|
2000-05-15 08:12:31 +04:00
|
|
|
needsLayout = PR_FALSE;
|
|
|
|
}
|
|
|
|
|
2003-11-21 13:45:24 +03:00
|
|
|
// place the scrollcorner
|
|
|
|
if (mScrollCornerBox) {
|
|
|
|
nsRect r(0, 0, 0, 0);
|
|
|
|
if (clientRect.x != scrollAreaRect.x) {
|
|
|
|
// scrollbar (if any) on left
|
|
|
|
r.x = clientRect.x;
|
|
|
|
r.width = scrollAreaRect.x - clientRect.x;
|
|
|
|
NS_ASSERTION(r.width >= 0, "Scroll area should be inside client rect");
|
|
|
|
} else {
|
|
|
|
// scrollbar (if any) on right
|
|
|
|
r.x = scrollAreaRect.XMost();
|
|
|
|
r.width = clientRect.XMost() - scrollAreaRect.XMost();
|
|
|
|
NS_ASSERTION(r.width >= 0, "Scroll area should be inside client rect");
|
|
|
|
}
|
|
|
|
if (clientRect.y != scrollAreaRect.y) {
|
|
|
|
// scrollbar (if any) on top
|
|
|
|
r.y = clientRect.y;
|
|
|
|
r.height = scrollAreaRect.y - clientRect.y;
|
|
|
|
NS_ASSERTION(r.height >= 0, "Scroll area should be inside client rect");
|
|
|
|
} else {
|
|
|
|
// scrollbar (if any) on bottom
|
|
|
|
r.y = scrollAreaRect.YMost();
|
|
|
|
r.height = clientRect.YMost() - scrollAreaRect.YMost();
|
|
|
|
NS_ASSERTION(r.height >= 0, "Scroll area should be inside client rect");
|
|
|
|
}
|
|
|
|
LayoutBox(aState, mScrollCornerBox, r);
|
|
|
|
}
|
|
|
|
|
2001-04-17 05:45:38 +04:00
|
|
|
// may need to update fixed position children of the viewport,
|
|
|
|
// if the client area changed size because of some dirty reflow
|
|
|
|
// (if the reflow is initial or resize, the fixed children will
|
|
|
|
// be re-laid out anyway)
|
|
|
|
if ((oldScrollAreaBounds.width != scrollAreaRect.width
|
|
|
|
|| oldScrollAreaBounds.height != scrollAreaRect.height)
|
2004-06-22 06:55:04 +04:00
|
|
|
&& nsBoxLayoutState::Dirty == aState.LayoutReason()) {
|
2003-06-29 07:43:05 +04:00
|
|
|
nsIFrame* parentFrame = mOuter->GetParent();
|
2001-04-17 05:45:38 +04:00
|
|
|
if (parentFrame) {
|
2003-10-31 23:19:18 +03:00
|
|
|
if (parentFrame->GetType() == nsLayoutAtoms::viewportFrame) {
|
2001-04-17 05:45:38 +04:00
|
|
|
// Usually there are no fixed children, so don't do anything unless there's
|
|
|
|
// at least one fixed child
|
2004-01-09 17:20:53 +03:00
|
|
|
if (parentFrame->GetFirstChild(nsLayoutAtoms::fixedList)) {
|
2001-04-17 05:45:38 +04:00
|
|
|
// force a reflow of the fixed children
|
2005-02-08 03:59:52 +03:00
|
|
|
mOuter->GetPresContext()->PresShell()->
|
|
|
|
AppendReflowCommand(parentFrame, eReflowType_UserDefined,
|
|
|
|
nsLayoutAtoms::fixedList);
|
2001-04-17 05:45:38 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2000-04-25 11:10:48 +04:00
|
|
|
|
2004-09-13 06:10:29 +04:00
|
|
|
ScrollToRestoredPosition();
|
|
|
|
|
2000-04-25 11:10:48 +04:00
|
|
|
return NS_OK;
|
2001-04-17 05:45:38 +04:00
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
|
|
|
void
|
2004-08-01 03:15:21 +04:00
|
|
|
nsGfxScrollFrameInner::ScrollbarChanged(nsPresContext* aPresContext, nscoord aX, nscoord aY, PRUint32 aFlags)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2004-05-05 06:32:27 +04:00
|
|
|
nsIScrollableView* scrollable = GetScrollableView();
|
2003-03-24 08:29:45 +03:00
|
|
|
scrollable->ScrollTo(aX, aY, aFlags);
|
2000-10-29 02:17:53 +04:00
|
|
|
// printf("scrolling to: %d, %d\n", aX, aY);
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
2004-09-22 10:33:36 +04:00
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::SetScrollbarEnabled(nsIBox* aBox, nscoord aMaxPos, PRBool aReflow)
|
|
|
|
{
|
|
|
|
mOuter->GetPresContext()->PresShell()->PostAttributeChange(
|
2004-09-28 22:37:50 +04:00
|
|
|
aBox->GetContent(),
|
2004-09-22 10:33:36 +04:00
|
|
|
kNameSpaceID_None,
|
|
|
|
nsHTMLAtoms::disabled,
|
|
|
|
NS_LITERAL_STRING("true"),
|
|
|
|
aReflow,
|
|
|
|
aMaxPos ? eChangeType_Remove : eChangeType_Set);
|
|
|
|
}
|
|
|
|
|
1) implememted box reflow coelescing.
2) implemented gfx scrollbars for list boxes
3) fixed progess meter to be an animated gif
4) fixed bugs 23521, 24721, 19114, 20546, 24385, 24457, 23156, 20226, 22543
-r hyatt, troy, rod
2000-02-10 01:02:40 +03:00
|
|
|
/**
|
|
|
|
* Returns whether it actually needed to change the attribute
|
|
|
|
*/
|
|
|
|
PRBool
|
2000-03-31 11:02:06 +04:00
|
|
|
nsGfxScrollFrameInner::SetAttribute(nsIBox* aBox, nsIAtom* aAtom, nscoord aSize, PRBool aReflow)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
|
|
|
// convert to pixels
|
|
|
|
aSize /= mOnePixel;
|
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
// only set the attribute if it changed.
|
1999-08-20 02:16:23 +04:00
|
|
|
|
2000-03-31 11:02:06 +04:00
|
|
|
PRInt32 current = GetIntegerAttribute(aBox, aAtom, -1);
|
1999-10-12 04:16:06 +04:00
|
|
|
if (current != aSize)
|
|
|
|
{
|
2001-08-02 16:12:53 +04:00
|
|
|
nsAutoString newValue;
|
|
|
|
newValue.AppendInt(aSize);
|
2004-09-28 22:37:50 +04:00
|
|
|
aBox->GetContent()->SetAttr(kNameSpaceID_None, aAtom, newValue, aReflow);
|
1) implememted box reflow coelescing.
2) implemented gfx scrollbars for list boxes
3) fixed progess meter to be an animated gif
4) fixed bugs 23521, 24721, 19114, 20546, 24385, 24457, 23156, 20226, 22543
-r hyatt, troy, rod
2000-02-10 01:02:40 +03:00
|
|
|
return PR_TRUE;
|
1999-10-12 04:16:06 +04:00
|
|
|
}
|
1) implememted box reflow coelescing.
2) implemented gfx scrollbars for list boxes
3) fixed progess meter to be an animated gif
4) fixed bugs 23521, 24721, 19114, 20546, 24385, 24457, 23156, 20226, 22543
-r hyatt, troy, rod
2000-02-10 01:02:40 +03:00
|
|
|
|
|
|
|
return PR_FALSE;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
|
|
|
|
2004-09-29 06:08:51 +04:00
|
|
|
nsSize
|
|
|
|
nsGfxScrollFrameInner::GetScrolledSize() const
|
2000-07-08 02:24:06 +04:00
|
|
|
{
|
2005-03-31 07:40:12 +04:00
|
|
|
nsRect r = mScrolledFrame->GetOverflowRect();
|
|
|
|
return nsSize(r.XMost(), r.YMost());
|
2004-09-29 06:08:51 +04:00
|
|
|
}
|
2000-07-08 02:24:06 +04:00
|
|
|
|
2004-09-29 06:08:51 +04:00
|
|
|
nsMargin
|
|
|
|
nsGfxScrollFrameInner::GetActualScrollbarSizes() const {
|
|
|
|
nsRect contentRect;
|
|
|
|
mOuter->GetClientRect(contentRect);
|
2005-03-31 07:40:12 +04:00
|
|
|
nsRect scrollArea = mScrollableView->View()->GetBounds();
|
2004-09-29 06:08:51 +04:00
|
|
|
|
|
|
|
return nsMargin(scrollArea.x - contentRect.x, scrollArea.y - contentRect.y,
|
|
|
|
contentRect.XMost() - scrollArea.XMost(),
|
|
|
|
contentRect.YMost() - scrollArea.YMost());
|
2000-07-08 02:24:06 +04:00
|
|
|
}
|
|
|
|
|
2000-05-15 08:12:31 +04:00
|
|
|
void
|
|
|
|
nsGfxScrollFrameInner::SetScrollbarVisibility(nsIBox* aScrollbar, PRBool aVisible)
|
|
|
|
{
|
2002-10-24 07:11:53 +04:00
|
|
|
if (!aScrollbar)
|
|
|
|
return;
|
|
|
|
|
2000-07-14 03:00:59 +04:00
|
|
|
nsCOMPtr<nsIScrollbarFrame> scrollbar(do_QueryInterface(aScrollbar));
|
|
|
|
if (scrollbar) {
|
|
|
|
// See if we have a mediator.
|
|
|
|
nsCOMPtr<nsIScrollbarMediator> mediator;
|
|
|
|
scrollbar->GetScrollbarMediator(getter_AddRefs(mediator));
|
|
|
|
if (mediator) {
|
|
|
|
// Inform the mediator of the visibility change.
|
2004-05-29 04:09:05 +04:00
|
|
|
mediator->VisibilityChanged(scrollbar, aVisible);
|
2000-07-14 03:00:59 +04:00
|
|
|
}
|
|
|
|
}
|
2000-05-15 08:12:31 +04:00
|
|
|
}
|
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
PRInt32
|
2000-03-31 11:02:06 +04:00
|
|
|
nsGfxScrollFrameInner::GetIntegerAttribute(nsIBox* aBox, nsIAtom* atom, PRInt32 defaultValue)
|
1999-08-20 02:16:23 +04:00
|
|
|
{
|
2004-09-28 22:37:50 +04:00
|
|
|
nsIContent* content = aBox->GetContent();
|
1999-08-20 02:16:23 +04:00
|
|
|
|
Landing changes Vidur made while the tree was closed for beta1 work, here's a list of the changes. r=me
[1] Cutting down the size of content. Made nsIJSScriptObject inherit from nsIScriptObjectOwner
[2] Cutting down the size of content. Made nsITextContent inherit from nsIContent.
[3] Cutting down the size of content. Moved implementation of nsIDOMReceiver to nsListenerManager. This is not true aggregation since it isn't transitive, but it's OK for now. It will be necessary for nsListenerManager to have a reference to its content in the future anyway, so the transitivity could be done.
dom/public/nsDOMPropEnums.h,v - bug 12559
dom/public/nsIJSScriptObject.h,v - [1]
dom/public/html/MANIFEST,v - bug 12559
dom/public/html/Makefile.in,v - bug 12559
dom/public/html/makefile.win,v - bug 12559
dom/public/html/nsIDOMHTMLInputElement.h,v - bug 17544
dom/public/idl/html/HTMLAnchorElement.idl,v - bug 12559
dom/public/idl/html/HTMLAreaElement.idl,v - bug 12559
dom/public/idl/html/HTMLInputElement.idl,v - bug 17544
dom/src/base/nsGlobalWindow.cpp,v - bug 30700
dom/src/base/nsGlobalWindow.h,v - [1]
dom/src/base/nsLocation.cpp,v - [1]
dom/src/html/nsJSHTMLAnchorElement.cpp,v - bug 12559
dom/src/html/nsJSHTMLAreaElement.cpp,v - bug 12559
dom/src/html/nsJSHTMLInputElement.cpp,v - bug 17544
layout/base/public/nsIDocument.h,v - bug 27953
layout/base/public/nsITextContent.h,v - [2]
layout/base/src/nsCommentNode.cpp,v - [2]
layout/base/src/nsDocument.cpp,v - bug 27953
layout/base/src/nsDocument.h,v - bug 27953
layout/base/src/nsDocumentViewer.cpp,v - bug 27953
layout/base/src/nsGenericDOMDataNode.cpp,v - [3]
layout/base/src/nsGenericDOMDataNode.h,v - [3]
layout/base/src/nsGenericElement.cpp,v - [3]
layout/base/src/nsGenericElement.h,v - [3]
layout/base/src/nsNameSpaceManager.cpp,v - bug 7834
layout/base/src/nsStyleContext.cpp,v - outline property shouldn't reflow
layout/base/src/nsTextNode.cpp,v - [2]
layout/events/src/nsEventListenerManager.cpp,v - [3]
layout/events/src/nsEventListenerManager.h,v - [3]
layout/html/base/src/nsGfxScrollFrame.cpp,v - nsString->nsAutoString
layout/html/content/src/nsAttributeContent.cpp,v - [2]
layout/html/content/src/nsHTMLAnchorElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLAppletElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLAreaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBRElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBaseElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBaseFontElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLBodyElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLButtonElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDelElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDirectoryElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLDivElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLEmbedElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFieldSetElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFontElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFormElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFrameElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLFrameSetElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHRElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHeadElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHeadingElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLHtmlElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLIFrameElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLImageElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLInputElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLInsElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLIsIndexElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLIElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLabelElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLayerElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLegendElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLLinkElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMapElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMenuElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLMetaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLModElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLObjectElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOptGroupElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLOptionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLParagraphElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLParamElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLPreElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLQuoteElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLScriptElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSelectElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSpacerElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLSpanElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLStyleElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableCaptionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableCellElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableColElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableColGroupElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableRowElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTableSectionElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTextAreaElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLTitleElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLUListElement.cpp,v - [1][3]
layout/html/content/src/nsHTMLWBRElement.cpp,v - [1][3]
layout/html/document/src/nsHTMLDocument.cpp,v - bug 27953
layout/html/document/src/nsHTMLDocument.h,v - bug 27953
layout/xml/content/src/nsXMLCDATASection.cpp,v - [1][2]
layout/xml/content/src/nsXMLDocumentType.cpp,v - [1][2]
layout/xml/content/src/nsXMLElement.h,v - [1][2]
layout/xml/content/src/nsXMLEntity.cpp,v - [1][2]
layout/xml/content/src/nsXMLNotation.cpp,v - [1][2]
layout/xml/content/src/nsXMLProcessingInstruction.cpp,v - [1][2]
layout/xul/base/src/nsBoxFrame.cpp,v - nsString->nsAutoString
layout/xul/base/src/nsSliderFrame.cpp,v - nsString->nsAutoString
netwerk/protocol/http/src/nsHTTPRequest.cpp,v - nsString->nsAutoString
rdf/content/src/nsXULDocument.cpp,v - bug 27953
rdf/content/src/nsXULDocument.h,v - bug 27953
rdf/content/src/nsXULElement.h,v - [1]
xpcom/base/IIDS.h,v - bug 12559
2000-03-17 16:27:00 +03:00
|
|
|
nsAutoString value;
|
2001-08-17 12:14:14 +04:00
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == content->GetAttr(kNameSpaceID_None, atom, value))
|
1999-10-12 04:16:06 +04:00
|
|
|
{
|
|
|
|
PRInt32 error;
|
1999-08-20 02:16:23 +04:00
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
// convert it to an integer
|
|
|
|
defaultValue = value.ToInteger(&error);
|
|
|
|
}
|
1999-08-20 02:16:23 +04:00
|
|
|
|
1999-10-12 04:16:06 +04:00
|
|
|
return defaultValue;
|
1999-08-20 02:16:23 +04:00
|
|
|
}
|
2004-09-13 06:10:29 +04:00
|
|
|
|
2005-01-28 01:52:53 +03:00
|
|
|
nsPresState*
|
2004-09-13 06:10:29 +04:00
|
|
|
nsGfxScrollFrameInner::SaveState()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIScrollbarMediator> mediator;
|
|
|
|
nsIFrame* first = GetScrolledFrame();
|
|
|
|
mediator = do_QueryInterface(first);
|
|
|
|
if (mediator) {
|
|
|
|
// Child manages its own scrolling. Bail.
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIScrollableView* scrollingView = GetScrollableView();
|
|
|
|
PRInt32 x,y;
|
|
|
|
scrollingView->GetScrollPosition(x,y);
|
|
|
|
// Don't save scroll position if we are at (0,0)
|
|
|
|
if (!x && !y) {
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIView* child = nsnull;
|
|
|
|
scrollingView->GetScrolledView(child);
|
|
|
|
if (!child) {
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRect childRect = child->GetBounds();
|
2005-01-28 01:52:53 +03:00
|
|
|
nsAutoPtr<nsPresState> state;
|
|
|
|
nsresult rv = NS_NewPresState(getter_Transfers(state));
|
2004-09-13 06:10:29 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, nsnull);
|
|
|
|
|
2004-11-01 21:50:36 +03:00
|
|
|
nsCOMPtr<nsISupportsPRInt32> xoffset = do_CreateInstance(NS_SUPPORTS_PRINT32_CONTRACTID);
|
2004-09-13 06:10:29 +04:00
|
|
|
if (xoffset) {
|
|
|
|
rv = xoffset->SetData(x);
|
|
|
|
NS_ENSURE_SUCCESS(rv, nsnull);
|
|
|
|
state->SetStatePropertyAsSupports(NS_LITERAL_STRING("x-offset"), xoffset);
|
|
|
|
}
|
|
|
|
|
2004-11-01 21:50:36 +03:00
|
|
|
nsCOMPtr<nsISupportsPRInt32> yoffset = do_CreateInstance(NS_SUPPORTS_PRINT32_CONTRACTID);
|
2004-09-13 06:10:29 +04:00
|
|
|
if (yoffset) {
|
|
|
|
rv = yoffset->SetData(y);
|
|
|
|
NS_ENSURE_SUCCESS(rv, nsnull);
|
|
|
|
state->SetStatePropertyAsSupports(NS_LITERAL_STRING("y-offset"), yoffset);
|
|
|
|
}
|
|
|
|
|
2004-11-01 21:50:36 +03:00
|
|
|
nsCOMPtr<nsISupportsPRInt32> width = do_CreateInstance(NS_SUPPORTS_PRINT32_CONTRACTID);
|
2004-09-13 06:10:29 +04:00
|
|
|
if (width) {
|
|
|
|
rv = width->SetData(childRect.width);
|
|
|
|
NS_ENSURE_SUCCESS(rv, nsnull);
|
|
|
|
state->SetStatePropertyAsSupports(NS_LITERAL_STRING("width"), width);
|
|
|
|
}
|
|
|
|
|
2004-11-01 21:50:36 +03:00
|
|
|
nsCOMPtr<nsISupportsPRInt32> height = do_CreateInstance(NS_SUPPORTS_PRINT32_CONTRACTID);
|
2004-09-13 06:10:29 +04:00
|
|
|
if (height) {
|
|
|
|
rv = height->SetData(childRect.height);
|
|
|
|
NS_ENSURE_SUCCESS(rv, nsnull);
|
|
|
|
state->SetStatePropertyAsSupports(NS_LITERAL_STRING("height"), height);
|
|
|
|
}
|
2005-01-28 01:52:53 +03:00
|
|
|
return state.forget();
|
2004-09-13 06:10:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-01-28 01:52:53 +03:00
|
|
|
nsGfxScrollFrameInner::RestoreState(nsPresState* aState)
|
2004-09-13 06:10:29 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsISupportsPRInt32> xoffset;
|
|
|
|
nsCOMPtr<nsISupportsPRInt32> yoffset;
|
|
|
|
nsCOMPtr<nsISupportsPRInt32> width;
|
|
|
|
nsCOMPtr<nsISupportsPRInt32> height;
|
|
|
|
aState->GetStatePropertyAsSupports(NS_LITERAL_STRING("x-offset"), getter_AddRefs(xoffset));
|
|
|
|
aState->GetStatePropertyAsSupports(NS_LITERAL_STRING("y-offset"), getter_AddRefs(yoffset));
|
|
|
|
aState->GetStatePropertyAsSupports(NS_LITERAL_STRING("width"), getter_AddRefs(width));
|
|
|
|
aState->GetStatePropertyAsSupports(NS_LITERAL_STRING("height"), getter_AddRefs(height));
|
|
|
|
|
|
|
|
if (xoffset && yoffset) {
|
|
|
|
PRInt32 x,y,w,h;
|
|
|
|
nsresult rv = xoffset->GetData(&x);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
rv = yoffset->GetData(&y);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
rv = width->GetData(&w);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
rv = height->GetData(&h);
|
|
|
|
|
|
|
|
mLastPos.x = -1;
|
|
|
|
mLastPos.y = -1;
|
|
|
|
mRestoreRect.SetRect(-1, -1, -1, -1);
|
|
|
|
|
|
|
|
// don't do it now, store it later and do it in layout.
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
mRestoreRect.SetRect(x, y, w, h);
|
2004-09-22 01:41:01 +04:00
|
|
|
mDidHistoryRestore = PR_TRUE;
|
2004-09-13 06:10:29 +04:00
|
|
|
nsIScrollableView* scrollingView = GetScrollableView();
|
|
|
|
if (scrollingView) {
|
|
|
|
scrollingView->GetScrollPosition(mLastPos.x, mLastPos.y);
|
2004-09-22 01:41:01 +04:00
|
|
|
} else {
|
|
|
|
mLastPos = nsPoint(0, 0);
|
2004-09-13 06:10:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|