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                         if (__currentContentType == RECENTLY_ADDED_CONTENT)
 192                         {
 193                                 RemoveCheckedTableviewItem(true);
 194                         }
 195                         else
 196                         {
 197                                 int totalCount = __pPresentationModel->GetContentCount();
 198                                 for (int iCount = 0; iCount < totalCount; iCount++)
 199                                 {
 200                                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 201                                         {
 202                                                 ContentInformation* pContentInfoStruct = __pPresentationModel->GetContentInfoN(iCount);
 203                                                 if (pContentInfoStruct == null)
 204                                                 {
 205                                                         return;
 206                                                 }
 207 //                                              __pContentListTableView->SetItemChecked(iCount, false);
 208                                                 __pPresentationModel->DeleteContent(__currentContentType, *pContentInfoStruct);
 209
 210                                                 delete pContentInfoStruct;
 211                                         }
 212                                 }
 213                                 RemoveCheckedTableviewItem(false);
 214                                 __pPresentationModel->UpdatePlaylistContentList(__currentContentType, __headerTitle);
 215                                 UpdateScreenState();
 216                                 UpdateTableView();
 217
 218                                 if(__pPresentationModel->GetContentCount() == 0)
 219                                 {
 220                                         ToggleScreenState(SCREEN_STATE_NORMAL);
 221                                 }
 222                         }
 223                 }
 224                 break;
 225
 226         default:
 227                 break;
 228         }
 229
 230         TryRemoveContextMenu(actionId);
 231         AppLogDebug("EXIT");
 232 }
 233
 234 void
 235 PlaylistContentListForm::OnSceneActivatedN(const Tizen::Ui::Scenes::SceneId& previousSceneId,
 236                                         const Tizen::Ui::Scenes::SceneId& currentSceneId,
 237                                         Tizen::Base::Collection::IList* pArgs)
 238 {
 239         AppLogDebug("ENTER");
 240         if (pArgs != null && previousSceneId.Equals(IDSCN_PLAYLIST_LIST, true) == true)
 241         {
 242                 __headerTitle.Clear();
 243                 __prevSceneId.Append(*static_cast<String*>(pArgs->GetAt(DATA_ITEM_SCENE_NAME)));
 244                 __headerTitle.Append(*static_cast<String*>(pArgs->GetAt(DATA_ITEM_CONTENT_NAME)));
 245                 __currentContentType = static_cast<Integer*>(pArgs->GetAt(DATA_ITEM_CONTENT_TYPE))->ToInt();
 246                 SetHeader();
 247                 pArgs->RemoveAll(true);
 248                 delete pArgs;
 249         }
 250         else if (pArgs != null && previousSceneId.Equals(IDSCN_PLAYLIST_CREATOR, true) == true)
 251         {
 252                 SetItemCheckedAll(false);
 253                 pArgs->RemoveAll(true);
 254                 delete pArgs;
 255         }
 256
 257         __pPresentationModel = PlaylistListPresentationModel::GetInstance();
 258         __pPresentationModel->UpdatePlaylistContentList(__currentContentType, __headerTitle);
 259         UpdateScreenState();
 260         if (__currentContentType < RECENTLY_ADDED_CONTENT || !previousSceneId.Equals(IDSCN_PLAYER,true))
 261         {
 262                 UpdateTableView();
 263         }
 264
 265         AppLogDebug("EXIT");
 266 }
 267
 268 void
 269 PlaylistContentListForm::OnSceneDeactivated(const Tizen::Ui::Scenes::SceneId& currentSceneId,
 270                                                                         const Tizen::Ui::Scenes::SceneId& nextSceneId)
 271 {
 272         AppLogDebug("ENTER");
 273         CancelAllThumbnailRequest();
 274         AppLogDebug("EXIT");
 275 }
 276
 277 int
 278 PlaylistContentListForm::GetItemCount(void)
 279 {
 280         AppLogDebug("ENTER");
 281         if (__pPresentationModel == null)
 282         {
 283                 AppLogDebug("EXIT");
 284                 return INIT_VALUE;
 285         }
 286         AppLogDebug("EXIT");
 287         return __pPresentationModel->GetContentCount();
 288 }
 289
 290 Tizen::Ui::Controls::TableViewItem*
 291 PlaylistContentListForm::CreateItem(const int itemIndex, int itemWidth)
 292 {
 293         AppLogDebug("ENTER");
 294         RelativeLayout layout;
 295         layout.Construct();
 296
 297         TableViewAnnexStyle tableViewAnnexStyle = TABLE_VIEW_ANNEX_STYLE_NORMAL;
 298         if (GetScreenState() != SCREEN_STATE_NORMAL)
 299         {
 300                 tableViewAnnexStyle = TABLE_VIEW_ANNEX_STYLE_MARK;
 301         }
 302
 303         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 304         ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(itemIndex);
 305
 306         result r = pItem->Construct(layout, Dimension(itemWidth, __itemHeight), tableViewAnnexStyle);
 307         TryCatch(r == E_SUCCESS, delete pItem, "pItem->Construct(%s)", GetErrorMessage(r));
 308         TryCatch(pContentInfo != null, delete pItem, "pContentInfo is null", GetErrorMessage(GetLastResult()));
 309
 310         r = CreateTableViewItem(*pItem, *pContentInfo);
 311         TryCatch(r == E_SUCCESS, delete pItem, "CreateTableViewItem failed(%s)", GetErrorMessage(r));
 312
 313         RequestThumbnail(pContentInfo->contentId, (new (std::nothrow) Integer(itemIndex)));
 314         delete pContentInfo;
 315
 316         AppLogDebug("EXIT");
 317         return pItem;
 318
 319 CATCH:
 320         AppLogDebug("EXIT(%ls)", GetErrorMessage(GetLastResult()));
 321         delete pContentInfo;
 322         return null;
 323 }
 324
 325 void
 326 PlaylistContentListForm::OnTableViewItemStateChanged(Tizen::Ui::Controls::TableView& tableView,
 327                                                         int itemIndex,
 328                                                         Tizen::Ui::Controls::TableViewItem* pItem,
 329                                                         Tizen::Ui::Controls::TableViewItemStatus status)
 330 {
 331         AppLogDebug("ENTER");
 332         if (GetScreenState() != SCREEN_STATE_NORMAL)
 333         {
 334                 SetItemCheckedStateChanged(status);
 335                 AppLogDebug("EXIT");
 336                 return;
 337         }
 338
 339         if (status == TABLE_VIEW_ITEM_STATUS_SELECTED)
 340         {
 341                 SceneManager* pSceneManager = SceneManager::GetInstance();
 342                 AppAssert(pSceneManager);
 343
 344                 ArrayList* pSceneArg = MakePlayerSceneParam(itemIndex);
 345                 if (pSceneArg != null)
 346                 {
 347                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_PLAYER), pSceneArg);
 348                 }
 349         }
 350         AppLogDebug("EXIT");
 351 }
 352
 353 void
 354 PlaylistContentListForm::OnTableViewContextItemActivationStateChanged(Tizen::Ui::Controls::TableView& tableView, int itemIndex,
 355                                                                                 Tizen::Ui::Controls::TableViewContextItem* pContextItem,
 356                                                                                 bool activated)
 357 {
 358         AppLogDebug("ENTER");
 359         if (itemIndex >= 0)
 360         {
 361                 __activatedStateContextItem = itemIndex;
 362         }
 363         AppLogDebug("EXIT");
 364 }
 365
 366 int
 367 PlaylistContentListForm::GetDefaultItemHeight(void)
 368 {
 369         AppLogDebug("ENTER");
 370         AppLogDebug("EXIT");
 371         return ITEM_HEIGHT;
 372 }
 373
 374 bool
 375 PlaylistContentListForm::DeleteItem(const int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 376 {
 377         AppLogDebug("ENTER");
 378         AppLogDebug("EXIT");
 379         return false;
 380 }
 381
 382 void
 383 PlaylistContentListForm::OnTableViewItemReordered(Tizen::Ui::Controls::TableView& tableView,
 384                                                         int itemIndexFrom,
 385                                                         int itemIndexTo)
 386 {
 387         AppLogDebug("ENTER");
 388         AppLogDebug("EXIT");
 389 }
 390
 391 Tizen::Base::Collection::ArrayList*
 392 PlaylistContentListForm::GetSearchResultContentList(int itemIndex)
 393 {
 394         AppLogDebug("ENTER");
 395         ArrayList* pTempList = new (std::nothrow) ArrayList();
 396         if (pTempList == null)
 397         {
 398                 AppLogDebug("EXIT");
 399                 return null;
 400         }
 401         pTempList->Construct();
 402
 403         pTempList->Add(*(new (std::nothrow) String(MUSIC)));
 404         pTempList->Add(*(new (std::nothrow) Integer(itemIndex)));
 405         pTempList->Add(*(__pPresentationModel->GetContentPathListN(__currentContentType)));
 406         AppLogDebug("EXIT");
 407         return pTempList;
 408 }
 409
 410 Tizen::Base::Collection::ArrayList*
 411 PlaylistContentListForm::GetAudioContentInfoContentList(int itemIndex)
 412 {
 413         AppLogDebug("ENTER");
 414         ArrayList* pTempList = new (std::nothrow) ArrayList();
 415         if (pTempList == null)
 416         {
 417                 AppLogDebug("EXIT");
 418                 return null;
 419         }
 420         pTempList->Construct();
 421
 422         pTempList->Add(*(new (std::nothrow) String(MUSIC)));
 423         pTempList->Add(*(new (std::nothrow) Integer(itemIndex)));
 424         pTempList->Add(*(__pPresentationModel->GetContentPathListN(__currentContentType)));
 425         AppLogDebug("EXIT");
 426         return pTempList;
 427 }
 428
 429 bool
 430 PlaylistContentListForm::IsEmptyContentList(void)
 431 {
 432         AppLogDebug("ENTER");
 433         if (__pPresentationModel->GetContentCount() != INIT_VALUE)
 434         {
 435                 return false;
 436         }
 437         AppLogDebug("EXIT");
 438         return true;
 439 }
 440
 441 int
 442 PlaylistContentListForm::GetCheckedItemCount(void)
 443 {
 444         AppLogDebug("ENTER");
 445         AppLogDebug("EXIT");
 446         return __checkedItemCount;
 447 }
 448
 449 Tizen::Base::Collection::ArrayList*
 450 PlaylistContentListForm::MakePlayerSceneParam(int startIndex)
 451 {
 452         AppLogDebug("ENTER");
 453         if (__currentContentType != RECENTLY_ADDED_CONTENT)
 454         {
 455                 AppLogDebug("EXIT");
 456                 return GetAudioContentInfoContentList(startIndex);
 457         }
 458         else if (__currentContentType == RECENTLY_ADDED_CONTENT)
 459         {
 460                 AppLogDebug("EXIT");
 461                 return GetSearchResultContentList(startIndex);
 462         }
 463         AppLogDebug("EXIT");
 464         return null;
 465 }
 466
 467 result
 468 PlaylistContentListForm::SetHeader(void)
 469 {
 470         AppLogDebug("ENTER");
 471         CommonUtil::SetSimpleTitleStyle(*GetHeader(), __headerTitle);
 472         AppLogDebug("EXIT");
 473         return E_SUCCESS;
 474 }
 475
 476 result
 477 PlaylistContentListForm::CreateTableViewItem(Tizen::Ui::Controls::TableViewItem& parent, const ContentInformation& contentInfo)
 478 {
 479         AppLogDebug("ENTER");
 480         Panel* pTableViewItem =  new (std::nothrow) Panel();
 481
 482         if (GetScreenState() != SCREEN_STATE_NORMAL)
 483         {
 484                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 485                 {
 486                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_GIANT)))
 487                         {
 488                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 489                                 return E_FAILURE;
 490                         }
 491                 }
 492                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 493                 {
 494                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_HUGE)))
 495                         {
 496                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 497                                 return E_FAILURE;
 498                         }
 499                 }
 500                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 501                 {
 502                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_LARGE)))
 503                         {
 504                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 505                                 return E_FAILURE;
 506                         }
 507                 }
 508                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 509                 {
 510                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_SMALL)))
 511                         {
 512                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 513                                 return E_FAILURE;
 514                         }
 515                 }
 516                 else
 517                 {
 518                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_DEFAULT)))
 519                         {
 520                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 521                                 return E_FAILURE;
 522                         }
 523                 }
 524         }
 525         else
 526         {
 527                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 528                 {
 529                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_GIANT)))
 530                         {
 531                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 532                                 return E_FAILURE;
 533                         }
 534                 }
 535                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 536                 {
 537                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_HUGE)))
 538                         {
 539                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 540                                 return E_FAILURE;
 541                         }
 542                 }
 543                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 544                 {
 545                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_LARGE)))
 546                         {
 547                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 548                                 return E_FAILURE;
 549                         }
 550                 }
 551                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 552                 {
 553                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_SMALL)))
 554                         {
 555                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 556                                 return E_FAILURE;
 557                         }
 558                 }
 559                 else
 560                 {
 561                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_DEFAULT)))
 562                         {
 563                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 564                                 return E_FAILURE;
 565                         }
 566                 }
 567         }
 568
 569         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_TITLE_NAME))->SetText(contentInfo.TitleName);
 570         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_ARTIST_NAME))->SetText(contentInfo.ArtistName);
 571         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_THUMBNAIL))->SetBackgroundBitmap(*GetDefaultThumbnail());
 572
 573         parent.AddControl(pTableViewItem);
 574         CommonUtil::SetLayoutFitToContainer(parent, *pTableViewItem);
 575
 576         AppLogDebug("EXIT");
 577         return E_SUCCESS;
 578 }
 579
 580 void
 581 PlaylistContentListForm::OnAppControlCompleteResponseReceived(const AppId& appId,
 582                 const String& operationId, AppCtrlResult appControlResult,
 583                 const IMap* pExtraData)
 584 {
 585         AppLogDebug("ENTER");
 586         if (pExtraData == null)
 587         {
 588                 AppLogDebug("EXIT");
 589                 return;
 590         }
 591         AppLogDebug("%ls, %ls", appId.GetPointer(), operationId.GetPointer());
 592         if (appId.Equals(String(PROVIDER_ID_CONTACT)))
 593         {
 594                 if (appControlResult == APP_CTRL_RESULT_SUCCEEDED)
 595                 {
 596                         const String* pResultString = static_cast<const String*>(pExtraData->GetValue(String(APPCONTROL_KEY_SOCIAL_ITEM_ID)));
 597
 598                         AppLogDebug("%ls", pResultString->GetPointer());
 599                         int contactId;
 600                         Integer::Parse(*pResultString, contactId);
 601
 602                         AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
 603                         Addressbook* pAddressbook = pAddressbookManager->GetAddressbookN(DEFAULT_ADDRESSBOOK_ID);
 604
 605                         ContentInformation* pCcontentInfo = __pPresentationModel->GetContentInfoN(__activatedStateContextItem);
 606                         if (pCcontentInfo == null)
 607                         {
 608                                 delete pAddressbook;
 609                                 pAddressbook = null;
 610                                 return;
 611                         }
 612
 613                         Contact* pContact = pAddressbook->GetContactN(contactId);
 614                         pContact->SetValue(CONTACT_PROPERTY_ID_RINGTONE, pCcontentInfo->ContentFilePath);
 615                         result r = pAddressbook->UpdateContact(*pContact);
 616
 617                         if (r == E_SUCCESS)
 618                         {
 619                                 ShowDelayedMessageBox(ResourceManager::GetString(L"IDS_COM_POP_SUCCESS"));
 620                         }
 621
 622                         delete pCcontentInfo;
 623                         pCcontentInfo = null;
 624
 625                         delete pContact;
 626                         pContact = null;
 627
 628                         delete pAddressbook;
 629                         pAddressbook = null;
 630                 }
 631         }
 632         AppLogDebug("EXIT");
 633 }
 634
 635 void
 636 PlaylistContentListForm::OnFormMenuRequested(Tizen::Ui::Controls::Form& source)
 637 {
 638         if (GetScreenState() == SCREEN_STATE_NORMAL && IsEmptyContentList() == false)
 639         {
 640                 CreateOptionMenuN(source);
 641                 SetOptionMenuItem(CONTEXT_MENU_ITEM_STYLE_SHARE_VIA | CONTEXT_MENU_ITEM_STYLE_EDIT);
 642         }
 643 }
 644
 645 void
 646 PlaylistContentListForm::OnThumbnailInfoReveivedN(ThumbnailInfo* pThumbnailInfo)
 647 {
 648         AppLogDebug("ENTER");
 649         Object* pParam = null;
 650         __pThumbnail = pThumbnailInfo->GetBitmapN();
 651         pParam = pThumbnailInfo->GetUserParamN();
 652         if (pParam != null)
 653         {
 654                 __pContentListTableView->RefreshItem((static_cast<Integer*>(pParam))->ToInt(), TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 655                 delete pParam;
 656         }
 657
 658         delete pThumbnailInfo;
 659         AppLogDebug("EXIT");
 660 }
 661
 662 void
 663 PlaylistContentListForm::UpdateItem(int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 664 {
 665         AppLogDebug("ENTER");
 666
 667         if (pItem == null)
 668         {
 669                 AppLogDebug("pItem is null");
 670                 delete __pThumbnail;
 671                 __pThumbnail = null;
 672                 return;
 673         }
 674
 675         Label* pThumbnailLabel = static_cast<Label*>(pItem->GetControl(IDC_CONTENTS_THUMBNAIL, true));
 676         if (__pThumbnail == null || pThumbnailLabel == null)
 677         {
 678                 AppLogDebug("__pThumbnail or pThumbnailLabel is null");
 679                 delete __pThumbnail;
 680                 __pThumbnail = null;
 681                 return;
 682         }
 683
 684         pThumbnailLabel->SetBackgroundBitmap(*__pThumbnail);
 685         delete __pThumbnail;
 686         __pThumbnail = null;
 687         pThumbnailLabel->Invalidate(true);
 688         AppLogDebug("EXIT");
 689 }
 690
 691 void
 692 PlaylistContentListForm::UpdateTableView(void)
 693 {
 694         AppLogDebug("ENTER");
 695         __pContentListTableView->UpdateTableView();
 696         AppLogDebug("EXIT");
 697 }
 698
 699 void
 700 PlaylistContentListForm::UpdateContentList(void)
 701 {
 702         AppLogDebug("ENTER");
 703         __pPresentationModel->UpdatePlaylistContentList(__currentContentType, __headerTitle);
 704
 705         if (__pPresentationModel->GetContentCount() == 0)
 706         {
 707                 SceneManager* pSceneManager = SceneManager::GetInstance();
 708                 ToggleScreenState(SCREEN_STATE_NORMAL);
 709                 AppAssert(pSceneManager);
 710                 pSceneManager->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_NONE,SCENE_DESTROY_OPTION_KEEP));
 711         }
 712         else
 713         {
 714                 UpdateTableView();
 715         }
 716         AppLogDebug("EXIT");
 717 }
 718
 719 void
 720 PlaylistContentListForm::SetItemCheckedAll(bool isChecked)
 721 {
 722         AppLogDebug("ENTER");
 723         if (isChecked == true)
 724         {
 725                 __checkedItemCount = __pContentListTableView->GetItemCount();
 726         }
 727         else
 728         {
 729                 __checkedItemCount = INIT_VALUE;
 730         }
 731         CommonUtil::SetItemCheckedAll(isChecked, *__pContentListTableView);
 732
 733         if (GetFooter() != null)
 734         {
 735                 CommonUtil::SetFooterItemEnabled(*GetFooter(), isChecked);
 736         }
 737
 738         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 739         AppLogDebug("EXIT");
 740 }
 741
 742 void
 743 PlaylistContentListForm::RemoveCheckedTableviewItem(bool itemRemove)
 744 {
 745         AppLogDebug("ENTER");
 746         if (itemRemove)
 747         {
 748                 int totalCount = __pContentListTableView->GetItemCount();
 749                 for (int iCount = 0; iCount < totalCount; iCount++)
 750                 {
 751                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 752                         {
 753                                 __pContentListTableView->SetItemChecked(iCount, false);
 754                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 755                                 if (pContentInfo != null)
 756                                 {
 757                                         RemoveContentAt(pContentInfo->contentId);
 758                                         delete pContentInfo;
 759                                 }
 760                         }
 761                 }
 762         }
 763         else
 764         {
 765                 SetItemCheckedAll(false);
 766         }
 767         AppLogDebug("EXIT");
 768 }
 769
 770 void
 771 PlaylistContentListForm::SetItemCheckedStateChanged(Tizen::Ui::Controls::TableViewItemStatus status)
 772 {
 773         AppLogDebug("ENTER");
 774         if (status == TABLE_VIEW_ITEM_STATUS_UNCHECKED)
 775         {
 776                 __checkedItemCount--;
 777                 if (__checkedItemCount == INIT_VALUE)
 778                 {
 779                         if (GetFooter() != null)
 780                         {
 781                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), false);
 782                         }
 783                 }
 784         }
 785         else if (status == TABLE_VIEW_ITEM_STATUS_CHECKED)
 786         {
 787                 if (__checkedItemCount == INIT_VALUE)
 788                 {
 789                         if (GetFooter() != null)
 790                         {
 791                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), true);
 792                         }
 793                 }
 794
 795                 __checkedItemCount++;
 796         }
 797
 798         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 799         AppLogDebug("EXIT");
 800 }
 801
 802 Tizen::Base::Collection::IList*
 803 PlaylistContentListForm::GetPickerArgumentListN(PickerType pickerType, PickerArgumentType argumentType)
 804 {
 805         AppLogDebug("ENTER");
 806         Tizen::Base::Collection::ArrayList* pContentFilePathList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 807         if (IsFailed(pContentFilePathList->Construct()))
 808         {
 809                 AppLogDebug("pContentList->Construct failed(%s)", GetErrorMessage(GetLastResult()));
 810                 delete pContentFilePathList;
 811                 return null;
 812         }
 813
 814         if (argumentType == PICKER_ARGUMENT_TYPE_ACTIVATED_STATE_CONTEXT_ITEM)
 815         {
 816                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(__activatedStateContextItem);
 817                 if (pContentInfo == null)
 818                 {
 819                         delete pContentFilePathList;
 820                         AppLogDebug("GetContentInfoN(%d) is null", __activatedStateContextItem);
 821                         return null;
 822                 }
 823
 824                 pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 825                 delete pContentInfo;
 826         }
 827         else if (argumentType == PICKER_ARGUMENT_TYPE_CHECKED_ITEM_ALL)
 828         {
 829                 int totalCount = __pContentListTableView->GetItemCount();
 830                 for (int iCount = 0; iCount < totalCount; iCount++)
 831                 {
 832                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 833                         {
 834                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 835                                 if (pContentInfo == null)
 836                                 {
 837                                         AppLogDebug("GetContentInfoN(%d) is null", iCount);
 838                                         delete pContentFilePathList;
 839                                         return null;
 840                                 }
 841
 842                                 if (pickerType == PICKER_TYPE_PLAY_LIST_PICKER)
 843                                 {
 844                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 845                                 }
 846                                 else if (pickerType == PICKER_TYPE_SHARE_PICKER)
 847                                 {
 848                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 849                                 }
 850                                 delete pContentInfo;
 851                         }
 852                 }
 853         }
 854         AppLogDebug("EXIT");
 855         return pContentFilePathList;
 856 }
 857
 858 void
 859 PlaylistContentListForm::OnFontSizeChanged(void)
 860 {
 861         __fontSizeValue = CommonUtil::GetFontSizeValue();
 862         __itemHeight = CommonUtil::GetItemHeight(__fontSizeValue);
 863         __pContentListTableView->UpdateTableView();
 864 }