src/views/album-songs-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 #include <utilX.h>
  20 #include "AppCommon.h"
  21 #include "dbg.h"
  22 #include "i18n.h"
  23 #include "define.h"
  24 #include "song_info.h"
  25 #include "album_info.h"
  26 #include "music-controller.h"
  27 #include "LayoutMgr.h"
  28 #include "common.h"
  29 #include "common-ui.h"
  30 #include "BaseView.h"
  31 #include "ExtBaseLayout.h"
  32 #include "ViewMgr.h"
  33 #include "InputHandler.h"
  34 #include "album-songs-layout.h"
  35 #include "base-view.h"
  36
  37 #define TOTAL_ADD_BTNS 3
  38
  39
  40 enum EObjectType {
  41         ALBUM_SONGS_LAYOUT,
  42         ALBUM_SONGS_GENLIST,
  43         ALBUM_SONGS_PLAY_BUTTON,
  44         ALBUM_SONGS_NEXT_BUTTON,
  45         ALBUM_SONGS_LAST_BUTTON,
  46 };
  47
  48 enum EBtnType {
  49         BTN_PLAY,
  50         BTN_NEXT,
  51         BTN_LAST
  52 };
  53
  54 struct SAlbumSongsItemInfo {
  55         CSongInfo *sinfo;
  56         Elm_Object_Item *item;
  57 };
  58
  59 struct SAlbumSongsLayout {
  60         Evas_Object *win;
  61         Evas_Object *base;
  62         Evas_Object *songlist;
  63         Elm_Object_Item *focused_item;
  64
  65         CMusicController* mhandle;
  66         CLayoutMgr *mgr;
  67         CViewMgr *vmgr;
  68         SContentInfo *ctxtinfo;
  69         Eina_List *slist;
  70         Eina_List *it_infolist;
  71         Elm_Genlist_Item_Class *item_class;
  72         int total_duration;
  73         CAlbumSongsLayout *parent;
  74
  75         SAlbumSongsLayout() {
  76                 memset(this, 0, sizeof(SAlbumSongsLayout));
  77         }
  78
  79         ~SAlbumSongsLayout() {
  80         }
  81 };
  82
  83
  84 struct SBtnInfo {
  85         const char *name;
  86         const char *part;
  87         const char *style;
  88         const char *icon;
  89         EObjectType type;
  90 };
  91
  92
  93 char *CAlbumSongsLayout::sm_CbGetListItemText(void *data, Evas_Object *obj, const char *part)
  94 {
  95         SAlbumSongsItemInfo *itinfo = (SAlbumSongsItemInfo *)data;
  96         CSongInfo *sinfo = NULL;
  97         char buf[MAX_LENGTH];
  98         char *timestr = NULL;
  99         int duration;
 100         int index;
 101
 102         if (!itinfo || !obj)
 103                 return NULL;
 104
 105         sinfo = itinfo->sinfo;
 106
 107         snprintf(buf, sizeof(buf), "%s", MUSIC_STR_EMPTY);
 108
 109         if (!strcmp(part, "elm.text")) {
 110                 index = elm_genlist_item_index_get(itinfo->item);
 111                 if ((index & 1) == 1) {
 112                         elm_object_item_signal_emit(itinfo->item,
 113                                 MUSIC_SIGNAL_EVEN_ROW, MUSIC_BASE_VIEW);
 114                 }
 115                 else {
 116                         elm_object_item_signal_emit(itinfo->item,
 117                                 MUSIC_SIGNAL_ODD_ROW, MUSIC_BASE_VIEW);
 118                 }
 119                 snprintf(buf, sizeof(buf), "%d", index);
 120         }
 121         else if (!strcmp(part, "elm.text1"))
 122                 snprintf(buf, sizeof(buf), "%s", sinfo->Name());
 123         else if (!strcmp(part, "elm.text2"))
 124                 snprintf(buf, sizeof(buf), "%s", sinfo->Artist());
 125         else if (!strcmp(part, "elm.text3")) {
 126                 duration = sinfo->Duration();
 127                 timestr = _get_timestr_from_milseconds(duration);
 128                 if (timestr) {
 129                         snprintf(buf, sizeof(buf), "%s", timestr);
 130                         free(timestr);
 131                 }
 132         }
 133
 134         if (strcmp(buf, MUSIC_STR_EMPTY))
 135                 return strdup(buf);
 136
 137         return NULL;
 138 }
 139
 140
 141 void CAlbumSongsLayout::sm_CbRemoveListItem(void *data, Evas_Object *obj)
 142 {
 143         free(data);
 144 }
 145
 146
 147 void CAlbumSongsLayout::sm_CbCtxtUpdate(void *dt, enum EActionType type, int lid)
 148 {
 149         CAlbumSongsLayout *root = (CAlbumSongsLayout*)dt;
 150
 151         if (root)
 152                 root->m_OnCtxtUpdate(type, lid);
 153 }
 154
 155 void CAlbumSongsLayout::m_OnCtxtUpdate(EActionType type, int lid)
 156 {
 157         Eina_List *list = NULL;
 158         EAddType mode;
 159
 160         if (!m->ctxtinfo || !m->ctxtinfo->context)
 161                 return;
 162
 163         if (type == ACTION_TYPE_ADDNEXT)
 164                 mode = ADD_TYPE_NEXT;
 165         else
 166                 mode = ADD_TYPE_END;
 167
 168         list = eina_list_append(list, m->ctxtinfo->context);
 169         if (type == ACTION_TYPE_ADDTO) {
 170                 if (!m->mhandle->MediaAddsongsPlaylist(lid, list))
 171                         _ERR(" Adding songs to playlist failed ");
 172                 else
 173                         _create_message_box(m->base, MUSIC_TEXT_ADDTO_MSG);
 174
 175                 return;
 176         }
 177
 178         m->mhandle->UpdatePlaylist(list, mode);
 179         eina_list_free(list);
 180
 181         if (type == ACTION_TYPE_PLAY) {
 182                 m->mhandle->Stop();
 183                 m->mhandle->SetCurrentSong(((CSongInfo *)m->ctxtinfo->context)->Id());
 184         }
 185
 186         _update_playback_view((EAddType)type, m->parent->Layout(), m->focused_item);
 187 }
 188
 189 void CAlbumSongsLayout::sm_CbCtxtClose(void *dt)
 190 {
 191         CAlbumSongsLayout *root = (CAlbumSongsLayout*)dt;
 192
 193         if (root)
 194                 root->m_OnCtxtClose();
 195 }
 196
 197 void CAlbumSongsLayout::m_OnCtxtClose(void)
 198 {
 199         m->vmgr->PopView();
 200         m->vmgr->PushView(MUSIC_BASE_VIEW, NULL);
 201         elm_object_item_focus_set(m->focused_item, EINA_TRUE);
 202 }
 203
 204 void CAlbumSongsLayout::sm_CbItemSelect(void *data, Evas_Object *obj, void *event_info)
 205 {
 206         CAlbumSongsLayout *root = (CAlbumSongsLayout*)data;
 207
 208         if (root)
 209                 root->m_OnItemSelect(obj, event_info);
 210 }
 211
 212 void CAlbumSongsLayout::m_OnItemSelect(Evas_Object *obj, void *event_info)
 213 {
 214         SAlbumSongsItemInfo *itinfo = NULL;
 215         char *mediaId = NULL;
 216
 217         itinfo = m_FindItemInfoFromItem(m->it_infolist, (Elm_Object_Item *)event_info);
 218         if (!itinfo) {
 219                 _ERR(" no item info found ");
 220                 return;
 221         }
 222
 223         mediaId = itinfo->sinfo->Id();
 224
 225         m_GotoPlayback(ADD_TYPE_FRESH, mediaId);
 226 }
 227
 228
 229 SAlbumSongsItemInfo *CAlbumSongsLayout::m_FindItemInfoFromItem(Eina_List *list, Elm_Object_Item *item)
 230 {
 231         Eina_List *l = NULL;
 232         SAlbumSongsItemInfo *itinfo = NULL;
 233         void *obj = NULL;
 234
 235         EINA_LIST_FOREACH(list, l, obj) {
 236                 itinfo = (SAlbumSongsItemInfo *)obj;
 237                 if (itinfo->item == item)
 238                         return itinfo;
 239         }
 240
 241         return NULL;
 242 }
 243
 244
 245 void  CAlbumSongsLayout::m_UpdateSongList(void)
 246 {
 247         CSongInfo *sinfo = NULL;
 248         void *obj = NULL;
 249         Eina_List *l = NULL;
 250         SAlbumSongsItemInfo *itinfo = NULL;
 251         Elm_Object_Item *item = NULL;
 252         int dur = 0;
 253         CAlbumInfo *alinfo = NULL;
 254
 255         if (!m->songlist || !m->item_class)
 256                 return;
 257
 258         /* Remove existing songlist and prepare afresh */
 259         m_EmptySongList();
 260
 261         alinfo = m->mhandle->CurrentAlbum();
 262         if (!m->mhandle->MediaGetList(LIST_TYPE_ALBUM_SONG, alinfo, &(m->slist))) {
 263                 _ERR(" Fetching song list from media failed ");
 264                 return;
 265         }
 266
 267         EINA_LIST_FOREACH(m->slist, l, obj) {
 268                 sinfo = (CSongInfo *)obj;
 269                 itinfo = (SAlbumSongsItemInfo *)calloc(1, sizeof(*itinfo));
 270                 if (!itinfo)
 271                         return;
 272
 273                 itinfo->sinfo = sinfo;
 274                 item = elm_genlist_item_append(m->songlist, m->item_class,
 275                         itinfo, NULL, ELM_GENLIST_ITEM_NONE, sm_CbItemSelect, this);
 276                 itinfo->item = item;
 277                 m->it_infolist = eina_list_append(m->it_infolist, itinfo);
 278                 dur = sinfo->Duration();
 279                 m->total_duration = m->total_duration + dur;
 280         }
 281 }
 282
 283 void CAlbumSongsLayout::m_EmptySongList(void)
 284 {
 285         if (m->songlist)
 286                 elm_genlist_clear(m->songlist);
 287
 288         if (m->slist) {
 289                 eina_list_free(m->slist);
 290                 m->slist = NULL;
 291         }
 292
 293         if (m->it_infolist) {
 294                 eina_list_free(m->it_infolist);
 295                 m->it_infolist = NULL;
 296         }
 297
 298         m->total_duration = 0;
 299 }
 300
 301
 302 int CAlbumSongsLayout::m_ConvertToMin(int milsec)
 303 {
 304         int min;
 305         min = milsec / 60000;  /*milli seconds per minute*/
 306
 307         return min;
 308 }
 309
 310
 311 void CAlbumSongsLayout::m_GotoPlayback(int mode, char *id)
 312 {
 313         Eina_List *list = NULL;
 314         Eina_List *l = NULL;
 315         SAlbumSongsItemInfo *itinfo = NULL;
 316         void *obj = NULL;
 317
 318         if (!m->it_infolist || eina_list_count(m->it_infolist) == 0) {
 319                 _ERR(" No songs for playback ");
 320                 return;
 321         }
 322
 323         EINA_LIST_FOREACH(m->it_infolist, l, obj) {
 324                 itinfo = (SAlbumSongsItemInfo *)obj;
 325                 list = eina_list_append(list, itinfo->sinfo);
 326         }
 327
 328         m->mhandle->UpdatePlaylist(list, mode);
 329         eina_list_free(list);
 330
 331         if (mode == ADD_TYPE_FRESH) {
 332                 m->mhandle->Stop();
 333                 if (id)   /* If want to play selected song */
 334                         m->mhandle->SetCurrentSong(id);
 335         }
 336
 337         _update_playback_view((EAddType)mode, Layout(), NULL);
 338 }
 339
 340
 341 Evas_Object *CAlbumSongsLayout::m_AddAlbumCover(void)
 342 {
 343         Evas_Object *album_cover = NULL;
 344
 345         album_cover = elm_image_add(Layout());
 346         if (!album_cover)
 347                 return NULL;
 348
 349         evas_object_size_hint_weight_set(album_cover, EVAS_HINT_EXPAND,
 350                 EVAS_HINT_EXPAND);
 351
 352         return album_cover;
 353 }
 354
 355
 356 void CAlbumSongsLayout::m_CreateTopSection(void)
 357 {
 358         Evas_Object *thumb = NULL;
 359         int i;
 360         Evas_Object *btn[TOTAL_ADD_BTNS];
 361         Evas_Object *img = NULL;
 362         char *path = NULL;
 363         char buf[MAX_LENGTH];
 364         CAlbumInfo *alinfo = NULL;
 365         SBtnInfo btninfo[TOTAL_ADD_BTNS];
 366         Evas_Object *layout = Layout();
 367
 368         btninfo[BTN_PLAY].name = MUSIC_STR_PLAY;
 369         btninfo[BTN_PLAY].part = MUSIC_PART_ALBUM_PLAYBTN;
 370         btninfo[BTN_PLAY].style = MUSIC_STYLE_ADD_PLAY_BTN;
 371         btninfo[BTN_PLAY].icon = MUSIC_IMAGE_ADD_PLAY;
 372         btninfo[BTN_PLAY].type = ALBUM_SONGS_PLAY_BUTTON;
 373
 374         btninfo[BTN_NEXT].name = MUSIC_STR_ADDNEXT;
 375         btninfo[BTN_NEXT].part = MUSIC_PART_ALBUM_NEXTBTN;
 376         btninfo[BTN_NEXT].style = MUSIC_STYLE_ADD_NEXT_BTN;
 377         btninfo[BTN_NEXT].icon = MUSIC_IMAGE_ADD_NEXT;
 378         btninfo[BTN_NEXT].type = ALBUM_SONGS_NEXT_BUTTON;
 379
 380         btninfo[BTN_LAST].name = MUSIC_STR_ADDLAST;
 381         btninfo[BTN_LAST].part = MUSIC_PART_ALBUM_LASTBTN;
 382         btninfo[BTN_LAST].style = MUSIC_STYLE_ADD_LAST_BTN;
 383         btninfo[BTN_LAST].icon = MUSIC_IMAGE_ADD_LAST;
 384         btninfo[BTN_LAST].type = ALBUM_SONGS_LAST_BUTTON;
 385
 386         thumb = m_AddAlbumCover();
 387         if (!thumb)
 388                 return;
 389
 390         for (i = 0; i < TOTAL_ADD_BTNS; i++) {
 391                 btn[i] = elm_button_add(layout);
 392                 if (!btn[i])
 393                         continue;
 394
 395                 evas_object_size_hint_weight_set(btn[i],
 396                         EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 397                 elm_object_text_set(btn[i], _(btninfo[i].name));
 398                 elm_object_style_set(btn[i], btninfo[i].style);
 399
 400                 Connect(btn[i], btninfo[i].type, TYPE_MOUSE_MOVE | TYPE_CLICKED);
 401
 402                 img = elm_image_add(btn[i]);
 403                 if (img) {
 404                         snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 405                                 btninfo[i].icon);
 406                         elm_image_file_set(img, buf, NULL);
 407                         elm_object_part_content_set(btn[i],
 408                                 MUSIC_PART_ELM_SWALLOWICON, img);
 409                 }
 410
 411                 elm_object_part_content_set(layout, btninfo[i].part,
 412                         btn[i]);
 413         }
 414
 415         elm_object_focus_set(btn[0], EINA_TRUE);
 416         alinfo = m->mhandle->CurrentAlbum();
 417         if (!alinfo)
 418                 return;
 419
 420         path = alinfo->ThumbnailPath();
 421         if (path) {
 422                 elm_image_file_set(thumb, path, NULL);
 423                 elm_image_aspect_fixed_set(thumb, EINA_FALSE);
 424         }
 425         else {
 426                 snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 427                         MUSIC_IMAGE_DEFAULT_THUMB_126);
 428                 elm_image_file_set(thumb, buf, NULL);
 429                 elm_image_no_scale_set(thumb, EINA_TRUE);
 430         }
 431
 432         elm_object_part_content_set(layout, MUSIC_PART_ALBUM_THUMB,
 433                 thumb);
 434         elm_object_part_text_set(layout, MUSIC_PART_ALBUM_NAME,
 435                 alinfo->Name());
 436         elm_object_part_text_set(layout, MUSIC_PART_ALBUM_ARTIST,
 437                 alinfo->Artist());
 438
 439         snprintf(buf, sizeof(buf), "%d", eina_list_count(m->slist));
 440         elm_object_part_text_set(layout, MUSIC_PART_ALBUM_SONGCOUNT, buf);
 441         snprintf(buf, sizeof(buf), "%d %s", m_ConvertToMin(m->total_duration), _(MUSIC_TEXT_MIN));
 442
 443         elm_object_part_text_set(layout, MUSIC_PART_ALBUM_TIME, buf);
 444 }
 445
 446
 447 void CAlbumSongsLayout::m_CreateSongList(void)
 448 {
 449         Evas_Object *genlist = NULL;
 450         Elm_Genlist_Item_Class *list_item = NULL;
 451         Evas_Object *layout = Layout();
 452
 453         genlist = elm_genlist_add(layout);
 454         if (!genlist)
 455                 return;
 456
 457         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 458         evas_object_size_hint_weight_set(genlist,
 459                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 460         elm_object_part_content_set(layout, MUSIC_PART_SONGLIST, genlist);
 461         Connect(genlist, ALBUM_SONGS_GENLIST, TYPE_MOUSE_MOVE | TYPE_KEY_DOWN | TYPE_ACTIVATED);
 462         m->songlist = genlist;
 463
 464         list_item = elm_genlist_item_class_new();
 465         if (!list_item) {
 466                 evas_object_del(genlist);
 467                 _ERR(" elm_genlist_item_class_new failed ");
 468                 return;
 469         }
 470         list_item->item_style = MUSIC_STYLE_ALBUM_SONGLIST;
 471         list_item->func.text_get = sm_CbGetListItemText;
 472         list_item->func.content_get = NULL;
 473         list_item->func.state_get = NULL;
 474         list_item->func.del = sm_CbRemoveListItem;
 475         m->item_class = list_item;
 476
 477         m_UpdateSongList();
 478 }
 479
 480
 481 bool CAlbumSongsLayout::Create(CLayoutMgr *mgr)
 482 {
 483         ASSERT(!m);
 484
 485         Evas_Object *base = NULL;
 486         Evas_Object *win = NULL;
 487         Evas_Object *layout = NULL;
 488         CMusicController *mhandle;
 489         CViewMgr *vmgr;
 490
 491         if (!mgr)
 492                 return false;
 493
 494         m = new SAlbumSongsLayout;
 495         if (!m) {
 496                 _ERR(" calloc failed ");
 497                 return false;
 498         }
 499
 500         vmgr = CViewMgr::GetInstance();
 501         if (!vmgr) {
 502                 _ERR(" get view mgr failed ");
 503                 delete m;
 504                 m = NULL;
 505                 return false;
 506         }
 507
 508         base = mgr->Base();
 509         if (!base) {
 510                 _ERR(" get base failed ");
 511                 delete m;
 512                 m = NULL;
 513                 return false;
 514         }
 515
 516         win = vmgr->Window();
 517         if (!win) {
 518                 _ERR(" vimewmgr get win failed ");
 519                 delete m;
 520                 m = NULL;
 521                 return false;
 522         }
 523
 524         mhandle = CMusicController::GetInstance();
 525         if (!mhandle) {
 526                 _ERR(" music controller get music instance failed ");
 527                 delete m;
 528                 m = NULL;
 529                 return false;
 530         }
 531
 532         layout = _add_base(base, MUSIC_ALBUM_SONGS_LAYOUT);
 533         if (!layout) {
 534                 _ERR(" get layout failed ");
 535                 delete m;
 536                 m = NULL;
 537                 return false;
 538         }
 539
 540         bool r = CExtBaseLayout::Create(layout);
 541         if (!r) {
 542                 _ERR(" CBaseLayout creation failed ");
 543                 evas_object_del(layout);
 544                 delete m;
 545                 m = NULL;
 546                 return false;
 547         }
 548
 549         m->win = win;
 550         m->base = base;
 551         m->vmgr = vmgr;
 552         m->mhandle = mhandle;
 553         m->mgr = mgr;
 554         m->parent = this;
 555
 556         Connect(layout, ALBUM_SONGS_LAYOUT, TYPE_KEY_DOWN);
 557
 558         return true;
 559 }
 560
 561 void CAlbumSongsLayout::Destroy(void)
 562 {
 563         ASSERT(m);
 564
 565         m_EmptySongList();
 566         CExtBaseLayout::Destroy();
 567         evas_object_del(Layout());
 568
 569         free(m->ctxtinfo);
 570         delete m;
 571         m = NULL;
 572 }
 573
 574
 575 void CAlbumSongsLayout::t_OnShow(void)
 576 {
 577         ASSERT(m);
 578
 579         m_EmptySongList();
 580
 581         m_CreateSongList();
 582         m_CreateTopSection();
 583
 584         CBaseLayout::t_OnShow();
 585
 586         SParcel parcel;
 587         parcel.ctxtInfo = NULL;
 588         parcel.updateType = E_LAYOUT_UPDATE;
 589         parcel.layoutId = MUSIC_ALBUM_SONGS_LAYOUT;
 590         parcel.keyEvent = NULL;
 591         m->vmgr->UpdateView((const char *)MUSIC_BASE_VIEW, &parcel);
 592 }
 593
 594
 595 void CAlbumSongsLayout::OnKeyDown(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Down *ev)
 596 {
 597         switch (id)
 598         {
 599         case ALBUM_SONGS_LAYOUT:
 600                 if (!strcmp(ev->keyname, KEY_BACK)) {
 601                         SParcel parcel;
 602                         parcel.ctxtInfo = NULL;
 603                         parcel.updateType = E_DEPTH_UPDATE;
 604                         parcel.layoutId = MUSIC_ALBUM_SONGS_LAYOUT;
 605                         parcel.keyEvent = NULL;
 606                         m->vmgr->UpdateView((const char *)MUSIC_BASE_VIEW, &parcel);
 607                 }
 608                 break;
 609
 610         case ALBUM_SONGS_GENLIST:
 611                 {
 612                         Elm_Object_Item *it = NULL;
 613                         SContentInfo *ctxtinfo = NULL;
 614                         SAlbumSongsItemInfo *itinfo = NULL;
 615
 616                         if (strcmp(ev->keyname, KEY_MENU))
 617                                 return;
 618
 619                         it = elm_object_focused_item_get(obj);
 620                         if (!it) {
 621                                 _ERR(" unable to get focused item ");
 622                                 return;
 623                         }
 624                         m->focused_item = it;
 625
 626                         if (m->ctxtinfo) {
 627                                 free(m->ctxtinfo);
 628                                 m->ctxtinfo = NULL;
 629                         }
 630
 631                         ctxtinfo = (SContentInfo *)calloc(1, sizeof(*ctxtinfo));
 632                         if (!ctxtinfo)
 633                                 return;
 634
 635                         itinfo = m_FindItemInfoFromItem(m->it_infolist, it);
 636                         if (!itinfo) {
 637                                 free(ctxtinfo);
 638                                 return;
 639                         }
 640
 641                         ctxtinfo->type = CONTEXT_TYPE_SONG;
 642                         ctxtinfo->context = itinfo->sinfo;
 643                         ctxtinfo->cbdata = this;
 644                         ctxtinfo->update = sm_CbCtxtUpdate;
 645                         ctxtinfo->close = sm_CbCtxtClose;
 646
 647                         m->ctxtinfo = ctxtinfo;
 648
 649                         SParcel parcel;
 650                         parcel.ctxtInfo = ctxtinfo;
 651                         if (!m->vmgr->PushView(MUSIC_CONTEXT_VIEW, &parcel))
 652                                 _ERR("viewmgr push view MUSIC_CONTEXT_VIEW failed");
 653                 }
 654                 break;
 655
 656         default:
 657                 break;
 658         }
 659 }
 660
 661
 662 void CAlbumSongsLayout::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
 663 {
 664         switch (id) {
 665         case ALBUM_SONGS_GENLIST:
 666                 {
 667                         Elm_Object_Item *item;
 668
 669                         item = elm_genlist_at_xy_item_get(obj, ev->cur.canvas.x,
 670                                 ev->cur.canvas.y, NULL);
 671
 672                         if (!elm_object_item_focus_get(item))
 673                                 elm_object_item_focus_set(item, EINA_TRUE);
 674                 }
 675                 break;
 676
 677         case ALBUM_SONGS_PLAY_BUTTON:
 678         case ALBUM_SONGS_NEXT_BUTTON:
 679         case ALBUM_SONGS_LAST_BUTTON:
 680                 {
 681                         if (!elm_object_focus_get(obj))
 682                                 elm_object_focus_set(obj, EINA_TRUE);
 683                 }
 684                 break;
 685
 686         default:
 687                 break;
 688         }
 689 }
 690
 691
 692 void CAlbumSongsLayout::OnMouseClicked(int id, Evas_Object *obj)
 693 {
 694         switch (id)
 695         {
 696         case ALBUM_SONGS_PLAY_BUTTON:
 697                 m_GotoPlayback(ADD_TYPE_FRESH, NULL);
 698                 break;
 699
 700         case ALBUM_SONGS_NEXT_BUTTON:
 701                 m_GotoPlayback(ADD_TYPE_NEXT, NULL);
 702                 break;
 703
 704         case ALBUM_SONGS_LAST_BUTTON:
 705                 m_GotoPlayback(ADD_TYPE_END, NULL);
 706                 break;
 707
 708         default:
 709                 break;
 710         }
 711 }
 712
 713
 714 void CAlbumSongsLayout::OnActivated(int id, Evas_Object *obj, Elm_Object_Item *item)
 715 {
 716         switch (id) {
 717         case ALBUM_SONGS_GENLIST:
 718                 m_OnItemSelect(obj, item);
 719                 break;
 720
 721         default:
 722                 break;
 723         }
 724 }