src/GlAlbumListEditorForm.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                GlAlbumListEditorForm.cpp
  19  * @brief               This is the implementation file for AlbumListEditorForm class.
  20  */
  21
  22 #include "GlAlbumInfo.h"
  23 #include "GlAlbumListEditorForm.h"
  24 #include "GlAlbumListPresentationModel.h"
  25 #include "GlResourceManager.h"
  26 #include "GlTypes.h"
  27
  28 using namespace Tizen::App;
  29 using namespace Tizen::Base;
  30 using namespace Tizen::Base::Collection;
  31 using namespace Tizen::Content;
  32 using namespace Tizen::Graphics;
  33 using namespace Tizen::Io;
  34 using namespace Tizen::Media;
  35 using namespace Tizen::System;
  36 using namespace Tizen::Ui;
  37 using namespace Tizen::Ui::Controls;
  38 using namespace Tizen::Ui::Scenes;
  39
  40 static const unsigned int COLOR_DELETE_BUTTON_NORMAL = Color32<208, 82, 82>::Value;
  41 static const unsigned int COLOR_DELETE_BUTTON_PRESSED = Color32<194, 71, 71>::Value;
  42 static const unsigned int COLOR_DELETE_BUTTON_TEXT = Color32<248, 246, 239>::Value;
  43 static const String RESERVED_CAMERA_PATH = Environment::GetMediaPath() + L"Camera" + DIRECTORY_SEPARATOR;
  44 static const String RESERVED_CAMERA_PATH_EXT = Environment::GetExternalStoragePath() + L"Camera" + DIRECTORY_SEPARATOR;
  45 static const String RESERVED_MEDIA_PATH = Environment::GetMediaPath();
  46 static const String RESERVED_EXTERNAL_MEDIA_PATH = Environment::GetExternalStoragePath();
  47
  48 static const int GAP_W_POPUP_ITEM = 5;
  49 static const int W_DELETE_POPUP = 620;
  50 static const int H_DELETE_POPUP = 300;
  51 static const int H_DELETE_LABEL = 180;
  52 static const int Y_DELETE_BUTTON = 180;
  53 static const int H_DELETE_BUTTON = 80;
  54
  55 static const int FORMAT_BUFFER_SIZE = 256;
  56
  57 static const Color COLOR_FOLDER_BITMAP_DIM(Color::GetColor(COLOR_ID_BLACK));
  58 static const int ALPHA_FOLDER_BITMAP_DIM = 70;
  59
  60 static const int IDA_ALBUM_EDIT = 503;
  61
  62 AlbumListEditorForm::AlbumListEditorForm(void)
  63         : __checkedCount(0)
  64         , __pSelectCountLabel(null)
  65         , __pEditorFolderIconList(null)
  66         , __pShareContextMenu(null)
  67         , __pDeletePopup(null)
  68         , __pFileUpdateTimer(null)
  69         , __pPresentationModel(null)
  70 {
  71         AppLogDebug("ENTER");
  72         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
  73 }
  74
  75 AlbumListEditorForm::~AlbumListEditorForm(void)
  76 {
  77         AppLogDebug("ENTER");
  78         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
  79 }
  80
  81 result
  82 AlbumListEditorForm::Initialize(void)
  83 {
  84         AppLogDebug("ENTER");
  85         result r = Form::Construct(IDL_FORM_ALBUM_LIST_EDITOR);
  86         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
  87
  88         return r;
  89 }
  90
  91 result
  92 AlbumListEditorForm::OnInitializing(void)
  93 {
  94         AppLogDebug("ENTER");
  95         result r = E_SUCCESS;
  96
  97         SetOrientation(ORIENTATION_AUTOMATIC);
  98         AddOrientationEventListener(*this);
  99
 100         __pPresentationModel = AlbumListPresentationModel::GetInstance();
 101         __pPresentationModel->ClearThumbnailRequests();
 102         r = __pPresentationModel->AddPresentationModelListener(this);
 103
 104         SetFormBackEventListener(this);
 105         GetHeader()->AddActionEventListener(*this);
 106         GetFooter()->AddActionEventListener(*this);
 107
 108         r = InitializeControl();
 109         if (r != E_SUCCESS)
 110         {
 111                 AppLogDebug("[%s] Unable to set InitializeControl.", GetErrorMessage(r));
 112         }
 113
 114         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 115
 116         return r;
 117 }
 118
 119 result
 120 AlbumListEditorForm::OnTerminating(void)
 121 {
 122         AppLogDebug("ENTER");
 123         result r = E_SUCCESS;
 124         r = __pPresentationModel->RemovePresentationModelListener(*this);
 125         __pPresentationModel->RemoveContentEventListener(*this);
 126
 127         if (__pDeletePopup != null)
 128         {
 129                 delete __pDeletePopup;
 130                 __pDeletePopup = null;
 131         }
 132         if (__pFileUpdateTimer != null)
 133         {
 134                 delete __pFileUpdateTimer;
 135                 __pFileUpdateTimer = null;
 136         }
 137         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 138
 139         return r;
 140 }
 141
 142 void
 143 AlbumListEditorForm::OnContentUpdated(void)
 144 {
 145         AppLogDebug("ENTER");
 146         int maxCount = __pPresentationModel->GetFolderCount();
 147         if (__pDeletePopup != null)
 148         {
 149                 if (__pDeletePopup->IsVisible() == true)
 150                 {
 151                         __pDeletePopup->Destroy();
 152                         __pDeletePopup = null;
 153                         InitializePopup();
 154                 }
 155         }
 156
 157         for (int i = 0; i < maxCount; ++i)
 158         {
 159                 __pEditorFolderIconList->SetItemChecked(i, false);
 160         }
 161         SceneManager* pSceneManager = SceneManager::GetInstance();
 162         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_ALBUM_LIST));
 163         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 164 }
 165
 166 result
 167 AlbumListEditorForm::InitializeControl(void)
 168 {
 169         AppLogDebug("ENTER");
 170         result r = E_SUCCESS;
 171         String tempString;
 172
 173         __pSelectCountLabel = static_cast<Label*>(GetControl(L"IDC_LABEL_ALBUM_LIST_EDITOR_SELECTED"));
 174                 AppAssert(__pSelectCountLabel);
 175
 176         CreateIconListView();
 177         __checkedCount = GetCheckedFolderCount();
 178
 179
 180         r = InitializePopup();
 181         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 182
 183         return r;
 184 }
 185
 186 result
 187 AlbumListEditorForm::InitializePopup(void)
 188 {
 189         AppLogDebug("ENTER");
 190         if (__pDeletePopup == null)
 191         {
 192                 __pDeletePopup = new (std::nothrow) Popup();
 193                 __pDeletePopup->Construct(false, Dimension(W_DELETE_POPUP, H_DELETE_POPUP));
 194                 __pDeletePopup->SetPropagatedKeyEventListener(this);
 195
 196                 Rectangle popupClientBounds = __pDeletePopup->GetClientAreaBounds();
 197
 198                 Label* pLabel = new (std::nothrow) Label();
 199                 pLabel->Construct(Rectangle(0, 0, popupClientBounds.width, H_DELETE_LABEL),
 200                                 ResourceManager::GetString(L"IDS_COM_POP_DELETE_Q"));
 201                 pLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 202                 pLabel->SetTextConfig(34,LABEL_TEXT_STYLE_BOLD);
 203
 204                 Button* pDeleteButton = new (std::nothrow) Button();
 205                 pDeleteButton->Construct(Rectangle(popupClientBounds.width / 2 + GAP_W_POPUP_ITEM, Y_DELETE_BUTTON,     popupClientBounds.width / 2 - GAP_W_POPUP_ITEM -10, H_DELETE_BUTTON),
 206                                 ResourceManager::GetString(L"IDS_COM_BODY_DELETE"));
 207                 pDeleteButton->SetColor(BUTTON_STATUS_NORMAL, COLOR_DELETE_BUTTON_NORMAL);
 208                 pDeleteButton->SetColor(BUTTON_STATUS_PRESSED, COLOR_DELETE_BUTTON_PRESSED);
 209                 pDeleteButton->SetTextColor(COLOR_DELETE_BUTTON_TEXT);
 210                 pDeleteButton->SetActionId(IDA_DELETE_POPUP_DEL);
 211                 pDeleteButton->AddActionEventListener(*this);
 212
 213                 Button* pCancelButton = new (std::nothrow) Button();
 214                 pCancelButton->Construct(Rectangle(10, Y_DELETE_BUTTON, popupClientBounds.width / 2 - GAP_W_POPUP_ITEM -10, H_DELETE_BUTTON),
 215                                 ResourceManager::GetString(L"IDS_COM_POP_CANCEL"));
 216                 pCancelButton->SetActionId(IDA_DELETE_POPUP_CANCEL);
 217                 pCancelButton->AddActionEventListener(*this);
 218
 219                 __pDeletePopup->AddControl(pLabel);
 220                 __pDeletePopup->AddControl(pDeleteButton);
 221                 __pDeletePopup->AddControl(pCancelButton);
 222         }
 223         else
 224         {
 225                 __pDeletePopup->SetShowState(true);
 226                 __pDeletePopup->Show();
 227         }
 228         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 229
 230         return E_SUCCESS;
 231 }
 232
 233 void
 234 AlbumListEditorForm::CreateIconListView(void)
 235 {
 236         AppLogDebug("ENTER");
 237
 238
 239         __pEditorFolderIconList = new IconListView();
 240         __pEditorFolderIconList->Construct(Rectangle(0, 0, GetClientAreaBounds().width, GetClientAreaBounds().height - __pSelectCountLabel->GetHeight()),
 241                     Dimension(348, 348), ICON_LIST_VIEW_STYLE_MARK, ICON_LIST_VIEW_SCROLL_DIRECTION_VERTICAL);
 242         __pEditorFolderIconList->SetCheckBoxPosition(ICON_LIST_VIEW_CHECK_BOX_POSITION_TOP_LEFT);
 243         __pEditorFolderIconList->SetTouchAnimationEnabled(false);
 244         __pEditorFolderIconList->SetItemProvider(*this);
 245         __pEditorFolderIconList->SetItemBorderStyle(ICON_LIST_VIEW_ITEM_BORDER_STYLE_NONE);
 246         __pEditorFolderIconList->AddIconListViewItemEventListener(*this);
 247
 248         Bitmap* pBitmap = ResourceManager::GetBitmapN(IDB_LISTVIEW_EMPTY);
 249
 250         if (pBitmap != null)
 251         {
 252                 __pEditorFolderIconList->SetBitmapOfEmptyList(pBitmap);
 253                 delete pBitmap;
 254         }
 255
 256         __pEditorFolderIconList->SetTextOfEmptyList(ResourceManager::GetString(L"IDS_COM_BODY_NO_ITEMS"));
 257
 258         AddControl(__pEditorFolderIconList);
 259
 260         __pEditorFolderIconList->SetShowState(true);
 261
 262         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 263 }
 264
 265 int
 266 AlbumListEditorForm::GetItemCount(void)
 267 {
 268         AppLogDebug("ENTER");
 269         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 270
 271         return __pPresentationModel->GetFolderCount();
 272 }
 273
 274 IconListViewItem*
 275 AlbumListEditorForm::CreateItem(int index)
 276 {
 277         AppLogDebug("ENTER : index(%d)", index);
 278         Bitmap* pBitmap = null;
 279         Canvas* pEditAlbumCanvas = null;
 280         Bitmap* pEditAlbumBitmap = null;
 281         Bitmap* pBitmapRenameBg = null;
 282         Bitmap* pBitmapRename = null;
 283         String albumName;
 284         int canvasWidth = 75;
 285         int canvasHeight = 75;
 286
 287         IconListViewItem* pIconListviewItem = new (std::nothrow) IconListViewItem();
 288
 289         IList* pAlbumInfoList = __pPresentationModel->GetAlbumInfoList();
 290         AlbumInfo* pAlbumInfo = static_cast<AlbumInfo*>(pAlbumInfoList->GetAt(index));
 291
 292         Bitmap* pAlbumBitmap = pAlbumInfo->GetFolderThumnailBitmap();
 293         if (pAlbumBitmap == null)
 294         {
 295                 __pPresentationModel->RequestThumbnail(index, 0);
 296         }
 297
 298         pBitmap = __pPresentationModel->CreateMergeBitmapN(index);
 299
 300         if (__pEditorFolderIconList->IsItemChecked(index) == true)
 301         {
 302                 if (pBitmap != null)
 303                 {
 304                         BufferInfo bufferInfo;
 305                         pBitmap->Lock(bufferInfo, INFINITE);
 306                         pBitmap->Unlock();
 307                         Color dimColor(COLOR_FOLDER_BITMAP_DIM);
 308                         dimColor.SetAlpha(ALPHA_FOLDER_BITMAP_DIM);
 309                         Canvas canvas;
 310                         canvas.Construct(bufferInfo);
 311                         canvas.FillRectangle(dimColor, canvas.GetBounds());
 312                         Bitmap* pSelectedBitmap = new (std::nothrow) Bitmap();
 313                         pSelectedBitmap->Construct(canvas, canvas.GetBounds());
 314                         pIconListviewItem->Construct(*pBitmap, null, pSelectedBitmap);
 315                         delete pSelectedBitmap;
 316                 }
 317         }
 318         else
 319         {
 320                 pIconListviewItem->Construct(*pBitmap);
 321         }
 322
 323         if (pBitmap != null)
 324         {
 325                 delete pBitmap;
 326         }
 327
 328         pBitmapRenameBg = ResourceManager::GetBitmapN(IDB_ALBUM_EDIT_RENAME_BG);
 329         pBitmapRename = ResourceManager::GetBitmapN(IDB_ALBUM_EDIT_RENAME);
 330
 331         if (pBitmapRenameBg != null && pBitmapRename != null)
 332         {
 333
 334                 pEditAlbumCanvas = new (std::nothrow) Canvas();
 335                 pEditAlbumCanvas->Construct(Rectangle(0, 0, canvasWidth, canvasHeight));
 336                 pEditAlbumCanvas->DrawBitmap(Point(0, 6), *pBitmapRenameBg);
 337                 pEditAlbumCanvas->DrawBitmap(Point(0, 6), *pBitmapRename);
 338
 339
 340                 pEditAlbumBitmap = new (std::nothrow) Bitmap();
 341
 342                 if (pEditAlbumBitmap != NULL)
 343                 {
 344                         pEditAlbumBitmap->Construct(*pEditAlbumCanvas, Rectangle(0, 0, canvasWidth, canvasHeight));
 345
 346                 }
 347                 delete pEditAlbumCanvas;
 348
 349                 albumName = pAlbumInfo->GetAlbumName();
 350                 String reservedCameraName = ResourceManager::GetString(L"IDS_MEDIABR_BODY_CAMERA_ROLL_ABB");
 351                 String albumPath = pAlbumInfo->GetDirectory(0);
 352                 albumPath.Append(DIRECTORY_SEPARATOR);
 353
 354                 if (index == 0 || (reservedCameraName.Equals(albumName, true) &&
 355                         (RESERVED_CAMERA_PATH.Equals(albumPath, true) || RESERVED_CAMERA_PATH_EXT.Equals(albumPath, true)))
 356                         || RESERVED_MEDIA_PATH.Equals(albumPath, true) || RESERVED_EXTERNAL_MEDIA_PATH.Equals(albumPath, true))
 357                 {
 358                         // rename disabled
 359                 }
 360                 else
 361                 {
 362                         pIconListviewItem->SetOverlayBitmap(IDA_ALBUM_EDIT, pEditAlbumBitmap, ALIGNMENT_RIGHT, ALIGNMENT_TOP);
 363                 }
 364
 365                 if (pEditAlbumBitmap != null)
 366                 {
 367                         delete pEditAlbumBitmap;
 368                 }
 369         }
 370
 371         if (pBitmapRenameBg)
 372         {
 373                 delete pBitmapRenameBg;
 374         }
 375         if (pBitmapRename)
 376         {
 377                 delete pBitmapRename;
 378         }
 379
 380         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 381
 382         return pIconListviewItem;
 383 }
 384
 385 void
 386 AlbumListEditorForm::OnIconListViewItemStateChanged(IconListView& view, int index, IconListViewItemStatus status)
 387 {
 388         AppLogDebug("ENTER");
 389
 390         if (status == ICON_LIST_VIEW_ITEM_CHECKED || status == ICON_LIST_VIEW_ITEM_UNCHECKED)
 391         {
 392                 if (status == ICON_LIST_VIEW_ITEM_CHECKED)
 393                 {
 394                         ++__checkedCount;
 395                 }
 396                 else if (status == ICON_LIST_VIEW_ITEM_UNCHECKED)
 397                 {
 398                         --__checkedCount;
 399                 }
 400
 401                 String tempString;
 402                 if (__checkedCount == 0)
 403                 {
 404                         tempString = ResourceManager::GetString(L"IDS_ST_POP_NO_ITEMS_SELECTED");
 405                 }
 406                 else if (__checkedCount == 1)
 407                 {
 408                         tempString = ResourceManager::GetString(L"IDS_VR_POP_1_ITEM_SELECTED");
 409                 }
 410                 else
 411                 {
 412                         tempString.Format(FORMAT_BUFFER_SIZE, ResourceManager::GetString(L"IDS_VR_POP_PD_ITEMS_SELECTED").GetPointer(), __checkedCount);
 413                 }
 414
 415                 __pSelectCountLabel->SetText(tempString);
 416                 __pSelectCountLabel->RequestRedraw();
 417                 __pEditorFolderIconList->RefreshList(index, LIST_REFRESH_TYPE_ITEM_MODIFY);
 418         }
 419
 420         SetButtonState();
 421         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 422 }
 423
 424 void
 425 AlbumListEditorForm::OnIconListViewOverlayBitmapSelected (IconListView &iconListView, int index,
 426                 int overlayBitmapId)
 427 {
 428         AppLogDebug("ENTER");
 429         SceneManager* pSceneManager = SceneManager::GetInstance();
 430
 431         ArrayList* pSelectedIndex = new (std::nothrow) ArrayList(SingleObjectDeleter);
 432         pSelectedIndex->Construct();
 433         //Adding the Action Type
 434         pSelectedIndex->Add(new (std::nothrow) Integer(ALBUM_RENAME));
 435         pSelectedIndex->Add(new (std::nothrow) Integer(FILE_ACTION_MOVE));
 436         pSelectedIndex->Add(new (std::nothrow) Integer(index));
 437
 438         if (__pEditorFolderIconList->IsItemChecked(index) == false)
 439         {
 440                 __pEditorFolderIconList->SetItemChecked(index,true);
 441         }
 442         else
 443         {
 444                 __pEditorFolderIconList->SetItemChecked(index,false);
 445         }
 446         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_ALBUM_NAME_EDITOR), pSelectedIndex);
 447         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 448 }
 449
 450 bool
 451 AlbumListEditorForm::DeleteItem(int index, IconListViewItem* pItem)
 452 {
 453         AppLogDebug("ENTER");
 454         delete pItem;
 455         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 456
 457         return true;
 458 }
 459
 460 result
 461 AlbumListEditorForm::DeleteFolder(void)
 462 {
 463
 464         AppLogDebug("ENTER");
 465         IList* pIndexList = GetItemCheckedIndexListN();
 466         if (pIndexList->GetCount() <= 0)
 467         {
 468                 delete pIndexList;
 469                 AppLogDebug("EXIT 1(%s)", GetErrorMessage(GetLastResult()));
 470                 return E_FAILURE;
 471         }
 472
 473         if (__pFileUpdateTimer != null)
 474         {
 475                 delete __pFileUpdateTimer;
 476         }
 477         __pFileUpdateTimer = new (std::nothrow) FileUpdateTimer(pIndexList, __pPresentationModel, this, FILE_ACTION_DELETE);
 478         result r = __pFileUpdateTimer->StartTimer();
 479
 480         if (IsFailed(r))
 481         {
 482                 delete __pFileUpdateTimer;
 483                 __pFileUpdateTimer = null;
 484                 return E_FAILURE;
 485         }
 486         else
 487         {
 488                 __pPresentationModel->SetUpdateProgressStatus(true);
 489         }
 490         return E_SUCCESS;
 491 }
 492
 493 IList*
 494 AlbumListEditorForm::GetItemCheckedIndexListN(void) const
 495 {
 496         AppLogDebug("ENTER");
 497         IList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 498         Integer* pIndex = null;
 499
 500         if (__pEditorFolderIconList!=null)
 501         {
 502                 int loopCount = __pPresentationModel->GetFolderCount();
 503                 for (int i = 0; i < loopCount; ++i)
 504                 {
 505                         if (__pEditorFolderIconList->IsItemChecked(i) == true)
 506                         {
 507                                 pIndex = new (std::nothrow) Integer(i);
 508                                 pList->Add(pIndex);
 509                                 AppLogDebug("checked index(%d)", i);
 510                         }
 511                 }
 512         }
 513         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 514
 515         return pList;
 516 }
 517
 518 void
 519 AlbumListEditorForm::SetAllCheckState(const bool state)
 520 {
 521         AppLogDebug("ENTER");
 522
 523         int maxCount = __pPresentationModel->GetFolderCount();
 524         String tempString;
 525
 526         if (state == true)
 527         {
 528                 if (maxCount == 1)
 529                 {
 530                         tempString = ResourceManager::GetString(L"IDS_VR_POP_1_ITEM_SELECTED;");
 531                 }
 532                 else
 533                 {
 534                         tempString.Format(FORMAT_BUFFER_SIZE,
 535                                         ResourceManager::GetString(L"IDS_VR_POP_PD_ITEMS_SELECTED").GetPointer(), maxCount);
 536                 }
 537         }
 538         else
 539         {
 540                 tempString = ResourceManager::GetString(L"IDS_ST_POP_NO_ITEMS_SELECTED");
 541         }
 542
 543         for (int i = 0; i < maxCount; ++i)
 544         {
 545                 __pEditorFolderIconList->SetItemChecked(i, state);
 546                 __pEditorFolderIconList->RefreshList(i, LIST_REFRESH_TYPE_ITEM_MODIFY);
 547         }
 548
 549         __pEditorFolderIconList->Draw();
 550         __pSelectCountLabel->SetText(tempString);
 551         __pSelectCountLabel->RequestRedraw();
 552         __checkedCount = GetCheckedFolderCount();
 553
 554         SetButtonState();
 555
 556         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 557 }
 558
 559 int
 560 AlbumListEditorForm::GetCheckedFolderCount(void) const
 561 {
 562         AppLogDebug("ENTER");
 563         int maxCount = __pPresentationModel->GetFolderCount();
 564         int count = 0;
 565
 566         for (int i = 0; i < maxCount; ++i)
 567         {
 568                 if (__pEditorFolderIconList->IsItemChecked (i))
 569                 {
 570                         ++count;
 571                 }
 572         }
 573         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 574
 575         return count;
 576 }
 577
 578 void
 579 AlbumListEditorForm::OnActionPerformed(const Control& source, int actionId)
 580 {
 581         AppLogDebug("ENTER");
 582         switch (actionId)
 583         {
 584         case IDA_ALBUM_LIST_SELECT_ALL:
 585         {
 586                 if (__pPresentationModel->GetFolderCount() == GetCheckedFolderCount())
 587                 {
 588                         SetAllCheckState(false);
 589                 }
 590                 else
 591                 {
 592                         SetAllCheckState(true);
 593                 }
 594         }
 595         break;
 596
 597         case IDA_FOOTER_DELETE:
 598         {
 599                 __pDeletePopup->SetShowState(true);
 600                 __pDeletePopup->Show();
 601         }
 602         break;
 603
 604         case IDA_FOOTER_SHARE:
 605         {
 606
 607                 if (__pShareContextMenu != NULL)
 608                 {
 609                         delete __pShareContextMenu;
 610                         __pShareContextMenu = null;
 611                 }
 612
 613
 614                 Bitmap* pBitmapEmailContextItem = null;
 615                 Bitmap* pBitmapMessageContextItem = null;
 616                 pBitmapEmailContextItem = ResourceManager::GetBitmapN(IDB_IMAGE_CONTEXT_EMAIL_ICON);
 617                 pBitmapMessageContextItem = ResourceManager::GetBitmapN(IDB_IMAGE_CONTEXT_MESSAGE_ICON);
 618
 619                 __pShareContextMenu = new (std::nothrow) ContextMenu();
 620                 __pShareContextMenu->Construct(Point(GetClientAreaBounds().width/3 + 15, GetClientAreaBounds().height + __pSelectCountLabel->GetHeight() + 5),
 621                                 CONTEXT_MENU_STYLE_LIST, CONTEXT_MENU_ANCHOR_DIRECTION_UPWARD);
 622
 623                 if ( pBitmapMessageContextItem != null)
 624                 {
 625                  __pShareContextMenu->AddItem(ResourceManager::GetString(L"IDS_COM_BODY_MESSAGE"),
 626                                 IDA_CONTEXT_MENU_MESSAGE , *pBitmapMessageContextItem, null, null);
 627
 628                          delete pBitmapMessageContextItem;
 629                 }
 630
 631                 if ( pBitmapEmailContextItem != null)
 632                 {
 633                         __pShareContextMenu->AddItem(ResourceManager::GetString(L"IDS_COM_BODY_EMAIL"), IDA_CONTEXT_MENU_EMAIL,
 634                                         *pBitmapEmailContextItem, null, null);
 635
 636                          delete pBitmapEmailContextItem;
 637                 }
 638
 639                 __pShareContextMenu->SetFocusable(true);
 640                 __pShareContextMenu->AddActionEventListener(*this);
 641                 __pShareContextMenu->SetShowState(true);
 642                 __pShareContextMenu->Show();
 643         }
 644         break;
 645
 646         case IDA_CONTEXT_MENU_MESSAGE:
 647         {
 648                 OnRequestMessage();
 649         }
 650         break;
 651
 652         case IDA_CONTEXT_MENU_EMAIL:
 653         {
 654                 OnRequestEmail();
 655         }
 656         break;
 657
 658         case IDA_DELETE_POPUP_DEL:
 659         {
 660                 __pDeletePopup->SetShowState(false);
 661                 __pDeletePopup->Show();
 662                 DeleteFolder();
 663         }
 664         break;
 665
 666         case IDA_DELETE_POPUP_CANCEL:
 667         {
 668                 __pDeletePopup->SetShowState(false);
 669                 __pDeletePopup->Show();
 670         }
 671         break;
 672
 673         default:
 674                 break;
 675         }
 676         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 677 }
 678
 679 void
 680 AlbumListEditorForm::OnFormBackRequested(Form& source)
 681 {
 682         AppLogDebug("ENTER");
 683         SceneManager* pSceneManager = SceneManager::GetInstance();
 684         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_ALBUM_LIST));
 685         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 686 }
 687
 688 void
 689 AlbumListEditorForm::OnSceneActivatedN(const SceneId& previousSceneId,
 690                 const SceneId& currentSceneId, IList* pArgs)
 691 {
 692         AppLogDebug("ENTER OnSceneActivatedN");
 693         String tempString;
 694
 695
 696         int count = __pPresentationModel->GetFolderCount();
 697
 698         __pPresentationModel->AddContentEventListener(this);
 699
 700         __checkedCount = GetCheckedFolderCount();
 701
 702         if (previousSceneId == IDSCN_ALBUM_NAME_EDITOR)
 703         {
 704
 705                 if (__checkedCount ==  0)
 706                 {
 707                         tempString = ResourceManager::GetString(L"IDS_ST_POP_NO_ITEMS_SELECTED");
 708                 }
 709                 else
 710                 {
 711                         tempString.Format(FORMAT_BUFFER_SIZE,
 712                                         ResourceManager::GetString(L"IDS_VR_POP_PD_ITEMS_SELECTED").GetPointer(), __checkedCount);
 713                 }
 714         }
 715         else
 716         {
 717                 __pPresentationModel->InitializeAlbumInfoList(CONTENT_TYPE_ALL);
 718
 719                 for (int index = 0; index < count; ++index)
 720                 {
 721                         __pEditorFolderIconList->SetItemChecked(index,false);
 722                 }
 723
 724                 __pEditorFolderIconList->UpdateList();
 725
 726                 tempString = ResourceManager::GetString(L"IDS_ST_POP_NO_ITEMS_SELECTED");
 727         }
 728
 729         __pSelectCountLabel->SetText(tempString);
 730         __pSelectCountLabel->Invalidate(true);
 731
 732         SetButtonState();
 733         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 734 }
 735
 736 void
 737 AlbumListEditorForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 738 {
 739         AppLogDebug("ENTER");
 740         __pPresentationModel->RemoveContentEventListener(*this);
 741
 742         if (nextSceneId != IDSCN_ALBUM_NAME_EDITOR)
 743         {
 744                 int loopCount = __pPresentationModel->GetFolderCount();
 745
 746                 for (int count = 0; count < loopCount; ++count)
 747                 {
 748                         __pEditorFolderIconList->SetItemChecked(count,false);
 749                 }
 750                 __pEditorFolderIconList->UpdateList();
 751         }
 752
 753         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 754 }
 755
 756 void
 757 AlbumListEditorForm::OnFileInfoChanged(const ContentType contentType)
 758 {
 759         AppLogDebug("ENTER");
 760         Update();
 761         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 762 }
 763
 764 void
 765 AlbumListEditorForm::OnThumbnailDecoded(const int index)
 766 {
 767         AppLogDebug("ENTER : index(%d)", index);
 768         __pEditorFolderIconList->RefreshList(index, LIST_REFRESH_TYPE_ITEM_MODIFY);
 769         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 770 }
 771
 772 void AlbumListEditorForm::OnFileOpInvalidate(enum FileActionMode actionId)
 773 {
 774         Invalidate(true);
 775 }
 776
 777 void AlbumListEditorForm::OnFileOpComplete(enum FileActionMode actionId, enum FileActionCompleteRes res)
 778 {
 779         AppLogDebug("ENTER");
 780         __pPresentationModel->SetUpdateProgressStatus(false);
 781         SetAllCheckState(false);
 782         __pPresentationModel->InitializeAlbumInfoList(CONTENT_TYPE_ALL);
 783         __pEditorFolderIconList->UpdateList();
 784
 785         SceneManager* pSceneManager = SceneManager::GetInstance();
 786         AppAssert(pSceneManager);
 787         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_ALBUM_LIST));
 788         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 789 }
 790
 791 bool AlbumListEditorForm::OnKeyReleased(Control& source, const Tizen::Ui::KeyEventInfo& keyEventInfo)
 792 {
 793         AppLogDebug("ENTER");
 794
 795         if (keyEventInfo.GetKeyCode() == KEY_BACK || keyEventInfo.GetKeyCode() == KEY_ESC)
 796         {
 797                 __pDeletePopup->SetShowState(false);
 798                 __pDeletePopup->Show();
 799         }
 800         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 801         return false;
 802 }
 803
 804 result
 805 AlbumListEditorForm::Update(void)
 806 {
 807         AppLogDebug("ENTER");
 808         result r = __pEditorFolderIconList->UpdateList();
 809         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 810
 811         return r;
 812 }
 813
 814 void
 815 AlbumListEditorForm::OnRequestMessage(void)
 816 {
 817         AppLogDebug("ENTER");
 818
 819         int checkCount = GetCheckedFolderCount();
 820
 821         if (checkCount <= 0)
 822         {
 823                 AppLogDebug("EXIT 1(%s)", GetErrorMessage(GetLastResult()));
 824
 825                 return;
 826         }
 827
 828         IList* pAlbumInfoList = __pPresentationModel->GetAlbumInfoList();
 829
 830         int maxCount = __pPresentationModel->GetFolderCount();
 831         ContentManager contentManager;
 832         result r = contentManager.Construct();
 833         if (r == E_SUCCESS)
 834         {
 835                 if (maxCount <= 0)
 836                 {
 837                         AppLogDebug("EXIT 2(%s)", GetErrorMessage(GetLastResult()));
 838                         return;
 839                 }
 840
 841                 ArrayList* pArrayList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 842                 pArrayList->Construct();
 843                 for (int i = 0; i < maxCount; ++i)
 844                 {
 845                         if (__pEditorFolderIconList->IsItemChecked (i))
 846                         {
 847                                 AlbumInfo* pAlbumInfo = static_cast<AlbumInfo*>(pAlbumInfoList->GetAt(i));
 848                                 IList* pContentIdList = pAlbumInfo->GetContentIdListN();
 849                                 int loopCount = pContentIdList->GetCount();
 850                                 for (int k = 0; k < loopCount; ++k)
 851                                 {
 852                                         ContentId* pContentId = static_cast<ContentId*>(pContentIdList->GetAt(k));
 853                                         ContentInfo* pContentInfo = contentManager.GetContentInfoN(*pContentId);
 854
 855                                         if (pContentInfo == null)
 856                                         {
 857                                                 break;
 858                                         }
 859
 860                                         pArrayList->Add(new (std::nothrow) String(pContentInfo->GetContentPath()));
 861                                 }
 862
 863                                 if (i == 0)
 864                                 {
 865                                         break;
 866                                 }
 867                         }
 868                 }
 869
 870                 HashMap* pDataList = new (std::nothrow) HashMap(SingleObjectDeleter);
 871                 pDataList->Construct();
 872                 pDataList->Add(new (std::nothrow) String(APPCONTROL_KEY_MESSAGE_TYPE), new (std::nothrow) String(APPCONTROL_DATA_MMS));
 873                 pDataList->Add(new (std::nothrow) String(APPCONTROL_KEY_PATH), (Object*)pArrayList);
 874
 875                 r = __pPresentationModel->StartAppControl(APPCONTROL_PROVIDER_ID_MESSAGE, APPCONTROL_OPERATION_ID_COMPOSE,
 876                                 null, null, pDataList, null);
 877
 878                 if (r == E_MAX_EXCEEDED)
 879                 {
 880                         MessageBox messageBox;
 881                         messageBox.Construct(L"", ResourceManager::GetString(L"IDS_RCS_BODY_MAXIMUM_NUMBER_OF_FILES_EXCEEDED"),
 882                                         MSGBOX_STYLE_NONE, 3000);
 883                         int modalResult;
 884                         messageBox.ShowAndWait(modalResult);
 885                 }
 886         }
 887         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 888 }
 889
 890 void
 891 AlbumListEditorForm::OnRequestEmail(void)
 892 {
 893         AppLogDebug("ENTER");
 894
 895         int checkCount = GetCheckedFolderCount();
 896
 897         if (checkCount <= 0)
 898         {
 899                 AppLogDebug("EXIT 1(%s)", GetErrorMessage(GetLastResult()));
 900
 901                 return;
 902         }
 903
 904         IList* pAlbumInfoList = __pPresentationModel->GetAlbumInfoList();
 905
 906         int maxCount = __pPresentationModel->GetFolderCount();
 907         ContentManager contentManager;
 908         result r = contentManager.Construct();
 909         if (r == E_SUCCESS)
 910         {
 911                 if (maxCount <= 0)
 912                 {
 913                         AppLogDebug("EXIT 2(%s)", GetErrorMessage(GetLastResult()));
 914                         return;
 915                 }
 916
 917                 ArrayList* pArrayList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 918                 pArrayList->Construct();
 919                 for (int i = 0; i < maxCount; ++i)
 920                 {
 921                         if (__pEditorFolderIconList->IsItemChecked(i))
 922                         {
 923                                 AlbumInfo* pAlbumInfo = static_cast<AlbumInfo*>(pAlbumInfoList->GetAt(i));
 924                                 IList* pContentIdList = pAlbumInfo->GetContentIdListN();
 925                                 int loopCount = pContentIdList->GetCount();
 926                                 for (int k = 0; k < loopCount; ++k)
 927                                 {
 928                                         ContentId* pContentId = static_cast<ContentId*>(pContentIdList->GetAt(k));
 929                                         ContentInfo* pContentInfo = contentManager.GetContentInfoN(*pContentId);
 930
 931                                         if (pContentInfo == null)
 932                                         {
 933                                                 break;
 934                                         }
 935
 936                                         pArrayList->Add(new (std::nothrow) String(pContentInfo->GetContentPath()));
 937                                 }
 938
 939                                 if (i == 0)
 940                                 {
 941                                         break;
 942                                 }
 943                         }
 944                 }
 945
 946                 HashMap* pDataList = new (std::nothrow) HashMap(SingleObjectDeleter);
 947                 pDataList->Construct();
 948                 pDataList->Add(new (std::nothrow) String(APPCONTROL_KEY_PATH), (Object*)pArrayList);
 949
 950                 r = __pPresentationModel->StartAppControl(APPCONTROL_PROVIDER_ID_EMAIL, APPCONTROL_OPERATION_ID_COMPOSE,
 951                                 new (std::nothrow) String(APPCONTROL_URI_MAIL_TO), null, pDataList, null);
 952
 953                 if (r == E_MAX_EXCEEDED)
 954                 {
 955                         MessageBox messageBox;
 956                         messageBox.Construct(L"", ResourceManager::GetString(L"IDS_RCS_BODY_MAXIMUM_NUMBER_OF_FILES_EXCEEDED"),
 957                                         MSGBOX_STYLE_NONE, 3000);
 958                         int modalResult;
 959                         messageBox.ShowAndWait(modalResult);
 960                 }
 961         }
 962         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 963 }
 964
 965 void
 966 AlbumListEditorForm::SetFooterButtonsState(const bool enableState)
 967 {
 968         AppLogDebug("ENTER");
 969         Footer* pFooter = GetFooter();
 970         AppAssert(pFooter);
 971
 972         if (enableState == true)
 973         {
 974                 pFooter->SetItemEnabled(0, true);
 975                 pFooter->SetItemEnabled(1, true);
 976         }
 977         else
 978         {
 979                 pFooter->SetItemEnabled(0, false);
 980                 pFooter->SetItemEnabled(1, false);
 981         }
 982
 983         pFooter->RequestRedraw(true);
 984         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 985 }
 986
 987 void
 988 AlbumListEditorForm::SetButtonState(void)
 989 {
 990         AppLogDebug("ENTER");
 991         if (GetCheckedFolderCount() > 0)
 992         {
 993                 AppLogDebug("BUTTONSTATE : Request Enable");
 994                 SetFooterButtonsState(true);
 995         }
 996         else
 997         {
 998                 AppLogDebug("BUTTONSTATE : Request disable");
 999                 SetFooterButtonsState(false);
1000         }
1001         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
1002 }
1003
1004
1005 void
1006 AlbumListEditorForm::OnOrientationChanged(const Tizen::Ui::Control &source, Tizen::Ui::OrientationStatus orientationStatus)
1007 {
1008
1009         IList* pIndexList = GetItemCheckedIndexListN();
1010
1011         if (__pEditorFolderIconList != null)
1012         {
1013                 RemoveControl(__pEditorFolderIconList);
1014         }
1015
1016         __pEditorFolderIconList = new IconListView();
1017
1018         if (orientationStatus == ORIENTATION_STATUS_PORTRAIT)
1019         {
1020                 __pEditorFolderIconList->Construct(Rectangle(0, 0, GetClientAreaBounds().width, GetClientAreaBounds().height- __pSelectCountLabel->GetHeight()),
1021                     Dimension(348, 348), ICON_LIST_VIEW_STYLE_MARK, ICON_LIST_VIEW_SCROLL_DIRECTION_VERTICAL);
1022         }
1023         else if (orientationStatus == ORIENTATION_STATUS_LANDSCAPE || orientationStatus == ORIENTATION_STATUS_LANDSCAPE_REVERSE)
1024         {
1025                 int horizontalSpacing = 8;
1026                 int verticalSpacing = 60;
1027         int height = 424;
1028         int width = 410;
1029
1030         __pEditorFolderIconList->Construct(Rectangle(0, 0, GetClientAreaBounds().width, GetClientAreaBounds().height - __pSelectCountLabel->GetHeight()),
1031                                     Dimension(width, height), ICON_LIST_VIEW_STYLE_MARK, ICON_LIST_VIEW_SCROLL_DIRECTION_VERTICAL);
1032
1033         __pEditorFolderIconList->SetItemSpacing(horizontalSpacing, verticalSpacing);
1034         __pEditorFolderIconList->SetMargin(MARGIN_TYPE_TOP,40);
1035         }
1036
1037         Bitmap* pBitmap = ResourceManager::GetBitmapN(IDB_LISTVIEW_EMPTY);
1038
1039         if (pBitmap != null)
1040         {
1041                 __pEditorFolderIconList->SetBitmapOfEmptyList(pBitmap);
1042                 delete pBitmap;
1043         }
1044
1045         __pEditorFolderIconList->SetCheckBoxPosition(ICON_LIST_VIEW_CHECK_BOX_POSITION_TOP_LEFT);
1046         __pEditorFolderIconList->SetTextOfEmptyList(ResourceManager::GetString(L"IDS_COM_BODY_NO_ITEMS"));
1047         __pEditorFolderIconList->SetTouchAnimationEnabled(false);
1048         __pEditorFolderIconList->SetItemProvider(*this);
1049         __pEditorFolderIconList->SetItemBorderStyle(ICON_LIST_VIEW_ITEM_BORDER_STYLE_NONE);
1050         __pEditorFolderIconList->AddIconListViewItemEventListener(*this);
1051
1052         AddControl(__pEditorFolderIconList);
1053
1054         int loopCount = pIndexList->GetCount();
1055         int index = -1;
1056         for (int count = 0; count < loopCount; ++count)
1057         {
1058                 Integer* pRealIndex = static_cast<Integer*>(pIndexList->GetAt(count));
1059                  index = pRealIndex->ToInt();
1060                 __pEditorFolderIconList->SetItemChecked(index, true);
1061                 __pEditorFolderIconList->RefreshList(index, LIST_REFRESH_TYPE_ITEM_MODIFY);
1062         }
1063 }