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                         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
 226                 }
 227         }
 228 }
 229
 230 static void __searchbar_focused_cb(void *data, Evas_Object *obj, void *event_info)
 231 {
 232         Evas_Object *layout = (Evas_Object *)data;
 233
 234         if (!elm_entry_is_empty(obj))
 235                 elm_object_signal_emit(layout, "elm,state,eraser,show", "elm");
 236
 237         elm_object_signal_emit(layout, "elm,state,guidetext,hide", "elm");
 238         elm_object_signal_emit(layout, "cancel,in", "");
 239 }
 240
 241 static void __searchbar_unfocused_cb(void *data, Evas_Object *obj, void *event_info)
 242 {
 243         Evas_Object *layout = (Evas_Object *)data;
 244
 245         if (elm_entry_is_empty(obj))
 246                 elm_object_signal_emit(layout, "elm,state,guidetext,show", "elm");
 247         elm_object_signal_emit(layout, "elm,state,eraser,hide", "elm");
 248 }
 249
 250 static void __searchbar_eraser_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 251 {
 252         Evas_Object *entry = (Evas_Object *)data;
 253
 254         elm_entry_entry_set(entry, "");
 255 }
 256
 257 static void __searchbar_bg_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 258 {
 259         Evas_Object *entry = (Evas_Object *)data;
 260
 261         elm_object_focus_set(entry, EINA_TRUE);
 262 }
 263
 264 static void __searchbar_cancel_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 265 {
 266         Evas_Object *searchbar_layout = (Evas_Object *)data;
 267         Evas_Object *entry = elm_object_part_content_get(searchbar_layout, "elm.swallow.content");
 268         const char* text;
 269         evas_object_hide(obj);
 270         elm_object_signal_emit(searchbar_layout, "cancel,out", "");
 271
 272         text = elm_entry_entry_get(entry);
 273         if (text != NULL && strlen(text) > 0)
 274                 elm_entry_entry_set(entry, NULL);
 275
 276         elm_object_focus_set(entry, EINA_FALSE);
 277 }
 278
 279 static void __search_entry_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 280 {
 281         Evas_Object *entry = (Evas_Object *)data;
 282         if (!elm_object_focus_allow_get(entry)) {
 283                 elm_object_focus_allow_set(entry, EINA_TRUE);
 284                 elm_object_focus_set(entry, EINA_TRUE);
 285         }
 286 }
 287
 288 Evas_Object *br_elm_searchbar_add(Evas_Object *parent)
 289 {
 290         Evas_Object *searchbar_layout = elm_layout_add(parent);
 291         elm_layout_theme_set(searchbar_layout, "layout", "searchbar", "cancel_button");
 292         Evas_Object *entry = elm_entry_add(searchbar_layout);
 293         elm_entry_scrollable_set(entry, EINA_TRUE);
 294         elm_entry_single_line_set(entry, EINA_TRUE);
 295         elm_object_part_content_set(searchbar_layout, "elm.swallow.content", entry);
 296         elm_object_part_text_set(searchbar_layout, "elm.guidetext", BR_STRING_SEARCH);
 297
 298         /* Workaround
 299           * When tab history view, the search entry has focus automatically.
 300           * So the keypad is shown. So give focus manually. */
 301         edje_object_signal_callback_add(elm_layout_edje_get(searchbar_layout),
 302                                         "mouse,clicked,1", "elm.swallow.content", __search_entry_clicked_cb, entry);
 303
 304         elm_object_focus_allow_set(entry, EINA_FALSE);
 305
 306         Evas_Object *cancel_button = elm_button_add(searchbar_layout);
 307         elm_object_part_content_set(searchbar_layout, "button_cancel", cancel_button);
 308         elm_object_style_set(cancel_button, "searchbar/default");
 309         elm_object_text_set(cancel_button, BR_STRING_CANCEL);
 310         evas_object_smart_callback_add(cancel_button, "clicked", __searchbar_cancel_clicked_cb, searchbar_layout);
 311
 312         evas_object_smart_callback_add(entry, "changed", __searchbar_changed_cb, searchbar_layout);
 313         evas_object_smart_callback_add(entry, "focused", __searchbar_focused_cb, searchbar_layout);
 314         evas_object_smart_callback_add(entry, "unfocused", __searchbar_unfocused_cb, searchbar_layout);
 315         elm_object_signal_callback_add(searchbar_layout, "elm,eraser,clicked", "elm",
 316                                                 __searchbar_eraser_clicked_cb, entry);
 317         elm_object_signal_callback_add(searchbar_layout, "elm,bg,clicked", "elm", __searchbar_bg_clicked_cb, entry);
 318
 319         return searchbar_layout;
 320 }
 321
 322 void br_elm_searchbar_text_set(Evas_Object *obj, const char *text)
 323 {
 324         Evas_Object *entry = elm_object_part_content_get(obj, "elm.swallow.content");
 325         elm_object_text_set(entry, text);
 326 }
 327
 328 char *br_elm_searchbar_text_get(Evas_Object *obj)
 329 {
 330         Evas_Object *entry = elm_object_part_content_get(obj, "elm.swallow.content");
 331         const char *text = elm_object_text_get(entry);
 332         BROWSER_LOGD("search entry text=[%s]", text);
 333
 334         if (text && strlen(text))
 335                 return strdup(text);
 336         else
 337                 return NULL;
 338 }
 339
 340 Evas_Object *br_elm_searchbar_entry_get(Evas_Object *obj)
 341 {
 342         return elm_object_part_content_get(obj, "elm.swallow.content");
 343 }
 344
 345 bool br_preference_set_bool(const char *key, bool value)
 346 {
 347         int ret;
 348         ret = preference_set_boolean(key, value);
 349         switch (ret) {
 350         case PREFERENCE_ERROR_NONE:
 351                 return true;
 352         case PREFERENCE_ERROR_INVALID_PARAMETER:
 353                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 354                 return false;
 355         case PREFERENCE_ERROR_IO_ERROR:
 356                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 357                 return false;
 358         default:
 359                 return false;
 360         }
 361         return true;
 362 }
 363
 364 bool br_preference_get_bool(const char *key, bool *value)
 365 {
 366         int ret = preference_get_boolean(key, value);
 367         switch (ret) {
 368         case PREFERENCE_ERROR_NONE:
 369                 return true;
 370         case PREFERENCE_ERROR_INVALID_PARAMETER:
 371                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 372                 return false;
 373         case PREFERENCE_ERROR_NO_KEY:
 374                 BROWSER_LOGE("Can not get [%s] value. Required key not available\n", key);
 375                 return false;
 376         case PREFERENCE_ERROR_IO_ERROR:
 377                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 378                 return false;
 379         default:
 380                 return false;
 381         }
 382         return true;
 383 }
 384
 385 bool br_preference_create_bool(const char *key, bool value)
 386 {
 387         BROWSER_LOGD("%s(%d)", key, value);
 388         bool existing = false;
 389         int ret = preference_is_existing(key, &existing);
 390         switch (ret) {
 391         case PREFERENCE_ERROR_NONE:
 392                 if (!existing)
 393                         preference_set_boolean(key, value);
 394                 return true;
 395         case PREFERENCE_ERROR_INVALID_PARAMETER:
 396                 BROWSER_LOGE("Can not initialize [%s] value. Invalid parameter\n", key);
 397                 return false;
 398         case PREFERENCE_ERROR_IO_ERROR:
 399                 BROWSER_LOGE("Can not initialize [%s] value. Internal IO error\n", key);
 400                 return false;
 401         default:
 402                 return false;
 403         }
 404         return true;
 405 }
 406
 407 bool br_preference_set_int(const char *key, int value)
 408 {
 409         int ret;
 410         ret = preference_set_int(key, value);
 411         switch (ret) {
 412         case PREFERENCE_ERROR_NONE:
 413                 return true;
 414         case PREFERENCE_ERROR_INVALID_PARAMETER:
 415                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 416                 return false;
 417         case PREFERENCE_ERROR_IO_ERROR:
 418                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 419                 return false;
 420         default:
 421                 return false;
 422         }
 423         return true;
 424 }
 425
 426 bool br_preference_get_int(const char *key, int *value)
 427 {
 428         int ret = preference_get_int(key, value);
 429         switch (ret) {
 430         case PREFERENCE_ERROR_NONE:
 431                 return true;
 432         case PREFERENCE_ERROR_INVALID_PARAMETER:
 433                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 434                 return false;
 435         case PREFERENCE_ERROR_NO_KEY:
 436                 BROWSER_LOGE("Can not get [%s] value. Required key not available\n", key);
 437                 return false;
 438         case PREFERENCE_ERROR_IO_ERROR:
 439                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 440                 return false;
 441         default:
 442                 return false;
 443         }
 444         return true;
 445 }
 446
 447 bool br_preference_create_int(const char *key, int value)
 448 {
 449         BROWSER_LOGD("%s(%d)", key, value);
 450         bool existing = false;
 451         int ret = preference_is_existing(key, &existing);
 452         switch (ret) {
 453         case PREFERENCE_ERROR_NONE:
 454                 if (!existing)
 455                         preference_set_int(key, value);
 456                 return true;
 457         case PREFERENCE_ERROR_INVALID_PARAMETER:
 458                 BROWSER_LOGE("Can not initialize [%s] value. Invalid parameter\n", key);
 459                 return false;
 460         case PREFERENCE_ERROR_IO_ERROR:
 461                 BROWSER_LOGE("Can not initialize [%s] value. Internal IO error\n", key);
 462                 return false;
 463         default:
 464                 return false;
 465         }
 466         return true;
 467 }
 468
 469 bool br_preference_set_str(const char *key, const char *value)
 470 {
 471         int ret;
 472         ret = preference_set_string(key, value);
 473         switch (ret) {
 474         case PREFERENCE_ERROR_NONE:
 475                 return true;
 476         case PREFERENCE_ERROR_INVALID_PARAMETER:
 477                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 478                 return false;
 479         case PREFERENCE_ERROR_IO_ERROR:
 480                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 481                 return false;
 482         default:
 483                 return false;
 484         }
 485         return true;
 486 }
 487
 488 bool br_preference_get_str(const char *key, char **value)
 489 {
 490         int ret = preference_get_string(key, value);
 491         switch (ret) {
 492         case PREFERENCE_ERROR_NONE:
 493                 return true;
 494         case PREFERENCE_ERROR_INVALID_PARAMETER:
 495                 BROWSER_LOGE("Can not get [%s] value. Invalid parameter\n", key);
 496                 return false;
 497         case PREFERENCE_ERROR_OUT_OF_MEMORY:
 498                 BROWSER_LOGE("Can not get [%s] value. Out of Memory\n", key);
 499                 return false;
 500         case PREFERENCE_ERROR_NO_KEY:
 501                 BROWSER_LOGE("Can not get [%s] value. Required key not available\n", key);
 502                 return false;
 503         case PREFERENCE_ERROR_IO_ERROR:
 504                 BROWSER_LOGE("Can not get [%s] value. Internal IO error\n", key);
 505                 return false;
 506         default:
 507                 return false;
 508         }
 509         return true;
 510 }
 511
 512 bool br_preference_create_str(const char *key, const char *value)
 513 {
 514         BROWSER_LOGD("%s(%s)", key, value);
 515         bool existing = false;
 516         int ret = preference_is_existing(key, &existing);
 517         switch (ret) {
 518         case PREFERENCE_ERROR_NONE:
 519                 if (!existing)
 520                         preference_set_string(key, value);
 521                 return true;
 522         case PREFERENCE_ERROR_INVALID_PARAMETER:
 523                 BROWSER_LOGE("Can not initialize [%s] value. Invalid parameter\n", key);
 524                 return false;
 525         case PREFERENCE_ERROR_IO_ERROR:
 526                 BROWSER_LOGE("Can not initialize [%s] value. Internal IO error\n", key);
 527                 return false;
 528         default:
 529                 return false;
 530         }
 531         return true;
 532 }
 533
 534 bool br_preference_set_changed_cb(const char *key, br_preference_changed_cb callback, void *user_data)
 535 {
 536         BROWSER_LOGD("[%s]", key);
 537         int ret = preference_set_changed_cb(key, (preference_changed_cb)callback, user_data);
 538         switch (ret) {
 539         case PREFERENCE_ERROR_NONE:
 540                 return true;
 541         case PREFERENCE_ERROR_INVALID_PARAMETER:
 542                 BROWSER_LOGE("Can not set [%s] callback. Invalid parameter\n", key);
 543                 return false;
 544         case PREFERENCE_ERROR_OUT_OF_MEMORY:
 545                 BROWSER_LOGE("Can not set [%s] callback. Out of Memory\n", key);
 546                 return false;
 547         case PREFERENCE_ERROR_NO_KEY:
 548                 BROWSER_LOGE("Can not set [%s] callback. Required key not available\n", key);
 549                 return false;
 550         case PREFERENCE_ERROR_IO_ERROR:
 551                 BROWSER_LOGE("Can not set [%s] callback. Internal IO error\n", key);
 552                 return false;
 553         default:
 554                 return false;
 555         }
 556         return true;
 557 }
 558
 559 bool br_preference_unset_changed_cb(const char *key)
 560 {
 561         BROWSER_LOGD("[%s]", key);
 562         int ret = preference_unset_changed_cb(key);
 563         switch (ret) {
 564         case PREFERENCE_ERROR_NONE:
 565                 return true;
 566         case PREFERENCE_ERROR_INVALID_PARAMETER:
 567                 BROWSER_LOGE("Can not unset [%s] callback. Invalid parameter\n", key);
 568                 return false;
 569         case PREFERENCE_ERROR_IO_ERROR:
 570                 BROWSER_LOGE("Can not unset [%s] callback. Internal IO error\n", key);
 571                 return false;
 572         default:
 573                 return false;
 574         }
 575         return true;
 576 }
 577