src/MpPlaylistContentListForm.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
   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 /**
  18  * @file                MpPlaylistContentListForm.cpp
  19  * @brief               This is the implementation file for PlaylistContentListForm class.
  20  */
  21
  22 #include <FSocial.h>
  23 #include "MpMusicPlayerApp.h"
  24 #include "MpNowPlayContentPanel.h"
  25 #include "MpPlaylistContentListForm.h"
  26 #include "MpPlaylistListPresentationModel.h"
  27 #include "MpPlaylistPickerPopup.h"
  28 #include "MpSharePopup.h"
  29 #include "MpThumbnailInfo.h"
  30
  31 using namespace Tizen::App;
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Content;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Io;
  37 using namespace Tizen::Social;
  38 using namespace Tizen::Ui;
  39 using namespace Tizen::Ui::Controls;
  40 using namespace Tizen::Ui::Scenes;
  41
  42 PlaylistContentListForm::PlaylistContentListForm(void)
  43         : ContentListForm::ContentListForm()
  44         , ThumbnailBase::ThumbnailBase()
  45         , __pContentListTableView(null)
  46         , __pThumbnail(null)
  47         , __pPresentationModel(null)
  48         , __checkedItemCount(0)
  49         , __currentContentType(-1)
  50         , __activatedStateContextItem(-1)
  51 {
  52         AppLogDebug("ENTER");
  53         AppLogDebug("EXIT");
  54 }
  55
  56 PlaylistContentListForm::~PlaylistContentListForm(void)
  57 {
  58         AppLogDebug("ENTER");
  59         AppLogDebug("EXIT");
  60 }
  61
  62 result
  63 PlaylistContentListForm::Initialize(void)
  64 {
  65         AppLogDebug("ENTER");
  66         if (IsFailed(Form::Construct(IDL_CONTENT_LIST_FORM)))
  67         {
  68                 AppLogDebug("Construct(IDL_CONTENT_LIST_FORM) failed(%s)", GetErrorMessage(GetLastResult()));
  69                 return false;
  70         }
  71
  72         AppLogDebug("EXIT");
  73         return Construct();
  74 }
  75
  76 result
  77 PlaylistContentListForm::Construct(void)
  78 {
  79         AppLogDebug("ENTER");
  80         __pContentListTableView = static_cast<TableView*>(GetControl(IDC_TABLEVIEW_CONTENT_LIST));
  81         __pContentListTableView->AddTableViewItemEventListener(*this);
  82         __pContentListTableView->SetItemProvider(this);
  83
  84         SetContentList(__pContentListTableView);
  85         AppLogDebug("EXIT");
  86         return ContentListForm::Construct();
  87 }
  88
  89 result
  90 PlaylistContentListForm::OnInitializing(void)
  91 {
  92         AppLogDebug("ENTER");
  93         __fontSizeValue = CommonUtil::GetFontSizeValue();
  94         __itemHeight = CommonUtil::GetItemHeight(__fontSizeValue);
  95         AppLogDebug("EXIT");
  96         return ThumbnailBase::Construct();
  97 }
  98
  99 result
 100 PlaylistContentListForm::OnTerminating(void)
 101 {
 102         AppLogDebug("ENTER");
 103         ThumbnailBase::Stop();
 104         AppLogDebug("EXIT");
 105         return ContentListForm::OnTerminating();
 106 }
 107
 108 void
 109 PlaylistContentListForm::OnActionPerformed(const Tizen::Ui::Control& source, int actionId)
 110 {
 111         AppLogDebug("ENTER");
 112         SceneManager* pSceneManager = SceneManager::GetInstance();
 113
 114         AppAssert(pSceneManager);
 115
 116         switch (actionId)
 117         {
 118         case IDA_HEADER_BUTTON_SELECTE_ALL:
 119                 {
 120                         bool isChecked = true;
 121                         if (__checkedItemCount == __pContentListTableView->GetItemCount())
 122                         {
 123                                 isChecked = false;
 124                         }
 125                         SetItemCheckedAll(isChecked);
 126                 }
 127                 break;
 128
 129         case IDA_CONTEXT_MENU_ITEM_SEARCH:
 130                 {
 131                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SEARCH, SCENE_TRANSITION_ANIMATION_TYPE_NONE, SCENE_HISTORY_OPTION_NO_HISTORY));
 132                 }
 133                 break;
 134
 135         case IDA_CONTEXT_MENU_ITEM_EDIT:
 136                 {
 137                         if (__pPresentationModel->GetContentCount() == 0)
 138                         {
 139                                 MessageBox messageBox;
 140                                 messageBox.Construct(L"", ResourceManager::GetString(L"IDS_MUSIC_HEADER_NO_SONGS"), MSGBOX_STYLE_NONE, 3000);
 141
 142                                 int modalResult = 0;
 143                                 messageBox.ShowAndWait(modalResult);
 144                         }
 145                         else
 146                         {
 147                                 ToggleScreenState(SCREEN_STATE_EDITOR);
 148                         }
 149                 }
 150                 break;
 151
 152         case IDA_CONTEXT_MENU_ITEM_SHARE_VIA:
 153                 {
 154                         if (__pPresentationModel->GetContentCount() == 0)
 155                         {
 156                                 MessageBox messageBox;
 157                                 messageBox.Construct(L"", ResourceManager::GetString(L"IDS_MUSIC_HEADER_NO_SONGS"), MSGBOX_STYLE_NONE, 3000);
 158
 159                                 int modalResult = 0;
 160                                 messageBox.ShowAndWait(modalResult);
 161                         }
 162                         else
 163                         {
 164                                 ToggleScreenState(SCREEN_STATE_SHARE_VIA);
 165 //                              LanucherPicker(PICKER_TYPE_SHARE_PICKER);
 166                         }
 167                 }
 168                 break;
 169
 170         case IDA_FOOTER_BUTTON_SHARE:
 171                 {
 172                         LanucherPicker(PICKER_TYPE_SHARE_PICKER);
 173                 }
 174                 break;
 175
 176         case IDA_FOOTER_BUTTON_ADD_TO_PLAYLIST:
 177                 {
 178                         LanucherPicker(PICKER_TYPE_PLAY_LIST_PICKER);
 179                 }
 180                 break;
 181
 182         case IDA_FOOTER_BUTTON_MORE:
 183                 {
 184                         CreateOptionMenuN(source);
 185                         SetOptionMenuItem(CONTEXT_MENU_ITEM_STYLE_SHARE_VIA | CONTEXT_MENU_ITEM_STYLE_EDIT);
 186                 }
 187                 break;
 188
 189         case IDA_FOOTER_BUTTON_DELETE:
 190                         {
 191                                 SetCommonPopup(CommonUtil::CreateContentDeletePopup(*this, IDA_COMMON_POPUP_DELETE, IDA_COMMON_POPUP_CANCEL),this);
 192                         }
 193                         break;
 194
 195         case IDA_COMMON_POPUP_DELETE:
 196                 {
 197                         if (__currentContentType == RECENTLY_ADDED_CONTENT)
 198                         {
 199                                 RemoveCheckedTableviewItem(true);
 200                         }
 201                         else
 202                         {
 203                                 int totalCount = __pPresentationModel->GetContentCount();
 204                                 for (int iCount = 0; iCount < totalCount; iCount++)
 205                                 {
 206                                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 207                                         {
 208                                                 ContentInformation* pContentInfoStruct = __pPresentationModel->GetContentInfoN(iCount);
 209                                                 __pContentListTableView->SetItemChecked(iCount, false);
 210                                                 __checkedItemCount--;
 211
 212                                                 if (pContentInfoStruct == null)
 213                                                 {
 214                                                         return;
 215                                                 }
 216                                                 //      __pContentListTableView->SetItemChecked(iCount, false);
 217                                                 __pPresentationModel->DeleteContent(__currentContentType, *pContentInfoStruct);
 218
 219                                                 delete pContentInfoStruct;
 220                                         }
 221                                 }
 222                                 RemoveCheckedTableviewItem(false);
 223                                 __pPresentationModel->UpdatePlaylistContentList(__currentContentType, __headerTitle);
 224                                 UpdateScreenState();
 225                                 UpdateTableView();
 226
 227                                 if(__pPresentationModel->GetContentCount() == 0)
 228                                 {
 229                                         ToggleScreenState(SCREEN_STATE_NORMAL);
 230                                 }
 231                         }
 232                 }
 233                 break;
 234
 235                 case IDA_COMMON_POPUP_CANCEL:
 236                         {
 237                                 //empty statement
 238                         }
 239                         break;
 240         /*case IDA_FOOTER_BUTTON_DELETE:
 241                 {
 242                         if (__currentContentType == RECENTLY_ADDED_CONTENT)
 243                         {
 244                                 RemoveCheckedTableviewItem(true);
 245                         }
 246                         else
 247                         {
 248                                 int totalCount = __pPresentationModel->GetContentCount();
 249                                 for (int iCount = 0; iCount < totalCount; iCount++)
 250                                 {
 251                                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 252                                         {
 253                                                 ContentInformation* pContentInfoStruct = __pPresentationModel->GetContentInfoN(iCount);
 254                                                 if (pContentInfoStruct == null)
 255                                                 {
 256                                                         return;
 257                                                 }
 258 //                                              __pContentListTableView->SetItemChecked(iCount, false);
 259                                                 __pPresentationModel->DeleteContent(__currentContentType, *pContentInfoStruct);
 260
 261                                                 delete pContentInfoStruct;
 262                                         }
 263                                 }
 264                                 RemoveCheckedTableviewItem(false);
 265                                 __pPresentationModel->UpdatePlaylistContentList(__currentContentType, __headerTitle);
 266                                 UpdateScreenState();
 267                                 UpdateTableView();
 268
 269                                 if(__pPresentationModel->GetContentCount() == 0)
 270                                 {
 271                                         ToggleScreenState(SCREEN_STATE_NORMAL);
 272                                 }
 273                         }
 274                 }
 275                 break;*/
 276
 277         default:
 278                 break;
 279         }
 280
 281         TryRemoveCommonPopup(actionId);
 282         TryRemoveContextMenu(actionId);
 283         AppLogDebug("EXIT");
 284 }
 285
 286 void
 287 PlaylistContentListForm::OnSceneActivatedN(const Tizen::Ui::Scenes::SceneId& previousSceneId,
 288                                         const Tizen::Ui::Scenes::SceneId& currentSceneId,
 289                                         Tizen::Base::Collection::IList* pArgs)
 290 {
 291         AppLogDebug("ENTER");
 292         if (pArgs != null && previousSceneId.Equals(IDSCN_PLAYLIST_LIST, true) == true)
 293         {
 294                 __headerTitle.Clear();
 295                 __prevSceneId.Clear();
 296                 __prevSceneId.Append(*static_cast<String*>(pArgs->GetAt(DATA_ITEM_SCENE_NAME)));
 297                 __headerTitle.Append(*static_cast<String*>(pArgs->GetAt(DATA_ITEM_CONTENT_NAME)));
 298                 __currentContentType = static_cast<Integer*>(pArgs->GetAt(DATA_ITEM_CONTENT_TYPE))->ToInt();
 299                 SetHeader();
 300                 pArgs->RemoveAll(true);
 301                 delete pArgs;
 302         }
 303         else if (pArgs != null && previousSceneId.Equals(IDSCN_PLAYLIST_CREATOR, true) == true)
 304         {
 305                 SetItemCheckedAll(false);
 306                 pArgs->RemoveAll(true);
 307                 delete pArgs;
 308         }
 309
 310         __pPresentationModel = PlaylistListPresentationModel::GetInstance();
 311         __pPresentationModel->UpdatePlaylistContentList(__currentContentType, __headerTitle);
 312         UpdateScreenState();
 313         if (__currentContentType < RECENTLY_ADDED_CONTENT || !previousSceneId.Equals(IDSCN_PLAYER,true))
 314         {
 315                 UpdateTableView();
 316         }
 317
 318         AppLogDebug("EXIT");
 319 }
 320
 321 void
 322 PlaylistContentListForm::OnSceneDeactivated(const Tizen::Ui::Scenes::SceneId& currentSceneId,
 323                                                                         const Tizen::Ui::Scenes::SceneId& nextSceneId)
 324 {
 325         AppLogDebug("ENTER");
 326         CancelAllThumbnailRequest();
 327         AppLogDebug("EXIT");
 328 }
 329
 330 int
 331 PlaylistContentListForm::GetItemCount(void)
 332 {
 333         AppLogDebug("ENTER");
 334         if (__pPresentationModel == null)
 335         {
 336                 AppLogDebug("EXIT");
 337                 return INIT_VALUE;
 338         }
 339         AppLogDebug("EXIT");
 340         return __pPresentationModel->GetContentCount();
 341 }
 342
 343 Tizen::Ui::Controls::TableViewItem*
 344 PlaylistContentListForm::CreateItem(const int itemIndex, int itemWidth)
 345 {
 346         AppLogDebug("ENTER");
 347         RelativeLayout layout;
 348         layout.Construct();
 349
 350         TableViewAnnexStyle tableViewAnnexStyle = TABLE_VIEW_ANNEX_STYLE_NORMAL;
 351         if (GetScreenState() != SCREEN_STATE_NORMAL)
 352         {
 353                 tableViewAnnexStyle = TABLE_VIEW_ANNEX_STYLE_MARK;
 354         }
 355
 356         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 357         ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(itemIndex);
 358
 359         result r = pItem->Construct(layout, Dimension(itemWidth, __itemHeight), tableViewAnnexStyle);
 360         TryCatch(r == E_SUCCESS, delete pItem, "pItem->Construct(%s)", GetErrorMessage(r));
 361         TryCatch(pContentInfo != null, delete pItem, "pContentInfo is null", GetErrorMessage(GetLastResult()));
 362
 363         r = CreateTableViewItem(*pItem, *pContentInfo);
 364         TryCatch(r == E_SUCCESS, delete pItem, "CreateTableViewItem failed(%s)", GetErrorMessage(r));
 365
 366         RequestThumbnail(pContentInfo->contentId, (new (std::nothrow) Integer(itemIndex)));
 367         delete pContentInfo;
 368
 369         AppLogDebug("EXIT");
 370         return pItem;
 371
 372 CATCH:
 373         AppLogDebug("EXIT(%ls)", GetErrorMessage(GetLastResult()));
 374         delete pContentInfo;
 375         return null;
 376 }
 377
 378 void
 379 PlaylistContentListForm::OnTableViewItemStateChanged(Tizen::Ui::Controls::TableView& tableView,
 380                                                         int itemIndex,
 381                                                         Tizen::Ui::Controls::TableViewItem* pItem,
 382                                                         Tizen::Ui::Controls::TableViewItemStatus status)
 383 {
 384         AppLogDebug("ENTER");
 385         if (GetScreenState() != SCREEN_STATE_NORMAL)
 386         {
 387                 SetItemCheckedStateChanged(status);
 388                 AppLogDebug("EXIT");
 389                 return;
 390         }
 391
 392         if (status == TABLE_VIEW_ITEM_STATUS_SELECTED)
 393         {
 394                 SceneManager* pSceneManager = SceneManager::GetInstance();
 395                 AppAssert(pSceneManager);
 396
 397                 ArrayList* pSceneArg = MakePlayerSceneParam(itemIndex);
 398                 if (pSceneArg != null)
 399                 {
 400                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_PLAYER), pSceneArg);
 401                 }
 402         }
 403         AppLogDebug("EXIT");
 404 }
 405
 406 void
 407 PlaylistContentListForm::OnTableViewContextItemActivationStateChanged(Tizen::Ui::Controls::TableView& tableView, int itemIndex,
 408                                                                                 Tizen::Ui::Controls::TableViewContextItem* pContextItem,
 409                                                                                 bool activated)
 410 {
 411         AppLogDebug("ENTER");
 412         if (itemIndex >= 0)
 413         {
 414                 __activatedStateContextItem = itemIndex;
 415         }
 416         AppLogDebug("EXIT");
 417 }
 418
 419 int
 420 PlaylistContentListForm::GetDefaultItemHeight(void)
 421 {
 422         AppLogDebug("ENTER");
 423         AppLogDebug("EXIT");
 424         return ITEM_HEIGHT;
 425 }
 426
 427 bool
 428 PlaylistContentListForm::DeleteItem(const int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 429 {
 430         AppLogDebug("ENTER");
 431         AppLogDebug("EXIT");
 432         return false;
 433 }
 434
 435 void
 436 PlaylistContentListForm::OnTableViewItemReordered(Tizen::Ui::Controls::TableView& tableView,
 437                                                         int itemIndexFrom,
 438                                                         int itemIndexTo)
 439 {
 440         AppLogDebug("ENTER");
 441         AppLogDebug("EXIT");
 442 }
 443
 444 Tizen::Base::Collection::ArrayList*
 445 PlaylistContentListForm::GetSearchResultContentList(int itemIndex)
 446 {
 447         AppLogDebug("ENTER");
 448         ArrayList* pTempList = new (std::nothrow) ArrayList();
 449         if (pTempList == null)
 450         {
 451                 AppLogDebug("EXIT");
 452                 return null;
 453         }
 454         pTempList->Construct();
 455
 456         pTempList->Add(*(new (std::nothrow) String(MUSIC)));
 457         pTempList->Add(*(new (std::nothrow) Integer(itemIndex)));
 458         pTempList->Add(*(__pPresentationModel->GetContentPathListN(__currentContentType)));
 459         AppLogDebug("EXIT");
 460         return pTempList;
 461 }
 462
 463 Tizen::Base::Collection::ArrayList*
 464 PlaylistContentListForm::GetAudioContentInfoContentList(int itemIndex)
 465 {
 466         AppLogDebug("ENTER");
 467         ArrayList* pTempList = new (std::nothrow) ArrayList();
 468         if (pTempList == null)
 469         {
 470                 AppLogDebug("EXIT");
 471                 return null;
 472         }
 473         pTempList->Construct();
 474
 475         pTempList->Add(*(new (std::nothrow) String(MUSIC)));
 476         pTempList->Add(*(new (std::nothrow) Integer(itemIndex)));
 477         pTempList->Add(*(__pPresentationModel->GetContentPathListN(__currentContentType)));
 478         AppLogDebug("EXIT");
 479         return pTempList;
 480 }
 481
 482 bool
 483 PlaylistContentListForm::IsEmptyContentList(void)
 484 {
 485         AppLogDebug("ENTER");
 486         if (__pPresentationModel->GetContentCount() != INIT_VALUE)
 487         {
 488                 return false;
 489         }
 490         AppLogDebug("EXIT");
 491         return true;
 492 }
 493
 494 int
 495 PlaylistContentListForm::GetCheckedItemCount(void)
 496 {
 497         AppLogDebug("ENTER");
 498         AppLogDebug("EXIT");
 499         return __checkedItemCount;
 500 }
 501
 502 Tizen::Base::Collection::ArrayList*
 503 PlaylistContentListForm::MakePlayerSceneParam(int startIndex)
 504 {
 505         AppLogDebug("ENTER");
 506         if (__currentContentType != RECENTLY_ADDED_CONTENT)
 507         {
 508                 AppLogDebug("EXIT");
 509                 return GetAudioContentInfoContentList(startIndex);
 510         }
 511         else if (__currentContentType == RECENTLY_ADDED_CONTENT)
 512         {
 513                 AppLogDebug("EXIT");
 514                 return GetSearchResultContentList(startIndex);
 515         }
 516         AppLogDebug("EXIT");
 517         return null;
 518 }
 519
 520 result
 521 PlaylistContentListForm::SetHeader(void)
 522 {
 523         AppLogDebug("ENTER");
 524         CommonUtil::SetSimpleTitleStyle(*GetHeader(), __headerTitle);
 525         AppLogDebug("EXIT");
 526         return E_SUCCESS;
 527 }
 528
 529 result
 530 PlaylistContentListForm::CreateTableViewItem(Tizen::Ui::Controls::TableViewItem& parent, const ContentInformation& contentInfo)
 531 {
 532         AppLogDebug("ENTER");
 533         Panel* pTableViewItem =  new (std::nothrow) Panel();
 534
 535         if (GetScreenState() != SCREEN_STATE_NORMAL)
 536         {
 537                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 538                 {
 539                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_GIANT)))
 540                         {
 541                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 542                                 return E_FAILURE;
 543                         }
 544                 }
 545                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 546                 {
 547                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_HUGE)))
 548                         {
 549                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 550                                 return E_FAILURE;
 551                         }
 552                 }
 553                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 554                 {
 555                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_LARGE)))
 556                         {
 557                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 558                                 return E_FAILURE;
 559                         }
 560                 }
 561                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 562                 {
 563                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_SMALL)))
 564                         {
 565                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 566                                 return E_FAILURE;
 567                         }
 568                 }
 569                 else
 570                 {
 571                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_DEFAULT)))
 572                         {
 573                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 574                                 return E_FAILURE;
 575                         }
 576                 }
 577         }
 578         else
 579         {
 580                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 581                 {
 582                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_GIANT)))
 583                         {
 584                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 585                                 return E_FAILURE;
 586                         }
 587                 }
 588                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 589                 {
 590                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_HUGE)))
 591                         {
 592                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 593                                 return E_FAILURE;
 594                         }
 595                 }
 596                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 597                 {
 598                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_LARGE)))
 599                         {
 600                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 601                                 return E_FAILURE;
 602                         }
 603                 }
 604                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 605                 {
 606                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_SMALL)))
 607                         {
 608                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 609                                 return E_FAILURE;
 610                         }
 611                 }
 612                 else
 613                 {
 614                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_DEFAULT)))
 615                         {
 616                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 617                                 return E_FAILURE;
 618                         }
 619                 }
 620         }
 621
 622         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_TITLE_NAME))->SetText(contentInfo.TitleName);
 623         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_ARTIST_NAME))->SetText(contentInfo.ArtistName);
 624 //      static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_THUMBNAIL))->SetBackgroundBitmap(*GetDefaultThumbnail());
 625
 626         parent.AddControl(pTableViewItem);
 627         CommonUtil::SetLayoutFitToContainer(parent, *pTableViewItem);
 628
 629         AppLogDebug("EXIT");
 630         return E_SUCCESS;
 631 }
 632
 633 void
 634 PlaylistContentListForm::OnAppControlCompleteResponseReceived(const AppId& appId,
 635                 const String& operationId, AppCtrlResult appControlResult,
 636                 const IMap* pExtraData)
 637 {
 638         AppLogDebug("ENTER");
 639         if (pExtraData == null)
 640         {
 641                 AppLogDebug("EXIT");
 642                 return;
 643         }
 644         AppLogDebug("%ls, %ls", appId.GetPointer(), operationId.GetPointer());
 645         if (appId.Equals(String(PROVIDER_ID_CONTACT)))
 646         {
 647                 if (appControlResult == APP_CTRL_RESULT_SUCCEEDED)
 648                 {
 649                         const String* pResultString = static_cast<const String*>(pExtraData->GetValue(String(APPCONTROL_KEY_SOCIAL_ITEM_ID)));
 650
 651                         AppLogDebug("%ls", pResultString->GetPointer());
 652                         int contactId;
 653                         Integer::Parse(*pResultString, contactId);
 654
 655                         AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
 656                         Addressbook* pAddressbook = pAddressbookManager->GetAddressbookN(DEFAULT_ADDRESSBOOK_ID);
 657
 658                         ContentInformation* pCcontentInfo = __pPresentationModel->GetContentInfoN(__activatedStateContextItem);
 659                         if (pCcontentInfo == null)
 660                         {
 661                                 delete pAddressbook;
 662                                 pAddressbook = null;
 663                                 return;
 664                         }
 665
 666                         Contact* pContact = pAddressbook->GetContactN(contactId);
 667                         pContact->SetValue(CONTACT_PROPERTY_ID_RINGTONE, pCcontentInfo->ContentFilePath);
 668                         result r = pAddressbook->UpdateContact(*pContact);
 669
 670                         if (r == E_SUCCESS)
 671                         {
 672                                 ShowDelayedMessageBox(ResourceManager::GetString(L"IDS_COM_POP_SUCCESS"));
 673                         }
 674
 675                         delete pCcontentInfo;
 676                         pCcontentInfo = null;
 677
 678                         delete pContact;
 679                         pContact = null;
 680
 681                         delete pAddressbook;
 682                         pAddressbook = null;
 683                 }
 684         }
 685         AppLogDebug("EXIT");
 686 }
 687
 688 void
 689 PlaylistContentListForm::OnFormMenuRequested(Tizen::Ui::Controls::Form& source)
 690 {
 691         if (GetScreenState() == SCREEN_STATE_NORMAL && IsEmptyContentList() == false)
 692         {
 693                 CreateOptionMenuN(source);
 694                 SetOptionMenuItem(CONTEXT_MENU_ITEM_STYLE_SHARE_VIA | CONTEXT_MENU_ITEM_STYLE_EDIT);
 695         }
 696 }
 697
 698 void
 699 PlaylistContentListForm::OnThumbnailInfoReveivedN(ThumbnailInfo* pThumbnailInfo)
 700 {
 701         AppLogDebug("ENTER");
 702         Object* pParam = null;
 703         __pThumbnail = pThumbnailInfo->GetBitmapN();
 704         pParam = pThumbnailInfo->GetUserParamN();
 705         if (pParam != null)
 706         {
 707                 __pContentListTableView->RefreshItem((static_cast<Integer*>(pParam))->ToInt(), TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 708                 delete pParam;
 709         }
 710
 711         delete pThumbnailInfo;
 712         AppLogDebug("EXIT");
 713 }
 714
 715 void
 716 PlaylistContentListForm::UpdateItem(int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 717 {
 718         AppLogDebug("ENTER");
 719
 720         if (pItem == null)
 721         {
 722                 AppLogDebug("pItem is null");
 723                 delete __pThumbnail;
 724                 __pThumbnail = null;
 725                 return;
 726         }
 727
 728         Label* pThumbnailLabel = static_cast<Label*>(pItem->GetControl(IDC_CONTENTS_THUMBNAIL, true));
 729         if (__pThumbnail == null || pThumbnailLabel == null)
 730         {
 731                 AppLogDebug("__pThumbnail or pThumbnailLabel is null");
 732                 delete __pThumbnail;
 733                 __pThumbnail = null;
 734                 return;
 735         }
 736
 737         pThumbnailLabel->SetBackgroundBitmap(*__pThumbnail);
 738         delete __pThumbnail;
 739         __pThumbnail = null;
 740         pThumbnailLabel->Invalidate(true);
 741         AppLogDebug("EXIT");
 742 }
 743
 744 void
 745 PlaylistContentListForm::UpdateTableView(void)
 746 {
 747         AppLogDebug("ENTER");
 748         __pContentListTableView->UpdateTableView();
 749         AppLogDebug("EXIT");
 750 }
 751
 752 void
 753 PlaylistContentListForm::UpdateContentList(void)
 754 {
 755         AppLogDebug("ENTER");
 756         __pPresentationModel->UpdatePlaylistContentList(__currentContentType, __headerTitle);
 757
 758         if (__pPresentationModel->GetContentCount() == 0)
 759         {
 760                 ToggleScreenState(SCREEN_STATE_NORMAL);
 761                 SceneManager* pSceneManager = SceneManager::GetInstance();
 762                 if (pSceneManager->GetCurrentSceneId().Equals(IDSCN_PLAYLIST_CONTENT_LIST,true))
 763                 {
 764                         AppAssert(pSceneManager);
 765                         pSceneManager->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_NONE,SCENE_DESTROY_OPTION_KEEP));
 766                 }
 767         }
 768         else
 769         {
 770                 UpdateTableView();
 771         }
 772         AppLogDebug("EXIT");
 773 }
 774
 775 void
 776 PlaylistContentListForm::SetItemCheckedAll(bool isChecked)
 777 {
 778         AppLogDebug("ENTER");
 779         if (isChecked == true)
 780         {
 781                 __checkedItemCount = __pContentListTableView->GetItemCount();
 782         }
 783         else
 784         {
 785                 __checkedItemCount = INIT_VALUE;
 786         }
 787         CommonUtil::SetItemCheckedAll(isChecked, *__pContentListTableView);
 788
 789         if (GetFooter() != null)
 790         {
 791                 CommonUtil::SetFooterItemEnabled(*GetFooter(), isChecked);
 792         }
 793
 794         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 795         AppLogDebug("EXIT");
 796 }
 797
 798 void
 799 PlaylistContentListForm::RemoveCheckedTableviewItem(bool itemRemove)
 800 {
 801         AppLogDebug("ENTER");
 802         if (itemRemove)
 803         {
 804                 int totalCount = __pContentListTableView->GetItemCount();
 805                 for (int iCount = 0; iCount < totalCount; iCount++)
 806                 {
 807                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 808                         {
 809                                 __pContentListTableView->SetItemChecked(iCount, false);
 810                                 __checkedItemCount--;
 811                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 812                                 if (pContentInfo != null)
 813                                 {
 814                                         RemoveContentAt(pContentInfo->contentId);
 815                                         delete pContentInfo;
 816                                 }
 817                         }
 818                 }
 819         }
 820         else
 821         {
 822                 SetItemCheckedAll(false);
 823         }
 824         AppLogDebug("EXIT");
 825 }
 826
 827 void
 828 PlaylistContentListForm::SetItemCheckedStateChanged(Tizen::Ui::Controls::TableViewItemStatus status)
 829 {
 830         AppLogDebug("ENTER");
 831         if (status == TABLE_VIEW_ITEM_STATUS_UNCHECKED)
 832         {
 833                 __checkedItemCount--;
 834                 if (__checkedItemCount == INIT_VALUE)
 835                 {
 836                         if (GetFooter() != null)
 837                         {
 838                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), false);
 839                         }
 840                 }
 841         }
 842         else if (status == TABLE_VIEW_ITEM_STATUS_CHECKED)
 843         {
 844                 if (__checkedItemCount == INIT_VALUE)
 845                 {
 846                         if (GetFooter() != null)
 847                         {
 848                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), true);
 849                         }
 850                 }
 851
 852                 __checkedItemCount++;
 853         }
 854
 855         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 856         AppLogDebug("EXIT");
 857 }
 858
 859 Tizen::Base::Collection::IList*
 860 PlaylistContentListForm::GetPickerArgumentListN(PickerType pickerType, PickerArgumentType argumentType)
 861 {
 862         AppLogDebug("ENTER");
 863         Tizen::Base::Collection::ArrayList* pContentFilePathList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 864         if (IsFailed(pContentFilePathList->Construct()))
 865         {
 866                 AppLogDebug("pContentList->Construct failed(%s)", GetErrorMessage(GetLastResult()));
 867                 delete pContentFilePathList;
 868                 return null;
 869         }
 870
 871         if (argumentType == PICKER_ARGUMENT_TYPE_ACTIVATED_STATE_CONTEXT_ITEM)
 872         {
 873                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(__activatedStateContextItem);
 874                 if (pContentInfo == null)
 875                 {
 876                         delete pContentFilePathList;
 877                         AppLogDebug("GetContentInfoN(%d) is null", __activatedStateContextItem);
 878                         return null;
 879                 }
 880
 881                 pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 882                 delete pContentInfo;
 883         }
 884         else if (argumentType == PICKER_ARGUMENT_TYPE_CHECKED_ITEM_ALL)
 885         {
 886                 int totalCount = __pContentListTableView->GetItemCount();
 887                 for (int iCount = 0; iCount < totalCount; iCount++)
 888                 {
 889                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 890                         {
 891                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 892                                 if (pContentInfo == null)
 893                                 {
 894                                         AppLogDebug("GetContentInfoN(%d) is null", iCount);
 895                                         delete pContentFilePathList;
 896                                         return null;
 897                                 }
 898
 899                                 if (pickerType == PICKER_TYPE_PLAY_LIST_PICKER)
 900                                 {
 901                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 902                                 }
 903                                 else if (pickerType == PICKER_TYPE_SHARE_PICKER)
 904                                 {
 905                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 906                                 }
 907                                 delete pContentInfo;
 908                         }
 909                 }
 910         }
 911         AppLogDebug("EXIT");
 912         return pContentFilePathList;
 913 }
 914
 915 void
 916 PlaylistContentListForm::OnFontSizeChanged(void)
 917 {
 918         __fontSizeValue = CommonUtil::GetFontSizeValue();
 919         __itemHeight = CommonUtil::GetItemHeight(__fontSizeValue);
 920         __pContentListTableView->UpdateTableView();
 921 }