src/views/playback-view.cpp

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