html_form.cpp
// --------------------------------------------------------------------------
#include "dom/html_form.h"
#include "dom/dom_exception.h"
#include "dom/dom_doc.h"
#include "html/html_formimpl.h"
#include "html/html_miscimpl.h"
#include "xml/dom_docimpl.h"
#include "misc/htmlhashes.h"
using namespace DOM;
HTMLButtonElement::HTMLButtonElement() : HTMLElement()
{
}
HTMLButtonElement::HTMLButtonElement(const HTMLButtonElement &other) : HTMLElement(other)
{
}
HTMLButtonElement::HTMLButtonElement(HTMLButtonElementImpl *impl) : HTMLElement(impl)
{
}
HTMLButtonElement &HTMLButtonElement::operator = (const Node &other)
{
assignOther( other, ID_BUTTON );
return *this;
}
HTMLButtonElement &HTMLButtonElement::operator = (const HTMLButtonElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLButtonElement::~HTMLButtonElement()
{
}
HTMLFormElement HTMLButtonElement::form() const
{
return Element::form();
}
DOMString HTMLButtonElement::accessKey() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
}
void HTMLButtonElement::setAccessKey( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
}
bool HTMLButtonElement::disabled() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
}
void HTMLButtonElement::setDisabled( bool _disabled )
{
if (impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ? "" : 0);
}
DOMString HTMLButtonElement::name() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_NAME);
}
void HTMLButtonElement::setName( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_NAME, value);
}
void HTMLButtonElement::focus( )
{
if(impl)
static_cast<HTMLButtonElementImpl*>(impl)->focus();
}
void HTMLButtonElement::blur( )
{
if(impl)
static_cast<HTMLButtonElementImpl*>(impl)->blur();
}
long HTMLButtonElement::tabIndex() const
{
if(!impl) return 0;
return static_cast<ElementImpl*>(impl)->tabIndex();
}
void HTMLButtonElement::setTabIndex( long _tabIndex )
{
if (!impl) return;
static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
}
DOMString HTMLButtonElement::type() const
{
if(!impl) return DOMString();
return static_cast<HTMLButtonElementImpl*>(impl)->type();
}
DOMString HTMLButtonElement::value() const
{
if(!impl) return DOMString();
DOMString s = static_cast<ElementImpl*>(impl)->getAttribute(ATTR_VALUE);
if (s.isNull()) return DOMString("");
return s;
}
void HTMLButtonElement::setValue( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_VALUE, value);
}
// --------------------------------------------------------------------------
HTMLFieldSetElement::HTMLFieldSetElement() : HTMLElement()
{
}
HTMLFieldSetElement::HTMLFieldSetElement(const HTMLFieldSetElement &other) : HTMLElement(other)
{
}
HTMLFieldSetElement::HTMLFieldSetElement(HTMLFieldSetElementImpl *impl) : HTMLElement(impl)
{
}
HTMLFieldSetElement &HTMLFieldSetElement::operator = (const Node &other)
{
assignOther( other, ID_FIELDSET );
return *this;
}
HTMLFieldSetElement &HTMLFieldSetElement::operator = (const HTMLFieldSetElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLFieldSetElement::~HTMLFieldSetElement()
{
}
HTMLFormElement HTMLFieldSetElement::form() const
{
return Element::form();
}
// --------------------------------------------------------------------------
HTMLFormElement::HTMLFormElement() : HTMLElement()
{
}
HTMLFormElement::HTMLFormElement(const HTMLFormElement &other) : HTMLElement(other)
{
}
HTMLFormElement::HTMLFormElement(HTMLFormElementImpl *impl) : HTMLElement(impl)
{
}
HTMLFormElement &HTMLFormElement::operator = (const Node &other)
{
assignOther( other, ID_FORM );
return *this;
}
HTMLFormElement &HTMLFormElement::operator = (const HTMLFormElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLFormElement::~HTMLFormElement()
{
}
HTMLCollection HTMLFormElement::elements() const
{
if(!impl) return HTMLCollection();
return HTMLFormCollection(impl);
}
long HTMLFormElement::length() const
{
if(!impl) return 0;
return static_cast<HTMLFormElementImpl*>(impl)->length();
}
DOMString HTMLFormElement::name() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_NAME);
}
void HTMLFormElement::setName( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_NAME, value);
}
DOMString HTMLFormElement::acceptCharset() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCEPT_CHARSET);
}
void HTMLFormElement::setAcceptCharset( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCEPT_CHARSET, value);
}
DOMString HTMLFormElement::action() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACTION);
}
void HTMLFormElement::setAction( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACTION, value);
}
DOMString HTMLFormElement::enctype() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ENCTYPE);
}
void HTMLFormElement::setEnctype( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ENCTYPE, value);
}
DOMString HTMLFormElement::method() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_METHOD);
}
void HTMLFormElement::setMethod( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_METHOD, value);
}
DOMString HTMLFormElement::target() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_TARGET);
}
void HTMLFormElement::setTarget( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_TARGET, value);
}
void HTMLFormElement::submit( )
{
if(impl) static_cast<HTMLFormElementImpl*>(impl)->submit( );
}
void HTMLFormElement::reset( )
{
if(impl) static_cast<HTMLFormElementImpl*>(impl)->reset( );
}
// --------------------------------------------------------------------------
HTMLInputElement::HTMLInputElement() : HTMLElement()
{
}
HTMLInputElement::HTMLInputElement(const HTMLInputElement &other) : HTMLElement(other)
{
}
HTMLInputElement::HTMLInputElement(HTMLInputElementImpl *impl) : HTMLElement(impl)
{
}
HTMLInputElement &HTMLInputElement::operator = (const Node &other)
{
assignOther( other, ID_INPUT );
return *this;
}
HTMLInputElement &HTMLInputElement::operator = (const HTMLInputElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLInputElement::~HTMLInputElement()
{
}
DOMString HTMLInputElement::defaultValue() const
{
if(!impl) return DOMString();
DOMString s = static_cast<ElementImpl*>(impl)->getAttribute(ATTR_VALUE);
if (s.isNull()) return DOMString("");
return s;
}
void HTMLInputElement::setDefaultValue( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALUE, value);
}
bool HTMLInputElement::defaultChecked() const
{
if(!impl) return 0;
return !((ElementImpl *)impl)->getAttribute(ATTR_CHECKED).isNull();
}
void HTMLInputElement::setDefaultChecked( bool _defaultChecked )
{
if(impl)
((ElementImpl *)impl)->setAttribute(ATTR_CHECKED, _defaultChecked ? "" : 0);
}
HTMLFormElement HTMLInputElement::form() const
{
return Element::form();
}
DOMString HTMLInputElement::accept() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ACCEPT);
}
void HTMLInputElement::setAccept( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ACCEPT, value);
}
DOMString HTMLInputElement::accessKey() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ACCESSKEY);
}
void HTMLInputElement::setAccessKey( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ACCESSKEY, value);
}
DOMString HTMLInputElement::align() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
}
void HTMLInputElement::setAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
}
DOMString HTMLInputElement::alt() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALT);
}
void HTMLInputElement::setAlt( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALT, value);
}
bool HTMLInputElement::checked() const
{
if(!impl) return 0;
return ((HTMLInputElementImpl*)impl)->checked();
}
void HTMLInputElement::setChecked( bool _checked )
{
if(impl)
((HTMLInputElementImpl*)impl)->setChecked(_checked);
}
bool HTMLInputElement::indeterminate() const
{
if(!impl) return 0;
return ((HTMLInputElementImpl*)impl)->indeterminate();
}
void HTMLInputElement::setIndeterminate( bool _indeterminate )
{
if(impl)
((HTMLInputElementImpl*)impl)->setIndeterminate(_indeterminate);
}
bool HTMLInputElement::disabled() const
{
if(!impl) return 0;
return !((ElementImpl *)impl)->getAttribute(ATTR_DISABLED).isNull();
}
void HTMLInputElement::setDisabled( bool _disabled )
{
if(impl)
{
((ElementImpl *)impl)->setAttribute(ATTR_DISABLED, _disabled ? "" : 0);
}
}
long HTMLInputElement::maxLength() const
{
if(!impl) return 0;
return ((HTMLInputElementImpl *)impl)->getAttribute(ATTR_MAXLENGTH).toInt();
}
void HTMLInputElement::setMaxLength( long _maxLength )
{
if(impl) {
DOMString value(QString::number(_maxLength));
((ElementImpl *)impl)->setAttribute(ATTR_MAXLENGTH,value);
}
}
DOMString HTMLInputElement::name() const
{
if(!impl) return DOMString();
return static_cast<HTMLInputElementImpl* const>(impl)->name();
}
void HTMLInputElement::setName( const DOMString &value )
{
if(impl) static_cast<HTMLInputElementImpl*>(impl)->setName(value);
}
bool HTMLInputElement::readOnly() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_READONLY).isNull();
}
void HTMLInputElement::setReadOnly( bool _readOnly )
{
if(impl)
static_cast<ElementImpl*>(impl)->setAttribute(ATTR_READONLY, _readOnly ? "" : 0);
}
/* The next two are provided for backwards compatibility. */
DOMString HTMLInputElement::size() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SIZE);
}
void HTMLInputElement::setSize( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SIZE, value);
}
long HTMLInputElement::getSize() const
{
if(!impl) return 0;
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SIZE).toInt();
}
void HTMLInputElement::setSize( long value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SIZE, QString::number(value));
}
DOMString HTMLInputElement::src() const
{
if(!impl) return DOMString();
DOMString s = static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SRC);
return !s.isNull() ? impl->getDocument()->completeURL( s.string() ) : s;
}
void HTMLInputElement::setSrc( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SRC, value);
}
long HTMLInputElement::tabIndex() const
{
if(!impl) return 0;
return static_cast<ElementImpl*>(impl)->tabIndex();
}
void HTMLInputElement::setTabIndex( long _tabIndex )
{
if (!impl) return;
static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
}
DOMString HTMLInputElement::type() const
{
if(!impl) return DOMString();
return ((HTMLInputElementImpl *)impl)->type();
}
void HTMLInputElement::setType(const DOMString& _type)
{
if (!impl) return;
static_cast<HTMLInputElementImpl*>(impl)->setType(_type);
}
DOMString HTMLInputElement::useMap() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_USEMAP);
}
void HTMLInputElement::setUseMap( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_USEMAP, value);
}
DOMString HTMLInputElement::value() const
{
if(!impl) return DOMString();
return ((HTMLInputElementImpl*)impl)->value();
}
void HTMLInputElement::setValue( const DOMString &value )
{
if (impl)
((HTMLInputElementImpl*)impl)->setValue(value);
}
void HTMLInputElement::blur( )
{
if(impl)
((HTMLInputElementImpl*)impl)->blur();
}
void HTMLInputElement::focus( )
{
if(impl)
((HTMLInputElementImpl*)impl)->focus();
}
void HTMLInputElement::select( )
{
if(impl)
((HTMLInputElementImpl *)impl)->select( );
}
void HTMLInputElement::click( )
{
if(impl)
((HTMLInputElementImpl *)impl)->click( );
}
long HTMLInputElement::selectionStart()
{
if (impl)
return ((HTMLInputElementImpl *)impl)->selectionStart( );
return -1;
}
long HTMLInputElement::selectionEnd()
{
if (impl)
return ((HTMLInputElementImpl *)impl)->selectionEnd( );
return -1;
}
void HTMLInputElement::setSelectionStart(long pos)
{
if (impl)
((HTMLInputElementImpl *)impl)->setSelectionStart( pos );
}
void HTMLInputElement::setSelectionEnd(long pos)
{
if (impl)
((HTMLInputElementImpl *)impl)->setSelectionEnd( pos );
}
void HTMLInputElement::setSelectionRange(long start, long end)
{
if (impl)
((HTMLInputElementImpl *)impl)->setSelectionRange( start, end );
}
// --------------------------------------------------------------------------
HTMLLabelElement::HTMLLabelElement() : HTMLElement()
{
}
HTMLLabelElement::HTMLLabelElement(const HTMLLabelElement &other) : HTMLElement(other)
{
}
HTMLLabelElement::HTMLLabelElement(HTMLLabelElementImpl *impl) : HTMLElement(impl)
{
}
HTMLLabelElement &HTMLLabelElement::operator = (const Node &other)
{
assignOther( other, ID_LABEL );
return *this;
}
HTMLLabelElement &HTMLLabelElement::operator = (const HTMLLabelElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLLabelElement::~HTMLLabelElement()
{
}
DOMString HTMLLabelElement::accessKey() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
}
void HTMLLabelElement::setAccessKey( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
}
DOMString HTMLLabelElement::htmlFor() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_FOR);
}
void HTMLLabelElement::setHtmlFor( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_FOR, value);
}
// --------------------------------------------------------------------------
HTMLLegendElement::HTMLLegendElement() : HTMLElement()
{
}
HTMLLegendElement::HTMLLegendElement(const HTMLLegendElement &other) : HTMLElement(other)
{
}
HTMLLegendElement::HTMLLegendElement(HTMLLegendElementImpl *impl) : HTMLElement(impl)
{
}
HTMLLegendElement &HTMLLegendElement::operator = (const Node &other)
{
assignOther( other, ID_LEGEND );
return *this;
}
HTMLLegendElement &HTMLLegendElement::operator = (const HTMLLegendElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLLegendElement::~HTMLLegendElement()
{
}
HTMLFormElement HTMLLegendElement::form() const
{
return Element::form();
}
DOMString HTMLLegendElement::accessKey() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
}
void HTMLLegendElement::setAccessKey( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
}
DOMString HTMLLegendElement::align() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ALIGN);
}
void HTMLLegendElement::setAlign( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ALIGN, value);
}
// --------------------------------------------------------------------------
HTMLOptGroupElement::HTMLOptGroupElement() : HTMLElement()
{
}
HTMLOptGroupElement::HTMLOptGroupElement(const HTMLOptGroupElement &other) : HTMLElement(other)
{
}
HTMLOptGroupElement::HTMLOptGroupElement(HTMLOptGroupElementImpl *impl) : HTMLElement(impl)
{
}
HTMLOptGroupElement &HTMLOptGroupElement::operator = (const Node &other)
{
assignOther( other, ID_OPTGROUP );
return *this;
}
HTMLOptGroupElement &HTMLOptGroupElement::operator = (const HTMLOptGroupElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLOptGroupElement::~HTMLOptGroupElement()
{
}
bool HTMLOptGroupElement::disabled() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
}
void HTMLOptGroupElement::setDisabled( bool _disabled )
{
if(impl)
static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ? "" : 0);
}
DOMString HTMLOptGroupElement::label() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_LABEL);
}
void HTMLOptGroupElement::setLabel( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_LABEL, value);
}
// --------------------------------------------------------------------------
HTMLSelectElement::HTMLSelectElement() : HTMLElement()
{
}
HTMLSelectElement::HTMLSelectElement(const HTMLSelectElement &other) : HTMLElement(other)
{
}
HTMLSelectElement::HTMLSelectElement(HTMLSelectElementImpl *impl) : HTMLElement(impl)
{
}
HTMLSelectElement &HTMLSelectElement::operator = (const Node &other)
{
assignOther( other, ID_SELECT );
return *this;
}
HTMLSelectElement &HTMLSelectElement::operator = (const HTMLSelectElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLSelectElement::~HTMLSelectElement()
{
}
DOMString HTMLSelectElement::type() const
{
if(!impl) return DOMString();
return ((HTMLSelectElementImpl *)impl)->type();
}
long HTMLSelectElement::selectedIndex() const
{
if(!impl) return 0;
return ((HTMLSelectElementImpl *)impl)->selectedIndex();
}
void HTMLSelectElement::setSelectedIndex( long _selectedIndex )
{
if(impl)
((HTMLSelectElementImpl *)impl)->setSelectedIndex(_selectedIndex);
}
DOMString HTMLSelectElement::value() const
{
if(!impl) return DOMString();
return static_cast<HTMLSelectElementImpl*>(impl)->value();
}
void HTMLSelectElement::setValue( const DOMString &value )
{
if(!impl || value.isNull()) return;
static_cast<HTMLSelectElementImpl*>(impl)->setValue(value.implementation());
}
long HTMLSelectElement::length() const
{
if(!impl) return 0;
return ((HTMLSelectElementImpl *)impl)->length();
}
HTMLFormElement HTMLSelectElement::form() const
{
return Element::form();
}
HTMLCollection HTMLSelectElement::options() const
{
if(!impl) return HTMLCollection();
return HTMLCollection(impl, HTMLCollectionImpl::SELECT_OPTIONS);
}
bool HTMLSelectElement::disabled() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
}
void HTMLSelectElement::setDisabled( bool _disabled )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ? "" : 0);
}
bool HTMLSelectElement::multiple() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_MULTIPLE).isNull();
}
void HTMLSelectElement::setMultiple( bool _multiple )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_MULTIPLE, _multiple ? "" : 0);
}
DOMString HTMLSelectElement::name() const
{
if(!impl) return DOMString();
return static_cast<HTMLSelectElementImpl* const>(impl)->name();
}
void HTMLSelectElement::setName( const DOMString &value )
{
if(impl) static_cast<HTMLSelectElementImpl*>(impl)->setName(value);
}
long HTMLSelectElement::size() const
{
if(!impl) return 0;
return ((HTMLSelectElementImpl *)impl)->getAttribute(ATTR_SIZE).toInt();
}
void HTMLSelectElement::setSize( long _size )
{
if(impl) {
DOMString value(QString::number(_size));
static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SIZE,value);
}
}
long HTMLSelectElement::tabIndex() const
{
if(!impl) return 0;
return static_cast<ElementImpl*>(impl)->tabIndex();
}
void HTMLSelectElement::setTabIndex( long _tabIndex )
{
if (!impl) return;
static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
}
void HTMLSelectElement::add( const HTMLElement &element, const HTMLElement &before )
{
if (!impl)
throw DOMException(DOMException::NOT_FOUND_ERR);
int exceptioncode = 0;
static_cast<HTMLSelectElementImpl*>(impl)->add( element, before, exceptioncode );
if ( exceptioncode )
throw DOMException( exceptioncode );
}
void HTMLSelectElement::remove( long index )
{
if(impl) static_cast<HTMLSelectElementImpl*>(impl)->remove( index );
}
void HTMLSelectElement::blur( )
{
if(impl)
((HTMLSelectElementImpl*)impl)->blur();
}
void HTMLSelectElement::focus( )
{
if(impl)
((HTMLSelectElementImpl*)impl)->focus();
}
// --------------------------------------------------------------------------
HTMLTextAreaElement::HTMLTextAreaElement() : HTMLElement()
{
}
HTMLTextAreaElement::HTMLTextAreaElement(const HTMLTextAreaElement &other) : HTMLElement(other)
{
}
HTMLTextAreaElement::HTMLTextAreaElement(HTMLTextAreaElementImpl *impl) : HTMLElement(impl)
{
}
HTMLTextAreaElement &HTMLTextAreaElement::operator = (const Node &other)
{
assignOther( other, ID_TEXTAREA );
return *this;
}
HTMLTextAreaElement &HTMLTextAreaElement::operator = (const HTMLTextAreaElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLTextAreaElement::~HTMLTextAreaElement()
{
}
DOMString HTMLTextAreaElement::defaultValue() const
{
if(!impl) return DOMString();
return ((HTMLTextAreaElementImpl *)impl)->defaultValue();
}
void HTMLTextAreaElement::setDefaultValue( const DOMString &value )
{
if (impl) ((HTMLTextAreaElementImpl *)impl)->setDefaultValue(value);
}
HTMLFormElement HTMLTextAreaElement::form() const
{
return Element::form();
}
DOMString HTMLTextAreaElement::accessKey() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
}
void HTMLTextAreaElement::setAccessKey( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
}
long HTMLTextAreaElement::cols() const
{
if(!impl) return 0;
return ((HTMLTextAreaElementImpl *)impl)->getAttribute(ATTR_COLS).toInt();
}
void HTMLTextAreaElement::setCols( long _cols )
{
if(impl) {
DOMString value(QString::number(_cols));
static_cast<ElementImpl*>(impl)->setAttribute(ATTR_COLS,value);
}
}
bool HTMLTextAreaElement::disabled() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
}
void HTMLTextAreaElement::setDisabled( bool _disabled )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ? "" : 0);
}
DOMString HTMLTextAreaElement::name() const
{
if(!impl) return DOMString();
return static_cast<HTMLTextAreaElementImpl* const>(impl)->name();
}
void HTMLTextAreaElement::setName( const DOMString &value )
{
if(impl) static_cast<HTMLTextAreaElementImpl*>(impl)->setName(value);
}
bool HTMLTextAreaElement::readOnly() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_READONLY).isNull();
}
void HTMLTextAreaElement::setReadOnly( bool _readOnly )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_READONLY, _readOnly ? "" : 0);
}
long HTMLTextAreaElement::rows() const
{
if(!impl) return 0;
return ((HTMLTextAreaElementImpl *)impl)->getAttribute(ATTR_ROWS).toInt();
}
void HTMLTextAreaElement::setRows( long _rows )
{
if(impl) {
DOMString value(QString::number(_rows));
static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ROWS,value);
}
}
long HTMLTextAreaElement::tabIndex() const
{
if(!impl) return 0;
return static_cast<ElementImpl*>(impl)->tabIndex();
}
void HTMLTextAreaElement::setTabIndex( long _tabIndex )
{
if (!impl) return;
static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
}
DOMString HTMLTextAreaElement::type() const
{
if(!impl) return DOMString();
return ((HTMLTextAreaElementImpl *)impl)->type();
}
DOMString HTMLTextAreaElement::value() const
{
if(!impl) return DOMString();
return ((HTMLTextAreaElementImpl *)impl)->value();
}
void HTMLTextAreaElement::setValue( const DOMString &value )
{
if(impl) ((HTMLTextAreaElementImpl *)impl)->setValue(value);
}
void HTMLTextAreaElement::blur( )
{
if(impl)
((HTMLTextAreaElementImpl*)impl)->blur();
}
void HTMLTextAreaElement::focus( )
{
if(impl)
((HTMLTextAreaElementImpl*)impl)->focus();
}
void HTMLTextAreaElement::select( )
{
if(impl)
((HTMLTextAreaElementImpl *)impl)->select( );
}
long HTMLTextAreaElement::selectionStart()
{
if (impl)
return ((HTMLTextAreaElementImpl *)impl)->selectionStart( );
return 0;
}
long HTMLTextAreaElement::selectionEnd()
{
if (impl)
return ((HTMLTextAreaElementImpl *)impl)->selectionEnd( );
return 0;
}
long HTMLTextAreaElement::textLength()
{
if (impl)
return ((HTMLTextAreaElementImpl *)impl)->textLength( );
return 0;
}
void HTMLTextAreaElement::setSelectionStart(long pos)
{
if (impl)
((HTMLTextAreaElementImpl *)impl)->setSelectionStart( pos );
}
void HTMLTextAreaElement::setSelectionEnd(long pos)
{
if (impl)
((HTMLTextAreaElementImpl *)impl)->setSelectionEnd( pos );
}
void HTMLTextAreaElement::setSelectionRange(long start, long end)
{
if (impl)
((HTMLTextAreaElementImpl *)impl)->setSelectionRange( start, end );
}
// --------------------------------------------------------------------------
HTMLOptionElement::HTMLOptionElement() : HTMLElement()
{
}
HTMLOptionElement::HTMLOptionElement(const HTMLOptionElement &other) : HTMLElement(other)
{
}
HTMLOptionElement::HTMLOptionElement(HTMLOptionElementImpl *impl) : HTMLElement(impl)
{
}
HTMLOptionElement &HTMLOptionElement::operator = (const Node &other)
{
assignOther( other, ID_OPTION );
return *this;
}
HTMLOptionElement &HTMLOptionElement::operator = (const HTMLOptionElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLOptionElement::~HTMLOptionElement()
{
}
HTMLFormElement HTMLOptionElement::form() const
{
return Element::form();
}
bool HTMLOptionElement::defaultSelected() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SELECTED).isNull();
}
void HTMLOptionElement::setDefaultSelected( bool _defaultSelected )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SELECTED, _defaultSelected ? "" : 0);
}
DOMString HTMLOptionElement::text() const
{
if(!impl) return DOMString();
return ((HTMLOptionElementImpl *)impl)->text();
}
long HTMLOptionElement::index() const
{
if(!impl) return 0;
return ((HTMLOptionElementImpl *)impl)->index();
}
void HTMLOptionElement::setIndex( long /*_index*/ )
{
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
}
bool HTMLOptionElement::disabled() const
{
if(!impl) return 0;
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
}
void HTMLOptionElement::setDisabled( bool _disabled )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ? "" : 0);
}
DOMString HTMLOptionElement::label() const
{
if(!impl) return DOMString();
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_LABEL);
}
void HTMLOptionElement::setLabel( const DOMString &value )
{
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_LABEL, value);
}
bool HTMLOptionElement::selected() const
{
if(!impl) return 0;
return ((HTMLOptionElementImpl *)impl)->selected();
}
void HTMLOptionElement::setSelected(bool _selected) {
if(!impl) return;
((HTMLOptionElementImpl *)impl)->setSelected(_selected);
}
DOMString HTMLOptionElement::value() const
{
if(!impl) return DOMString();
return static_cast<HTMLOptionElementImpl*>(impl)->value();
}
void HTMLOptionElement::setValue( const DOMString &value )
{
if(impl) static_cast<HTMLOptionElementImpl*>(impl)->setValue(value.implementation());
}
// -----------------------------------------------------------------------------
HTMLIsIndexElement::HTMLIsIndexElement() : HTMLElement()
{
}
HTMLIsIndexElement::HTMLIsIndexElement(const HTMLIsIndexElement &other) : HTMLElement(other)
{
}
HTMLIsIndexElement::HTMLIsIndexElement(HTMLIsIndexElementImpl *impl) : HTMLElement(impl)
{
}
HTMLIsIndexElement &HTMLIsIndexElement::operator = (const Node &other)
{
assignOther( other, ID_ISINDEX );
return *this;
}
HTMLIsIndexElement &HTMLIsIndexElement::operator = (const HTMLIsIndexElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLIsIndexElement::~HTMLIsIndexElement()
{
}
HTMLFormElement HTMLIsIndexElement::form() const
{
return Element::form();
}
DOMString HTMLIsIndexElement::prompt() const
{
if(!impl) return DOMString();
return static_cast<HTMLIsIndexElementImpl*>(impl)->prompt();
}
void HTMLIsIndexElement::setPrompt( const DOMString &value )
{
if(impl) static_cast<HTMLIsIndexElementImpl*>(impl)->setPrompt(value);
}
DOM::HTMLFormElement::method
DOMString method() const
HTTP method used to submit form.
Definition: html_form.cpp:266
DOM::HTMLTextAreaElement::readOnly
bool readOnly() const
This control is read-only.
Definition: html_form.cpp:1039
DOM::HTMLSelectElement::remove
void remove(long index)
Remove an element from the collection of OPTION elements for this SELECT .
Definition: html_form.cpp:928
DOM::HTMLTextAreaElement::setReadOnly
void setReadOnly(bool)
see readOnly
Definition: html_form.cpp:1045
DOM::HTMLTextAreaElement::setSelectionRange
void setSelectionRange(long start, long end)
Selects the text from start to end, and positions the cursor after the selection. ...
Definition: html_form.cpp:1145
DOM::HTMLInputElement::setReadOnly
void setReadOnly(bool)
see readOnly
Definition: html_form.cpp:472
DOM::HTMLSelectElement::type
DOMString type() const
The type of control created.
Definition: html_form.cpp:809
DOM::HTMLInputElement::setAccessKey
void setAccessKey(const DOMString &)
see accessKey
Definition: html_form.cpp:376
DOM::HTMLIsIndexElement::setPrompt
void setPrompt(const DOMString &)
see prompt
Definition: html_form.cpp:1299
DOM::Node
The Node interface is the primary datatype for the entire Document Object Model.
Definition: dom_node.h:274
DOM::HTMLTextAreaElement::form
HTMLFormElement form() const
KDE 4.0: remove.
Definition: html_form.cpp:986
DOM::HTMLInputElement::setSelectionEnd
void setSelectionEnd(long offset)
Move the end of the selection (and the cursor) to the given offset in text This call has no effect if...
Definition: html_form.cpp:605
DOM::HTMLButtonElement::tabIndex
long tabIndex() const
Index that represents the element's position in the tabbing order.
Definition: html_form.cpp:114
DOM::HTMLInputElement::setTabIndex
void setTabIndex(long)
see tabIndex
Definition: html_form.cpp:519
DOM::HTMLInputElement::name
DOMString name() const
Form control or object name when submitted with a form.
Definition: html_form.cpp:455
DOM::HTMLSelectElement
The select element allows the selection of an option.
Definition: html_form.h:878
DOM::HTMLLegendElement::accessKey
DOMString accessKey() const
A single character access key to give access to the form control.
Definition: html_form.cpp:704
DOM::HTMLFormElement::submit
void submit()
Submits the form.
Definition: html_form.cpp:288
DOM::HTMLInputElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_form.cpp:387
DOM::HTMLTextAreaElement::textLength
long textLength()
Returns the length of the text.
Definition: html_form.cpp:1126
DOM::HTMLIsIndexElement
This element is used for single-line text input.
Definition: html_form.h:1389
DOM::HTMLButtonElement::setName
void setName(const DOMString &)
see name
Definition: html_form.cpp:97
DOM::HTMLSelectElement::tabIndex
long tabIndex() const
Index that represents the element's position in the tabbing order.
Definition: html_form.cpp:905
DOM::HTMLFormElement::setAction
void setAction(const DOMString &)
see action
Definition: html_form.cpp:250
DOM::HTMLOptionElement::label
DOMString label() const
Option label for use in hierarchical menus.
Definition: html_form.cpp:1225
DOM::HTMLSelectElement::name
DOMString name() const
Form control or object name when submitted with a form.
Definition: html_form.cpp:879
DOM::HTMLFormElement::setEnctype
void setEnctype(const DOMString &)
see enctype
Definition: html_form.cpp:261
DOM::HTMLFormElement::elements
HTMLCollection elements() const
Returns a collection of all control elements in the form.
Definition: html_form.cpp:210
DOM::HTMLInputElement::defaultValue
DOMString defaultValue() const
Stores the initial control value (i.e., the initial value of value ).
Definition: html_form.cpp:328
DOM::HTMLSelectElement::setTabIndex
void setTabIndex(long)
see tabIndex
Definition: html_form.cpp:911
DOM::HTMLButtonElement::value
DOMString value() const
The current form control value.
Definition: html_form.cpp:132
DOM::HTMLFormElement
The FORM element encompasses behavior similar to a collection and an element.
Definition: html_form.h:206
DOM::HTMLSelectElement::setValue
void setValue(const DOMString &)
see value
Definition: html_form.cpp:833
DOM::HTMLInputElement::alt
DOMString alt() const
Alternate text for user agents not rendering the normal content of this element.
Definition: html_form.cpp:392
DOM::HTMLInputElement::accept
DOMString accept() const
A comma-separated list of content types that a server processing this form will handle correctly...
Definition: html_form.cpp:359
DOM::HTMLInputElement::setAccept
void setAccept(const DOMString &)
see accept
Definition: html_form.cpp:365
DOM::HTMLTextAreaElement::rows
long rows() const
Number of text rows.
Definition: html_form.cpp:1050
DOM::HTMLSelectElement::length
long length() const
The number of options in this SELECT .
Definition: html_form.cpp:839
DOM::HTMLTextAreaElement::setAccessKey
void setAccessKey(const DOMString &)
see accessKey
Definition: html_form.cpp:997
DOM::HTMLTextAreaElement::value
DOMString value() const
The current textual content of the multi-line text field.
Definition: html_form.cpp:1083
DOM::HTMLInputElement::selectionEnd
long selectionEnd()
Returns the character offset of end of selection, or if none, the cursor position.
Definition: html_form.cpp:592
DOM::HTMLInputElement::click
void click()
Simulate a mouse-click.
Definition: html_form.cpp:579
DOM::HTMLButtonElement::focus
void focus()
Gives keyboard focus to this element.
Definition: html_form.cpp:102
DOM::HTMLOptionElement::index
long index() const
The index of this OPTION in its parent SELECT .
Definition: html_form.cpp:1203
DOM::HTMLInputElement
Form control.
Definition: html_form.h:349
DOM::HTMLSelectElement::focus
void focus()
Gives keyboard focus to this element.
Definition: html_form.cpp:939
DOM::HTMLSelectElement::setMultiple
void setMultiple(bool)
see multiple
Definition: html_form.cpp:874
DOM::HTMLInputElement::readOnly
bool readOnly() const
This control is read-only.
Definition: html_form.cpp:466
DOM::HTMLInputElement::getSize
long getSize() const
Size information.
Definition: html_form.cpp:490
DOM::HTMLTextAreaElement::setCols
void setCols(long)
see cols
Definition: html_form.cpp:1008
DOM::DOMException
DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impos...
Definition: dom_exception.h:57
DOM::HTMLButtonElement::setAccessKey
void setAccessKey(const DOMString &)
see accessKey
Definition: html_form.cpp:75
DOM::HTMLInputElement::value
DOMString value() const
The current form control value.
Definition: html_form.cpp:548
DOM::HTMLButtonElement::setTabIndex
void setTabIndex(long)
see tabIndex
Definition: html_form.cpp:120
DOM::HTMLButtonElement::form
HTMLFormElement form() const
Returns the FORM element containing this control.
Definition: html_form.cpp:64
DOM::HTMLOptionElement::value
DOMString value() const
The current form control value.
Definition: html_form.cpp:1247
DOM::HTMLInputElement::setDefaultValue
void setDefaultValue(const DOMString &)
see defaultValue
Definition: html_form.cpp:337
DOM::HTMLFormElement::target
DOMString target() const
Frame to render the resource in.
Definition: html_form.cpp:277
DOM::Element::setAttribute
void setAttribute(const DOMString &name, const DOMString &value)
Adds a new attribute.
Definition: dom_element.cpp:162
DOM::HTMLSelectElement::selectedIndex
long selectedIndex() const
The ordinal index of the selected option.
Definition: html_form.cpp:815
DOM::HTMLFormElement::acceptCharset
DOMString acceptCharset() const
List of character sets supported by the server.
Definition: html_form.cpp:233
DOM::HTMLFormElement::enctype
DOMString enctype() const
The content type of the submitted form, generally "application/x-www-form-urlencoded".
Definition: html_form.cpp:255
DOM::HTMLCollection
An HTMLCollection is a list of nodes.
Definition: html_misc.h:126
DOM::HTMLTextAreaElement::disabled
bool disabled() const
The control is unavailable in this context.
Definition: html_form.cpp:1017
DOM::HTMLInputElement::disabled
bool disabled() const
The control is unavailable in this context.
Definition: html_form.cpp:427
DOM::HTMLLabelElement::setAccessKey
void setAccessKey(const DOMString &)
see accessKey
Definition: html_form.cpp:653
DOM::HTMLInputElement::defaultChecked
bool defaultChecked() const
When type has the value "Radio" or "Checkbox", stores the initial value of the checked attribute...
Definition: html_form.cpp:342
DOM::HTMLInputElement::tabIndex
long tabIndex() const
Index that represents the element's position in the tabbing order.
Definition: html_form.cpp:513
DOM::HTMLIsIndexElement::prompt
DOMString prompt() const
The prompt message.
Definition: html_form.cpp:1293
DOM::HTMLTextAreaElement::setDefaultValue
void setDefaultValue(const DOMString &)
see defaultValue
Definition: html_form.cpp:981
DOM::HTMLFormElement::setTarget
void setTarget(const DOMString &)
see target
Definition: html_form.cpp:283
DOM::HTMLInputElement::size
DOMString size() const KDE_DEPRECATED
Definition: html_form.cpp:479
DOM::HTMLSelectElement::options
HTMLCollection options() const
The collection of OPTION elements contained by this element.
Definition: html_form.cpp:850
DOM::HTMLTextAreaElement::setRows
void setRows(long)
see rows
Definition: html_form.cpp:1056
DOM::HTMLFormElement::action
DOMString action() const
Server-side form handler.
Definition: html_form.cpp:244
DOM::HTMLSelectElement::disabled
bool disabled() const
The control is unavailable in this context.
Definition: html_form.cpp:856
DOM::HTMLTextAreaElement::setTabIndex
void setTabIndex(long)
see tabIndex
Definition: html_form.cpp:1071
DOM::HTMLTextAreaElement::focus
void focus()
Gives keyboard focus to this element.
Definition: html_form.cpp:1100
DOM::HTMLOptGroupElement
Group options together in logical subdivisions.
Definition: html_form.h:824
DOM::HTMLOptionElement::text
DOMString text() const
The text contained within the option element.
Definition: html_form.cpp:1197
DOM::HTMLIsIndexElement::form
HTMLFormElement form() const
KDE 4.0: remove
Definition: html_form.cpp:1288
DOM::HTMLOptionElement::form
HTMLFormElement form() const
KDE 4.0: remove
Definition: html_form.cpp:1181
DOM::HTMLOptGroupElement::disabled
bool disabled() const
The control is unavailable in this context.
Definition: html_form.cpp:756
DOM::HTMLLegendElement
Provides a caption for a FIELDSET grouping.
Definition: html_form.h:765
DOM::HTMLInputElement::setAlt
void setAlt(const DOMString &)
see alt
Definition: html_form.cpp:398
DOM::HTMLTextAreaElement::setSelectionEnd
void setSelectionEnd(long offset)
Move the end of the selection (and the cursor) to the given offset in text NOTE: this method is not p...
Definition: html_form.cpp:1139
DOM::HTMLTextAreaElement::accessKey
DOMString accessKey() const
A single character access key to give access to the form control.
Definition: html_form.cpp:991
DOM::HTMLInputElement::checked
bool checked() const
Describes whether a radio or check box is checked, when type has the value "Radio" or "Checkbox"...
Definition: html_form.cpp:403
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:43
DOM::HTMLInputElement::maxLength
long maxLength() const
Maximum number of characters for text fields, when type has the value "Text" or "Password".
Definition: html_form.cpp:441
DOM::HTMLInputElement::setType
void setType(const DOMString &)
see type
Definition: html_form.cpp:531
DOM::HTMLInputElement::type
DOMString type() const
The type of control created.
Definition: html_form.cpp:525
DOM::HTMLInputElement::align
DOMString align() const
Aligns this object (vertically or horizontally) with respect to its surrounding text.
Definition: html_form.cpp:381
DOM::HTMLTextAreaElement::selectionEnd
long selectionEnd()
Returns the character offset of end of selection, or if none, the cursor position.
Definition: html_form.cpp:1119
DOM::HTMLSelectElement::value
DOMString value() const
The current form control value.
Definition: html_form.cpp:827
DOM::HTMLOptionElement::selected
bool selected() const
Means that this option is initially selected.
Definition: html_form.cpp:1236
DOM::HTMLFieldSetElement::form
HTMLFormElement form() const
KDE 4.0: remove.
Definition: html_form.cpp:175
DOM::HTMLLegendElement::form
HTMLFormElement form() const
KDE 4.0: remove
Definition: html_form.cpp:699
DOM::HTMLTextAreaElement::cols
long cols() const
Width of control (in characters).
Definition: html_form.cpp:1002
DOM::HTMLTextAreaElement::blur
void blur()
Removes keyboard focus from this element.
Definition: html_form.cpp:1094
DOM::HTMLOptionElement::setDisabled
void setDisabled(bool)
see disabled
Definition: html_form.cpp:1220
DOM::HTMLTextAreaElement::setDisabled
void setDisabled(bool)
see disabled
Definition: html_form.cpp:1023
DOM::HTMLInputElement::focus
void focus()
Gives keyboard focus to this element.
Definition: html_form.cpp:567
DOM::HTMLLabelElement::accessKey
DOMString accessKey() const
A single character access key to give access to the form control.
Definition: html_form.cpp:647
DOM::HTMLTextAreaElement::setSelectionStart
void setSelectionStart(long offset)
Move the beginning of the selection to the given offset in text NOTE: this method is not part of the ...
Definition: html_form.cpp:1133
DOM::HTMLTextAreaElement::name
DOMString name() const
Form control or object name when submitted with a form.
Definition: html_form.cpp:1028
DOM::HTMLFormElement::reset
void reset()
Restores a form element's default values.
Definition: html_form.cpp:293
DOM::HTMLFormElement::setName
void setName(const DOMString &)
see name
Definition: html_form.cpp:228
DOM::HTMLInputElement::setValue
void setValue(const DOMString &)
see value
Definition: html_form.cpp:554
DOM::HTMLSelectElement::blur
void blur()
Removes keyboard focus from this element.
Definition: html_form.cpp:933
DOM::HTMLInputElement::setSelectionStart
void setSelectionStart(long offset)
Move the beginning of the selection to the given offset in text This call has no effect if the type o...
Definition: html_form.cpp:599
DOM::HTMLSelectElement::size
long size() const
Number of visible rows.
Definition: html_form.cpp:890
DOM::HTMLInputElement::src
DOMString src() const
When the type attribute has the value "Image", this attribute specifies the location of the image to ...
Definition: html_form.cpp:501
DOM::HTMLSelectElement::setName
void setName(const DOMString &)
see name
Definition: html_form.cpp:885
DOM::HTMLButtonElement::setValue
void setValue(const DOMString &)
see value
Definition: html_form.cpp:140
DOM::HTMLInputElement::selectionStart
long selectionStart()
Returns the character offset of beginning of selection, or if none, the cursor position.
Definition: html_form.cpp:585
DOM::HTMLInputElement::blur
void blur()
Removes keyboard focus from this element.
Definition: html_form.cpp:561
DOM::HTMLButtonElement::accessKey
DOMString accessKey() const
A single character access key to give access to the form control.
Definition: html_form.cpp:69
DOM::HTMLButtonElement::setDisabled
void setDisabled(bool)
see disabled
Definition: html_form.cpp:86
DOM::HTMLInputElement::setUseMap
void setUseMap(const DOMString &)
see useMap
Definition: html_form.cpp:543
DOM::HTMLTextAreaElement
Multi-line text field.
Definition: html_form.h:1054
DOM::HTMLButtonElement::type
DOMString type() const
The type of button.
Definition: html_form.cpp:126
DOM::HTMLLabelElement::htmlFor
DOMString htmlFor() const
This attribute links this label with another form control by id attribute.
Definition: html_form.cpp:658
DOM::HTMLInputElement::setChecked
void setChecked(bool)
see checked
Definition: html_form.cpp:409
DOM::HTMLButtonElement
Push button.
Definition: html_form.h:50
DOM::HTMLInputElement::setMaxLength
void setMaxLength(long)
see maxLength
Definition: html_form.cpp:447
DOM::HTMLSelectElement::setSize
void setSize(long)
see size
Definition: html_form.cpp:896
DOM::HTMLInputElement::select
void select()
Select the contents of the text area.
Definition: html_form.cpp:573
DOM::HTMLOptionElement::setValue
void setValue(const DOMString &)
see value
Definition: html_form.cpp:1253
DOM::HTMLInputElement::setSize
void setSize(const DOMString &) KDE_DEPRECATED
Definition: html_form.cpp:485
DOM::HTMLFormElement::setMethod
void setMethod(const DOMString &)
see method
Definition: html_form.cpp:272
DOM::HTMLButtonElement::blur
void blur()
Removes keyboard focus from this element.
Definition: html_form.cpp:108
DOM::HTMLOptionElement::setLabel
void setLabel(const DOMString &)
see label
Definition: html_form.cpp:1231
DOM::HTMLLegendElement::setAccessKey
void setAccessKey(const DOMString &)
see accessKey
Definition: html_form.cpp:710
DOM::Element::getAttribute
DOMString getAttribute(const DOMString &name)
Retrieves an attribute value by name.
Definition: dom_element.cpp:147
DOM::HTMLInputElement::setSelectionRange
void setSelectionRange(long start, long end)
Makes the position span from start to end, and positions the cursor after the selection.
Definition: html_form.cpp:611
DOM::HTMLButtonElement::name
DOMString name() const
Form control or object name when submitted with a form.
Definition: html_form.cpp:91
DOM::HTMLFieldSetElement
Organizes form controls into logical groups.
Definition: html_form.h:172
DOM::HTMLSelectElement::setDisabled
void setDisabled(bool)
see disabled
Definition: html_form.cpp:862
DOM::HTMLButtonElement::disabled
bool disabled() const
The control is unavailable in this context.
Definition: html_form.cpp:80
DOM::HTMLOptGroupElement::setLabel
void setLabel(const DOMString &)
see label
Definition: html_form.cpp:774
DOM::HTMLInputElement::indeterminate
bool indeterminate() const
Describes whether a radio box is indeterminate.
Definition: html_form.cpp:415
DOM::HTMLInputElement::setName
void setName(const DOMString &)
see name
Definition: html_form.cpp:461
DOM::Element::form
Element form() const
KHTML extension to DOM This method returns the associated form element.
Definition: dom_element.cpp:338
DOM::HTMLLegendElement::align
DOMString align() const
Text alignment relative to FIELDSET .
Definition: html_form.cpp:715
DOM::HTMLInputElement::form
HTMLFormElement form() const
KDE 4.0: remove.
Definition: html_form.cpp:354
DOM::HTMLTextAreaElement::tabIndex
long tabIndex() const
Index that represents the element's position in the tabbing order.
Definition: html_form.cpp:1065
DOM::HTMLFormElement::setAcceptCharset
void setAcceptCharset(const DOMString &)
see acceptCharset
Definition: html_form.cpp:239
DOM::HTMLOptionElement::defaultSelected
bool defaultSelected() const
Stores the initial value of the selected attribute.
Definition: html_form.cpp:1186
DOM::HTMLLabelElement::setHtmlFor
void setHtmlFor(const DOMString &)
see htmlFor
Definition: html_form.cpp:664
DOM::HTMLTextAreaElement::setName
void setName(const DOMString &)
see name
Definition: html_form.cpp:1034
DOM::HTMLOptionElement::setIndex
void setIndex(long)
see index
Definition: html_form.cpp:1209
DOM::HTMLInputElement::accessKey
DOMString accessKey() const
A single character access key to give access to the form control.
Definition: html_form.cpp:370
DOM::HTMLTextAreaElement::setValue
void setValue(const DOMString &)
see value
Definition: html_form.cpp:1089
DOM::HTMLInputElement::setIndeterminate
void setIndeterminate(bool)
see indeterminate
Definition: html_form.cpp:421
DOM::HTMLTextAreaElement::selectionStart
long selectionStart()
Returns the character offset of beginning of selection, or if none, the cursor position.
Definition: html_form.cpp:1112
DOM::HTMLOptionElement
A selectable choice.
Definition: html_form.h:1269
DOM::HTMLSelectElement::multiple
bool multiple() const
If true, multiple OPTION elements may be selected in this SELECT .
Definition: html_form.cpp:868
DOM::HTMLOptGroupElement::setDisabled
void setDisabled(bool)
see disabled
Definition: html_form.cpp:762
DOM::HTMLSelectElement::setSelectedIndex
void setSelectedIndex(long)
see selectedIndex
Definition: html_form.cpp:821
DOM::HTMLFormElement::name
DOMString name() const
Names the form.
Definition: html_form.cpp:222
DOM::HTMLInputElement::setDisabled
void setDisabled(bool)
see disabled
Definition: html_form.cpp:433
DOM::HTMLOptionElement::setSelected
void setSelected(bool)
see selected
Definition: html_form.cpp:1242
DOM::HTMLTextAreaElement::defaultValue
DOMString defaultValue() const
Stores the initial control value (i.e., the initial value of value ).
Definition: html_form.cpp:975
DOM::HTMLOptionElement::disabled
bool disabled() const
The control is unavailable in this context.
Definition: html_form.cpp:1214
DOM::HTMLSelectElement::form
HTMLFormElement form() const
KDE 4.0: remove.
Definition: html_form.cpp:845
DOM::HTMLOptGroupElement::label
DOMString label() const
Assigns a label to this option group.
Definition: html_form.cpp:768
DOM::HTMLOptionElement::setDefaultSelected
void setDefaultSelected(bool)
see defaultSelected
Definition: html_form.cpp:1192
DOM::HTMLLabelElement
Form field label text.
Definition: html_form.h:710
DOM::HTMLFormElement::length
long length() const
The number of form controls in the form.
Definition: html_form.cpp:216
DOM::HTMLElement
All HTML element interfaces derive from this class.
Definition: html_element.h:69
DOM::HTMLInputElement::setSrc
void setSrc(const DOMString &)
see src
Definition: html_form.cpp:508
DOM::HTMLTextAreaElement::select
void select()
Select the contents of the TEXTAREA .
Definition: html_form.cpp:1106
DOM::HTMLTextAreaElement::type
DOMString type() const
The type of this form control.
Definition: html_form.cpp:1077
DOM::HTMLInputElement::useMap
DOMString useMap() const
Use client-side image map.
Definition: html_form.cpp:537
DOM::HTMLLegendElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_form.cpp:721
DOM::HTMLSelectElement::add
void add(const HTMLElement &element, const HTMLElement &before)
Add a new element to the collection of OPTION elements for this SELECT .
Definition: html_form.cpp:917
DOM::HTMLInputElement::setDefaultChecked
void setDefaultChecked(bool)
see defaultChecked
Definition: html_form.cpp:348

KDE Home | KDE Accessibility Home | Description of Access Keys