src/features/gl-albums.c

   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 #include <vconf.h>
  18 #include <vconf-keys.h>
  19 #include "gl-debug.h"
  20 #include "gl-albums.h"
  21 #include "gl-gridview.h"
  22 #include "gl-listview.h"
  23 #include "gl-controlbar.h"
  24 #include "gl-ui-util.h"
  25 #include "gl-util.h"
  26 #include "gl-button.h"
  27 #include "gl-db-handler.h"
  28 #include "gl-popup.h"
  29 #include "gl-progressbar.h"
  30 #include "gl-strings.h"
  31
  32 /* Width and height of album item */
  33 #define GL_ALBUM_ITEM_WIDTH 358
  34 #define GL_ALBUM_ITEM_HEIGHT 360
  35
  36 #define GL_ALBUM_COVER_THUMB_1 1
  37 #define GL_ALBUM_COVER_THUMB_2 2
  38 #define GL_ALBUM_COVER_THUMB_3 3
  39
  40 /* Size of album icon */
  41 #define GL_COVER_SIZE 318
  42 /* Size of table padding */
  43 #define GL_COVER_PAD 3
  44 #define GL_COVER_PAD_1 2
  45 /* Pure size of album icon; value: 196 */
  46 #define GL_COVER_ICON_S (GL_COVER_SIZE - 2 * GL_COVER_PAD)
  47 /**
  48 * Album icon is set by elm_table,
  49 * it's divided into 3x3, 9 grids, each grid size is 64
  50 */
  51 #define GL_COVER_GRID_S 102
  52 /* value: 130 */
  53 #define GL_COVER_2X_GRID_S (GL_COVER_ICON_S - GL_COVER_GRID_S - GL_COVER_PAD)
  54
  55 /* Album color level and alpha value */
  56 #define GL_ALBUM_TEXT_COLOR_CNT 6
  57 #define GL_ALBUM_TEXT_COLOR_ALPHA 255
  58
  59 #define GL_CHECKBOX_STYLE_ALBUM "gallery/album"
  60 #define GL_CHECKBOX_STYLE_ALBUM_GRID "gallery/album/grid"
  61 #define GL_GENGRID_STYLE_ALBUM "unclipped"
  62 #define GL_ALBUM_CHECKBOX "elm.swallow.end"
  63 #define GL_ALBUM_CHECKBOX_GRID "elm.swallow.check_grid"
  64 #define GL_ALBUM_RENAME "elm.swallow.rename"
  65 #define GL_GENGRID_STYLE_ALBUM_VIEW  "gallery/albums_view"
  66 #define GL_GENGRID_STYLE_ALBUM_VIEW_BLUE  "gallery/albums_view_blue"
  67
  68
  69 struct gl_color {
  70         int r;
  71         int g;
  72         int b;
  73 };
  74
  75 /**
  76 *  Album "All albums", "Camera shots"
  77 *  bg color is 25:25:25
  78 */
  79 static struct gl_color bg_color[] = {
  80         {50, 50, 50},
  81         {78, 74, 64},
  82         {206, 108, 1},
  83         {157, 35, 39},
  84         {20, 60, 128},
  85         {84, 109, 49},
  86         {25, 25, 25},
  87 };
  88
  89 static void _gl_albums_drag_up(void *data, Evas_Object *obj, void *event_info)
  90 {
  91 }
  92
  93 static void _gl_albums_drag_right(void *data, Evas_Object *obj,
  94                                   void *event_info)
  95 {
  96 }
  97
  98 static void _gl_albums_drag_down(void *data, Evas_Object *obj, void *event_info)
  99 {
 100 }
 101
 102 static void _gl_albums_drag_left(void *data, Evas_Object *obj, void *event_info)
 103 {
 104 }
 105
 106 static void _gl_albums_drag_stop(void *data, Evas_Object *obj, void *event_info)
 107 {
 108 }
 109
 110 void _gl_albums_realized(void *data, Evas_Object *obj, void *event_info)
 111 {
 112 }
 113
 114 static void _gl_albums_selected(void *data, Evas_Object *obj, void *event_info)
 115 {
 116 }
 117
 118 static void _gl_albums_unselected(void *data, Evas_Object *obj,
 119                                   void *event_info)
 120 {
 121 }
 122
 123 static void _gl_albums_clicked(void *data, Evas_Object *obj, void *event_info)
 124 {
 125 }
 126
 127 static void _gl_albums_longpress(void *data, Evas_Object *obj, void *event_info)
 128 {
 129 }
 130
 131 static void _gl_albums_comeback_from_view_cb(void *data,
 132                                              Evas_Object *obj, void *event_info)
 133 {
 134         GL_CHECK(data);
 135         gl_appdata *ad = (gl_appdata *)data;
 136         gl_dbg("");
 137         /* Reset aul launch flag if change to albums view */
 138         ad->albuminfo.aul_launch_by_mime = false;
 139         ad->albuminfo.aul_launch_type = GL_AUL_T_NONE;
 140
 141         gl_albums_del_grid_append_idler(ad);
 142         gl_albums_comeback_from_view(ad);
 143
 144         gl_ui_disable_toolbar_item(ad, false, GL_NAVI_ALBUMS, false);
 145 }
 146
 147 static Eina_Bool _gl_albums_append_grid_idler(void *data)
 148 {
 149         GL_CHECK_CANCEL(data);
 150
 151         /* Try to get other medias from DB and append them to gridview */
 152         int ret = gl_grid_idler_append_items(data);
 153         if (ret < 0) {
 154                 gl_dbg("Failed to append grid items!");
 155                 /* Maybe all medias were already showed */
 156                 if (ret == MB_SVC_ERROR_DB_NO_RECORD)
 157                         gl_dbg("No any more records!");
 158         } else {
 159                 gl_dbg("Successful to append grid items!");
 160         }
 161
 162         /* Remove idler after all items appended */
 163         gl_albums_del_grid_append_idler(data);
 164
 165         return ECORE_CALLBACK_CANCEL;
 166 }
 167
 168 /**
 169 * @Brif Update checkbox state and album cover and update selectioninfo.
 170 *
 171 * @Param data  gl_appdata.
 172 * @Param album_item  album item.
 173 * @Param check_obj  object of checkbox.
 174 * @Param b_ck_box  true: Checkbox selection, false: album cover selection.
 175 */
 176 static int _gl_albums_update_check_state(void *data,
 177                                          gl_cluster *album_item,
 178                                          Evas_Object *check_obj, bool b_ck_box)
 179 {
 180         GL_CHECK_VAL(album_item, -1);
 181         GL_CHECK_VAL(album_item->cluster, -1);
 182         GL_CHECK_VAL(album_item->cluster->uuid, -1);
 183         GL_CHECK_VAL(check_obj, -1);
 184         GL_CHECK_VAL(data, -1);
 185         gl_appdata *ad = (gl_appdata *)data;
 186         gl_dbg("Select checkbox[1]/album_cover[0]: %d.", b_ck_box);
 187
 188         /* Update state of checkbox */
 189         album_item->checked = !album_item->checked;
 190         gl_dbg("album (%s) check state: %d", album_item->cluster->display_name,
 191                album_item->checked);
 192
 193         /**
 194         * If album cover selected, update checkbox icon manually,
 195         * If checkbox selected, its icon is updated by system automatically.
 196         */
 197         Evas_Object *ck = NULL;
 198         if (b_ck_box == false)
 199                 ck = elm_object_item_part_content_get(album_item->item,
 200                                                       GL_ALBUM_CHECKBOX);
 201         else
 202                 ck = elm_object_item_part_content_get(album_item->item,
 203                                                       GL_ALBUM_CHECKBOX_GRID);
 204         elm_check_state_set(ck, album_item->checked);
 205
 206         if (album_item->checked) {
 207                 gl_dbg("Append:%s, id:%s", album_item->cluster->display_name,
 208                        album_item->cluster->uuid);
 209                 gl_db_albums_selected_list_append(ad, album_item);
 210         } else {
 211                 gl_dbg("Remove:%s, id:%s", album_item->cluster->display_name,
 212                        album_item->cluster->uuid);
 213                 gl_db_albums_selected_list_remove(ad, album_item);
 214         }
 215
 216         /* Display selectioninfo */
 217         int cnt = gl_db_get_albums_selected_cnt(ad);
 218         gl_ui_create_selinfo(ad, ad->albuminfo.edit_layout,
 219                              ad->albuminfo.nf_it_edit, ad->albuminfo.albums_cnt,
 220                              cnt, false);
 221
 222         return 0;
 223 }
 224
 225 static void _gl_albums_check_changed(void *data, Evas_Object *obj,
 226                                      void *event_info)
 227 {
 228         GL_CHECK(obj);
 229         GL_CHECK(data);
 230         gl_cluster *album_item = (gl_cluster *)data;
 231         GL_CHECK(album_item->ad);
 232         gl_appdata *ad = (gl_appdata *)album_item->ad;
 233         gl_dbg("");
 234
 235         if (gl_get_view_mode(ad) != GL_VIEW_ALBUMS_EDIT) {
 236                 gl_dbgE("Wrong view mode!");
 237                 return;
 238         }
 239
 240         /* Checkbox selected, b_ck_box=true */
 241         _gl_albums_update_check_state(ad, album_item, obj, true);
 242 }
 243
 244 static void _gl_albums_check_grid_changed(void *data, Evas_Object *obj,
 245                                            void *event_info)
 246 {
 247         GL_CHECK(obj);
 248         GL_CHECK(data);
 249         gl_cluster *album_item = (gl_cluster *)data;
 250         GL_CHECK(album_item->ad);
 251         gl_appdata *ad = (gl_appdata *)album_item->ad;
 252         gl_dbg("");
 253
 254         if (gl_get_view_mode(ad) != GL_VIEW_ALBUMS_EDIT) {
 255                 gl_dbgE("Wrong view mode!");
 256                 return;
 257         } else {
 258                 /* gl_dbg("EditMode"); */
 259         }
 260
 261         /* Grid checkbox selected, b_ck_box=false */
 262         _gl_albums_update_check_state(ad, album_item, obj, false);
 263 }
 264
 265 /* Callback of normal icon */
 266 static void __gl_albums_sel_cb(void *data,Evas_Object *obj, void *event_info)
 267 {
 268         GL_CHECK(event_info);
 269         GL_CHECK(data);
 270         gl_cluster *album_item = (gl_cluster *)data;
 271         GL_CHECK(album_item->cluster);
 272         GL_CHECK(album_item->ad);
 273         gl_appdata *ad = (gl_appdata *)album_item->ad;
 274         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event_info;
 275
 276         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
 277                 return;
 278
 279         int view_mode = gl_get_view_mode(ad);
 280         gl_dbg("view mode: %d.", view_mode);
 281         if (view_mode != GL_VIEW_ALBUMS_EDIT) {
 282                 if (album_item->cluster->count == 0) {
 283                         gl_dbgW("Empty album, return;");
 284                         return;
 285                 }
 286                 gl_albums_sel_album(album_item);
 287         }
 288 }
 289
 290 static void __gl_rename_album_job_cb(void *userdata)
 291 {
 292         GL_CHECK(userdata);
 293         gl_cluster *album_item = (gl_cluster *)userdata;
 294         gl_ui_rename_album(album_item);
 295         return;
 296 }
 297
 298 static void _gl_albums_rename_btn_cb(void *data, Evas_Object *obj,
 299                                      void *event_info)
 300 {
 301         gl_dbg("");
 302         GL_CHECK(data);
 303         gl_cluster *album_item = (gl_cluster *)data;
 304         gl_appdata *ad = (gl_appdata *)album_item->ad;
 305
 306         /* Return if album selected */
 307         if (!album_item->checked) {
 308                 gl_dbgW("Album checked!");
 309                 return;
 310         }
 311
 312         /* Album cover selected, b_ck_box=false, deselect checkbox */
 313         Evas_Object *ck = NULL;
 314         ck = elm_object_item_part_content_get(album_item->item,
 315                                               GL_ALBUM_CHECKBOX);
 316         _gl_albums_update_check_state(ad, album_item, ck, false);
 317
 318         if(ad->maininfo.rename_album_job) {
 319                 ecore_job_del(ad->maininfo.rename_album_job);
 320                 ad->maininfo.rename_album_job = NULL;
 321         }
 322         ad->maininfo.rename_album_job = ecore_job_add(__gl_rename_album_job_cb,album_item);
 323 }
 324
 325 char *_gl_albums_get_text(void *data, Evas_Object *obj, const char *part)
 326 {
 327         GL_CHECK_NULL(part);
 328         GL_CHECK_NULL(strlen(part));
 329         GL_CHECK_NULL(data);
 330         gl_cluster *album_item = (gl_cluster *)data;
 331         GL_CHECK_NULL(album_item->cluster);
 332         GL_CHECK_NULL(album_item->cluster->display_name);
 333         GL_CHECK_NULL(album_item->cluster->uuid);
 334         GL_CHECK_NULL(album_item->ad);
 335         gl_appdata *ad = (gl_appdata *)album_item->ad;
 336         char buf[GL_ALBUM_NAME_LEN_MAX] = { 0, };
 337
 338         if (!strcmp(part, "elm.text.name")) {
 339                 gl_dbg("text.name");
 340                 if (album_item->cluster->display_name &&
 341                     strlen(album_item->cluster->display_name))
 342                         snprintf(buf, sizeof(buf), "%s",
 343                                  (char *)(album_item->cluster->display_name));
 344                 else if (gl_db_is_root_path(ad, album_item->cluster->uuid, NULL))
 345                         snprintf(buf, sizeof(buf), GL_ALBUM_PHOME_ROOT_NAME);
 346                 else
 347                         gl_dbgE("Album name[%s] is wrong!",
 348                                 album_item->cluster->display_name);
 349         } else if (!strcmp(part, "elm.text.date")) {
 350                 struct tm t1;
 351                 struct tm t2;
 352                 char date1[GL_DATE_INFO_LEN_MAX] = { 0, };
 353                 char date2[GL_DATE_INFO_LEN_MAX] = { 0, };
 354                 char date3[GL_DATE_INFO_LEN_MAX] = { 0, };
 355                 int i = 0;
 356                 int item_count = GL_ALBUM_COVER_THUMB_NUM;
 357                 gl_item **items1 = ad->albuminfo.cover_thumbs;
 358                 gl_albums_free_cover_thumbs(ad);
 359
 360                 gl_db_get_first_several_items(album_item,
 361                                               items1, &item_count,
 362                                               MINFO_MEDIA_SORT_BY_DATE_DESC);
 363
 364
 365                 if (item_count <= 0) {
 366                         gl_dbg("Empty album...");
 367                         ad->albuminfo.album_medias_cnt = 0;
 368                         return NULL;
 369                 }
 370
 371                 ad->albuminfo.album_medias_cnt = item_count;
 372                 if (items1[0] == NULL || items1[0]->item == NULL) {
 373                         gl_dbgE("[Error] Invalid item!");
 374                         ad->albuminfo.album_medias_cnt = 0;
 375                         return NULL;
 376                 }
 377                 memcpy(&album_item->item_mtime,
 378                        &(items1[0]->item->mtime), sizeof(time_t));
 379
 380                 item_count = 1;
 381                 gl_item *items2[1];
 382                 int sort_t = MINFO_MEDIA_SORT_BY_DATE_ASC;
 383                 memset(items2, 0x00, item_count * sizeof(int));
 384                 gl_db_get_first_several_items(album_item,
 385                                               items2, &item_count,
 386                                               sort_t);
 387
 388                 if (item_count <= 0) {
 389                         gl_dbg("Empty album...");
 390                         return NULL;
 391                 } else {
 392                         memset(&t1, 0x00, sizeof(struct tm));
 393                         localtime_r((time_t *)&(album_item->item_mtime),
 394                                     &t1);
 395                         strftime(date1, sizeof(date1), "%Y.%m.%d", &t1);
 396                         strftime(date3, sizeof(date3), "%Y.%m", &t1);
 397
 398                         if (items2[0] == NULL
 399                             || items2[0]->item == NULL) {
 400                                 gl_dbgE("Invalid items2[0].");
 401                                 ad->albuminfo.album_medias_cnt = 0;
 402                                 return NULL;
 403                         }
 404                         memset(&t2, 0x00, sizeof(struct tm));
 405                         localtime_r((time_t *)&(items2[0]->item->mtime),
 406                                     &t2);
 407                         strftime(date2, sizeof(date2), "%Y.%m.%d", &t2);
 408
 409                         if (!strcmp(date1, date2)) {
 410                                 g_strlcpy(buf, date1, sizeof(buf));
 411                         } else {
 412                                 strftime(date2, sizeof(date2), "%Y.%m",
 413                                          &t2);
 414                                 snprintf(buf, sizeof(buf), "%s - %s",
 415                                          date2, date3);
 416                         }
 417                 }
 418
 419                 for (i = 0; i < item_count; i++) {
 420                         gl_db_destroy_item(items2[i]);
 421                         items2[i] = NULL;
 422                 }
 423         } else if (!strcmp(part, "elm.text.count")) {
 424                 gl_db_update_item_cnt(album_item);
 425                 snprintf(buf, sizeof(buf), "%d",
 426                          (int)(album_item->cluster->count));
 427         }
 428
 429         return strdup(buf);
 430
 431 }
 432
 433 static Evas_Object *_gl_albums_add_1_icon_bg(Evas_Object *obj, gl_item *git,
 434                                              int wid, int hei)
 435 {
 436         GL_CHECK_NULL(obj);
 437         Evas_Object *bg = elm_bg_add(obj);
 438         GL_CHECK_NULL(bg);
 439         elm_bg_load_size_set(bg, wid, hei);
 440
 441         _gl_ui_elm_bg_file_set(bg, git);
 442
 443         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 444                                          EVAS_HINT_EXPAND);
 445         evas_object_size_hint_align_set(bg, 0.5, 0.5);
 446         evas_object_show(bg);
 447
 448         return bg;
 449 }
 450
 451 static Evas_Object *_gl_albums_add_1st_icon_bg(Evas_Object *obj, gl_item *git,
 452                                                int wid, int hei)
 453 {
 454         GL_CHECK_NULL(obj);
 455         Evas_Object *bg = elm_bg_add(obj);
 456         GL_CHECK_NULL(bg);
 457         elm_bg_load_size_set(bg, wid, hei);
 458
 459         _gl_ui_elm_bg_file_set(bg, git);
 460
 461         evas_object_size_hint_min_set(bg, wid, hei);
 462         evas_object_size_hint_aspect_set(bg, EVAS_ASPECT_CONTROL_VERTICAL,
 463                                          1, 1);
 464         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 465                                          EVAS_HINT_EXPAND);
 466         evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 467         evas_object_show(bg);
 468         return bg;
 469 }
 470
 471 static Evas_Object *_gl_albums_add_3_icon_bg(Evas_Object *obj, gl_item **items,
 472                                              int length, double scale)
 473 {
 474         GL_CHECK_NULL(obj);
 475         gl_item *git = NULL;
 476         int i = 0;
 477         int r1 = 0;
 478         int wid = 0;
 479         int hei = 0;
 480         Evas_Object *bg = NULL;
 481         int tp_val = 0;
 482         Evas_Object *tb = elm_table_add(obj);
 483         GL_CHECK_NULL(tb);
 484         elm_table_padding_set(tb, GL_COVER_PAD * scale, GL_COVER_PAD * scale);
 485
 486         r1 = 1;
 487         for (i = 1; i < length; i++) {
 488                 git = items[i];
 489                 bg = elm_bg_add(tb);
 490                 GL_CHECK_NULL(bg);
 491                 if (i == 1) {
 492                         wid = (int)(GL_COVER_2X_GRID_S * scale);
 493                         hei = wid;
 494                 } else {
 495                         wid = (int)(GL_COVER_GRID_S * scale);
 496                         hei = (int)(GL_COVER_2X_GRID_S * scale);
 497                 }
 498                 elm_bg_load_size_set(bg, wid, hei);
 499                 evas_object_size_hint_min_set(bg, wid, hei);
 500                 elm_table_padding_set(tb, GL_COVER_PAD_1 * scale,
 501                                       GL_COVER_PAD_1 * scale);
 502
 503                 _gl_ui_elm_bg_file_set(bg, git);
 504
 505                 evas_object_size_hint_aspect_set(bg, EVAS_ASPECT_CONTROL_VERTICAL,
 506                                                  1, 1);
 507                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 508                                                  EVAS_HINT_EXPAND);
 509                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL,
 510                                                 EVAS_HINT_FILL);
 511                 if (i == 1) {
 512                         elm_table_pack(tb, bg, 0, 0, 2, 2);
 513                 } else {
 514                         tp_val = EVAS_ASPECT_CONTROL_VERTICAL;
 515                         evas_object_size_hint_aspect_set(bg, tp_val, 1, 1);
 516                         elm_table_pack(tb, bg, 2, 0, 1, 2);
 517                 }
 518                 evas_object_show(bg);
 519         }
 520
 521         return tb;
 522 }
 523
 524 static Evas_Object *_gl_albums_add_4_icon_bg(Evas_Object *obj, gl_item **items,
 525                                              int length, double scale)
 526 {
 527         GL_CHECK_NULL(obj);
 528         gl_item *git = NULL;
 529         int i = 0;
 530         int r1 = 0;
 531         int wid = 0;
 532         int hei = 0;
 533         Evas_Object *bg = NULL;
 534
 535         Evas_Object *tb = elm_table_add(obj);
 536         GL_CHECK_NULL(tb);
 537         elm_table_padding_set(tb, GL_COVER_PAD * scale, GL_COVER_PAD * scale);
 538         elm_table_padding_set(tb, GL_COVER_PAD_1 * scale,
 539                               GL_COVER_PAD_1 * scale);
 540         r1 = 1;
 541         for (i = 1; i < length; i++) {
 542                 git = items[i];
 543                 bg = elm_bg_add(tb);
 544                 GL_CHECK_NULL(bg);
 545                 if (i == 1) {
 546                         wid = (int)(GL_COVER_2X_GRID_S * scale);
 547                         hei = wid;
 548                 } else {
 549                         wid = (int)(GL_COVER_GRID_S * scale);
 550                         hei = wid;
 551                 }
 552                 elm_bg_load_size_set(bg, wid, hei);
 553                 evas_object_size_hint_min_set(bg, wid, hei);
 554
 555                 _gl_ui_elm_bg_file_set(bg, git);
 556
 557                 evas_object_size_hint_aspect_set(bg,
 558                                                  EVAS_ASPECT_CONTROL_VERTICAL,
 559                                                  1, 1);
 560                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 561                                                  EVAS_HINT_EXPAND);
 562                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL,
 563                                                 EVAS_HINT_FILL);
 564                 if (i == 1)
 565                         elm_table_pack(tb, bg, 0, 0, 2, 2);
 566                 else if (i == 2)
 567                         elm_table_pack(tb, bg, 2, 0, 1, 1);
 568                 else if (i == 3)
 569                         elm_table_pack(tb, bg, 2, 1, 1, 1);
 570                 evas_object_show(bg);
 571         }
 572
 573         return tb;
 574 }
 575
 576 static Evas_Object *_gl_albums_add_7_icon_bg(Evas_Object *obj, gl_cluster *album,
 577                                              gl_item **items, int length, int idx,
 578                                              double scale)
 579 {
 580         GL_CHECK_NULL(album);
 581         GL_CHECK_NULL(album->cluster);
 582         GL_CHECK_NULL(album->cluster->uuid);
 583         GL_CHECK_NULL(obj);
 584         gl_item *git = NULL;
 585         int i = 0;
 586         int j = 0;
 587         int wid = 0;
 588         int hei = 0;
 589         Evas_Object *bg = NULL;
 590
 591         Evas_Object *tb = elm_table_add(obj);
 592         GL_CHECK_NULL(tb);
 593         elm_table_padding_set(tb, GL_COVER_PAD * scale, GL_COVER_PAD * scale);
 594
 595         wid = (int)(GL_COVER_GRID_S * scale);
 596         hei = wid;
 597
 598         for (i = 1; i < GL_ALBUM_COVER_THUMB_NUM; i++) {
 599                 if (i < length) {
 600                         git = items[i];
 601                         bg = elm_bg_add(tb);
 602                         GL_CHECK_NULL(bg);
 603                         elm_bg_load_size_set(bg, wid, hei);
 604                         _gl_ui_elm_bg_file_set(bg, git);
 605                 } else {
 606                         Evas *evas = evas_object_evas_get(obj);
 607                         GL_CHECK_NULL(evas);
 608                         bg = evas_object_rectangle_add(evas);
 609                         GL_CHECK_NULL(bg);
 610                         if (!g_strcmp0(album->cluster->uuid, GL_ALBUM_ALL_ID) ||
 611                             gl_db_is_default_album(album->ad, album->cluster))
 612                                 j = GL_ALBUM_TEXT_COLOR_CNT;
 613                         else
 614                                 j = idx % GL_ALBUM_TEXT_COLOR_CNT;
 615                         evas_object_color_set(bg, bg_color[j].r, bg_color[j].g,
 616                                               bg_color[j].b,
 617                                               GL_ALBUM_TEXT_COLOR_ALPHA);
 618                 }
 619
 620                 evas_object_size_hint_aspect_set(bg,
 621                                                  EVAS_ASPECT_CONTROL_VERTICAL,
 622                                                  1, 1);
 623                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 624                                                  EVAS_HINT_EXPAND);
 625                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL,
 626                                                 EVAS_HINT_FILL);
 627                 elm_table_pack(tb, bg, (int)((i - 1) % 3), (int)((i - 1) / 3),
 628                                1, 1);
 629                 evas_object_show(bg);
 630         }
 631
 632         return tb;
 633 }
 634
 635 Evas_Object *_gl_albums_get_content(void *data, Evas_Object *obj, const char *part)
 636 {
 637         GL_CHECK_NULL(part);
 638         GL_CHECK_NULL(strlen(part));
 639         GL_CHECK_NULL(data);
 640         gl_cluster *album_item = (gl_cluster *)data;
 641         GL_CHECK_NULL(album_item->cluster);
 642         GL_CHECK_NULL(album_item->ad);
 643         gl_appdata *ad = (gl_appdata *)album_item->ad;
 644         double scale = ad->maininfo.win_scale;
 645         GL_CHECK_NULL(album_item->cluster->uuid);
 646         const char *al_id = album_item->cluster->uuid;
 647         int view_mode = gl_get_view_mode(ad);
 648         int idx = album_item->index;
 649         int j = 0;
 650
 651         if ((!strcmp(part, "elm.swallow.firsticon")) ||
 652             (!strcmp(part, "elm.swallow.icon")) ||
 653             (!strcmp(part, "elm.swallow.onlyicon"))) {
 654                 if (view_mode != GL_VIEW_ALBUMS &&
 655                     view_mode != GL_VIEW_ALBUMS_EDIT)
 656                         return NULL;
 657
 658                 gl_item **items = ad->albuminfo.cover_thumbs;
 659                 int len = ad->albuminfo.album_medias_cnt;
 660                 if (len <= 0) {
 661                         gl_dbg("Empty local album.");
 662                         return NULL;
 663                 }
 664
 665                 Evas_Object *bg = NULL;
 666                 int wid = 0;
 667                 int hei = 0;
 668                 gl_item *gl_it = NULL;
 669
 670                 if (!strcmp(part, "elm.swallow.onlyicon")) {
 671                         if (len != GL_ALBUM_COVER_THUMB_1) {
 672                                 return NULL;
 673                         } else {
 674                                 wid = (int)(GL_COVER_ICON_S * scale);
 675                                 hei = wid;
 676                                 gl_it = items[0];
 677                                 bg = _gl_albums_add_1_icon_bg(obj, gl_it, wid,
 678                                                               hei);
 679                                 return bg;
 680                         }
 681                 }
 682
 683                 if (!strcmp(part, "elm.swallow.firsticon")) {
 684                         gl_dbg("firsticon");
 685                         if (len <= GL_ALBUM_COVER_THUMB_1) {
 686                                 return NULL;
 687                         } else {
 688                                 wid = (int)(GL_COVER_GRID_S * scale);
 689                                 hei = wid;
 690                                 gl_it = items[0];
 691                                 bg = _gl_albums_add_1st_icon_bg(obj, gl_it, wid,
 692                                                                 hei);
 693
 694                                 return bg;
 695                         }
 696                 }
 697
 698                 if (!strcmp(part, "elm.swallow.icon")) {
 699                         gl_dbg("icon");
 700                         Evas_Object *tb = NULL;
 701                         if (len == GL_ALBUM_COVER_THUMB_1) {
 702                                 return NULL;
 703                         } else if (len == GL_ALBUM_COVER_THUMB_2) {
 704                                 wid = (int)(GL_COVER_ICON_S * scale);
 705                                 hei = (int)(GL_COVER_2X_GRID_S * scale);
 706                                 gl_it = items[1];
 707                                 bg = _gl_albums_add_1_icon_bg(obj, gl_it, wid,
 708                                                               hei);
 709                                 return bg;
 710                         } else if (len == GL_ALBUM_COVER_THUMB_3) {
 711                                 tb = _gl_albums_add_3_icon_bg(obj, items, len,
 712                                                               scale);
 713                         } else if (len < GL_ALBUM_COVER_THUMB_NUM) {
 714                                 len = GL_ALBUM_COVER_THUMB_NUM_SEC;
 715                                 tb = _gl_albums_add_4_icon_bg(obj, items, len,
 716                                                               scale);
 717                         } else {
 718                                 /**
 719                                 * Set 7 grid for 'All' album
 720                                 * and 'Camera shots'.
 721                                 */
 722                                 Mcluster *mclu = album_item->cluster;
 723                                 bool is_def = false;
 724                                 is_def = gl_db_is_default_album(ad, mclu);
 725
 726                                 if (!g_strcmp0(al_id, GL_ALBUM_ALL_ID) ||
 727                                     is_def) {
 728                                         tb = _gl_albums_add_7_icon_bg(obj,
 729                                                                       album_item,
 730                                                                       items,
 731                                                                       len,
 732                                                                       idx,
 733                                                                       scale);
 734                                 } else {
 735                                         int al_len = 0;
 736                                         al_len = GL_ALBUM_COVER_THUMB_NUM_SEC;
 737                                         tb = _gl_albums_add_4_icon_bg(obj,
 738                                                                       items,
 739                                                                       al_len,
 740                                                                       scale);
 741                                 }
 742                         }
 743                         evas_object_show(tb);
 744                         return tb;
 745                 }
 746         } else if (!strcmp(part, "label_bg")) {
 747                 Evas *evas = evas_object_evas_get(obj);
 748                 GL_CHECK_NULL(evas);
 749                 Evas_Object *bg = NULL;
 750                 bg = evas_object_rectangle_add(evas);
 751                 GL_CHECK_NULL(bg);
 752                 /**
 753                 *  for "All albums", and "Camera shots", their colors should be
 754                 *  25:25:25 by new gui
 755                 */
 756                 if (!g_strcmp0(al_id, GL_ALBUM_ALL_ID) ||
 757                     gl_db_is_default_album(ad, album_item->cluster))
 758                         j = GL_ALBUM_TEXT_COLOR_CNT;
 759                 else
 760                         j = idx % GL_ALBUM_TEXT_COLOR_CNT;
 761                 evas_object_color_set(bg, bg_color[j].r, bg_color[j].g,
 762                                       bg_color[j].b,
 763                                       GL_ALBUM_TEXT_COLOR_ALPHA);
 764
 765                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 766                                                  EVAS_HINT_EXPAND);
 767                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL,
 768                                                 EVAS_HINT_FILL);
 769                 evas_object_show(bg);
 770                 return bg;
 771         } else if (!strcmp(part, GL_ALBUM_CHECKBOX_GRID) &&
 772                    view_mode == GL_VIEW_ALBUMS_EDIT) {
 773                 Evas_Object *ck = NULL;
 774                 ck = elm_check_add(obj);
 775                 GL_CHECK_NULL(ck);
 776                 elm_object_style_set(ck, GL_CHECKBOX_STYLE_ALBUM_GRID);
 777                 evas_object_repeat_events_set(ck, EINA_TRUE);
 778                 elm_check_state_set(ck, album_item->checked);
 779                 evas_object_smart_callback_add(ck, "changed",
 780                                                _gl_albums_check_grid_changed,
 781                                                data);
 782                 evas_object_show(ck);
 783                 return ck;
 784         } else if (!strcmp(part, GL_ALBUM_CHECKBOX) &&
 785                    view_mode == GL_VIEW_ALBUMS_EDIT) {
 786                 Evas_Object *ck = NULL;
 787                 ck = elm_check_add(obj);
 788                 GL_CHECK_NULL(ck);
 789                 elm_object_style_set(ck, GL_CHECKBOX_STYLE_ALBUM);
 790                 evas_object_propagate_events_set(ck, EINA_FALSE);
 791                 elm_check_state_set(ck, album_item->checked);
 792                 evas_object_smart_callback_add(ck, "changed",
 793                                                _gl_albums_check_changed,
 794                                                data);
 795                 evas_object_show(ck);
 796                 return ck;
 797         } else if (!strcmp(part, GL_ALBUM_RENAME) &&
 798                    view_mode == GL_VIEW_ALBUMS_EDIT) {
 799                 /**
 800                 * Fixme: In My Files app, it's unable to rename
 801                 * 'My video clips', 'Wallpapers' and 'My photo clips'.
 802                 * Maybe we need to remove rename button
 803                 * from these three albums cover.
 804                 */
 805
 806                 /**
 807                 * Don't add rename button to 'All albums',
 808                 * and 'Camera shot'[default album]
 809                 */
 810                 if (!g_strcmp0(al_id, GL_ALBUM_ALL_ID) ||
 811                     gl_db_is_default_album(ad, album_item->cluster))
 812                         return NULL;
 813
 814                 Evas_Object *btn = NULL;
 815                 btn = _gl_but_create_but(obj, GL_BUT_NONE,
 816                                          GL_BUTTON_STYLE_RENAME);
 817                 GL_CHECK_NULL(btn);
 818                 evas_object_propagate_events_set(btn, EINA_FALSE);
 819                 evas_object_smart_callback_add(btn, "clicked",
 820                                                _gl_albums_rename_btn_cb, data);
 821                 return btn;
 822         }
 823         return NULL;
 824 }
 825
 826 static int _gl_albums_create_items(void *data, Evas_Object *parent)
 827 {
 828         GL_CHECK_VAL(parent, -1);
 829         GL_CHECK_VAL(data, -1);
 830         gl_appdata *ad = (gl_appdata *)data;
 831         int i = 0;
 832         gl_cluster *album_item = NULL;
 833         int length = 0;
 834         int view_mode = gl_get_view_mode(ad);
 835         gl_dbg("");
 836
 837         /* Clear albums view */
 838         elm_gengrid_clear(parent);
 839
 840         ad->albuminfo.albumgic.item_style = GL_GENGRID_STYLE_ALBUM_VIEW;
 841         ad->albuminfo.albumgic.func.text_get = _gl_albums_get_text;
 842         ad->albuminfo.albumgic.func.content_get = _gl_albums_get_content;
 843         /* Show blue folder name */
 844         ad->albuminfo.albumgic_blue.item_style = GL_GENGRID_STYLE_ALBUM_VIEW_BLUE;
 845         ad->albuminfo.albumgic_blue.func.text_get = _gl_albums_get_text;
 846         ad->albuminfo.albumgic_blue.func.content_get = _gl_albums_get_content;
 847
 848         GL_CHECK_VAL(ad->albuminfo.cluster_list, -1);
 849         GL_CHECK_VAL(ad->albuminfo.cluster_list->clist, -1);
 850         Eina_List *clist = ad->albuminfo.cluster_list->clist;
 851         length = eina_list_count(clist);
 852         gl_dbg("Albums length: %d", length);
 853         const char *al_id = NULL;
 854         Elm_Gengrid_Item_Class *pgic = &(ad->albuminfo.albumgic);
 855         Elm_Gengrid_Item_Class *pgic_blue = &(ad->albuminfo.albumgic_blue);
 856         int item_cnt = 0;
 857
 858         for (i = 0; i < length; i++) {
 859                 album_item = eina_list_nth(clist, i);
 860                 GL_CHECK_VAL(album_item, -1);
 861                 GL_CHECK_VAL(album_item->cluster, -1);
 862                 GL_CHECK_VAL(album_item->cluster->display_name, -1);
 863                 GL_CHECK_VAL(album_item->cluster->uuid, -1);
 864                 al_id = album_item->cluster->uuid;
 865
 866
 867                 if (view_mode == GL_VIEW_ALBUMS_EDIT) {
 868                         if (!g_strcmp0(al_id, GL_ALBUM_ALL_ID) )
 869                                 continue;
 870                 }
 871
 872                 /* Show blue folder name */
 873                 if (!g_strcmp0(album_item->cluster->uuid, GL_ALBUM_ALL_ID) ||
 874                     gl_db_is_default_album(ad, album_item->cluster))
 875                         album_item->item = elm_gengrid_item_append(parent,
 876                                                                    pgic_blue,
 877                                                                    album_item,
 878                                                                    __gl_albums_sel_cb,
 879                                                                    album_item);
 880                 else
 881                         album_item->item = elm_gengrid_item_append(parent, pgic,
 882                                                                    album_item,
 883                                                                    __gl_albums_sel_cb,
 884                                                                    album_item);
 885                 album_item->index = item_cnt;
 886                 item_cnt++;
 887                 gl_dbg("Append[%s], id=%s.", album_item->cluster->display_name,
 888                        al_id);
 889         }
 890
 891         ad->albuminfo.albums_cnt = item_cnt;
 892
 893         return 0;
 894 }
 895
 896 int gl_albums_sel_album(gl_cluster *album_item)
 897 {
 898         GL_CHECK_VAL(album_item, -1);
 899         GL_CHECK_VAL(album_item->cluster, -1);
 900         GL_CHECK_VAL(album_item->cluster->uuid, -1);
 901         GL_CHECK_VAL(album_item->ad, -1);
 902         gl_appdata *ad = (gl_appdata *)album_item->ad;
 903         GL_CHECK_VAL(ad->albuminfo.cluster_list, -1);
 904         GL_CHECK_VAL(ad->albuminfo.cluster_list->clist, -1);
 905         int view_mode = gl_get_view_mode(ad);
 906
 907         if (view_mode != GL_VIEW_ALBUMS) {
 908                 gl_dbgE("Wrong view mode!");
 909                 return -1;
 910         } else {
 911                 gl_dbg("ViewMode");
 912         }
 913
 914         Evas_Object *layout = NULL;
 915         char *al_na = album_item->cluster->display_name;
 916         Evas_Object *navi = ad->maininfo.navi_bar;
 917         gl_dbg("current %s album, id=%s, cluster_index=%d",
 918                al_na, album_item->cluster->uuid, album_item->index);
 919         ad->albuminfo.current_album = album_item;
 920         /* Remove idler */
 921         gl_albums_del_grid_append_idler(ad);
 922
 923         gl_db_get_item_list(ad, album_item, GL_FIRST_VIEW_START_POS,
 924                             GL_FIRST_VIEW_END_POS);
 925
 926         gl_set_view_mode(ad, GL_VIEW_THUMBS);
 927         /* Save the index of current selected album */
 928         ad->albuminfo.cluster_list->cur_pos = album_item->index;
 929         gl_dbg("Album index: %d", album_item->index);
 930         layout = gl_ui_create_view_ly(navi);
 931         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND,
 932                                          EVAS_HINT_EXPAND);
 933         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 934         Evas_Object *gv = gl_grid_create_view(ad, navi, GL_GRID_ALL);
 935         elm_object_part_content_set(layout, "elm.swallow.view", gv);
 936         ad->gridinfo.all_view = gv;
 937         ad->gridinfo.layout = layout;
 938
 939         /* View mode reset, Update view mode */
 940         view_mode = gl_get_view_mode(ad);
 941         if (view_mode != GL_VIEW_THUMBS) {
 942                 gl_dbgE("View mode is wrong!");
 943                 return -1;
 944         }
 945
 946         gl_navi_mode mode = GL_NAVI_THUMBS;
 947         /* check root case */
 948         if (gl_db_is_root_path(ad, album_item->cluster->uuid, NULL))
 949                 al_na = GL_ALBUM_PHOME_ROOT_NAME;
 950
 951         /* Clear view */
 952         elm_gengrid_clear(ad->albuminfo.view);
 953
 954         gl_ui_create_title_and_push(ad, navi, layout, mode, al_na);
 955
 956         gl_dbg("albums_view 0x%x cleared", ad->albuminfo.view);
 957
 958         Evas_Object *bk_btn = NULL;
 959         bk_btn = elm_object_item_part_content_get(ad->gridinfo.nf_it,
 960                                                   GE_NAVIFRAME_PREB_BTN);
 961         elm_object_style_set(bk_btn, GL_BUTTON_STYLE_NAVI_PRE);
 962         evas_object_smart_callback_add(bk_btn, "clicked",
 963                                        _gl_albums_comeback_from_view_cb, ad);
 964
 965         edje_object_signal_emit(_EDJ(layout), "elm,swallow_view,state,default",
 966                                 "elm");
 967         gl_dbg("Done albums selected");
 968
 969         if (ad->maininfo.medias_cnt == (GL_FIRST_VIEW_END_POS + 1)) {
 970                 gl_dbg("\n\n\tIdler to append other medias--Start\n");
 971                 Ecore_Idler *ap_idl = NULL;
 972                 ap_idl = ecore_idler_add(_gl_albums_append_grid_idler, ad);
 973                 ad->gridinfo.append_idler = ap_idl;
 974         }
 975
 976         return 0;
 977 }
 978
 979 Evas_Object *gl_albums_create_view(void *data, Evas_Object *parent)
 980 {
 981         GL_CHECK_NULL(parent);
 982         GL_CHECK_NULL(data);
 983         gl_appdata *ad = (gl_appdata *)data;
 984         GL_CHECK_NULL(ad->albuminfo.cluster_list);
 985         gl_dbg("");
 986
 987         gl_albums_free_cover_thumbs(ad);
 988         memset(ad->albuminfo.cover_thumbs, 0x00,
 989                GL_ALBUM_COVER_THUMB_NUM * sizeof(int));
 990         ad->albuminfo.album_medias_cnt = 0;
 991
 992         Evas_Object *grid = elm_gengrid_add(parent);
 993         elm_object_style_set(grid, GL_GENGRID_STYLE_ALBUM);
 994
 995         double scale_factor = ad->maininfo.win_scale;
 996         gl_dbg("Own scale: %f, elm_config_scale_get =%f", scale_factor,
 997                elm_config_scale_get());
 998         elm_gengrid_item_size_set(grid,
 999                                   (int)(GL_ALBUM_ITEM_WIDTH * scale_factor),
1000                                   (int)(GL_ALBUM_ITEM_HEIGHT * scale_factor));
1001
1002         elm_gengrid_align_set(grid, 0.5, 0.0);
1003
1004         /* Vertical scrolling. */
1005         elm_gengrid_horizontal_set(grid, EINA_FALSE);
1006         elm_gengrid_bounce_set(grid, EINA_FALSE, EINA_TRUE);
1007         elm_gengrid_multi_select_set(grid, EINA_TRUE);
1008
1009         evas_object_smart_callback_add(grid, "selected", _gl_albums_selected,
1010                                        NULL);
1011         evas_object_smart_callback_add(grid, "unselected",
1012                                        _gl_albums_unselected, NULL);
1013         evas_object_smart_callback_add(grid, "clicked", _gl_albums_clicked,
1014                                        NULL);
1015         evas_object_smart_callback_add(grid, "longpressed",
1016                                        _gl_albums_longpress, NULL);
1017         evas_object_smart_callback_add(grid, "drag,start,up",
1018                                        _gl_albums_drag_up, NULL);
1019         evas_object_smart_callback_add(grid, "drag,start,right",
1020                                        _gl_albums_drag_right, NULL);
1021         evas_object_smart_callback_add(grid, "drag,start,down",
1022                                        _gl_albums_drag_down, NULL);
1023         evas_object_smart_callback_add(grid, "drag,start,left",
1024                                        _gl_albums_drag_left, NULL);
1025         evas_object_smart_callback_add(grid, "drag,stop", _gl_albums_drag_stop,
1026                                        NULL);
1027         evas_object_smart_callback_add(grid, "realized", _gl_albums_realized,
1028                                        NULL);
1029
1030         evas_object_size_hint_weight_set(grid, EVAS_HINT_EXPAND,
1031                                          EVAS_HINT_EXPAND);
1032
1033         gl_get_mass_storage_state(ad);
1034         if (ad->maininfo.app_exit_mode == GL_APP_EXIT_NONE) {
1035                 if (ad->maininfo.view_mode != GL_VIEW_THUMBS)
1036                         _gl_albums_create_items(ad, grid);
1037         }
1038         /* show no contents none album exists */
1039         if (ad->maininfo.app_exit_mode ||
1040             gl_check_gallery_empty(ad)) {
1041                 evas_object_del(grid);
1042                 grid = NULL;
1043
1044                 /* Set the grid view mode for creating nocontents view */
1045                 ad->gridinfo.grid_view_mode = GL_GRID_ALBUMS;
1046                 Evas_Object *noc = gl_ui_create_nocontents_full(ad);
1047                 evas_object_show(noc);
1048                 ad->albuminfo.nocontents = noc;
1049
1050                 return noc;
1051         } else {
1052                 ad->albuminfo.nocontents = NULL;
1053                 evas_object_show(grid);
1054         }
1055
1056         gl_dbg("gl_albums_create_view:done");
1057
1058         return grid;
1059 }
1060
1061 /* From thumbnails view to albums view */
1062 int gl_albums_comeback_from_view(void *data)
1063 {
1064         gl_dbg("");
1065         GL_CHECK_VAL(data, -1);
1066         gl_appdata *ad = (gl_appdata *)data;
1067
1068         gl_ui_destroy_notiinfo(ad);
1069
1070         gl_grid_clear_view(ad);
1071         gl_list_clear_view(ad);
1072
1073         ad->albuminfo.current_album = NULL;
1074         gl_albums_update_items(ad);
1075
1076         evas_object_show(ad->albuminfo.view);
1077
1078         gl_set_view_mode(ad, GL_VIEW_ALBUMS);
1079         ad->albuminfo.seg_mode = GL_CTRL_SEG_ALL;
1080
1081         return 0;
1082 }
1083
1084 /* From albums edit view to albums view */
1085 int gl_albums_change_to_view(void *data)
1086 {
1087         GL_CHECK_VAL(data, -1);
1088         gl_appdata *ad = (gl_appdata *)data;
1089         GL_CHECK_VAL(ad->albuminfo.cluster_list, -1);
1090         gl_dbg("");
1091
1092         GL_CHECK_VAL(ad->albuminfo.view, -1);
1093         gl_set_view_mode(ad, GL_VIEW_ALBUMS);
1094         /* changed to show no contents if needed */
1095         if (gl_check_gallery_empty(ad)) {
1096                 if (ad->albuminfo.view)
1097                         evas_object_del(ad->albuminfo.view);
1098
1099                 /* Set the grid view mode for creating nocontents view */
1100                 ad->gridinfo.grid_view_mode = GL_GRID_ALBUMS;
1101                 Evas_Object *noc = gl_ui_create_nocontents_full(ad);
1102                 ad->albuminfo.nocontents = noc;
1103                 ad->albuminfo.view = noc;
1104                 evas_object_show(noc);
1105
1106                 Evas_Object *old_view = NULL;
1107                 old_view = elm_object_part_content_unset(ad->albuminfo.layout,
1108                                                     "elm.swallow.view");
1109                 evas_object_del(old_view);
1110                 elm_object_part_content_set(ad->albuminfo.layout,
1111                                        "elm.swallow.view", noc);
1112         } else {
1113                 _gl_albums_create_items(ad, ad->albuminfo.view);
1114         }
1115
1116         return 0;
1117 }
1118
1119 /* Update albums view */
1120 int gl_albums_update_items(void *data)
1121 {
1122         GL_CHECK_VAL(data, -1);
1123         gl_appdata *ad = (gl_appdata *)data;
1124         GL_CHECK_VAL(ad->albuminfo.cluster_list, -1);
1125         int view_mode = gl_get_view_mode(ad);
1126         gl_dbg("");
1127         /* Changed to show no contents if needed */
1128         if (gl_check_gallery_empty(ad)) {
1129                 /* Set the grid view mode for creating nocontents view */
1130                 ad->gridinfo.grid_view_mode = GL_GRID_ALBUMS;
1131
1132                 evas_object_del(ad->albuminfo.view);
1133
1134                 Evas_Object *noc = gl_ui_create_nocontents_full(ad);
1135                 ad->albuminfo.nocontents = noc;
1136                 ad->albuminfo.view = noc;
1137                 evas_object_show(noc);
1138
1139                 Evas_Object *old_view = NULL;
1140                 old_view = elm_object_part_content_unset(ad->albuminfo.layout,
1141                                                     "elm.swallow.view");
1142                 evas_object_del(old_view);
1143                 elm_object_part_content_set(ad->albuminfo.layout, "elm.swallow.view",
1144                                        noc);
1145         } else {
1146                 if (view_mode == GL_VIEW_ALBUMS_EDIT) {
1147                         _gl_albums_create_items(ad, ad->albuminfo.edit_view);
1148                 } else {
1149                         if (ad->albuminfo.nocontents) {
1150                                 /**
1151                                 * current view is nocontents,
1152                                 * unset it first then create albums view.
1153                                 */
1154                                 gl_albums_remove_nocontents(ad);
1155                         } else {
1156                                 Evas_Object *al_view = NULL;
1157                                 al_view = ad->albuminfo.view;
1158                                 _gl_albums_create_items(ad, al_view);
1159                         }
1160                 }
1161         }
1162
1163         return 0;
1164 }
1165
1166 /* Update albums list and refresh albums view, remove invalid widgets */
1167 int gl_albums_update_view(void *data)
1168 {
1169         GL_CHECK_VAL(data, -1);
1170         gl_appdata *ad = (gl_appdata *)data;
1171         int view_mode = gl_get_view_mode(ad);
1172         gl_dbg("view_mode: %d.", view_mode);
1173
1174         gl_albums_free_cover_thumbs(ad);
1175         memset(ad->albuminfo.cover_thumbs, 0x00,
1176                GL_ALBUM_COVER_THUMB_NUM * sizeof(int));
1177
1178         if (view_mode == GL_VIEW_ALBUMS) {
1179                 /* Update mass storage state */
1180                 gl_get_mass_storage_state(ad);
1181                 /* Update albums list*/
1182                 gl_refresh_albums_list(ad);
1183
1184                 if (ad->albuminfo.nocontents) {
1185                         gl_albums_remove_nocontents(ad);
1186                 } else if (!gl_check_gallery_empty(ad)) {
1187                         _gl_albums_create_items(ad, ad->albuminfo.view);
1188                         if (ad->albuminfo.cluster_list->edit_cnt)
1189                                 gl_ui_disable_toolbar_item(ad, false,
1190                                                            GL_NAVI_ALBUMS,
1191                                                            false);
1192                         else
1193                                 gl_ui_disable_toolbar_item(ad, true,
1194                                                            GL_NAVI_ALBUMS,
1195                                                            true);
1196                 } else {
1197                         gl_dbg("View is empty.");
1198                         gl_albums_update_items(ad);
1199                         gl_ui_disable_toolbar_item(ad, true, GL_NAVI_ALBUMS,
1200                                                    true);
1201                 }
1202         } else if (view_mode == GL_VIEW_ALBUMS_EDIT ||
1203             view_mode == GL_VIEW_ALBUMS_RENAME) {
1204                 if (gl_db_update_cluster_list(ad) != GL_DB_SUCCESS) {
1205                         gl_dbgE("gl_db_update_cluster_list failed!");
1206                         return -1;
1207                 }
1208
1209                 if (gl_check_gallery_empty(ad) ||
1210                     ad->albuminfo.cluster_list->edit_cnt == 0) {
1211                         /* Remove invalid widgets */
1212                         gl_del_invalid_widgets(ad, GL_INVALID_NONE);
1213
1214                         gl_dbg("Edit view is empty, back to albums view");
1215                         gl_ui_edit_cancel(ad);
1216
1217                         gl_ui_disable_toolbar_item(ad, true, GL_NAVI_ALBUMS,
1218                                                    true);
1219                 } else {
1220                         int sel_cnt = gl_db_get_albums_selected_cnt(ad);
1221                         int invalid_m = GL_INVALID_NONE;
1222                         /* Album selected for rename was deleted */
1223                         if (view_mode == GL_VIEW_ALBUMS_RENAME) {
1224                                 if (ad->albuminfo.selected_album == NULL) {
1225                                         gl_dbgW("Rename invalid album!");
1226                                         invalid_m = GL_INVALID_RENAME_ALBUM;
1227                                         /* Remove invalid widgets */
1228                                         gl_del_invalid_widgets(ad, invalid_m);
1229                                         /* Disable control bar buttons */
1230                                         gl_ui_disable_toolbar_items(ad,
1231                                                                     ad->albuminfo.nf_it_edit);
1232                                         if (sel_cnt == 0)
1233                                         /* Reset view mode */
1234                                         gl_set_view_mode(ad,
1235                                                          GL_VIEW_ALBUMS_EDIT);
1236                                 }
1237                         } else if (sel_cnt == 0) {
1238                                 /* If none albums selected */
1239                                 gl_dbgW("None albums selected!");
1240                                 /* Disable control bar buttons */
1241                                 gl_ui_disable_toolbar_items(ad,
1242                                                             ad->albuminfo.nf_it_edit);
1243                                 /* Remove invalid widgets */
1244                                 gl_del_invalid_widgets(ad, invalid_m);
1245                                 /* Reset view mode */
1246                                 gl_set_view_mode(ad, GL_VIEW_ALBUMS_EDIT);
1247                         }
1248
1249                         /* Update edit view, other update view in cancel callback */
1250                         Evas_Object *edit_view = ad->albuminfo.edit_view;
1251                         if (gl_get_view_mode(ad) == GL_VIEW_ALBUMS_EDIT) {
1252                                 _gl_albums_create_items(ad, edit_view);
1253                         } else {
1254                                 /* Cluster list updated, clear view */
1255                                 elm_gengrid_clear(edit_view);
1256                         }
1257                 }
1258         }
1259         return 0;
1260 }
1261
1262 /**
1263 * Remove nocontents view and show albums view.
1264 * gallery is empty->home key tapped
1265 *       ->take photos with camera->back to gallery;
1266 */
1267 int gl_albums_remove_nocontents(void *data)
1268 {
1269         GL_CHECK_VAL(data, -1);
1270         gl_appdata *ad = (gl_appdata *)data;
1271         Evas_Object *layout_inner = NULL;
1272         gl_dbg("");
1273
1274         if (ad->albuminfo.nocontents && !gl_check_gallery_empty(ad)) {
1275                 gl_dbg("Remove nocontents view then create albums view.");
1276
1277                 evas_object_del(ad->albuminfo.nocontents);
1278                 ad->albuminfo.nocontents = NULL;
1279
1280                 layout_inner = gl_albums_create_view(ad, ad->maininfo.navi_bar);
1281
1282                 Evas_Object *old_view = NULL;
1283                 old_view = elm_object_part_content_unset(ad->albuminfo.layout,
1284                                                     "elm.swallow.view");
1285                 evas_object_del(old_view);
1286                 elm_object_part_content_set(ad->albuminfo.layout, "elm.swallow.view",
1287                                        layout_inner);
1288                 evas_object_show(layout_inner);
1289                 ad->albuminfo.view = layout_inner;
1290
1291                 gl_ui_disable_toolbar_item(ad, false, GL_NAVI_ALBUMS, false);
1292         } else {
1293                 gl_dbg("Nocontents was removed or Gallery is empty!");
1294         }
1295
1296         return 0;
1297 }
1298
1299 int gl_albums_del_grid_append_idler(void *data)
1300 {
1301         GL_CHECK_VAL(data, -1);
1302         gl_appdata *ad = (gl_appdata *)data;
1303
1304         if (ad->gridinfo.append_idler) {
1305                 ecore_idler_del(ad->gridinfo.append_idler);
1306                 ad->gridinfo.append_idler = NULL;
1307         }
1308
1309         return 0;
1310 }
1311
1312 int gl_albums_free_cover_thumbs(void *data)
1313 {
1314         gl_dbg("");
1315         GL_CHECK_VAL(data, -1);
1316         gl_appdata *ad = (gl_appdata *)data;
1317         int i = 0;
1318
1319         for (i = 0; i < GL_ALBUM_COVER_THUMB_NUM; i++) {
1320                 if (ad->albuminfo.cover_thumbs[i]) {
1321                         gl_db_destroy_item(ad->albuminfo.cover_thumbs[i]);
1322                         ad->albuminfo.cover_thumbs[i] = NULL;
1323                 }
1324         }
1325
1326         return 0;
1327 }
1328
1329 /* Free resources allocated for albums view */
1330 int gl_albums_free_data(void *data)
1331 {
1332         gl_dbg("");
1333         GL_CHECK_VAL(data, -1);
1334         gl_appdata *ad = (gl_appdata *)data;
1335
1336         gl_albums_del_grid_append_idler(data);
1337
1338         gl_albums_free_cover_thumbs(data);
1339
1340         if (ad->albuminfo.move_album_id) {
1341                 free(ad->albuminfo.move_album_id);
1342                 ad->albuminfo.move_album_id = NULL;
1343         }
1344         return 0;
1345 }
1346