WebCore/html/HTMLInputElement.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
   6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
   7  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public License
  20  * along with this library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  *
  24  */
  25
  26 #include "config.h"
  27 #include "HTMLInputElement.h"
  28
  29 #include "BeforeTextInsertedEvent.h"
  30 #include "CSSPropertyNames.h"
  31 #include "Document.h"
  32 #include "Editor.h"
  33 #include "Event.h"
  34 #include "EventHandler.h"
  35 #include "EventNames.h"
  36 #include "FocusController.h"
  37 #include "FormDataList.h"
  38 #include "Frame.h"
  39 #include "HTMLFormElement.h"
  40 #include "HTMLImageLoader.h"
  41 #include "HTMLNames.h"
  42 #include "KeyboardEvent.h"
  43 #include "LocalizedStrings.h"
  44 #include "MouseEvent.h"
  45 #include "Page.h"
  46 #include "RenderButton.h"
  47 #include "RenderFileUploadControl.h"
  48 #include "RenderImage.h"
  49 #include "RenderText.h"
  50 #include "RenderTextControl.h"
  51 #include "RenderTheme.h"
  52 #include "RenderSlider.h"
  53 #include "SelectionController.h"
  54 #include "TextBreakIterator.h"
  55 #include "TextEvent.h"
  56
  57 using namespace std;
  58
  59 namespace WebCore {
  60
  61 using namespace EventNames;
  62 using namespace HTMLNames;
  63
  64 const int maxSavedResults = 256;
  65
  66 // FIXME: According to HTML4, the length attribute's value can be arbitrarily
  67 // large. However, due to http://bugs.webkit.org/show_bugs.cgi?id=14536 things
  68 // get rather sluggish when a text field has a larger number of characters than
  69 // this, even when just clicking in the text field.
  70 static const int cMaxLen = 524288;
  71
  72 static int numGraphemeClusters(const StringImpl* s)
  73 {
  74     if (!s)
  75         return 0;
  76
  77     TextBreakIterator* it = characterBreakIterator(s->characters(), s->length());
  78     if (!it)
  79         return 0;
  80     int num = 0;
  81     while (textBreakNext(it) != TextBreakDone)
  82         ++num;
  83     return num;
  84 }
  85
  86 static int numCharactersInGraphemeClusters(const StringImpl* s, int numGraphemeClusters)
  87 {
  88     if (!s)
  89         return 0;
  90
  91     TextBreakIterator* it = characterBreakIterator(s->characters(), s->length());
  92     if (!it)
  93         return 0;
  94     for (int i = 0; i < numGraphemeClusters; ++i)
  95         if (textBreakNext(it) == TextBreakDone)
  96             return s->length();
  97     return textBreakCurrent(it);
  98 }
  99
 100 HTMLInputElement::HTMLInputElement(Document* doc, HTMLFormElement* f)
 101     : HTMLFormControlElementWithState(inputTag, doc, f)
 102 {
 103     init();
 104 }
 105
 106 HTMLInputElement::HTMLInputElement(const QualifiedName& tagName, Document* doc, HTMLFormElement* f)
 107     : HTMLFormControlElementWithState(tagName, doc, f)
 108 {
 109     init();
 110 }
 111
 112 void HTMLInputElement::init()
 113 {
 114     m_imageLoader = 0;
 115     m_type = TEXT;
 116     m_maxLen = cMaxLen;
 117     m_size = 20;
 118     m_checked = false;
 119     m_defaultChecked = false;
 120     m_useDefaultChecked = true;
 121     m_indeterminate = false;
 122
 123     m_haveType = false;
 124     m_activeSubmit = false;
 125     m_autocomplete = true;
 126     m_inited = false;
 127     m_autofilled = false;
 128
 129     xPos = 0;
 130     yPos = 0;
 131
 132     cachedSelStart = -1;
 133     cachedSelEnd = -1;
 134
 135     m_maxResults = -1;
 136
 137     if (form())
 138         m_autocomplete = form()->autoComplete();
 139 }
 140
 141 HTMLInputElement::~HTMLInputElement()
 142 {
 143     if (inputType() == PASSWORD)
 144         document()->unregisterForCacheCallbacks(this);
 145
 146     document()->checkedRadioButtons().removeButton(this);
 147
 148     delete m_imageLoader;
 149 }
 150
 151 const AtomicString& HTMLInputElement::name() const
 152 {
 153     return m_name.isNull() ? emptyAtom : m_name;
 154 }
 155
 156 static inline HTMLFormElement::CheckedRadioButtons& checkedRadioButtons(const HTMLInputElement *element)
 157 {
 158     if (HTMLFormElement* form = element->form())
 159         return form->checkedRadioButtons();
 160
 161     return element->document()->checkedRadioButtons();
 162 }
 163
 164 bool HTMLInputElement::isKeyboardFocusable(KeyboardEvent* event) const
 165 {
 166     // If text fields can be focused, then they should always be keyboard focusable
 167     if (isTextField())
 168         return HTMLFormControlElementWithState::isFocusable();
 169
 170     // If the base class says we can't be focused, then we can stop now.
 171     if (!HTMLFormControlElementWithState::isKeyboardFocusable(event))
 172         return false;
 173
 174     if (inputType() == RADIO) {
 175         // Unnamed radio buttons are never focusable (matches WinIE).
 176         if (name().isEmpty())
 177             return false;
 178
 179         // Never allow keyboard tabbing to leave you in the same radio group.  Always
 180         // skip any other elements in the group.
 181         Node* currentFocusedNode = document()->focusedNode();
 182         if (currentFocusedNode && currentFocusedNode->hasTagName(inputTag)) {
 183             HTMLInputElement* focusedInput = static_cast<HTMLInputElement*>(currentFocusedNode);
 184             if (focusedInput->inputType() == RADIO && focusedInput->form() == form() &&
 185                 focusedInput->name() == name())
 186                 return false;
 187         }
 188
 189         // Allow keyboard focus if we're checked or if nothing in the group is checked.
 190         return checked() || !checkedRadioButtons(this).checkedButtonForGroup(name());
 191     }
 192
 193     return true;
 194 }
 195
 196 bool HTMLInputElement::isMouseFocusable() const
 197 {
 198     if (isTextField())
 199         return HTMLFormControlElementWithState::isFocusable();
 200     return HTMLFormControlElementWithState::isMouseFocusable();
 201 }
 202
 203 void HTMLInputElement::updateFocusAppearance(bool restorePreviousSelection)
 204 {
 205     if (isTextField()) {
 206         if (!restorePreviousSelection || cachedSelStart == -1)
 207             select();
 208         else
 209             // Restore the cached selection.
 210             setSelectionRange(cachedSelStart, cachedSelEnd);
 211
 212         if (document() && document()->frame())
 213             document()->frame()->revealSelection();
 214     } else
 215         HTMLFormControlElementWithState::updateFocusAppearance(restorePreviousSelection);
 216 }
 217
 218 void HTMLInputElement::aboutToUnload()
 219 {
 220     if (isTextField() && focused() && document()->frame())
 221         document()->frame()->textFieldDidEndEditing(this);
 222 }
 223
 224 bool HTMLInputElement::shouldUseInputMethod() const
 225 {
 226     return m_type == TEXT || m_type == SEARCH || m_type == ISINDEX;
 227 }
 228
 229 void HTMLInputElement::dispatchFocusEvent()
 230 {
 231     if (isTextField()) {
 232         setAutofilled(false);
 233         if (inputType() == PASSWORD && document()->frame())
 234             document()->setUseSecureKeyboardEntryWhenActive(true);
 235     }
 236     HTMLFormControlElementWithState::dispatchFocusEvent();
 237 }
 238
 239 void HTMLInputElement::dispatchBlurEvent()
 240 {
 241     if (isTextField() && document()->frame()) {
 242         if (inputType() == PASSWORD)
 243             document()->setUseSecureKeyboardEntryWhenActive(false);
 244         document()->frame()->textFieldDidEndEditing(this);
 245     }
 246     HTMLFormControlElementWithState::dispatchBlurEvent();
 247 }
 248
 249 void HTMLInputElement::setType(const String& t)
 250 {
 251     if (t.isEmpty()) {
 252         int exccode;
 253         removeAttribute(typeAttr, exccode);
 254     } else
 255         setAttribute(typeAttr, t);
 256 }
 257
 258 void HTMLInputElement::setInputType(const String& t)
 259 {
 260     InputType newType;
 261
 262     if (equalIgnoringCase(t, "password"))
 263         newType = PASSWORD;
 264     else if (equalIgnoringCase(t, "checkbox"))
 265         newType = CHECKBOX;
 266     else if (equalIgnoringCase(t, "radio"))
 267         newType = RADIO;
 268     else if (equalIgnoringCase(t, "submit"))
 269         newType = SUBMIT;
 270     else if (equalIgnoringCase(t, "reset"))
 271         newType = RESET;
 272     else if (equalIgnoringCase(t, "file"))
 273         newType = FILE;
 274     else if (equalIgnoringCase(t, "hidden"))
 275         newType = HIDDEN;
 276     else if (equalIgnoringCase(t, "image"))
 277         newType = IMAGE;
 278     else if (equalIgnoringCase(t, "button"))
 279         newType = BUTTON;
 280     else if (equalIgnoringCase(t, "khtml_isindex"))
 281         newType = ISINDEX;
 282     else if (equalIgnoringCase(t, "search"))
 283         newType = SEARCH;
 284     else if (equalIgnoringCase(t, "range"))
 285         newType = RANGE;
 286     else
 287         newType = TEXT;
 288
 289     // IMPORTANT: Don't allow the type to be changed to FILE after the first
 290     // type change, otherwise a JavaScript programmer would be able to set a text
 291     // field's value to something like /etc/passwd and then change it to a file field.
 292     if (inputType() != newType) {
 293         if (newType == FILE && m_haveType)
 294             // Set the attribute back to the old value.
 295             // Useful in case we were called from inside parseMappedAttribute.
 296             setAttribute(typeAttr, type());
 297         else {
 298             checkedRadioButtons(this).removeButton(this);
 299
 300             bool wasAttached = m_attached;
 301             if (wasAttached)
 302                 detach();
 303
 304             bool didStoreValue = storesValueSeparateFromAttribute();
 305             bool wasPasswordField = inputType() == PASSWORD;
 306             bool didRespectHeightAndWidth = respectHeightAndWidthAttrs();
 307             m_type = newType;
 308             bool willStoreValue = storesValueSeparateFromAttribute();
 309             bool isPasswordField = inputType() == PASSWORD;
 310             bool willRespectHeightAndWidth = respectHeightAndWidthAttrs();
 311
 312             if (didStoreValue && !willStoreValue && !m_value.isNull()) {
 313                 setAttribute(valueAttr, m_value);
 314                 m_value = String();
 315             }
 316             if (!didStoreValue && willStoreValue)
 317                 m_value = constrainValue(getAttribute(valueAttr));
 318             else
 319                 recheckValue();
 320
 321             if (wasPasswordField && !isPasswordField)
 322                 document()->unregisterForCacheCallbacks(this);
 323             else if (!wasPasswordField && isPasswordField)
 324                 document()->registerForCacheCallbacks(this);
 325
 326             if (didRespectHeightAndWidth != willRespectHeightAndWidth) {
 327                 NamedMappedAttrMap* map = mappedAttributes();
 328                 if (MappedAttribute* height = map->getAttributeItem(heightAttr))
 329                     attributeChanged(height, false);
 330                 if (MappedAttribute* width = map->getAttributeItem(widthAttr))
 331                     attributeChanged(width, false);
 332                 if (MappedAttribute* align = map->getAttributeItem(alignAttr))
 333                     attributeChanged(align, false);
 334             }
 335
 336             if (wasAttached)
 337                 attach();
 338
 339             checkedRadioButtons(this).addButton(this);
 340         }
 341     }
 342     m_haveType = true;
 343
 344     if (inputType() != IMAGE && m_imageLoader) {
 345         delete m_imageLoader;
 346         m_imageLoader = 0;
 347     }
 348 }
 349
 350 const AtomicString& HTMLInputElement::type() const
 351 {
 352     // needs to be lowercase according to DOM spec
 353     switch (inputType()) {
 354         case BUTTON: {
 355             static const AtomicString button("button");
 356             return button;
 357         }
 358         case CHECKBOX: {
 359             static const AtomicString checkbox("checkbox");
 360             return checkbox;
 361         }
 362         case FILE: {
 363             static const AtomicString file("file");
 364             return file;
 365         }
 366         case HIDDEN: {
 367             static const AtomicString hidden("hidden");
 368             return hidden;
 369         }
 370         case IMAGE: {
 371             static const AtomicString image("image");
 372             return image;
 373         }
 374         case ISINDEX:
 375             return emptyAtom;
 376         case PASSWORD: {
 377             static const AtomicString password("password");
 378             return password;
 379         }
 380         case RADIO: {
 381             static const AtomicString radio("radio");
 382             return radio;
 383         }
 384         case RANGE: {
 385             static const AtomicString range("range");
 386             return range;
 387         }
 388         case RESET: {
 389             static const AtomicString reset("reset");
 390             return reset;
 391         }
 392         case SEARCH: {
 393             static const AtomicString search("search");
 394             return search;
 395         }
 396         case SUBMIT: {
 397             static const AtomicString submit("submit");
 398             return submit;
 399         }
 400         case TEXT: {
 401             static const AtomicString text("text");
 402             return text;
 403         }
 404     }
 405     return emptyAtom;
 406 }
 407
 408 bool HTMLInputElement::saveState(String& result) const
 409 {
 410     switch (inputType()) {
 411         case BUTTON:
 412         case FILE:
 413         case HIDDEN:
 414         case IMAGE:
 415         case ISINDEX:
 416         case RANGE:
 417         case RESET:
 418         case SEARCH:
 419         case SUBMIT:
 420         case TEXT:
 421             result = value();
 422             return true;
 423         case CHECKBOX:
 424         case RADIO:
 425             result = checked() ? "on" : "off";
 426             return true;
 427         case PASSWORD:
 428             return false;
 429     }
 430     ASSERT_NOT_REACHED();
 431     return false;
 432 }
 433
 434 void HTMLInputElement::restoreState(const String& state)
 435 {
 436     ASSERT(inputType() != PASSWORD); // should never save/restore password fields
 437     switch (inputType()) {
 438         case BUTTON:
 439         case FILE:
 440         case HIDDEN:
 441         case IMAGE:
 442         case ISINDEX:
 443         case RANGE:
 444         case RESET:
 445         case SEARCH:
 446         case SUBMIT:
 447         case TEXT:
 448             setValue(state);
 449             break;
 450         case CHECKBOX:
 451         case RADIO:
 452             setChecked(state == "on");
 453             break;
 454         case PASSWORD:
 455             break;
 456     }
 457 }
 458
 459 bool HTMLInputElement::canStartSelection() const
 460 {
 461     if (!isTextField())
 462         return false;
 463     return HTMLFormControlElementWithState::canStartSelection();
 464 }
 465
 466 bool HTMLInputElement::canHaveSelection() const
 467 {
 468     return isTextField();
 469 }
 470
 471 int HTMLInputElement::selectionStart() const
 472 {
 473     if (!isTextField())
 474         return 0;
 475     if (document()->focusedNode() != this && cachedSelStart != -1)
 476         return cachedSelStart;
 477     if (!renderer())
 478         return 0;
 479     return static_cast<RenderTextControl*>(renderer())->selectionStart();
 480 }
 481
 482 int HTMLInputElement::selectionEnd() const
 483 {
 484     if (!isTextField())
 485         return 0;
 486     if (document()->focusedNode() != this && cachedSelEnd != -1)
 487         return cachedSelEnd;
 488     if (!renderer())
 489         return 0;
 490     return static_cast<RenderTextControl*>(renderer())->selectionEnd();
 491 }
 492
 493 void HTMLInputElement::setSelectionStart(int start)
 494 {
 495     if (!isTextField())
 496         return;
 497     if (!renderer())
 498         return;
 499     static_cast<RenderTextControl*>(renderer())->setSelectionStart(start);
 500 }
 501
 502 void HTMLInputElement::setSelectionEnd(int end)
 503 {
 504     if (!isTextField())
 505         return;
 506     if (!renderer())
 507         return;
 508     static_cast<RenderTextControl*>(renderer())->setSelectionEnd(end);
 509 }
 510
 511 void HTMLInputElement::select()
 512 {
 513     if (!isTextField())
 514         return;
 515     if (!renderer())
 516         return;
 517     static_cast<RenderTextControl*>(renderer())->select();
 518 }
 519
 520 void HTMLInputElement::setSelectionRange(int start, int end)
 521 {
 522     if (!isTextField())
 523         return;
 524     if (!renderer())
 525         return;
 526     static_cast<RenderTextControl*>(renderer())->setSelectionRange(start, end);
 527 }
 528
 529 void HTMLInputElement::accessKeyAction(bool sendToAnyElement)
 530 {
 531     switch (inputType()) {
 532         case BUTTON:
 533         case CHECKBOX:
 534         case FILE:
 535         case IMAGE:
 536         case RADIO:
 537         case RANGE:
 538         case RESET:
 539         case SUBMIT:
 540             focus(false);
 541             // send the mouse button events iff the caller specified sendToAnyElement
 542             dispatchSimulatedClick(0, sendToAnyElement);
 543             break;
 544         case HIDDEN:
 545             // a no-op for this type
 546             break;
 547         case ISINDEX:
 548         case PASSWORD:
 549         case SEARCH:
 550         case TEXT:
 551             // should never restore previous selection here
 552             focus(false);
 553             break;
 554     }
 555 }
 556
 557 bool HTMLInputElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
 558 {
 559     if (((attrName == heightAttr || attrName == widthAttr) && respectHeightAndWidthAttrs()) ||
 560         attrName == vspaceAttr ||
 561         attrName == hspaceAttr) {
 562         result = eUniversal;
 563         return false;
 564     }
 565
 566     if (attrName == alignAttr) {
 567         if (inputType() == IMAGE) {
 568             // Share with <img> since the alignment behavior is the same.
 569             result = eReplaced;
 570             return false;
 571         }
 572     }
 573
 574     return HTMLElement::mapToEntry(attrName, result);
 575 }
 576
 577 void HTMLInputElement::parseMappedAttribute(MappedAttribute *attr)
 578 {
 579     if (attr->name() == nameAttr) {
 580         checkedRadioButtons(this).removeButton(this);
 581         m_name = attr->value();
 582         checkedRadioButtons(this).addButton(this);
 583     } else if (attr->name() == autocompleteAttr) {
 584         m_autocomplete = !equalIgnoringCase(attr->value(), "off");
 585     } else if (attr->name() == typeAttr) {
 586         setInputType(attr->value());
 587     } else if (attr->name() == valueAttr) {
 588         // We only need to setChanged if the form is looking at the default value right now.
 589         if (m_value.isNull())
 590             setChanged();
 591         setValueMatchesRenderer(false);
 592     } else if (attr->name() == checkedAttr) {
 593         m_defaultChecked = !attr->isNull();
 594         if (m_useDefaultChecked) {
 595             setChecked(m_defaultChecked);
 596             m_useDefaultChecked = true;
 597         }
 598     } else if (attr->name() == maxlengthAttr) {
 599         int oldMaxLen = m_maxLen;
 600         m_maxLen = !attr->isNull() ? attr->value().toInt() : cMaxLen;
 601         if (m_maxLen <= 0 || m_maxLen > cMaxLen)
 602             m_maxLen = cMaxLen;
 603         if (oldMaxLen != m_maxLen)
 604             recheckValue();
 605         setChanged();
 606     } else if (attr->name() == sizeAttr) {
 607         m_size = !attr->isNull() ? attr->value().toInt() : 20;
 608     } else if (attr->name() == altAttr) {
 609         if (renderer() && inputType() == IMAGE)
 610             static_cast<RenderImage*>(renderer())->updateAltText();
 611     } else if (attr->name() == srcAttr) {
 612         if (renderer() && inputType() == IMAGE) {
 613             if (!m_imageLoader)
 614                 m_imageLoader = new HTMLImageLoader(this);
 615             m_imageLoader->updateFromElement();
 616         }
 617     } else if (attr->name() == usemapAttr ||
 618                attr->name() == accesskeyAttr) {
 619         // FIXME: ignore for the moment
 620     } else if (attr->name() == vspaceAttr) {
 621         addCSSLength(attr, CSS_PROP_MARGIN_TOP, attr->value());
 622         addCSSLength(attr, CSS_PROP_MARGIN_BOTTOM, attr->value());
 623     } else if (attr->name() == hspaceAttr) {
 624         addCSSLength(attr, CSS_PROP_MARGIN_LEFT, attr->value());
 625         addCSSLength(attr, CSS_PROP_MARGIN_RIGHT, attr->value());
 626     } else if (attr->name() == alignAttr) {
 627         if (inputType() == IMAGE)
 628             addHTMLAlignment(attr);
 629     } else if (attr->name() == widthAttr) {
 630         if (respectHeightAndWidthAttrs())
 631             addCSSLength(attr, CSS_PROP_WIDTH, attr->value());
 632     } else if (attr->name() == heightAttr) {
 633         if (respectHeightAndWidthAttrs())
 634             addCSSLength(attr, CSS_PROP_HEIGHT, attr->value());
 635     } else if (attr->name() == onfocusAttr) {
 636         setHTMLEventListener(focusEvent, attr);
 637     } else if (attr->name() == onblurAttr) {
 638         setHTMLEventListener(blurEvent, attr);
 639     } else if (attr->name() == onselectAttr) {
 640         setHTMLEventListener(selectEvent, attr);
 641     } else if (attr->name() == onchangeAttr) {
 642         setHTMLEventListener(changeEvent, attr);
 643     } else if (attr->name() == oninputAttr) {
 644         setHTMLEventListener(inputEvent, attr);
 645     }
 646     // Search field and slider attributes all just cause updateFromElement to be called through style
 647     // recalcing.
 648     else if (attr->name() == onsearchAttr) {
 649         setHTMLEventListener(searchEvent, attr);
 650     } else if (attr->name() == resultsAttr) {
 651         int oldResults = m_maxResults;
 652         m_maxResults = !attr->isNull() ? min(attr->value().toInt(), maxSavedResults) : -1;
 653         // FIXME: Detaching just for maxResults change is not ideal.  We should figure out the right
 654         // time to relayout for this change.
 655         if (m_maxResults != oldResults && (m_maxResults <= 0 || oldResults <= 0) && attached()) {
 656             detach();
 657             attach();
 658         }
 659         setChanged();
 660     } else if (attr->name() == autosaveAttr ||
 661                attr->name() == incrementalAttr ||
 662                attr->name() == placeholderAttr ||
 663                attr->name() == minAttr ||
 664                attr->name() == maxAttr ||
 665                attr->name() == precisionAttr) {
 666         setChanged();
 667     } else
 668         HTMLFormControlElementWithState::parseMappedAttribute(attr);
 669 }
 670
 671 bool HTMLInputElement::rendererIsNeeded(RenderStyle *style)
 672 {
 673     switch (inputType()) {
 674         case BUTTON:
 675         case CHECKBOX:
 676         case FILE:
 677         case IMAGE:
 678         case ISINDEX:
 679         case PASSWORD:
 680         case RADIO:
 681         case RANGE:
 682         case RESET:
 683         case SEARCH:
 684         case SUBMIT:
 685         case TEXT:
 686             return HTMLFormControlElementWithState::rendererIsNeeded(style);
 687         case HIDDEN:
 688             return false;
 689     }
 690     ASSERT(false);
 691     return false;
 692 }
 693
 694 RenderObject *HTMLInputElement::createRenderer(RenderArena *arena, RenderStyle *style)
 695 {
 696     switch (inputType()) {
 697         case BUTTON:
 698         case RESET:
 699         case SUBMIT:
 700             return new (arena) RenderButton(this);
 701         case CHECKBOX:
 702         case RADIO:
 703             return RenderObject::createObject(this, style);
 704         case FILE:
 705             return new (arena) RenderFileUploadControl(this);
 706         case HIDDEN:
 707             break;
 708         case IMAGE:
 709             return new (arena) RenderImage(this);
 710         case RANGE:
 711             return new (arena) RenderSlider(this);
 712         case ISINDEX:
 713         case PASSWORD:
 714         case SEARCH:
 715         case TEXT:
 716             return new (arena) RenderTextControl(this, false);
 717     }
 718     ASSERT(false);
 719     return 0;
 720 }
 721
 722 void HTMLInputElement::attach()
 723 {
 724     if (!m_inited) {
 725         if (!m_haveType)
 726             setInputType(getAttribute(typeAttr));
 727         m_inited = true;
 728     }
 729
 730     HTMLFormControlElementWithState::attach();
 731
 732     if (inputType() == IMAGE) {
 733         if (!m_imageLoader)
 734             m_imageLoader = new HTMLImageLoader(this);
 735         m_imageLoader->updateFromElement();
 736         if (renderer()) {
 737             RenderImage* imageObj = static_cast<RenderImage*>(renderer());
 738             imageObj->setCachedImage(m_imageLoader->image());
 739
 740             // If we have no image at all because we have no src attribute, set
 741             // image height and width for the alt text instead.
 742             if (!m_imageLoader->image() && !imageObj->cachedImage())
 743                 imageObj->setImageSizeForAltText();
 744         }
 745     }
 746 }
 747
 748 void HTMLInputElement::detach()
 749 {
 750     HTMLFormControlElementWithState::detach();
 751     setValueMatchesRenderer(false);
 752 }
 753
 754 String HTMLInputElement::altText() const
 755 {
 756     // http://www.w3.org/TR/1998/REC-html40-19980424/appendix/notes.html#altgen
 757     // also heavily discussed by Hixie on bugzilla
 758     // note this is intentionally different to HTMLImageElement::altText()
 759     String alt = getAttribute(altAttr);
 760     // fall back to title attribute
 761     if (alt.isNull())
 762         alt = getAttribute(titleAttr);
 763     if (alt.isNull())
 764         alt = getAttribute(valueAttr);
 765     if (alt.isEmpty())
 766         alt = inputElementAltText();
 767     return alt;
 768 }
 769
 770 bool HTMLInputElement::isSuccessfulSubmitButton() const
 771 {
 772     // HTML spec says that buttons must have names to be considered successful.
 773     // However, other browsers do not impose this constraint. So we do likewise.
 774     return !disabled() && (inputType() == IMAGE || inputType() == SUBMIT);
 775 }
 776
 777 bool HTMLInputElement::isActivatedSubmit() const
 778 {
 779     return m_activeSubmit;
 780 }
 781
 782 void HTMLInputElement::setActivatedSubmit(bool flag)
 783 {
 784     m_activeSubmit = flag;
 785 }
 786
 787 bool HTMLInputElement::appendFormData(FormDataList& encoding, bool multipart)
 788 {
 789     // image generates its own names, but for other types there is no form data unless there's a name
 790     if (name().isEmpty() && inputType() != IMAGE)
 791         return false;
 792
 793     switch (inputType()) {
 794         case HIDDEN:
 795         case ISINDEX:
 796         case PASSWORD:
 797         case RANGE:
 798         case SEARCH:
 799         case TEXT:
 800             // always successful
 801             encoding.appendData(name(), value());
 802             return true;
 803
 804         case CHECKBOX:
 805         case RADIO:
 806             if (checked()) {
 807                 encoding.appendData(name(), value());
 808                 return true;
 809             }
 810             break;
 811
 812         case BUTTON:
 813         case RESET:
 814             // these types of buttons are never successful
 815             return false;
 816
 817         case IMAGE:
 818             if (m_activeSubmit) {
 819                 encoding.appendData(name().isEmpty() ? "x" : (name() + ".x"), xPos);
 820                 encoding.appendData(name().isEmpty() ? "y" : (name() + ".y"), yPos);
 821                 if (!name().isEmpty() && !value().isEmpty())
 822                     encoding.appendData(name(), value());
 823                 return true;
 824             }
 825             break;
 826
 827         case SUBMIT:
 828             if (m_activeSubmit) {
 829                 String enc_str = valueWithDefault();
 830                 encoding.appendData(name(), enc_str);
 831                 return true;
 832             }
 833             break;
 834
 835         case FILE:
 836             // Can't submit file on GET.
 837             if (!multipart)
 838                 return false;
 839
 840             // If no filename at all is entered, return successful but empty.
 841             // Null would be more logical, but Netscape posts an empty file. Argh.
 842             if (value().isEmpty()) {
 843                 encoding.appendData(name(), String(""));
 844                 return true;
 845             }
 846
 847             encoding.appendFile(name(), value());
 848             return true;
 849     }
 850     return false;
 851 }
 852
 853 void HTMLInputElement::reset()
 854 {
 855     if (storesValueSeparateFromAttribute())
 856         setValue(String());
 857
 858     setChecked(m_defaultChecked);
 859     m_useDefaultChecked = true;
 860 }
 861
 862 void HTMLInputElement::setChecked(bool nowChecked, bool sendChangeEvent)
 863 {
 864     if (checked() == nowChecked)
 865         return;
 866
 867     m_useDefaultChecked = false;
 868     m_checked = nowChecked;
 869     setChanged();
 870
 871     checkedRadioButtons(this).addButton(this);
 872
 873     if (renderer() && renderer()->style()->hasAppearance())
 874         theme()->stateChanged(renderer(), CheckedState);
 875
 876     // Only send a change event for items in the document (avoid firing during
 877     // parsing) and don't send a change event for a radio button that's getting
 878     // unchecked to match other browsers. DOM is not a useful standard for this
 879     // because it says only to fire change events at "lose focus" time, which is
 880     // definitely wrong in practice for these types of elements.
 881     if (sendChangeEvent && inDocument() && (inputType() != RADIO || nowChecked))
 882         onChange();
 883 }
 884
 885 void HTMLInputElement::setIndeterminate(bool _indeterminate)
 886 {
 887     // Only checkboxes honor indeterminate.
 888     if (inputType() != CHECKBOX || indeterminate() == _indeterminate)
 889         return;
 890
 891     m_indeterminate = _indeterminate;
 892
 893     setChanged();
 894
 895     if (renderer() && renderer()->style()->hasAppearance())
 896         theme()->stateChanged(renderer(), CheckedState);
 897 }
 898
 899 void HTMLInputElement::copyNonAttributeProperties(const Element *source)
 900 {
 901     const HTMLInputElement *sourceElem = static_cast<const HTMLInputElement *>(source);
 902
 903     m_value = sourceElem->m_value;
 904     m_checked = sourceElem->m_checked;
 905     m_indeterminate = sourceElem->m_indeterminate;
 906
 907     HTMLFormControlElementWithState::copyNonAttributeProperties(source);
 908 }
 909
 910 String HTMLInputElement::value() const
 911 {
 912     String value = m_value;
 913
 914     // It's important *not* to fall back to the value attribute for file inputs,
 915     // because that would allow a malicious web page to upload files by setting the
 916     // value attribute in markup.
 917     if (value.isNull() && inputType() != FILE)
 918         value = constrainValue(getAttribute(valueAttr));
 919
 920     // If no attribute exists, then just use "on" or "" based off the checked() state of the control.
 921     if (value.isNull() && (inputType() == CHECKBOX || inputType() == RADIO))
 922         return checked() ? "on" : "";
 923
 924     return value;
 925 }
 926
 927 String HTMLInputElement::valueWithDefault() const
 928 {
 929     String v = value();
 930     if (v.isNull()) {
 931         switch (inputType()) {
 932             case BUTTON:
 933             case CHECKBOX:
 934             case FILE:
 935             case HIDDEN:
 936             case IMAGE:
 937             case ISINDEX:
 938             case PASSWORD:
 939             case RADIO:
 940             case RANGE:
 941             case SEARCH:
 942             case TEXT:
 943                 break;
 944             case RESET:
 945                 v = resetButtonDefaultLabel();
 946                 break;
 947             case SUBMIT:
 948                 v = submitButtonDefaultLabel();
 949                 break;
 950         }
 951     }
 952     return v;
 953 }
 954
 955 void HTMLInputElement::setValue(const String& value)
 956 {
 957     // For security reasons, we don't allow setting the filename, but we do allow clearing it.
 958     if (inputType() == FILE && !value.isEmpty())
 959         return;
 960
 961     setValueMatchesRenderer(false);
 962     if (storesValueSeparateFromAttribute()) {
 963         m_value = constrainValue(value);
 964         if (isTextField() && inDocument())
 965             document()->updateRendering();
 966         if (renderer())
 967             renderer()->updateFromElement();
 968         setChanged();
 969     } else
 970         setAttribute(valueAttr, constrainValue(value));
 971
 972     if (isTextField()) {
 973         unsigned max = m_value.length();
 974         if (document()->focusedNode() == this)
 975             setSelectionRange(max, max);
 976         else {
 977             cachedSelStart = max;
 978             cachedSelEnd = max;
 979         }
 980     }
 981 }
 982
 983 void HTMLInputElement::setValueFromRenderer(const String& value)
 984 {
 985     // Renderer and our event handler are responsible for constraining values.
 986     ASSERT(value == constrainValue(value) || constrainValue(value).isEmpty());
 987
 988     // Workaround for bug where trailing \n is included in the result of textContent.
 989     // The assert macro above may also be simplified to:  value == constrainValue(value)
 990     // http://bugs.webkit.org/show_bug.cgi?id=9661
 991     if (value == "\n")
 992         m_value = "";
 993     else
 994         m_value = value;
 995
 996     setValueMatchesRenderer();
 997
 998     // Fire the "input" DOM event.
 999     dispatchHTMLEvent(inputEvent, true, false);
1000 }
1001
1002 bool HTMLInputElement::storesValueSeparateFromAttribute() const
1003 {
1004     switch (inputType()) {
1005         case BUTTON:
1006         case CHECKBOX:
1007         case HIDDEN:
1008         case IMAGE:
1009         case RADIO:
1010         case RESET:
1011         case SUBMIT:
1012             return false;
1013         case FILE:
1014         case ISINDEX:
1015         case PASSWORD:
1016         case RANGE:
1017         case SEARCH:
1018         case TEXT:
1019             return true;
1020     }
1021     return false;
1022 }
1023
1024 void* HTMLInputElement::preDispatchEventHandler(Event *evt)
1025 {
1026     // preventDefault or "return false" are used to reverse the automatic checking/selection we do here.
1027     // This result gives us enough info to perform the "undo" in postDispatch of the action we take here.
1028     void* result = 0;
1029     if ((inputType() == CHECKBOX || inputType() == RADIO) && evt->isMouseEvent()
1030             && evt->type() == clickEvent && static_cast<MouseEvent*>(evt)->button() == LeftButton) {
1031         if (inputType() == CHECKBOX) {
1032             // As a way to store the state, we return 0 if we were unchecked, 1 if we were checked, and 2 for
1033             // indeterminate.
1034             if (indeterminate()) {
1035                 result = (void*)0x2;
1036                 setIndeterminate(false);
1037             } else {
1038                 if (checked())
1039                     result = (void*)0x1;
1040                 setChecked(!checked(), true);
1041             }
1042         } else {
1043             // For radio buttons, store the current selected radio object.
1044             if (name().isEmpty() || checked())
1045                 return 0; // Match WinIE and don't allow unnamed radio buttons to be checked.
1046                           // Checked buttons just stay checked.
1047                           // FIXME: Need to learn to work without a form.
1048
1049             // We really want radio groups to end up in sane states, i.e., to have something checked.
1050             // Therefore if nothing is currently selected, we won't allow this action to be "undone", since
1051             // we want some object in the radio group to actually get selected.
1052             HTMLInputElement* currRadio = checkedRadioButtons(this).checkedButtonForGroup(name());
1053             if (currRadio) {
1054                 // We have a radio button selected that is not us.  Cache it in our result field and ref it so
1055                 // that it can't be destroyed.
1056                 currRadio->ref();
1057                 result = currRadio;
1058             }
1059             setChecked(true, true);
1060         }
1061     }
1062     return result;
1063 }
1064
1065 void HTMLInputElement::postDispatchEventHandler(Event *evt, void* data)
1066 {
1067     if ((inputType() == CHECKBOX || inputType() == RADIO) && evt->isMouseEvent()
1068             && evt->type() == clickEvent && static_cast<MouseEvent*>(evt)->button() == LeftButton) {
1069         if (inputType() == CHECKBOX) {
1070             // Reverse the checking we did in preDispatch.
1071             if (evt->defaultPrevented() || evt->defaultHandled()) {
1072                 if (data == (void*)0x2)
1073                     setIndeterminate(true);
1074                 else
1075                     setChecked(data);
1076             }
1077         } else if (data) {
1078             HTMLInputElement* input = static_cast<HTMLInputElement*>(data);
1079             if (evt->defaultPrevented() || evt->defaultHandled()) {
1080                 // Restore the original selected radio button if possible.
1081                 // Make sure it is still a radio button and only do the restoration if it still
1082                 // belongs to our group.
1083
1084                 // Match WinIE and don't allow unnamed radio buttons to be checked.
1085                 if (input->form() == form() && input->inputType() == RADIO && !name().isEmpty() && input->name() == name()) {
1086                     // Ok, the old radio button is still in our form and in our group and is still a
1087                     // radio button, so it's safe to restore selection to it.
1088                     input->setChecked(true);
1089                 }
1090             }
1091             input->deref();
1092         }
1093
1094         // Left clicks on radio buttons and check boxes already performed default actions in preDispatchEventHandler().
1095         evt->setDefaultHandled();
1096     }
1097 }
1098
1099 void HTMLInputElement::defaultEventHandler(Event* evt)
1100 {
1101     bool clickDefaultFormButton = false;
1102
1103     if (isTextField() && evt->type() == textInputEvent && evt->isTextEvent() && static_cast<TextEvent*>(evt)->data() == "\n")
1104         clickDefaultFormButton = true;
1105
1106     if (inputType() == IMAGE && evt->isMouseEvent() && evt->type() == clickEvent) {
1107         // record the mouse position for when we get the DOMActivate event
1108         MouseEvent* me = static_cast<MouseEvent*>(evt);
1109         // FIXME: We could just call offsetX() and offsetY() on the event,
1110         // but that's currently broken, so for now do the computation here.
1111         if (me->isSimulated() || !renderer()) {
1112             xPos = 0;
1113             yPos = 0;
1114         } else {
1115             int offsetX, offsetY;
1116             renderer()->absolutePosition(offsetX, offsetY);
1117             xPos = me->pageX() - offsetX;
1118             // FIXME: Why is yPos a short?
1119             yPos = me->pageY() - offsetY;
1120         }
1121     }
1122
1123     // Before calling the base class defaultEventHandler, which will call handleKeypress, call doTextFieldCommandFromEvent.
1124     if (isTextField() && evt->type() == keypressEvent && evt->isKeyboardEvent() && focused() && document()->frame()
1125                 && document()->frame()->doTextFieldCommandFromEvent(this, static_cast<KeyboardEvent*>(evt))) {
1126         evt->setDefaultHandled();
1127         return;
1128     }
1129
1130     if (inputType() == RADIO && evt->isMouseEvent()
1131             && evt->type() == clickEvent && static_cast<MouseEvent*>(evt)->button() == LeftButton) {
1132         evt->setDefaultHandled();
1133         return;
1134     }
1135
1136     // Let the key handling done in EventTargetNode take precedence over the event handling here for editable text fields
1137     if (!clickDefaultFormButton) {
1138         HTMLFormControlElementWithState::defaultEventHandler(evt);
1139         if (evt->defaultHandled())
1140             return;
1141     }
1142
1143     // DOMActivate events cause the input to be "activated" - in the case of image and submit inputs, this means
1144     // actually submitting the form. For reset inputs, the form is reset. These events are sent when the user clicks
1145     // on the element, or presses enter while it is the active element. JavaScript code wishing to activate the element
1146     // must dispatch a DOMActivate event - a click event will not do the job.
1147     if (evt->type() == DOMActivateEvent && !disabled()) {
1148         if (inputType() == IMAGE || inputType() == SUBMIT || inputType() == RESET) {
1149             if (!form())
1150                 return;
1151             if (inputType() == RESET)
1152                 form()->reset();
1153             else {
1154                 m_activeSubmit = true;
1155                 // FIXME: Would be cleaner to get xPos and yPos out of the underlying mouse
1156                 // event (if any) here instead of relying on the variables set above when
1157                 // processing the click event. Even better, appendFormData could pass the
1158                 // event in, and then we could get rid of xPos and yPos altogether!
1159                 if (!form()->prepareSubmit(evt)) {
1160                     xPos = 0;
1161                     yPos = 0;
1162                 }
1163                 m_activeSubmit = false;
1164             }
1165         } else if (inputType() == FILE && renderer())
1166             static_cast<RenderFileUploadControl*>(renderer())->click();
1167     }
1168
1169     // Use key press event here since sending simulated mouse events
1170     // on key down blocks the proper sending of the key press event.
1171     if (evt->type() == keypressEvent && evt->isKeyboardEvent()) {
1172         bool clickElement = false;
1173
1174         String key = static_cast<KeyboardEvent*>(evt)->keyIdentifier();
1175
1176         if (key == "U+0020") {
1177             switch (inputType()) {
1178                 case BUTTON:
1179                 case CHECKBOX:
1180                 case FILE:
1181                 case IMAGE:
1182                 case RESET:
1183                 case SUBMIT:
1184                     // Simulate mouse click for spacebar for these types of elements.
1185                     // The AppKit already does this for some, but not all, of them.
1186                     clickElement = true;
1187                     break;
1188                 case RADIO:
1189                     // If an unselected radio is tabbed into (because the entire group has nothing
1190                     // checked, or because of some explicit .focus() call), then allow space to check it.
1191                     if (!checked())
1192                         clickElement = true;
1193                     break;
1194                 case HIDDEN:
1195                 case ISINDEX:
1196                 case PASSWORD:
1197                 case RANGE:
1198                 case SEARCH:
1199                 case TEXT:
1200                     break;
1201             }
1202         }
1203
1204         if (key == "Enter") {
1205             switch (inputType()) {
1206                 case BUTTON:
1207                 case CHECKBOX:
1208                 case HIDDEN:
1209                 case ISINDEX:
1210                 case PASSWORD:
1211                 case RANGE:
1212                 case SEARCH:
1213                 case TEXT:
1214                     // Simulate mouse click on the default form button for enter for these types of elements.
1215                     clickDefaultFormButton = true;
1216                     break;
1217                 case FILE:
1218                 case IMAGE:
1219                 case RESET:
1220                 case SUBMIT:
1221                     // Simulate mouse click for enter for these types of elements.
1222                     clickElement = true;
1223                     break;
1224                 case RADIO:
1225                     break; // Don't do anything for enter on a radio button.
1226             }
1227         }
1228
1229         if (inputType() == RADIO && (key == "Up" || key == "Down" || key == "Left" || key == "Right")) {
1230             // Left and up mean "previous radio button".
1231             // Right and down mean "next radio button".
1232             // Tested in WinIE, and even for RTL, left still means previous radio button (and so moves
1233             // to the right).  Seems strange, but we'll match it.
1234             bool forward = (key == "Down" || key == "Right");
1235
1236             // We can only stay within the form's children if the form hasn't been demoted to a leaf because
1237             // of malformed HTML.
1238             Node* n = this;
1239             while ((n = (forward ? n->traverseNextNode() : n->traversePreviousNode()))) {
1240                 // Once we encounter a form element, we know we're through.
1241                 if (n->hasTagName(formTag))
1242                     break;
1243
1244                 // Look for more radio buttons.
1245                 if (n->hasTagName(inputTag)) {
1246                     HTMLInputElement* elt = static_cast<HTMLInputElement*>(n);
1247                     if (elt->form() != form())
1248                         break;
1249                     if (n->hasTagName(inputTag)) {
1250                         // Match WinIE and don't allow unnamed radio buttons to be checked.
1251                         HTMLInputElement* inputElt = static_cast<HTMLInputElement*>(n);
1252                         if (inputElt->inputType() == RADIO && !name().isEmpty() && inputElt->name() == name() && inputElt->isFocusable()) {
1253                             inputElt->setChecked(true);
1254                             document()->setFocusedNode(inputElt);
1255                             inputElt->dispatchSimulatedClick(evt, false, false);
1256                             evt->setDefaultHandled();
1257                             break;
1258                         }
1259                     }
1260                 }
1261             }
1262         }
1263
1264         if (clickElement) {
1265             dispatchSimulatedClick(evt);
1266             evt->setDefaultHandled();
1267             return;
1268         }
1269     }
1270
1271     if (clickDefaultFormButton) {
1272         if (isSearchField()) {
1273             addSearchResult();
1274             onSearch();
1275         }
1276         // Fire onChange for text fields.
1277         RenderObject* r = renderer();
1278         if (r && r->isTextField() && r->isEdited()) {
1279             onChange();
1280             // Refetch the renderer since arbitrary JS code run during onchange can do anything, including destroying it.
1281             r = renderer();
1282             if (r)
1283                 r->setEdited(false);
1284         }
1285         // Form may never have been present, or may have been destroyed by the change event.
1286         if (form())
1287             form()->submitClick(evt);
1288         evt->setDefaultHandled();
1289         return;
1290     }
1291
1292     if (evt->isBeforeTextInsertedEvent()) {
1293         // Make sure that the text to be inserted will not violate the maxLength.
1294         int oldLen = numGraphemeClusters(value().impl());
1295         ASSERT(oldLen <= maxLength());
1296         int selectionLen = numGraphemeClusters(document()->frame()->selectionController()->toString().impl());
1297         ASSERT(oldLen >= selectionLen);
1298         int maxNewLen = maxLength() - (oldLen - selectionLen);
1299
1300         // Truncate the inserted text to avoid violating the maxLength and other constraints.
1301         BeforeTextInsertedEvent* textEvent = static_cast<BeforeTextInsertedEvent*>(evt);
1302         textEvent->setText(constrainValue(textEvent->text(), maxNewLen));
1303     }
1304
1305     if (isTextField() && renderer() && (evt->isMouseEvent() || evt->isDragEvent() || evt->isWheelEvent() || evt->type() == blurEvent || evt->type() == focusEvent))
1306         static_cast<RenderTextControl*>(renderer())->forwardEvent(evt);
1307
1308     if (inputType() == RANGE && renderer()) {
1309         RenderSlider* slider = static_cast<RenderSlider*>(renderer());
1310         if (evt->isMouseEvent() && evt->type() == mousedownEvent && static_cast<MouseEvent*>(evt)->button() == LeftButton) {
1311             MouseEvent* mEvt = static_cast<MouseEvent*>(evt);
1312             if (!slider->mouseEventIsInThumb(mEvt)) {
1313                 slider->setValueForPosition(slider->positionForOffset(IntPoint(mEvt->offsetX(), mEvt->offsetY())));
1314             }
1315         }
1316         if (evt->isMouseEvent() || evt->isDragEvent() || evt->isWheelEvent())
1317             slider->forwardEvent(evt);
1318     }
1319 }
1320
1321 bool HTMLInputElement::isURLAttribute(Attribute *attr) const
1322 {
1323     return (attr->name() == srcAttr);
1324 }
1325
1326 String HTMLInputElement::defaultValue() const
1327 {
1328     return getAttribute(valueAttr);
1329 }
1330
1331 void HTMLInputElement::setDefaultValue(const String &value)
1332 {
1333     setAttribute(valueAttr, value);
1334 }
1335
1336 bool HTMLInputElement::defaultChecked() const
1337 {
1338     return !getAttribute(checkedAttr).isNull();
1339 }
1340
1341 void HTMLInputElement::setDefaultChecked(bool defaultChecked)
1342 {
1343     setAttribute(checkedAttr, defaultChecked ? "" : 0);
1344 }
1345
1346 String HTMLInputElement::accept() const
1347 {
1348     return getAttribute(acceptAttr);
1349 }
1350
1351 void HTMLInputElement::setAccept(const String &value)
1352 {
1353     setAttribute(acceptAttr, value);
1354 }
1355
1356 String HTMLInputElement::accessKey() const
1357 {
1358     return getAttribute(accesskeyAttr);
1359 }
1360
1361 void HTMLInputElement::setAccessKey(const String &value)
1362 {
1363     setAttribute(accesskeyAttr, value);
1364 }
1365
1366 String HTMLInputElement::align() const
1367 {
1368     return getAttribute(alignAttr);
1369 }
1370
1371 void HTMLInputElement::setAlign(const String &value)
1372 {
1373     setAttribute(alignAttr, value);
1374 }
1375
1376 String HTMLInputElement::alt() const
1377 {
1378     return getAttribute(altAttr);
1379 }
1380
1381 void HTMLInputElement::setAlt(const String &value)
1382 {
1383     setAttribute(altAttr, value);
1384 }
1385
1386 void HTMLInputElement::setMaxLength(int _maxLength)
1387 {
1388     setAttribute(maxlengthAttr, String::number(_maxLength));
1389 }
1390
1391 void HTMLInputElement::setSize(unsigned _size)
1392 {
1393     setAttribute(sizeAttr, String::number(_size));
1394 }
1395
1396 String HTMLInputElement::src() const
1397 {
1398     return document()->completeURL(getAttribute(srcAttr));
1399 }
1400
1401 void HTMLInputElement::setSrc(const String &value)
1402 {
1403     setAttribute(srcAttr, value);
1404 }
1405
1406 String HTMLInputElement::useMap() const
1407 {
1408     return getAttribute(usemapAttr);
1409 }
1410
1411 void HTMLInputElement::setUseMap(const String &value)
1412 {
1413     setAttribute(usemapAttr, value);
1414 }
1415
1416 String HTMLInputElement::constrainValue(const String& proposedValue) const
1417 {
1418     return constrainValue(proposedValue, m_maxLen);
1419 }
1420
1421 void HTMLInputElement::recheckValue()
1422 {
1423     String oldValue = value();
1424     String newValue = constrainValue(oldValue);
1425     if (newValue != oldValue)
1426         setValue(newValue);
1427 }
1428
1429 String HTMLInputElement::constrainValue(const String& proposedValue, int maxLen) const
1430 {
1431     if (isTextField()) {
1432         StringImpl* s = proposedValue.impl();
1433         int newLen = numCharactersInGraphemeClusters(s, maxLen);
1434         for (int i = 0; i < newLen; ++i) {
1435             const UChar current = (*s)[i];
1436             if (current < ' ' && current != '\t') {
1437                 newLen = i;
1438                 break;
1439             }
1440         }
1441         if (newLen < static_cast<int>(proposedValue.length()))
1442             return proposedValue.substring(0, newLen);
1443     }
1444     return proposedValue;
1445 }
1446
1447 void HTMLInputElement::addSearchResult()
1448 {
1449     ASSERT(isSearchField());
1450     if (renderer())
1451         static_cast<RenderTextControl*>(renderer())->addSearchResult();
1452 }
1453
1454 void HTMLInputElement::onSearch()
1455 {
1456     ASSERT(isSearchField());
1457     if (renderer())
1458         static_cast<RenderTextControl*>(renderer())->stopSearchEventTimer();
1459     dispatchHTMLEvent(searchEvent, true, false);
1460 }
1461
1462 Selection HTMLInputElement::selection() const
1463 {
1464    if (!renderer() || !isTextField() || cachedSelStart == -1 || cachedSelEnd == -1)
1465         return Selection();
1466    return static_cast<RenderTextControl*>(renderer())->selection(cachedSelStart, cachedSelEnd);
1467 }
1468
1469 void HTMLInputElement::didRestoreFromCache()
1470 {
1471     ASSERT(inputType() == PASSWORD);
1472     reset();
1473 }
1474
1475 void HTMLInputElement::willMoveToNewOwnerDocument()
1476 {
1477     if (inputType() == PASSWORD)
1478         document()->unregisterForCacheCallbacks(this);
1479
1480     document()->checkedRadioButtons().removeButton(this);
1481
1482     HTMLFormControlElementWithState::willMoveToNewOwnerDocument();
1483 }
1484
1485 void HTMLInputElement::didMoveToNewOwnerDocument()
1486 {
1487     if (inputType() == PASSWORD)
1488         document()->registerForCacheCallbacks(this);
1489
1490     HTMLFormControlElementWithState::didMoveToNewOwnerDocument();
1491 }
1492
1493 } // namespace