src/views/playback-view.cpp

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