src/browser-utility.cpp

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 extern "C" {
  19 #include <Elementary.h>
  20 }
  21
  22 #include "browser-utility.h"
  23 #include "app.h" /* for preference CAPI */
  24
  25 static void __changed_cb(void *data, Evas_Object *obj, void *event_info)
  26 {
  27         Evas_Object *layout = (Evas_Object *)data;
  28
  29         void *erase = evas_object_data_get(layout, "eraser");
  30         BROWSER_LOGD("erase = %d", erase);
  31         if (!erase)
  32                 return;
  33
  34         if (elm_object_focus_get(layout)) {
  35                 if (elm_entry_is_empty(obj))
  36                         elm_object_signal_emit(layout, "elm,state,eraser,hide", "elm");
  37                 else {
  38                         elm_object_signal_emit(layout, "elm,state,eraser,show", "elm");
  39                         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
  40                 }
  41         }
  42 }
  43
  44 static void __focused_cb(void *data, Evas_Object *obj, void *event_info)
  45 {
  46         Evas_Object *layout = (Evas_Object *)data;
  47
  48         void *erase = evas_object_data_get(layout, "eraser");
  49         BROWSER_LOGD("erase = %d", erase);
  50
  51         if (!elm_entry_is_empty(obj) && erase)
  52                 elm_object_signal_emit(layout, "elm,state,eraser,show", "elm");
  53
  54         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
  55 }
  56
  57 static void __unfocused_cb(void *data, Evas_Object *obj, void *event_info)
  58 {
  59         Evas_Object *layout = (Evas_Object *)data;
  60
  61         if (elm_entry_is_empty(obj))
  62                 elm_object_signal_emit(layout, "elm,state,guidetext,show", "elm");
  63
  64         elm_object_signal_emit(layout, "elm,state,eraser,hide", "elm");
  65 }
  66
  67 static void __url_entry_focused_cb(void *data, Evas_Object *obj, void *event_info)
  68 {
  69         Evas_Object *layout = (Evas_Object *)data;
  70
  71         void *erase = evas_object_data_get(layout, "eraser");
  72         BROWSER_LOGD("erase = %d", erase);
  73
  74         if (!elm_entry_is_empty(obj) && erase)
  75                 elm_object_signal_emit(layout, "elm,state,eraser,show", "elm");
  76
  77         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
  78 //      edje_object_signal_emit(elm_layout_edje_get(layout), "ellipsis_hide,signal", "");
  79         elm_object_signal_emit(layout, "ellipsis_hide,signal", "elm");
  80
  81         int *cursor_position = (int *)evas_object_data_get(obj, "cursor_position");
  82         BROWSER_LOGD("cursor_position = %d", cursor_position);
  83         elm_entry_cursor_pos_set(obj, (int)cursor_position);
  84 }
  85
  86 static void __url_entry_unfocused_cb(void *data, Evas_Object *obj, void *event_info)
  87 {
  88         Evas_Object *layout = (Evas_Object *)data;
  89
  90         if (elm_entry_is_empty(obj))
  91                 elm_object_signal_emit(layout, "elm,state,guidetext,show", "elm");
  92
  93         elm_object_signal_emit(layout, "elm,state,eraser,hide", "elm");
  94
  95 //      edje_object_signal_emit(elm_layout_edje_get(layout), "ellipsis_show,signal", "");
  96         elm_object_signal_emit(layout, "ellipsis_show,signal", "elm");
  97
  98         evas_object_data_set(obj, "cursor_position", (void *)elm_entry_cursor_pos_get(obj));
  99
 100         BROWSER_LOGD("cursor_position = %d", elm_entry_cursor_pos_get(obj));
 101 }
 102
 103 static void __eraser_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 104 {
 105         Evas_Object *entry = (Evas_Object *)data;
 106         elm_entry_entry_set(entry, "");
 107 }
 108
 109 Evas_Object *br_elm_url_editfield_add(Evas_Object *parent)
 110 {
 111         Evas_Object *layout = elm_layout_add(parent);
 112
 113         elm_layout_theme_set(layout, "layout", "browser-editfield", "default");
 114
 115         Evas_Object *entry = elm_entry_add(parent);
 116
 117         elm_entry_single_line_set(entry, EINA_TRUE);
 118         elm_entry_scrollable_set(entry, EINA_TRUE);
 119
 120         elm_entry_text_style_user_push(entry, "DEFAULT='font_size=35 color=#3C3632 ellipsis=1'");
 121         elm_object_part_content_set(layout, "elm.swallow.content", entry);
 122
 123         evas_object_smart_callback_add(entry, "changed", __changed_cb, layout);
 124         evas_object_smart_callback_add(entry, "focused", __url_entry_focused_cb, layout);
 125         evas_object_smart_callback_add(entry, "unfocused", __url_entry_unfocused_cb, layout);
 126         elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm",
 127                                                 __eraser_clicked_cb, entry);
 128
 129         elm_object_signal_emit(layout, "ellipsis_show,signal", "elm");
 130
 131         return layout;
 132 }
 133
 134 Evas_Object *br_elm_find_word_editfield_add(Evas_Object *parent)
 135 {
 136         Evas_Object *layout = elm_layout_add(parent);
 137
 138         elm_layout_theme_set(layout, "layout", "browser-editfield", "default");
 139
 140         Evas_Object *entry = elm_entry_add(parent);
 141
 142         elm_entry_single_line_set(entry, EINA_TRUE);
 143         elm_entry_scrollable_set(entry, EINA_TRUE);
 144
 145         elm_entry_text_style_user_push(entry, "color=#000000 ellipsis=1'");
 146         elm_object_part_content_set(layout, "elm.swallow.content", entry);
 147
 148         evas_object_smart_callback_add(entry, "changed", __changed_cb, layout);
 149         evas_object_smart_callback_add(entry, "focused", __focused_cb, layout);
 150         evas_object_smart_callback_add(entry, "unfocused", __unfocused_cb, layout);
 151         elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm",
 152                                                 __eraser_clicked_cb, entry);
 153
 154         elm_object_signal_emit(layout, "ellipsis_hide,signal", "elm");
 155
 156         return layout;
 157 }
 158
 159 Evas_Object *br_elm_editfield_add(Evas_Object *parent, Eina_Bool title)
 160 {
 161         Evas_Object *layout = elm_layout_add(parent);
 162         if (title)
 163                 elm_layout_theme_set(layout, "layout", "editfield", "title");
 164         else
 165                 elm_layout_theme_set(layout, "layout", "editfield", "default");
 166
 167         Evas_Object *entry = elm_entry_add(parent);
 168         elm_object_part_content_set(layout, "elm.swallow.content", entry);
 169
 170         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
 171         evas_object_data_set(layout, "eraser", (void *)EINA_TRUE);
 172
 173         evas_object_smart_callback_add(entry, "changed", __changed_cb, layout);
 174         evas_object_smart_callback_add(entry, "focused", __focused_cb, layout);
 175         evas_object_smart_callback_add(entry, "unfocused", __unfocused_cb, layout);
 176         elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm",
 177                                                 __eraser_clicked_cb, entry);
 178
 179         return layout;
 180 }
 181
 182 void br_elm_editfield_label_set(Evas_Object *obj, const char *label)
 183 {
 184         elm_object_part_text_set(obj, "elm.text", label);
 185 }
 186
 187 Evas_Object *br_elm_editfield_entry_get(Evas_Object *obj)
 188 {
 189         return elm_object_part_content_get(obj, "elm.swallow.content");
 190 }
 191
 192 void br_elm_editfield_guide_text_set(Evas_Object *obj, const char *text)
 193 {
 194         elm_object_part_text_set(obj, "elm.guidetext", text);
 195 }
 196
 197 void br_elm_editfield_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line)
 198 {
 199         Evas_Object *entry = br_elm_editfield_entry_get(obj);
 200         elm_entry_single_line_set(entry, EINA_TRUE);
 201         elm_entry_scrollable_set(entry, EINA_TRUE);
 202 }
 203
 204 void br_elm_editfield_eraser_set(Evas_Object *obj, Eina_Bool visible)
 205 {
 206         evas_object_data_set(obj, "eraser", (void *)visible);
 207
 208         if (visible)
 209                 elm_object_signal_emit(obj, "elm,state,eraser,show", "elm");
 210         else
 211                 elm_object_signal_emit(obj, "elm,state,eraser,hide", "elm");
 212 }
 213
 214
 215 static void __searchbar_changed_cb(void *data, Evas_Object *obj, void *event_info)
 216 {
 217         Evas_Object *layout = (Evas_Object *)data;
 218
 219         if (elm_object_focus_get(layout)) {
 220                 if (elm_entry_is_empty(obj))
 221                         elm_object_signal_emit(layout, "elm,state,eraser,hide", "elm");
 222                 else {
 223                         elm_object_signal_emit(layout, "elm,state,eraser,show", "elm");
 224                         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
 225                 }
 226         }
 227 }
 228
 229 static void __searchbar_focused_cb(void *data, Evas_Object *obj, void *event_info)
 230 {
 231         Evas_Object *layout = (Evas_Object *)data;
 232
 233         if (!elm_entry_is_empty(obj))
 234                 elm_object_signal_emit(layout, "elm,state,eraser,show", "elm");
 235
 236         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
 237         elm_object_signal_emit(layout, "cancel,in", "");
 238 }
 239
 240 static void __searchbar_unfocused_cb(void *data, Evas_Object *obj, void *event_info)
 241 {
 242         Evas_Object *layout = (Evas_Object *)data;
 243
 244         if (elm_entry_is_empty(obj))
 245                 elm_object_signal_emit(layout, "elm,state,guidetext,show", "elm");
 246         elm_object_signal_emit(layout, "elm,state,eraser,hide", "elm");
 247 }
 248
 249 static void __searchbar_eraser_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 250 {
 251         Evas_Object *entry = (Evas_Object *)data;
 252
 253         elm_entry_entry_set(entry, "");
 254 }
 255
 256 static void __searchbar_bg_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 257 {
 258         Evas_Object *entry = (Evas_Object *)data;
 259
 260         elm_object_focus_set(entry, EINA_TRUE);
 261 }
 262
 263 static void __searchbar_cancel_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 264 {
 265         Evas_Object *searchbar_layout = (Evas_Object *)data;
 266         Evas_Object *entry = elm_object_part_content_get(searchbar_layout, "elm.swallow.content");
 267         const char* text;
 268         evas_object_hide(obj);
 269         elm_object_signal_emit(searchbar_layout, "cancel,out", "");
 270
 271         text = elm_entry_entry_get(entry);
 272         if (text != NULL && strlen(text) > 0)
 273                 elm_entry_entry_set(entry, NULL);
 274
 275         elm_object_focus_set(entry, EINA_FALSE);
 276 }
 277
 278 static void __search_entry_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 279 {
 280         Evas_Object *entry = (Evas_Object *)data;
 281         if (!elm_object_focus_allow_get(entry)) {
 282                 elm_object_focus_allow_set(entry, EINA_TRUE);
 283                 elm_object_focus_set(entry, EINA_TRUE);
 284         }
 285 }
 286
 287 Evas_Object *br_elm_searchbar_add(Evas_Object *parent)
 288 {
 289         Evas_Object *searchbar_layout = elm_layout_add(parent);
 290         elm_layout_theme_set(searchbar_layout, "layout", "searchbar", "cancel_button");
 291         Evas_Object *entry = elm_entry_add(searchbar_layout);
 292         elm_entry_scrollable_set(entry, EINA_TRUE);
 293         elm_entry_single_line_set(entry, EINA_TRUE);
 294         elm_object_part_content_set(searchbar_layout, "elm.swallow.content", entry);
 295         elm_object_part_text_set(searchbar_layout, "elm.guidetext", BR_STRING_SEARCH);
 296
 297         /* Workaround
 298           * When tab history view, the search entry has focus automatically.
 299           * So the keypad is shown. So give focus manually. */
 300         edje_object_signal_callback_add(elm_layout_edje_get(searchbar_layout),
 301                                         "mouse,clicked,1", "elm.swallow.content", __search_entry_clicked_cb, entry);
 302
 303         elm_object_focus_allow_set(entry, EINA_FALSE);
 304
 305         Evas_Object *cancel_button = elm_button_add(searchbar_layout);
 306         elm_object_part_content_set(searchbar_layout, "button_cancel", cancel_button);
 307         elm_object_style_set(cancel_button, "searchbar/default");
 308         elm_object_text_set(cancel_button, BR_STRING_CANCEL);
 309         evas_object_smart_callback_add(cancel_button, "clicked", __searchbar_cancel_clicked_cb, searchbar_layout);
 310
 311         evas_object_smart_callback_add(entry, "changed", __searchbar_changed_cb, searchbar_layout);
 312         evas_object_smart_callback_add(entry, "focused", __searchbar_focused_cb, searchbar_layout);
 313         evas_object_smart_callback_add(entry, "unfocused", __searchbar_unfocused_cb, searchbar_layout);
 314         elm_object_signal_callback_add(searchbar_layout, "elm,eraser,clicked", "elm",
 315                                                 __searchbar_eraser_clicked_cb, entry);
 316         elm_object_signal_callback_add(searchbar_layout, "elm,bg,clicked", "elm", __searchbar_bg_clicked_cb, entry);
 317
 318         return searchbar_layout;
 319 }
 320
 321 void br_elm_searchbar_text_set(Evas_Object *obj, const char *text)
 322 {
 323         Evas_Object *entry = elm_object_part_content_get(obj, "elm.swallow.content");
 324         elm_object_text_set(entry, text);
 325 }
 326
 327 char *br_elm_searchbar_text_get(Evas_Object *obj)
 328 {
 329         Evas_Object *entry = elm_object_part_content_get(obj, "elm.swallow.content");
 330         const char *text = elm_object_text_get(entry);
 331         BROWSER_LOGD("search entry text=[%s]", text);
 332
 333         if (text && strlen(text))
 334                 return strdup(text);
 335         else
 336                 return NULL;
 337 }
 338
 339 Evas_Object *br_elm_searchbar_entry_get(Evas_Object *obj)
 340 {
 341         return elm_object_part_content_get(obj, "elm.swallow.content");
 342 }
 343
 344 bool br_preference_set_bool(const char *key, bool value)
 345 {
 346         int ret;
 347         ret = preference_set_boolean(key, value);
 348         switch (ret) {
 349         case PREFERENCE_ERROR_NONE:
 350                 return true;
 351         case PREFERENCE_ERROR_INVALID_PARAMETER:
 352                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 353                 return false;
 354         case PREFERENCE_ERROR_IO_ERROR:
 355                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 356                 return false;
 357         default:
 358                 return false;
 359         }
 360         return true;
 361 }
 362
 363 bool br_preference_get_bool(const char *key, bool *value)
 364 {
 365         int ret = preference_get_boolean(key, value);
 366         switch (ret) {
 367         case PREFERENCE_ERROR_NONE:
 368                 return true;
 369         case PREFERENCE_ERROR_INVALID_PARAMETER:
 370                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 371                 return false;
 372         case PREFERENCE_ERROR_NO_KEY:
 373                 BROWSER_LOGE("Can not get [%s] value. Required key not available\n", key);
 374                 return false;
 375         case PREFERENCE_ERROR_IO_ERROR:
 376                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 377                 return false;
 378         default:
 379                 return false;
 380         }
 381         return true;
 382 }
 383
 384 bool br_preference_create_bool(const char *key, bool value)
 385 {
 386         BROWSER_LOGD("%s(%d)", key, value);
 387         bool existing = false;
 388         int ret = preference_is_existing(key, &existing);
 389         switch (ret) {
 390         case PREFERENCE_ERROR_NONE:
 391                 if (!existing)
 392                         preference_set_boolean(key, value);
 393                 return true;
 394         case PREFERENCE_ERROR_INVALID_PARAMETER:
 395                 BROWSER_LOGE("Can not initialize [%s] value. Invalid parameter\n", key);
 396                 return false;
 397         case PREFERENCE_ERROR_IO_ERROR:
 398                 BROWSER_LOGE("Can not initialize [%s] value. Internal IO error\n", key);
 399                 return false;
 400         default:
 401                 return false;
 402         }
 403         return true;
 404 }
 405
 406 bool br_preference_set_int(const char *key, int value)
 407 {
 408         int ret;
 409         ret = preference_set_int(key, value);
 410         switch (ret) {
 411         case PREFERENCE_ERROR_NONE:
 412                 return true;
 413         case PREFERENCE_ERROR_INVALID_PARAMETER:
 414                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 415                 return false;
 416         case PREFERENCE_ERROR_IO_ERROR:
 417                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 418                 return false;
 419         default:
 420                 return false;
 421         }
 422         return true;
 423 }
 424
 425 bool br_preference_get_int(const char *key, int *value)
 426 {
 427         int ret = preference_get_int(key, value);
 428         switch (ret) {
 429         case PREFERENCE_ERROR_NONE:
 430                 return true;
 431         case PREFERENCE_ERROR_INVALID_PARAMETER:
 432                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 433                 return false;
 434         case PREFERENCE_ERROR_NO_KEY:
 435                 BROWSER_LOGE("Can not get [%s] value. Required key not available\n", key);
 436                 return false;
 437         case PREFERENCE_ERROR_IO_ERROR:
 438                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 439                 return false;
 440         default:
 441                 return false;
 442         }
 443         return true;
 444 }
 445
 446 bool br_preference_create_int(const char *key, int value)
 447 {
 448         BROWSER_LOGD("%s(%d)", key, value);
 449         bool existing = false;
 450         int ret = preference_is_existing(key, &existing);
 451         switch (ret) {
 452         case PREFERENCE_ERROR_NONE:
 453                 if (!existing)
 454                         preference_set_int(key, value);
 455                 return true;
 456         case PREFERENCE_ERROR_INVALID_PARAMETER:
 457                 BROWSER_LOGE("Can not initialize [%s] value. Invalid parameter\n", key);
 458                 return false;
 459         case PREFERENCE_ERROR_IO_ERROR:
 460                 BROWSER_LOGE("Can not initialize [%s] value. Internal IO error\n", key);
 461                 return false;
 462         default:
 463                 return false;
 464         }
 465         return true;
 466 }
 467
 468 bool br_preference_set_str(const char *key, const char *value)
 469 {
 470         int ret;
 471         ret = preference_set_string(key, value);
 472         switch (ret) {
 473         case PREFERENCE_ERROR_NONE:
 474                 return true;
 475         case PREFERENCE_ERROR_INVALID_PARAMETER:
 476                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 477                 return false;
 478         case PREFERENCE_ERROR_IO_ERROR:
 479                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 480                 return false;
 481         default:
 482                 return false;
 483         }
 484         return true;
 485 }
 486
 487 bool br_preference_get_str(const char *key, char **value)
 488 {
 489         int ret = preference_get_string(key, value);
 490         switch (ret) {
 491         case PREFERENCE_ERROR_NONE:
 492                 return true;
 493         case PREFERENCE_ERROR_INVALID_PARAMETER:
 494                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 495                 return false;
 496         case PREFERENCE_ERROR_OUT_OF_MEMORY:
 497                 BROWSER_LOGE("Can not get [%s] value. Out of Memory\n", key);
 498                 return false;
 499         case PREFERENCE_ERROR_NO_KEY:
 500                 BROWSER_LOGE("Can not get [%s] value. Required key not available\n", key);
 501                 return false;
 502         case PREFERENCE_ERROR_IO_ERROR:
 503                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 504                 return false;
 505         default:
 506                 return false;
 507         }
 508         return true;
 509 }
 510
 511 bool br_preference_create_str(const char *key, const char *value)
 512 {
 513         BROWSER_LOGD("%s(%s)", key, value);
 514         bool existing = false;
 515         int ret = preference_is_existing(key, &existing);
 516         switch (ret) {
 517         case PREFERENCE_ERROR_NONE:
 518                 if (!existing)
 519                         preference_set_string(key, value);
 520                 return true;
 521         case PREFERENCE_ERROR_INVALID_PARAMETER:
 522                 BROWSER_LOGE("Can not initialize [%s] value. Invalid parameter\n", key);
 523                 return false;
 524         case PREFERENCE_ERROR_IO_ERROR:
 525                 BROWSER_LOGE("Can not initialize [%s] value. Internal IO error\n", key);
 526                 return false;
 527         default:
 528                 return false;
 529         }
 530         return true;
 531 }
 532
 533 bool br_preference_set_changed_cb(const char *key, br_preference_changed_cb callback, void *user_data)
 534 {
 535         BROWSER_LOGD("[%s]", key);
 536         int ret = preference_set_changed_cb(key, (preference_changed_cb)callback, user_data);
 537         switch (ret) {
 538         case PREFERENCE_ERROR_NONE:
 539                 return true;
 540         case PREFERENCE_ERROR_INVALID_PARAMETER:
 541                 BROWSER_LOGE("Can not set [%s] callback. Invalid parameter\n", key);
 542                 return false;
 543         case PREFERENCE_ERROR_OUT_OF_MEMORY:
 544                 BROWSER_LOGE("Can not set [%s] callback. Out of Memory\n", key);
 545                 return false;
 546         case PREFERENCE_ERROR_NO_KEY:
 547                 BROWSER_LOGE("Can not set [%s] callback. Required key not available\n", key);
 548                 return false;
 549         case PREFERENCE_ERROR_IO_ERROR:
 550                 BROWSER_LOGE("Can not set [%s] callback. Internal IO error\n", key);
 551                 return false;
 552         default:
 553                 return false;
 554         }
 555         return true;
 556 }
 557
 558 bool br_preference_unset_changed_cb(const char *key)
 559 {
 560         BROWSER_LOGD("[%s]", key);
 561         int ret = preference_unset_changed_cb(key);
 562         switch (ret) {
 563         case PREFERENCE_ERROR_NONE:
 564                 return true;
 565         case PREFERENCE_ERROR_INVALID_PARAMETER:
 566                 BROWSER_LOGE("Can not unset [%s] callback. Invalid parameter\n", key);
 567                 return false;
 568         case PREFERENCE_ERROR_IO_ERROR:
 569                 BROWSER_LOGE("Can not unset [%s] callback. Internal IO error\n", key);
 570                 return false;
 571         default:
 572                 return false;
 573         }
 574         return true;
 575 }
 576
 577 Browser_Utility::Browser_Utility(void)
 578 {
 579         BROWSER_LOGD("[%s]", __func__);
 580 }
 581
 582 Browser_Utility::~Browser_Utility(void)
 583 {
 584         BROWSER_LOGD("[%s]", __func__);
 585 }
 586
 587 std::string Browser_Utility::convert_WKStringRef(WKStringRef string_ref)
 588 {
 589         BROWSER_LOGD("[%s]", __func__);
 590         std::string return_string;
 591         int string_length = WKStringGetMaximumUTF8CStringSize(string_ref);
 592         char *buffer =(char *)calloc(string_length + 1, sizeof(char));
 593         if (buffer) {
 594                 WKStringGetUTF8CString(string_ref, buffer, string_length);
 595                 return_string = std::string(buffer);
 596                 free(buffer);
 597         }
 598
 599         return return_string;
 600 }
 601