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, 2008, 2009, 2010 Apple Inc. All rights reserved.

     6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)

     7  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)

     8  * Copyright (C) 2010 Google Inc. All rights reserved.

     9  *

    10  * This library is free software; you can redistribute it and/or

    11  * modify it under the terms of the GNU Library General Public

    12  * License as published by the Free Software Foundation; either

    13  * version 2 of the License, or (at your option) any later version.

    14  *

    15  * This library is distributed in the hope that it will be useful,

    16  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18  * Library General Public License for more details.

    19  *

    20  * You should have received a copy of the GNU Library General Public License

    21  * along with this library; see the file COPYING.LIB.  If not, write to

    22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    23  * Boston, MA 02110-1301, USA.

    24  *

    25  */

    26 

    27 #include "config.h"

    28 #include "HTMLInputElement.h"

    29 

    30 #include "AXObjectCache.h"

    31 #include "Attribute.h"

    32 #include "BeforeTextInsertedEvent.h"

    33 #include "CSSPropertyNames.h"

    34 #include "ChromeClient.h"

    35 #include "DateComponents.h"

    36 #include "Document.h"

    37 #include "Editor.h"

    38 #include "Event.h"

    39 #include "EventHandler.h"

    40 #include "EventNames.h"

    41 #include "ExceptionCode.h"

    42 #include "File.h"

    43 #include "FileList.h"

    44 #include "FileSystem.h"

    45 #include "FocusController.h"

    46 #include "FormDataList.h"

    47 #include "Frame.h"

    48 #include "HTMLDataListElement.h"

    49 #include "HTMLFormElement.h"

    50 #include "HTMLImageLoader.h"

    51 #include "HTMLNames.h"

    52 #include "HTMLOptionElement.h"

    53 #include "LegacyHTMLTreeBuilder.h"

    54 #include "KeyboardEvent.h"

    55 #include "LocalizedStrings.h"

    56 #include "MouseEvent.h"

    57 #include "Page.h"

    58 #include "RegularExpression.h"

    59 #include "RenderButton.h"

    60 #include "RenderFileUploadControl.h"

    61 #include "RenderImage.h"

    62 #include "RenderSlider.h"

    63 #include "RenderText.h"

    64 #include "RenderTextControlSingleLine.h"

    65 #include "RenderTheme.h"

    66 #include "ScriptEventListener.h"

    67 #include "StepRange.h"

    68 #include "StringHash.h"

    69 #include "TextEvent.h"

    70 #include <wtf/HashMap.h>

    71 #include <wtf/MathExtras.h>

    72 #include <wtf/StdLibExtras.h>

    73 

    74 using namespace std;

    75 

    76 namespace WebCore {

    77 

    78 using namespace HTMLNames;

    79 

    80 const int maxSavedResults = 256;

    81 

    82 // Constant values for getAllowedValueStep().

    83 static const double dateDefaultStep = 1.0;

    84 static const double dateStepScaleFactor = 86400000.0;

    85 static const double dateTimeDefaultStep = 60.0;

    86 static const double dateTimeStepScaleFactor = 1000.0;

    87 static const double monthDefaultStep = 1.0;

    88 static const double monthStepScaleFactor = 1.0;

    89 static const double numberDefaultStep = 1.0;

    90 static const double numberStepScaleFactor = 1.0;

    91 static const double timeDefaultStep = 60.0;

    92 static const double timeStepScaleFactor = 1000.0;

    93 static const double weekDefaultStep = 1.0;

    94 static const double weekStepScaleFactor = 604800000.0;

    95 

    96 // Constant values for minimum().

    97 static const double numberDefaultMinimum = -DBL_MAX;

    98 static const double rangeDefaultMinimum = 0.0;

    99 

   100 // Constant values for maximum().

   101 static const double numberDefaultMaximum = DBL_MAX;

   102 static const double rangeDefaultMaximum = 100.0;

   103 

   104 static const double defaultStepBase = 0.0;

   105 static const double weekDefaultStepBase = -259200000.0; // The first day of 1970-W01.

   106 

   107 static const double msecPerMinute = 60 * 1000;

   108 static const double msecPerSecond = 1000;

   109 

   110 static bool isNumberCharacter(UChar ch)

   111 {

   112     return ch == '+' || ch == '-' || ch == '.' || ch == 'e' || ch == 'E'

   113         || ch >= '0' && ch <= '9';

   114 }

   115 

   116 HTMLInputElement::HTMLInputElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)

   117     : HTMLTextFormControlElement(tagName, document, form)

   118     , m_xPos(0)

   119     , m_yPos(0)

   120     , m_maxResults(-1)

   121     , m_type(TEXT)

   122     , m_checked(false)

   123     , m_defaultChecked(false)

   124     , m_useDefaultChecked(true)

   125     , m_indeterminate(false)

   126     , m_haveType(false)

   127     , m_activeSubmit(false)

   128     , m_autocomplete(Uninitialized)

   129     , m_autofilled(false)

   130     , m_inited(false)

   131 {

   132     ASSERT(hasTagName(inputTag) || hasTagName(isindexTag));

   133 }

   134 

   135 PassRefPtr<HTMLInputElement> HTMLInputElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form)

   136 {

   137     return adoptRef(new HTMLInputElement(tagName, document, form));

   138 }

   139 

   140 HTMLInputElement::~HTMLInputElement()

   141 {

   142     if (needsActivationCallback())

   143         document()->unregisterForDocumentActivationCallbacks(this);

   144 

   145     document()->checkedRadioButtons().removeButton(this);

   146 

   147     // Need to remove this from the form while it is still an HTMLInputElement,

   148     // so can't wait for the base class's destructor to do it.

   149     removeFromForm();

   150 }

   151 

   152 const AtomicString& HTMLInputElement::formControlName() const

   153 {

   154     return m_data.name();

   155 }

   156 

   157 bool HTMLInputElement::autoComplete() const

   158 {

   159     if (m_autocomplete != Uninitialized)

   160         return m_autocomplete == On;

   161     return HTMLTextFormControlElement::autoComplete();

   162 }

   163 

   164 static inline CheckedRadioButtons& checkedRadioButtons(const HTMLInputElement* element)

   165 {

   166     if (HTMLFormElement* form = element->form())

   167         return form->checkedRadioButtons();

   168     return element->document()->checkedRadioButtons();

   169 }

   170 

   171 void HTMLInputElement::updateCheckedRadioButtons()

   172 {

   173     if (attached() && checked())

   174         checkedRadioButtons(this).addButton(this);

   175 

   176     if (form()) {

   177         const Vector<HTMLFormControlElement*>& controls = form()->associatedElements();

   178         for (unsigned i = 0; i < controls.size(); ++i) {

   179             HTMLFormControlElement* control = controls[i];

   180             if (control->name() != name())

   181                 continue;

   182             if (control->type() != type())

   183                 continue;

   184             control->setNeedsValidityCheck();

   185         }

   186     } else {

   187         // FIXME: Traversing the document is inefficient.

   188         for (Node* node = document()->body(); node; node = node->traverseNextNode()) {

   189             if (!node->isElementNode())

   190                 continue;

   191             Element* element = static_cast<Element*>(node);

   192             if (element->formControlName() != name())

   193                 continue;

   194             if (element->formControlType() != type())

   195                 continue;

   196             HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(element);

   197             if (control->form())

   198                 continue;

   199             control->setNeedsValidityCheck();

   200         }

   201     }

   202    

   203     if (renderer() && renderer()->style()->hasAppearance())

   204         renderer()->theme()->stateChanged(renderer(), CheckedState);

   205 }

   206 

   207 bool HTMLInputElement::valueMissing() const

   208 {

   209     if (!isRequiredFormControl() || readOnly() || disabled())

   210         return false;

   211 

   212     switch (inputType()) {

   213     case DATE:

   214     case DATETIME:

   215     case DATETIMELOCAL:

   216     case EMAIL:

   217     case FILE:

   218     case MONTH:

   219     case NUMBER:

   220     case PASSWORD:

   221     case SEARCH:

   222     case TELEPHONE:

   223     case TEXT:

   224     case TIME:

   225     case URL:

   226     case WEEK:

   227         return value().isEmpty();

   228     case CHECKBOX:

   229         return !checked();

   230     case RADIO:

   231         return !checkedRadioButtons(this).checkedButtonForGroup(name());

   232     case COLOR:

   233         return false;

   234     case BUTTON:

   235     case HIDDEN:

   236     case IMAGE:

   237     case ISINDEX:

   238     case RANGE:

   239     case RESET:

   240     case SUBMIT:

   241         break;

   242     }

   243 

   244     ASSERT_NOT_REACHED();

   245     return false;

   246 }

   247 

   248 bool HTMLInputElement::patternMismatch() const

   249 {

   250     switch (inputType()) {

   251     case BUTTON:

   252     case CHECKBOX:

   253     case COLOR:

   254     case DATE:

   255     case DATETIME:

   256     case DATETIMELOCAL:

   257     case FILE:

   258     case HIDDEN:

   259     case IMAGE:

   260     case ISINDEX:

   261     case MONTH:

   262     case NUMBER:

   263     case RADIO:

   264     case RANGE:

   265     case RESET:

   266     case SUBMIT:

   267     case TIME:

   268     case WEEK:

   269         return false;

   270     case EMAIL:

   271     case PASSWORD:

   272     case SEARCH:

   273     case TELEPHONE:

   274     case TEXT:

   275     case URL:

   276         const AtomicString& pattern = getAttribute(patternAttr);

   277         String value = this->value();

   278          // Empty values can't be mismatched

   279         if (pattern.isEmpty() || value.isEmpty())

   280             return false;

   281         RegularExpression patternRegExp(pattern, TextCaseSensitive);

   282         int matchLength = 0;

   283         int valueLength = value.length();

   284         int matchOffset = patternRegExp.match(value, 0, &matchLength);

   285         return matchOffset || matchLength != valueLength;

   286     }

   287     ASSERT_NOT_REACHED();

   288     return false;

   289 }

   290 

   291 bool HTMLInputElement::tooLong() const

   292 {

   293     switch (inputType()) {

   294     case EMAIL:

   295     case PASSWORD:

   296     case SEARCH:

   297     case TELEPHONE:

   298     case TEXT:

   299     case URL: {

   300         int max = maxLength();

   301         if (max < 0)

   302             return false;

   303         // Return false for the default value even if it is longer than maxLength.

   304         bool userEdited = !m_data.value().isNull();

   305         if (!userEdited)

   306             return false;

   307         return numGraphemeClusters(value()) > static_cast<unsigned>(max);

   308     }

   309     case BUTTON:

   310     case CHECKBOX:

   311     case COLOR:

   312     case DATE:

   313     case DATETIME:

   314     case DATETIMELOCAL:

   315     case FILE:

   316     case HIDDEN:

   317     case IMAGE:

   318     case ISINDEX:

   319     case MONTH:

   320     case NUMBER:

   321     case RADIO:

   322     case RANGE:

   323     case RESET:

   324     case SUBMIT:

   325     case TIME:

   326     case WEEK:

   327         return false;

   328     }

   329     ASSERT_NOT_REACHED();

   330     return false;

   331 }

   332 

   333 bool HTMLInputElement::rangeUnderflow() const

   334 {

   335     const double nan = numeric_limits<double>::quiet_NaN();

   336     switch (inputType()) {

   337     case DATE:

   338     case DATETIME:

   339     case DATETIMELOCAL:

   340     case MONTH:

   341     case NUMBER:

   342     case TIME:

   343     case WEEK: {

   344         double doubleValue = parseToDouble(value(), nan);

   345         return isfinite(doubleValue) && doubleValue < minimum();

   346     }

   347     case RANGE: // Guaranteed by sanitization.

   348         ASSERT(parseToDouble(value(), nan) >= minimum());

   349     case BUTTON:

   350     case CHECKBOX:

   351     case COLOR:

   352     case EMAIL:

   353     case FILE:

   354     case HIDDEN:

   355     case IMAGE:

   356     case ISINDEX:

   357     case PASSWORD:

   358     case RADIO:

   359     case RESET:

   360     case SEARCH:

   361     case SUBMIT:

   362     case TELEPHONE:

   363     case TEXT:

   364     case URL:

   365         break;

   366     }

   367     return false;

   368 }

   369 

   370 bool HTMLInputElement::rangeOverflow() const

   371 {

   372     const double nan = numeric_limits<double>::quiet_NaN();

   373     switch (inputType()) {

   374     case DATE:

   375     case DATETIME:

   376     case DATETIMELOCAL:

   377     case MONTH:

   378     case NUMBER:

   379     case TIME:

   380     case WEEK: {

   381         double doubleValue = parseToDouble(value(), nan);

   382         return isfinite(doubleValue) && doubleValue > maximum();

   383     }

   384     case RANGE: // Guaranteed by sanitization.

   385         ASSERT(parseToDouble(value(), nan) <= maximum());

   386     case BUTTON:

   387     case CHECKBOX:

   388     case COLOR:

   389     case EMAIL:

   390     case FILE:

   391     case HIDDEN:

   392     case IMAGE:

   393     case ISINDEX:

   394     case PASSWORD:

   395     case RADIO:

   396     case RESET:

   397     case SEARCH:

   398     case SUBMIT:

   399     case TELEPHONE:

   400     case TEXT:

   401     case URL:

   402         break;

   403     }

   404     return false;

   405 }

   406 

   407 double HTMLInputElement::minimum() const

   408 {

   409     switch (inputType()) {

   410     case DATE:

   411         return parseToDouble(getAttribute(minAttr), DateComponents::minimumDate());

   412     case DATETIME:

   413     case DATETIMELOCAL:

   414         return parseToDouble(getAttribute(minAttr), DateComponents::minimumDateTime());

   415     case MONTH:

   416         return parseToDouble(getAttribute(minAttr), DateComponents::minimumMonth());

   417     case NUMBER:

   418         return parseToDouble(getAttribute(minAttr), numberDefaultMinimum);

   419     case RANGE:

   420         return parseToDouble(getAttribute(minAttr), rangeDefaultMinimum);

   421     case TIME:

   422         return parseToDouble(getAttribute(minAttr), DateComponents::minimumTime());

   423     case WEEK:

   424         return parseToDouble(getAttribute(minAttr), DateComponents::minimumWeek());

   425     case BUTTON:

   426     case CHECKBOX:

   427     case COLOR:

   428     case EMAIL:

   429     case FILE:

   430     case HIDDEN:

   431     case IMAGE:

   432     case ISINDEX:

   433     case PASSWORD:

   434     case RADIO:

   435     case RESET:

   436     case SEARCH:

   437     case SUBMIT:

   438     case TELEPHONE:

   439     case TEXT:

   440     case URL:

   441         break;

   442     }

   443     ASSERT_NOT_REACHED();

   444     return 0;

   445 }

   446 

   447 double HTMLInputElement::maximum() const

   448 {

   449     switch (inputType()) {

   450     case DATE:

   451         return parseToDouble(getAttribute(maxAttr), DateComponents::maximumDate());

   452     case DATETIME:

   453     case DATETIMELOCAL:

   454         return parseToDouble(getAttribute(maxAttr), DateComponents::maximumDateTime());

   455     case MONTH:

   456         return parseToDouble(getAttribute(maxAttr), DateComponents::maximumMonth());

   457     case NUMBER:

   458         return parseToDouble(getAttribute(maxAttr), numberDefaultMaximum);

   459     case RANGE: {

   460         double max = parseToDouble(getAttribute(maxAttr), rangeDefaultMaximum);

   461         // A remedy for the inconsistent min/max values for RANGE.

   462         // Sets the maximum to the default or the minimum value.

   463         double min = minimum();

   464         if (max < min)

   465             max = std::max(min, rangeDefaultMaximum);

   466         return max;

   467     }

   468     case TIME:

   469         return parseToDouble(getAttribute(maxAttr), DateComponents::maximumTime());

   470     case WEEK:

   471         return parseToDouble(getAttribute(maxAttr), DateComponents::maximumWeek());

   472     case BUTTON:

   473     case CHECKBOX:

   474     case COLOR:

   475     case EMAIL:

   476     case FILE:

   477     case HIDDEN:

   478     case IMAGE:

   479     case ISINDEX:

   480     case PASSWORD:

   481     case RADIO:

   482     case RESET:

   483     case SEARCH:

   484     case SUBMIT:

   485     case TELEPHONE:

   486     case TEXT:

   487     case URL:

   488         break;

   489     }

   490     ASSERT_NOT_REACHED();

   491     return 0;

   492 }

   493 

   494 double HTMLInputElement::stepBase() const

   495 {

   496     switch (inputType()) {

   497     case RANGE:

   498         return minimum();

   499     case DATE:

   500     case DATETIME:

   501     case DATETIMELOCAL:

   502     case MONTH:

   503     case NUMBER:

   504     case TIME:

   505         return parseToDouble(getAttribute(minAttr), defaultStepBase);

   506     case WEEK:

   507         return parseToDouble(getAttribute(minAttr), weekDefaultStepBase);

   508     case BUTTON:

   509     case CHECKBOX:

   510     case COLOR:

   511     case EMAIL:

   512     case FILE:

   513     case HIDDEN:

   514     case IMAGE:

   515     case ISINDEX:

   516     case PASSWORD:

   517     case RADIO:

   518     case RESET:

   519     case SEARCH:

   520     case SUBMIT:

   521     case TELEPHONE:

   522     case TEXT:

   523     case URL:

   524         break;

   525     }

   526     ASSERT_NOT_REACHED();

   527     return 0.0;

   528 }

   529 

   530 bool HTMLInputElement::stepMismatch() const

   531 {

   532     double step;

   533     if (!getAllowedValueStep(&step))

   534         return false;

   535     switch (inputType()) {

   536     case RANGE:

   537         // stepMismatch doesn't occur for RANGE. RenderSlider guarantees the

   538         // value matches to step on user input, and sanitation takes care

   539         // of the general case.

   540         return false;

   541     case NUMBER: {

   542         double doubleValue;

   543         if (!parseToDoubleForNumberType(value(), &doubleValue))

   544             return false;

   545         doubleValue = fabs(doubleValue - stepBase());

   546         if (isinf(doubleValue))

   547             return false;

   548         // double's fractional part size is DBL_MAN_DIG-bit.  If the current

   549         // value is greater than step*2^DBL_MANT_DIG, the following fmod() makes

   550         // no sense.

   551         if (doubleValue / pow(2.0, DBL_MANT_DIG) > step)

   552             return false;

   553         double remainder = fmod(doubleValue, step);

   554         // Accepts errors in lower 7-bit.

   555         double acceptableError = step / pow(2.0, DBL_MANT_DIG - 7);

   556         return acceptableError < remainder && remainder < (step - acceptableError);

   557     }

   558     case DATE:

   559     case DATETIME:

   560     case DATETIMELOCAL:

   561     case MONTH:

   562     case TIME:

   563     case WEEK: {

   564         const double nan = numeric_limits<double>::quiet_NaN();

   565         double doubleValue = parseToDouble(value(), nan);

   566         doubleValue = fabs(doubleValue - stepBase());

   567         if (!isfinite(doubleValue))

   568             return false;

   569         ASSERT(round(doubleValue) == doubleValue);

   570         ASSERT(round(step) == step);

   571         return fmod(doubleValue, step);

   572     }

   573     case BUTTON:

   574     case CHECKBOX:

   575     case COLOR:

   576     case EMAIL:

   577     case FILE:

   578     case HIDDEN:

   579     case IMAGE:

   580     case ISINDEX:

   581     case PASSWORD:

   582     case RADIO:

   583     case RESET:

   584     case SEARCH:

   585     case SUBMIT:

   586     case TELEPHONE:

   587     case TEXT:

   588     case URL:

   589         break;

   590     }

   591     // Non-supported types should be rejected by getAllowedValueStep().

   592     ASSERT_NOT_REACHED();

   593     return false;

   594 }

   595 

   596 bool HTMLInputElement::getStepParameters(double* defaultStep, double* stepScaleFactor) const

   597 {

   598     ASSERT(defaultStep);

   599     ASSERT(stepScaleFactor);

   600     switch (inputType()) {

   601     case NUMBER:

   602     case RANGE:

   603         *defaultStep = numberDefaultStep;

   604         *stepScaleFactor = numberStepScaleFactor;

   605         return true;

   606     case DATE:

   607         *defaultStep = dateDefaultStep;

   608         *stepScaleFactor = dateStepScaleFactor;

   609         return true;

   610     case DATETIME:

   611     case DATETIMELOCAL:

   612         *defaultStep = dateTimeDefaultStep;

   613         *stepScaleFactor = dateTimeStepScaleFactor;

   614         return true;

   615     case MONTH:

   616         *defaultStep = monthDefaultStep;

   617         *stepScaleFactor = monthStepScaleFactor;

   618         return true;

   619     case TIME:

   620         *defaultStep = timeDefaultStep;

   621         *stepScaleFactor = timeStepScaleFactor;

   622         return true;

   623     case WEEK:

   624         *defaultStep = weekDefaultStep;

   625         *stepScaleFactor = weekStepScaleFactor;

   626         return true;

   627     case BUTTON:

   628     case CHECKBOX:

   629     case COLOR:

   630     case EMAIL:

   631     case FILE:

   632     case HIDDEN:

   633     case IMAGE:

   634     case ISINDEX:

   635     case PASSWORD:

   636     case RADIO:

   637     case RESET:

   638     case SEARCH:

   639     case SUBMIT:

   640     case TELEPHONE:

   641     case TEXT:

   642     case URL:

   643         return false;

   644     }

   645     ASSERT_NOT_REACHED();

   646     return false;

   647 }

   648 

   649 bool HTMLInputElement::getAllowedValueStep(double* step) const

   650 {

   651     ASSERT(step);

   652     double defaultStep;

   653     double stepScaleFactor;

   654     if (!getStepParameters(&defaultStep, &stepScaleFactor))

   655         return false;

   656     const AtomicString& stepString = getAttribute(stepAttr);

   657     if (stepString.isEmpty()) {

   658         *step = defaultStep * stepScaleFactor;

   659         return true;

   660     }

   661     if (equalIgnoringCase(stepString, "any"))

   662         return false;

   663     double parsed;

   664     if (!parseToDoubleForNumberType(stepString, &parsed) || parsed <= 0.0) {

   665         *step = defaultStep * stepScaleFactor;

   666         return true;

   667     }

   668     // For DATE, MONTH, WEEK, the parsed value should be an integer.

   669     if (inputType() == DATE || inputType() == MONTH || inputType() == WEEK)

   670         parsed = max(round(parsed), 1.0);

   671     double result = parsed * stepScaleFactor;

   672     // For DATETIME, DATETIMELOCAL, TIME, the result should be an integer.

   673     if (inputType() == DATETIME || inputType() == DATETIMELOCAL || inputType() == TIME)

   674         result = max(round(result), 1.0);

   675     ASSERT(result > 0);

   676     *step = result;

   677     return true;

   678 }

   679 

   680 void HTMLInputElement::applyStep(double count, ExceptionCode& ec)

   681 {

   682     double step;

   683     if (!getAllowedValueStep(&step)) {

   684         ec = INVALID_STATE_ERR;

   685         return;

   686     }

   687     const double nan = numeric_limits<double>::quiet_NaN();

   688     double current = parseToDouble(value(), nan);

   689     if (!isfinite(current)) {

   690         ec = INVALID_STATE_ERR;

   691         return;

   692     }

   693     double newValue = current + step * count;

   694     if (isinf(newValue)) {

   695         ec = INVALID_STATE_ERR;

   696         return;

   697     }

   698     if (newValue < minimum()) {

   699         ec = INVALID_STATE_ERR;

   700         return;

   701     }

   702     double base = stepBase();

   703     newValue = base + round((newValue - base) / step) * step;

   704     if (newValue > maximum()) {

   705         ec = INVALID_STATE_ERR;

   706         return;

   707     }

   708     setValueAsNumber(newValue, ec);

   709 }

   710 

   711 void HTMLInputElement::stepUp(int n, ExceptionCode& ec)

   712 {

   713     applyStep(n, ec);

   714 }

   715 

   716 void HTMLInputElement::stepDown(int n, ExceptionCode& ec)

   717 {

   718     applyStep(-n, ec);

   719 }

   720 

   721 bool HTMLInputElement::isKeyboardFocusable(KeyboardEvent* event) const

   722 {

   723     // If text fields can be focused, then they should always be keyboard focusable

   724     if (isTextField())

   725         return HTMLFormControlElementWithState::isFocusable();

   726         

   727     // If the base class says we can't be focused, then we can stop now.

   728     if (!HTMLFormControlElementWithState::isKeyboardFocusable(event))

   729         return false;

   730 

   731     if (inputType() == RADIO) {

   732 

   733         // Never allow keyboard tabbing to leave you in the same radio group.  Always

   734         // skip any other elements in the group.

   735         Node* currentFocusedNode = document()->focusedNode();

   736         if (currentFocusedNode && currentFocusedNode->hasTagName(inputTag)) {

   737             HTMLInputElement* focusedInput = static_cast<HTMLInputElement*>(currentFocusedNode);

   738             if (focusedInput->inputType() == RADIO && focusedInput->form() == form() && focusedInput->name() == name())

   739                 return false;

   740         }

   741         

   742         // Allow keyboard focus if we're checked or if nothing in the group is checked.

   743         return checked() || !checkedRadioButtons(this).checkedButtonForGroup(name());

   744     }

   745     

   746     return true;

   747 }

   748 

   749 bool HTMLInputElement::isMouseFocusable() const

   750 {

   751     if (isTextField())

   752         return HTMLFormControlElementWithState::isFocusable();

   753     return HTMLFormControlElementWithState::isMouseFocusable();

   754 }

   755 

   756 void HTMLInputElement::updateFocusAppearance(bool restorePreviousSelection)

   757 {        

   758     if (isTextField())

   759         InputElement::updateFocusAppearance(m_data, this, this, restorePreviousSelection);

   760     else

   761         HTMLFormControlElementWithState::updateFocusAppearance(restorePreviousSelection);

   762 }

   763 

   764 void HTMLInputElement::aboutToUnload()

   765 {

   766     InputElement::aboutToUnload(this, this);

   767 }

   768 

   769 bool HTMLInputElement::shouldUseInputMethod() const

   770 {

   771     // The reason IME's are disabled for the password field is because IMEs 

   772     // can access the underlying password and display it in clear text --

   773     // e.g. you can use it to access the stored password for any site 

   774     // with only trivial effort.

   775     return isTextField() && inputType() != PASSWORD;

   776 }

   777 

   778 void HTMLInputElement::handleFocusEvent()

   779 {

   780     InputElement::dispatchFocusEvent(this, this);

   781 }

   782 

   783 void HTMLInputElement::handleBlurEvent()

   784 {

   785     InputElement::dispatchBlurEvent(this, this);

   786 }

   787 

   788 void HTMLInputElement::setType(const String& t)

   789 {

   790     if (t.isEmpty()) {

   791         int exccode;

   792         removeAttribute(typeAttr, exccode);

   793     } else

   794         setAttribute(typeAttr, t);

   795 }

   796 

   797 typedef HashMap<String, HTMLInputElement::InputType, CaseFoldingHash> InputTypeMap;

   798 static const InputTypeMap* createTypeMap()

   799 {

   800     InputTypeMap* map = new InputTypeMap;

   801     map->add("button", HTMLInputElement::BUTTON);

   802     map->add("checkbox", HTMLInputElement::CHECKBOX);

   803     map->add("color", HTMLInputElement::COLOR);

   804     map->add("date", HTMLInputElement::DATE);

   805     map->add("datetime", HTMLInputElement::DATETIME);

   806     map->add("datetime-local", HTMLInputElement::DATETIMELOCAL);

   807     map->add("email", HTMLInputElement::EMAIL);

   808     map->add("file", HTMLInputElement::FILE);

   809     map->add("hidden", HTMLInputElement::HIDDEN);

   810     map->add("image", HTMLInputElement::IMAGE);

   811     map->add("khtml_isindex", HTMLInputElement::ISINDEX);

   812     map->add("month", HTMLInputElement::MONTH);

   813     map->add("number", HTMLInputElement::NUMBER);

   814     map->add("password", HTMLInputElement::PASSWORD);

   815     map->add("radio", HTMLInputElement::RADIO);

   816     map->add("range", HTMLInputElement::RANGE);

   817     map->add("reset", HTMLInputElement::RESET);

   818     map->add("search", HTMLInputElement::SEARCH);

   819     map->add("submit", HTMLInputElement::SUBMIT);

   820     map->add("tel", HTMLInputElement::TELEPHONE);

   821     map->add("time", HTMLInputElement::TIME);

   822     map->add("url", HTMLInputElement::URL);

   823     map->add("week", HTMLInputElement::WEEK);

   824     // No need to register "text" because it is the default type.

   825     return map;

   826 }

   827 

   828 void HTMLInputElement::setInputType(const String& t)

   829 {

   830     static const InputTypeMap* typeMap = createTypeMap();

   831     InputType newType = t.isNull() ? TEXT : typeMap->get(t);

   832 

   833     // IMPORTANT: Don't allow the type to be changed to FILE after the first

   834     // type change, otherwise a JavaScript programmer would be able to set a text

   835     // field's value to something like /etc/passwd and then change it to a file field.

   836     if (inputType() != newType) {

   837         if (newType == FILE && m_haveType)

   838             // Set the attribute back to the old value.

   839             // Useful in case we were called from inside parseMappedAttribute.

   840             setAttribute(typeAttr, type());

   841         else {

   842             checkedRadioButtons(this).removeButton(this);

   843 

   844             if (newType == FILE && !m_fileList)

   845                 m_fileList = FileList::create();

   846 

   847             bool wasAttached = attached();

   848             if (wasAttached)

   849                 detach();

   850 

   851             bool didStoreValue = storesValueSeparateFromAttribute();

   852             bool wasPasswordField = inputType() == PASSWORD;

   853             bool didRespectHeightAndWidth = respectHeightAndWidthAttrs();

   854             m_type = newType;

   855             setNeedsWillValidateCheck();

   856             bool willStoreValue = storesValueSeparateFromAttribute();

   857             bool isPasswordField = inputType() == PASSWORD;

   858             bool willRespectHeightAndWidth = respectHeightAndWidthAttrs();

   859 

   860             if (didStoreValue && !willStoreValue && !m_data.value().isNull()) {

   861                 setAttribute(valueAttr, m_data.value());

   862                 m_data.setValue(String());

   863             }

   864             if (!didStoreValue && willStoreValue)

   865                 m_data.setValue(sanitizeValue(getAttribute(valueAttr)));

   866             else

   867                 InputElement::updateValueIfNeeded(m_data, this);

   868 

   869             if (wasPasswordField && !isPasswordField)

   870                 unregisterForActivationCallbackIfNeeded();

   871             else if (!wasPasswordField && isPasswordField)

   872                 registerForActivationCallbackIfNeeded();

   873 

   874             if (didRespectHeightAndWidth != willRespectHeightAndWidth) {

   875                 NamedNodeMap* map = attributeMap();

   876                 ASSERT(map);

   877                 if (Attribute* height = map->getAttributeItem(heightAttr))

   878                     attributeChanged(height, false);

   879                 if (Attribute* width = map->getAttributeItem(widthAttr))

   880                     attributeChanged(width, false);

   881                 if (Attribute* align = map->getAttributeItem(alignAttr))

   882                     attributeChanged(align, false);

   883             }

   884 

   885             if (wasAttached) {

   886                 attach();

   887                 if (document()->focusedNode() == this)

   888                     updateFocusAppearance(true);

   889             }

   890 

   891             checkedRadioButtons(this).addButton(this);

   892         }

   893 

   894         setNeedsValidityCheck();

   895         InputElement::notifyFormStateChanged(this);

   896     }

   897     m_haveType = true;

   898 

   899     if (inputType() != IMAGE && m_imageLoader)

   900         m_imageLoader.clear();

   901 }

   902 

   903 static const AtomicString* createFormControlTypes()

   904 {

   905     AtomicString* types = new AtomicString[HTMLInputElement::numberOfTypes];

   906     // The values must be lowercased because they will be the return values of

   907     //  input.type and it must be lowercase according to DOM Level 2.

   908     types[HTMLInputElement::BUTTON] = "button";

   909     types[HTMLInputElement::CHECKBOX] = "checkbox";

   910     types[HTMLInputElement::COLOR] = "color";

   911     types[HTMLInputElement::DATE] = "date";

   912     types[HTMLInputElement::DATETIME] = "datetime";

   913     types[HTMLInputElement::DATETIMELOCAL] = "datetime-local";

   914     types[HTMLInputElement::EMAIL] = "email";

   915     types[HTMLInputElement::FILE] = "file";

   916     types[HTMLInputElement::HIDDEN] = "hidden";

   917     types[HTMLInputElement::IMAGE] = "image";

   918     types[HTMLInputElement::ISINDEX] = emptyAtom;

   919     types[HTMLInputElement::MONTH] = "month";

   920     types[HTMLInputElement::NUMBER] = "number";

   921     types[HTMLInputElement::PASSWORD] = "password";

   922     types[HTMLInputElement::RADIO] = "radio";

   923     types[HTMLInputElement::RANGE] = "range";

   924     types[HTMLInputElement::RESET] = "reset";

   925     types[HTMLInputElement::SEARCH] = "search";

   926     types[HTMLInputElement::SUBMIT] = "submit";

   927     types[HTMLInputElement::TELEPHONE] = "tel";

   928     types[HTMLInputElement::TEXT] = "text";

   929     types[HTMLInputElement::TIME] = "time";

   930     types[HTMLInputElement::URL] = "url";

   931     types[HTMLInputElement::WEEK] = "week";

   932     return types;

   933 }

   934 

   935 const AtomicString& HTMLInputElement::formControlType() const

   936 {

   937     static const AtomicString* formControlTypes = createFormControlTypes();

   938     return formControlTypes[inputType()];

   939 }

   940 

   941 bool HTMLInputElement::saveFormControlState(String& result) const

   942 {

   943     switch (inputType()) {

   944     case BUTTON:

   945     case COLOR:

   946     case DATE:

   947     case DATETIME:

   948     case DATETIMELOCAL:

   949     case EMAIL:

   950     case FILE:

   951     case HIDDEN:

   952     case IMAGE:

   953     case ISINDEX:

   954     case MONTH:

   955     case NUMBER:

   956     case RANGE:

   957     case RESET:

   958     case SEARCH:

   959     case SUBMIT:

   960     case TELEPHONE:

   961     case TEXT:

   962     case TIME:

   963     case URL:

   964     case WEEK: {

   965         String currentValue = value();

   966         if (currentValue == defaultValue())

   967             return false;

   968         result = currentValue;

   969         return true;

   970     }

   971     case CHECKBOX:

   972     case RADIO:

   973         result = checked() ? "on" : "off";

   974         return true;

   975     case PASSWORD:

   976         return false;

   977     }

   978     ASSERT_NOT_REACHED();

   979     return false;

   980 }

   981 

   982 void HTMLInputElement::restoreFormControlState(const String& state)

   983 {

   984     ASSERT(inputType() != PASSWORD); // should never save/restore password fields

   985     switch (inputType()) {

   986     case BUTTON:

   987     case COLOR:

   988     case DATE:

   989     case DATETIME:

   990     case DATETIMELOCAL:

   991     case EMAIL:

   992     case FILE:

   993     case HIDDEN:

   994     case IMAGE:

   995     case ISINDEX:

   996     case MONTH:

   997     case NUMBER:

   998     case RANGE:

   999     case RESET:

  1000     case SEARCH:

  1001     case SUBMIT:

  1002     case TELEPHONE:

  1003     case TEXT:

  1004     case TIME:

  1005     case URL:

  1006     case WEEK:

  1007         setValue(state);

  1008         break;

  1009     case CHECKBOX:

  1010     case RADIO:

  1011         setChecked(state == "on");

  1012         break;

  1013     case PASSWORD:

  1014         break;

  1015     }

  1016 }

  1017 

  1018 bool HTMLInputElement::canStartSelection() const

  1019 {

  1020     if (!isTextField())

  1021         return false;

  1022     return HTMLFormControlElementWithState::canStartSelection();

  1023 }

  1024 

  1025 bool HTMLInputElement::canHaveSelection() const

  1026 {

  1027     return isTextField();

  1028 }

  1029 

  1030 void HTMLInputElement::accessKeyAction(bool sendToAnyElement)

  1031 {

  1032     switch (inputType()) {

  1033     case BUTTON:

  1034     case CHECKBOX:

  1035     case FILE:

  1036     case IMAGE:

  1037     case RADIO:

  1038     case RANGE:

  1039     case RESET:

  1040     case SUBMIT:

  1041         focus(false);

  1042         // send the mouse button events iff the caller specified sendToAnyElement

  1043         dispatchSimulatedClick(0, sendToAnyElement);

  1044         break;

  1045     case HIDDEN:

  1046         // a no-op for this type

  1047         break;

  1048     case COLOR:

  1049     case DATE:

  1050     case DATETIME:

  1051     case DATETIMELOCAL:

  1052     case EMAIL:

  1053     case ISINDEX:

  1054     case MONTH:

  1055     case NUMBER:

  1056     case PASSWORD:

  1057     case SEARCH:

  1058     case TELEPHONE:

  1059     case TEXT:

  1060     case TIME:

  1061     case URL:

  1062     case WEEK:

  1063         // should never restore previous selection here

  1064         focus(false);

  1065          break;

  1066     }

  1067 }

  1068 

  1069 bool HTMLInputElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const

  1070 {

  1071     if (((attrName == heightAttr || attrName == widthAttr) && respectHeightAndWidthAttrs())

  1072         || attrName == vspaceAttr 

  1073         || attrName == hspaceAttr) {

  1074         result = eUniversal;

  1075         return false;

  1076     } 

  1077 

  1078     if (attrName == alignAttr) {

  1079         if (inputType() == IMAGE) {

  1080             // Share with <img> since the alignment behavior is the same.

  1081             result = eReplaced;

  1082             return false;

  1083         }

  1084     }

  1085 

  1086     return HTMLElement::mapToEntry(attrName, result);

  1087 }

  1088 

  1089 void HTMLInputElement::parseMappedAttribute(Attribute* attr)

  1090 {

  1091     if (attr->name() == nameAttr) {

  1092         checkedRadioButtons(this).removeButton(this);

  1093         m_data.setName(attr->value());

  1094         checkedRadioButtons(this).addButton(this);

  1095         HTMLFormControlElementWithState::parseMappedAttribute(attr);

  1096     } else if (attr->name() == autocompleteAttr) {

  1097         if (equalIgnoringCase(attr->value(), "off")) {

  1098             m_autocomplete = Off;

  1099             registerForActivationCallbackIfNeeded();

  1100         } else {

  1101             bool needsToUnregister = m_autocomplete == Off;

  1102 

  1103             if (attr->isEmpty())

  1104                 m_autocomplete = Uninitialized;

  1105             else

  1106                 m_autocomplete = On;

  1107 

  1108             if (needsToUnregister)

  1109                 unregisterForActivationCallbackIfNeeded();

  1110         }

  1111     } else if (attr->name() == typeAttr) {

  1112         setInputType(attr->value());

  1113     } else if (attr->name() == valueAttr) {

  1114         // We only need to setChanged if the form is looking at the default value right now.

  1115         if (m_data.value().isNull())

  1116             setNeedsStyleRecalc();

  1117         setFormControlValueMatchesRenderer(false);

  1118         setNeedsValidityCheck();

  1119     } else if (attr->name() == checkedAttr) {

  1120         m_defaultChecked = !attr->isNull();

  1121         if (m_useDefaultChecked) {

  1122             setChecked(m_defaultChecked);

  1123             m_useDefaultChecked = true;

  1124         }

  1125         setNeedsValidityCheck();

  1126     } else if (attr->name() == maxlengthAttr) {

  1127         InputElement::parseMaxLengthAttribute(m_data, this, this, attr);

  1128         setNeedsValidityCheck();

  1129     } else if (attr->name() == sizeAttr)

  1130         InputElement::parseSizeAttribute(m_data, this, attr);

  1131     else if (attr->name() == altAttr) {

  1132         if (renderer() && inputType() == IMAGE)

  1133             toRenderImage(renderer())->updateAltText();

  1134     } else if (attr->name() == srcAttr) {

  1135         if (renderer() && inputType() == IMAGE) {