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 <Elementary.h>
  18 #include <Eina.h>
  19
  20 #include "AppCommon.h"
  21 #include <InputHandler.h>
  22
  23 #include "define.h"
  24 #include "common.h"
  25 #include "dbg.h"
  26 #include "song_info.h"
  27 #include "album_info.h"
  28 #include "music-controller.h"
  29 #include "volume-control.h"
  30 #include "i18n.h"
  31 #include "common-ui.h"
  32 #include "BaseView.h"
  33 #include "ViewMgr.h"
  34 #include "playback-view.h"
  35 #include "context-view.h"
  36 #include "HandleVolume.h"
  37 #include <app-res-defines.h>
  38 #include "PlaySettingCtxPopup.h"
  39 #include "Info.h"
  40
  41
  42 #define ARRAY_SIZE(array)       (sizeof(array) / sizeof(array[0]))
  43 #define TITLE_FONT_SIZE         50
  44 #define ARTIST_FONT_SIZE        30
  45 #define TOTAL_CONTROL_BTNS      6
  46 #define TOTAL_EDIT_BTNS         3
  47 #define S_INTERVAL              1       /* seconds */
  48 #define LP_INTERVAL             0.5     /* seconds */
  49 #define WAIT_INTERVAL           0.5     /* seconds */
  50 #define SLIDER_STEP             5000    /* milli seconds */
  51 #define LP_CHANGE               10000   /* milli seconds */
  52 #define S_INCREMENT             1000    /* milli seconds */
  53
  54
  55 ////////////////////////////////////////////////////////////////////////////////
  56 //
  57 struct SSliderWidget {
  58         Evas_Object *eoSlider;
  59         Evas_Object *eoBase;
  60
  61         Ecore_Timer *etSlider;
  62
  63         CSongInfo *pSongInfo;
  64
  65         CMusicController controller;
  66
  67         SSliderWidget() {
  68                 eoSlider = NULL;
  69                 eoBase = NULL;
  70                 etSlider = NULL;
  71                 pSongInfo = NULL;
  72         }
  73 };
  74
  75
  76 Eina_Bool CSliderWidget::sm_CbUpdateSlider(void *dt)
  77 {
  78         CSliderWidget *root = (CSliderWidget*)dt;
  79         Eina_Bool ret = ECORE_CALLBACK_CANCEL;
  80
  81         if (root)
  82                 ret = root->m_OnUpdateSlider();
  83
  84         return ret;
  85 }
  86
  87
  88 Eina_Bool CSliderWidget::m_OnUpdateSlider(void)
  89 {
  90         char *timestr = NULL;
  91         int value;
  92         int duration;
  93
  94         if (!m->controller.GetPosition(&value)) {
  95                 m->etSlider = NULL;
  96                 return ECORE_CALLBACK_CANCEL;
  97         }
  98
  99         m_UpdateSongInfo();
 100
 101         duration = m->pSongInfo->Duration();
 102
 103         value = value + S_INCREMENT;
 104         if (value > duration) {
 105                 m->etSlider = NULL;
 106                 return ECORE_CALLBACK_CANCEL;
 107         }
 108
 109         elm_slider_value_set(m->eoSlider, value);
 110         timestr = CCommonUI::TimeStrFromMilSeconds(value);
 111         if (timestr) {
 112                 elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
 113                         timestr);
 114                 free(timestr);
 115         }
 116
 117         return ECORE_CALLBACK_RENEW;
 118 }
 119
 120
 121 bool CSliderWidget::m_AddSlider(void)
 122 {
 123         Evas_Object *eoSlider = NULL;
 124
 125         eoSlider = elm_slider_add(m->eoBase);
 126         if (!eoSlider)
 127                 return false;
 128
 129         elm_slider_indicator_show_set(eoSlider, EINA_FALSE);
 130         elm_slider_indicator_show_on_focus_set(eoSlider, EINA_FALSE);
 131         elm_object_style_set(eoSlider, MUSIC_STYLE_SLIDER);
 132         elm_slider_horizontal_set(eoSlider, EINA_TRUE);
 133         elm_object_part_content_set(m->eoBase, MUSIC_PART_PROGRESSBAR, eoSlider);
 134
 135         Connect(eoSlider, TYPE_CHANGED | TYPE_MOUSE_MOVE);
 136
 137         evas_object_show(eoSlider);
 138         m->eoSlider = eoSlider;
 139
 140         return true;
 141 }
 142
 143
 144 void CSliderWidget::m_RemoveTimer(void)
 145 {
 146         if (m->etSlider) {
 147                 ecore_timer_del(m->etSlider);
 148                 m->etSlider = NULL;
 149         }
 150 }
 151
 152
 153 void CSliderWidget::m_UpdateSongInfo(void)
 154 {
 155         CSongInfo *sinfo = NULL;
 156         int index;
 157
 158         if (!m->controller.GetCurrentSongIndex(&index)) {
 159                 _ERR(" music get current song index failed ");
 160                 return;
 161         }
 162
 163         if (!m->controller.GetSonginfoFromIndex(index, &sinfo)) {
 164                 _ERR(" music get songinfo failed ");
 165                 return;
 166         }
 167         m->pSongInfo = sinfo;
 168 }
 169
 170
 171 bool CSliderWidget::Create(Evas_Object *eoBase)
 172 {
 173         ASSERT(!m);
 174
 175         _CREATE_BEGIN{
 176                 _CHECK(m = new SSliderWidget)
 177                 _COMMAND{ m->eoBase = eoBase; }
 178                 _CHECK(m->controller.Create())
 179                 _CHECK(m->controller.AddListener(this))
 180                 _CHECK(m_AddSlider())
 181
 182                 _CHECK_FAIL{}
 183                 _CHECK_FAIL{ m->controller.RemoveListener(this); }
 184                 _CHECK_FAIL{ m->controller.Destroy(); }
 185                 _CHECK_FAIL{ delete m; m = NULL; }
 186         } _CREATE_END_AND_CATCH{ return false; }
 187
 188         return true;
 189 }
 190
 191
 192 void CSliderWidget::Destroy(void)
 193 {
 194         ASSERT(m);
 195
 196         m->controller.RemoveListener(this);
 197         m_RemoveTimer();
 198
 199         delete m;
 200         m = NULL;
 201 }
 202
 203
 204 Evas_Object* CSliderWidget::Base(void)
 205 {
 206         ASSERT(m);
 207
 208         return m->eoSlider;
 209 }
 210
 211
 212 void CSliderWidget::Init(void)
 213 {
 214         elm_object_disabled_set(m->eoSlider, EINA_TRUE);
 215         elm_slider_value_set(m->eoSlider, 0);
 216 }
 217
 218
 219 void CSliderWidget::OnComplete(void)
 220 {
 221 }
 222
 223
 224 void CSliderWidget::OnStartPlayback(void)
 225 {
 226         int duration;
 227         char *timestr = NULL;
 228         double step;
 229
 230         elm_slider_value_set(m->eoSlider, 0);
 231         elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
 232
 233         elm_object_disabled_set(m->eoSlider, EINA_FALSE);
 234
 235         m_UpdateSongInfo();
 236         duration = m->pSongInfo->Duration();
 237
 238         m_RemoveTimer();
 239         m->etSlider = ecore_timer_add(S_INTERVAL, sm_CbUpdateSlider, this);
 240
 241         elm_slider_min_max_set(m->eoSlider, 0, duration);
 242         timestr = CCommonUI::TimeStrFromMilSeconds(duration);
 243         if (timestr) {
 244                 elm_object_part_text_set(m->eoBase,
 245                         MUSIC_PART_FULLTIME, timestr);
 246                 free(timestr);
 247         }
 248
 249         step = (double)SLIDER_STEP / (double)duration;
 250         elm_slider_step_set(m->eoSlider, step);
 251 }
 252
 253
 254 void CSliderWidget::OnStopPlayback(void)
 255 {
 256         elm_slider_value_set(m->eoSlider, 0);
 257         elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
 258
 259         elm_object_disabled_set(m->eoSlider, EINA_TRUE);
 260         m_RemoveTimer();
 261 }
 262
 263
 264 void CSliderWidget::OnPausePlayback(void)
 265 {
 266         if (m->etSlider)
 267                 ecore_timer_freeze(m->etSlider);
 268 }
 269
 270
 271 void CSliderWidget::OnResumePlayback(void)
 272 {
 273         if (m->etSlider)
 274                 ecore_timer_thaw(m->etSlider);
 275 }
 276
 277
 278 void CSliderWidget::OnPosition(int milsec)
 279 {
 280         elm_slider_value_set(m->eoSlider, milsec);
 281 }
 282
 283
 284 void CSliderWidget::OnChanged(int id, Evas_Object *obj)
 285 {
 286         char *timestr = NULL;
 287         int value;
 288
 289         if (m->controller.PlayState() == PLAY_STATUS_PLAY) {
 290                 if (m->etSlider)
 291                         ecore_timer_freeze(m->etSlider);
 292         }
 293
 294         value = elm_slider_value_get(obj);
 295         m->controller.SetPosition(value);
 296         timestr = CCommonUI::TimeStrFromMilSeconds(value);
 297         if (timestr) {
 298                 elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
 299                         timestr);
 300                 free(timestr);
 301         }
 302
 303         if (m->controller.PlayState() == PLAY_STATUS_PLAY) {
 304                 if (m->etSlider)
 305                         ecore_timer_thaw(m->etSlider);
 306         }
 307 }
 308
 309
 310 void CSliderWidget::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
 311 {
 312         if (!elm_object_focus_get(obj))
 313                 elm_object_focus_set(obj, EINA_TRUE);
 314 }
 315 //
 316 ////////////////////////////////////////////////////////////////////////////////
 317
 318
 319 struct STimer {
 320         int count;
 321         int s, e;
 322         struct SCookie {
 323                 Ecore_Timer *etTimer;
 324                 CTimer *root;
 325                 int     id;
 326                 SCookie(CTimer *timer, int _id) {
 327                         root = timer;
 328                         id = _id;
 329                 }
 330         };
 331
 332         Eina_List *elList;
 333 };
 334
 335
 336 Eina_Bool CTimer::sm_CbTimer(void *data)
 337 {
 338         STimer::SCookie *cookie = (STimer::SCookie*)data;
 339
 340         if (cookie->root)
 341                 cookie->root->t_OnTimer(cookie->id);
 342
 343         cookie->root->m->elList = eina_list_remove(cookie->root->m->elList, cookie);
 344
 345         delete cookie;
 346
 347         return EINA_FALSE;
 348 }
 349
 350
 351 void CTimer::t_OnTimer(int id)
 352 {
 353 }
 354
 355
 356 bool CTimer::Create(void)
 357 {
 358         ASSERT(!m);
 359
 360         m = new STimer;
 361         if (!m)
 362                 return false;
 363
 364         m->elList = NULL;
 365
 366         return true;
 367 }
 368
 369
 370 void CTimer::Destroy(void)
 371 {
 372         ASSERT(m);
 373
 374         delete m;
 375         m = NULL;
 376 }
 377
 378
 379 bool CTimer::SetTimer(int id, int ms)
 380 {
 381         ASSERT(m);
 382
 383
 384         STimer::SCookie *cookie = new STimer::SCookie(this, id);
 385         if (!cookie)
 386                 return false;
 387
 388         m->elList = eina_list_append(m->elList, cookie);
 389         cookie->etTimer = ecore_timer_add(ms, sm_CbTimer, cookie);
 390         return true;
 391 }
 392
 393
 394 void CTimer::KillTimer(int id)
 395 {
 396         ASSERT(m);
 397
 398
 399 }
 400
 401
 402
 403
 404
 405
 406 enum EEvasObject {
 407         EO_BASE,
 408
 409         EO_ERROR_POPUP_BUTTON,
 410
 411         EO_CANCEL,
 412         EO_DESELECT,
 413         EO_DELETE,           // TOTAL_EDIT_BTNS
 414
 415         EO_BTN_SETTINGS,
 416         EO_BTN_SHUFFLE,
 417         EO_BTN_REPEAT,
 418         EO_BTN_REWIND,
 419         EO_BTN_PLAY,
 420         EO_BTN_FORWARD,   // TOTAL_CONTROL_BTNS
 421
 422         EO_PLAYLIST,
 423 };
 424
 425
 426 struct SItemInfo {
 427         Elm_Object_Item *item;
 428         CSongInfo *sinfo;
 429         bool edit_mode;
 430         bool check_status;
 431         bool select_status;
 432 };
 433
 434
 435 enum EPressTypes {
 436         PRESS_SHORT,
 437         PRESS_SHORT_PAUSE,
 438         PRESS_LONG,
 439         PRESS_LONG_PAUSE,
 440 };
 441
 442
 443 struct SPlaybackView {
 444         Evas_Object *eoWin;
 445
 446         Evas_Object *eoBase;
 447         CPlaySettingCtxPopup *eoCtxPopup;
 448         Evas_Object *eoErrPopup;
 449         Evas_Object *eoPlaylist;
 450
 451         Elm_Object_Item *focused_item;
 452
 453         Evas_Object *eoBtnControl[TOTAL_CONTROL_BTNS];
 454         Evas_Object *eoBtnEdit[TOTAL_EDIT_BTNS];
 455
 456         Evas_Object *eoAlbumCover;
 457         CSliderWidget *pSliderWidget;
 458         Evas_Object *eoPressedObj;
 459
 460         Eina_List   *elInfo;
 461         Ecore_Timer *etLongPress;
 462         Ecore_Timer *etWait;
 463         CMusicController *pController; //! NOT NULL
 464         CSongInfo *csinfo;
 465         CViewMgr *mgr;
 466         SItemInfo *cs_itinfo;
 467         SContentInfo *ctxtinfo;
 468         EPressTypes press_status;
 469
 470         CHandleVolume *pHandleVolume;
 471
 472         SPlaybackView() {
 473                 memset(this, 0, sizeof(SPlaybackView));
 474         }
 475         ~SPlaybackView() {
 476         }
 477 };
 478
 479 struct SBtnInfo {
 480         const char *txt;
 481         const char *part;
 482         EEvasObject type;
 483 };
 484
 485
 486 enum EControlBtns {
 487         BTN_SETTINGS,
 488         BTN_SHUFFLE,
 489         BTN_REPEAT,
 490         BTN_REWIND,
 491         BTN_PLAY,
 492         BTN_FORWARD
 493 };
 494
 495 enum ESettingBtns {
 496         BTN_EDIT,
 497         BTN_CLEAR
 498 };
 499
 500 enum EEditBtns {
 501         BTN_CANCEL,
 502         BTN_DESELECT,
 503         BTN_DELETE
 504 };
 505
 506 enum ETimers {
 507         TIMER_WAIT,
 508         TIMER_LONGPRESS,
 509         TIMER_VOLUME
 510 };
 511
 512
 513
 514 Eina_Bool CPlaybackView::sm_CbLongpressTimer(void *dt)
 515 {
 516         CPlaybackView *root = (CPlaybackView *)dt;
 517         if (root)
 518                 root->m_OnLongpressTimer();
 519
 520         return ECORE_CALLBACK_RENEW;
 521 }
 522
 523
 524 void CPlaybackView::m_OnLongpressTimer(void)
 525 {
 526         m_HandleOnRepeated();
 527 }
 528
 529
 530 Eina_Bool CPlaybackView::sm_CbWaitTimer(void *dt)
 531 {
 532         CPlaybackView *root = (CPlaybackView *)dt;
 533         if (root)
 534                 root->m_OnWaitTimer();
 535
 536         return ECORE_CALLBACK_CANCEL;
 537 }
 538
 539
 540 void CPlaybackView::m_OnWaitTimer(void)
 541 {
 542         m->press_status = PRESS_LONG;
 543         if (m->pController->PlayState() == PLAY_STATUS_PLAY) {
 544                 /* Handle long press */
 545                 m_PlaybackPause();
 546                 m->etLongPress = ecore_timer_add(LP_INTERVAL, sm_CbLongpressTimer, this);
 547         }
 548         else {
 549                 m->press_status = PRESS_LONG_PAUSE;
 550         }
 551
 552         m->etWait = NULL;
 553 }
 554
 555
 556 void CPlaybackView::sm_CbCtxtUpdate(void *dt, enum EActionType type, int lid)
 557 {
 558         CPlaybackView *root = (CPlaybackView *)dt;
 559         if (root)
 560                 root->m_OnCtxtUpdate(type, lid);
 561 }
 562
 563
 564 void CPlaybackView::m_OnCtxtUpdate(EActionType type, int lid)
 565 {
 566         SItemInfo *itinfo = NULL;
 567         Elm_Object_Item *focusedItem = NULL;
 568
 569         if (!m->ctxtinfo || !m->ctxtinfo->context)
 570                 return;
 571
 572         itinfo = m_FindItemInfoFromSong(m->elInfo,
 573                 (CSongInfo *)m->ctxtinfo->context);
 574         if (!itinfo) {
 575                 _ERR(" Unable to find song in the list ");
 576                 return;
 577         }
 578
 579         if (type == ACTION_TYPE_DELETE) {
 580                 itinfo->check_status = true;
 581                 m_DeleteSelectedItems();
 582
 583                 if (!m->mgr->PopView()) {
 584                         _ERR("CViewMgr::PopView failed");
 585                         return;
 586                 }
 587
 588                 SParcel parcel;
 589                 memset(&parcel, 0, sizeof(SParcel));
 590                 parcel.updateType = E_PLAYLIST_UPDATE;
 591                 t_OnUpdate(&parcel);
 592
 593                 focusedItem = m->cs_itinfo->item;
 594         }
 595         else { // ACTION_TYPE_PLAY
 596                 if (m->ctxtinfo->status == PLAY_STATUS_PLAY)
 597                         m_KeyPausePress();
 598                 else {
 599                         if (itinfo == m->cs_itinfo)
 600                                 m_KeyPlayPress();
 601                         else
 602                                 m_HandleGenlistItemActivated(m->eoPlaylist, itinfo->item);
 603                 }
 604
 605                 if (!m->mgr->PopView()) {
 606                         _ERR("CViewMgr::PopView failed");
 607                         return;
 608                 }
 609
 610                 focusedItem = m->focused_item;
 611         }
 612
 613         if (!CViewMgr::GetInstance()->HideView(MUSIC_BASE_VIEW))
 614                 _ERR("CViewMgr::HideView failed");
 615
 616         t_OnShow();
 617
 618         if (focusedItem) {
 619                 elm_genlist_item_show(focusedItem, ELM_GENLIST_ITEM_SCROLLTO_IN);
 620                 elm_object_item_focus_set(focusedItem, EINA_TRUE);
 621         }
 622 }
 623
 624
 625 void CPlaybackView::sm_CbCtxtClose(void *dt)
 626 {
 627         CPlaybackView *root = (CPlaybackView *)dt;
 628         if (root)
 629                 root->m_OnCtxtClose();
 630 }
 631
 632
 633 void CPlaybackView::m_OnCtxtClose(void)
 634 {
 635         if (!m->mgr->PopView()) {
 636                 _ERR("CViewMgr::PopView failed");
 637                 return;
 638         }
 639
 640         elm_object_item_focus_set(m->focused_item, EINA_TRUE);
 641 }
 642
 643
 644 void CPlaybackView::sm_CbCtxPopupBtnSelected(void* cookie, CCtxPopup* instance, const char* text)
 645 {
 646         CPlaybackView *root = (CPlaybackView *)cookie;
 647         if (root)
 648                 root->m_CbCtxPopupBtnSelected(instance, text);
 649 }
 650
 651
 652 void CPlaybackView::m_CbCtxPopupBtnSelected(CCtxPopup* instance, const char* text)
 653 {
 654         int type = CInfo::PlaybackSettingType();
 655
 656         switch (type) {
 657         case BTN_EDIT:
 658                 m_FromPlaybackToEditMode();
 659                 break;
 660
 661         case BTN_CLEAR:
 662                 m->pController->Stop();
 663                 m->pController->EmptyPlaylist();
 664                 eina_list_free(m->elInfo);
 665                 m->elInfo = NULL;
 666                 elm_genlist_clear(m->eoPlaylist);
 667                 m_UpdateEmptySongInfo();
 668                 break;
 669
 670         default:
 671                 break;
 672         }
 673 }
 674
 675
 676 void CPlaybackView::m_RemoveTimer(int timer_code)
 677 {
 678         ETimers timerCode = (ETimers)timer_code;
 679
 680         switch (timerCode) {
 681         case TIMER_WAIT:
 682                 if (m->etWait) {
 683                         ecore_timer_del(m->etWait);
 684                         m->etWait = NULL;
 685                 }
 686                 break;
 687
 688         case TIMER_LONGPRESS:
 689                 if (m->etLongPress) {
 690                         ecore_timer_del(m->etLongPress);
 691                         m->etLongPress = NULL;
 692                 }
 693                 break;
 694
 695         case TIMER_VOLUME:
 696                 m->pHandleVolume->RemoveTimer();
 697                 break;
 698
 699         default:
 700                 _ERR(" invalid value ");
 701                 break;
 702         }
 703 }
 704
 705
 706 void CPlaybackView::m_PlaybackPause(void)
 707 {
 708         m->pController->Pause();
 709 }
 710
 711
 712 void CPlaybackView::m_PlaybackResume(void)
 713 {
 714         m->pController->Resume();
 715 }
 716
 717
 718 void CPlaybackView::m_ChangeEditmodeAll(Eina_List *list, bool flag)
 719 {
 720         SItemInfo *itinfo = NULL;
 721         void *obj = NULL;
 722         Eina_List *l = NULL;
 723
 724         EINA_LIST_FOREACH(list, l, obj) {
 725                 itinfo = (SItemInfo *)obj;
 726                 itinfo->edit_mode = flag;
 727         }
 728 }
 729
 730
 731 void CPlaybackView::m_DisableCheckAll(Eina_List *list)
 732 {
 733         SItemInfo *itinfo = NULL;
 734         void *obj = NULL;
 735         Eina_List *l = NULL;
 736
 737         EINA_LIST_FOREACH(list, l, obj) {
 738                 itinfo = (SItemInfo *)obj;
 739                 itinfo->check_status = false;
 740         }
 741 }
 742
 743
 744 void CPlaybackView::m_SelectItem(SItemInfo *pItemInfo)
 745 {
 746         if (!pItemInfo || !pItemInfo->item)
 747                 return;
 748
 749         elm_genlist_item_bring_in(pItemInfo->item, ELM_GENLIST_ITEM_SCROLLTO_IN);
 750         elm_object_item_signal_emit(pItemInfo->item, MUSIC_SIGNAL_SELECT_ITEM, MUSIC_PLAYBACK_VIEW);
 751
 752         pItemInfo->select_status = true;
 753 }
 754
 755
 756 void CPlaybackView::m_UnselectItem(SItemInfo *pItemInfo)
 757 {
 758         if (!pItemInfo || !pItemInfo->item)
 759                 return;
 760
 761         elm_object_item_signal_emit(pItemInfo->item, MUSIC_SIGNAL_UNSELECT_ITEM,
 762                 MUSIC_PLAYBACK_VIEW);
 763
 764         pItemInfo->select_status = false;
 765 }
 766
 767
 768 void CPlaybackView::m_UpdateControlBtns(void)
 769 {
 770         int state;
 771
 772         state = m->pController->PlayState();
 773         switch (state) {
 774         case PLAY_STATUS_INITIAL:
 775                 // Initial State, Do nothing
 776                 break;
 777
 778         case PLAY_STATUS_STOP:
 779                 if (!m->eoErrPopup)
 780                         elm_object_focus_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
 781                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_TRUE);
 782                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_TRUE);
 783                 break;
 784
 785         case PLAY_STATUS_PLAY:
 786                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_FALSE);
 787                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_FALSE);
 788                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
 789                         MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
 790                 break;
 791
 792         case PLAY_STATUS_PAUSE:
 793                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_FALSE);
 794                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_FALSE);
 795                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
 796                         MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 797                 break;
 798
 799         default:
 800                 ASSERT(!"Invalid State");
 801                 break;
 802         }
 803
 804         state = m->pController->ShuffleState();
 805         switch (state) {
 806         case SHUFFLE_STATUS_OFF:
 807                 elm_object_signal_emit(m->eoBtnControl[BTN_SHUFFLE],
 808                         MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
 809                 break;
 810
 811         case SHUFFLE_STATUS_ON:
 812                 elm_object_signal_emit(m->eoBtnControl[BTN_SHUFFLE],
 813                         MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
 814                 break;
 815
 816         default:
 817                 ASSERT(!"Invalid State");
 818                 break;
 819         }
 820
 821         state = m->pController->RepeatState();
 822         switch (state) {
 823         case REPEAT_STATUS_NONE:
 824                 elm_object_signal_emit(m->eoBtnControl[BTN_REPEAT],
 825                         MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
 826                 break;
 827
 828         case REPEAT_STATUS_ALL:
 829                 elm_object_signal_emit(m->eoBtnControl[BTN_REPEAT],
 830                         MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
 831                 break;
 832
 833         case REPEAT_STATUS_ONE:
 834                 elm_object_signal_emit(m->eoBtnControl[BTN_REPEAT],
 835                         MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
 836                 break;
 837
 838         default:
 839                 ASSERT(!"Invalid State");
 840                 break;
 841         }
 842 }
 843
 844
 845 void CPlaybackView::m_UpdateCurrentSongThumbnail(void)
 846 {
 847         char *path = NULL;
 848         char buf[MAX_LENGTH];
 849
 850         if (!m->cs_itinfo || !m->cs_itinfo->sinfo)
 851                 return;
 852
 853         path = m->cs_itinfo->sinfo->ThumbnailPath();
 854         if (path)
 855                 elm_image_file_set(m->eoAlbumCover, path, NULL);
 856         else {
 857                 snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 858                         MUSIC_IMAGE_DEFAULT_THUMB_450);
 859                 elm_image_file_set(m->eoAlbumCover, buf, NULL);
 860         }
 861 }
 862
 863
 864 void CPlaybackView::m_UpdateCurrentSongLabels(void)
 865 {
 866         char buf[MAX_LENGTH];
 867
 868         if (!m->csinfo)
 869                 return;
 870
 871         elm_object_part_text_set(m->eoBase, MUSIC_PART_SONG_TITLE,
 872                 m->csinfo->Name());
 873
 874         snprintf(buf, sizeof(buf), "%s - %s", m->csinfo->Artist(),
 875                 m->csinfo->Album());
 876
 877         elm_object_part_text_set(m->eoBase, MUSIC_PART_ARTIST_ALBUM, buf);
 878 }
 879
 880
 881 void CPlaybackView::m_UpdateEmptySongInfo(void)
 882 {
 883         char buf[MAX_LENGTH];
 884
 885         elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
 886                 MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 887         elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
 888         elm_object_focus_next_object_set(m->eoBtnControl[BTN_REPEAT],
 889                 m->eoBtnControl[BTN_REPEAT], ELM_FOCUS_RIGHT);
 890         elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_TRUE);
 891         elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_TRUE);
 892         elm_object_disabled_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
 893         elm_object_part_text_set(m->eoBase, MUSIC_PART_FULLTIME, "00:00");
 894         elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
 895
 896         m->pSliderWidget->Init();
 897
 898         elm_object_part_text_set(m->eoBase, MUSIC_PART_SONG_TITLE,
 899                 _(NO_PLAYLIST_MESSAGE));
 900         elm_object_part_text_set(m->eoBase, MUSIC_PART_ARTIST_ALBUM,
 901                 _(NO_PLAYLIST_MESSAGE_SUB));
 902         snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 903                 MUSIC_IMAGE_DEFAULT_THUMB_450);
 904         elm_image_file_set(m->eoAlbumCover, buf, NULL);
 905         m->pController->SetPlayState(PLAY_STATUS_INITIAL);
 906 }
 907
 908
 909 void CPlaybackView::m_UpdateCtxtView(int playStatus)
 910 {
 911         if (!m->cs_itinfo || !m->ctxtinfo)
 912                 return;
 913
 914         if (!m->mgr->CheckTop(MUSIC_CONTEXT_VIEW))
 915                 return;
 916
 917         if (m->cs_itinfo->sinfo == m->ctxtinfo->context) {
 918                 m->ctxtinfo->status = (EPlayStatus)playStatus;
 919
 920                 SParcel parcel;
 921                 memset(&parcel, 0, sizeof(SParcel));
 922                 parcel.updateType = E_SONG_UPDATE;
 923                 m->mgr->UpdateView((const char *)MUSIC_CONTEXT_VIEW, &parcel);
 924         }
 925 }
 926
 927
 928 void CPlaybackView::m_UpdateCurrentSongItem(int index)
 929 {
 930         SItemInfo *pItemInfo = NULL;
 931
 932         if (m->cs_itinfo) {
 933                 m_UnselectItem(m->cs_itinfo);
 934                 m_UpdateCtxtView(PLAY_STATUS_PAUSE);
 935         }
 936
 937         pItemInfo = (SItemInfo *)eina_list_nth(m->elInfo, index);
 938
 939         if (pItemInfo) {
 940                 m->cs_itinfo = pItemInfo;
 941                 if (m->pController->PlayState() == PLAY_STATUS_STOP) {
 942                         elm_genlist_item_bring_in(pItemInfo->item,
 943                                 ELM_GENLIST_ITEM_SCROLLTO_IN);
 944                 }
 945                 else {
 946                         m_SelectItem(pItemInfo);
 947                         m_UpdateCtxtView(PLAY_STATUS_PLAY);
 948                 }
 949         }
 950 }
 951
 952
 953 void CPlaybackView::m_UpdateEditmodeFocusSequence(void)
 954 {
 955         elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnEdit[BTN_CANCEL], ELM_FOCUS_LEFT);
 956         elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL], m->eoPlaylist, ELM_FOCUS_RIGHT);
 957         elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoBtnEdit[BTN_CANCEL], ELM_FOCUS_DOWN);
 958 }
 959
 960
 961 void CPlaybackView::m_UpdatePlaymodeFocusSequence(void)
 962 {
 963         elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoPlaylist,             ELM_FOCUS_UP);
 964         elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoBtnControl[BTN_PLAY], ELM_FOCUS_DOWN);
 965         switch (m->pController->PlayState()) {
 966         case PLAY_STATUS_INITIAL:
 967                 // Do nothing
 968                 break;
 969
 970         case PLAY_STATUS_STOP:
 971                 elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnControl[BTN_PLAY], ELM_FOCUS_LEFT);
 972                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY], m->eoPlaylist, ELM_FOCUS_RIGHT);
 973                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY], m->eoBtnControl[BTN_REPEAT], ELM_FOCUS_LEFT);
 974                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_REPEAT], m->eoBtnControl[BTN_PLAY], ELM_FOCUS_RIGHT);
 975                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY], MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 976                 break;
 977
 978         case PLAY_STATUS_PLAY:
 979         case PLAY_STATUS_PAUSE:
 980                 elm_object_focus_next_object_set(m->eoPlaylist,
 981                         m->eoBtnControl[BTN_FORWARD], ELM_FOCUS_LEFT);
 982                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_FORWARD],
 983                         m->eoPlaylist, ELM_FOCUS_RIGHT);
 984                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY],
 985                         m->eoBtnControl[BTN_FORWARD], ELM_FOCUS_RIGHT);
 986                 break;
 987
 988         default:
 989                 ASSERT(!"Invalid State");
 990                 break;
 991         }
 992 }
 993
 994
 995 void CPlaybackView::m_UpdateCurrentSongInfo(void)
 996 {
 997         CSongInfo *sinfo = NULL;
 998         int index;
 999
1000         if (eina_list_count(m->elInfo) == 0) {
1001                 m_UpdateEmptySongInfo();
1002                 return;
1003         }
1004
1005         if (!m->pController->GetCurrentSongIndex(&index)) {
1006                 _ERR(" music get current song index failed ");
1007                 return;
1008         }
1009
1010         if (!m->pController->GetSonginfoFromIndex(index, &sinfo)) {
1011                 _ERR(" music get songinfo failed ");
1012                 return;
1013         }
1014         m->csinfo = sinfo;
1015
1016         m_UpdateCurrentSongItem(index);
1017         m_UpdateCurrentSongLabels();
1018         m_UpdateCurrentSongThumbnail();
1019         m_UpdateControlBtns();
1020         m_UpdatePlaymodeFocusSequence();
1021 }
1022
1023
1024 void CPlaybackView::m_DisableEditButtons(bool flag)
1025 {
1026         /* flag - 1 means disable edit buttons and 0 means enable */
1027         if (flag)
1028                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1029
1030         elm_object_disabled_set(m->eoBtnEdit[BTN_DELETE], (Eina_Bool)flag);
1031         elm_object_disabled_set(m->eoBtnEdit[BTN_DESELECT], (Eina_Bool)flag);
1032         if (flag) {
1033                 m_UpdateEditmodeFocusSequence();
1034                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1035         }
1036         else {
1037                 elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL], m->eoBtnEdit[BTN_DESELECT], ELM_FOCUS_RIGHT);
1038                 elm_object_focus_next_object_set(m->eoBtnEdit[BTN_DELETE], m->eoPlaylist,              ELM_FOCUS_RIGHT);
1039                 elm_object_focus_next_object_set(m->eoPlaylist,            m->eoBtnEdit[BTN_DELETE],   ELM_FOCUS_LEFT);
1040         }
1041 }
1042
1043
1044 void CPlaybackView::m_CreateErrorPopup(void)
1045 {
1046         Evas_Object *popup = NULL, *btn = NULL, *label = NULL;
1047
1048         popup = elm_popup_add(m->eoBase);
1049         if (!popup)
1050                 return;
1051
1052         elm_object_style_set(popup, MUSIC_STYLE_ERROR_POPUP);
1053         evas_object_show(popup);
1054
1055         label = elm_label_add(popup);
1056         if (!label) {
1057                 evas_object_del(popup);
1058                 return;
1059         }
1060
1061         elm_object_style_set(label, MUSIC_STYLE_ERROR_LABEL);
1062         elm_object_text_set(label, MUSIC_TEXT_PLAYBACK_ERROR);
1063         elm_object_content_set(popup, label);
1064
1065         btn = elm_button_add(popup);
1066         if (!btn) {
1067                 evas_object_del(popup);
1068                 return;
1069         }
1070
1071         elm_object_style_set(btn, MUSIC_STYLE_EDIT_BTN);
1072         elm_object_text_set(btn, MUSIC_TEXT_OK);
1073         elm_object_part_content_set(popup, MUSIC_PART_POPUP_BUTTON, btn);
1074
1075         m->eoErrPopup = popup;
1076
1077         Connect(btn, EO_ERROR_POPUP_BUTTON, TYPE_CLICKED | TYPE_KEY_DOWN);
1078
1079         elm_object_focus_set(btn, EINA_TRUE);
1080
1081         return;
1082 }
1083
1084
1085 void CPlaybackView::m_DestroyErrorPopup(void)
1086 {
1087         if (!m->eoErrPopup)
1088                 return;
1089
1090         evas_object_del(m->eoErrPopup);
1091         m->eoErrPopup = NULL;
1092 }
1093
1094
1095 void CPlaybackView::m_CreateSettingsPopup(void)
1096 {
1097         CCtxPopup::SCallback cb;
1098         cb.cookie = this;
1099         cb.onSelected = sm_CbCtxPopupBtnSelected;
1100
1101         m->eoCtxPopup = new CPlaySettingCtxPopup;
1102         m->eoCtxPopup->Create(m->eoWin, &cb);
1103 }
1104
1105
1106 void CPlaybackView::m_DestroySettingsPopup(void)
1107 {
1108         if (!m->eoCtxPopup)
1109                 return;
1110
1111         if (m->eoCtxPopup->FlagCreate())
1112                 m->eoCtxPopup->Destroy();
1113
1114         delete m->eoCtxPopup;
1115         m->eoCtxPopup = NULL;
1116 }
1117
1118
1119 void CPlaybackView::m_FromEditToPlaybackMode(void)
1120 {
1121         if (m->pController->PlayState() == PLAY_STATUS_STOP) {
1122                 elm_genlist_item_bring_in(m->cs_itinfo->item,
1123                         ELM_GENLIST_ITEM_SCROLLTO_IN);
1124         }
1125         else
1126                 m_SelectItem(m->cs_itinfo);
1127
1128         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE,
1129                 MUSIC_PLAYBACK_VIEW);
1130         elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
1131
1132         m_ChangeEditmodeAll(m->elInfo, false);
1133
1134         elm_genlist_realized_items_update(m->eoPlaylist);
1135
1136         m_UpdatePlaymodeFocusSequence();
1137 }
1138
1139
1140 void CPlaybackView::m_FromPlaybackToEditMode(void)
1141 {
1142         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_EDIT_MODE,
1143                 MUSIC_PLAYBACK_VIEW);
1144
1145         m_DisableEditButtons(true);
1146
1147         elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1148
1149         m_ChangeEditmodeAll(m->elInfo, true);
1150
1151         elm_genlist_realized_items_update(m->eoPlaylist);
1152
1153         m_UpdateEditmodeFocusSequence();
1154 }
1155
1156
1157 void CPlaybackView::m_HandleOnRepeated(void)
1158 {
1159         Evas_Object *obj = NULL;
1160         int value;
1161         int duration;
1162         char *timestr = NULL;
1163
1164         if (!m->eoPressedObj)
1165                 return;
1166
1167         obj = m->eoPressedObj;
1168
1169
1170         m->pController->GetPosition(&value);
1171         duration = m->cs_itinfo->sinfo->Duration();
1172
1173         if (obj == m->eoBtnControl[BTN_REWIND]) {
1174                 if (value == 0) {
1175                         m_RemoveTimer(TIMER_LONGPRESS);
1176                         return;
1177                 }
1178                 value = value - LP_CHANGE;
1179                 if (value <= 0)
1180                         value = 0;
1181         }
1182         else {
1183                 if (value == duration) {
1184                         m->pController->PlayNextSong();
1185
1186                         m->press_status = PRESS_LONG_PAUSE;
1187                         elm_object_signal_emit(m->eoBtnControl[BTN_PLAY], MUSIC_SIGNAL_PAUSE,
1188                                 MUSIC_PLAYBACK_VIEW);
1189                         m_PlaybackPause();
1190                         m_RemoveTimer(TIMER_LONGPRESS);
1191
1192                         return;
1193                 }
1194                 value = value + LP_CHANGE;
1195                 if (value >= duration)
1196                         value = duration;
1197         }
1198
1199         m->pController->SetPosition(value);
1200         timestr = CCommonUI::TimeStrFromMilSeconds(value);
1201         if (timestr) {
1202                 elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
1203                         timestr);
1204                 free(timestr);
1205         }
1206
1207         return;
1208 }
1209
1210
1211 void CPlaybackView::m_DeleteSelectedItems(void)
1212 {
1213         Eina_List *l = NULL, *l_next = NULL;
1214         SItemInfo *pItemInfo = NULL;
1215         void *obj = NULL;
1216         bool updateFlag = false;
1217         int index;
1218
1219         m_DisableEditButtons(true);
1220         EINA_LIST_FOREACH_SAFE(m->elInfo, l, l_next, obj) {
1221                 pItemInfo = (SItemInfo *)obj;
1222                 if (pItemInfo->check_status) {
1223                         if (m->cs_itinfo == pItemInfo) {
1224                                 updateFlag = true;
1225                                 m_UnselectItem(m->cs_itinfo);
1226                                 m->cs_itinfo = NULL;
1227                                 m->pController->SetPlayState(PLAY_STATUS_STOP);
1228                                 m->pController->Stop();
1229                         }
1230                         index = elm_genlist_item_index_get(pItemInfo->item);
1231                         m->pController->RemoveSong(pItemInfo->sinfo, index);
1232
1233                         m->elInfo = eina_list_remove(m->elInfo, pItemInfo);
1234                         elm_object_item_del(pItemInfo->item);
1235                 }
1236         }
1237
1238         if (eina_list_count(m->elInfo) == 0) {
1239                 m_UpdateEmptySongInfo();
1240                 elm_genlist_realized_items_update(m->eoPlaylist);
1241                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1242                 return;
1243         }
1244
1245         if (updateFlag)
1246                 m_UpdateCurrentSongInfo();
1247
1248         elm_genlist_realized_items_update(m->eoPlaylist);
1249         elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1250 }
1251
1252
1253 void CPlaybackView::m_KeyBackPress(void)
1254 {
1255         if (m->eoCtxPopup) {
1256                 m_DestroySettingsPopup();
1257                 elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
1258                 return;
1259         }
1260
1261         t_OnHide();
1262
1263         if (!CViewMgr::GetInstance()->ShowView(MUSIC_BASE_VIEW))
1264                 _ERR("CViewMgr::ShowView failed");
1265
1266         if (CViewMgr::GetInstance()->CheckTop(MUSIC_CONTEXT_VIEW)) {
1267                 if (!CViewMgr::GetInstance()->UpdateView(MUSIC_CONTEXT_VIEW, NULL))
1268                         _ERR("CViewMgr::UpdateView failed");
1269
1270                 if (!CViewMgr::GetInstance()->ShowView(MUSIC_CONTEXT_VIEW))
1271                         _ERR("CViewMgr::ShowView failed");
1272         }
1273 }
1274
1275
1276 void CPlaybackView::m_KeyExitPress(void)
1277 {
1278         m->pController->Stop();
1279         elm_exit();
1280 }
1281
1282
1283 void CPlaybackView::m_KeyPlayPress(void)
1284 {
1285         int state;
1286
1287         if (elm_object_disabled_get(m->eoBtnControl[BTN_PLAY]))
1288                 return;
1289
1290         state = m->pController->PlayState();
1291         if (state == PLAY_STATUS_PAUSE) {
1292                 m_PlaybackResume();
1293                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
1294                         MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
1295         }
1296         else if (state != PLAY_STATUS_PLAY) {
1297                 m->pController->Start();
1298         }
1299 }
1300
1301
1302 void CPlaybackView::m_KeyPausePress(void)
1303 {
1304         int state;
1305
1306         if (elm_object_disabled_get(m->eoBtnControl[BTN_PLAY]))
1307                 return;
1308
1309         state = m->pController->PlayState();
1310         if (state == PLAY_STATUS_PLAY) {
1311                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
1312                         MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
1313                 m_PlaybackPause();
1314         }
1315 }
1316
1317
1318 void CPlaybackView::m_KeyNextPress(void)
1319 {
1320         if (elm_object_disabled_get(m->eoBtnControl[BTN_FORWARD]))
1321                 return;
1322
1323         m_HandleOnPressed(m->eoBtnControl[BTN_FORWARD]);
1324 }
1325
1326
1327 void CPlaybackView::m_KeyPreviousPress(void)
1328 {
1329         if (elm_object_disabled_get(m->eoBtnControl[BTN_REWIND]))
1330                 return;
1331
1332         m_HandleOnPressed(m->eoBtnControl[BTN_REWIND]);
1333 }
1334
1335
1336 void CPlaybackView::m_KeyNextUnpress(void)
1337 {
1338         if (elm_object_disabled_get(m->eoBtnControl[BTN_FORWARD]))
1339                 return;
1340
1341         m_HandleOnUnpressed(m->eoBtnControl[BTN_FORWARD]);
1342 }
1343
1344
1345 void CPlaybackView::m_KeyPreviousUnpress(void)
1346 {
1347         if (elm_object_disabled_get(m->eoBtnControl[BTN_REWIND]))
1348                 return;
1349
1350         m_HandleOnUnpressed(m->eoBtnControl[BTN_REWIND]);
1351 }
1352
1353
1354 void CPlaybackView::m_HandleKeyPress(char *keyname)
1355 {
1356         if (!strcmp(keyname, (char *)KEY_EXIT))
1357                 m_KeyExitPress();
1358         else if (!strcmp(keyname, (char *)KEY_BACK) ||
1359                 !strcmp(keyname, (char *)KEY_BACK_REMOTE))
1360                 m_KeyBackPress();
1361         else if (!strcmp(keyname, (char *)KEY_PLAY))
1362                 m_KeyPlayPress();
1363         else if (!strcmp(keyname, (char *)KEY_PAUSE))
1364                 m_KeyPausePress();
1365         else if (!strcmp(keyname, (char *)KEY_NEXT))
1366                 m_KeyNextPress();
1367         else if (!strcmp(keyname, (char *)KEY_PREVIOUS))
1368                 m_KeyPreviousPress();
1369         else if (!strcmp(keyname, (char *)KEY_VOLUMEUP))
1370                 m->pHandleVolume->Up();
1371         else if (!strcmp(keyname, (char *)KEY_VOLUMEDOWN))
1372                 m->pHandleVolume->Down();
1373         else if (!strcmp(keyname, (char *)KEY_MUTE))
1374                 m->pHandleVolume->Mute();
1375 }
1376
1377
1378 void CPlaybackView::m_HandleKeyUnpress(char *keyname)
1379 {
1380         if (!strcmp(keyname, KEY_PREVIOUS))
1381                 m_KeyPreviousUnpress();
1382         else if (!strcmp(keyname, KEY_NEXT))
1383                 m_KeyNextUnpress();
1384 }
1385
1386
1387 void CPlaybackView::m_AddAlbumCover(void)
1388 {
1389         Evas_Object *eoAlbumCover = NULL;
1390
1391         eoAlbumCover = elm_image_add(m->eoBase);
1392         if (!eoAlbumCover)
1393                 return;
1394
1395         evas_object_size_hint_weight_set(eoAlbumCover, EVAS_HINT_EXPAND,
1396                         EVAS_HINT_EXPAND);
1397         elm_image_aspect_fixed_set(eoAlbumCover, EINA_FALSE);
1398
1399         elm_object_part_content_set(m->eoBase, MUSIC_PART_ALBUMCOVER,
1400                         eoAlbumCover);
1401         evas_object_show(eoAlbumCover);
1402         m->eoAlbumCover = eoAlbumCover;
1403
1404 }
1405
1406
1407 void CPlaybackView::m_AddCurrentSonginfo(void)
1408 {
1409         m_AddAlbumCover();
1410
1411         m->pSliderWidget = new CSliderWidget;
1412         m->pSliderWidget->Create(m->eoBase);
1413 }
1414
1415
1416 void CPlaybackView::m_AddEditPlaylistButtons(void)
1417 {
1418         Evas_Object *box = NULL;
1419         int i;
1420         SBtnInfo btninfo[TOTAL_EDIT_BTNS];
1421
1422         btninfo[BTN_CANCEL].txt = MUSIC_TEXT_CANCEL;
1423         btninfo[BTN_CANCEL].type = EO_CANCEL;
1424
1425         btninfo[BTN_DESELECT].txt = MUSIC_TEXT_DESELECT;
1426         btninfo[BTN_DESELECT].type = EO_DESELECT;
1427
1428         btninfo[BTN_DELETE].txt = MUSIC_TEXT_DELETE;
1429         btninfo[BTN_DELETE].type = EO_DELETE;
1430
1431         box = CCommonUI::AddBox(m->eoBase);
1432         if (!box)
1433                 return;
1434
1435         elm_box_horizontal_set(box, EINA_TRUE);
1436         elm_box_padding_set(box, MUSIC_EDIT_BTNS_PADDING * elm_config_scale_get(), 0);
1437
1438         for (i = 0; i < TOTAL_EDIT_BTNS; i++) {
1439                 m->eoBtnEdit[i] = elm_button_add(m->eoBase);
1440                 if (!m->eoBtnEdit[i])
1441                         continue;
1442
1443                 elm_object_style_set(m->eoBtnEdit[i], MUSIC_STYLE_EDIT_BTN);
1444                 evas_object_size_hint_weight_set(m->eoBtnEdit[i], EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1445                 elm_box_pack_end(box, m->eoBtnEdit[i]);
1446                 elm_object_text_set(m->eoBtnEdit[i], _(btninfo[i].txt));
1447
1448                 Connect(m->eoBtnEdit[i], btninfo[i].type, TYPE_CLICKED | TYPE_MOUSE_MOVE);
1449
1450                 evas_object_show(m->eoBtnEdit[i]);
1451         }
1452         elm_object_part_content_set(m->eoBase, MUSIC_PART_EDITBTNS, box);
1453         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE, MUSIC_PLAYBACK_VIEW);
1454 }
1455
1456
1457 void CPlaybackView::m_AddControlButtons(void)
1458 {
1459         Evas_Object *box = NULL;
1460         int i;
1461         SBtnInfo btninfo[TOTAL_CONTROL_BTNS];
1462
1463         btninfo[BTN_SETTINGS].txt = MUSIC_STYLE_BTN_SETTINGS;
1464         btninfo[BTN_SETTINGS].type = EO_BTN_SETTINGS;
1465
1466         btninfo[BTN_SHUFFLE].txt = MUSIC_STYLE_BTN_SHUFFLE;
1467         btninfo[BTN_SHUFFLE].type = EO_BTN_SHUFFLE;
1468
1469         btninfo[BTN_REPEAT].txt = MUSIC_STYLE_BTN_REPEAT;
1470         btninfo[BTN_REPEAT].type = EO_BTN_REPEAT;
1471
1472         btninfo[BTN_REWIND].txt = MUSIC_STYLE_BTN_REWIND;
1473         btninfo[BTN_REWIND].type = EO_BTN_REWIND;
1474
1475         btninfo[BTN_PLAY].txt = MUSIC_STYLE_BTN_PLAY;
1476         btninfo[BTN_PLAY].type = EO_BTN_PLAY;
1477
1478         btninfo[BTN_FORWARD].txt = MUSIC_STYLE_BTN_FORWARD;
1479         btninfo[BTN_FORWARD].type = EO_BTN_FORWARD;
1480
1481         box = elm_box_add(m->eoBase);
1482         if (!box)
1483                 return;
1484
1485         evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, 0);
1486         evas_object_size_hint_align_set(box, EVAS_HINT_FILL, 0);
1487         elm_box_horizontal_set(box, EINA_TRUE);
1488         elm_box_padding_set(box,
1489                 MUSIC_CONTROL_BTNS_PADDING * elm_config_scale_get(), 0);
1490
1491         for (i = 0; i < TOTAL_CONTROL_BTNS; i++) {
1492                 m->eoBtnControl[i] = elm_button_add(m->eoBase);
1493                 if (!m->eoBtnControl[i])
1494                         continue;
1495
1496                 elm_object_style_set(m->eoBtnControl[i], btninfo[i].txt);
1497                 evas_object_size_hint_weight_set(m->eoBtnControl[i],
1498                         EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1499                 elm_box_pack_end(box, m->eoBtnControl[i]);
1500
1501                 if (i == BTN_REWIND || i == BTN_FORWARD) {
1502                         Connect(m->eoBtnControl[i], btninfo[i].type, TYPE_PRESSED | TYPE_UNPRESSED | TYPE_MOUSE_MOVE);
1503                 }
1504                 else {
1505                         Connect(m->eoBtnControl[i], btninfo[i].type, TYPE_CLICKED | TYPE_MOUSE_MOVE);
1506                 }
1507                 evas_object_show(m->eoBtnControl[i]);
1508         }
1509
1510         elm_object_part_content_set(m->eoBase, MUSIC_PART_CONTROLBTNS, box);
1511 }
1512
1513
1514 SItemInfo *CPlaybackView::m_FindItemInfoFromSong(Eina_List *list, CSongInfo *sinfo)
1515 {
1516         Eina_List *l = NULL;
1517         SItemInfo *itinfo = NULL;
1518         void *obj = NULL;
1519
1520         EINA_LIST_FOREACH(list, l, obj) {
1521                 itinfo = (SItemInfo *)obj;
1522                 if (itinfo->sinfo == sinfo)
1523                         return itinfo;
1524         }
1525
1526         return NULL;
1527 }
1528
1529
1530 SItemInfo *CPlaybackView::m_FindItemInfoFromItem(Eina_List *list, Elm_Object_Item *item)
1531 {
1532         Eina_List *l = NULL;
1533         SItemInfo *itinfo = NULL;
1534         void *obj = NULL;
1535
1536         EINA_LIST_FOREACH(list, l, obj) {
1537                 itinfo = (SItemInfo *)obj;
1538                 if (itinfo->item == item)
1539                         return itinfo;
1540         }
1541
1542         return NULL;
1543 }
1544
1545
1546 void CPlaybackView::m_UpdateItemCheck(SItemInfo *itinfo)
1547 {
1548         if (!itinfo) {
1549                 _ERR(" No item info to Update check ");
1550                 return;
1551         }
1552
1553         if (itinfo->check_status) {
1554                 elm_object_item_signal_emit(itinfo->item,
1555                         MUSIC_SIGNAL_CHECK_OFF, MUSIC_PLAYBACK_VIEW);
1556                 itinfo->check_status = false;
1557                 return;
1558         }
1559
1560         elm_object_item_signal_emit(itinfo->item,
1561                 MUSIC_SIGNAL_CHECK_ON, MUSIC_PLAYBACK_VIEW);
1562         itinfo->check_status = true;
1563 }
1564
1565
1566 class CElmGenlistItemClass {
1567 public:
1568         static char *sm_CbTextGet(void *data, Evas_Object *obj, const char *part)
1569         {
1570                 CSongInfo *sinfo = NULL;
1571                 SItemInfo *pItemInfo = (SItemInfo *)data;
1572                 char buf[MAX_LENGTH];
1573                 char *timestr = NULL;
1574                 int duration;
1575                 int index;
1576
1577                 if (!pItemInfo || !obj)
1578                         return NULL;
1579
1580                 sinfo = pItemInfo->sinfo;
1581
1582                 snprintf(buf, sizeof(buf), "%s", MUSIC_STR_EMPTY);
1583
1584                 if (!strcmp(part, "elm.text0")) {
1585                         index = elm_genlist_item_index_get(pItemInfo->item);
1586                         snprintf(buf, sizeof(buf), "%d", index);
1587                 }
1588                 else if (!strcmp(part, "elm.text1"))
1589                         snprintf(buf, sizeof(buf), "%s", sinfo->Name());
1590                 else if (!strcmp(part, "elm.text2"))
1591                         snprintf(buf, sizeof(buf), "%s - %s",
1592                         sinfo->Artist(),
1593                         sinfo->Album());
1594                 else if (!strcmp(part, "elm.text3")) {
1595                         duration = sinfo->Duration();
1596                         timestr = CCommonUI::TimeStrFromMilSeconds(duration);
1597                         if (timestr) {
1598                                 snprintf(buf, sizeof(buf), "%s", timestr);
1599                                 free(timestr);
1600                         }
1601                 }
1602
1603                 if (strcmp(buf, MUSIC_STR_EMPTY))
1604                         return strdup(buf);
1605
1606                 return NULL;
1607         }
1608         static Evas_Object *sm_CbContentGet(void *data, Evas_Object *obj, const char *part)
1609         {
1610                 CSongInfo *sinfo = NULL;
1611                 SItemInfo *pItemInfo = (SItemInfo *)data;
1612                 Evas_Object *img = NULL;
1613                 char *path = NULL;
1614                 char buf[MAX_LENGTH];
1615
1616                 if (!pItemInfo || !obj)
1617                         return NULL;
1618
1619                 sinfo = pItemInfo->sinfo;
1620
1621                 img = elm_image_add(obj);
1622                 if (!img)
1623                         return NULL;
1624
1625                 elm_image_aspect_fixed_set(img, EINA_FALSE);
1626
1627                 if (!strcmp(part, "elm.swallow.icon")) {
1628                         path = sinfo->ThumbnailPath();
1629                         if (path)
1630                                 elm_image_file_set(img, path, "NULL");
1631                         else {
1632                                 snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
1633                                         MUSIC_IMAGE_DEFAULT_THUMB_126);
1634                                 elm_image_file_set(img, buf, "NULL");
1635                         }
1636                 }
1637
1638                 return img;
1639
1640         }
1641         static void         sm_CbDel(void *data, Evas_Object *obj)
1642         {
1643                 free(data);
1644         }
1645 };
1646
1647
1648 Elm_Genlist_Item_Class *CPlaybackView::m_GetItemClass(void)
1649 {
1650         Elm_Genlist_Item_Class *list_item = NULL;
1651
1652         list_item = elm_genlist_item_class_new();
1653         if (!list_item) {
1654                 _ERR(" elm_genlist_item_class_new failed ");
1655                 return NULL;
1656         }
1657
1658         list_item->item_style       = MUSIC_STYLE_PLAYLIST;
1659         list_item->func.text_get    = CElmGenlistItemClass::sm_CbTextGet;
1660         list_item->func.content_get = CElmGenlistItemClass::sm_CbContentGet;
1661         list_item->func.state_get   = NULL;
1662         list_item->func.del         = CElmGenlistItemClass::sm_CbDel;
1663
1664         return list_item;
1665 }
1666
1667
1668 void CPlaybackView::m_AddGenlist(void)
1669 {
1670         Evas_Object *genlist = NULL;
1671         Evas_Object *eoBase = NULL;
1672
1673         eoBase = m->eoBase;
1674         genlist = elm_genlist_add(eoBase);
1675         if (!genlist)
1676                 return;
1677
1678         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
1679         evas_object_size_hint_weight_set(genlist,
1680                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1681         elm_object_part_content_set(eoBase, MUSIC_PART_PLAYLIST, genlist);
1682         elm_genlist_select_mode_set(genlist, ELM_OBJECT_SELECT_MODE_ALWAYS);
1683         elm_genlist_multi_select_set(genlist, EINA_FALSE);
1684
1685         Connect(genlist, EO_PLAYLIST, TYPE_REALIZED | TYPE_MOUSE_MOVE |
1686                 TYPE_KEY_DOWN | TYPE_ACTIVATED);
1687
1688         evas_object_show(genlist);
1689         m->eoPlaylist = genlist;
1690 }
1691
1692
1693 void CPlaybackView::m_AddPlaylist(void)
1694 {
1695         Elm_Genlist_Item_Class *list_item = NULL;
1696         int ts = 0;
1697         int i, index = -1;
1698         CSongInfo *sinfo = NULL;
1699         Elm_Object_Item *item = NULL;
1700         SItemInfo *pItemInfo = NULL;
1701
1702         m_AddGenlist();
1703         if (!m->eoPlaylist)
1704                 return;
1705
1706         list_item = m_GetItemClass();
1707         if (!list_item) {
1708                 evas_object_del(m->eoPlaylist);
1709                 return;
1710         }
1711
1712         if (!m->pController->GetTotalSongs(&ts)) {
1713                 _ERR(" music get total songs failed ");
1714                 return;
1715         }
1716
1717         if (!m->pController->GetCurrentSongIndex(&index))
1718                 _ERR(" music get current song index failed ");
1719
1720         for (i = 0; i < ts; i++) {
1721                 if (!m->pController->GetSonginfoFromIndex(i, &sinfo)) {
1722                         _ERR(" music get songinfo failed ");
1723                         continue;
1724                 }
1725                 pItemInfo = (SItemInfo *)calloc(1, sizeof(*pItemInfo));
1726                 if (!pItemInfo)
1727                         return;
1728                 pItemInfo->sinfo = sinfo;
1729                 pItemInfo->edit_mode = false;
1730                 pItemInfo->check_status = false;
1731                 pItemInfo->select_status = false;
1732
1733                 // event handling will be done in OnActivated function
1734                 item = elm_genlist_item_append(m->eoPlaylist, list_item,
1735                         pItemInfo, NULL, ELM_GENLIST_ITEM_NONE,
1736                         NULL, m);
1737                 pItemInfo->item = item;
1738
1739                 if (i == index) {
1740                         pItemInfo->select_status = true;
1741                         m->cs_itinfo = pItemInfo;
1742                 }
1743                 m->elInfo = eina_list_append(m->elInfo, pItemInfo);
1744         }
1745 }
1746
1747
1748 void CPlaybackView::m_RemovePlaylist(void)
1749 {
1750         if (m->eoPlaylist) {
1751                 elm_genlist_clear(m->eoPlaylist);
1752                 m->eoPlaylist = NULL;
1753         }
1754
1755         if (m->elInfo) {
1756                 eina_list_free(m->elInfo);
1757                 m->elInfo = NULL;
1758         }
1759 }
1760
1761
1762 void CPlaybackView::m_HandleRewindBtnClicked(Evas_Object *obj)
1763 {
1764         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
1765                 MUSIC_PLAYBACK_VIEW);
1766
1767         if (m->pController->PlayState() == PLAY_STATUS_STOP)
1768                 return;
1769
1770         if (!m->pController->PlayPreviousSong()){
1771                 _ERR(" music play previous song failed ");
1772                 return;
1773         }
1774 }
1775
1776
1777 void CPlaybackView::m_HandleForwardBtnClicked(Evas_Object *obj)
1778 {
1779         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
1780                 MUSIC_PLAYBACK_VIEW);
1781
1782         if (m->pController->PlayState() == PLAY_STATUS_STOP)
1783                 return;
1784
1785         if (!m->pController->PlayNextSong()) {
1786                 _ERR(" music play next song failed ");
1787                 return;
1788         }
1789 }
1790
1791
1792 void CPlaybackView::m_HandleOnPressed(Evas_Object *obj)
1793 {
1794         m->press_status = PRESS_SHORT;
1795         m->eoPressedObj = obj;
1796
1797         m->etWait = ecore_timer_add(WAIT_INTERVAL, sm_CbWaitTimer, this);
1798 }
1799
1800
1801 void CPlaybackView::m_HandleOnUnpressed(Evas_Object *obj)
1802 {
1803         m_RemoveTimer(TIMER_WAIT);
1804         m_RemoveTimer(TIMER_LONGPRESS);
1805
1806         if (m->press_status == PRESS_SHORT) {
1807                 /* Handle song change */
1808                 if (m->pController->PlayState() == PLAY_STATUS_PLAY)
1809                         m_PlaybackPause();
1810
1811                 if (obj == m->eoBtnControl[BTN_FORWARD])
1812                         m_HandleForwardBtnClicked(obj);
1813                 else
1814                         m_HandleRewindBtnClicked(obj);
1815
1816                 if (m->pController->PlayState() != PLAY_STATUS_PLAY)
1817                         m_PlaybackResume();
1818         }
1819         else if (m->press_status == PRESS_LONG) {
1820                 if (m->pController->PlayState() != PLAY_STATUS_PLAY)
1821                         m_PlaybackResume();
1822         }
1823
1824         m->press_status = PRESS_SHORT;
1825 }
1826
1827
1828 void CPlaybackView::m_HandleGenlistItemActivated(Evas_Object *obj, Elm_Object_Item *genListItem)
1829 {
1830         int index;
1831         SItemInfo *itinfo = NULL;
1832
1833         if (!obj || !genListItem)
1834                 return;
1835
1836         itinfo = m_FindItemInfoFromItem(m->elInfo, genListItem);
1837         if (!itinfo) {
1838                 _ERR(" no item info found ");
1839                 return;
1840         }
1841
1842         if (itinfo->edit_mode) {
1843                 m_UpdateItemCheck(itinfo);
1844                 m_DisableEditButtons(false);
1845                 return;
1846         }
1847
1848         index = elm_genlist_item_index_get(genListItem);
1849
1850         m->pController->PlayIndexSong(--index);
1851 }
1852
1853
1854 bool CPlaybackView::Create(void *data)
1855 {
1856         ASSERT(!m);
1857
1858         _CREATE_BEGIN{
1859                 _CHECK(m = new SPlaybackView)
1860                 _CHECK(m->mgr = CViewMgr::GetInstance())
1861                 _CHECK(m->eoWin = m->mgr->Window())
1862                 _CHECK(m->pController = new CMusicController)
1863                 _CHECK(m->pController->Create())
1864                 _CHECK(m->eoBase = CCommonUI::AddBase(m->eoWin, MUSIC_PLAYBACK_VIEW))
1865                 _CHECK(CBaseView::Create(data))
1866                 _CHECK(CTimer::Create());
1867                 _CHECK(m->pController->AddListener(this))
1868
1869                 _WHEN_SUCCESS{
1870                         m->press_status = PRESS_SHORT;
1871                         evas_object_data_set(m->eoBase, PLAYBACK_VIEW_DATA, m);
1872
1873                         m_AddControlButtons();
1874                         m_AddEditPlaylistButtons();
1875                         m_AddCurrentSonginfo();
1876                         m_AddPlaylist();
1877
1878                         m->pHandleVolume = new CHandleVolume;
1879                         m->pHandleVolume->Create(m->eoBase);
1880                         m_UpdatePlaymodeFocusSequence();
1881
1882                         Connect(m->eoBase, EO_BASE, TYPE_KEY_DOWN | TYPE_KEY_UP);
1883                 }
1884
1885                 _CHECK_FAIL{ m->pController->RemoveListener(this); }
1886                 _CHECK_FAIL{ CTimer::Destroy(); }
1887                 _CHECK_FAIL{ CBaseView::Destroy(); }
1888                 _CHECK_FAIL{ evas_object_del(m->eoBase); }
1889                 _CHECK_FAIL{ m->pController->Destroy(); }
1890                 _CHECK_FAIL{ delete m->pController; }
1891                 _CHECK_FAIL{ /* mgr->Window() */ }
1892                 _CHECK_FAIL{ /* CViewerMgr::GetInstance() */}
1893                 _CHECK_FAIL{ delete m; m = NULL; }
1894         }_CREATE_END_AND_CATCH{ return false; }
1895
1896         return true;
1897 }
1898
1899
1900 void CPlaybackView::Destroy(void)
1901 {
1902         ASSERT(m);
1903
1904         Disconnect(m->eoBase);
1905         m->pController->RemoveListener(this);
1906
1907         m_DestroyErrorPopup();
1908
1909         m->pSliderWidget->Destroy();
1910
1911         m_RemoveTimer(TIMER_WAIT);
1912         m_RemoveTimer(TIMER_LONGPRESS);
1913         m_DestroySettingsPopup();
1914
1915         m->pHandleVolume->Destroy();
1916         delete m->pHandleVolume;
1917         CBaseView::Destroy();
1918         evas_object_del(m->eoBase);
1919
1920         free(m->ctxtinfo);
1921         delete m;
1922         m = NULL;
1923 }
1924
1925
1926 Evas_Object* CPlaybackView::Base(void)
1927 {
1928         ASSERT(m);
1929
1930         return m->eoBase;
1931 }
1932
1933
1934 void CPlaybackView::t_OnClickedSettings(Evas_Object *obj)
1935 {
1936         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1937
1938         if (eina_list_count(m->elInfo) == 0)
1939                 return;
1940
1941         elm_object_signal_emit(obj, MUSIC_SIGNAL_CONTROL_SELECTED, MUSIC_PLAYBACK_VIEW);
1942         m_DestroySettingsPopup();
1943         m_CreateSettingsPopup();
1944 }
1945
1946
1947 void CPlaybackView::t_OnClickedShuffle(Evas_Object *obj)
1948 {
1949         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1950
1951         switch (m->pController->ShuffleState()) {
1952         case SHUFFLE_STATUS_OFF:
1953                 m->pController->SetShuffleState(SHUFFLE_STATUS_ON);
1954                 elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
1955                 break;
1956
1957         default:
1958                 m->pController->SetShuffleState(SHUFFLE_STATUS_OFF);
1959                 elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
1960                 break;
1961         }
1962 }
1963
1964
1965 void CPlaybackView::t_OnClickedRepeat(Evas_Object *obj)
1966 {
1967         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1968
1969         switch (m->pController->RepeatState()) {
1970         case REPEAT_STATUS_NONE:
1971                 m->pController->SetRepeatState(REPEAT_STATUS_ALL);
1972                 elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
1973                 break;
1974
1975         case REPEAT_STATUS_ALL:
1976                 m->pController->SetRepeatState(REPEAT_STATUS_ONE);
1977                 elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
1978                 break;
1979
1980         default:
1981                 m->pController->SetRepeatState(REPEAT_STATUS_NONE);
1982                 elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
1983                 break;
1984         }
1985 }
1986
1987
1988 void CPlaybackView::t_OnClickedPlay(Evas_Object *obj)
1989 {
1990         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1991
1992         switch (m->pController->PlayState()) {
1993         case PLAY_STATUS_PAUSE:
1994                 m_PlaybackResume();
1995                 elm_object_signal_emit(obj, MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
1996                 break;
1997
1998         case PLAY_STATUS_PLAY:
1999                 elm_object_signal_emit(obj, MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
2000                 m_PlaybackPause();
2001                 break;
2002
2003         default:
2004                 if (m->pController)
2005                         m->pController->Start();
2006                 break;
2007         }
2008 }
2009
2010
2011 void CPlaybackView::t_OnShow(void)
2012 {
2013         ASSERT(m);
2014
2015         int state;
2016
2017         m_UpdateCurrentSongInfo();
2018
2019         state = m->pController->PlayState();
2020         if (state == PLAY_STATUS_INITIAL || state == PLAY_STATUS_STOP) {
2021                 m_RemovePlaylist();
2022                 m_AddPlaylist();
2023                 m->pController->Start();
2024         }
2025
2026         if (m->cs_itinfo) {
2027                 elm_genlist_item_show(m->cs_itinfo->item, ELM_GENLIST_ITEM_SCROLLTO_IN);
2028                 elm_object_item_focus_set(m->cs_itinfo->item, EINA_TRUE);
2029         }
2030
2031         evas_object_show(m->eoBase);
2032 }
2033
2034
2035 void CPlaybackView::t_OnUpdate(void *data)
2036 {
2037         ASSERT(m);
2038
2039         SParcel *parcel = (SParcel *)data;
2040         int updateType;
2041         char *keyEvent = NULL;
2042
2043         if (!parcel)
2044                 updateType = E_PLAYLIST_UPDATE;
2045         else {
2046                 updateType = parcel->updateType;
2047                 keyEvent = (char *)parcel->keyEvent;
2048         }
2049
2050         switch (updateType) {
2051         case E_PLAYLIST_UPDATE:
2052                 m_RemovePlaylist();
2053                 m_AddPlaylist();
2054                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_FALSE);
2055                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_FALSE);
2056                 elm_object_disabled_set(m->eoBtnControl[BTN_PLAY], EINA_FALSE);
2057                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_REPEAT],
2058                         m->eoBtnControl[BTN_REWIND], ELM_FOCUS_RIGHT);
2059                 m_FromEditToPlaybackMode();
2060                 break;
2061
2062         case E_KEY_PRESS:
2063                 m_HandleKeyPress(keyEvent);
2064                 break;
2065
2066         case E_KEY_RELEASE:
2067                 m_HandleKeyUnpress(keyEvent);
2068                 break;
2069
2070         default:
2071                 break;
2072         }
2073 }
2074
2075
2076 void CPlaybackView::t_OnHide(void)
2077 {
2078         ASSERT(m);
2079
2080         evas_object_hide(m->eoBase);
2081 }
2082
2083
2084 void CPlaybackView::OnKeyDown(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Down *ev)
2085 {
2086         switch (id) {
2087         case EO_BASE:
2088                 m_HandleKeyPress(ev->keyname);
2089                 break;
2090
2091         case EO_ERROR_POPUP_BUTTON:
2092                 if (!strcmp(ev->keyname, KEY_BACK) ||
2093                         !strcmp(ev->keyname, KEY_BACK_REMOTE)) {
2094                         m_DestroyErrorPopup();
2095                         elm_object_focus_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
2096                 }
2097                 break;
2098
2099         case EO_PLAYLIST:
2100                 {
2101                         Elm_Object_Item *it = NULL;
2102                         SContentInfo *ctxtinfo = NULL;
2103                         SItemInfo *itinfo = NULL;
2104
2105                         if (strcmp(ev->keyname, KEY_MENU) &&
2106                                 strcmp(ev->keyname, KEY_MENU_REMOTE))
2107                                 return;
2108
2109                         it = elm_object_focused_item_get(obj);
2110                         if (!it) {
2111                                 _ERR(" unable to get focused item ");
2112                                 return;
2113                         }
2114                         m->focused_item = it;
2115
2116                         if (m->ctxtinfo) {
2117                                 free(m->ctxtinfo);
2118                                 m->ctxtinfo = NULL;
2119                         }
2120
2121                         ctxtinfo = (SContentInfo *)calloc(1, sizeof(*ctxtinfo));
2122                         if (!ctxtinfo)
2123                                 return;
2124
2125                         itinfo = m_FindItemInfoFromItem(m->elInfo, it);
2126                         if (!itinfo) {
2127                                 free(ctxtinfo);
2128                                 return;
2129                         }
2130
2131                         if (m->pController->PlayState() == PLAY_STATUS_PLAY &&
2132                                 itinfo == m->cs_itinfo)
2133                                 ctxtinfo->status = PLAY_STATUS_PLAY;
2134                         else
2135                                 ctxtinfo->status = PLAY_STATUS_PAUSE;
2136
2137                         ctxtinfo->cbdata = this;
2138                         ctxtinfo->update = sm_CbCtxtUpdate;
2139                         ctxtinfo->close = sm_CbCtxtClose;
2140                         ctxtinfo->type = CONTEXT_TYPE_PLAYSONG;
2141                         ctxtinfo->context = itinfo->sinfo;
2142
2143                         m->ctxtinfo = ctxtinfo;
2144
2145                         SParcel parcel;
2146                         memset(&parcel, 0, sizeof(SParcel));
2147                         parcel.ctxtInfo = ctxtinfo;
2148                         if (!m->mgr->PushView(MUSIC_CONTEXT_VIEW, &parcel))
2149                                 _ERR("viewmgr push view MUSIC_CONTEXT_VIEW failed");
2150                 }
2151
2152         default:
2153                 break;
2154         }
2155 }
2156
2157
2158 void CPlaybackView::OnKeyUp(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Up *ev)
2159 {
2160         switch (id) {
2161         case EO_BASE:
2162                 m_HandleKeyUnpress(ev->keyname);
2163                 break;
2164
2165         default:
2166                 break;
2167         }
2168 }
2169
2170
2171 void CPlaybackView::OnMouseClicked(int id, Evas_Object *obj)
2172 {
2173         switch (id) {
2174         case EO_ERROR_POPUP_BUTTON:
2175                 m_DestroyErrorPopup();
2176                 elm_object_focus_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
2177                 break;
2178
2179         case EO_CANCEL:
2180                 m_DisableCheckAll(m->elInfo);
2181                 m_DisableEditButtons(true);
2182                 m_FromEditToPlaybackMode();
2183                 break;
2184
2185         case EO_DESELECT:
2186                 m_DisableCheckAll(m->elInfo);
2187                 m_DisableEditButtons(true);
2188                 elm_genlist_realized_items_update(m->eoPlaylist);
2189                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
2190                 break;
2191
2192         case EO_DELETE:
2193                 m_DeleteSelectedItems();
2194                 break;
2195
2196         case EO_BTN_SETTINGS:
2197                 t_OnClickedSettings(obj);
2198                 break;
2199
2200         case EO_BTN_SHUFFLE:
2201                 t_OnClickedShuffle(obj);
2202                 break;
2203
2204         case EO_BTN_REPEAT:
2205                 t_OnClickedRepeat(obj);
2206                 break;
2207
2208         case EO_BTN_PLAY:
2209                 t_OnClickedPlay(obj);
2210                 break;
2211
2212         default:
2213                 break;
2214         }
2215 }
2216
2217
2218 void CPlaybackView::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
2219 {
2220         switch (id) {
2221         case EO_CANCEL:
2222         case EO_DESELECT:
2223         case EO_DELETE:
2224         case EO_BTN_FORWARD:
2225         case EO_BTN_PLAY:
2226         case EO_BTN_REPEAT:
2227         case EO_BTN_REWIND:
2228         case EO_BTN_SETTINGS:
2229         case EO_BTN_SHUFFLE:
2230                 if (!elm_object_focus_get(obj))
2231                         elm_object_focus_set(obj, EINA_TRUE);
2232                 break;
2233
2234         case EO_PLAYLIST:
2235                 {
2236                         Elm_Object_Item *item;
2237
2238                         item = elm_genlist_at_xy_item_get(obj, ev->cur.canvas.x,
2239                                 ev->cur.canvas.y, NULL);
2240                         if (!item)
2241                                 return;
2242
2243                         if (!elm_object_item_focus_get(item))
2244                                 elm_object_item_focus_set(item, EINA_TRUE);
2245                 }
2246                 break;
2247
2248         default:
2249                 break;
2250         }
2251 }
2252
2253
2254 void CPlaybackView::OnPressed(int id, Evas_Object *obj)
2255 {
2256         switch (id) {
2257         case EO_BTN_FORWARD:
2258         case EO_BTN_REWIND:
2259                 m_HandleOnPressed(obj);
2260                 break;
2261
2262         default:
2263                 break;
2264         }
2265 }
2266
2267
2268 void CPlaybackView::OnUnpressed(int id, Evas_Object *obj)
2269 {
2270         switch (id) {
2271         case EO_BTN_FORWARD:
2272         case EO_BTN_REWIND:
2273                 m_HandleOnUnpressed(obj);
2274                 break;
2275
2276         default:
2277                 break;
2278         }
2279 }
2280
2281
2282 void CPlaybackView::OnRealized(int id, Evas_Object *obj, Elm_Object_Item *item)
2283 {
2284         switch (id) {
2285         case EO_PLAYLIST:
2286                 {
2287                         int index = elm_genlist_item_index_get(item);
2288                         if ((index & 1) == 1)
2289                                 elm_object_item_signal_emit(item,
2290                                         MUSIC_SIGNAL_EVEN_ROW, MUSIC_PLAYBACK_VIEW);
2291                         else
2292                                 elm_object_item_signal_emit(item,
2293                                         MUSIC_SIGNAL_ODD_ROW, MUSIC_PLAYBACK_VIEW);
2294
2295                         SItemInfo *itInfo = m_FindItemInfoFromItem(m->elInfo, item);
2296                         if (itInfo->select_status)
2297                                 elm_object_item_signal_emit(item,
2298                                         MUSIC_SIGNAL_SELECT_ITEM, MUSIC_PLAYBACK_VIEW);
2299                         else
2300                                 elm_object_item_signal_emit(item,
2301                                         MUSIC_SIGNAL_UNSELECT_ITEM, MUSIC_PLAYBACK_VIEW);
2302
2303                         if (itInfo->edit_mode) {
2304                                 elm_object_item_signal_emit(item,
2305                                         MUSIC_SIGNAL_EDITMODE_ON, MUSIC_PLAYBACK_VIEW);
2306                                 if (itInfo->check_status) {
2307                                         elm_object_item_signal_emit(item,
2308                                                 MUSIC_SIGNAL_CHECK_ON, MUSIC_PLAYBACK_VIEW);
2309                                 }
2310                                 else
2311                                         elm_object_item_signal_emit(item,
2312                                                 MUSIC_SIGNAL_CHECK_OFF, MUSIC_PLAYBACK_VIEW);
2313                         }
2314                         else
2315                                 elm_object_item_signal_emit(item,
2316                                         MUSIC_SIGNAL_EDITMODE_OFF, MUSIC_PLAYBACK_VIEW);
2317                 }
2318                 break;
2319
2320         default:
2321                 break;
2322         }
2323 }
2324
2325
2326 void CPlaybackView::OnActivated(int id, Evas_Object *obj, Elm_Object_Item *item)
2327 {
2328         switch (id) {
2329         case EO_PLAYLIST:
2330                 m_HandleGenlistItemActivated(obj, item);
2331                 break;
2332
2333         default:
2334                 break;
2335         }
2336 }
2337
2338
2339 void CPlaybackView::OnComplete(void)
2340 {
2341         m_UpdateCurrentSongInfo();
2342 }
2343
2344
2345 void CPlaybackView::OnError(void)
2346 {
2347         m_CreateErrorPopup();
2348 }
2349
2350
2351 void CPlaybackView::OnUsbStatusChanged(SUsbStorageStatus status)
2352 {
2353 }
2354
2355
2356 void CPlaybackView::OnUpdateContent(void)
2357 {
2358 }
2359
2360
2361 void CPlaybackView::OnStartPlayback(void)
2362 {
2363         m_UpdateCurrentSongInfo();
2364 }
2365
2366
2367 void CPlaybackView::OnStopPlayback(void)
2368 {
2369 }