Attachment #445683 for bug #556743

Attachment #445683: Patch - WIP for bug #556743

View | Details | Raw Unified | Return to bug 556743
Collapse All | Expand All





GK_ATOM(key, "key")
GK_ATOM(keycode, "keycode")
GK_ATOM(keydown, "keydown")
GK_ATOM(keypress, "keypress")
GK_ATOM(keyset, "keyset")
GK_ATOM(keytext, "keytext")
GK_ATOM(keyup, "keyup")
GK_ATOM(label, "label")
GK_ATOM(labels, "labels")
GK_ATOM(lang, "lang")
GK_ATOM(last, "last")
GK_ATOM(layer, "layer")
GK_ATOM(layout, "layout")
GK_ATOM(leading, "leading")
GK_ATOM(leaf, "leaf")
GK_ATOM(left, "left")
GK_ATOM(leftmargin, "leftmargin")

(-)a/content/html/content/public/Makefile.in (+1 lines)

Line	Link Here

Lines 63-74 EXPORTS = \	Link Here

		nsITextControlElement.h \

		nsITextControlElement.h \

		nsIFileControlElement.h \

		nsIFileControlElement.h \

		nsIFormSubmission.h \

		nsIFormSubmission.h \

		nsIFrameSetElement.h \

		nsIFrameSetElement.h \

		nsHTMLAudioElement.h \

		nsHTMLAudioElement.h \

		nsHTMLMediaElement.h \

		nsHTMLMediaElement.h \

		nsHTMLVideoElement.h \

		nsHTMLVideoElement.h \

		nsIHTMLCollection.h \

		nsIHTMLCollection.h \

		nsILabelableElement.h \

                $(NULL)

                $(NULL)

include $(topsrcdir)/config/rules.mk

include $(topsrcdir)/config/rules.mk

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Mozilla Foundation
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Mounir Lamouri <mounir.lamouri@mozilla.com> (original author)
+ *
+ * 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"),
+ * 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 ***** */
+#ifndef nsILabelableElement_h___
+#define nsILabelableElement_h___
+#include "nsISupports.h"
+#include "nsIContent.h"
+#include "nsContentList.h"
+#define NS_ILABELABLEELEMENT_IID \
+{ 0x6108a3d2, 0xf607, 0x4215, \
+ { 0xa6, 0xdc, 0xa3, 0xb7, 0xca, 0x1e, 0x0c, 0x8e } }
+/**
+ * Interface which labelable form controls have to use.
+ */
+class nsILabelableElement : public nsISupports
+{
+public:
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_ILABELABLEELEMENT_IID);
+  void AppendLabel(nsIContent* aContent)
+  {
+    mLabelList.AppendElement(aContent);
+  }
+  void RemoveLabel(nsIContent* aContent)
+  {
+    mLabelList.RemoveElement(aContent);
+  }
+protected:
+  nsBaseContentList   mLabelList;
+};
+NS_DEFINE_STATIC_IID_ACCESSOR(nsILabelableElement, NS_ILABELABLEELEMENT_IID)
+#endif /* nsILabelableElement_h___ */





    NS_INTERFACE_TABLE_ENTRY(_class, _i4)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i5)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i6)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i7)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i8)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i9)                                     \
  NS_OFFSET_AND_INTERFACE_TABLE_END

#define NS_HTML_CONTENT_INTERFACE_TABLE11(_class, _i1, _i2, _i3, _i4, _i5,    \
                                          _i6, _i7, _i8, _i9, _i10, _i11)     \
  NS_HTML_CONTENT_INTERFACE_TABLE_BEGIN(_class)                               \
    NS_INTERFACE_TABLE_ENTRY(_class, _i1)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i2)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i3)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i4)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i5)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i6)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i7)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i8)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i9)                                     \
    NS_INTERFACE_TABLE_ENTRY(_class, _i10)                                    \
    NS_INTERFACE_TABLE_ENTRY(_class, _i11)                                    \
  NS_OFFSET_AND_INTERFACE_TABLE_END


// Element class factory methods

#define NS_DECLARE_NS_NEW_HTML_ELEMENT(_elementName)              \
nsGenericHTMLElement*                                             \
NS_NewHTML##_elementName##Element(nsINodeInfo *aNodeInfo,         \





#include "nsGkAtoms.h"
#include "nsIPresShell.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIFormControl.h"
#include "nsIForm.h"
#include "nsIFormSubmission.h"
#include "nsIURL.h"
#include "nsILabelableElement.h"

#include "nsIFrame.h"
#include "nsIFormControlFrame.h"
#include "nsIEventStateManager.h"
#include "nsIDOMEvent.h"
#include "nsIDOMNSEvent.h"
#include "nsIDocument.h"
#include "nsGUIEvent.h"

  { 0 }
};

// Default type is 'submit'.
static const nsAttrValue::EnumTable* kButtonDefaultType = &kButtonTypeTable[2];

class nsHTMLButtonElement : public nsGenericHTMLFormElement,
                            public nsIDOMHTMLButtonElement,
                            public nsIDOMNSHTMLButtonElement,
                            public nsILabelableElement
{
public:
  nsHTMLButtonElement(nsINodeInfo *aNodeInfo);
  virtual ~nsHTMLButtonElement();

  // nsISupports
  NS_DECL_ISUPPORTS_INHERITED



  // nsIDOMNSHTMLButtonElement
  // Can't just use the macro, since it shares GetType with
  // nsIDOMHTMLButtonElement
  NS_IMETHOD Blur();
  NS_IMETHOD Focus();
  NS_IMETHOD Click();
  NS_IMETHOD SetType(const nsAString& aType);
  NS_IMETHOD GetLabels(nsIDOMNodeList** aLabels);

  // overriden nsIFormControl methods
  NS_IMETHOD_(PRInt32) GetType() const { return mType; }
  NS_IMETHOD Reset();
  NS_IMETHOD SubmitNamesValues(nsFormSubmission* aFormSubmission,
                               nsIContent* aSubmitElement);
  NS_IMETHOD SaveState();
  PRBool RestoreState(nsPresState* aState);

NS_IMPL_ADDREF_INHERITED(nsHTMLButtonElement, nsGenericElement)
NS_IMPL_RELEASE_INHERITED(nsHTMLButtonElement, nsGenericElement)


DOMCI_DATA(HTMLButtonElement, nsHTMLButtonElement)

// QueryInterface implementation for nsHTMLButtonElement
NS_INTERFACE_TABLE_HEAD(nsHTMLButtonElement)
  NS_HTML_CONTENT_INTERFACE_TABLE3(nsHTMLButtonElement,
                                   nsIDOMHTMLButtonElement,
                                   nsIDOMNSHTMLButtonElement,
                                   nsILabelableElement)
  NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLButtonElement,
                                               nsGenericHTMLFormElement)
NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLButtonElement)

// nsIDOMHTMLButtonElement


NS_IMPL_ELEMENT_CLONE(nsHTMLButtonElement)

// nsIDOMHTMLButtonElement

NS_IMETHODIMP
nsHTMLButtonElement::GetForm(nsIDOMHTMLFormElement** aForm)
{
  return nsGenericHTMLFormElement::GetForm(aForm);
}

NS_IMETHODIMP
nsHTMLButtonElement::GetLabels(nsIDOMNodeList** aLabels)
{
  *aLabels = nsnull;

  return NS_OK;
}

NS_IMPL_STRING_ATTR(nsHTMLButtonElement, AccessKey, accesskey)
NS_IMPL_BOOL_ATTR(nsHTMLButtonElement, Disabled, disabled)
NS_IMPL_STRING_ATTR(nsHTMLButtonElement, Name, name)
NS_IMPL_INT_ATTR_DEFAULT_VALUE(nsHTMLButtonElement, TabIndex, tabindex, 0)
NS_IMPL_STRING_ATTR(nsHTMLButtonElement, Value, value)
NS_IMPL_ENUM_ATTR_DEFAULT_VALUE(nsHTMLButtonElement, Type, type,
                                kButtonDefaultType->tag)






#include "nsIDOMHTMLInputElement.h"
#include "nsIDOMNSHTMLInputElement.h"
#include "nsITextControlElement.h"
#include "nsIFileControlElement.h"
#include "nsIDOMNSEditableElement.h"
#include "nsIRadioControlElement.h"
#include "nsIRadioVisitor.h"
#include "nsIPhonetic.h"
#include "nsILabelableElement.h"

#include "nsIControllers.h"
#include "nsFocusManager.h"
#include "nsPIDOMWindow.h"
#include "nsContentCID.h"
#include "nsIComponentManager.h"
#include "nsIDOMHTMLFormElement.h"
#include "nsIDOMEventTarget.h"

class nsHTMLInputElement : public nsGenericHTMLFormElement,
                           public nsImageLoadingContent,
                           public nsIDOMHTMLInputElement,
                           public nsIDOMNSHTMLInputElement,
                           public nsITextControlElement,
                           public nsIRadioControlElement,
                           public nsIPhonetic,
                           public nsIDOMNSEditableElement,
                           public nsIFileControlElement,
                           public nsILabelableElement
{
public:
  nsHTMLInputElement(nsINodeInfo *aNodeInfo, PRBool aFromParser);
  virtual ~nsHTMLInputElement();

  // nsISupports
  NS_DECL_ISUPPORTS_INHERITED


NS_IMPL_ADDREF_INHERITED(nsHTMLInputElement, nsGenericElement) 
NS_IMPL_RELEASE_INHERITED(nsHTMLInputElement, nsGenericElement) 


DOMCI_DATA(HTMLInputElement, nsHTMLInputElement)

// QueryInterface implementation for nsHTMLInputElement
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsHTMLInputElement)
  NS_HTML_CONTENT_INTERFACE_TABLE11(nsHTMLInputElement,
                                    nsIDOMHTMLInputElement,
                                    nsIDOMNSHTMLInputElement,
                                    nsITextControlElement,
                                    nsIFileControlElement,
                                    nsIRadioControlElement,
                                    nsIPhonetic,
                                    imgIDecoderObserver,
                                    nsIImageLoadingContent,
                                    imgIContainerObserver,
                                    nsIDOMNSEditableElement,
                                    nsILabelableElement)
  NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLInputElement,
                                               nsGenericHTMLFormElement)
NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLInputElement)


// nsIDOMNode

nsresult

    nsITextControlFrame* textControlFrame = do_QueryFrame(formControlFrame);
    if (textControlFrame)
      textControlFrame->GetPhonetic(aPhonetic);
  }

  return NS_OK;
}

NS_IMETHODIMP
nsHTMLInputElement::GetLabels(nsIDOMNodeList** aLabels)
{
  *aLabels = nsnull;
  // Use mLabelList from nsILabelableElement.
  NS_IF_ADDREF(*aLabels = new nsBaseContentList(mLabelList));

  return NS_OK;
}

#ifdef ACCESSIBILITY
/*static*/ nsresult
FireEventForAccessibility(nsIDOMHTMLInputElement* aTarget,
                          nsPresContext* aPresContext,
                          const nsAString& aEventType)
{
  nsCOMPtr<nsIDOMEvent> event;
  if (NS_SUCCEEDED(nsEventDispatcher::CreateEvent(aPresContext, nsnull,





#include "nsIForm.h"
#include "nsIDOMDocument.h"
#include "nsIDocument.h"
#include "nsGUIEvent.h"
#include "nsIEventStateManager.h"
#include "nsEventDispatcher.h"
#include "nsPIDOMWindow.h"
#include "nsFocusManager.h"
#include "nsILabelableElement.h"

class nsHTMLLabelElement : public nsGenericHTMLFormElement,
                           public nsIDOMHTMLLabelElement,
                           public nsIDOMNSHTMLLabelElement,
                           public nsStubMutationObserver
{
public:
  nsHTMLLabelElement(nsINodeInfo *aNodeInfo);
  virtual ~nsHTMLLabelElement();

  // nsISupports
  NS_DECL_ISUPPORTS_INHERITED


                           nsIAtom* aPrefix, const nsAString& aValue,
                           PRBool aNotify);
  virtual nsresult UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
                             PRBool aNotify);
  virtual void PerformAccesskey(PRBool aKeyCausesActivation,
                                PRBool aIsTrustedEvent);
  virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const;

  // nsIMutationObserver
  void ContentAppended    (nsIDocument* aDocument,
                           nsIContent* aContainer,
                           nsIContent* aFirstNewContent,
                           PRInt32 aNewIndexInContainer);
  void ContentInserted    (nsIDocument* aDocument,
                           nsIContent* aContainer,
                           nsIContent* aChild,
                           PRInt32 aIndexInContainer);
  void ContentRemoved     (nsIDocument* aDocument,
                           nsIContent* aContainer,
                           nsIContent* aChild,
                           PRInt32 aIndexInContainer);
  void NodeWillBeDestroyed(const nsINode* aNode);

  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsHTMLLabelElement,
                                           nsGenericHTMLFormElement)

protected:
  already_AddRefed<nsIContent> GetControlContent();
  already_AddRefed<nsIContent> GetFirstFormControl(nsIContent *current);
  void SetControl();

  // XXX It would be nice if we could use an event flag instead.
  PRPackedBool           mHandlingEvent;

  // The form control the label element is labeling.
  nsCOMPtr<nsILabelableElement>   mControl;

  // Whether we are observing the parent node.
  PRBool                 mObservingParent;
};

// construction, destruction


NS_IMPL_NS_NEW_HTML_ELEMENT(Label)


nsHTMLLabelElement::nsHTMLLabelElement(nsINodeInfo *aNodeInfo)
  : nsGenericHTMLFormElement(aNodeInfo)
  , mHandlingEvent(PR_FALSE)
  , mObservingParent(PR_FALSE)
{
}

nsHTMLLabelElement::~nsHTMLLabelElement()
{
  if (mControl) {
    mControl->RemoveLabel(this);
    mControl = nsnull;
  }
}

// nsISupports 

NS_IMPL_CYCLE_COLLECTION_CLASS(nsHTMLLabelElement)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsHTMLLabelElement, nsGenericHTMLFormElement)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mControl)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsHTMLLabelElement, nsGenericHTMLFormElement)
  NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mControl)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_ADDREF_INHERITED(nsHTMLLabelElement, nsGenericHTMLElement)
NS_IMPL_RELEASE_INHERITED(nsHTMLLabelElement, nsGenericHTMLElement)


DOMCI_DATA(HTMLLabelElement, nsHTMLLabelElement)

// QueryInterface implementation for nsHTMLLabelElement
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsHTMLLabelElement)
  NS_HTML_CONTENT_INTERFACE_TABLE3(nsHTMLLabelElement,
                                   nsIDOMHTMLLabelElement,
                                   nsIDOMNSHTMLLabelElement,
                                   nsIMutationObserver)
  NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLLabelElement,
                                               nsGenericHTMLFormElement)
NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLLabelElement)


// nsIDOMHTMLLabelElement



                                                     aBindingParent,
                                                     aCompileEventHandlers);
  NS_ENSURE_SUCCESS(rv, rv);

  if (aDocument) {
    RegUnRegAccessKey(PR_TRUE);
  }

  if (aParent) {
    aParent->AddMutationObserver(this);
    mObservingParent = PR_TRUE;
  }

  return rv;
}

void
nsHTMLLabelElement::UnbindFromTree(PRBool aDeep, PRBool aNullParent)
{
  if (IsInDoc()) {
    RegUnRegAccessKey(PR_FALSE);
  }

  if (mControl) {
    mControl->RemoveLabel(this);
  }

  nsIContent* parent = GetParent();
  if (mObservingParent && parent) {
    parent->RemoveMutationObserver(this);
  }

  nsGenericHTMLFormElement::UnbindFromTree(aDeep, aNullParent);
}

static PRBool
EventTargetIn(nsEvent *aEvent, nsIContent *aChild, nsIContent *aStop)
{
  nsCOMPtr<nsIContent> c = do_QueryInterface(aEvent->target);
  nsIContent *content = c;

{
  return NS_OK;
}

nsresult
nsHTMLLabelElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
                            const nsAString& aValue, PRBool aNotify)
{
  if (kNameSpaceID_None == aNameSpaceID) {
    if (aName == nsGkAtoms::accesskey) {
      RegUnRegAccessKey(PR_FALSE);
    }
    if (aName == nsGkAtoms::_for && !aValue.IsEmpty()) {
      if (mControl) {
        mControl->RemoveLabel(this);
        mControl = nsnull;
      }
    }
  }

  nsresult rv =
      nsGenericHTMLElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue,
                                    aNotify);

  if (aName == nsGkAtoms::accesskey && kNameSpaceID_None == aNameSpaceID &&
      !aValue.IsEmpty()) {


  return rv;
}

nsresult
nsHTMLLabelElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
                              PRBool aNotify)
{
  if (kNameSpaceID_None == aNameSpaceID) {
    if (aAttribute == nsGkAtoms::accesskey) {
      RegUnRegAccessKey(PR_FALSE);
    }
    if (aAttribute == nsGkAtoms::_for) {
      SetControl();
    }
  }

  return nsGenericHTMLElement::UnsetAttr(aNameSpaceID, aAttribute, aNotify);
}

void
nsHTMLLabelElement::PerformAccesskey(PRBool aKeyCausesActivation,
                                     PRBool aIsTrustedEvent)

    nsAutoPopupStatePusher popupStatePusher(aIsTrustedEvent ?
                                            openAllowed : openAbused);

    nsEventDispatcher::Dispatch(static_cast<nsIContent*>(this), presContext,
                                &event);
  }
}

void
nsHTMLLabelElement::SetControl()
{
  nsAutoString elementId;

  if (!GetAttr(kNameSpaceID_None, nsGkAtoms::_for, elementId)) {
    nsCOMPtr<nsIContent> content = GetFirstFormControl(this);
    mControl = do_QueryInterface(content);
    if (mControl) {
      mControl->AppendLabel(this);
    }
  } else {
    if (mControl) {
      mControl->RemoveLabel(this);
      mControl = nsnull;
    }
  }
}

already_AddRefed<nsIContent>
nsHTMLLabelElement::GetControlContent()
{
  nsAutoString elementId;

  if (!GetAttr(kNameSpaceID_None, nsGkAtoms::_for, elementId)) {
    // No @for, so we are a label for our first form control element.
    // Do a depth-first traversal to look for the first form control element.
    if (!mControl) {
      SetControl();
    }
    nsCOMPtr<nsIContent> content = do_QueryInterface(mControl);
    return content.get();
  }

  // We have a @for. The id has to be linked to an element in the same document
  // and this element should be a labelable form control.
  nsIDocument* doc = GetCurrentDoc();
  if (!doc) {
    return nsnull;
  }

  nsIContent* content = doc->GetElementById(elementId);
  if (!content) {
    return nsnull;
  }

  nsCOMPtr<nsILabelableElement> element = do_QueryInterface(content);
  if (element) {
    NS_ADDREF(content);
    return content;
  }

  return nsnull;
}

already_AddRefed<nsIContent>

  PRUint32 numNodes = current->GetChildCount();

  for (PRUint32 i = 0; i < numNodes; i++) {
    nsIContent *child = current->GetChildAt(i);
    if (!child) {
      continue;
    }

    nsCOMPtr<nsILabelableElement> element = do_QueryInterface(child);
    if (element) {
      NS_ADDREF(child);
      return child;
    }

    nsIContent* content = GetFirstFormControl(child).get();
    if (content) {
      return content;
    }
  }

  return nsnull;
}

// nsIMutationObserver

void
nsHTMLLabelElement::ContentAppended(nsIDocument* aDocument,
                                         nsIContent* aContainer,
                                         nsIContent* aFirstNewContent,
                                         PRInt32 aNewIndexInContainer)
{
  if (mObservingParent && aFirstNewContent == this) {
      GetParent()->RemoveMutationObserver(this);
      AddMutationObserver(this);
      mObservingParent = PR_FALSE;
  } else {
    SetControl();
  }
}

void
nsHTMLLabelElement::ContentInserted(nsIDocument* aDocument,
                                         nsIContent* aContainer,
                                         nsIContent* aChild,
                                         PRInt32 aIndexInContainer)
{
  if (mObservingParent) {
    if (aContainer == this) {
      SetControl();
    } else if (aChild == this) {
      GetParent()->RemoveMutationObserver(this);
      AddMutationObserver(this);
      mObservingParent = PR_FALSE;
    }
  } else {
    SetControl();
  }
}

void
nsHTMLLabelElement::ContentRemoved(nsIDocument* aDocument,
                                        nsIContent* aContainer,
                                        nsIContent* aChild,
                                        PRInt32 aIndexInContainer)
{
  if (!mObservingParent) {
    SetControl();
  }
}

void
nsHTMLLabelElement::NodeWillBeDestroyed(const nsINode *aNode)
{
  if (!mObservingParent) {
    // TODO: useful ?
#ifdef DEBUG
    printf(" === nsHTMLLabelElement::NodeWillBeDestroyed\n");
#endif // DEBUG
  }
}






 *
 * ***** END LICENSE BLOCK ***** */

#include "nsIDOMHTMLOutputElement.h"
#include "nsGenericHTMLElement.h"
#include "nsIFormSubmission.h"
#include "nsDOMSettableTokenList.h"
#include "nsStubMutationObserver.h"
#include "nsILabelableElement.h"


class nsHTMLOutputElement : public nsGenericHTMLFormElement,
                            public nsIDOMHTMLOutputElement,
                            public nsStubMutationObserver,
                            public nsILabelableElement
{
public:
  nsHTMLOutputElement(nsINodeInfo *aNodeInfo);
  virtual ~nsHTMLOutputElement();

  // nsISupports
  NS_DECL_ISUPPORTS_INHERITED




NS_IMPL_ADDREF_INHERITED(nsHTMLOutputElement, nsGenericElement)
NS_IMPL_RELEASE_INHERITED(nsHTMLOutputElement, nsGenericElement)

DOMCI_DATA(HTMLOutputElement, nsHTMLOutputElement)

NS_INTERFACE_TABLE_HEAD(nsHTMLOutputElement)
  NS_HTML_CONTENT_INTERFACE_TABLE3(nsHTMLOutputElement,
                                   nsIDOMHTMLOutputElement,
                                   nsIMutationObserver,
                                   nsILabelableElement)
  NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLOutputElement,
                                               nsGenericHTMLFormElement)
NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLOutputElement)

NS_IMPL_ELEMENT_CLONE(nsHTMLOutputElement)


NS_IMPL_STRING_ATTR(nsHTMLOutputElement, Name, name)

    mTokenList = new nsDOMSettableTokenList(this, nsGkAtoms::_for);
  }

  NS_ADDREF(*aResult = mTokenList);

  return NS_OK;
}

NS_IMETHODIMP
nsHTMLOutputElement::GetLabels(nsIDOMNodeList** aLabels)
{
  *aLabels = nsnull;

  return NS_OK;
}

void nsHTMLOutputElement::DescendantsChanged()
{
  if (mValueModeFlag == eModeDefault) {
    nsContentUtils::GetNodeTextContent(this, PR_TRUE, mDefaultValue);
  }
}

// nsIMutationObserver





NS_IMPL_ADDREF_INHERITED(nsHTMLSelectElement, nsGenericElement)
NS_IMPL_RELEASE_INHERITED(nsHTMLSelectElement, nsGenericElement)


DOMCI_DATA(HTMLSelectElement, nsHTMLSelectElement)

// QueryInterface implementation for nsHTMLSelectElement
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsHTMLSelectElement)
  NS_HTML_CONTENT_INTERFACE_TABLE4(nsHTMLSelectElement,
                                   nsIDOMHTMLSelectElement,
                                   nsIDOMNSHTMLSelectElement,
                                   nsISelectElement,
                                   nsILabelableElement)
  NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLSelectElement,
                                               nsGenericHTMLFormElement)
NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLSelectElement)


// nsIDOMHTMLSelectElement



        }
      }
    }
  }

  return rv;
}

NS_IMETHODIMP
nsHTMLSelectElement::GetLabels(nsIDOMNodeList** aLabels)
{
  *aLabels = nsnull;

  return NS_OK;
}

NS_IMPL_BOOL_ATTR(nsHTMLSelectElement, Disabled, disabled)
NS_IMPL_BOOL_ATTR(nsHTMLSelectElement, Multiple, multiple)
NS_IMPL_STRING_ATTR(nsHTMLSelectElement, Name, name)
NS_IMPL_INT_ATTR_DEFAULT_VALUE(nsHTMLSelectElement, Size, size, 0)
NS_IMPL_INT_ATTR_DEFAULT_VALUE(nsHTMLSelectElement, TabIndex, tabindex, 0)

NS_IMETHODIMP





#include "nsIDOMNSHTMLSelectElement.h"
#include "nsIDOMHTMLFormElement.h"
#include "nsIDOMHTMLOptionElement.h"
#include "nsIDOMHTMLOptionsCollection.h"
#include "nsIDOMNSHTMLOptionCollectn.h"
#include "nsISelectControlFrame.h"
#include "nsContentUtils.h"
#include "nsIHTMLCollection.h"
#include "nsILabelableElement.h"

// PresState
#include "nsXPCOM.h"
#include "nsPresState.h"
#include "nsIComponentManager.h"
#include "nsCheapSets.h"
#include "nsLayoutErrors.h"




/**
 * Implementation of &lt;select&gt;
 */
class nsHTMLSelectElement : public nsGenericHTMLFormElement,
                            public nsIDOMHTMLSelectElement,
                            public nsIDOMNSHTMLSelectElement,
                            public nsISelectElement,
                            public nsILabelableElement
{
public:
  nsHTMLSelectElement(nsINodeInfo *aNodeInfo, PRBool aFromParser = PR_FALSE);
  virtual ~nsHTMLSelectElement();

  // nsISupports
  NS_DECL_ISUPPORTS_INHERITED






#include "nsReadableUtils.h"
#include "nsEventDispatcher.h"
#include "nsLayoutUtils.h"
#include "nsLayoutErrors.h"
#include "nsStubMutationObserver.h"
#include "nsDOMError.h"
#include "mozAutoDocUpdate.h"
#include "nsISupportsPrimitives.h"
#include "nsILabelableElement.h"

static NS_DEFINE_CID(kXULControllersCID,  NS_XULCONTROLLERS_CID);

#define NS_NO_CONTENT_DISPATCH (1 << 0)

class nsHTMLTextAreaElement : public nsGenericHTMLFormElement,
                              public nsIDOMHTMLTextAreaElement,
                              public nsIDOMNSHTMLTextAreaElement,
                              public nsITextControlElement,
                              public nsIDOMNSEditableElement,
                              public nsStubMutationObserver,
                              public nsILabelableElement
{
public:
  nsHTMLTextAreaElement(nsINodeInfo *aNodeInfo, PRBool aFromParser = PR_FALSE);
  virtual ~nsHTMLTextAreaElement();

  // nsISupports
  NS_DECL_ISUPPORTS_INHERITED


NS_IMPL_ADDREF_INHERITED(nsHTMLTextAreaElement, nsGenericElement) 
NS_IMPL_RELEASE_INHERITED(nsHTMLTextAreaElement, nsGenericElement) 


DOMCI_DATA(HTMLTextAreaElement, nsHTMLTextAreaElement)

// QueryInterface implementation for nsHTMLTextAreaElement
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsHTMLTextAreaElement)
  NS_HTML_CONTENT_INTERFACE_TABLE6(nsHTMLTextAreaElement,
                                   nsIDOMHTMLTextAreaElement,
                                   nsIDOMNSHTMLTextAreaElement,
                                   nsITextControlElement,
                                   nsIDOMNSEditableElement,
                                   nsIMutationObserver,
                                   nsILabelableElement)
  NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLTextAreaElement,
                                               nsGenericHTMLFormElement)
NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLTextAreaElement)


// nsIDOMHTMLTextAreaElement



    return PR_TRUE;
  }

  // disabled textareas are not focusable
  *aIsFocusable = !HasAttr(kNameSpaceID_None, nsGkAtoms::disabled);
  return PR_FALSE;
}

NS_IMETHODIMP
nsHTMLTextAreaElement::GetLabels(nsIDOMNodeList** aLabels)
{
  *aLabels = nsnull;

  return NS_OK;
}

NS_IMPL_STRING_ATTR(nsHTMLTextAreaElement, AccessKey, accesskey)
NS_IMPL_INT_ATTR(nsHTMLTextAreaElement, Cols, cols)
NS_IMPL_BOOL_ATTR(nsHTMLTextAreaElement, Disabled, disabled)
NS_IMPL_NON_NEGATIVE_INT_ATTR(nsHTMLTextAreaElement, MaxLength, maxlength)
NS_IMPL_STRING_ATTR(nsHTMLTextAreaElement, Name, name)
NS_IMPL_BOOL_ATTR(nsHTMLTextAreaElement, ReadOnly, readonly)
NS_IMPL_INT_ATTR(nsHTMLTextAreaElement, Rows, rows)
NS_IMPL_INT_ATTR_DEFAULT_VALUE(nsHTMLTextAreaElement, TabIndex, tabindex, 0)





 * For more information on this interface, please see
 * http://dev.w3.org/html5/spec/forms.html#the-output-element
 *
 * @status UNDER_DEVELOPMENT
 */

interface nsIDOMDOMSettableTokenList;

[scriptable, uuid(ca1a9f35-510d-4730-b450-5999e6447392)]
interface nsIDOMHTMLOutputElement : nsIDOMHTMLElement
{
  readonly attribute nsIDOMDOMSettableTokenList htmlFor;
  readonly attribute nsIDOMHTMLFormElement      form;
           attribute DOMString                  name;

  readonly attribute DOMString                  type;
           attribute DOMString                  defaultValue;

   * See bug bug 345624.
   */
  //readonly attribute boolean willValidate;
  //readonly attribute ValidityState validity;
  //readonly attribute DOMString validationMessage;
  //boolean checkValidity();
  //void setCustomValidity(in DOMString error);

  readonly attribute nsIDOMNodeList             labels;
   * The labels IDL attribute will be added with bug 556743.
   */
  //readonly attribute nsIDOMNodeList             labels;
};






 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "domstubs.idl"

[scriptable, uuid(41693745-9c56-43c9-9c64-6b303afabf6e)]
interface nsIDOMNSHTMLButtonElement : nsISupports
{
  void                      blur();
  void                      focus();
  void                      click();
  attribute DOMString       type;

  readonly attribute nsIDOMNodeList labels;
};





 *
 * ***** END LICENSE BLOCK ***** */

#include "domstubs.idl"

interface nsIControllers;
interface nsIDOMFileList;

[scriptable, uuid(7daebcd1-a917-45fa-bdc6-df7c8e15d3ae)]
interface nsIDOMNSHTMLInputElement : nsISupports
{
	readonly attribute nsIControllers   controllers;
	
	readonly attribute long             textLength;
	
           attribute long             selectionStart;
           attribute long             selectionEnd;


           attribute DOMString        placeholder;

  void mozGetFileNameArray([optional] out unsigned long aLength,
                           [array,size_is(aLength), retval] out wstring aFileNames);
  void mozSetFileNameArray([array,size_is(aLength)] in wstring aFileNames,
                           in unsigned long aLength);

  readonly attribute nsIDOMNodeList labels;

	/* convenience */
  void                      setSelectionRange(in long selectionStart,
                                              in long selectionEnd);
};





 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "domstubs.idl"

[scriptable, uuid(8e1faa12-f704-45c0-9f81-334b8c9abcd7)]
interface nsIDOMNSHTMLSelectElement : nsISupports
{
  nsIDOMNode                item(in unsigned long index);
  nsIDOMNode                namedItem(in DOMString name);

  readonly attribute nsIDOMNodeList labels;
};





 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "domstubs.idl"

interface nsIControllers;

[scriptable, uuid(9bc51cd7-6191-4328-a029-464ddd23a3b1)]
interface nsIDOMNSHTMLTextAreaElement : nsISupports
{
  readonly attribute nsIControllers   controllers;

  readonly attribute long    textLength;
  attribute long             selectionStart;
  attribute long             selectionEnd;
  attribute long             maxLength;
  attribute DOMString        placeholder;

  readonly attribute nsIDOMNodeList labels;

  /**
   * Reflects the wrap content attribute. Possible values are "soft, "hard" and
   * "off". "soft" is the default.
   */
  [Null(Stringify)] attribute DOMString wrap;

  void                       setSelectionRange(in long selectionStart,
                                               in long selectionEnd);





 *
 * ***** END LICENSE BLOCK ***** */

#ifndef nsCycleCollector_h__
#define nsCycleCollector_h__

// NOTE: If you use header files to define DEBUG_CC, you must do so here
// *and* in nsCycleCollectionParticipant.h
#define DEBUG_CC

class nsISupports;
class nsCycleCollectionParticipant;
class nsCycleCollectionTraversalCallback;

// An nsCycleCollectionLanguageRuntime is a per-language object that
// implements language-specific aspects of the cycle collection task.







#ifndef nsCycleCollectionParticipant_h__
#define nsCycleCollectionParticipant_h__

#include "nsISupports.h"

// NOTE: If you use header files to define DEBUG_CC, you must do so here
// *and* in nsCycleCollector.h
#define DEBUG_CC

#define NS_CYCLECOLLECTIONPARTICIPANT_IID                                      \
{                                                                              \
    0x9674489b,                                                                \
    0x1f6f,                                                                    \
    0x4550,                                                                    \
    { 0xa7, 0x30, 0xcc, 0xae, 0xdd, 0x10, 0x4c, 0xf9 }                         \
}

Return to bug 556743