HTMLFormControlElement.cpp [plain text]
#include "config.h"
#include "HTMLFormControlElement.h"
#include "Document.h"
#include "EventHandler.h"
#include "Event.h"
#include "EventNames.h"
#include "Frame.h"
#include "HTMLFormElement.h"
#include "HTMLInputElement.h"
#include "HTMLNames.h"
#include "HTMLParser.h"
#include "HTMLTokenizer.h"
#include "RenderTheme.h"
namespace WebCore {
using namespace HTMLNames;
HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName, Document* doc, HTMLFormElement* f)
: HTMLElement(tagName, doc)
, m_form(f)
, m_disabled(false)
, m_readOnly(false)
, m_valueMatchesRenderer(false)
{
if (!m_form)
m_form = findFormAncestor();
if (m_form)
m_form->registerFormElement(this);
}
HTMLFormControlElement::~HTMLFormControlElement()
{
if (m_form)
m_form->removeFormElement(this);
}
void HTMLFormControlElement::parseMappedAttribute(MappedAttribute *attr)
{
if (attr->name() == nameAttr) {
} else if (attr->name() == disabledAttr) {
bool oldDisabled = m_disabled;
m_disabled = !attr->isNull();
if (oldDisabled != m_disabled) {
setChanged();
if (renderer() && renderer()->style()->hasAppearance())
theme()->stateChanged(renderer(), EnabledState);
}
} else if (attr->name() == readonlyAttr) {
bool oldReadOnly = m_readOnly;
m_readOnly = !attr->isNull();
if (oldReadOnly != m_readOnly) {
setChanged();
if (renderer() && renderer()->style()->hasAppearance())
theme()->stateChanged(renderer(), ReadOnlyState);
}
} else
HTMLElement::parseMappedAttribute(attr);
}
void HTMLFormControlElement::attach()
{
ASSERT(!attached());
HTMLElement::attach();
if (renderer())
renderer()->updateFromElement();
if (autofocus() && renderer() && !document()->ignoreAutofocus() && !isReadOnlyControl() &&
((hasTagName(inputTag) && !isInputTypeHidden()) || hasTagName(selectTag) ||
hasTagName(buttonTag) || hasTagName(textareaTag)))
focus();
}
void HTMLFormControlElement::insertedIntoTree(bool deep)
{
if (!m_form) {
m_form = findFormAncestor();
if (m_form)
m_form->registerFormElement(this);
else
document()->checkedRadioButtons().addButton(this);
}
HTMLElement::insertedIntoTree(deep);
}
static inline Node* findRoot(Node* n)
{
Node* root = n;
for (; n; n = n->parentNode())
root = n;
return root;
}
void HTMLFormControlElement::removedFromTree(bool deep)
{
HTMLParser* parser = 0;
if (Tokenizer* tokenizer = document()->tokenizer())
if (tokenizer->isHTMLTokenizer())
parser = static_cast<HTMLTokenizer*>(tokenizer)->htmlParser();
if (m_form && !(parser && parser->isHandlingResidualStyleAcrossBlocks()) && findRoot(this) != findRoot(m_form)) {
m_form->removeFormElement(this);
m_form = 0;
}
HTMLElement::removedFromTree(deep);
}
const AtomicString& HTMLFormControlElement::name() const
{
const AtomicString& n = getAttribute(nameAttr);
return n.isNull() ? emptyAtom : n;
}
void HTMLFormControlElement::setName(const AtomicString &value)
{
setAttribute(nameAttr, value);
}
void HTMLFormControlElement::onChange()
{
dispatchEventForType(eventNames().changeEvent, true, false);
}
bool HTMLFormControlElement::disabled() const
{
return m_disabled;
}
void HTMLFormControlElement::setDisabled(bool b)
{
setAttribute(disabledAttr, b ? "" : 0);
}
void HTMLFormControlElement::setReadOnly(bool b)
{
setAttribute(readonlyAttr, b ? "" : 0);
}
bool HTMLFormControlElement::autofocus() const
{
return hasAttribute(autofocusAttr);
}
void HTMLFormControlElement::setAutofocus(bool b)
{
setAttribute(autofocusAttr, b ? "autofocus" : 0);
}
void HTMLFormControlElement::recalcStyle(StyleChange change)
{
HTMLElement::recalcStyle(change);
if (renderer())
renderer()->updateFromElement();
}
bool HTMLFormControlElement::isFocusable() const
{
if (disabled() || !renderer() ||
(renderer()->style() && renderer()->style()->visibility() != VISIBLE) ||
!renderer()->isBox() || toRenderBox(renderer())->size().isEmpty())
return false;
return true;
}
bool HTMLFormControlElement::isKeyboardFocusable(KeyboardEvent* event) const
{
if (isFocusable())
if (document()->frame())
return document()->frame()->eventHandler()->tabsToAllControls(event);
return false;
}
bool HTMLFormControlElement::isMouseFocusable() const
{
#if PLATFORM(GTK)
return HTMLElement::isMouseFocusable();
#else
return false;
#endif
}
short HTMLFormControlElement::tabIndex() const
{
return Element::tabIndex();
}
bool HTMLFormControlElement::willValidate() const
{
return form() && name().length() && !disabled() && !isReadOnlyControl();
}
bool HTMLFormControlElement::supportsFocus() const
{
return isFocusable() || (!disabled() && !document()->haveStylesheetsLoaded());
}
HTMLFormElement* HTMLFormControlElement::virtualForm() const
{
return m_form;
}
void HTMLFormControlElement::removeFromForm()
{
if (!m_form)
return;
m_form->removeFormElement(this);
m_form = 0;
}
HTMLFormControlElementWithState::HTMLFormControlElementWithState(const QualifiedName& tagName, Document* doc, HTMLFormElement* f)
: HTMLFormControlElement(tagName, doc, f)
{
FormControlElementWithState::registerFormControlElementWithState(this, document());
}
HTMLFormControlElementWithState::~HTMLFormControlElementWithState()
{
FormControlElementWithState::unregisterFormControlElementWithState(this, document());
}
void HTMLFormControlElementWithState::willMoveToNewOwnerDocument()
{
FormControlElementWithState::unregisterFormControlElementWithState(this, document());
HTMLFormControlElement::willMoveToNewOwnerDocument();
}
void HTMLFormControlElementWithState::didMoveToNewOwnerDocument()
{
FormControlElementWithState::registerFormControlElementWithState(this, document());
HTMLFormControlElement::didMoveToNewOwnerDocument();
}
void HTMLFormControlElementWithState::finishParsingChildren()
{
HTMLFormControlElement::finishParsingChildren();
Document* doc = document();
if (doc->hasStateForNewFormElements()) {
String state;
if (doc->takeStateForFormElement(name().impl(), type().impl(), state))
restoreState(state);
}
}
void HTMLFormControlElement::dispatchFocusEvent()
{
if (document()->frame())
document()->frame()->formElementDidFocus(this);
HTMLElement::dispatchFocusEvent();
}
void HTMLFormControlElement::dispatchBlurEvent()
{
if (document()->frame())
document()->frame()->formElementDidBlur(this);
HTMLElement::dispatchBlurEvent();
}
bool HTMLFormControlElement::autocorrect() const
{
if (hasAttribute(autocorrectAttr))
return !equalIgnoringCase(getAttribute(autocorrectAttr), "off");
if (HTMLFormElement* form = this->form())
return form->autocorrect();
return true;
}
void HTMLFormControlElement::setAutocorrect(bool b)
{
setAttribute(autocorrectAttr, b ? "on" : "off");
}
bool HTMLFormControlElement::autocapitalize() const
{
if (hasAttribute(autocapitalizeAttr))
return !equalIgnoringCase(getAttribute(autocapitalizeAttr), "off");
if (HTMLFormElement* form = this->form())
return form->autocapitalize();
return true;
}
void HTMLFormControlElement::setAutocapitalize(bool b)
{
setAttribute(autocapitalizeAttr, b ? "on" : "off");
}
}