1998-09-23 21:44:33 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
|
|
* http://www.mozilla.org/NPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* NPL.
|
|
|
|
*
|
|
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
|
|
* Communications Corporation. Portions created by Netscape are
|
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
|
|
* Reserved.
|
|
|
|
*/
|
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 "nsHTMLIIDs.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 "nsDOMEvent.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"
|
1998-12-15 22:03:36 +03:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
|
|
|
|
static NS_DEFINE_IID(kIWidgetIID, NS_IWIDGET_IID);
|
|
|
|
static NS_DEFINE_IID(kIFormControlIID, NS_IFORMCONTROL_IID);
|
|
|
|
static NS_DEFINE_IID(kIFormControlFrameIID, NS_IFORMCONTROLFRAME_IID);
|
|
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
1998-11-14 02:13:42 +03:00
|
|
|
static NS_DEFINE_IID(kViewCID, NS_VIEW_CID);
|
|
|
|
static NS_DEFINE_IID(kIViewIID, NS_IVIEW_IID);
|
1999-01-06 03:02:27 +03:00
|
|
|
static NS_DEFINE_IID(kIDOMHTMLInputElementIID, NS_IDOMHTMLINPUTELEMENT_IID);
|
1998-11-14 02:13:42 +03:00
|
|
|
|
1998-12-03 09:31:43 +03:00
|
|
|
nsFormControlFrame::nsFormControlFrame()
|
|
|
|
: nsLeafFrame()
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
mLastMouseState = eMouseNone;
|
|
|
|
mDidInit = PR_FALSE;
|
|
|
|
mWidget = nsnull;
|
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;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsFormControlFrame::~nsFormControlFrame()
|
|
|
|
{
|
|
|
|
mFormFrame = nsnull;
|
|
|
|
NS_IF_RELEASE(mWidget);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::QueryInterface(const nsIID& aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(0 != aInstancePtr, "null ptr");
|
|
|
|
if (NULL == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
if (aIID.Equals(kIFormControlFrameIID)) {
|
|
|
|
*aInstancePtr = (void*) ((nsIFormControlFrame*) this);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return nsLeafFrame::QueryInterface(aIID, aInstancePtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
nscoord
|
|
|
|
nsFormControlFrame::GetScrollbarWidth(float aPixToTwip)
|
|
|
|
{
|
|
|
|
return NSIntPixelsToTwips(19, aPixToTwip); // XXX this is windows
|
|
|
|
}
|
|
|
|
|
|
|
|
nscoord
|
|
|
|
nsFormControlFrame::GetVerticalBorderWidth(float aPixToTwip) const
|
|
|
|
{
|
|
|
|
return NSIntPixelsToTwips(3, aPixToTwip);
|
|
|
|
}
|
|
|
|
|
|
|
|
nscoord
|
|
|
|
nsFormControlFrame::GetHorizontalBorderWidth(float aPixToTwip) const
|
|
|
|
{
|
|
|
|
return GetVerticalBorderWidth(aPixToTwip);
|
|
|
|
}
|
|
|
|
|
|
|
|
nscoord
|
|
|
|
nsFormControlFrame::GetVerticalInsidePadding(float aPixToTwip,
|
|
|
|
nscoord aInnerHeight) const
|
|
|
|
{
|
|
|
|
return NSIntPixelsToTwips(3, aPixToTwip);
|
|
|
|
}
|
|
|
|
|
|
|
|
nscoord
|
|
|
|
nsFormControlFrame::GetHorizontalInsidePadding(nsIPresContext& aPresContext,
|
|
|
|
float aPixToTwip,
|
|
|
|
nscoord aInnerWidth,
|
|
|
|
nscoord aCharWidth) const
|
|
|
|
{
|
|
|
|
return GetVerticalInsidePadding(aPixToTwip, aInnerWidth);
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32
|
|
|
|
nsFormControlFrame::GetMaxNumValues()
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
nsFormControlFrame::GetNamesValues(PRInt32 aMaxNumValues, PRInt32& aNumValues,
|
|
|
|
nsString* aValues, nsString* aNames)
|
|
|
|
{
|
|
|
|
aNumValues = 0;
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
nsFormControlFrame::Paint(nsIPresContext& aPresContext,
|
1998-12-18 18:54:23 +03:00
|
|
|
nsIRenderingContext& aRenderingContext,
|
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
nsFramePaintLayer aWhichLayer)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
1998-12-18 18:54:23 +03:00
|
|
|
return nsLeafFrame::Paint(aPresContext, aRenderingContext, aDirtyRect,
|
|
|
|
aWhichLayer);
|
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;
|
|
|
|
GetStyleSize(*aPresContext, aReflowState, styleSize);
|
|
|
|
|
|
|
|
// 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
|
|
|
|
nsFormControlFrame::DidReflow(nsIPresContext& aPresContext,
|
|
|
|
nsDidReflowStatus aStatus)
|
|
|
|
{
|
|
|
|
nsresult rv = nsLeafFrame::DidReflow(aPresContext, aStatus);
|
|
|
|
|
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-02-10 08:38:18 +03:00
|
|
|
GetView(&view);
|
1999-05-20 02:14:11 +04:00
|
|
|
if (view) {
|
|
|
|
const nsStyleDisplay* display;
|
|
|
|
GetStyleData(eStyleStruct_Display, ((const nsStyleStruct *&)display));
|
|
|
|
nsViewVisibility newVis = NS_STYLE_VISIBILITY_HIDDEN == display->mVisible ? nsViewVisibility_kHide : nsViewVisibility_kShow;
|
|
|
|
nsViewVisibility oldVis;
|
|
|
|
// only change if different.
|
|
|
|
view->GetVisibility(oldVis);
|
|
|
|
if (newVis != oldVis)
|
|
|
|
view->SetVisibility(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
|
1998-11-10 09:05:32 +03:00
|
|
|
nsFormControlFrame::SetInitialChildList(nsIPresContext& aPresContext,
|
|
|
|
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-02-27 06:59:19 +03:00
|
|
|
nsFormControlFrame::Reflow(nsIPresContext& aPresContext,
|
|
|
|
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
|
|
|
{
|
|
|
|
nsresult result = NS_OK;
|
|
|
|
|
1999-04-27 04:06:03 +04:00
|
|
|
// add ourself as an nsIFormControlFrame
|
|
|
|
if (!mFormFrame && (eReflowReason_Initial == aReflowState.reason)) {
|
|
|
|
nsFormFrame::AddFormControlFrame(aPresContext, *this);
|
|
|
|
}
|
|
|
|
|
1999-02-12 20:45:58 +03:00
|
|
|
nsCOMPtr<nsIDeviceContext> dx;
|
|
|
|
aPresContext.GetDeviceContext(getter_AddRefs(dx));
|
1999-02-09 21:25:40 +03:00
|
|
|
PRBool requiresWidget = PR_TRUE;
|
|
|
|
|
|
|
|
// Checkto see if the device context supports widgets at all
|
1999-02-12 21:41:26 +03:00
|
|
|
if (dx) {
|
1999-02-09 21:25:40 +03:00
|
|
|
dx->SupportsNativeWidgets(requiresWidget);
|
|
|
|
}
|
|
|
|
|
1999-03-03 01:43:26 +03:00
|
|
|
nsWidgetRendering mode;
|
|
|
|
aPresContext.GetWidgetRenderingMode(&mode);
|
1999-07-21 02:32:41 +04:00
|
|
|
if ((eWidgetRendering_Gfx == mode) || (eWidgetRendering_PartialGfx == mode)) {
|
1999-03-03 01:43:26 +03:00
|
|
|
// Check with the frame to see if requires a widget to render
|
|
|
|
if (PR_TRUE == requiresWidget) {
|
|
|
|
RequiresWidget(requiresWidget);
|
|
|
|
}
|
1998-12-10 20:29:13 +03:00
|
|
|
}
|
|
|
|
|
1998-11-14 02:13:42 +03:00
|
|
|
GetDesiredSize(&aPresContext, aReflowState, aDesiredSize, mWidgetSize);
|
|
|
|
|
|
|
|
if (!mDidInit) {
|
1999-02-09 21:25:40 +03:00
|
|
|
if (PR_TRUE == requiresWidget) {
|
1999-02-12 20:45:58 +03:00
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
|
|
aPresContext.GetShell(getter_AddRefs(presShell));
|
|
|
|
nsCOMPtr<nsIViewManager> viewMan;
|
|
|
|
presShell->GetViewManager(getter_AddRefs(viewMan));
|
1999-02-09 21:25:40 +03:00
|
|
|
nsRect boundBox(0, 0, aDesiredSize.width, aDesiredSize.height);
|
|
|
|
|
|
|
|
// absolutely positioned controls already have a view but not a widget
|
|
|
|
nsIView* view = nsnull;
|
1999-02-10 08:38:18 +03:00
|
|
|
GetView(&view);
|
1999-02-09 21:25:40 +03:00
|
|
|
if (nsnull == view) {
|
1999-03-09 12:44:27 +03:00
|
|
|
result = nsComponentManager::CreateInstance(kViewCID, nsnull, kIViewIID, (void **)&view);
|
1999-02-09 21:25:40 +03:00
|
|
|
if (!NS_SUCCEEDED(result)) {
|
|
|
|
NS_ASSERTION(0, "Could not create view for form control");
|
|
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIFrame* parWithView;
|
|
|
|
nsIView *parView;
|
|
|
|
|
1999-02-10 08:38:18 +03:00
|
|
|
GetParentWithView(&parWithView);
|
|
|
|
parWithView->GetView(&parView);
|
1999-02-09 21:25:40 +03:00
|
|
|
|
|
|
|
// initialize the view as hidden since we don't know the (x,y) until Paint
|
|
|
|
result = view->Init(viewMan, boundBox, parView, nsnull, nsViewVisibility_kHide);
|
|
|
|
if (NS_OK != result) {
|
|
|
|
NS_ASSERTION(0, "view initialization failed");
|
|
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
viewMan->InsertChild(parView, view, 0);
|
|
|
|
SetView(view);
|
|
|
|
}
|
1998-11-14 02:13:42 +03:00
|
|
|
|
1999-02-09 21:25:40 +03:00
|
|
|
PRInt32 type;
|
|
|
|
GetType(&type);
|
|
|
|
const nsIID& id = GetCID();
|
1998-11-14 02:13:42 +03:00
|
|
|
|
1999-02-09 21:25:40 +03:00
|
|
|
if ((NS_FORM_INPUT_HIDDEN != type) && (PR_TRUE == requiresWidget)) {
|
|
|
|
// Do the following only if a widget is created
|
|
|
|
nsWidgetInitData* initData = GetWidgetInitData(aPresContext); // needs to be deleted
|
|
|
|
view->CreateWidget(id, initData);
|
1999-02-03 20:25:25 +03:00
|
|
|
|
1999-02-09 21:25:40 +03:00
|
|
|
if (nsnull != initData) {
|
|
|
|
delete(initData);
|
|
|
|
}
|
|
|
|
|
|
|
|
// set our widget
|
|
|
|
result = GetWidget(view, &mWidget);
|
1999-05-14 03:45:40 +04:00
|
|
|
if ((PR_FALSE == NS_SUCCEEDED(result)) || (nsnull == mWidget)) { // keep the ref on mWidget
|
1999-02-09 21:25:40 +03:00
|
|
|
NS_ASSERTION(0, "could not get widget");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PostCreateWidget(&aPresContext, aDesiredSize.width, aDesiredSize.height);
|
|
|
|
mDidInit = PR_TRUE;
|
1999-02-03 20:25:25 +03:00
|
|
|
|
1999-02-09 21:25:40 +03:00
|
|
|
if ((aDesiredSize.width != boundBox.width) || (aDesiredSize.height != boundBox.height)) {
|
|
|
|
viewMan->ResizeView(view, aDesiredSize.width, aDesiredSize.height);
|
1998-11-14 02:13:42 +03:00
|
|
|
}
|
|
|
|
|
1999-02-27 06:59:19 +03:00
|
|
|
} else {
|
1999-02-09 21:25:40 +03:00
|
|
|
PostCreateWidget(&aPresContext, aDesiredSize.width, aDesiredSize.height);
|
|
|
|
mDidInit = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
1998-11-14 02:13:42 +03:00
|
|
|
|
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
|
|
|
aDesiredSize.descent = 0;
|
|
|
|
|
|
|
|
if (nsnull != aDesiredSize.maxElementSize) {
|
1999-02-23 06:48:01 +03:00
|
|
|
//XXX aDesiredSize.AddBorderPaddingToMaxElementSize(borderPadding);
|
1998-11-14 02:13:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-11-10 02:30:16 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::AttributeChanged(nsIPresContext* aPresContext,
|
|
|
|
nsIContent* aChild,
|
|
|
|
nsIAtom* aAttribute,
|
|
|
|
PRInt32 aHint)
|
|
|
|
{
|
1999-01-26 10:57:54 +03:00
|
|
|
if (nsnull != mWidget) {
|
|
|
|
if (nsHTMLAtoms::disabled == aAttribute) {
|
|
|
|
mWidget->Enable(!nsFormFrame::GetDisabled(this));
|
|
|
|
}
|
|
|
|
}
|
1998-11-10 02:30:16 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
nsWidgetInitData*
|
|
|
|
nsFormControlFrame::GetWidgetInitData(nsIPresContext& aPresContext)
|
|
|
|
{
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
1998-09-29 01:32:24 +04:00
|
|
|
void
|
1998-10-08 08:38:41 +04:00
|
|
|
nsFormControlFrame::SetColors(nsIPresContext& aPresContext)
|
1998-09-29 01:32:24 +04:00
|
|
|
{
|
|
|
|
if (mWidget) {
|
1998-10-08 08:38:41 +04:00
|
|
|
nsCompatibility mode;
|
1999-02-12 20:45:58 +03:00
|
|
|
aPresContext.GetCompatibilityMode(&mode);
|
1998-10-08 08:38:41 +04:00
|
|
|
const nsStyleColor* color =
|
|
|
|
(const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color);
|
1998-09-29 01:32:24 +04:00
|
|
|
if (nsnull != color) {
|
1998-10-08 08:38:41 +04:00
|
|
|
if (!(NS_STYLE_BG_COLOR_TRANSPARENT & color->mBackgroundFlags)) {
|
|
|
|
mWidget->SetBackgroundColor(color->mBackgroundColor);
|
|
|
|
#ifdef bug_1021_closed
|
|
|
|
} else if (eCompatibility_NavQuirks == mode) {
|
|
|
|
#else
|
|
|
|
} else {
|
|
|
|
#endif
|
|
|
|
mWidget->SetBackgroundColor(NS_RGB(0xFF, 0xFF, 0xFF));
|
|
|
|
}
|
|
|
|
mWidget->SetForegroundColor(color->mColor);
|
1998-09-29 01:32:24 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
void
|
1998-10-15 03:01:44 +04:00
|
|
|
nsFormControlFrame::PostCreateWidget(nsIPresContext* aPresContext, nscoord& aWidth, nscoord& aHeight)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
1999-07-26 19:02:19 +04:00
|
|
|
// native widgets don't need to repaint
|
1998-10-23 03:00:37 +04:00
|
|
|
void
|
|
|
|
nsFormControlFrame::SetFocus(PRBool aOn, PRBool aRepaint)
|
|
|
|
{
|
1999-07-26 19:02:19 +04:00
|
|
|
if (mWidget) {
|
|
|
|
if (aOn) {
|
|
|
|
mWidget->SetFocus();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
//Unsetting of focus on native widget is accomplised
|
|
|
|
//by pushing focus up to its parent
|
|
|
|
nsIWidget *parentWidget = mWidget->GetParent();
|
|
|
|
if (parentWidget) {
|
|
|
|
parentWidget->SetFocus();
|
|
|
|
NS_RELEASE(parentWidget);
|
|
|
|
}
|
|
|
|
}
|
1998-10-23 03:00:37 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::GetWidget(nsIWidget** aWidget)
|
|
|
|
{
|
|
|
|
if (mWidget) {
|
|
|
|
NS_ADDREF(mWidget);
|
|
|
|
*aWidget = mWidget;
|
1998-10-14 01:31:26 +04:00
|
|
|
mWidget->Enable(!nsFormFrame::GetDisabled(this));
|
1998-09-23 21:44:33 +04:00
|
|
|
return NS_OK;
|
|
|
|
} else {
|
|
|
|
*aWidget = nsnull;
|
|
|
|
return NS_FORM_NOTOK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsFormControlFrame::GetWidget(nsIView* aView, nsIWidget** aWidget)
|
|
|
|
{
|
|
|
|
nsIWidget* widget;
|
|
|
|
aView->GetWidget(widget);
|
|
|
|
nsresult result;
|
|
|
|
|
|
|
|
if (nsnull == widget) {
|
|
|
|
*aWidget = nsnull;
|
|
|
|
result = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
result = widget->QueryInterface(kIWidgetIID, (void**)aWidget); // keep the ref
|
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
NS_ASSERTION(0, "The widget interface is invalid"); // need to print out more details of the widget
|
|
|
|
}
|
1998-11-23 07:41:51 +03:00
|
|
|
NS_RELEASE(widget);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
const nsIID&
|
|
|
|
nsFormControlFrame::GetIID()
|
|
|
|
{
|
|
|
|
static NS_DEFINE_IID(kButtonIID, NS_IBUTTON_IID);
|
|
|
|
return kButtonIID;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
nsIHTMLContent* content = nsnull;
|
|
|
|
mContent->QueryInterface(kIHTMLContentIID, (void**) &content);
|
|
|
|
if (nsnull != content) {
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
NS_RELEASE(content);
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
nsIHTMLContent* content = nsnull;
|
|
|
|
mContent->QueryInterface(kIHTMLContentIID, (void**) &content);
|
|
|
|
if (nsnull != content) {
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
NS_RELEASE(content);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::GetType(PRInt32* aType) const
|
|
|
|
{
|
|
|
|
nsresult result = NS_FORM_NOTOK;
|
|
|
|
if (mContent) {
|
|
|
|
nsIFormControl* formControl = nsnull;
|
|
|
|
result = mContent->QueryInterface(kIFormControlIID, (void**)&formControl);
|
|
|
|
if ((NS_OK == result) && formControl) {
|
|
|
|
result = formControl->GetType(aType);
|
|
|
|
NS_RELEASE(formControl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::GetName(nsString* aResult)
|
|
|
|
{
|
|
|
|
nsresult result = NS_FORM_NOTOK;
|
|
|
|
if (mContent) {
|
|
|
|
nsIHTMLContent* formControl = nsnull;
|
|
|
|
result = mContent->QueryInterface(kIHTMLContentIID, (void**)&formControl);
|
|
|
|
if ((NS_OK == result) && formControl) {
|
|
|
|
nsHTMLValue value;
|
1998-12-20 04:21:23 +03:00
|
|
|
result = formControl->GetHTMLAttribute(nsHTMLAtoms::name, value);
|
1998-09-23 21:44:33 +04:00
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == result) {
|
|
|
|
if (eHTMLUnit_String == value.GetUnit()) {
|
|
|
|
value.GetStringValue(*aResult);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_RELEASE(formControl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-02-11 04:13:28 +03:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsFormControlFrame::GetValue(nsString* aResult)
|
|
|
|
{
|
|
|
|
nsresult result = NS_FORM_NOTOK;
|
|
|
|
if (mContent) {
|
|
|
|
nsIHTMLContent* formControl = nsnull;
|
|
|
|
result = mContent->QueryInterface(kIHTMLContentIID, (void**)&formControl);
|
|
|
|
if ((NS_OK == result) && formControl) {
|
|
|
|
nsHTMLValue value;
|
1998-12-20 04:21:23 +03:00
|
|
|
result = formControl->GetHTMLAttribute(nsHTMLAtoms::value, value);
|
1998-09-23 21:44:33 +04:00
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == result) {
|
|
|
|
if (eHTMLUnit_String == value.GetUnit()) {
|
|
|
|
value.GetStringValue(*aResult);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_RELEASE(formControl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-02-11 04:13:28 +03:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
PRBool
|
1998-10-30 21:05:29 +03:00
|
|
|
nsFormControlFrame::IsSuccessful(nsIFormControlFrame* aSubmitter)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
|
|
|
nsAutoString name;
|
1999-01-13 02:11:26 +03:00
|
|
|
// Since JS Submit() calls are not linked to an element, aSubmitter is null.
|
|
|
|
// Return success to allow the call to go through.
|
|
|
|
if (aSubmitter == nsnull) return PR_TRUE;
|
1998-09-23 21:44:33 +04:00
|
|
|
return (NS_CONTENT_ATTR_HAS_VALUE == GetName(&name));
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_METHOD nsFormControlFrame::HandleEvent(nsIPresContext& aPresContext,
|
|
|
|
nsGUIEvent* aEvent,
|
|
|
|
nsEventStatus& aEventStatus)
|
|
|
|
{
|
1998-11-18 08:25:26 +03:00
|
|
|
if (nsEventStatus_eConsumeNoDefault == aEventStatus) {
|
|
|
|
return NS_OK;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
|
1999-02-04 01:56:50 +03:00
|
|
|
if (nsnull != mWidget) {
|
|
|
|
// make sure that the widget in the event is this input
|
|
|
|
// XXX if there is no view, it could be an image button. Unfortunately,
|
|
|
|
// every image button will get every event.
|
|
|
|
nsIView* view;
|
1999-02-10 08:38:18 +03:00
|
|
|
GetView(&view);
|
1999-02-04 01:56:50 +03:00
|
|
|
if (view) {
|
|
|
|
if (mWidget != aEvent->widget) {
|
|
|
|
aEventStatus = nsEventStatus_eIgnore;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
if (nsnull == mWidget) {
|
|
|
|
switch (aEvent->message) {
|
|
|
|
case NS_MOUSE_LEFT_CLICK:
|
|
|
|
MouseClicked(&aPresContext);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
//printf(" %d %d %d %d (%d,%d) \n", this, aEvent->widget, aEvent->widgetSupports,
|
|
|
|
// aEvent->message, aEvent->point.x, aEvent->point.y);
|
|
|
|
|
|
|
|
PRInt32 type;
|
|
|
|
GetType(&type);
|
|
|
|
switch (aEvent->message) {
|
|
|
|
case NS_MOUSE_ENTER:
|
|
|
|
mLastMouseState = eMouseEnter;
|
|
|
|
break;
|
|
|
|
case NS_MOUSE_LEFT_BUTTON_DOWN:
|
|
|
|
if (NS_FORM_INPUT_IMAGE == type) {
|
|
|
|
mLastMouseState = eMouseDown;
|
|
|
|
} else {
|
|
|
|
mLastMouseState = (eMouseEnter == mLastMouseState) ? eMouseDown : eMouseNone;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NS_MOUSE_LEFT_BUTTON_UP:
|
|
|
|
if (eMouseDown == mLastMouseState) {
|
|
|
|
MouseClicked(&aPresContext);
|
|
|
|
}
|
|
|
|
mLastMouseState = eMouseEnter;
|
|
|
|
break;
|
|
|
|
case NS_MOUSE_EXIT:
|
|
|
|
mLastMouseState = eMouseNone;
|
|
|
|
break;
|
1999-05-28 05:05:19 +04:00
|
|
|
case NS_CONTROL_CHANGE:
|
|
|
|
ControlChanged(&aPresContext);
|
|
|
|
break;
|
1999-05-14 01:29:57 +04:00
|
|
|
}
|
1999-05-13 05:35:16 +04:00
|
|
|
}
|
|
|
|
|
1999-05-14 01:29:57 +04:00
|
|
|
// see if a key was pressed
|
|
|
|
switch (aEvent->message) {
|
|
|
|
case NS_KEY_DOWN:
|
|
|
|
if (NS_KEY_EVENT == aEvent->eventStructType) {
|
|
|
|
nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent;
|
|
|
|
if (NS_VK_RETURN == keyEvent->keyCode) {
|
1999-06-03 22:05:40 +04:00
|
|
|
EnterPressed(aPresContext);
|
|
|
|
}
|
1999-05-14 01:29:57 +04:00
|
|
|
else if (NS_VK_SPACE == keyEvent->keyCode) {
|
|
|
|
MouseClicked(&aPresContext);
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
1999-05-14 01:29:57 +04:00
|
|
|
}
|
|
|
|
break;
|
1998-09-23 21:44:33 +04:00
|
|
|
}
|
1999-05-14 01:29:57 +04:00
|
|
|
|
1998-09-23 21:44:33 +04:00
|
|
|
aEventStatus = nsEventStatus_eConsumeDoDefault;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-22 18:32:57 +03:00
|
|
|
void
|
1998-10-12 21:00:32 +04:00
|
|
|
nsFormControlFrame::GetStyleSize(nsIPresContext& aPresContext,
|
|
|
|
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
|
|
|
void
|
|
|
|
nsFormControlFrame::Reset()
|
1998-09-29 01:32:24 +04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
nsFormControlFrame::GetFont(nsIPresContext* aPresContext,
|
|
|
|
nsFont& aFont)
|
1998-09-23 21:44:33 +04:00
|
|
|
{
|
1999-01-22 18:32:57 +03:00
|
|
|
nsFormControlHelper::GetFont(this, aPresContext, mStyleContext, aFont);
|
1998-09-23 21:44:33 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-06 03:02:27 +03:00
|
|
|
nsresult nsFormControlFrame::GetDefaultCheckState(PRBool *aState)
|
1999-02-09 21:25:40 +03:00
|
|
|
{ nsresult res = NS_OK;
|
1999-01-06 03:02:27 +03:00
|
|
|
nsIDOMHTMLInputElement* inputElement;
|
|
|
|
if (NS_OK == mContent->QueryInterface(kIDOMHTMLInputElementIID, (void**)&inputElement)) {
|
|
|
|
res = inputElement->GetDefaultChecked(aState);
|
|
|
|
NS_RELEASE(inputElement);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-02-03 20:25:25 +03:00
|
|
|
nsresult nsFormControlFrame::SetDefaultCheckState(PRBool aState)
|
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
|
|
|
nsIDOMHTMLInputElement* inputElement;
|
|
|
|
if (NS_OK == mContent->QueryInterface(kIDOMHTMLInputElementIID, (void**)&inputElement)) {
|
|
|
|
res = inputElement->SetDefaultChecked(aState);
|
|
|
|
NS_RELEASE(inputElement);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-01-06 03:02:27 +03:00
|
|
|
nsresult nsFormControlFrame::GetCurrentCheckState(PRBool *aState)
|
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
|
|
|
nsIDOMHTMLInputElement* inputElement;
|
|
|
|
if (NS_OK == mContent->QueryInterface(kIDOMHTMLInputElementIID, (void**)&inputElement)) {
|
|
|
|
res = inputElement->GetChecked(aState);
|
|
|
|
NS_RELEASE(inputElement);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult nsFormControlFrame::SetCurrentCheckState(PRBool aState)
|
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
|
|
|
nsIDOMHTMLInputElement* inputElement;
|
|
|
|
if (NS_OK == mContent->QueryInterface(kIDOMHTMLInputElementIID, (void**)&inputElement)) {
|
|
|
|
inputElement->SetChecked(aState);
|
|
|
|
NS_RELEASE(inputElement);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-01-26 01:16:27 +03:00
|
|
|
NS_IMETHODIMP nsFormControlFrame::SetProperty(nsIAtom* aName, const nsString& aValue)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsFormControlFrame::GetProperty(nsIAtom* aName, nsString& aValue)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-02-03 20:25:25 +03:00
|
|
|
nsresult nsFormControlFrame::RequiresWidget(PRBool & aRequiresWidget)
|
|
|
|
{
|
|
|
|
aRequiresWidget = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-26 01:16:27 +03:00
|
|
|
|
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
|
|
|
NS_IMETHODIMP nsFormControlFrame::SetSuggestedSize(nscoord aWidth, nscoord aHeight)
|
|
|
|
{
|
|
|
|
mSuggestedWidth = aWidth;
|
|
|
|
mSuggestedHeight = aHeight;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|