src/IntEditBookmarkListForm.cpp

   1 //
   2
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 //!Internet
  19 /*@file:    EditBookmarkListForm
  20  *@brief:       This class defines EditBookmarkListForm used to edit the bookmark
  21  *
  22  */
  23
  24 #include <FAppUiApp.h>
  25 #include <FUi.h>
  26
  27 #include "IntBookmarkData.h"
  28 #include "IntBookmarkPresentationModel.h"
  29 #include "IntCommonLib.h"
  30 #include "IntEditBookmarkListForm.h"
  31 #include "IntFaviconManager.h"
  32 #include "IntNotificationPanel.h"
  33 #include "IntSceneRegister.h"
  34 #include "IntTypes.h"
  35
  36 using namespace Tizen::App;
  37 using namespace Tizen::Base;
  38 using namespace Tizen::Base::Collection;
  39 using namespace Tizen::Base::Runtime;
  40 using namespace Tizen::Graphics;
  41 using namespace Tizen::Ui;
  42 using namespace Tizen::Ui::Controls;
  43 using namespace Tizen::Ui::Scenes;
  44
  45 static const wchar_t* IDB_ICON_FOLDER_OPEN = L"I01_icon_folder_open.png";
  46 static const wchar_t* IDB_ITEM = L"edit_item.png";
  47 static const wchar_t* IDB_RIGHT_ARROW = L"I01_right_arrow.png";
  48
  49
  50 const int EditBookmarkListForm::IDA_BUTTON_CHECKED = 101;
  51 const int EditBookmarkListForm::IDA_TABBAR_ITEM_1 = 102;
  52 const int EditBookmarkListForm::IDA_TABBAR_ITEM_2 = 103;
  53 const int EditBookmarkListForm::IDA_DELETEITEM_CLICKED = 104;
  54 const int EditBookmarkListForm::IDA_SHAREITEM_CLICKED = 105;
  55 const int EditBookmarkListForm::IDA_CANCELITEM_CLICKED = 106;
  56 const int EditBookmarkListForm::IDA_FORMAT_FOLDER = 107;
  57 const int EditBookmarkListForm::IDA_FORMAT_SITE = 108;
  58 const int EditBookmarkListForm::IDA_FORMAT_ICON = 109;
  59 const int EditBookmarkListForm::IDA_FORMAT_BITMAP = 110;
  60 const int EditBookmarkListForm::IDA_BUTTON_UNCHECKED = 111;
  61 const int EditBookmarkListForm::IDA_FORMAT_URL = 112;
  62
  63
  64 EditBookmarkListForm::EditBookmarkListForm(void)
  65 {
  66         __pListview = null;
  67         __pData = null;
  68         __pTimer = null;
  69         __parentID = L"0";
  70         __pInfoPanel = null;
  71         __pInfoLabel = null;
  72         __selectedItemCount = 0;
  73         __pCheckButton = null;
  74         __pConfirmationPopup = null;
  75         __pSelectedList = null;
  76 }
  77
  78 EditBookmarkListForm::~EditBookmarkListForm(void)
  79 {
  80         if (__pData != null)
  81         {
  82                 __pData->RemoveAll(false);
  83                 delete __pData;
  84         }
  85         if(__pSelectedList != null)
  86         {
  87                 __pSelectedList->RemoveAll(false);
  88                 delete __pSelectedList;
  89         }
  90 }
  91
  92 bool
  93 EditBookmarkListForm::Initialize(void)
  94 {
  95         Construct(L"IDL_EDIT_BOOKMARK_LIST");
  96
  97         return true;
  98 }
  99 result
 100 EditBookmarkListForm::OnInitializing(void)
 101 {
 102         result r = E_SUCCESS;
 103
 104         Rectangle rc = GetClientAreaBounds();
 105         String selected = CommonUtil::GetString(L"IDS_COM_OPT_SELECTED");
 106
 107         // Setup back event listener
 108         SetFormBackEventListener(this);
 109         AddOrientationEventListener(*this);
 110
 111         SceneManager* pSceneManager = SceneManager::GetInstance();
 112
 113         if (pSceneManager != null)
 114         {
 115                 pSceneManager->AddSceneEventListener(IDSCN_EDIT_BOOKMARK_LIST, *this);
 116         }
 117
 118         Header* pHeader = GetHeader();
 119
 120         if (pHeader == NULL)
 121         {
 122                 return E_FAILURE;
 123         }
 124         pHeader->SetTitleText(CommonUtil::GetString(L"IDS_BR_HEADER_EDIT_BOOKMARK"));
 125
 126         __pCheckButton = static_cast< CheckButton* >(GetControl(
 127                         L"IDC_SELECT_CHECKBUTTON", true));
 128
 129         if (__pCheckButton == null)
 130         {
 131                 return E_FAILURE;
 132         }
 133
 134         __pCheckButton->SetActionId(IDA_BUTTON_CHECKED, IDA_BUTTON_UNCHECKED);
 135         __pCheckButton->AddActionEventListener(*this);
 136
 137         __pListview = static_cast< ListView* >(GetControl("IDC_LISTVIEW1"));
 138
 139         if (__pListview == null)
 140         {
 141                 return E_FAILURE;
 142         }
 143
 144         __pListview->AddFastScrollListener(*this);
 145         __pListview->AddListViewItemEventListener(*this);
 146         __pListview->SetItemProvider(*this);
 147
 148         __pInfoPanel = static_cast< Panel* >(GetControl(
 149                         L"IDC_INFO_PANEL", true));
 150
 151         if (__pInfoPanel == null)
 152         {
 153                 return E_FAILURE;
 154         }
 155
 156         __pInfoLabel = static_cast< Label* >(GetControl(
 157                         L"IDC_INFO_LABEL", true));
 158
 159         if (__pInfoLabel == null)
 160         {
 161                 return E_FAILURE;
 162         }
 163
 164 //      __pInfoLabel->SetBounds(Rectangle(0,0,rc.width, 48));
 165         selected.Append(L"(0)");
 166         __pInfoLabel->SetText(selected);
 167
 168         __pInfoLabel->SetTextConfig(32,LABEL_TEXT_STYLE_BOLD);
 169         //__pInfoLabel->SetBackgroundColor(CUSTOM_COLOR_INFO_LABEL);
 170         __pInfoLabel->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 171         __pInfoLabel->SetTextHorizontalAlignment(ALIGNMENT_CENTER);
 172         GetFooter()->SetItemEnabled(0,false);
 173         GetFooter()->AddActionEventListener(*this);
 174         __pTimer = new (std::nothrow) Timer();
 175         __pTimer->Construct(*this);
 176
 177         __pSelectedList = new(std::nothrow) ArrayList();
 178                 __pSelectedList->Construct();
 179         return r;
 180 }
 181
 182 void
 183 EditBookmarkListForm::OnActionPerformed(const Tizen::Ui::Control& source, int actionId)
 184 {
 185         result r = E_SUCCESS;
 186
 187         SceneManager* pSceneManager = SceneManager::GetInstance();
 188
 189         switch (actionId)
 190         {
 191         case IDA_DELETEITEM_CLICKED:
 192         {
 193                 String labelString;
 194                 int count = 0;
 195                 if(__pListview == null)
 196                 {
 197                         return;
 198                 }
 199                 int totalCount = __pListview->GetItemCount();
 200                 for (int count = 0;count < totalCount;count++)
 201                 {
 202                         if (__pListview->IsItemChecked(count))
 203                         {
 204                                 int id = 0;
 205                                 String bookmarkId;
 206                                 BookmarkData* pBookMark = dynamic_cast< BookmarkData* >(__pData->GetAt(count));
 207                                 if (pBookMark == null)
 208                                 {
 209                                         return;
 210                                 }
 211                                 bookmarkId = pBookMark->GetBookmarkId();
 212                                 Integer::Parse(bookmarkId,id);
 213
 214                                 if (pBookMark->GetBookmarkType() == BOOKMARK_TYPE_URL)
 215                                 {
 216                                         r = BookmarkPresentationModel::GetInstance()->DeleteBookmark(id);
 217                                         TryCatch( r == E_SUCCESS,,"EditBookmarkListForm::OnActionPerformed BookmarkPresentationModel::GetInstance()->DeleteBookmark failed %s",GetErrorMessage(r));
 218                                 }
 219                                 else
 220                                 {
 221                                         r = BookmarkPresentationModel::GetInstance()->DeleteFolder(id);
 222                                         TryCatch( r == E_SUCCESS,,"EditBookmarkListForm::OnActionPerformed BookmarkPresentationModel::GetInstance()->DeleteBookmark failed %s",GetErrorMessage(r));
 223                                 }
 224                         }
 225                 }
 226
 227                 if (__pListview != null)
 228                 {
 229                         count = __pListview->GetItemCount();
 230
 231                         for(int index = 0; index < count ; index ++)
 232                         {
 233                                 if(__pListview->IsItemChecked(index) == true )
 234                                 {
 235                                         __pListview->SetItemChecked(index,false);
 236                                 }
 237                         }
 238
 239                         __pCheckButton->SetSelected(false);
 240                         __pListview->UpdateList();
 241
 242                         if ( __pListview->GetItemCount() == 0)
 243                         {
 244                                 __pCheckButton->SetShowState(false);
 245                                 __pCheckButton->Invalidate(true);
 246                                 if (__pInfoPanel != null)
 247                                 {
 248                                         __pInfoPanel->SetShowState(false);
 249                                 }
 250                                 r = __pListview->SetBounds(__pListview->GetX(), 0, __pListview->GetWidth(), GetClientAreaBounds().height);
 251                                 if (IsFailed(r))
 252                                 {
 253                                         return;
 254                                 }
 255
 256
 257                         }
 258                 }
 259                 GetFooter()->SetItemEnabled(0,false);
 260                 GetFooter()->Invalidate(true);
 261                 // removing all the element from selected list
 262                 __pSelectedList->RemoveAll(false);
 263                 labelString.Append(CommonUtil::GetString(L"IDS_COM_OPT_SELECTED"));
 264                 labelString.Append(L"\x200E"); // LEFT-TO-RIGHT MARK
 265                 labelString.Append(L"(0)");
 266
 267                 if (__pInfoPanel != null)
 268                 {
 269                         __pInfoLabel->SetText(labelString);
 270                         __pInfoPanel->Draw();
 271                         __pInfoPanel->Show();
 272                 }
 273
 274                 NotificationPanel* pNotification = new (std::nothrow) NotificationPanel(*this);
 275                 String notification = CommonUtil::GetString(L"IDS_BR_POP_DELETED");
 276                 pNotification->SetText(notification);
 277                 pNotification->ShowNotification();
 278
 279
 280                 if( __pListview->GetItemCount() == 0)
 281                 {
 282                         __pTimer->Start(1000);
 283                 }
 284         }
 285         break;
 286         case IDA_CANCELITEM_CLICKED:
 287         {
 288                 if ( __pTimer != NULL)
 289                 {
 290                         __pTimer->Cancel();
 291                 }
 292                 if(pSceneManager != NULL)
 293                 {
 294                         r = pSceneManager->GoBackward(BackwardSceneTransition());
 295                 }
 296                 if (IsFailed(r))
 297                 {
 298                         AppLogDebug("EditBookmarkListForm::OnActionPerformed Failed to GoBackward %s",GetErrorMessage(r));
 299                         return;
 300                 }
 301         }
 302         break;
 303         case IDA_BUTTON_CHECKED:
 304         {
 305                 String labelString;
 306                 bool flag = false;
 307
 308                 for (int count = 0;count < __pListview->GetItemCount();count++)
 309                 {
 310                         __pListview->SetItemChecked(count,true);
 311                 }
 312
 313                 GetFooter()->SetItemEnabled(0,true);
 314                 GetFooter()->Invalidate(true);
 315
 316                 labelString.Append(CommonUtil::GetString(L"IDS_COM_OPT_SELECTED"));
 317                 labelString.Append(L"\x200E"); // LEFT-TO-RIGHT MARK
 318                 labelString.Append(L"(");
 319                 labelString.Append(__pListview->GetItemCount());
 320                 labelString.Append(L")");
 321                 __selectedItemCount = 0;
 322
 323                 __pInfoLabel->SetText(labelString);
 324                 __pInfoPanel->Draw();
 325                 __pInfoPanel->Show();
 326
 327                 __pSelectedList->RemoveAll();
 328                 int totalCount = __pData->GetCount();
 329                 for(int index = 0; index <  totalCount; index++)
 330                 {
 331                         BookmarkData* pBookMark = dynamic_cast< BookmarkData* >(__pData->GetAt(index));
 332                         if (pBookMark == null)
 333                         {
 334                                 continue;
 335                         }
 336                         String *pBookmarkId = new(std::nothrow) String();
 337                         if(pBookMark->GetBookmarkType() == BOOKMARK_TYPE_FOLDER)
 338                         {
 339                                 pBookmarkId->Append("F");
 340                         }
 341                         else
 342                         {
 343                                 pBookmarkId->Append("U");
 344                         }
 345                         pBookmarkId->Append(pBookMark->GetBookmarkId());
 346
 347                         __pListview->SetItemChecked(index, true);
 348                         __pSelectedList->Add(pBookmarkId);
 349                 }
 350         __pListview->Invalidate(true);
 351         }
 352         break;
 353         case IDA_BUTTON_UNCHECKED:
 354         {
 355                 String labelString = L"";
 356
 357                 for (int count = 0;count < __pListview->GetItemCount();count++)
 358                 {
 359                         __pListview->SetItemChecked(count,false);
 360                 }
 361
 362                 labelString.Append(CommonUtil::GetString(L"IDS_COM_OPT_SELECTED"));
 363                 labelString.Append(L"\x200E"); // LEFT-TO-RIGHT MARK
 364                 labelString.Append(L"(0)");
 365                 __pInfoLabel->SetText(labelString);
 366                 __pInfoPanel->Draw();
 367                 __pInfoPanel->Show();
 368                 __pSelectedList->RemoveAll(true);
 369                 __pListview->Invalidate(true);
 370
 371                 GetFooter()->SetItemEnabled(0,false);
 372                 GetFooter()->Invalidate(true);
 373         }
 374         break;
 375         default:
 376                 break;
 377         }
 378
 379         CATCH: return ;
 380 }
 381
 382 ListItemBase*
 383 EditBookmarkListForm::CreateItem(int index, int itemWidth)
 384 {
 385         result r = E_SUCCESS;
 386         ListAnnexStyle style = LIST_ANNEX_STYLE_MARK;
 387         CustomItem* pItem = null;
 388         BookmarkData* pBookMark = null;
 389         Bitmap* pBitmap = null;
 390         String bitmapId;
 391         const int x_Margin_Url = 104;
 392         const int y_Margin_Url = 70;
 393         const int height_Url = 40;
 394         const int width_Url = GetClientAreaBounds().width - 104 - 120 - 16 - 48;
 395         const int itemHeight = 112;
 396         const int textSize = 32;
 397         const int width_Title = GetClientAreaBounds().width - 104 - 120 - 16 - 48;
 398
 399         pItem = new(std::nothrow) CustomItem();
 400         if (pItem == null)
 401         {
 402                 return null;
 403         }
 404         pBookMark = dynamic_cast< BookmarkData* >(__pData->GetAt(index));
 405         if (pBookMark == null)
 406         {
 407                 delete pItem;
 408                 pItem = null;
 409                 return null;
 410         }
 411         if (pBookMark->GetBookmarkType() == BOOKMARK_TYPE_FOLDER)
 412         {
 413                 r = pItem->Construct(Tizen::Graphics::Dimension(itemWidth, 112), style);
 414                 TryCatch( r == E_SUCCESS,,"EditBookmarkListForm::CreateItem contruct item failed  %s",GetErrorMessage(r));
 415
 416                 pBitmap = AppResource::GetInstance()->GetBitmapN(IDB_ICON_FOLDER_OPEN);
 417
 418                 if (pBitmap != null)
 419                 {
 420                         pItem->AddElement(Rectangle(16, 26, 60, 60), IDA_FORMAT_ICON, *pBitmap, null);
 421                         delete pBitmap;
 422                 }
 423
 424                 pItem->AddElement(Rectangle(92, 8, width_Title/*__pListview->GetWidth() - 92 - 80*/, 112), IDA_FORMAT_FOLDER, pBookMark->GetBookmarkTitle(), true);
 425
 426
 427                 pBitmap = AppResource::GetInstance()->GetBitmapN(IDB_ITEM);
 428
 429                 if (pBitmap != null)
 430                 {
 431                         pItem->AddElement(Rectangle(GetClientAreaBounds().width - 92 - 80, 20, 60, 60), IDA_FORMAT_BITMAP, *pBitmap, null, null);
 432                         pItem->SetElementSelectionEnabled(IDA_FORMAT_BITMAP, true);
 433                         delete pBitmap;
 434                 }
 435         }
 436         else
 437         {
 438                 r = pItem->Construct(Tizen::Graphics::Dimension(itemWidth, 128), style);
 439                 TryCatch( r == E_SUCCESS,,"EditBookmarkListForm::CreateItem contruct item failed  %s",GetErrorMessage(r));
 440
 441                 pBitmap = pBookMark->GetFavIconBitmap();
 442
 443                 if (pBitmap == null)
 444                 {
 445                         pBitmap = FaviconManager::GetInstance()->GetDefaultFaviconN();
 446                 }
 447
 448                 pItem->AddElement(Rectangle(16, 28, 72, 72), IDA_FORMAT_ICON, *pBitmap, null);
 449                 delete pBitmap;
 450
 451                 pItem->AddElement(Rectangle(104, 10, width_Title, itemHeight - height_Url), IDA_FORMAT_SITE, pBookMark->GetBookmarkTitle(), true);
 452                 pItem->AddElement(Rectangle(x_Margin_Url, y_Margin_Url, width_Url, height_Url), IDA_FORMAT_URL, pBookMark->GetUrl(),textSize,CUSTOM_COLOR_GREY,CUSTOM_COLOR_GREY,CUSTOM_COLOR_GREY,true);
 453
 454                 //pBitmap = AppResource::GetInstance()->GetBitmapN("I01_picker_arrow_right.png");
 455                 pBitmap = AppResource::GetInstance()->GetBitmapN(IDB_RIGHT_ARROW);
 456                 if (pBitmap != null)
 457                 {
 458                         pItem->AddElement(Rectangle(GetClientAreaBounds().width - 92 - 84, 32, 64, 64), IDA_FORMAT_BITMAP, *pBitmap, null, null);
 459                         pItem->SetElementSelectionEnabled(IDA_FORMAT_BITMAP, true);
 460                         delete pBitmap;
 461                 }
 462         }
 463         return pItem;
 464
 465         CATCH:
 466         delete pItem;
 467         pItem = null;
 468         return NULL;
 469 }
 470
 471 bool
 472 EditBookmarkListForm::DeleteItem(int index, Tizen::Ui::Controls::ListItemBase* pItem, int itemWidth)
 473 {
 474         delete pItem;
 475         pItem = null;
 476         return true;
 477 }
 478
 479 int
 480 EditBookmarkListForm::GetItemCount(void)
 481 {
 482         int count = 0;
 483         result r = E_SUCCESS;
 484
 485         BookmarkPresentationModel::GetInstance()->GetFolderBookmarkCount(__parentID, count);
 486
 487         if (__pData != NULL)
 488         {
 489                 __pData->RemoveAll(true);
 490                 delete __pData;
 491                 __pData = NULL ;
 492
 493         }
 494         __pData = new(std::nothrow) ArrayList();
 495
 496         if (__pData == null)
 497         {
 498                 return 0;
 499         }
 500
 501         r = __pData->Construct();
 502
 503         TryCatch( r == E_SUCCESS,,"EditBookmarkListForm::GetItemCount __pData->Construct() failed  %s",GetErrorMessage(r));
 504
 505         BookmarkPresentationModel::GetInstance()->GetFoldersBookmarks(__parentID, 0, count, *__pData);
 506
 507
 508         if ( count == 0)
 509         {
 510                 if(__pCheckButton != null)
 511                 {
 512                         __pCheckButton->SetShowState(false);
 513                 }
 514                 if(__pInfoPanel != null)
 515                 {
 516                         __pInfoPanel->SetShowState(false);
 517                 }
 518                 __pListview->SetBounds(__pListview->GetX(), 0, __pListview->GetWidth(), GetClientAreaBounds().height);
 519
 520         }
 521         else
 522         {
 523                 if(__pCheckButton != null)
 524                 {
 525                         __pCheckButton->SetShowState(true);
 526                 }
 527                 if(__pInfoPanel != null)
 528                 {
 529                         __pInfoPanel->SetShowState(true);
 530                 }
 531                 if(__pCheckButton != null && __pInfoPanel != null)
 532                 __pListview->SetBounds(__pListview->GetX(), __pListview->GetY(), __pListview->GetWidth(), GetClientAreaBounds().height - __pCheckButton->GetHeight() - __pInfoPanel->GetHeight());
 533
 534         }
 535         if(__pCheckButton != null)
 536         {
 537                 __pCheckButton->Invalidate(true);
 538         }
 539         if(__pInfoPanel != null)
 540         {
 541                 __pInfoPanel->Invalidate(false);
 542         }
 543
 544         return count;
 545
 546         CATCH:
 547         __pData->RemoveAll(true);
 548         delete __pData;
 549         __pData = null;
 550         return 0;
 551 }
 552
 553 void
 554 EditBookmarkListForm::OnListViewContextItemStateChanged(Tizen::Ui::Controls::ListView& listView, int index, int elementId, Tizen::Ui::Controls::ListContextItemStatus status)
 555 {
 556
 557 }
 558
 559 void
 560 EditBookmarkListForm::OnListViewItemLongPressed(Tizen::Ui::Controls::ListView& listView, int index, int elementId, bool& invokeListViewItemCallback)
 561 {
 562
 563 }
 564
 565 void
 566 EditBookmarkListForm::OnListViewItemStateChanged(Tizen::Ui::Controls::ListView& listView, int index, int elementId, Tizen::Ui::Controls::ListItemStatus status)
 567 {
 568         String labelString;
 569         __selectedItemCount = 0;
 570         result r = E_SUCCESS;
 571
 572         switch (elementId)
 573         {
 574         case IDA_FORMAT_BITMAP:
 575         {
 576                 ArrayList* pArgList = null;
 577                 SceneManager* pSceneManager = SceneManager::GetInstance();
 578                 BookmarkData* pBookMark = dynamic_cast< BookmarkData* >(__pData->GetAt(index));
 579
 580                 if(pBookMark == NULL)
 581                 {
 582                         return;
 583                 }
 584
 585                 if (pBookMark->GetBookmarkType() == BOOKMARK_TYPE_FOLDER)
 586                 {
 587                         pArgList = new(std::nothrow) ArrayList();
 588
 589                         if (pArgList != null)
 590                         {
 591                                 pArgList->Construct();
 592                                 pArgList->Add(*new(std::nothrow) BookmarkData(*pBookMark));
 593                                 if ( pSceneManager != null)
 594                                 {
 595                                         result r = pSceneManager->GoForward(ForwardSceneTransition(IDSCN_CREATE_BOOKMARK_FOLDER, SCENE_TRANSITION_ANIMATION_TYPE_NONE),pArgList);
 596                                 }
 597
 598                                 if (pArgList != null)
 599                                 {
 600                                         pArgList->RemoveAll(false);
 601                                         delete pArgList;
 602                                         pArgList = null;
 603                                 }
 604                                 if(IsFailed(r))
 605                                 {
 606                                         AppLogDebug("BookmarkListForm::CreateItem Construct failed %s",GetErrorMessage(r));
 607                                         return;
 608                                 }
 609                         }
 610                 }
 611                 else
 612                 {
 613                         pArgList = new(std::nothrow) ArrayList();
 614
 615                         if (pArgList != null)
 616                         {
 617                                 pArgList->Construct();
 618                                 pArgList->Add(*new(std::nothrow) String(L"1"));
 619                                 pArgList->Add(*new(std::nothrow) BookmarkData(*pBookMark));
 620                                 if ( pSceneManager != null)
 621                                 {
 622                                         result r = pSceneManager->GoForward(ForwardSceneTransition(IDSCN_ADD_BOOKMARK, SCENE_TRANSITION_ANIMATION_TYPE_NONE), pArgList);
 623                                 }
 624                                 if (pArgList != null)
 625                                 {
 626                                         pArgList->RemoveAll(false);
 627                                         delete pArgList;
 628                                         pArgList = null;
 629                                 }
 630                                 if(IsFailed(r))
 631                                 {
 632                                         AppLogDebug("BookmarkListForm::CreateItem Construct failed %s",GetErrorMessage(r));
 633                                         return;
 634                                 }
 635                         }
 636                 }
 637         }
 638         break;
 639
 640         default:
 641         {
 642                 int count = 0;
 643                 bool flag = false;
 644                 BookmarkData* pBookMark = dynamic_cast< BookmarkData* >(__pData->GetAt(index));
 645
 646
 647                 if(pBookMark == NULL)
 648                 {
 649                         return;
 650                 }
 651                 String *pBookmarkId = new(std::nothrow) String();
 652                 if(pBookMark->GetBookmarkType() == BOOKMARK_TYPE_FOLDER)
 653                 {
 654                         pBookmarkId->Append("F");
 655                 }
 656                 else
 657                 {
 658                         pBookmarkId->Append("U");
 659                 }
 660                 pBookmarkId->Append(pBookMark->GetBookmarkId());
 661
 662                 if (__pListview->IsItemChecked(index) == false)
 663                 {
 664                         __pSelectedList->Remove(*pBookmarkId);
 665                 }
 666                 else
 667                 {
 668                         __pSelectedList->Add(pBookmarkId);
 669                 }
 670
 671
 672                 int itemCount = __pListview->GetItemCount();
 673                 for (int count = 0;count < itemCount ; count++)
 674                 {
 675                         if (__pListview->IsItemChecked(count))
 676                         {
 677                                 __selectedItemCount++;
 678                         }
 679                 }
 680
 681                 //labelString.Append(__selectedItemCount);
 682                 labelString.Append(CommonUtil::GetString(L"IDS_COM_OPT_SELECTED"));
 683                 labelString.Append(L"\x200E"); // LEFT-TO-RIGHT MARK
 684                 labelString.Append(L"(");
 685                 labelString.Append(__selectedItemCount);
 686                 labelString.Append(L")");
 687                 __pInfoLabel->SetText(labelString);
 688                 __pInfoPanel->Draw();
 689                 __pInfoPanel->Show();
 690                 BookmarkPresentationModel::GetInstance()->GetFolderBookmarkCount(__parentID,count);
 691                 if (__selectedItemCount == count)
 692                 {
 693                         __pCheckButton->SetSelected(true);
 694                 }
 695                 else
 696                 {
 697                         __pCheckButton->SetSelected(false);
 698                 }
 699
 700                 itemCount = __pListview->GetItemCount();
 701                 for (int count = 0;count < itemCount ;count++)
 702                 {
 703                         if (__pListview->IsItemChecked(count))
 704                         {
 705                                 flag = true;
 706                                 break;
 707                         }
 708                 }
 709
 710                 if (flag == true)
 711                 {
 712                         GetFooter()->SetItemEnabled(0,true);
 713                 }
 714                 else
 715                 {
 716                         GetFooter()->SetItemEnabled(0,false);
 717                 }
 718
 719                 GetFooter()->Invalidate(true);
 720
 721         }
 722         break;
 723         }
 724 }
 725
 726 void
 727 EditBookmarkListForm::OnListViewItemSwept(Tizen::Ui::Controls::ListView& listView, int index, Tizen::Ui::Controls::SweepDirection direction)
 728 {
 729
 730 }
 731
 732 void
 733 EditBookmarkListForm::OnFastScrollIndexSelected(Tizen::Ui::Control& source, Tizen::Base::String& index)
 734 {
 735
 736 }
 737 void
 738 EditBookmarkListForm::OnListViewItemReordered(Tizen::Ui::Controls::ListView& listView, int indexFrom, int indexTo)
 739 {
 740
 741 }
 742
 743 void
 744 EditBookmarkListForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 745 {
 746         result r = E_FAILURE;
 747         String labelString ;
 748         int count = 0;
 749         BookmarkData* pBookMark = null;
 750
 751         if (pArgs != null)
 752         {
 753                 __parentID.Clear();
 754                 String* pStr = dynamic_cast<String*>(pArgs->GetAt(0));
 755                 if(pStr == null)
 756                 {
 757                         return;
 758                 }
 759                 __parentID.Append(pStr->GetPointer());
 760         }
 761
 762         __selectedItemCount = 0;
 763
 764         labelString.Append(CommonUtil::GetString(L"IDS_COM_OPT_SELECTED"));
 765         labelString.Append(L"\x200E"); // LEFT-TO-RIGHT MARK
 766         labelString.Append(L"(");
 767         labelString.Append(__pSelectedList->GetCount());
 768         labelString.Append(L")");
 769         __pInfoLabel->SetText(labelString);
 770         __pListview->UpdateList();
 771
 772         count = __pListview->GetItemCount();
 773
 774         for(int index = 0 ; index < count ; index++)
 775         {
 776                 pBookMark = dynamic_cast< BookmarkData* >(__pData->GetAt(index));
 777
 778                 if(pBookMark == NULL)
 779                 {
 780                         return;
 781                 }
 782                 String *pBookmarkId = new(std::nothrow) String();
 783                 if(pBookMark->GetBookmarkType() == BOOKMARK_TYPE_FOLDER)
 784                 {
 785                         pBookmarkId->Append("F");
 786                 }
 787                 else
 788                 {
 789                         pBookmarkId->Append("U");
 790                 }
 791                 pBookmarkId->Append(pBookMark->GetBookmarkId());
 792
 793                 AppLog("BookmarkId: %ls", pBookmarkId->GetPointer());
 794
 795                 if(__pSelectedList->Contains(*pBookmarkId))
 796                 {
 797                         __pListview->SetItemChecked(index,true);
 798                         __selectedItemCount++;
 799                 }
 800                 else
 801                 {
 802                         __pListview->SetItemChecked(index,false);
 803                 }
 804         }
 805         if(__selectedItemCount == 0)
 806         {
 807                 GetFooter()->SetItemEnabled(0, false);
 808                 GetFooter()->Invalidate(true);
 809         }
 810         else
 811         {
 812                 GetFooter()->SetItemEnabled(0, true);
 813                 GetFooter()->Invalidate(true);
 814         }
 815         if(__selectedItemCount < __pListview->GetItemCount())
 816         {
 817                 __pCheckButton->SetSelected(false);
 818         }
 819         else
 820         {
 821                 __pCheckButton->SetSelected(true);
 822         }
 823         __pInfoPanel->Draw();
 824         __pInfoPanel->Show();
 825
 826         Invalidate(true);
 827
 828 }
 829
 830 void
 831 EditBookmarkListForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 832 {
 833
 834 }
 835
 836 void
 837 EditBookmarkListForm::OnFormBackRequested(Form& source)
 838 {
 839         SceneManager* pSceneManager = SceneManager::GetInstance();
 840
 841         if ( __pTimer != NULL)
 842         {
 843                 __pTimer->Cancel();
 844         }
 845
 846         if (pSceneManager != null)
 847         {
 848                 //pSceneManager->GoBackward(BackwardSceneTransition(IDSCN_BOOKMARK_VIEW, SCENE_TRANSITION_ANIMATION_TYPE_RIGHT));
 849                 result r = pSceneManager->GoBackward(BackwardSceneTransition());
 850                 if(IsFailed(r))
 851                 {
 852                         AppLogDebug("BookmarkListForm::CreateItem Construct failed %s",GetErrorMessage(r));
 853                         return;
 854                 }
 855
 856         }
 857         GetFooter()->Invalidate(true);
 858 }
 859
 860
 861 void EditBookmarkListForm::OnOrientationChanged(const Tizen::Ui::Control &source, Tizen::Ui::OrientationStatus orientationStatus)
 862 {
 863         int itemCount = 0;
 864         ArrayList* pCheckedItems  = NULL ;
 865
 866         if (__pListview != null)
 867         {
 868                 AppLog("the list Y axis is %d", __pListview->GetY());
 869                 pCheckedItems  = new(std::nothrow) ArrayList();
 870                 pCheckedItems->Construct();
 871                 if ( __pListview->GetItemCount() == 0)
 872                 {
 873                         __pCheckButton->SetShowState(false);
 874                         __pInfoPanel->SetShowState(false);
 875                         __pListview->SetBounds(0, __pListview->GetY(), GetClientAreaBounds().width, GetClientAreaBounds().height -__pListview->GetY());
 876
 877                 }
 878                 else
 879                 {
 880                         AppLog("EditBookmarkListForm::OnOrientationChanged 1");
 881                         __pCheckButton->SetShowState(true);
 882                         __pInfoPanel->SetShowState(true);
 883                         __pListview->SetBounds(__pListview->GetX(), __pListview->GetY(), __pListview->GetWidth(), GetClientAreaBounds().height - __pCheckButton->GetHeight() - __pInfoPanel->GetHeight());
 884                         __pInfoLabel->SetBounds(__pInfoLabel->GetX(),__pInfoLabel->GetY(), GetClientAreaBounds().width,__pInfoLabel->GetHeight());
 885                         __pInfoLabel->Invalidate(true);
 886                 }
 887                 __pCheckButton->Invalidate(true);
 888
 889                 itemCount = __pListview->GetItemCount();
 890
 891                 for (int count = 0;count < itemCount ; count++)
 892                 {
 893
 894                         if (__pListview->IsItemChecked(count))
 895                         {
 896                                 pCheckedItems->Add(* new Integer(count));
 897                         }
 898                 }
 899
 900                 __pListview->UpdateList();
 901
 902                 for (int count = 0;count < itemCount ;count++)
 903                 {
 904                         if (pCheckedItems->Contains(* new Integer(count)) == true)
 905                         {
 906                                 __pListview->SetItemChecked(count, true);
 907                         }
 908                 }
 909                 if ( pCheckedItems != NULL )
 910                 {
 911                         pCheckedItems->RemoveAll(true);
 912                         delete pCheckedItems;
 913                 }
 914                 Invalidate(true);
 915         }
 916 }
 917
 918 void
 919 EditBookmarkListForm::OnTimerExpired(Timer&  timer)
 920 {
 921         SceneManager* pSceneManager = SceneManager::GetInstance();
 922
 923         if ( pSceneManager != NULL)
 924         {
 925                 result r = pSceneManager->GoBackward(BackwardSceneTransition());
 926                 if(IsFailed(r))
 927                 {
 928                         AppLogDebug("EditBookmarkListForm::OnTimerExpired GoBackward failed %s",GetErrorMessage(r));
 929                 }
 930         }
 931 }