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