Bug 312956 – Expose XForms node state directly on instance data nodes, r=aaronr, smaug

git-svn-id: svn://10.0.0.236/trunk@253837 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/extensions/xforms/nsIModelElementPrivate.idl

@@ -48,7 +48,7 @@ interface nsISVSchemaBuiltinType;
  * Private interface implemented by the model element for other
  * elements to use.
  */
-[uuid(bbc19255-4341-45fb-a9dc-23f4add8a7c3)]
+[uuid(64599272-49a8-463c-8937-b69165541f4f)]
 interface nsIModelElementPrivate : nsIXFormsModelElement
 {
   /**
@@ -122,6 +122,12 @@ interface nsIModelElementPrivate : nsIXFormsModelElement
    */
   unsigned short handleInstanceDataNode(in nsIDOMNode aInstanceDataNode);
 
+  /**
+   * Return states for bound node in terms of NS_EVENT_STATE constants
+   * @param aBoundNode         The instance node
+   */
+  long getStates(in nsIDOMNode aBoundNode);
+
   /**
    * Set MIP states for given control bound to the given bound node.
    * @param aControl          The control

mozilla/extensions/xforms/nsIXFormsControl.idl

@@ -37,6 +37,7 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsIXFormsContextControl.idl"
+#include "nsIModelElementPrivate.idl"
 
 interface nsIDOMNode;
 interface nsIDOMElement;
@@ -49,7 +50,7 @@ interface nsIDOMElement;
 /**
  * Interface implemented by all XForms form control classes.
  */
-[uuid(6fb46b32-9aa1-4d81-aa54-d57a414948c3)]
+[uuid(2dd97021-e7bd-46cb-b439-2affb8bbd482)]
 interface nsIXFormsControl : nsIXFormsContextControl
 {
   /**
@@ -57,6 +58,11 @@ interface nsIXFormsControl : nsIXFormsContextControl
    */
   boolean tryFocus();
 
+  /**
+   * The model that the control is bound to.
+   */
+  readonly attribute nsIModelElementPrivate model;
+
   /**
    * The instance node that the control is bound to.
    */

mozilla/extensions/xforms/nsIXFormsNSModelElement.idl

@@ -21,6 +21,7 @@
  *
  * Contributor(s):
  *   Allan Beaufour <allan@beaufour.dk>
+ *   Alexander Surkov <surkov.alexander@gmail.com>
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
@@ -39,12 +40,32 @@
 #include "domstubs.idl"
 
 interface nsIDOMNodeList;
+interface nsIXFormsAccessors;
 
 /**
  * Defines additional post-spec. functions for the \<model\> element.
  */
-[scriptable, uuid(85fd60c7-1db7-40c0-ae8d-f723fdd1eea8)]
+[scriptable, uuid(b1638cdd-db01-4082-a3e9-dc629c469a01)]
 interface nsIXFormsNSModelElement : nsISupports
 {
+  /*
+   * Returns a list of the instance documents for the model.
+   */
   nsIDOMNodeList getInstanceDocuments();
+
+  /*
+   * Returns an accessor interface to the given instance node.
+   */
+  nsIXFormsAccessors getAccessorsByNode(in nsIDOMNode node);
+
+  /*
+   * Evaluates the XPath expression as if it was an XForms single node binding
+   * expression for an outer-most control and returns an accessor interface to
+   * the resulting node. If XPath expression is invalid then method dispatches
+   * "xforms-compute-exception" event to the model and rises an exception. If
+   * XPath doesn't point to a node then method rises an exception.
+   *
+   * @note The expression is only evaluated once.
+   */
+  nsIXFormsAccessors getAccessorsByExpr(in DOMString xpath);
 };

mozilla/extensions/xforms/nsXFormsAccessors.cpp

@@ -22,6 +22,7 @@
  * Contributor(s):
  *  Allan Beaufour <abeaufour@novell.com>
  *  Olli Pettay <Olli.Pettay@helsinki.fi>
+ *  Alexander Surkov <surkov.alexander@gmail.com>
  *
  * 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
@@ -46,100 +47,113 @@
 #include "nsIXFormsControl.h"
 #include "nsIProgrammingLanguage.h"
 
-NS_IMPL_ISUPPORTS2(nsXFormsAccessors, nsIXFormsAccessors, nsIClassInfo)
+// nsXFormsAccessors object implementation
 
-void
+NS_IMPL_ISUPPORTS2(nsXFormsAccessorsBase, nsIXFormsAccessors, nsIClassInfo)
-nsXFormsAccessors::Destroy()
-{
-  mElement = nsnull;
-  mDelegate = nsnull;
-}
 
 nsresult
-nsXFormsAccessors::GetState(PRInt32 aState, PRBool *aStateVal)
+nsXFormsAccessorsBase::GetState(PRInt32 aState, PRBool *aStateVal)
 {
   NS_ENSURE_ARG_POINTER(aStateVal);
-  nsCOMPtr<nsIContent> content(do_QueryInterface(mElement));
+
-  *aStateVal = (content && (content->IntrinsicState() & aState));
+  nsCOMPtr<nsIModelElementPrivate> model;
+  GetModel(getter_AddRefs(model));
+  NS_ENSURE_STATE(model);
+
+  nsCOMPtr<nsIDOMNode> instNode;
+  GetInstanceNode(getter_AddRefs(instNode));
+  NS_ENSURE_STATE(instNode);
+
+  PRInt32 states;
+  model->GetStates(instNode, &states);
+  *aStateVal = states & aState;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetValue(nsAString &aValue)
+nsXFormsAccessorsBase::GetValue(nsAString &aValue)
 {
-  if (mDelegate) {
+  nsCOMPtr<nsIDOMNode> instNode;
-    mDelegate->GetValue(aValue);
+  GetInstanceNode(getter_AddRefs(instNode));
-  } else {
+  NS_ENSURE_STATE(instNode);
-    aValue.SetIsVoid(PR_TRUE);
+
-  }
+  nsXFormsUtils::GetNodeValue(instNode, aValue);
+
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::SetValue(const nsAString & aValue)
+nsXFormsAccessorsBase::SetValue(const nsAString &aValue)
 {
-  return mDelegate ? mDelegate->SetValue(aValue) : NS_OK;
+  nsCOMPtr<nsIModelElementPrivate> model;
+  GetModel(getter_AddRefs(model));
+  NS_ENSURE_STATE(model);
+
+  nsCOMPtr<nsIDOMNode> instNode;
+  GetInstanceNode(getter_AddRefs(instNode));
+  NS_ENSURE_STATE(instNode);
+
+  PRBool nodeChanged;
+  return model->SetNodeValue(instNode, aValue, PR_TRUE, &nodeChanged);
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::HasBoundNode(PRBool *aHasBoundNode)
+nsXFormsAccessorsBase::HasBoundNode(PRBool *aHasBoundNode)
 {
   NS_ENSURE_ARG_POINTER(aHasBoundNode);
-  *aHasBoundNode = PR_FALSE;
+
-  return mDelegate ? mDelegate->GetHasBoundNode(aHasBoundNode) : NS_OK;
+  nsCOMPtr<nsIDOMNode> instNode;
+  GetInstanceNode(getter_AddRefs(instNode));
+  *aHasBoundNode = instNode ? PR_TRUE : PR_FALSE;
+
+  return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::IsReadonly(PRBool *aStateVal)
+nsXFormsAccessorsBase::IsReadonly(PRBool *aStateVal)
 {
   return GetState(NS_EVENT_STATE_MOZ_READONLY, aStateVal);
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::IsRelevant(PRBool *aStateVal)
+nsXFormsAccessorsBase::IsRelevant(PRBool *aStateVal)
 {
   return GetState(NS_EVENT_STATE_ENABLED, aStateVal);
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::IsRequired(PRBool *aStateVal)
+nsXFormsAccessorsBase::IsRequired(PRBool *aStateVal)
 {
   return GetState(NS_EVENT_STATE_REQUIRED, aStateVal);
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::IsValid(PRBool *aStateVal)
+nsXFormsAccessorsBase::IsValid(PRBool *aStateVal)
 {
   return GetState(NS_EVENT_STATE_VALID, aStateVal);
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::SetContent(nsIDOMNode *aNode, PRBool aForceUpdate)
+nsXFormsAccessorsBase::SetContent(nsIDOMNode *aNode, PRBool aForceUpdate)
 {
-  NS_ENSURE_STATE(mElement);
   NS_ENSURE_ARG(aNode);
 
-  nsCOMPtr<nsIDOMNode> boundNode;
+  nsCOMPtr<nsIModelElementPrivate> model;
-  nsresult rv = GetBoundNode(getter_AddRefs(boundNode));
+  GetModel(getter_AddRefs(model));
-  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_STATE(model);
-  NS_ENSURE_STATE(boundNode);
 
-  nsCOMPtr<nsIModelElementPrivate> modelPriv = nsXFormsUtils::GetModel(mElement);
+  nsCOMPtr<nsIDOMNode> instNode;
-  NS_ENSURE_STATE(modelPriv);
+  GetInstanceNode(getter_AddRefs(instNode));
+  NS_ENSURE_STATE(instNode);
 
-  return modelPriv->SetNodeContent(boundNode, aNode, aForceUpdate);
+  return model->SetNodeContent(instNode, aNode, aForceUpdate);
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetBoundNode(nsIDOMNode **aBoundNode)
+nsXFormsAccessorsBase::GetBoundNode(nsIDOMNode **aBoundNode)
 {
-  NS_ENSURE_ARG_POINTER(aBoundNode);
+  return GetInstanceNode(aBoundNode);
-  if (mDelegate) {
-    nsCOMPtr<nsIXFormsControl> control = do_QueryInterface(mDelegate);
-    return control->GetBoundNode(aBoundNode);
-  }
-  return NS_OK;
 }
 
 // nsIClassInfo implementation
@@ -149,7 +163,7 @@ static const nsIID sScriptingIIDs[] = {
 };
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetInterfaces(PRUint32 *aCount, nsIID * **aArray)
+nsXFormsAccessorsBase::GetInterfaces(PRUint32 *aCount, nsIID * **aArray)
 {
   return nsXFormsUtils::CloneScriptingInterfaces(sScriptingIIDs,
                                                  NS_ARRAY_LENGTH(sScriptingIIDs),
@@ -157,50 +171,141 @@ nsXFormsAccessors::GetInterfaces(PRUint32 *aCount, nsIID * **aArray)
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetHelperForLanguage(PRUint32 language,
+nsXFormsAccessorsBase::GetHelperForLanguage(PRUint32 language,
-                                        nsISupports **_retval)
+                                            nsISupports **_retval)
 {
   *_retval = nsnull;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetContractID(char * *aContractID)
+nsXFormsAccessorsBase::GetContractID(char * *aContractID)
 {
   *aContractID = nsnull;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetClassDescription(char * *aClassDescription)
+nsXFormsAccessorsBase::GetClassDescription(char * *aClassDescription)
 {
   *aClassDescription = nsnull;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetClassID(nsCID * *aClassID)
+nsXFormsAccessorsBase::GetClassID(nsCID * *aClassID)
 {
   *aClassID = nsnull;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetImplementationLanguage(PRUint32 *aImplementationLanguage)
+nsXFormsAccessorsBase::GetImplementationLanguage(PRUint32 *aImplementationLanguage)
 {
   *aImplementationLanguage = nsIProgrammingLanguage::CPLUSPLUS;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetFlags(PRUint32 *aFlags)
+nsXFormsAccessorsBase::GetFlags(PRUint32 *aFlags)
 {
   *aFlags = nsIClassInfo::DOM_OBJECT;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXFormsAccessors::GetClassIDNoAlloc(nsCID *aClassIDNoAlloc)
+nsXFormsAccessorsBase::GetClassIDNoAlloc(nsCID *aClassIDNoAlloc)
 {
   return NS_ERROR_NOT_AVAILABLE;
 }
+
+// nsXFormsAccessors implementation
+
+nsXFormsAccessors::nsXFormsAccessors(nsIModelElementPrivate *aModel,
+                                     nsIDOMNode *aInstanceNode)
+  : mModel(aModel), mInstanceNode(aInstanceNode)
+{
+}
+
+nsresult
+nsXFormsAccessors::GetModel(nsIModelElementPrivate **aModel)
+{
+  NS_ENSURE_ARG_POINTER(aModel);
+
+  NS_IF_ADDREF(*aModel = mModel);
+  return NS_OK;
+}
+
+nsresult
+nsXFormsAccessors::GetInstanceNode(nsIDOMNode **aInstanceNode)
+{
+  NS_ENSURE_ARG_POINTER(aInstanceNode);
+
+  NS_IF_ADDREF(*aInstanceNode = mInstanceNode);
+  return NS_OK;
+}
+
+// nsXFormsControlAccessors implementation
+nsXFormsControlAccessors::nsXFormsControlAccessors(nsIDelegateInternal *aControl,
+                                                   nsIDOMElement *aElement)
+: mDelegate(aControl), mElement(aElement)
+{
+}
+
+nsresult
+nsXFormsControlAccessors::GetModel(nsIModelElementPrivate **aModel)
+{
+  NS_ENSURE_ARG_POINTER(aModel);
+  NS_ENSURE_STATE(mDelegate);
+
+  nsCOMPtr<nsIXFormsControl> control = do_QueryInterface(mDelegate);
+  return control->GetModel(aModel);
+}
+
+nsresult
+nsXFormsControlAccessors::GetInstanceNode(nsIDOMNode **aInstanceNode)
+{
+  NS_ENSURE_ARG_POINTER(aInstanceNode);
+  NS_ENSURE_STATE(mDelegate);
+
+  nsCOMPtr<nsIXFormsControl> control = do_QueryInterface(mDelegate);
+  return control->GetBoundNode(aInstanceNode);
+}
+
+nsresult
+nsXFormsControlAccessors::GetState(PRInt32 aState, PRBool *aStateVal)
+{
+  NS_ENSURE_ARG_POINTER(aStateVal);
+
+  if (mDelegate) {
+    NS_ENSURE_STATE(mElement);
+
+    nsCOMPtr<nsIContent> content(do_QueryInterface(mElement));
+    *aStateVal = (content && (content->IntrinsicState() & aState));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXFormsControlAccessors::GetValue(nsAString &aValue)
+{
+  if (mDelegate)
+    return mDelegate->GetValue(aValue);
+
+  aValue.SetIsVoid(PR_TRUE);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXFormsControlAccessors::SetValue(const nsAString &aValue)
+{
+  return mDelegate ? mDelegate->SetValue(aValue) : NS_OK;
+}
+
+void
+nsXFormsControlAccessors::Destroy()	
+{
+  mElement = nsnull;
+  mDelegate = nsnull;
+}

mozilla/extensions/xforms/nsXFormsAccessors.h

@@ -21,6 +21,7 @@
  *
  * Contributor(s):
  *  Allan Beaufour <abeaufour@novell.com>
+ *  Alexander Surkov <surkov.alexander@gmail.com>
  *
  * 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
@@ -39,47 +40,101 @@
 #ifndef __NSXFORMSACCESSORS_H__
 #define __NSXFORMSACCESSORS_H__
 
+#include "nsCOMPtr.h"
+
 #include "nsIClassInfo.h"
 #include "nsIXFormsAccessors.h"
 #include "nsIDelegateInternal.h"
-
+#include "nsIModelElementPrivate.h"
-class nsIDOMElement;
 
 /**
- * Implementation of the nsIXFormsAccessors object. It is always owned by a
+ * Abstract class for nsIXFormsAccessors objects. nsXFormsAccessorsBase isn't
- * nsIXFormsDelegate.
+ * meant to be instantiated, but instead a user should instantiate
+ * nsXFormsAccessors or nsXFormsControlAccessors.
  */
-class nsXFormsAccessors : public nsIXFormsAccessors,
+class nsXFormsAccessorsBase : public nsIXFormsAccessors,
-                          public nsIClassInfo
+                              public nsIClassInfo
 {
 public:
   NS_DECL_ISUPPORTS
+
   NS_DECL_NSICLASSINFO
   NS_DECL_NSIXFORMSACCESSORS
 
-  /** Constructor */
-  nsXFormsAccessors(nsIDelegateInternal* aDelegate, nsIDOMElement* aElement)
-    : mDelegate(aDelegate), mElement(aElement) 
-  {
-  }
-
-  /** Called by the owning delegate when it itself is destroyed */
-  void Destroy();
-
 protected:
+  // The next methods should be implemented by successors. Methods are used
+  // to get xforms model and instance node that are both needed to make possible
+  // implementation of nsIXFormsAccessors interface by this class.
+  virtual nsresult GetModel(nsIModelElementPrivate **aModel) = 0;
+  virtual nsresult GetInstanceNode(nsIDOMNode **aInstanceNode) = 0;
+
   /**
    * Checks the status of the model item properties
    *
    * @param aState       The state to check
    * @para  aStateVal    The returned state
    */
-  nsresult GetState(PRInt32 aState, PRBool *aStateVal);
+  virtual nsresult GetState(PRInt32 aState, PRBool *aStateVal);
+};
 
-  /** The delegate owning us */
-  nsIDelegateInternal*   mDelegate;
 
-  /** The control DOM element */
+/**
-  nsIDOMElement*         mElement;
+ * Implementation of the nsIXFormsAccessors object for instance node.
+ */
+
+class nsXFormsAccessors : public nsXFormsAccessorsBase
+{
+public:
+  nsXFormsAccessors(nsIModelElementPrivate *aModel, nsIDOMNode *aInstanceNode);
+
+protected:
+  virtual nsresult GetModel(nsIModelElementPrivate **aModel);
+  virtual nsresult GetInstanceNode(nsIDOMNode **aInstanceNode);
+
+private:
+  /* The model */
+  nsCOMPtr<nsIModelElementPrivate> mModel;
+
+  /* The instance node */
+  nsCOMPtr<nsIDOMNode>             mInstanceNode;
+};
+
+/**
+ * Implementation of the nsIXFormsAccessors object for nsIXFormsDelegate
+ * controls.
+ *
+ * Some nsIXFormsDelegate controls have a value even if they are not bound to
+ * instance node (like xforms:label and xforms:output). nsXFormsControlAccessors
+ * object redirects getValue()/setValue() calls to nsIXFormsDelegate control.
+ */
+
+class nsXFormsControlAccessors : public nsXFormsAccessorsBase
+{
+public:
+  nsXFormsControlAccessors(nsIDelegateInternal *aControl,
+                           nsIDOMElement *aElement);
+
+  // nsIXFormsAccessors
+  NS_IMETHOD GetValue(nsAString &aValue);
+  NS_IMETHOD SetValue(const nsAString &aValue);
+
+  /**
+   * Called by the owning delegate when it itself is destroyed.
+   */
+  void Destroy();
+
+protected:
+  virtual nsresult GetModel(nsIModelElementPrivate **aModel);
+  virtual nsresult GetInstanceNode(nsIDOMNode **aInstanceNode);
+  virtual nsresult GetState(PRInt32 aState, PRBool *aStateVal);
+
+  /* The DOM element for xforms control the accessor is bound to. */
+  nsIDOMElement *mElement;
+
+private:
+  /* The XTF element for xforms control the accessor is bound to. */
+  nsIDelegateInternal *mDelegate;
 };
 
 #endif
+

mozilla/extensions/xforms/nsXFormsControlStub.cpp

@@ -104,9 +104,20 @@ nsXFormsHintHelpListener::HandleEvent(nsIDOMEvent* aEvent)
   return NS_OK;
 }
 
+NS_IMETHODIMP
+nsXFormsControlStub::GetModel(nsIModelElementPrivate **aModel)
+{
+  NS_ENSURE_ARG_POINTER(aModel);
+
+  NS_IF_ADDREF(*aModel = mModel);
+  return NS_OK;
+}
+
 NS_IMETHODIMP
 nsXFormsControlStub::GetBoundNode(nsIDOMNode **aBoundNode)
 {
+  NS_ENSURE_ARG_POINTER(aBoundNode);
+
   NS_IF_ADDREF(*aBoundNode = mBoundNode);
   return NS_OK;  
 }

mozilla/extensions/xforms/nsXFormsControlStub.h

@@ -81,6 +81,7 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsIXFormsControl
+  NS_IMETHOD GetModel(nsIModelElementPrivate **aModel);
   NS_IMETHOD GetBoundNode(nsIDOMNode **aBoundNode);
   NS_IMETHOD BindToModel(PRBool aSetBoundNode = PR_FALSE);
   NS_IMETHOD GetDependencies(nsCOMArray<nsIDOMNode> **aDependencies);

mozilla/extensions/xforms/nsXFormsDelegateStub.cpp

@@ -94,6 +94,7 @@ nsXFormsDelegateStub::OnDestroyed()
   nsXFormsModelElement::CancelPostRefresh(this);
   if (mAccessor) {
     mAccessor->Destroy();
+    mAccessor = nsnull;
   }
   return nsXFormsControlStub::OnDestroyed();
 }
@@ -310,7 +311,7 @@ NS_IMETHODIMP
 nsXFormsDelegateStub::GetXFormsAccessors(nsIXFormsAccessors **aAccessor)
 {
   if (!mAccessor) {
-    mAccessor = new nsXFormsAccessors(this, mElement);
+    mAccessor = new nsXFormsControlAccessors(this, mElement);
     if (!mAccessor) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
@@ -318,3 +319,4 @@ nsXFormsDelegateStub::GetXFormsAccessors(nsIXFormsAccessors **aAccessor)
   NS_ADDREF(*aAccessor = mAccessor);
   return NS_OK;
 }
+

mozilla/extensions/xforms/nsXFormsDelegateStub.h

@@ -119,7 +119,7 @@ protected:
 
   nsString      mControlType;
   /** The accessors object for this delegate */
-  nsRefPtr<nsXFormsAccessors> mAccessor;
+  nsRefPtr<nsXFormsControlAccessors> mAccessor;
 };
 
 #endif

mozilla/extensions/xforms/nsXFormsModelElement.cpp

@@ -65,6 +65,7 @@
 #include "nsIURL.h"
 #include "nsNetUtil.h"
 #include "nsIXFormsControl.h"
+#include "nsXFormsAccessors.h"
 #include "nsXFormsTypes.h"
 #include "nsXFormsXPathParser.h"
 #include "nsXFormsXPathAnalyzer.h"
@@ -1037,7 +1038,7 @@ nsXFormsModelElement::OnCreated(nsIXTFElementWrapper *aWrapper)
   return NS_OK;
 }
 
-// nsIXFormsModelElement
+// nsIXFormsNSModelElement
 
 NS_IMETHODIMP
 nsXFormsModelElement::GetInstanceDocuments(nsIDOMNodeList **aDocuments)
@@ -1048,6 +1049,69 @@ nsXFormsModelElement::GetInstanceDocuments(nsIDOMNodeList **aDocuments)
   return NS_OK;
 }
 
+NS_IMETHODIMP
+nsXFormsModelElement::GetAccessorsByNode(nsIDOMNode          *aInstanceNode,
+                                         nsIXFormsAccessors **aAccessors)
+{
+  NS_ENSURE_ARG(aInstanceNode);
+  NS_ENSURE_ARG_POINTER(aAccessors);
+  *aAccessors = nsnull;
+
+  nsCOMPtr<nsIDOMNode> instanceDocNode;
+  nsresult rv =
+    nsXFormsUtils::GetInstanceNodeForData(aInstanceNode,
+                                          getter_AddRefs(instanceDocNode));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMNode> modelNode;
+  instanceDocNode->GetParentNode(getter_AddRefs(modelNode));
+  NS_ENSURE_STATE(modelNode);
+
+  nsCOMPtr<nsIDOM3Node> theModelNode(do_QueryInterface(mElement));
+  PRBool isSameNode = PR_FALSE;
+  theModelNode->IsSameNode(modelNode, &isSameNode);
+  NS_ENSURE_TRUE(isSameNode, NS_ERROR_UNEXPECTED);
+
+  *aAccessors = new nsXFormsAccessors(this, aInstanceNode);
+  NS_ENSURE_TRUE(*aAccessors, NS_ERROR_OUT_OF_MEMORY);
+
+  NS_ADDREF(*aAccessors);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXFormsModelElement::GetAccessorsByExpr(const nsAString&     aXPathExpr,
+                                         nsIXFormsAccessors **aAccessors)
+{
+  NS_ENSURE_ARG_POINTER(aAccessors);
+  *aAccessors = nsnull;
+
+  nsCOMPtr<nsIDOMDocument> firstInstanceDoc =
+    FindInstanceDocument(EmptyString());
+  NS_ENSURE_STATE(firstInstanceDoc);
+
+  nsCOMPtr<nsIDOMElement> defaultContextNode;
+  firstInstanceDoc->GetDocumentElement(getter_AddRefs(defaultContextNode));
+
+  nsCOMPtr<nsIDOMXPathResult> xpRes;
+  nsXFormsUtils::EvaluateXPath(aXPathExpr, defaultContextNode, mElement,
+                               nsIDOMXPathResult::FIRST_ORDERED_NODE_TYPE,
+                               getter_AddRefs(xpRes));
+  NS_ENSURE_STATE(xpRes);
+
+  nsCOMPtr<nsIDOMNode> instanceNode;
+  xpRes->GetSingleNodeValue(getter_AddRefs(instanceNode));
+  NS_ENSURE_STATE(instanceNode);
+
+  *aAccessors = new nsXFormsAccessors(this, instanceNode);
+  NS_ENSURE_TRUE(*aAccessors, NS_ERROR_OUT_OF_MEMORY);
+
+  NS_ADDREF(*aAccessors);
+  return NS_OK;
+}
+
+// nsIXFormsModelElement
+
 NS_IMETHODIMP
 nsXFormsModelElement::GetInstanceDocument(const nsAString& aInstanceID,
                                           nsIDOMDocument **aDocument)
@@ -1180,6 +1244,18 @@ nsXFormsModelElement::SetStates(nsIXFormsControl *aControl,
   return NS_OK;
 }
 
+NS_IMETHODIMP
+nsXFormsModelElement::GetStates(nsIDOMNode *aBoundNode, PRInt32 *aStates)
+{
+  NS_ENSURE_ARG_POINTER(aStates);
+
+  const nsXFormsNodeState *ns = mMDG.GetNodeState(aBoundNode);
+  NS_ENSURE_STATE(ns);
+
+  *aStates = ns->GetIntrinsicState();
+  return NS_OK;
+}
+
 NS_IMETHODIMP
 nsXFormsModelElement::Revalidate()
 {

mozilla/extensions/xforms/nsXFormsRangeAccessors.h

@@ -51,11 +51,10 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIXFORMSRANGEACCESSORS
   NS_FORWARD_NSIXFORMSRANGECONDITIONACCESSORS(nsXFormsRangeConditionAccessors::)
-  NS_FORWARD_NSIXFORMSACCESSORS(nsXFormsAccessors::)
+  NS_FORWARD_NSIXFORMSACCESSORS(nsXFormsControlAccessors::)
 
   // Constructor
-  nsXFormsRangeAccessors(nsIDelegateInternal* aDelegate,
+  nsXFormsRangeAccessors(nsIDelegateInternal* aDelegate, nsIDOMElement *aElement)
-                         nsIDOMElement* aElement)
     : nsXFormsRangeConditionAccessors(aDelegate, aElement)
   {
   }

mozilla/extensions/xforms/nsXFormsRangeConditionAccessors.cpp

@@ -45,10 +45,17 @@
 #include "nsXFormsUtils.h"
 
 NS_IMPL_ISUPPORTS_INHERITED2(nsXFormsRangeConditionAccessors,
-                             nsXFormsAccessors,
+                             nsXFormsControlAccessors,
                              nsIXFormsRangeConditionAccessors,
                              nsIClassInfo)
 
+// Constructor
+nsXFormsRangeConditionAccessors::nsXFormsRangeConditionAccessors(nsIDelegateInternal *aDelegate,
+                                                                 nsIDOMElement *aElement)
+  : nsXFormsControlAccessors(aDelegate, aElement)
+{
+}
+
 // nsXFormsRangeConditionAccessors
 
 NS_IMETHODIMP
@@ -71,14 +78,9 @@ nsXFormsRangeConditionAccessors::SetInRange(PRBool aInRange)
    * then we need to set the state to the new value and dispatch
    * xforms-in-range or xforms-out-of-range
    */
-  nsCOMPtr<nsIXFormsControl> control(do_QueryInterface(mDelegate));
+  nsCOMPtr<nsIXTFElementWrapper> xtfWrap(do_QueryInterface(mElement));
-  NS_ENSURE_STATE(control);
-
-  nsCOMPtr<nsIDOMElement> element;
-  control->GetElement(getter_AddRefs(element));
-  nsCOMPtr<nsIXTFElementWrapper> xtfWrap(do_QueryInterface(element));
   NS_ENSURE_STATE(xtfWrap);
-  nsCOMPtr<nsIContent> content(do_QueryInterface(element));
+  nsCOMPtr<nsIContent> content(do_QueryInterface(mElement));
   NS_ENSURE_STATE(content);
 
   PRInt32 state = content->IntrinsicState();
@@ -93,7 +95,7 @@ nsXFormsRangeConditionAccessors::SetInRange(PRBool aInRange)
   rv = xtfWrap->SetIntrinsicState(state);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  nsXFormsUtils::DispatchEvent(element,
+  nsXFormsUtils::DispatchEvent(mElement,
                                aInRange ? eEvent_InRange : eEvent_OutOfRange);
 
   return NS_OK;

mozilla/extensions/xforms/nsXFormsRangeConditionAccessors.h

@@ -45,21 +45,19 @@
  * nsIXFormsRangeConditionAccessors.
  *
  */
-class nsXFormsRangeConditionAccessors : public nsXFormsAccessors,
+class nsXFormsRangeConditionAccessors : public nsXFormsControlAccessors,
                                         public nsIXFormsRangeConditionAccessors
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIXFORMSRANGECONDITIONACCESSORS
-  NS_FORWARD_NSIXFORMSACCESSORS(nsXFormsAccessors::)
+  NS_FORWARD_NSIXFORMSACCESSORS(nsXFormsControlAccessors::)
 
   // Constructor
   nsXFormsRangeConditionAccessors(nsIDelegateInternal *aDelegate,
-                                  nsIDOMElement *aElement)
+                                  nsIDOMElement *aElement);
-    : nsXFormsAccessors(aDelegate, aElement)
-  {
-  }
 
   // nsIClassInfo overrides
   NS_IMETHOD GetInterfaces(PRUint32 *aCount, nsIID * **aArray);
 };
+