[EFL] Change data type of parameter in ewk_view_viewport_attributes_get().
[WebKit-https.git] / Source / WebKit / efl / ewk / ewk_view.cpp
1 /*
2     Copyright (C) 2009-2010 ProFUSION embedded systems
3     Copyright (C) 2009-2011 Samsung Electronics
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 #define __STDC_FORMAT_MACROS
22 #include "config.h"
23 #include "ewk_view.h"
24
25 #include "BackForwardListImpl.h"
26 #include "Bridge.h"
27 #include "Chrome.h"
28 #include "ChromeClientEfl.h"
29 #include "ContextMenuController.h"
30 #include "DocumentLoader.h"
31 #include "DragClientEfl.h"
32 #include "EWebKit.h"
33 #include "EditorClientEfl.h"
34 #include "EventHandler.h"
35 #include "FocusController.h"
36 #include "FrameLoaderClientEfl.h"
37 #include "FrameView.h"
38 #include "GraphicsContext.h"
39 #include "HTMLElement.h"
40 #include "HTMLInputElement.h"
41 #include "HTMLNames.h"
42 #include "InspectorClientEfl.h"
43 #include "IntSize.h"
44 #include "JSDOMBinding.h"
45 #include "JSDOMWindow.h"
46 #include "JSLock.h"
47 #include "PlatformMouseEvent.h"
48 #include "PopupMenuClient.h"
49 #include "ProgressTracker.h"
50 #include "RenderTheme.h"
51 #include "c_instance.h"
52 #include "ewk_private.h"
53 #include "ewk_protocol_handler.h"
54
55 #include <Ecore.h>
56 #include <Eina.h>
57 #include <Evas.h>
58 #include <eina_safety_checks.h>
59 #include <inttypes.h>
60 #include <limits>
61 #include <math.h>
62 #include <sys/time.h>
63
64 #if ENABLE(DEVICE_ORIENTATION)
65 #include "DeviceMotionClientEfl.h"
66 #include "DeviceOrientationClientEfl.h"
67 #endif
68
69 #define ZOOM_MIN (0.05)
70 #define ZOOM_MAX (4.0)
71
72 #define DEVICE_PIXEL_RATIO (1.0)
73
74 static const char EWK_VIEW_TYPE_STR[] = "EWK_View";
75
76 static const size_t EWK_VIEW_REPAINTS_SIZE_INITIAL = 32;
77 static const size_t EWK_VIEW_REPAINTS_SIZE_STEP = 8;
78 static const size_t EWK_VIEW_REPAINTS_SIZE_MAX_FREE = 64;
79
80 static const size_t EWK_VIEW_SCROLLS_SIZE_INITIAL = 8;
81 static const size_t EWK_VIEW_SCROLLS_SIZE_STEP = 2;
82 static const size_t EWK_VIEW_SCROLLS_SIZE_MAX_FREE = 32;
83
84 /**
85  * @brief Private data that is used internally by EFL WebKit
86  * and should never be modified from outside.
87  *
88  * @internal
89  */
90 struct _Ewk_View_Private_Data {
91     WebCore::Page* page;
92     WebCore::Settings* page_settings;
93     WebCore::Frame* main_frame;
94     WebCore::ViewportArguments viewport_arguments;
95     Ewk_History* history;
96     struct {
97         void* context;
98         Ewk_View_Resource_Handler_Cb function;
99     } custom_resource_handler;
100     struct {
101         Ewk_Menu menu;
102         WebCore::PopupMenuClient* menu_client;
103     } popup;
104     struct {
105         Eina_Rectangle* array;
106         size_t count;
107         size_t allocated;
108     } repaints;
109     struct {
110         Ewk_Scroll_Request* array;
111         size_t count;
112         size_t allocated;
113     } scrolls;
114     unsigned int imh; /**< input method hints */
115     struct {
116         Eina_Bool view_cleared : 1;
117         Eina_Bool need_touch_events : 1;
118     } flags;
119     struct {
120         const char* user_agent;
121         const char* user_stylesheet;
122         const char* encoding_default;
123         const char* encoding_custom;
124         const char* theme;
125         const char* local_storage_database_path;
126         int font_minimum_size;
127         int font_minimum_logical_size;
128         int font_default_size;
129         int font_monospace_size;
130         const char* font_standard;
131         const char* font_cursive;
132         const char* font_monospace;
133         const char* font_fantasy;
134         const char* font_serif;
135         const char* font_sans_serif;
136         Eina_Bool auto_load_images : 1;
137         Eina_Bool auto_shrink_images : 1;
138         Eina_Bool enable_auto_resize_window : 1;
139         Eina_Bool enable_developer_extras : 1;
140         Eina_Bool enable_scripts : 1;
141         Eina_Bool enable_plugins : 1;
142         Eina_Bool enable_frame_flattening : 1;
143         Eina_Bool encoding_detector : 1;
144         Eina_Bool scripts_window_open : 1;
145         Eina_Bool scripts_can_close_windows : 1;
146         Eina_Bool resizable_textareas : 1;
147         Eina_Bool private_browsing : 1;
148         Eina_Bool caret_browsing : 1;
149         Eina_Bool spatial_navigation : 1;
150         Eina_Bool local_storage : 1;
151         Eina_Bool offline_app_cache : 1;
152         Eina_Bool page_cache : 1;
153         struct {
154             float min_scale;
155             float max_scale;
156             Eina_Bool user_scalable : 1;
157         } zoom_range;
158         float device_pixel_ratio;
159         double dom_timer_interval;
160     } settings;
161     struct {
162         struct {
163             double start;
164             double end;
165             double duration;
166         } time;
167         struct {
168             float start;
169             float end;
170             float range;
171         } zoom;
172         struct {
173             Evas_Coord x, y;
174         } center;
175         Ecore_Animator* animator;
176     } animated_zoom;
177 };
178
179 #ifndef EWK_TYPE_CHECK
180 #define EWK_VIEW_TYPE_CHECK(o, ...) do { } while (0)
181 #else
182 #define EWK_VIEW_TYPE_CHECK(o, ...)                                     \
183     do {                                                                \
184         const char* _tmp_otype = evas_object_type_get(o);               \
185         const Evas_Smart* _tmp_s = evas_object_smart_smart_get(o);      \
186         if (EINA_UNLIKELY(!_tmp_s)) {                                   \
187             EINA_LOG_CRIT                                               \
188                 ("%p (%s) is not a smart object!", o,                   \
189                 _tmp_otype ? _tmp_otype : "(null)");                   \
190             return __VA_ARGS__;                                         \
191         }                                                               \
192         const Evas_Smart_Class* _tmp_sc = evas_smart_class_get(_tmp_s); \
193         if (EINA_UNLIKELY(!_tmp_sc)) {                                  \
194             EINA_LOG_CRIT                                               \
195                 ("%p (%s) is not a smart object!", o,                   \
196                 _tmp_otype ? _tmp_otype : "(null)");                   \
197             return __VA_ARGS__;                                         \
198         }                                                               \
199         if (EINA_UNLIKELY(_tmp_sc->data != EWK_VIEW_TYPE_STR)) {        \
200             EINA_LOG_CRIT                                               \
201                 ("%p (%s) is not of an ewk_view (need %p, got %p)!",    \
202                 o, _tmp_otype ? _tmp_otype : "(null)",                 \
203                 EWK_VIEW_TYPE_STR, _tmp_sc->data);                     \
204             return __VA_ARGS__;                                         \
205         }                                                               \
206     } while (0)
207 #endif
208
209 #define EWK_VIEW_SD_GET(o, ptr)                                 \
210     Ewk_View_Smart_Data* ptr = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(o))
211
212 #define EWK_VIEW_SD_GET_OR_RETURN(o, ptr, ...)          \
213     EWK_VIEW_TYPE_CHECK(o, __VA_ARGS__);                \
214     EWK_VIEW_SD_GET(o, ptr);                            \
215     if (!ptr) {                                         \
216         CRITICAL("no smart data for object %p (%s)",    \
217                  o, evas_object_type_get(o));           \
218         return __VA_ARGS__;                             \
219     }
220
221 #define EWK_VIEW_PRIV_GET(sd, ptr)              \
222     Ewk_View_Private_Data *ptr = sd->_priv
223
224 #define EWK_VIEW_PRIV_GET_OR_RETURN(sd, ptr, ...)               \
225     EWK_VIEW_PRIV_GET(sd, ptr);                                 \
226     if (!ptr) {                                                 \
227         CRITICAL("no private data for object %p (%s)",          \
228                  sd->self, evas_object_type_get(sd->self));     \
229         return __VA_ARGS__;                                     \
230     }
231
232 static void _ewk_view_smart_changed(Ewk_View_Smart_Data* sd)
233 {
234     if (sd->changed.any)
235         return;
236     sd->changed.any = EINA_TRUE;
237     evas_object_smart_changed(sd->self);
238 }
239
240 static Eina_Bool _ewk_view_repaints_resize(Ewk_View_Private_Data* priv, size_t size)
241 {
242     void* tmp = realloc(priv->repaints.array, size * sizeof(Eina_Rectangle));
243     if (!tmp) {
244         CRITICAL("could not realloc repaints array to %zu elements.", size);
245         return EINA_FALSE;
246     }
247     priv->repaints.allocated = size;
248     priv->repaints.array = static_cast<Eina_Rectangle*>(tmp);
249     return EINA_TRUE;
250 }
251
252 static void _ewk_view_repaint_add(Ewk_View_Private_Data* priv, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
253 {
254     Eina_Rectangle* r;
255
256     // fprintf(stderr, ">>> repaint requested: %d,%d+%dx%d\n", x, y, w, h);
257     if (priv->repaints.allocated == priv->repaints.count) {
258         size_t size;
259         if (!priv->repaints.allocated)
260             size = EWK_VIEW_REPAINTS_SIZE_INITIAL;
261         else
262             size = priv->repaints.allocated + EWK_VIEW_REPAINTS_SIZE_STEP;
263         if (!_ewk_view_repaints_resize(priv, size))
264             return;
265     }
266
267     r = priv->repaints.array + priv->repaints.count;
268     priv->repaints.count++;
269
270     r->x = x;
271     r->y = y;
272     r->w = w;
273     r->h = h;
274
275     DBG("add repaint %d, %d+%dx%d", x, y, w, h);
276 }
277
278 static void _ewk_view_repaints_flush(Ewk_View_Private_Data* priv)
279 {
280     priv->repaints.count = 0;
281     if (priv->repaints.allocated <= EWK_VIEW_REPAINTS_SIZE_MAX_FREE)
282         return;
283     _ewk_view_repaints_resize(priv, EWK_VIEW_REPAINTS_SIZE_MAX_FREE);
284 }
285
286 static Eina_Bool _ewk_view_scrolls_resize(Ewk_View_Private_Data* priv, size_t size)
287 {
288     void* tmp = realloc(priv->scrolls.array, size * sizeof(Ewk_Scroll_Request));
289     if (!tmp) {
290         CRITICAL("could not realloc scrolls array to %zu elements.", size);
291         return EINA_FALSE;
292     }
293     priv->scrolls.allocated = size;
294     priv->scrolls.array = static_cast<Ewk_Scroll_Request*>(tmp);
295     return EINA_TRUE;
296 }
297
298 static void _ewk_view_scroll_add(Ewk_View_Private_Data* priv, Evas_Coord dx, Evas_Coord dy, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, Eina_Bool main_scroll)
299 {
300     Ewk_Scroll_Request* r;
301     Ewk_Scroll_Request* r_end;
302     Evas_Coord x2 = x + w, y2 = y + h;
303
304     r = priv->scrolls.array;
305     r_end = r + priv->scrolls.count;
306     for (; r < r_end; r++) {
307         if (r->x == x && r->y == y && r->w == w && r->h == h) {
308             DBG("region already scrolled %d,%d+%dx%d %+03d,%+03d add "
309                 "%+03d,%+03d",
310                 r->x, r->y, r->w, r->h, r->dx, r->dy, dx, dy);
311             r->dx += dx;
312             r->dy += dy;
313             return;
314         }
315         if ((x <= r->x && x2 >= r->x2) && (y <= r->y && y2 >= r->y2)) {
316             DBG("old viewport (%d,%d+%dx%d %+03d,%+03d) was scrolled itself, "
317                 "add %+03d,%+03d",
318                 r->x, r->y, r->w, r->h, r->dx, r->dy, dx, dy);
319             r->x += dx;
320             r->y += dy;
321         }
322     }
323
324     if (priv->scrolls.allocated == priv->scrolls.count) {
325         size_t size;
326         if (!priv->scrolls.allocated)
327             size = EWK_VIEW_SCROLLS_SIZE_INITIAL;
328         else
329             size = priv->scrolls.allocated + EWK_VIEW_SCROLLS_SIZE_STEP;
330         if (!_ewk_view_scrolls_resize(priv, size))
331             return;
332     }
333
334     r = priv->scrolls.array + priv->scrolls.count;
335     priv->scrolls.count++;
336
337     r->x = x;
338     r->y = y;
339     r->w = w;
340     r->h = h;
341     r->x2 = x2;
342     r->y2 = y2;
343     r->dx = dx;
344     r->dy = dy;
345     r->main_scroll = main_scroll;
346     DBG("add scroll in region: %d, %d+%dx%d %+03d, %+03d", x, y, w, h, dx, dy);
347
348     Eina_Rectangle* pr;
349     Eina_Rectangle* pr_end;
350     size_t count;
351     pr = priv->repaints.array;
352     count = priv->repaints.count;
353     pr_end = pr + count;
354     for (; pr < pr_end; pr++) {
355         pr->x += dx;
356         pr->y += dy;
357     }
358 }
359
360 static void _ewk_view_scrolls_flush(Ewk_View_Private_Data* priv)
361 {
362     priv->scrolls.count = 0;
363     if (priv->scrolls.allocated <= EWK_VIEW_SCROLLS_SIZE_MAX_FREE)
364         return;
365     _ewk_view_scrolls_resize(priv, EWK_VIEW_SCROLLS_SIZE_MAX_FREE);
366 }
367
368 // Default Event Handling //////////////////////////////////////////////
369 static Eina_Bool _ewk_view_smart_focus_in(Ewk_View_Smart_Data* sd)
370 {
371     EWK_VIEW_PRIV_GET(sd, priv);
372     WebCore::FocusController* fc = priv->page->focusController();
373     DBG("o=%p, fc=%p", sd->self, fc);
374     EINA_SAFETY_ON_NULL_RETURN_VAL(fc, EINA_FALSE);
375
376     fc->setActive(true);
377     fc->setFocused(true);
378     return EINA_TRUE;
379 }
380
381 static Eina_Bool _ewk_view_smart_focus_out(Ewk_View_Smart_Data* sd)
382 {
383     EWK_VIEW_PRIV_GET(sd, priv);
384     WebCore::FocusController* fc = priv->page->focusController();
385     DBG("o=%p, fc=%p", sd->self, fc);
386     EINA_SAFETY_ON_NULL_RETURN_VAL(fc, EINA_FALSE);
387
388     fc->setActive(false);
389     fc->setFocused(false);
390     return EINA_TRUE;
391 }
392
393 static Eina_Bool _ewk_view_smart_mouse_wheel(Ewk_View_Smart_Data* sd, const Evas_Event_Mouse_Wheel* ev)
394 {
395     return ewk_frame_feed_mouse_wheel(sd->main_frame, ev);
396 }
397
398 static Eina_Bool _ewk_view_smart_mouse_down(Ewk_View_Smart_Data* sd, const Evas_Event_Mouse_Down* ev)
399 {
400     return ewk_frame_feed_mouse_down(sd->main_frame, ev);
401 }
402
403 static Eina_Bool _ewk_view_smart_mouse_up(Ewk_View_Smart_Data* sd, const Evas_Event_Mouse_Up* ev)
404 {
405     return ewk_frame_feed_mouse_up(sd->main_frame, ev);
406 }
407
408 static Eina_Bool _ewk_view_smart_mouse_move(Ewk_View_Smart_Data* sd, const Evas_Event_Mouse_Move* ev)
409 {
410     return ewk_frame_feed_mouse_move(sd->main_frame, ev);
411 }
412
413 static Eina_Bool _ewk_view_smart_key_down(Ewk_View_Smart_Data* sd, const Evas_Event_Key_Down* ev)
414 {
415     Evas_Object* frame = ewk_view_frame_focused_get(sd->self);
416
417     if (!frame)
418         frame = sd->main_frame;
419
420     return ewk_frame_feed_key_down(frame, ev);
421 }
422
423 static Eina_Bool _ewk_view_smart_key_up(Ewk_View_Smart_Data* sd, const Evas_Event_Key_Up* ev)
424 {
425     Evas_Object* frame = ewk_view_frame_focused_get(sd->self);
426
427     if (!frame)
428         frame = sd->main_frame;
429
430     return ewk_frame_feed_key_up(frame, ev);
431 }
432
433 static void _ewk_view_smart_add_console_message(Ewk_View_Smart_Data* sd, const char* message, unsigned int lineNumber, const char* sourceID)
434 {
435     INF("console message: %s @%d: %s\n", sourceID, lineNumber, message);
436 }
437
438 static void _ewk_view_smart_run_javascript_alert(Ewk_View_Smart_Data* sd, Evas_Object* frame, const char* message)
439 {
440     INF("javascript alert: %s\n", message);
441 }
442
443 static Eina_Bool _ewk_view_smart_run_javascript_confirm(Ewk_View_Smart_Data* sd, Evas_Object* frame, const char* message)
444 {
445     INF("javascript confirm: %s", message);
446     INF("javascript confirm (HARD CODED)? YES");
447     return EINA_TRUE;
448 }
449
450 static Eina_Bool _ewk_view_smart_should_interrupt_javascript(Ewk_View_Smart_Data* sd)
451 {
452     INF("should interrupt javascript?\n"
453         "\t(HARD CODED) NO");
454     return EINA_FALSE;
455 }
456
457 static Eina_Bool _ewk_view_smart_run_javascript_prompt(Ewk_View_Smart_Data* sd, Evas_Object* frame, const char* message, const char* defaultValue, char** value)
458 {
459     *value = strdup("test");
460     Eina_Bool ret = EINA_TRUE;
461     INF("javascript prompt:\n"
462         "\t      message: %s\n"
463         "\tdefault value: %s\n"
464         "\tgiving answer: %s\n"
465         "\t       button: %s", message, defaultValue, *value, ret ? "ok" : "cancel");
466
467     return ret;
468 }
469
470 // Event Handling //////////////////////////////////////////////////////
471 static void _ewk_view_on_focus_in(void* data, Evas* e, Evas_Object* o, void* event_info)
472 {
473     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
474     EINA_SAFETY_ON_NULL_RETURN(sd->api);
475     EINA_SAFETY_ON_NULL_RETURN(sd->api->focus_in);
476     sd->api->focus_in(sd);
477 }
478
479 static void _ewk_view_on_focus_out(void* data, Evas* e, Evas_Object* o, void* event_info)
480 {
481     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
482     EINA_SAFETY_ON_NULL_RETURN(sd->api);
483     EINA_SAFETY_ON_NULL_RETURN(sd->api->focus_out);
484     sd->api->focus_out(sd);
485 }
486
487 static void _ewk_view_on_mouse_wheel(void* data, Evas* e, Evas_Object* o, void* event_info)
488 {
489     Evas_Event_Mouse_Wheel* ev = static_cast<Evas_Event_Mouse_Wheel*>(event_info);
490     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
491     EINA_SAFETY_ON_NULL_RETURN(sd->api);
492     EINA_SAFETY_ON_NULL_RETURN(sd->api->mouse_wheel);
493     sd->api->mouse_wheel(sd, ev);
494 }
495
496 static void _ewk_view_on_mouse_down(void* data, Evas* e, Evas_Object* o, void* event_info)
497 {
498     Evas_Event_Mouse_Down* ev = static_cast<Evas_Event_Mouse_Down*>(event_info);
499     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
500     EINA_SAFETY_ON_NULL_RETURN(sd->api);
501     EINA_SAFETY_ON_NULL_RETURN(sd->api->mouse_down);
502     sd->api->mouse_down(sd, ev);
503 }
504
505 static void _ewk_view_on_mouse_up(void* data, Evas* e, Evas_Object* o, void* event_info)
506 {
507     Evas_Event_Mouse_Up* ev = static_cast<Evas_Event_Mouse_Up*>(event_info);
508     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
509     EINA_SAFETY_ON_NULL_RETURN(sd->api);
510     EINA_SAFETY_ON_NULL_RETURN(sd->api->mouse_up);
511     sd->api->mouse_up(sd, ev);
512 }
513
514 static void _ewk_view_on_mouse_move(void* data, Evas* e, Evas_Object* o, void* event_info)
515 {
516     Evas_Event_Mouse_Move* ev = static_cast<Evas_Event_Mouse_Move*>(event_info);
517     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
518     EINA_SAFETY_ON_NULL_RETURN(sd->api);
519     EINA_SAFETY_ON_NULL_RETURN(sd->api->mouse_move);
520     sd->api->mouse_move(sd, ev);
521 }
522
523 static void _ewk_view_on_key_down(void* data, Evas* e, Evas_Object* o, void* event_info)
524 {
525     Evas_Event_Key_Down* ev = static_cast<Evas_Event_Key_Down*>(event_info);
526     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
527     EINA_SAFETY_ON_NULL_RETURN(sd->api);
528     EINA_SAFETY_ON_NULL_RETURN(sd->api->key_down);
529     sd->api->key_down(sd, ev);
530 }
531
532 static void _ewk_view_on_key_up(void* data, Evas* e, Evas_Object* o, void* event_info)
533 {
534     Evas_Event_Key_Up* ev = static_cast<Evas_Event_Key_Up*>(event_info);
535     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
536     EINA_SAFETY_ON_NULL_RETURN(sd->api);
537     EINA_SAFETY_ON_NULL_RETURN(sd->api->key_up);
538     sd->api->key_up(sd, ev);
539 }
540
541 static WTF::PassRefPtr<WebCore::Frame> _ewk_view_core_frame_new(Ewk_View_Smart_Data* sd, Ewk_View_Private_Data* priv, WebCore::HTMLFrameOwnerElement* owner)
542 {
543     WebCore::FrameLoaderClientEfl* flc = new WebCore::FrameLoaderClientEfl(sd->self);
544     if (!flc) {
545         CRITICAL("Could not create frame loader client.");
546         return 0;
547     }
548     flc->setCustomUserAgent(String::fromUTF8(priv->settings.user_agent));
549
550     return WebCore::Frame::create(priv->page, owner, flc);
551 }
552
553 static Evas_Smart_Class _parent_sc = EVAS_SMART_CLASS_INIT_NULL;
554
555 static Ewk_View_Private_Data* _ewk_view_priv_new(Ewk_View_Smart_Data* sd)
556 {
557     Ewk_View_Private_Data* priv =
558         static_cast<Ewk_View_Private_Data*>(calloc(1, sizeof(Ewk_View_Private_Data)));
559     AtomicString s;
560     WebCore::KURL url;
561
562     if (!priv) {
563         CRITICAL("could not allocate Ewk_View_Private_Data");
564         return 0;
565     }
566
567     WebCore::Page::PageClients pageClients;
568     pageClients.chromeClient = static_cast<WebCore::ChromeClient*>(new WebCore::ChromeClientEfl(sd->self));
569     pageClients.editorClient = static_cast<WebCore::EditorClient*>(new WebCore::EditorClientEfl(sd->self));
570     pageClients.dragClient = static_cast<WebCore::DragClient*>(new WebCore::DragClientEfl);
571     pageClients.inspectorClient = static_cast<WebCore::InspectorClient*>(new WebCore::InspectorClientEfl);
572 #if ENABLE(DEVICE_ORIENTATION)
573     pageClients.deviceMotionClient = static_cast<WebCore::DeviceMotionClient*>(new WebCore::DeviceMotionClientEfl);
574     pageClients.deviceOrientationClient = static_cast<WebCore::DeviceOrientationClient*>(new WebCore::DeviceOrientationClientEfl);
575 #endif
576     priv->page = new WebCore::Page(pageClients);
577     if (!priv->page) {
578         CRITICAL("Could not create WebKit Page");
579         goto error_page;
580     }
581
582     priv->page_settings = priv->page->settings();
583     if (!priv->page_settings) {
584         CRITICAL("Could not get page settings.");
585         goto error_settings;
586     }
587
588     priv->viewport_arguments.width = WebCore::ViewportArguments::ValueAuto;
589     priv->viewport_arguments.height = WebCore::ViewportArguments::ValueAuto;
590     priv->viewport_arguments.initialScale = WebCore::ViewportArguments::ValueAuto;
591     priv->viewport_arguments.minimumScale = WebCore::ViewportArguments::ValueAuto;
592     priv->viewport_arguments.maximumScale = WebCore::ViewportArguments::ValueAuto;
593     priv->viewport_arguments.targetDensityDpi = WebCore::ViewportArguments::ValueAuto;
594     priv->viewport_arguments.userScalable = EINA_TRUE;
595
596     priv->page_settings->setLoadsImagesAutomatically(true);
597     priv->page_settings->setDefaultFixedFontSize(12);
598     priv->page_settings->setDefaultFontSize(16);
599     priv->page_settings->setSerifFontFamily("serif");
600     priv->page_settings->setFixedFontFamily("monotype");
601     priv->page_settings->setSansSerifFontFamily("sans");
602     priv->page_settings->setStandardFontFamily("sans");
603     priv->page_settings->setJavaScriptEnabled(true);
604     priv->page_settings->setPluginsEnabled(true);
605     priv->page_settings->setLocalStorageEnabled(true);
606     priv->page_settings->setOfflineWebApplicationCacheEnabled(true);
607     priv->page_settings->setUsesPageCache(true);
608     priv->page_settings->setUsesEncodingDetector(false);
609
610     url = priv->page_settings->userStyleSheetLocation();
611     priv->settings.user_stylesheet = eina_stringshare_add(url.string().utf8().data());
612
613     priv->settings.encoding_default = eina_stringshare_add
614                                           (priv->page_settings->defaultTextEncodingName().utf8().data());
615     priv->settings.encoding_custom = 0;
616
617     s = priv->page_settings->localStorageDatabasePath();
618     priv->settings.local_storage_database_path = eina_stringshare_add(s.string().utf8().data());
619
620     priv->settings.font_minimum_size = priv->page_settings->minimumFontSize();
621     priv->settings.font_minimum_logical_size = priv->page_settings->minimumLogicalFontSize();
622     priv->settings.font_default_size = priv->page_settings->defaultFontSize();
623     priv->settings.font_monospace_size = priv->page_settings->defaultFixedFontSize();
624
625     s = priv->page_settings->standardFontFamily();
626     priv->settings.font_standard = eina_stringshare_add(s.string().utf8().data());
627     s = priv->page_settings->cursiveFontFamily();
628     priv->settings.font_cursive = eina_stringshare_add(s.string().utf8().data());
629     s = priv->page_settings->fixedFontFamily();
630     priv->settings.font_monospace = eina_stringshare_add(s.string().utf8().data());
631     s = priv->page_settings->fantasyFontFamily();
632     priv->settings.font_fantasy = eina_stringshare_add(s.string().utf8().data());
633     s = priv->page_settings->serifFontFamily();
634     priv->settings.font_serif = eina_stringshare_add(s.string().utf8().data());
635     s = priv->page_settings->sansSerifFontFamily();
636     priv->settings.font_sans_serif = eina_stringshare_add(s.string().utf8().data());
637
638     priv->settings.auto_load_images = priv->page_settings->loadsImagesAutomatically();
639     priv->settings.auto_shrink_images = priv->page_settings->shrinksStandaloneImagesToFit();
640     priv->settings.enable_auto_resize_window = EINA_TRUE;
641     priv->settings.enable_developer_extras = priv->page_settings->developerExtrasEnabled();
642     priv->settings.enable_scripts = priv->page_settings->isJavaScriptEnabled();
643     priv->settings.enable_plugins = priv->page_settings->arePluginsEnabled();
644     priv->settings.enable_frame_flattening = priv->page_settings->frameFlatteningEnabled();
645     priv->settings.scripts_window_open = priv->page_settings->javaScriptCanOpenWindowsAutomatically();
646     priv->settings.scripts_can_close_windows = priv->page_settings->allowScriptsToCloseWindows();
647     priv->settings.resizable_textareas = priv->page_settings->textAreasAreResizable();
648     priv->settings.private_browsing = priv->page_settings->privateBrowsingEnabled();
649     priv->settings.caret_browsing = priv->page_settings->caretBrowsingEnabled();
650     priv->settings.spatial_navigation = priv->page_settings->isSpatialNavigationEnabled();
651     priv->settings.local_storage = priv->page_settings->localStorageEnabled();
652     priv->settings.offline_app_cache = true; // XXX no function to read setting; this keeps the original setting
653     priv->settings.page_cache = priv->page_settings->usesPageCache();
654     priv->settings.encoding_detector = priv->page_settings->usesEncodingDetector();
655
656     priv->settings.user_agent = ewk_settings_default_user_agent_get();
657
658     // Since there's no scale separated from zooming in webkit-efl, this functionality of
659     // viewport meta tag is implemented using zoom. When scale zoom is supported by webkit-efl,
660     // this functionality will be modified by the scale zoom patch.
661     priv->settings.zoom_range.min_scale = ZOOM_MIN;
662     priv->settings.zoom_range.max_scale = ZOOM_MAX;
663     priv->settings.zoom_range.user_scalable = EINA_TRUE;
664     priv->settings.device_pixel_ratio = DEVICE_PIXEL_RATIO;
665
666     priv->settings.dom_timer_interval = priv->page_settings->defaultMinDOMTimerInterval();
667
668     priv->main_frame = _ewk_view_core_frame_new(sd, priv, 0).get();
669     if (!priv->main_frame) {
670         CRITICAL("Could not create main frame.");
671         goto error_main_frame;
672     }
673
674     priv->history = ewk_history_new(static_cast<WebCore::BackForwardListImpl*>(priv->page->backForwardList()));
675     if (!priv->history) {
676         CRITICAL("Could not create history instance for view.");
677         goto error_history;
678     }
679
680     return priv;
681
682 error_history:
683     // delete priv->main_frame; /* do not delete priv->main_frame */
684 error_main_frame:
685 error_settings:
686     delete priv->page;
687 error_page:
688     free(priv);
689     return 0;
690 }
691
692 static void _ewk_view_priv_del(Ewk_View_Private_Data* priv)
693 {
694     if (!priv)
695         return;
696
697     /* do not delete priv->main_frame */
698
699     free(priv->repaints.array);
700     free(priv->scrolls.array);
701
702     eina_stringshare_del(priv->settings.user_agent);
703     eina_stringshare_del(priv->settings.user_stylesheet);
704     eina_stringshare_del(priv->settings.encoding_default);
705     eina_stringshare_del(priv->settings.encoding_custom);
706     eina_stringshare_del(priv->settings.font_standard);
707     eina_stringshare_del(priv->settings.font_cursive);
708     eina_stringshare_del(priv->settings.font_monospace);
709     eina_stringshare_del(priv->settings.font_fantasy);
710     eina_stringshare_del(priv->settings.font_serif);
711     eina_stringshare_del(priv->settings.font_sans_serif);
712     eina_stringshare_del(priv->settings.local_storage_database_path);
713
714     if (priv->animated_zoom.animator)
715         ecore_animator_del(priv->animated_zoom.animator);
716
717     ewk_history_free(priv->history);
718
719     delete priv->page;
720     free(priv);
721 }
722
723 static void _ewk_view_smart_add(Evas_Object* o)
724 {
725     const Evas_Smart* smart = evas_object_smart_smart_get(o);
726     const Evas_Smart_Class* sc = evas_smart_class_get(smart);
727     const Ewk_View_Smart_Class* api = reinterpret_cast<const Ewk_View_Smart_Class*>(sc);
728     EINA_SAFETY_ON_NULL_RETURN(api->backing_store_add);
729     EWK_VIEW_SD_GET(o, sd);
730
731     if (!sd) {
732         sd = static_cast<Ewk_View_Smart_Data*>(calloc(1, sizeof(Ewk_View_Smart_Data)));
733         if (!sd) {
734             CRITICAL("could not allocate Ewk_View_Smart_Data");
735             return;
736         }
737         evas_object_smart_data_set(o, sd);
738     }
739
740     sd->bg_color.r = 255;
741     sd->bg_color.g = 255;
742     sd->bg_color.b = 255;
743     sd->bg_color.a = 255;
744
745     sd->self = o;
746     sd->_priv = _ewk_view_priv_new(sd);
747     sd->api = api;
748
749     _parent_sc.add(o);
750
751     if (!sd->_priv)
752         return;
753
754     EWK_VIEW_PRIV_GET(sd, priv);
755
756     sd->backing_store = api->backing_store_add(sd);
757     if (!sd->backing_store) {
758         ERR("Could not create backing store object.");
759         return;
760     }
761
762     evas_object_smart_member_add(sd->backing_store, o);
763     evas_object_show(sd->backing_store);
764     evas_object_pass_events_set(sd->backing_store, EINA_TRUE);
765
766     sd->events_rect = evas_object_rectangle_add(sd->base.evas);
767     evas_object_color_set(sd->events_rect, 0, 0, 0, 0);
768     evas_object_smart_member_add(sd->events_rect, o);
769     evas_object_show(sd->events_rect);
770
771     sd->main_frame = ewk_frame_add(sd->base.evas);
772     if (!sd->main_frame) {
773         ERR("Could not create main frame object.");
774         return;
775     }
776
777     if (!ewk_frame_init(sd->main_frame, o, priv->main_frame)) {
778         ERR("Could not initialize main frme object.");
779         evas_object_del(sd->main_frame);
780         sd->main_frame = 0;
781
782         delete priv->main_frame;
783         priv->main_frame = 0;
784         return;
785     }
786
787     evas_object_name_set(sd->main_frame, "EWK_Frame:main");
788     evas_object_smart_member_add(sd->main_frame, o);
789     evas_object_show(sd->main_frame);
790
791 #define CONNECT(s, c) evas_object_event_callback_add(o, s, c, sd)
792     CONNECT(EVAS_CALLBACK_FOCUS_IN, _ewk_view_on_focus_in);
793     CONNECT(EVAS_CALLBACK_FOCUS_OUT, _ewk_view_on_focus_out);
794     CONNECT(EVAS_CALLBACK_MOUSE_WHEEL, _ewk_view_on_mouse_wheel);
795     CONNECT(EVAS_CALLBACK_MOUSE_DOWN, _ewk_view_on_mouse_down);
796     CONNECT(EVAS_CALLBACK_MOUSE_UP, _ewk_view_on_mouse_up);
797     CONNECT(EVAS_CALLBACK_MOUSE_MOVE, _ewk_view_on_mouse_move);
798     CONNECT(EVAS_CALLBACK_KEY_DOWN, _ewk_view_on_key_down);
799     CONNECT(EVAS_CALLBACK_KEY_UP, _ewk_view_on_key_up);
800 #undef CONNECT
801 }
802
803 static void _ewk_view_smart_del(Evas_Object* o)
804 {
805     EWK_VIEW_SD_GET(o, sd);
806     Ewk_View_Private_Data* priv = sd ? sd->_priv : 0;
807
808     ewk_view_stop(o);
809     _parent_sc.del(o);
810     _ewk_view_priv_del(priv);
811 }
812
813 static void _ewk_view_smart_resize(Evas_Object* o, Evas_Coord w, Evas_Coord h)
814 {
815     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
816
817     // these should be queued and processed in calculate as well!
818     evas_object_resize(sd->backing_store, w, h);
819
820     sd->changed.size = EINA_TRUE;
821     _ewk_view_smart_changed(sd);
822 }
823
824 static void _ewk_view_smart_move(Evas_Object* o, Evas_Coord x, Evas_Coord y)
825 {
826     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
827     sd->changed.position = EINA_TRUE;
828     _ewk_view_smart_changed(sd);
829 }
830
831 static void _ewk_view_smart_calculate(Evas_Object* o)
832 {
833     EWK_VIEW_SD_GET(o, sd);
834     EWK_VIEW_PRIV_GET(sd, priv);
835     EINA_SAFETY_ON_NULL_RETURN(sd->api->contents_resize);
836     EINA_SAFETY_ON_NULL_RETURN(sd->api->scrolls_process);
837     EINA_SAFETY_ON_NULL_RETURN(sd->api->repaints_process);
838     Evas_Coord x, y, w, h;
839
840     sd->changed.any = EINA_FALSE;
841
842     if (!sd->main_frame || !priv->main_frame)
843         return;
844
845     evas_object_geometry_get(o, &x, &y, &w, &h);
846
847     DBG("o=%p geo=[%d, %d + %dx%d], changed: size=%hhu, "
848         "scrolls=%zu, repaints=%zu",
849         o, x, y, w, h, sd->changed.size,
850         priv->scrolls.count, priv->repaints.count);
851
852     if (sd->changed.size && ((w != sd->view.w) || (h != sd->view.h))) {
853         WebCore::FrameView* view = priv->main_frame->view();
854         if (view) {
855             view->resize(w, h);
856             view->forceLayout();
857             view->adjustViewSize();
858         }
859         evas_object_resize(sd->main_frame, w, h);
860         evas_object_resize(sd->events_rect, w, h);
861         sd->changed.frame_rect = EINA_TRUE;
862         sd->view.w = w;
863         sd->view.h = h;
864
865         _ewk_view_repaint_add(priv, 0, 0, w, h);
866
867         // This callback is a good place e.g. to change fixed layout size (ewk_view_fixed_layout_size_set).
868         evas_object_smart_callback_call(o, "view,resized", 0);
869     }
870     sd->changed.size = EINA_FALSE;
871
872     if (sd->changed.position && ((x != sd->view.x) || (y != sd->view.y))) {
873         evas_object_move(sd->main_frame, x, y);
874         evas_object_move(sd->backing_store, x, y);
875         evas_object_move(sd->events_rect, x, y);
876         sd->changed.frame_rect = EINA_TRUE;
877         sd->view.x = x;
878         sd->view.y = y;
879     }
880     sd->changed.position = EINA_FALSE;
881
882     if (!sd->api->scrolls_process(sd))
883         ERR("failed to process scrolls.");
884     _ewk_view_scrolls_flush(priv);
885
886     if (!sd->api->repaints_process(sd))
887         ERR("failed to process repaints.");
888     _ewk_view_repaints_flush(priv);
889
890     if (sd->changed.frame_rect) {
891         WebCore::FrameView* view = priv->main_frame->view();
892         view->frameRectsChanged(); /* force tree to get position from root */
893         sd->changed.frame_rect = EINA_FALSE;
894     }
895 }
896
897 static void _ewk_view_smart_show(Evas_Object* o)
898 {
899     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
900
901     if (evas_object_clipees_get(sd->base.clipper))
902         evas_object_show(sd->base.clipper);
903     evas_object_show(sd->backing_store);
904 }
905
906 static void _ewk_view_smart_hide(Evas_Object* o)
907 {
908     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
909
910     evas_object_hide(sd->base.clipper);
911     evas_object_hide(sd->backing_store);
912 }
913
914 static Eina_Bool _ewk_view_smart_contents_resize(Ewk_View_Smart_Data* sd, int w, int h)
915 {
916     return EINA_TRUE;
917 }
918
919 static Eina_Bool _ewk_view_smart_zoom_set(Ewk_View_Smart_Data* sd, float zoom, Evas_Coord cx, Evas_Coord cy)
920 {
921     double px, py;
922     Evas_Coord x, y, w, h;
923     Eina_Bool ret;
924
925     ewk_frame_scroll_size_get(sd->main_frame, &w, &h);
926     ewk_frame_scroll_pos_get(sd->main_frame, &x, &y);
927
928     if (w + sd->view.w > 0)
929         px = static_cast<double>(x + cx) / (w + sd->view.w);
930     else
931         px = 0.0;
932
933     if (h + sd->view.h > 0)
934         py = static_cast<double>(y + cy) / (h + sd->view.h);
935     else
936         py = 0.0;
937
938     ret = ewk_frame_zoom_set(sd->main_frame, zoom);
939
940     ewk_frame_scroll_size_get(sd->main_frame, &w, &h);
941     x = (w + sd->view.w) * px - cx;
942     y = (h + sd->view.h) * py - cy;
943     ewk_frame_scroll_set(sd->main_frame, x, y);
944     return ret;
945 }
946
947 static void _ewk_view_smart_flush(Ewk_View_Smart_Data* sd)
948 {
949     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
950     _ewk_view_repaints_flush(priv);
951     _ewk_view_scrolls_flush(priv);
952 }
953
954 static Eina_Bool _ewk_view_smart_pre_render_region(Ewk_View_Smart_Data* sd, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, float zoom)
955 {
956     WRN("not supported by engine. sd=%p area=%d,%d+%dx%d, zoom=%f",
957         sd, x, y, w, h, zoom);
958     return EINA_FALSE;
959 }
960
961 static Eina_Bool _ewk_view_smart_pre_render_relative_radius(Ewk_View_Smart_Data* sd, unsigned int n, float zoom)
962 {
963     WRN("not supported by engine. sd=%p, n=%u zoom=%f",
964         sd, n, zoom);
965     return EINA_FALSE;
966 }
967
968 static void _ewk_view_smart_pre_render_cancel(Ewk_View_Smart_Data* sd)
969 {
970     WRN("not supported by engine. sd=%p", sd);
971 }
972
973 static void _ewk_view_zoom_animated_mark_stop(Ewk_View_Smart_Data* sd)
974 {
975     sd->animated_zoom.zoom.start = 0.0;
976     sd->animated_zoom.zoom.end = 0.0;
977     sd->animated_zoom.zoom.current = 0.0;
978 }
979
980 static void _ewk_view_zoom_animated_finish(Ewk_View_Smart_Data* sd)
981 {
982     EWK_VIEW_PRIV_GET(sd, priv);
983     ecore_animator_del(priv->animated_zoom.animator);
984     priv->animated_zoom.animator = 0;
985     _ewk_view_zoom_animated_mark_stop(sd);
986     evas_object_smart_callback_call(sd->self, "zoom,animated,end", 0);
987 }
988
989 static float _ewk_view_zoom_animated_current(Ewk_View_Private_Data* priv)
990 {
991     double now = ecore_loop_time_get();
992     double delta = now - priv->animated_zoom.time.start;
993
994     if (delta > priv->animated_zoom.time.duration)
995         delta = priv->animated_zoom.time.duration;
996     if (delta < 0.0) // time went back, clock adjusted?
997         delta = 0.0;
998
999     delta /= priv->animated_zoom.time.duration;
1000
1001     return ((priv->animated_zoom.zoom.range * delta)
1002             + priv->animated_zoom.zoom.start);
1003 }
1004
1005 static Eina_Bool _ewk_view_zoom_animator_cb(void* data)
1006 {
1007     Ewk_View_Smart_Data* sd = static_cast<Ewk_View_Smart_Data*>(data);
1008     Evas_Coord cx, cy;
1009     EWK_VIEW_PRIV_GET(sd, priv);
1010     double now = ecore_loop_time_get();
1011
1012     cx = priv->animated_zoom.center.x;
1013     cy = priv->animated_zoom.center.y;
1014
1015     // TODO: progressively center (cx, cy) -> (view.x + view.h/2, view.y + view.h/2)
1016     if (cx >= sd->view.w)
1017         cx = sd->view.w - 1;
1018     if (cy >= sd->view.h)
1019         cy = sd->view.h - 1;
1020
1021     if ((now >= priv->animated_zoom.time.end)
1022         || (now < priv->animated_zoom.time.start)) {
1023         _ewk_view_zoom_animated_finish(sd);
1024         ewk_view_zoom_set(sd->self, priv->animated_zoom.zoom.end, cx, cy);
1025         sd->api->sc.calculate(sd->self);
1026         return EINA_FALSE;
1027     }
1028
1029     sd->animated_zoom.zoom.current = _ewk_view_zoom_animated_current(priv);
1030     sd->api->zoom_weak_set(sd, sd->animated_zoom.zoom.current, cx, cy);
1031     return EINA_TRUE;
1032 }
1033
1034 static void _ewk_view_zoom_animation_start(Ewk_View_Smart_Data* sd)
1035 {
1036     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
1037     if (priv->animated_zoom.animator)
1038         return;
1039     priv->animated_zoom.animator = ecore_animator_add
1040                                        (_ewk_view_zoom_animator_cb, sd);
1041 }
1042
1043 static WebCore::ViewportAttributes _ewk_view_viewport_attributes_compute(const Evas_Object* o)
1044 {
1045     EWK_VIEW_SD_GET(o, sd);
1046     EWK_VIEW_PRIV_GET(sd, priv);
1047
1048     int desktop_width = 980;
1049     int device_dpi = ewk_util_dpi_get();
1050
1051     WebCore::IntRect available_rect = enclosingIntRect(priv->page->chrome()->client()->pageRect());
1052     WebCore::IntRect device_rect = enclosingIntRect(priv->page->chrome()->client()->windowRect());
1053
1054     WebCore::ViewportAttributes attributes = WebCore::computeViewportAttributes(priv->viewport_arguments, desktop_width, device_rect.width(), device_rect.height(), device_dpi, available_rect.size());
1055
1056     return attributes;
1057 }
1058
1059 static Eina_Bool _ewk_view_smart_disable_render(Ewk_View_Smart_Data* sd)
1060 {
1061     WRN("not supported by engine. sd=%p", sd);
1062     return EINA_FALSE;
1063 }
1064
1065 static Eina_Bool _ewk_view_smart_enable_render(Ewk_View_Smart_Data* sd)
1066 {
1067     WRN("not supported by engine. sd=%p", sd);
1068     return EINA_FALSE;
1069 }
1070
1071 Eina_Bool ewk_view_base_smart_set(Ewk_View_Smart_Class* api)
1072 {
1073     EINA_SAFETY_ON_NULL_RETURN_VAL(api, EINA_FALSE);
1074
1075     if (api->version != EWK_VIEW_SMART_CLASS_VERSION) {
1076         EINA_LOG_CRIT
1077             ("Ewk_View_Smart_Class %p is version %lu while %lu was expected.",
1078             api, api->version, EWK_VIEW_SMART_CLASS_VERSION);
1079         return EINA_FALSE;
1080     }
1081
1082     if (EINA_UNLIKELY(!_parent_sc.add))
1083         evas_object_smart_clipped_smart_set(&_parent_sc);
1084
1085     evas_object_smart_clipped_smart_set(&api->sc);
1086     api->sc.add = _ewk_view_smart_add;
1087     api->sc.del = _ewk_view_smart_del;
1088     api->sc.resize = _ewk_view_smart_resize;
1089     api->sc.move = _ewk_view_smart_move;
1090     api->sc.calculate = _ewk_view_smart_calculate;
1091     api->sc.show = _ewk_view_smart_show;
1092     api->sc.hide = _ewk_view_smart_hide;
1093     api->sc.data = EWK_VIEW_TYPE_STR; /* used by type checking */
1094
1095     api->contents_resize = _ewk_view_smart_contents_resize;
1096     api->zoom_set = _ewk_view_smart_zoom_set;
1097     api->flush = _ewk_view_smart_flush;
1098     api->pre_render_region = _ewk_view_smart_pre_render_region;
1099     api->pre_render_relative_radius = _ewk_view_smart_pre_render_relative_radius;
1100     api->pre_render_cancel = _ewk_view_smart_pre_render_cancel;
1101     api->disable_render = _ewk_view_smart_disable_render;
1102     api->enable_render = _ewk_view_smart_enable_render;
1103
1104     api->focus_in = _ewk_view_smart_focus_in;
1105     api->focus_out = _ewk_view_smart_focus_out;
1106     api->mouse_wheel = _ewk_view_smart_mouse_wheel;
1107     api->mouse_down = _ewk_view_smart_mouse_down;
1108     api->mouse_up = _ewk_view_smart_mouse_up;
1109     api->mouse_move = _ewk_view_smart_mouse_move;
1110     api->key_down = _ewk_view_smart_key_down;
1111     api->key_up = _ewk_view_smart_key_up;
1112
1113     api->add_console_message = _ewk_view_smart_add_console_message;
1114     api->run_javascript_alert = _ewk_view_smart_run_javascript_alert;
1115     api->run_javascript_confirm = _ewk_view_smart_run_javascript_confirm;
1116     api->run_javascript_prompt = _ewk_view_smart_run_javascript_prompt;
1117     api->should_interrupt_javascript = _ewk_view_smart_should_interrupt_javascript;
1118
1119     return EINA_TRUE;
1120 }
1121
1122 void ewk_view_fixed_layout_size_set(Evas_Object* o, Evas_Coord w, Evas_Coord h)
1123 {
1124     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
1125     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
1126
1127     WebCore::FrameView* view = priv->main_frame->view();
1128     if (w <= 0 && h <= 0) {
1129         if (!view->useFixedLayout())
1130             return;
1131         view->setUseFixedLayout(EINA_FALSE);
1132     } else {
1133         WebCore::IntSize size = view->fixedLayoutSize();
1134         if (size.width() == w && size.height() == h)
1135             return;
1136         if (view)
1137             view->setFixedLayoutSize(WebCore::IntSize(w, h));
1138     }
1139
1140     if (!view)
1141         return;
1142     view->setUseFixedLayout(EINA_TRUE);
1143     view->forceLayout();
1144 }
1145
1146 void ewk_view_fixed_layout_size_get(const Evas_Object* o, Evas_Coord* w, Evas_Coord* h)
1147 {
1148     if (w)
1149         *w = 0;
1150     if (h)
1151         *h = 0;
1152     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
1153     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
1154     WebCore::FrameView* view = priv->main_frame->view();
1155     if (view->useFixedLayout()) {
1156         WebCore::IntSize size = view->fixedLayoutSize();
1157         if (w)
1158             *w = size.width();
1159         if (h)
1160             *h = size.height();
1161     }
1162 }
1163
1164 void ewk_view_theme_set(Evas_Object* o, const char* path)
1165 {
1166     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
1167     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
1168     if (!eina_stringshare_replace(&priv->settings.theme, path))
1169         return;
1170
1171     WebCore::FrameView* view = priv->main_frame->view();
1172     if (view) {
1173         view->setEdjeTheme(WTF::String(path));
1174         priv->page->theme()->themeChanged();
1175     }
1176
1177 }
1178
1179 const char* ewk_view_theme_get(const Evas_Object* o)
1180 {
1181     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1182     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1183     return priv->settings.theme;
1184 }
1185
1186 Evas_Object* ewk_view_frame_main_get(const Evas_Object* o)
1187 {
1188     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1189     return sd->main_frame;
1190 }
1191
1192 Evas_Object* ewk_view_frame_focused_get(const Evas_Object* o)
1193 {
1194     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1195     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1196
1197     WebCore::Frame* core = priv->page->focusController()->focusedFrame();
1198     if (!core)
1199         return 0;
1200
1201     WebCore::FrameLoaderClientEfl* client = static_cast<WebCore::FrameLoaderClientEfl*>(core->loader()->client());
1202     if (!client)
1203         return 0;
1204     return client->webFrame();
1205 }
1206
1207 Eina_Bool ewk_view_uri_set(Evas_Object* o, const char* uri)
1208 {
1209     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1210     return ewk_frame_uri_set(sd->main_frame, uri);
1211 }
1212
1213 const char* ewk_view_uri_get(const Evas_Object* o)
1214 {
1215     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1216     return ewk_frame_uri_get(sd->main_frame);
1217 }
1218
1219 const char* ewk_view_title_get(const Evas_Object* o)
1220 {
1221     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1222     return ewk_frame_title_get(sd->main_frame);
1223 }
1224
1225 Eina_Bool ewk_view_editable_get(const Evas_Object* o)
1226 {
1227     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1228     return ewk_frame_editable_get(sd->main_frame);
1229 }
1230
1231 void ewk_view_bg_color_set(Evas_Object* o, int r, int g, int b, int a)
1232 {
1233     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
1234     EINA_SAFETY_ON_NULL_RETURN(sd->api);
1235     EINA_SAFETY_ON_NULL_RETURN(sd->api->bg_color_set);
1236
1237     if (a < 0) {
1238         WRN("Alpha less than zero (%d).", a);
1239         a = 0;
1240     } else if (a > 255) {
1241         WRN("Alpha is larger than 255 (%d).", a);
1242         a = 255;
1243     }
1244
1245 #define CHECK_PREMUL_COLOR(c, a)                                        \
1246     if (c < 0) {                                                        \
1247         WRN("Color component " #c " is less than zero (%d).", c);         \
1248         c = 0;                                                          \
1249     } else if (c > a) {                                                 \
1250         WRN("Color component " #c " is greater than alpha (%d, alpha=%d).", \
1251             c, a);                                                      \
1252         c = a;                                                          \
1253     }
1254     CHECK_PREMUL_COLOR(r, a);
1255     CHECK_PREMUL_COLOR(g, a);
1256     CHECK_PREMUL_COLOR(b, a);
1257 #undef CHECK_PREMUL_COLOR
1258
1259     sd->bg_color.r = r;
1260     sd->bg_color.g = g;
1261     sd->bg_color.b = b;
1262     sd->bg_color.a = a;
1263
1264     sd->api->bg_color_set(sd, r, g, b, a);
1265
1266     WebCore::FrameView* view = sd->_priv->main_frame->view();
1267     if (view) {
1268         WebCore::Color color;
1269
1270         if (!a)
1271             color = WebCore::Color(0, 0, 0, 0);
1272         else if (a == 255)
1273             color = WebCore::Color(r, g, b, a);
1274         else
1275             color = WebCore::Color(r * 255 / a, g * 255 / a, b * 255 / a, a);
1276
1277         view->updateBackgroundRecursively(color, !a);
1278     }
1279 }
1280
1281 void ewk_view_bg_color_get(const Evas_Object* o, int* r, int* g, int* b, int* a)
1282 {
1283     if (r)
1284         *r = 0;
1285     if (g)
1286         *g = 0;
1287     if (b)
1288         *b = 0;
1289     if (a)
1290         *a = 0;
1291     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
1292     if (r)
1293         *r = sd->bg_color.r;
1294     if (g)
1295         *g = sd->bg_color.g;
1296     if (b)
1297         *b = sd->bg_color.b;
1298     if (a)
1299         *a = sd->bg_color.a;
1300 }
1301
1302 Eina_Bool ewk_view_text_search(const Evas_Object* o, const char* string, Eina_Bool case_sensitive, Eina_Bool forward, Eina_Bool wrap)
1303 {
1304     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1305     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1306     EINA_SAFETY_ON_NULL_RETURN_VAL(string, EINA_FALSE);
1307     WTF::TextCaseSensitivity sensitive;
1308     WebCore::FindDirection direction;
1309
1310     if (case_sensitive)
1311         sensitive = WTF::TextCaseSensitive;
1312     else
1313         sensitive = WTF::TextCaseInsensitive;
1314
1315     if (forward)
1316         direction = WebCore::FindDirectionForward;
1317     else
1318         direction = WebCore::FindDirectionBackward;
1319
1320     return priv->page->findString(String::fromUTF8(string), sensitive, direction, wrap);
1321 }
1322
1323 /**
1324  * Mark matches the given text string in document.
1325  *
1326  * @param o view object where to search text.
1327  * @param string reference string to match.
1328  * @param case_sensitive if match should be case sensitive or not.
1329  * @param highlight if matches should be highlighted.
1330  * @param limit maximum amount of matches, or zero to unlimited.
1331  *
1332  * @return number of matches.
1333  */
1334 unsigned int ewk_view_text_matches_mark(Evas_Object* o, const char* string, Eina_Bool case_sensitive, Eina_Bool highlight, unsigned int limit)
1335 {
1336     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1337     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1338     EINA_SAFETY_ON_NULL_RETURN_VAL(string, 0);
1339     WTF::TextCaseSensitivity sensitive;
1340
1341     if (case_sensitive)
1342         sensitive = WTF::TextCaseSensitive;
1343     else
1344         sensitive = WTF::TextCaseInsensitive;
1345
1346     return priv->page->markAllMatchesForText(String::fromUTF8(string), sensitive, highlight, limit);
1347 }
1348
1349 Eina_Bool ewk_view_text_matches_unmark_all(Evas_Object* o)
1350 {
1351     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1352     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1353     priv->page->unmarkAllTextMatches();
1354     return EINA_TRUE;
1355 }
1356
1357 Eina_Bool ewk_view_text_matches_highlight_set(Evas_Object* o, Eina_Bool highlight)
1358 {
1359     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1360     return ewk_frame_text_matches_highlight_set(sd->main_frame, highlight);
1361 }
1362
1363 Eina_Bool ewk_view_text_matches_highlight_get(const Evas_Object* o)
1364 {
1365     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1366     return ewk_frame_text_matches_highlight_get(sd->main_frame);
1367 }
1368
1369 Eina_Bool ewk_view_editable_set(Evas_Object* o, Eina_Bool editable)
1370 {
1371     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1372     return ewk_frame_editable_set(sd->main_frame, editable);
1373 }
1374
1375 char* ewk_view_selection_get(const Evas_Object* o)
1376 {
1377     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1378     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1379     CString s = priv->page->focusController()->focusedOrMainFrame()->editor()->selectedText().utf8();
1380     if (s.isNull())
1381         return 0;
1382     return strdup(s.data());
1383 }
1384
1385 static Eina_Bool _ewk_view_editor_command(Ewk_View_Private_Data* priv, const char* command, const char* value = 0)
1386 {
1387     return priv->page->focusController()->focusedOrMainFrame()->editor()->command(WTF::String::fromUTF8(command)).execute(value);
1388 }
1389
1390 Eina_Bool ewk_view_execute_editor_command(Evas_Object* o, const Ewk_Editor_Command command, const char* value)
1391 {
1392     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1393     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1394
1395     switch (command) {
1396     case EWK_EDITOR_COMMAND_INSERT_IMAGE:
1397         return _ewk_view_editor_command(priv, "InsertImage", value);
1398     case EWK_EDITOR_COMMAND_INSERT_TEXT:
1399         return _ewk_view_editor_command(priv, "InsertText", value);
1400     case EWK_EDITOR_COMMAND_SELECT_NONE:
1401         return _ewk_view_editor_command(priv, "Unselect");
1402     case EWK_EDITOR_COMMAND_SELECT_ALL:
1403         return _ewk_view_editor_command(priv, "SelectAll");
1404     case EWK_EDITOR_COMMAND_SELECT_PARAGRAPH:
1405         return _ewk_view_editor_command(priv, "SelectParagraph");
1406     case EWK_EDITOR_COMMAND_SELECT_SENTENCE:
1407         return _ewk_view_editor_command(priv, "SelectSentence");
1408     case EWK_EDITOR_COMMAND_SELECT_LINE:
1409         return _ewk_view_editor_command(priv, "SelectLine");
1410     case EWK_EDITOR_COMMAND_SELECT_WORD:
1411         return _ewk_view_editor_command(priv, "SelectWord");
1412     default:
1413         return EINA_FALSE;
1414     }
1415 }
1416
1417 Eina_Bool ewk_view_context_menu_forward_event(Evas_Object* o, const Evas_Event_Mouse_Down* ev)
1418 {
1419 #if ENABLE(CONTEXT_MENUS)
1420     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1421     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1422     Eina_Bool mouse_press_handled = EINA_FALSE;
1423
1424     priv->page->contextMenuController()->clearContextMenu();
1425     WebCore::Frame* main_frame = priv->page->mainFrame();
1426     Evas_Coord x, y;
1427     evas_object_geometry_get(sd->self, &x, &y, 0, 0);
1428
1429     WebCore::PlatformMouseEvent event(ev, WebCore::IntPoint(x, y));
1430
1431     if (main_frame->view()) {
1432         mouse_press_handled =
1433             main_frame->eventHandler()->handleMousePressEvent(event);
1434     }
1435
1436     if (main_frame->eventHandler()->sendContextMenuEvent(event))
1437         return EINA_FALSE;
1438
1439     WebCore::ContextMenu* coreMenu =
1440         priv->page->contextMenuController()->contextMenu();
1441     if (!coreMenu) {
1442         // WebCore decided not to create a context menu, return true if event
1443         // was handled by handleMouseReleaseEvent
1444         return mouse_press_handled;
1445     }
1446
1447     return EINA_TRUE;
1448 #else
1449     return EINA_FALSE;
1450 #endif
1451 }
1452
1453 double ewk_view_load_progress_get(const Evas_Object* o)
1454 {
1455     EWK_VIEW_SD_GET_OR_RETURN(o, sd, -1.0);
1456     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, -1.0);
1457     return priv->page->progress()->estimatedProgress();
1458 }
1459
1460 Eina_Bool ewk_view_stop(Evas_Object* o)
1461 {
1462     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1463     return ewk_frame_stop(sd->main_frame);
1464 }
1465
1466 Eina_Bool ewk_view_reload(Evas_Object* o)
1467 {
1468     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1469     return ewk_frame_reload(sd->main_frame);
1470 }
1471
1472 Eina_Bool ewk_view_reload_full(Evas_Object* o)
1473 {
1474     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1475     return ewk_frame_reload_full(sd->main_frame);
1476 }
1477
1478 Eina_Bool ewk_view_back(Evas_Object* o)
1479 {
1480     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1481     return ewk_frame_back(sd->main_frame);
1482 }
1483
1484 Eina_Bool ewk_view_forward(Evas_Object* o)
1485 {
1486     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1487     return ewk_frame_forward(sd->main_frame);
1488 }
1489
1490 Eina_Bool ewk_view_navigate(Evas_Object* o, int steps)
1491 {
1492     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1493     return ewk_frame_navigate(sd->main_frame, steps);
1494 }
1495
1496 Eina_Bool ewk_view_back_possible(Evas_Object* o)
1497 {
1498     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1499     return ewk_frame_back_possible(sd->main_frame);
1500 }
1501
1502 Eina_Bool ewk_view_forward_possible(Evas_Object* o)
1503 {
1504     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1505     return ewk_frame_forward_possible(sd->main_frame);
1506 }
1507
1508 Eina_Bool ewk_view_navigate_possible(Evas_Object* o, int steps)
1509 {
1510     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1511     return ewk_frame_navigate_possible(sd->main_frame, steps);
1512 }
1513
1514 Eina_Bool ewk_view_history_enable_get(const Evas_Object* o)
1515 {
1516     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1517     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1518     return static_cast<WebCore::BackForwardListImpl*>(priv->page->backForwardList())->enabled();
1519 }
1520
1521 Eina_Bool ewk_view_history_enable_set(Evas_Object* o, Eina_Bool enable)
1522 {
1523     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1524     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1525     static_cast<WebCore::BackForwardListImpl*>(priv->page->backForwardList())->setEnabled(enable);
1526     return EINA_TRUE;
1527 }
1528
1529 Ewk_History* ewk_view_history_get(const Evas_Object* o)
1530 {
1531     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1532     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1533     if (!static_cast<WebCore::BackForwardListImpl*>(priv->page->backForwardList())->enabled()) {
1534         ERR("asked history, but it's disabled! Returning 0!");
1535         return 0;
1536     }
1537     return priv->history;
1538 }
1539
1540 float ewk_view_zoom_get(const Evas_Object* o)
1541 {
1542     EWK_VIEW_SD_GET_OR_RETURN(o, sd, -1.0);
1543     return ewk_frame_zoom_get(sd->main_frame);
1544 }
1545
1546 Eina_Bool ewk_view_zoom_set(Evas_Object* o, float zoom, Evas_Coord cx, Evas_Coord cy)
1547 {
1548     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1549     EWK_VIEW_PRIV_GET(sd, priv);
1550
1551     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_FALSE);
1552     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api->zoom_set, EINA_FALSE);
1553
1554     if (!priv->settings.zoom_range.user_scalable) {
1555         WRN("userScalable is false");
1556         return EINA_FALSE;
1557     }
1558
1559     if (zoom < priv->settings.zoom_range.min_scale) {
1560         WRN("zoom level is < %f : %f", priv->settings.zoom_range.min_scale, zoom);
1561         return EINA_FALSE;
1562     }
1563     if (zoom > priv->settings.zoom_range.max_scale) {
1564         WRN("zoom level is > %f : %f", priv->settings.zoom_range.max_scale, zoom);
1565         return EINA_FALSE;
1566     }
1567
1568     _ewk_view_zoom_animated_mark_stop(sd);
1569     return sd->api->zoom_set(sd, zoom, cx, cy);
1570 }
1571
1572 Eina_Bool ewk_view_zoom_weak_smooth_scale_get(const Evas_Object* o)
1573 {
1574     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1575     return sd->zoom_weak_smooth_scale;
1576 }
1577
1578 void ewk_view_zoom_weak_smooth_scale_set(Evas_Object* o, Eina_Bool smooth_scale)
1579 {
1580     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
1581     smooth_scale = !!smooth_scale;
1582     if (sd->zoom_weak_smooth_scale == smooth_scale)
1583         return;
1584     sd->zoom_weak_smooth_scale = smooth_scale;
1585     EINA_SAFETY_ON_NULL_RETURN(sd->api);
1586     EINA_SAFETY_ON_NULL_RETURN(sd->api->zoom_weak_smooth_scale_set);
1587     sd->api->zoom_weak_smooth_scale_set(sd, smooth_scale);
1588 }
1589
1590 Eina_Bool ewk_view_zoom_weak_set(Evas_Object* o, float zoom, Evas_Coord cx, Evas_Coord cy)
1591 {
1592     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1593     EWK_VIEW_PRIV_GET(sd, priv);
1594
1595     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_FALSE);
1596     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api->zoom_weak_set, EINA_FALSE);
1597
1598     if (!priv->settings.zoom_range.user_scalable) {
1599         WRN("userScalable is false");
1600         return EINA_FALSE;
1601     }
1602
1603     if (zoom < priv->settings.zoom_range.min_scale) {
1604         WRN("zoom level is < %f : %f", priv->settings.zoom_range.min_scale, zoom);
1605         return EINA_FALSE;
1606     }
1607     if (zoom > priv->settings.zoom_range.max_scale) {
1608         WRN("zoom level is > %f : %f", priv->settings.zoom_range.max_scale, zoom);
1609         return EINA_FALSE;
1610     }
1611
1612     sd->animated_zoom.zoom.start = ewk_frame_zoom_get(sd->main_frame);
1613     sd->animated_zoom.zoom.end = zoom;
1614     sd->animated_zoom.zoom.current = zoom;
1615     return sd->api->zoom_weak_set(sd, zoom, cx, cy);
1616 }
1617
1618 Eina_Bool ewk_view_zoom_animated_mark_start(Evas_Object* o, float zoom)
1619 {
1620     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1621     sd->animated_zoom.zoom.start = zoom;
1622     return EINA_TRUE;
1623 }
1624
1625 Eina_Bool ewk_view_zoom_animated_mark_end(Evas_Object* o, float zoom)
1626 {
1627     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1628     sd->animated_zoom.zoom.end = zoom;
1629     return EINA_TRUE;
1630 }
1631
1632 Eina_Bool ewk_view_zoom_animated_mark_current(Evas_Object* o, float zoom)
1633 {
1634     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1635     sd->animated_zoom.zoom.current = zoom;
1636     return EINA_TRUE;
1637 }
1638
1639 Eina_Bool ewk_view_zoom_animated_mark_stop(Evas_Object* o)
1640 {
1641     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1642     _ewk_view_zoom_animated_mark_stop(sd);
1643     return EINA_TRUE;
1644 }
1645
1646 Eina_Bool ewk_view_zoom_animated_set(Evas_Object* o, float zoom, float duration, Evas_Coord cx, Evas_Coord cy)
1647 {
1648     double now;
1649     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1650     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1651     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_FALSE);
1652     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api->zoom_weak_set, EINA_FALSE);
1653
1654     if (!priv->settings.zoom_range.user_scalable) {
1655         WRN("userScalable is false");
1656         return EINA_FALSE;
1657     }
1658
1659     if (zoom < priv->settings.zoom_range.min_scale) {
1660         WRN("zoom level is < %f : %f", priv->settings.zoom_range.min_scale, zoom);
1661         return EINA_FALSE;
1662     }
1663     if (zoom > priv->settings.zoom_range.max_scale) {
1664         WRN("zoom level is > %f : %f", priv->settings.zoom_range.max_scale, zoom);
1665         return EINA_FALSE;
1666     }
1667
1668     if (priv->animated_zoom.animator)
1669         priv->animated_zoom.zoom.start = _ewk_view_zoom_animated_current(priv);
1670     else {
1671         priv->animated_zoom.zoom.start = ewk_frame_zoom_get(sd->main_frame);
1672         _ewk_view_zoom_animation_start(sd);
1673     }
1674
1675     if (cx < 0)
1676         cx = 0;
1677     if (cy < 0)
1678         cy = 0;
1679
1680     now = ecore_loop_time_get();
1681     priv->animated_zoom.time.start = now;
1682     priv->animated_zoom.time.end = now + duration;
1683     priv->animated_zoom.time.duration = duration;
1684     priv->animated_zoom.zoom.end = zoom;
1685     priv->animated_zoom.zoom.range = (priv->animated_zoom.zoom.end - priv->animated_zoom.zoom.start);
1686     priv->animated_zoom.center.x = cx;
1687     priv->animated_zoom.center.y = cy;
1688     sd->animated_zoom.zoom.current = priv->animated_zoom.zoom.start;
1689     sd->animated_zoom.zoom.start = priv->animated_zoom.zoom.start;
1690     sd->animated_zoom.zoom.end = priv->animated_zoom.zoom.end;
1691
1692     return EINA_TRUE;
1693 }
1694
1695 Eina_Bool ewk_view_zoom_text_only_get(const Evas_Object* o)
1696 {
1697     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1698     return ewk_frame_zoom_text_only_get(sd->main_frame);
1699 }
1700
1701 Eina_Bool ewk_view_zoom_text_only_set(Evas_Object* o, Eina_Bool setting)
1702 {
1703     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1704     return ewk_frame_zoom_text_only_set(sd->main_frame, setting);
1705 }
1706
1707 Eina_Bool ewk_view_pre_render_region(Evas_Object* o, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, float zoom)
1708 {
1709     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1710     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1711     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api->pre_render_region, EINA_FALSE);
1712     float cur_zoom;
1713     Evas_Coord cw, ch;
1714
1715     /* When doing animated zoom it's not possible to call pre-render since it
1716      * would screw up parameters that animation is currently using
1717      */
1718     if (priv->animated_zoom.animator)
1719         return EINA_FALSE;
1720
1721     cur_zoom = ewk_frame_zoom_get(sd->main_frame);
1722
1723     if (cur_zoom < 0.00001)
1724         return EINA_FALSE;
1725     if (!ewk_frame_contents_size_get(sd->main_frame, &cw, &ch))
1726         return EINA_FALSE;
1727
1728     cw *= zoom / cur_zoom;
1729     ch *= zoom / cur_zoom;
1730     DBG("region %d,%d+%dx%d @ %f contents=%dx%d", x, y, w, h, zoom, cw, ch);
1731
1732     if (x + w > cw)
1733         w = cw - x;
1734
1735     if (y + h > ch)
1736         h = ch - y;
1737
1738     if (x < 0) {
1739         w += x;
1740         x = 0;
1741     }
1742     if (y < 0) {
1743         h += y;
1744         y = 0;
1745     }
1746
1747     return sd->api->pre_render_region(sd, x, y, w, h, zoom);
1748 }
1749
1750 Eina_Bool ewk_view_pre_render_relative_radius(Evas_Object* o, unsigned int n)
1751 {
1752     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1753     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1754     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api->pre_render_relative_radius, EINA_FALSE);
1755     float cur_zoom;
1756
1757     if (priv->animated_zoom.animator)
1758         return EINA_FALSE;
1759
1760     cur_zoom = ewk_frame_zoom_get(sd->main_frame);
1761     return sd->api->pre_render_relative_radius(sd, n, cur_zoom);
1762 }
1763
1764 unsigned int ewk_view_imh_get(const Evas_Object* o)
1765 {
1766     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1767     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1768     return priv->imh;
1769 }
1770
1771 void ewk_view_pre_render_cancel(Evas_Object* o)
1772 {
1773     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
1774     EINA_SAFETY_ON_NULL_RETURN(sd->api->pre_render_cancel);
1775     sd->api->pre_render_cancel(sd);
1776 }
1777
1778 Eina_Bool ewk_view_enable_render(const Evas_Object* o)
1779 {
1780     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1781     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api->enable_render, EINA_FALSE);
1782     return sd->api->enable_render(sd);
1783 }
1784
1785 Eina_Bool ewk_view_disable_render(const Evas_Object* o)
1786 {
1787     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1788     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api->disable_render, EINA_FALSE);
1789     return sd->api->disable_render(sd);
1790 }
1791
1792 const char* ewk_view_setting_user_agent_get(const Evas_Object* o)
1793 {
1794     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1795     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1796     return priv->settings.user_agent;
1797 }
1798
1799 Eina_Bool ewk_view_setting_user_agent_set(Evas_Object* o, const char* user_agent)
1800 {
1801     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1802     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1803     if (eina_stringshare_replace(&priv->settings.user_agent, user_agent)) {
1804         WebCore::FrameLoaderClientEfl* client = static_cast<WebCore::FrameLoaderClientEfl*>(priv->main_frame->loader()->client());
1805         client->setCustomUserAgent(String::fromUTF8(user_agent));
1806     }
1807     return EINA_TRUE;
1808 }
1809
1810 const char* ewk_view_setting_user_stylesheet_get(const Evas_Object* o)
1811 {
1812     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
1813     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
1814     return priv->settings.user_stylesheet;
1815 }
1816
1817 Eina_Bool ewk_view_setting_user_stylesheet_set(Evas_Object* o, const char* uri)
1818 {
1819     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1820     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1821     if (eina_stringshare_replace(&priv->settings.user_stylesheet, uri)) {
1822         WebCore::KURL kurl(WebCore::KURL(), String::fromUTF8(uri));
1823         priv->page_settings->setUserStyleSheetLocation(kurl);
1824     }
1825     return EINA_TRUE;
1826 }
1827
1828 Eina_Bool ewk_view_setting_auto_load_images_get(const Evas_Object* o)
1829 {
1830     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1831     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1832     return priv->settings.auto_load_images;
1833 }
1834
1835 Eina_Bool ewk_view_setting_auto_load_images_set(Evas_Object* o, Eina_Bool automatic)
1836 {
1837     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1838     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1839     automatic = !!automatic;
1840     if (priv->settings.auto_load_images != automatic) {
1841         priv->page_settings->setLoadsImagesAutomatically(automatic);
1842         priv->settings.auto_load_images = automatic;
1843     }
1844     return EINA_TRUE;
1845 }
1846
1847 Eina_Bool ewk_view_setting_auto_shrink_images_get(const Evas_Object* o)
1848 {
1849     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1850     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1851     return priv->settings.auto_shrink_images;
1852 }
1853
1854 Eina_Bool ewk_view_setting_auto_shrink_images_set(Evas_Object* o, Eina_Bool automatic)
1855 {
1856     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1857     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1858     automatic = !!automatic;
1859     if (priv->settings.auto_shrink_images != automatic) {
1860         priv->page_settings->setShrinksStandaloneImagesToFit(automatic);
1861         priv->settings.auto_shrink_images = automatic;
1862     }
1863     return EINA_TRUE;
1864 }
1865
1866 Eina_Bool ewk_view_setting_enable_auto_resize_window_get(const Evas_Object* o)
1867 {
1868     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1869     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1870     return priv->settings.enable_auto_resize_window;
1871 }
1872
1873 Eina_Bool ewk_view_setting_enable_auto_resize_window_set(Evas_Object* o, Eina_Bool resizable)
1874 {
1875     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1876     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1877     priv->settings.enable_auto_resize_window = resizable;
1878     return EINA_TRUE;
1879 }
1880
1881 Eina_Bool ewk_view_setting_enable_scripts_get(const Evas_Object* o)
1882 {
1883     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1884     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1885     return priv->settings.enable_scripts;
1886 }
1887
1888 Eina_Bool ewk_view_setting_enable_scripts_set(Evas_Object* o, Eina_Bool enable)
1889 {
1890     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1891     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1892     enable = !!enable;
1893     if (priv->settings.enable_scripts != enable) {
1894         priv->page_settings->setJavaScriptEnabled(enable);
1895         priv->settings.enable_scripts = enable;
1896     }
1897     return EINA_TRUE;
1898 }
1899
1900 Eina_Bool ewk_view_setting_enable_plugins_get(const Evas_Object* o)
1901 {
1902     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1903     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1904     return priv->settings.enable_plugins;
1905 }
1906
1907 Eina_Bool ewk_view_setting_enable_plugins_set(Evas_Object* o, Eina_Bool enable)
1908 {
1909     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1910     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1911     enable = !!enable;
1912     if (priv->settings.enable_plugins != enable) {
1913         priv->page_settings->setPluginsEnabled(enable);
1914         priv->settings.enable_plugins = enable;
1915     }
1916     return EINA_TRUE;
1917 }
1918
1919 Eina_Bool ewk_view_setting_enable_frame_flattening_get(const Evas_Object* o)
1920 {
1921     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1922     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1923     return priv->settings.enable_frame_flattening;
1924 }
1925
1926 Eina_Bool ewk_view_setting_enable_frame_flattening_set(Evas_Object* o, Eina_Bool enable)
1927 {
1928     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1929     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1930     enable = !!enable;
1931     if (priv->settings.enable_frame_flattening != enable) {
1932         priv->page_settings->setFrameFlatteningEnabled(enable);
1933         priv->settings.enable_frame_flattening = enable;
1934     }
1935     return EINA_TRUE;
1936 }
1937
1938 Eina_Bool ewk_view_setting_scripts_window_open_get(const Evas_Object* o)
1939 {
1940     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1941     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1942     return priv->settings.scripts_window_open;
1943 }
1944
1945 Eina_Bool ewk_view_setting_scripts_window_open_set(Evas_Object* o, Eina_Bool allow)
1946 {
1947     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1948     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1949     allow = !!allow;
1950     if (priv->settings.scripts_window_open != allow) {
1951         priv->page_settings->setJavaScriptCanOpenWindowsAutomatically(allow);
1952         priv->settings.scripts_window_open = allow;
1953     }
1954     return EINA_TRUE;
1955 }
1956
1957 Eina_Bool ewk_view_setting_scripts_can_close_windows_get(const Evas_Object* o)
1958 {
1959     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1960     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1961     return priv->settings.scripts_can_close_windows;
1962 }
1963
1964 Eina_Bool ewk_view_setting_scripts_can_close_windows_set(Evas_Object* o, Eina_Bool allow)
1965 {
1966     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1967     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1968     allow = !!allow;
1969     if (priv->settings.scripts_can_close_windows != allow) {
1970         priv->page_settings->setAllowScriptsToCloseWindows(allow);
1971         priv->settings.scripts_can_close_windows = allow;
1972     }
1973     return EINA_TRUE;
1974 }
1975
1976 Eina_Bool ewk_view_setting_resizable_textareas_get(const Evas_Object* o)
1977 {
1978     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1979     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1980     return priv->settings.resizable_textareas;
1981 }
1982
1983 Eina_Bool ewk_view_setting_resizable_textareas_set(Evas_Object* o, Eina_Bool enable)
1984 {
1985     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1986     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1987     enable = !!enable;
1988     if (priv->settings.resizable_textareas != enable) {
1989         priv->page_settings->setTextAreasAreResizable(enable);
1990         priv->settings.resizable_textareas = enable;
1991     }
1992     return EINA_TRUE;
1993 }
1994
1995 Eina_Bool ewk_view_setting_private_browsing_get(const Evas_Object* o)
1996 {
1997     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
1998     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
1999     return priv->settings.private_browsing;
2000 }
2001
2002 Eina_Bool ewk_view_setting_private_browsing_set(Evas_Object* o, Eina_Bool enable)
2003 {
2004     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2005     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2006     enable = !!enable;
2007     if (priv->settings.private_browsing != enable) {
2008         priv->page_settings->setPrivateBrowsingEnabled(enable);
2009         priv->settings.private_browsing = enable;
2010     }
2011     return EINA_TRUE;
2012 }
2013
2014 Eina_Bool ewk_view_setting_offline_app_cache_get(const Evas_Object* o)
2015 {
2016     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2017     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2018     return priv->settings.offline_app_cache;
2019 }
2020
2021 Eina_Bool ewk_view_setting_offline_app_cache_set(Evas_Object* o, Eina_Bool enable)
2022 {
2023     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2024     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2025     enable = !!enable;
2026     if (priv->settings.offline_app_cache != enable) {
2027         priv->page_settings->setOfflineWebApplicationCacheEnabled(enable);
2028         priv->settings.offline_app_cache = enable;
2029     }
2030     return EINA_TRUE;
2031 }
2032
2033
2034 Eina_Bool ewk_view_setting_caret_browsing_get(const Evas_Object* o)
2035 {
2036     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2037     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2038     return priv->settings.caret_browsing;
2039 }
2040
2041 Eina_Bool ewk_view_setting_caret_browsing_set(Evas_Object* o, Eina_Bool enable)
2042 {
2043     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2044     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2045     enable = !!enable;
2046     if (priv->settings.caret_browsing != enable) {
2047         priv->page_settings->setCaretBrowsingEnabled(enable);
2048         priv->settings.caret_browsing = enable;
2049     }
2050     return EINA_TRUE;
2051 }
2052
2053 const char* ewk_view_setting_encoding_custom_get(const Evas_Object* o)
2054 {
2055     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2056     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2057     Evas_Object* main_frame = ewk_view_frame_main_get(o);
2058     WebCore::Frame* core_frame = ewk_frame_core_get(main_frame);
2059
2060     String overrideEncoding = core_frame->loader()->documentLoader()->overrideEncoding();
2061
2062     if (overrideEncoding.isEmpty())
2063         return 0;
2064
2065     eina_stringshare_replace(&priv->settings.encoding_custom, overrideEncoding.utf8().data());
2066     return priv->settings.encoding_custom;
2067 }
2068
2069 Eina_Bool ewk_view_setting_encoding_custom_set(Evas_Object* o, const char* encoding)
2070 {
2071     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2072     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2073     Evas_Object* main_frame = ewk_view_frame_main_get(o);
2074     WebCore::Frame* core_frame = ewk_frame_core_get(main_frame);
2075     DBG("%s", encoding);
2076     if (eina_stringshare_replace(&priv->settings.encoding_custom, encoding))
2077         core_frame->loader()->reloadWithOverrideEncoding(String::fromUTF8(encoding));
2078     return EINA_TRUE;
2079 }
2080
2081 const char* ewk_view_setting_encoding_default_get(const Evas_Object* o)
2082 {
2083     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2084     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2085     return priv->settings.encoding_default;
2086 }
2087
2088 Eina_Bool ewk_view_setting_encoding_default_set(Evas_Object* o, const char* encoding)
2089 {
2090     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2091     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2092     if (eina_stringshare_replace(&priv->settings.encoding_default, encoding))
2093         priv->page_settings->setDefaultTextEncodingName(String::fromUTF8(encoding));
2094     return EINA_TRUE;
2095 }
2096
2097 Eina_Bool ewk_view_setting_encoding_detector_set(Evas_Object* o, Eina_Bool enable)
2098 {
2099     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2100     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2101     enable = !!enable;
2102     if (priv->settings.encoding_detector != enable) {
2103         priv->page_settings->setUsesEncodingDetector(enable);
2104         priv->settings.encoding_detector = enable;
2105     }
2106     return EINA_TRUE;
2107 }
2108
2109 Eina_Bool ewk_view_setting_encoding_detector_get(const Evas_Object* o)
2110 {
2111     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2112     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2113     return priv->settings.encoding_detector;
2114 }
2115
2116 Eina_Bool ewk_view_setting_enable_developer_extras_get(const Evas_Object* o)
2117 {
2118     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2119     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2120     return priv->settings.enable_developer_extras;
2121 }
2122
2123 Eina_Bool ewk_view_setting_enable_developer_extras_set(Evas_Object* o, Eina_Bool enable)
2124 {
2125     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2126     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2127     enable = !!enable;
2128     if (priv->settings.enable_developer_extras != enable) {
2129         priv->page_settings->setDeveloperExtrasEnabled(enable);
2130         priv->settings.enable_developer_extras = enable;
2131     }
2132     return EINA_TRUE;
2133 }
2134
2135 int ewk_view_setting_font_minimum_size_get(const Evas_Object* o)
2136 {
2137     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2138     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2139     return priv->settings.font_minimum_size;
2140 }
2141
2142 Eina_Bool ewk_view_setting_font_minimum_size_set(Evas_Object* o, int size)
2143 {
2144     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2145     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2146     if (priv->settings.font_minimum_size != size) {
2147         priv->page_settings->setMinimumFontSize(size);
2148         priv->settings.font_minimum_size = size;
2149     }
2150     return EINA_TRUE;
2151 }
2152
2153 int ewk_view_setting_font_minimum_logical_size_get(const Evas_Object* o)
2154 {
2155     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2156     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2157     return priv->settings.font_minimum_logical_size;
2158 }
2159
2160 Eina_Bool ewk_view_setting_font_minimum_logical_size_set(Evas_Object* o, int size)
2161 {
2162     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2163     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2164     if (priv->settings.font_minimum_logical_size != size) {
2165         priv->page_settings->setMinimumLogicalFontSize(size);
2166         priv->settings.font_minimum_logical_size = size;
2167     }
2168     return EINA_TRUE;
2169 }
2170
2171 int ewk_view_setting_font_default_size_get(const Evas_Object* o)
2172 {
2173     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2174     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2175     return priv->settings.font_default_size;
2176 }
2177
2178 Eina_Bool ewk_view_setting_font_default_size_set(Evas_Object* o, int size)
2179 {
2180     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2181     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2182     if (priv->settings.font_default_size != size) {
2183         priv->page_settings->setDefaultFontSize(size);
2184         priv->settings.font_default_size = size;
2185     }
2186     return EINA_TRUE;
2187 }
2188
2189 int ewk_view_setting_font_monospace_size_get(const Evas_Object* o)
2190 {
2191     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2192     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2193     return priv->settings.font_monospace_size;
2194 }
2195
2196 Eina_Bool ewk_view_setting_font_monospace_size_set(Evas_Object* o, int size)
2197 {
2198     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2199     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2200     if (priv->settings.font_monospace_size != size) {
2201         priv->page_settings->setDefaultFixedFontSize(size);
2202         priv->settings.font_monospace_size = size;
2203     }
2204     return EINA_TRUE;
2205 }
2206
2207 const char* ewk_view_font_family_name_get(const Evas_Object* o, Ewk_Font_Family font_family)
2208 {
2209     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2210     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2211
2212     switch (font_family) {
2213     case EWK_FONT_FAMILY_STANDARD:
2214         return priv->settings.font_standard;
2215     case EWK_FONT_FAMILY_CURSIVE:
2216         return priv->settings.font_cursive;
2217     case EWK_FONT_FAMILY_FANTASY:
2218         return priv->settings.font_fantasy;
2219     case EWK_FONT_FAMILY_MONOSPACE:
2220         return priv->settings.font_monospace;
2221     case EWK_FONT_FAMILY_SERIF:
2222         return priv->settings.font_serif;
2223     case EWK_FONT_FAMILY_SANS_SERIF:
2224         return priv->settings.font_sans_serif;
2225     }
2226     return 0;
2227 }
2228
2229 Eina_Bool ewk_view_font_family_name_set(Evas_Object* o, Ewk_Font_Family font_family, const char* name)
2230 {
2231     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2232     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2233
2234     switch (font_family) {
2235     case EWK_FONT_FAMILY_STANDARD:
2236         if (eina_stringshare_replace(&priv->settings.font_standard, name))
2237             priv->page_settings->setStandardFontFamily(AtomicString::fromUTF8(name));
2238         break;
2239     case EWK_FONT_FAMILY_CURSIVE:
2240         if (eina_stringshare_replace(&priv->settings.font_cursive, name))
2241             priv->page_settings->setCursiveFontFamily(AtomicString::fromUTF8(name));
2242         break;
2243     case EWK_FONT_FAMILY_FANTASY:
2244         if (eina_stringshare_replace(&priv->settings.font_fantasy, name))
2245             priv->page_settings->setFantasyFontFamily(AtomicString::fromUTF8(name));
2246         break;
2247     case EWK_FONT_FAMILY_MONOSPACE:
2248         if (eina_stringshare_replace(&priv->settings.font_monospace, name))
2249             priv->page_settings->setFixedFontFamily(AtomicString::fromUTF8(name));
2250         break;
2251     case EWK_FONT_FAMILY_SERIF:
2252         if (eina_stringshare_replace(&priv->settings.font_serif, name))
2253             priv->page_settings->setSerifFontFamily(AtomicString::fromUTF8(name));
2254         break;
2255     case EWK_FONT_FAMILY_SANS_SERIF:
2256         if (eina_stringshare_replace(&priv->settings.font_sans_serif, name))
2257             priv->page_settings->setSansSerifFontFamily(AtomicString::fromUTF8(name));
2258         break;
2259     default:
2260         return EINA_FALSE;
2261     }
2262
2263     return EINA_TRUE;
2264 }
2265
2266 Eina_Bool ewk_view_setting_spatial_navigation_get(const Evas_Object* o)
2267 {
2268     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2269     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2270     return priv->settings.spatial_navigation;
2271 }
2272
2273 Eina_Bool ewk_view_setting_spatial_navigation_set(Evas_Object* o, Eina_Bool enable)
2274 {
2275     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2276     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2277     enable = !!enable;
2278     if (priv->settings.spatial_navigation != enable) {
2279         priv->page_settings->setSpatialNavigationEnabled(enable);
2280         priv->settings.spatial_navigation = enable;
2281     }
2282     return EINA_TRUE;
2283 }
2284
2285 Eina_Bool ewk_view_setting_local_storage_get(const Evas_Object* o)
2286 {
2287     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2288     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2289     return priv->settings.local_storage;
2290 }
2291
2292 Eina_Bool ewk_view_setting_local_storage_set(Evas_Object* o, Eina_Bool enable)
2293 {
2294     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2295     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2296     enable = !!enable;
2297     if (priv->settings.local_storage != enable) {
2298         priv->page_settings->setLocalStorageEnabled(enable);
2299         priv->settings.local_storage = enable;
2300     }
2301     return EINA_TRUE;
2302 }
2303
2304 Eina_Bool ewk_view_setting_page_cache_get(const Evas_Object* o)
2305 {
2306     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2307     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2308     return priv->settings.page_cache;
2309 }
2310
2311 Eina_Bool ewk_view_setting_page_cache_set(Evas_Object* o, Eina_Bool enable)
2312 {
2313     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2314     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2315     enable = !!enable;
2316     if (priv->settings.page_cache != enable) {
2317         priv->page_settings->setUsesPageCache(enable);
2318         priv->settings.page_cache = enable;
2319     }
2320     return EINA_TRUE;
2321 }
2322
2323 const char* ewk_view_setting_local_storage_database_path_get(const Evas_Object* o)
2324 {
2325     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2326     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
2327     return priv->settings.local_storage_database_path;
2328 }
2329
2330 Eina_Bool ewk_view_setting_local_storage_database_path_set(Evas_Object* o, const char* path)
2331 {
2332     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2333     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2334     if (eina_stringshare_replace(&priv->settings.local_storage_database_path, path))
2335         priv->page_settings->setLocalStorageDatabasePath(String::fromUTF8(path));
2336     return EINA_TRUE;
2337 }
2338
2339 Eina_Bool ewk_view_setting_minimum_timer_interval_set(Evas_Object* o, double interval)
2340 {
2341     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2342     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2343     if (fabs(priv->settings.dom_timer_interval - interval) >= std::numeric_limits<double>::epsilon()) {
2344         priv->page_settings->setMinDOMTimerInterval(interval);
2345         priv->settings.dom_timer_interval = interval;
2346     }
2347     return EINA_TRUE;
2348 }
2349
2350 double ewk_view_setting_minimum_timer_interval_get(const Evas_Object* o)
2351 {
2352     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
2353     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
2354     return priv->settings.dom_timer_interval;
2355 }
2356
2357 Ewk_View_Smart_Data* ewk_view_smart_data_get(const Evas_Object* o)
2358 {
2359     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2360     return sd;
2361 }
2362
2363 /**
2364  * Gets the internal array of repaint requests.
2365  *
2366  * This array should not be modified anyhow. It should be processed
2367  * immediately as any further ewk_view call might change it, like
2368  * those that add repaints or flush them, so be sure that your code
2369  * does not call any of those while you process the repaints,
2370  * otherwise copy the array.
2371  *
2372  * @param priv private handle pointer of the view to get repaints.
2373  * @param count where to return the number of elements of returned array, may be @c 0.
2374  *
2375  * @return reference to array of requested repaints.
2376  *
2377  * @note this is not for general use but just for subclasses that want
2378  *       to define their own backing store.
2379  */
2380 const Eina_Rectangle* ewk_view_repaints_get(const Ewk_View_Private_Data* priv, size_t* count)
2381 {
2382     if (count)
2383         *count = 0;
2384     EINA_SAFETY_ON_NULL_RETURN_VAL(priv, 0);
2385     if (count)
2386         *count = priv->repaints.count;
2387     return priv->repaints.array;
2388 }
2389
2390 /**
2391  * Gets the internal array of scroll requests.
2392  *
2393  * This array should not be modified anyhow. It should be processed
2394  * immediately as any further ewk_view call might change it, like
2395  * those that add scrolls or flush them, so be sure that your code
2396  * does not call any of those while you process the scrolls,
2397  * otherwise copy the array.
2398  *
2399  * @param priv private handle pointer of the view to get scrolls.
2400  * @param count where to return the number of elements of returned array, may be @c 0.
2401  *
2402  * @return reference to array of requested scrolls.
2403  *
2404  * @note this is not for general use but just for subclasses that want
2405  *       to define their own backing store.
2406  */
2407 const Ewk_Scroll_Request* ewk_view_scroll_requests_get(const Ewk_View_Private_Data* priv, size_t* count)
2408 {
2409     if (count)
2410         *count = 0;
2411     EINA_SAFETY_ON_NULL_RETURN_VAL(priv, 0);
2412     if (count)
2413         *count = priv->scrolls.count;
2414     return priv->scrolls.array;
2415 }
2416
2417 /**
2418  * Add a new repaint request to queue.
2419  *
2420  * The repaints are assumed to be relative to current viewport.
2421  *
2422  * @param priv private handle pointer of the view to add repaint request.
2423  * @param x horizontal position relative to current view port (scrolled).
2424  * @param y vertical position relative to current view port (scrolled).
2425  * @param w width of area to be repainted
2426  * @param h height of area to be repainted
2427  *
2428  * @note this is not for general use but just for subclasses that want
2429  *       to define their own backing store.
2430  */
2431 void ewk_view_repaint_add(Ewk_View_Private_Data* priv, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
2432 {
2433     EINA_SAFETY_ON_NULL_RETURN(priv);
2434     _ewk_view_repaint_add(priv, x, y, w, h);
2435 }
2436
2437 /**
2438  * Do layout if required, applied recursively.
2439  *
2440  * @param priv private handle pointer of the view to layout.
2441  *
2442  * @note this is not for general use but just for subclasses that want
2443  *       to define their own backing store.
2444  */
2445 void ewk_view_layout_if_needed_recursive(Ewk_View_Private_Data* priv)
2446 {
2447     EINA_SAFETY_ON_NULL_RETURN(priv);
2448
2449     WebCore::FrameView* v = priv->main_frame->view();
2450     if (!v) {
2451         ERR("no main frame view");
2452         return;
2453     }
2454     v->updateLayoutAndStyleIfNeededRecursive();
2455 }
2456
2457 void ewk_view_scrolls_process(Ewk_View_Smart_Data* sd)
2458 {
2459     EINA_SAFETY_ON_NULL_RETURN(sd);
2460     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
2461     if (!sd->api->scrolls_process(sd))
2462         ERR("failed to process scrolls.");
2463     _ewk_view_scrolls_flush(priv);
2464 }
2465
2466 /**
2467  * @brief Structure that keeps the paint context.
2468  *
2469  * @internal
2470  *
2471  * @note This is not for general use but just for subclasses that want
2472  *       to define their own backing store.
2473  */
2474 struct _Ewk_View_Paint_Context {
2475     WebCore::GraphicsContext* gc;
2476     WebCore::FrameView* view;
2477     cairo_t* cr;
2478 };
2479
2480 Ewk_View_Paint_Context* ewk_view_paint_context_new(Ewk_View_Private_Data* priv, cairo_t* cr)
2481 {
2482     EINA_SAFETY_ON_NULL_RETURN_VAL(priv, 0);
2483     EINA_SAFETY_ON_NULL_RETURN_VAL(cr, 0);
2484     EINA_SAFETY_ON_NULL_RETURN_VAL(priv->main_frame, 0);
2485     WebCore::FrameView* view = priv->main_frame->view();
2486     EINA_SAFETY_ON_NULL_RETURN_VAL(view, 0);
2487     Ewk_View_Paint_Context* ctxt = static_cast<Ewk_View_Paint_Context*>(malloc(sizeof(*ctxt)));
2488     EINA_SAFETY_ON_NULL_RETURN_VAL(ctxt, 0);
2489
2490     ctxt->gc = new WebCore::GraphicsContext(cr);
2491     if (!ctxt->gc) {
2492         free(ctxt);
2493         return 0;
2494     }
2495     ctxt->view = view;
2496     ctxt->cr = cairo_reference(cr);
2497     return ctxt;
2498 }
2499
2500 void ewk_view_paint_context_free(Ewk_View_Paint_Context* ctxt)
2501 {
2502     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2503     delete ctxt->gc;
2504     cairo_destroy(ctxt->cr);
2505     free(ctxt);
2506 }
2507
2508 void ewk_view_paint_context_save(Ewk_View_Paint_Context* ctxt)
2509 {
2510     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2511     cairo_save(ctxt->cr);
2512     ctxt->gc->save();
2513 }
2514
2515 void ewk_view_paint_context_restore(Ewk_View_Paint_Context* ctxt)
2516 {
2517     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2518     ctxt->gc->restore();
2519     cairo_restore(ctxt->cr);
2520 }
2521
2522 void ewk_view_paint_context_clip(Ewk_View_Paint_Context* ctxt, const Eina_Rectangle* area)
2523 {
2524     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2525     EINA_SAFETY_ON_NULL_RETURN(area);
2526     ctxt->gc->clip(WebCore::IntRect(area->x, area->y, area->w, area->h));
2527 }
2528
2529 void ewk_view_paint_context_paint(Ewk_View_Paint_Context* ctxt, const Eina_Rectangle* area)
2530 {
2531     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2532     EINA_SAFETY_ON_NULL_RETURN(area);
2533
2534     WebCore::IntRect rect(area->x, area->y, area->w, area->h);
2535
2536     if (ctxt->view->isTransparent())
2537         ctxt->gc->clearRect(rect);
2538     ctxt->view->paint(ctxt->gc, rect);
2539 }
2540
2541 void ewk_view_paint_context_paint_contents(Ewk_View_Paint_Context* ctxt, const Eina_Rectangle* area)
2542 {
2543     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2544     EINA_SAFETY_ON_NULL_RETURN(area);
2545
2546     WebCore::IntRect rect(area->x, area->y, area->w, area->h);
2547
2548     if (ctxt->view->isTransparent())
2549         ctxt->gc->clearRect(rect);
2550
2551     ctxt->view->paintContents(ctxt->gc, rect);
2552 }
2553
2554 void ewk_view_paint_context_scale(Ewk_View_Paint_Context* ctxt, float scale_x, float scale_y)
2555 {
2556     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2557
2558     ctxt->gc->scale(WebCore::FloatSize(scale_x, scale_y));
2559 }
2560
2561 void ewk_view_paint_context_translate(Ewk_View_Paint_Context* ctxt, float x, float y)
2562 {
2563     EINA_SAFETY_ON_NULL_RETURN(ctxt);
2564
2565     ctxt->gc->translate(x, y);
2566 }
2567
2568 Eina_Bool ewk_view_paint(Ewk_View_Private_Data* priv, cairo_t* cr, const Eina_Rectangle* area)
2569 {
2570     EINA_SAFETY_ON_NULL_RETURN_VAL(priv, EINA_FALSE);
2571     EINA_SAFETY_ON_NULL_RETURN_VAL(cr, EINA_FALSE);
2572     EINA_SAFETY_ON_NULL_RETURN_VAL(area, EINA_FALSE);
2573     WebCore::FrameView* view = priv->main_frame->view();
2574     EINA_SAFETY_ON_NULL_RETURN_VAL(view, EINA_FALSE);
2575
2576     if (view->needsLayout())
2577         view->forceLayout();
2578     WebCore::GraphicsContext gc(cr);
2579     WebCore::IntRect rect(area->x, area->y, area->w, area->h);
2580
2581     cairo_save(cr);
2582     gc.save();
2583     gc.clip(rect);
2584     if (view->isTransparent())
2585         gc.clearRect(rect);
2586     view->paint(&gc, rect);
2587     gc.restore();
2588     cairo_restore(cr);
2589
2590     return EINA_TRUE;
2591 }
2592
2593 Eina_Bool ewk_view_paint_contents(Ewk_View_Private_Data* priv, cairo_t* cr, const Eina_Rectangle* area)
2594 {
2595     EINA_SAFETY_ON_NULL_RETURN_VAL(priv, EINA_FALSE);
2596     EINA_SAFETY_ON_NULL_RETURN_VAL(cr, EINA_FALSE);
2597     EINA_SAFETY_ON_NULL_RETURN_VAL(area, EINA_FALSE);
2598     WebCore::FrameView* view = priv->main_frame->view();
2599     EINA_SAFETY_ON_NULL_RETURN_VAL(view, EINA_FALSE);
2600
2601     WebCore::GraphicsContext gc(cr);
2602     WebCore::IntRect rect(area->x, area->y, area->w, area->h);
2603
2604     cairo_save(cr);
2605     gc.save();
2606     gc.clip(rect);
2607     if (view->isTransparent())
2608         gc.clearRect(rect);
2609     view->paintContents(&gc,  rect);
2610     gc.restore();
2611     cairo_restore(cr);
2612
2613     return EINA_TRUE;
2614 }
2615
2616
2617 /* internal methods ****************************************************/
2618 /**
2619  * @internal
2620  * Reports the view is ready to be displayed as all elements are aready.
2621  *
2622  * Emits signal: "ready" with no parameters.
2623  */
2624 void ewk_view_ready(Evas_Object* o)
2625 {
2626     DBG("o=%p", o);
2627     evas_object_smart_callback_call(o, "ready", 0);
2628 }
2629
2630 /**
2631  * @internal
2632  * Reports the state of input method changed. This is triggered, for example
2633  * when a input field received/lost focus
2634  *
2635  * Emits signal: "inputmethod,changed" with a boolean indicating whether it's
2636  * enabled or not.
2637  */
2638 void ewk_view_input_method_state_set(Evas_Object* o, Eina_Bool active)
2639 {
2640     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
2641     EWK_VIEW_PRIV_GET(sd, priv);
2642     WebCore::Frame* focusedFrame = priv->page->focusController()->focusedOrMainFrame();
2643
2644     priv->imh = 0;
2645     if (focusedFrame
2646         && focusedFrame->document()
2647         && focusedFrame->document()->focusedNode()
2648         && focusedFrame->document()->focusedNode()->hasTagName(WebCore::HTMLNames::inputTag)) {
2649         WebCore::HTMLInputElement* inputElement;
2650
2651         inputElement = static_cast<WebCore::HTMLInputElement*>(focusedFrame->document()->focusedNode());
2652         if (inputElement) {
2653             // for password fields, active == false
2654             if (!active) {
2655                 active = inputElement->isPasswordField();
2656                 priv->imh = inputElement->isPasswordField() * EWK_IMH_PASSWORD;
2657             } else {
2658                 // Set input method hints for "number", "tel", "email", and "url" input elements.
2659                 priv->imh |= inputElement->isTelephoneField() * EWK_IMH_TELEPHONE;
2660                 priv->imh |= inputElement->isNumberField() * EWK_IMH_NUMBER;
2661                 priv->imh |= inputElement->isEmailField() * EWK_IMH_EMAIL;
2662                 priv->imh |= inputElement->isURLField() * EWK_IMH_URL;
2663             }
2664         }
2665     }
2666
2667     evas_object_smart_callback_call(o, "inputmethod,changed", (void*)active);
2668 }
2669
2670 /**
2671  * @internal
2672  * The view title was changed by the frame loader.
2673  *
2674  * Emits signal: "title,changed" with pointer to new title string.
2675  */
2676 void ewk_view_title_set(Evas_Object* o, const char* title)
2677 {
2678     DBG("o=%p, title=%s", o, title ? title : "(null)");
2679     evas_object_smart_callback_call(o, "title,changed", (void*)title);
2680 }
2681
2682 /**
2683  * @internal
2684  * Reports that main frame's uri changed.
2685  *
2686  * Emits signal: "uri,changed" with pointer to the new uri string.
2687  */
2688 void ewk_view_uri_changed(Evas_Object* o)
2689 {
2690     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
2691     const char* uri = ewk_frame_uri_get(sd->main_frame);
2692     DBG("o=%p, uri=%s", o, uri ? uri : "(null)");
2693     evas_object_smart_callback_call(o, "uri,changed", (void*)uri);
2694 }
2695
2696 /**
2697  * @internal
2698  * Reports that a DOM document object has finished loading for @p frame.
2699  *
2700  * @param o View which contains the frame.
2701  * @param frame The frame whose load has triggered the event.
2702  *
2703  * Emits signal: "load,document,finished" with @p frame as the parameter.
2704  */
2705 void ewk_view_load_document_finished(Evas_Object* o, Evas_Object* frame)
2706 {
2707     evas_object_smart_callback_call(o, "load,document,finished", frame);
2708 }
2709
2710 /**
2711  * @internal
2712  * Reports the view started loading something.
2713  *
2714  * @param o View.
2715  *
2716  * Emits signal: "load,started" with no parameters.
2717  */
2718 void ewk_view_load_started(Evas_Object* o)
2719 {
2720     DBG("o=%p", o);
2721     evas_object_smart_callback_call(o, "load,started", 0);
2722 }
2723
2724 /**
2725  * Reports the frame started loading something.
2726  *
2727  * @param o View.
2728  *
2729  * Emits signal: "load,started" on main frame with no parameters.
2730  */
2731 void ewk_view_frame_main_load_started(Evas_Object* o)
2732 {
2733     DBG("o=%p", o);
2734     Evas_Object* frame = ewk_view_frame_main_get(o);
2735     evas_object_smart_callback_call(frame, "load,started", 0);
2736 }
2737
2738 /**
2739  * @internal
2740  * Reports the main frame started provisional load.
2741  *
2742  * @param o View.
2743  *
2744  * Emits signal: "load,provisional" on View with no parameters.
2745  */
2746 void ewk_view_load_provisional(Evas_Object* o)
2747 {
2748     DBG("o=%p", o);
2749     evas_object_smart_callback_call(o, "load,provisional", 0);
2750 }
2751
2752 /**
2753  * @internal
2754  * Reports view can be shown after a new window is created.
2755  *
2756  * @param o Frame.
2757  *
2758  * Emits signal: "load,newwindow,show" on view with no parameters.
2759  */
2760 void ewk_view_load_show(Evas_Object* o)
2761 {
2762     DBG("o=%p", o);
2763     evas_object_smart_callback_call(o, "load,newwindow,show", 0);
2764 }
2765
2766
2767 /**
2768  * @internal
2769  * Reports the main frame was cleared.
2770  *
2771  * @param o View.
2772  */
2773 void ewk_view_frame_main_cleared(Evas_Object* o)
2774 {
2775     DBG("o=%p", o);
2776     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
2777     EINA_SAFETY_ON_NULL_RETURN(sd->api->flush);
2778     sd->api->flush(sd);
2779 }
2780
2781 /**
2782  * @internal
2783  * Reports the main frame received an icon.
2784  *
2785  * @param o View.
2786  *
2787  * Emits signal: "icon,received" with no parameters.
2788  */
2789 void ewk_view_frame_main_icon_received(Evas_Object* o)
2790 {
2791     DBG("o=%p", o);
2792     Evas_Object* frame = ewk_view_frame_main_get(o);
2793     evas_object_smart_callback_call(frame, "icon,received", 0);
2794 }
2795
2796 /**
2797  * @internal
2798  * Reports load finished, optionally with error information.
2799  *
2800  * Emits signal: "load,finished" with pointer to #Ewk_Frame_Load_Error
2801  * if any error, or @c 0 if successful load.
2802  *
2803  * @note there should not be any error stuff here, but trying to be
2804  *       compatible with previous WebKit.
2805  */
2806 void ewk_view_load_finished(Evas_Object* o, const Ewk_Frame_Load_Error* error)
2807 {
2808     DBG("o=%p, error=%p", o, error);
2809     evas_object_smart_callback_call(o, "load,finished", (void*)error);
2810 }
2811
2812 /**
2813  * @internal
2814  * Reports load failed with error information.
2815  *
2816  * Emits signal: "load,error" with pointer to Ewk_Frame_Load_Error.
2817  */
2818 void ewk_view_load_error(Evas_Object* o, const Ewk_Frame_Load_Error* error)
2819 {
2820     DBG("o=%p, error=%p", o, error);
2821     evas_object_smart_callback_call(o, "load,error", (void*)error);
2822 }
2823
2824 /**
2825  * @internal
2826  * Reports load progress changed.
2827  *
2828  * Emits signal: "load,progress" with pointer to a double from 0.0 to 1.0.
2829  */
2830 void ewk_view_load_progress_changed(Evas_Object* o)
2831 {
2832     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
2833     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
2834
2835     // Evas_Coord w, h;
2836     double progress = priv->page->progress()->estimatedProgress();
2837
2838     DBG("o=%p (p=%0.3f)", o, progress);
2839
2840     evas_object_smart_callback_call(o, "load,progress", &progress);
2841 }
2842
2843 /**
2844  * @internal
2845  * Reports view @param o should be restored to default conditions
2846  *
2847  * @param o View.
2848  * @param frame Frame that originated restore.
2849  *
2850  * Emits signal: "restore" with frame.
2851  */
2852 void ewk_view_restore_state(Evas_Object* o, Evas_Object* frame)
2853 {
2854     evas_object_smart_callback_call(o, "restore", frame);
2855 }
2856
2857 /**
2858  * @internal
2859  * Delegates to browser the creation of a new window. If it is not implemented,
2860  * current view is returned, so navigation might continue in same window. If
2861  * browser supports the creation of new windows, a new Ewk_Window_Features is
2862  * created and passed to browser. If it intends to keep the request for opening
2863  * the window later it must increments the Ewk_Winwdow_Features ref count by
2864  * calling ewk_window_features_ref(window_features). Otherwise this struct will
2865  * be freed after returning to this function.
2866  *
2867  * @param o Current view.
2868  * @param javascript @c EINA_TRUE if the new window is originated from javascript,
2869  * @c EINA_FALSE otherwise
2870  * @param window_features Features of the new window being created. If it's @c
2871  * NULL, it will be created a window with default features.
2872  *
2873  * @return New view, in case smart class implements the creation of new windows;
2874  * else, current view @param o or @c 0 on failure.
2875  *
2876  * @see ewk_window_features_ref().
2877  */
2878 Evas_Object* ewk_view_window_create(Evas_Object* o, Eina_Bool javascript, const WebCore::WindowFeatures* coreFeatures)
2879 {
2880     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
2881
2882     if (!sd->api->window_create)
2883         return o;
2884
2885     Ewk_Window_Features* window_features = ewk_window_features_new_from_core(coreFeatures);
2886     if (!window_features)
2887         return 0;
2888
2889     Evas_Object* view = sd->api->window_create(sd, javascript, window_features);
2890     ewk_window_features_unref(window_features);
2891
2892     return view;
2893 }
2894
2895 /**
2896  * @internal
2897  * Reports a window should be closed. It's client responsibility to decide if
2898  * the window should in fact be closed. So, if only windows created by javascript
2899  * are allowed to be closed by this call, browser needs to save the javascript
2900  * flag when the window is created. Since a window can close itself (for example
2901  * with a 'self.close()' in Javascript) browser must postpone the deletion to an
2902  * idler.
2903  *
2904  * @param o View to be closed.
2905  */
2906 void ewk_view_window_close(Evas_Object* o)
2907 {
2908     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
2909
2910     ewk_view_stop(o);
2911     if (!sd->api->window_close)
2912         return;
2913     sd->api->window_close(sd);
2914 }
2915
2916 /**
2917  * @internal
2918  * Reports mouse has moved over a link.
2919  *
2920  * Emits signal: "link,hover,in"
2921  */
2922 void ewk_view_mouse_link_hover_in(Evas_Object* o, void* data)
2923 {
2924     evas_object_smart_callback_call(o, "link,hover,in", data);
2925 }
2926
2927 /**
2928  * @internal
2929  * Reports mouse is not over a link anymore.
2930  *
2931  * Emits signal: "link,hover,out"
2932  */
2933 void ewk_view_mouse_link_hover_out(Evas_Object* o)
2934 {
2935     evas_object_smart_callback_call(o, "link,hover,out", 0);
2936 }
2937
2938 /**
2939  * @internal
2940  * Set toolbar visible.
2941  *
2942  * Emits signal: "toolbars,visible,set" with a pointer to a boolean.
2943  */
2944 void ewk_view_toolbars_visible_set(Evas_Object* o, Eina_Bool visible)
2945 {
2946     DBG("o=%p (visible=%d)", o, !!visible);
2947     evas_object_smart_callback_call(o, "toolbars,visible,set", &visible);
2948 }
2949
2950 /**
2951  * @internal
2952  * Get toolbar visibility.
2953  *
2954  * @param o View.
2955  * @param visible boolean pointer in which to save the result. It defaults
2956  * to @c FALSE, i.e. if browser does no listen to emitted signal, it means
2957  * there are no toolbars and therefore they are not visible.
2958  *
2959  * Emits signal: "toolbars,visible,get" with a pointer to a boolean.
2960  */
2961 void ewk_view_toolbars_visible_get(Evas_Object* o, Eina_Bool* visible)
2962 {
2963     DBG("%s, o=%p", __func__, o);
2964     *visible = EINA_FALSE;
2965     evas_object_smart_callback_call(o, "toolbars,visible,get", visible);
2966 }
2967
2968 /**
2969  * @internal
2970  * Set statusbar visible.
2971  *
2972  * @param o View.
2973  * @param visible @c TRUE if statusbar are visible, @c FALSE otherwise.
2974  *
2975  * Emits signal: "statusbar,visible,set" with a pointer to a boolean.
2976  */
2977 void ewk_view_statusbar_visible_set(Evas_Object* o, Eina_Bool visible)
2978 {
2979     DBG("o=%p (visible=%d)", o, !!visible);
2980     evas_object_smart_callback_call(o, "statusbar,visible,set", &visible);
2981 }
2982
2983 /**
2984  * @internal
2985  * Get statusbar visibility.
2986  *
2987  * @param o View.
2988  * @param visible boolean pointer in which to save the result. It defaults
2989  * to @c FALSE, i.e. if browser does no listen to emitted signal, it means
2990  * there is no statusbar and therefore it is not visible.
2991  *
2992  * Emits signal: "statusbar,visible,get" with a pointer to a boolean.
2993  */
2994 void ewk_view_statusbar_visible_get(Evas_Object* o, Eina_Bool* visible)
2995 {
2996     DBG("%s, o=%p", __func__, o);
2997     *visible = EINA_FALSE;
2998     evas_object_smart_callback_call(o, "statusbar,visible,get", visible);
2999 }
3000
3001 /**
3002  * @internal
3003  * Set text of statusbar
3004  *
3005  * @param o View.
3006  * @param text New text to put on statusbar.
3007  *
3008  * Emits signal: "statusbar,text,set" with a string.
3009  */
3010 void ewk_view_statusbar_text_set(Evas_Object* o, const char* text)
3011 {
3012     DBG("o=%p (text=%s)", o, text);
3013     INF("status bar text set: %s", text);
3014     evas_object_smart_callback_call(o, "statusbar,text,set", (void*)text);
3015 }
3016
3017 /**
3018  * @internal
3019  * Set scrollbars visible.
3020  *
3021  * @param o View.
3022  * @param visible @c TRUE if scrollbars are visible, @c FALSE otherwise.
3023  *
3024  * Emits signal: "scrollbars,visible,set" with a pointer to a boolean.
3025  */
3026 void ewk_view_scrollbars_visible_set(Evas_Object* o, Eina_Bool visible)
3027 {
3028     DBG("o=%p (visible=%d)", o, !!visible);
3029     evas_object_smart_callback_call(o, "scrollbars,visible,set", &visible);
3030 }
3031
3032 /**
3033  * @internal
3034  * Get scrollbars visibility.
3035  *
3036  * @param o View.
3037  * @param visible boolean pointer in which to save the result. It defaults
3038  * to @c FALSE, i.e. if browser does no listen to emitted signal, it means
3039  * there are no scrollbars and therefore they are not visible.
3040  *
3041  * Emits signal: "scrollbars,visible,get" with a pointer to a boolean.
3042  */
3043 void ewk_view_scrollbars_visible_get(Evas_Object* o, Eina_Bool* visible)
3044 {
3045     DBG("%s, o=%p", __func__, o);
3046     *visible = EINA_FALSE;
3047     evas_object_smart_callback_call(o, "scrollbars,visible,get", visible);
3048 }
3049
3050 /**
3051  * @internal
3052  * Set menubar visible.
3053  *
3054  * @param o View.
3055  * @param visible @c TRUE if menubar is visible, @c FALSE otherwise.
3056  *
3057  * Emits signal: "menubar,visible,set" with a pointer to a boolean.
3058  */
3059 void ewk_view_menubar_visible_set(Evas_Object* o, Eina_Bool visible)
3060 {
3061     DBG("o=%p (visible=%d)", o, !!visible);
3062     evas_object_smart_callback_call(o, "menubar,visible,set", &visible);
3063 }
3064
3065 /**
3066  * @internal
3067  * Get menubar visibility.
3068  *
3069  * @param o View.
3070  * @param visible boolean pointer in which to save the result. It defaults
3071  * to @c FALSE, i.e. if browser does no listen to emitted signal, it means
3072  * there is no menubar and therefore it is not visible.
3073  *
3074  * Emits signal: "menubar,visible,get" with a pointer to a boolean.
3075  */
3076 void ewk_view_menubar_visible_get(Evas_Object* o, Eina_Bool* visible)
3077 {
3078     DBG("%s, o=%p", __func__, o);
3079     *visible = EINA_FALSE;
3080     evas_object_smart_callback_call(o, "menubar,visible,get", visible);
3081 }
3082
3083 /**
3084  * @internal
3085  * Set tooltip text and display if it is currently hidden.
3086  *
3087  * @param o View.
3088  * @param text Text to set tooltip to.
3089  *
3090  * Emits signal: "tooltip,text,set" with a string. If tooltip must be actually
3091  * removed, text will be 0 or '\0'
3092  */
3093 void ewk_view_tooltip_text_set(Evas_Object* o, const char* text)
3094 {
3095     DBG("o=%p text=%s", o, text);
3096     evas_object_smart_callback_call(o, "tooltip,text,set", (void*)text);
3097 }
3098
3099 /**
3100  * @internal
3101  *
3102  * @param o View.
3103  * @param message String to show on console.
3104  * @param lineNumber Line number.
3105  * @sourceID Source id.
3106  *
3107  */
3108 void ewk_view_add_console_message(Evas_Object* o, const char* message, unsigned int lineNumber, const char* sourceID)
3109 {
3110     DBG("o=%p message=%s lineNumber=%u sourceID=%s", o, message, lineNumber, sourceID);
3111     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3112     EINA_SAFETY_ON_NULL_RETURN(sd->api);
3113     EINA_SAFETY_ON_NULL_RETURN(sd->api->add_console_message);
3114     sd->api->add_console_message(sd, message, lineNumber, sourceID);
3115 }
3116
3117 bool ewk_view_focus_can_cycle(Evas_Object* o, Ewk_Focus_Direction direction)
3118 {
3119     DBG("o=%p direction=%d", o, direction);
3120     EWK_VIEW_SD_GET_OR_RETURN(o, sd, false);
3121     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, false);
3122
3123     if (!sd->api->focus_can_cycle)
3124         return false;
3125
3126     return sd->api->focus_can_cycle(sd, direction);
3127 }
3128
3129 void ewk_view_run_javascript_alert(Evas_Object* o, Evas_Object* frame, const char* message)
3130 {
3131     DBG("o=%p frame=%p message=%s", o, frame, message);
3132     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3133     EINA_SAFETY_ON_NULL_RETURN(sd->api);
3134
3135     if (!sd->api->run_javascript_alert)
3136         return;
3137
3138     sd->api->run_javascript_alert(sd, frame, message);
3139 }
3140
3141 Eina_Bool ewk_view_run_javascript_confirm(Evas_Object* o, Evas_Object* frame, const char* message)
3142 {
3143     DBG("o=%p frame=%p message=%s", o, frame, message);
3144     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3145     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_FALSE);
3146
3147     if (!sd->api->run_javascript_confirm)
3148         return EINA_FALSE;
3149
3150     return sd->api->run_javascript_confirm(sd, frame, message);
3151 }
3152
3153 Eina_Bool ewk_view_run_javascript_prompt(Evas_Object* o, Evas_Object* frame, const char* message, const char* defaultValue, char** value)
3154 {
3155     DBG("o=%p frame=%p message=%s", o, frame, message);
3156     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3157     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_FALSE);
3158
3159     if (!sd->api->run_javascript_prompt)
3160         return EINA_FALSE;
3161
3162     return sd->api->run_javascript_prompt(sd, frame, message, defaultValue, value);
3163 }
3164
3165 /**
3166  * @internal
3167  * Delegates to client to decide whether a script must be stopped because it's
3168  * running for too long. If client does not implement it, it goes to default
3169  * implementation, which logs and returns EINA_FALSE. Client may remove log by
3170  * setting this function 0, which will just return EINA_FALSE.
3171  *
3172  * @param o View.
3173  *
3174  * @return @c EINA_TRUE if script should be stopped; @c EINA_FALSE otherwise
3175  */
3176 Eina_Bool ewk_view_should_interrupt_javascript(Evas_Object* o)
3177 {
3178     DBG("o=%p", o);
3179     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3180     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_FALSE);
3181
3182     if (!sd->api->should_interrupt_javascript)
3183         return EINA_FALSE;
3184
3185     return sd->api->should_interrupt_javascript(sd);
3186 }
3187
3188 /**
3189  * @internal
3190  * This is called whenever the web site shown in @param frame is asking to store data
3191  * to the database @param databaseName and the quota allocated to that web site
3192  * is exceeded. Browser may use this to increase the size of quota before the
3193  * originating operationa fails.
3194  *
3195  * @param o View.
3196  * @param frame The frame whose web page exceeded its database quota.
3197  * @param databaseName Database name.
3198  * @param current_size Current size of this database
3199  * @param expected_size The expected size of this database in order to fulfill
3200  * site's requirement.
3201  */
3202 uint64_t ewk_view_exceeded_database_quota(Evas_Object* o, Evas_Object* frame, const char* databaseName, uint64_t current_size, uint64_t expected_size)
3203 {
3204     DBG("o=%p", o);
3205     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
3206     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, 0);
3207     if (!sd->api->exceeded_database_quota)
3208         return 0;
3209
3210     INF("current_size=%" PRIu64 " expected_size=%" PRIu64, current_size, expected_size);
3211     return sd->api->exceeded_database_quota(sd, frame, databaseName, current_size, expected_size);
3212 }
3213
3214 /**
3215  * @internal
3216  * Open panel to choose a file.
3217  *
3218  * @param o View.
3219  * @param frame Frame in which operation is required.
3220  * @param allows_multiple_files @c EINA_TRUE when more than one file may be
3221  * selected, @c EINA_FALSE otherwise
3222  * @param accept_types accept mime types
3223  * @selected_filenames List of files selected.
3224  *
3225  * @return @EINA_FALSE if user canceled file selection; @EINA_TRUE if confirmed.
3226  */
3227 Eina_Bool ewk_view_run_open_panel(Evas_Object* o, Evas_Object* frame, Eina_Bool allows_multiple_files, const char* accept_types, Eina_List** selected_filenames)
3228 {
3229     DBG("o=%p frame=%p allows_multiple_files=%d", o, frame, allows_multiple_files);
3230     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3231     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_FALSE);
3232     Eina_Bool confirm;
3233
3234     if (!sd->api->run_open_panel)
3235         return EINA_FALSE;
3236
3237     *selected_filenames = 0;
3238
3239     confirm = sd->api->run_open_panel(sd, frame, allows_multiple_files, accept_types, selected_filenames);
3240     if (!confirm && *selected_filenames)
3241         ERR("Canceled file selection, but selected filenames != 0. Free names before return.");
3242     return confirm;
3243 }
3244
3245 void ewk_view_repaint(Evas_Object* o, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
3246 {
3247     DBG("o=%p, region=%d,%d + %dx%d", o, x, y, w, h);
3248     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3249     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
3250
3251     if (!priv->main_frame->contentRenderer()) {
3252         ERR("no main frame content renderer.");
3253         return;
3254     }
3255
3256     _ewk_view_repaint_add(priv, x, y, w, h);
3257     _ewk_view_smart_changed(sd);
3258 }
3259
3260 void ewk_view_scroll(Evas_Object* o, Evas_Coord dx, Evas_Coord dy, Evas_Coord sx, Evas_Coord sy, Evas_Coord sw, Evas_Coord sh, Evas_Coord cx, Evas_Coord cy, Evas_Coord cw, Evas_Coord ch, Eina_Bool main_frame)
3261 {
3262     DBG("o=%p, delta: %d,%d, scroll: %d,%d+%dx%d, clip: %d,%d+%dx%d",
3263         o, dx, dy, sx, sy, sw, sh, cx, cy, cw, ch);
3264
3265     if ((sx != cx) || (sy != cy) || (sw != cw) || (sh != ch))
3266         WRN("scroll region and clip are different! %d,%d+%dx%d and %d,%d+%dx%d",
3267             sx, sy, sw, sh, cx, cy, cw, ch);
3268
3269     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3270     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
3271     EINA_SAFETY_ON_TRUE_RETURN(!dx && !dy);
3272
3273     _ewk_view_scroll_add(priv, dx, dy, sx, sy, sw, sh, main_frame);
3274
3275     _ewk_view_smart_changed(sd);
3276 }
3277
3278 WebCore::Page* ewk_view_core_page_get(const Evas_Object* o)
3279 {
3280     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
3281     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
3282     return priv->page;
3283 }
3284
3285 /**
3286  * Creates a new frame for given url and owner element.
3287  *
3288  * Emits "frame,created" with the new frame object on success.
3289  */
3290 WTF::PassRefPtr<WebCore::Frame> ewk_view_frame_create(Evas_Object* o, Evas_Object* frame, const WTF::String& name, WebCore::HTMLFrameOwnerElement* ownerElement, const WebCore::KURL& url, const WTF::String& referrer)
3291 {
3292     DBG("o=%p, frame=%p, name=%s, ownerElement=%p, url=%s, referrer=%s",
3293         o, frame, name.utf8().data(), ownerElement,
3294         url.string().utf8().data(), referrer.utf8().data());
3295
3296     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
3297     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, 0);
3298
3299     WTF::RefPtr<WebCore::Frame> cf = _ewk_view_core_frame_new
3300                                          (sd, priv, ownerElement);
3301     if (!cf) {
3302         ERR("Could not create child core frame '%s'", name.utf8().data());
3303         return 0;
3304     }
3305
3306     if (!ewk_frame_child_add(frame, cf, name, url, referrer)) {
3307         ERR("Could not create child frame object '%s'", name.utf8().data());
3308         return 0;
3309     }
3310
3311     // The creation of the frame may have removed itself already.
3312     if (!cf->page() || !cf->tree() || !cf->tree()->parent())
3313         return 0;
3314
3315     sd->changed.frame_rect = EINA_TRUE;
3316     _ewk_view_smart_changed(sd);
3317
3318     evas_object_smart_callback_call(o, "frame,created", frame);
3319     return cf.release();
3320 }
3321
3322 WTF::PassRefPtr<WebCore::Widget> ewk_view_plugin_create(Evas_Object* o, Evas_Object* frame, const WebCore::IntSize& pluginSize, WebCore::HTMLPlugInElement* element, const WebCore::KURL& url, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues, const WTF::String& mimeType, bool loadManually)
3323 {
3324     DBG("o=%p, frame=%p, size=%dx%d, element=%p, url=%s, mimeType=%s",
3325         o, frame, pluginSize.width(), pluginSize.height(), element,
3326         url.string().utf8().data(), mimeType.utf8().data());
3327
3328     EWK_VIEW_SD_GET_OR_RETURN(o, sd, 0);
3329     sd->changed.frame_rect = EINA_TRUE;
3330     _ewk_view_smart_changed(sd);
3331
3332     return ewk_frame_plugin_create
3333                (frame, pluginSize, element, url, paramNames, paramValues,
3334                mimeType, loadManually);
3335 }
3336
3337 /**
3338  * @internal
3339  *
3340  * Creates a new popup with options when a select widget was clicked.
3341  *
3342  * @param client PopupMenuClient instance that allows communication with webkit.
3343  * @param selected Selected item.
3344  * @param rect Menu's position.
3345  *
3346  * Emits: "popup,create" with a list of Ewk_Menu containing each item's data
3347  */
3348 void ewk_view_popup_new(Evas_Object* o, WebCore::PopupMenuClient* client, int selected, const WebCore::IntRect& rect)
3349 {
3350     INF("o=%p", o);
3351     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3352     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
3353
3354     if (priv->popup.menu_client)
3355         ewk_view_popup_destroy(o);
3356
3357     priv->popup.menu_client = client;
3358
3359     // populate items
3360     const int size = client->listSize();
3361     for (int i = 0; i < size; ++i) {
3362         Ewk_Menu_Item* item = static_cast<Ewk_Menu_Item*>(malloc(sizeof(*item)));
3363         if (client->itemIsSeparator(i))
3364             item->type = EWK_MENU_SEPARATOR;
3365         else if (client->itemIsLabel(i))
3366             item->type = EWK_MENU_GROUP;
3367         else
3368             item->type = EWK_MENU_OPTION;
3369         item->text = eina_stringshare_add(client->itemText(i).utf8().data());
3370
3371         priv->popup.menu.items = eina_list_append(priv->popup.menu.items, item);
3372     }
3373
3374     priv->popup.menu.x = rect.x();
3375     priv->popup.menu.y = rect.y();
3376     priv->popup.menu.width = rect.width();
3377     priv->popup.menu.height = rect.height();
3378     evas_object_smart_callback_call(o, "popup,create", &priv->popup.menu);
3379 }
3380
3381 Eina_Bool ewk_view_popup_destroy(Evas_Object* o)
3382 {
3383     INF("o=%p", o);
3384     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3385     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
3386
3387     if (!priv->popup.menu_client)
3388         return EINA_FALSE;
3389
3390     evas_object_smart_callback_call(o, "popup,willdelete", &priv->popup.menu);
3391
3392     void* itemv;
3393     EINA_LIST_FREE(priv->popup.menu.items, itemv) {
3394         Ewk_Menu_Item* item = static_cast<Ewk_Menu_Item*>(itemv);
3395         eina_stringshare_del(item->text);
3396         free(item);
3397     }
3398     priv->popup.menu_client->popupDidHide();
3399     priv->popup.menu_client = 0;
3400
3401     return EINA_TRUE;
3402 }
3403
3404 void ewk_view_popup_selected_set(Evas_Object* o, int index)
3405 {
3406     INF("o=%p", o);
3407     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3408     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
3409     EINA_SAFETY_ON_NULL_RETURN(priv->popup.menu_client);
3410
3411     priv->popup.menu_client->valueChanged(index);
3412 }
3413
3414 /**
3415  * @internal
3416  * Request a download to user.
3417  *
3418  * @param o View.
3419  * @oaram download Ewk_Download struct to be sent.
3420  *
3421  * Emits: "download,request" with an Ewk_Download containing the details of the
3422  * requested download. The download per se must be handled outside of webkit.
3423  */
3424 void ewk_view_download_request(Evas_Object* o, Ewk_Download* download)
3425 {
3426     DBG("view=%p", o);
3427     evas_object_smart_callback_call(o, "download,request", download);
3428 }
3429
3430 /**
3431  * @internal
3432  * Reports the JS window object was cleared.
3433  *
3434  * @param o view.
3435  * @param frame the frame.
3436  */
3437 void ewk_view_js_window_object_clear(Evas_Object* o, Evas_Object* frame)
3438 {
3439     evas_object_smart_callback_call(o, "js,windowobject,clear", frame);
3440 }
3441
3442 /**
3443  * @internal
3444  * Reports the viewport has changed.
3445  *
3446  * @param arguments viewport argument.
3447  *
3448  * Emits signal: "viewport,changed" with no parameters.
3449  */
3450 void ewk_view_viewport_attributes_set(Evas_Object* o, const WebCore::ViewportArguments& arguments)
3451 {
3452     EWK_VIEW_SD_GET(o, sd);
3453     EWK_VIEW_PRIV_GET(sd, priv);
3454
3455     priv->viewport_arguments = arguments;
3456     evas_object_smart_callback_call(o, "viewport,changed", 0);
3457 }
3458
3459 void ewk_view_viewport_attributes_get(const Evas_Object* o, int* w, int* h, float* init_scale, float* max_scale, float* min_scale, float* device_pixel_ratio, Eina_Bool* user_scalable)
3460 {
3461     WebCore::ViewportAttributes attributes = _ewk_view_viewport_attributes_compute(o);
3462
3463     if (w)
3464         *w = attributes.layoutSize.width();
3465     if (h)
3466         *h = attributes.layoutSize.height();
3467     if (init_scale)
3468         *init_scale = attributes.initialScale;
3469     if (max_scale)
3470         *max_scale = attributes.maximumScale;
3471     if (min_scale)
3472         *min_scale = attributes.minimumScale;
3473     if (device_pixel_ratio)
3474         *device_pixel_ratio = attributes.devicePixelRatio;
3475     if (user_scalable)
3476         *user_scalable = static_cast<bool>(attributes.userScalable);
3477 }
3478
3479 Eina_Bool ewk_view_zoom_range_set(Evas_Object* o, float min_scale, float max_scale)
3480 {
3481     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3482     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
3483
3484     if (max_scale < min_scale) {
3485         WRN("min_scale is larger than max_scale");
3486         return EINA_FALSE;
3487     }
3488
3489     priv->settings.zoom_range.min_scale = min_scale;
3490     priv->settings.zoom_range.max_scale = max_scale;
3491
3492     return EINA_TRUE;
3493 }
3494
3495 float ewk_view_zoom_range_min_get(const Evas_Object* o)
3496 {
3497     EWK_VIEW_SD_GET_OR_RETURN(o, sd, -1.0);
3498     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, -1.0);
3499
3500     return priv->settings.zoom_range.min_scale;
3501 }
3502
3503 float ewk_view_zoom_range_max_get(const Evas_Object* o)
3504 {
3505     EWK_VIEW_SD_GET_OR_RETURN(o, sd, -1.0);
3506     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, -1.0);
3507
3508     return priv->settings.zoom_range.max_scale;
3509 }
3510
3511 Eina_Bool ewk_view_user_scalable_set(Evas_Object* o, Eina_Bool user_scalable)
3512 {
3513     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3514     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
3515
3516     priv->settings.zoom_range.user_scalable = user_scalable;
3517
3518     return EINA_TRUE;
3519 }
3520
3521 Eina_Bool ewk_view_user_scalable_get(const Evas_Object* o)
3522 {
3523     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3524     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
3525
3526     return priv->settings.zoom_range.user_scalable;
3527 }
3528
3529 float ewk_view_device_pixel_ratio_get(const Evas_Object* o)
3530 {
3531     EWK_VIEW_SD_GET_OR_RETURN(o, sd, -1.0);
3532     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, -1.0);
3533
3534     return priv->settings.device_pixel_ratio;
3535 }
3536
3537 void ewk_view_did_first_visually_nonempty_layout(Evas_Object* o)
3538 {
3539     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3540     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
3541     if (!priv->flags.view_cleared) {
3542         ewk_view_frame_main_cleared(o);
3543         ewk_view_enable_render(o);
3544         priv->flags.view_cleared = EINA_TRUE;
3545     }
3546 }
3547
3548 /**
3549  * @internal
3550  * Dispatch finished loading.
3551  *
3552  * @param o view.
3553  */
3554 void ewk_view_dispatch_did_finish_loading(Evas_Object* o)
3555 {
3556     /* If we reach this point and rendering is still disabled, WebCore will not
3557      * trigger the didFirstVisuallyNonEmptyLayout signal anymore. So, we
3558      * forcefully re-enable the rendering.
3559      */
3560     ewk_view_did_first_visually_nonempty_layout(o);
3561 }
3562
3563 void ewk_view_transition_to_commited_for_newpage(Evas_Object* o)
3564 {
3565     EWK_VIEW_SD_GET_OR_RETURN(o, sd);
3566     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv);
3567
3568     ewk_view_disable_render(o);
3569     priv->flags.view_cleared = EINA_FALSE;
3570 }
3571
3572
3573 /**
3574  * @internal
3575  * Reports a requeset will be loaded. It's client responsibility to decide if
3576  * request would be used. If @return is true, loader will try to load. Else,
3577  * Loader ignore action of request.
3578  *
3579  * @param o View to load
3580  * @param request Request which contain url to navigate
3581  */
3582 Eina_Bool ewk_view_navigation_policy_decision(Evas_Object* o, Ewk_Frame_Resource_Request* request)
3583 {
3584     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_TRUE);
3585     EINA_SAFETY_ON_NULL_RETURN_VAL(sd->api, EINA_TRUE);
3586
3587     if (!sd->api->navigation_policy_decision)
3588         return EINA_TRUE;
3589
3590     return sd->api->navigation_policy_decision(sd, request);
3591 }
3592
3593 Eina_Bool ewk_view_js_object_add(Evas_Object* o, Ewk_JS_Object* obj, const char* obj_name)
3594 {
3595 #if ENABLE(NETSCAPE_PLUGIN_API)
3596     if (obj->view) // object has already been added to another ewk_view
3597         return EINA_FALSE;
3598     obj->name = eina_stringshare_add(obj_name);
3599     EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
3600     EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
3601
3602     JSC::JSLock lock(JSC::SilenceAssertionsOnly);
3603     WebCore::JSDOMWindow* window = toJSDOMWindow(priv->main_frame, WebCore::mainThreadNormalWorld());
3604     JSC::Bindings::RootObject* root;
3605     root = priv->main_frame->script()->bindingRootObject();
3606
3607     if (!window) {
3608         ERR("Warning: couldn't get window object");
3609         return EINA_FALSE;
3610     }
3611
3612     JSC::ExecState* exec = window->globalExec();
3613
3614     obj->view = o;
3615     JSC::JSObject* runtimeObject = (JSC::JSObject*)JSC::Bindings::CInstance::create((NPObject*)obj, root)->createRuntimeObject(exec);
3616     JSC::Identifier id = JSC::Identifier(exec, obj_name);
3617
3618     JSC::PutPropertySlot slot;
3619     window->put(exec, id, runtimeObject, slot);
3620     return EINA_TRUE;
3621 #else
3622     return EINA_FALSE;
3623 #endif // ENABLE(NETSCAPE_PLUGIN_API)
3624 }
3625
3626 Eina_Bool ewk_view_protocol_handler_set(Evas_Object* o, const char** protocols, Ewk_View_Resource_Handler_Cb handler, void* context)
3627 {
3628     EWK_VIEW_SD_GET(o, sd);
3629     EWK_VIEW_PRIV_GET(sd, priv);
3630
3631     if (!handler)
3632         return EINA_FALSE;
3633
3634     priv->custom_resource_handler.function = handler;
3635     priv->custom_resource_handler.context = context;
3636
3637     return ewk_custom_protocol_handler_set(protocols);
3638 }
3639
3640 Eina_Bool ewk_view_protocol_handler_unset(Evas_Object* o)
3641 {
3642     EWK_VIEW_SD_GET(o, sd);
3643     EWK_VIEW_PRIV_GET(sd, priv);
3644     Eina_Bool ret = ewk_custom_protocol_handler_all_unset();
3645
3646     if (ret) {
3647         priv->custom_resource_handler.function = 0;
3648         priv->custom_resource_handler.context = 0;
3649     }
3650
3651     return ret;
3652 }
3653