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                         int totalCount = __pPresentationModel->GetContentCount();
 172                         for (int iCount = 0; iCount < totalCount; iCount++)
 173                         {
 174                                 if (__pContentListTableView->IsItemChecked(iCount) == true)
 175                                 {
 176                                         ContentInformation* pContentInfoStruct = __pPresentationModel->GetContentInfoN(iCount);
 177                                         __pContentListTableView->SetItemChecked(iCount, false);
 178                                         if (pContentInfoStruct == null)
 179                                         {
 180                                                 return;
 181                                         }
 182                                         __pPresentationModel->DeleteContent(USER_CONTENT, *pContentInfoStruct);
 183
 184                                         delete pContentInfoStruct;
 185                                 }
 186                         }
 187                         RemoveCheckedTableviewItem(false);
 188                         __pPresentationModel->UpdatePlaylistContentList(USER_CONTENT, __headerTitle);
 189                         UpdateScreenState();
 190                         UpdateTableView();
 191
 192                         if(__pPresentationModel->GetContentCount() == 0)
 193                         {
 194                                 ToggleScreenState(SCREEN_STATE_NORMAL);
 195                         }
 196                 }
 197                 break;
 198
 199         case IDA_CONTEXT_MENU_ITEM_STYLE_ADD:
 200                 {
 201                         AllListPresentationModel* pPresentationModel = AllListPresentationModel::GetInstance();
 202                         if (pPresentationModel->GetTotalCount() == 0)
 203                         {
 204                                 MessageBox messageBox;
 205                                 messageBox.Construct(L"", ResourceManager::GetString(L"IDS_MUSIC_HEADER_NO_SONGS"), MSGBOX_STYLE_NONE, 500);
 206
 207                                 int modalResult = 0;
 208                                 messageBox.ShowAndWait(modalResult);
 209                         }
 210                         else
 211                         {
 212                                 CommonUtil::SetAddtoPlaylistState(true);
 213                                 CommonUtil::SetAddtoPlaylistName(__headerTitle);
 214                                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_ALL_CONTENT_PICKER));
 215                         }
 216                 }
 217                 break;
 218
 219         default:
 220                 break;
 221         }
 222
 223         TryRemoveContextMenu(actionId);
 224         AppLogDebug("EXIT");
 225 }
 226
 227 void
 228 UserPlaylistContentListForm::OnSceneActivatedN(const Tizen::Ui::Scenes::SceneId& previousSceneId,
 229                                                         const Tizen::Ui::Scenes::SceneId& currentSceneId,
 230                                                         Tizen::Base::Collection::IList* pArgs)
 231 {
 232         AppLogDebug("ENTER");
 233         if (pArgs != null && previousSceneId.Equals(IDSCN_PLAYLIST_LIST, true) == true)
 234         {
 235                 __prevSceneId.Clear();
 236                 __headerTitle.Clear();
 237                 __prevSceneId.Append(*static_cast<String*>(pArgs->GetAt(DATA_ITEM_SCENE_NAME)));
 238                 __headerTitle.Append(*static_cast<String*>(pArgs->GetAt(DATA_ITEM_CONTENT_NAME)));
 239
 240                 __pPresentationModel = PlaylistListPresentationModel::GetInstance();
 241                 __pPresentationModel->UpdatePlaylistContentList(USER_CONTENT, __headerTitle);
 242
 243                 SetHeader();
 244                 UpdateScreenState();
 245                 UpdateTableView();
 246
 247                 pArgs->RemoveAll(true);
 248                 delete pArgs;
 249         }
 250         else if (pArgs != null && previousSceneId.Equals(IDSCN_PLAYLIST_CREATOR, false))
 251         {
 252                 SetItemCheckedAll(false);
 253                 pArgs->RemoveAll(true);
 254                 delete pArgs;
 255         }
 256         else if (!(__headerTitle.Equals(L"", false)))
 257         {
 258                 __pPresentationModel->UpdatePlaylistContentList(USER_CONTENT, __headerTitle);
 259                 UpdateScreenState();
 260                 if (!previousSceneId.Equals(IDSCN_PLAYER,true))
 261                 {
 262                         UpdateTableView();
 263                 }
 264         }
 265         AppLogDebug("EXIT");
 266 }
 267
 268 void
 269 UserPlaylistContentListForm::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 UserPlaylistContentListForm::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 UserPlaylistContentListForm::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 UserPlaylistContentListForm::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 UserPlaylistContentListForm::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 UserPlaylistContentListForm::GetDefaultItemHeight(void)
 368 {
 369         AppLogDebug("ENTER");
 370         AppLogDebug("EXIT");
 371         return ITEM_HEIGHT;
 372 }
 373
 374 bool
 375 UserPlaylistContentListForm::DeleteItem(const int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 376 {
 377         AppLogDebug("ENTER");
 378         AppLogDebug("EXIT");
 379         return false;
 380 }
 381
 382 void
 383 UserPlaylistContentListForm::OnTableViewItemReordered(Tizen::Ui::Controls::TableView& tableView,
 384                                                         int itemIndexFrom,
 385                                                         int itemIndexTo)
 386 {
 387         AppLogDebug("ENTER");
 388         AppLogDebug("EXIT");
 389 }
 390
 391 result
 392 UserPlaylistContentListForm::CreateTableViewItem(Tizen::Ui::Container& parent, const ContentInformation& contentInfo)
 393 {
 394         AppLogDebug("ENTER");
 395         Panel* pTableViewItem = new (std::nothrow) Panel();
 396
 397         if (GetScreenState() != SCREEN_STATE_NORMAL)
 398         {
 399                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 400                 {
 401                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_GIANT)))
 402                         {
 403                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 404                                 return E_FAILURE;
 405                         }
 406                 }
 407                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 408                 {
 409                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_HUGE)))
 410                         {
 411                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 412                                 return E_FAILURE;
 413                         }
 414                 }
 415                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 416                 {
 417                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_LARGE)))
 418                         {
 419                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 420                                 return E_FAILURE;
 421                         }
 422                 }
 423                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 424                 {
 425                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_FONT_SIZE_SMALL)))
 426                         {
 427                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 428                                 return E_FAILURE;
 429                         }
 430                 }
 431                 else
 432                 {
 433                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_EDITOR_ITEM_PANEL_DEFAULT)))
 434                         {
 435                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 436                                 return E_FAILURE;
 437                         }
 438                 }
 439         }
 440         else
 441         {
 442                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 443                 {
 444                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_GIANT)))
 445                         {
 446                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 447                                 return E_FAILURE;
 448                         }
 449                 }
 450                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 451                 {
 452                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_HUGE)))
 453                         {
 454                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 455                                 return E_FAILURE;
 456                         }
 457                 }
 458                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 459                 {
 460                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_LARGE)))
 461                         {
 462                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 463                                 return E_FAILURE;
 464                         }
 465                 }
 466                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 467                 {
 468                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_FONT_SIZE_SMALL)))
 469                         {
 470                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 471                                 return E_FAILURE;
 472                         }
 473                 }
 474                 else
 475                 {
 476                         if (IsFailed(pTableViewItem->Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL_DEFAULT)))
 477                         {
 478                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 479                                 return E_FAILURE;
 480                         }
 481                 }
 482         }
 483
 484         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_TITLE_NAME))->SetText(contentInfo.TitleName);
 485         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_ARTIST_NAME))->SetText(contentInfo.ArtistName);
 486         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_THUMBNAIL))->SetBackgroundBitmap(*GetDefaultThumbnail());
 487
 488         parent.AddControl(pTableViewItem);
 489         CommonUtil::SetLayoutFitToContainer(parent, *pTableViewItem);
 490
 491         AppLogDebug("EXIT");
 492         return E_SUCCESS;
 493 }
 494
 495 result
 496 UserPlaylistContentListForm::SetHeader(void)
 497 {
 498         AppLogDebug("ENTER");
 499         CommonUtil::SetSimpleTitleStyle(*GetHeader(), __headerTitle);
 500         AppLogDebug("EXIT");
 501         return E_SUCCESS;
 502 }
 503
 504 bool
 505 UserPlaylistContentListForm::IsEmptyContentList(void)
 506 {
 507         AppLogDebug("ENTER");
 508         if (__pPresentationModel->GetContentCount() != INIT_VALUE)
 509         {
 510                 return false;
 511         }
 512         AppLogDebug("EXIT");
 513         return true;
 514 }
 515
 516 Tizen::Base::Collection::ArrayList*
 517 UserPlaylistContentListForm::MakePlayerSceneParam(int startIndex)
 518 {
 519         AppLogDebug("ENTER");
 520         ArrayList* pArgs = new (std::nothrow) ArrayList();
 521         result r = pArgs->Construct();
 522         if (IsFailed(r))
 523         {
 524                 AppLogDebug("pArgs->Construct failed(%s)", GetErrorMessage(r));
 525                 return null;
 526         }
 527
 528         pArgs->Add(*(new (std::nothrow) String(MUSIC)));
 529         pArgs->Add(*(new (std::nothrow) Integer(startIndex)));
 530         pArgs->Add(*(__pPresentationModel->GetContentPathListN(USER_CONTENT)));
 531
 532         AppLogDebug("EXIT");
 533         return pArgs;
 534 }
 535
 536 void
 537 UserPlaylistContentListForm::OnThumbnailInfoReveivedN(ThumbnailInfo* pThumbnailInfo)
 538 {
 539         AppLogDebug("ENTER");
 540         __pThumbnail = pThumbnailInfo->GetBitmapN();
 541         Object* pParam = pThumbnailInfo->GetUserParamN();
 542         if (pParam != null)
 543         {
 544                 __pContentListTableView->RefreshItem((static_cast<Integer*>(pParam))->ToInt(), TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 545                 delete pParam;
 546         }
 547
 548         delete pThumbnailInfo;
 549         AppLogDebug("EXIT");
 550 }
 551
 552 void
 553 UserPlaylistContentListForm::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
 554 {
 555         AppLogDebug("ENTER");
 556         ContentListForm::OnUserEventReceivedN(requestId, pArgs);
 557         if (requestId == ID_DESTORY_PLAY_LIST_PICKER_POPUP)
 558         {
 559                 __pPresentationModel->UpdatePlaylistContentList(USER_CONTENT, __headerTitle);
 560                 __pContentListTableView->UpdateTableView();
 561         }
 562         AppLogDebug("EXIT");
 563 }
 564
 565 void
 566 UserPlaylistContentListForm::UpdateItem(int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 567 {
 568         AppLogDebug("ENTER");
 569
 570         if (pItem == null)
 571         {
 572                 AppLogDebug("pItem is null");
 573                 delete __pThumbnail;
 574                 __pThumbnail = null;
 575                 return;
 576         }
 577
 578         Label* pThumbnailLabel = static_cast<Label*>(pItem->GetControl(IDC_CONTENTS_THUMBNAIL, true));
 579         if (__pThumbnail == null || pThumbnailLabel == null)
 580         {
 581                 AppLogDebug("__pThumbnail or pThumbnailLabel is null");
 582                 delete __pThumbnail;
 583                 __pThumbnail = null;
 584                 return;
 585         }
 586
 587         pThumbnailLabel->SetBackgroundBitmap(*__pThumbnail);
 588         delete __pThumbnail;
 589         __pThumbnail = null;
 590         pThumbnailLabel->Invalidate(true);
 591         AppLogDebug("EXIT");
 592 }
 593
 594 int
 595 UserPlaylistContentListForm::GetCheckedItemCount(void)
 596 {
 597         AppLogDebug("ENTER");
 598         AppLogDebug("EXIT");
 599         return __checkedItemCount;
 600 }
 601
 602 void
 603 UserPlaylistContentListForm::UpdateTableView(void)
 604 {
 605         AppLogDebug("ENTER");
 606         __pContentListTableView->UpdateTableView();
 607         AppLogDebug("EXIT");
 608 }
 609
 610 void
 611 UserPlaylistContentListForm::UpdateContentList(void)
 612 {
 613         AppLogDebug("ENTER");
 614         __pPresentationModel->UpdatePlaylistContentList(USER_CONTENT, __headerTitle);
 615
 616         if(__pPresentationModel->GetContentCount() == 0)
 617         {
 618 //              __headerTitle.Clear();
 619                 CommonUtil::SetAddtoPlaylistState(false);
 620 //              CommonUtil::SetAddtoPlaylistName(__headerTitle);
 621                 ToggleScreenState(SCREEN_STATE_NORMAL);
 622         }
 623         else
 624         {
 625                 UpdateTableView();
 626         }
 627
 628         AppLogDebug("EXIT");
 629 }
 630
 631 void
 632 UserPlaylistContentListForm::SetItemCheckedAll(bool isChecked)
 633 {
 634         AppLogDebug("ENTER");
 635         if (isChecked == true)
 636         {
 637                 __checkedItemCount = __pContentListTableView->GetItemCount();
 638         }
 639         else
 640         {
 641                 __checkedItemCount = INIT_VALUE;
 642         }
 643         CommonUtil::SetItemCheckedAll(isChecked, *__pContentListTableView);
 644         if (GetFooter() != null)
 645         {
 646                 CommonUtil::SetFooterItemEnabled(*GetFooter(), isChecked);
 647         }
 648
 649         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 650         AppLogDebug("EXIT");
 651 }
 652
 653 void
 654 UserPlaylistContentListForm::RemoveCheckedTableviewItem(bool itemRemove)
 655 {
 656         AppLogDebug("ENTER");
 657         if (itemRemove)
 658         {
 659                 int totalCount = __pContentListTableView->GetItemCount();
 660                 for (int iCount = 0; iCount < totalCount; iCount++)
 661                 {
 662                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 663                         {
 664                                 __pContentListTableView->SetItemChecked(iCount, false);
 665                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 666                                 if (pContentInfo != null)
 667                                 {
 668                                         RemoveContentAt(pContentInfo->contentId);
 669                                         delete pContentInfo;
 670                                 }
 671                         }
 672                 }
 673         }
 674
 675         __checkedItemCount = INIT_VALUE;
 676         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 677         if (GetFooter() != null)
 678         {
 679                 CommonUtil::SetFooterItemEnabled(*GetFooter(), false);
 680         }
 681         AppLogDebug("EXIT");
 682 }
 683
 684 void
 685 UserPlaylistContentListForm::SetItemCheckedStateChanged(Tizen::Ui::Controls::TableViewItemStatus status)
 686 {
 687         AppLogDebug("ENTER");
 688         if (status == TABLE_VIEW_ITEM_STATUS_UNCHECKED)
 689         {
 690                 __checkedItemCount--;
 691                 if (__checkedItemCount == INIT_VALUE)
 692                 {
 693                         if (GetFooter() != null)
 694                         {
 695                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), false);
 696                         }
 697                 }
 698         }
 699         else if (status == TABLE_VIEW_ITEM_STATUS_CHECKED)
 700         {
 701                 if (__checkedItemCount == INIT_VALUE)
 702                 {
 703                         if (GetFooter() != null)
 704                         {
 705                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), true);
 706                         }
 707                 }
 708
 709                 __checkedItemCount++;
 710         }
 711
 712         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 713         AppLogDebug("EXIT");
 714 }
 715
 716 Tizen::Base::Collection::IList*
 717 UserPlaylistContentListForm::GetPickerArgumentListN(PickerType pickerType, PickerArgumentType argumentType)
 718 {
 719         AppLogDebug("ENTER");
 720         Tizen::Base::Collection::ArrayList* pContentFilePathList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 721         if (IsFailed(pContentFilePathList->Construct()))
 722         {
 723                 AppLogDebug("pContentList->Construct failed(%s)", GetErrorMessage(GetLastResult()));
 724                 delete pContentFilePathList;
 725                 return null;
 726         }
 727
 728         if (argumentType == PICKER_ARGUMENT_TYPE_ACTIVATED_STATE_CONTEXT_ITEM)
 729         {
 730                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(__activatedStateContextItem);
 731                 if (pContentInfo == null)
 732                 {
 733                         delete pContentFilePathList;
 734                         AppLogDebug("GetContentInfoN(%d) is null", __activatedStateContextItem);
 735                         return null;
 736                 }
 737
 738                 pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 739                 delete pContentInfo;
 740         }
 741         else if (argumentType == PICKER_ARGUMENT_TYPE_CHECKED_ITEM_ALL)
 742         {
 743                 int totalCount = __pContentListTableView->GetItemCount();
 744                 for (int iCount = 0; iCount < totalCount; iCount++)
 745                 {
 746                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 747                         {
 748                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 749                                 if (pContentInfo == null)
 750                                 {
 751                                         AppLogDebug("GetContentInfoN(%d) is null", iCount);
 752                                         delete pContentFilePathList;
 753                                         return null;
 754                                 }
 755
 756                                 if (pickerType == PICKER_TYPE_PLAY_LIST_PICKER)
 757                                 {
 758                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 759                                 }
 760                                 else if (pickerType == PICKER_TYPE_SHARE_PICKER)
 761                                 {
 762                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 763                                 }
 764                                 delete pContentInfo;
 765                         }
 766                 }
 767         }
 768         AppLogDebug("EXIT");
 769         return pContentFilePathList;
 770 }
 771
 772 void
 773 UserPlaylistContentListForm::OnFormBackRequested(Tizen::Ui::Controls::Form& source)
 774 {
 775         AppLogDebug("ENTER");
 776         if (GetScreenState() != SCREEN_STATE_NORMAL)
 777         {
 778                 ToggleScreenState(SCREEN_STATE_NORMAL);
 779                 AppLogDebug("EXIT");
 780                 return;
 781         }
 782
 783         SceneManager* pSceneManager = SceneManager::GetInstance();
 784         AppAssert(pSceneManager);
 785         pSceneManager->GoBackward(BackwardSceneTransition(), null);
 786         AppLogDebug("EXIT");
 787 }
 788
 789 void
 790 UserPlaylistContentListForm::OnFormMenuRequested(Tizen::Ui::Controls::Form& source)
 791 {
 792         if (GetScreenState() == SCREEN_STATE_NORMAL)
 793         {
 794                 CreateOptionMenuN(source);
 795                 if (IsEmptyContentList())
 796                 {
 797                         SetOptionMenuItem(CONTEXT_MENU_ITEM_STYLE_ADD);
 798                 }
 799                 else
 800                 {
 801                         SetOptionMenuItem(CONTEXT_MENU_ITEM_STYLE_ADD | CONTEXT_MENU_ITEM_STYLE_SHARE_VIA | CONTEXT_MENU_ITEM_STYLE_EDIT);
 802                 }
 803         }
 804 }
 805
 806 void
 807 UserPlaylistContentListForm::OnFontSizeChanged(void)
 808 {
 809         __fontSizeValue = CommonUtil::GetFontSizeValue();
 810         __itemHeight = CommonUtil::GetItemHeight(__fontSizeValue);
 811         __pContentListTableView->UpdateTableView();
 812 }