src/app_icon.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (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://floralicense.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 #include <Elementary.h>
  18 #include <stdbool.h>
  19 #include <package_manager.h>
  20 #include <package_info.h>
  21 #include <app_control.h>
  22
  23 #include "homescreen-efl.h"
  24 #include "app_icon.h"
  25 #include "all_apps.h"
  26 #include "util.h"
  27 #include "folder_panel.h"
  28 #include "option_menu.h"
  29 #include "folder_panel.h"
  30 #include "popup.h"
  31 #include "app_grid.h"
  32 #include "data_model.h"
  33
  34 #define MAX_BADGE_COUNT_STR_LEN 32
  35 #define MAX_BADGE_DISPLAY_COUNT 999
  36 #define ABOVE_MAX_BADGE_APPENDIX "+"
  37
  38 static struct {
  39         Evas_Object *icon_layout;
  40         Evas_Object *icon_image;
  41         char *runned_app_id;
  42         bool click_ignore;
  43
  44 } s_info = {
  45         .icon_layout = NULL,
  46         .icon_image = NULL,
  47         .runned_app_id = NULL,
  48         .click_ignore = false,
  49 };
  50
  51 static void __app_icon_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  52 static void __app_icon_pressed_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  53 static void __app_icon_launch_request_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *data);
  54 static bool __app_icon_check_removeable_state(Evas_Object *icon);
  55 static void __app_icon_check_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  56 static void __app_icon_uncheck_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  57 static Evas_Object *__app_icon_load(Evas_Object *parent, const char *icon_path);
  58 static void __app_icon_uninstall_button_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  59
  60 static void __app_icon_uninstall(void *data);
  61 static void __app_icon_highlight_folder_icon_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  62 static void __app_icon_unhighlight_folder_icon_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  63 static void __app_icon_higlight_impossible_folder_icon_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
  64
  65 /*=========================================PUBLIC FUNCTIONS IMPLEMENTATION===========================================*/
  66 HAPI Evas_Object *app_icon_create(Tree_node_t *tree_data, app_icon_type_t type)
  67 {
  68         Evas_Object *icon_image = NULL, *icon_layout = NULL, *folder_icon_layout = NULL;
  69         Evas_Object *parent = home_screen_get_win();
  70         app_item_t *item = NULL;
  71
  72         if (!parent || !tree_data) {
  73                 LOGE("[INVALID_PARAM][parent='%p'][item='%p']", parent, tree_data);
  74                 return NULL;
  75         }
  76
  77         item = tree_data->data;
  78         if (!item) {
  79                 LOGE("[FAILED][item='%p']", item);
  80                 return NULL;
  81         }
  82
  83         if (type == APP_ICON_TYPE_APP || type == APP_ICON_TYPE_FOLDER) {
  84                 icon_layout = util_create_edje_layout(parent, EDJE_DIR"/icon.edj", GROUP_ICON_LY);
  85                 if (!icon_layout) {
  86                         LOGE("Failed to create icon layout");
  87                         return NULL;
  88                 }
  89
  90                 elm_object_signal_callback_add(icon_layout, SIGNAL_CHECKBOX_CHECKED, SIGNAL_SOURCE, __app_icon_check_cb, tree_data);
  91                 elm_object_signal_callback_add(icon_layout, SIGNAL_CHECKBOX_UNCHECKED, SIGNAL_SOURCE, __app_icon_uncheck_cb, tree_data);
  92                 elm_object_signal_callback_add(icon_layout, SIGNAL_UNINSTALL_BUTTON_CLICKED, SIGNAL_SOURCE, __app_icon_uninstall_button_clicked_cb, tree_data);
  93
  94                 elm_object_signal_callback_add(icon_layout, "mouse,down,1", SIGNAL_PRESS_SOURCE, __app_icon_pressed_cb, (void *)item->type);
  95
  96                 home_screen_mvc_set_ly_scale(icon_layout);
  97         }
  98
  99         if (type == APP_ICON_TYPE_APP) {
 100                 icon_image = __app_icon_load(icon_layout, item->icon);
 101                 if (!icon_image) {
 102                         LOGE("Failed to create icon layout");
 103                         evas_object_del(icon_layout);
 104                         return NULL;
 105                 }
 106
 107                 elm_object_part_content_set(icon_layout, PART_ICON_CONTENT, icon_image);
 108                 elm_object_signal_callback_add(icon_layout, SIGNAL_ICON_CLICKED, SIGNAL_SOURCE, __app_icon_clicked_cb, (void *)item->appid);
 109
 110                 app_icon_set_label(icon_layout, item->label);
 111
 112                 evas_object_show(icon_image);
 113         } else if (type == APP_ICON_TYPE_FOLDER) {
 114                 folder_icon_layout = elm_layout_add(parent);
 115                 if (!folder_icon_layout) {
 116                         LOGE("Failed to create icon layout");
 117                         evas_object_del(icon_layout);
 118                         return NULL;
 119                 }
 120
 121                 if (!elm_layout_file_set(folder_icon_layout, EDJE_DIR"/folder.edj", GROUP_FOLDER_ICON_LAYOUT)) {
 122                         LOGE("Failed to load edje file for layout");
 123                         evas_object_del(folder_icon_layout);
 124                         evas_object_del(icon_layout);
 125                         return NULL;
 126                 }
 127
 128                 elm_object_part_content_set(icon_layout, PART_ICON_CONTENT, folder_icon_layout);
 129                 elm_object_signal_callback_add(icon_layout, SIGNAL_HIGHLIGHT_FOLDER, SIGNAL_SOURCE, __app_icon_highlight_folder_icon_cb, item);
 130                 elm_object_signal_callback_add(icon_layout, SIGNAL_HIGHLIGHT_IMPOSSIBLE_FOLDER, SIGNAL_SOURCE, __app_icon_higlight_impossible_folder_icon_cb, item);
 131                 elm_object_signal_callback_add(icon_layout, SIGNAL_UNHIGHLIGHT_FOLDER, SIGNAL_SOURCE, __app_icon_unhighlight_folder_icon_cb, item);
 132                 app_icon_set_label(icon_layout, item->label);
 133                 evas_object_show(folder_icon_layout);
 134         } else {
 135                 /*create miniatures*/
 136                 if (item->icon) {
 137                         icon_layout = __app_icon_load(parent, item->icon);
 138                         if (!icon_layout) {
 139                                 LOGE("Failed to create icon layout");
 140                                 return NULL;
 141                         }
 142                 }
 143         }
 144
 145         evas_object_size_hint_align_set(icon_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 146         evas_object_size_hint_weight_set(icon_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 147         evas_object_show(icon_layout);
 148
 149         evas_object_data_set(icon_layout, KEY_ICON_DATA, tree_data);
 150         evas_object_data_set(icon_layout, KEY_IS_REPOSITIONABLE, (void *)true);
 151
 152         return icon_layout;
 153 }
 154
 155 HAPI void app_icon_update_folder_icon(Tree_node_t *folder_node)
 156 {
 157         LOGI("");
 158         Evas_Object *miniatures_list_item = NULL;
 159         Evas_Object *folder_icon = NULL;
 160         Evas_Object *item = NULL;
 161         Eina_List *it = NULL;
 162         Tree_node_t *it2;
 163         folder_data_t *folder_data = NULL;
 164         app_item_t *tree_item = NULL;
 165
 166         char part_buf[BUF_SIZE];
 167         char signal_buf[BUF_SIZE];
 168
 169         int miniatures = 0;
 170         int miniatures_iterator = 0;
 171
 172         if (!folder_node || !folder_node->data || !folder_node->data->layout || !folder_node->data->data) {
 173                 LOGE("[INVALID_PARAMS]");
 174                 return;
 175         }
 176
 177         folder_icon = elm_object_part_content_get(folder_node->data->layout, PART_ICON_CONTENT);
 178         if (!folder_icon) {
 179                 LOGE("Failed to get folder icon");
 180                 return;
 181         }
 182
 183         folder_data = (folder_data_t *)folder_node->data->data;
 184
 185         if (!folder_data) {
 186                 LOGE("Failed to get folder_data");
 187                 return;
 188         }
 189
 190         EINA_LIST_FOREACH(folder_data->miniatures, it, miniatures_list_item) {
 191                 snprintf(part_buf, sizeof(part_buf), "miniature_%d", miniatures_iterator++);
 192                 elm_object_part_content_unset(folder_icon, part_buf);
 193                 evas_object_del(miniatures_list_item);
 194         }
 195         folder_data->miniatures = eina_list_free(folder_data->miniatures);
 196         folder_data->miniatures = NULL;
 197
 198         if (!folder_node->first || !(miniatures = folder_node->first->count)) {
 199                 elm_object_signal_emit(folder_icon, SIGNAL_EMPTY_BG_SHOW, SIGNAL_SOURCE);
 200                 return;
 201         }
 202
 203         if (miniatures >= 3) {
 204                 miniatures = 4;
 205         }
 206
 207         miniatures_iterator = 0;
 208         TREE_NODE_FOREACH(folder_node->first, it2)
 209         {
 210                 tree_item = it2->data;
 211
 212                 if (tree_item) {
 213                         if (miniatures_iterator >= FOLDER_ICON_MAX_MINIATURES)
 214                                 break;
 215                         LOGI("label %s", tree_item->label);
 216                         item  = app_icon_create(it2, APP_ICON_TYPE_MINIATURE);
 217
 218                         if (!item)
 219                                 return;
 220
 221                         folder_data->miniatures = eina_list_append(folder_data->miniatures, item);
 222                         if (!folder_data->miniatures) {
 223                                 app_icon_destroy(item);
 224                                 return;
 225                         }
 226
 227                         snprintf(part_buf, sizeof(part_buf), "miniature_%d", miniatures_iterator++);
 228                         elm_object_part_content_set(folder_icon, part_buf, item);
 229                 }
 230         }
 231
 232         snprintf(signal_buf, sizeof(signal_buf), "set,miniatures,%d", miniatures);
 233         elm_object_signal_emit(folder_icon, signal_buf, SIGNAL_SOURCE);
 234 }
 235
 236 HAPI void app_icon_highlight_folder_icon(Evas_Object *folder_icon_layout, folder_icon_frame_type_t frame_type)
 237 {
 238         Evas_Object *icon = NULL;
 239         Tree_node_t *node = NULL;
 240
 241         if (!folder_icon_layout) {
 242                 LOGE("Invalid parameter");
 243                 return;
 244         }
 245
 246         icon = elm_object_part_content_get(folder_icon_layout, PART_ICON_CONTENT);
 247         if (!icon) {
 248                 LOGE("Failed to get icon");
 249                 return;
 250         }
 251
 252         node = evas_object_data_get(folder_icon_layout, KEY_ICON_DATA);
 253         if (!node) {
 254                 LOGE("[FAILED][node=NULL]");
 255                 return;
 256         }
 257
 258         LOGI("count %d ", node->count);
 259
 260         if (frame_type == FOLDER_ICON_FRAME_POSSIBLE) {
 261                 elm_object_signal_emit(icon, SIGNAL_FRAME_POSSIBLE_SHOW, SIGNAL_SOURCE);
 262         } else if (frame_type == FOLDER_ICON_FRAME_IMPOSSIBLE) {
 263                 elm_object_signal_emit(icon, SIGNAL_FRAME_IMPOSSIBLE_SHOW, SIGNAL_SOURCE);
 264         } else {
 265                 elm_object_signal_emit(icon, SIGNAL_FRAME_HIDE, SIGNAL_SOURCE);
 266         }
 267 }
 268
 269 HAPI void app_icon_set_click_ignore(bool ignore)
 270 {
 271         s_info.click_ignore = ignore;
 272         folder_panel_set_click_ignore_state(ignore);
 273 }
 274
 275 HAPI bool app_icon_set_view_mode(Evas_Object *icon, homescreen_view_t view, bool in_folder)
 276 {
 277         switch (view) {
 278         case HOMESCREEN_VIEW_ALL_APPS:
 279                 in_folder ? elm_object_signal_emit(icon, SIGNAL_EDIT_MODE_BLACK_OFF, SIGNAL_SOURCE) :
 280                                 elm_object_signal_emit(icon, SIGNAL_EDIT_MODE_OFF, SIGNAL_SOURCE);
 281                 elm_object_signal_emit(icon, SIGNAL_UNINSTALL_BUTTON_HIDE, SIGNAL_SOURCE);
 282                 elm_object_signal_emit(icon, SIGNAL_CHECKBOX_HIDE, SIGNAL_SOURCE);
 283                 app_icon_set_click_ignore(false);
 284                 break;
 285         case HOMESCREEN_VIEW_ALL_APPS_EDIT:
 286                 in_folder ? elm_object_signal_emit(icon, SIGNAL_EDIT_MODE_BLACK_ON, SIGNAL_SOURCE) :
 287                                 elm_object_signal_emit(icon, SIGNAL_EDIT_MODE_ON, SIGNAL_SOURCE);
 288                 if (__app_icon_check_removeable_state(icon))
 289                         elm_object_signal_emit(icon, SIGNAL_UNINSTALL_BUTTON_SHOW, SIGNAL_SOURCE);
 290                 app_icon_set_click_ignore(true);
 291                 break;
 292         case HOMESCREEN_VIEW_ALL_APPS_CHOOSE:
 293                 in_folder ? elm_object_signal_emit(icon, SIGNAL_EDIT_MODE_BLACK_ON, SIGNAL_SOURCE) :
 294                                 elm_object_signal_emit(icon, SIGNAL_EDIT_MODE_ON, SIGNAL_SOURCE);
 295                 elm_object_signal_emit(icon, SIGNAL_UNINSTALL_BUTTON_HIDE, SIGNAL_SOURCE);
 296                 elm_object_signal_emit(icon, SIGNAL_CHECKBOX_SHOW_UNCHECKED, SIGNAL_SOURCE);
 297                 app_icon_set_click_ignore(true);
 298                 break;
 299         case HOMESCREEN_VIEW_HOME:
 300         case HOMESCREEN_VIEW_HOME_EDIT:
 301         case HOMESCREEN_VIEW_HOME_ALL_PAGES:
 302         default:
 303                 app_icon_set_click_ignore(true);
 304                 break;
 305         }
 306
 307         return true;
 308 }
 309
 310 HAPI void app_icon_set_label(Evas_Object *icon_layout, const char* label)
 311 {
 312         if (!icon_layout || !label) {
 313                 LOGE("Invalid parameter");
 314                 return;
 315         }
 316
 317         elm_object_part_text_set(icon_layout, PART_ICON_NAME, label);
 318 }
 319
 320 HAPI void app_icon_set_label_black(Evas_Object *icon_layout)
 321 {
 322         if (home_screen_get_view_type() == HOMESCREEN_VIEW_ALL_APPS_EDIT) {
 323                 elm_object_signal_emit(icon_layout, SIGNAL_EDIT_MODE_BLACK_ON, SIGNAL_SOURCE);
 324         } else {
 325                 elm_object_signal_emit(icon_layout, SIGNAL_BLACK_TEXT, SIGNAL_SOURCE);
 326         }
 327 }
 328
 329 HAPI void app_icon_set_color(Evas_Object *icon_layout, int r, int g, int b, int a)
 330 {
 331         if (!icon_layout) {
 332                 LOGE("Failed to get folder icon layout");
 333                 return;
 334         }
 335
 336         evas_object_color_set(icon_layout, r, g, b, a);
 337 }
 338
 339 HAPI void app_icon_destroy(Evas_Object *icon_layout)
 340 {
 341         if (!icon_layout) {
 342                 LOGE("Invalid parameter : icon_layout is NULL");
 343                 return;
 344         }
 345
 346         evas_object_del(icon_layout);
 347 }
 348
 349
 350 HAPI void app_icon_show_badge(Evas_Object *app_icon_layout, const unsigned int number)
 351 {
 352         char number_str[MAX_BADGE_COUNT_STR_LEN];
 353
 354         if (!app_icon_layout) {
 355                 LOGE("Invalid state of the application - icon_layout is NULL");
 356                 return;
 357         }
 358
 359         if (number == 0) {
 360                 app_icon_hide_badge(app_icon_layout);
 361                 return;
 362         }
 363
 364         if (number > MAX_BADGE_DISPLAY_COUNT) {
 365                 eina_convert_itoa(MAX_BADGE_DISPLAY_COUNT, number_str);
 366                 strncat(number_str, ABOVE_MAX_BADGE_APPENDIX, MAX_BADGE_COUNT_STR_LEN);
 367         } else {
 368                 eina_convert_itoa(number, number_str);
 369         }
 370
 371         elm_layout_text_set(app_icon_layout, "icon_badge_text", number_str);
 372
 373         elm_object_signal_emit(app_icon_layout, SIGNAL_BADGE_SHOW, SIGNAL_SOURCE);
 374 }
 375
 376 HAPI void app_icon_hide_badge(Evas_Object *app_icon_layout)
 377 {
 378         if (!app_icon_layout) {
 379                 LOGE("Invalid state of the application - icon_layout is NULL");
 380                 return;
 381         }
 382
 383         elm_object_signal_emit(app_icon_layout, SIGNAL_BADGE_HIDE, SIGNAL_SOURCE);
 384 }
 385
 386 HAPI void app_icon_show_label(Evas_Object *app_icon_layout)
 387 {
 388         Evas_Object *icon = NULL;
 389
 390         if (app_icon_layout) {
 391                 icon = elm_object_part_content_get(app_icon_layout, PART_ICON_CONTENT);
 392                 if (icon)
 393                         elm_object_signal_emit(icon, SIGNAL_LABEL_SHOW, SIGNAL_SOURCE);
 394         }
 395 }
 396
 397 HAPI void app_icon_hide_label(Evas_Object *app_icon_layout)
 398 {
 399         Evas_Object *icon = NULL;
 400
 401         if (app_icon_layout) {
 402                 icon = elm_object_part_content_get(app_icon_layout, PART_ICON_CONTENT);
 403                 if (icon)
 404                         elm_object_signal_emit(icon, SIGNAL_LABEL_HIDE, SIGNAL_SOURCE);
 405         }
 406 }
 407
 408 HAPI void app_icon_remove(Evas_Object *icon_layout)
 409 {
 410         if (!icon_layout) {
 411                 LOGE("[INVALID_PARAM]");
 412                 return;
 413         }
 414
 415         evas_object_data_del(icon_layout, KEY_ICON_DATA);
 416         evas_object_del(icon_layout);
 417 }
 418
 419
 420 /*=========================================PRIVATE FUNCTIONS IMPLEMENTATION======================================*/
 421 static void __app_icon_launch_request_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *data)
 422 {
 423         LOGD("[__app_icon_launch_request_cb]");
 424         switch (result) {
 425         case APP_CONTROL_RESULT_CANCELED:
 426                 LOGD("[APP_CONTROL_RESULT_CANCELED]");
 427                 s_info.runned_app_id = NULL;
 428                 break;
 429         case APP_CONTROL_RESULT_FAILED:
 430                 LOGD("[APP_CONTROL_RESULT_FAILED]");
 431                 s_info.runned_app_id = NULL;
 432                 break;
 433         case APP_CONTROL_RESULT_SUCCEEDED:
 434                 LOGD("[APP_CONTROL_RESULT_SUCCEEDED]");
 435                 break;
 436         default:
 437                 LOGD("UNKNOWN ERROR");
 438                 s_info.runned_app_id = NULL;
 439                 break;
 440         }
 441 }
 442
 443 static void __app_icon_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 444 {
 445         char *appid = (char *) data;
 446         app_control_h app_control_handle = NULL;
 447
 448         if (!appid) {
 449                 LOGE("Failed to obtain pgk_id of clicked application");
 450                 return;
 451         }
 452
 453         if (s_info.click_ignore == false) {
 454                 if (!s_info.runned_app_id) {
 455                         folder_panel_close_folder();
 456
 457                         if (app_control_create(&app_control_handle) != APP_CONTROL_ERROR_NONE) {
 458                                 LOGE("[FAILED][app_control_create]");
 459                                 return;
 460                         }
 461
 462                         if (app_control_set_app_id(app_control_handle, appid) != APP_CONTROL_ERROR_NONE) {
 463                                 LOGE("[FAILED][app_control_set_app_id]");
 464                                 app_control_destroy(app_control_handle);
 465                                 return;
 466                         }
 467
 468                         if (app_control_send_launch_request(app_control_handle, __app_icon_launch_request_cb, NULL) != APP_CONTROL_ERROR_NONE) {
 469                                 LOGE("[FAILED][app_control_send_launch_request]");
 470                                 app_control_destroy(app_control_handle);
 471                                 return;
 472                         }
 473                         app_control_destroy(app_control_handle);
 474                 }
 475         }
 476
 477 }
 478
 479 static void __app_icon_pressed_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 480 {
 481         app_item_type_t type = (app_item_type_t)data;
 482
 483         if (type == APP_ITEM_FOLDER ||
 484                 home_screen_get_view_type() == HOMESCREEN_VIEW_ALL_APPS)
 485                         elm_object_signal_emit(obj, SIGNAL_ICON_PRESS, SIGNAL_PRESS_SOURCE);
 486 }
 487
 488 static bool __app_icon_check_removeable_state(Evas_Object *icon)
 489 {
 490         Tree_node_t *item = NULL;
 491         if (!icon) {
 492                 LOGE("[INVALID_PARAM][icon='%p']", icon);
 493                 return false;
 494         }
 495
 496         item = evas_object_data_get(icon, KEY_ICON_DATA);
 497         if (!item) {
 498                 LOGE("[FAILED][evas_object_data_get]");
 499                 return false;
 500         }
 501
 502         if (!item->data) {
 503                 LOGE("[FAILED][item->data='%p']", item->data);
 504                 return false;
 505         }
 506
 507         return item->data->removable;
 508 }
 509
 510 static void __app_icon_check_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 511 {
 512         Tree_node_t *node = (Tree_node_t *)data;
 513         app_item_t *item = node->data;
 514         int count = -1;
 515         char trbuf[PATH_MAX] = {0, };
 516
 517         if (item->type == APP_ITEM_ICON) {
 518                 item->is_checked = true;
 519                 if (node->parent->parent->data->type == APP_ITEM_FOLDER && folder_panel_set_content_checked(node->parent->parent))
 520                         elm_object_signal_emit(node->parent->parent->data->layout, SIGNAL_CHECKBOX_SHOW_CHECKED, SIGNAL_SOURCE);
 521         } else if (item->type == APP_ITEM_FOLDER) {
 522                 data_model_check_all_apps(node, true);
 523         }
 524         option_menu_update_on_item_selected();
 525
 526         count = data_model_get_app_check_state();
 527         if (count > FOLDER_MAX_ITEMS) {
 528                 __app_icon_uncheck_cb(data, obj, SIGNAL_CHECKBOX_UNCHECKED, SIGNAL_SOURCE);
 529                 elm_object_signal_emit(node->data->layout, SIGNAL_CHECKBOX_SHOW_UNCHECKED, SIGNAL_SOURCE);
 530
 531                 popup_data_t *p_data = popup_create_data();
 532                 if (!p_data) {
 533                         LOGE("[FAILED][failed to create popup data]");
 534                         return;
 535                 }
 536
 537                 snprintf(trbuf, sizeof(trbuf), _("IDS_HS_TPOP_MAXIMUM_NUMBER_OF_APPLICATIONS_IN_FOLDER_HPD_REACHED"),
 538                         FOLDER_APPS_PAGE);
 539
 540                 p_data->type = POPUP_INFO;
 541                 p_data->popup_title_text = NULL;
 542                 p_data->popup_content_text = strdup(trbuf);
 543                 p_data->popup_confirm_text = NULL;
 544                 p_data->popup_cancel_text = NULL;
 545                 p_data->orientation = ELM_POPUP_ORIENT_CENTER;
 546                 p_data->visible_time = 2.0;
 547
 548                 popup_show(p_data, NULL, NULL, NULL);
 549         }
 550 }
 551
 552 static void __app_icon_uncheck_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 553 {
 554         Tree_node_t *node = (Tree_node_t *)data;
 555         app_item_t *item = node->data;
 556         if (item->type == APP_ITEM_ICON) {
 557                 item->is_checked = false;
 558                 if (node->parent->parent->data->type == APP_ITEM_FOLDER && !folder_panel_set_content_checked(node->parent->parent))
 559                         elm_object_signal_emit(node->parent->parent->data->layout, SIGNAL_CHECKBOX_SHOW_UNCHECKED, SIGNAL_SOURCE);
 560         } else if (item->type == APP_ITEM_FOLDER) {
 561                 data_model_check_all_apps(node, false);
 562         }
 563         option_menu_update_on_item_selected();
 564 }
 565
 566 Evas_Object *__app_icon_load(Evas_Object *parent, const char *icon_path)
 567 {
 568         Evas_Object *icon_image = NULL;
 569
 570         if (!parent || !icon_path) {
 571                 LOGE("Invalid parameter");
 572                 return NULL;
 573         }
 574
 575         icon_image = elm_image_add(parent);
 576         if (!icon_image) {
 577                 LOGE("Failed to create an icon.");
 578                 return NULL;
 579         }
 580
 581         if ((strncmp("", icon_path, strlen(icon_path)) && elm_image_file_set(icon_image, icon_path, NULL)) || elm_image_file_set(icon_image, DEFAULT_APP_ICON, NULL))
 582                 return icon_image;
 583
 584         evas_object_del(icon_image);
 585         return NULL;
 586 }
 587
 588 static void __app_icon_uninstall_button_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 589 {
 590         LOGI("__app_icon_uninstall_button_clicked_cb");
 591         Tree_node_t *app_node = NULL;
 592         char buf[BUF_SIZE] = {0, };
 593
 594         app_node = (Tree_node_t *) data;
 595         if (!app_node) {
 596                 LOGE("[FAILED][evas_object_data_get]");
 597                 return;
 598         }
 599
 600         if (!app_node->data || !app_node->data->label) {
 601                 LOGE("[INVALID][invalid node data]");
 602                 return;
 603         }
 604
 605         popup_data_t *p_data = popup_create_data();
 606         if (!p_data) {
 607                 LOGE("[FAILED][failed to create popup data]");
 608                 return;
 609         }
 610
 611         if ((app_node->data->type == APP_ITEM_FOLDER) && (folder_panel_get_items_count(app_node) > 0)) {
 612                 p_data->type = POPUP_TWO_BUTTONS;
 613                 p_data->popup_title_text = strdup(_("IDS_HS_HEADER_REMOVE_FOLDER_ABB"));
 614                 p_data->popup_content_text = strdup(_("IDS_HS_BODY_FOLDER_WILL_BE_REMOVED_APPLICATIONS_IN_THIS_FOLDER_WILL_NOT_BE_UNINSTALLED"));
 615                 p_data->popup_confirm_text = strdup(_("IDS_ST_BUTTON_REMOVE_ABB2"));
 616                 p_data->popup_cancel_text = strdup(_("IDS_CAM_SK_CANCEL"));
 617                 p_data->orientation = ELM_POPUP_ORIENT_CENTER;
 618                 popup_show(p_data, __app_icon_uninstall, NULL, (void *) obj);
 619         } else if (app_node->data->type == APP_ITEM_ICON) {
 620                 snprintf(buf, sizeof(buf), _("IDS_HS_POP_PS_WILL_BE_UNINSTALLED"), app_node->data->label);
 621                 p_data->type = POPUP_TWO_BUTTONS;
 622                 p_data->popup_title_text = strdup(_("IDS_AT_BODY_UNINSTALL"));
 623                 p_data->popup_content_text = strdup(buf);
 624                 p_data->popup_confirm_text = strdup(_("IDS_AT_BODY_UNINSTALL"));
 625                 p_data->popup_cancel_text = strdup(_("IDS_CAM_SK_CANCEL"));
 626                 p_data->orientation = ELM_POPUP_ORIENT_CENTER;
 627                 popup_show(p_data, __app_icon_uninstall, NULL, (void *) obj);
 628         } else {
 629                 __app_icon_uninstall((void *) obj);
 630                 popup_data_free(p_data);
 631         }
 632 }
 633
 634 static void __app_icon_uninstall(void *data)
 635 {
 636         Tree_node_t *app_node = NULL;
 637         Evas_Object *icon = NULL;
 638
 639         icon = (Evas_Object *) data;
 640         if (!icon) {
 641                 LOGE("[INVALID_PARAM][data='%p']", data);
 642                 return;
 643         }
 644
 645         LOGI("[%s]", evas_object_type_get(icon));
 646
 647         app_node = evas_object_data_get(icon, KEY_ICON_DATA);
 648         if (!app_node || !app_node->data) {
 649                 LOGE("[FAILED][evas_object_data_get]");
 650                 return;
 651         }
 652
 653         all_apps_detach_from_grid(app_node->data->grid_item);
 654         app_node->data->grid_item = NULL;
 655         app_icon_remove(icon);
 656         app_node->data->layout = NULL;
 657
 658         home_screen_mvc_item_uninstall_cb(app_node);
 659 }
 660
 661 static void __app_icon_highlight_folder_icon_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 662 {
 663         Evas_Object *icon = elm_object_part_content_get(obj, PART_ICON_CONTENT);
 664         elm_object_signal_emit(icon, SIGNAL_FRAME_POSSIBLE_SHOW, SIGNAL_SOURCE);
 665 }
 666
 667 static void __app_icon_unhighlight_folder_icon_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 668 {
 669         Evas_Object *icon = elm_object_part_content_get(obj, PART_ICON_CONTENT);
 670         elm_object_signal_emit(icon, SIGNAL_FRAME_HIDE, SIGNAL_SOURCE);
 671 }
 672
 673 static void __app_icon_higlight_impossible_folder_icon_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 674 {
 675         Evas_Object *icon = elm_object_part_content_get(obj, PART_ICON_CONTENT);
 676         elm_object_signal_emit(icon, SIGNAL_FRAME_IMPOSSIBLE_SHOW, SIGNAL_SOURCE);
 677 }
 678 /*===============================================================================================================*/