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