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