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