libug/libug-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-db-handler.h"
  23 #include "ge-strings.h"
  24
  25 static Elm_Gengrid_Item_Class album_gic;
  26 static int gl_albums_item_cnt;
  27 static ge_item* gl_album_items[GE_ALBUM_COVER_THUMB_NUM];
  28 static int gl_album_count;
  29
  30 struct ge_color {
  31         int r;
  32         int g;
  33         int b;
  34 };
  35
  36 /* Size of table padding */
  37 #define GE_COVER_PAD 3
  38 #define GE_COVER_PAD_2 2
  39
  40 #define GE_ALBUM_TEXT_COLOR_ALPHA 255
  41 #define GE_BG_COLOR_CNT 6
  42 static struct ge_color ge_bg_color[] =
  43 {
  44         {50, 50, 50},
  45         {78, 74, 64},
  46         {206, 108, 1},
  47         {157, 35, 39},
  48         {20, 60, 128},
  49         {84, 109, 49},
  50         {25, 25, 25},
  51 };
  52
  53
  54 static void _ge_albums_drag_up(void *data, Evas_Object *obj, void *event_info)
  55 {
  56         ge_dbg("");
  57 }
  58
  59 static void _ge_albums_drag_right(void *data, Evas_Object *obj, void *event_info)
  60 {
  61         ge_dbg("");
  62 }
  63
  64 static void _ge_albums_drag_down(void *data, Evas_Object *obj, void *event_info)
  65 {
  66         ge_dbg("");
  67 }
  68
  69 static void _ge_albums_drag_left(void *data, Evas_Object *obj, void *event_info)
  70 {
  71         ge_dbg("");
  72 }
  73
  74 static void _ge_albums_drag_stop(void *data, Evas_Object *obj, void *event_info)
  75 {
  76         ge_dbg("");
  77 }
  78
  79 static void _ge_albums_realized(void *data, Evas_Object *obj, void *event_info)
  80 {
  81         ge_dbg("");
  82 }
  83
  84 static void _ge_albums_selected(void *data, Evas_Object *obj, void *event_info)
  85 {
  86         ge_dbg("");
  87 }
  88
  89 static void _ge_albums_unselected(void *data, Evas_Object *obj, void *event_info)
  90 {
  91         ge_dbg("");
  92 }
  93
  94 static void _ge_albums_clicked(void *data, Evas_Object *obj, void *event_info)
  95 {
  96         ge_dbg("");
  97 }
  98
  99 static void _ge_albums_longpress(void *data, Evas_Object *obj, void *event_info)
 100 {
 101         ge_dbg("");
 102 }
 103
 104 static Eina_Bool _ge_albums_append_grid_idler(void *data)
 105 {
 106         GE_CHECK_CANCEL(data);
 107         ge_ugdata* ugd = (ge_ugdata*)data;
 108
 109         /* Try to get other medias from DB and append them to gridview*/
 110         int ret = ge_grid_idler_append_thumbs(data);
 111         if(ret < 0)
 112         {
 113                 ge_dbg("Failed to append grid items!");
 114                 if(ret == MB_SVC_ERROR_DB_NO_RECORD)
 115                 {
 116                         /* Maybe all medias were already showed */
 117                         ge_dbg("No any more records!");
 118                 }
 119         }
 120         else
 121         {
 122                 ge_dbg("Successful to append grid items!");
 123         }
 124
 125         /* Remove idler after all items appended */
 126         GE_DEL_IDLER(ugd->grid_append_idler)
 127
 128         return ECORE_CALLBACK_CANCEL;
 129 }
 130
 131 static void __ge_albums_sel_cb(void *data, Evas_Object *obj, void *event_info)
 132 {
 133         GE_CHECK(data);
 134         GE_CHECK(event_info);
 135         Evas_Event_Mouse_Up *ev = event_info;
 136
 137         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
 138                 return;
 139
 140         ge_dbg("");
 141         ge_cluster *album_item = (ge_cluster*)data;
 142         GE_CHECK(album_item->cluster);
 143         GE_CHECK(album_item->ugd);
 144         ge_ugdata *ugd = album_item->ugd;
 145         if(ugd->ug == NULL) {
 146                 ge_dbg("UG already destroyed, return!");
 147                 return;
 148         }
 149
 150         if (album_item->cluster->count == 0) {
 151                 ge_dbgW("Empty album, return;");
 152                 return;
 153         }
 154
 155         ge_albums_sel_album(album_item);
 156 }
 157
 158 char * _ge_albums_get_text(void *data, Evas_Object *obj, const char *part)
 159 {
 160         GE_CHECK_NULL(part);
 161         GE_CHECK_NULL(data);
 162         ge_cluster *album_item = (ge_cluster *)data;
 163         GE_CHECK_NULL(album_item->cluster);
 164         GE_CHECK_NULL(album_item->cluster->uuid);
 165         GE_CHECK_NULL(album_item->ugd);
 166         ge_ugdata *ugd = album_item->ugd;
 167         char buf[GE_FILE_PATH_LEN_MAX] = {0,};
 168
 169         if (!strcmp(part, "elm.text.name"))
 170         {
 171                 GE_CHECK_NULL(album_item->cluster->display_name);
 172                 if(strlen(album_item->cluster->display_name)) {
 173                         snprintf(buf, sizeof(buf), "%s", (char*)(album_item->cluster->display_name));
 174                         buf[strlen(buf)] = '\0';
 175                 } else if(ge_db_is_root_path(ugd, album_item->cluster->uuid, NULL)) {
 176                         snprintf(buf, sizeof(buf), GE_ALBUM_ROOT_NAME);
 177                         buf[strlen(buf)] = '\0';
 178                 }
 179                 /* Show blue folder name */
 180                 if (!g_strcmp0(album_item->cluster->uuid, GE_ALBUM_ALL_ID) ||
 181                     ge_db_is_default_album(ugd, album_item->cluster)) {
 182                         Elm_Object_Item *grid_it = album_item->griditem;
 183                         const Evas_Object *con_it_obj = NULL;
 184                         con_it_obj = elm_object_item_widget_get(grid_it);
 185                         GE_CHECK_NULL(con_it_obj);
 186                         Evas_Object *it_obj = (Evas_Object *)con_it_obj;
 187                         edje_object_signal_emit(it_obj, "elm,name,show,blue",
 188                                                 "elm");
 189                         edje_object_message_signal_process(it_obj);
 190                 }
 191         }
 192         else if (!strcmp(part, "elm.text.date"))
 193         {
 194                 struct tm  t1;
 195                 struct tm  t2;
 196                 char date1[GE_ALBUM_DATE_LEN_MAX] = {0,};
 197                 char date2[GE_ALBUM_DATE_LEN_MAX] = {0,};
 198                 char date3[GE_ALBUM_DATE_LEN_MAX] = {0,};
 199
 200                 ge_albums_free_cover_thumbs(ugd);
 201
 202                 int item_count = GE_ALBUM_COVER_THUMB_NUM;
 203                 ge_item** items1 = gl_album_items;
 204
 205                 ge_db_get_first_several_items(ugd, album_item, items1, &item_count, MINFO_MEDIA_SORT_BY_DATE_DESC);
 206                 if(item_count <= 0)
 207                 {
 208                         gl_album_count = 0;
 209                         return NULL;
 210                 }
 211
 212                 gl_album_count = item_count;
 213                 if(items1[0] == NULL || items1[0]->item == NULL)
 214                 {
 215                         gl_album_count = 0;
 216                         return NULL;
 217                 }
 218                 memcpy(&album_item->item_mtime, &(items1[0]->item->mtime), sizeof(time_t));
 219
 220                 item_count = 1;
 221                 ge_item* items2[1];
 222                 memset(items2, 0x00, item_count * sizeof(int));
 223                 ge_db_get_first_several_items(ugd, album_item, items2, &item_count, MINFO_MEDIA_SORT_BY_DATE_ASC);
 224
 225                 if(item_count <= 0)
 226                 {
 227                         return NULL;
 228                 }
 229                 else
 230                 {
 231                         memset(&t1, 0x00, sizeof(struct tm));
 232                         localtime_r((time_t *) &(album_item->item_mtime), &t1);
 233                         strftime(date1, sizeof(date1), "%Y.%m.%d", &t1);
 234                         strftime(date3, sizeof(date3), "%Y.%m", &t1);
 235
 236                         if(items2[0] == NULL || items2[0]->item == NULL)
 237                         {
 238                                 gl_album_count = 0;
 239                                 return NULL;
 240                         }
 241                         memset(&t2, 0x00, sizeof(struct tm));
 242                         localtime_r((time_t *) &(items2[0]->item->mtime), &t2);
 243                         strftime(date2, sizeof(date2), "%Y.%m.%d", &t2);
 244
 245                         if(!strcmp(date1, date2))
 246                         {
 247                                 g_strlcpy(buf, date1, sizeof(buf));
 248                         }
 249                         else
 250                         {
 251                                 strftime(date2, sizeof(date2), "%Y.%m", &t2);
 252                                 snprintf(buf, sizeof(buf), "%s - %s", date2, date3);
 253                                 buf[strlen(buf)] = '\0';
 254                         }
 255                 }
 256
 257                 int i = 0;
 258                 for(i = 0; i < item_count; i++)
 259                 {
 260                         ge_db_destroy_item(items2[i]);
 261                         items2[i] = NULL;
 262                 }
 263         }
 264         else if (!strcmp(part, "elm.text.count"))
 265         {
 266                 ge_db_update_items_cnt(ugd, album_item);
 267                 snprintf(buf, sizeof(buf), "%d", (int)(album_item->cluster->count));
 268                 buf[strlen(buf)] = '\0';
 269         }
 270
 271         return strdup(buf);
 272 }
 273
 274 Evas_Object * _ge_albums_get_content(void *data, Evas_Object *obj, const char *part)
 275 {
 276         GE_CHECK_NULL(part);
 277         GE_CHECK_NULL(obj);
 278         GE_CHECK_NULL(data);
 279         if(strlen(part) <= 0)
 280         {
 281                 ge_dbgE("part length <= 0");
 282                 return NULL;
 283         }
 284
 285         ge_cluster* album_item = (ge_cluster*)data;
 286         GE_CHECK_NULL(album_item->cluster);
 287         GE_CHECK_NULL(album_item->cluster->uuid);
 288         GE_CHECK_NULL(album_item->ugd);
 289         ge_ugdata *ugd = album_item->ugd;
 290         double scale_factor = ugd->win_scale;
 291         int i = 0;
 292         int j =0;
 293         int r1 = 0;
 294
 295         if((!strcmp(part, "elm.swallow.firsticon")) ||
 296                 (!strcmp(part, "elm.swallow.icon")) ||
 297                 (!strcmp(part, "elm.swallow.onlyicon")))
 298         {
 299                 if(_ge_get_view_mode() != GE_AlbumsView_Mode)
 300                 {
 301                         ge_dbgE("View mode is wrong!");
 302                         return NULL;
 303                 }
 304
 305                 ge_item **items = gl_album_items;
 306                 int item_count = gl_album_count;
 307                 int length = item_count;
 308                 Evas_Object* bg = NULL;
 309
 310                 if(!strcmp(part, "elm.swallow.onlyicon"))
 311                 {
 312                         /* Part for album contains only one media */
 313                         if(length != 1)
 314                         {
 315                                 return NULL;
 316                         }
 317                         else
 318                         {
 319                                 bg = elm_bg_add(obj);
 320                                 GE_CHECK_NULL(bg);
 321                                 elm_bg_load_size_set(bg,
 322                                         (int)(GE_COVER_ICON_S * scale_factor),
 323                                         (int)(GE_COVER_ICON_S * scale_factor));
 324
 325                                 if(items[0] && (items[0])->item)
 326                                 {
 327                                         elm_bg_file_set(bg, _GETICON((items[0])->item->thumb_url), NULL);
 328                                 }
 329
 330                                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 331                                 evas_object_size_hint_align_set(bg, 0.5, 0.5);
 332                                 evas_object_show(bg);
 333                                 return bg;
 334                         }
 335                 }
 336
 337                 if(!strcmp(part, "elm.swallow.firsticon"))
 338                 {
 339                         ge_dbg("firsticon");
 340                         if(length <= 1)
 341                         {
 342                                 return NULL;
 343                         }
 344                         else
 345                         {
 346                                 bg = elm_bg_add(obj);
 347                                 GE_CHECK_NULL(bg);
 348                                 elm_bg_load_size_set(bg,
 349                                         (int)(GE_COVER_GRID_S * scale_factor),
 350                                         (int)(GE_COVER_GRID_S * scale_factor));
 351                                 if(items[0] && (items[0])->item)
 352                                 {
 353                                         elm_bg_file_set(bg, _GETICON((items[0])->item->thumb_url), NULL);
 354                                 }
 355                         }
 356
 357                         evas_object_size_hint_max_set(bg,
 358                                 (int)(GE_COVER_GRID_S * scale_factor),
 359                                 (int)(GE_COVER_GRID_S * scale_factor));
 360                         evas_object_size_hint_aspect_set(bg, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 361                         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 362                         evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 363                         evas_object_show(bg);
 364                         return bg;
 365                 }
 366
 367                 if(!strcmp(part, "elm.swallow.icon"))
 368                 {
 369                         ge_dbg("icon");
 370                         Evas_Object * tb = NULL;
 371
 372                         if(length <= 0)
 373                         {
 374                                 bg = elm_bg_add(obj);
 375                                 GE_CHECK_NULL(bg);
 376                                 elm_bg_load_size_set(bg,
 377                                         (int)(GE_COVER_ICON_S * scale_factor),
 378                                         (int)(GE_COVER_ICON_S * scale_factor));
 379                                 elm_bg_file_set(bg, GE_DEFAULT_THUMB_ICON, NULL);
 380                                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 381                                 evas_object_size_hint_align_set(bg, 0.5, 0.5);
 382                                 evas_object_show(bg);
 383                                 return bg;
 384                         }
 385                         else if(length == 1)
 386                         {
 387                                 return NULL;
 388                         }
 389                         else if(length == 2)
 390                         {
 391                                 bg = elm_bg_add(obj);
 392                                 GE_CHECK_NULL(bg);
 393                                 elm_bg_load_size_set(bg,
 394                                         (int)(GE_COVER_ICON_S * scale_factor),
 395                                         (int)(GE_COVER_2X_GRID_S * scale_factor));
 396
 397                                 if(items[1] && (items[1])->item)
 398                                 {
 399                                         elm_bg_file_set(bg, _GETICON((items[1])->item->thumb_url), NULL);
 400                                 }
 401
 402                                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 403                                 evas_object_size_hint_align_set(bg, 0.5, 0.5);
 404                                 evas_object_show(bg);
 405                                 return bg;
 406                         }
 407                         else if(length == 3)
 408                         {
 409                                 tb = elm_table_add(obj);
 410                                 GE_CHECK_NULL(tb);
 411                                 elm_table_padding_set(tb,
 412                                                       GE_COVER_PAD * scale_factor,
 413                                                       GE_COVER_PAD * scale_factor);
 414                                 r1 = 1;
 415                                 for(i = 1; i < length; i++)
 416                                 {
 417                                         bg = elm_bg_add(obj);
 418                                         GE_CHECK_NULL(bg);
 419                                         if(i==1)
 420                                         {
 421                                                 elm_bg_load_size_set(bg,
 422                                                         (int)(GE_COVER_2X_GRID_S * scale_factor),
 423                                                         (int)(GE_COVER_2X_GRID_S * scale_factor));
 424                                                 evas_object_size_hint_min_set(bg,
 425                                                         (int)(GE_COVER_2X_GRID_S * scale_factor),
 426                                                         (int)(GE_COVER_2X_GRID_S * scale_factor));
 427                                         }
 428                                         else
 429                                         {
 430                                                 elm_bg_load_size_set(bg,
 431                                                         (int)(GE_COVER_GRID_S * scale_factor),
 432                                                         (int)(GE_COVER_2X_GRID_S * scale_factor));
 433                                                 evas_object_size_hint_min_set(bg,
 434                                                         (int)(GE_COVER_GRID_S * scale_factor),
 435                                                         (int)(GE_COVER_2X_GRID_S * scale_factor));
 436                                         }
 437
 438                                         elm_table_padding_set(tb,
 439                                                               GE_COVER_PAD_2 * scale_factor,
 440                                                               GE_COVER_PAD_2 * scale_factor);
 441
 442                                         if(items[i] && (items[i])->item)
 443                                         {
 444                                                 elm_bg_file_set(bg, _GETICON((items[i])->item->thumb_url), NULL);
 445                                         }
 446
 447                                         if(i==1)
 448                                         {
 449                                                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 450                                                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 451                                                 elm_table_pack(tb, bg, 0, 0, 2, 2);
 452                                         }
 453                                         else
 454                                         {
 455                                                 evas_object_size_hint_aspect_set(bg, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 456                                                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 457                                                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 458                                                 elm_table_pack(tb, bg, 2, 0, 1, 2);
 459                                         }
 460                                         evas_object_show(bg);
 461                                 }
 462                         }
 463                         else if(length < GE_ALBUM_COVER_THUMB_NUM)
 464                         {
 465                                 length = GE_ALBUM_COVER_THUMB_NUM_SEC;
 466                                 tb = elm_table_add(obj);
 467                                 GE_CHECK_NULL(tb);
 468                                 elm_table_padding_set(tb,
 469                                                       GE_COVER_PAD * scale_factor,
 470                                                       GE_COVER_PAD * scale_factor);
 471                                 elm_table_padding_set(tb,
 472                                                       GE_COVER_PAD_2 * scale_factor,
 473                                                       GE_COVER_PAD_2 * scale_factor);
 474                                 r1 = 1;
 475                                 for(i = 1; i < length; i++)
 476                                 {
 477                                         bg = elm_bg_add(obj);
 478                                         GE_CHECK_NULL(bg);
 479                                         if(i == 1)
 480                                         {
 481                                                 elm_bg_load_size_set(bg,
 482                                                         (int)(GE_COVER_2X_GRID_S * scale_factor),
 483                                                         (int)(GE_COVER_2X_GRID_S * scale_factor));
 484                                                 evas_object_size_hint_min_set(bg,
 485                                                         (int)(GE_COVER_2X_GRID_S * scale_factor),
 486                                                         (int)(GE_COVER_2X_GRID_S * scale_factor));
 487                                         }
 488                                         else
 489                                         {
 490                                                 elm_bg_load_size_set(bg,
 491                                                         (int)(GE_COVER_GRID_S * scale_factor),
 492                                                         (int)(GE_COVER_GRID_S * scale_factor));
 493                                                 evas_object_size_hint_min_set(bg,
 494                                                         (int)(GE_COVER_GRID_S * scale_factor),
 495                                                         (int)(GE_COVER_GRID_S * scale_factor));
 496                                         }
 497
 498                                         if(items[i] && (items[i])->item)
 499                                         {
 500                                                 elm_bg_file_set(bg, _GETICON((items[i])->item->thumb_url), NULL);
 501                                         }
 502
 503                                         evas_object_size_hint_aspect_set(bg, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 504                                         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 505                                         evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 506
 507                                         if(i == 1)
 508                                                 elm_table_pack(tb, bg, 0, 0, 2, 2);
 509                                         else if(i == 2)
 510                                                 elm_table_pack(tb, bg, 2, 0, 1, 1);
 511                                         else if(i == 3)
 512                                                 elm_table_pack(tb, bg, 2, 1, 1, 1);
 513                                         evas_object_show(bg);
 514                                 }
 515                         }
 516                         else
 517                         {
 518                                 tb = elm_table_add(obj);
 519                                 GE_CHECK_NULL(tb);
 520                                 elm_table_padding_set(tb,
 521                                                       GE_COVER_PAD * scale_factor,
 522                                                       GE_COVER_PAD * scale_factor);
 523
 524                                 if((!strcmp(album_item->cluster->display_name, GE_ALBUM_ALL_NAME)) ||
 525                                         (!strcmp(album_item->cluster->display_name, GE_ALBUM_MY_NAME)))
 526                                 {
 527                                         for(i = 1; i < GE_ALBUM_COVER_THUMB_NUM; i++)
 528                                         {
 529                                                 if(i < item_count)
 530                                                 {
 531                                                         bg = elm_bg_add(obj);
 532                                                         GE_CHECK_NULL(bg);
 533                                                         elm_bg_load_size_set(bg,
 534                                                                 (int)(GE_COVER_GRID_S * scale_factor),
 535                                                                 (int)(GE_COVER_GRID_S * scale_factor));
 536
 537                                                         if(items[i] && (items[i])->item)
 538                                                         {
 539                                                                 elm_bg_file_set(bg, _GETICON((items[i])->item->thumb_url), NULL);
 540                                                         }
 541                                                 }
 542                                                 else
 543                                                 {
 544                                                         bg = evas_object_rectangle_add(evas_object_evas_get(obj));
 545
 546                                                         if (!g_strcmp0(album_item->cluster->uuid, GE_ALBUM_ALL_ID) ||
 547                                                             ge_db_is_default_album(ugd, album_item->cluster))
 548                                                                 j = GE_BG_COLOR_CNT;
 549                                                         else
 550                                                                 j = (album_item->index) % GE_BG_COLOR_CNT;
 551                                                         evas_object_color_set(bg, ge_bg_color[j].r,
 552                                                                               ge_bg_color[j].g, ge_bg_color[j].b,
 553                                                                               GE_ALBUM_TEXT_COLOR_ALPHA);
 554                                                 }
 555
 556                                                 evas_object_size_hint_aspect_set(bg, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 557                                                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 558                                                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 559
 560                                                 elm_table_pack(tb, bg, (int)((i-1)%3), (int)((i-1)/3), 1, 1);
 561
 562                                                 evas_object_show(bg);
 563                                         }
 564                                 }
 565                                 else
 566                                 {
 567                                         elm_table_padding_set(tb,
 568                                                               GE_COVER_PAD_2 * scale_factor,
 569                                                               GE_COVER_PAD_2 * scale_factor);
 570                                         r1= 1;
 571                                         for(i = 1; i < GE_ALBUM_COVER_THUMB_NUM_SEC; i++)
 572                                         {
 573                                                 bg = elm_bg_add(obj);
 574                                                 GE_CHECK_NULL(bg);
 575                                                 if(i == 1)
 576                                                 {
 577                                                         elm_bg_load_size_set(bg,
 578                                                                 (int)(GE_COVER_2X_GRID_S * scale_factor),
 579                                                                 (int)(GE_COVER_2X_GRID_S * scale_factor));
 580                                                         evas_object_size_hint_min_set(bg,
 581                                                                 (int)(GE_COVER_2X_GRID_S * scale_factor),
 582                                                                 (int)(GE_COVER_2X_GRID_S * scale_factor));
 583                                                 }
 584                                                 else
 585                                                 {
 586                                                         elm_bg_load_size_set(bg,
 587                                                                 (int)(GE_COVER_GRID_S * scale_factor),
 588                                                                 (int)(GE_COVER_GRID_S * scale_factor));
 589                                                         evas_object_size_hint_min_set(bg,
 590                                                                 (int)(GE_COVER_GRID_S * scale_factor),
 591                                                                 (int)(GE_COVER_GRID_S * scale_factor));
 592                                                 }
 593
 594                                                 if(items[i] && (items[i])->item)
 595                                                 {
 596                                                         elm_bg_file_set(bg, _GETICON((items[i])->item->thumb_url), NULL);
 597                                                 }
 598
 599                                                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 600                                                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 601
 602                                                 if(i == 1)
 603                                                         elm_table_pack(tb, bg, 0, 0, 2, 2);
 604                                                 else if(i == 2)
 605                                                         elm_table_pack(tb, bg, 2, 0, 1, 1);
 606                                                 else if( i == 3)
 607                                                         elm_table_pack(tb, bg, 2, 1, 1, 1);
 608                                                 evas_object_show(bg);
 609                                         }
 610                                 }
 611                         }
 612                         evas_object_show(tb);
 613                         return tb;
 614                 }
 615         }
 616         else if (!strcmp(part, "label_bg"))
 617         {
 618                 Evas_Object *bg = evas_object_rectangle_add(evas_object_evas_get(obj));
 619                 GE_CHECK_NULL(bg);
 620                 /**
 621                 *  for "All"  their colors should be
 622                 *  25:25:25 by new gui
 623                 */
 624                 if (!g_strcmp0(album_item->cluster->uuid, GE_ALBUM_ALL_ID) ||
 625                     ge_db_is_default_album(ugd, album_item->cluster))
 626                         j = GE_BG_COLOR_CNT;
 627                 else
 628                         j = (album_item->index) % GE_BG_COLOR_CNT;
 629                 evas_object_color_set(bg, ge_bg_color[j].r,
 630                                       ge_bg_color[j].g, ge_bg_color[j].b,
 631                                       GE_ALBUM_TEXT_COLOR_ALPHA);
 632
 633                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 634                 evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 635                 evas_object_show(bg);
 636
 637                 return bg;
 638         }
 639
 640         return NULL;
 641 }
 642
 643 static int _ge_albums_create_album(ge_ugdata* ugd, Evas_Object* parent)
 644 {
 645         ge_dbg("");
 646         GE_CHECK_VAL(parent, -1);
 647         GE_CHECK_VAL(ugd, -1);
 648         GE_CHECK_VAL(ugd->cluster_list, -1);
 649         int i = 0;
 650         int grid_cnt = 0;
 651         ge_cluster *album_item = NULL;
 652
 653         album_gic.item_style = "albums_view";
 654         album_gic.func.text_get = _ge_albums_get_text;
 655         album_gic.func.content_get = _ge_albums_get_content;
 656
 657         int length = eina_list_count(ugd->cluster_list->clist);
 658         ge_dbg("Albums list length: %d.", length);
 659
 660         elm_gengrid_clear(parent);
 661
 662         if(ugd->th)
 663         {
 664                 elm_object_theme_set(parent, ugd->th);
 665         }
 666         elm_object_style_set(parent, "gallery_efl/default");
 667
 668         for(i = 0; i < length; i++)
 669         {
 670                 album_item = eina_list_nth(ugd->cluster_list->clist, i);
 671                 GE_CHECK_VAL(album_item, -1);
 672                 GE_CHECK_VAL(album_item->cluster, -1);
 673                 GE_CHECK_VAL(album_item->cluster->display_name, -1);
 674
 675                 album_item->griditem = elm_gengrid_item_append(parent,
 676                                                                &album_gic,
 677                                                                album_item,
 678                                                                __ge_albums_sel_cb,
 679                                                                album_item);
 680                 album_item->index = grid_cnt;
 681                 grid_cnt++;
 682
 683                 ge_dbg("Append [%s], id=%s.", album_item->cluster->display_name,
 684                        album_item->cluster->uuid);
 685         }
 686
 687         gl_albums_item_cnt = grid_cnt;
 688
 689         if(grid_cnt)
 690         {
 691                 return 0;
 692         }
 693         else
 694         {
 695                 ge_dbgW("None albums appended to view!");
 696                 return -1;
 697         }
 698 }
 699
 700 int ge_albums_free_cover_thumbs(ge_ugdata *ugd)
 701 {
 702         GE_CHECK_VAL(ugd, -1);
 703         int i = 0;
 704
 705         for(i = 0; i < GE_ALBUM_COVER_THUMB_NUM; i++)
 706         {
 707                 if(gl_album_items[i])
 708                 {
 709                         ge_db_destroy_item(gl_album_items[i]);
 710                         gl_album_items[i] = NULL;
 711                 }
 712         }
 713
 714         return 0;
 715 }
 716
 717 int ge_albums_back_to_view(ge_ugdata *ugd)
 718 {
 719         ge_dbg("");
 720         GE_CHECK_VAL(ugd, -1);
 721
 722         if(ugd->file_select_mode == GE_File_Select_Multiple)
 723         {
 724                 ge_ui_destroy_selinfo(ugd);
 725                 ge_db_selected_list_finalize();
 726         }
 727
 728         GE_DEL_IDLER(ugd->grid_append_idler)
 729
 730         ge_albums_update_view(ugd);
 731         ge_grid_clear_view(ugd);
 732
 733         _ge_set_view_mode(GE_AlbumsView_Mode);
 734         return 0;
 735 }
 736
 737 int ge_albums_sel_album(ge_cluster* album_item)
 738 {
 739         ge_dbg("");
 740         GE_CHECK_VAL(album_item, -1);
 741         GE_CHECK_VAL(album_item->cluster, -1);
 742         GE_CHECK_VAL(album_item->cluster->uuid, -1);
 743         GE_CHECK_VAL(album_item->ugd, -1);
 744
 745         if(_ge_get_view_mode() != GE_AlbumsView_Mode)
 746         {
 747                 ge_dbgE("error mode.. now return!");
 748                 return -1;
 749         }
 750         else
 751         {
 752                 ge_dbg("ViewMode");
 753         }
 754
 755         ge_ugdata *ugd = album_item->ugd;
 756         GE_CHECK_VAL(ugd->cluster_list, -1);
 757         GE_CHECK_VAL(ugd->navi_bar, -1);
 758         ge_dbg("Album: %s, id: %s, cluster_index: %d.",
 759                album_item->cluster->display_name, album_item->cluster->uuid,
 760                album_item->index);
 761
 762         if(ugd->album_select_mode == GE_Album_Select_One)
 763         {
 764                 ge_dbg("One album selected, return album id and destroy the ug!");
 765
 766                 char folder_path[GE_DIR_PATH_LEN_MAX] = { 0, };
 767                 ge_db_get_folder_fullpath(ugd, album_item->cluster->uuid,
 768                                           folder_path);
 769                 bundle_del(ugd->bundle, GE_ALBUM_SELECT_RETURN_PATH);
 770                 bundle_add(ugd->bundle, GE_ALBUM_SELECT_RETURN_PATH, folder_path);
 771                 ge_dbg("return folder-path: %s", folder_path);
 772                 ug_send_result(ugd->ug, ugd->bundle);
 773                 ug_destroy_me(ugd->ug);
 774                 ugd->ug = NULL;
 775                 return 0;
 776         }
 777
 778         /* Set current album */
 779         _ge_set_current_album(album_item);
 780         /* Remove idler */
 781         GE_DEL_IDLER(ugd->grid_append_idler)
 782         /* Get album contents from DB */
 783         ge_db_get_items_list(ugd, album_item, GE_FIRST_VIEW_START_POS, GE_FIRST_VIEW_END_POS);
 784
 785         if(ugd->file_select_mode == GE_File_Select_Setas)
 786         {
 787                 ge_dbg("setas mode->thumbnail is view mode");
 788                 _ge_set_view_mode(GE_ThumbnailView_Mode);
 789         }
 790         else
 791         {
 792                 ge_dbg("select mode->thumbnail is edit mode");
 793                 _ge_set_view_mode(GE_ThumbnailEdit_Mode);
 794         }
 795
 796         ugd->cluster_list->cur_pos = album_item->index; //save the index of current selected album
 797         ge_dbg("\n\nIndex is %d\n",album_item->index);
 798
 799         ugd->thumbs_view_ly = ge_grid_create_ly(ugd->navi_bar);
 800         GE_CHECK_VAL(ugd->thumbs_view_ly, -1);
 801         Evas_Object* gv = NULL;
 802
 803         gv = ge_grid_create_view(ugd, ugd->thumbs_view_ly);
 804         GE_CHECK_VAL(gv, -1);
 805
 806         elm_object_part_content_set(ugd->thumbs_view_ly, "contents", gv);
 807         ugd->thumbs_view = gv;
 808         if(gv == ugd->nocontents)
 809         {
 810                 ugd->thumbs_nocontents = gv;
 811         }
 812
 813         /* Clear view */
 814         elm_gengrid_clear(ugd->albums_view);
 815
 816         if(_ge_get_view_mode() == GE_ThumbnailView_Mode)
 817         {
 818                 /* Check root case */
 819                 if(ge_db_is_root_path(ugd, album_item->cluster->uuid, NULL))
 820                 {
 821                         ge_ui_create_title_and_push(ugd, ugd->navi_bar,
 822                                 ugd->thumbs_view_ly, ThumbnailView_Title, GE_ALBUM_ROOT_NAME);
 823                 }
 824                 else
 825                 {
 826                         ge_ui_create_title_and_push(ugd, ugd->navi_bar,
 827                                 ugd->thumbs_view_ly, ThumbnailView_Title, album_item->cluster->display_name);
 828                 }
 829         }
 830         else
 831         {
 832                 ge_ui_create_title_and_push(ugd, ugd->navi_bar,
 833                         ugd->thumbs_view_ly, ThumbnailView_Title, ugd->albums_view_title);
 834         }
 835
 836         if(ge_db_get_count_all() == (GE_FIRST_VIEW_END_POS+1))
 837         {
 838                 ge_dbg("\n\n>>>>>>>>Use idler to append other medias--Start>>>>>>>>\n");
 839                 ugd->grid_append_idler = ecore_idler_add(_ge_albums_append_grid_idler, ugd);
 840         }
 841
 842         ge_dbg("Done ge_albums_sel_album");
 843         return 0;
 844 }
 845
 846 Evas_Object* ge_albums_create_ly(Evas_Object* parent)
 847 {
 848         ge_dbg("");
 849         GE_CHECK_NULL(parent);
 850         Evas_Object* layout = ge_ui_load_edj(parent, GE_EDJ_FILE, GE_GRP_ALBUMVIEW);
 851         GE_CHECK_NULL(layout);
 852         evas_object_show (layout);
 853
 854         return layout;
 855 }
 856
 857 int ge_albums_del_callbacks(ge_ugdata* ugd)
 858 {
 859         GE_CHECK_VAL(ugd, -1);
 860         if(ugd->albums_view)
 861         {
 862                 ge_dbg("Delete albums callbacks!");
 863                 evas_object_smart_callback_del(ugd->albums_view, "selected", _ge_albums_selected);
 864                 evas_object_smart_callback_del(ugd->albums_view, "unselected", _ge_albums_unselected);
 865                 evas_object_smart_callback_del(ugd->albums_view, "clicked", _ge_albums_clicked);
 866                 evas_object_smart_callback_del(ugd->albums_view, "longpressed", _ge_albums_longpress);
 867                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,up", _ge_albums_drag_up);
 868                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,right", _ge_albums_drag_right);
 869                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,down", _ge_albums_drag_down);
 870                 evas_object_smart_callback_del(ugd->albums_view, "drag,start,left", _ge_albums_drag_left);
 871                 evas_object_smart_callback_del(ugd->albums_view, "drag,stop", _ge_albums_drag_stop);
 872                 evas_object_smart_callback_del(ugd->albums_view, "realized", _ge_albums_realized);
 873         }
 874         return 0;
 875 }
 876
 877 Evas_Object* ge_albums_create_view(ge_ugdata* ugd, Evas_Object* parent)
 878 {
 879         ge_dbg("");
 880         GE_CHECK_NULL(parent);
 881         GE_CHECK_NULL(ugd);
 882         GE_CHECK_NULL(ugd->cluster_list);
 883
 884         memset(gl_album_items, 0x00, GE_ALBUM_COVER_THUMB_NUM * sizeof(int));
 885         gl_album_count = 0;
 886
 887         ge_get_ums_state(ugd);
 888         if(ugd->ug_exit_mode || !ugd->cluster_list->clist ||
 889            (eina_list_count(ugd->cluster_list->clist) == 0)) {
 890                 ge_dbgW("It's UMS mode or clusters list is empty!");
 891                 goto ALBUMS_FAILED;
 892         }
 893
 894         double scale_factor = ugd->win_scale;
 895         ge_dbg("Own scale facotr: %f, elm_config_scale_get =%f.", scale_factor, elm_config_scale_get());
 896
 897         Evas_Object *grid = elm_gengrid_add(parent);
 898         GE_CHECK_NULL(grid);
 899         elm_gengrid_item_size_set(grid,
 900                 (int)(GE_ALBUM_ITEM_WIDTH * scale_factor),
 901                 (int)(GE_ALBUM_ITEM_HEIGHT * scale_factor));
 902         elm_gengrid_align_set(grid, 0.5, 0.0);
 903         elm_gengrid_horizontal_set(grid, EINA_FALSE);
 904         elm_gengrid_bounce_set(grid, EINA_FALSE, EINA_TRUE);
 905         elm_gengrid_multi_select_set(grid, EINA_TRUE);
 906         evas_object_size_hint_weight_set(grid, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 907
 908         if(_ge_albums_create_album(ugd, grid) != 0)
 909         {
 910                 ge_dbgW("Failed to append album items!");
 911                 evas_object_del(grid);
 912                 grid = NULL;
 913
 914                 goto ALBUMS_FAILED;
 915         }
 916         else
 917         {
 918                 evas_object_show (grid);
 919         }
 920
 921         evas_object_smart_callback_add(grid, "selected", _ge_albums_selected, NULL);
 922         evas_object_smart_callback_add(grid, "unselected", _ge_albums_unselected, NULL);
 923         evas_object_smart_callback_add(grid, "clicked", _ge_albums_clicked, NULL);
 924         evas_object_smart_callback_add(grid, "longpressed", _ge_albums_longpress, NULL);
 925         evas_object_smart_callback_add(grid, "drag,start,up", _ge_albums_drag_up, NULL);
 926         evas_object_smart_callback_add(grid, "drag,start,right", _ge_albums_drag_right, NULL);
 927         evas_object_smart_callback_add(grid, "drag,start,down", _ge_albums_drag_down, NULL);
 928         evas_object_smart_callback_add(grid, "drag,start,left", _ge_albums_drag_left, NULL);
 929         evas_object_smart_callback_add(grid, "drag,stop", _ge_albums_drag_stop, NULL);
 930         evas_object_smart_callback_add(grid, "realized", _ge_albums_realized, NULL);
 931
 932         return grid;
 933
 934 ALBUMS_FAILED:
 935         /* Show no contents if none albums exist */
 936         ge_dbgW("@@@@@@@  To create nocontents view  @@@@@@@@");
 937         ugd->nocontents = ge_ui_create_nocontents(ugd);
 938         ugd->albums_view = ugd->nocontents;
 939         evas_object_show (ugd->nocontents);
 940
 941         return ugd->nocontents;
 942 }
 943
 944 int ge_albums_update_view(ge_ugdata *ugd)
 945 {
 946         ge_dbg("");
 947         GE_CHECK_VAL(ugd, -1);
 948         GE_CHECK_VAL(ugd->cluster_list, -1);
 949         /* Changed to show no contents if needed */
 950         ge_get_ums_state(ugd);
 951         if(ugd->ug_exit_mode || !ugd->cluster_list->clist ||
 952            (eina_list_count(ugd->cluster_list->clist) == 0)) {
 953                 ge_dbgW("It's UMS mode or clusters list is empty!");
 954                 goto ALBUMS_FAILED;
 955         }
 956
 957         if(ugd->nocontents && ugd->nocontents == ugd->albums_view) {
 958                 /* It is nocontents, unset it first then create albums view*/
 959                 evas_object_del(ugd->nocontents);
 960                 ugd->nocontents = NULL;
 961
 962                 ugd->albums_view = ge_albums_create_view(ugd, ugd->navi_bar);
 963                 GE_CHECK_VAL(ugd->albums_view, -1);
 964                 elm_object_part_content_set(ugd->albums_view_ly, "contents",
 965                                        ugd->albums_view);
 966                 evas_object_show(ugd->albums_view);
 967         } else {
 968                 if(_ge_albums_create_album(ugd, ugd->albums_view) != 0)
 969                         goto ALBUMS_FAILED;
 970         }
 971
 972         return 0;
 973
 974 ALBUMS_FAILED:
 975
 976         if(ugd->albums_view && ugd->albums_view != ugd->nocontents)
 977                 ge_albums_del_callbacks(ugd);
 978
 979         evas_object_del(ugd->albums_view);
 980
 981         ge_dbgW("@@@@@@@  To create nocontents view @@@@@@@@");
 982         ugd->nocontents = ge_ui_create_nocontents(ugd);
 983         ugd->albums_view = ugd->nocontents;
 984         GE_CHECK_VAL(ugd->albums_view, -1);
 985         evas_object_show(ugd->albums_view);
 986
 987         elm_object_part_content_set(ugd->albums_view_ly, "contents", ugd->albums_view);
 988         return -1;
 989 }
 990