diff --git a/mozilla/extensions/xforms/jar.mn b/mozilla/extensions/xforms/jar.mn
index 98d6f2c646a..9a1a96a9bed 100755
--- a/mozilla/extensions/xforms/jar.mn
+++ b/mozilla/extensions/xforms/jar.mn
@@ -9,6 +9,7 @@ xforms.jar:
 * content/xforms/xforms-prefs.js               (resources/content/xforms-prefs.js)
   content/xforms/xforms.xml                    (resources/content/xforms.xml)
   content/xforms/select1.xml                   (resources/content/select1.xml)
+  content/xforms/select.xml                    (resources/content/select.xml)
 * locale/en-US/xforms/contents.rdf             (resources/locale/en-US/contents.rdf)
   locale/en-US/xforms/xforms.properties        (resources/locale/en-US/xforms.properties)
   locale/en-US/xforms/xforms.dtd               (resources/locale/en-US/xforms.dtd)
diff --git a/mozilla/extensions/xforms/nsIXFormsSelectChild.idl b/mozilla/extensions/xforms/nsIXFormsSelectChild.idl
index 51e900cd317..8ec3355d25c 100644
--- a/mozilla/extensions/xforms/nsIXFormsSelectChild.idl
+++ b/mozilla/extensions/xforms/nsIXFormsSelectChild.idl
@@ -55,47 +55,10 @@ class nsStringArray;
 [scriptable, uuid(a29ac2bd-f36a-451e-99e1-0f3bd94ffbef)]
 interface nsIXFormsSelectChild : nsISupports
 {
-  /**
-   * The DOM elements returned by this attribute are inserted into the select
-   * element's anonymous content tree.
-   */
-  readonly attribute nsIArray anonymousNodes;
-
-  /**
-   * selectItemsByValue() handles children that have a value element child.
-   * If the value element text for this child is contained in the |values|
-   * array, then the item should select itself. Used in \<select\>.
-   *
-   */
-  [noscript] void selectItemsByValue(in constStringArray values);
-  
-  /**
-   * selectItemsByContent() handles children that have a copy element child.
-   * If |node| points to the same instance data node as the item, then the
-   * item should select itself.
-   */
-  void selectItemsByContent(in nsIDOMNode node);
-
   /*
    * selectItemByValue is used in \<select1\>. If the XFormsSelectChild is or
    * contains an \<item\>, which has the same value as the parameter |value|,
    * this method returns that \<item\>.
    */
   nsIDOMNode selectItemByValue(in AString value);
-
-  /**
-   * Instructs the item to serialize its selected elements.
-   * For children that have a value child, they should append the value of
-   * any selected items to the provided string buffer.  For children
-   * that have a copy child, they should copy the instance data element into
-   * |container|.
-   */
-  void writeSelectedItems(in nsIDOMNode container, out AString stringBuffer);
-
-  /**
-   * Set the context node, position, and size to be used for XPath evaluation.
-   * This is used by itemset to create a context for its anonymous item
-   * elements.
-   */
-  void setContext(in nsIDOMElement node, in long position, in long size);
 };
diff --git a/mozilla/extensions/xforms/nsXFormsChoicesElement.cpp b/mozilla/extensions/xforms/nsXFormsChoicesElement.cpp
index 3f7570b5ce5..4bde0d6151f 100644
--- a/mozilla/extensions/xforms/nsXFormsChoicesElement.cpp
+++ b/mozilla/extensions/xforms/nsXFormsChoicesElement.cpp
@@ -44,21 +44,16 @@
 #include "nsIXTFBindableElementWrapper.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMNodeList.h"
+#include "nsIXFormsControl.h"
 #include "nsXFormsUtils.h"
 #include "nsArray.h"
 #include "nsIXTFXMLVisualWrapper.h"
 
-/**
- * Implementation of XForms \<choices\> element.  This creates an HTML
- * optgroup element and inserts any childrens' anonymous content as children
- * of the optgroup.
- */
-
 class nsXFormsChoicesElement : public nsXFormsBindableStub,
                                public nsIXFormsSelectChild
 {
 public:
-  nsXFormsChoicesElement() : mElement(nsnull) {}
+  nsXFormsChoicesElement() : mElement(nsnull), mDoneAddingChildren(PR_FALSE) {}
 
   NS_DECL_ISUPPORTS_INHERITED
 
@@ -72,16 +67,15 @@ public:
   NS_IMETHOD BeginAddingChildren();
   NS_IMETHOD DoneAddingChildren();
 
-  // nsIXFormsControlBase overrides
-  NS_IMETHOD Refresh();
-
   // nsIXFormsSelectChild
   NS_DECL_NSIXFORMSSELECTCHILD
 
 private:
-  nsIDOMElement*                      mElement;
-  nsCOMPtr<nsIDOMHTMLOptGroupElement> mOptGroup;
-  PRBool                              mInsideSelect1;
+  nsIDOMElement* mElement;
+  PRBool         mDoneAddingChildren;
+
+  void Refresh();
+
 };
 
 NS_IMPL_ISUPPORTS_INHERITED1(nsXFormsChoicesElement,
@@ -100,8 +94,6 @@ nsXFormsChoicesElement::OnCreated(nsIXTFBindableElementWrapper *aWrapper)
                                 nsIXTFElement::NOTIFY_CHILD_REMOVED |
                                 nsIXTFElement::NOTIFY_BEGIN_ADDING_CHILDREN);
 
-  mInsideSelect1 = PR_FALSE;
-
   nsCOMPtr<nsIDOMElement> node;
   aWrapper->GetElementNode(getter_AddRefs(node));
 
@@ -112,42 +104,13 @@ nsXFormsChoicesElement::OnCreated(nsIXTFBindableElementWrapper *aWrapper)
   mElement = node;
   NS_ASSERTION(mElement, "Wrapper is not an nsIDOMElement, we'll crash soon");
 
-  // Our anonymous content structure in <select> will look like this:
-  //
-  // <optgroup label="myLabel"/>   (mOptGroup)
-  //
-  // <select1>'s anonymous content is created in XBL.
-
-  nsCOMPtr<nsIDOMDocument> domDoc;
-  node->GetOwnerDocument(getter_AddRefs(domDoc));
-
-  //XXX Remove this when XBLizing <select>.
-  nsCOMPtr<nsIDOMElement> element;
-  domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
-                          NS_LITERAL_STRING("optgroup"),
-                          getter_AddRefs(element));
-
-  mOptGroup = do_QueryInterface(element);
-  NS_ENSURE_TRUE(mOptGroup, NS_ERROR_FAILURE);
-
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsXFormsChoicesElement::ParentChanged(nsIDOMElement *aNewParent)
 {
-  mInsideSelect1 = PR_FALSE;
   if (aNewParent) {
-    nsCOMPtr<nsIDOMNode> parent, tmp;
-    mElement->GetParentNode(getter_AddRefs(parent));
-    while (parent) {
-      if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1"))) {
-        mInsideSelect1 = PR_TRUE;
-        break;
-      }
-      tmp.swap(parent);
-      tmp->GetParentNode(getter_AddRefs(parent));
-    }
     Refresh();
   }
   return NS_OK;
@@ -186,9 +149,7 @@ nsXFormsChoicesElement::ChildAppended(nsIDOMNode *aChild)
 NS_IMETHODIMP
 nsXFormsChoicesElement::ChildRemoved(PRUint32 aIndex)
 {
-  // TODO: should remove the anonymous content owned by the removed item.
-
-  // TOOD: only need to Refresh() when a label child is removed, but it's
+  // XXX: only need to Refresh() when a label child is removed, but it's
   // not possible to get ahold of the actual removed child at this point.
 
   Refresh();
@@ -211,6 +172,8 @@ nsXFormsChoicesElement::BeginAddingChildren()
 NS_IMETHODIMP
 nsXFormsChoicesElement::DoneAddingChildren()
 {
+  mDoneAddingChildren = PR_TRUE;
+
   // Unsuppress notifications
   nsCOMPtr<nsIXTFElementWrapper> wrapper = do_QueryInterface(mElement);
   NS_ASSERTION(wrapper, "huh? our element must be an xtf wrapper");
@@ -220,36 +183,6 @@ nsXFormsChoicesElement::DoneAddingChildren()
                                nsIXTFElement::NOTIFY_CHILD_APPENDED |
                                nsIXTFElement::NOTIFY_CHILD_REMOVED);
 
-  // Walk our children and get their anonymous content.
-  nsCOMPtr<nsIDOMNodeList> children;
-  nsresult rv = mElement->GetChildNodes(getter_AddRefs(children));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  nsCOMPtr<nsIDOMNode> childNode, childAnonymousNode, nodeReturn;
-  nsCOMPtr<nsIXFormsSelectChild> childItem;
-
-  PRUint32 childCount = 0;
-  children->GetLength(&childCount);
-
-  for (PRUint32 i = 0; i < childCount; ++i) {
-    children->Item(i, getter_AddRefs(childNode));
-    childItem = do_QueryInterface(childNode);
-    if (childItem) {
-      nsCOMPtr<nsIArray> childItems;
-      childItem->GetAnonymousNodes(getter_AddRefs(childItems));
-      if (childItems) {
-        PRUint32 childNodesLength = 0;
-        childItems->GetLength(&childNodesLength);
-
-        for (PRUint32 j = 0; j < childNodesLength; ++j) {
-          childAnonymousNode = do_QueryElementAt(childItems, j);
-          mOptGroup->AppendChild(childAnonymousNode,
-                                 getter_AddRefs(nodeReturn));
-        }
-      }
-    }
-  }
-
   // Assume that we've got something worth refreshing now.
   Refresh();
   return NS_OK;
@@ -257,19 +190,6 @@ nsXFormsChoicesElement::DoneAddingChildren()
 
 // nsIXFormsSelectChild
 
-NS_IMETHODIMP
-nsXFormsChoicesElement::GetAnonymousNodes(nsIArray **aNodes)
-{
-  nsCOMPtr<nsIMutableArray> array;
-  nsresult rv = NS_NewArray(getter_AddRefs(array));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  array->AppendElement(mOptGroup, PR_FALSE);
-
-  NS_ADDREF(*aNodes = array);
-  return NS_OK;
-}
-
 NS_IMETHODIMP
 nsXFormsChoicesElement::SelectItemByValue(const nsAString &aValue, nsIDOMNode **aSelected)
 {
@@ -299,122 +219,27 @@ nsXFormsChoicesElement::SelectItemByValue(const nsAString &aValue, nsIDOMNode **
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsXFormsChoicesElement::SelectItemsByValue(const nsStringArray &aValueList)
-{
-  nsCOMPtr<nsIDOMNodeList> children;
-  nsresult rv = mElement->GetChildNodes(getter_AddRefs(children));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  PRUint32 childCount = 0;
-  children->GetLength(&childCount);
-
-  nsCOMPtr<nsIDOMNode> childNode;
-  nsCOMPtr<nsIXFormsSelectChild> childItem;
-
-  for (PRUint32 i = 0; i < childCount; ++i) {
-    children->Item(i, getter_AddRefs(childNode));
-    childItem = do_QueryInterface(childNode);
-    if (childItem) {
-      childItem->SelectItemsByValue(aValueList);
-    }
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsChoicesElement::SelectItemsByContent(nsIDOMNode *aNode)
-{
-  // Not applicable for choices element.
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsChoicesElement::WriteSelectedItems(nsIDOMNode *aContainer, 
-                                           nsAString  &aStringBuffer)
-{
-  nsCOMPtr<nsIDOMNodeList> children;
-  nsresult rv = mElement->GetChildNodes(getter_AddRefs(children));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  PRUint32 childCount = 0;
-  children->GetLength(&childCount);
-
-  nsCOMPtr<nsIDOMNode> childNode;
-  nsCOMPtr<nsIXFormsSelectChild> childItem;
-
-  for (PRUint32 i = 0; i < childCount; ++i) {
-    children->Item(i, getter_AddRefs(childNode));
-    childItem = do_QueryInterface(childNode);
-    if (childItem) {
-      childItem->WriteSelectedItems(aContainer, aStringBuffer);
-    }
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsChoicesElement::SetContext(nsIDOMElement *aContextNode,
-                                   PRInt32 aContextPosition,
-                                   PRInt32 aContextSize)
-{
-  // choices cannot be created by an itemset, so we don't need to worry
-  // about this case.
-  return NS_OK;
-}
-
 // internal methods
 
-NS_IMETHODIMP
+void
 nsXFormsChoicesElement::Refresh()
 {
-  if (mInsideSelect1) {
-    // <select1> is XBLized, so there is no need to recreate UI -
-    // XBL will do it for us.
-    return NS_OK;
+  if (mDoneAddingChildren) {
+    nsCOMPtr<nsIDOMNode> parent, current;
+    current = mElement;
+    do {
+      current->GetParentNode(getter_AddRefs(parent));
+      if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1")) ||
+          nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select"))) {
+        nsCOMPtr<nsIXFormsControl> select(do_QueryInterface(parent));
+        if (select) {
+          select->Refresh();
+        }
+        return;
+      }
+      current = parent;
+    } while(current);
   }
-
-  // Remove any existing first child that is not an option, to clear out
-  // any existing label.
-  nsCOMPtr<nsIDOMNode> firstChild, child2;
-  nsresult rv = mOptGroup->GetFirstChild(getter_AddRefs(firstChild));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  nsAutoString value;
-
-  if (firstChild) {
-    firstChild->GetLocalName(value);
-    if (!value.EqualsLiteral("option")) {
-      mOptGroup->RemoveChild(firstChild, getter_AddRefs(child2));
-      mOptGroup->GetFirstChild(getter_AddRefs(firstChild));
-    }
-  }
-
-  // We need to find our label element and clone it into the optgroup.
-  // This content will appear before any of the optgroup's options.
-
-  nsCOMPtr<nsIDOMNodeList> children;
-  rv = mElement->GetChildNodes(getter_AddRefs(children));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  PRUint32 childCount;
-  children->GetLength(&childCount);
-
-  nsCOMPtr<nsIDOMNode> child;
-  nsAutoString labelValue;
-
-  for (PRUint32 i = 0; i < childCount; ++i) {
-    children->Item(i, getter_AddRefs(child));
-    if (nsXFormsUtils::IsLabelElement(child)) {
-      // Clone our label into the optgroup
-      child->CloneNode(PR_TRUE, getter_AddRefs(child2));
-      mOptGroup->InsertBefore(child2, firstChild, getter_AddRefs(child));
-    }
-  }
-
-  return NS_OK;
 }
 
 NS_HIDDEN_(nsresult)
diff --git a/mozilla/extensions/xforms/nsXFormsItemElement.cpp b/mozilla/extensions/xforms/nsXFormsItemElement.cpp
index ee0c14c0bb6..f6a0430d07e 100644
--- a/mozilla/extensions/xforms/nsXFormsItemElement.cpp
+++ b/mozilla/extensions/xforms/nsXFormsItemElement.cpp
@@ -69,10 +69,7 @@ class nsXFormsItemElement : public nsXFormsBindableStub,
                             public nsIXFormsItemElement
 {
 public:
-  nsXFormsItemElement() : mElement(nsnull),
-                          mContextPosition(0),
-                          mContextSize(0),
-                          mInsideSelect1(PR_FALSE)
+  nsXFormsItemElement() : mElement(nsnull), mDoneAddingChildren(PR_FALSE)
   {
   }
 
@@ -89,22 +86,14 @@ public:
   NS_IMETHOD BeginAddingChildren();
   NS_IMETHOD DoneAddingChildren();
 
-  // nsIXFormsControlBase overrides
-  NS_IMETHOD Refresh();
+  void Refresh();
 
   // nsIXFormsSelectChild
   NS_DECL_NSIXFORMSSELECTCHILD
 
 private:
-
   nsIDOMElement* mElement;
-  nsCOMPtr<nsIDOMHTMLOptionElement> mOption;
-
-  // context node (used by itemset in select)
-  nsCOMPtr<nsIDOMElement>           mContextNode;
-  PRInt32                           mContextPosition;
-  PRInt32                           mContextSize;
-  PRBool                            mInsideSelect1;
+  PRBool         mDoneAddingChildren;
 };
 
 NS_IMPL_ISUPPORTS_INHERITED2(nsXFormsItemElement,
@@ -135,42 +124,13 @@ nsXFormsItemElement::OnCreated(nsIXTFBindableElementWrapper *aWrapper)
   mElement = node;
   NS_ASSERTION(mElement, "Wrapper is not an nsIDOMElement, we'll crash soon");
 
-  // Our anonymous content structure in <select> will look like this:
-  //
-  // <option/>   (mOption, also insertion point)
-  //
-  //XXX Remove when XBLizing <select>
-
-  nsCOMPtr<nsIDOMDocument> domDoc;
-  node->GetOwnerDocument(getter_AddRefs(domDoc));
-
-  nsCOMPtr<nsIDOMElement> element;
-  domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
-                          NS_LITERAL_STRING("option"),
-                          getter_AddRefs(element));
-
-  mOption = do_QueryInterface(element);
-  NS_ENSURE_TRUE(mOption, NS_ERROR_FAILURE);
-
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsXFormsItemElement::ParentChanged(nsIDOMElement *aNewParent)
 {
-  mInsideSelect1 = PR_FALSE;
   if (aNewParent) {
-    nsCOMPtr<nsIDOMNode> parent, tmp;
-    mElement->GetParentNode(getter_AddRefs(parent));
-    while (parent) {
-      if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1"))) {
-        mInsideSelect1 = PR_TRUE;
-        break;
-      }
-      tmp.swap(parent);
-      tmp->GetParentNode(getter_AddRefs(parent));
-    }
-
     Refresh();
   }
 
@@ -236,6 +196,8 @@ nsXFormsItemElement::BeginAddingChildren()
 NS_IMETHODIMP
 nsXFormsItemElement::DoneAddingChildren()
 {
+  mDoneAddingChildren = PR_TRUE;
+
   // Unsuppress notifications
   nsCOMPtr<nsIXTFElementWrapper> wrapper = do_QueryInterface(mElement);
   NS_ASSERTION(wrapper, "huh? our element must be an xtf wrapper");
@@ -252,19 +214,6 @@ nsXFormsItemElement::DoneAddingChildren()
 
 // nsIXFormsSelectChild
 
-NS_IMETHODIMP
-nsXFormsItemElement::GetAnonymousNodes(nsIArray **aNodes)
-{
-  nsCOMPtr<nsIMutableArray> array;
-  nsresult rv = NS_NewArray(getter_AddRefs(array));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  array->AppendElement(mOption, PR_FALSE);
-
-  NS_ADDREF(*aNodes = array);
-  return NS_OK;
-}
-
 NS_IMETHODIMP
 nsXFormsItemElement::SelectItemByValue(const nsAString &aValue, nsIDOMNode **aSelected)
 {
@@ -281,64 +230,6 @@ nsXFormsItemElement::SelectItemByValue(const nsAString &aValue, nsIDOMNode **aSe
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsXFormsItemElement::SelectItemsByValue(const nsStringArray &aValueList)
-{
-  nsAutoString value;
-  nsresult rv = GetValue(value);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  PRInt32 count = aValueList.Count();
-  for (PRInt32 i = 0; i < count; ++i) {
-    if (aValueList[i]->Equals(value)) {
-      mOption->SetSelected(PR_TRUE);
-      break;
-    }
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsItemElement::SelectItemsByContent(nsIDOMNode *aNode)
-{
-  // TODO: implement support for \<copy\> element.
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsItemElement::WriteSelectedItems(nsIDOMNode *aContainer, 
-                                        nsAString  &aStringBuffer)
-{
-  PRBool selected;
-  mOption->GetSelected(&selected);
-  if (!selected)
-    return NS_OK;
-
-  nsAutoString value;
-  nsresult rv = GetValue(value);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  if(aStringBuffer.IsEmpty()){
-    aStringBuffer.Append(value);
-  }
-  else{
-    aStringBuffer.Append(NS_LITERAL_STRING(" ") + value);
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsItemElement::SetContext(nsIDOMElement *aContextNode,
-                                PRInt32 aContextPosition, PRInt32 aContextSize)
-{
-  mContextNode = aContextNode;
-  mContextPosition = aContextPosition;
-  mContextSize = aContextSize;
-  return NS_OK;
-}
-
 NS_IMETHODIMP
 nsXFormsItemElement::GetValue(nsAString &aValue)
 {
@@ -380,67 +271,26 @@ nsXFormsItemElement::GetValue(nsAString &aValue)
   return NS_OK;
 }
 
-NS_IMETHODIMP
+void
 nsXFormsItemElement::Refresh()
 {
-  if (mInsideSelect1) {
-    // <select1> is XBLized, so there is no need to recreate UI -
-    // XBL will do it for us.
-    return NS_OK;
-  }
-
-  // Clear out all of the existing option text
-  nsCOMPtr<nsIDOMNode> child, child2;
-  while (NS_SUCCEEDED(mOption->GetFirstChild(getter_AddRefs(child))) && child)
-    mOption->RemoveChild(child, getter_AddRefs(child2));
-    
-  // We need to find our label child, serialize its contents
-  // (which can be xtf-generated), and set that as our label attribute.
-
-  nsCOMPtr<nsIDOMNodeList> children;
-  nsresult rv = mElement->GetChildNodes(getter_AddRefs(children));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  PRUint32 childCount;
-  children->GetLength(&childCount);
-
-  nsAutoString value;
-
-  nsCOMPtr<nsIDOMDocument> doc;
-  mElement->GetOwnerDocument(getter_AddRefs(doc));
-
-  nsCOMPtr<nsIDOMElement> container;
-  doc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS),
-                       NS_LITERAL_STRING("contextcontainer-inline"),
-                       getter_AddRefs(container));
-
-  NS_NAMED_LITERAL_STRING(modelStr, "model");
-
-  nsAutoString modelID;
-  mElement->GetAttribute(modelStr, modelID);
-  container->SetAttribute(modelStr, modelID);
-
-  nsCOMPtr<nsIXFormsContextControl> context = do_QueryInterface(container);
-  context->SetContext(mContextNode, 1, 1);
-
-  for (PRUint32 i = 0; i < childCount; ++i) {
-    children->Item(i, getter_AddRefs(child));
-    child->GetLocalName(value);
-    if (value.EqualsLiteral("label")) {
-      child->GetNamespaceURI(value);
-      if (value.EqualsLiteral(NS_NAMESPACE_XFORMS)) {
-        child->CloneNode(PR_TRUE, getter_AddRefs(child2));
-        container->AppendChild(child2, getter_AddRefs(child));
+  if (mDoneAddingChildren) {
+    nsCOMPtr<nsIDOMNode> parent, current;
+    current = mElement;
+    do {
+      current->GetParentNode(getter_AddRefs(parent));
+      if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1")) ||
+          nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select"))) {
+        nsCOMPtr<nsIXFormsControl> select(do_QueryInterface(parent));
+        if (select) {
+          select->Refresh();
+        }
+        return;
       }
-    }
+      current = parent;
+    } while(current);
   }
-
-  nsCOMPtr<nsIDOMNode> childReturn;
-  mOption->AppendChild(container, getter_AddRefs(childReturn));
-
-  return NS_OK;
 }
-
 NS_IMETHODIMP
 nsXFormsItemElement::SetActive(PRBool aActive)
 {
@@ -514,10 +364,11 @@ nsXFormsItemElement::LabelRefreshed()
   current = mElement;
   do {
     current->GetParentNode(getter_AddRefs(parent));
-    if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1"))) {
-      nsCOMPtr<nsIXFormsControl> select1(do_QueryInterface(parent));
-      if (select1) {
-        select1->Refresh();
+    if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1")) ||
+        nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select"))) {
+      nsCOMPtr<nsIXFormsControl> select(do_QueryInterface(parent));
+      if (select) {
+        select->Refresh();
       }
       return NS_OK;
     }
diff --git a/mozilla/extensions/xforms/nsXFormsItemSetElement.cpp b/mozilla/extensions/xforms/nsXFormsItemSetElement.cpp
index 6ab6fee7cb9..83e73730f1a 100644
--- a/mozilla/extensions/xforms/nsXFormsItemSetElement.cpp
+++ b/mozilla/extensions/xforms/nsXFormsItemSetElement.cpp
@@ -175,37 +175,6 @@ nsXFormsItemSetElement::DoneAddingChildren()
 
 // nsIXFormsSelectChild
 
-NS_IMETHODIMP
-nsXFormsItemSetElement::GetAnonymousNodes(nsIArray **aNodes)
-{
-  nsCOMPtr<nsIMutableArray> array;
-  nsresult rv = NS_NewArray(getter_AddRefs(array));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  PRInt32 itemCount = mItems.Count();
-  nsCOMPtr<nsIArray> childNodes;
-  nsCOMPtr<nsIDOMNode> childOption;
-
-  for (PRInt32 i = 0; i < itemCount; ++i) {
-    mItems[i]->GetAnonymousNodes(getter_AddRefs(childNodes));
-    if (!childNodes)
-      continue;
-
-    PRUint32 anonLength = 0;
-    childNodes->GetLength(&anonLength);
-
-    for (PRUint32 j = 0; j < anonLength; ++j) {
-      childOption = do_QueryElementAt(childNodes, j);
-      NS_ASSERTION(childOption, "invalid nodelist");
-
-      array->AppendElement(childOption, PR_FALSE);
-    }
-  }
-
-  NS_ADDREF(*aNodes = array);
-  return NS_OK;
-}
-
 NS_IMETHODIMP
 nsXFormsItemSetElement::SelectItemByValue(const nsAString &aValue, nsIDOMNode **aSelected)
 {
@@ -237,35 +206,6 @@ nsXFormsItemSetElement::SelectItemByValue(const nsAString &aValue, nsIDOMNode **
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsXFormsItemSetElement::SelectItemsByValue(const nsStringArray &aValueList)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsItemSetElement::SelectItemsByContent(nsIDOMNode *aNode)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsItemSetElement::WriteSelectedItems(nsIDOMNode *aContainer, 
-                                           nsAString  &aStringBuffer)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsItemSetElement::SetContext(nsIDOMElement *aContextNode,
-                                   PRInt32 aContextPosition,
-                                   PRInt32 aContextSize)
-{
-  // itemset can't be inside another itemset, so we don't need to worry about
-  // this.
-  return NS_OK;
-}
-
 // internal methods
 
 NS_IMETHODIMP
@@ -312,125 +252,82 @@ nsXFormsItemSetElement::Refresh()
   PRUint32 templateNodeCount = 0;
   if (templateNodes)
     templateNodes->GetLength(&templateNodeCount);
-  
-  nsCOMPtr<nsIDOMDocument> document;
-  mElement->GetOwnerDocument(getter_AddRefs(document));
-  if (!document)
+
+  if (!domDoc)
     return NS_OK;
 
   PRUint32 nodeCount;
   result->GetSnapshotLength(&nodeCount);
 
-  // XXX Possibly cleanup this when XBLizing <select>.
   nsCOMPtr<nsIDOMNode> parent, tmp;
   mElement->GetParentNode(getter_AddRefs(parent));
-  PRBool parentIsSelect1 = PR_FALSE;
-  while (parent &&
-    !nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select"))) {
-    if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1"))) {
-      parentIsSelect1 = PR_TRUE;
+
+  while (parent) {
+    if (nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select1")) ||
+        nsXFormsUtils::IsXFormsElement(parent, NS_LITERAL_STRING("select"))) {
       break;
     }
     tmp.swap(parent);
     tmp->GetParentNode(getter_AddRefs(parent));
   }
-  
-  if (parentIsSelect1) {
-    // For select1
-    nsCOMPtr<nsIXFormsItemSetUIElement> uiItemSet(do_QueryInterface(mElement));
-    nsCOMPtr<nsIDOMElement> anonContent;
-    if (uiItemSet) {
-      uiItemSet->GetAnonymousItemSetContent(getter_AddRefs(anonContent));
-    }
 
-    NS_ENSURE_STATE(anonContent);
-
-    nsCOMPtr<nsIDOMNode> childNode, nodeReturn;
-    while (NS_SUCCEEDED(anonContent->GetFirstChild(getter_AddRefs(childNode))) &&
-         childNode) {
-      anonContent->RemoveChild(childNode, getter_AddRefs(nodeReturn));
-    }
-
-    for (PRUint32 i = 0; i < nodeCount; ++i) {
-      result->SnapshotItem(i, getter_AddRefs(node));
-      NS_ASSERTION(node, "incorrect snapshot length");
-
-      nsresult rv = document->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS),
-                                              NS_LITERAL_STRING("item"),
-                                              getter_AddRefs(itemNode));
-      NS_ENSURE_SUCCESS(rv, rv);
-
-      // XXX Could we get rid of the <contextcontainer>?
-      rv = document->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS),
-                                     NS_LITERAL_STRING("contextcontainer"),
-                                     getter_AddRefs(contextContainer));
-
-      NS_ENSURE_SUCCESS(rv, rv);
-
-      nsCOMPtr<nsIDOMElement> modelElement = do_QueryInterface(model);
-      nsAutoString modelID;
-      modelElement->GetAttribute(NS_LITERAL_STRING("id"), modelID);
-
-      contextContainer->SetAttribute(NS_LITERAL_STRING("model"), modelID);
-
-      nsCOMPtr<nsIXFormsContextControl> ctx(do_QueryInterface(contextContainer));
-      if (ctx) {
-        ctx->SetContext(nsCOMPtr<nsIDOMElement>(do_QueryInterface(node)),
-                        i + 1, nodeCount);
-      }
-      // Clone the template content under the item
-      for (PRUint32 j = 0; j < templateNodeCount; ++j) {
-        templateNodes->Item(j, getter_AddRefs(templateNode));
-        templateNode->CloneNode(PR_TRUE, getter_AddRefs(cloneNode));
-        contextContainer->AppendChild(cloneNode, getter_AddRefs(templateNode));
-      }
-
-      itemNode->AppendChild(contextContainer, getter_AddRefs(tmpNode));
-      anonContent->AppendChild(itemNode, getter_AddRefs(tmpNode));
-    }
-  } else {
-    for (PRUint32 i = 0; i < nodeCount; ++i) {
-      result->SnapshotItem(i, getter_AddRefs(node));
-      NS_ASSERTION(node, "incorrect snapshot length");
-
-      document->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS),
-                                NS_LITERAL_STRING("item"),
-                                getter_AddRefs(itemNode));
-
-      if (!itemNode)
-        return NS_OK;
-
-      nsCOMPtr<nsIDOMElement> modelElement = do_QueryInterface(model);
-      nsAutoString modelID;
-      modelElement->GetAttribute(NS_LITERAL_STRING("id"), modelID);
-
-      itemNode->SetAttribute(NS_LITERAL_STRING("model"), modelID);
-
-      nsCOMPtr<nsIXFormsSelectChild> item = do_QueryInterface(itemNode);
-      NS_ASSERTION(item, "item must be a SelectChild!");
-
-      item->SetContext(nsCOMPtr<nsIDOMElement>(do_QueryInterface(node)),
-                       i + 1, nodeCount);
-
-      // Clone the template content under the item
-      for (PRUint32 j = 0; j < templateNodeCount; ++j) {
-        templateNodes->Item(j, getter_AddRefs(templateNode));
-        templateNode->CloneNode(PR_TRUE, getter_AddRefs(cloneNode));
-        itemNode->AppendChild(cloneNode, getter_AddRefs(templateNode));
-      }
-
-      mItems.AppendObject(item);
-    }
+  nsCOMPtr<nsIXFormsItemSetUIElement> uiItemSet(do_QueryInterface(mElement));
+  nsCOMPtr<nsIDOMElement> anonContent;
+  if (uiItemSet) {
+    uiItemSet->GetAnonymousItemSetContent(getter_AddRefs(anonContent));
   }
 
-  // refresh parent control, since we are being defered
-  nsCOMPtr<nsIDOMNode> parentNode;
-  mElement->GetParentNode(getter_AddRefs(parentNode));
-  if (parentNode) {
+  NS_ENSURE_STATE(anonContent);
 
-    nsCOMPtr<nsIXFormsControlBase> stub = do_QueryInterface(parentNode);
-    if (stub) {
-      stub->Refresh();
+  nsCOMPtr<nsIDOMNode> childNode, nodeReturn;
+  while (NS_SUCCEEDED(anonContent->GetFirstChild(getter_AddRefs(childNode))) &&
+       childNode) {
+    anonContent->RemoveChild(childNode, getter_AddRefs(nodeReturn));
+  }
+
+  for (PRUint32 i = 0; i < nodeCount; ++i) {
+    result->SnapshotItem(i, getter_AddRefs(node));
+    NS_ASSERTION(node, "incorrect snapshot length");
+
+    nsresult rv = domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS),
+                                          NS_LITERAL_STRING("item"),
+                                          getter_AddRefs(itemNode));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // XXX Could we get rid of the <contextcontainer>?
+    rv = domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS),
+                                 NS_LITERAL_STRING("contextcontainer"),
+                                 getter_AddRefs(contextContainer));
+
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIDOMElement> modelElement = do_QueryInterface(model);
+    nsAutoString modelID;
+    modelElement->GetAttribute(NS_LITERAL_STRING("id"), modelID);
+
+    contextContainer->SetAttribute(NS_LITERAL_STRING("model"), modelID);
+
+    nsCOMPtr<nsIXFormsContextControl> ctx(do_QueryInterface(contextContainer));
+    if (ctx) {
+      ctx->SetContext(nsCOMPtr<nsIDOMElement>(do_QueryInterface(node)),
+                      i + 1, nodeCount);
+    }
+    // Clone the template content under the item
+    for (PRUint32 j = 0; j < templateNodeCount; ++j) {
+      templateNodes->Item(j, getter_AddRefs(templateNode));
+      templateNode->CloneNode(PR_TRUE, getter_AddRefs(cloneNode));
+      contextContainer->AppendChild(cloneNode, getter_AddRefs(templateNode));
+    }
+
+    itemNode->AppendChild(contextContainer, getter_AddRefs(tmpNode));
+    anonContent->AppendChild(itemNode, getter_AddRefs(tmpNode));
+  }
+
+  // refresh parent we
+  if (parent) {
+    nsCOMPtr<nsIXFormsControlBase> control = do_QueryInterface(parent);
+    if (control) {
+      control->Refresh();
     }
   }
 
diff --git a/mozilla/extensions/xforms/nsXFormsSelectElement.cpp b/mozilla/extensions/xforms/nsXFormsSelectElement.cpp
index f3d442a5b79..8820920c6d0 100644
--- a/mozilla/extensions/xforms/nsXFormsSelectElement.cpp
+++ b/mozilla/extensions/xforms/nsXFormsSelectElement.cpp
@@ -21,6 +21,7 @@
  *
  * Contributor(s):
  *  Brian Ryner <bryner@brianryner.com>
+ *  Doron Rosenberg <doronr@us.ibm.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
@@ -36,474 +37,76 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
-#include "nsXFormsControlStub.h"
-#include "nsIXTFXMLVisualWrapper.h"
-#include "nsIDOMFocusListener.h"
-#include "nsVoidArray.h"
-#include "nsIDOMElement.h"
-#include "nsCOMPtr.h"
-#include "nsString.h"
-#include "nsIDOMHTMLSelectElement.h"
-#include "nsIDOMDocument.h"
-#include "nsIDOMNodeList.h"
 #include "nsXFormsUtils.h"
+#include "nsXFormsControlStub.h"
+#include "nsXFormsDelegateStub.h"
 #include "nsXFormsAtoms.h"
-#include "nsIModelElementPrivate.h"
-#include "nsIXFormsSelectChild.h"
-#include "nsArray.h"
-#include "nsIDOMEventListener.h"
-#include "nsIDOMEventTarget.h"
+#include "nsCOMPtr.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMXPathResult.h"
+#include "nsIDOM3Node.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMText.h"
+#include "nsIXTFXMLVisualWrapper.h"
+#include "nsString.h"
+#include "nsIXFormsUIWidget.h"
+#include "nsIDocument.h"
+#include "nsNetUtil.h"
 
-class nsXFormsSelectElement : public nsXFormsControlStub,
-                              public nsIDOMEventListener
+class nsXFormsSelectElement : public nsXFormsDelegateStub
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
-  // nsIXTFXMLVisual overrides
-  NS_IMETHOD OnCreated(nsIXTFXMLVisualWrapper *aWrapper);
-
-  // nsIXTFVisual overrides
-  NS_IMETHOD GetVisualContent(nsIDOMElement **aElement);
-  NS_IMETHOD GetInsertionPoint(nsIDOMElement **aPoint);
+  NS_IMETHOD OnCreated(nsIXTFBindableElementWrapper *aWrapper);
 
   // nsIXTFElement overrides
-  NS_IMETHOD OnDestroyed();
-  NS_IMETHOD WillSetAttribute(nsIAtom *aName, const nsAString &aValue);
   NS_IMETHOD ChildInserted(nsIDOMNode *aChild, PRUint32 aIndex);
   NS_IMETHOD ChildAppended(nsIDOMNode *aChild);
-  NS_IMETHOD WillRemoveChild(PRUint32 aIndex);
-
-  NS_IMETHOD BeginAddingChildren();
-  NS_IMETHOD DoneAddingChildren();
-
-  // nsIXFormsControl
-  NS_IMETHOD Refresh();
-  NS_IMETHOD TryFocus(PRBool* aOK);
-
-  // nsIDOMEventListener
-  NS_DECL_NSIDOMEVENTLISTENER
+  NS_IMETHOD ChildRemoved(PRUint32 aIndex);
 
 #ifdef DEBUG_smaug
   virtual const char* Name() { return "select"; }
 #endif
-private:
-  NS_HIDDEN_(void) SelectItemsInList(const nsString &aValueList);
-  NS_HIDDEN_(void) SelectCopiedItem(nsIDOMNode *aNode);
-  NS_HIDDEN_(void) SelectItemsByValue(nsIDOMNode *aNode,
-                                      const nsStringArray &aItems);
-  NS_HIDDEN_(void) RemoveChildren(nsIDOMNode* aParent);
-
-  nsCOMPtr<nsIDOMElement> mLabel;
-  nsCOMPtr<nsIDOMHTMLSelectElement> mSelect;
 };
 
-NS_IMPL_ISUPPORTS_INHERITED1(nsXFormsSelectElement,
-                             nsXFormsControlStub,
-                             nsIDOMEventListener)
-
-// nsIXTFXMLVisual
+NS_IMPL_ISUPPORTS_INHERITED0(nsXFormsSelectElement,
+                             nsXFormsDelegateStub)
 
 NS_IMETHODIMP
-nsXFormsSelectElement::OnCreated(nsIXTFXMLVisualWrapper *aWrapper)
+nsXFormsSelectElement::OnCreated(nsIXTFBindableElementWrapper *aWrapper)
 {
-  nsXFormsControlStub::OnCreated(aWrapper);
+  nsresult rv = nsXFormsDelegateStub::OnCreated(aWrapper);
+  NS_ENSURE_SUCCESS(rv, rv);
 
   aWrapper->SetNotificationMask(kStandardNotificationMask |
                                 nsIXTFElement::NOTIFY_CHILD_INSERTED |
-                                nsIXTFElement::NOTIFY_CHILD_REMOVED |
-                                nsIXTFElement::NOTIFY_WILL_REMOVE_CHILD |
-                                nsIXTFElement::NOTIFY_BEGIN_ADDING_CHILDREN |
-                                nsIXTFElement::NOTIFY_DONE_ADDING_CHILDREN);
-
-  // Our anonymous content structure will look like this:
-  //
-  // <label>              (mLabel)
-  //   <span/>            (insertion point)
-  //   <select/>           (mSelect)
-  // </label>
-  //
-
-  nsCOMPtr<nsIDOMDocument> domDoc;
-  mElement->GetOwnerDocument(getter_AddRefs(domDoc));
-
-  domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
-                          NS_LITERAL_STRING("label"),
-                          getter_AddRefs(mLabel));
-  NS_ENSURE_TRUE(mLabel, NS_ERROR_FAILURE);
-
-  nsCOMPtr<nsIDOMElement> element;
-  nsCOMPtr<nsIDOMNode> childReturn;
-  domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
-                          NS_LITERAL_STRING("span"),
-                          getter_AddRefs(element));
-  NS_ENSURE_TRUE(element, NS_ERROR_FAILURE);
-
-  mLabel->AppendChild(element, getter_AddRefs(childReturn));
-
-  domDoc->CreateElementNS(NS_LITERAL_STRING(NS_NAMESPACE_XHTML),
-                          NS_LITERAL_STRING("select"),
-                          getter_AddRefs(element));
-
-  mSelect = do_QueryInterface(element);
-  NS_ENSURE_TRUE(mSelect, NS_ERROR_FAILURE);
-
-  // Unless we're a select1, set multiple=true
-  nsAutoString tag;
-  mElement->GetLocalName(tag);
-  if (!tag.EqualsLiteral("select1")) {
-    mSelect->SetMultiple(PR_TRUE);
-
-    // TODO: should leave default size=1 for select1, but options don't
-    // select correctly if we do that.  Need to figure out why.
-    //    mSelect->SetSize(4);
-  }
-
-  // Default to minimal/compact appearance
-  mSelect->SetSize(4);
-
-  // TODO: support "selection" and "incremental" attributes.
-
-  mLabel->AppendChild(mSelect, getter_AddRefs(childReturn));
-
-  nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(mSelect);
-  NS_ASSERTION(targ, "Select must be an event target");
-
-  // We need an onchange handler to support non-incremental mode, and
-  // a blur handler to support incremental mode.
-  targ->AddEventListener(NS_LITERAL_STRING("change"), this, PR_FALSE);
-  targ->AddEventListener(NS_LITERAL_STRING("blur"), this, PR_FALSE);
-  
-  return NS_OK;
-}
-
-// nsIXTFVisual
-
-NS_IMETHODIMP
-nsXFormsSelectElement::GetVisualContent(nsIDOMElement **aElement)
-{
-  NS_ADDREF(*aElement = mLabel);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsSelectElement::GetInsertionPoint(nsIDOMElement **aPoint)
-{
-  nsCOMPtr<nsIDOMNode> childNode;
-  mLabel->GetFirstChild(getter_AddRefs(childNode));
-  return CallQueryInterface(childNode, aPoint);
-}
-
-// nsIXTFElement
-
-void
-nsXFormsSelectElement::RemoveChildren(nsIDOMNode* aParent)
-{
-  if (aParent) {
-    nsCOMPtr<nsIDOMNode> childNode, nodeReturn;
-    while (NS_SUCCEEDED(aParent->GetFirstChild(getter_AddRefs(childNode))) &&
-           childNode) {
-      aParent->RemoveChild(childNode, getter_AddRefs(nodeReturn));
-
-      if (nodeReturn) {
-        RemoveChildren(nodeReturn);
-      }
-    }
-  }
-}
-
-NS_IMETHODIMP
-nsXFormsSelectElement::OnDestroyed()
-{
-  nsCOMPtr<nsIDOMEventTarget> targ = do_QueryInterface(mSelect);
-  if (NS_LIKELY(targ != nsnull)) {
-    targ->RemoveEventListener(NS_LITERAL_STRING("blur"), this, PR_FALSE);
-    targ->RemoveEventListener(NS_LITERAL_STRING("change"), this, PR_FALSE);
-  }
-
-  // XXX For some reason we leak <contextcontainer-inline> and
-  //     <label> elements, if the child elements of the <select>
-  //     are not removed manually.
-  RemoveChildren(mSelect);
-
-  mLabel = nsnull;
-  mSelect = nsnull;
-  return nsXFormsControlStub::OnDestroyed();
-}
-
-NS_IMETHODIMP
-nsXFormsSelectElement::WillSetAttribute(nsIAtom *aName,
-                                        const nsAString &aValue)
-{
-  nsXFormsControlStub::WillSetAttribute(aName, aValue);
-
-  if (aName == nsXFormsAtoms::appearance) {
-    //    if (aValue.EqualsLiteral("full")) {
-      // XXX todo
-    //    }
-
-    mSelect->SetSize(4);
-  }
-
+                                nsIXTFElement::NOTIFY_CHILD_APPENDED |
+                                nsIXTFElement::NOTIFY_CHILD_REMOVED);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsXFormsSelectElement::ChildInserted(nsIDOMNode *aChild, PRUint32 aIndex)
 {
+  Refresh();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsXFormsSelectElement::ChildAppended(nsIDOMNode *aChild)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsSelectElement::WillRemoveChild(PRUint32 aIndex)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsSelectElement::BeginAddingChildren()
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsXFormsSelectElement::DoneAddingChildren()
 {
   Refresh();
   return NS_OK;
 }
 
-// nsIXFormsControl
-
 NS_IMETHODIMP
-nsXFormsSelectElement::Refresh()
+nsXFormsSelectElement::ChildRemoved(PRUint32 aIndex)
 {
-  nsCOMPtr<nsIDOMNode> childNode, nodeReturn;
-  while (NS_SUCCEEDED(mSelect->GetFirstChild(getter_AddRefs(childNode))) &&
-         childNode) {
-
-    mSelect->RemoveChild(childNode, getter_AddRefs(nodeReturn));
-  }
-
-  nsCOMPtr<nsIDOMNodeList> childNodes;
-  nsresult rv = mElement->GetChildNodes(getter_AddRefs(childNodes));
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  nsCOMPtr<nsIXFormsSelectChild> childItem;
-  nsCOMPtr<nsIArray> childContent;
-
-  PRUint32 childCount;
-  childNodes->GetLength(&childCount);
-
-  for (PRUint32 i = 0; i < childCount; ++i) {
-    childNodes->Item(i, getter_AddRefs(childNode));
-    childItem = do_QueryInterface(childNode);
-    if (!childItem)
-      continue;
-
-    childItem->GetAnonymousNodes(getter_AddRefs(childContent));
-
-    PRUint32 nodeCount;
-    childContent->GetLength(&nodeCount);
-
-    for (PRUint32 j = 0; j < nodeCount; ++j) {
-      childNode = do_QueryElementAt(childContent, j);
-      mSelect->AppendChild(childNode, getter_AddRefs(nodeReturn));
-    }
-    // Deselect all of the options.  We'll resync with our bound node below.
-    mSelect->SetSelectedIndex(-1);
-  }
-
-  // since single node binding is optional, we won't send an error code.  But
-  // there is no point continuing below without mBoundNode.
-  if(!mBoundNode) {
-    return NS_OK;
-  }
-
-  nsCOMPtr<nsIDOMNodeList> children;
-  mBoundNode->GetChildNodes(getter_AddRefs(children));
-
-  if (!children)
-    return NS_OK;
-
-  nsCOMPtr<nsIDOMNode> child;
-  children->GetLength(&childCount);
-
-  for (PRUint32 k = 0; k < childCount; ++k) {
-    children->Item(k, getter_AddRefs(child));
-
-    PRUint16 nodeType;
-    child->GetNodeType(&nodeType);
-    switch (nodeType) {
-      case nsIDOMNode::TEXT_NODE:
-      {
-        nsAutoString nodeValue;
-        child->GetNodeValue(nodeValue);
-        SelectItemsInList(nodeValue);
-      }
-      break;
-
-      case nsIDOMNode::ELEMENT_NODE:
-        SelectCopiedItem(child);
-        break;
-
-      default:
-        break;
-    }
-  }
-
+  Refresh();
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsXFormsSelectElement::TryFocus(PRBool* aOK)
-{
-  *aOK = GetRelevantState() && nsXFormsUtils::FocusControl(mSelect);
-  return NS_OK;
-}
-
-// nsIDOMEventListener
-
-NS_IMETHODIMP
-nsXFormsSelectElement::HandleEvent(nsIDOMEvent *aEvent)
-{
-  if (!nsXFormsUtils::EventHandlingAllowed(aEvent, mElement))
-    return NS_OK;
-
-  nsAutoString type;
-  aEvent->GetType(type);
-
-  nsAutoString value;
-  mElement->GetAttribute(NS_LITERAL_STRING("incremental"), value);
-
-  // the default incremental value for a select element is 'true' according
-  // to the spec, so if there is no incremental value, assume true.
-  PRBool isIncremental = !value.EqualsLiteral("false");
-
-  if ((isIncremental && type.EqualsLiteral("change")) ||
-      (!isIncremental && type.EqualsLiteral("blur"))) {
-
-    if (!mBoundNode || !mModel)
-      return NS_OK;
-
-    // Update the instance data with our selected items.
-    nsCOMPtr<nsIDOMNodeList> children;
-    nsresult rv = mElement->GetChildNodes(getter_AddRefs(children));
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    nsCOMPtr<nsIDOMNode> child;
-    nsCOMPtr<nsIXFormsSelectChild> childItem;
-    PRUint32 childCount;
-    children->GetLength(&childCount);
-
-    nsAutoString stringBuffer;
-    for (PRUint32 i = 0; i < childCount; ++i) {
-      children->Item(i, getter_AddRefs(child));
-      childItem = do_QueryInterface(child);
-      if (childItem) {
-        // This will go item by item, looking for selected nodes.  For every
-        // selected option that it finds, it will append the option's value
-        // to the string buffer (for childItems that are not xforms:itemset's).
-        childItem->WriteSelectedItems(mBoundNode, stringBuffer);
-      }
-    }
-
-    PRBool changed = PR_FALSE;
-
-    rv = mModel->SetNodeValue(mBoundNode, stringBuffer, &changed);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    if (changed) {
-      nsCOMPtr<nsIDOMNode> modelNode = do_QueryInterface(mModel);
-      NS_ENSURE_STATE(modelNode);
-    
-      rv = nsXFormsUtils::DispatchEvent(modelNode, eEvent_Recalculate);
-      NS_ENSURE_SUCCESS(rv, rv);
-      rv = nsXFormsUtils::DispatchEvent(modelNode, eEvent_Revalidate);
-      NS_ENSURE_SUCCESS(rv, rv);        
-      rv = nsXFormsUtils::DispatchEvent(modelNode, eEvent_Refresh);
-      NS_ENSURE_SUCCESS(rv, rv);        
-    }
-  }
-
-  return NS_OK;
-}
-
-// internal methods
-
-inline PRBool
-IsWhiteSpace(PRUnichar c)
-{
-  return (c == PRUnichar(' ') || c == PRUnichar('\r') || c == PRUnichar('\n')
-          || c == PRUnichar('\t'));
-}
-
-void
-nsXFormsSelectElement::SelectItemsInList(const nsString &aValueList)
-{
-  // Start by separating out the space-separated list of values.
-
-  const PRUnichar *start = aValueList.get();
-  nsStringArray valueList;
-
-  do {
-    // Skip past any whitespace.
-    while (*start && IsWhiteSpace(*start))
-      ++start;
-
-    const PRUnichar *valueStart = start;
-
-    // Now search for the end of the value
-    while (*start && !IsWhiteSpace(*start))
-      ++start;
-
-    valueList.AppendString(nsDependentSubstring(valueStart, start));
-  } while (*start);
-
-  // Now walk our children and figure out which ones to select.
-  // We use a helper function for this that can recurse into choices
-  // and itemset nodes.
-  SelectItemsByValue(mElement, valueList);
-}
-
-void
-nsXFormsSelectElement::SelectItemsByValue(nsIDOMNode          *aNode,
-                                          const nsStringArray &aItems)
-{
-  // If we have no children, we can stop immediately.
-  nsCOMPtr<nsIDOMNodeList> children;
-  aNode->GetChildNodes(getter_AddRefs(children));
-  if (!children)
-    return;
-
-  PRUint32 childCount;
-  children->GetLength(&childCount);
-
-  nsAutoString temp;
-  nsCOMPtr<nsIDOMNode> child;
-  nsCOMPtr<nsIXFormsSelectChild> item;
-
-  for (PRUint32 i = 0; i < childCount; ++i) {
-    children->Item(i, getter_AddRefs(child));
-    item = do_QueryInterface(child);
-
-    if (item)
-      item->SelectItemsByValue(aItems);
-  }
-}
-
-void
-nsXFormsSelectElement::SelectCopiedItem(nsIDOMNode *aNode)
-{
-  // TODO: this should select the item which is a copy of |aNode|.
-}
-
 NS_HIDDEN_(nsresult)
 NS_NewXFormsSelectElement(nsIXTFElement **aResult)
 {
@@ -514,3 +117,4 @@ NS_NewXFormsSelectElement(nsIXTFElement **aResult)
   NS_ADDREF(*aResult);
   return NS_OK;
 }
+
diff --git a/mozilla/extensions/xforms/resources/content/select.xml b/mozilla/extensions/xforms/resources/content/select.xml
new file mode 100644
index 00000000000..08e72ce04fa
--- /dev/null
+++ b/mozilla/extensions/xforms/resources/content/select.xml
@@ -0,0 +1,676 @@
+<?xml version="1.0"?>
+
+<!-- ***** 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
+   - IBM Corporation.
+   - Portions created by the Initial Developer are Copyright (C) 2005
+   - the Initial Developer. All Rights Reserved.
+   -
+   - Contributor(s):
+   -  Doron Rosenberg <doronr@us.ibm.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
+   - 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 ***** -->
+
+<!--
+  XBL select parses the childnodes of the xforms:select and then constructs
+  the anonymous content programmatically.
+
+  The main _buildSelect() method assumes that each select implementation
+  has three methods: _addSelectItem (for xf:item), _handleChoices (for xf:choice,
+  which can be nested) and _addItemSetItem for itemsets.
+
+  _controlArray is used to store each generated selectable item in the UI
+  (html:select for regular select and checkboxes for appearance="full" selects.
+
+  For a regular select (default appearance), the anonymous content generates
+  an html:select and child html:option and html:optgroup (for choices).
+
+  For an appearance="full" select, the anonymous content generates:
+
+    <html:table>
+      <html:tr>
+        <html:td valign="bottom">
+          // label goes here
+        </html:td>
+        <html:td anonid="checkbox-group"
+          <html:div>
+            <html:input type="checkbox"/>
+            <html:span>Label</html:span>
+          </html:div>
+        </html:td>
+      </html:tr>
+    </html:table>
+-->
+
+<bindings id="xformsBindings"
+          xmlns="http://www.mozilla.org/xbl"
+          xmlns:html="http://www.w3.org/1999/xhtml"
+          xmlns:xbl="http://www.mozilla.org/xbl"
+          xmlns:xforms="http://www.w3.org/2002/xforms">
+
+ <!-- SELECT: <DEFAULT> -->
+  <binding id="xformswidget-select"
+           extends="chrome://xforms/content/xforms.xml#xformswidget-base">
+    <content>
+      <html:label>
+        <html:span>
+           <children includes="label"/>
+        </html:span>
+        <html:select xbl:inherits="style"
+                     onchange="this.parentNode.parentNode.selectionChanged();"
+                     onblur="this.parentNode.parentNode.handleBlur();"
+                     multiple="true"
+                     size="5"
+                     anonid="select"/>
+        <children/>
+      </html:label>
+    </content>
+
+    <implementation implements="nsIXFormsUIWidget">
+      <constructor>
+        <![CDATA[
+        ]]>
+      </constructor>
+
+      <field name="_uiElement">null</field>
+      <property name="uiElement" readonly="true">
+        <getter>
+          if (!this._uiElement) {
+            this._uiElement =
+              document.getAnonymousElementByAttribute(this, "anonid", "select");
+          }
+
+          return this._uiElement;
+        </getter>
+      </property>
+
+      <property name="selectedIndex">
+        <setter>
+          this.uiElement.selectedIndex = val;
+        </setter>
+      </property>
+
+      <field name="_delegateValueCache">null</field>
+
+      <!-- Make sure we don't refresh while we are refreshing (race condition).
+           This happens when we are inside a repeat for example. We use the
+           _refreshing field to store if we are refreshing or not. -->
+      <field name="_refreshing">false</field>
+      <method name="refresh">
+        <body>
+        <![CDATA[
+          if (this._refreshing)
+            return;
+
+          if (this.delegate.isReadonly) {
+            this.uiElement.setAttribute("readonly", "readonly");
+          } else {
+            this.uiElement.removeAttribute("readonly");
+          }
+
+          if (!this.delegate.hasBoundNode)
+            return;
+
+          this._refreshing = true;
+
+          // We detect if the instance data we bind to has changed.  If it has,
+          // changed, we simply update the selection.  If it hasn't, that means
+          // we rebuild the select UI.  We also rebuild if the delegate cache is
+          // null (first load).
+          if (this._delegateValueCache == null ||
+              this._delegateValueCache == this.delegate.value) {
+            // refresh was not called due to instance data changing, so build the
+            // UI.
+            this._buildSelect();
+          } else {
+            // update selection
+            this._updateSelection();
+          }
+
+          // store the delegate value
+          this._delegateValueCache = this.delegate.value;
+
+          this._refreshing = false;
+
+          return true;
+         ]]>
+        </body>
+      </method>
+
+      <field name="_controlArraySize">0</field>
+      <field name="_controlArray">new Array()</field>
+
+      <method name="_buildSelect">
+        <body>
+        <![CDATA[
+          // select builds its own UI by parsing it's children.
+
+          // replace new line (\n), tabs (\t) and carriage returns (\r) with "".
+          var value = this.delegate.value.replace(/\n|\t|\r/g, " ");
+
+          // get an array of values selected in the bound node
+          var selectedArray = value.split(" ");
+
+          // create a hash from the default values so we can store how often
+          // we encountered them.  This allows us to figure out later if any were
+          // not hit, which requires us to send an event.
+          var defaultHash = new Object();
+          for (var run = 0; run < selectedArray.length; run++) {
+            defaultHash[selectedArray[run]] = {hits: 0}
+          }
+
+          // clear the UI children
+          for (var i = this.uiElement.childNodes.length; i > 0; i--) {
+             this.uiElement.removeChild(this.uiElement.childNodes[i-1]);
+          }
+
+          // create children
+          var child, option;
+          var childNodes = this.childNodes;
+
+          // these hold an array of generated HTML controls
+          this._controlArraySize = 0;
+          this._controlArray = new Array();
+
+          for (var i = 0; i < childNodes.length; i++) {
+            child = childNodes[i];
+
+            // we only care about element nodes in the XForms namespace.
+            if (child.nodeType == child.ELEMENT_NODE &&
+                child.namespaceURI == this.XFORMS_NS) {
+              if (child.localName == "item") {
+                // cache the item's label/value
+                var itemElement =
+                  child.QueryInterface(Components.interfaces.nsIXFormsItemElement);
+                var value = itemElement.value;
+                var label = itemElement.labelText;
+
+                this._addSelectItem(label, value, child);
+
+                // check if we should pre-select this option
+                if (defaultHash[value] != null) {
+                  var control = this._controlArray[this._controlArraySize - 1]
+                  this._setItemSelection(control, true);
+
+                  defaultHash[value].hits++;
+                }
+              } else if (child.localName == "choices") {
+                var optGroup = this._handleChoices(child);
+                this.uiElement.appendChild(optGroup);
+              } else if (child.localName == "itemset") {
+                var uiElement =
+                  child.QueryInterface(Components.interfaces.nsIXFormsItemSetUIElement);
+                var containers = uiElement.anonymousItemSetContent.childNodes;
+                for (var y = 0; y < containers.length; y++) {
+                  if (containers[y].nodeType == containers[y].ELEMENT_NODE) {
+                    this._addItemSetItem(containers[y]);
+                  }
+                }
+              }
+            }
+          }
+
+          // check if any default values were not found
+          for (var index in defaultHash) {
+            if (defaultHash[index].hits == 0) {
+              // XXX: some of default values not found, we need to throw an
+              // xforms-out-of-range event, but only if the select is 'closed'.
+              // If the select is open, the missing elements should be added
+              // and selected per 8.1.10 in the spec.
+            }
+          }
+
+          return true;
+         ]]>
+        </body>
+      </method>
+
+      <method name="_buildSelectItem">
+        <parameter name="aLabel"/>
+        <parameter name="aValue"/>
+        <parameter name="aControl"/>
+        <parameter name="aUseLabelValue"/>
+        <body>
+        <![CDATA[
+          // creates a select item element (html:option) and returns it
+
+          option = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                            "option");
+
+          option.setAttribute("value", aValue);
+          option.setAttribute("optionid", this._controlArraySize);
+
+          // itemsets needs to use aLabel and not the label element contents
+          if (aUseLabelValue) {
+            option.textContent = aLabel;
+          } else {
+            // label can contain other elements such as html, so we clone it
+            var label = aControl.getElementsByTagName("label")[0];
+            var newLabel = label.cloneNode(true);
+            option.appendChild(newLabel);
+          }
+
+          return option;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_addSelectItem">
+        <parameter name="aLabel"/>
+        <parameter name="aValue"/>
+        <parameter name="aControl"/>
+        <body>
+        <![CDATA[
+          // adds a new select item into the select
+
+          var option = this._buildSelectItem(aLabel, aValue, aControl, false);
+
+          var newOption = this.uiElement.appendChild(option);
+          option = newOption;
+
+          // add to the control array
+          this._controlArray[this._controlArraySize] =
+            {control: aControl, option: option, type: "item"}
+          this._controlArraySize++;
+
+          return option;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_setItemSelection">
+        <parameter name="aControl"/>
+        <parameter name="aValue"/>
+        <body>
+        <![CDATA[
+          aControl.option.selected = aValue;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_handleChoices">
+        <parameter name="aChoicesElement"/>
+        <body>
+        <![CDATA[
+          // creates the items for a choice and it's children
+
+          var child, label = "", option;
+
+          // create the html:optgroup
+          var optGroup = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                                  "optgroup");
+
+          for (var i = 0; i < aChoicesElement.childNodes.length; i++) {
+            child = aChoicesElement.childNodes[i];
+
+            // we only care about element nodes
+            if (child.nodeType == child.ELEMENT_NODE) {
+              if (child.localName == "label") {
+                label = child.textContent;
+              } else if (child.localName == "item") {
+                var itemElm = child.QueryInterface(Components.interfaces.nsIXFormsItemElement);
+                var itemValue = itemElm.value;
+                var itemLabel = itemElm.labelText;
+
+                var option = this._buildSelectItem(itemLabel, itemValue, child, false);
+                optGroup.appendChild(option);
+
+                // add to the control array
+                this._controlArray[this._controlArraySize] =
+                  {control: child, option: option, type: "item"}
+                this._controlArraySize++;
+              } else if (child.localName == "choices") {
+                optGroup.appendChild(this._handleChoices(child));
+              }
+            }
+          }
+
+          // set the label
+          optGroup.setAttribute("label", label);
+
+          return optGroup;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_addItemSetItem">
+        <parameter name="aItemElement"/>
+        <body>
+        <![CDATA[
+          var itemElm = aItemElement.QueryInterface(Components.interfaces.nsIXFormsItemElement);
+          var itemValue = itemElm.value;
+          var itemLabel = itemElm.labelText;
+
+          var option = this._buildSelectItem(itemLabel, itemValue, aItemElement, true);
+
+          // add to the control array
+          this._controlArray[this._controlArraySize] =
+            {control: aItemElement, option: option, type: "item"}
+          this._controlArraySize++;
+
+          this.uiElement.appendChild(option);
+        ]]>
+        </body>
+      </method>
+
+      <method name="selectionChanged">
+        <parameter name="aEvent"/>
+        <body>
+        <![CDATA[
+          // if incremental, change instance data and send the value-changed event
+          if (this.incremental) {
+            this._setBoundValue();
+          }
+        ]]>
+        </body>
+      </method>
+
+      <method name="_setBoundValue">
+        <body>
+        <![CDATA[
+          this.delegate.value = this._getSelectedValues();
+        ]]>
+        </body>
+      </method>
+
+      <method name="_getSelectedValues">
+        <body>
+        <![CDATA[
+          var selectedValues = "";
+
+          // select if found, unselect if not
+          var options = this._controlArray;
+
+          for (var i = 0; i < options.length; i++) {
+            var isSelected =
+              options[i].option ? options[i].option.selected : options[i].checkbox.checked;
+
+            if (isSelected) {
+              // space delimeted list
+              if (selectedValues.length > 0) {
+                selectedValues += " ";
+              }
+
+              selectedValues +=
+                options[i].control.QueryInterface(Components.interfaces.nsIXFormsSelectChild).value;
+            }
+          }
+
+          return selectedValues;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_updateSelection">
+        <body>
+        <![CDATA[
+          // get an array of values selected in the bound node
+          var selectedArray = this.delegate.value.split(" ");
+
+          // store the values in a hash for quick access
+          var defaultHash = new Object();
+          for (var run = 0; run < selectedArray.length; run++) {
+            defaultHash[selectedArray[run]] = {}
+          }
+
+          // select if found, unselect if not
+          var options = this._controlArray;
+
+          for (var i = 0; i < options.length; i++) {
+            var value =
+              options[i].control.QueryInterface(Components.interfaces.nsIXFormsSelectChild).value;
+            var selectionValue = (defaultHash[value] != null);
+
+            // either a checkbox or an option
+            if (options[i].option) {
+              if (options[i].option.selected != selectionValue)
+                options[i].option.selected = selectionValue;
+            } else {
+              if (options[i].checkbox.checked != selectionValue)
+                options[i].checkbox.checked = selectionValue;
+            }
+          }
+        ]]>
+        </body>
+      </method>
+
+      <property name="incremental">
+        <getter>
+        <![CDATA[
+          // default is true
+          var incremental = true;
+
+          if (this.hasAttribute("incremental")) {
+            if (this.getAttribute("incremental") == "false")
+              incremental = false;
+          }
+
+          return incremental;
+        ]]>
+        </getter>
+      </property>
+
+      <method name="focus">
+        <body>
+        <![CDATA[
+          this.uiElement.focus();
+          return true;
+        ]]>
+        </body>
+      </method>
+
+      <method name="handleBlur">
+        <body>
+        <![CDATA[
+          // update instance data if we are not incremental
+          if (!this.incremental) {
+            this._setBoundValue();
+          }
+        ]]>
+        </body>
+      </method>
+
+    </implementation>
+  </binding>
+
+ <!-- SELECT: <FULL> -->
+  <binding id="xformswidget-select-full"
+           extends="chrome://xforms/content/select.xml#xformswidget-select">
+    <content>
+      <html:table xbl:inherits="style">
+        <html:tr>
+          <html:td valign="bottom">
+            <children includes="label"/>
+          </html:td>
+          <html:td anonid="checkbox-group"
+                   onchange="this.parentNode.parentNode.parentNode.selectionChanged();">
+          </html:td>
+        </html:tr>
+      </html:table>
+
+      <html:span style="display:none">
+        <children/>
+      </html:span>
+    </content>
+
+   <implementation implements="nsIXFormsUIWidget">
+
+      <field name="_uiElement">null</field>
+      <property name="uiElement" readonly="true">
+        <getter>
+        <![CDATA[
+          if (!this._uiElement) {
+            this._uiElement =
+              document.getAnonymousElementByAttribute(this, "anonid",
+                                                      "checkbox-group");
+          }
+
+          return this._uiElement;
+        ]]>
+        </getter>
+      </property>
+
+      <method name="_buildSelectItem">
+        <parameter name="aLabel"/>
+        <parameter name="aValue"/>
+        <parameter name="aControl"/>
+        <parameter name="aUseLabelValue"/>
+        <body>
+        <![CDATA[
+          var div = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                             "div");
+
+          var labelSpan = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                                   "span");
+
+          if (aUseLabelValue) {
+            labelSpan.textContent = aLabel;
+          } else {
+            // label can contain other elements such as html, so we clone it
+            var label = aControl.getElementsByTagName("label")[0];
+            var newLabel = label.cloneNode(true);
+            labelSpan.appendChild(newLabel);
+          }
+
+          var input = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                               "input");
+          input.setAttribute("type", "checkbox");
+          input.setAttribute("value", aValue);
+          input.setAttribute("optionid", this._controlArraySize);
+
+          div.appendChild(input);
+          div.appendChild(labelSpan);
+
+          return div;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_addSelectItem">
+        <parameter name="aLabel"/>
+        <parameter name="aValue"/>
+        <parameter name="aControl"/>
+        <body>
+        <![CDATA[
+          var item = this._buildSelectItem(aLabel, aValue, aControl, false);
+          var newElement = this.uiElement.appendChild(item);
+          item = newElement;
+
+          // add to the control array
+          this._controlArray[this._controlArraySize] =
+            {control: aControl, checkbox: item.firstChild, type: "item"}
+          this._controlArraySize++;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_setItemSelection">
+        <parameter name="aControl"/>
+        <parameter name="aValue"/>
+        <body>
+        <![CDATA[
+          aControl.checkbox.checked = aValue;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_handleChoices">
+        <parameter name="aChoicesElement"/>
+        <body>
+        <![CDATA[
+          var child;
+
+          var mainDiv = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                                 "div");
+
+          var label = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                                "div");
+          label.className = "select-choice-label"
+          mainDiv.appendChild(label);
+
+          var contentDiv = document.createElementNS("http://www.w3.org/1999/xhtml",
+                                                    "div");
+          contentDiv.className = "select-choice-content";
+
+          for (var i = 0; i < aChoicesElement.childNodes.length; i++) {
+            child = aChoicesElement.childNodes[i];
+
+            // we only care about element nodes
+            if (child.nodeType == child.ELEMENT_NODE) {
+              if (child.localName == "label") {
+                label.textContent = child.textContent;
+              } else if (child.localName == "item") {
+                var itemElm =
+                  child.QueryInterface(Components.interfaces.nsIXFormsItemElement)
+                var itemValue = itemElm.value;
+                var itemLabel = itemElm.labelText;
+
+                var item = this._buildSelectItem(itemLabel, itemValue, child, false);
+                contentDiv.appendChild(item);
+
+                // add to the control array
+                this._controlArray[this._controlArraySize] =
+                  {control: child, checkbox: item.firstChild, type: "item"}
+                this._controlArraySize++;
+
+              } else if (child.localName == "choices") {
+                contentDiv.appendChild(this._handleChoices(child));
+              }
+            }
+          }
+
+          mainDiv.appendChild(contentDiv);
+          return mainDiv;
+        ]]>
+        </body>
+      </method>
+
+      <method name="_addItemSetItem">
+        <parameter name="aItemElement"/>
+        <body>
+        <![CDATA[
+          var itemElm = aItemElement.QueryInterface(Components.interfaces.nsIXFormsItemElement);
+          var itemValue = itemElm.value;
+          var itemLabel = itemElm.labelText;
+
+          var item = this._buildSelectItem(itemLabel, itemValue, aItemElement, true);
+
+          // add to the control array
+          this._controlArray[this._controlArraySize] =
+            {control: aItemElement, checkbox: item.firstChild, type: "item"}
+          this._controlArraySize++;
+
+          this.uiElement.appendChild(item);
+        ]]>
+        </body>
+      </method>
+
+    </implementation>
+  </binding>
+</bindings>
diff --git a/mozilla/extensions/xforms/resources/content/select1.xml b/mozilla/extensions/xforms/resources/content/select1.xml
index 52682f5c4e0..14e134780f7 100644
--- a/mozilla/extensions/xforms/resources/content/select1.xml
+++ b/mozilla/extensions/xforms/resources/content/select1.xml
@@ -628,7 +628,7 @@
     </implementation>
   </binding>
 
-  <binding id="xformswidget-select1-itemset">
+  <binding id="xformswidget-itemset">
     <content>
       <html:div style="display:none;">
         <children/>
diff --git a/mozilla/extensions/xforms/resources/content/xforms.css b/mozilla/extensions/xforms/resources/content/xforms.css
index 7e227baff7e..7335b6cd157 100755
--- a/mozilla/extensions/xforms/resources/content/xforms.css
+++ b/mozilla/extensions/xforms/resources/content/xforms.css
@@ -113,8 +113,9 @@ select1 {
   -moz-binding: url('chrome://xforms/content/select1.xml#xformswidget-select1');
 }
 
-select1 itemset {
-  -moz-binding: url('chrome://xforms/content/select1.xml#xformswidget-select1-itemset');
+select1 itemset,
+select itemset {
+  -moz-binding: url('chrome://xforms/content/select1.xml#xformswidget-itemset');
 }
 
 /* Most of the select1 specific CSS is copied from forms.css */
@@ -232,3 +233,23 @@ case > html|div.-moz-xforms-case-container {
   display: inherit;
 }
 
+/* select */
+select {
+  -moz-binding: url('chrome://xforms/content/select.xml#xformswidget-select');
+}
+
+select[appearance="full"] {
+  -moz-binding: url('chrome://xforms/content/select.xml#xformswidget-select-full');
+}
+
+select html|div.select-choice-label {
+  font: -moz-list;
+  font-style: italic;
+  font-weight: bold;
+}
+
+select html|div.select-choice-content {
+  padding-left: 10px;
+}
+
+