d2ea721c975e1f6624b6b434d517409125666349
[WebKit-https.git] / Source / WebKit2 / WebProcess / InjectedBundle / API / gtk / DOM / WebKitDOMHTMLTextAreaElement.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 "WebKitDOMHTMLTextAreaElement.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 "WebKitDOMHTMLFormElementPrivate.h"
35 #include "WebKitDOMHTMLTextAreaElementPrivate.h"
36 #include "WebKitDOMNodeListPrivate.h"
37 #include "WebKitDOMNodePrivate.h"
38 #include "WebKitDOMPrivate.h"
39 #include "WebKitDOMValidityStatePrivate.h"
40 #include "ConvertToUTF8String.h"
41 #include "WebKitDOMHTMLTextAreaElementUnstable.h"
42 #include <wtf/GetPtr.h>
43 #include <wtf/RefPtr.h>
44
45 namespace WebKit {
46
47 WebKitDOMHTMLTextAreaElement* kit(WebCore::HTMLTextAreaElement* obj)
48 {
49     return WEBKIT_DOM_HTML_TEXT_AREA_ELEMENT(kit(static_cast<WebCore::Node*>(obj)));
50 }
51
52 WebCore::HTMLTextAreaElement* core(WebKitDOMHTMLTextAreaElement* request)
53 {
54     return request ? static_cast<WebCore::HTMLTextAreaElement*>(WEBKIT_DOM_OBJECT(request)->coreObject) : 0;
55 }
56
57 WebKitDOMHTMLTextAreaElement* wrapHTMLTextAreaElement(WebCore::HTMLTextAreaElement* coreObject)
58 {
59     ASSERT(coreObject);
60     return WEBKIT_DOM_HTML_TEXT_AREA_ELEMENT(g_object_new(WEBKIT_DOM_TYPE_HTML_TEXT_AREA_ELEMENT, "core-object", coreObject, nullptr));
61 }
62
63 } // namespace WebKit
64
65 static gboolean webkit_dom_html_text_area_element_dispatch_event(WebKitDOMEventTarget* target, WebKitDOMEvent* event, GError** error)
66 {
67     WebCore::Event* coreEvent = WebKit::core(event);
68     if (!coreEvent)
69         return false;
70     WebCore::HTMLTextAreaElement* coreTarget = static_cast<WebCore::HTMLTextAreaElement*>(WEBKIT_DOM_OBJECT(target)->coreObject);
71
72     WebCore::ExceptionCode ec = 0;
73     gboolean result = coreTarget->dispatchEventForBindings(*coreEvent, ec);
74     if (ec) {
75         WebCore::ExceptionCodeDescription description(ec);
76         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), description.code, description.name);
77     }
78     return result;
79 }
80
81 static gboolean webkit_dom_html_text_area_element_add_event_listener(WebKitDOMEventTarget* target, const char* eventName, GClosure* handler, gboolean useCapture)
82 {
83     WebCore::HTMLTextAreaElement* coreTarget = static_cast<WebCore::HTMLTextAreaElement*>(WEBKIT_DOM_OBJECT(target)->coreObject);
84     return WebKit::GObjectEventListener::addEventListener(G_OBJECT(target), coreTarget, eventName, handler, useCapture);
85 }
86
87 static gboolean webkit_dom_html_text_area_element_remove_event_listener(WebKitDOMEventTarget* target, const char* eventName, GClosure* handler, gboolean useCapture)
88 {
89     WebCore::HTMLTextAreaElement* coreTarget = static_cast<WebCore::HTMLTextAreaElement*>(WEBKIT_DOM_OBJECT(target)->coreObject);
90     return WebKit::GObjectEventListener::removeEventListener(G_OBJECT(target), coreTarget, eventName, handler, useCapture);
91 }
92
93 static void webkit_dom_event_target_init(WebKitDOMEventTargetIface* iface)
94 {
95     iface->dispatch_event = webkit_dom_html_text_area_element_dispatch_event;
96     iface->add_event_listener = webkit_dom_html_text_area_element_add_event_listener;
97     iface->remove_event_listener = webkit_dom_html_text_area_element_remove_event_listener;
98 }
99
100 G_DEFINE_TYPE_WITH_CODE(WebKitDOMHTMLTextAreaElement, webkit_dom_html_text_area_element, WEBKIT_DOM_TYPE_HTML_ELEMENT, G_IMPLEMENT_INTERFACE(WEBKIT_DOM_TYPE_EVENT_TARGET, webkit_dom_event_target_init))
101
102 enum {
103     PROP_0,
104     PROP_AUTOFOCUS,
105     PROP_DIR_NAME,
106     PROP_DISABLED,
107     PROP_FORM,
108     PROP_MAX_LENGTH,
109     PROP_NAME,
110     PROP_PLACEHOLDER,
111     PROP_READ_ONLY,
112     PROP_REQUIRED,
113     PROP_ROWS,
114     PROP_COLS,
115     PROP_WRAP,
116     PROP_TYPE,
117     PROP_DEFAULT_VALUE,
118     PROP_VALUE,
119     PROP_TEXT_LENGTH,
120     PROP_WILL_VALIDATE,
121     PROP_VALIDITY,
122     PROP_VALIDATION_MESSAGE,
123     PROP_LABELS,
124     PROP_SELECTION_START,
125     PROP_SELECTION_END,
126     PROP_SELECTION_DIRECTION,
127     PROP_AUTOCORRECT,
128     PROP_AUTOCAPITALIZE,
129     PROP_AUTOCOMPLETE,
130 };
131
132 static void webkit_dom_html_text_area_element_set_property(GObject* object, guint propertyId, const GValue* value, GParamSpec* pspec)
133 {
134     WebKitDOMHTMLTextAreaElement* self = WEBKIT_DOM_HTML_TEXT_AREA_ELEMENT(object);
135
136     switch (propertyId) {
137     case PROP_AUTOFOCUS:
138         webkit_dom_html_text_area_element_set_autofocus(self, g_value_get_boolean(value));
139         break;
140     case PROP_DIR_NAME:
141         webkit_dom_html_text_area_element_set_dir_name(self, g_value_get_string(value));
142         break;
143     case PROP_DISABLED:
144         webkit_dom_html_text_area_element_set_disabled(self, g_value_get_boolean(value));
145         break;
146     case PROP_MAX_LENGTH:
147         webkit_dom_html_text_area_element_set_max_length(self, g_value_get_long(value), nullptr);
148         break;
149     case PROP_NAME:
150         webkit_dom_html_text_area_element_set_name(self, g_value_get_string(value));
151         break;
152     case PROP_PLACEHOLDER:
153         webkit_dom_html_text_area_element_set_placeholder(self, g_value_get_string(value));
154         break;
155     case PROP_READ_ONLY:
156         webkit_dom_html_text_area_element_set_read_only(self, g_value_get_boolean(value));
157         break;
158     case PROP_REQUIRED:
159         webkit_dom_html_text_area_element_set_required(self, g_value_get_boolean(value));
160         break;
161     case PROP_ROWS:
162         webkit_dom_html_text_area_element_set_rows(self, g_value_get_long(value));
163         break;
164     case PROP_COLS:
165         webkit_dom_html_text_area_element_set_cols(self, g_value_get_long(value));
166         break;
167     case PROP_WRAP:
168         webkit_dom_html_text_area_element_set_wrap(self, g_value_get_string(value));
169         break;
170     case PROP_DEFAULT_VALUE:
171         webkit_dom_html_text_area_element_set_default_value(self, g_value_get_string(value));
172         break;
173     case PROP_VALUE:
174         webkit_dom_html_text_area_element_set_value(self, g_value_get_string(value));
175         break;
176     case PROP_SELECTION_START:
177         webkit_dom_html_text_area_element_set_selection_start(self, g_value_get_long(value));
178         break;
179     case PROP_SELECTION_END:
180         webkit_dom_html_text_area_element_set_selection_end(self, g_value_get_long(value));
181         break;
182     case PROP_SELECTION_DIRECTION:
183         webkit_dom_html_text_area_element_set_selection_direction(self, g_value_get_string(value));
184         break;
185     case PROP_AUTOCORRECT:
186         webkit_dom_html_text_area_element_set_autocorrect(self, g_value_get_boolean(value));
187         break;
188     case PROP_AUTOCAPITALIZE:
189         webkit_dom_html_text_area_element_set_autocapitalize(self, g_value_get_string(value));
190         break;
191     case PROP_AUTOCOMPLETE:
192         webkit_dom_html_text_area_element_set_autocomplete(self, g_value_get_string(value));
193         break;
194     default:
195         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propertyId, pspec);
196         break;
197     }
198 }
199
200 static void webkit_dom_html_text_area_element_get_property(GObject* object, guint propertyId, GValue* value, GParamSpec* pspec)
201 {
202     WebKitDOMHTMLTextAreaElement* self = WEBKIT_DOM_HTML_TEXT_AREA_ELEMENT(object);
203
204     switch (propertyId) {
205     case PROP_AUTOFOCUS:
206         g_value_set_boolean(value, webkit_dom_html_text_area_element_get_autofocus(self));
207         break;
208     case PROP_DIR_NAME:
209         g_value_take_string(value, webkit_dom_html_text_area_element_get_dir_name(self));
210         break;
211     case PROP_DISABLED:
212         g_value_set_boolean(value, webkit_dom_html_text_area_element_get_disabled(self));
213         break;
214     case PROP_FORM:
215         g_value_set_object(value, webkit_dom_html_text_area_element_get_form(self));
216         break;
217     case PROP_MAX_LENGTH:
218         g_value_set_long(value, webkit_dom_html_text_area_element_get_max_length(self));
219         break;
220     case PROP_NAME:
221         g_value_take_string(value, webkit_dom_html_text_area_element_get_name(self));
222         break;
223     case PROP_PLACEHOLDER:
224         g_value_take_string(value, webkit_dom_html_text_area_element_get_placeholder(self));
225         break;
226     case PROP_READ_ONLY:
227         g_value_set_boolean(value, webkit_dom_html_text_area_element_get_read_only(self));
228         break;
229     case PROP_REQUIRED:
230         g_value_set_boolean(value, webkit_dom_html_text_area_element_get_required(self));
231         break;
232     case PROP_ROWS:
233         g_value_set_long(value, webkit_dom_html_text_area_element_get_rows(self));
234         break;
235     case PROP_COLS:
236         g_value_set_long(value, webkit_dom_html_text_area_element_get_cols(self));
237         break;
238     case PROP_WRAP:
239         g_value_take_string(value, webkit_dom_html_text_area_element_get_wrap(self));
240         break;
241     case PROP_TYPE:
242         g_value_take_string(value, webkit_dom_html_text_area_element_get_area_type(self));
243         break;
244     case PROP_DEFAULT_VALUE:
245         g_value_take_string(value, webkit_dom_html_text_area_element_get_default_value(self));
246         break;
247     case PROP_VALUE:
248         g_value_take_string(value, webkit_dom_html_text_area_element_get_value(self));
249         break;
250     case PROP_TEXT_LENGTH:
251         g_value_set_ulong(value, webkit_dom_html_text_area_element_get_text_length(self));
252         break;
253     case PROP_WILL_VALIDATE:
254         g_value_set_boolean(value, webkit_dom_html_text_area_element_get_will_validate(self));
255         break;
256     case PROP_VALIDITY:
257         g_value_set_object(value, webkit_dom_html_text_area_element_get_validity(self));
258         break;
259     case PROP_VALIDATION_MESSAGE:
260         g_value_take_string(value, webkit_dom_html_text_area_element_get_validation_message(self));
261         break;
262     case PROP_LABELS:
263         g_value_set_object(value, webkit_dom_html_text_area_element_get_labels(self));
264         break;
265     case PROP_SELECTION_START:
266         g_value_set_long(value, webkit_dom_html_text_area_element_get_selection_start(self));
267         break;
268     case PROP_SELECTION_END:
269         g_value_set_long(value, webkit_dom_html_text_area_element_get_selection_end(self));
270         break;
271     case PROP_SELECTION_DIRECTION:
272         g_value_take_string(value, webkit_dom_html_text_area_element_get_selection_direction(self));
273         break;
274     case PROP_AUTOCORRECT:
275         g_value_set_boolean(value, webkit_dom_html_text_area_element_get_autocorrect(self));
276         break;
277     case PROP_AUTOCAPITALIZE:
278         g_value_take_string(value, webkit_dom_html_text_area_element_get_autocapitalize(self));
279         break;
280     case PROP_AUTOCOMPLETE:
281         g_value_take_string(value, webkit_dom_html_text_area_element_get_autocomplete(self));
282         break;
283     default:
284         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propertyId, pspec);
285         break;
286     }
287 }
288
289 static void webkit_dom_html_text_area_element_class_init(WebKitDOMHTMLTextAreaElementClass* requestClass)
290 {
291     GObjectClass* gobjectClass = G_OBJECT_CLASS(requestClass);
292     gobjectClass->set_property = webkit_dom_html_text_area_element_set_property;
293     gobjectClass->get_property = webkit_dom_html_text_area_element_get_property;
294
295     g_object_class_install_property(
296         gobjectClass,
297         PROP_AUTOFOCUS,
298         g_param_spec_boolean(
299             "autofocus",
300             "HTMLTextAreaElement:autofocus",
301             "read-write gboolean HTMLTextAreaElement:autofocus",
302             FALSE,
303             WEBKIT_PARAM_READWRITE));
304
305     g_object_class_install_property(
306         gobjectClass,
307         PROP_DIR_NAME,
308         g_param_spec_string(
309             "dir-name",
310             "HTMLTextAreaElement:dir-name",
311             "read-write gchar* HTMLTextAreaElement:dir-name",
312             "",
313             WEBKIT_PARAM_READWRITE));
314
315     g_object_class_install_property(
316         gobjectClass,
317         PROP_DISABLED,
318         g_param_spec_boolean(
319             "disabled",
320             "HTMLTextAreaElement:disabled",
321             "read-write gboolean HTMLTextAreaElement:disabled",
322             FALSE,
323             WEBKIT_PARAM_READWRITE));
324
325     g_object_class_install_property(
326         gobjectClass,
327         PROP_FORM,
328         g_param_spec_object(
329             "form",
330             "HTMLTextAreaElement:form",
331             "read-only WebKitDOMHTMLFormElement* HTMLTextAreaElement:form",
332             WEBKIT_DOM_TYPE_HTML_FORM_ELEMENT,
333             WEBKIT_PARAM_READABLE));
334
335     g_object_class_install_property(
336         gobjectClass,
337         PROP_MAX_LENGTH,
338         g_param_spec_long(
339             "max-length",
340             "HTMLTextAreaElement:max-length",
341             "read-write glong HTMLTextAreaElement:max-length",
342             G_MINLONG, G_MAXLONG, 0,
343             WEBKIT_PARAM_READWRITE));
344
345     g_object_class_install_property(
346         gobjectClass,
347         PROP_NAME,
348         g_param_spec_string(
349             "name",
350             "HTMLTextAreaElement:name",
351             "read-write gchar* HTMLTextAreaElement:name",
352             "",
353             WEBKIT_PARAM_READWRITE));
354
355     g_object_class_install_property(
356         gobjectClass,
357         PROP_PLACEHOLDER,
358         g_param_spec_string(
359             "placeholder",
360             "HTMLTextAreaElement:placeholder",
361             "read-write gchar* HTMLTextAreaElement:placeholder",
362             "",
363             WEBKIT_PARAM_READWRITE));
364
365     g_object_class_install_property(
366         gobjectClass,
367         PROP_READ_ONLY,
368         g_param_spec_boolean(
369             "read-only",
370             "HTMLTextAreaElement:read-only",
371             "read-write gboolean HTMLTextAreaElement:read-only",
372             FALSE,
373             WEBKIT_PARAM_READWRITE));
374
375     g_object_class_install_property(
376         gobjectClass,
377         PROP_REQUIRED,
378         g_param_spec_boolean(
379             "required",
380             "HTMLTextAreaElement:required",
381             "read-write gboolean HTMLTextAreaElement:required",
382             FALSE,
383             WEBKIT_PARAM_READWRITE));
384
385     g_object_class_install_property(
386         gobjectClass,
387         PROP_ROWS,
388         g_param_spec_long(
389             "rows",
390             "HTMLTextAreaElement:rows",
391             "read-write glong HTMLTextAreaElement:rows",
392             G_MINLONG, G_MAXLONG, 0,
393             WEBKIT_PARAM_READWRITE));
394
395     g_object_class_install_property(
396         gobjectClass,
397         PROP_COLS,
398         g_param_spec_long(
399             "cols",
400             "HTMLTextAreaElement:cols",
401             "read-write glong HTMLTextAreaElement:cols",
402             G_MINLONG, G_MAXLONG, 0,
403             WEBKIT_PARAM_READWRITE));
404
405     g_object_class_install_property(
406         gobjectClass,
407         PROP_WRAP,
408         g_param_spec_string(
409             "wrap",
410             "HTMLTextAreaElement:wrap",
411             "read-write gchar* HTMLTextAreaElement:wrap",
412             "",
413             WEBKIT_PARAM_READWRITE));
414
415     g_object_class_install_property(
416         gobjectClass,
417         PROP_TYPE,
418         g_param_spec_string(
419             "type",
420             "HTMLTextAreaElement:type",
421             "read-only gchar* HTMLTextAreaElement:type",
422             "",
423             WEBKIT_PARAM_READABLE));
424
425     g_object_class_install_property(
426         gobjectClass,
427         PROP_DEFAULT_VALUE,
428         g_param_spec_string(
429             "default-value",
430             "HTMLTextAreaElement:default-value",
431             "read-write gchar* HTMLTextAreaElement:default-value",
432             "",
433             WEBKIT_PARAM_READWRITE));
434
435     g_object_class_install_property(
436         gobjectClass,
437         PROP_VALUE,
438         g_param_spec_string(
439             "value",
440             "HTMLTextAreaElement:value",
441             "read-write gchar* HTMLTextAreaElement:value",
442             "",
443             WEBKIT_PARAM_READWRITE));
444
445     g_object_class_install_property(
446         gobjectClass,
447         PROP_TEXT_LENGTH,
448         g_param_spec_ulong(
449             "text-length",
450             "HTMLTextAreaElement:text-length",
451             "read-only gulong HTMLTextAreaElement:text-length",
452             0, G_MAXULONG, 0,
453             WEBKIT_PARAM_READABLE));
454
455     g_object_class_install_property(
456         gobjectClass,
457         PROP_WILL_VALIDATE,
458         g_param_spec_boolean(
459             "will-validate",
460             "HTMLTextAreaElement:will-validate",
461             "read-only gboolean HTMLTextAreaElement:will-validate",
462             FALSE,
463             WEBKIT_PARAM_READABLE));
464
465     g_object_class_install_property(
466         gobjectClass,
467         PROP_VALIDITY,
468         g_param_spec_object(
469             "validity",
470             "HTMLTextAreaElement:validity",
471             "read-only WebKitDOMValidityState* HTMLTextAreaElement:validity",
472             WEBKIT_DOM_TYPE_VALIDITY_STATE,
473             WEBKIT_PARAM_READABLE));
474
475     g_object_class_install_property(
476         gobjectClass,
477         PROP_VALIDATION_MESSAGE,
478         g_param_spec_string(
479             "validation-message",
480             "HTMLTextAreaElement:validation-message",
481             "read-only gchar* HTMLTextAreaElement:validation-message",
482             "",
483             WEBKIT_PARAM_READABLE));
484
485     g_object_class_install_property(
486         gobjectClass,
487         PROP_LABELS,
488         g_param_spec_object(
489             "labels",
490             "HTMLTextAreaElement:labels",
491             "read-only WebKitDOMNodeList* HTMLTextAreaElement:labels",
492             WEBKIT_DOM_TYPE_NODE_LIST,
493             WEBKIT_PARAM_READABLE));
494
495     g_object_class_install_property(
496         gobjectClass,
497         PROP_SELECTION_START,
498         g_param_spec_long(
499             "selection-start",
500             "HTMLTextAreaElement:selection-start",
501             "read-write glong HTMLTextAreaElement:selection-start",
502             G_MINLONG, G_MAXLONG, 0,
503             WEBKIT_PARAM_READWRITE));
504
505     g_object_class_install_property(
506         gobjectClass,
507         PROP_SELECTION_END,
508         g_param_spec_long(
509             "selection-end",
510             "HTMLTextAreaElement:selection-end",
511             "read-write glong HTMLTextAreaElement:selection-end",
512             G_MINLONG, G_MAXLONG, 0,
513             WEBKIT_PARAM_READWRITE));
514
515     g_object_class_install_property(
516         gobjectClass,
517         PROP_SELECTION_DIRECTION,
518         g_param_spec_string(
519             "selection-direction",
520             "HTMLTextAreaElement:selection-direction",
521             "read-write gchar* HTMLTextAreaElement:selection-direction",
522             "",
523             WEBKIT_PARAM_READWRITE));
524
525     g_object_class_install_property(
526         gobjectClass,
527         PROP_AUTOCORRECT,
528         g_param_spec_boolean(
529             "autocorrect",
530             "HTMLTextAreaElement:autocorrect",
531             "read-write gboolean HTMLTextAreaElement:autocorrect",
532             FALSE,
533             WEBKIT_PARAM_READWRITE));
534
535     g_object_class_install_property(
536         gobjectClass,
537         PROP_AUTOCAPITALIZE,
538         g_param_spec_string(
539             "autocapitalize",
540             "HTMLTextAreaElement:autocapitalize",
541             "read-write gchar* HTMLTextAreaElement:autocapitalize",
542             "",
543             WEBKIT_PARAM_READWRITE));
544
545     g_object_class_install_property(
546         gobjectClass,
547         PROP_AUTOCOMPLETE,
548         g_param_spec_string(
549             "autocomplete",
550             "HTMLTextAreaElement:autocomplete",
551             "read-write gchar* HTMLTextAreaElement:autocomplete",
552             "",
553             WEBKIT_PARAM_READWRITE));
554
555 }
556
557 static void webkit_dom_html_text_area_element_init(WebKitDOMHTMLTextAreaElement* request)
558 {
559     UNUSED_PARAM(request);
560 }
561
562 gboolean webkit_dom_html_text_area_element_check_validity(WebKitDOMHTMLTextAreaElement* self)
563 {
564     WebCore::JSMainThreadNullState state;
565     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), FALSE);
566     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
567     gboolean result = item->checkValidity();
568     return result;
569 }
570
571 void webkit_dom_html_text_area_element_set_custom_validity(WebKitDOMHTMLTextAreaElement* self, const gchar* error)
572 {
573     WebCore::JSMainThreadNullState state;
574     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
575     g_return_if_fail(error);
576     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
577     WTF::String convertedError = WTF::String::fromUTF8(error);
578     item->setCustomValidity(convertedError);
579 }
580
581 void webkit_dom_html_text_area_element_select(WebKitDOMHTMLTextAreaElement* self)
582 {
583     WebCore::JSMainThreadNullState state;
584     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
585     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
586     item->select();
587 }
588
589 void webkit_dom_html_text_area_element_set_range_text(WebKitDOMHTMLTextAreaElement* self, const gchar* replacement, gulong start, gulong end, const gchar* selectionMode, GError** error)
590 {
591     WebCore::JSMainThreadNullState state;
592     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
593     g_return_if_fail(replacement);
594     g_return_if_fail(selectionMode);
595     g_return_if_fail(!error || !*error);
596     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
597     WTF::String convertedReplacement = WTF::String::fromUTF8(replacement);
598     WTF::String convertedSelectionMode = WTF::String::fromUTF8(selectionMode);
599     WebCore::ExceptionCode ec = 0;
600     item->setRangeText(convertedReplacement, start, end, convertedSelectionMode, ec);
601     if (ec) {
602         WebCore::ExceptionCodeDescription ecdesc(ec);
603         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
604     }
605 }
606
607 void webkit_dom_html_text_area_element_set_selection_range(WebKitDOMHTMLTextAreaElement* self, glong start, glong end, const gchar* direction)
608 {
609     WebCore::JSMainThreadNullState state;
610     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
611     g_return_if_fail(direction);
612     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
613     WTF::String convertedDirection = WTF::String::fromUTF8(direction);
614     item->setSelectionRange(start, end, convertedDirection);
615 }
616
617 gboolean webkit_dom_html_text_area_element_get_autofocus(WebKitDOMHTMLTextAreaElement* self)
618 {
619     WebCore::JSMainThreadNullState state;
620     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), FALSE);
621     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
622     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::autofocusAttr);
623     return result;
624 }
625
626 void webkit_dom_html_text_area_element_set_autofocus(WebKitDOMHTMLTextAreaElement* self, gboolean value)
627 {
628     WebCore::JSMainThreadNullState state;
629     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
630     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
631     item->setBooleanAttribute(WebCore::HTMLNames::autofocusAttr, value);
632 }
633
634 gchar* webkit_dom_html_text_area_element_get_dir_name(WebKitDOMHTMLTextAreaElement* self)
635 {
636     WebCore::JSMainThreadNullState state;
637     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
638     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
639     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::dirnameAttr));
640     return result;
641 }
642
643 void webkit_dom_html_text_area_element_set_dir_name(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
644 {
645     WebCore::JSMainThreadNullState state;
646     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
647     g_return_if_fail(value);
648     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
649     WTF::String convertedValue = WTF::String::fromUTF8(value);
650     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::dirnameAttr, convertedValue);
651 }
652
653 gboolean webkit_dom_html_text_area_element_get_disabled(WebKitDOMHTMLTextAreaElement* self)
654 {
655     WebCore::JSMainThreadNullState state;
656     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), FALSE);
657     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
658     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::disabledAttr);
659     return result;
660 }
661
662 void webkit_dom_html_text_area_element_set_disabled(WebKitDOMHTMLTextAreaElement* self, gboolean value)
663 {
664     WebCore::JSMainThreadNullState state;
665     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
666     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
667     item->setBooleanAttribute(WebCore::HTMLNames::disabledAttr, value);
668 }
669
670 WebKitDOMHTMLFormElement* webkit_dom_html_text_area_element_get_form(WebKitDOMHTMLTextAreaElement* self)
671 {
672     WebCore::JSMainThreadNullState state;
673     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
674     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
675     RefPtr<WebCore::HTMLFormElement> gobjectResult = WTF::getPtr(item->form());
676     return WebKit::kit(gobjectResult.get());
677 }
678
679 glong webkit_dom_html_text_area_element_get_max_length(WebKitDOMHTMLTextAreaElement* self)
680 {
681     WebCore::JSMainThreadNullState state;
682     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
683     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
684     glong result = item->maxLengthForBindings();
685     return result;
686 }
687
688 void webkit_dom_html_text_area_element_set_max_length(WebKitDOMHTMLTextAreaElement* self, glong value, GError** error)
689 {
690     WebCore::JSMainThreadNullState state;
691     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
692     g_return_if_fail(!error || !*error);
693     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
694     WebCore::ExceptionCode ec = 0;
695     item->setMaxLengthForBindings(value, ec);
696     if (ec) {
697         WebCore::ExceptionCodeDescription ecdesc(ec);
698         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
699     }
700 }
701
702 gchar* webkit_dom_html_text_area_element_get_name(WebKitDOMHTMLTextAreaElement* self)
703 {
704     WebCore::JSMainThreadNullState state;
705     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
706     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
707     gchar* result = convertToUTF8String(item->getNameAttribute());
708     return result;
709 }
710
711 void webkit_dom_html_text_area_element_set_name(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
712 {
713     WebCore::JSMainThreadNullState state;
714     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
715     g_return_if_fail(value);
716     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
717     WTF::String convertedValue = WTF::String::fromUTF8(value);
718     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::nameAttr, convertedValue);
719 }
720
721 gchar* webkit_dom_html_text_area_element_get_placeholder(WebKitDOMHTMLTextAreaElement* self)
722 {
723     WebCore::JSMainThreadNullState state;
724     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
725     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
726     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::placeholderAttr));
727     return result;
728 }
729
730 void webkit_dom_html_text_area_element_set_placeholder(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
731 {
732     WebCore::JSMainThreadNullState state;
733     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
734     g_return_if_fail(value);
735     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
736     WTF::String convertedValue = WTF::String::fromUTF8(value);
737     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::placeholderAttr, convertedValue);
738 }
739
740 gboolean webkit_dom_html_text_area_element_get_read_only(WebKitDOMHTMLTextAreaElement* self)
741 {
742     WebCore::JSMainThreadNullState state;
743     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), FALSE);
744     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
745     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::readonlyAttr);
746     return result;
747 }
748
749 void webkit_dom_html_text_area_element_set_read_only(WebKitDOMHTMLTextAreaElement* self, gboolean value)
750 {
751     WebCore::JSMainThreadNullState state;
752     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
753     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
754     item->setBooleanAttribute(WebCore::HTMLNames::readonlyAttr, value);
755 }
756
757 gboolean webkit_dom_html_text_area_element_get_required(WebKitDOMHTMLTextAreaElement* self)
758 {
759     WebCore::JSMainThreadNullState state;
760     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), FALSE);
761     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
762     gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::requiredAttr);
763     return result;
764 }
765
766 void webkit_dom_html_text_area_element_set_required(WebKitDOMHTMLTextAreaElement* self, gboolean value)
767 {
768     WebCore::JSMainThreadNullState state;
769     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
770     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
771     item->setBooleanAttribute(WebCore::HTMLNames::requiredAttr, value);
772 }
773
774 glong webkit_dom_html_text_area_element_get_rows(WebKitDOMHTMLTextAreaElement* self)
775 {
776     WebCore::JSMainThreadNullState state;
777     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
778     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
779     glong result = item->rows();
780     return result;
781 }
782
783 void webkit_dom_html_text_area_element_set_rows(WebKitDOMHTMLTextAreaElement* self, glong value)
784 {
785     WebCore::JSMainThreadNullState state;
786     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
787     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
788     item->setRows(value);
789 }
790
791 glong webkit_dom_html_text_area_element_get_cols(WebKitDOMHTMLTextAreaElement* self)
792 {
793     WebCore::JSMainThreadNullState state;
794     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
795     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
796     glong result = item->cols();
797     return result;
798 }
799
800 void webkit_dom_html_text_area_element_set_cols(WebKitDOMHTMLTextAreaElement* self, glong value)
801 {
802     WebCore::JSMainThreadNullState state;
803     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
804     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
805     item->setCols(value);
806 }
807
808 gchar* webkit_dom_html_text_area_element_get_wrap(WebKitDOMHTMLTextAreaElement* self)
809 {
810     WebCore::JSMainThreadNullState state;
811     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
812     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
813     gchar* result = convertToUTF8String(item->attributeWithoutSynchronization(WebCore::HTMLNames::wrapAttr));
814     return result;
815 }
816
817 void webkit_dom_html_text_area_element_set_wrap(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
818 {
819     WebCore::JSMainThreadNullState state;
820     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
821     g_return_if_fail(value);
822     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
823     WTF::String convertedValue = WTF::String::fromUTF8(value);
824     item->setAttributeWithoutSynchronization(WebCore::HTMLNames::wrapAttr, convertedValue);
825 }
826
827 gchar* webkit_dom_html_text_area_element_get_area_type(WebKitDOMHTMLTextAreaElement* self)
828 {
829     WebCore::JSMainThreadNullState state;
830     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
831     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
832     gchar* result = convertToUTF8String(item->type());
833     return result;
834 }
835
836 gchar* webkit_dom_html_text_area_element_get_default_value(WebKitDOMHTMLTextAreaElement* self)
837 {
838     WebCore::JSMainThreadNullState state;
839     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
840     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
841     gchar* result = convertToUTF8String(item->defaultValue());
842     return result;
843 }
844
845 void webkit_dom_html_text_area_element_set_default_value(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
846 {
847     WebCore::JSMainThreadNullState state;
848     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
849     g_return_if_fail(value);
850     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
851     WTF::String convertedValue = WTF::String::fromUTF8(value);
852     item->setDefaultValue(convertedValue);
853 }
854
855 gchar* webkit_dom_html_text_area_element_get_value(WebKitDOMHTMLTextAreaElement* self)
856 {
857     WebCore::JSMainThreadNullState state;
858     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
859     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
860     gchar* result = convertToUTF8String(item->value());
861     return result;
862 }
863
864 void webkit_dom_html_text_area_element_set_value(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
865 {
866     WebCore::JSMainThreadNullState state;
867     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
868     g_return_if_fail(value);
869     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
870     WTF::String convertedValue = WTF::String::fromUTF8(value);
871     item->setValue(convertedValue);
872 }
873
874 gulong webkit_dom_html_text_area_element_get_text_length(WebKitDOMHTMLTextAreaElement* self)
875 {
876     WebCore::JSMainThreadNullState state;
877     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
878     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
879     gulong result = item->textLength();
880     return result;
881 }
882
883 gboolean webkit_dom_html_text_area_element_get_will_validate(WebKitDOMHTMLTextAreaElement* self)
884 {
885     WebCore::JSMainThreadNullState state;
886     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), FALSE);
887     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
888     gboolean result = item->willValidate();
889     return result;
890 }
891
892 WebKitDOMValidityState* webkit_dom_html_text_area_element_get_validity(WebKitDOMHTMLTextAreaElement* self)
893 {
894     WebCore::JSMainThreadNullState state;
895     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
896     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
897     RefPtr<WebCore::ValidityState> gobjectResult = WTF::getPtr(item->validity());
898     return WebKit::kit(gobjectResult.get());
899 }
900
901 gchar* webkit_dom_html_text_area_element_get_validation_message(WebKitDOMHTMLTextAreaElement* self)
902 {
903     WebCore::JSMainThreadNullState state;
904     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
905     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
906     gchar* result = convertToUTF8String(item->validationMessage());
907     return result;
908 }
909
910 WebKitDOMNodeList* webkit_dom_html_text_area_element_get_labels(WebKitDOMHTMLTextAreaElement* self)
911 {
912     WebCore::JSMainThreadNullState state;
913     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
914     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
915     RefPtr<WebCore::NodeList> gobjectResult = WTF::getPtr(item->labels());
916     return WebKit::kit(gobjectResult.get());
917 }
918
919 glong webkit_dom_html_text_area_element_get_selection_start(WebKitDOMHTMLTextAreaElement* self)
920 {
921     WebCore::JSMainThreadNullState state;
922     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
923     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
924     glong result = item->selectionStart();
925     return result;
926 }
927
928 void webkit_dom_html_text_area_element_set_selection_start(WebKitDOMHTMLTextAreaElement* self, glong value)
929 {
930     WebCore::JSMainThreadNullState state;
931     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
932     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
933     item->setSelectionStart(value);
934 }
935
936 glong webkit_dom_html_text_area_element_get_selection_end(WebKitDOMHTMLTextAreaElement* self)
937 {
938     WebCore::JSMainThreadNullState state;
939     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
940     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
941     glong result = item->selectionEnd();
942     return result;
943 }
944
945 void webkit_dom_html_text_area_element_set_selection_end(WebKitDOMHTMLTextAreaElement* self, glong value)
946 {
947     WebCore::JSMainThreadNullState state;
948     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
949     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
950     item->setSelectionEnd(value);
951 }
952
953 gchar* webkit_dom_html_text_area_element_get_selection_direction(WebKitDOMHTMLTextAreaElement* self)
954 {
955     WebCore::JSMainThreadNullState state;
956     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
957     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
958     gchar* result = convertToUTF8String(item->selectionDirection());
959     return result;
960 }
961
962 void webkit_dom_html_text_area_element_set_selection_direction(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
963 {
964     WebCore::JSMainThreadNullState state;
965     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
966     g_return_if_fail(value);
967     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
968     WTF::String convertedValue = WTF::String::fromUTF8(value);
969     item->setSelectionDirection(convertedValue);
970 }
971
972 gboolean webkit_dom_html_text_area_element_get_autocorrect(WebKitDOMHTMLTextAreaElement* self)
973 {
974 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
975     WebCore::JSMainThreadNullState state;
976     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), FALSE);
977     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
978     gboolean result = item->autocorrect();
979     return result;
980 #else
981     UNUSED_PARAM(self);
982     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
983     return static_cast<gboolean>(0);
984 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
985 }
986
987 void webkit_dom_html_text_area_element_set_autocorrect(WebKitDOMHTMLTextAreaElement* self, gboolean value)
988 {
989 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
990     WebCore::JSMainThreadNullState state;
991     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
992     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
993     item->setAutocorrect(value);
994 #else
995     UNUSED_PARAM(self);
996     UNUSED_PARAM(value);
997     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
998 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
999 }
1000
1001 gchar* webkit_dom_html_text_area_element_get_autocapitalize(WebKitDOMHTMLTextAreaElement* self)
1002 {
1003 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
1004     WebCore::JSMainThreadNullState state;
1005     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
1006     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
1007     gchar* result = convertToUTF8String(item->autocapitalize());
1008     return result;
1009 #else
1010     UNUSED_PARAM(self);
1011     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
1012     return 0;
1013 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
1014 }
1015
1016 void webkit_dom_html_text_area_element_set_autocapitalize(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
1017 {
1018 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
1019     WebCore::JSMainThreadNullState state;
1020     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
1021     g_return_if_fail(value);
1022     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
1023     WTF::String convertedValue = WTF::String::fromUTF8(value);
1024     item->setAutocapitalize(convertedValue);
1025 #else
1026     UNUSED_PARAM(self);
1027     UNUSED_PARAM(value);
1028     WEBKIT_WARN_FEATURE_NOT_PRESENT("Ios Autocorrect And Autocapitalize")
1029 #endif /* ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE) */
1030 }
1031
1032 gchar* webkit_dom_html_text_area_element_get_autocomplete(WebKitDOMHTMLTextAreaElement* self)
1033 {
1034     WebCore::JSMainThreadNullState state;
1035     g_return_val_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self), 0);
1036     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
1037     gchar* result = convertToUTF8String(item->autocomplete());
1038     return result;
1039 }
1040
1041 void webkit_dom_html_text_area_element_set_autocomplete(WebKitDOMHTMLTextAreaElement* self, const gchar* value)
1042 {
1043     WebCore::JSMainThreadNullState state;
1044     g_return_if_fail(WEBKIT_DOM_IS_HTML_TEXT_AREA_ELEMENT(self));
1045     g_return_if_fail(value);
1046     WebCore::HTMLTextAreaElement* item = WebKit::core(self);
1047     WTF::String convertedValue = WTF::String::fromUTF8(value);
1048     item->setAutocomplete(convertedValue);
1049 }
1050