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