src/views/playback-view.cpp

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