зеркало из https://github.com/mozilla/pjs.git
671 строка
20 KiB
C++
671 строка
20 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* 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/
|
|
*
|
|
* 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.
|
|
*
|
|
* The Original Code is Mozilla XForms support.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Novell, Inc.
|
|
* Portions created by the Initial Developer are Copyright (C) 2004
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Allan Beaufour <abeaufour@novell.com>
|
|
* Olli Pettay <Olli.Pettay@helsinki.fi>
|
|
*
|
|
* 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 MPL, 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 MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#include "nsIModelElementPrivate.h"
|
|
#include "nsXFormsControlStub.h"
|
|
#include "nsXFormsMDGEngine.h"
|
|
|
|
#include "nsIDOMDocument.h"
|
|
#include "nsIDOMEvent.h"
|
|
#include "nsIDOMKeyEvent.h"
|
|
#include "nsIDOMEventTarget.h"
|
|
#include "nsIDOMXPathResult.h"
|
|
#include "nsIXTFXMLVisualWrapper.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsXFormsModelElement.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsIFocusController.h"
|
|
#include "nsIScriptGlobalObject.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsIEventStateManager.h"
|
|
#include "nsIContent.h"
|
|
|
|
/** This class is used to generate xforms-hint and xforms-help events.*/
|
|
class nsXFormsHintHelpListener : public nsIDOMEventListener {
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIDOMEVENTLISTENER
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS1(nsXFormsHintHelpListener, nsIDOMEventListener)
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsHintHelpListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
{
|
|
if (!aEvent)
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
nsCOMPtr<nsIDOMEventTarget> target;
|
|
aEvent->GetCurrentTarget(getter_AddRefs(target));
|
|
nsCOMPtr<nsIDOMNode> targetNode(do_QueryInterface(target));
|
|
if (nsXFormsUtils::EventHandlingAllowed(aEvent, targetNode)) {
|
|
nsCOMPtr<nsIDOMKeyEvent> keyEvent(do_QueryInterface(aEvent));
|
|
if (keyEvent) {
|
|
PRUint32 code = 0;
|
|
keyEvent->GetKeyCode(&code);
|
|
if (code == nsIDOMKeyEvent::DOM_VK_F1) {
|
|
PRBool defaultEnabled = PR_TRUE;
|
|
nsresult rv = nsXFormsUtils::DispatchEvent(targetNode, eEvent_Help,
|
|
&defaultEnabled);
|
|
|
|
// If the xforms event's default behavior was disabled, prevent the DOM
|
|
// event's default action as well. This means that the F1 key was
|
|
// handled (a help dialog was shown) and we don't want the browser to
|
|
// show it's help dialog.
|
|
if (NS_SUCCEEDED(rv) && !defaultEnabled)
|
|
aEvent->PreventDefault();
|
|
}
|
|
} else {
|
|
nsAutoString type;
|
|
aEvent->GetType(type);
|
|
nsXFormsUtils::DispatchEvent(targetNode,
|
|
(type.EqualsLiteral("mouseover") ||
|
|
type.EqualsLiteral("focus"))
|
|
? eEvent_Hint : eEvent_MozHintOff);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::GetBoundNode(nsIDOMNode **aBoundNode)
|
|
{
|
|
NS_IF_ADDREF(*aBoundNode = mBoundNode);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::GetDependencies(nsCOMArray<nsIDOMNode> **aDependencies)
|
|
{
|
|
if (aDependencies)
|
|
*aDependencies = &mDependencies;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::GetElement(nsIDOMElement **aElement)
|
|
{
|
|
NS_IF_ADDREF(*aElement = mElement);
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsXFormsControlStubBase::RemoveIndexListeners()
|
|
{
|
|
if (!mIndexesUsed.Count())
|
|
return;
|
|
|
|
for (PRInt32 i = 0; i < mIndexesUsed.Count(); ++i) {
|
|
nsCOMPtr<nsIXFormsRepeatElement> rep = mIndexesUsed[i];
|
|
rep->RemoveIndexUser(this);
|
|
}
|
|
|
|
mIndexesUsed.Clear();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::ResetBoundNode(const nsString &aBindAttribute,
|
|
PRUint16 aResultType,
|
|
nsIDOMXPathResult **aResult)
|
|
{
|
|
// Clear existing bound node, etc.
|
|
mBoundNode = nsnull;
|
|
mDependencies.Clear();
|
|
RemoveIndexListeners();
|
|
|
|
if (!mHasParent || !mBindAttrsCount)
|
|
return NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMXPathResult> result;
|
|
nsresult rv =
|
|
ProcessNodeBinding(aBindAttribute,
|
|
aResultType,
|
|
getter_AddRefs(result));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
nsXFormsUtils::ReportError(NS_LITERAL_STRING("controlBindError"), mElement);
|
|
return rv;
|
|
}
|
|
|
|
if (!result)
|
|
return NS_OK;
|
|
|
|
// Get context node, if any
|
|
result->GetSingleNodeValue(getter_AddRefs(mBoundNode));
|
|
|
|
if (mBoundNode && mModel) {
|
|
mModel->SetStates(this, mBoundNode);
|
|
} else if (mModel) {
|
|
// we should have been successful. Must be pointing to a node that
|
|
// doesn't exist in the instance document. Disable the control
|
|
// per 4.2.2 in the spec
|
|
|
|
nsCOMPtr<nsIXTFElementWrapper> xtfWrap(do_QueryInterface(mElement));
|
|
NS_ENSURE_STATE(xtfWrap);
|
|
xtfWrap->SetIntrinsicState(NS_EVENT_STATE_DISABLED);
|
|
|
|
// Dispatch event
|
|
nsXFormsUtils::DispatchEvent(mElement, eEvent_Disabled);
|
|
}
|
|
|
|
if (aResult) {
|
|
*aResult = nsnull;
|
|
result.swap(*aResult);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::Bind()
|
|
{
|
|
return ResetBoundNode(NS_LITERAL_STRING("ref"),
|
|
nsIDOMXPathResult::FIRST_ORDERED_NODE_TYPE);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::TryFocus(PRBool* aOK)
|
|
{
|
|
*aOK = PR_FALSE;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::IsEventTarget(PRBool *aOK)
|
|
{
|
|
*aOK = PR_TRUE;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::ProcessNodeBinding(const nsString &aBindingAttr,
|
|
PRUint16 aResultType,
|
|
nsIDOMXPathResult **aResult,
|
|
nsIModelElementPrivate **aModel)
|
|
{
|
|
nsStringArray indexesUsed;
|
|
|
|
// let's not go through all of this rigamarol if we don't have a chance
|
|
// in heck of binding anyhow. Check to see if the models will be receptive
|
|
// to some binding. readyForBindProperty is set when they are. Make sure
|
|
// to return NS_OK so that we don't start complaining about binding
|
|
// failures in this situation.
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
mElement->GetOwnerDocument(getter_AddRefs(domDoc));
|
|
|
|
if (!nsXFormsUtils::IsDocumentReadyForBind(domDoc)) {
|
|
nsXFormsModelElement::DeferElementBind(domDoc, this);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult rv;
|
|
rv = nsXFormsUtils::EvaluateNodeBinding(mElement,
|
|
kElementFlags,
|
|
aBindingAttr,
|
|
EmptyString(),
|
|
aResultType,
|
|
getter_AddRefs(mModel),
|
|
aResult,
|
|
&mDependencies,
|
|
&indexesUsed);
|
|
NS_ENSURE_STATE(mModel);
|
|
|
|
mModel->AddFormControl(this);
|
|
if (aModel)
|
|
NS_ADDREF(*aModel = mModel);
|
|
|
|
if (NS_SUCCEEDED(rv) && indexesUsed.Count()) {
|
|
// add index listeners on repeat elements
|
|
|
|
for (PRInt32 i = 0; i < indexesUsed.Count(); ++i) {
|
|
// Find the repeat element and add |this| as a listener
|
|
nsCOMPtr<nsIDOMElement> repElem;
|
|
domDoc->GetElementById(*(indexesUsed[i]), getter_AddRefs(repElem));
|
|
nsCOMPtr<nsIXFormsRepeatElement> rep(do_QueryInterface(repElem));
|
|
if (!rep)
|
|
continue;
|
|
|
|
rv = rep->AddIndexUser(this);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = mIndexesUsed.AppendObject(rep);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsXFormsControlStubBase::ResetHelpAndHint(PRBool aInitialize)
|
|
{
|
|
nsCOMPtr<nsIDOMEventTarget> targ(do_QueryInterface(mElement));
|
|
if (!targ)
|
|
return;
|
|
|
|
NS_NAMED_LITERAL_STRING(mouseover, "mouseover");
|
|
NS_NAMED_LITERAL_STRING(mouseout, "mouseout");
|
|
NS_NAMED_LITERAL_STRING(focus, "focus");
|
|
NS_NAMED_LITERAL_STRING(blur, "blur");
|
|
NS_NAMED_LITERAL_STRING(keypress, "keypress");
|
|
|
|
if (mEventListener) {
|
|
targ->RemoveEventListener(mouseover, mEventListener, PR_TRUE);
|
|
targ->RemoveEventListener(mouseout, mEventListener, PR_TRUE);
|
|
targ->RemoveEventListener(focus, mEventListener, PR_TRUE);
|
|
targ->RemoveEventListener(blur, mEventListener, PR_TRUE);
|
|
targ->RemoveEventListener(keypress, mEventListener, PR_TRUE);
|
|
mEventListener = nsnull;
|
|
}
|
|
|
|
if (aInitialize) {
|
|
mEventListener = new nsXFormsHintHelpListener();
|
|
if (!mEventListener)
|
|
return;
|
|
|
|
targ->AddEventListener(mouseover, mEventListener, PR_TRUE);
|
|
targ->AddEventListener(mouseout, mEventListener, PR_TRUE);
|
|
targ->AddEventListener(focus, mEventListener, PR_TRUE);
|
|
targ->AddEventListener(blur, mEventListener, PR_TRUE);
|
|
targ->AddEventListener(keypress, mEventListener, PR_TRUE);
|
|
}
|
|
}
|
|
|
|
PRBool
|
|
nsXFormsControlStubBase::GetRelevantState()
|
|
{
|
|
PRBool res = PR_FALSE;
|
|
nsCOMPtr<nsIContent> content(do_QueryInterface(mElement));
|
|
if (content && (content->IntrinsicState() & NS_EVENT_STATE_ENABLED)) {
|
|
res = PR_TRUE;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::HandleDefault(nsIDOMEvent *aEvent,
|
|
PRBool *aHandled)
|
|
{
|
|
NS_ENSURE_ARG(aHandled);
|
|
*aHandled = PR_FALSE;
|
|
|
|
if (nsXFormsUtils::EventHandlingAllowed(aEvent, mElement)) {
|
|
|
|
// Check that we are the target of the event
|
|
nsCOMPtr<nsIDOMEventTarget> target;
|
|
aEvent->GetTarget(getter_AddRefs(target));
|
|
nsCOMPtr<nsIDOMElement> targetE(do_QueryInterface(target));
|
|
if (targetE && targetE != mElement) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Handle event
|
|
nsAutoString type;
|
|
aEvent->GetType(type);
|
|
|
|
if (type.EqualsASCII(sXFormsEventsEntries[eEvent_Focus].name)) {
|
|
TryFocus(aHandled);
|
|
} else if (type.Equals(NS_LITERAL_STRING("keypress"))) {
|
|
nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aEvent);
|
|
if (keyEvent) {
|
|
PRUint32 keycode;
|
|
keyEvent->GetKeyCode(&keycode);
|
|
if (keycode == nsIDOMKeyEvent::DOM_VK_TAB) {
|
|
PRBool extraKey = PR_FALSE;
|
|
|
|
keyEvent->GetAltKey(&extraKey);
|
|
if (extraKey) {
|
|
return NS_OK;
|
|
}
|
|
|
|
keyEvent->GetCtrlKey(&extraKey);
|
|
if (extraKey) {
|
|
return NS_OK;
|
|
}
|
|
|
|
keyEvent->GetMetaKey(&extraKey);
|
|
if (extraKey) {
|
|
return NS_OK;
|
|
}
|
|
|
|
keyEvent->GetShiftKey(&extraKey);
|
|
mPreventLoop = PR_TRUE;
|
|
if (extraKey) {
|
|
nsXFormsUtils::DispatchEvent(mElement, eEvent_Previous);
|
|
} else {
|
|
nsXFormsUtils::DispatchEvent(mElement, eEvent_Next);
|
|
}
|
|
}
|
|
}
|
|
} else if (type.EqualsASCII(sXFormsEventsEntries[eEvent_Next].name) ||
|
|
type.EqualsASCII(sXFormsEventsEntries[eEvent_Previous].name)) {
|
|
|
|
// only continue this processing if xforms-next or xforms-previous were
|
|
// dispatched by the form and not as part of the 'tab' and 'shift+tab'
|
|
// processing
|
|
if (mPreventLoop) {
|
|
mPreventLoop = PR_FALSE;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
mElement->GetOwnerDocument(getter_AddRefs(domDoc));
|
|
|
|
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
|
|
// element isn't in a document, yet? Odd, indeed. Well, if not in
|
|
// document, these two events have no meaning.
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
|
|
nsCOMPtr<nsPIDOMWindow> win =
|
|
do_QueryInterface(doc->GetScriptGlobalObject());
|
|
|
|
|
|
// An inelegant way to retrieve this to be sure, but we are
|
|
// guaranteed that the focus controller outlives us, so it
|
|
// is safe to hold on to it (since we can't die until it has
|
|
// died).
|
|
nsIFocusController *focusController = win->GetRootFocusController();
|
|
if (focusController &&
|
|
type.EqualsASCII(sXFormsEventsEntries[eEvent_Next].name)) {
|
|
focusController->MoveFocus(PR_TRUE, nsnull);
|
|
} else {
|
|
focusController->MoveFocus(PR_FALSE, nsnull);
|
|
}
|
|
} else if (type.EqualsASCII(sXFormsEventsEntries[eEvent_BindingException].name)) {
|
|
*aHandled = nsXFormsUtils::HandleBindingException(mElement);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#ifdef DEBUG_smaug
|
|
static nsVoidArray* sControlList = nsnull;
|
|
class ControlDebug
|
|
{
|
|
public:
|
|
ControlDebug() {
|
|
sControlList = new nsVoidArray();
|
|
NS_ASSERTION(sControlList, "Out of memory!");
|
|
}
|
|
|
|
~ControlDebug() {
|
|
for (PRInt32 i = 0; i < sControlList->Count(); ++i) {
|
|
nsXFormsControlStubBase* control =
|
|
NS_STATIC_CAST(nsXFormsControlStubBase*, sControlList->ElementAt(i));
|
|
if (control) {
|
|
printf("Possible leak, <xforms:%s>\n", control->Name());
|
|
}
|
|
}
|
|
delete sControlList;
|
|
sControlList = nsnull;
|
|
}
|
|
};
|
|
|
|
static ControlDebug tester = ControlDebug();
|
|
#endif
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::Create(nsIXTFElementWrapper *aWrapper)
|
|
{
|
|
aWrapper->SetNotificationMask(kStandardNotificationMask);
|
|
|
|
// It's ok to keep a weak pointer to mElement. mElement will have an
|
|
// owning reference to this object, so as long as we null out mElement in
|
|
// OnDestroyed, it will always be valid.
|
|
nsCOMPtr<nsIDOMElement> node;
|
|
aWrapper->GetElementNode(getter_AddRefs(node));
|
|
mElement = node;
|
|
NS_ASSERTION(mElement, "Wrapper is not an nsIDOMElement, we'll crash soon");
|
|
|
|
ResetHelpAndHint(PR_TRUE);
|
|
|
|
// enabled is on pr. default
|
|
aWrapper->SetIntrinsicState(NS_EVENT_STATE_ENABLED);
|
|
|
|
#ifdef DEBUG_smaug
|
|
sControlList->AppendElement(this);
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::OnDestroyed()
|
|
{
|
|
ResetHelpAndHint(PR_FALSE);
|
|
RemoveIndexListeners();
|
|
|
|
if (mModel) {
|
|
mModel->RemoveFormControl(this);
|
|
mModel = nsnull;
|
|
}
|
|
|
|
#ifdef DEBUG_smaug
|
|
sControlList->RemoveElement(this);
|
|
#endif
|
|
|
|
mElement = nsnull;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::DocumentChanged(nsIDOMDocument *aNewDocument)
|
|
{
|
|
// We need to re-evaluate our instance data binding when our document
|
|
// changes, since our context can change
|
|
if (aNewDocument) {
|
|
Bind();
|
|
Refresh();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::ParentChanged(nsIDOMElement *aNewParent)
|
|
{
|
|
mHasParent = aNewParent != nsnull;
|
|
// We need to re-evaluate our instance data binding when our parent changes,
|
|
// since xmlns declarations or our context could have changed.
|
|
if (mHasParent) {
|
|
Bind();
|
|
Refresh();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::WillSetAttribute(nsIAtom *aName, const nsAString &aValue)
|
|
{
|
|
MaybeRemoveFromModel(aName, aValue);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::AttributeSet(nsIAtom *aName, const nsAString &aValue)
|
|
{
|
|
MaybeBindAndRefresh(aName);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::WillRemoveAttribute(nsIAtom *aName)
|
|
{
|
|
MaybeRemoveFromModel(aName, EmptyString());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsXFormsControlStubBase::AttributeRemoved(nsIAtom *aName)
|
|
{
|
|
MaybeBindAndRefresh(aName);
|
|
return NS_OK;
|
|
}
|
|
|
|
// nsIXFormsContextControl
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::SetContext(nsIDOMNode *aContextNode,
|
|
PRInt32 aContextPosition,
|
|
PRInt32 aContextSize)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXFormsControlStubBase::GetContext(nsAString &aModelID,
|
|
nsIDOMNode **aContextNode,
|
|
PRInt32 *aContextPosition,
|
|
PRInt32 *aContextSize)
|
|
{
|
|
NS_ENSURE_ARG(aContextSize);
|
|
NS_ENSURE_ARG(aContextPosition);
|
|
|
|
*aContextPosition = 1;
|
|
*aContextSize = 1;
|
|
|
|
if (aContextNode) {
|
|
if (mBoundNode) {
|
|
// We are bound to a node: This is the context node
|
|
CallQueryInterface(mBoundNode, aContextNode); // addrefs
|
|
NS_ASSERTION(*aContextNode, "could not QI context node from bound node?");
|
|
} else if (mModel) {
|
|
// We are bound to a model: The document element of its default instance
|
|
// document is the context node
|
|
nsCOMPtr<nsIDOMDocument> instanceDoc;
|
|
mModel->GetInstanceDocument(EmptyString(), getter_AddRefs(instanceDoc));
|
|
NS_ENSURE_STATE(instanceDoc);
|
|
|
|
nsIDOMElement* docElement;
|
|
instanceDoc->GetDocumentElement(&docElement); // addrefs
|
|
NS_ENSURE_STATE(docElement);
|
|
*aContextNode = docElement; // addref'ed above
|
|
}
|
|
}
|
|
|
|
///
|
|
/// @todo expensive to run this
|
|
nsCOMPtr<nsIDOMElement> model = do_QueryInterface(mModel);
|
|
if (model) {
|
|
model->GetAttribute(NS_LITERAL_STRING("id"), aModelID);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsXFormsControlStubBase::ResetProperties()
|
|
{
|
|
nsCOMPtr<nsIXTFElementWrapper> xtfWrap(do_QueryInterface(mElement));
|
|
if (!xtfWrap) {
|
|
return;
|
|
}
|
|
|
|
// enabled is on pr. default
|
|
xtfWrap->SetIntrinsicState(NS_EVENT_STATE_ENABLED);
|
|
}
|
|
|
|
void
|
|
nsXFormsControlStubBase::AddRemoveSNBAttr(nsIAtom *aName, const nsAString &aValue)
|
|
{
|
|
nsAutoString attrStr, attrValue;
|
|
aName->ToString(attrStr);
|
|
mElement->GetAttribute(attrStr, attrValue);
|
|
|
|
// if we are setting a single node binding attribute that we don't already
|
|
// have, bump the count.
|
|
if (!aValue.IsEmpty() && attrValue.IsEmpty()) {
|
|
++mBindAttrsCount;
|
|
} else if (!attrValue.IsEmpty()) {
|
|
// if we are setting a currently existing binding attribute to have an
|
|
// empty value, treat it like the binding attr is being removed.
|
|
--mBindAttrsCount;
|
|
NS_ASSERTION(mBindAttrsCount>=0, "bad mojo! mBindAttrsCount < 0!");
|
|
if (!mBindAttrsCount) {
|
|
ResetProperties();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsXFormsControlStubBase::MaybeBindAndRefresh(nsIAtom *aName)
|
|
{
|
|
if (aName == nsXFormsAtoms::bind ||
|
|
aName == nsXFormsAtoms::ref ||
|
|
aName == nsXFormsAtoms::model) {
|
|
|
|
Bind();
|
|
Refresh();
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
nsXFormsControlStubBase::MaybeRemoveFromModel(nsIAtom *aName,
|
|
const nsAString &aValue)
|
|
{
|
|
if (aName == nsXFormsAtoms::model ||
|
|
aName == nsXFormsAtoms::bind ||
|
|
aName == nsXFormsAtoms::ref) {
|
|
if (mModel)
|
|
mModel->RemoveFormControl(this);
|
|
|
|
AddRemoveSNBAttr(aName, aValue);
|
|
}
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED3(nsXFormsControlStub,
|
|
nsXFormsXMLVisualStub,
|
|
nsIXFormsContextControl,
|
|
nsIXFormsControl,
|
|
nsIXFormsControlBase)
|
|
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED3(nsXFormsBindableControlStub,
|
|
nsXFormsBindableStub,
|
|
nsIXFormsContextControl,
|
|
nsIXFormsControl,
|
|
nsIXFormsControlBase)
|
|
|