ug/ug-gallery-efl/src/ge-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 "ge-debug.h"
  18 #include "ge-albums.h"
  19 #include "ge-gridview.h"
  20 #include "ge-ui-util.h"
  21 #include "ge-util.h"
  22 #include "ge-drm.h"
  23 #include "ge-data.h"
  24 #include "ge-strings.h"
  25 #include "ge-tile.h"
  26 #include "ge-rotate-bg.h"
  27
  28 static Elm_Gengrid_Item_Class album_gic;
  29 static Elm_Gengrid_Item_Class album_gic_blue;
  30 static int gl_albums_item_cnt;
  31 static ge_item* gl_album_items[GE_ALBUM_COVER_THUMB_NUM];
  32 static int gl_album_count;
  33
  34 static void _ge_albums_drag_up(void *data, Evas_Object *obj, void *event_info)
  35 {
  36         ge_dbg("");
  37 }
  38
  39 static void _ge_albums_drag_right(void *data, Evas_Object *obj, void *event_info)
  40 {
  41         ge_dbg("");
  42 }
  43
  44 static void _ge_albums_drag_down(void *data, Evas_Object *obj, void *event_info)
  45 {
  46         ge_dbg("");
  47 }
  48
  49 static void _ge_albums_drag_left(void *data, Evas_Object *obj, void *event_info)
  50 {
  51         ge_dbg("");
  52 }
  53
  54 static void _ge_albums_drag_stop(void *data, Evas_Object *obj, void *event_info)
  55 {
  56         ge_dbg("");
  57 }
  58
  59 static void _ge_albums_realized(void *data, Evas_Object *obj, void *event_info)
  60 {
  61         //ge_dbg("");
  62 }
  63
  64 static void _ge_albums_selected(void *data, Evas_Object *obj, void *event_info)
  65 {
  66         ge_dbg("");
  67 }
  68
  69 static void _ge_albums_unselected(void *data, Evas_Object *obj, void *event_info)
  70 {
  71         ge_dbg("");
  72 }
  73
  74 static void _ge_albums_clicked(void *data, Evas_Object *obj, void *event_info)
  75 {
  76         ge_dbg("");
  77 }
  78
  79 static void _ge_albums_longpress(void *data, Evas_Object *obj, void *event_info)
  80 {
  81         ge_dbg("");
  82 }
  83
  84 static Eina_Bool _ge_albums_append_grid_idler(void *data)
  85 {
  86         GE_CHECK_CANCEL(data);
  87         ge_ugdata* ugd = (ge_ugdata*)data;
  88
  89         /* Try to get other medias from DB and append them to gridview*/
  90         int ret = ge_grid_idler_append_thumbs(data);
  91         if(ret != 0) {
  92                 ge_dbg("Failed to append grid items!");
  93         } else {
  94                 ge_dbg("Successful to append grid items!");
  95         }
  96
  97         /* Remove idler after all items appended */
  98         GE_IF_DEL_IDLER(ugd->grid_append_idler)
  99
 100         return ECORE_CALLBACK_CANCEL;
 101 }
 102
 103 static void __ge_albums_sel_cb(void *data, Evas_Object *obj, void *event_info)
 104 {
 105         GE_CHECK(data);
 106         GE_CHECK(event_info);
 107         Evas_Event_Mouse_Up *ev = event_info;
 108
 109         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
 110                 return;
 111
 112         ge_dbg("");
 113         ge_cluster *album_item = (ge_cluster*)data;
 114         GE_CHECK(album_item->cluster);
 115         GE_CHECK(album_item->ugd);
 116         ge_ugdata *ugd = album_item->ugd;
 117         if(ugd->ug == NULL) {
 118                 ge_dbg("UG already destroyed, return!");
 119                 return;
 120         }
 121
 122         if (album_item->cluster->count == 0) {
 123                 ge_dbgW("Empty album, return;");
 124                 return;
 125         }
 126
 127         ge_albums_sel_album(album_item);
 128 }
 129
 130 static char *__ge_albums_get_text(void *data, Evas_Object *obj, const char *part)
 131 {
 132         GE_CHECK_NULL(part);
 133         GE_CHECK_NULL(data);
 134         ge_cluster *album_item = (ge_cluster *)data;
 135         GE_CHECK_NULL(album_item->cluster);
 136         GE_CHECK_NULL(album_item->cluster->uuid);
 137         GE_CHECK_NULL(album_item->ugd);
 138         ge_ugdata *ugd = album_item->ugd;
 139         char buf[GE_FILE_PATH_LEN_MAX] = {0,};
 140
 141         if (!g_strcmp0(part, "elm.text.name"))
 142         {
 143                 GE_CHECK_NULL(album_item->cluster->display_name);
 144                 if(_ge_data_is_root_path(album_item->cluster->path)) {
 145                         snprintf(buf, sizeof(buf), "%s", GE_ALBUM_ROOT_NAME);
 146                         buf[strlen(buf)] = '\0';
 147                 } else if(strlen(album_item->cluster->display_name)) {
 148                         snprintf(buf, sizeof(buf), "%s", (char*)(album_item->cluster->display_name));
 149                         buf[strlen(buf)] = '\0';
 150                 }
 151
 152                 /* Show blue folder name */
 153                 if (!g_strcmp0(album_item->cluster->uuid, GE_ALBUM_ALL_ID) ||
 154                     _ge_data_is_default_album(GE_ALBUM_MY_NAME, album_item->cluster)) {
 155                         Elm_Object_Item *grid_it = album_item->griditem;
 156                         Evas_Object *it_obj = NULL;
 157                         it_obj = elm_object_item_widget_get(grid_it);
 158                         GE_CHECK_NULL(it_obj);
 159                         edje_object_signal_emit(it_obj, "elm,name,show,blue",
 160                                                 "elm");
 161                         edje_object_message_signal_process(it_obj);
 162                 }
 163         }
 164         else if (!g_strcmp0(part, "elm.text.date"))
 165         {
 166                 struct tm  t1;
 167                 struct tm  t2;
 168                 char date1[GE_ALBUM_DATE_LEN_MAX] = {0,};
 169                 char date2[GE_ALBUM_DATE_LEN_MAX] = {0,};
 170                 char date3[GE_ALBUM_DATE_LEN_MAX] = {0,};
 171
 172                 ge_albums_free_cover_thumbs(ugd);
 173
 174                 int item_count = GE_ALBUM_COVER_THUMB_NUM;
 175                 ge_item** items1 = gl_album_items;
 176
 177                 _ge_data_get_first_several_items(ugd, album_item, items1,
 178                                                  &item_count,
 179                                                  MEDIA_CONTENT_ORDER_DESC);
 180                 if(item_count <= 0)
 181                 {
 182                         gl_album_count = 0;
 183                         return NULL;
 184                 }
 185
 186                 gl_album_count = item_count;
 187                 if(items1[0] == NULL || items1[0]->item == NULL)
 188                 {
 189                         gl_album_count = 0;
 190                         return NULL;
 191                 }
 192                 memcpy(&album_item->item_mtime, &(items1[0]->item->mtime), sizeof(time_t));
 193
 194                 item_count = 1;
 195                 ge_item* items2[1];
 196                 memset(items2, 0x00, item_count * sizeof(int));
 197                 _ge_data_get_first_several_items(ugd, album_item, items2,
 198                                                  &item_count,
 199                                                  MEDIA_CONTENT_ORDER_ASC);
 200
 201                 if(item_count <= 0)
 202                 {
 203                         return NULL;
 204                 }
 205                 else
 206                 {
 207                         memset(&t1, 0x00, sizeof(struct tm));
 208                         localtime_r((time_t *) &(album_item->item_mtime), &t1);
 209                         strftime(date1, sizeof(date1), "%Y.%m.%d", &t1);
 210                         strftime(date3, sizeof(date3), "%Y.%m", &t1);
 211
 212                         if(items2[0] == NULL || items2[0]->item == NULL)
 213                         {
 214                                 gl_album_count = 0;
 215                                 return NULL;
 216                         }
 217                         memset(&t2, 0x00, sizeof(struct tm));
 218                         localtime_r((time_t *) &(items2[0]->item->mtime), &t2);
 219                         strftime(date2, sizeof(date2), "%Y.%m.%d", &t2);
 220
 221                         if(!g_strcmp0(date1, date2))
 222                         {
 223                                 g_strlcpy(buf, date1, sizeof(buf));
 224                         }
 225                         else
 226                         {
 227                                 strftime(date2, sizeof(date2), "%Y.%m", &t2);
 228                                 snprintf(buf, sizeof(buf), "%s - %s", date2, date3);
 229                                 buf[strlen(buf)] = '\0';
 230                         }
 231                 }
 232
 233                 int i = 0;
 234                 for(i = 0; i < item_count; i++)
 235                 {
 236                         _ge_data_destroy_item(items2[i]);
 237                         items2[i] = NULL;
 238                 }
 239         }
 240         else if (!g_strcmp0(part, "elm.text.count"))
 241         {
 242                 _ge_data_update_items_cnt(ugd, album_item);
 243                 snprintf(buf, sizeof(buf), "%d", (int)(album_item->cluster->count));
 244                 buf[strlen(buf)] = '\0';
 245         }
 246
 247         return strdup(buf);
 248 }
 249
 250 static ge_icon_type __ge_albums_set_bg_file(Evas_Object *bg, void *data)
 251 {
 252         ge_item *git =  (ge_item *)data;
 253         char *bg_path = GE_DEFAULT_THUMB_ICON;
 254         ge_icon_type ret_val = GE_ICON_CORRUPTED_FILE;
 255
 256         if (git == NULL || git->item == NULL) {
 257                 ge_dbgE("Invalid item :%p", git);
 258                 goto GE_ALBUMS_FAILED;
 259         }
 260
 261         /* Is it DRM file? Has a valid RO? */
 262         char *path = git->item->file_url;
 263         if(ge_drm_is_drm_file(path) &&
 264            !ge_drm_check_valid_ro(path, ge_drm_get_permtype(git->item->type))) {
 265                 ret_val = GE_ICON_EXPIRED_DRM;
 266                 goto GE_ALBUMS_FAILED;
 267         }
 268
 269         ret_val= GE_ICON_NORMAL;
 270         bg_path = _GETICON(git->item->thumb_url);
 271
 272  GE_ALBUMS_FAILED:
 273
 274 #ifdef _USE_ROTATE_BG_GE
 275         _ge_rotate_bg_set_image_file(bg, bg_path);
 276 #else
 277         elm_bg_file_set(bg, bg_path, NULL);
 278 #endif
 279
 280         return ret_val;
 281 }
 282
 283 static Evas_Object *__ge_albums_get_content(void *data, Evas_Object *obj, const char *part)
 284 {
 285         GE_CHECK_NULL(part);
 286         GE_CHECK_NULL(strlen(part));
 287         GE_CHECK_NULL(data);
 288         ge_cluster *album_item = (ge_cluster *)data;
 289         GE_CHECK_NULL(album_item->cluster);
 290         GE_CHECK_NULL(album_item->ugd);
 291         ge_ugdata *ugd = album_item->ugd;
 292
 293         GE_CHECK_NULL(album_item->cluster->uuid);
 294         const char *al_id = album_item->cluster->uuid;
 295         ge_dbg("");
 296
 297         Evas_Object *_obj = NULL;
 298         if ((!g_strcmp0(part, GT_TILE_FIRSTICON)) ||
 299             (!g_strcmp0(part, GT_TILE_ONLYICON)) ||
 300             (!g_strcmp0(part, GT_TILE_ICON))
 301 #ifdef _USE_ROTATE_BG_GE
 302             || (!g_strcmp0(part, GT_TILE_3ICON1)) ||
 303             (!g_strcmp0(part, GT_TILE_3ICON2)) ||
 304             (!g_strcmp0(part, GT_TILE_4ICON3)) ||
 305             (!g_strcmp0(part, GT_TILE_4ICON4)) ||
 306             (!g_strcmp0(part, GT_TILE_5ICON1)) ||
 307             (!g_strcmp0(part, GT_TILE_5ICON2)) ||
 308             (!g_strcmp0(part, GT_TILE_6ICON4)) ||
 309             (!g_strcmp0(part, GT_TILE_6ICON5))
 310 #endif
 311             ) {
 312                 _obj = _ge_tile_show_part_icon(obj, part, gl_album_count,
 313                                                ugd->win_scale,
 314                                                __ge_albums_set_bg_file,
 315                                                (void **)gl_album_items);
 316         } else if (!g_strcmp0(part, GT_TILE_LABEL)) {
 317                 /**
 318                 *  for "Camera", its color should be
 319                 *  25:25:25 by new gui
 320                 */
 321                 bool b_default = false;
 322                 if (!g_strcmp0(al_id, GE_ALBUM_ALL_ID) ||
 323                     _ge_data_is_default_album(GE_ALBUM_MY_NAME, album_item->cluster))
 324                         b_default = true;
 325                 _obj = _ge_tile_show_part_label(obj, album_item->index,
 326                                                 b_default);
 327
 328                 if (album_item->cluster->count <= 0)
 329                         ge_dbg("Empty album");
 330         }
 331         return _obj;
 332 }
 333
 334 static int _ge_albums_create_album(ge_ugdata* ugd, Evas_Object* parent)
 335 {
 336         ge_dbg("");
 337         GE_CHECK_VAL(parent, -1);
 338         GE_CHECK_VAL(ugd, -1);
 339         GE_CHECK_VAL(ugd->cluster_list, -1);
 340         int i = 0;
 341         int grid_cnt = 0;
 342         ge_cluster *album_item = NULL;
 343
 344         album_gic.item_style = "albums_view";
 345         album_gic.func.text_get = __ge_albums_get_text;
 346         album_gic.func.content_get = __ge_albums_get_content;
 347
 348         album_gic_blue.item_style = "albums_view_blue";
 349         album_gic_blue.func.text_get = __ge_albums_get_text;
 350         album_gic_blue.func.content_get = __ge_albums_get_content;
 351
 352
 353         int length = eina_list_count(ugd->cluster_list->clist);
 354         ge_dbg("Albums list length: %d.", length);
 355
 356         elm_gengrid_clear(parent);
 357
 358         if(ugd->th)
 359         {
 360                 elm_object_theme_set(parent, ugd->th);
 361         }
 362         elm_object_style_set(parent, "gallery_efl/default");
 363
 364         for(i = 0; i < length; i++)
 365         {
 366                 album_item = eina_list_nth(ugd->cluster_list->clist, i);
 367                 GE_CHECK_VAL(album_item, -1);
 368                 GE_CHECK_VAL(album_item->cluster, -1);
 369                 GE_CHECK_VAL(album_item->cluster->display_name, -1);
 370
 371                 /* Show blue folder name */
 372                 if (!g_strcmp0(album_item->cluster->uuid, GE_ALBUM_ALL_ID) ||
 373                     _ge_data_is_default_album(GE_ALBUM_MY_NAME, album_item->cluster))
 374                         album_item->griditem = elm_gengrid_item_append(parent,
 375                                                                        &album_gic_blue,
 376                                                                        album_item,
 377                                                                        __ge_albums_sel_cb,
 378                                                                        album_item);
 379                 else
 380                         album_item->griditem = elm_gengrid_item_append(parent,
 381                                                                        &album_gic,
 382                                                                        album_item,
 383                                                                        __ge_albums_sel_cb,
 384                                                                        album_item);
 385                 album_item->index = grid_cnt;
 386                 grid_cnt++;
 387                 ge_dbg("Append [%s], id=%s.", album_item->cluster->display_name,
 388                        album_item->cluster->uuid);
 389         }
 390
 391         gl_albums_item_cnt = grid_cnt;
 392
 393         if(grid_cnt)
 394         {
 395                 return 0;
 396         }
 397         else
 398         {
 399                 ge_dbgW("None albums appended to view!");
 400                 return -1;
 401         }
 402 }
 403
 404 int ge_albums_free_cover_thumbs(ge_ugdata *ugd)
 405 {
 406         GE_CHECK_VAL(ugd, -1);
 407         int i = 0;
 408
 409         for(i = 0; i < GE_ALBUM_COVER_THUMB_NUM; i++)
 410         {
 411                 if(gl_album_items[i])
 412                 {
 413                         _ge_data_destroy_item(gl_album_items[i]);
 414                         gl_album_items[i] = NULL;
 415                 }
 416         }
 417
 418         return 0;
 419 }
 420
 421 int ge_albums_back_to_view(ge_ugdata *ugd)
 422 {
 423         ge_dbg("");
 424         GE_CHECK_VAL(ugd, -1);
 425
 426         if(ugd->file_select_mode == GE_File_Select_Multiple)
 427         {
 428                 ge_ui_destroy_selinfo(ugd);
 429                 _ge_data_selected_list_finalize();
 430         }
 431
 432         GE_IF_DEL_IDLER(ugd->grid_append_idler)
 433
 434         ge_albums_update_view(ugd);
 435         ge_grid_clear_view(ugd);
 436
 437         _ge_set_view_mode(GE_AlbumsView_Mode);
 438         return 0;
 439 }
 440
 441 int ge_albums_sel_album(ge_cluster* album_item)
 442 {
 443         ge_dbg("");
 444         GE_CHECK_VAL(album_item, -1);
 445         GE_CHECK_VAL(album_item->cluster, -1);
 446         GE_CHECK_VAL(album_item->cluster->uuid, -1);
 447         GE_CHECK_VAL(album_item->ugd, -1);
 448
 449         if(_ge_get_view_mode() != GE_AlbumsView_Mode)
 450         {
 451                 ge_dbgE("error mode.. now return!");
 452                 return -1;
 453         }
 454         else
 455         {
 456                 ge_dbg("ViewMode");
 457         }
 458
 459         ge_ugdata *ugd = album_item->ugd;
 460         GE_CHECK_VAL(ugd->cluster_list, -1);
 461         GE_CHECK_VAL(ugd->navi_bar, -1);
 462         ge_dbg("Album: %s, id: %s.", album_item->cluster->display_name,
 463                album_item->cluster->uuid);
 464
 465         if(ugd->album_select_mode == GE_Album_Select_One)
 466         {
 467                 ge_dbg("One album selected, return album id and destroy the ug!");
 468
 469                 char folder_path[GE_DIR_PATH_LEN_MAX] = { 0, };
 470                 g_strlcpy(folder_path, album_item->cluster->path,
 471                           GE_DIR_PATH_LEN_MAX);
 472                 service_add_extra_data(ugd->service,
 473                                        GE_ALBUM_SELECT_RETURN_PATH,
 474                                        folder_path);
 475                 ge_dbg("return folder-path: %s", folder_path);
 476                 ug_send_result(ugd->ug, ugd->service);
 477                 ug_destroy_me(ugd->ug);
 478                 ugd->ug = NULL;
 479                 return 0;
 480         }
 481
 482         /* Set current album */
 483         _ge_set_current_album(album_item);
 484         /* Remove idler */
 485         GE_IF_DEL_IDLER(ugd->grid_append_idler)
 486         /* Get album contents from DB */
 487         _ge_data_get_items_list(ugd, album_item, GE_FIRST_VIEW_START_POS,
 488                                 GE_FIRST_VIEW_END_POS);
 489
 490         if(ugd->file_select_mode == GE_File_Select_Setas)
 491         {
 492                 ge_dbg("setas mode->thumbnail is view mode");
 493                 _ge_set_view_mode(GE_ThumbnailView_Mode);
 494         }
 495         else
 496         {
 497                 ge_dbg("select mode->thumbnail is edit mode");
 498                 _ge_set_view_mode(GE_ThumbnailEdit_Mode);
 499         }
 500
 501         ugd->thumbs_view_ly = ge_grid_create_ly(ugd->navi_bar);
 502         GE_CHECK_VAL(ugd->thumbs_view_ly, -1);
 503         Evas_Object* gv = NULL;
 504
 505         gv = ge_grid_create_view(ugd, ugd->thumbs_view_ly);
 506         GE_CHECK_VAL(gv, -1);
 507
 508         elm_object_part_content_set(ugd->thumbs_view_ly, "contents", gv);
 509         ugd->thumbs_view = gv;
 510         if(gv == ugd->nocontents)
 511         {
 512                 ugd->thumbs_nocontents = gv;
 513         }
 514
 515         /* Checkme: clear albums view for animation effect pause issue */
 516         elm_gengrid_clear(ugd->albums_view);
 517
 518         if(_ge_get_view_mode() == GE_ThumbnailView_Mode)
 519         {
 520                 /* Check root case */
 521                 if(_ge_data_is_root_path(album_item->cluster->path))
 522                 {
 523                         ge_ui_create_title_and_push(ugd, ugd->navi_bar,
 524                                 ugd->thumbs_view_ly, ThumbnailView_Title, GE_ALBUM_ROOT_NAME);
 525                 }
 526                 else
 527                 {
 528                         ge_ui_create_title_and_push(ugd, ugd->navi_bar,
 529                                 ugd->thumbs_view_ly, ThumbnailView_Title, album_item->cluster->display_name);
 530                 }
 531         }
 532         else
 533         {
 534                 ge_ui_create_title_and_push(ugd, ugd->navi_bar,
 535                         ugd->thumbs_view_ly, ThumbnailView_Title, ugd->albums_view_title);
 536         }
 537
 538         if(_ge_data_get_count_all() == (GE_FIRST_VIEW_END_POS+1))
 539         {
 540                 ge_dbg("\n\n>>>>>>>>Use idler to append other medias--Start>>>>>>>>\n");
 541                 ugd->grid_append_idler = ecore_idler_add(_ge_albums_append_grid_idler, ugd);
 542         }
 543
 544         ge_dbg("Done ge_albums_sel_album");
 545         return 0;
 546 }
 547
 548 Evas_Object* ge_albums_create_ly(Evas_Object* parent)
 549 {
 550         ge_dbg("");
 551         GE_CHECK_NULL(parent);
 552         Evas_Object* layout = ge_ui_load_edj(parent, GE_EDJ_FILE, GE_GRP_ALBUMVIEW);
 553         GE_CHECK_NULL(layout);
 554         evas_object_show (layout);
 555
 556         return layout;
 557 }
 558
 559 int ge_albums_del_callbacks(ge_ugdata* ugd)
 560 {
 561         GE_CHECK_VAL(ugd, -1);
 562         if(ugd->albums_view)
 563         {
 564                 ge_dbg("Delete albums callbacks!");
 565                 evas_object_smart_callback_del(ugd->albums_view, "selected", _ge_albums_selected);
 566                 evas_object_smart_callback_del(ugd->albums_view, "unselected", _ge_albums_unselected);
 567                 evas_object_smart_callback_del(ugd->albums_view, "clicked", _ge_albums_clicked);
 568                 evas_object_smart_callback_del(ugd->albums_view, "longpressed", _ge_albums_longpress);
 569                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,up", _ge_albums_drag_up);
 570                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,right", _ge_albums_drag_right);
 571                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,down", _ge_albums_drag_down);
 572                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,left", _ge_albums_drag_left);
 573                 evas_object_smart_callback_del(ugd->albums_view, "drag,stop", _ge_albums_drag_stop);
 574                 evas_object_smart_callback_del(ugd->albums_view, "realized", _ge_albums_realized);
 575         }
 576         return 0;
 577 }
 578
 579 Evas_Object* ge_albums_create_view(ge_ugdata* ugd, Evas_Object* parent)
 580 {
 581         ge_dbg("");
 582         GE_CHECK_NULL(parent);
 583         GE_CHECK_NULL(ugd);
 584         GE_CHECK_NULL(ugd->cluster_list);
 585
 586         memset(gl_album_items, 0x00, GE_ALBUM_COVER_THUMB_NUM * sizeof(int));
 587         gl_album_count = 0;
 588
 589         if(!ugd->cluster_list->clist ||
 590            (eina_list_count(ugd->cluster_list->clist) == 0)) {
 591                 ge_dbgW("Clusters list is empty!");
 592                 goto ALBUMS_FAILED;
 593         }
 594
 595         double scale_factor = ugd->win_scale;
 596         ge_dbg("Own scale facotr: %f, elm_config_scale_get =%f.", scale_factor, elm_config_scale_get());
 597
 598         Evas_Object *grid = elm_gengrid_add(parent);
 599         GE_CHECK_NULL(grid);
 600         elm_gengrid_item_size_set(grid,
 601                 (int)(GE_ALBUM_ITEM_WIDTH * scale_factor),
 602                 (int)(GE_ALBUM_ITEM_HEIGHT * scale_factor));
 603         elm_gengrid_align_set(grid, 0.5, 0.0);
 604         elm_gengrid_horizontal_set(grid, EINA_FALSE);
 605         elm_gengrid_bounce_set(grid, EINA_FALSE, EINA_TRUE);
 606         elm_gengrid_multi_select_set(grid, EINA_TRUE);
 607         evas_object_size_hint_weight_set(grid, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 608
 609         if(_ge_albums_create_album(ugd, grid) != 0)
 610         {
 611                 ge_dbgW("Failed to append album items!");
 612                 evas_object_del(grid);
 613                 grid = NULL;
 614
 615                 goto ALBUMS_FAILED;
 616         }
 617         else
 618         {
 619                 evas_object_show (grid);
 620         }
 621
 622         evas_object_smart_callback_add(grid, "selected", _ge_albums_selected, NULL);
 623         evas_object_smart_callback_add(grid, "unselected", _ge_albums_unselected, NULL);
 624         evas_object_smart_callback_add(grid, "clicked", _ge_albums_clicked, NULL);
 625         evas_object_smart_callback_add(grid, "longpressed", _ge_albums_longpress, NULL);
 626         evas_object_smart_callback_add(grid, "drag,start,up", _ge_albums_drag_up, NULL);
 627         evas_object_smart_callback_add(grid, "drag,start,right", _ge_albums_drag_right, NULL);
 628         evas_object_smart_callback_add(grid, "drag,start,down", _ge_albums_drag_down, NULL);
 629         evas_object_smart_callback_add(grid, "drag,start,left", _ge_albums_drag_left, NULL);
 630         evas_object_smart_callback_add(grid, "drag,stop", _ge_albums_drag_stop, NULL);
 631         evas_object_smart_callback_add(grid, "realized", _ge_albums_realized, NULL);
 632
 633         return grid;
 634
 635 ALBUMS_FAILED:
 636         /* Show no contents if none albums exist */
 637         ge_dbgW("@@@@@@@  To create nocontents view  @@@@@@@@");
 638         ugd->nocontents = ge_ui_create_nocontents(ugd);
 639         ugd->albums_view = ugd->nocontents;
 640         evas_object_show(ugd->nocontents);
 641
 642         return ugd->nocontents;
 643 }
 644
 645 int ge_albums_update_view(ge_ugdata *ugd)
 646 {
 647         ge_dbg("");
 648         GE_CHECK_VAL(ugd, -1);
 649         GE_CHECK_VAL(ugd->cluster_list, -1);
 650         /* Changed to show no contents if needed */
 651         if(!ugd->cluster_list->clist ||
 652            (eina_list_count(ugd->cluster_list->clist) == 0)) {
 653                 ge_dbgW("Clusters list is empty!");
 654                 goto ALBUMS_FAILED;
 655         }
 656
 657         if(ugd->nocontents && ugd->nocontents == ugd->albums_view) {
 658                 /* It is nocontents, unset it first then create albums view*/
 659                 evas_object_del(ugd->nocontents);
 660                 ugd->nocontents = NULL;
 661
 662                 ugd->albums_view = ge_albums_create_view(ugd, ugd->navi_bar);
 663                 GE_CHECK_VAL(ugd->albums_view, -1);
 664                 elm_object_part_content_set(ugd->albums_view_ly, "contents",
 665                                             ugd->albums_view);
 666                 evas_object_show(ugd->albums_view);
 667         } else {
 668                 if(_ge_albums_create_album(ugd, ugd->albums_view) != 0)
 669                         goto ALBUMS_FAILED;
 670         }
 671
 672         return 0;
 673
 674 ALBUMS_FAILED:
 675
 676         if(ugd->albums_view && ugd->albums_view != ugd->nocontents)
 677                 ge_albums_del_callbacks(ugd);
 678
 679         evas_object_del(ugd->albums_view);
 680
 681         ge_dbgW("@@@@@@@  To create nocontents view @@@@@@@@");
 682         ugd->nocontents = ge_ui_create_nocontents(ugd);
 683         ugd->albums_view = ugd->nocontents;
 684         GE_CHECK_VAL(ugd->albums_view, -1);
 685         evas_object_show(ugd->albums_view);
 686
 687         elm_object_part_content_set(ugd->albums_view_ly, "contents",
 688                                     ugd->albums_view);
 689         return -1;
 690 }