src/views/playback-view.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 "define.h"
  18 #include "common.h"
  19 #include "dbg.h"
  20 #include <AppCommon.h>
  21
  22 #include "Timer.h"
  23 #include "song_info.h"
  24 #include "album_info.h"
  25 #include "music-controller.h"
  26 #include "volume-control.h"
  27 #include "i18n.h"
  28 #include "common-ui.h"
  29 #include "playback-view.h"
  30 #include "context-view.h"
  31 #include "HandleVolume.h"
  32 #include "PlaySettingCtxPopup.h"
  33 #include "Info.h"
  34 #include "SliderWidget.h"
  35 #include "PlaybackController.h"
  36
  37
  38 #define TOTAL_CONTROL_BTNS 6
  39 #define TOTAL_EDIT_BTNS    3
  40
  41
  42 enum EEvasObject {
  43         EO_BASE,
  44         EO_PLAYLIST,
  45 };
  46
  47 struct SItemInfo {
  48         Elm_Object_Item *item;
  49         CSongInfo *sinfo;
  50         bool edit_mode;
  51         bool check_status;
  52         bool select_status;
  53 };
  54
  55 struct SPlaybackView {
  56         Evas_Object *eoWin;
  57
  58         Evas_Object *eoBase;
  59         Evas_Object *eoPlaylist;
  60
  61         Elm_Object_Item *focused_item;
  62
  63         CPlaybackController *pPlaybackController;
  64         // These are reference values.
  65         Evas_Object *eoBtnControl[TOTAL_CONTROL_BTNS];
  66         Evas_Object *eoBtnEdit[TOTAL_EDIT_BTNS];
  67
  68         Evas_Object *eoAlbumCover;
  69         CSliderWidget *pSliderWidget;
  70
  71         Eina_List *elInfo;
  72         CMusicController *pController; //! NOT NULL
  73         CSongInfo *csinfo;
  74         CViewMgr *mgr;
  75         SItemInfo *cs_itinfo;
  76         SContentInfo *ctxtinfo;
  77
  78         CHandleVolume *pHandleVolume;
  79
  80         SPlaybackView() {
  81                 memset(this, 0, sizeof(SPlaybackView));
  82         }
  83 };
  84
  85
  86 void CPlaybackView::sm_CbCtxtUpdate(void *dt, enum EActionType type, int lid)
  87 {
  88         CPlaybackView *root = (CPlaybackView *)dt;
  89         if (root)
  90                 root->m_OnCtxtUpdate(type, lid);
  91 }
  92
  93
  94 void CPlaybackView::m_OnCtxtUpdate(EActionType type, int lid)
  95 {
  96         SItemInfo *itinfo = NULL;
  97         Elm_Object_Item *focusedItem = NULL;
  98
  99         if (!m->ctxtinfo || !m->ctxtinfo->context)
 100                 return;
 101
 102         itinfo = m_FindItemInfoFromSong(m->elInfo,
 103                 (CSongInfo *)m->ctxtinfo->context);
 104         if (!itinfo) {
 105                 _ERR(" Unable to find song in the list ");
 106                 return;
 107         }
 108
 109         if (type == ACTION_TYPE_DELETE) {
 110                 itinfo->check_status = true;
 111                 m_DeleteSelectedItems();
 112
 113                 if (!m->mgr->PopView()) {
 114                         _ERR("CViewMgr::PopView failed");
 115                         return;
 116                 }
 117
 118                 SParcel parcel;
 119                 memset(&parcel, 0, sizeof(SParcel));
 120                 parcel.updateType = E_PLAYLIST_UPDATE;
 121                 t_OnUpdate(&parcel);
 122
 123                 focusedItem = m->cs_itinfo->item;
 124         }
 125         else { // ACTION_TYPE_PLAY
 126                 if (m->ctxtinfo->status == PLAY_STATUS_PLAY)
 127                         m_KeyPausePress();
 128                 else {
 129                         if (itinfo == m->cs_itinfo)
 130                                 m_KeyPlayPress();
 131                         else
 132                                 m_HandleGenlistItemActivated(m->eoPlaylist, itinfo->item);
 133                 }
 134
 135                 if (!m->mgr->PopView()) {
 136                         _ERR("CViewMgr::PopView failed");
 137                         return;
 138                 }
 139
 140                 focusedItem = m->focused_item;
 141         }
 142
 143         if (!CViewMgr::GetInstance()->HideView(MUSIC_BASE_VIEW))
 144                 _ERR("CViewMgr::HideView failed");
 145
 146         t_OnShow();
 147
 148         if (focusedItem) {
 149                 elm_genlist_item_show(focusedItem, ELM_GENLIST_ITEM_SCROLLTO_IN);
 150                 elm_object_item_focus_set(focusedItem, EINA_TRUE);
 151         }
 152 }
 153
 154
 155 void CPlaybackView::sm_CbCtxtClose(void *dt)
 156 {
 157         CPlaybackView *root = (CPlaybackView *)dt;
 158         if (root)
 159                 root->m_OnCtxtClose();
 160 }
 161
 162
 163 void CPlaybackView::m_OnCtxtClose(void)
 164 {
 165         if (!m->mgr->PopView()) {
 166                 _ERR("CViewMgr::PopView failed");
 167                 return;
 168         }
 169
 170         elm_object_item_focus_set(m->focused_item, EINA_TRUE);
 171 }
 172
 173
 174 int CPlaybackView::sm_CbCurrentSongCount(void *cookie)
 175 {
 176         CPlaybackView *root = (CPlaybackView *)cookie;
 177         int ret = 0;
 178         if (root)
 179                 ret = root->m_CbCurrentSongCount();
 180
 181         return ret;
 182 }
 183
 184
 185 int CPlaybackView::m_CbCurrentSongCount(void)
 186 {
 187         return eina_list_count(m->elInfo);
 188 }
 189
 190
 191 void CPlaybackView::m_ChangeEditmodeAll(Eina_List *list, bool flag)
 192 {
 193         SItemInfo *itinfo = NULL;
 194         void *obj = NULL;
 195         Eina_List *l = NULL;
 196
 197         EINA_LIST_FOREACH(list, l, obj) {
 198                 itinfo = (SItemInfo *)obj;
 199                 itinfo->edit_mode = flag;
 200         }
 201 }
 202
 203
 204 void CPlaybackView::m_DisableCheckAll(Eina_List *list)
 205 {
 206         SItemInfo *itinfo = NULL;
 207         void *obj = NULL;
 208         Eina_List *l = NULL;
 209
 210         EINA_LIST_FOREACH(list, l, obj) {
 211                 itinfo = (SItemInfo *)obj;
 212                 itinfo->check_status = false;
 213         }
 214 }
 215
 216
 217 void CPlaybackView::m_SelectItem(SItemInfo *pItemInfo)
 218 {
 219         if (!pItemInfo || !pItemInfo->item)
 220                 return;
 221
 222         elm_genlist_item_bring_in(pItemInfo->item, ELM_GENLIST_ITEM_SCROLLTO_IN);
 223         elm_object_item_signal_emit(pItemInfo->item, MUSIC_SIGNAL_SELECT_ITEM, MUSIC_PLAYBACK_VIEW);
 224
 225         pItemInfo->select_status = true;
 226 }
 227
 228
 229 void CPlaybackView::m_UnselectItem(SItemInfo *pItemInfo)
 230 {
 231         if (!pItemInfo || !pItemInfo->item)
 232                 return;
 233
 234         elm_object_item_signal_emit(pItemInfo->item, MUSIC_SIGNAL_UNSELECT_ITEM,
 235                 MUSIC_PLAYBACK_VIEW);
 236
 237         pItemInfo->select_status = false;
 238 }
 239
 240
 241 void CPlaybackView::m_UpdateCurrentSongThumbnail(void)
 242 {
 243         char *path = NULL;
 244         char buf[MAX_LENGTH];
 245
 246         if (!m->cs_itinfo || !m->cs_itinfo->sinfo)
 247                 return;
 248
 249         path = m->cs_itinfo->sinfo->ThumbnailPath();
 250         if (path)
 251                 elm_image_file_set(m->eoAlbumCover, path, NULL);
 252         else {
 253                 snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 254                         MUSIC_IMAGE_DEFAULT_THUMB_450);
 255                 elm_image_file_set(m->eoAlbumCover, buf, NULL);
 256         }
 257 }
 258
 259
 260 void CPlaybackView::m_UpdateCurrentSongLabels(void)
 261 {
 262         char buf[MAX_LENGTH];
 263
 264         if (!m->csinfo)
 265                 return;
 266
 267         elm_object_part_text_set(m->eoBase, MUSIC_PART_SONG_TITLE,
 268                 m->csinfo->Name());
 269
 270         snprintf(buf, sizeof(buf), "%s - %s", m->csinfo->Artist(),
 271                 m->csinfo->Album());
 272
 273         elm_object_part_text_set(m->eoBase, MUSIC_PART_ARTIST_ALBUM, buf);
 274 }
 275
 276
 277 void CPlaybackView::m_UpdateEmptySongInfo(void)
 278 {
 279         char buf[MAX_LENGTH];
 280
 281         m->pSliderWidget->Init();
 282
 283         elm_object_part_text_set(m->eoBase, MUSIC_PART_SONG_TITLE,
 284                 _(NO_PLAYLIST_MESSAGE));
 285         elm_object_part_text_set(m->eoBase, MUSIC_PART_ARTIST_ALBUM,
 286                 _(NO_PLAYLIST_MESSAGE_SUB));
 287         snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 288                 MUSIC_IMAGE_DEFAULT_THUMB_450);
 289         elm_image_file_set(m->eoAlbumCover, buf, NULL);
 290         m->pController->SetPlayState(PLAY_STATUS_INITIAL);
 291 }
 292
 293
 294 void CPlaybackView::m_UpdateCtxtView(int playStatus)
 295 {
 296         if (!m->cs_itinfo || !m->ctxtinfo)
 297                 return;
 298
 299         if (!m->mgr->CheckTop(MUSIC_CONTEXT_VIEW))
 300                 return;
 301
 302         if (m->cs_itinfo->sinfo == m->ctxtinfo->context) {
 303                 m->ctxtinfo->status = (EPlayStatus)playStatus;
 304
 305                 SParcel parcel;
 306                 memset(&parcel, 0, sizeof(SParcel));
 307                 parcel.updateType = E_SONG_UPDATE;
 308                 m->mgr->UpdateView((const char *)MUSIC_CONTEXT_VIEW, &parcel);
 309         }
 310 }
 311
 312
 313 void CPlaybackView::m_UpdateCurrentSongItem(int index)
 314 {
 315         SItemInfo *pItemInfo = NULL;
 316
 317         if (m->cs_itinfo) {
 318                 m_UnselectItem(m->cs_itinfo);
 319                 m_UpdateCtxtView(PLAY_STATUS_PAUSE);
 320         }
 321
 322         pItemInfo = (SItemInfo *)eina_list_nth(m->elInfo, index);
 323
 324         if (pItemInfo) {
 325                 m->cs_itinfo = pItemInfo;
 326                 if (m->pController->PlayState() == PLAY_STATUS_STOP) {
 327                         elm_genlist_item_bring_in(pItemInfo->item,
 328                                 ELM_GENLIST_ITEM_SCROLLTO_IN);
 329                 }
 330                 else {
 331                         m_SelectItem(pItemInfo);
 332                         m_UpdateCtxtView(PLAY_STATUS_PLAY);
 333                 }
 334         }
 335 }
 336
 337
 338 void CPlaybackView::m_UpdateEditmodeFocusSequence(void)
 339 {
 340         elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnEdit[EDIT_BTN_CANCEL], ELM_FOCUS_LEFT);
 341         elm_object_focus_next_object_set(m->eoBtnEdit[EDIT_BTN_CANCEL], m->eoPlaylist, ELM_FOCUS_RIGHT);
 342         elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoBtnEdit[EDIT_BTN_CANCEL], ELM_FOCUS_DOWN);
 343 }
 344
 345
 346 void CPlaybackView::m_UpdatePlaymodeFocusSequence(void)
 347 {
 348         switch (m->pController->PlayState()) {
 349         case PLAY_STATUS_INITIAL:
 350                 // Do nothing
 351                 break;
 352
 353         case PLAY_STATUS_STOP:
 354                 elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnControl[CTRL_BTN_PLAY], ELM_FOCUS_LEFT);
 355                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_PLAY], m->eoPlaylist, ELM_FOCUS_RIGHT);
 356                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_PLAY], m->eoBtnControl[CTRL_BTN_REPEAT], ELM_FOCUS_LEFT);
 357                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_REPEAT], m->eoBtnControl[CTRL_BTN_PLAY], ELM_FOCUS_RIGHT);
 358                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY], MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 359                 break;
 360
 361         case PLAY_STATUS_PLAY:
 362         case PLAY_STATUS_PAUSE:
 363                 elm_object_focus_next_object_set(m->eoPlaylist,
 364                         m->eoBtnControl[CTRL_BTN_FORWARD], ELM_FOCUS_LEFT);
 365                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_FORWARD],
 366                         m->eoPlaylist, ELM_FOCUS_RIGHT);
 367                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_PLAY],
 368                         m->eoBtnControl[CTRL_BTN_FORWARD], ELM_FOCUS_RIGHT);
 369                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_PLAY],
 370                         m->eoBtnControl[CTRL_BTN_REWIND], ELM_FOCUS_LEFT);
 371                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_REPEAT],
 372                         m->eoBtnControl[CTRL_BTN_REWIND], ELM_FOCUS_RIGHT);
 373                 break;
 374
 375         default:
 376                 ASSERT(!"Invalid State");
 377                 break;
 378         }
 379 }
 380
 381
 382 void CPlaybackView::m_UpdateCurrentSongInfo(void)
 383 {
 384         CSongInfo *sinfo = NULL;
 385         int index;
 386
 387         if (eina_list_count(m->elInfo) == 0) {
 388                 m_UpdateEmptySongInfo();
 389                 return;
 390         }
 391
 392         if (!m->pController->GetCurrentSongIndex(&index)) {
 393                 _ERR(" music get current song index failed ");
 394                 return;
 395         }
 396
 397         if (!m->pController->GetSonginfoFromIndex(index, &sinfo)) {
 398                 _ERR(" music get songinfo failed ");
 399                 return;
 400         }
 401         m->csinfo = sinfo;
 402
 403         m_UpdateCurrentSongItem(index);
 404         m_UpdateCurrentSongLabels();
 405         m_UpdateCurrentSongThumbnail();
 406         m->pPlaybackController->Update();
 407         m_UpdatePlaymodeFocusSequence();
 408 }
 409
 410
 411 void CPlaybackView::m_DisableEditButtons(bool flag)
 412 {
 413         /* flag - 1 means disable edit buttons and 0 means enable */
 414         if (flag)
 415                 elm_object_focus_set(m->eoBtnEdit[EDIT_BTN_CANCEL], EINA_TRUE);
 416
 417         elm_object_disabled_set(m->eoBtnEdit[EDIT_BTN_DELETE], (Eina_Bool)flag);
 418         elm_object_disabled_set(m->eoBtnEdit[EDIT_BTN_DESELECT], (Eina_Bool)flag);
 419         if (flag) {
 420                 m_UpdateEditmodeFocusSequence();
 421                 elm_object_focus_set(m->eoBtnEdit[EDIT_BTN_CANCEL], EINA_TRUE);
 422         }
 423         else {
 424                 elm_object_focus_next_object_set(m->eoBtnEdit[EDIT_BTN_CANCEL], m->eoBtnEdit[EDIT_BTN_DESELECT], ELM_FOCUS_RIGHT);
 425                 elm_object_focus_next_object_set(m->eoBtnEdit[EDIT_BTN_DELETE], m->eoPlaylist, ELM_FOCUS_RIGHT);
 426                 elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnEdit[EDIT_BTN_DELETE], ELM_FOCUS_LEFT);
 427         }
 428 }
 429
 430
 431 void CPlaybackView::m_FromEditToPlaybackMode(void)
 432 {
 433         if (m->pController->PlayState() == PLAY_STATUS_STOP) {
 434                 elm_genlist_item_bring_in(m->cs_itinfo->item,
 435                         ELM_GENLIST_ITEM_SCROLLTO_IN);
 436         }
 437         else
 438                 m_SelectItem(m->cs_itinfo);
 439
 440         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE,
 441                 MUSIC_PLAYBACK_VIEW);
 442         elm_object_focus_set(m->eoBtnControl[CTRL_BTN_SETTINGS], EINA_TRUE);
 443
 444         m_ChangeEditmodeAll(m->elInfo, false);
 445
 446         elm_genlist_realized_items_update(m->eoPlaylist);
 447
 448         m_UpdatePlaymodeFocusSequence();
 449 }
 450
 451
 452 void CPlaybackView::m_FromPlaybackToEditMode(void)
 453 {
 454         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_EDIT_MODE,
 455                 MUSIC_PLAYBACK_VIEW);
 456
 457         m_DisableEditButtons(true);
 458
 459         elm_object_focus_set(m->eoBtnEdit[EDIT_BTN_CANCEL], EINA_TRUE);
 460
 461         m_ChangeEditmodeAll(m->elInfo, true);
 462
 463         elm_genlist_realized_items_update(m->eoPlaylist);
 464
 465         m_UpdateEditmodeFocusSequence();
 466 }
 467
 468
 469 void CPlaybackView::m_DeleteSelectedItems(void)
 470 {
 471         Eina_List *l = NULL, *l_next = NULL;
 472         SItemInfo *pItemInfo = NULL;
 473         void *obj = NULL;
 474         bool updateFlag = false;
 475         int index;
 476
 477         m_DisableEditButtons(true);
 478         EINA_LIST_FOREACH_SAFE(m->elInfo, l, l_next, obj) {
 479                 pItemInfo = (SItemInfo *)obj;
 480                 if (pItemInfo->check_status) {
 481                         if (m->cs_itinfo == pItemInfo) {
 482                                 updateFlag = true;
 483                                 m_UnselectItem(m->cs_itinfo);
 484                                 m->cs_itinfo = NULL;
 485                                 m->pController->SetPlayState(PLAY_STATUS_STOP);
 486                                 m->pController->Stop();
 487                         }
 488                         index = elm_genlist_item_index_get(pItemInfo->item);
 489                         m->pController->RemoveSong(pItemInfo->sinfo, index);
 490
 491                         m->elInfo = eina_list_remove(m->elInfo, pItemInfo);
 492                         elm_object_item_del(pItemInfo->item);
 493                 }
 494         }
 495
 496         if (eina_list_count(m->elInfo) == 0) {
 497                 m_UpdateEmptySongInfo();
 498                 elm_genlist_realized_items_update(m->eoPlaylist);
 499                 elm_object_focus_set(m->eoBtnEdit[EDIT_BTN_CANCEL], EINA_TRUE);
 500                 return;
 501         }
 502
 503         if (updateFlag)
 504                 m_UpdateCurrentSongInfo();
 505
 506         elm_genlist_realized_items_update(m->eoPlaylist);
 507         elm_object_focus_set(m->eoBtnEdit[EDIT_BTN_CANCEL], EINA_TRUE);
 508 }
 509
 510
 511 void CPlaybackView::m_KeyBackPress(void)
 512 {
 513         t_OnHide();
 514
 515         if (!CViewMgr::GetInstance()->ShowView(MUSIC_BASE_VIEW))
 516                 _ERR("CViewMgr::ShowView failed");
 517
 518         if (CViewMgr::GetInstance()->CheckTop(MUSIC_CONTEXT_VIEW)) {
 519                 if (!CViewMgr::GetInstance()->UpdateView(MUSIC_CONTEXT_VIEW, NULL))
 520                         _ERR("CViewMgr::UpdateView failed");
 521
 522                 if (!CViewMgr::GetInstance()->ShowView(MUSIC_CONTEXT_VIEW))
 523                         _ERR("CViewMgr::ShowView failed");
 524         }
 525 }
 526
 527
 528 void CPlaybackView::m_KeyExitPress(void)
 529 {
 530         m->pController->Stop();
 531         elm_exit();
 532 }
 533
 534
 535 void CPlaybackView::m_KeyPlayPress(void)
 536 {
 537         int state;
 538
 539         if (elm_object_disabled_get(m->eoBtnControl[CTRL_BTN_PLAY]))
 540                 return;
 541
 542         state = m->pController->PlayState();
 543         if (state == PLAY_STATUS_PAUSE) {
 544                 m->pController->Resume();
 545                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY],
 546                         MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
 547         }
 548         else if (state != PLAY_STATUS_PLAY) {
 549                 m->pController->Start();
 550         }
 551 }
 552
 553
 554 void CPlaybackView::m_KeyPausePress(void)
 555 {
 556         int state;
 557
 558         if (elm_object_disabled_get(m->eoBtnControl[CTRL_BTN_PLAY]))
 559                 return;
 560
 561         state = m->pController->PlayState();
 562         if (state == PLAY_STATUS_PLAY) {
 563                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY],
 564                         MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 565                 m->pController->Pause();
 566         }
 567 }
 568
 569
 570 void CPlaybackView::m_KeyNextPress(void)
 571 {
 572         if (elm_object_disabled_get(m->eoBtnControl[CTRL_BTN_FORWARD]))
 573                 return;
 574
 575         m->pController->HandleRemoteButtons(m->eoBtnControl[CTRL_BTN_FORWARD], EVENT_PRESSED);
 576 }
 577
 578
 579 void CPlaybackView::m_KeyPreviousPress(void)
 580 {
 581         if (elm_object_disabled_get(m->eoBtnControl[CTRL_BTN_REWIND]))
 582                 return;
 583
 584         m->pController->HandleRemoteButtons(m->eoBtnControl[CTRL_BTN_REWIND], EVENT_PRESSED);
 585 }
 586
 587
 588 void CPlaybackView::m_KeyNextUnpress(void)
 589 {
 590         if (elm_object_disabled_get(m->eoBtnControl[CTRL_BTN_FORWARD]))
 591                 return;
 592
 593         m->pController->HandleRemoteButtons(m->eoBtnControl[CTRL_BTN_FORWARD], EVENT_UNPRESSED);
 594 }
 595
 596
 597 void CPlaybackView::m_KeyPreviousUnpress(void)
 598 {
 599         if (elm_object_disabled_get(m->eoBtnControl[CTRL_BTN_REWIND]))
 600                 return;
 601
 602         m->pController->HandleRemoteButtons(m->eoBtnControl[CTRL_BTN_REWIND], EVENT_UNPRESSED);
 603 }
 604
 605
 606 void CPlaybackView::m_HandleKeyPress(char *keyname)
 607 {
 608         if (!strcmp(keyname, (char *)KEY_EXIT))
 609                 m_KeyExitPress();
 610         else if (!strcmp(keyname, (char *)KEY_BACK) ||
 611                 !strcmp(keyname, (char *)KEY_BACK_REMOTE))
 612                 m_KeyBackPress();
 613         else if (!strcmp(keyname, (char *)KEY_PLAY))
 614                 m_KeyPlayPress();
 615         else if (!strcmp(keyname, (char *)KEY_PAUSE))
 616                 m_KeyPausePress();
 617         else if (!strcmp(keyname, (char *)KEY_NEXT))
 618                 m_KeyNextPress();
 619         else if (!strcmp(keyname, (char *)KEY_PREVIOUS))
 620                 m_KeyPreviousPress();
 621         else if (!strcmp(keyname, (char *)KEY_VOLUMEUP) ||
 622                 !strcmp(keyname, (char *)KEY_VOLUMEUP_REMOTE))
 623                 m->pHandleVolume->Up();
 624         else if (!strcmp(keyname, (char *)KEY_VOLUMEDOWN) ||
 625                 !strcmp(keyname, (char *)KEY_VOLUMEDOWN_REMOTE))
 626                 m->pHandleVolume->Down();
 627         else if (!strcmp(keyname, (char *)KEY_MUTE) ||
 628                 !strcmp(keyname, (char *)KEY_MUTE_REMOTE))
 629                 m->pHandleVolume->Mute();
 630 }
 631
 632
 633 void CPlaybackView::m_HandleKeyUnpress(char *keyname)
 634 {
 635         if (!strcmp(keyname, KEY_PREVIOUS))
 636                 m_KeyPreviousUnpress();
 637         else if (!strcmp(keyname, KEY_NEXT))
 638                 m_KeyNextUnpress();
 639 }
 640
 641
 642 void CPlaybackView::m_AddAlbumCover(void)
 643 {
 644         Evas_Object *eoAlbumCover = NULL;
 645
 646         eoAlbumCover = elm_image_add(m->eoBase);
 647         if (!eoAlbumCover)
 648                 return;
 649
 650         evas_object_size_hint_weight_set(eoAlbumCover, EVAS_HINT_EXPAND,
 651                         EVAS_HINT_EXPAND);
 652         elm_image_aspect_fixed_set(eoAlbumCover, EINA_FALSE);
 653
 654         elm_object_part_content_set(m->eoBase, MUSIC_PART_ALBUMCOVER,
 655                         eoAlbumCover);
 656         evas_object_show(eoAlbumCover);
 657         m->eoAlbumCover = eoAlbumCover;
 658
 659 }
 660
 661
 662 void CPlaybackView::m_AddCurrentSonginfo(void)
 663 {
 664         m_AddAlbumCover();
 665
 666         m->pSliderWidget = new CSliderWidget;
 667         m->pSliderWidget->Create(m->eoBase);
 668 }
 669
 670
 671 SItemInfo *CPlaybackView::m_FindItemInfoFromSong(Eina_List *list, CSongInfo *sinfo)
 672 {
 673         Eina_List *l = NULL;
 674         SItemInfo *itinfo = NULL;
 675         void *obj = NULL;
 676
 677         EINA_LIST_FOREACH(list, l, obj) {
 678                 itinfo = (SItemInfo *)obj;
 679                 if (itinfo->sinfo == sinfo)
 680                         return itinfo;
 681         }
 682
 683         return NULL;
 684 }
 685
 686
 687 SItemInfo *CPlaybackView::m_FindItemInfoFromItem(Eina_List *list, Elm_Object_Item *item)
 688 {
 689         Eina_List *l = NULL;
 690         SItemInfo *itinfo = NULL;
 691         void *obj = NULL;
 692
 693         EINA_LIST_FOREACH(list, l, obj) {
 694                 itinfo = (SItemInfo *)obj;
 695                 if (itinfo->item == item)
 696                         return itinfo;
 697         }
 698
 699         return NULL;
 700 }
 701
 702
 703 void CPlaybackView::m_UpdateItemCheck(SItemInfo *itinfo)
 704 {
 705         if (!itinfo) {
 706                 _ERR(" No item info to Update check ");
 707                 return;
 708         }
 709
 710         if (itinfo->check_status) {
 711                 elm_object_item_signal_emit(itinfo->item,
 712                         MUSIC_SIGNAL_CHECK_OFF, MUSIC_PLAYBACK_VIEW);
 713                 itinfo->check_status = false;
 714                 return;
 715         }
 716
 717         elm_object_item_signal_emit(itinfo->item,
 718                 MUSIC_SIGNAL_CHECK_ON, MUSIC_PLAYBACK_VIEW);
 719         itinfo->check_status = true;
 720 }
 721
 722
 723 class CElmGenlistItemClass {
 724 public:
 725         static char *sm_CbTextGet(void *data, Evas_Object *obj, const char *part)
 726         {
 727                 CSongInfo *sinfo = NULL;
 728                 SItemInfo *pItemInfo = (SItemInfo *)data;
 729                 char buf[MAX_LENGTH];
 730                 char *timestr = NULL;
 731                 int duration;
 732                 int index;
 733
 734                 if (!pItemInfo || !obj)
 735                         return NULL;
 736
 737                 sinfo = pItemInfo->sinfo;
 738
 739                 snprintf(buf, sizeof(buf), "%s", MUSIC_STR_EMPTY);
 740
 741                 if (!strcmp(part, "elm.text0")) {
 742                         index = elm_genlist_item_index_get(pItemInfo->item);
 743                         snprintf(buf, sizeof(buf), "%d", index);
 744                 }
 745                 else if (!strcmp(part, "elm.text1"))
 746                         snprintf(buf, sizeof(buf), "%s", sinfo->Name());
 747                 else if (!strcmp(part, "elm.text2"))
 748                         snprintf(buf, sizeof(buf), "%s - %s",
 749                         sinfo->Artist(),
 750                         sinfo->Album());
 751                 else if (!strcmp(part, "elm.text3")) {
 752                         duration = sinfo->Duration();
 753                         timestr = CCommonUI::TimeStrFromMilSeconds(duration);
 754                         if (timestr) {
 755                                 snprintf(buf, sizeof(buf), "%s", timestr);
 756                                 free(timestr);
 757                         }
 758                 }
 759
 760                 if (strcmp(buf, MUSIC_STR_EMPTY))
 761                         return strdup(buf);
 762
 763                 return NULL;
 764         }
 765         static Evas_Object *sm_CbContentGet(void *data, Evas_Object *obj, const char *part)
 766         {
 767                 CSongInfo *sinfo = NULL;
 768                 SItemInfo *pItemInfo = (SItemInfo *)data;
 769                 Evas_Object *img = NULL;
 770                 char *path = NULL;
 771                 char buf[MAX_LENGTH];
 772
 773                 if (!pItemInfo || !obj)
 774                         return NULL;
 775
 776                 sinfo = pItemInfo->sinfo;
 777
 778                 img = elm_image_add(obj);
 779                 if (!img)
 780                         return NULL;
 781
 782                 elm_image_aspect_fixed_set(img, EINA_FALSE);
 783
 784                 if (!strcmp(part, "elm.swallow.icon")) {
 785                         path = sinfo->ThumbnailPath();
 786                         if (path)
 787                                 elm_image_file_set(img, path, "NULL");
 788                         else {
 789                                 snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 790                                         MUSIC_IMAGE_DEFAULT_THUMB_126);
 791                                 elm_image_file_set(img, buf, "NULL");
 792                         }
 793                 }
 794
 795                 return img;
 796
 797         }
 798         static void         sm_CbDel(void *data, Evas_Object *obj)
 799         {
 800                 free(data);
 801         }
 802 };
 803
 804
 805 Elm_Genlist_Item_Class *CPlaybackView::m_GetItemClass(void)
 806 {
 807         Elm_Genlist_Item_Class *list_item = NULL;
 808
 809         list_item = elm_genlist_item_class_new();
 810         if (!list_item) {
 811                 _ERR(" elm_genlist_item_class_new failed ");
 812                 return NULL;
 813         }
 814
 815         list_item->item_style       = MUSIC_STYLE_PLAYLIST;
 816         list_item->func.text_get    = CElmGenlistItemClass::sm_CbTextGet;
 817         list_item->func.content_get = CElmGenlistItemClass::sm_CbContentGet;
 818         list_item->func.state_get   = NULL;
 819         list_item->func.del         = CElmGenlistItemClass::sm_CbDel;
 820
 821         return list_item;
 822 }
 823
 824
 825 void CPlaybackView::m_AddGenlist(void)
 826 {
 827         Evas_Object *genlist = NULL;
 828         Evas_Object *eoBase = NULL;
 829
 830         eoBase = m->eoBase;
 831         genlist = elm_genlist_add(eoBase);
 832         if (!genlist)
 833                 return;
 834
 835         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 836         evas_object_size_hint_weight_set(genlist,
 837                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 838         elm_object_part_content_set(eoBase, MUSIC_PART_PLAYLIST, genlist);
 839         elm_genlist_select_mode_set(genlist, ELM_OBJECT_SELECT_MODE_ALWAYS);
 840         elm_genlist_multi_select_set(genlist, EINA_FALSE);
 841
 842         Connect(genlist, EO_PLAYLIST, TYPE_REALIZED | TYPE_MOUSE_MOVE |
 843                 TYPE_KEY_DOWN | TYPE_ACTIVATED);
 844
 845         evas_object_show(genlist);
 846         m->eoPlaylist = genlist;
 847 }
 848
 849
 850 void CPlaybackView::m_AddPlaylist(void)
 851 {
 852         Elm_Genlist_Item_Class *list_item = NULL;
 853         int ts = 0;
 854         int i, index = -1;
 855         CSongInfo *sinfo = NULL;
 856         Elm_Object_Item *item = NULL;
 857         SItemInfo *pItemInfo = NULL;
 858
 859         m_AddGenlist();
 860         if (!m->eoPlaylist)
 861                 return;
 862
 863         list_item = m_GetItemClass();
 864         if (!list_item) {
 865                 evas_object_del(m->eoPlaylist);
 866                 return;
 867         }
 868
 869         if (!m->pController->GetTotalSongs(&ts)) {
 870                 _ERR(" music get total songs failed ");
 871                 return;
 872         }
 873
 874         if (!m->pController->GetCurrentSongIndex(&index))
 875                 _ERR(" music get current song index failed ");
 876
 877         for (i = 0; i < ts; i++) {
 878                 if (!m->pController->GetSonginfoFromIndex(i, &sinfo)) {
 879                         _ERR(" music get songinfo failed ");
 880                         continue;
 881                 }
 882                 pItemInfo = (SItemInfo *)calloc(1, sizeof(*pItemInfo));
 883                 if (!pItemInfo)
 884                         return;
 885                 pItemInfo->sinfo = sinfo;
 886                 pItemInfo->edit_mode = false;
 887                 pItemInfo->check_status = false;
 888                 pItemInfo->select_status = false;
 889
 890                 // event handling will be done in OnActivated function
 891                 item = elm_genlist_item_append(m->eoPlaylist, list_item,
 892                         pItemInfo, NULL, ELM_GENLIST_ITEM_NONE,
 893                         NULL, m);
 894                 pItemInfo->item = item;
 895
 896                 if (i == index) {
 897                         pItemInfo->select_status = true;
 898                         m->cs_itinfo = pItemInfo;
 899                 }
 900                 m->elInfo = eina_list_append(m->elInfo, pItemInfo);
 901         }
 902 }
 903
 904
 905 void CPlaybackView::m_RemovePlaylist(void)
 906 {
 907         if (m->eoPlaylist) {
 908                 elm_genlist_clear(m->eoPlaylist);
 909                 m->eoPlaylist = NULL;
 910         }
 911
 912         if (m->elInfo) {
 913                 eina_list_free(m->elInfo);
 914                 m->elInfo = NULL;
 915         }
 916 }
 917
 918
 919 void CPlaybackView::m_HandleGenlistItemActivated(Evas_Object *obj, Elm_Object_Item *genListItem)
 920 {
 921         int index;
 922         SItemInfo *itinfo = NULL;
 923
 924         if (!obj || !genListItem)
 925                 return;
 926
 927         itinfo = m_FindItemInfoFromItem(m->elInfo, genListItem);
 928         if (!itinfo) {
 929                 _ERR(" no item info found ");
 930                 return;
 931         }
 932
 933         if (itinfo->edit_mode) {
 934                 m_UpdateItemCheck(itinfo);
 935                 m_DisableEditButtons(false);
 936                 return;
 937         }
 938
 939         index = elm_genlist_item_index_get(genListItem);
 940
 941         m->pController->PlayIndexSong(--index);
 942 }
 943
 944
 945 bool CPlaybackView::Create(void *data)
 946 {
 947         ASSERT(!m);
 948
 949         CPlaybackController::SCallback cb;
 950
 951         _CREATE_BEGIN{
 952                 _CHECK(m = new SPlaybackView)
 953                 _CHECK(m->mgr = CViewMgr::GetInstance())
 954                 _CHECK(m->eoWin = m->mgr->Window())
 955                 _CHECK(m->pController = new CMusicController)
 956                 _CHECK(m->pController->Create())
 957                 _CHECK(m->eoBase = CCommonUI::AddBase(m->eoWin, MUSIC_PLAYBACK_VIEW))
 958                 _CHECK(CBaseView::Create(data))
 959                 _CHECK(CTimer::Create());
 960                 _CHECK(m->pController->AddListener(this))
 961                 _CHECK(m->pPlaybackController = new CPlaybackController)
 962                 _COMMAND{ cb.cookie = this; cb.OnCurrentSongCount = sm_CbCurrentSongCount; }
 963                 _CHECK(m->pPlaybackController->Create(m->eoBase, &cb))
 964
 965                 _WHEN_SUCCESS{
 966                         evas_object_data_set(m->eoBase, PLAYBACK_VIEW_DATA, m);
 967
 968                         m_AddCurrentSonginfo();
 969                         m_AddPlaylist();
 970
 971                         int i;
 972                         for (i = 0; i < TOTAL_CONTROL_BTNS; i++)
 973                                 m->eoBtnControl[i] = m->pPlaybackController->ControlBtnsObject((EPlayerControlBtns)i);
 974
 975                         for (i = 0; i < TOTAL_EDIT_BTNS; i++)
 976                                 m->eoBtnEdit[i] = m->pPlaybackController->EditBtnsObject((EPlayerEditBtns)i);
 977
 978                         m->pHandleVolume = new CHandleVolume;
 979                         m->pHandleVolume->Create(m->eoBase);
 980                         m_UpdatePlaymodeFocusSequence();
 981
 982                         Connect(m->eoBase, EO_BASE, TYPE_KEY_DOWN | TYPE_KEY_UP);
 983                 }
 984
 985                 _CHECK_FAIL{ m->pPlaybackController->Destroy(); }
 986                 _CHECK_FAIL{ delete m->pPlaybackController; }
 987                 _CHECK_FAIL{ m->pController->RemoveListener(this); }
 988                 _CHECK_FAIL{ CTimer::Destroy(); }
 989                 _CHECK_FAIL{ CBaseView::Destroy(); }
 990                 _CHECK_FAIL{ evas_object_del(m->eoBase); }
 991                 _CHECK_FAIL{ m->pController->Destroy(); }
 992                 _CHECK_FAIL{ delete m->pController; }
 993                 _CHECK_FAIL{ /* mgr->Window() */ }
 994                 _CHECK_FAIL{ /* CViewerMgr::GetInstance() */}
 995                 _CHECK_FAIL{ delete m; m = NULL; }
 996         }_CREATE_END_AND_CATCH{ return false; }
 997
 998         return true;
 999 }
1000
1001
1002 void CPlaybackView::Destroy(void)
1003 {
1004         ASSERT(m);
1005
1006         Disconnect(m->eoBase);
1007
1008         m->pPlaybackController->Destroy();
1009         delete m->pPlaybackController;
1010
1011         m->pController->RemoveListener(this);
1012
1013         m->pSliderWidget->Destroy();
1014         delete m->pSliderWidget;
1015
1016         m->pHandleVolume->Destroy();
1017         delete m->pHandleVolume;
1018         CBaseView::Destroy();
1019         evas_object_del(m->eoBase);
1020
1021         free(m->ctxtinfo);
1022         delete m;
1023         m = NULL;
1024 }
1025
1026
1027 Evas_Object* CPlaybackView::Base(void)
1028 {
1029         ASSERT(m);
1030
1031         return m->eoBase;
1032 }
1033
1034
1035 void CPlaybackView::t_OnShow(void)
1036 {
1037         ASSERT(m);
1038
1039         int state;
1040
1041         m_UpdateCurrentSongInfo();
1042
1043         state = m->pController->PlayState();
1044         if (state == PLAY_STATUS_INITIAL || state == PLAY_STATUS_STOP) {
1045                 m_RemovePlaylist();
1046                 m_AddPlaylist();
1047                 m->pController->Start();
1048         }
1049
1050         if (m->cs_itinfo) {
1051                 elm_genlist_item_show(m->cs_itinfo->item, ELM_GENLIST_ITEM_SCROLLTO_IN);
1052                 elm_object_item_focus_set(m->cs_itinfo->item, EINA_TRUE);
1053         }
1054
1055         evas_object_show(m->eoBase);
1056 }
1057
1058
1059 void CPlaybackView::t_OnUpdate(void *data)
1060 {
1061         ASSERT(m);
1062
1063         SParcel *parcel = (SParcel *)data;
1064         int updateType;
1065         char *keyEvent = NULL;
1066
1067         if (!parcel)
1068                 updateType = E_PLAYLIST_UPDATE;
1069         else {
1070                 updateType = parcel->updateType;
1071                 keyEvent = (char *)parcel->keyEvent;
1072         }
1073
1074         switch (updateType) {
1075         case E_PLAYLIST_UPDATE:
1076                 m_RemovePlaylist();
1077                 m_AddPlaylist();
1078                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_FALSE);
1079                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_FALSE);
1080                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_PLAY], EINA_FALSE);
1081                 elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_REPEAT],
1082                         m->eoBtnControl[CTRL_BTN_REWIND], ELM_FOCUS_RIGHT);
1083                 m_FromEditToPlaybackMode();
1084                 break;
1085
1086         case E_KEY_PRESS:
1087                 m_HandleKeyPress(keyEvent);
1088                 break;
1089
1090         case E_KEY_RELEASE:
1091                 m_HandleKeyUnpress(keyEvent);
1092                 break;
1093
1094         default:
1095                 break;
1096         }
1097 }
1098
1099
1100 void CPlaybackView::t_OnTimer(int id)
1101 {
1102 }
1103
1104
1105 void CPlaybackView::t_OnHide(void)
1106 {
1107         ASSERT(m);
1108
1109         evas_object_hide(m->eoBase);
1110 }
1111
1112
1113 void CPlaybackView::OnKeyDown(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Down *ev)
1114 {
1115         switch (id) {
1116         case EO_BASE:
1117                 m_HandleKeyPress(ev->keyname);
1118                 break;
1119
1120         case EO_PLAYLIST:
1121                 {
1122                         Elm_Object_Item *it = NULL;
1123                         SContentInfo *ctxtinfo = NULL;
1124                         SItemInfo *itinfo = NULL;
1125                         SParcel parcel;
1126
1127                         if (!strcmp(ev->keyname, KEY_MENU) ||
1128                                 !strcmp(ev->keyname, KEY_MENU_REMOTE)) {
1129                                 it = elm_object_focused_item_get(obj);
1130                                 if (!it) {
1131                                         _ERR(" unable to get focused item ");
1132                                         return;
1133                                 }
1134                                 m->focused_item = it;
1135
1136                                 if (m->ctxtinfo) {
1137                                         free(m->ctxtinfo);
1138                                         m->ctxtinfo = NULL;
1139                                 }
1140
1141                                 ctxtinfo = (SContentInfo *)calloc(1, sizeof(*ctxtinfo));
1142                                 if (!ctxtinfo)
1143                                         return;
1144
1145                                 itinfo = m_FindItemInfoFromItem(m->elInfo, it);
1146                                 if (!itinfo) {
1147                                         free(ctxtinfo);
1148                                         return;
1149                                 }
1150
1151                                 if (m->pController->PlayState() == PLAY_STATUS_PLAY &&
1152                                         itinfo == m->cs_itinfo)
1153                                         ctxtinfo->status = PLAY_STATUS_PLAY;
1154                                 else
1155                                         ctxtinfo->status = PLAY_STATUS_PAUSE;
1156
1157                                 ctxtinfo->cbdata = this;
1158                                 ctxtinfo->update = sm_CbCtxtUpdate;
1159                                 ctxtinfo->close = sm_CbCtxtClose;
1160                                 ctxtinfo->type = CONTEXT_TYPE_PLAYSONG;
1161                                 ctxtinfo->context = itinfo->sinfo;
1162
1163                                 m->ctxtinfo = ctxtinfo;
1164
1165                                 memset(&parcel, 0, sizeof(SParcel));
1166                                 parcel.ctxtInfo = ctxtinfo;
1167                                 if (!m->mgr->PushView(MUSIC_CONTEXT_VIEW, &parcel))
1168                                         _ERR("viewmgr push view MUSIC_CONTEXT_VIEW failed");
1169                         }
1170                 }
1171
1172         default:
1173                 break;
1174         }
1175 }
1176
1177
1178 void CPlaybackView::OnKeyUp(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Up *ev)
1179 {
1180         switch (id) {
1181         case EO_BASE:
1182                 m_HandleKeyUnpress(ev->keyname);
1183                 break;
1184
1185         default:
1186                 break;
1187         }
1188 }
1189
1190
1191 void CPlaybackView::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
1192 {
1193         switch (id) {
1194         case EO_PLAYLIST:
1195                 {
1196                         Elm_Object_Item *item;
1197
1198                         item = elm_genlist_at_xy_item_get(obj, ev->cur.canvas.x,
1199                                 ev->cur.canvas.y, NULL);
1200                         if (!item)
1201                                 return;
1202
1203                         if (!elm_object_item_focus_get(item))
1204                                 elm_object_item_focus_set(item, EINA_TRUE);
1205                 }
1206                 break;
1207
1208         default:
1209                 break;
1210         }
1211 }
1212
1213
1214 void CPlaybackView::OnRealized(int id, Evas_Object *obj, Elm_Object_Item *item)
1215 {
1216         switch (id) {
1217         case EO_PLAYLIST:
1218                 {
1219                         int index = elm_genlist_item_index_get(item);
1220                         if ((index & 1) == 1)
1221                                 elm_object_item_signal_emit(item,
1222                                         MUSIC_SIGNAL_EVEN_ROW, MUSIC_PLAYBACK_VIEW);
1223                         else
1224                                 elm_object_item_signal_emit(item,
1225                                         MUSIC_SIGNAL_ODD_ROW, MUSIC_PLAYBACK_VIEW);
1226
1227                         SItemInfo *itInfo = m_FindItemInfoFromItem(m->elInfo, item);
1228                         if (itInfo->select_status)
1229                                 elm_object_item_signal_emit(item,
1230                                         MUSIC_SIGNAL_SELECT_ITEM, MUSIC_PLAYBACK_VIEW);
1231                         else
1232                                 elm_object_item_signal_emit(item,
1233                                         MUSIC_SIGNAL_UNSELECT_ITEM, MUSIC_PLAYBACK_VIEW);
1234
1235                         if (itInfo->edit_mode) {
1236                                 elm_object_item_signal_emit(item,
1237                                         MUSIC_SIGNAL_EDITMODE_ON, MUSIC_PLAYBACK_VIEW);
1238                                 if (itInfo->check_status) {
1239                                         elm_object_item_signal_emit(item,
1240                                                 MUSIC_SIGNAL_CHECK_ON, MUSIC_PLAYBACK_VIEW);
1241                                 }
1242                                 else
1243                                         elm_object_item_signal_emit(item,
1244                                                 MUSIC_SIGNAL_CHECK_OFF, MUSIC_PLAYBACK_VIEW);
1245                         }
1246                         else
1247                                 elm_object_item_signal_emit(item,
1248                                         MUSIC_SIGNAL_EDITMODE_OFF, MUSIC_PLAYBACK_VIEW);
1249                 }
1250                 break;
1251
1252         default:
1253                 break;
1254         }
1255 }
1256
1257
1258 void CPlaybackView::OnActivated(int id, Evas_Object *obj, Elm_Object_Item *item)
1259 {
1260         switch (id) {
1261         case EO_PLAYLIST:
1262                 m_HandleGenlistItemActivated(obj, item);
1263                 break;
1264
1265         default:
1266                 break;
1267         }
1268 }
1269
1270
1271 void CPlaybackView::OnComplete(void)
1272 {
1273         m_UpdateCurrentSongInfo();
1274 }
1275
1276
1277 void CPlaybackView::OnError(void)
1278 {
1279 }
1280
1281
1282 void CPlaybackView::OnUsbStatusChanged(SUsbStorageStatus status)
1283 {
1284 }
1285
1286
1287 void CPlaybackView::OnUpdateContent(void)
1288 {
1289 }
1290
1291
1292 void CPlaybackView::OnStartPlayback(void)
1293 {
1294         m_UpdateCurrentSongInfo();
1295 }
1296
1297
1298 void CPlaybackView::OnStopPlayback(void)
1299 {
1300 }
1301
1302
1303 void CPlaybackView::OnEmptyPlaylist(void)
1304 {
1305         eina_list_free(m->elInfo);
1306         m->elInfo = NULL;
1307         elm_genlist_clear(m->eoPlaylist);
1308         m_UpdateEmptySongInfo();
1309 }
1310
1311
1312 void CPlaybackView::OnPlayerModeChanged(EPlayerMode mode)
1313 {
1314         switch (mode) {
1315         case MODE_PLAYLIST_EDIT:
1316                 m_FromPlaybackToEditMode();
1317                 break;
1318
1319         case MODE_PLAYBACK:
1320                 m_FromEditToPlaybackMode();
1321                 break;
1322
1323         default:
1324                 ASSERT(!"Invalid Player Mode");
1325                 break;
1326         }
1327 }
1328
1329
1330 void CPlaybackView::OnEditButtonsPressed(EPlayerEditBtns editBtns)
1331 {
1332         switch (editBtns) {
1333         case EDIT_BTN_CANCEL:
1334                 m_DisableCheckAll(m->elInfo);
1335                 m_DisableEditButtons(true);
1336                 break;
1337
1338         case EDIT_BTN_DESELECT:
1339                 m_DisableCheckAll(m->elInfo);
1340                 m_DisableEditButtons(true);
1341                 elm_genlist_realized_items_update(m->eoPlaylist);
1342                 break;
1343
1344         case EDIT_BTN_DELETE:
1345                 m_DeleteSelectedItems();
1346                 break;
1347
1348         default:
1349                 ASSERT(!"Invalid Edit Button");
1350                 break;
1351         }
1352 }