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