src/lib/els_webview.c

   1 /*
   2  *
   3  * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
   4  */
   5 #include <Elementary.h>
   6 #include "elm_priv.h"
   7
   8 #ifdef ELM_EWEBKIT
   9 #include <EWebKit.h>
  10 #include <cairo.h>
  11
  12 #define SMART_NAME "els_webview"
  13 #define API_ENTRY Smart_Data *sd; sd = evas_object_smart_data_get(obj); if ((!obj) || (!sd) || (evas_object_type_get(obj) && strcmp(evas_object_type_get(obj), SMART_NAME)))
  14 #define INTERNAL_ENTRY Smart_Data *sd; sd = evas_object_smart_data_get(obj); if (!sd) return;
  15 #define EWK_VIEW_PRIV_GET_OR_RETURN(sd, ptr, ...)                   \
  16    Ewk_View_Private_Data* ptr = ((Ewk_View_Smart_Data*)sd)->_priv; \
  17    if (!ptr) \
  18    {                                                     \
  19       ERR("no private data for object %p (%s)",               \
  20          ((Ewk_View_Smart_Data*)sd)->self,                           \
  21          evas_object_type_get(((Ewk_View_Smart_Data*)sd)->self));    \
  22       return __VA_ARGS__;                                         \
  23    }
  24
  25 #define EWEBKIT_PATH "/usr/lib/libewebkit.so"
  26 #define CAIRO_PATH "/usr/lib/libcairo.so.2"
  27
  28 #define MINIMAP_WIDTH 120
  29 #define MINIMAP_HEIGHT 200
  30
  31 #define USE_MAX_TUC_20MB
  32
  33 #ifdef USE_MAX_TUC_20MB
  34 #define MAX_TUC 1024*1024*20
  35 #else
  36 #define MAX_TUC 1024*1024*10
  37 #endif
  38 #define MAX_URI 512
  39 #define MOBILE_DEFAULT_ZOOM_RATIO 1.5f
  40
  41 #define WEBVIEW_EDJ "/usr/share/edje/ewebview.edj"
  42 #define WEBKIT_EDJ "/usr/share/edje/webkit.edj"
  43 #define WEBVIEW_THEME_EDJ "/usr/share/edje/ewebview-theme.edj"
  44
  45 #define DEFAULT_LAYOUT_WIDTH 1024
  46 #define MIN_ZOOM_RATIO 0.09f
  47 #define MAX_ZOOM_RATIO 4.0f
  48 #define ZOOM_OUT_BOUNCING 0.85f
  49 #define ZOOM_IN_BOUNCING 1.25f
  50 #define BOUNCING_DISTANCE 400
  51
  52 //                      "<!--<body bgcolor=#4c4c4c text=white text-align=left>-->"
  53 #define NOT_FOUND_PAGE_HEADER "<html>" \
  54                         "<head><title>Page Not Found</title></head>" \
  55                         "<body bgcolor=white text=black text-align=left>" \
  56                         "<center>" \
  57                         "<table>" \
  58                         "<tr><td><h1>Page Not Found<br/></td></tr>" \
  59                         "<meta name='viewport' content='width=device-width, initial-scale=1.0, user-scalable=no'>" \
  60                         "<tr><td>" \
  61                         "<script type='text/javascript'>"\
  62                         "var s = "
  63
  64 #define NOT_FOUND_PAGE_FOOTER ";" \
  65                         "var failingUrl = s.substring(s.indexOf(\"?\"\)+1, s.lastIndexOf(\"?\"\));" \
  66                         "document.write(\"<p><tr><td><h2>URL: \" + unescape(failingUrl) + \"</h2></td></tr>\");" \
  67                         "var errorDesc = s.substring(s.lastIndexOf(\"?\")+1, s.length);" \
  68                         "document.write(\"<tr><td><h2>Error: \" + unescape(errorDesc) + \"</h2></td></tr>\");" \
  69                         "document.write(\"<tr><td><h3>Google: <form method=\'get\' action=\'http://www.google.com/custom\'><input type=text name=\'q\' size=15 maxlength=100 value=\'\"+ unescape(failingUrl)+\"\'> <input type=submit name=\'sa\' value=Search></form></h3></td></tr>\");" \
  70                         "</script>" \
  71                         "</td></tr>" \
  72                         "</table>" \
  73                         "</h1>" \
  74                         "</body>" \
  75                         "</html>"
  76
  77 #define NEED_TO_REMOVE
  78 //#define DBG printf
  79 //#define ERR printf
  80
  81 typedef struct _Smart_Data Smart_Data;
  82
  83 struct _Smart_Data {
  84      Ewk_View_Smart_Data base; //default data
  85
  86      Evas_Object* widget;
  87 #ifdef BOUNCING_SUPPORT
  88      Evas_Object* container;
  89 #endif
  90      Ecore_Job *move_calc_job;
  91      Ecore_Job *resize_calc_job;
  92      Eina_Hash* mime_func_hash;
  93      int locked_dx;
  94      int locked_dy;
  95      unsigned char bounce_horiz : 1;
  96      unsigned char bounce_vert : 1;
  97      unsigned char events_feed : 1;
  98      unsigned char auto_fitting : 1;
  99      unsigned char mouse_clicked : 1;
 100      unsigned char on_flick : 1;
 101
 102      /* ewk functions */
 103      void (*ewk_view_theme_set)(Evas_Object *, const char *);
 104      Evas_Object *(*ewk_view_frame_main_get)(const Evas_Object *);
 105      Eina_Bool (*ewk_view_uri_set)(Evas_Object *, const char *);
 106      float (*ewk_view_zoom_get)(const Evas_Object *);
 107      const char * (*ewk_view_uri_get)(const Evas_Object *o);
 108      Eina_Bool (*ewk_view_zoom_set)(Evas_Object *, float, Evas_Coord, Evas_Coord);
 109      Eina_Bool (*ewk_view_zoom_weak_set)(Evas_Object *, float, Evas_Coord, Evas_Coord);
 110      Eina_Bool (*ewk_view_zoom_text_only_set)(Evas_Object *, Eina_Bool);
 111      Eina_Bool (*ewk_view_zoom_cairo_scaling_get)(const Evas_Object *);
 112      Eina_Bool (*ewk_view_zoom_cairo_scaling_set)(Evas_Object *, Eina_Bool);
 113      void (*ewk_view_viewport_get)(Evas_Object *, int *, int *, float *, float *, float *, Eina_Bool *);
 114      Eina_Bool (*ewk_view_zoom_range_set)(Evas_Object *, float, float);
 115      void (*ewk_view_user_scalable_set)(Evas_Object *, Eina_Bool);
 116      Eina_Bool (*ewk_view_pre_render_region)(Evas_Object *, Evas_Coord, Evas_Coord, Evas_Coord, Evas_Coord, float);
 117      void (*ewk_view_pre_render_cancel)(Evas_Object *);
 118      Eina_Bool (*ewk_view_enable_render)(const Evas_Object *);
 119      Eina_Bool (*ewk_view_disable_render)(const Evas_Object *);
 120      void (*ewk_view_javascript_suspend)(Evas_Object *);
 121      void (*ewk_view_javascript_resume)(Evas_Object *);
 122      void (*ewk_view_fixed_layout_size_set)(Evas_Object *, Evas_Coord, Evas_Coord);
 123      Eina_Bool (*ewk_view_setting_enable_plugins_get)(const Evas_Object *);
 124      void (*ewk_view_pause_and_or_hide_plugins)(Evas_Object *, Eina_Bool, Eina_Bool);
 125      Eina_Bool (*ewk_view_suspend_request)(Evas_Object *);
 126      Eina_Bool (*ewk_view_resume_request)(Evas_Object *);
 127      Eina_Bool (*ewk_view_select_none)(Evas_Object *);
 128      Eina_Bool (*ewk_view_get_smart_zoom_rect)(Evas_Object *, int, int, const Evas_Event_Mouse_Up *, Eina_Rectangle *);
 129      Eina_Bool (*ewk_view_paint_contents)(Ewk_View_Private_Data *, cairo_t *, const Eina_Rectangle *);
 130      Eina_Bool (*ewk_view_stop)(Evas_Object *);
 131      Ewk_Tile_Unused_Cache *(*ewk_view_tiled_unused_cache_get)(const Evas_Object *);
 132      void (*ewk_view_tiled_unused_cache_set)(Evas_Object *, Ewk_Tile_Unused_Cache *);
 133      void (*ewk_tile_unused_cache_max_set)(Ewk_Tile_Unused_Cache *, size_t);
 134      size_t (*ewk_tile_unused_cache_max_get)(const Ewk_Tile_Unused_Cache *);
 135      size_t (*ewk_tile_unused_cache_used_get)(const Ewk_Tile_Unused_Cache *);
 136      size_t (*ewk_tile_unused_cache_flush)(Ewk_Tile_Unused_Cache *, size_t);
 137      void (*ewk_tile_unused_cache_auto_flush)(Ewk_Tile_Unused_Cache *);
 138      char * (*ewk_page_check_point_for_keyboard)(Evas_Object *, int, int, Eina_Bool *);
 139      Eina_Bool (*ewk_page_check_point)(Evas_Object *, int, int, Evas_Event_Mouse_Down *, Eina_Bool *, Eina_Bool *, char **, char **, char **);
 140      char ** (*ewk_page_dropdown_get_options)(Evas_Object *, int, int, int *, int *);
 141      Eina_Bool (*ewk_page_dropdown_set_current_index)(Evas_Object *, int, int, int);
 142      Eina_Bool (*ewk_frame_contents_size_get)(const Evas_Object *, Evas_Coord *, Evas_Coord *);
 143      Ewk_Hit_Test * (*ewk_frame_hit_test_new)(const Evas_Object *, int, int);
 144      Eina_Bool (*ewk_frame_feed_mouse_down)(Evas_Object *, const Evas_Event_Mouse_Down *);
 145      Eina_Bool (*ewk_frame_feed_mouse_up)(Evas_Object *, const Evas_Event_Mouse_Up *);
 146      Eina_Bool (*ewk_frame_visible_content_geometry_get)(const Evas_Object *, Eina_Bool, int *, int *, int *, int *);
 147      Eina_Bool (*ewk_frame_scroll_pos_get)(const Evas_Object *, int *, int *);
 148      void (*ewk_frame_hit_test_free)(Ewk_Hit_Test *);
 149      Eina_Bool (*ewk_frame_contents_set)(Evas_Object *, const char *, size_t, const char *, const char *, const char *);
 150      Eina_Bool (*ewk_frame_select_closest_word)(Evas_Object *, int, int, int *, int *, int *, int *, int *, int *);
 151      Eina_Bool (*ewk_frame_selection_handlers_get)(Evas_Object *, int *, int *, int *, int *, int *, int *);
 152      Eina_Bool (*ewk_frame_selection_left_set)(Evas_Object *, int, int, int *, int *, int *);
 153      Eina_Bool (*ewk_frame_selection_right_set)(Evas_Object *, int, int, int *, int *, int *);
 154      Eina_Bool (*ewk_frame_feed_focus_in)(Evas_Object *);
 155      Eina_Bool (*ewk_frame_scroll_add)(Evas_Object *, int, int);
 156      unsigned int (*ewk_view_imh_get)(Evas_Object *);
 157      Ecore_IMF_Context* (*ewk_view_core_imContext_get)(Evas_Object *);
 158      void (*ewk_set_show_geolocation_permission_dialog_callback)(ewk_show_geolocation_permission_dialog_callback);
 159      void (*ewk_set_geolocation_sharing_allowed)(void *, Eina_Bool);
 160
 161      /* cairo functions */
 162      cairo_t * (*cairo_create)(cairo_surface_t *);
 163      void (*cairo_destroy)(cairo_t *);
 164      void (*cairo_paint)(cairo_t *);
 165      void (*cairo_stroke)(cairo_t *cr);
 166      void (*cairo_scale)(cairo_t *, double, double);
 167      void (*cairo_rectangle)(cairo_t *, double, double, double, double);
 168      void (*cairo_set_source_rgb)(cairo_t *, double, double, double);
 169      cairo_status_t (*cairo_surface_status)(cairo_surface_t *);
 170      void (*cairo_surface_destroy)(cairo_surface_t *);
 171      void (*cairo_set_line_width)(cairo_t *, double);
 172      void (*cairo_set_source_surface)(cairo_t *, cairo_surface_t *, double, double);
 173      cairo_status_t (*cairo_surface_write_to_png)(cairo_surface_t *, const char *);
 174      cairo_surface_t * (*cairo_image_surface_create)(cairo_format_t, int, int);
 175      void (*cairo_set_antialias)(cairo_t *, cairo_antialias_t);
 176      cairo_surface_t * (*cairo_image_surface_create_for_data)(unsigned char *, cairo_format_t, int, int, int);
 177
 178      /* add user data */
 179      struct {
 180           Evas_Object* eo;
 181           Evas_Object* content;
 182           int cw, ch;
 183      } minimap;
 184
 185      struct {
 186           char** options;
 187           int option_cnt;
 188           int option_idx;
 189      } dropdown;
 190
 191      struct {
 192           Evas_Point basis;    // basis point of zoom
 193           int finger_distance; // distance between two finger
 194           int zooming_level;
 195           float zooming_rate;
 196           float zoom_rate_at_start;
 197           float zoom_rate_to_set;
 198           Evas_Point scroll_at_start;
 199           Evas_Point scroll_to_set;
 200           float init_zoom_rate;
 201           float min_zoom_rate; //content based minimum
 202           float max_zoom_rate;
 203           Eina_Bool scalable;
 204      } zoom;
 205
 206      struct {
 207           int w, h;
 208      } content;
 209
 210      struct {
 211           int default_w;
 212           int w, h;
 213      } layout;
 214
 215      Ecore_Animator* smart_zoom_animator;
 216
 217      Evas_Point pan_s;
 218      Evas_Event_Mouse_Down mouse_down_copy;
 219      Evas_Event_Mouse_Up mouse_up_copy;
 220
 221      cairo_surface_t* thumbnail;
 222      float current_zoom_level;
 223
 224      Eina_Bool tiled;
 225      Eina_Bool on_panning;
 226      Eina_Bool on_zooming;
 227      Eina_Bool is_mobile_page;
 228
 229      Eina_Bool use_text_selection;
 230      Eina_Bool text_selection_on;
 231      struct {
 232           Evas_Coord_Rectangle front;
 233           Evas_Coord_Rectangle back;
 234           Evas_Point front_handle;
 235           Evas_Point back_handle;
 236           Eina_Bool front_handle_moving;
 237           Eina_Bool back_handle_moving;
 238      } text_selection;
 239      void* touch_obj;
 240
 241      Ecore_Idler *flush_and_pre_render_idler;
 242      Eina_Bool use_zoom_bouncing;
 243 };
 244
 245 /* local subsystem functions */
 246 static void      _resize_calc_job(void *data);
 247 static void      _move_calc_job(void *data);
 248 static void      _smart_show(Evas_Object* obj);
 249 static void      _smart_hide(Evas_Object* obj);
 250 static void      _smart_resize(Evas_Object* obj, Evas_Coord w, Evas_Coord h);
 251 static void      _smart_move(Evas_Object* obj, Evas_Coord x, Evas_Coord y);
 252 #ifdef DEBUG
 253 static void      _smart_calculate(Evas_Object* obj);
 254 #endif
 255 static Eina_Bool _smart_mouse_down(Ewk_View_Smart_Data *esd, const Evas_Event_Mouse_Down* ev);
 256 static Eina_Bool _smart_mouse_up(Ewk_View_Smart_Data *esd, const Evas_Event_Mouse_Up* ev);
 257 static Eina_Bool _smart_mouse_move(Ewk_View_Smart_Data *esd, const Evas_Event_Mouse_Move* ev);
 258 static void      _smart_add_console_message(Ewk_View_Smart_Data *esd, const char *message, unsigned int lineNumber, const char *sourceID);
 259 static void      _smart_run_javascript_alert(Ewk_View_Smart_Data *esd, Evas_Object *frame, const char *message);
 260 static Eina_Bool _smart_run_javascript_confirm(Ewk_View_Smart_Data *esd, Evas_Object *frame, const char *message);
 261 static Eina_Bool _smart_run_javascript_prompt(Ewk_View_Smart_Data *esd, Evas_Object *frame, const char *message, const char *defaultValue, char **value);
 262 static Eina_Bool _smart_should_interrupt_javascript(Ewk_View_Smart_Data *esd);
 263 static Eina_Bool _smart_run_open_panel(Ewk_View_Smart_Data *esd, Evas_Object *frame, Eina_Bool allows_multiple_files, const Eina_List *suggested_filenames, Eina_List **selected_filenames);
 264 static Eina_Bool _smart_navigation_policy_decision(Ewk_View_Smart_Data *esd, Ewk_Frame_Resource_Request *request);
 265 static void      _view_on_mouse_down(void* data, Evas* e, Evas_Object* o, void* event_info);
 266 static void      _view_on_mouse_up(void* data, Evas* e, Evas_Object* o, void* event_info);
 267 static void      _smart_load_started(void* data, Evas_Object* webview, void* error);
 268 static void      _smart_load_finished(void* data, Evas_Object* webview, void* arg);
 269 static void      _smart_load_error(void* data, Evas_Object* webview, void* arg);
 270 static void      _smart_viewport_changed(void* data, Evas_Object* webview, void* arg);
 271 static void      _smart_input_method_changed(void* data, Evas_Object* webview, void* arg);
 272 static void      _smart_page_layout_info_set(Smart_Data *sd, float init_zoom_rate, float min_zoom_rate, float max_zoom_rate, Eina_Bool scalable);
 273 static void      _smart_contents_size_changed(void* data, Evas_Object* frame, void* arg);
 274 static void      _smart_load_nonemptylayout_finished(void* data, Evas_Object* frame, void* arg);
 275 static void      _smart_cb_view_created(void* data, Evas_Object* webview, void* arg);
 276 static void      _smart_add(Evas_Object* obj);
 277 static void      _smart_del(Evas_Object* o);
 278 static void      _directional_pre_render(Evas_Object* webview, int dx, int dy);
 279 static void      _smart_cb_mouse_down(void* data, Evas_Object* webview, void* ev);
 280 static void      _smart_cb_mouse_up(void* data, Evas_Object* webview, void* ev);
 281 static void      _smart_cb_mouse_tap(void* data, Evas_Object* webview, void* ev);
 282 static void      _smart_cb_pan_start(void* data, Evas_Object* webview, void* ev);
 283 static void      _smart_cb_pan_by(void* data, Evas_Object* webview, void* ev);
 284 static void      _smart_cb_pan_stop(void* data, Evas_Object* webview, void* ev);
 285 static void      _smart_cb_select_closest_word(void* data, Evas_Object* webview, void* ev);
 286 static void      _smart_cb_unselect_closest_word(void* data, Evas_Object* webview, void* ev);
 287 static void      _suspend_all(Smart_Data *sd, Eina_Bool hidePlugin);
 288 static void      _resume_all(Smart_Data *sd, Eina_Bool hidePlugin);
 289 static void      _zoom_start(Smart_Data* sd, int centerX, int centerY, int distance);
 290 static void      _zoom_move(Smart_Data* sd, int centerX, int centerY, int distance);
 291 static void      _zoom_stop(Smart_Data* sd);
 292 static void      _adjust_to_contents_boundary(Evas_Object* webview, int* to_x, int* to_y, int from_x, int from_y, float new_zoom_rate);
 293 static int       _smart_zoom_animator(void* data);
 294 static void      _smart_cb_pinch_zoom_start(void* data, Evas_Object* webview, void* event_info);
 295 static void      _smart_cb_pinch_zoom_move(void* data, Evas_Object* webview, void* event_info);
 296 static void      _smart_cb_pinch_zoom_stop(void* data, Evas_Object* webview, void* event_info);
 297 static void      _smart_cb_vertical_zoom_start(void* data, Evas_Object* webview, void* event_info);
 298 static void      _smart_cb_vertical_zoom_move(void* data, Evas_Object* webview, void* event_info);
 299 static void      _smart_cb_vertical_zoom_stop(void* data, Evas_Object* webview, void* event_info);
 300 static void      _smart_cb_smart_zoom(void* data, Evas_Object* webview, void* event_info);
 301 static void      _zoom_to_rect(Smart_Data *sd, int x, int y);
 302 static void      _text_selection_init(Evas_Object* parent);
 303 static void      _text_selection_show(void);
 304 static void      _text_selection_hide(Smart_Data *sd);
 305 static void      _text_selection_set_front_info(Smart_Data *sd, int x, int y, int height);
 306 static void      _text_selection_set_back_info(Smart_Data *sd, int x, int y, int height);
 307 static Eina_Bool _text_selection_handle_pressed(Smart_Data *sd, int x, int y);
 308 static void      _text_selection_update_position(Smart_Data *sd, int x, int y);
 309 static void      _text_selection_move_by(Smart_Data *sd, int dx, int dy);
 310 static void      _minimap_update_detail(Evas_Object* minimap, Smart_Data *sd, cairo_surface_t* src, int srcW, int srcH, Eina_Rectangle* visibleRect);
 311 static void      _minimap_update(Evas_Object* minimap, Smart_Data *sd, cairo_surface_t* src, int minimapW, int minimapH);
 312 static cairo_surface_t* _image_clone_get(Smart_Data *sd, int* minimap_w, int* minimap_h);
 313 static void      _unzoom_position(Evas_Object* webview, int x, int y, int* ux, int* uy);
 314 static void      _coords_evas_to_ewk(Evas_Object* webview, int x, int y, int* ux, int* uy);
 315 static void      _coords_ewk_to_evas(Evas_Object* webview, int x, int y, int* ux, int* uy);
 316 static void      _update_min_zoom_rate(Evas_Object *obj);
 317 static void      _geolocation_permission_callback(void *geolocation_obj, const char* url);
 318
 319 /* local subsystem globals */
 320 static Evas_Smart *_smart = NULL;
 321 static Ewk_View_Smart_Class _parent_sc = EWK_VIEW_SMART_CLASS_INIT_NULL;
 322
 323 /* ewk functions */
 324 static void *ewk_handle;
 325 static void *cairo_handle;
 326
 327 static Ewk_Tile_Unused_Cache *ewk_tile_cache = NULL;
 328 static ewk_tile_cache_ref_count = 0;
 329
 330 static Evas_Object *obj = NULL;
 331
 332 /* externally accessible functions */
 333 Evas_Object*
 334 _elm_smart_webview_add(Evas *evas, Eina_Bool tiled)
 335 {
 336    Evas_Object* webview;
 337    int (*ewk_init)(void) = NULL;
 338    void (*ewk_dnet_open)(void) = NULL;
 339    Eina_Bool (*ewk_view_single_smart_set)(Ewk_View_Smart_Class *) = NULL;
 340    Eina_Bool (*ewk_view_tiled_smart_set)(Ewk_View_Smart_Class *) = NULL;
 341
 342    if (!_smart)
 343      {
 344         ewk_handle = dlopen(EWEBKIT_PATH, RTLD_LAZY);
 345         if (ewk_handle == NULL)
 346           {
 347              ERR("could not initialize ewk \n");
 348              return NULL;
 349           }
 350         cairo_handle = dlopen(CAIRO_PATH, RTLD_LAZY);
 351         if (cairo_handle == NULL)
 352           {
 353              ERR("could not initialize cairo \n");
 354              return NULL;
 355           }
 356
 357         // init ewk
 358         if (!ewk_init)
 359           ewk_init = (int (*)())dlsym(ewk_handle, "ewk_init");
 360         ewk_init();
 361
 362         if (!ewk_dnet_open)
 363           ewk_dnet_open = (void (*)())dlsym(ewk_handle, "ewk_dnet_open");
 364         ewk_dnet_open();
 365
 366         /* create subclass */
 367         static Ewk_View_Smart_Class _api = EWK_VIEW_SMART_CLASS_INIT_NAME_VERSION(SMART_NAME);
 368
 369         if (tiled)
 370           {
 371              if (!ewk_view_tiled_smart_set)
 372                ewk_view_tiled_smart_set = (Eina_Bool (*)(Ewk_View_Smart_Class *))dlsym(ewk_handle, "ewk_view_tiled_smart_set");
 373              ewk_view_tiled_smart_set(&_api);
 374              if (EINA_UNLIKELY(!_parent_sc.sc.add))
 375                ewk_view_tiled_smart_set(&_parent_sc);
 376
 377           } else {
 378                if (!ewk_view_single_smart_set)
 379                  ewk_view_single_smart_set = (Eina_Bool (*)(Ewk_View_Smart_Class *))dlsym(ewk_handle, "ewk_view_single_smart_set");
 380                ewk_view_single_smart_set(&_api);
 381                if (EINA_UNLIKELY(!_parent_sc.sc.add))
 382                  ewk_view_single_smart_set(&_parent_sc);
 383           }
 384
 385         _api.sc.add     = _smart_add;
 386         _api.sc.del     = _smart_del;
 387         _api.sc.show    = _smart_show;
 388         _api.sc.hide    = _smart_hide;
 389         _api.sc.resize  = _smart_resize;
 390         _api.sc.move  = _smart_move;
 391 #ifdef DEBUG
 392         _api.sc.calculate = _smart_calculate;
 393 #endif
 394         _api.mouse_down = _smart_mouse_down;
 395         _api.mouse_up   = _smart_mouse_up  ;
 396         _api.mouse_move = _smart_mouse_move;
 397
 398         _api.add_console_message = _smart_add_console_message;
 399         _api.run_javascript_alert = _smart_run_javascript_alert;
 400         _api.run_javascript_confirm = _smart_run_javascript_confirm;
 401         _api.run_javascript_prompt = _smart_run_javascript_prompt;
 402         _api.should_interrupt_javascript = _smart_should_interrupt_javascript;
 403         _api.run_open_panel = _smart_run_open_panel;
 404         //_api.navigation_policy_decision = _smart_navigation_policy_decision;
 405
 406         _smart = evas_smart_class_new(&_api.sc);
 407         elm_theme_overlay_add(NULL, WEBVIEW_THEME_EDJ);
 408
 409      }
 410
 411    if (!_smart)
 412      {
 413         ERR("could not create smart class\n");
 414         return NULL;
 415      }
 416
 417    webview = evas_object_smart_add(evas, _smart);
 418    if (!webview)
 419      {
 420         ERR("could not create smart object for webview");
 421         return NULL;
 422      }
 423    obj = webview;
 424
 425    // set tiled and unused cache
 426    Smart_Data* sd = evas_object_smart_data_get(webview);
 427    if (sd)
 428      {
 429         sd->tiled = tiled;
 430         if (sd->tiled)
 431           {
 432              if (ewk_tile_cache_ref_count == 0)
 433                {
 434                   if (!sd->ewk_view_tiled_unused_cache_get)
 435                     sd->ewk_view_tiled_unused_cache_get = (Ewk_Tile_Unused_Cache *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_tiled_unused_cache_get");
 436                   ewk_tile_cache = sd->ewk_view_tiled_unused_cache_get(webview);
 437
 438                   if (!sd->ewk_tile_unused_cache_max_set)
 439                     sd->ewk_tile_unused_cache_max_set = (void (*)(Ewk_Tile_Unused_Cache *, size_t))dlsym(ewk_handle, "ewk_tile_unused_cache_max_set");
 440                   sd->ewk_tile_unused_cache_max_set(ewk_tile_cache, MAX_TUC);
 441                } else {
 442                     if (!sd->ewk_view_tiled_unused_cache_set)
 443                       sd->ewk_view_tiled_unused_cache_set = (void (*)(Evas_Object *, Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_view_tiled_unused_cache_set");
 444                     sd->ewk_view_tiled_unused_cache_set(webview, ewk_tile_cache);
 445                }
 446              ++ewk_tile_cache_ref_count;
 447              //size_t mem = ewk_tile_unused_cache_used_get(ewk_tile_cache);
 448              //DBG("%s: Used cache: %d (%dkB)", __func__, mem, (mem/1024));
 449           }
 450      }
 451
 452    return webview;
 453 }
 454
 455 void
 456 _elm_smart_webview_events_feed_set(Evas_Object* obj, Eina_Bool feed)
 457 {
 458    API_ENTRY return;
 459    sd->events_feed = feed;
 460 }
 461
 462 Eina_Bool
 463 _elm_smart_webview_events_feed_get(Evas_Object* obj)
 464 {
 465    API_ENTRY return EINA_FALSE;
 466    return sd->events_feed;
 467 }
 468
 469 void
 470 _elm_smart_webview_auto_fitting_set(Evas_Object* obj, Eina_Bool enable)
 471 {
 472    API_ENTRY return;
 473    sd->auto_fitting = enable;
 474 }
 475
 476 Eina_Bool
 477 _elm_smart_webview_auto_fitting_get(Evas_Object *obj)
 478 {
 479    API_ENTRY return EINA_FALSE;
 480    return sd->auto_fitting;
 481 }
 482
 483 Evas_Object *
 484 _elm_smart_webview_minimap_get(Evas_Object* obj)
 485 {
 486    DBG("%s\n", __func__);
 487    API_ENTRY return NULL;
 488
 489    if (sd->minimap.eo != NULL) return sd->minimap.eo;
 490
 491    sd->minimap.eo = edje_object_add(evas_object_evas_get(obj));
 492    edje_object_file_set(sd->minimap.eo, WEBVIEW_EDJ, "minimap");
 493
 494    sd->minimap.content = evas_object_image_add(evas_object_evas_get(sd->minimap.eo));
 495    evas_object_size_hint_align_set(sd->minimap.content, 0.5, 0.5);
 496    evas_object_image_colorspace_set(sd->minimap.content, EVAS_COLORSPACE_ARGB8888);
 497    evas_object_image_alpha_set(sd->minimap.content, EINA_FALSE);
 498
 499    Evas_Object* box = evas_object_box_add(evas_object_evas_get(sd->minimap.eo));
 500    evas_object_box_append(box, sd->minimap.content);
 501    evas_object_show(sd->minimap.content);
 502    edje_object_part_swallow(sd->minimap.eo, "swallow.content", box);
 503
 504    return sd->minimap.eo;
 505 }
 506
 507 void
 508 _elm_smart_webview_uri_set(Evas_Object* obj, const char* uri)
 509 {
 510    API_ENTRY return;
 511
 512    char full_uri[MAX_URI] = "";
 513    printf("<< uri [%s] >>\n", uri);
 514
 515    if (uri == NULL)
 516      return;
 517
 518    // check uri string
 519    int len = strlen(uri);
 520    if (len)
 521      {
 522         if (strstr(uri, "://") == NULL) {
 523              strncpy(full_uri, "http://", 7);
 524              full_uri[7] = '\0';
 525              len = (len >= (MAX_URI - 7)) ? (MAX_URI - 8) : len;
 526              strncat(full_uri, uri, len);
 527         } else {
 528              len = (len >= MAX_URI) ? (MAX_URI - 1) : len;
 529              strncpy(full_uri, uri, len);
 530              full_uri[len] = '\0';
 531         }
 532
 533         printf("<< full uri [%s] >>\n", full_uri);
 534         if (!sd->ewk_view_uri_set)
 535           sd->ewk_view_uri_set = (Eina_Bool (*)(Evas_Object *, const char *))dlsym(ewk_handle, "ewk_view_uri_set");
 536         sd->ewk_view_uri_set(obj, full_uri);
 537      }
 538 }
 539
 540 void
 541 _elm_smart_webview_widget_set(Evas_Object *obj, Evas_Object *wid)
 542 {
 543    API_ENTRY return;
 544    sd->widget = wid;
 545 }
 546
 547 void
 548 _elm_smart_webview_bounce_allow_set(Evas_Object* obj, Eina_Bool horiz, Eina_Bool vert)
 549 {
 550    API_ENTRY return;
 551    sd->bounce_horiz = horiz;
 552    sd->bounce_vert = vert;
 553 }
 554
 555 void
 556 _elm_smart_webview_mime_callback_set(Evas_Object* obj, const char *mime, Elm_WebView_Mime_Cb func)
 557 {
 558    API_ENTRY return;
 559    if (!sd->mime_func_hash)
 560      sd->mime_func_hash = eina_hash_pointer_new(NULL);
 561
 562    if (!func)
 563      eina_hash_del(sd->mime_func_hash, mime, func);
 564    else
 565      eina_hash_add(sd->mime_func_hash, mime, func);
 566 }
 567
 568 void
 569 _elm_smart_webview_default_layout_width_set(Evas_Object *obj, int width)
 570 {
 571    API_ENTRY return;
 572    sd->layout.default_w = width;
 573 }
 574
 575 #ifdef BOUNCING_SUPPORT
 576 void
 577 _elm_smart_webview_container_set(Evas_Object *obj, Evas_Object *container)
 578 {
 579    API_ENTRY return;
 580    sd->container = container;
 581 }
 582 #endif
 583
 584 int
 585 _flush_and_pre_render(void *data)
 586 {
 587    Evas_Object *obj = (Evas_Object *)data;
 588    API_ENTRY return ECORE_CALLBACK_CANCEL;
 589
 590    if (!sd->ewk_view_tiled_unused_cache_get)
 591      sd->ewk_view_tiled_unused_cache_get = (Ewk_Tile_Unused_Cache *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_tiled_unused_cache_get");
 592    if (!sd->ewk_tile_unused_cache_used_get)
 593      sd->ewk_tile_unused_cache_used_get = (size_t (*)(const Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_used_get");
 594    if (!sd->ewk_tile_unused_cache_flush)
 595      sd->ewk_tile_unused_cache_flush = (size_t (*)(Ewk_Tile_Unused_Cache *, size_t))dlsym(ewk_handle, "ewk_tile_unused_cache_flush");
 596
 597    Ewk_Tile_Unused_Cache *tuc = sd->ewk_view_tiled_unused_cache_get(obj);
 598    sd->ewk_tile_unused_cache_flush(tuc, sd->ewk_tile_unused_cache_used_get(tuc));
 599    _directional_pre_render(obj, 0, 0);
 600
 601    sd->flush_and_pre_render_idler = NULL;
 602
 603    return ECORE_CALLBACK_CANCEL;
 604 }
 605
 606 /* local subsystem functions */
 607 static void
 608 _smart_show(Evas_Object* obj)
 609 {
 610    DBG("%s\n", __func__);
 611    INTERNAL_ENTRY;
 612
 613    _elm_smart_touch_start(sd->touch_obj);
 614    _parent_sc.sc.show(obj);
 615 }
 616
 617 static void
 618 _smart_hide(Evas_Object* obj)
 619 {
 620    DBG("%s\n", __func__);
 621    INTERNAL_ENTRY;
 622
 623    _elm_smart_touch_stop(sd->touch_obj);
 624    _parent_sc.sc.hide(obj);
 625 }
 626
 627 static void
 628 _smart_resize(Evas_Object* obj, Evas_Coord w, Evas_Coord h)
 629 {
 630    DBG("%s\n", __func__);
 631    INTERNAL_ENTRY;
 632
 633    Evas_Coord ow, oh;
 634    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
 635    if ((ow == w) && (oh == h)) return;
 636    if (sd->resize_calc_job) ecore_job_del(sd->resize_calc_job);
 637    sd->resize_calc_job = ecore_job_add(_resize_calc_job, obj);
 638 }
 639
 640 static void
 641 _resize_calc_job(void *data)
 642 {
 643    Evas_Object *obj = data;
 644    INTERNAL_ENTRY;
 645
 646    int object_w, object_h;
 647    evas_object_geometry_get(obj, NULL, NULL, &object_w, &object_h);
 648    object_w = (object_w % 10) ? (object_w / 10 * 10 + 10) : object_w;
 649
 650    if (sd->is_mobile_page)
 651      {
 652         int old_layout_w = sd->layout.w;
 653         sd->layout.w = object_w / sd->zoom.init_zoom_rate;
 654         sd->layout.h = object_h / sd->zoom.init_zoom_rate;
 655         if (old_layout_w != sd->layout.w)
 656           {
 657              if (!sd->ewk_view_fixed_layout_size_set)
 658                sd->ewk_view_fixed_layout_size_set = (void (*)(Evas_Object *, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_fixed_layout_size_set");
 659              sd->ewk_view_fixed_layout_size_set(obj, sd->layout.w, sd->layout.h);
 660           }
 661      }
 662    else
 663      {
 664         if (!sd->ewk_view_zoom_get)
 665           sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
 666         if (!sd->ewk_view_zoom_set)
 667           sd->ewk_view_zoom_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_set");
 668
 669         _update_min_zoom_rate(obj);
 670
 671         // set zoom
 672         if (sd->ewk_view_zoom_get(obj) < sd->zoom.min_zoom_rate)
 673           sd->ewk_view_zoom_set(obj, sd->zoom.min_zoom_rate, 0, 0);
 674      }
 675
 676    // call preRender by timer, because we can not get the correct visible_content of frame
 677    // when call it directly.
 678    if (!sd->ewk_view_uri_get)
 679      sd->ewk_view_uri_get = (const char * (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_uri_get");
 680    const char *url = sd->ewk_view_uri_get(obj);
 681    if (url && strcmp(url, "") != 0 && sd->flush_and_pre_render_idler == NULL)
 682      {
 683         sd->flush_and_pre_render_idler = ecore_idler_add(_flush_and_pre_render, obj);
 684      }
 685
 686    sd->resize_calc_job = NULL;
 687    _parent_sc.sc.resize(obj, object_w, object_h);
 688 }
 689
 690 static void
 691 _move_calc_job(void *data)
 692 {
 693    Evas_Object *obj = data;
 694    INTERNAL_ENTRY;
 695    int x, y;
 696    evas_object_geometry_get(obj, &x, &y, NULL, NULL);
 697    sd->move_calc_job = NULL;
 698    _parent_sc.sc.move(obj, x, y);
 699 }
 700
 701 static void
 702 _smart_move(Evas_Object* obj, Evas_Coord x, Evas_Coord y)
 703 {
 704    DBG("%s\n", __func__);
 705    INTERNAL_ENTRY;
 706
 707    if (sd->move_calc_job) ecore_job_del(sd->move_calc_job);
 708    sd->move_calc_job = ecore_job_add(_move_calc_job, obj);
 709 }
 710
 711 #ifdef DEBUG
 712 static void
 713 _smart_calculate(Evas_Object* obj)
 714 {
 715    _parent_sc.sc.calculate(obj);
 716 }
 717 #endif
 718
 719 static Eina_Bool
 720 _smart_mouse_down(Ewk_View_Smart_Data *esd, const Evas_Event_Mouse_Down* ev)
 721 {
 722    DBG("[NATIVE]%s is called\n", __func__);
 723    Smart_Data *sd = (Smart_Data *)esd;
 724    sd->mouse_down_copy = *ev;
 725
 726    if (sd->events_feed)
 727      {
 728         _suspend_all(sd, EINA_FALSE);
 729         sd->mouse_clicked = EINA_TRUE;
 730         return _parent_sc.mouse_down(esd, ev);
 731      }
 732    else return EINA_TRUE;
 733 }
 734
 735 static Eina_Bool
 736 _smart_mouse_up(Ewk_View_Smart_Data *esd, const Evas_Event_Mouse_Up* ev)
 737 {
 738    DBG("[NATIVE]%s is called\n", __func__);
 739    Smart_Data *sd = (Smart_Data *)esd;
 740    sd->mouse_up_copy = *ev;
 741
 742    if (sd->events_feed)
 743      {
 744         _resume_all(sd, EINA_FALSE);
 745         //check if user hold touch
 746         if (ev && (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
 747           {
 748              return EINA_TRUE;
 749           }
 750
 751         Eina_Bool ret = _parent_sc.mouse_up(esd, ev);
 752         sd->mouse_clicked = EINA_FALSE;
 753         return ret;
 754      }
 755    else
 756      return EINA_TRUE;
 757 }
 758
 759 static Eina_Bool
 760 _smart_mouse_move(Ewk_View_Smart_Data *esd, const Evas_Event_Mouse_Move* ev)
 761 {
 762    Smart_Data *sd = (Smart_Data *)esd;
 763    if (sd->events_feed) _parent_sc.mouse_move(esd, ev);
 764    else return EINA_TRUE;
 765 }
 766
 767 static void
 768 _smart_add_console_message(Ewk_View_Smart_Data *esd, const char *message, unsigned int lineNumber, const char *sourceID)
 769 {
 770    //TODO
 771 }
 772
 773 static void
 774 _smart_run_javascript_alert(Ewk_View_Smart_Data *esd, Evas_Object *frame, const char *message)
 775 {
 776    Evas_Object *popup;
 777    popup = elm_popup_add(esd->self);
 778    evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 779    elm_popup_desc_set(popup, message);
 780    elm_popup_buttons_add(popup, 1, "Ok", ELM_POPUP_RESPONSE_OK, NULL);
 781    evas_object_show(popup);
 782 }
 783
 784 static Eina_Bool
 785 _smart_run_javascript_confirm(Ewk_View_Smart_Data *esd, Evas_Object *frame, const char *message)
 786 {
 787    Evas_Object *popup;
 788    popup = elm_popup_add(esd->self);
 789    evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 790    elm_popup_desc_set(popup, message);
 791    elm_popup_buttons_add(popup, 2, "Ok", ELM_POPUP_RESPONSE_OK, "Cancel", ELM_POPUP_RESPONSE_CANCEL, NULL);
 792
 793    int ret = elm_popup_run(popup);
 794    evas_object_del(popup);
 795    switch (ret)
 796      {
 797       case ELM_POPUP_RESPONSE_OK:
 798          return EINA_TRUE;
 799       case ELM_POPUP_RESPONSE_CANCEL:
 800          return EINA_FALSE;
 801       default:
 802          elm_exit();
 803      }
 804    return EINA_FALSE;
 805 }
 806
 807 static Eina_Bool
 808 _smart_run_javascript_prompt(Ewk_View_Smart_Data *esd, Evas_Object *frame, const char *message, const char *defaultValue, char **value)
 809 {
 810    //FIXME: it's not work
 811    Evas_Object *popup;
 812    Evas_Object *box, *entry, *label;
 813
 814    popup = elm_popup_add(esd->self);
 815    elm_object_style_set(popup, "customstyle");
 816    evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 817    elm_popup_buttons_add(popup, 2, "Ok", ELM_POPUP_RESPONSE_OK, "Cancel", ELM_POPUP_RESPONSE_CANCEL, NULL);
 818
 819    box = elm_box_add(popup);
 820    evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 821    evas_object_size_hint_fill_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
 822    evas_object_show(box);
 823
 824    label = elm_label_add(box);
 825    evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 826    elm_label_label_set(label, message);
 827    elm_box_pack_start(box, label);
 828    evas_object_show(label);
 829
 830    entry = elm_entry_add(box);
 831    evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 832    elm_entry_single_line_set(entry, EINA_TRUE);
 833    elm_entry_entry_set(entry, defaultValue);
 834    elm_box_pack_end(box, entry);
 835    evas_object_show(entry);
 836
 837    int ret = elm_popup_run(popup);
 838    *value = strdup("temp");
 839    evas_object_del(popup);
 840
 841    return EINA_FALSE;
 842 }
 843
 844 static Eina_Bool
 845 _smart_should_interrupt_javascript(Ewk_View_Smart_Data *esd)
 846 {
 847    //TODO
 848    return EINA_FALSE;
 849 }
 850
 851 static Eina_Bool
 852 _smart_run_open_panel(Ewk_View_Smart_Data *esd, Evas_Object *frame, Eina_Bool allows_multiple_files, const Eina_List *suggested_filenames, Eina_List **selected_filenames)
 853 {
 854    //TODO
 855    return EINA_FALSE;
 856 }
 857
 858 static Eina_Bool
 859 _smart_navigation_policy_decision(Ewk_View_Smart_Data *esd, Ewk_Frame_Resource_Request *request)
 860 {
 861    char *protocol_hack;
 862    Smart_Data *sd = (Smart_Data*)esd;
 863    if (!sd->mime_func_hash)
 864      return EINA_FALSE;
 865
 866    protocol_hack = strstr(request->url, ":");
 867    *protocol_hack = '\0';
 868    Elm_WebView_Mime_Cb func = (Elm_WebView_Mime_Cb) eina_hash_find(sd->mime_func_hash, request->url);
 869    *protocol_hack = ':';
 870
 871    if (!func)
 872      {
 873         if (strncmp(request->url, "http", 4) == 0
 874               || strncmp(request->url, "https", 5) == 0
 875               || strncmp(request->url, "file", 4) == 0)
 876           return EINA_TRUE;
 877         return EINA_FALSE;
 878      }
 879    else
 880      return func(esd->self);
 881 }
 882
 883 #ifdef NEED_TO_REMOVE
 884 // TODO: temporary mouse callback until the webkit engine can receive mouse events
 885 static void
 886 _view_on_mouse_down(void* data, Evas* e, Evas_Object* o, void* event_info)
 887 {
 888    Evas_Event_Mouse_Down* ev = (Evas_Event_Mouse_Down*)event_info;
 889    Ewk_View_Smart_Data* sd = (Ewk_View_Smart_Data*)data;
 890    EINA_SAFETY_ON_NULL_RETURN(sd->api);
 891    EINA_SAFETY_ON_NULL_RETURN(sd->api->mouse_down);
 892    sd->api->mouse_down(sd, ev);
 893 }
 894
 895 static void
 896 _view_on_mouse_up(void* data, Evas* e, Evas_Object* o, void* event_info)
 897 {
 898    Evas_Event_Mouse_Up* ev = (Evas_Event_Mouse_Up*)event_info;
 899    Ewk_View_Smart_Data* sd = (Ewk_View_Smart_Data*)data;
 900    EINA_SAFETY_ON_NULL_RETURN(sd->api);
 901    EINA_SAFETY_ON_NULL_RETURN(sd->api->mouse_up);
 902    sd->api->mouse_up(sd, ev);
 903 }
 904 #endif
 905
 906 static void
 907 _smart_load_started(void* data, Evas_Object* webview, void* error)
 908 {
 909    DBG("%s is called\n", __func__);
 910    Smart_Data *sd = (Smart_Data *)data;
 911    if (!sd) return;
 912
 913    if (!sd->ewk_view_user_scalable_set)
 914      sd->ewk_view_user_scalable_set = (void (*)(Evas_Object *, Eina_Bool))dlsym(ewk_handle, "ewk_view_user_scalable_set");
 915
 916    // set default layout and zoom level
 917    sd->is_mobile_page = EINA_FALSE;
 918    sd->layout.w = -1;
 919    sd->layout.h = -1;
 920    sd->zoom.init_zoom_rate = 1.0f;
 921    sd->zoom.scalable = EINA_TRUE;
 922    sd->ewk_view_user_scalable_set(webview, EINA_TRUE);
 923 }
 924
 925 static void
 926 _smart_load_finished(void* data, Evas_Object* webview, void* arg)
 927 {
 928    DBG("%s is called\n", __func__);
 929    Smart_Data* sd = (Smart_Data *)data;
 930    if (!sd) return;
 931
 932    // if error, call loadNotFoundPage
 933    Ewk_Frame_Load_Error *error = (Ewk_Frame_Load_Error *) arg;
 934    int errorCode = (error)? error->code: 0;
 935    if ( errorCode != 0 && errorCode != -999 )
 936      { // 0 ok, -999 request cancelled
 937         DBG( "page not found:, [code: %d] [domain: %s] [description: %s] [failing_url: %s] \n",
 938               error->code, error->domain, error->description, error->failing_url);
 939         //ecore_job_add(loadNotFoundPage, (void *)this);
 940         return;
 941      }
 942
 943    if (sd->auto_fitting == EINA_TRUE)
 944      {
 945         if (!sd->ewk_view_zoom_set)
 946           sd->ewk_view_zoom_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_set");
 947         sd->ewk_view_zoom_set(webview, sd->zoom.min_zoom_rate, 0, 0);
 948      }
 949
 950    // update thumbnail and minimap
 951    if (sd->thumbnail != NULL)
 952      {
 953         if (!sd->cairo_surface_destroy)
 954           sd->cairo_surface_destroy = (void (*)(cairo_surface_t *))dlsym(cairo_handle, "cairo_surface_destroy");
 955         sd->cairo_surface_destroy(sd->thumbnail);
 956      }
 957    sd->thumbnail = _image_clone_get(sd, &(sd->minimap.cw), &(sd->minimap.ch));
 958
 959    if (sd->tiled)
 960      _directional_pre_render(sd->base.self, 0, 0);
 961
 962    if (sd->minimap.eo != NULL)
 963      {
 964    _minimap_update(sd->minimap.content, sd, sd->thumbnail,
 965          sd->minimap.cw, sd->minimap.ch);
 966      }
 967 }
 968
 969 static void
 970 _smart_load_error(void* data, Evas_Object* webview, void* arg)
 971 {
 972    DBG("%s is called\n", __func__);
 973    Smart_Data* sd = (Smart_Data *)data;
 974    char szBuffer[2048];
 975    if (!sd) return;
 976
 977    // if error, call loadNotFoundPage
 978    Ewk_Frame_Load_Error *error = (Ewk_Frame_Load_Error *) arg;
 979    int errorCode = (error)? error->code: 0;
 980    if ( errorCode != 0 && errorCode != -999 )
 981      { // 0 ok, -999 request cancelled
 982         //char szStrBuffer[1024];
 983         //snprintf(szStrBuffer, 1024, "page not found:, [code: %d] [domain: %s] [description: %s] [failing_url: %s] \n",
 984         //      error->code, error->domain, error->description, error->failing_url);
 985         //DBG(szStrBuffer);
 986
 987         //ecore_job_add(loadNotFoundPage, (void *)this);
 988         if (!sd->ewk_view_stop)
 989           sd->ewk_view_stop = (Eina_Bool (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_stop");
 990         sd->ewk_view_stop(webview);
 991
 992         if (!sd->ewk_view_frame_main_get)
 993           sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
 994
 995         if (!sd->ewk_frame_contents_set)
 996           sd->ewk_frame_contents_set = (Eina_Bool (*)(Evas_Object *, const char *, size_t, const char *, const char *, const char *))dlsym(ewk_handle, "ewk_frame_contents_set");
 997
 998         snprintf(szBuffer, 2048, NOT_FOUND_PAGE_HEADER "\"?%s?%s\"" NOT_FOUND_PAGE_FOOTER, error->failing_url, error->description);
 999         //sd->ewk_frame_contents_set(sd->ewk_view_frame_main_get(webview), szStrBuffer, 0, NULL, NULL, NULL);
1000         sd->ewk_frame_contents_set(error->frame, szBuffer, 0, NULL, NULL, NULL);
1001         return;
1002      }
1003 }
1004
1005 static void
1006 _smart_viewport_changed(void* data, Evas_Object* webview, void* arg)
1007 {
1008    DBG("%s is called\n", __func__);
1009    Smart_Data* sd = (Smart_Data *)data;
1010    if (!sd) return;
1011
1012    // check for mobile page
1013    int layout_w, layout_h;
1014    float init_zoom_rate, max_zoom_rate, min_zoom_rate;
1015    Eina_Bool scalable;
1016
1017    if (!sd->ewk_view_viewport_get)
1018      sd->ewk_view_viewport_get = (void (*)(Evas_Object *, int *, int *, float *, float *, float *, Eina_Bool *))dlsym(ewk_handle, "ewk_view_viewport_get");
1019    sd->ewk_view_viewport_get(webview, &layout_w, &layout_h,
1020          &init_zoom_rate, &max_zoom_rate, &min_zoom_rate, &scalable);
1021
1022    int object_w, object_h;
1023    evas_object_geometry_get(webview, NULL, NULL, &object_w, &object_h);
1024    object_w = (object_w % 10) ? (object_w / 10 * 10 + 10) : object_w;
1025
1026    // if layout width is bigger than object width, we regard current page to not the mobile page
1027    // for bbc.co.uk
1028    if (layout_w > object_w)
1029      {
1030         sd->layout.w = layout_w;
1031         return;
1032      }
1033
1034    // if there is no layout_w and url does not have mobile keyword, it is the desktop site.
1035    if (layout_w <= 0)
1036      {
1037         if (!sd->ewk_view_uri_get)
1038           sd->ewk_view_uri_get = (const char * (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_uri_get");
1039         const char *url = sd->ewk_view_uri_get(webview);
1040         if ((url && (strstr(url, "://m.") != NULL
1041                     || strstr(url, "://wap.") != NULL
1042                     || strstr(url, ".m.") != NULL
1043                     || strstr(url, "/mobile/i") != NULL))) // For www.bbc.co.uk/mobile/i site
1044           {
1045              min_zoom_rate = MIN_ZOOM_RATIO;
1046              max_zoom_rate = MAX_ZOOM_RATIO;
1047              scalable = 1;
1048           }
1049         else
1050           {
1051              return;
1052           }
1053      }
1054
1055    // set data for mobile page
1056    sd->is_mobile_page = EINA_TRUE;
1057    _smart_page_layout_info_set(sd, MOBILE_DEFAULT_ZOOM_RATIO, min_zoom_rate, max_zoom_rate, scalable);
1058 }
1059
1060 //#ifdef PROFUSION_INPUT_PATCH
1061 /**
1062  * Rotaion modes
1063  * @see appcore_set_rotation_cb(), appcore_get_rotation_state()
1064  */
1065 enum appcore_rm {
1066      APPCORE_RM_UNKNOWN, /**< Unknown mode */
1067      APPCORE_RM_PORTRAIT_NORMAL , /**< Portrait mode */
1068      APPCORE_RM_PORTRAIT_REVERSE , /**< Portrait upside down mode */
1069      APPCORE_RM_LANDSCAPE_NORMAL , /**< Left handed landscape mode */
1070      APPCORE_RM_LANDSCAPE_REVERSE ,  /**< Right handed landscape mode */
1071 };
1072 /*
1073 static void
1074 updateIMFOrientation( Ecore_IMF_Context *ctx )
1075 {
1076    if ( !ctx )
1077      return;
1078
1079    enum appcore_rm current_state = APPCORE_RM_UNKNOWN;
1080    int ret = appcore_get_rotation_state(&current_state);
1081
1082    switch (current_state)
1083      {
1084       case APPCORE_RM_PORTRAIT_NORMAL:
1085         ecore_imf_context_input_panel_orient_set(ctx, ECORE_IMF_INPUT_PANEL_ORIENT_NONE);
1086         break;
1087       case APPCORE_RM_PORTRAIT_REVERSE:
1088         ecore_imf_context_input_panel_orient_set(ctx, ECORE_IMF_INPUT_PANEL_ORIENT_180);
1089         break;
1090       case APPCORE_RM_LANDSCAPE_NORMAL:
1091         ecore_imf_context_input_panel_orient_set(ctx, ECORE_IMF_INPUT_PANEL_ORIENT_90_CW);
1092         break;
1093       case APPCORE_RM_LANDSCAPE_REVERSE:
1094         ecore_imf_context_input_panel_orient_set(ctx, ECORE_IMF_INPUT_PANEL_ORIENT_90_CCW);
1095         break;
1096      }
1097
1098    // call to show needed
1099    if ( ecore_imf_context_input_panel_state_get(ctx) == ECORE_IMF_INPUT_PANEL_STATE_SHOW )
1100      ecore_imf_context_input_panel_show(ctx);
1101 }
1102 */
1103
1104 static void
1105 _smart_input_method_changed(void* data, Evas_Object* webview, void* arg)
1106 {
1107    DBG("%s is called\n", __func__);
1108    Smart_Data* sd = (Smart_Data *)data;
1109    if (!sd) return;
1110
1111    if (sd->ewk_view_core_imContext_get == NULL)
1112      sd->ewk_view_core_imContext_get = (Ecore_IMF_Context* (*)(Evas_Object *)) dlsym(ewk_handle, "ewk_view_core_imContext_get");
1113
1114    Ecore_IMF_Context* imContext = sd->ewk_view_core_imContext_get(webview);
1115    Eina_Bool active = (Eina_Bool)arg;
1116    if (active && sd->mouse_clicked)
1117      {
1118         static unsigned int lastImh = 0;//FIXME
1119         if (sd->ewk_view_imh_get == NULL)
1120           sd->ewk_view_imh_get = (unsigned int (*)(Evas_Object *)) dlsym(ewk_handle, "ewk_view_imh_get");
1121         unsigned int imh = sd->ewk_view_imh_get(webview);
1122         if (ecore_imf_context_input_panel_state_get(imContext) != ECORE_IMF_INPUT_PANEL_STATE_SHOW || lastImh != imh)
1123           {
1124              lastImh = imh;
1125              //currentPage->reactToInputFieldTap(view, currentPage->getLastClickInfo().x, currentPage->getLastClickInfo().y);
1126              //updateIMFOrientation( imContext );
1127              ecore_imf_context_input_panel_reset (imContext);
1128              switch (imh)
1129                {
1130                 case EWK_IMH_TELEPHONE: ecore_imf_context_input_panel_layout_set(imContext, ECORE_IMF_INPUT_PANEL_LAYOUT_PHONENUMBER); break;
1131                 case EWK_IMH_NUMBER: ecore_imf_context_input_panel_layout_set(imContext, ECORE_IMF_INPUT_PANEL_LAYOUT_NUMBER); break;
1132                 case EWK_IMH_EMAIL: ecore_imf_context_input_panel_layout_set(imContext, ECORE_IMF_INPUT_PANEL_LAYOUT_EMAIL); break;
1133                 case EWK_IMH_URL: ecore_imf_context_input_panel_layout_set(imContext, ECORE_IMF_INPUT_PANEL_LAYOUT_URL); break;
1134                 default: ecore_imf_context_input_panel_layout_set(imContext, ECORE_IMF_INPUT_PANEL_LAYOUT_NORMAL);
1135                }
1136              DBG("ecore_imf_context_input_panel_show");
1137              ecore_imf_context_focus_in(imContext);
1138              ecore_imf_context_client_canvas_set(imContext, evas_object_evas_get(sd->base.self));
1139              ecore_imf_context_input_panel_show (imContext);
1140           }
1141      }
1142    else
1143      {
1144         DBG("ecore_imf_context_input_panel_hide");
1145         ecore_imf_context_input_panel_hide (imContext);
1146      }
1147 }
1148 //#endif
1149
1150 static void _smart_page_layout_info_set(Smart_Data *sd, float init_zoom_rate, float min_zoom_rate, float max_zoom_rate, Eina_Bool scalable)
1151 {
1152    Evas_Object* webview = sd->base.self;
1153
1154    int object_w, object_h;
1155    evas_object_geometry_get(webview, NULL, NULL, &object_w, &object_h);
1156    object_w = (object_w % 10) ? (object_w / 10 * 10 + 10) : object_w;
1157
1158    sd->zoom.init_zoom_rate = init_zoom_rate;
1159    sd->layout.w = object_w / sd->zoom.init_zoom_rate;
1160    sd->layout.h = object_h / sd->zoom.init_zoom_rate;
1161    sd->zoom.scalable = scalable;
1162    if (scalable)
1163      {
1164         sd->zoom.min_zoom_rate = (min_zoom_rate <= sd->zoom.init_zoom_rate) ? sd->zoom.init_zoom_rate : min_zoom_rate;
1165         sd->zoom.max_zoom_rate = (max_zoom_rate <= sd->zoom.init_zoom_rate) ? sd->zoom.init_zoom_rate : max_zoom_rate;
1166         if (sd->zoom.max_zoom_rate < sd->zoom.min_zoom_rate)
1167           sd->zoom.max_zoom_rate = sd->zoom.min_zoom_rate;
1168      }
1169    else
1170      {
1171         sd->zoom.min_zoom_rate = init_zoom_rate;
1172         sd->zoom.max_zoom_rate = init_zoom_rate;
1173      }
1174 }
1175
1176 static void
1177 _smart_contents_size_changed(void* data, Evas_Object* frame, void* arg)
1178 {
1179    Smart_Data* sd = (Smart_Data *)data;
1180    if (!sd) return;
1181
1182    Evas_Object* webview = sd->base.self;
1183
1184    Evas_Coord* size = (Evas_Coord*)arg;
1185    if (!size || size[0] == 0)
1186      return;
1187
1188    _update_min_zoom_rate(sd->base.self);
1189 }
1190
1191 static void
1192 _smart_load_nonemptylayout_finished(void* data, Evas_Object* frame, void* arg)
1193 {
1194    DBG("%s is called\n", __func__);
1195    Smart_Data* sd = (Smart_Data *)data;
1196    if (!sd) return;
1197
1198    Evas_Object* webview = sd->base.self;
1199
1200    if (!sd->ewk_view_user_scalable_set)
1201      sd->ewk_view_user_scalable_set = (void (*)(Evas_Object *, Eina_Bool))dlsym(ewk_handle, "ewk_view_user_scalable_set");
1202    if (!sd->ewk_view_zoom_range_set)
1203      sd->ewk_view_zoom_range_set = (Eina_Bool (*)(Evas_Object *, float, float))dlsym(ewk_handle, "ewk_view_zoom_range_set");
1204    if (!sd->ewk_view_fixed_layout_size_set)
1205      sd->ewk_view_fixed_layout_size_set = (void (*)(Evas_Object *, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_fixed_layout_size_set");
1206
1207    sd->ewk_view_zoom_range_set(webview, MIN_ZOOM_RATIO, MAX_ZOOM_RATIO);
1208
1209    // set default layout size
1210    int object_w, object_h;
1211    evas_object_geometry_get(webview, NULL, NULL, &object_w, &object_h);
1212    object_w = (object_w % 10) ? (object_w / 10 * 10 + 10) : object_w;
1213    sd->ewk_view_fixed_layout_size_set(webview, object_w, object_h);
1214
1215    sd->ewk_view_user_scalable_set(webview, EINA_TRUE);
1216
1217    // set zoom and layout
1218    if (sd->is_mobile_page)
1219      {
1220         if (!sd->ewk_view_zoom_set)
1221           sd->ewk_view_zoom_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_set");
1222         if (!sd->ewk_frame_contents_size_get)
1223           sd->ewk_frame_contents_size_get = (Eina_Bool (*)(const Evas_Object *, Evas_Coord *, Evas_Coord *))dlsym(ewk_handle, "ewk_frame_contents_size_get");
1224         if (!sd->ewk_view_uri_get)
1225           sd->ewk_view_uri_get = (const char * (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_uri_get");
1226
1227         sd->ewk_view_zoom_set(webview, sd->zoom.init_zoom_rate, 0, 0);
1228         sd->ewk_view_fixed_layout_size_set(webview, sd->layout.w, sd->layout.h);
1229
1230         int content_w;
1231         sd->ewk_frame_contents_size_get(frame, &content_w, NULL);
1232
1233         const char *url = sd->ewk_view_uri_get(webview);
1234         if ((content_w > sd->layout.w && !strstr(url, "docs.google.com"))
1235               || strstr(url, "maps.google.com/maps/m"))
1236           {
1237              // set page layout info, zoom and layout again
1238              _smart_page_layout_info_set(sd, 1.0f, sd->zoom.min_zoom_rate, sd->zoom.max_zoom_rate, sd->zoom.scalable);
1239              sd->ewk_view_zoom_range_set(webview, MIN_ZOOM_RATIO, MAX_ZOOM_RATIO);
1240              sd->ewk_view_zoom_set(webview, sd->zoom.init_zoom_rate, 0, 0);
1241              sd->ewk_view_fixed_layout_size_set(webview, sd->layout.w, sd->layout.h);
1242           }
1243         if (sd->use_zoom_bouncing)
1244           {
1245              float min_zoom_rate = sd->zoom.min_zoom_rate * ZOOM_OUT_BOUNCING;
1246              if (min_zoom_rate <= 0) min_zoom_rate = MIN_ZOOM_RATIO;
1247              float max_zoom_rate = sd->zoom.max_zoom_rate * ZOOM_IN_BOUNCING;
1248              sd->ewk_view_zoom_range_set(webview, min_zoom_rate, max_zoom_rate);
1249           }
1250         else
1251           {
1252              sd->ewk_view_zoom_range_set(webview, sd->zoom.min_zoom_rate, sd->zoom.max_zoom_rate);
1253           }
1254
1255      } else {
1256           sd->zoom.min_zoom_rate = MIN_ZOOM_RATIO;
1257           sd->zoom.max_zoom_rate = MAX_ZOOM_RATIO;
1258           if (sd->layout.w <= 0) sd->layout.w = sd->layout.default_w;
1259           sd->layout.h = object_h;
1260
1261           if (!sd->ewk_view_zoom_set)
1262             sd->ewk_view_zoom_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_set");
1263           sd->ewk_view_zoom_set(webview, sd->zoom.init_zoom_rate, 0, 0);
1264           sd->ewk_view_fixed_layout_size_set(webview, sd->layout.w, sd->layout.h);
1265
1266           _update_min_zoom_rate(webview);
1267      }
1268
1269    sd->ewk_view_user_scalable_set(webview, sd->zoom.scalable);
1270 }
1271
1272 static void
1273 _smart_cb_view_created(void* data, Evas_Object* webview, void* arg)
1274 {
1275    printf("%s is called\n", __func__);
1276    Smart_Data* sd = (Smart_Data *)data;
1277    if (!sd) return;
1278    *((Evas_Object**)arg) = webview;
1279 }
1280
1281 static void
1282 _smart_add(Evas_Object* obj)
1283 {
1284    DBG("%s\n", __func__);
1285    Smart_Data* sd;
1286
1287    sd = calloc(1, sizeof(Smart_Data));
1288    if (!sd) return;
1289    evas_object_smart_data_set(obj, sd);
1290    _parent_sc.sc.add(obj);
1291
1292    sd->resize_calc_job = NULL;
1293    sd->move_calc_job = NULL;
1294    sd->thumbnail = NULL;
1295    sd->minimap.eo = NULL;
1296    sd->dropdown.options = NULL;
1297    sd->dropdown.option_cnt = 0;
1298    sd->use_text_selection = EINA_FALSE;
1299    sd->text_selection_on = EINA_FALSE;
1300    sd->events_feed = EINA_FALSE;
1301    sd->touch_obj = _elm_smart_touch_add(evas_object_evas_get(obj));
1302    sd->layout.default_w = DEFAULT_LAYOUT_WIDTH;
1303
1304    sd->ewk_view_theme_set = (void (*)(Evas_Object *, const char *))dlsym(ewk_handle, "ewk_view_theme_set");
1305    sd->ewk_view_theme_set(obj, WEBKIT_EDJ);
1306
1307    // set geolocation callback
1308    sd->ewk_set_show_geolocation_permission_dialog_callback = (void (*)(ewk_show_geolocation_permission_dialog_callback))dlsym(ewk_handle, "ewk_set_show_geolocation_permission_dialog_callback");
1309    sd->ewk_set_show_geolocation_permission_dialog_callback(_geolocation_permission_callback);
1310
1311    sd->ewk_view_zoom_text_only_set = (Eina_Bool (*)(Evas_Object *, Eina_Bool))dlsym(ewk_handle, "ewk_view_zoom_text_only_set");
1312    sd->ewk_view_zoom_text_only_set(obj, EINA_FALSE);
1313    sd->ewk_view_zoom_cairo_scaling_set = (Eina_Bool (*)(Evas_Object *, Eina_Bool))dlsym(ewk_handle, "ewk_view_zoom_cairo_scaling_set");
1314    sd->ewk_view_zoom_cairo_scaling_set(obj, EINA_TRUE);
1315    sd->flush_and_pre_render_idler = NULL;
1316    sd->use_zoom_bouncing = EINA_TRUE;
1317
1318 #ifdef NEED_TO_REMOVE
1319    // TODO: temporary add the mouse callbacks until the webkit engine can receive mouse events
1320    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_DOWN, _view_on_mouse_down, sd);
1321    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_UP, _view_on_mouse_up, sd);
1322 #endif
1323
1324    evas_object_smart_callback_add(obj, "load,started", _smart_load_started, sd);
1325    evas_object_smart_callback_add(obj, "load,finished", _smart_load_finished, sd);
1326    evas_object_smart_callback_add(obj, "load,error", _smart_load_error, sd);
1327    evas_object_smart_callback_add(obj, "viewport,changed", _smart_viewport_changed, sd);
1328    evas_object_smart_callback_add(obj, "inputmethod,changed", _smart_input_method_changed, sd);
1329
1330    evas_object_smart_callback_add(obj, "webview,created", _smart_cb_view_created, sd); // I need to consider more
1331
1332    if (!(sd->ewk_view_frame_main_get))
1333      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
1334    evas_object_smart_callback_add(sd->ewk_view_frame_main_get(obj), "contents,size,changed",
1335          _smart_contents_size_changed, sd);
1336    evas_object_smart_callback_add(sd->ewk_view_frame_main_get(obj), "load,nonemptylayout,finished",
1337          _smart_load_nonemptylayout_finished, sd);
1338
1339    evas_object_smart_callback_add(obj, "one,press", _smart_cb_mouse_down, sd);
1340    evas_object_smart_callback_add(obj, "one,release", _smart_cb_mouse_up, sd);
1341    evas_object_smart_callback_add(obj, "one,single,tap", _smart_cb_mouse_tap, sd);
1342    evas_object_smart_callback_add(obj, "one,long,press", _smart_cb_select_closest_word, sd);
1343    evas_object_smart_callback_add(obj, "one,double,tap", _smart_cb_smart_zoom, sd);
1344    evas_object_smart_callback_add(obj, "one,move,start", _smart_cb_pan_start, sd);
1345    evas_object_smart_callback_add(obj, "one,move", _smart_cb_pan_by, sd);
1346    evas_object_smart_callback_add(obj, "one,move,end", _smart_cb_pan_stop, sd);
1347    evas_object_smart_callback_add(obj, "two,move,start", _smart_cb_pinch_zoom_start, sd);
1348    evas_object_smart_callback_add(obj, "two,move", _smart_cb_pinch_zoom_move, sd);
1349    evas_object_smart_callback_add(obj, "two,move,end", _smart_cb_pinch_zoom_stop, sd);
1350
1351    evas_object_size_hint_weight_set(obj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1352    evas_object_size_hint_align_set(obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
1353
1354    _elm_smart_touch_child_set(sd->touch_obj, obj);
1355    _text_selection_init(obj);
1356 }
1357
1358 static void
1359 _smart_del(Evas_Object* obj)
1360 {
1361    DBG("%s\n", __func__);
1362    INTERNAL_ENTRY;
1363
1364    if (sd->minimap.eo != NULL)
1365      {
1366         evas_object_del(sd->minimap.eo);
1367         sd->minimap.eo = NULL;
1368      }
1369
1370    if (sd->minimap.content != NULL)
1371      {
1372         evas_object_del(sd->minimap.content);
1373         sd->minimap.content = NULL;
1374      }
1375
1376    _parent_sc.sc.del(obj);
1377
1378    if (--ewk_tile_cache_ref_count == 0)
1379      ewk_tile_cache = NULL;
1380 }
1381
1382 static void
1383 _directional_pre_render(Evas_Object* obj, int dx, int dy)
1384 {
1385    INTERNAL_ENTRY;
1386
1387    if (!sd->ewk_view_frame_main_get)
1388      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
1389    if (!sd->ewk_frame_visible_content_geometry_get)
1390      sd->ewk_frame_visible_content_geometry_get = (Eina_Bool (*)(const Evas_Object *, Eina_Bool, int *, int *, int *, int *))dlsym(ewk_handle, "ewk_frame_visible_content_geometry_get");
1391    int x, y, w, h;
1392    sd->ewk_frame_visible_content_geometry_get(sd->ewk_view_frame_main_get(obj), false, &x, &y, &w, &h);
1393    DBG("visible content: (%d, %d, %d, %d)", x, y, w, h);
1394
1395    typedef enum { up, down, left, right, up_left, up_right, down_left, down_right, undefined } Directions;
1396    Directions direction = undefined;
1397
1398 #ifdef USE_MAX_TUC_20MB
1399    if (!sd->ewk_view_zoom_get)
1400      sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
1401    float zoom = sd->ewk_view_zoom_get(obj);
1402 #endif
1403
1404    if (dx == 0 && dy <  0) direction = down;
1405    if (dx >  0 && dy <  0) direction = down_left;
1406    if (dx >  0 && dy == 0) direction = left;
1407    if (dx >  0 && dy >  0) direction = up_left;
1408    if (dx == 0 && dy >  0) direction = up;
1409    if (dx <  0 && dy >  0) direction = up_right;
1410    if (dx <  0 && dy == 0) direction = right;
1411    if (dx <  0 && dy <  0) direction = down_right;
1412
1413 #ifdef USE_MAX_TUC_20MB
1414    const float DIRECTION_PLAIN_CX = 2.0/zoom;
1415    const float DIRECTION_CROSS_CX = 1.0/zoom;
1416    const float DIRECTION_UNDEFINED_CX_LEVEL_1 = 0.5/zoom;
1417    const float DIRECTION_UNDEFINED_CX_LEVEL_2 = 0.8/zoom;
1418 #else
1419    const float DIRECTION_PLAIN_CX = 1.5;
1420    const float DIRECTION_CROSS_CX = 0.7;
1421    const float DIRECTION_UNDEFINED_CX_LEVEL_1 = 0.3;
1422    const float DIRECTION_UNDEFINED_CX_LEVEL_2 = 0.6;
1423    const float DIRECTION_UNDEFINED_CX_LEVEL_3 = 0.8;
1424 #endif
1425
1426    int p_x = x, p_y = y, p_w = w, p_h = h;
1427
1428    switch (direction) {
1429       case up:
1430          DBG("Direction: up");
1431          p_y = y - h * DIRECTION_PLAIN_CX;
1432          p_h = h * DIRECTION_PLAIN_CX;
1433          break;
1434       case up_right:
1435          DBG("Direction: up_right");
1436          p_w = w + w * DIRECTION_CROSS_CX;
1437          p_y = y - h * DIRECTION_CROSS_CX;
1438          p_h = h + h * DIRECTION_CROSS_CX;
1439          break;
1440       case right:
1441          DBG("Direction: right");
1442          p_x = x + w;
1443          p_w = w * DIRECTION_PLAIN_CX;
1444          break;
1445       case down_right:
1446          DBG("Direction: down_right");
1447          p_w = w + w * DIRECTION_CROSS_CX;
1448          p_h = h + h * DIRECTION_CROSS_CX;
1449          break;
1450       case down:
1451          DBG("Direction: down");
1452          p_y = y + h;
1453          p_h = h * DIRECTION_PLAIN_CX;
1454          break;
1455       case down_left:
1456          DBG("Direction: down_left");
1457          p_x = x - w * DIRECTION_CROSS_CX;
1458          p_w = w + w * DIRECTION_CROSS_CX;
1459          p_h = h + h * DIRECTION_CROSS_CX;
1460          break;
1461       case left:
1462          DBG("Direction: left");
1463          p_x = x - w * DIRECTION_PLAIN_CX;
1464          p_w = w * DIRECTION_PLAIN_CX;
1465          break;
1466       case up_left:
1467          DBG("Direction: left_up");
1468          p_x = x - w * DIRECTION_CROSS_CX;
1469          p_w = w + w * DIRECTION_CROSS_CX;
1470          p_y = y - h * DIRECTION_CROSS_CX;
1471          p_h = h + h * DIRECTION_CROSS_CX;
1472          break;
1473       case undefined:
1474          DBG("Direction: undefined");
1475          break;
1476       default:
1477          DBG("Shouldn't happen!!");
1478    }
1479
1480 #ifndef USE_MAX_TUC_20MB
1481    if (!sd->ewk_view_zoom_get)
1482      sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
1483    float zoom = sd->ewk_view_zoom_get(obj);
1484 #endif
1485
1486    // cancel the previously scheduled pre-rendering
1487    // This makes sense especilaly for zooming operation - when user
1488    // finishes zooming, and pre-render for the previous zoom was
1489    // not finished, it doesn't make sense to continue pre-rendering for the previous zoom
1490    if (!sd->ewk_view_pre_render_cancel)
1491      sd->ewk_view_pre_render_cancel = (void (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_pre_render_cancel");
1492    sd->ewk_view_pre_render_cancel(obj);
1493
1494    if (!sd->ewk_view_pre_render_region)
1495      sd->ewk_view_pre_render_region = (Eina_Bool (*)(Evas_Object *, Evas_Coord, Evas_Coord, Evas_Coord, Evas_Coord, float))dlsym(ewk_handle, "ewk_view_pre_render_region");
1496
1497    if (direction != undefined)
1498      {
1499         /* Queue tiles in the direction of the last panning */
1500         DBG("pre rendering - directional - content: (%d, %d, %d, %d), zoom %.3f",p_x, p_y, p_w, p_h, zoom);
1501
1502         sd->ewk_view_pre_render_region(obj, p_x, p_y, p_w, p_h, zoom);
1503         //dbg_draw_scaled_area(obj, 0, p_x, p_y, p_w, p_h);
1504      }
1505    else
1506      {
1507         DBG("pre rendering - directional - skipped");
1508         //dbg_draw_scaled_area(obj, 0, 0, 0, 0, 0);
1509      }
1510
1511 #ifdef USE_MAX_TUC_20MB
1512    int content_w=0, content_h=0;
1513    int center_x=0,center_y=0;
1514    int tmp_h=0;
1515
1516    if (!sd->ewk_frame_contents_size_get)
1517      sd->ewk_frame_contents_size_get = (Eina_Bool (*)(const Evas_Object *, Evas_Coord *, Evas_Coord *))dlsym(ewk_handle, "ewk_frame_contents_size_get");
1518    sd->ewk_frame_contents_size_get(sd->ewk_view_frame_main_get(obj), &content_w, &content_h);
1519
1520    p_w = content_w;
1521    p_h = content_h;
1522
1523    size_t size = (size_t)roundf(p_w * zoom * p_h * zoom * 4);
1524    Eina_Bool  toggle = EINA_FALSE;
1525
1526    while(size > (MAX_TUC*0.8))
1527      {
1528         if(toggle)
1529           {
1530              p_h = p_h -32;
1531           }
1532         else
1533           {
1534              p_w = p_w - 32;
1535              if(p_w < w)
1536                {
1537                   p_w = w;
1538                   toggle = EINA_TRUE;
1539                }
1540           }
1541         size = (size_t)roundf(p_w * zoom * p_h * zoom * 4);
1542      }
1543
1544    center_x = (int)roundf(x + w/2);
1545    center_y = (int)roundf(y + h/2);
1546
1547    tmp_h = p_h* DIRECTION_UNDEFINED_CX_LEVEL_1;
1548    p_x = center_x - (int)roundf(p_w/2);
1549    p_y = center_y - (int)roundf(tmp_h/2);
1550    if(p_x < 0) p_x = 0;
1551    if(p_y < 0) p_y = 0;
1552    sd->ewk_view_pre_render_region(obj, p_x, p_y, p_w, tmp_h, zoom);
1553
1554    tmp_h = p_h* DIRECTION_UNDEFINED_CX_LEVEL_2;
1555    p_x = center_x - (int)roundf(p_w/2);
1556    p_y = center_y - (int)roundf(tmp_h/2);
1557    if(p_x < 0) p_x = 0;
1558    if(p_y < 0) p_y = 0;
1559    sd->ewk_view_pre_render_region(obj, p_x, p_y, p_w, tmp_h, zoom);
1560
1561    p_x = center_x - (int)roundf(p_w/2);
1562    p_y = center_y - (int)roundf(p_h/2);
1563    if(p_x < 0) p_x = 0;
1564    if(p_y < 0) p_y = 0;
1565    sd->ewk_view_pre_render_region(obj, p_x, p_y, p_w, p_h, zoom);
1566 #else
1567    /* Queue tiles in a small rectangle around the viewport */
1568    p_x = x - w * DIRECTION_UNDEFINED_CX_LEVEL_1;
1569    p_y = y - h * DIRECTION_UNDEFINED_CX_LEVEL_1;
1570    p_w = w + 2.0 * w * DIRECTION_UNDEFINED_CX_LEVEL_1;
1571    p_h = h + 2.0 * h * DIRECTION_UNDEFINED_CX_LEVEL_1;
1572    DBG("pre rendering - small - content: (%d, %d, %d, %d), zoom %.3f", p_x, p_y, p_w, p_h, zoom);
1573    sd->ewk_view_pre_render_region(obj, p_x, p_y, p_w, p_h, zoom);
1574    //dbg_draw_scaled_area(obj, 1, p_x, p_y, p_w, p_h);
1575
1576    /* Queue tiles in a medium rectangle around the viewport */
1577    p_x = x - w * DIRECTION_UNDEFINED_CX_LEVEL_2;
1578    p_y = y - h * DIRECTION_UNDEFINED_CX_LEVEL_2;
1579    p_w = w + 2.0 * w * DIRECTION_UNDEFINED_CX_LEVEL_2;
1580    p_h = h + 2.0 * h * DIRECTION_UNDEFINED_CX_LEVEL_2;
1581    DBG("pre rendering - medium - content: (%d, %d, %d, %d), zoom %.3f", p_x, p_y, p_w, p_h, zoom);
1582    sd->ewk_view_pre_render_region(obj, p_x, p_y, p_w, p_h, zoom);
1583    //dbg_draw_scaled_area(obj, 2, p_x, p_y, p_w, p_h);
1584
1585    /* Queue tiles in a large rectangle around the viewport */
1586    p_x = x - w * DIRECTION_UNDEFINED_CX_LEVEL_3;
1587    p_y = y - h * DIRECTION_UNDEFINED_CX_LEVEL_3;
1588    p_w = w + 2.0 * w * DIRECTION_UNDEFINED_CX_LEVEL_3;
1589    p_h = h + 2.0 * h * DIRECTION_UNDEFINED_CX_LEVEL_3;
1590    DBG("pre rendering - large - content: (%d, %d, %d, %d), zoom %.3f", p_x, p_y, p_w, p_h, zoom);
1591    sd->ewk_view_pre_render_region(obj, p_x, p_y, p_w, p_h, zoom);
1592    //dbg_draw_scaled_area(obj, 3, p_x, p_y, p_w, p_h);
1593 #endif
1594
1595    /* Log some statistics */
1596    /*
1597       int v_w, v_h;
1598       evas_object_geometry_get(obj, NULL, NULL, &v_w, &v_h);
1599       Ewk_Tile_Unused_Cache *tuc = ewk_view_tiled_unused_cache_get(obj);
1600       size_t used = ewk_tile_unused_cache_used_get(tuc);
1601       size_t max = ewk_tile_unused_cache_max_get(tuc);
1602    // Will this work for non cairo scaling?
1603    int est = (zoomRatio*p_w * zoomRatio*p_h - v_w * v_h) * 4; // 4 bytes per pixel
1604    DBG("pre rendering - Cache max = %.1fMB  Cache used = %.1fMB  Estimated size of pre-render area: %.1fMB\n",
1605    max/1024.0/1024.0, used/1024.0/1024.0, est/1024.0/1024.0);
1606    if (est > max)
1607    DBG("WARNING!! estimated size of pre-render are is larger than the cache size. This will result in inefficient use of cache!");
1608    */
1609 }
1610
1611 static void
1612 _smart_cb_mouse_down(void* data, Evas_Object* webview, void* ev)
1613 {
1614    DBG("%s\n", __func__);
1615    Smart_Data* sd = (Smart_Data *)data;
1616    if (!sd) return;
1617    if (sd->events_feed == EINA_TRUE) return;
1618    //Evas_Point* point = (Evas_Point*)ev;
1619
1620    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE) return;
1621
1622 #ifdef NEED_TO_REMOVE
1623    evas_object_focus_set(webview, EINA_TRUE);
1624    if (!sd->ewk_view_frame_main_get)
1625      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
1626    if (!sd->ewk_frame_feed_focus_in)
1627      sd->ewk_frame_feed_focus_in = (Eina_Bool (*)(Evas_Object *))dlsym(ewk_handle, "ewk_frame_feed_focus_in");
1628    sd->ewk_frame_feed_focus_in(sd->ewk_view_frame_main_get(webview));
1629 #endif
1630
1631    sd->mouse_clicked = EINA_TRUE;
1632    Evas_Event_Mouse_Down mouse_down = sd->mouse_down_copy;
1633    Evas_Point* point = (Evas_Point*)ev;
1634    mouse_down.canvas.x = point->x;
1635    mouse_down.canvas.y = point->y;
1636    _parent_sc.mouse_down((Ewk_View_Smart_Data*)sd, &mouse_down);
1637
1638 #if 0 // comment out below code until it is completed
1639    if (sd->bounce_horiz)
1640      elm_widget_drag_lock_x_set(sd->widget, EINA_TRUE);
1641    if (sd->bounce_vert)
1642      elm_widget_drag_lock_y_set(sd->widget, EINA_TRUE);
1643 #endif
1644 }
1645
1646 static void
1647 _smart_cb_mouse_up(void* data, Evas_Object* webview, void* ev)
1648 {
1649    DBG("%s\n", __func__);
1650    Smart_Data* sd = (Smart_Data *)data;
1651    if (!sd) return;
1652    if (sd->events_feed == EINA_TRUE) return;
1653    sd->on_flick = EINA_TRUE;
1654
1655    Evas_Point* point = (Evas_Point*)ev;
1656    DBG(" argument : (%d, %d)\n", point->x, point->y);
1657 }
1658
1659 static void
1660 _smart_cb_mouse_tap(void* data, Evas_Object* webview, void* ev)
1661 {
1662    DBG("%s\n", __func__);
1663    Smart_Data* sd = (Smart_Data *)data;
1664    if (!sd) return;
1665    if (sd->events_feed == EINA_TRUE) return;
1666
1667    Evas_Point* point = (Evas_Point*)ev;
1668    DBG(" argument : (%d, %d)\n", point->x, point->y);
1669
1670    // check for video link
1671    int ewk_x, ewk_y;
1672    _coords_evas_to_ewk(webview, point->x, point->y, &ewk_x, &ewk_y);
1673    Eina_Bool have_link = EINA_FALSE;
1674    Eina_Bool have_image = EINA_FALSE;
1675    char *link_url = NULL, *link_text = NULL, *image_url = NULL;
1676    if (!sd->ewk_page_check_point)
1677      sd->ewk_page_check_point = (Eina_Bool (*)(Evas_Object *, int, int, Evas_Event_Mouse_Down *, Eina_Bool *, Eina_Bool *, char **, char **, char **))dlsym(ewk_handle, "ewk_page_check_point");
1678    sd->ewk_page_check_point(webview, ewk_x, ewk_y, &sd->mouse_down_copy,
1679          &have_link, &have_image, &link_url, &link_text, &image_url);
1680    if (link_url) free(link_url);
1681    if (link_text) free(link_text);
1682    if (image_url) free(image_url);
1683
1684    //TODO: below code is not based on open source (need to check and refactor)
1685    int x = 0, y = 0;
1686    _unzoom_position(webview, point->x, point->y, &x, &y);
1687
1688    // check for input field
1689    if (!sd->ewk_page_check_point_for_keyboard)
1690      sd->ewk_page_check_point_for_keyboard = (char * (*)(Evas_Object *, int, int, Eina_Bool *))dlsym(ewk_handle, "ewk_page_check_point_for_keyboard");
1691    if (!sd->ewk_page_dropdown_get_options)
1692      sd->ewk_page_dropdown_get_options = (char ** (*)(Evas_Object *, int, int, int *, int *))dlsym(ewk_handle, "ewk_page_dropdown_get_options");
1693
1694    Eina_Bool have_input_field;
1695    sd->ewk_page_check_point_for_keyboard(webview, x, y, &have_input_field);
1696    if (have_input_field == EINA_TRUE)
1697      {
1698         _zoom_to_rect(sd, point->x, point->y);
1699
1700         // check whether it is radio
1701      }
1702    else if (NULL != (sd->dropdown.options = sd->ewk_page_dropdown_get_options(webview, x, y,
1703                &sd->dropdown.option_cnt, &sd->dropdown.option_idx)))
1704      {
1705         Evas* evas;
1706         evas = evas_object_evas_get(webview);
1707
1708         // TODO: we have to show list instead of discpicker
1709         /* below code is deprecated
1710         Evas_Object* discpicker = elm_discpicker_add(webview);
1711         if (discpicker)
1712           {
1713              // set items
1714              int i;
1715              Elm_Discpicker_Item* item;
1716              for (i = 0; i < sd->dropdown.option_cnt; i++)
1717                {
1718                   item = elm_discpicker_item_append(discpicker, sd->dropdown.options[i], NULL, NULL);
1719                   if (i == sd->dropdown.option_idx)
1720                     {
1721                        elm_discpicker_item_selected_set(item);
1722                     }
1723                }
1724
1725              // selected callback
1726              void discpicker_selected_cb(void* data, Evas_Object* obj, void* event_info)
1727                {
1728                   Smart_Data* sd = (Smart_Data *)data;
1729                   if (!sd) return;
1730                   Evas_Object* webview = sd->base.self;
1731
1732                   int x = 0, y = 0;
1733                   Evas_Point* point = &sd->mouse_up_copy.output;
1734                   _unzoom_position(webview, point->x, point->y, &x, &y);
1735
1736                   Elm_Discpicker_Item* item = event_info;
1737                   const char *selected_label = elm_discpicker_item_label_get(item);
1738                   int selected_index;
1739                   for (selected_index = 0; selected_index < sd->dropdown.option_cnt; selected_index++)
1740                     {
1741                        if (!strcmp(selected_label, sd->dropdown.options[selected_index]))
1742                          {
1743                             break;
1744                          }
1745                     }
1746                   printf("<< selected [%d | %s] >>\n", selected_index, selected_label);
1747                   if (!sd->ewk_page_dropdown_set_current_index)
1748                     sd->ewk_page_dropdown_set_current_index = (Eina_Bool (*)(Evas_Object *, int, int, int))dlsym(ewk_handle, "ewk_page_dropdown_set_current_index");
1749                   sd->ewk_page_dropdown_set_current_index(webview, x, y, selected_index);
1750                   //evas_object_del(obj);
1751                }
1752
1753              // show discpicker
1754              evas_object_smart_callback_add(discpicker, "selected", discpicker_selected_cb, sd);
1755              elm_discpicker_row_height_set(discpicker, 80);
1756              evas_object_resize(discpicker, 480, 400);
1757              evas_object_move(discpicker, 0, 400);
1758              evas_object_show(discpicker);
1759           }
1760           */
1761      }
1762
1763    if (sd->use_text_selection  == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
1764      {
1765         _smart_cb_unselect_closest_word(sd, webview, NULL);
1766         return;
1767      }
1768
1769    Evas_Event_Mouse_Up mouse_up = sd->mouse_up_copy;
1770    mouse_up.canvas.x = point->x;
1771    mouse_up.canvas.y = point->y;
1772    _parent_sc.mouse_up((Ewk_View_Smart_Data*)sd, &mouse_up);
1773    sd->mouse_clicked = EINA_FALSE;
1774 }
1775
1776 static void
1777 _smart_cb_pan_start(void* data, Evas_Object* webview, void* ev)
1778 {
1779    DBG("%s\n", __func__);
1780    Smart_Data* sd = (Smart_Data *)data;
1781    if (!sd) return;
1782    Evas_Point* point = (Evas_Point*)ev;
1783
1784    if (sd->events_feed == EINA_TRUE) return;
1785
1786    sd->pan_s = *point;
1787    sd->on_panning = EINA_TRUE;
1788    sd->on_flick = EINA_FALSE;
1789
1790    if (sd->use_text_selection  == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
1791      {
1792         if (_text_selection_handle_pressed(sd, point->x, point->y))
1793           _elm_smart_touch_is_one_drag_mode_enable(sd->touch_obj, EINA_FALSE);
1794      }
1795
1796    _suspend_all(sd, EINA_FALSE);
1797
1798    sd->locked_dx = 0;
1799    sd->locked_dy = 0;
1800 }
1801
1802 static void
1803 _smart_cb_pan_by(void* data, Evas_Object* webview, void* ev)
1804 {
1805    //DBG("%s\n", __func__);
1806    Smart_Data* sd = (Smart_Data *)data;
1807    if (!sd) return;
1808    Evas_Point* point = (Evas_Point*)ev;
1809
1810    if (sd->events_feed == EINA_TRUE)
1811      {
1812         Evas* evas = evas_object_evas_get(webview);
1813         Evas_Modifier *modifiers = (Evas_Modifier *)evas_key_modifier_get(evas);
1814         Evas_Lock *locks = (Evas_Lock *)evas_key_lock_get(evas);
1815
1816         Evas_Event_Mouse_Move event_move;
1817         event_move.buttons = 1;
1818         event_move.cur.output.x = point->x;
1819         event_move.cur.output.y = point->y;
1820         event_move.cur.canvas.x = point->x;
1821         event_move.cur.canvas.y = point->y;
1822         event_move.data = NULL;
1823         event_move.modifiers = modifiers;
1824         event_move.locks = locks;
1825         event_move.timestamp = ecore_loop_time_get();
1826         event_move.event_flags = EVAS_EVENT_FLAG_NONE;
1827         event_move.dev = NULL;
1828
1829         _parent_sc.mouse_move((Ewk_View_Smart_Data*)sd, &event_move);
1830         return;
1831      }
1832    if (sd->on_panning == EINA_FALSE) return;
1833
1834    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
1835      {
1836         if (sd->text_selection.front_handle_moving == EINA_TRUE
1837               || sd->text_selection.back_handle_moving == EINA_TRUE)
1838           {
1839              _text_selection_update_position(sd, point->x, point->y);
1840              return;
1841           }
1842      }
1843
1844    if (!sd->ewk_frame_scroll_pos_get)
1845      sd->ewk_frame_scroll_pos_get = (Eina_Bool (*)(const Evas_Object *, int *, int *))dlsym(ewk_handle, "ewk_frame_scroll_pos_get");
1846
1847    int dx = sd->pan_s.x - point->x;
1848    int dy = sd->pan_s.y - point->y;
1849
1850    if (!sd->ewk_view_frame_main_get)
1851      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
1852
1853    int old_x, old_y;
1854    sd->ewk_frame_scroll_pos_get(sd->ewk_view_frame_main_get(webview), &old_x, &old_y);
1855
1856    if (!sd->ewk_frame_contents_size_get)
1857      sd->ewk_frame_contents_size_get = (Eina_Bool (*)(const Evas_Object *, Evas_Coord *, Evas_Coord *))dlsym(ewk_handle, "ewk_frame_contents_size_get");
1858
1859    int content_w, content_h;
1860    sd->ewk_frame_contents_size_get(sd->ewk_view_frame_main_get(webview), &content_w, &content_h);
1861    if (!sd->ewk_view_zoom_get)
1862      sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
1863    float zoom = sd->ewk_view_zoom_get(webview);
1864    content_w *= zoom;
1865    content_h *= zoom;
1866    DBG("<< ========content [%d, %d] new pos [%d, %d] >>\n", content_w, content_h, old_x + dx, old_y + dy);
1867
1868 #if 0 // comment out below code until it is completed
1869    Eina_Bool locked = EINA_FALSE;
1870    if (!elm_widget_drag_lock_x_get(sd->widget))
1871      {
1872         if ((old_x + dx) >= 0 && (old_x + dx) <=content_w)
1873           elm_widget_drag_lock_x_set(sd->widget, EINA_TRUE);
1874         else if ((sd->locked_dx > 0 && (sd->locked_dx + dx) <= 0)
1875               || (sd->locked_dx < 0 && (sd->locked_dx + dx) >= 0))
1876           {
1877              elm_widget_drag_lock_x_set(sd->widget, EINA_TRUE);
1878              DBG("===============<< widget x lock >>\n");
1879              dx += sd->locked_dx;
1880           }
1881         else
1882           {
1883              sd->locked_dx += dx;
1884              locked = EINA_TRUE;
1885           }
1886      }
1887    if (!elm_widget_drag_lock_y_get(sd->widget))
1888      {
1889         if ((old_y + dy) >= 0 && (old_y + dy) <= content_h)
1890           elm_widget_drag_lock_y_set(sd->widget, EINA_TRUE);
1891         else if ((sd->locked_dy > 0 && (sd->locked_dy + dy) <= 0)
1892               || (sd->locked_dy < 0 && (sd->locked_dy + dy) >= 0))
1893           {
1894              elm_widget_drag_lock_y_set(sd->widget, EINA_TRUE);
1895              DBG("===============<< widget y lock >>\n");
1896              dy += sd->locked_dy;
1897           }
1898         else
1899           {
1900              sd->locked_dy += dy;
1901              locked = EINA_TRUE;
1902           }
1903      }
1904
1905    if (locked) return;
1906 #endif
1907
1908 #ifdef BOUNCING_SUPPORT
1909    printf(":::::::: %s\n", __func__);
1910    _elm_smart_webview_container_scroll_adjust(sd->container, &dx, &dy);
1911    if (dx == 0 && dy == 0)
1912      {
1913         sd->pan_s = *point;
1914         _elm_smart_webview_container_bounce_add(sd->container, 0, 0);
1915         if (sd->on_flick)
1916           _elm_smart_touch_reset(sd->touch_obj);
1917         return;
1918      }
1919 #endif
1920
1921    if (!sd->ewk_view_frame_main_get)
1922      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
1923    if (!sd->ewk_frame_scroll_add)
1924      sd->ewk_frame_scroll_add = (Eina_Bool (*)(Evas_Object *, int, int))dlsym(ewk_handle, "ewk_frame_scroll_add");
1925    sd->ewk_frame_scroll_add(sd->ewk_view_frame_main_get(webview), dx, dy);
1926
1927    _minimap_update(sd->minimap.content, sd, sd->thumbnail,
1928          sd->minimap.cw, sd->minimap.ch);
1929    sd->pan_s = *point;
1930
1931    int new_x, new_y;
1932    sd->ewk_frame_scroll_pos_get(sd->ewk_view_frame_main_get(webview), &new_x, &new_y);
1933
1934    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
1935      _text_selection_move_by(sd, old_x - new_x, old_y - new_y);
1936
1937 #ifdef BOUNCING_SUPPORT
1938    int bx, by;
1939    bx = old_x + dx - new_x;
1940    by = old_y + dy - new_y;
1941    if (sd->on_flick && (bx != 0 || by != 0))
1942      {
1943         _elm_smart_webview_container_decelerated_flick_get(sd->container, &bx, &by);
1944      }
1945    _elm_smart_webview_container_bounce_add(sd->container, bx, by);
1946 #endif
1947
1948 #if 0 // comment out below code until it is completed
1949    if (!sd->bounce_horiz &&
1950          (dx && elm_widget_drag_lock_x_get(sd->widget) && (old_x == new_x)))
1951      {
1952         sd->locked_dx = dx - (old_x - new_x);
1953         elm_widget_drag_lock_x_set(sd->widget, EINA_FALSE);
1954         DBG("===============<< widget x unlock >>\n");
1955      }
1956
1957    if (!sd->bounce_vert &&
1958          (dy && elm_widget_drag_lock_y_get(sd->widget) && (old_y == new_y)))
1959      {
1960         sd->locked_dy = dy - (old_y - new_y);
1961         elm_widget_drag_lock_y_set(sd->widget, EINA_FALSE);
1962         DBG("===============<< widget y unlock >>\n");
1963      }
1964 #endif
1965 }
1966
1967 static void
1968 _smart_cb_pan_stop(void* data, Evas_Object* webview, void* ev)
1969 {
1970    DBG("%s\n", __func__);
1971    Smart_Data* sd = (Smart_Data *)data;
1972    if (!sd) return;
1973    if (sd->events_feed == EINA_TRUE) return;
1974
1975    Evas_Point* point = (Evas_Point*)ev;
1976    sd->on_panning = EINA_FALSE;
1977
1978    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
1979      {
1980         if (sd->text_selection.front_handle_moving == EINA_TRUE
1981               || sd->text_selection.back_handle_moving == EINA_TRUE)
1982           _elm_smart_touch_is_one_drag_mode_enable(sd->touch_obj, EINA_TRUE);
1983         sd->text_selection.front_handle_moving = EINA_FALSE;
1984         sd->text_selection.back_handle_moving = EINA_FALSE;
1985      }
1986
1987    _resume_all(sd, EINA_FALSE);
1988
1989    if (sd->tiled)
1990      {
1991         if (!sd->ewk_view_tiled_unused_cache_get)
1992           sd->ewk_view_tiled_unused_cache_get = (Ewk_Tile_Unused_Cache *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_tiled_unused_cache_get");
1993         if (!sd->ewk_tile_unused_cache_used_get)
1994           sd->ewk_tile_unused_cache_used_get = (size_t (*)(const Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_used_get");
1995         if (!sd->ewk_tile_unused_cache_max_get)
1996           sd->ewk_tile_unused_cache_max_get = (size_t (*)(const Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_max_get");
1997         Ewk_Tile_Unused_Cache *tuc = sd->ewk_view_tiled_unused_cache_get(webview);
1998         size_t used = sd->ewk_tile_unused_cache_used_get(tuc);
1999         size_t max = sd->ewk_tile_unused_cache_max_get(tuc);
2000         DBG("[%s] max = %d  used = %d \n", __func__, max, used);
2001         if (used > max)
2002           {
2003              if (!sd->ewk_tile_unused_cache_auto_flush)
2004                sd->ewk_tile_unused_cache_auto_flush = (void (*)(Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_auto_flush");
2005              sd->ewk_tile_unused_cache_auto_flush(tuc);
2006           }
2007         _directional_pre_render(webview,
2008               (sd->mouse_down_copy.canvas.x - point->x), (sd->mouse_down_copy.canvas.y - point->y));
2009      }
2010 #ifdef BOUNCING_SUPPORT
2011    _elm_smart_webview_container_mouse_up(sd->container);
2012 #endif
2013
2014 #if 0 // comment out below code until it is completed
2015    if (!sd->bounce_horiz && elm_widget_drag_lock_x_get(sd->widget))
2016      {
2017         DBG("==============<< widget x unlock >>\n");
2018         elm_widget_drag_lock_x_set(sd->widget, EINA_FALSE);
2019      }
2020
2021    if (!sd->bounce_vert && elm_widget_drag_lock_y_get(sd->widget))
2022      {
2023         DBG("==============<< widget y unlock >>\n");
2024         elm_widget_drag_lock_y_set(sd->widget, EINA_FALSE);
2025      }
2026 #endif
2027 }
2028
2029 static void
2030 _smart_cb_select_closest_word(void* data, Evas_Object* webview, void* ev)
2031 {
2032    DBG("%s\n", __func__);
2033    Smart_Data* sd = (Smart_Data *)data;
2034    if (!sd) return;
2035    if (sd->events_feed == EINA_TRUE) return;
2036
2037    Evas_Point* point = (Evas_Point*)ev;
2038
2039    if (sd->use_text_selection == EINA_FALSE) return;
2040
2041    int x, y;
2042    _coords_evas_to_ewk(webview, point->x, point->y, &x, &y);
2043
2044    if (!sd->ewk_view_frame_main_get)
2045      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
2046    if (!sd->ewk_frame_select_closest_word)
2047      sd->ewk_frame_select_closest_word = (Eina_Bool (*)(Evas_Object *, int, int, int *, int *, int *, int *, int *, int *))dlsym(ewk_handle, "ewk_frame_select_closest_word");
2048    int tx, ty, th, bx, by, bh;
2049    Eina_Bool ret = sd->ewk_frame_select_closest_word(sd->ewk_view_frame_main_get(webview), x, y,
2050          &tx, &ty, &th, &bx, &by, &bh);
2051    if (ret)
2052      {
2053         _coords_ewk_to_evas(webview, tx, ty, &tx, &ty);
2054         _coords_ewk_to_evas(webview, bx, by, &bx, &by);
2055         _text_selection_show();
2056         _text_selection_set_front_info(sd, tx, ty, th);
2057         _text_selection_set_back_info(sd, bx, by, bh);
2058         sd->text_selection_on = EINA_TRUE;
2059      }
2060 }
2061
2062 static void
2063 _smart_cb_unselect_closest_word(void* data, Evas_Object* webview, void* ev)
2064 {
2065    DBG("%s\n", __func__);
2066    Smart_Data* sd = (Smart_Data *)data;
2067    if (!sd) return;
2068
2069    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
2070      {
2071         _text_selection_hide(sd);
2072         if (!sd->ewk_view_select_none)
2073           sd->ewk_view_select_none = (Eina_Bool (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_select_none");
2074         sd->ewk_view_select_none(webview);
2075         sd->text_selection_on = EINA_FALSE;
2076      }
2077 }
2078
2079 // zoom
2080 static const int ZOOM_STEP_TRESHOLD = 20;
2081 static const float ZOOM_STEP_PER_PIXEL = 0.005f;
2082
2083 #define ZOOM_FRAMERATE 60
2084 #define N_COSINE 18
2085 static const float cosine[N_COSINE] =
2086 { 1.0f, 0.99f, 0.96f, 0.93f, 0.88f, 0.82f, 0.75f, 0.67f, 0.59f, 0.5f,
2087    0.41f, 0.33f, 0.25f, 0.18f, 0.12f, 0.07f, 0.01f, 0.0f };
2088 static int smart_zoom_index = N_COSINE - 1;
2089
2090 #define INPUT_LOCATION_X 20
2091 #define INPUT_LOCATION_Y 50
2092 #define INPUT_ZOOM_RATIO 2.5
2093
2094 static void
2095 _suspend_all(Smart_Data *sd, Eina_Bool hidePlugin)
2096 {
2097    Evas_Object *webview = sd->base.self;
2098
2099    // javascript suspend
2100    if (!sd->ewk_view_javascript_suspend)
2101      sd->ewk_view_javascript_suspend = (void (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_javascript_suspend");
2102    sd->ewk_view_javascript_suspend(webview);
2103
2104    // render suspend
2105    if (!sd->ewk_view_disable_render)
2106      sd->ewk_view_disable_render = (Eina_Bool (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_disable_render");
2107    sd->ewk_view_disable_render(webview);
2108
2109    // plugin suspend
2110    if (!sd->ewk_view_setting_enable_plugins_get)
2111      sd->ewk_view_setting_enable_plugins_get = (Eina_Bool (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_setting_enable_plugins_get");
2112    if (sd->ewk_view_setting_enable_plugins_get(webview))
2113      {
2114         if (!sd->ewk_view_pause_and_or_hide_plugins)
2115           sd->ewk_view_pause_and_or_hide_plugins = (void (*)(Evas_Object *, Eina_Bool, Eina_Bool))dlsym(ewk_handle, "ewk_view_pause_and_or_hide_plugins");
2116         sd->ewk_view_pause_and_or_hide_plugins(webview, EINA_FALSE, hidePlugin);
2117      }
2118
2119    // cancel pre-render
2120    if (sd->tiled)
2121      {
2122         if (!sd->ewk_view_pre_render_cancel)
2123           sd->ewk_view_pre_render_cancel = (void (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_pre_render_cancel");
2124         sd->ewk_view_pre_render_cancel(webview);
2125      }
2126
2127    // network suspend
2128    if (!sd->ewk_view_suspend_request)
2129      sd->ewk_view_suspend_request = (Eina_Bool (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_suspend_request");
2130    sd->ewk_view_suspend_request(webview); // suspend network loading
2131
2132 }
2133
2134 static void
2135 _resume_all(Smart_Data *sd, Eina_Bool hidePlugin)
2136 {
2137    Evas_Object *webview = sd->base.self;
2138
2139    // js resume
2140    if (!sd->ewk_view_javascript_resume)
2141      sd->ewk_view_javascript_resume = (void (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_javascript_resume");
2142    sd->ewk_view_javascript_resume(webview);
2143
2144    // render resume
2145    if (sd->tiled)
2146      {
2147         if (!sd->ewk_view_enable_render)
2148           sd->ewk_view_enable_render = (Eina_Bool (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_enable_render");
2149         sd->ewk_view_enable_render(webview);
2150      }
2151
2152    // plugin resume
2153    if (!sd->ewk_view_pause_and_or_hide_plugins)
2154      sd->ewk_view_pause_and_or_hide_plugins = (void (*)(Evas_Object *, Eina_Bool, Eina_Bool))dlsym(ewk_handle, "ewk_view_pause_and_or_hide_plugins");
2155    sd->ewk_view_pause_and_or_hide_plugins(webview, EINA_FALSE, hidePlugin);
2156
2157    // network resume
2158    if (!sd->ewk_view_resume_request)
2159      sd->ewk_view_resume_request = (Eina_Bool (*)(Evas_Object *))dlsym(ewk_handle, "ewk_view_resume_request");
2160    sd->ewk_view_resume_request(webview);
2161 }
2162
2163 static void
2164 _zoom_start(Smart_Data* sd, int centerX, int centerY, int distance)
2165 {
2166    DBG("%s\n", __func__);
2167    sd->zoom.basis.x = centerX;
2168    sd->zoom.basis.y = centerY;
2169    sd->zoom.finger_distance = distance;
2170    sd->zoom.zooming_level = 0;
2171    sd->on_zooming = EINA_TRUE;
2172    if (!sd->ewk_view_zoom_get)
2173      sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
2174    sd->zoom.zoom_rate_at_start = sd->ewk_view_zoom_get(sd->base.self);
2175    sd->zoom.zooming_rate = sd->zoom.zoom_rate_at_start;
2176
2177    _suspend_all(sd, EINA_TRUE);
2178
2179    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
2180      _text_selection_hide(sd);
2181 }
2182
2183 static void
2184 _zoom_move(Smart_Data* sd, int centerX, int centerY, int distance)
2185 {
2186    if (sd->on_zooming == EINA_FALSE) return;
2187    //DBG("%s\n", __func__);
2188
2189    int zoom_distance = distance - sd->zoom.finger_distance;
2190
2191    if (zoom_distance != sd->zoom.zooming_level)
2192      {
2193         float zoom_ratio;
2194
2195         if (sd->use_zoom_bouncing)
2196           {
2197              float min_zoom_rate = sd->zoom.min_zoom_rate * ZOOM_OUT_BOUNCING;
2198              if (min_zoom_rate <= 0) min_zoom_rate = MIN_ZOOM_RATIO;
2199              float max_zoom_rate = sd->zoom.max_zoom_rate * ZOOM_IN_BOUNCING;
2200
2201              if (sd->zoom.zooming_rate < sd->zoom.min_zoom_rate)
2202                {
2203                   float step = (sd->zoom.min_zoom_rate - min_zoom_rate) / (float)BOUNCING_DISTANCE;
2204                   zoom_ratio = sd->zoom.zooming_rate + (zoom_distance - sd->zoom.zooming_level) * step;
2205                }
2206              else if (sd->zoom.zooming_rate > sd->zoom.max_zoom_rate)
2207                {
2208                   float step = (max_zoom_rate - sd->zoom.max_zoom_rate) / (float)BOUNCING_DISTANCE;
2209                   zoom_ratio = sd->zoom.zooming_rate + (zoom_distance - sd->zoom.zooming_level) * step;
2210                }
2211              else
2212                {
2213                   zoom_ratio = sd->zoom.zoom_rate_at_start + zoom_distance * ZOOM_STEP_PER_PIXEL;
2214                }
2215
2216              if (zoom_ratio < min_zoom_rate)
2217                zoom_ratio = min_zoom_rate;
2218              if (zoom_ratio > max_zoom_rate)
2219                zoom_ratio = max_zoom_rate;
2220           }
2221         else
2222           {
2223              zoom_ratio = sd->zoom.zoom_rate_at_start + zoom_distance * ZOOM_STEP_PER_PIXEL;
2224              if (zoom_ratio < sd->zoom.min_zoom_rate)
2225                zoom_ratio = sd->zoom.min_zoom_rate;
2226              if (zoom_ratio > sd->zoom.max_zoom_rate)
2227                zoom_ratio = sd->zoom.max_zoom_rate;
2228           }
2229         sd->zoom.zooming_level = zoom_distance;
2230         sd->zoom.zooming_rate = zoom_ratio;
2231
2232         //printf("new zoom : %f, (%d, %d)\n", zoom_ratio, centerX, centerY);
2233         if (!sd->ewk_view_zoom_weak_set)
2234           sd->ewk_view_zoom_weak_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_weak_set");
2235         sd->ewk_view_zoom_weak_set(sd->base.self, zoom_ratio, sd->zoom.basis.x, sd->zoom.basis.y);
2236         DBG("<< zoom weak set [%f] >>\n", zoom_ratio);
2237      }
2238 }
2239
2240 static void
2241 _zoom_stop(Smart_Data* sd)
2242 {
2243    sd->on_zooming = EINA_FALSE;
2244    DBG("%s ( %d )\n", __func__, sd->zoom.zooming_level);
2245    if (sd->zoom.zooming_level == 0) return;
2246
2247    sd->zoom.zoom_rate_to_set = sd->zoom.zooming_rate;
2248    if (sd->zoom.zoom_rate_to_set < sd->zoom.min_zoom_rate)
2249      sd->zoom.zoom_rate_to_set = sd->zoom.min_zoom_rate;
2250    if (sd->zoom.zoom_rate_to_set > sd->zoom.max_zoom_rate)
2251      sd->zoom.zoom_rate_to_set = sd->zoom.max_zoom_rate;
2252    if (sd->use_zoom_bouncing
2253          && (sd->zoom.zoom_rate_to_set != sd->zoom.zooming_rate))
2254      {
2255         sd->zoom.zoom_rate_at_start = sd->zoom.zooming_rate;
2256         smart_zoom_index = N_COSINE - 1;
2257         ecore_animator_frametime_set(1.0 / ZOOM_FRAMERATE);
2258         sd->smart_zoom_animator = ecore_animator_add(_smart_zoom_animator, sd);
2259      }
2260    else
2261      {
2262         if (!sd->ewk_view_zoom_set)
2263           sd->ewk_view_zoom_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_set");
2264         sd->ewk_view_zoom_set(sd->base.self, sd->zoom.zoom_rate_to_set, sd->zoom.basis.x, sd->zoom.basis.y);
2265      }
2266    DBG("<< zoom set [%f] >>\n", sd->zoom.zooming_rate);
2267
2268    _resume_all(sd, EINA_FALSE);
2269
2270    if (sd->tiled)
2271      {
2272         if (!sd->ewk_view_tiled_unused_cache_get)
2273           sd->ewk_view_tiled_unused_cache_get = (Ewk_Tile_Unused_Cache *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_tiled_unused_cache_get");
2274         Ewk_Tile_Unused_Cache* ewk_tile_cache = sd->ewk_view_tiled_unused_cache_get(sd->base.self);
2275         if (!sd->ewk_tile_unused_cache_auto_flush)
2276           sd->ewk_tile_unused_cache_auto_flush = (void (*)(Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_auto_flush");
2277         sd->ewk_tile_unused_cache_auto_flush(ewk_tile_cache);
2278         _directional_pre_render(sd->base.self, 0, 0);
2279      }
2280
2281    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
2282      {
2283         if (!sd->ewk_view_frame_main_get)
2284           sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
2285         if (!sd->ewk_frame_selection_handlers_get)
2286           sd->ewk_frame_selection_handlers_get = (Eina_Bool (*)(Evas_Object *, int *, int *, int *, int *, int *, int *))dlsym(ewk_handle, "ewk_frame_selection_handlers_get");
2287         int tx, ty, th, bx, by, bh;
2288         sd->ewk_frame_selection_handlers_get(sd->ewk_view_frame_main_get(sd->base.self), &tx, &ty, &th, &bx, &by, &bh);
2289         _coords_ewk_to_evas(sd->base.self, tx, ty, &tx, &ty);
2290         _coords_ewk_to_evas(sd->base.self, bx, by, &bx, &by);
2291         _text_selection_show();
2292         _text_selection_set_front_info(sd, tx, ty, th);
2293         _text_selection_set_back_info(sd, bx, by, bh);
2294      }
2295 }
2296
2297 static void
2298 _adjust_to_contents_boundary(Evas_Object* obj, int* to_x, int* to_y,
2299       int from_x, int from_y, float new_zoom_rate)
2300 {
2301    INTERNAL_ENTRY;
2302    // get view's geometry
2303    int view_x, view_y, view_w, view_h;
2304    evas_object_geometry_get(obj, &view_x, &view_y, &view_w, &view_h);
2305
2306    // get contentsSize
2307    if (!sd->ewk_view_frame_main_get)
2308      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
2309    if (!sd->ewk_frame_contents_size_get)
2310      sd->ewk_frame_contents_size_get = (Eina_Bool (*)(const Evas_Object *, Evas_Coord *, Evas_Coord *))dlsym(ewk_handle, "ewk_frame_contents_size_get");
2311
2312    int contents_w, contents_h;
2313    sd->ewk_frame_contents_size_get(sd->ewk_view_frame_main_get(obj), &contents_w, &contents_h);
2314    if (!sd->ewk_view_zoom_get)
2315      sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
2316    float current_zoom_rate = sd->ewk_view_zoom_get(obj);
2317    if (!sd->ewk_view_zoom_cairo_scaling_get)
2318      sd->ewk_view_zoom_cairo_scaling_get = (Eina_Bool (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_cairo_scaling_get");
2319    if (sd->ewk_view_zoom_cairo_scaling_get(obj))
2320      {
2321         contents_w *= current_zoom_rate;
2322         contents_h *= current_zoom_rate;
2323      }
2324
2325    // check boundary - should not exceed the left, right, top and bottom of contents after zoom
2326    float zoom_step = new_zoom_rate / current_zoom_rate;
2327    int ewk_from_x, ewk_from_y;
2328    _coords_evas_to_ewk(obj, from_x, from_y, &ewk_from_x, &ewk_from_y);
2329    int contents_left = ewk_from_x * zoom_step; // left contents size of from
2330    int contents_right = contents_w * zoom_step - contents_left; // right contents size of from
2331    int screen_left = (*to_x) - view_x;
2332    int screen_right = view_w - screen_left;
2333    if (contents_left < screen_left)
2334      (*to_x) -= (screen_left - contents_left);
2335    else if (contents_right < screen_right)
2336      (*to_x) += (screen_right - contents_right);
2337    int contents_top = ewk_from_y * zoom_step; // top contents size of from
2338    int contents_bottom = contents_h * zoom_step - contents_top; // bottom contents size of from
2339    int screen_top = (*to_y) - view_y;
2340    int screen_bottom = view_h - screen_top;
2341    if (contents_top < screen_top)
2342      (*to_y) -= (screen_top - contents_top);
2343    else if (contents_bottom < screen_bottom)
2344      (*to_y) += (screen_bottom - contents_bottom);
2345 }
2346
2347 static int
2348 _smart_zoom_animator(void* data)
2349 {
2350    Smart_Data* sd = (Smart_Data*)data;
2351
2352    if (!sd->ewk_view_frame_main_get)
2353      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
2354
2355    // stop
2356    if (smart_zoom_index < 0)
2357      {
2358         if (!sd->ewk_view_zoom_set)
2359           sd->ewk_view_zoom_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_set");
2360         sd->ewk_view_zoom_set(sd->base.self, sd->zoom.zoom_rate_to_set,
2361               sd->zoom.basis.x, sd->zoom.basis.y);
2362         if (sd->smart_zoom_animator)
2363           {
2364              ecore_animator_del(sd->smart_zoom_animator);
2365              sd->smart_zoom_animator = NULL;
2366           }
2367
2368         _elm_smart_touch_start(sd->touch_obj);
2369
2370         _resume_all(sd, EINA_FALSE);
2371
2372         if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
2373           {
2374              if (!sd->ewk_frame_selection_handlers_get)
2375                sd->ewk_frame_selection_handlers_get = (Eina_Bool (*)(Evas_Object *, int *, int *, int *, int *, int *, int *))dlsym(ewk_handle, "ewk_frame_selection_handlers_get");
2376              int tx, ty, th, bx, by, bh;
2377              sd->ewk_frame_selection_handlers_get(sd->ewk_view_frame_main_get(sd->base.self),
2378                    &tx, &ty, &th, &bx, &by, &bh);
2379              _coords_ewk_to_evas(sd->base.self, tx, ty, &tx, &ty);
2380              _coords_ewk_to_evas(sd->base.self, bx, by, &bx, &by);
2381              _text_selection_show();
2382              _text_selection_set_front_info(sd, tx, ty, th);
2383              _text_selection_set_back_info(sd, bx, by, bh);
2384           }
2385
2386         return ECORE_CALLBACK_CANCEL;
2387      }
2388
2389    if (sd->zoom.zoom_rate_at_start != sd->zoom.zoom_rate_to_set)
2390      {
2391         // weak zoom
2392         float zoom_rate = sd->zoom.zoom_rate_at_start
2393            + ((sd->zoom.zoom_rate_to_set - sd->zoom.zoom_rate_at_start) * cosine[smart_zoom_index]);
2394         if (!sd->ewk_view_zoom_weak_set)
2395           sd->ewk_view_zoom_weak_set = (Eina_Bool (*)(Evas_Object *, float, Evas_Coord, Evas_Coord))dlsym(ewk_handle, "ewk_view_zoom_weak_set");
2396         if (zoom_rate <= sd->zoom.min_zoom_rate)
2397           {
2398              if (!sd->ewk_frame_scroll_pos_get)
2399                sd->ewk_frame_scroll_pos_get = (Eina_Bool (*)(const Evas_Object *, int *, int *))dlsym(ewk_handle, "ewk_frame_scroll_pos_get");
2400              if (!sd->ewk_view_zoom_get)
2401                sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
2402              int scroll_x, scroll_y;
2403              sd->ewk_frame_scroll_pos_get(sd->ewk_view_frame_main_get(sd->base.self), &scroll_x, &scroll_y);
2404              float current_zoom_rate = sd->ewk_view_zoom_get(sd->base.self);
2405              int center_x = (scroll_x * sd->zoom.zoom_rate_to_set * current_zoom_rate)
2406                             / (current_zoom_rate - sd->zoom.zoom_rate_to_set);
2407              int center_y = (scroll_y * sd->zoom.zoom_rate_to_set * current_zoom_rate)
2408                             / (current_zoom_rate - sd->zoom.zoom_rate_to_set);
2409
2410              int basis_x = sd->zoom.basis.x + (center_x - sd->zoom.basis.x) * cosine[smart_zoom_index];
2411              int basis_y = sd->zoom.basis.y + (center_y - sd->zoom.basis.y) * cosine[smart_zoom_index];
2412              sd->ewk_view_zoom_weak_set(sd->base.self, zoom_rate, basis_x, basis_y);
2413              smart_zoom_index--; // in order to make zoom bouncing more faster
2414           }
2415         if (zoom_rate >= sd->zoom.max_zoom_rate)
2416           {
2417              sd->ewk_view_zoom_weak_set(sd->base.self, zoom_rate, sd->zoom.basis.x, sd->zoom.basis.y);
2418              smart_zoom_index--; // in order to make zoom bouncing more faster
2419           }
2420         else
2421           {
2422              sd->ewk_view_zoom_weak_set(sd->base.self, zoom_rate, sd->zoom.basis.x, sd->zoom.basis.y);
2423           }
2424      } else {
2425           if (!sd->ewk_frame_scroll_pos_get)
2426             sd->ewk_frame_scroll_pos_get = (Eina_Bool (*)(const Evas_Object *, int *, int *))dlsym(ewk_handle, "ewk_frame_scroll_pos_get");
2427           // save old scroll positions
2428           int current_scroll_x, current_scroll_y;
2429           sd->ewk_frame_scroll_pos_get(sd->ewk_view_frame_main_get(sd->base.self), &current_scroll_x, &current_scroll_y);
2430
2431           // get to set position
2432           int to_set_x = sd->zoom.scroll_at_start.x
2433              + (sd->zoom.scroll_to_set.x - sd->zoom.scroll_at_start.x) * cosine[smart_zoom_index];
2434           int to_set_y = sd->zoom.scroll_at_start.y
2435              + (sd->zoom.scroll_to_set.y - sd->zoom.scroll_at_start.y) * cosine[smart_zoom_index];
2436
2437           if (!sd->ewk_frame_scroll_add)
2438             sd->ewk_frame_scroll_add = (Eina_Bool (*)(Evas_Object *, int, int))dlsym(ewk_handle, "ewk_frame_scroll_add");
2439           // scroll
2440           sd->ewk_frame_scroll_add(sd->ewk_view_frame_main_get(sd->base.self),
2441                 to_set_x - current_scroll_x, to_set_y - current_scroll_y);
2442      }
2443    smart_zoom_index--;
2444
2445    return ECORE_CALLBACK_RENEW;
2446 }
2447
2448 static void
2449 _smart_cb_pinch_zoom_start(void* data, Evas_Object* webview, void* event_info)
2450 {
2451    //DBG("%s\n", __func__);
2452    Smart_Data *sd = (Smart_Data *)data;
2453    if (!sd) return;
2454
2455    Evas_Point* arr = (Evas_Point*) event_info;
2456    int centerX = (arr[0].x + arr[1].x) / 2;
2457    int centerY = (arr[0].y + arr[1].y) / 2;
2458    int dx = arr[0].x - arr[1].x;
2459    int dy = arr[0].y - arr[1].y;
2460    int distance = sqrt((double)(dx * dx + dy * dy));
2461    _zoom_start(sd, centerX, centerY, distance);
2462 }
2463
2464 static void
2465 _smart_cb_pinch_zoom_move(void* data, Evas_Object* webview, void* event_info)
2466 {
2467    //DBG("%s\n", __func__);
2468    Smart_Data *sd = (Smart_Data *)data;
2469    if (!sd) return;
2470
2471    Evas_Point* arr = (Evas_Point*) event_info;
2472    int centerX = (arr[0].x + arr[1].x) / 2;
2473    int centerY = (arr[0].y + arr[1].y) / 2;
2474    int dx = arr[0].x - arr[1].x;
2475    int dy = arr[0].y - arr[1].y;
2476    int distance = sqrt((double)(dx * dx + dy * dy));
2477    _zoom_move(sd, centerX, centerY, distance);
2478 }
2479
2480 static void
2481 _smart_cb_pinch_zoom_stop(void* data, Evas_Object* webview, void* event_info)
2482 {
2483    //DBG("%s\n", __func__);
2484    Smart_Data *sd = (Smart_Data *)data;
2485    if (!sd) return;
2486
2487    _zoom_stop(sd);
2488    _minimap_update(sd->minimap.content, sd, sd->thumbnail, sd->minimap.cw, sd->minimap.ch);
2489
2490    if (sd->tiled)
2491      {
2492         if (!sd->ewk_view_tiled_unused_cache_get)
2493           sd->ewk_view_tiled_unused_cache_get = (Ewk_Tile_Unused_Cache *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_tiled_unused_cache_get");
2494         Ewk_Tile_Unused_Cache *tuc = sd->ewk_view_tiled_unused_cache_get(webview);
2495         if (!sd->ewk_tile_unused_cache_used_get)
2496           sd->ewk_tile_unused_cache_used_get = (size_t (*)(const Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_used_get");
2497         size_t used = sd->ewk_tile_unused_cache_used_get(tuc);
2498         if (!sd->ewk_tile_unused_cache_max_get)
2499           sd->ewk_tile_unused_cache_max_get = (size_t (*)(const Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_max_get");
2500         size_t max = sd->ewk_tile_unused_cache_max_get(tuc);
2501         DBG("[%s] max = %d  used = %d \n", __func__, max, used);
2502         if (used > max)
2503           {
2504              if (!sd->ewk_tile_unused_cache_auto_flush)
2505                sd->ewk_tile_unused_cache_auto_flush = (void (*)(Ewk_Tile_Unused_Cache *))dlsym(ewk_handle, "ewk_tile_unused_cache_auto_flush");
2506              sd->ewk_tile_unused_cache_auto_flush(tuc);
2507           }
2508      }
2509 }
2510
2511 static void
2512 _smart_cb_vertical_zoom_start(void* data, Evas_Object* webview, void* event_info)
2513 {
2514    DBG("%s\n", __func__);
2515    Smart_Data *sd = (Smart_Data *)data;
2516    if (!sd) return;
2517
2518    Evas_Point* arr = (Evas_Point*) event_info;
2519    int centerX = (arr[0].x + arr[1].x) / 2;
2520    int centerY = (arr[0].y + arr[1].y) / 2;
2521    //int dx = arr[0].x - arr[1].x;
2522    //int dy = arr[0].y - arr[1].y;
2523    //int distance = sqrt((double)(dx * dx + dy * dy));
2524    _zoom_start(sd, centerX, centerY, centerY);
2525 }
2526
2527 static void
2528 _smart_cb_vertical_zoom_move(void* data, Evas_Object* webview, void* event_info)
2529 {
2530    DBG("%s\n", __func__);
2531    Smart_Data *sd = (Smart_Data *)data;
2532    if (!sd) return;
2533
2534    Evas_Point* arr = (Evas_Point*) event_info;
2535    int centerX = (arr[0].x + arr[1].x) / 2;
2536    int centerY = (arr[0].y + arr[1].y) / 2;
2537    //int dx = arr[0].x - arr[1].x;
2538    //int dy = arr[0].y - arr[1].y;
2539    //int distance = centerY - sd->zoom.cy;
2540    _zoom_move(sd, centerX, centerY, centerY);
2541 }
2542
2543 static void
2544 _smart_cb_vertical_zoom_stop(void* data, Evas_Object* webview, void* event_info)
2545 {
2546    DBG("%s\n", __func__);
2547    Smart_Data *sd = (Smart_Data *)data;
2548    if (!sd) return;
2549
2550    _zoom_stop(sd);
2551    _minimap_update(sd->minimap.content, sd, sd->thumbnail, sd->minimap.cw, sd->minimap.ch);
2552 }
2553
2554 static void
2555 _smart_cb_smart_zoom(void* data, Evas_Object* webview, void* event_info)
2556 {
2557    DBG("%s\n", __func__);
2558    Smart_Data *sd = (Smart_Data *)data;
2559    if (!sd) return;
2560    Evas_Point* point = (Evas_Point*)event_info;
2561
2562    if (sd->events_feed == EINA_TRUE) return;
2563
2564    if (!sd->ewk_view_frame_main_get)
2565      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
2566
2567    _elm_smart_touch_stop(sd->touch_obj);
2568
2569    // get rect
2570    int ewk_x = 0, ewk_y = 0;
2571    Eina_Rectangle rect;
2572    _coords_evas_to_ewk(webview, point->x, point->y, &ewk_x, &ewk_y);
2573    if (!sd->ewk_view_get_smart_zoom_rect)
2574      sd->ewk_view_get_smart_zoom_rect = (Eina_Bool (*)(Evas_Object *, int, int, const Evas_Event_Mouse_Up *, Eina_Rectangle *))dlsym(ewk_handle, "ewk_view_get_smart_zoom_rect");
2575    sd->ewk_view_get_smart_zoom_rect(webview, ewk_x, ewk_y, &sd->mouse_up_copy, &rect);
2576
2577    // calculate zoom_rate and center of rect
2578    int view_x, view_y, view_w, view_h;
2579    evas_object_geometry_get(webview, &view_x, &view_y, &view_w, &view_h);
2580    if (!sd->ewk_view_zoom_get)
2581      sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
2582    float current_zoom_rate = sd->ewk_view_zoom_get(webview);
2583    float zoom_rate;
2584    int rect_center_x, rect_center_y;
2585    if (rect.w)
2586      {
2587         zoom_rate = current_zoom_rate * (float)view_w / (float)rect.w;
2588         _coords_ewk_to_evas(webview, rect.x + (rect.w >> 1), rect.y + (rect.h >> 1), &rect_center_x, &rect_center_y);
2589         if ((rect.h / current_zoom_rate) * zoom_rate > view_h)
2590           {
2591              rect_center_y = point->y;
2592           }
2593         // check zoom rate
2594         if (zoom_rate < sd->zoom.min_zoom_rate)
2595           zoom_rate = sd->zoom.min_zoom_rate;
2596         if (zoom_rate > sd->zoom.max_zoom_rate)
2597           zoom_rate = sd->zoom.max_zoom_rate;
2598         if (zoom_rate == current_zoom_rate)
2599           zoom_rate = sd->zoom.min_zoom_rate;
2600      } else {
2601           zoom_rate = sd->zoom.min_zoom_rate;
2602           rect_center_x = point->x;
2603           rect_center_y = point->y;
2604      }
2605
2606    // set zooming data
2607    float zoom_step = zoom_rate / current_zoom_rate;
2608    int center_x = view_x + (view_w >> 1);
2609    int center_y = view_y + (view_h >> 1);
2610
2611    _adjust_to_contents_boundary(webview, &center_x, &center_y, rect_center_x, rect_center_y, zoom_rate);
2612
2613    // set data for smart zoom
2614    sd->zoom.basis.x = (center_x - zoom_step * rect_center_x) / (1 - zoom_step);
2615    sd->zoom.basis.y = (center_y - zoom_step * rect_center_y) / (1 - zoom_step) - view_y;
2616    sd->zoom.zoom_rate_at_start = current_zoom_rate;
2617    sd->zoom.zoom_rate_to_set = zoom_rate;
2618    smart_zoom_index = N_COSINE - 1;
2619
2620    _suspend_all(sd, EINA_TRUE);
2621
2622    // run animator
2623    ecore_animator_frametime_set(1.0 / ZOOM_FRAMERATE);
2624    sd->smart_zoom_animator = ecore_animator_add(_smart_zoom_animator, sd);
2625
2626    // hide textSelection handlers during zooming
2627    if (sd->use_text_selection == EINA_TRUE && sd->text_selection_on == EINA_TRUE)
2628      _text_selection_hide(sd);
2629 }
2630
2631 static void
2632 _zoom_to_rect(Smart_Data *sd, int x, int y)
2633 {
2634    DBG("%s\n", __func__);
2635    Evas_Object *webview = sd->base.self;
2636
2637    if (!sd->ewk_view_frame_main_get)
2638      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
2639
2640    // performing a hit test
2641    _coords_evas_to_ewk(webview, x, y, &x, &y);
2642    if (!sd->ewk_frame_hit_test_new)
2643      sd->ewk_frame_hit_test_new = (Ewk_Hit_Test * (*)(const Evas_Object *, int, int))dlsym(ewk_handle, "ewk_frame_hit_test_new");
2644    Ewk_Hit_Test *hit_test = sd->ewk_frame_hit_test_new(sd->ewk_view_frame_main_get(webview), x, y);
2645
2646    // calculate zoom_rate and center of rect
2647    if (hit_test->bounding_box.w && hit_test->bounding_box.h)
2648      {
2649         // set zooming data
2650         float zoom_rate = INPUT_ZOOM_RATIO;
2651         if (!sd->ewk_view_zoom_get)
2652           sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
2653         float current_zoom_rate = sd->ewk_view_zoom_get(webview);
2654         float zoom_step = zoom_rate / current_zoom_rate;
2655
2656         // get position to move from
2657         int view_x, view_y, view_w, view_h;
2658         evas_object_geometry_get(webview, &view_x, &view_y, &view_w, &view_h);
2659         int from_x, from_y;
2660         _coords_ewk_to_evas(webview, hit_test->bounding_box.x, hit_test->bounding_box.y, &from_x, &from_y);
2661         from_x = from_x + ((view_w - INPUT_LOCATION_X) / 2) / zoom_step;
2662         from_y = from_y + hit_test->bounding_box.h / 2;
2663
2664         // get position to move to
2665         int to_x = view_x + INPUT_LOCATION_X + (view_w - INPUT_LOCATION_X) / 2;
2666         int to_y = view_y + INPUT_LOCATION_Y + (hit_test->bounding_box.h / 2) * zoom_step;
2667
2668         // adjust to contents
2669         _adjust_to_contents_boundary(webview, &to_x, &to_y, from_x, from_y, zoom_rate);
2670
2671         // set data for smart zoom
2672         sd->zoom.basis.x = (to_x - zoom_step * from_x) / (1 - zoom_step);
2673         sd->zoom.basis.y = (to_y - zoom_step * from_y) / (1 - zoom_step) - view_y;
2674         sd->zoom.zoom_rate_at_start = current_zoom_rate;
2675         sd->zoom.zoom_rate_to_set = zoom_rate;
2676         if (!sd->ewk_frame_scroll_pos_get)
2677           sd->ewk_frame_scroll_pos_get = (Eina_Bool (*)(const Evas_Object *, int *, int *))dlsym(ewk_handle, "ewk_frame_scroll_pos_get");
2678         sd->ewk_frame_scroll_pos_get(sd->ewk_view_frame_main_get(webview),
2679               &sd->zoom.scroll_at_start.x, &sd->zoom.scroll_at_start.y);
2680         sd->zoom.scroll_to_set.x = sd->zoom.scroll_at_start.x + (from_x - to_x);
2681         sd->zoom.scroll_to_set.y = sd->zoom.scroll_at_start.y + (from_y - to_y);
2682         smart_zoom_index = N_COSINE - 1;
2683
2684         _suspend_all(sd, EINA_TRUE);
2685
2686         // run animator
2687         ecore_animator_frametime_set(1.0 / ZOOM_FRAMERATE);
2688         sd->smart_zoom_animator = ecore_animator_add(_smart_zoom_animator, sd);
2689      }
2690
2691    if (!sd->ewk_frame_hit_test_free)
2692      sd->ewk_frame_hit_test_free = (void (*)(Ewk_Hit_Test *))dlsym(ewk_handle, "ewk_frame_hit_test_free");
2693    sd->ewk_frame_hit_test_free(hit_test);
2694 }
2695
2696 // text-selection
2697 #define BAR_WIDTH            4
2698 #define BAR_HEIGHT           10
2699 #define HANDLE_WIDTH         60
2700 #define HANDLE_HEIGHT        60
2701 #define HANDLE_PRESS_RANGE   50
2702 #define HANDLE_MIDDLE_LENGTH 60
2703
2704 static Evas_Object* front_bar_icon;
2705 static Evas_Object* front_handle_icon;
2706 static Evas_Object* back_bar_icon;
2707 static Evas_Object* back_handle_icon;
2708
2709 static Eina_Bool initialized = EINA_FALSE;
2710
2711 static void
2712 _text_selection_init(Evas_Object* parent)
2713 {
2714    DBG("<< %s >>\n", __FUNCTION__);
2715
2716    if (initialized)
2717      return;
2718
2719    // front bar
2720    front_bar_icon = (Evas_Object*)elm_icon_add(parent);
2721    elm_icon_standard_set(front_bar_icon, "webview/ts_bar");
2722    elm_icon_scale_set(front_bar_icon, true, true);
2723    evas_object_pass_events_set(front_bar_icon, true);
2724
2725    // front handle
2726    front_handle_icon = (Evas_Object*)elm_icon_add(parent);
2727    elm_icon_standard_set(front_handle_icon, "webview/ts_handle_front");
2728    elm_icon_scale_set(front_handle_icon, false, false);
2729    evas_object_pass_events_set(front_handle_icon, true);
2730
2731    // back bar
2732    back_bar_icon = (Evas_Object*)elm_icon_add(parent);
2733    elm_icon_standard_set(back_bar_icon, "webview/ts_bar");
2734    elm_icon_scale_set(back_bar_icon, true, true);
2735    evas_object_pass_events_set(back_bar_icon, true);
2736
2737    // back handle
2738    back_handle_icon = (Evas_Object*)elm_icon_add(parent);
2739    elm_icon_standard_set(back_handle_icon, "webview/ts_handle_back");
2740    elm_icon_scale_set(back_handle_icon, false, false);
2741    evas_object_pass_events_set(back_handle_icon, true);
2742
2743    initialized = EINA_TRUE;
2744 }
2745
2746 static void
2747 _text_selection_show(void)
2748 {
2749    evas_object_show(front_bar_icon);
2750    evas_object_show(front_handle_icon);
2751    evas_object_show(back_bar_icon);
2752    evas_object_show(back_handle_icon);
2753 }
2754
2755 static void
2756 _text_selection_hide(Smart_Data *sd)
2757 {
2758    evas_object_hide(front_bar_icon);
2759    evas_object_hide(front_handle_icon);
2760    evas_object_hide(back_bar_icon);
2761    evas_object_hide(back_handle_icon);
2762
2763    sd->text_selection.front.x = -1;
2764    sd->text_selection.front.y = -1;
2765    sd->text_selection.front.h = -1;
2766    sd->text_selection.front_handle.x = -1;
2767    sd->text_selection.front_handle.y = -1;
2768    sd->text_selection.back.x = -1;
2769    sd->text_selection.back.y = -1;
2770    sd->text_selection.back.h = -1;
2771    sd->text_selection.back_handle.x = -1;
2772    sd->text_selection.back_handle.y = -1;
2773 }
2774
2775 static void
2776 _text_selection_set_front_info(Smart_Data *sd, int x, int y, int height)
2777 {
2778    Evas_Object *webview = sd->base.self;
2779
2780    Evas_Coord_Rectangle* front = &(sd->text_selection.front);
2781    Evas_Point* front_handle = &(sd->text_selection.front_handle);
2782
2783    front->h = height;
2784    int front_bar_height = height + HANDLE_MIDDLE_LENGTH + HANDLE_HEIGHT;
2785
2786    // set size
2787    evas_object_resize(front_bar_icon, BAR_WIDTH, front_bar_height);
2788    evas_object_resize(front_handle_icon, HANDLE_WIDTH, HANDLE_HEIGHT);
2789
2790    // set location
2791    front_handle->x = x - (HANDLE_WIDTH / 2);
2792    int win_y, win_height, win_bottom;
2793    evas_object_geometry_get(webview, NULL, &win_y, NULL, &win_height);
2794    win_bottom = win_y + win_height;
2795    if ((front_handle->y == -1 && (y + front_bar_height > win_bottom))
2796          || ((front_handle->y < front->y) && (y + front->h - front_bar_height > win_y))
2797          || ((front_handle->y > front->y) && (y + front_bar_height > win_bottom)))
2798      { // upper handle
2799         front_handle->y = y + front->h - front_bar_height + (HANDLE_HEIGHT / 2);
2800         evas_object_move(front_bar_icon, x, y + front->h - front_bar_height);
2801         evas_object_move(front_handle_icon, x - HANDLE_WIDTH, y + front->h - front_bar_height);
2802
2803      }
2804    else
2805      { // lower handle
2806         front_handle->y = y + front_bar_height - (HANDLE_HEIGHT / 2);
2807         evas_object_move(front_bar_icon, x, y);
2808         evas_object_move(front_handle_icon, x - HANDLE_WIDTH, front_handle->y - (HANDLE_HEIGHT / 2));
2809      }
2810
2811    front->x = x;
2812    front->y = y;
2813 }
2814
2815 static void
2816 _text_selection_set_back_info(Smart_Data *sd, int x, int y, int height)
2817 {
2818    Evas_Object *webview = sd->base.self;
2819
2820    Evas_Coord_Rectangle* back = &(sd->text_selection.back);
2821    Evas_Point* back_handle = &(sd->text_selection.back_handle);
2822
2823    back->h = height;
2824    int back_bar_height = height + HANDLE_MIDDLE_LENGTH + HANDLE_HEIGHT;
2825
2826    // set size
2827    evas_object_resize(back_bar_icon, BAR_WIDTH, back_bar_height);
2828    evas_object_resize(back_handle_icon, HANDLE_WIDTH, HANDLE_HEIGHT);
2829
2830    // set location
2831    back_handle->x = x + (HANDLE_WIDTH / 2);
2832    int win_y, win_height, win_bottom;
2833    evas_object_geometry_get(webview, NULL, &win_y, NULL, &win_height);
2834    win_bottom = win_y + win_height;
2835    if ((back_handle->y == -1 && (y - back->h + back_bar_height > win_bottom))
2836          || ((back_handle->y < back->y) && (y - back_bar_height > win_y))
2837          || ((back_handle->y > back->y) && (y - back->h + back_bar_height > win_bottom))) { // upper handle
2838         back_handle->y = y - back->h - HANDLE_MIDDLE_LENGTH - (HANDLE_HEIGHT / 2);
2839         evas_object_move(back_bar_icon, x - BAR_WIDTH, y - back_bar_height);
2840         evas_object_move(back_handle_icon, x, back_handle->y - (HANDLE_HEIGHT / 2));
2841
2842    } else {
2843         back_handle->y = y + HANDLE_MIDDLE_LENGTH + (HANDLE_HEIGHT / 2);
2844         evas_object_move(back_bar_icon, x - BAR_WIDTH, y - back->h);
2845         evas_object_move(back_handle_icon, x, back_handle->y - (HANDLE_HEIGHT / 2));
2846    }
2847
2848    back->x = x;
2849    back->y = y;
2850 }
2851
2852 static Eina_Bool
2853 _text_selection_handle_pressed(Smart_Data *sd, int x, int y)
2854 {
2855    Evas_Point front_handle = sd->text_selection.front_handle;
2856    Evas_Point back_handle = sd->text_selection.back_handle;
2857
2858    // check front handle
2859    if (x > (front_handle.x - HANDLE_PRESS_RANGE) && x < (front_handle.x + HANDLE_PRESS_RANGE)
2860          && y > (front_handle.y - HANDLE_PRESS_RANGE) && y < (front_handle.y + HANDLE_PRESS_RANGE))
2861      sd->text_selection.front_handle_moving = EINA_TRUE;
2862
2863    // check back handle
2864    if (x > (back_handle.x - HANDLE_PRESS_RANGE) && x < (back_handle.x + HANDLE_PRESS_RANGE)
2865          && y > (back_handle.y - HANDLE_PRESS_RANGE) && y < (back_handle.y + HANDLE_PRESS_RANGE))
2866      {
2867         if (sd->text_selection.front_handle_moving == EINA_TRUE)
2868           {
2869              if (abs(x - front_handle.x) + abs(y - front_handle.y)
2870                    > abs(x - back_handle.x) + abs(y - back_handle.y))
2871                {
2872                   sd->text_selection.front_handle_moving = EINA_FALSE;
2873                   sd->text_selection.back_handle_moving = EINA_TRUE;
2874                }
2875           }
2876         else
2877           {
2878              sd->text_selection.back_handle_moving = EINA_TRUE;
2879           }
2880      }
2881
2882    return (sd->text_selection.front_handle_moving || sd->text_selection.back_handle_moving);
2883 }
2884
2885 static void
2886 _text_selection_update_position(Smart_Data *sd, int x, int y)
2887 {
2888    Evas_Object *webview = sd->base.self;
2889
2890    Evas_Coord_Rectangle* front = &(sd->text_selection.front);
2891    Evas_Coord_Rectangle* back = &(sd->text_selection.back);
2892
2893    if (!sd->ewk_view_frame_main_get)
2894      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
2895
2896    // set selected region with front handle
2897    if (sd->text_selection.front_handle_moving == EINA_TRUE)
2898      {
2899         x = x + (HANDLE_WIDTH >> 1);
2900         if (sd->text_selection.front_handle.y < sd->text_selection.front.y)
2901           y = y + (HANDLE_HEIGHT >> 1) + HANDLE_MIDDLE_LENGTH;
2902         else
2903           y = y - front->h - HANDLE_MIDDLE_LENGTH - (HANDLE_HEIGHT >> 1);
2904
2905         if (y > back->y)
2906           y = back->y - back->h / 2;
2907
2908         if (!sd->ewk_frame_selection_left_set)
2909           sd->ewk_frame_selection_left_set = (Eina_Bool (*)(Evas_Object *, int, int, int *, int *, int *))dlsym(ewk_handle, "ewk_frame_selection_left_set");
2910         int ewkX, ewkY;
2911         _coords_evas_to_ewk(webview, x, y, &ewkX, &ewkY);
2912         if (sd->ewk_frame_selection_left_set(sd->ewk_view_frame_main_get(webview), ewkX, ewkY,
2913                  &front->x, &front->y, &front->h)) {
2914              _coords_ewk_to_evas(webview, front->x, front->y, &front->x, &front->y);
2915              _text_selection_set_front_info(sd, front->x, front->y, front->h);
2916         }
2917
2918         // set selected region with back handle
2919      }
2920    else if (sd->text_selection.back_handle_moving)
2921      {
2922         x = x - (HANDLE_WIDTH >> 1);
2923         if (sd->text_selection.back_handle.y < sd->text_selection.back.y)
2924           y = y + (HANDLE_HEIGHT >> 1) + HANDLE_MIDDLE_LENGTH;
2925         else
2926           y = y - back->h - HANDLE_MIDDLE_LENGTH - (HANDLE_HEIGHT >> 1);
2927
2928         if (y < front->y)
2929           y = front->y + front->h / 2;
2930
2931         if (!sd->ewk_frame_selection_right_set)
2932           sd->ewk_frame_selection_right_set = (Eina_Bool (*)(Evas_Object *, int, int, int *, int *, int *))dlsym(ewk_handle, "ewk_frame_selection_right_set");
2933         int ewkX, ewkY;
2934         _coords_evas_to_ewk(webview, x, y, &ewkX, &ewkY);
2935         if (sd->ewk_frame_selection_right_set(sd->ewk_view_frame_main_get(webview), ewkX, ewkY,
2936                  &back->x, &back->y, &back->h)) {
2937              _coords_ewk_to_evas(webview, back->x, back->y, &back->x, &back->y);
2938              _text_selection_set_back_info(sd, back->x, back->y, back->h);
2939         }
2940      }
2941 }
2942
2943 static void
2944 _text_selection_move_by(Smart_Data *sd, int dx, int dy)
2945 {
2946    _text_selection_set_front_info(sd, sd->text_selection.front.x + dx,
2947          sd->text_selection.front.y + dy,
2948          sd->text_selection.front.h);
2949    _text_selection_set_back_info(sd, sd->text_selection.back.x + dx,
2950          sd->text_selection.back.y + dy,
2951          sd->text_selection.back.h);
2952 }
2953 // minimap
2954 static void
2955 _minimap_update_detail(Evas_Object* minimap, Smart_Data *sd, cairo_surface_t* src, int srcW, int srcH, Eina_Rectangle* visibleRect)
2956 {
2957    void* pixels;
2958    cairo_t* cr;
2959    cairo_surface_t* dest;
2960    cairo_status_t status;
2961
2962    if (!sd->cairo_surface_status)
2963      sd->cairo_surface_status = (cairo_status_t (*)(cairo_surface_t *))dlsym(cairo_handle, "cairo_surface_status");
2964    if (!sd->cairo_image_surface_create_for_data)
2965      sd->cairo_image_surface_create_for_data = (cairo_surface_t * (*)(unsigned char *, cairo_format_t, int, int, int))dlsym(cairo_handle, "cairo_image_surface_create_for_data");
2966
2967    //TODO: check which one is faster
2968    //      1) reuse minimap
2969    //      2) recreate evas_object and set pixel
2970    evas_object_image_size_set(minimap, srcW, srcH);
2971    evas_object_image_fill_set(minimap, 0, 0, srcW, srcH);
2972    evas_object_resize(minimap, srcW, srcH);
2973
2974    pixels = evas_object_image_data_get(minimap, 1);
2975    dest = sd->cairo_image_surface_create_for_data(
2976          (unsigned char*)pixels, CAIRO_FORMAT_RGB24, srcW, srcH, srcW * 4);
2977    status = sd->cairo_surface_status(dest);
2978    if (status != CAIRO_STATUS_SUCCESS)
2979      {
2980         printf("[%s] fail to create cairo surface\n", __func__);
2981         goto error_cairo_surface;
2982      }
2983
2984    if (!sd->cairo_create)
2985      sd->cairo_create = (cairo_t * (*)(cairo_surface_t *))dlsym(cairo_handle, "cairo_create");
2986    cr = sd->cairo_create(dest);
2987    status = sd->cairo_surface_status(dest);
2988    if (status != CAIRO_STATUS_SUCCESS)
2989      {
2990         printf("[%s] fail to create cairo\n", __func__);
2991         goto error_cairo;
2992      }
2993
2994    if (!sd->cairo_set_source_surface)
2995      sd->cairo_set_source_surface = (void (*)(cairo_t *, cairo_surface_t *, double, double))dlsym(cairo_handle, "cairo_set_source_surface");
2996    if (!sd->cairo_paint)
2997      sd->cairo_paint = (void (*)(cairo_t *))dlsym(cairo_handle, "cairo_paint");
2998    if (!sd->cairo_set_source_rgb)
2999      sd->cairo_set_source_rgb = (void (*)(cairo_t *, double, double, double))dlsym(cairo_handle, "cairo_set_source_rgb");
3000    if (!sd->cairo_rectangle)
3001      sd->cairo_rectangle = (void (*)(cairo_t *, double, double, double, double))dlsym(cairo_handle, "cairo_rectangle");
3002    if (!sd->cairo_set_line_width)
3003      sd->cairo_set_line_width = (void (*)(cairo_t *, double))dlsym(cairo_handle, "cairo_set_line_width");
3004    if (!sd->cairo_stroke)
3005      sd->cairo_stroke = (void (*)(cairo_t *cr))dlsym(cairo_handle, "cairo_stroke");
3006    if (!sd->cairo_set_antialias)
3007      sd->cairo_set_antialias = (void (*)(cairo_t *, cairo_antialias_t))dlsym(cairo_handle, "cairo_set_antialias");
3008
3009    sd->cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
3010    sd->cairo_set_source_surface(cr, src, 0, 0);
3011    sd->cairo_paint(cr);
3012    sd->cairo_set_source_rgb(cr, 0, 0, 255);
3013    sd->cairo_set_line_width(cr, 1);
3014    sd->cairo_rectangle(cr,
3015          visibleRect->x, visibleRect->y, visibleRect->w, visibleRect->h);
3016    sd->cairo_stroke(cr);
3017
3018    if (!sd->cairo_destroy)
3019      sd->cairo_destroy = (void (*)(cairo_t *))dlsym(cairo_handle, "cairo_destroy");
3020    sd->cairo_destroy(cr);
3021
3022 error_cairo:
3023    if (!sd->cairo_surface_destroy)
3024      sd->cairo_surface_destroy = (void (*)(cairo_surface_t *))dlsym(cairo_handle, "cairo_surface_destroy");
3025    sd->cairo_surface_destroy(dest);
3026 error_cairo_surface:
3027    evas_object_image_data_set(minimap, pixels);
3028    return;
3029 }
3030
3031 static void
3032 _minimap_update(Evas_Object* minimap, Smart_Data *sd, cairo_surface_t* src, int minimapW, int minimapH)
3033 {
3034    if (minimap == NULL || src == NULL) return;
3035    Evas_Object *webview = sd->base.self;
3036
3037    if (!sd->ewk_view_frame_main_get)
3038      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
3039
3040    if (!sd->ewk_frame_contents_size_get)
3041      sd->ewk_frame_contents_size_get = (Eina_Bool (*)(const Evas_Object *, Evas_Coord *, Evas_Coord *))dlsym(ewk_handle, "ewk_frame_contents_size_get");
3042    int cw, ch;
3043    sd->ewk_frame_contents_size_get(sd->ewk_view_frame_main_get(webview), &cw, &ch);
3044    if (cw == 0 || ch == 0) return;
3045
3046    if (!sd->ewk_frame_visible_content_geometry_get)
3047      sd->ewk_frame_visible_content_geometry_get = (Eina_Bool (*)(const Evas_Object *, Eina_Bool, int *, int *, int *, int *))dlsym(ewk_handle, "ewk_frame_visible_content_geometry_get");
3048    int x, y, w, h;
3049    sd->ewk_frame_visible_content_geometry_get(
3050          sd->ewk_view_frame_main_get(webview), EINA_FALSE,
3051          &x, &y, &w, &h);
3052    DBG("visible area : %d, %d, %d, %d\n", x, y, w, h);
3053
3054    Eina_Rectangle rect = {
3055         x * minimapW / cw, y * minimapH / ch,
3056         w * minimapW / cw, h * minimapH / ch};
3057    _minimap_update_detail(minimap, sd, src, minimapW, minimapH, &rect);
3058 }
3059
3060 static cairo_surface_t*
3061 _image_clone_get(Smart_Data *sd, int* minimap_w, int* minimap_h)
3062 {
3063    DBG("%s is called\n", __func__);
3064    Evas_Object *webview = sd->base.self;
3065    EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, NULL);
3066
3067    if (!sd->ewk_view_frame_main_get)
3068      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
3069
3070    if (!sd->ewk_frame_contents_size_get)
3071      sd->ewk_frame_contents_size_get = (Eina_Bool (*)(const Evas_Object *, Evas_Coord *, Evas_Coord *))dlsym(ewk_handle, "ewk_frame_contents_size_get");
3072    int w, h;
3073    sd->ewk_frame_contents_size_get(sd->ewk_view_frame_main_get(webview), &w, &h);
3074    printf(" W : %d / H : %d\n", w, h);
3075
3076    float x_scale = MINIMAP_WIDTH / (float)w;
3077    float y_scale = MINIMAP_HEIGHT / (float)h;
3078    float scale_factor;
3079    if (x_scale < y_scale)
3080      {
3081         scale_factor = x_scale;
3082         *minimap_w = MINIMAP_WIDTH;
3083         *minimap_h = h * scale_factor;
3084      }
3085    else
3086      {
3087         scale_factor = y_scale;
3088         *minimap_w = w * scale_factor;
3089         *minimap_h = MINIMAP_HEIGHT;
3090      }
3091    printf(" minimap w,h : (%d, %d)\n", *minimap_w, *minimap_h);
3092
3093    if (!sd->ewk_view_paint_contents)
3094      sd->ewk_view_paint_contents = (Eina_Bool (*)(Ewk_View_Private_Data *, cairo_t *, const Eina_Rectangle *))dlsym(ewk_handle, "ewk_view_paint_contents");
3095    if (!sd->cairo_image_surface_create)
3096      sd->cairo_image_surface_create = (cairo_surface_t * (*)(cairo_format_t, int, int))dlsym(cairo_handle, "cairo_image_surface_create");
3097    if (!sd->cairo_create)
3098      sd->cairo_create = (cairo_t * (*)(cairo_surface_t *))dlsym(cairo_handle, "cairo_create");
3099    if (!sd->cairo_destroy)
3100      sd->cairo_destroy = (void (*)(cairo_t *))dlsym(cairo_handle, "cairo_destroy");
3101    if (!sd->cairo_scale)
3102      sd->cairo_scale = (void (*)(cairo_t *, double, double))dlsym(cairo_handle, "cairo_scale");
3103    if (!sd->cairo_surface_write_to_png)
3104      sd->cairo_surface_write_to_png = (cairo_status_t (*)(cairo_surface_t *, const char *))dlsym(cairo_handle, "cairo_surface_write_to_png");
3105    if (!sd->cairo_set_antialias)
3106      sd->cairo_set_antialias = (void (*)(cairo_t *, cairo_antialias_t))dlsym(cairo_handle, "cairo_set_antialias");
3107
3108    cairo_surface_t* ret = sd->cairo_image_surface_create(CAIRO_FORMAT_RGB24, *minimap_w, *minimap_h);
3109    cairo_t* cr = sd->cairo_create(ret);
3110    sd->cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
3111    sd->cairo_scale(cr, scale_factor, scale_factor);
3112    Eina_Rectangle rect = {0, 0, w, h};
3113    sd->ewk_view_paint_contents(priv, cr, &rect);
3114    sd->cairo_destroy(cr);
3115    sd->cairo_surface_write_to_png(ret, "/home/root/test.png");
3116
3117    return ret;
3118 }
3119
3120 // coord
3121 static void
3122 _unzoom_position(Evas_Object* obj, int x, int y, int* ux, int* uy)
3123 {
3124    INTERNAL_ENTRY;
3125    int viewY;
3126    evas_object_geometry_get(obj, NULL, &viewY, NULL, NULL);
3127
3128    if (!sd->ewk_view_zoom_get)
3129      sd->ewk_view_zoom_get = (float (*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_zoom_get");
3130    float zoomRatio = sd->ewk_view_zoom_get(obj);
3131    if (zoomRatio)
3132      {
3133         *ux = x / zoomRatio;
3134         *uy = (y - viewY) / zoomRatio;
3135      }
3136 }
3137
3138 static void
3139 _coords_evas_to_ewk(Evas_Object* obj, int x, int y, int* ux, int* uy)
3140 {
3141    INTERNAL_ENTRY;
3142
3143    if (!sd->ewk_view_frame_main_get)
3144      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
3145
3146    if (!sd->ewk_frame_scroll_pos_get)
3147      sd->ewk_frame_scroll_pos_get = (Eina_Bool (*)(const Evas_Object *, int *, int *))dlsym(ewk_handle, "ewk_frame_scroll_pos_get");
3148
3149    int scrollX, scrollY, viewY;
3150    sd->ewk_frame_scroll_pos_get(sd->ewk_view_frame_main_get(obj), &scrollX, &scrollY);
3151    evas_object_geometry_get(obj, NULL, &viewY, NULL, NULL);
3152    *ux = x + scrollX;
3153    *uy = y + scrollY - viewY;
3154 }
3155
3156 static void
3157 _coords_ewk_to_evas(Evas_Object* obj, int x, int y, int* ux, int* uy)
3158 {
3159    INTERNAL_ENTRY;
3160
3161    if (!sd->ewk_view_frame_main_get)
3162      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
3163
3164    if (!sd->ewk_frame_scroll_pos_get)
3165      sd->ewk_frame_scroll_pos_get = (Eina_Bool (*)(const Evas_Object *, int *, int *))dlsym(ewk_handle, "ewk_frame_scroll_pos_get");
3166
3167    int scrollX, scrollY, viewY;
3168    sd->ewk_frame_scroll_pos_get(sd->ewk_view_frame_main_get(obj), &scrollX, &scrollY);
3169    evas_object_geometry_get(obj, NULL, &viewY, NULL, NULL);
3170    *ux = x - scrollX;
3171    *uy = y - scrollY + viewY;
3172 }
3173 static void
3174 _update_min_zoom_rate(Evas_Object *obj)
3175 {
3176    INTERNAL_ENTRY;
3177
3178    if (!sd->ewk_view_frame_main_get)
3179      sd->ewk_view_frame_main_get = (Evas_Object *(*)(const Evas_Object *))dlsym(ewk_handle, "ewk_view_frame_main_get");
3180    if (!sd->ewk_frame_contents_size_get)
3181      sd->ewk_frame_contents_size_get = (Eina_Bool (*)(const Evas_Object *, Evas_Coord *, Evas_Coord *))dlsym(ewk_handle, "ewk_frame_contents_size_get");
3182    if (!sd->ewk_view_zoom_range_set)
3183      sd->ewk_view_zoom_range_set = (Eina_Bool (*)(Evas_Object *, float, float))dlsym(ewk_handle, "ewk_view_zoom_range_set");
3184
3185    int content_w, object_w;
3186    evas_object_geometry_get(obj, NULL, NULL, &object_w, NULL);
3187    sd->ewk_frame_contents_size_get(sd->ewk_view_frame_main_get(obj), &content_w, NULL);
3188    if (content_w)
3189      sd->zoom.min_zoom_rate = (float)object_w / (float)content_w;
3190
3191    if (sd->use_zoom_bouncing)
3192      {
3193         float min_zoom_rate = sd->zoom.min_zoom_rate * ZOOM_OUT_BOUNCING;
3194         if (min_zoom_rate <= 0) min_zoom_rate = MIN_ZOOM_RATIO;
3195         float max_zoom_rate = sd->zoom.max_zoom_rate * ZOOM_IN_BOUNCING;
3196         sd->ewk_view_zoom_range_set(obj, min_zoom_rate, max_zoom_rate);
3197      }
3198    else
3199      {
3200         sd->ewk_view_zoom_range_set(obj, sd->zoom.min_zoom_rate, sd->zoom.max_zoom_rate);
3201      }
3202 }
3203 static void
3204 _geolocation_permission_callback(void *geolocation_obj, const char* url)
3205 {
3206    printf("\n\n<< %s >>\n\n", __func__);
3207    INTERNAL_ENTRY;
3208
3209    Evas_Object *popup;
3210    int length;
3211    char msg1[] = "The page at ";
3212    char msg2[] = "<br>wants to know where you are.<br>Do you want to share location?";
3213    char *msg = NULL;
3214    int result;
3215
3216    length = strlen(msg1) + strlen(url) + strlen(msg2);
3217    msg = calloc(length + 1, sizeof(char));
3218    strncpy(msg, msg1, strlen(msg1));
3219    strncat(msg, url, strlen(url));
3220    strncat(msg, msg2, strlen(msg2));
3221    msg[length] = '\0';
3222
3223    popup = elm_popup_add(obj);
3224    evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3225    elm_popup_desc_set(popup, msg);
3226    elm_popup_buttons_add(popup, 2, "Share", ELM_POPUP_RESPONSE_OK,
3227                                    "Don't Share", ELM_POPUP_RESPONSE_CANCEL, NULL);
3228    result = elm_popup_run(popup); // modal dialog
3229    switch (result)
3230      {
3231       case ELM_POPUP_RESPONSE_OK:
3232          if (!sd->ewk_set_geolocation_sharing_allowed)
3233            sd->ewk_set_geolocation_sharing_allowed = (void (*)(void *, Eina_Bool))dlsym(ewk_handle, "ewk_set_geolocation_sharing_allowed");
3234          sd->ewk_set_geolocation_sharing_allowed(geolocation_obj, EINA_TRUE);
3235          break;
3236
3237       case ELM_POPUP_RESPONSE_CANCEL:
3238          if (!sd->ewk_set_geolocation_sharing_allowed)
3239            sd->ewk_set_geolocation_sharing_allowed = (void (*)(void *, Eina_Bool))dlsym(ewk_handle, "ewk_set_geolocation_sharing_allowed");
3240          sd->ewk_set_geolocation_sharing_allowed(geolocation_obj, EINA_FALSE);
3241          break;
3242
3243       default:
3244          break;
3245      }
3246    if (msg)
3247      free(msg);
3248 }
3249 #endif