src/views/album-layout.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15 */
  16
  17 #include <Elementary.h>
  18 #include <Eina.h>
  19
  20 #include <AppCommon.h>
  21 #include <InputHandler.h>
  22 #include <SortMgr.h>
  23
  24 #include "dbg.h"
  25 #include "i18n.h"
  26 #include "define.h"
  27 #include "common.h"
  28 #include "album_info.h"
  29 #include "song_info.h"
  30 #include "music-controller.h"
  31 #include "LayoutMgr.h"
  32 #include "common-ui.h"
  33 #include "BaseView.h"
  34 #include "BaseLayout.h"
  35 #include "ExtBaseLayout.h"
  36 #include "ViewMgr.h"
  37 #include "album-layout.h"
  38 #include "album-songs-layout.h"
  39 #include "base-view.h"
  40 #include "Info.h"
  41
  42 #define GENGRID_ITEM_SIZE_W (263+20)
  43 #define GENGRID_ITEM_SIZE_H (359+20)
  44
  45
  46 enum EObjectType {
  47         ALBUM_LAYOUT,
  48         ALBUM_GENGRID,
  49 };
  50
  51 struct SAlbumItemInfo {
  52         CAlbumInfo *alinfo;
  53         Elm_Object_Item *item;
  54 };
  55
  56 struct SCallback {
  57         void(*cbHandleEmptyStatus)(void *cookie, bool emptyStatus);
  58         void *cookie;
  59 };
  60
  61 struct SAlbumLayout {
  62         Evas_Object *win;
  63         Evas_Object *base;
  64         Evas_Object *grid;
  65         Elm_Object_Item *focusedItem;
  66         Eina_List *alblist;
  67         Eina_List *it_infolist;
  68         Elm_Gengrid_Item_Class *item_class;
  69         CMusicController *mhandle;
  70         CLayoutMgr *lmgr;
  71         CViewMgr *vmgr;
  72         SContentInfo *ctxtinfo;
  73         char *album_id;
  74         CAlbumSongsLayout *layoutAlbumSongs;
  75         SCallback callback;
  76         Ecore_Idler *focusIdler;
  77
  78         SAlbumLayout() {
  79                 memset(this, 0, sizeof(SAlbumLayout));
  80         }
  81
  82         ~SAlbumLayout() {
  83         }
  84 };
  85
  86
  87 Eina_Bool CAlbumLayout::sm_CbFocusIdler(void *dt)
  88 {
  89         CAlbumLayout *root = (CAlbumLayout *)dt;
  90
  91         if (root)
  92                 root->m_OnFocusIdler();
  93
  94         return ECORE_CALLBACK_CANCEL;
  95 }
  96
  97
  98 void CAlbumLayout::m_OnFocusIdler(void)
  99 {
 100         m->focusIdler = NULL;
 101
 102         ASSERT(m->focusedItem);
 103         elm_gengrid_item_show(m->focusedItem, ELM_GENGRID_ITEM_SCROLLTO_IN);
 104         elm_object_item_focus_set(m->focusedItem, EINA_TRUE);
 105 }
 106
 107
 108 char *CAlbumLayout::sm_CbGetGridItemText(void *data, Evas_Object *obj, const char *part)
 109 {
 110         SAlbumItemInfo *itinfo = (SAlbumItemInfo *)data;
 111         CAlbumInfo *alinfo = NULL;
 112         char *txt = NULL;
 113
 114         if (!itinfo || !obj)
 115                 return NULL;
 116
 117         alinfo = itinfo->alinfo;
 118         txt = NULL;
 119
 120         if (!strcmp(part, "elm.text"))
 121                 txt = alinfo->Name();
 122         else if (!strcmp(part, "elm.text1"))
 123                 txt = alinfo->Artist();
 124
 125         if (txt)
 126                 return strdup(txt);
 127
 128         return NULL;
 129 }
 130
 131
 132 Evas_Object *CAlbumLayout::sm_CbGetGridItemContent(void *data, Evas_Object *obj, const char *part)
 133 {
 134         SAlbumItemInfo *itinfo = (SAlbumItemInfo *)data;
 135         CAlbumInfo *alinfo = NULL;
 136         char *path = NULL;
 137         Evas_Object *img = NULL;
 138         char buf[MAX_LENGTH];
 139
 140         if (!itinfo || !obj)
 141                 return NULL;
 142
 143         alinfo = itinfo->alinfo;
 144
 145         if (!strcmp(part, "elm.swallow.icon")) {
 146                 img = elm_image_add(obj);
 147                 if (!img)
 148                         return NULL;
 149
 150                 path = alinfo->ThumbnailPath();
 151                 if (!path) {
 152                         snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 153                                 MUSIC_IMAGE_DEFAULT_THUMB_126);
 154                         elm_image_file_set(img, buf, "NULL");
 155                         elm_image_no_scale_set(img, EINA_TRUE);
 156                 }
 157                 else {
 158                         elm_image_file_set(img, path, "NULL");
 159                         elm_image_aspect_fixed_set(img, EINA_FALSE);
 160                 }
 161                 return img;
 162         }
 163
 164         return NULL;
 165 }
 166
 167
 168 void CAlbumLayout::sm_CbRemoveGridItem(void *data, Evas_Object *obj)
 169 {
 170         free(data);
 171 }
 172
 173
 174 void CAlbumLayout::sm_CbCtxtUpdate(void *dt, enum EActionType type, int lid)
 175 {
 176         CAlbumLayout *root = (CAlbumLayout*)dt;
 177
 178         if (root)
 179                 root->m_OnCtxtUpdate(type, lid);
 180 }
 181
 182
 183 void CAlbumLayout::m_OnCtxtUpdate(EActionType type, int lid)
 184 {
 185         Eina_List *list = NULL;
 186         CSongInfo *sinfo = NULL;
 187         EAddType mode;
 188
 189         if (!m->ctxtinfo || !m->ctxtinfo->context)
 190                 return;
 191
 192         if (type == ACTION_TYPE_ADDNEXT)
 193                 mode = ADD_TYPE_NEXT;
 194         else
 195                 mode = ADD_TYPE_END;
 196
 197         m->mhandle->MediaGetList(LIST_TYPE_ALBUM_SONG,
 198                 m->ctxtinfo->context, &list);
 199         if (type ==  ACTION_TYPE_ADDTO) {
 200                 if (!m->mhandle->MediaAddsongsPlaylist(lid, list))
 201                         _ERR(" Adding songs to playlist failed ");
 202                 else
 203                         CCommonUI::CreateMsgBox(m->base, MUSIC_TEXT_ADDTO_MSG);
 204
 205                 return;
 206         }
 207
 208         m->mhandle->UpdatePlaylist(list, mode);
 209         sinfo = (CSongInfo *)eina_list_data_get(list);
 210         eina_list_free(list);
 211
 212         if (type == ACTION_TYPE_PLAY) {
 213                 m->mhandle->Stop();
 214                 m->mhandle->SetCurrentSong(sinfo->Id());
 215         }
 216
 217         CCommonUI::UpdatePlaybackView((EAddType)type, Layout(), m->focusedItem);
 218 }
 219
 220
 221 void CAlbumLayout::sm_CbCtxtClose(void *dt)
 222 {
 223         CAlbumLayout *root = (CAlbumLayout*)dt;
 224
 225         if (root)
 226                 root->m_OnCtxtClose();
 227 }
 228
 229
 230 void CAlbumLayout::m_OnCtxtClose(void)
 231 {
 232         m->vmgr->PopView();
 233         m->vmgr->PushView(MUSIC_BASE_VIEW, NULL);
 234         elm_object_item_focus_set(m->focusedItem, EINA_TRUE);
 235 }
 236
 237
 238 void CAlbumLayout::sm_CbItemSelect(void *data, Elm_Object_Item *it, const char *emission, const char *source)
 239 {
 240         CAlbumLayout *root = (CAlbumLayout*)data;
 241
 242         if (root)
 243                 root->m_OnItemSelect(it, emission, source);
 244 }
 245
 246
 247 void CAlbumLayout::m_OnItemSelect(Elm_Object_Item *it, const char *emission, const char *source)
 248 {
 249         SAlbumItemInfo *itinfo;
 250
 251         itinfo = m_FindItemInfo(m->it_infolist, it);
 252         if (!itinfo) {
 253                 _ERR(" no item info found ");
 254                 return;
 255         }
 256
 257         m->layoutAlbumSongs->SetCurrentAlbum(itinfo->alinfo);
 258         m_ShowAlbumSongs();
 259 }
 260
 261
 262 SAlbumItemInfo *CAlbumLayout::m_FindItemInfo(Eina_List *list, Elm_Object_Item *item)
 263 {
 264         Eina_List *l = NULL;
 265         SAlbumItemInfo *itinfo = NULL;
 266         void *obj = NULL;
 267
 268         if (!list || !item)
 269                 return NULL;
 270
 271         EINA_LIST_FOREACH(list, l, obj) {
 272                 itinfo = (SAlbumItemInfo *)obj;
 273                 if (itinfo->item == item)
 274                         return itinfo;
 275         }
 276
 277         return NULL;
 278 }
 279
 280
 281 SAlbumItemInfo *CAlbumLayout::m_FindItemInfoById(Eina_List *list, int alid)
 282 {
 283         Eina_List *l = NULL;
 284         SAlbumItemInfo *itinfo = NULL;
 285         void *obj = NULL;
 286         int id;
 287
 288         if (!list)
 289                 return NULL;
 290
 291         EINA_LIST_FOREACH(list, l, obj) {
 292                 itinfo = (SAlbumItemInfo *)obj;
 293                 if (!itinfo->alinfo)
 294                         continue;
 295                 id = itinfo->alinfo->AlbumId();
 296                 if (alid == id) {
 297                         return itinfo;
 298                 }
 299         }
 300
 301         return NULL;
 302 }
 303
 304
 305 void CAlbumLayout::m_ShowAlbumSongs(void)
 306 {
 307         elm_object_part_content_unset(m->base, MUSIC_PART_CONTENT);
 308
 309         bool emptyStatus = m->layoutAlbumSongs->EmptyStatus();
 310
 311         if (emptyStatus == false) {
 312                 elm_object_part_content_set(m->base, MUSIC_PART_CONTENT, m->layoutAlbumSongs->Layout());
 313                 m->lmgr->Show(MUSIC_ALBUM_SONGS_LAYOUT);
 314         }
 315
 316         if (m->callback.cbHandleEmptyStatus != NULL) {
 317                 m->callback.cbHandleEmptyStatus(m->callback.cookie, emptyStatus);
 318         }
 319 }
 320
 321
 322 void CAlbumLayout::m_RemoveAlbumList(Eina_List *list)
 323 {
 324         eina_list_free(list);
 325 }
 326
 327
 328 void CAlbumLayout::m_CreateAlbumGrid(void)
 329 {
 330         Evas_Object *grid;
 331         Elm_Gengrid_Item_Class *grid_item;
 332
 333         grid = elm_gengrid_add(Layout());
 334         if (!grid)
 335                 return;
 336
 337         evas_object_size_hint_weight_set(grid,
 338                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 339         elm_gengrid_align_set(grid, 0, 0);
 340         elm_object_part_content_set(Layout(), MUSIC_PART_ALBUM_GRID, grid);
 341         Connect(grid, ALBUM_GENGRID, TYPE_MOUSE_MOVE | TYPE_KEY_DOWN | TYPE_REALIZED | TYPE_UNREALIZED | TYPE_ACTIVATED);
 342         elm_gengrid_item_size_set(grid,
 343                 elm_config_scale_get() * GENGRID_ITEM_SIZE_W,
 344                 elm_config_scale_get() * GENGRID_ITEM_SIZE_H);
 345
 346         m->grid = grid;
 347
 348         grid_item = elm_gengrid_item_class_new();
 349         if (!grid_item) {
 350                 evas_object_del(grid);
 351                 _ERR(" elm_genlist_item_class_new failed ");
 352                 return;
 353         }
 354
 355         grid_item->item_style = MUSIC_STYLE_ALBUM_GRID;
 356         grid_item->func.text_get = sm_CbGetGridItemText;
 357         grid_item->func.content_get = sm_CbGetGridItemContent;
 358         grid_item->func.state_get = NULL;
 359         grid_item->func.del = sm_CbRemoveGridItem;
 360         m->item_class = grid_item;
 361
 362         m_UpdateAlbumGrid(false);
 363 }
 364
 365
 366 void CAlbumLayout::m_EmptyAlbumGrid(bool sort_flag)
 367 {
 368         if (m->grid)
 369                 elm_gengrid_clear(m->grid);
 370
 371         if (!sort_flag) {
 372                 m_RemoveAlbumList(m->alblist);
 373                 m->alblist = NULL;
 374         }
 375
 376         eina_list_free(m->it_infolist);
 377         m->it_infolist = NULL;
 378 }
 379
 380
 381 void CAlbumLayout::m_SortAlbumGrid(void)
 382 {
 383         int sortType;
 384         const char *sortFuncId[] = {
 385                 SORT_BY_NAME_AZ,
 386                 SORT_BY_NAME_ZA,
 387         };
 388
 389         sortType = CInfo::SortType();
 390
 391         m->alblist = CSortMgr::Sort(m->alblist, sortFuncId[sortType]);
 392 }
 393
 394
 395 void CAlbumLayout::m_UpdateAlbumGrid(bool sort_flag)
 396 {
 397         bool r;
 398         CAlbumInfo *alinfo;
 399         void *obj;
 400         Eina_List *l;
 401         SAlbumItemInfo *itinfo;
 402         Elm_Object_Item *item;
 403
 404         /* Remove existing albumgrid and prepare afresh */
 405         m_EmptyAlbumGrid(sort_flag);
 406
 407         if (!sort_flag) {
 408                 r = m->mhandle->MediaGetList(LIST_TYPE_ALBUM, NULL, &(m->alblist));
 409                 if (r == false ||
 410                         eina_list_count(m->alblist) == 0) {
 411                         _ERR(" Fetching album list from media failed ");
 412                         SetEmptyStatus(true);
 413                         return;
 414                 }
 415         }
 416
 417         m_SortAlbumGrid();
 418
 419         int i = 0;
 420         EINA_LIST_FOREACH(m->alblist, l, obj) {
 421                 alinfo = (CAlbumInfo *)obj;
 422                 itinfo = (SAlbumItemInfo *)calloc(1, sizeof(*itinfo));
 423                 if (!itinfo)
 424                         return;
 425
 426                 itinfo->alinfo = alinfo;
 427                 item = elm_gengrid_item_append(m->grid, m->item_class, itinfo, NULL, NULL);
 428                 itinfo->item = item;
 429                 m->it_infolist = eina_list_append(m->it_infolist, itinfo);
 430                 if (i == 0)
 431                         m->focusedItem = item;
 432                 i++;
 433         }
 434 }
 435
 436
 437 bool CAlbumLayout::Create(CLayoutMgr *mgr, const char *albumId)
 438 {
 439         ASSERT(!m);
 440         ASSERT(mgr);
 441
 442         _CREATE_BEGIN{
 443                 Evas_Object *base = NULL;
 444                 Evas_Object *win = NULL;
 445                 Evas_Object *layout = NULL;
 446                 CMusicController *mhandle = NULL;
 447                 CViewMgr *vmgr = NULL;
 448                 CAlbumSongsLayout *layoutAlbumSongs = NULL;
 449                 SParcel parcel;
 450
 451                 _CHECK(m = new SAlbumLayout)
 452                 _CHECK(vmgr = CViewMgr::GetInstance())
 453                 _CHECK(base = mgr->Base())
 454                 _CHECK(win = vmgr->Window())
 455                 _CHECK(mhandle = CMusicController::GetInstance())
 456                 _CHECK(layout = CCommonUI::AddBase(base, MUSIC_ALBUM_LAYOUT))
 457                 _CHECK(CExtBaseLayout::Create(layout))
 458                 _CHECK(layoutAlbumSongs = new CAlbumSongsLayout(MUSIC_ALBUM_SONGS_LAYOUT))
 459                 _CHECK(layoutAlbumSongs->Create(mgr))
 460                 _CHECK(mgr->AddLayout(layoutAlbumSongs))
 461
 462                 _WHEN_SUCCESS{
 463                         if (albumId) {
 464                                 m->album_id = new char[strlen(albumId) + 1];
 465                                 strcpy(m->album_id, albumId);
 466                         }
 467                         else
 468                                 m->album_id = NULL;
 469
 470                         m->win = win;
 471                         m->base = base;
 472                         m->vmgr = vmgr;
 473                         m->mhandle = mhandle;
 474                         m->lmgr = mgr;
 475                         m->callback.cbHandleEmptyStatus = NULL;
 476                         m->callback.cookie = NULL;
 477                         m->layoutAlbumSongs = layoutAlbumSongs;
 478
 479                         m_CreateAlbumGrid();
 480                         Connect(layout, ALBUM_LAYOUT, TYPE_KEY_DOWN);
 481
 482                         parcel.ctxtInfo = NULL;
 483                         parcel.updateType = E_LAYOUT_UPDATE;
 484                         parcel.layoutId = MUSIC_ALBUM_LAYOUT;
 485                         parcel.keyEvent = NULL;
 486                         m->vmgr->UpdateView((const char *)MUSIC_BASE_VIEW, &parcel);
 487                 }
 488
 489                 _CHECK_FAIL{ mgr->RemoveLayout(layoutAlbumSongs); }
 490                 _CHECK_FAIL{ m->layoutAlbumSongs->Destroy(); }
 491                 _CHECK_FAIL{ delete m->layoutAlbumSongs; }
 492                 _CHECK_FAIL{ CExtBaseLayout::Destroy(); }
 493                 _CHECK_FAIL{ evas_object_del(layout); }
 494                 _CHECK_FAIL{}
 495                 _CHECK_FAIL{}
 496                 _CHECK_FAIL{}
 497                 _CHECK_FAIL{}
 498                 _CHECK_FAIL{ delete m; m = NULL; }
 499         } _CREATE_END_AND_CATCH{ return false; }
 500
 501         return true;
 502 }
 503
 504 void CAlbumLayout::Destroy(void)
 505 {
 506         ASSERT(m);
 507
 508         Disconnect(Layout());
 509
 510         m->lmgr->RemoveLayout(m->layoutAlbumSongs);
 511         m->layoutAlbumSongs->Destroy();
 512         delete m->layoutAlbumSongs;
 513
 514         m_EmptyAlbumGrid(false);
 515         CExtBaseLayout::Destroy();
 516         evas_object_del(Layout());
 517
 518         free(m->ctxtinfo);
 519         delete[] m->album_id;
 520         delete m;
 521         m = NULL;
 522 }
 523
 524
 525 void CAlbumLayout::t_OnShow(void)
 526 {
 527         ASSERT(m);
 528
 529         SAlbumItemInfo *itinfo = NULL;
 530
 531         m_UpdateAlbumGrid(false);
 532
 533         SParcel parcel;
 534         memset(&parcel, 0, sizeof(SParcel));
 535         parcel.updateType = E_LAYOUT_UPDATE;
 536         parcel.layoutId = MUSIC_ALBUM_LAYOUT;
 537         m->vmgr->UpdateView((const char *)MUSIC_BASE_VIEW, &parcel);
 538
 539         evas_object_show(Layout());
 540
 541         if (m->album_id) {
 542                 itinfo = m_FindItemInfoById(m->it_infolist,
 543                         atoi(m->album_id));
 544                 if (itinfo) {
 545                         m->layoutAlbumSongs->SetCurrentAlbum(itinfo->alinfo);
 546                         m_ShowAlbumSongs();
 547                         return;
 548                 }
 549                 delete[] m->album_id;
 550                 m->album_id = NULL;
 551         }
 552 }
 553
 554
 555 void CAlbumLayout::Update(bool focusFlag)
 556 {
 557         ASSERT(m);
 558
 559         CAlbumInfo *alinfo = NULL;
 560         SAlbumItemInfo *itinfo = NULL;
 561         int id;
 562
 563         if (!focusFlag) {
 564                 m_UpdateAlbumGrid(true);
 565                 return;
 566         }
 567
 568         alinfo = m->layoutAlbumSongs->CurrentAlbum();
 569         if (alinfo) {
 570                 id = alinfo->AlbumId();
 571                 itinfo = m_FindItemInfoById(m->it_infolist, id);
 572                 if (itinfo) {
 573                         m->layoutAlbumSongs->SetCurrentAlbum(NULL);
 574
 575                         elm_gengrid_item_show(itinfo->item,
 576                                 ELM_GENGRID_ITEM_SCROLLTO_IN);
 577                         elm_object_item_focus_set(itinfo->item, EINA_TRUE);
 578                         return;
 579                 }
 580         }
 581
 582         elm_object_focus_set(m->grid, EINA_TRUE);
 583 }
 584
 585
 586 void CAlbumLayout::SetFocus(const char *btnStr)
 587 {
 588         ASSERT(m);
 589         m->focusIdler = ecore_idler_add(sm_CbFocusIdler, this);
 590 }
 591
 592
 593 void CAlbumLayout::SetEmptyStatusHandleCallback(void(*handleEmptyStatusCb)(void *cookie, bool emptyStatus), void *cookie)
 594 {
 595         ASSERT(m);
 596
 597         m->callback.cbHandleEmptyStatus = handleEmptyStatusCb;
 598         m->callback.cookie = cookie;
 599 }
 600
 601
 602 void CAlbumLayout::OnKeyDown(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Down *ev)
 603 {
 604         switch (id) {
 605         case ALBUM_LAYOUT:
 606                 if (!strcmp(ev->keyname, KEY_BACK) ||
 607                         !strcmp(ev->keyname, KEY_BACK_REMOTE)) {
 608                         SParcel parcel;
 609                         memset(&parcel, 0, sizeof(SParcel));
 610                         parcel.updateType = E_FOCUS_UPDATE;
 611                         m->vmgr->UpdateView((const char *)MUSIC_BASE_VIEW, &parcel);
 612                 }
 613                 break;
 614
 615         case ALBUM_GENGRID:
 616                 {
 617                         Elm_Object_Item *it = NULL;
 618                         SContentInfo *ctxtinfo = NULL;
 619                         SAlbumItemInfo *itinfo = NULL;
 620
 621                         it = elm_object_focused_item_get(obj);
 622                         if (!it) {
 623                                 _ERR(" unable to get focused item ");
 624                                 return;
 625                         }
 626
 627                         m->focusedItem = it;
 628
 629                         if (!strcmp(ev->keyname, KEY_MENU) ||
 630                                 !strcmp(ev->keyname, KEY_MENU_REMOTE)) {
 631                                 if (m->ctxtinfo) {
 632                                         free(m->ctxtinfo);
 633                                         m->ctxtinfo = NULL;
 634                                 }
 635
 636                                 ctxtinfo = (SContentInfo *)calloc(1, sizeof(*ctxtinfo));
 637                                 if (!ctxtinfo)
 638                                         return;
 639
 640                                 itinfo = m_FindItemInfo(m->it_infolist, it);
 641                                 if (!itinfo) {
 642                                         free(ctxtinfo);
 643                                         return;
 644                                 }
 645
 646                                 ctxtinfo->type = CONTEXT_TYPE_ALBUM;
 647                                 ctxtinfo->context = itinfo->alinfo;
 648                                 ctxtinfo->cbdata = this;
 649                                 ctxtinfo->update = sm_CbCtxtUpdate;
 650                                 ctxtinfo->close = sm_CbCtxtClose;
 651
 652                                 m->ctxtinfo = ctxtinfo;
 653
 654                                 SParcel parcel;
 655                                 memset(&parcel, 0, sizeof(SParcel));
 656                                 parcel.ctxtInfo = ctxtinfo;
 657                                 if (!m->vmgr->PushView(MUSIC_CONTEXT_VIEW, &parcel))
 658                                         _ERR("viewmgr push view MUSIC_CONTEXT_VIEW failed");
 659                         }
 660                 }
 661                 break;
 662
 663         default:
 664                 break;
 665         }
 666 }
 667
 668
 669 void CAlbumLayout::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
 670 {
 671         switch (id) {
 672         case ALBUM_GENGRID:
 673                 {
 674                         Elm_Object_Item *item;
 675
 676                         item = elm_gengrid_at_xy_item_get(obj, ev->cur.canvas.x,
 677                                 ev->cur.canvas.y, NULL, NULL);
 678                         if (!item)
 679                                 return;
 680
 681                         if (!elm_object_item_focus_get(item))
 682                                 elm_object_item_focus_set(item, EINA_TRUE);
 683
 684                         m->focusedItem = item;
 685                 }
 686                 break;
 687
 688         default:
 689                 break;
 690         }
 691 }
 692
 693
 694 void CAlbumLayout::OnRealized(int id, Evas_Object *obj, Elm_Object_Item *item)
 695 {
 696         switch (id) {
 697         case ALBUM_GENGRID:
 698                 {
 699                         elm_object_item_signal_callback_add(item,
 700                         MUSIC_SIGNAL_BTN_CLICKED, MUSIC_BASE_VIEW,
 701                         sm_CbItemSelect, this);
 702                 }
 703                 break;
 704
 705         default:
 706                 break;
 707         }
 708 }
 709
 710
 711 void CAlbumLayout::OnUnrealized(int id, Evas_Object *obj, Elm_Object_Item *item)
 712 {
 713         switch (id) {
 714         case ALBUM_GENGRID:
 715                 {
 716                         elm_object_item_signal_callback_del(item,
 717                         MUSIC_SIGNAL_BTN_CLICKED, MUSIC_BASE_VIEW,
 718                         sm_CbItemSelect);
 719                 }
 720                 break;
 721
 722         default:
 723                 break;
 724         }
 725 }
 726
 727
 728 void CAlbumLayout::OnActivated(int id, Evas_Object *obj, Elm_Object_Item *item)
 729 {
 730         switch (id) {
 731         case ALBUM_GENGRID:
 732                 m_OnItemSelect(item, NULL, NULL);
 733                 break;
 734
 735         default:
 736                 break;
 737         }
 738 }