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