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