Unreviewed. Fix the GTK+ build after r205524.
[WebKit-https.git] / Source / WebKit2 / WebProcess / InjectedBundle / API / gtk / DOM / WebKitDOMHTMLInputElement.cpp
1 /*
2  *  This file is part of the WebKit open source project.
3  *  This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Library General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Library General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Library General Public License
16  *  along with this library; see the file COPYING.LIB.  If not, write to
17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  *  Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "WebKitDOMHTMLInputElement.h"
23
24 #include <WebCore/CSSImportRule.h>
25 #include "DOMObjectCache.h"
26 #include <WebCore/Document.h>
27 #include <WebCore/ExceptionCode.h>
28 #include <WebCore/ExceptionCodeDescription.h>
29 #include "GObjectEventListener.h"
30 #include <WebCore/HTMLNames.h>
31 #include <WebCore/JSMainThreadExecState.h>
32 #include "WebKitDOMEventPrivate.h"
33 #include "WebKitDOMEventTarget.h"
34 #include "WebKitDOMFileListPrivate.h"
35 #include "WebKitDOMHTMLElementPrivate.h"
36 #include "WebKitDOMHTMLFormElementPrivate.h"
37 #include "WebKitDOMHTMLInputElementPrivate.h"
38 #include "WebKitDOMNodeListPrivate.h"
39 #include "WebKitDOMNodePrivate.h"
40 #include "WebKitDOMPrivate.h"
41 #include "WebKitDOMValidityStatePrivate.h"
42 #include "ConvertToUTF8String.h"
43 #include "WebKitDOMHTMLInputElementUnstable.h"
44 #include <wtf/GetPtr.h>
45 #include <wtf/RefPtr.h>
46
47 namespace WebKit {
48
49 WebKitDOMHTMLInputElement* kit(WebCore::HTMLInputElement* obj)
50 {
51     return WEBKIT_DOM_HTML_INPUT_ELEMENT(kit(static_cast<WebCore::Node*>(obj)));
52 }
53
54 WebCore::HTMLInputElement* core(WebKitDOMHTMLInputElement* request)
55 {
56     return request ? static_cast<WebCore::HTMLInputElement*>(WEBKIT_DOM_OBJECT(request)->coreObject) : 0;
57 }
58
59 WebKitDOMHTMLInputElement* wrapHTMLInputElement(WebCore::HTMLInputElement* coreObject)
60 {
61     ASSERT(coreObject);
62     return WEBKIT_DOM_HTML_INPUT_ELEMENT(g_object_new(WEBKIT_DOM_TYPE_HTML_INPUT_ELEMENT, "core-object", coreObject, nullptr));
63 }
64
65 } // namespace WebKit
66
67 static gboolean webkit_dom_html_input_element_dispatch_event(WebKitDOMEventTarget* target, WebKitDOMEvent* event, GError** error)
68 {
69     WebCore::Event* coreEvent = WebKit::core(event);
70     if (!coreEvent)
71         return false;
72     WebCore::HTMLInputElement* coreTarget = static_cast<WebCore::HTMLInputElement*>(WEBKIT_DOM_OBJECT(target)->coreObject);
73
74     WebCore::ExceptionCode ec = 0;
75     gboolean result = coreTarget->dispatchEventForBindings(*coreEvent, ec);
76     if (ec) {
77         WebCore::ExceptionCodeDescription description(ec);
78         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), description.code, description.name);
79     }
80     return result;
81 }
82
83 static gboolean webkit_dom_html_input_element_add_event_listener(WebKitDOMEventTarget* target, const char* eventName, GClosure* handler, gboolean useCapture)
84 {
85     WebCore::HTMLInputElement* coreTarget = static_cast<WebCore::HTMLInputElement*>(WEBKIT_DOM_OBJECT(target)->coreObject);
86     return WebKit::GObjectEventListener::addEventListener(G_OBJECT(target), coreTarget, eventName, handler, useCapture);
87 }
88
89 static gboolean webkit_dom_html_input_element_remove_event_listener(WebKitDOMEventTarget* target, const char* eventName, GClosure* handler, gboolean useCapture)
90 {
91     WebCore::HTMLInputElement* coreTarget = static_cast<WebCore::HTMLInputElement*>(WEBKIT_DOM_OBJECT(target)->coreObject);
92     return WebKit::GObjectEventListener::removeEventListener(G_OBJECT(target), coreTarget, eventName, handler, useCapture);
93 }
94
95 static void webkit_dom_event_target_init(WebKitDOMEventTargetIface* iface)
96 {
97     iface->dispatch_event = webkit_dom_html_input_element_dispatch_event;
98     iface->add_event_listener = webkit_dom_html_input_element_add_event_listener;
99     iface->remove_event_listener = webkit_dom_html_input_element_remove_event_listener;
100 }
101
102 G_DEFINE_TYPE_WITH_CODE(WebKitDOMHTMLInputElement, webkit_dom_html_input_element, WEBKIT_DOM_TYPE_HTML_ELEMENT, G_IMPLEMENT_INTERFACE(WEBKIT_DOM_TYPE_EVENT_TARGET, webkit_dom_event_target_init))
103
104 enum {
105     PROP_0,
106     PROP_ACCEPT,
107     PROP_ALT,
108     PROP_AUTOCOMPLETE,
109     PROP_AUTOFOCUS,
110     PROP_DEFAULT_CHECKED,
111     PROP_CHECKED,
112     PROP_DIR_NAME,
113     PROP_DISABLED,
114     PROP_FORM,
115     PROP_FILES,
116     PROP_FORM_ACTION,
117     PROP_FORM_ENCTYPE,
118     PROP_FORM_METHOD,
119     PROP_FORM_NO_VALIDATE,
120     PROP_FORM_TARGET,
121     PROP_HEIGHT,
122     PROP_INDETERMINATE,
123     PROP_LIST,
124     PROP_MAX,
125     PROP_MAX_LENGTH,
126     PROP_MIN,
127     PROP_MULTIPLE,
128     PROP_NAME,
129     PROP_PATTERN,
130     PROP_PLACEHOLDER,
131     PROP_READ_ONLY,
132     PROP_REQUIRED,
133     PROP_SIZE,
134     PROP_SRC,
135     PROP_STEP,
136     PROP_TYPE,
137     PROP_DEFAULT_VALUE,
138     PROP_VALUE,
139     PROP_VALUE_AS_NUMBER,
140     PROP_WIDTH,
141     PROP_WILL_VALIDATE,
142     PROP_VALIDITY,
143     PROP_VALIDATION_MESSAGE,
144     PROP_LABELS,
145     PROP_ALIGN,
146     PROP_USE_MAP,
147     PROP_INCREMENTAL,
148     PROP_AUTOCORRECT,
149     PROP_AUTOCAPITALIZE,
150     PROP_CAPTURE,
151 };
152
153 static void webkit_dom_html_input_element_set_property(GObject* object, guint propertyId, const GValue* value, GParamSpec* pspec)
154 {
155     WebKitDOMHTMLInputElement* self = WEBKIT_DOM_HTML_INPUT_ELEMENT(object);
156
157     switch (propertyId) {
158     case PROP_ACCEPT:
159         webkit_dom_html_input_element_set_accept(self, g_value_get_string(value));
160         break;
161     case PROP_ALT:
162         webkit_dom_html_input_element_set_alt(self, g_value_get_string(value));
163         break;
164     case PROP_AUTOCOMPLETE:
165         webkit_dom_html_input_element_set_autocomplete(self, g_value_get_string(value));
166         break;
167     case PROP_AUTOFOCUS:
168         webkit_dom_html_input_element_set_autofocus(self, g_value_get_boolean(value));
169         break;
170     case PROP_DEFAULT_CHECKED:
171         webkit_dom_html_input_element_set_default_checked(self, g_value_get_boolean(value));
172         break;
173     case PROP_CHECKED:
174         webkit_dom_html_input_element_set_checked(self, g_value_get_boolean(value));
175         break;
176     case PROP_DIR_NAME:
177         webkit_dom_html_input_element_set_dir_name(self, g_value_get_string(value));
178         break;
179     case PROP_DISABLED:
180         webkit_dom_html_input_element_set_disabled(self, g_value_get_boolean(value));
181         break;
182     case PROP_FORM_ACTION:
183         webkit_dom_html_input_element_set_form_action(self, g_value_get_string(value));
184         break;
185     case PROP_FORM_ENCTYPE:
186         webkit_dom_html_input_element_set_form_enctype(self, g_value_get_string(value));
187         break;
188     case PROP_FORM_METHOD:
189         webkit_dom_html_input_element_set_form_method(self, g_value_get_string(value));
190         break;
191     case PROP_FORM_NO_VALIDATE:
192         webkit_dom_html_input_element_set_form_no_validate(self, g_value_get_boolean(value));
193         break;
194     case PROP_FORM_TARGET:
195         webkit_dom_html_input_element_set_form_target(self, g_value_get_string(value));
196         break;
197     case PROP_HEIGHT:
198         webkit_dom_html_input_element_set_height(self, g_value_get_ulong(value));
199         break;
200     case PROP_INDETERMINATE:
201         webkit_dom_html_input_element_set_indeterminate(self, g_value_get_boolean(value));
202         break;
203     case PROP_MAX:
204         webkit_dom_html_input_element_set_max(self, g_value_get_string(value));
205         break;
206     case PROP_MAX_LENGTH:
207         webkit_dom_html_input_element_set_max_length(self, g_value_get_long(value), nullptr);
208         break;
209     case PROP_MIN:
210         webkit_dom_html_input_element_set_min(self, g_value_get_string(value));
211         break;
212     case PROP_MULTIPLE:
213         webkit_dom_html_input_element_set_multiple(self, g_value_get_boolean(value));
214         break;
215     case PROP_NAME:
216         webkit_dom_html_input_element_set_name(self, g_value_get_string(value));
217         break;
218     case PROP_PATTERN:
219         webkit_dom_html_input_element_set_pattern(self, g_value_get_string(value));
220         break;
221     case PROP_PLACEHOLDER:
222         webkit_dom_html_input_element_set_placeholder(self, g_value_get_string(value));
223         break;
224     case PROP_READ_ONLY:
225         webkit_dom_html_input_element_set_read_only(self, g_value_get_boolean(value));
226         break;
227     case PROP_REQUIRED:
228         webkit_dom_html_input_element_set_required(self, g_value_get_boolean(value));
229         break;
230     case PROP_SIZE:
231         webkit_dom_html_input_element_set_size(self, g_value_get_ulong(value), nullptr);
232         break;
233     case PROP_SRC:
234         webkit_dom_html_input_element_set_src(self, g_value_get_string(value));
235         break;
236     case PROP_STEP:
237         webkit_dom_html_input_element_set_step(self, g_value_get_string(value));
238         break;
239     case PROP_TYPE:
240         webkit_dom_html_input_element_set_input_type(self, g_value_get_string(value));
241         break;
242     case PROP_DEFAULT_VALUE:
243         webkit_dom_html_input_element_set_default_value(self, g_value_get_string(value));
244         break;
245     case PROP_VALUE:
246         webkit_dom_html_input_element_set_value(self, g_value_get_string(value));
247         break;
248     case PROP_VALUE_AS_NUMBER:
249         webkit_dom_html_input_element_set_value_as_number(self, g_value_get_double(value), nullptr);
250         break;
251     case PROP_WIDTH:
252         webkit_dom_html_input_element_set_width(self, g_value_get_ulong(value));
253         break;
254     case PROP_ALIGN:
255         webkit_dom_html_input_element_set_align(self, g_value_get_string(value));
256         break;
257     case PROP_USE_MAP:
258         webkit_dom_html_input_element_set_use_map(self, g_value_get_string(value));
259         break;
260     case PROP_INCREMENTAL:
261         webkit_dom_html_input_element_set_incremental(self, g_value_get_boolean(value));
262         break;
263     case PROP_AUTOCORRECT:
264         webkit_dom_html_input_element_set_autocorrect(self, g_value_get_boolean(value));
265         break;
266     case PROP_AUTOCAPITALIZE:
267         webkit_dom_html_input_element_set_autocapitalize(self, g_value_get_string(value));
268         break;
269     case PROP_CAPTURE:
270         webkit_dom_html_input_element_set_capture(self, g_value_get_string(value));
271         break;
272     default:
273         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propertyId, pspec);
274         break;
275     }
276 }
277
278 static void webkit_dom_html_input_element_get_property(GObject* object, guint propertyId, GValue* value, GParamSpec* pspec)
279 {
280     WebKitDOMHTMLInputElement* self = WEBKIT_DOM_HTML_INPUT_ELEMENT(object);
281
282     switch (propertyId) {
283     case PROP_ACCEPT:
284         g_value_take_string(value, webkit_dom_html_input_element_get_accept(self));
285         break;
286     case PROP_ALT:
287         g_value_take_string(value, webkit_dom_html_input_element_get_alt(self));
288         break;
289     case PROP_AUTOCOMPLETE:
290         g_value_take_string(value, webkit_dom_html_input_element_get_autocomplete(self));
291         break;
292     case PROP_AUTOFOCUS:
293         g_value_set_boolean(value, webkit_dom_html_input_element_get_autofocus(self));
294         break;
295     case PROP_DEFAULT_CHECKED:
296         g_value_set_boolean(value, webkit_dom_html_input_element_get_default_checked(self));
297         break;
298     case PROP_CHECKED:
299         g_value_set_boolean(value, webkit_dom_html_input_element_get_checked(self));
300         break;
301     case PROP_DIR_NAME:
302         g_value_take_string(value, webkit_dom_html_input_element_get_dir_name(self));
303         break;
304     case PROP_DISABLED:
305         g_value_set_boolean(value, webkit_dom_html_input_element_get_disabled(self));
306         break;
307     case PROP_FORM:
308         g_value_set_object(value, webkit_dom_html_input_element_get_form(self));
309         break;
310     case PROP_FILES:
311         g_value_set_object(value, webkit_dom_html_input_element_get_files(self));
312         break;
313     case PROP_FORM_ACTION:
314         g_value_take_string(value, webkit_dom_html_input_element_get_form_action(self));
315         break;
316     case PROP_FORM_ENCTYPE:
317         g_value_take_string(value, webkit_dom_html_input_element_get_form_enctype(self));
318         break;
319     case PROP_FORM_METHOD:
320         g_value_take_string(value, webkit_dom_html_input_element_get_form_method(self));
321         break;
322     case PROP_FORM_NO_VALIDATE:
323         g_value_set_boolean(value, webkit_dom_html_input_element_get_form_no_validate(self));
324         break;
325     case PROP_FORM_TARGET:
326         g_value_take_string(value, webkit_dom_html_input_element_get_form_target(self));
327         break;
328     case PROP_HEIGHT:
329         g_value_set_ulong(value, webkit_dom_html_input_element_get_height(self));
330         break;
331     case PROP_INDETERMINATE:
332         g_value_set_boolean(value, webkit_dom_html_input_element_get_indeterminate(self));
333         break;
334     case PROP_LIST:
335         g_value_set_object(value, webkit_dom_html_input_element_get_list(self));
336         break;
337     case PROP_MAX:
338         g_value_take_string(value, webkit_dom_html_input_element_get_max(self));
339         break;
340     case PROP_MAX_LENGTH:
341         g_value_set_long(value, webkit_dom_html_input_element_get_max_length(self));
342         break;
343     case PROP_MIN:
344         g_value_take_string(value, webkit_dom_html_input_element_get_min(self));
345         break;
346     case PROP_MULTIPLE:
347         g_value_set_boolean(value, webkit_dom_html_input_element_get_multiple(self));
348         break;
349     case PROP_NAME:
350         g_value_take_string(value, webkit_dom_html_input_element_get_name(self));
351         break;
352     case PROP_PATTERN:
353         g_value_take_string(value, webkit_dom_html_input_element_get_pattern(self));
354         break;
355     case PROP_PLACEHOLDER:
356         g_value_take_string(value, webkit_dom_html_input_element_get_placeholder(self));
357         break;
358     case PROP_READ_ONLY:
359         g_value_set_boolean(value, webkit_dom_html_input_element_get_read_only(self));
360         break;
361     case PROP_REQUIRED:
362         g_value_set_boolean(value, webkit_dom_html_input_element_get_required(self));
363         break;
364     case PROP_SIZE:
365         g_value_set_ulong(value, webkit_dom_html_input_element_get_size(self));
366         break;
367     case PROP_SRC:
368         g_value_take_string(value, webkit_dom_html_input_element_get_src(self));
369         break;
370     case PROP_STEP:
371         g_value_take_string(value, webkit_dom_html_input_element_get_step(self));
372         break;
373     case PROP_TYPE:
374         g_value_take_string(value, webkit_dom_html_input_element_get_input_type(self));
375         break;
376     case PROP_DEFAULT_VALUE:
377         g_value_take_string(value, webkit_dom_html_input_element_get_default_value(self));
378         break;
379     case PROP_VALUE:
380         g_value_take_string(value, webkit_dom_html_input_element_get_value(self));
381         break;
382     case PROP_VALUE_AS_NUMBER:
383         g_value_set_double(value, webkit_dom_html_input_element_get_value_as_number(self));
384         break;
385     case PROP_WIDTH:
386         g_value_set_ulong(value, webkit_dom_html_input_element_get_width(self));
387         break;
388     case PROP_WILL_VALIDATE:
389         g_value_set_boolean(value, webkit_dom_html_input_element_get_will_validate(self));
390         break;
391     case PROP_VALIDITY:
392         g_value_set_object(value, webkit_dom_html_input_element_get_validity(self));
393         break;
394     case PROP_VALIDATION_MESSAGE:
395         g_value_take_string(value, webkit_dom_html_input_element_get_validation_message(self));
396         break;
397     case PROP_LABELS:
398         g_value_set_object(value, webkit_dom_html_input_element_get_labels(self));
399         break;
400     case PROP_ALIGN:
401         g_value_take_string(value, webkit_dom_html_input_element_get_align(self));
402         break;
403     case PROP_USE_MAP:
404         g_value_take_string(value, webkit_dom_html_input_element_get_use_map(self));
405         break;
406     case PROP_INCREMENTAL:
407         g_value_set_boolean(value, webkit_dom_html_input_element_get_incremental(self));
408         break;
409     case PROP_AUTOCORRECT:
410         g_value_set_boolean(value, webkit_dom_html_input_element_get_autocorrect(self));
411         break;
412     case PROP_AUTOCAPITALIZE:
413         g_value_take_string(value, webkit_dom_html_input_element_get_autocapitalize(self));
414         break;
415     case PROP_CAPTURE:
416         g_value_take_string(value, webkit_dom_html_input_element_get_capture_type(self));
417         break;
418     default:
419         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propertyId, pspec);
420         break;
421     }
422 }
423
424 static void webkit_dom_html_input_element_class_init(WebKitDOMHTMLInputElementClass* requestClass)
425 {
426     GObjectClass* gobjectClass = G_OBJECT_CLASS(requestClass);
427     gobjectClass->set_property = webkit_dom_html_input_element_set_property;
428     gobjectClass->get_property = webkit_dom_html_input_element_get_property;
429
430     g_object_class_install_property(
431         gobjectClass,
432         PROP_ACCEPT,
433         g_param_spec_string(
434             "accept",
435             "HTMLInputElement:accept",
436             "read-write gchar* HTMLInputElement:accept",
437             "",
438             WEBKIT_PARAM_READWRITE));
439
440     g_object_class_install_property(
441         gobjectClass,
442         PROP_ALT,
443         g_param_spec_string(
444             "alt",
445             "HTMLInputElement:alt",
446             "read-write gchar* HTMLInputElement:alt",
447             "",
448             WEBKIT_PARAM_READWRITE));
449
450     g_object_class_install_property(
451         gobjectClass,
452         PROP_AUTOCOMPLETE,
453         g_param_spec_string(
454             "autocomplete",
455             "HTMLInputElement:autocomplete",
456             "read-write gchar* HTMLInputElement:autocomplete",
457             "",
458             WEBKIT_PARAM_READWRITE));
459
460     g_object_class_install_property(
461         gobjectClass,
462         PROP_AUTOFOCUS,
463         g_param_spec_boolean(
464             "autofocus",
465             "HTMLInputElement:autofocus",
466             "read-write gboolean HTMLInputElement:autofocus",
467             FALSE,
468             WEBKIT_PARAM_READWRITE));
469
470     g_object_class_install_property(
471         gobjectClass,
472         PROP_DEFAULT_CHECKED,
473         g_param_spec_boolean(
474             "default-checked",
475             "HTMLInputElement:default-checked",
476             "read-write gboolean HTMLInputElement:default-checked",
477             FALSE,
478             WEBKIT_PARAM_READWRITE));
479
480     g_object_class_install_property(
481         gobjectClass,
482         PROP_CHECKED,
483         g_param_spec_boolean(
484             "checked",
485             "HTMLInputElement:checked",
486             "read-write gboolean HTMLInputElement:checked",
487             FALSE,
488             WEBKIT_PARAM_READWRITE));
489
490     g_object_class_install_property(
491         gobjectClass,
492         PROP_DIR_NAME,
493         g_param_spec_string(
494             "dir-name",
495             "HTMLInputElement:dir-name",
496             "read-write gchar* HTMLInputElement:dir-name",
497             "",
498             WEBKIT_PARAM_READWRITE));
499
500     g_object_class_install_property(
501         gobjectClass,
502         PROP_DISABLED,
503         g_param_spec_boolean(
504             "disabled",
505             "HTMLInputElement:disabled",
506             "read-write gboolean HTMLInputElement:disabled",
507             FALSE,
508             WEBKIT_PARAM_READWRITE));
509
510     g_object_class_install_property(
511         gobjectClass,
512         PROP_FORM,
513         g_param_spec_object(
514             "form",
515             "HTMLInputElement:form",
516             "read-only WebKitDOMHTMLFormElement* HTMLInputElement:form",
517             WEBKIT_DOM_TYPE_HTML_FORM_ELEMENT,
518             WEBKIT_PARAM_READABLE));
519
520     g_object_class_install_property(
521         gobjectClass,
522         PROP_FILES,
523         g_param_spec_object(
524             "files",
525             "HTMLInputElement:files",
526             "read-only WebKitDOMFileList* HTMLInputElement:files",
527             WEBKIT_DOM_TYPE_FILE_LIST,
528             WEBKIT_PARAM_READABLE));
529
530     g_object_class_install_property(
531         gobjectClass,
532         PROP_FORM_ACTION,
533         g_param_spec_string(
534             "form-action",
535             "HTMLInputElement:form-action",
536             "read-write gchar* HTMLInputElement:form-action",
537             "",
538             WEBKIT_PARAM_READWRITE));
539
540     g_object_class_install_property(
541         gobjectClass,
542         PROP_FORM_ENCTYPE,
543         g_param_spec_string(
544             "form-enctype",
545             "HTMLInputElement:form-enctype",
546             "read-write gchar* HTMLInputElement:form-enctype",
547             "",
548             WEBKIT_PARAM_READWRITE));
549
550     g_object_class_install_property(
551         gobjectClass,
552         PROP_FORM_METHOD,
553         g_param_spec_string(
554             "form-method",
555             "HTMLInputElement:form-method",
556             "read-write gchar* HTMLInputElement:form-method",
557             "",
558             WEBKIT_PARAM_READWRITE));
559
560     g_object_class_install_property(
561         gobjectClass,
562         PROP_FORM_NO_VALIDATE,
563         g_param_spec_boolean(
564             "form-no-validate",
565             "HTMLInputElement:form-no-validate",
566             "read-write gboolean HTMLInputElement:form-no-validate",
567             FALSE,
568             WEBKIT_PARAM_READWRITE));
569
570     g_object_class_install_property(
571         gobjectClass,
572         PROP_FORM_TARGET,
573         g_param_spec_string(
574             "form-target",
575             "HTMLInputElement:form-target",
576             "read-write gchar* HTMLInputElement:form-target",
577             "",
578             WEBKIT_PARAM_READWRITE));
579
580     g_object_class_install_property(
581         gobjectClass,
582         PROP_HEIGHT,
583         g_param_spec_ulong(
584             "height",
585             "HTMLInputElement:height",
586             "read-write gulong HTMLInputElement:height",
587             0, G_MAXULONG, 0,
588             WEBKIT_PARAM_READWRITE));
589
590     g_object_class_install_property(
591         gobjectClass,
592         PROP_INDETERMINATE,
593         g_param_spec_boolean(
594             "indeterminate",
595             "HTMLInputElement:indeterminate",
596             "read-write gboolean HTMLInputElement:indeterminate",
597             FALSE,
598             WEBKIT_PARAM_READWRITE));
599
600     g_object_class_install_property(
601         gobjectClass,
602         PROP_LIST,
603         g_param_spec_object(
604             "list",
605             "HTMLInputElement:list",
606             "read-only WebKitDOMHTMLElement* HTMLInputElement:list",
607             WEBKIT_DOM_TYPE_HTML_ELEMENT,
608             WEBKIT_PARAM_READABLE));
609
610     g_object_class_install_property(
611         gobjectClass,
612         PROP_MAX,
613         g_param_spec_string(
614             "max",
615             "HTMLInputElement:max",
616             "read-write gchar* HTMLInputElement:max",
617             "",
618             WEBKIT_PARAM_READWRITE));
619
620     g_object_class_install_property(
621         gobjectClass,
622         PROP_MAX_LENGTH,
623         g_param_spec_long(
624             "max-length",
625             "HTMLInputElement:max-length",
626             "read-write glong HTMLInputElement:max-length",
627             G_MINLONG, G_MAXLONG, 0,
628             WEBKIT_PARAM_READWRITE));
629
630     g_object_class_install_property(
631         gobjectClass,
632         PROP_MIN,
633         g_param_spec_string(
634             "min",
635             "HTMLInputElement:min",
636             "read-write gchar* HTMLInputElement:min",
637             "",
638             WEBKIT_PARAM_READWRITE));
639
640     g_object_class_install_property(
641         gobjectClass,
642         PROP_MULTIPLE,
643         g_param_spec_boolean(
644             "multiple",
645             "HTMLInputElement:multiple",
646             "read-write gboolean HTMLInputElement:multiple",
647             FALSE,
648             WEBKIT_PARAM_READWRITE));
649
650     g_object_class_install_property(
651         gobjectClass,
652         PROP_NAME,
653         g_param_spec_string(
654             "name",
655             "HTMLInputElement:name",
656             "read-write gchar* HTMLInputElement:name",
657             "",
658             WEBKIT_PARAM_READWRITE));
659
660     g_object_class_install_property(
661         gobjectClass,
662         PROP_PATTERN,
663         g_param_spec_string(
664             "pattern",
665             "HTMLInputElement:pattern",
666             "read-write gchar* HTMLInputElement:pattern",
667             "",
668             WEBKIT_PARAM_READWRITE));
669
670     g_object_class_install_property(
671         gobjectClass,
672         PROP_PLACEHOLDER,
673         g_param_spec_string(
674             "placeholder",
675             "HTMLInputElement:placeholder",
676             "read-write gchar* HTMLInputElement:placeholder",
677             "",
678             WEBKIT_PARAM_READWRITE));
679
680     g_object_class_install_property(
681         gobjectClass,
682         PROP_READ_ONLY,
683         g_param_spec_boolean(
684             "read-only",
685             "HTMLInputElement:read-only",
686             "read-write gboolean HTMLInputElement:read-only",
687             FALSE,
688             WEBKIT_PARAM_READWRITE));
689
690     g_object_class_install_property(
691         gobjectClass,
692         PROP_REQUIRED,
693         g_param_spec_boolean(
694             "required",
695             "HTMLInputElement:required",
696             "read-write gboolean HTMLInputElement:required",
697             FALSE,
698             WEBKIT_PARAM_READWRITE));
699
700     g_object_class_install_property(
701         gobjectClass,
702         PROP_SIZE,
703         g_param_spec_ulong(
704             "size",
705             "HTMLInputElement:size",
706             "read-write gulong HTMLInputElement:size",
707             0, G_MAXULONG, 0,
708             WEBKIT_PARAM_READWRITE));
709
710     g_object_class_install_property(
711         gobjectClass,
712         PROP_SRC,
713         g_param_spec_string(
714             "src",
715             "HTMLInputElement:src",
716             "read-write gchar* HTMLInputElement:src",
717             "",
718             WEBKIT_PARAM_READWRITE));
719
720     g_object_class_install_property(
721         gobjectClass,
722         PROP_STEP,
723         g_param_spec_string(
724             "step",
725             "HTMLInputElement:step",
726             "read-write gchar* HTMLInputElement:step",
727             "",
728             WEBKIT_PARAM_READWRITE));
729
730     g_object_class_install_property(
731         gobjectClass,
732         PROP_TYPE,
733         g_param_spec_string(
734             "type",
735             "HTMLInputElement:type",
736             "read-write gchar* HTMLInputElement:type",
737             "",
738             WEBKIT_PARAM_READWRITE));
739
740     g_object_class_install_property(
741         gobjectClass,
742         PROP_DEFAULT_VALUE,
743         g_param_spec_string(
744             "default-value",
745             "HTMLInputElement:default-value",
746             "read-write gchar* HTMLInputElement:default-value",
747             "",
748             WEBKIT_PARAM_READWRITE));
749
750     g_object_class_install_property(
751         gobjectClass,
752         PROP_VALUE,
753         g_param_spec_string(
754             "value",
755             "HTMLInputElement:value",
756             "read-write gchar* HTMLInputElement:value",
757             "",
758             WEBKIT_PARAM_READWRITE));
759
760     g_object_class_install_property(
761         gobjectClass,
762         PROP_VALUE_AS_NUMBER,
763         g_param_spec_double(
764             "value-as-number",
765             "HTMLInputElement:value-as-number",
766             "read-write gdouble HTMLInputElement:value-as-number",
767             -G_MAXDOUBLE, G_MAXDOUBLE, 0,
768             WEBKIT_PARAM_READWRITE));
769
770     g_object_class_install_property(
771         gobjectClass,
772         PROP_WIDTH,
773         g_param_spec_ulong(
774             "width",
775             "HTMLInputElement:width",
776             "read-write gulong HTMLInputElement:width",
777             0, G_MAXULONG, 0,
778             WEBKIT_PARAM_READWRITE));
779
780     g_object_class_install_property(
781         gobjectClass,
782         PROP_WILL_VALIDATE,
783         g_param_spec_boolean(
784             "will-validate",
785             "HTMLInputElement:will-validate",
786             "read-only gboolean HTMLInputElement:will-validate",
787             FALSE,
788             WEBKIT_PARAM_READABLE));
789
790     g_object_class_install_property(
791         gobjectClass,
792         PROP_VALIDITY,
793         g_param_spec_object(
794             "validity",
795             "HTMLInputElement:validity",
796             "read-only WebKitDOMValidityState* HTMLInputElement:validity",
797             WEBKIT_DOM_TYPE_VALIDITY_STATE,
798             WEBKIT_PARAM_READABLE));
799
800     g_object_class_install_property(
801         gobjectClass,
802         PROP_VALIDATION_MESSAGE,
803         g_param_spec_string(
804             "validation-message",
805             "HTMLInputElement:validation-message",
806             "read-only gchar* HTMLInputElement:validation-message",
807             "",
808             WEBKIT_PARAM_READABLE));
809
810     g_object_class_install_property(
811         gobjectClass,
812         PROP_LABELS,
813         g_param_spec_object(
814             "labels",
815             "HTMLInputElement:labels",
816             "read-only WebKitDOMNodeList* HTMLInputElement:labels",
817             WEBKIT_DOM_TYPE_NODE_LIST,
818             WEBKIT_PARAM_READABLE));
819
820     g_object_class_install_property(
821         gobjectClass,
822         PROP_ALIGN,
823         g_param_spec_string(
824             "align",
825             "HTMLInputElement:align",
826             "read-write gchar* HTMLInputElement:align",
827             "",
828             WEBKIT_PARAM_READWRITE));
829
830     g_object_class_install_property(
831         gobjectClass,
832         PROP_USE_MAP,
833         g_param_spec_string(
834             "use-map",
835             "HTMLInputElement:use-map",
836             "read-write gchar* HTMLInputElement:use-map",
837             "",
838             WEBKIT_PARAM_READWRITE));
839
840     g_object_class_install_property(
841         gobjectClass,
842         PROP_INCREMENTAL,
843         g_param_spec_boolean(
844             "incremental",
845             "HTMLInputElement:incremental",
846             "read-write gboolean HTMLInputElement:incremental",
847             FALSE,
848             WEBKIT_PARAM_READWRITE));
849
850     g_object_class_install_property(
851         gobjectClass,
852         PROP_AUTOCORRECT,
853         g_param_spec_boolean(
854             "autocorrect",
855             "HTMLInputElement:autocorrect",
856             "read-write gboolean HTMLInputElement:autocorrect",
857             FALSE,
858             WEBKIT_PARAM_READWRITE));
859
860     g_object_class_install_property(
861         gobjectClass,
862         PROP_AUTOCAPITALIZE,
863         g_param_spec_string(
864             "autocapitalize",
865             "HTMLInputElement:autocapitalize",
866             "read-write gchar* HTMLInputElement:autocapitalize",
867             "",
868             WEBKIT_PARAM_READWRITE));
869
870     g_object_class_install_property(
871         gobjectClass,
872         PROP_CAPTURE,
873         g_param_spec_string(
874             "capture",
875             "HTMLInputElement:capture",
876             "read-write gchar* HTMLInputElement:capture",
877             "",
878             WEBKIT_PARAM_READWRITE));
879
880 }
881
882 static void webkit_dom_html_input_element_init(WebKitDOMHTMLInputElement* request)
883 {
884     UNUSED_PARAM(request);
885 }
886
887 void webkit_dom_html_input_element_step_up(WebKitDOMHTMLInputElement* self, glong n, GError** error)
888 {
889     WebCore::JSMainThreadNullState state;
890     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
891     g_return_if_fail(!error || !*error);
892     WebCore::HTMLInputElement* item = WebKit::core(self);
893     WebCore::ExceptionCode ec = 0;
894     item->stepUp(n, ec);
895     if (ec) {
896         WebCore::ExceptionCodeDescription ecdesc(ec);
897         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
898     }
899 }
900
901 void webkit_dom_html_input_element_step_down(WebKitDOMHTMLInputElement* self, glong n, GError** error)
902 {
903     WebCore::JSMainThreadNullState state;
904     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
905     g_return_if_fail(!error || !*error);
906     WebCore::HTMLInputElement* item = WebKit::core(self);
907     WebCore::ExceptionCode ec = 0;
908     item->stepDown(n, ec);
909     if (ec) {
910         WebCore::ExceptionCodeDescription ecdesc(ec);
911         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
912     }
913 }
914
915 gboolean webkit_dom_html_input_element_check_validity(WebKitDOMHTMLInputElement* self)
916 {
917     WebCore::JSMainThreadNullState state;
918     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
919     WebCore::HTMLInputElement* item = WebKit::core(self);
920     gboolean result = item->checkValidity();
921     return result;
922 }
923
924 void webkit_dom_html_input_element_set_custom_validity(WebKitDOMHTMLInputElement* self, const gchar* error)
925 {
926     WebCore::JSMainThreadNullState state;
927     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
928     g_return_if_fail(error);
929     WebCore::HTMLInputElement* item = WebKit::core(self);
930     WTF::String convertedError = WTF::String::fromUTF8(error);
931     item->setCustomValidity(convertedError);
932 }
933
934 void webkit_dom_html_input_element_select(WebKitDOMHTMLInputElement* self)
935 {
936     WebCore::JSMainThreadNullState state;
937     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
938     WebCore::HTMLInputElement* item = WebKit::core(self);
939     item->select();
940 }
941
942 void webkit_dom_html_input_element_set_range_text(WebKitDOMHTMLInputElement* self, const gchar* replacement, gulong start, gulong end, const gchar* selectionMode, GError** error)
943 {
944     WebCore::JSMainThreadNullState state;
945     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
946     g_return_if_fail(replacement);
947     g_return_if_fail(selectionMode);
948     g_return_if_fail(!error || !*error);
949     WebCore::HTMLInputElement* item = WebKit::core(self);
950     WTF::String convertedReplacement = WTF::String::fromUTF8(replacement);
951     WTF::String convertedSelectionMode = WTF::String::fromUTF8(selectionMode);
952     WebCore::ExceptionCode ec = 0;
953     item->setRangeText(convertedReplacement, start, end, convertedSelectionMode, ec);
954     if (ec) {
955         WebCore::ExceptionCodeDescription ecdesc(ec);
956         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
957     }
958 }
959
960 void webkit_dom_html_input_element_set_value_for_user(WebKitDOMHTMLInputElement* self, const gchar* value)
961 {
962     WebCore::JSMainThreadNullState state;
963     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
964     g_return_if_fail(value);
965     WebCore::HTMLInputElement* item = WebKit::core(self);
966     WTF::String convertedValue = WTF::String::fromUTF8(value);
967     item->setValueForUser(convertedValue);
968 }
969
970 gchar* webkit_dom_html_input_element_get_accept(WebKitDOMHTMLInputElement* self)
971 {
972     WebCore::JSMainThreadNullState state;
973     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
974     WebCore::HTMLInputElement* item = WebKit::core(self);
975     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::acceptAttr));
976     return result;
977 }
978
979 void webkit_dom_html_input_element_set_accept(WebKitDOMHTMLInputElement* self, const gchar* value)
980 {
981     WebCore::JSMainThreadNullState state;
982     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
983     g_return_if_fail(value);
984     WebCore::HTMLInputElement* item = WebKit::core(self);
985     WTF::String convertedValue = WTF::String::fromUTF8(value);
986     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::acceptAttr, convertedValue);
987 }
988
989 gchar* webkit_dom_html_input_element_get_alt(WebKitDOMHTMLInputElement* self)
990 {
991     WebCore::JSMainThreadNullState state;
992     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
993     WebCore::HTMLInputElement* item = WebKit::core(self);
994     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::altAttr));
995     return result;
996 }
997
998 void webkit_dom_html_input_element_set_alt(WebKitDOMHTMLInputElement* self, const gchar* value)
999 {
1000     WebCore::JSMainThreadNullState state;
1001     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1002     g_return_if_fail(value);
1003     WebCore::HTMLInputElement* item = WebKit::core(self);
1004     WTF::String convertedValue = WTF::String::fromUTF8(value);
1005     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::altAttr, convertedValue);
1006 }
1007
1008 gchar* webkit_dom_html_input_element_get_autocomplete(WebKitDOMHTMLInputElement* self)
1009 {
1010     WebCore::JSMainThreadNullState state;
1011     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1012     WebCore::HTMLInputElement* item = WebKit::core(self);
1013     gchar* result = convertToUTF8String(item->autocomplete());
1014     return result;
1015 }
1016
1017 void webkit_dom_html_input_element_set_autocomplete(WebKitDOMHTMLInputElement* self, const gchar* value)
1018 {
1019     WebCore::JSMainThreadNullState state;
1020     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1021     g_return_if_fail(value);
1022     WebCore::HTMLInputElement* item = WebKit::core(self);
1023     WTF::String convertedValue = WTF::String::fromUTF8(value);
1024     item->setAutocomplete(convertedValue);
1025 }
1026
1027 gboolean webkit_dom_html_input_element_get_autofocus(WebKitDOMHTMLInputElement* self)
1028 {
1029     WebCore::JSMainThreadNullState state;
1030     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1031     WebCore::HTMLInputElement* item = WebKit::core(self);
1032     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::autofocusAttr);
1033     return result;
1034 }
1035
1036 void webkit_dom_html_input_element_set_autofocus(WebKitDOMHTMLInputElement* self, gboolean value)
1037 {
1038     WebCore::JSMainThreadNullState state;
1039     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1040     WebCore::HTMLInputElement* item = WebKit::core(self);
1041     item->setBooleanAttribute(WebCore::HTMLNames::autofocusAttr, value);
1042 }
1043
1044 gboolean webkit_dom_html_input_element_get_default_checked(WebKitDOMHTMLInputElement* self)
1045 {
1046     WebCore::JSMainThreadNullState state;
1047     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1048     WebCore::HTMLInputElement* item = WebKit::core(self);
1049     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::checkedAttr);
1050     return result;
1051 }
1052
1053 void webkit_dom_html_input_element_set_default_checked(WebKitDOMHTMLInputElement* self, gboolean value)
1054 {
1055     WebCore::JSMainThreadNullState state;
1056     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1057     WebCore::HTMLInputElement* item = WebKit::core(self);
1058     item->setBooleanAttribute(WebCore::HTMLNames::checkedAttr, value);
1059 }
1060
1061 gboolean webkit_dom_html_input_element_get_checked(WebKitDOMHTMLInputElement* self)
1062 {
1063     WebCore::JSMainThreadNullState state;
1064     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1065     WebCore::HTMLInputElement* item = WebKit::core(self);
1066     gboolean result = item->checked();
1067     return result;
1068 }
1069
1070 void webkit_dom_html_input_element_set_checked(WebKitDOMHTMLInputElement* self, gboolean value)
1071 {
1072     WebCore::JSMainThreadNullState state;
1073     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1074     WebCore::HTMLInputElement* item = WebKit::core(self);
1075     item->setChecked(value);
1076 }
1077
1078 gchar* webkit_dom_html_input_element_get_dir_name(WebKitDOMHTMLInputElement* self)
1079 {
1080     WebCore::JSMainThreadNullState state;
1081     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1082     WebCore::HTMLInputElement* item = WebKit::core(self);
1083     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::dirnameAttr));
1084     return result;
1085 }
1086
1087 void webkit_dom_html_input_element_set_dir_name(WebKitDOMHTMLInputElement* self, const gchar* value)
1088 {
1089     WebCore::JSMainThreadNullState state;
1090     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1091     g_return_if_fail(value);
1092     WebCore::HTMLInputElement* item = WebKit::core(self);
1093     WTF::String convertedValue = WTF::String::fromUTF8(value);
1094     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::dirnameAttr, convertedValue);
1095 }
1096
1097 gboolean webkit_dom_html_input_element_get_disabled(WebKitDOMHTMLInputElement* self)
1098 {
1099     WebCore::JSMainThreadNullState state;
1100     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1101     WebCore::HTMLInputElement* item = WebKit::core(self);
1102     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::disabledAttr);
1103     return result;
1104 }
1105
1106 void webkit_dom_html_input_element_set_disabled(WebKitDOMHTMLInputElement* self, gboolean value)
1107 {
1108     WebCore::JSMainThreadNullState state;
1109     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1110     WebCore::HTMLInputElement* item = WebKit::core(self);
1111     item->setBooleanAttribute(WebCore::HTMLNames::disabledAttr, value);
1112 }
1113
1114 WebKitDOMHTMLFormElement* webkit_dom_html_input_element_get_form(WebKitDOMHTMLInputElement* self)
1115 {
1116     WebCore::JSMainThreadNullState state;
1117     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1118     WebCore::HTMLInputElement* item = WebKit::core(self);
1119     RefPtr<WebCore::HTMLFormElement> gobjectResult = WTF::getPtr(item->form());
1120     return WebKit::kit(gobjectResult.get());
1121 }
1122
1123 WebKitDOMFileList* webkit_dom_html_input_element_get_files(WebKitDOMHTMLInputElement* self)
1124 {
1125     WebCore::JSMainThreadNullState state;
1126     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1127     WebCore::HTMLInputElement* item = WebKit::core(self);
1128     RefPtr<WebCore::FileList> gobjectResult = WTF::getPtr(item->files());
1129     return WebKit::kit(gobjectResult.get());
1130 }
1131
1132 void webkit_dom_html_input_element_set_files(WebKitDOMHTMLInputElement* self, WebKitDOMFileList* value)
1133 {
1134     WebCore::JSMainThreadNullState state;
1135     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1136     g_return_if_fail(WEBKIT_DOM_IS_FILE_LIST(value));
1137     WebCore::HTMLInputElement* item = WebKit::core(self);
1138     WebCore::FileList* convertedValue = WebKit::core(value);
1139     item->setFiles(convertedValue);
1140 }
1141
1142 gchar* webkit_dom_html_input_element_get_form_action(WebKitDOMHTMLInputElement* self)
1143 {
1144     WebCore::JSMainThreadNullState state;
1145     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1146     WebCore::HTMLInputElement* item = WebKit::core(self);
1147     gchar* result = convertToUTF8String(item->formAction());
1148     return result;
1149 }
1150
1151 void webkit_dom_html_input_element_set_form_action(WebKitDOMHTMLInputElement* self, const gchar* value)
1152 {
1153     WebCore::JSMainThreadNullState state;
1154     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1155     g_return_if_fail(value);
1156     WebCore::HTMLInputElement* item = WebKit::core(self);
1157     WTF::String convertedValue = WTF::String::fromUTF8(value);
1158     item->setFormAction(convertedValue);
1159 }
1160
1161 gchar* webkit_dom_html_input_element_get_form_enctype(WebKitDOMHTMLInputElement* self)
1162 {
1163     WebCore::JSMainThreadNullState state;
1164     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1165     WebCore::HTMLInputElement* item = WebKit::core(self);
1166     gchar* result = convertToUTF8String(item->formEnctype());
1167     return result;
1168 }
1169
1170 void webkit_dom_html_input_element_set_form_enctype(WebKitDOMHTMLInputElement* self, const gchar* value)
1171 {
1172     WebCore::JSMainThreadNullState state;
1173     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1174     g_return_if_fail(value);
1175     WebCore::HTMLInputElement* item = WebKit::core(self);
1176     WTF::String convertedValue = WTF::String::fromUTF8(value);
1177     item->setFormEnctype(convertedValue);
1178 }
1179
1180 gchar* webkit_dom_html_input_element_get_form_method(WebKitDOMHTMLInputElement* self)
1181 {
1182     WebCore::JSMainThreadNullState state;
1183     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1184     WebCore::HTMLInputElement* item = WebKit::core(self);
1185     gchar* result = convertToUTF8String(item->formMethod());
1186     return result;
1187 }
1188
1189 void webkit_dom_html_input_element_set_form_method(WebKitDOMHTMLInputElement* self, const gchar* value)
1190 {
1191     WebCore::JSMainThreadNullState state;
1192     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1193     g_return_if_fail(value);
1194     WebCore::HTMLInputElement* item = WebKit::core(self);
1195     WTF::String convertedValue = WTF::String::fromUTF8(value);
1196     item->setFormMethod(convertedValue);
1197 }
1198
1199 gboolean webkit_dom_html_input_element_get_form_no_validate(WebKitDOMHTMLInputElement* self)
1200 {
1201     WebCore::JSMainThreadNullState state;
1202     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1203     WebCore::HTMLInputElement* item = WebKit::core(self);
1204     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::formnovalidateAttr);
1205     return result;
1206 }
1207
1208 void webkit_dom_html_input_element_set_form_no_validate(WebKitDOMHTMLInputElement* self, gboolean value)
1209 {
1210     WebCore::JSMainThreadNullState state;
1211     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1212     WebCore::HTMLInputElement* item = WebKit::core(self);
1213     item->setBooleanAttribute(WebCore::HTMLNames::formnovalidateAttr, value);
1214 }
1215
1216 gchar* webkit_dom_html_input_element_get_form_target(WebKitDOMHTMLInputElement* self)
1217 {
1218     WebCore::JSMainThreadNullState state;
1219     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1220     WebCore::HTMLInputElement* item = WebKit::core(self);
1221     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::formtargetAttr));
1222     return result;
1223 }
1224
1225 void webkit_dom_html_input_element_set_form_target(WebKitDOMHTMLInputElement* self, const gchar* value)
1226 {
1227     WebCore::JSMainThreadNullState state;
1228     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1229     g_return_if_fail(value);
1230     WebCore::HTMLInputElement* item = WebKit::core(self);
1231     WTF::String convertedValue = WTF::String::fromUTF8(value);
1232     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::formtargetAttr, convertedValue);
1233 }
1234
1235 gulong webkit_dom_html_input_element_get_height(WebKitDOMHTMLInputElement* self)
1236 {
1237     WebCore::JSMainThreadNullState state;
1238     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1239     WebCore::HTMLInputElement* item = WebKit::core(self);
1240     gulong result = item->height();
1241     return result;
1242 }
1243
1244 void webkit_dom_html_input_element_set_height(WebKitDOMHTMLInputElement* self, gulong value)
1245 {
1246     WebCore::JSMainThreadNullState state;
1247     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1248     WebCore::HTMLInputElement* item = WebKit::core(self);
1249     item->setHeight(value);
1250 }
1251
1252 gboolean webkit_dom_html_input_element_get_indeterminate(WebKitDOMHTMLInputElement* self)
1253 {
1254     WebCore::JSMainThreadNullState state;
1255     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1256     WebCore::HTMLInputElement* item = WebKit::core(self);
1257     gboolean result = item->indeterminate();
1258     return result;
1259 }
1260
1261 void webkit_dom_html_input_element_set_indeterminate(WebKitDOMHTMLInputElement* self, gboolean value)
1262 {
1263     WebCore::JSMainThreadNullState state;
1264     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1265     WebCore::HTMLInputElement* item = WebKit::core(self);
1266     item->setIndeterminate(value);
1267 }
1268
1269 WebKitDOMHTMLElement* webkit_dom_html_input_element_get_list(WebKitDOMHTMLInputElement* self)
1270 {
1271 #if ENABLE(DATALIST_ELEMENT)
1272     WebCore::JSMainThreadNullState state;
1273     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1274     WebCore::HTMLInputElement* item = WebKit::core(self);
1275     RefPtr<WebCore::HTMLElement> gobjectResult = WTF::getPtr(item->list());
1276     return WebKit::kit(gobjectResult.get());
1277 #else
1278     UNUSED_PARAM(self);
1279     WEBKIT_WARN_FEATURE_NOT_PRESENT("Datalist Element")
1280     return 0;
1281 #endif /* ENABLE(DATALIST_ELEMENT) */
1282 }
1283
1284 gchar* webkit_dom_html_input_element_get_max(WebKitDOMHTMLInputElement* self)
1285 {
1286     WebCore::JSMainThreadNullState state;
1287     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1288     WebCore::HTMLInputElement* item = WebKit::core(self);
1289     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::maxAttr));
1290     return result;
1291 }
1292
1293 void webkit_dom_html_input_element_set_max(WebKitDOMHTMLInputElement* self, const gchar* value)
1294 {
1295     WebCore::JSMainThreadNullState state;
1296     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1297     g_return_if_fail(value);
1298     WebCore::HTMLInputElement* item = WebKit::core(self);
1299     WTF::String convertedValue = WTF::String::fromUTF8(value);
1300     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::maxAttr, convertedValue);
1301 }
1302
1303 glong webkit_dom_html_input_element_get_max_length(WebKitDOMHTMLInputElement* self)
1304 {
1305     WebCore::JSMainThreadNullState state;
1306     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1307     WebCore::HTMLInputElement* item = WebKit::core(self);
1308     glong result = item->maxLength();
1309     return result;
1310 }
1311
1312 void webkit_dom_html_input_element_set_max_length(WebKitDOMHTMLInputElement* self, glong value, GError** error)
1313 {
1314     WebCore::JSMainThreadNullState state;
1315     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1316     g_return_if_fail(!error || !*error);
1317     WebCore::HTMLInputElement* item = WebKit::core(self);
1318     WebCore::ExceptionCode ec = 0;
1319     item->setMaxLength(value, ec);
1320     if (ec) {
1321         WebCore::ExceptionCodeDescription ecdesc(ec);
1322         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
1323     }
1324 }
1325
1326 gchar* webkit_dom_html_input_element_get_min(WebKitDOMHTMLInputElement* self)
1327 {
1328     WebCore::JSMainThreadNullState state;
1329     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1330     WebCore::HTMLInputElement* item = WebKit::core(self);
1331     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::minAttr));
1332     return result;
1333 }
1334
1335 void webkit_dom_html_input_element_set_min(WebKitDOMHTMLInputElement* self, const gchar* value)
1336 {
1337     WebCore::JSMainThreadNullState state;
1338     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1339     g_return_if_fail(value);
1340     WebCore::HTMLInputElement* item = WebKit::core(self);
1341     WTF::String convertedValue = WTF::String::fromUTF8(value);
1342     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::minAttr, convertedValue);
1343 }
1344
1345 gboolean webkit_dom_html_input_element_get_multiple(WebKitDOMHTMLInputElement* self)
1346 {
1347     WebCore::JSMainThreadNullState state;
1348     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1349     WebCore::HTMLInputElement* item = WebKit::core(self);
1350     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::multipleAttr);
1351     return result;
1352 }
1353
1354 void webkit_dom_html_input_element_set_multiple(WebKitDOMHTMLInputElement* self, gboolean value)
1355 {
1356     WebCore::JSMainThreadNullState state;
1357     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1358     WebCore::HTMLInputElement* item = WebKit::core(self);
1359     item->setBooleanAttribute(WebCore::HTMLNames::multipleAttr, value);
1360 }
1361
1362 gchar* webkit_dom_html_input_element_get_name(WebKitDOMHTMLInputElement* self)
1363 {
1364     WebCore::JSMainThreadNullState state;
1365     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1366     WebCore::HTMLInputElement* item = WebKit::core(self);
1367     gchar* result = convertToUTF8String(item->getNameAttribute());
1368     return result;
1369 }
1370
1371 void webkit_dom_html_input_element_set_name(WebKitDOMHTMLInputElement* self, const gchar* value)
1372 {
1373     WebCore::JSMainThreadNullState state;
1374     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1375     g_return_if_fail(value);
1376     WebCore::HTMLInputElement* item = WebKit::core(self);
1377     WTF::String convertedValue = WTF::String::fromUTF8(value);
1378     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::nameAttr, convertedValue);
1379 }
1380
1381 gchar* webkit_dom_html_input_element_get_pattern(WebKitDOMHTMLInputElement* self)
1382 {
1383     WebCore::JSMainThreadNullState state;
1384     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1385     WebCore::HTMLInputElement* item = WebKit::core(self);
1386     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::patternAttr));
1387     return result;
1388 }
1389
1390 void webkit_dom_html_input_element_set_pattern(WebKitDOMHTMLInputElement* self, const gchar* value)
1391 {
1392     WebCore::JSMainThreadNullState state;
1393     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1394     g_return_if_fail(value);
1395     WebCore::HTMLInputElement* item = WebKit::core(self);
1396     WTF::String convertedValue = WTF::String::fromUTF8(value);
1397     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::patternAttr, convertedValue);
1398 }
1399
1400 gchar* webkit_dom_html_input_element_get_placeholder(WebKitDOMHTMLInputElement* self)
1401 {
1402     WebCore::JSMainThreadNullState state;
1403     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1404     WebCore::HTMLInputElement* item = WebKit::core(self);
1405     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::placeholderAttr));
1406     return result;
1407 }
1408
1409 void webkit_dom_html_input_element_set_placeholder(WebKitDOMHTMLInputElement* self, const gchar* value)
1410 {
1411     WebCore::JSMainThreadNullState state;
1412     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1413     g_return_if_fail(value);
1414     WebCore::HTMLInputElement* item = WebKit::core(self);
1415     WTF::String convertedValue = WTF::String::fromUTF8(value);
1416     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::placeholderAttr, convertedValue);
1417 }
1418
1419 gboolean webkit_dom_html_input_element_get_read_only(WebKitDOMHTMLInputElement* self)
1420 {
1421     WebCore::JSMainThreadNullState state;
1422     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1423     WebCore::HTMLInputElement* item = WebKit::core(self);
1424     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::readonlyAttr);
1425     return result;
1426 }
1427
1428 void webkit_dom_html_input_element_set_read_only(WebKitDOMHTMLInputElement* self, gboolean value)
1429 {
1430     WebCore::JSMainThreadNullState state;
1431     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1432     WebCore::HTMLInputElement* item = WebKit::core(self);
1433     item->setBooleanAttribute(WebCore::HTMLNames::readonlyAttr, value);
1434 }
1435
1436 gboolean webkit_dom_html_input_element_get_required(WebKitDOMHTMLInputElement* self)
1437 {
1438     WebCore::JSMainThreadNullState state;
1439     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1440     WebCore::HTMLInputElement* item = WebKit::core(self);
1441     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::requiredAttr);
1442     return result;
1443 }
1444
1445 void webkit_dom_html_input_element_set_required(WebKitDOMHTMLInputElement* self, gboolean value)
1446 {
1447     WebCore::JSMainThreadNullState state;
1448     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1449     WebCore::HTMLInputElement* item = WebKit::core(self);
1450     item->setBooleanAttribute(WebCore::HTMLNames::requiredAttr, value);
1451 }
1452
1453 gulong webkit_dom_html_input_element_get_size(WebKitDOMHTMLInputElement* self)
1454 {
1455     WebCore::JSMainThreadNullState state;
1456     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1457     WebCore::HTMLInputElement* item = WebKit::core(self);
1458     gulong result = item->size();
1459     return result;
1460 }
1461
1462 void webkit_dom_html_input_element_set_size(WebKitDOMHTMLInputElement* self, gulong value, GError** error)
1463 {
1464     WebCore::JSMainThreadNullState state;
1465     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1466     g_return_if_fail(!error || !*error);
1467     WebCore::HTMLInputElement* item = WebKit::core(self);
1468     WebCore::ExceptionCode ec = 0;
1469     item->setSize(value, ec);
1470     if (ec) {
1471         WebCore::ExceptionCodeDescription ecdesc(ec);
1472         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
1473     }
1474 }
1475
1476 gchar* webkit_dom_html_input_element_get_src(WebKitDOMHTMLInputElement* self)
1477 {
1478     WebCore::JSMainThreadNullState state;
1479     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1480     WebCore::HTMLInputElement* item = WebKit::core(self);
1481     gchar* result = convertToUTF8String(item->getURLAttribute(WebCore::HTMLNames::srcAttr));
1482     return result;
1483 }
1484
1485 void webkit_dom_html_input_element_set_src(WebKitDOMHTMLInputElement* self, const gchar* value)
1486 {
1487     WebCore::JSMainThreadNullState state;
1488     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1489     g_return_if_fail(value);
1490     WebCore::HTMLInputElement* item = WebKit::core(self);
1491     WTF::String convertedValue = WTF::String::fromUTF8(value);
1492     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::srcAttr, convertedValue);
1493 }
1494
1495 gchar* webkit_dom_html_input_element_get_step(WebKitDOMHTMLInputElement* self)
1496 {
1497     WebCore::JSMainThreadNullState state;
1498     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1499     WebCore::HTMLInputElement* item = WebKit::core(self);
1500     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::stepAttr));
1501     return result;
1502 }
1503
1504 void webkit_dom_html_input_element_set_step(WebKitDOMHTMLInputElement* self, const gchar* value)
1505 {
1506     WebCore::JSMainThreadNullState state;
1507     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1508     g_return_if_fail(value);
1509     WebCore::HTMLInputElement* item = WebKit::core(self);
1510     WTF::String convertedValue = WTF::String::fromUTF8(value);
1511     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::stepAttr, convertedValue);
1512 }
1513
1514 gchar* webkit_dom_html_input_element_get_input_type(WebKitDOMHTMLInputElement* self)
1515 {
1516     WebCore::JSMainThreadNullState state;
1517     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1518     WebCore::HTMLInputElement* item = WebKit::core(self);
1519     gchar* result = convertToUTF8String(item->type());
1520     return result;
1521 }
1522
1523 void webkit_dom_html_input_element_set_input_type(WebKitDOMHTMLInputElement* self, const gchar* value)
1524 {
1525     WebCore::JSMainThreadNullState state;
1526     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1527     g_return_if_fail(value);
1528     WebCore::HTMLInputElement* item = WebKit::core(self);
1529     WTF::String convertedValue = WTF::String::fromUTF8(value);
1530     item->setType(convertedValue);
1531 }
1532
1533 gchar* webkit_dom_html_input_element_get_default_value(WebKitDOMHTMLInputElement* self)
1534 {
1535     WebCore::JSMainThreadNullState state;
1536     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1537     WebCore::HTMLInputElement* item = WebKit::core(self);
1538     gchar* result = convertToUTF8String(item->defaultValue());
1539     return result;
1540 }
1541
1542 void webkit_dom_html_input_element_set_default_value(WebKitDOMHTMLInputElement* self, const gchar* value)
1543 {
1544     WebCore::JSMainThreadNullState state;
1545     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1546     g_return_if_fail(value);
1547     WebCore::HTMLInputElement* item = WebKit::core(self);
1548     WTF::String convertedValue = WTF::String::fromUTF8(value);
1549     item->setDefaultValue(convertedValue);
1550 }
1551
1552 gchar* webkit_dom_html_input_element_get_value(WebKitDOMHTMLInputElement* self)
1553 {
1554     WebCore::JSMainThreadNullState state;
1555     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1556     WebCore::HTMLInputElement* item = WebKit::core(self);
1557     gchar* result = convertToUTF8String(item->value());
1558     return result;
1559 }
1560
1561 void webkit_dom_html_input_element_set_value(WebKitDOMHTMLInputElement* self, const gchar* value)
1562 {
1563     WebCore::JSMainThreadNullState state;
1564     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1565     g_return_if_fail(value);
1566     WebCore::HTMLInputElement* item = WebKit::core(self);
1567     WTF::String convertedValue = WTF::String::fromUTF8(value);
1568     item->setValue(convertedValue);
1569 }
1570
1571 gdouble webkit_dom_html_input_element_get_value_as_number(WebKitDOMHTMLInputElement* self)
1572 {
1573     WebCore::JSMainThreadNullState state;
1574     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1575     WebCore::HTMLInputElement* item = WebKit::core(self);
1576     gdouble result = item->valueAsNumber();
1577     return result;
1578 }
1579
1580 void webkit_dom_html_input_element_set_value_as_number(WebKitDOMHTMLInputElement* self, gdouble value, GError** error)
1581 {
1582     WebCore::JSMainThreadNullState state;
1583     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1584     g_return_if_fail(!error || !*error);
1585     WebCore::HTMLInputElement* item = WebKit::core(self);
1586     WebCore::ExceptionCode ec = 0;
1587     item->setValueAsNumber(value, ec);
1588     if (ec) {
1589         WebCore::ExceptionCodeDescription ecdesc(ec);
1590         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
1591     }
1592 }
1593
1594 gulong webkit_dom_html_input_element_get_width(WebKitDOMHTMLInputElement* self)
1595 {
1596     WebCore::JSMainThreadNullState state;
1597     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1598     WebCore::HTMLInputElement* item = WebKit::core(self);
1599     gulong result = item->width();
1600     return result;
1601 }
1602
1603 void webkit_dom_html_input_element_set_width(WebKitDOMHTMLInputElement* self, gulong value)
1604 {
1605     WebCore::JSMainThreadNullState state;
1606     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1607     WebCore::HTMLInputElement* item = WebKit::core(self);
1608     item->setWidth(value);
1609 }
1610
1611 gboolean webkit_dom_html_input_element_get_will_validate(WebKitDOMHTMLInputElement* self)
1612 {
1613     WebCore::JSMainThreadNullState state;
1614     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1615     WebCore::HTMLInputElement* item = WebKit::core(self);
1616     gboolean result = item->willValidate();
1617     return result;
1618 }
1619
1620 WebKitDOMValidityState* webkit_dom_html_input_element_get_validity(WebKitDOMHTMLInputElement* self)
1621 {
1622     WebCore::JSMainThreadNullState state;
1623     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1624     WebCore::HTMLInputElement* item = WebKit::core(self);
1625     RefPtr<WebCore::ValidityState> gobjectResult = WTF::getPtr(item->validity());
1626     return WebKit::kit(gobjectResult.get());
1627 }
1628
1629 gchar* webkit_dom_html_input_element_get_validation_message(WebKitDOMHTMLInputElement* self)
1630 {
1631     WebCore::JSMainThreadNullState state;
1632     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1633     WebCore::HTMLInputElement* item = WebKit::core(self);
1634     gchar* result = convertToUTF8String(item->validationMessage());
1635     return result;
1636 }
1637
1638 WebKitDOMNodeList* webkit_dom_html_input_element_get_labels(WebKitDOMHTMLInputElement* self)
1639 {
1640     WebCore::JSMainThreadNullState state;
1641     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1642     WebCore::HTMLInputElement* item = WebKit::core(self);
1643     RefPtr<WebCore::NodeList> gobjectResult = WTF::getPtr(item->labels());
1644     return WebKit::kit(gobjectResult.get());
1645 }
1646
1647 gchar* webkit_dom_html_input_element_get_align(WebKitDOMHTMLInputElement* self)
1648 {
1649     WebCore::JSMainThreadNullState state;
1650     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1651     WebCore::HTMLInputElement* item = WebKit::core(self);
1652     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::alignAttr));
1653     return result;
1654 }
1655
1656 void webkit_dom_html_input_element_set_align(WebKitDOMHTMLInputElement* self, const gchar* value)
1657 {
1658     WebCore::JSMainThreadNullState state;
1659     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1660     g_return_if_fail(value);
1661     WebCore::HTMLInputElement* item = WebKit::core(self);
1662     WTF::String convertedValue = WTF::String::fromUTF8(value);
1663     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::alignAttr, convertedValue);
1664 }
1665
1666 gchar* webkit_dom_html_input_element_get_use_map(WebKitDOMHTMLInputElement* self)
1667 {
1668     WebCore::JSMainThreadNullState state;
1669     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1670     WebCore::HTMLInputElement* item = WebKit::core(self);
1671     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::usemapAttr));
1672     return result;
1673 }
1674
1675 void webkit_dom_html_input_element_set_use_map(WebKitDOMHTMLInputElement* self, const gchar* value)
1676 {
1677     WebCore::JSMainThreadNullState state;
1678     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1679     g_return_if_fail(value);
1680     WebCore::HTMLInputElement* item = WebKit::core(self);
1681     WTF::String convertedValue = WTF::String::fromUTF8(value);
1682     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::usemapAttr, convertedValue);
1683 }
1684
1685 gboolean webkit_dom_html_input_element_get_incremental(WebKitDOMHTMLInputElement* self)
1686 {
1687     WebCore::JSMainThreadNullState state;
1688     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1689     WebCore::HTMLInputElement* item = WebKit::core(self);
1690     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::incrementalAttr);
1691     return result;
1692 }
1693
1694 void webkit_dom_html_input_element_set_incremental(WebKitDOMHTMLInputElement* self, gboolean value)
1695 {
1696     WebCore::JSMainThreadNullState state;
1697     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1698     WebCore::HTMLInputElement* item = WebKit::core(self);
1699     item->setBooleanAttribute(WebCore::HTMLNames::incrementalAttr, value);
1700 }
1701
1702 gboolean webkit_dom_html_input_element_get_autocorrect(WebKitDOMHTMLInputElement* self)
1703 {
1704 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
1705     WebCore::JSMainThreadNullState state;
1706     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), FALSE);
1707     WebCore::HTMLInputElement* item = WebKit::core(self);
1708     gboolean result = item->autocorrect();
1709     return result;
1710 #else
1711     UNUSED_PARAM(self);
1712     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
1713     return static_cast<gboolean>(0);
1714 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
1715 }
1716
1717 void webkit_dom_html_input_element_set_autocorrect(WebKitDOMHTMLInputElement* self, gboolean value)
1718 {
1719 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
1720     WebCore::JSMainThreadNullState state;
1721     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1722     WebCore::HTMLInputElement* item = WebKit::core(self);
1723     item->setAutocorrect(value);
1724 #else
1725     UNUSED_PARAM(self);
1726     UNUSED_PARAM(value);
1727     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
1728 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
1729 }
1730
1731 gchar* webkit_dom_html_input_element_get_autocapitalize(WebKitDOMHTMLInputElement* self)
1732 {
1733 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
1734     WebCore::JSMainThreadNullState state;
1735     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1736     WebCore::HTMLInputElement* item = WebKit::core(self);
1737     gchar* result = convertToUTF8String(item->autocapitalize());
1738     return result;
1739 #else
1740     UNUSED_PARAM(self);
1741     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
1742     return 0;
1743 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
1744 }
1745
1746 void webkit_dom_html_input_element_set_autocapitalize(WebKitDOMHTMLInputElement* self, const gchar* value)
1747 {
1748 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
1749     WebCore::JSMainThreadNullState state;
1750     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1751     g_return_if_fail(value);
1752     WebCore::HTMLInputElement* item = WebKit::core(self);
1753     WTF::String convertedValue = WTF::String::fromUTF8(value);
1754     item->setAutocapitalize(convertedValue);
1755 #else
1756     UNUSED_PARAM(self);
1757     UNUSED_PARAM(value);
1758     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
1759 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
1760 }
1761
1762 gchar* webkit_dom_html_input_element_get_capture_type(WebKitDOMHTMLInputElement* self)
1763 {
1764 #if ENABLE(MEDIA_CAPTURE)
1765     WebCore::JSMainThreadNullState state;
1766     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self), 0);
1767     WebCore::HTMLInputElement* item = WebKit::core(self);
1768     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::captureAttr));
1769     return result;
1770 #else
1771     UNUSED_PARAM(self);
1772     WEBKIT_WARN_FEATURE_NOT_PRESENT("Media Capture")
1773     return 0;
1774 #endif /* ENABLE(MEDIA_CAPTURE) */
1775 }
1776
1777 void webkit_dom_html_input_element_set_capture(WebKitDOMHTMLInputElement* self, const gchar* value)
1778 {
1779 #if ENABLE(MEDIA_CAPTURE)
1780     WebCore::JSMainThreadNullState state;
1781     g_return_if_fail(WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(self));
1782     g_return_if_fail(value);
1783     WebCore::HTMLInputElement* item = WebKit::core(self);
1784     WTF::String convertedValue = WTF::String::fromUTF8(value);
1785     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::captureAttr, convertedValue);
1786 #else
1787     UNUSED_PARAM(self);
1788     UNUSED_PARAM(value);
1789     WEBKIT_WARN_FEATURE_NOT_PRESENT("Media Capture")
1790 #endif /* ENABLE(MEDIA_CAPTURE) */
1791 }
1792