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