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