2001-09-29 00:14:13 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
1998-09-23 21:44:33 +04:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.1 (the "License"); you may not use this file except in
|
|
|
|
* compliance with the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/NPL/
|
1998-09-23 21:44:33 +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.
|
1998-09-23 21:44:33 +04:00
|
|
|
*
|
1999-11-06 06:40:37 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:40:37 +03:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1999-02-12 20:45:58 +03:00
|
|
|
#include "nsCOMPtr.h"
|
1998-09-23 21:44:33 +04:00
|
|
|
#include "nsFormControlFrame.h"
|
|
|
|
#include "nsHTMLParts.h"
|
1998-09-25 01:37:45 +04:00
|
|
|
#include "nsIHTMLContent.h"
|
1998-09-23 21:44:33 +04:00
|
|
|
#include "nsIRenderingContext.h"
|
|
|
|
#include "nsIPresShell.h"
|
|
|
|
#include "nsIPresContext.h"
|
|
|
|
#include "nsIStyleContext.h"
|
|
|
|
#include "nsLeafFrame.h"
|
|
|
|
#include "nsCSSRendering.h"
|
|
|
|
#include "nsIView.h"
|
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsCoord.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
#include "nsViewsCID.h"
|
1999-03-09 12:44:27 +03:00
|
|
|
#include "nsIComponentManager.h"
|
1998-09-23 21:44:33 +04:00
|
|
|
#include "nsGUIEvent.h"
|
|
|
|
#include "nsIFontMetrics.h"
|
|
|
|
#include "nsIFormControl.h"
|
|
|
|
#include "nsIDeviceContext.h"
|
|
|
|
#include "nsHTMLAtoms.h"
|
|
|
|
#include "nsIButton.h" // remove this when GetCID is pure virtual
|
|
|
|
#include "nsICheckButton.h" //remove this
|
|
|
|
#include "nsITextWidget.h" //remove this
|
|
|
|
#include "nsISupports.h"
|
|
|
|
#include "nsStyleConsts.h"
|
|
|
|
#include "nsUnitConversion.h"
|
|
|
|
#include "nsStyleUtil.h"
|
|
|
|
#include "nsFormFrame.h"
|
|
|
|
#include "nsIContent.h"
|
1998-12-15 22:03:36 +03:00
|
|
|
#include "nsStyleUtil.h"
|
1998-12-20 04:21:23 +03:00
|
|
|
#include "nsINameSpaceManager.h"
|
1999-01-06 03:02:27 +03:00
|
|
|
#include "nsIDOMHTMLInputElement.h"
|
2000-02-09 22:34:39 +03:00
|
|
|
#include "nsIDOMHTMLLabelElement.h"
|
|
|
|
#include "nsIDOMHTMLTextAreaElement.h"
|
|
|
|
#include "nsIDOMHTMLLegendElement.h"
|
|
|
|
#include "nsIDOMHTMLButtonElement.h"
|
|
|
|
#include "nsIEventStateManager.h"
|
2000-03-21 18:18:07 +03:00
|
|
|
#include "nsIScrollableView.h"
|
2001-10-05 18:10:16 +04:00
|
|
|
#include "nsILookAndFeel.h"
|
1998-12-15 22:03:36 +03:00
|
|
|
|
2000-03-03 07:28:59 +03:00
|
|
|
#ifdef DEBUG_evaughan
|
2000-03-18 16:45:30 +03:00
|
|
|
//#define DEBUG_rods
|
2000-03-03 07:28:59 +03:00
|
|
|
#endif
|
|
|
|
|
2000-03-24 17:59:02 +03:00
|
|
|
#ifdef DEBUG_rods
|
|
|
|
//#define FCF_NOISY
|
|
|
|
#endif
|
|
|
|
|
2000-03-18 16:45:30 +03:00
|
|
|
#ifdef FCF_NOISY
|
2000-10-29 02:17:53 +04:00
|
|
|
#define REFLOW_DEBUG_MSG(_msg1) printf((_msg1))
|
|
|
|
#define REFLOW_DEBUG_MSG2(_msg1, _msg2) printf((_msg1), (_msg2))
|
|
|
|
#define REFLOW_DEBUG_MSG3(_msg1, _msg2, _msg3) printf((_msg1), (_msg2), (_msg3))
|
|
|
|
#define REFLOW_DEBUG_MSG4(_msg1, _msg2, _msg3, _msg4) printf((_msg1), (_msg2), (_msg3), (_msg4))
|
2000-03-18 16:45:30 +03:00
|
|
|
|
2000-10-29 02:17:53 +04:00
|
|
|
#define IF_REFLOW_DEBUG_MSG(_bool, _msg1) if ((_bool)) printf((_msg1))
|
|
|
|
#define IF_REFLOW_DEBUG_MSG2(_bool, _msg1, _msg2) if ((_bool)) printf((_msg1), (_msg2))
|
|
|
|
#define IF_REFLOW_DEBUG_MSG3(_bool, _msg1, _msg2, _msg3) if ((_bool)) printf((_msg1), (_msg2), (_msg3))
|
|
|
|
#define IF_REFLOW_DEBUG_MSG4(_bool, _msg1, _msg2, _msg3, _msg4) if ((_bool)) printf((_msg1), (_msg2), (_msg3), (_msg4))
|
2000-03-18 16:45:30 +03:00
|
|
|
|
|
|
|
#else //-------------
|
|
|
|
#define REFLOW_DEBUG_MSG(_msg)
|
|
|
|
#define REFLOW_DEBUG_MSG2(_msg1, _msg2)
|
|
|
|
#define REFLOW_DEBUG_MSG3(_msg1, _msg2, _msg3)
|
|
|
|
#define REFLOW_DEBUG_MSG4(_msg1, _msg2, _msg3, _msg4)
|
|
|
|
|
|
|
|
#define IF_REFLOW_DEBUG_MSG(_bool, _msg)
|
|
|
|
#define IF_REFLOW_DEBUG_MSG2(_bool, _msg1, _msg2)
|
|
|
|
#define IF_REFLOW_DEBUG_MSG3(_bool, _msg1, _msg2, _msg3)
|
|
|
|
#define IF_REFLOW_DEBUG_MSG4(_bool, _msg1, _msg2, _msg3, _msg4)
|
2000-03-03 07:28:59 +03:00
|
|
|
#endif
|
|
|
|
|
|
|
|
const PRInt32 kSizeNotSet = -1;
|
1998-09-23 21:44:33 +04:00
|
|
|
|
1998-12-03 09:31:43 +03:00
|
|
|
nsFormControlFrame::nsFormControlFrame()
|
|
|
|
: nsLeafFrame()
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
mDidInit = PR_FALSE;
|
1999-04-27 04:06:03 +04:00
|
|
|
mFormFrame = nsnull;
|
fixed bugs #6303, #6753, #6756, #6759
Re-wrote nsComboboxFrame.
removed the obsolete nsHTMLAtoms: comboText,comoTextSelected,comTextSelectedFocus,dropDownVisible,
dropdownHidden, dropDownBtnOut, dropDownBtnPressed,
Added nsHTMLAtoms::combobox, nsLayoutAtoms::popupList
Renamed dropDownList to dropDownListPseudo
Added "arrow.gif" as to be used the background-image for the combobox button
ua.css - added rules for select to differentiate between comboboxes and listboxes.
Added style rules to more closely match the XPTOOLKIT XPWidgets look.
removed the following :-moz-combobox-text, -moz-combobox-textselected
nsIFormControlFrame.h - Added SetSuggestedSize method.
nsButtonControlFrame - Implemented SetSuggestedSize.
nsCSSFrameConstructor.cpp - Rewrote ConstructSelectFrame.
nsIWidget.h -Added GetAbsoluteBounds method.
nsWindow.cpp - Implemented GetAbsoluteBounds.
1999-07-15 02:00:24 +04:00
|
|
|
mSuggestedWidth = NS_FORMSIZE_NOTSET;
|
|
|
|
mSuggestedHeight = NS_FORMSIZE_NOTSET;
|
2000-02-10 02:20:56 +03:00
|
|
|
mPresContext = nsnull;
|
2000-01-08 18:53:48 +03:00
|
|
|
|
|
|
|
// Reflow Optimization
|
2000-03-03 07:28:59 +03:00
|
|
|
mCacheSize.width = kSizeNotSet;
|
|
|
|
mCacheSize.height = kSizeNotSet;
|
|
|
|
mCachedMaxElementSize.width = kSizeNotSet;
|
|
|
|
mCachedMaxElementSize.height = kSizeNotSet;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsFormControlFrame::~nsFormControlFrame()
|
|
|
|
{
|
1999-11-05 02:16:47 +03:00
|
|
|
if (mFormFrame) {
|
|
|
|
mFormFrame->RemoveFormControlFrame(*this);
|
|
|
|
mFormFrame = nsnull;
|
|
|
|
}
|
2000-08-03 02:12:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::Destroy(nsIPresContext *aPresContext)
|
|
|
|
{
|
|
|
|
nsFormControlFrame::RegUnRegAccessKey(aPresContext, NS_STATIC_CAST(nsIFrame*, this), PR_FALSE);
|
|
|
|
return nsLeafFrame::Destroy(aPresContext);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
1999-11-02 04:50:15 +03:00
|
|
|
// Frames are not refcounted, no need to AddRef
|
|
|
|
NS_IMETHODIMP
|
1998-09-23 21:44:33 +04:00
|
|
|
nsFormControlFrame::QueryInterface(const nsIID& aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(0 != aInstancePtr, "null ptr");
|
|
|
|
if (NULL == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
2001-01-04 23:44:42 +03:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIFormControlFrame))) {
|
1998-09-23 21:44:33 +04:00
|
|
|
*aInstancePtr = (void*) ((nsIFormControlFrame*) this);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return nsLeafFrame::QueryInterface(aIID, aInstancePtr);
|
|
|
|
}
|
|
|
|
|
2000-01-08 18:53:48 +03:00
|
|
|
void nsFormControlFrame::SetupCachedSizes(nsSize& aCacheSize,
|
|
|
|
nsSize& aCachedMaxElementSize,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize)
|
|
|
|
{
|
|
|
|
aCacheSize.width = aDesiredSize.width;
|
|
|
|
aCacheSize.height = aDesiredSize.height;
|
|
|
|
if (aDesiredSize.maxElementSize != nsnull) {
|
|
|
|
aCachedMaxElementSize.width = aDesiredSize.maxElementSize->width;
|
|
|
|
aCachedMaxElementSize.height = aDesiredSize.maxElementSize->height;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-18 16:45:30 +03:00
|
|
|
#if 0 // Testing out changes
|
|
|
|
//------------------------------------------------------------
|
|
|
|
void nsFormControlFrame::SkipResizeReflow(nsSize& aCacheSize,
|
|
|
|
nsSize& aCachedMaxElementSize,
|
|
|
|
nsSize& aCachedAvailableSize,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus,
|
|
|
|
PRBool& aBailOnWidth,
|
|
|
|
PRBool& aBailOnHeight)
|
|
|
|
{
|
|
|
|
|
2000-04-12 18:51:10 +04:00
|
|
|
if (aReflowState.reason == eReflowReason_Incremental ||
|
|
|
|
aReflowState.reason == eReflowReason_Dirty) {
|
2000-03-18 16:45:30 +03:00
|
|
|
aBailOnHeight = PR_FALSE;
|
|
|
|
aBailOnWidth = PR_FALSE;
|
|
|
|
|
|
|
|
} else if (eReflowReason_Initial == aReflowState.reason) {
|
|
|
|
aBailOnHeight = PR_FALSE;
|
|
|
|
aBailOnWidth = PR_FALSE;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
nscoord width;
|
|
|
|
if (NS_UNCONSTRAINEDSIZE == aReflowState.mComputedWidth) {
|
|
|
|
if (aReflowState.availableWidth == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
width = NS_UNCONSTRAINEDSIZE;
|
|
|
|
aBailOnWidth = aCacheSize.width != kSizeNotSet;
|
|
|
|
IF_REFLOW_DEBUG_MSG2(aBailOnWidth, "-------------- #1 Bailing on aCachedAvailableSize.width %d != kSizeNotSet\n", aCachedAvailableSize.width);
|
|
|
|
} else {
|
|
|
|
//width = aReflowState.availableWidth - aReflowState.mComputedBorderPadding.left -
|
|
|
|
// aReflowState.mComputedBorderPadding.right;
|
|
|
|
aBailOnWidth = aCacheSize.width <= aReflowState.availableWidth && aCacheSize.width != kSizeNotSet;
|
|
|
|
|
|
|
|
if (aBailOnWidth) {
|
|
|
|
REFLOW_DEBUG_MSG3("-------------- #2 Bailing on aCachedSize.width %d <= (AW - BP) %d\n", aCachedAvailableSize.width, width );
|
|
|
|
} else {
|
|
|
|
//aBailOnWidth = width <= (aCacheSize.width - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right) &&
|
|
|
|
// aCachedAvailableSize.width == kSizeNotSet;
|
|
|
|
//if (aBailOnWidth) {
|
|
|
|
// REFLOW_DEBUG_MSG3("-------------- #2.2 Bailing on width %d <= aCachedSize.width %d\n", width, (aCacheSize.width - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right));
|
|
|
|
//}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
width = aReflowState.mComputedWidth;
|
|
|
|
aBailOnWidth = width == (aCacheSize.width - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right);
|
|
|
|
IF_REFLOW_DEBUG_MSG3(aBailOnWidth, "-------------- #3 Bailing on aCachedAvailableSize.width %d == aReflowState.mComputedWidth %d\n", aCachedAvailableSize.width, width );
|
|
|
|
}
|
|
|
|
|
|
|
|
nscoord height;
|
|
|
|
if (NS_UNCONSTRAINEDSIZE == aReflowState.mComputedHeight) {
|
|
|
|
if (aReflowState.availableHeight == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
height = NS_UNCONSTRAINEDSIZE;
|
|
|
|
aBailOnHeight = aCacheSize.height != kSizeNotSet;
|
|
|
|
if (aBailOnHeight) {
|
|
|
|
IF_REFLOW_DEBUG_MSG2(aBailOnHeight, "-------------- #1 Bailing on aCachedAvailableSize.height %d != kSizeNotSet\n", aCachedAvailableSize.height);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
height = aReflowState.availableHeight - aReflowState.mComputedBorderPadding.left -
|
|
|
|
aReflowState.mComputedBorderPadding.right;
|
|
|
|
aBailOnHeight = aCachedAvailableSize.height <= height && aCachedAvailableSize.height != kSizeNotSet;
|
|
|
|
if (aBailOnHeight) {
|
|
|
|
REFLOW_DEBUG_MSG3("-------------- #2 Bailing on aCachedAvailableSize.height %d <= height %d\n", aCachedAvailableSize.height, height );
|
|
|
|
} else {
|
|
|
|
aBailOnHeight = height <= (aCacheSize.height - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right) &&
|
|
|
|
aCachedAvailableSize.height == kSizeNotSet;
|
|
|
|
if (aBailOnHeight) {
|
|
|
|
REFLOW_DEBUG_MSG3("-------------- #2.2 Bailing on height %d <= aCachedSize.height %d\n", height, (aCacheSize.height - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
height = aReflowState.mComputedHeight;
|
|
|
|
aBailOnHeight = height == (aCacheSize.height - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right);
|
|
|
|
IF_REFLOW_DEBUG_MSG3(aBailOnHeight, "-------------- #3 Bailing on aCachedAvailableSize.height %d == aReflowState.mComputedHeight %d\n", aCachedAvailableSize.height, height );
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aBailOnWidth || aBailOnHeight) {
|
|
|
|
aDesiredSize.width = aCacheSize.width;
|
|
|
|
aDesiredSize.height = aCacheSize.height;
|
|
|
|
|
|
|
|
if (aDesiredSize.maxElementSize != nsnull) {
|
|
|
|
aDesiredSize.maxElementSize->width = aCachedMaxElementSize.width;
|
|
|
|
aDesiredSize.maxElementSize->height = aCachedMaxElementSize.height;
|
|
|
|
}
|
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
|
|
|
aDesiredSize.descent = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2000-03-03 07:28:59 +03:00
|
|
|
//------------------------------------------------------------
|
|
|
|
void nsFormControlFrame::SkipResizeReflow(nsSize& aCacheSize,
|
|
|
|
nsSize& aCachedMaxElementSize,
|
|
|
|
nsSize& aCachedAvailableSize,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus,
|
|
|
|
PRBool& aBailOnWidth,
|
|
|
|
PRBool& aBailOnHeight)
|
2000-01-08 18:53:48 +03:00
|
|
|
{
|
2000-03-03 07:28:59 +03:00
|
|
|
|
2000-04-12 18:51:10 +04:00
|
|
|
if (aReflowState.reason == eReflowReason_Incremental ||
|
2001-03-20 02:20:21 +03:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
aReflowState.reason == eReflowReason_StyleChange ||
|
|
|
|
#endif
|
2000-04-12 18:51:10 +04:00
|
|
|
aReflowState.reason == eReflowReason_Dirty) {
|
2000-03-03 07:28:59 +03:00
|
|
|
aBailOnHeight = PR_FALSE;
|
|
|
|
aBailOnWidth = PR_FALSE;
|
|
|
|
|
|
|
|
} else if (eReflowReason_Initial == aReflowState.reason) {
|
|
|
|
aBailOnHeight = PR_FALSE;
|
|
|
|
aBailOnWidth = PR_FALSE;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
nscoord width;
|
|
|
|
if (NS_UNCONSTRAINEDSIZE == aReflowState.mComputedWidth) {
|
|
|
|
if (aReflowState.availableWidth == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
width = NS_UNCONSTRAINEDSIZE;
|
|
|
|
aBailOnWidth = aCacheSize.width != kSizeNotSet;
|
|
|
|
#ifdef FCF_NOISY
|
|
|
|
if (aBailOnWidth) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #1 Bailing on aCachedAvailableSize.width %d != kSizeNotSet\n", aCachedAvailableSize.width);
|
2000-01-08 18:53:48 +03:00
|
|
|
}
|
2000-03-03 07:28:59 +03:00
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
width = aReflowState.availableWidth - aReflowState.mComputedBorderPadding.left -
|
|
|
|
aReflowState.mComputedBorderPadding.right;
|
|
|
|
aBailOnWidth = aCachedAvailableSize.width <= width && aCachedAvailableSize.width != kSizeNotSet;
|
|
|
|
#ifdef FCF_NOISY
|
|
|
|
if (aBailOnWidth) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #2 Bailing on aCachedAvailableSize.width %d <= width %d\n", aCachedAvailableSize.width, width );
|
2000-03-18 16:45:30 +03:00
|
|
|
} else {
|
|
|
|
aBailOnWidth = width <= (aCacheSize.width - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right) &&
|
|
|
|
aCachedAvailableSize.width == kSizeNotSet;
|
|
|
|
if (aBailOnWidth) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #2.2 Bailing on width %d <= aCachedAvailableSize.width %d\n",(aCacheSize.width - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right), width );
|
2000-03-18 16:45:30 +03:00
|
|
|
}
|
2000-03-03 07:28:59 +03:00
|
|
|
}
|
|
|
|
#endif
|
2000-01-08 18:53:48 +03:00
|
|
|
}
|
|
|
|
} else {
|
2000-03-03 07:28:59 +03:00
|
|
|
width = aReflowState.mComputedWidth;
|
|
|
|
//if (aCachedAvailableSize.width == kSizeNotSet) {
|
|
|
|
// //aBailOnWidth = aCachedAvailableSize.width == aCacheSize.width;
|
|
|
|
aBailOnWidth = PR_FALSE;
|
|
|
|
//} else {
|
|
|
|
aBailOnWidth = width == (aCacheSize.width - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right);
|
|
|
|
//}
|
|
|
|
#ifdef FCF_NOISY
|
|
|
|
if (aBailOnWidth) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #3 Bailing on aCachedAvailableSize.width %d == aReflowState.mComputedWidth %d\n", aCachedAvailableSize.width, width );
|
2000-01-08 18:53:48 +03:00
|
|
|
}
|
2000-03-03 07:28:59 +03:00
|
|
|
#endif
|
2000-01-08 18:53:48 +03:00
|
|
|
}
|
2000-03-03 07:28:59 +03:00
|
|
|
|
|
|
|
nscoord height;
|
|
|
|
if (NS_UNCONSTRAINEDSIZE == aReflowState.mComputedHeight) {
|
|
|
|
if (aReflowState.availableHeight == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
height = NS_UNCONSTRAINEDSIZE;
|
2000-03-18 16:45:30 +03:00
|
|
|
aBailOnHeight = aCacheSize.height != kSizeNotSet;
|
|
|
|
#ifdef FCF_NOISY
|
|
|
|
if (aBailOnHeight) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #1 Bailing on aCachedAvailableSize.height %d != kSizeNotSet\n", aCachedAvailableSize.height);
|
2000-03-18 16:45:30 +03:00
|
|
|
}
|
|
|
|
#endif
|
2000-03-03 07:28:59 +03:00
|
|
|
} else {
|
2000-03-18 16:45:30 +03:00
|
|
|
height = aReflowState.availableHeight - aReflowState.mComputedBorderPadding.left -
|
|
|
|
aReflowState.mComputedBorderPadding.right;
|
|
|
|
aBailOnHeight = aCachedAvailableSize.height <= height && aCachedAvailableSize.height != kSizeNotSet;
|
|
|
|
#ifdef FCF_NOISY
|
|
|
|
if (aBailOnHeight) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #2 Bailing on aCachedAvailableSize.height %d <= height %d\n", aCachedAvailableSize.height, height );
|
2000-03-18 16:45:30 +03:00
|
|
|
} else {
|
|
|
|
aBailOnHeight = height <= (aCacheSize.height - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right) &&
|
|
|
|
aCachedAvailableSize.height == kSizeNotSet;
|
|
|
|
if (aBailOnHeight) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #2.2 Bailing on height %d <= aCachedAvailableSize.height %d\n",(aCacheSize.height - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right), height );
|
2000-03-18 16:45:30 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2000-03-03 07:28:59 +03:00
|
|
|
}
|
|
|
|
} else {
|
2000-03-18 16:45:30 +03:00
|
|
|
height = aReflowState.mComputedHeight;
|
|
|
|
//if (aCachedAvailableSize.height == kSizeNotSet) {
|
|
|
|
// //aBailOnHeight = aCachedAvailableSize.height == aCacheSize.height;
|
|
|
|
aBailOnHeight = PR_FALSE;
|
|
|
|
//} else {
|
|
|
|
aBailOnHeight = height == (aCacheSize.height - aReflowState.mComputedBorderPadding.left - aReflowState.mComputedBorderPadding.right);
|
|
|
|
//}
|
|
|
|
#ifdef FCF_NOISY
|
|
|
|
if (aBailOnHeight) {
|
2000-10-29 02:17:53 +04:00
|
|
|
printf("-------------- #3 Bailing on aCachedAvailableSize.height %d == aReflowState.mComputedHeight %d\n", aCachedAvailableSize.height, height );
|
2000-03-18 16:45:30 +03:00
|
|
|
}
|
|
|
|
#endif
|
2000-03-03 07:28:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (aBailOnWidth || aBailOnHeight) {
|
|
|
|
aDesiredSize.width = aCacheSize.width;
|
|
|
|
aDesiredSize.height = aCacheSize.height;
|
2000-01-08 18:53:48 +03:00
|
|
|
|
2000-03-03 07:28:59 +03:00
|
|
|
if (aDesiredSize.maxElementSize != nsnull) {
|
|
|
|
aDesiredSize.maxElementSize->width = aCachedMaxElementSize.width;
|
|
|
|
aDesiredSize.maxElementSize->height = aCachedMaxElementSize.height;
|
|
|
|
}
|
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
|
|
|
aDesiredSize.descent = 0;
|
|
|
|
}
|
|
|
|
}
|
2000-01-08 18:53:48 +03:00
|
|
|
}
|
2000-03-18 16:45:30 +03:00
|
|
|
#endif
|
2000-01-08 18:53:48 +03:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
nscoord
|
|
|
|
nsFormControlFrame::GetScrollbarWidth(float aPixToTwip)
|
|
|
|
{
|
|
|
|
return NSIntPixelsToTwips(19, aPixToTwip); // XXX this is windows
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsFormControlFrame::SetClickPoint(nscoord aX, nscoord aY)
|
|
|
|
{
|
|
|
|
mLastClickPoint.x = aX;
|
|
|
|
mLastClickPoint.y = aY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// XXX it would be cool if form element used our rendering sw, then
|
|
|
|
// they could be blended, and bordered, and so on...
|
|
|
|
NS_METHOD
|
2001-09-19 16:35:19 +04:00
|
|
|
nsFormControlFrame::Paint(nsIPresContext* aPresContext,
|
1998-12-18 18:54:23 +03:00
|
|
|
nsIRenderingContext& aRenderingContext,
|
2001-09-19 16:35:19 +04:00
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
nsFramePaintLayer aWhichLayer,
|
|
|
|
PRUint32 aFlags)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
2001-01-27 17:09:34 +03:00
|
|
|
PRBool isVisible;
|
|
|
|
if (NS_SUCCEEDED(IsVisibleForPainting(aPresContext, aRenderingContext, PR_TRUE, &isVisible)) && !isVisible) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-03-03 07:28:59 +03:00
|
|
|
|
2001-11-03 09:23:19 +03:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
if (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND) {
|
|
|
|
rv = nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
|
|
NS_FRAME_PAINT_LAYER_BACKGROUND);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
// draw selection borders when appropriate
|
|
|
|
rv = nsFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
|
|
NS_FRAME_PAINT_LAYER_BACKGROUND);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
rv = nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
|
|
NS_FRAME_PAINT_LAYER_FLOATERS);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
// draw selection borders when appropriate
|
|
|
|
rv = nsFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
|
|
NS_FRAME_PAINT_LAYER_FLOATERS);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
rv = nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
|
|
NS_FRAME_PAINT_LAYER_FOREGROUND);
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
return rv;
|
|
|
|
// draw selection borders when appropriate
|
|
|
|
rv = nsFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
|
|
NS_FRAME_PAINT_LAYER_FOREGROUND);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::GetFrameForPoint(nsIPresContext* aPresContext,
|
|
|
|
const nsPoint& aPoint,
|
|
|
|
nsFramePaintLayer aWhichLayer,
|
|
|
|
nsIFrame** aFrame)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
if (aWhichLayer == NS_FRAME_PAINT_LAYER_FOREGROUND) {
|
|
|
|
rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
|
|
|
|
NS_FRAME_PAINT_LAYER_FOREGROUND, aFrame);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
return NS_OK;
|
|
|
|
rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
|
|
|
|
NS_FRAME_PAINT_LAYER_FLOATERS, aFrame);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
return NS_OK;
|
|
|
|
rv = nsLeafFrame::GetFrameForPoint(aPresContext, aPoint,
|
|
|
|
NS_FRAME_PAINT_LAYER_BACKGROUND, aFrame);
|
2000-03-03 07:28:59 +03:00
|
|
|
}
|
|
|
|
return rv;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1999-02-27 06:59:19 +03:00
|
|
|
nsFormControlFrame::GetDesiredSize(nsIPresContext* aPresContext,
|
1998-12-18 18:54:23 +03:00
|
|
|
const nsHTMLReflowState& aReflowState,
|
1999-02-27 06:59:19 +03:00
|
|
|
nsHTMLReflowMetrics& aDesiredLayoutSize,
|
|
|
|
nsSize& aDesiredWidgetSize)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
// get the css size and let the frame use or override it
|
|
|
|
nsSize styleSize;
|
1999-11-24 09:03:41 +03:00
|
|
|
GetStyleSize(aPresContext, aReflowState, styleSize);
|
1998-09-23 21:44:33 +04:00
|
|
|
|
|
|
|
// subclasses should always override this method, but if not and no css, make it small
|
|
|
|
aDesiredLayoutSize.width = (styleSize.width > CSS_NOTSET) ? styleSize.width : 144;
|
|
|
|
aDesiredLayoutSize.height = (styleSize.height > CSS_NOTSET) ? styleSize.height : 144;
|
|
|
|
aDesiredLayoutSize.ascent = aDesiredLayoutSize.height;
|
|
|
|
aDesiredLayoutSize.descent = 0;
|
1999-02-27 06:59:19 +03:00
|
|
|
if (aDesiredLayoutSize.maxElementSize) {
|
|
|
|
aDesiredLayoutSize.maxElementSize->width = aDesiredLayoutSize.width;
|
|
|
|
aDesiredLayoutSize.maxElementSize->height = aDesiredLayoutSize.height;
|
|
|
|
}
|
1998-09-23 21:44:33 +04:00
|
|
|
aDesiredWidgetSize.width = aDesiredLayoutSize.width;
|
|
|
|
aDesiredWidgetSize.height = aDesiredLayoutSize.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsFormControlFrame::GetDesiredSize(nsIPresContext* aPresContext,
|
1998-10-02 08:10:00 +04:00
|
|
|
const nsHTMLReflowState& aReflowState,
|
1998-10-01 08:46:11 +04:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
nsSize ignore;
|
|
|
|
GetDesiredSize(aPresContext, aReflowState, aDesiredSize, ignore);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-12-07 17:51:12 +03:00
|
|
|
nsFormControlFrame::DidReflow(nsIPresContext* aPresContext,
|
|
|
|
const nsHTMLReflowState* aReflowState,
|
|
|
|
nsDidReflowStatus aStatus)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
2001-12-07 17:51:12 +03:00
|
|
|
nsresult rv = nsLeafFrame::DidReflow(aPresContext, aReflowState, aStatus);
|
1998-09-23 21:44:33 +04:00
|
|
|
|
1999-05-20 02:14:11 +04:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
// The view is created hidden; once we have reflowed it and it has been
|
|
|
|
// positioned then we show it.
|
|
|
|
if (NS_FRAME_REFLOW_FINISHED == aStatus) {
|
|
|
|
nsIView* view = nsnull;
|
1999-11-24 09:03:41 +03:00
|
|
|
GetView(aPresContext, &view);
|
1999-05-20 02:14:11 +04:00
|
|
|
if (view) {
|
2001-06-01 02:19:43 +04:00
|
|
|
const nsStyleVisibility* vis;
|
|
|
|
GetStyleData(eStyleStruct_Visibility, ((const nsStyleStruct *&)vis));
|
|
|
|
nsViewVisibility newVis = vis->IsVisible() ? nsViewVisibility_kShow : nsViewVisibility_kHide;
|
1999-05-20 02:14:11 +04:00
|
|
|
nsViewVisibility oldVis;
|
|
|
|
// only change if different.
|
|
|
|
view->GetVisibility(oldVis);
|
2001-12-01 17:31:45 +03:00
|
|
|
if (newVis != oldVis) {
|
|
|
|
nsCOMPtr<nsIViewManager> vm;
|
|
|
|
view->GetViewManager(*getter_AddRefs(vm));
|
|
|
|
if (vm) {
|
|
|
|
vm->SetViewVisibility(view, newVis);
|
|
|
|
}
|
|
|
|
}
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
}
|
1999-05-20 02:14:11 +04:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1998-10-30 21:05:29 +03:00
|
|
|
NS_IMETHODIMP
|
1999-11-24 09:03:41 +03:00
|
|
|
nsFormControlFrame::SetInitialChildList(nsIPresContext* aPresContext,
|
1998-11-10 09:05:32 +03:00
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aChildList)
|
1998-10-30 21:05:29 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
NS_METHOD
|
1999-11-24 09:03:41 +03:00
|
|
|
nsFormControlFrame::Reflow(nsIPresContext* aPresContext,
|
1999-02-27 06:59:19 +03:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
1998-11-14 02:13:42 +03:00
|
|
|
const nsHTMLReflowState& aReflowState,
|
1999-02-27 06:59:19 +03:00
|
|
|
nsReflowStatus& aStatus)
|
1998-11-14 02:13:42 +03:00
|
|
|
{
|
2000-04-22 01:51:35 +04:00
|
|
|
DO_GLOBAL_REFLOW_COUNT("nsFormControlFrame", aReflowState.reason);
|
2001-11-14 16:40:03 +03:00
|
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
2000-04-22 01:51:35 +04:00
|
|
|
|
2000-02-09 22:34:39 +03:00
|
|
|
if (!mDidInit) {
|
|
|
|
mPresContext = aPresContext;
|
|
|
|
InitializeControl(aPresContext);
|
|
|
|
mDidInit = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
1999-04-27 04:06:03 +04:00
|
|
|
// add ourself as an nsIFormControlFrame
|
|
|
|
if (!mFormFrame && (eReflowReason_Initial == aReflowState.reason)) {
|
1999-11-24 09:03:41 +03:00
|
|
|
nsFormFrame::AddFormControlFrame(aPresContext, *NS_STATIC_CAST(nsIFrame*, this));
|
1999-04-27 04:06:03 +04:00
|
|
|
}
|
|
|
|
|
2000-03-03 07:28:59 +03:00
|
|
|
#if 0
|
2000-01-08 18:53:48 +03:00
|
|
|
nsresult skiprv = SkipResizeReflow(mCacheSize, mCachedMaxElementSize, aPresContext,
|
|
|
|
aDesiredSize, aReflowState, aStatus);
|
|
|
|
if (NS_SUCCEEDED(skiprv)) {
|
|
|
|
return skiprv;
|
|
|
|
}
|
2000-03-03 07:28:59 +03:00
|
|
|
#endif
|
2000-01-08 18:53:48 +03:00
|
|
|
|
2000-02-09 22:34:39 +03:00
|
|
|
nsresult rv = nsLeafFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
|
1999-08-27 18:38:54 +04:00
|
|
|
|
1998-11-14 02:13:42 +03:00
|
|
|
aStatus = NS_FRAME_COMPLETE;
|
2000-01-08 18:53:48 +03:00
|
|
|
SetupCachedSizes(mCacheSize, mCachedMaxElementSize, aDesiredSize);
|
2000-02-09 22:34:39 +03:00
|
|
|
return rv;
|
1998-11-14 02:13:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
nsWidgetInitData*
|
1999-11-24 09:03:41 +03:00
|
|
|
nsFormControlFrame::GetWidgetInitData(nsIPresContext* aPresContext)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
2000-02-09 22:34:39 +03:00
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::RegUnRegAccessKey(nsIPresContext* aPresContext, nsIFrame * aFrame, PRBool aDoReg)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aPresContext, "aPresContext is NULL in RegUnRegAccessKey!");
|
|
|
|
NS_ASSERTION(aFrame, "aFrame is NULL in RegUnRegAccessKey!");
|
|
|
|
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
nsAutoString accessKey;
|
|
|
|
|
|
|
|
if (aFrame != nsnull) {
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
if (NS_SUCCEEDED(aFrame->GetContent(getter_AddRefs(content)))) {
|
|
|
|
#if 1
|
|
|
|
PRInt32 nameSpaceID;
|
|
|
|
content->GetNameSpaceID(nameSpaceID);
|
|
|
|
nsAutoString resultValue;
|
2001-08-17 12:14:14 +04:00
|
|
|
rv = content->GetAttr(nameSpaceID, nsHTMLAtoms::accesskey, accessKey);
|
2000-02-09 22:34:39 +03:00
|
|
|
#else
|
|
|
|
nsCOMPtr<nsIDOMHTMLInputElement> inputElement(do_QueryInterface(content));
|
|
|
|
if (inputElement) {
|
|
|
|
rv = inputElement->GetAccessKey(accessKey);
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIDOMHTMLTextAreaElement> textarea(do_QueryInterface(content));
|
|
|
|
if (textarea) {
|
|
|
|
rv = textarea->GetAccessKey(accessKey);
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIDOMHTMLLabelElement> label(do_QueryInterface(content));
|
|
|
|
if (label) {
|
|
|
|
rv = label->GetAccessKey(accessKey);
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIDOMHTMLLegendElement> legend(do_QueryInterface(content));
|
|
|
|
if (legend) {
|
|
|
|
rv = legend->GetAccessKey(accessKey);
|
|
|
|
} else {
|
|
|
|
nsCOMPtr<nsIDOMHTMLButtonElement> btn(do_QueryInterface(content));
|
|
|
|
if (btn) {
|
|
|
|
rv = btn->GetAccessKey(accessKey);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_CONTENT_ATTR_NOT_THERE != rv) {
|
|
|
|
nsCOMPtr<nsIEventStateManager> stateManager;
|
|
|
|
if (NS_SUCCEEDED(aPresContext->GetEventStateManager(getter_AddRefs(stateManager)))) {
|
2002-05-22 04:14:51 +04:00
|
|
|
nsCOMPtr<nsIContent> content;
|
|
|
|
aFrame->GetContent(getter_AddRefs(content));
|
2000-02-09 22:34:39 +03:00
|
|
|
if (aDoReg) {
|
2002-05-22 04:14:51 +04:00
|
|
|
return stateManager->RegisterAccessKey(content, (PRUint32)accessKey.First());
|
2000-02-09 22:34:39 +03:00
|
|
|
} else {
|
2002-05-22 04:14:51 +04:00
|
|
|
return stateManager->UnregisterAccessKey(content, (PRUint32)accessKey.First());
|
2000-02-09 22:34:39 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
void
|
2000-02-09 22:34:39 +03:00
|
|
|
nsFormControlFrame::InitializeControl(nsIPresContext* aPresContext)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
2000-02-09 22:34:39 +03:00
|
|
|
RegUnRegAccessKey(aPresContext, NS_STATIC_CAST(nsIFrame*, this), PR_TRUE);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
1998-10-23 03:00:37 +04:00
|
|
|
void
|
|
|
|
nsFormControlFrame::SetFocus(PRBool aOn, PRBool aRepaint)
|
|
|
|
{
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
void
|
|
|
|
nsFormControlFrame::ScrollIntoView(nsIPresContext* aPresContext)
|
|
|
|
{
|
|
|
|
if (aPresContext) {
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
aPresContext->GetShell(getter_AddRefs(presShell));
|
2000-09-08 09:53:28 +04:00
|
|
|
if (presShell) {
|
|
|
|
presShell->ScrollFrameIntoView(this,
|
2000-01-25 18:25:46 +03:00
|
|
|
NS_PRESSHELL_SCROLL_IF_NOT_VISIBLE,NS_PRESSHELL_SCROLL_IF_NOT_VISIBLE);
|
2000-09-08 09:53:28 +04:00
|
|
|
}
|
1999-08-21 04:09:24 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-02-03 01:24:56 +03:00
|
|
|
/*
|
|
|
|
* FIXME: this ::GetIID() method has no meaning in life and should be
|
|
|
|
* removed.
|
|
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
|
|
|
*/
|
1998-09-23 21:44:33 +04:00
|
|
|
const nsIID&
|
|
|
|
nsFormControlFrame::GetIID()
|
|
|
|
{
|
2001-01-04 23:44:42 +03:00
|
|
|
return NS_GET_IID(nsIButton);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
const nsIID&
|
|
|
|
nsFormControlFrame::GetCID()
|
|
|
|
{
|
|
|
|
static NS_DEFINE_IID(kButtonCID, NS_BUTTON_CID);
|
|
|
|
return kButtonCID;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::GetMaxLength(PRInt32* aSize)
|
|
|
|
{
|
|
|
|
*aSize = -1;
|
|
|
|
nsresult result = NS_CONTENT_ATTR_NOT_THERE;
|
2002-05-23 04:00:34 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIHTMLContent> content(do_QueryInterface(mContent));
|
|
|
|
|
|
|
|
if (content) {
|
1998-09-23 21:44:33 +04:00
|
|
|
nsHTMLValue value;
|
1998-12-20 04:21:23 +03:00
|
|
|
result = content->GetHTMLAttribute(nsHTMLAtoms::maxlength, value);
|
1998-09-23 21:44:33 +04:00
|
|
|
if (eHTMLUnit_Integer == value.GetUnit()) {
|
|
|
|
*aSize = value.GetIntValue();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-02-04 01:56:50 +03:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::GetSizeFromContent(PRInt32* aSize) const
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
*aSize = -1;
|
|
|
|
nsresult result = NS_CONTENT_ATTR_NOT_THERE;
|
2002-05-23 04:00:34 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIHTMLContent> content(do_QueryInterface(mContent));
|
|
|
|
|
|
|
|
if (content) {
|
1998-09-23 21:44:33 +04:00
|
|
|
nsHTMLValue value;
|
1998-12-20 04:21:23 +03:00
|
|
|
result = content->GetHTMLAttribute(nsHTMLAtoms::size, value);
|
1998-09-23 21:44:33 +04:00
|
|
|
if (eHTMLUnit_Integer == value.GetUnit()) {
|
|
|
|
*aSize = value.GetIntValue();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::GetType(PRInt32* aType) const
|
|
|
|
{
|
|
|
|
nsresult result = NS_FORM_NOTOK;
|
|
|
|
if (mContent) {
|
|
|
|
nsIFormControl* formControl = nsnull;
|
2001-01-04 23:44:42 +03:00
|
|
|
result = mContent->QueryInterface(NS_GET_IID(nsIFormControl), (void**)&formControl);
|
1998-09-23 21:44:33 +04:00
|
|
|
if ((NS_OK == result) && formControl) {
|
|
|
|
result = formControl->GetType(aType);
|
|
|
|
NS_RELEASE(formControl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2001-11-02 10:40:01 +03:00
|
|
|
nsFormControlFrame::GetName(nsAString* aResult)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
nsresult result = NS_FORM_NOTOK;
|
2002-05-23 04:00:34 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIHTMLContent> formControl(do_QueryInterface(mContent));
|
|
|
|
|
|
|
|
if (formControl) {
|
|
|
|
nsHTMLValue value;
|
|
|
|
result = formControl->GetHTMLAttribute(nsHTMLAtoms::name, value);
|
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == result) {
|
|
|
|
if (eHTMLUnit_String == value.GetUnit()) {
|
|
|
|
value.GetStringValue(*aResult);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-02-11 04:13:28 +03:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
NS_IMETHODIMP
|
2001-11-02 10:40:01 +03:00
|
|
|
nsFormControlFrame::GetValue(nsAString* aResult)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
nsresult result = NS_FORM_NOTOK;
|
2002-05-23 04:00:34 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIHTMLContent> formControl(do_QueryInterface(mContent));
|
|
|
|
|
|
|
|
if (formControl) {
|
|
|
|
nsHTMLValue value;
|
|
|
|
result = formControl->GetHTMLAttribute(nsHTMLAtoms::value, value);
|
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == result) {
|
|
|
|
if (eHTMLUnit_String == value.GetUnit()) {
|
|
|
|
value.GetStringValue(*aResult);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-02-11 04:13:28 +03:00
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
NS_METHOD
|
1999-11-24 09:03:41 +03:00
|
|
|
nsFormControlFrame::HandleEvent(nsIPresContext* aPresContext,
|
1998-09-23 21:44:33 +04:00
|
|
|
nsGUIEvent* aEvent,
|
1999-11-24 09:03:41 +03:00
|
|
|
nsEventStatus* aEventStatus)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
1999-11-24 09:03:41 +03:00
|
|
|
NS_ENSURE_ARG_POINTER(aEventStatus);
|
|
|
|
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
|
1998-11-18 08:25:26 +03:00
|
|
|
return NS_OK;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
2000-08-09 03:38:00 +04:00
|
|
|
// Check for user-input:none style
|
|
|
|
const nsStyleUserInterface* uiStyle;
|
2000-08-09 04:52:02 +04:00
|
|
|
GetStyleData(eStyleStruct_UserInterface, (const nsStyleStruct *&)uiStyle);
|
2000-08-09 03:38:00 +04:00
|
|
|
if (uiStyle->mUserInput == NS_STYLE_USER_INPUT_NONE || uiStyle->mUserInput == NS_STYLE_USER_INPUT_DISABLED)
|
|
|
|
return nsFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
|
|
|
|
|
1999-05-14 01:29:57 +04:00
|
|
|
// if not native then use the NS_MOUSE_LEFT_CLICK to see if pressed
|
|
|
|
// unfortunately native widgets don't seem to handle this right.
|
|
|
|
// so use the old code for native stuff. -EDV
|
1999-08-06 09:11:39 +04:00
|
|
|
switch (aEvent->message) {
|
|
|
|
case NS_MOUSE_LEFT_CLICK:
|
1999-11-24 09:03:41 +03:00
|
|
|
MouseClicked(aPresContext);
|
1999-08-06 09:11:39 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NS_KEY_DOWN:
|
|
|
|
if (NS_KEY_EVENT == aEvent->eventStructType) {
|
|
|
|
nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent;
|
|
|
|
if (NS_VK_RETURN == keyEvent->keyCode) {
|
|
|
|
EnterPressed(aPresContext);
|
|
|
|
}
|
1999-09-08 23:55:08 +04:00
|
|
|
//else if (NS_VK_SPACE == keyEvent->keyCode) {
|
1999-11-24 09:03:41 +03:00
|
|
|
// MouseClicked(aPresContext);
|
1999-09-08 23:55:08 +04:00
|
|
|
//}
|
1999-08-06 09:11:39 +04:00
|
|
|
}
|
|
|
|
break;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
1999-05-14 01:29:57 +04:00
|
|
|
|
1999-11-24 09:03:41 +03:00
|
|
|
*aEventStatus = nsEventStatus_eConsumeDoDefault;
|
1998-09-23 21:44:33 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-22 18:32:57 +03:00
|
|
|
void
|
1999-11-24 09:03:41 +03:00
|
|
|
nsFormControlFrame::GetStyleSize(nsIPresContext* aPresContext,
|
1998-10-12 21:00:32 +04:00
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsSize& aSize)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
1999-07-20 07:41:03 +04:00
|
|
|
if (aReflowState.mComputedWidth != NS_INTRINSICSIZE) {
|
|
|
|
aSize.width = aReflowState.mComputedWidth;
|
1998-10-12 21:00:32 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-09-23 21:44:33 +04:00
|
|
|
aSize.width = CSS_NOTSET;
|
|
|
|
}
|
1999-07-20 07:41:03 +04:00
|
|
|
if (aReflowState.mComputedHeight != NS_INTRINSICSIZE) {
|
|
|
|
aSize.height = aReflowState.mComputedHeight;
|
1998-10-12 21:00:32 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-09-23 21:44:33 +04:00
|
|
|
aSize.height = CSS_NOTSET;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-01-22 18:32:57 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::GetFormContent(nsIContent*& aContent) const
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
1999-02-10 03:42:56 +03:00
|
|
|
nsIContent* content;
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
rv = GetContent(&content);
|
|
|
|
aContent = content;
|
|
|
|
return rv;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
1999-01-22 18:32:57 +03:00
|
|
|
NS_IMETHODIMP
|
2000-01-25 18:25:46 +03:00
|
|
|
nsFormControlFrame::GetFont(nsIPresContext* aPresContext,
|
|
|
|
const nsFont*& aFont)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
2000-01-25 18:25:46 +03:00
|
|
|
return nsFormControlHelper::GetFont(this, aPresContext, mStyleContext, aFont);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::GetDefaultCheckState(PRBool *aState)
|
2002-03-07 23:53:40 +03:00
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMHTMLInputElement> inputElement = do_QueryInterface(mContent);
|
|
|
|
if (inputElement) {
|
1999-01-06 03:02:27 +03:00
|
|
|
res = inputElement->GetDefaultChecked(aState);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::SetDefaultCheckState(PRBool aState)
|
1999-02-03 20:25:25 +03:00
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
2002-03-07 23:53:40 +03:00
|
|
|
nsCOMPtr<nsIDOMHTMLInputElement> inputElement = do_QueryInterface(mContent);
|
|
|
|
if (inputElement) {
|
1999-02-03 20:25:25 +03:00
|
|
|
res = inputElement->SetDefaultChecked(aState);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::GetCurrentCheckState(PRBool *aState)
|
1999-01-06 03:02:27 +03:00
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
2002-03-07 23:53:40 +03:00
|
|
|
nsCOMPtr<nsIDOMHTMLInputElement> inputElement = do_QueryInterface(mContent);
|
|
|
|
if (inputElement) {
|
1999-01-06 03:02:27 +03:00
|
|
|
res = inputElement->GetChecked(aState);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::SetCurrentCheckState(PRBool aState)
|
1999-01-06 03:02:27 +03:00
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
2002-03-07 23:53:40 +03:00
|
|
|
nsCOMPtr<nsIDOMHTMLInputElement> inputElement = do_QueryInterface(mContent);
|
|
|
|
if (inputElement) {
|
1999-01-06 03:02:27 +03:00
|
|
|
inputElement->SetChecked(aState);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
NS_IMETHODIMP
|
2002-03-24 01:26:36 +03:00
|
|
|
nsFormControlFrame::SetProperty(nsIPresContext* aPresContext, nsIAtom* aName, const nsAString& aValue)
|
1999-01-26 01:16:27 +03:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
NS_IMETHODIMP
|
2002-03-24 01:26:36 +03:00
|
|
|
nsFormControlFrame::GetProperty(nsIAtom* aName, nsAString& aValue)
|
1999-01-26 01:16:27 +03:00
|
|
|
{
|
2000-08-23 21:27:06 +04:00
|
|
|
aValue.Truncate();
|
1999-01-26 01:16:27 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::RequiresWidget(PRBool & aRequiresWidget)
|
1999-02-03 20:25:25 +03:00
|
|
|
{
|
|
|
|
aRequiresWidget = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-26 01:16:27 +03:00
|
|
|
|
1999-08-21 04:09:24 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::SetSuggestedSize(nscoord aWidth, nscoord aHeight)
|
fixed bugs #6303, #6753, #6756, #6759
Re-wrote nsComboboxFrame.
removed the obsolete nsHTMLAtoms: comboText,comoTextSelected,comTextSelectedFocus,dropDownVisible,
dropdownHidden, dropDownBtnOut, dropDownBtnPressed,
Added nsHTMLAtoms::combobox, nsLayoutAtoms::popupList
Renamed dropDownList to dropDownListPseudo
Added "arrow.gif" as to be used the background-image for the combobox button
ua.css - added rules for select to differentiate between comboboxes and listboxes.
Added style rules to more closely match the XPTOOLKIT XPWidgets look.
removed the following :-moz-combobox-text, -moz-combobox-textselected
nsIFormControlFrame.h - Added SetSuggestedSize method.
nsButtonControlFrame - Implemented SetSuggestedSize.
nsCSSFrameConstructor.cpp - Rewrote ConstructSelectFrame.
nsIWidget.h -Added GetAbsoluteBounds method.
nsWindow.cpp - Implemented GetAbsoluteBounds.
1999-07-15 02:00:24 +04:00
|
|
|
{
|
|
|
|
mSuggestedWidth = aWidth;
|
|
|
|
mSuggestedHeight = aHeight;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-11-15 18:16:28 +03:00
|
|
|
|
2000-03-18 16:45:30 +03:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::GetScreenHeight(nsIPresContext* aPresContext, nscoord& aHeight)
|
|
|
|
{
|
|
|
|
aHeight = 0;
|
2001-10-05 18:10:16 +04:00
|
|
|
nsCOMPtr<nsIDeviceContext> context;
|
|
|
|
aPresContext->GetDeviceContext( getter_AddRefs(context) );
|
|
|
|
if ( context ) {
|
|
|
|
nsRect screen;
|
|
|
|
|
|
|
|
PRBool dropdownCanOverlapOSBar = PR_FALSE;
|
|
|
|
nsCOMPtr<nsILookAndFeel> lookAndFeel;
|
|
|
|
aPresContext->GetLookAndFeel(getter_AddRefs(lookAndFeel));
|
|
|
|
if ( lookAndFeel )
|
|
|
|
lookAndFeel->GetMetric(nsILookAndFeel::eMetric_MenusCanOverlapOSBar, dropdownCanOverlapOSBar);
|
|
|
|
if ( dropdownCanOverlapOSBar )
|
|
|
|
context->GetRect ( screen );
|
|
|
|
else
|
|
|
|
context->GetClientRect(screen);
|
|
|
|
|
|
|
|
float devUnits;
|
|
|
|
context->GetDevUnitsToAppUnits(devUnits);
|
|
|
|
aHeight = NSToIntRound(float(screen.height) / devUnits );
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2000-03-18 16:45:30 +03:00
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2000-03-21 18:18:07 +03:00
|
|
|
|
|
|
|
// Calculate a frame's position in screen coordinates
|
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::GetAbsoluteFramePosition(nsIPresContext* aPresContext,
|
|
|
|
nsIFrame *aFrame,
|
|
|
|
nsRect& aAbsoluteTwipsRect,
|
|
|
|
nsRect& aAbsolutePixelRect)
|
|
|
|
{
|
|
|
|
//XXX: This code needs to take the view's offset into account when calculating
|
|
|
|
//the absolute coordinate of the frame.
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
aFrame->GetRect(aAbsoluteTwipsRect);
|
|
|
|
// zero these out,
|
|
|
|
// because the GetOffsetFromView figures them out
|
|
|
|
aAbsoluteTwipsRect.x = 0;
|
|
|
|
aAbsoluteTwipsRect.y = 0;
|
|
|
|
|
|
|
|
// Get conversions between twips and pixels
|
|
|
|
float t2p;
|
|
|
|
float p2t;
|
|
|
|
aPresContext->GetTwipsToPixels(&t2p);
|
|
|
|
aPresContext->GetPixelsToTwips(&p2t);
|
2002-02-20 00:33:26 +03:00
|
|
|
|
2000-03-21 18:18:07 +03:00
|
|
|
// Add in frame's offset from it it's containing view
|
|
|
|
nsIView *containingView = nsnull;
|
|
|
|
nsPoint offset;
|
|
|
|
rv = aFrame->GetOffsetFromView(aPresContext, offset, &containingView);
|
2002-02-20 00:33:26 +03:00
|
|
|
|
2000-03-21 18:18:07 +03:00
|
|
|
if (NS_SUCCEEDED(rv) && (nsnull != containingView)) {
|
|
|
|
aAbsoluteTwipsRect.x += offset.x;
|
|
|
|
aAbsoluteTwipsRect.y += offset.y;
|
|
|
|
|
|
|
|
nsPoint viewOffset;
|
|
|
|
containingView->GetPosition(&viewOffset.x, &viewOffset.y);
|
2002-02-20 00:33:26 +03:00
|
|
|
|
2000-03-21 18:18:07 +03:00
|
|
|
nsIView * parent;
|
|
|
|
containingView->GetParent(parent);
|
2000-04-12 18:51:10 +04:00
|
|
|
|
|
|
|
// if we don't have a parent view then
|
|
|
|
// check to see if we have a widget and adjust our offset for the widget
|
|
|
|
if (parent == nsnull) {
|
2002-02-20 00:33:26 +03:00
|
|
|
// account for space above and to the left of the containingView origin.
|
|
|
|
// the widget is aligned with containingView's bounds, not its origin
|
|
|
|
nsRect bounds;
|
|
|
|
containingView->GetBounds(bounds);
|
|
|
|
aAbsoluteTwipsRect.x += viewOffset.x - bounds.x;
|
|
|
|
aAbsoluteTwipsRect.y += viewOffset.y - bounds.y;
|
|
|
|
|
2000-03-21 18:18:07 +03:00
|
|
|
nsIWidget * widget;
|
2000-04-12 18:51:10 +04:00
|
|
|
containingView->GetWidget(widget);
|
2000-03-21 18:18:07 +03:00
|
|
|
if (nsnull != widget) {
|
|
|
|
// Add in the absolute offset of the widget.
|
|
|
|
nsRect absBounds;
|
|
|
|
nsRect lc;
|
|
|
|
widget->WidgetToScreen(lc, absBounds);
|
|
|
|
// Convert widget coordinates to twips
|
|
|
|
aAbsoluteTwipsRect.x += NSIntPixelsToTwips(absBounds.x, p2t);
|
|
|
|
aAbsoluteTwipsRect.y += NSIntPixelsToTwips(absBounds.y, p2t);
|
|
|
|
NS_RELEASE(widget);
|
|
|
|
}
|
2000-04-12 18:51:10 +04:00
|
|
|
rv = NS_OK;
|
|
|
|
} else {
|
|
|
|
while (nsnull != parent) {
|
|
|
|
nsPoint po;
|
|
|
|
parent->GetPosition(&po.x, &po.y);
|
|
|
|
viewOffset.x += po.x;
|
|
|
|
viewOffset.y += po.y;
|
|
|
|
nsIScrollableView * scrollView;
|
|
|
|
if (NS_OK == containingView->QueryInterface(NS_GET_IID(nsIScrollableView), (void **)&scrollView)) {
|
|
|
|
nscoord x;
|
|
|
|
nscoord y;
|
|
|
|
scrollView->GetScrollPosition(x, y);
|
|
|
|
viewOffset.x -= x;
|
|
|
|
viewOffset.y -= y;
|
|
|
|
}
|
|
|
|
nsIWidget * widget;
|
|
|
|
parent->GetWidget(widget);
|
|
|
|
if (nsnull != widget) {
|
2002-02-20 00:33:26 +03:00
|
|
|
// account for space above and to the left of the containingView origin.
|
|
|
|
// the widget is aligned with containingView's bounds, not its origin
|
|
|
|
nsRect bounds;
|
|
|
|
parent->GetBounds(bounds);
|
|
|
|
aAbsoluteTwipsRect.x += po.x - bounds.x;
|
|
|
|
aAbsoluteTwipsRect.y += po.y - bounds.y;
|
|
|
|
|
2000-04-12 18:51:10 +04:00
|
|
|
// Add in the absolute offset of the widget.
|
|
|
|
nsRect absBounds;
|
|
|
|
nsRect lc;
|
|
|
|
widget->WidgetToScreen(lc, absBounds);
|
|
|
|
// Convert widget coordinates to twips
|
|
|
|
aAbsoluteTwipsRect.x += NSIntPixelsToTwips(absBounds.x, p2t);
|
|
|
|
aAbsoluteTwipsRect.y += NSIntPixelsToTwips(absBounds.y, p2t);
|
|
|
|
NS_RELEASE(widget);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
parent->GetParent(parent);
|
|
|
|
}
|
|
|
|
aAbsoluteTwipsRect.x += viewOffset.x;
|
|
|
|
aAbsoluteTwipsRect.y += viewOffset.y;
|
2000-03-21 18:18:07 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// convert to pixel coordinates
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
aAbsolutePixelRect.x = NSTwipsToIntPixels(aAbsoluteTwipsRect.x, t2p);
|
|
|
|
aAbsolutePixelRect.y = NSTwipsToIntPixels(aAbsoluteTwipsRect.y, t2p);
|
|
|
|
aAbsolutePixelRect.width = NSTwipsToIntPixels(aAbsoluteTwipsRect.width, t2p);
|
|
|
|
aAbsolutePixelRect.height = NSTwipsToIntPixels(aAbsoluteTwipsRect.height, t2p);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|