--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebCore/bindings/js/JSHTMLInputElementBase.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2006 Apple Computer, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "JSHTMLInputElementBase.h"
+
+#include "HTMLInputElement.h"
+
+#include "JSHTMLInputElementBaseTable.cpp"
+
+using namespace KJS;
+
+namespace WebCore {
+
+/*
+@begin JSHTMLInputElementBaseTable 3
+  selectionStart        WebCore::JSHTMLInputElementBase::SelectionStart            DontDelete
+  selectionEnd          WebCore::JSHTMLInputElementBase::SelectionEnd              DontDelete
+@end
+@begin JSHTMLInputElementBasePrototypeTable 0
+@end
+@begin JSHTMLInputElementBaseFunctionTable 1
+  setSelectionRange     WebCore::JSHTMLInputElementBase::SetSelectionRange         DontDelete|Function 2
+@end
+*/
+
+KJS_IMPLEMENT_PROTOTYPE_FUNCTION(JSHTMLInputElementBasePrototypeFunction)
+KJS_IMPLEMENT_PROTOTYPE("JSHTMLInputElementBase", JSHTMLInputElementBasePrototype, JSHTMLInputElementBasePrototypeFunction)
+
+JSValue* JSHTMLInputElementBasePrototypeFunction::callAsFunction(ExecState*, JSObject*, const List&)
+{
+    return 0;
+}
+
+// SetSelectionRange is implemented on the class instead of on the prototype
+// to make it easier to enable/disable lookup of the function based on input type.
+class JSHTMLInputElementBaseFunction : public InternalFunctionImp {
+public:
+    JSHTMLInputElementBaseFunction(ExecState*, int i, int len, const Identifier& name);
+    virtual JSValue *callAsFunction(ExecState*, JSObject* thisObj, const List& args);
+private:
+    int m_id;
+};
+
+JSHTMLInputElementBaseFunction::JSHTMLInputElementBaseFunction(ExecState* exec, int i, int len, const Identifier& name)
+    : InternalFunctionImp(static_cast<FunctionPrototype*>(exec->lexicalInterpreter()->builtinFunctionPrototype()), name)
+    , m_id(i)
+{
+    put(exec, exec->propertyNames().length, jsNumber(len), DontDelete|ReadOnly|DontEnum);
+}
+
+JSValue* JSHTMLInputElementBaseFunction::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
+{
+    HTMLInputElement& input = *static_cast<HTMLInputElement*>(static_cast<JSHTMLInputElementBase*>(thisObj)->impl());
+    if (m_id == JSHTMLInputElementBase::SetSelectionRange) {
+        input.setSelectionRange(args[0]->toInt32(exec), args[1]->toInt32(exec));
+        return jsUndefined();
+    }
+    return jsUndefined();
+}
+
+const ClassInfo JSHTMLInputElementBase::info = { "JSHTMLInputElementBase", &JSHTMLElement::info, &JSHTMLInputElementBaseTable, 0 };
+
+JSHTMLInputElementBase::JSHTMLInputElementBase(ExecState* exec, PassRefPtr<HTMLInputElement> e)
+    : JSHTMLElement(exec, e.get())
+{
+    // We don't really need a prototype, just use our parent class's prototype
+    setPrototype(JSHTMLElementPrototype::self(exec));
+}
+
+bool JSHTMLInputElementBase::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    HTMLInputElement& input = *static_cast<HTMLInputElement*>(impl());
+    
+    // if this element doesn't support selection, we have nothing to do, try our parent
+    if (!input.canHaveSelection())
+        return JSHTMLElement::getOwnPropertySlot(exec, propertyName, slot);
+    
+    // otherwise, do our own function lookup on our function table
+    const HashEntry* entry = Lookup::findEntry(&JSHTMLInputElementBaseFunctionTable, propertyName);
+    if (entry && (entry->value == SetSelectionRange)) {
+        slot.setStaticEntry(this, entry, staticFunctionGetter<JSHTMLInputElementBaseFunction>); 
+        return true;
+    }
+    ASSERT(!entry);
+    
+    // finally try value lookup or walk the parent chain
+    return getStaticValueSlot<JSHTMLInputElementBase, JSHTMLElement>(exec, &JSHTMLInputElementBaseTable, this, propertyName, slot);
+}
+
+JSValue* JSHTMLInputElementBase::getValueProperty(ExecState* exec, int token) const
+{
+    HTMLInputElement& input = *static_cast<HTMLInputElement*>(impl());
+    ASSERT(input.canHaveSelection());
+    switch (token) {
+    case SelectionStart:
+        return jsNumber(input.selectionStart());
+    case SelectionEnd:
+        return jsNumber(input.selectionEnd());
+    }
+    ASSERT_NOT_REACHED();
+    return jsUndefined();
+}
+
+void JSHTMLInputElementBase::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attr)
+{
+    lookupPut<JSHTMLInputElementBase, JSHTMLElement>(exec, propertyName, value, attr, &JSHTMLInputElementBaseTable, this);
+}
+
+void JSHTMLInputElementBase::putValueProperty(ExecState* exec, int token, JSValue* value, int /*attr*/)
+{
+    HTMLInputElement& input = *static_cast<HTMLInputElement*>(impl());
+    ASSERT(input.canHaveSelection());
+    switch (token) {
+    case SelectionStart:
+        input.setSelectionStart(value->toInt32(exec));
+        return;
+    case SelectionEnd:
+        input.setSelectionEnd(value->toInt32(exec));
+        return;
+    }
+    ASSERT_NOT_REACHED();
+}
+
+} // namespace WebCore