src/IntCreateBookmarkFolderForm.cpp

   1 //
   2
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.1 (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:    IntCreateBookmarkFolderForm
  20  *@brief:       This class creates Bookmark folder
  21  *
  22  */
  23
  24 #include <FAppUiApp.h>
  25 #include <FUi.h>
  26 #include "IntBookmarkPresentationModel.h"
  27 #include "IntBookmarkData.h"
  28 #include "IntCommonLib.h"
  29 #include "IntCreateBookmarkFolderForm.h"
  30 #include "IntSceneRegister.h"
  31
  32 using namespace Tizen::App;
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Base::Collection;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Ui;
  37 using namespace Tizen::Ui::Controls;
  38 using namespace Tizen::Ui::Scenes;
  39
  40
  41 const int CreateBookmarkFolderForm::IDA_BUTTON_DONE = 101;
  42 const int CreateBookmarkFolderForm::IDA_BUTTON_CANCEL = 102;
  43
  44 CreateBookmarkFolderForm::CreateBookmarkFolderForm(void)
  45 : __pFolderTitle(null)
  46 , __pMsgBox(null)
  47 , __modalMsgBoxResult(0)
  48 , __pBookmark(null)
  49 , __ret(false)
  50 {
  51
  52 }
  53
  54 CreateBookmarkFolderForm::~CreateBookmarkFolderForm(void)
  55 {
  56
  57 }
  58
  59 bool
  60 CreateBookmarkFolderForm::Initialize(void)
  61 {
  62         result r = Construct(L"IDL_CREATE_BOOKMARK_FOLDER");
  63         AppLogDebug("CreateBookmarkFolderForm Construct returned %s",GetErrorMessage(r));
  64         return true;
  65 }
  66
  67 result
  68 CreateBookmarkFolderForm::OnInitializing(void)
  69 {
  70         // Add your initialization code here
  71
  72         result r = E_SUCCESS;
  73         Header* pHeader = null;
  74         SceneManager* pSceneManager = SceneManager::GetInstance();
  75         AppAssert(pSceneManager);
  76         pSceneManager->AddSceneEventListener(IDSCN_CREATE_BOOKMARK_FOLDER, *this);
  77         SetFormBackEventListener(this);
  78
  79         __pFolderTitle = static_cast< EditField* >(GetControl(L"IDC_EDITFIELD_FOLDER_TITLE"));
  80
  81         if (__pFolderTitle == null)
  82         {
  83                 return E_FAILURE;
  84         }
  85
  86         __pFolderTitle->AddKeypadEventListener(*this);
  87         __pFolderTitle->AddTextEventListener(*this);
  88         __pFolderTitle->SetOverlayKeypadCommandButtonVisible(false);
  89
  90         pHeader = GetHeader();
  91
  92         if (pHeader != NULL)
  93         {
  94                 pHeader->AddActionEventListener(*this);
  95         }
  96
  97         return r;
  98 }
  99
 100 result
 101 CreateBookmarkFolderForm::OnTerminating(void)
 102 {
 103         result r = E_SUCCESS;
 104         return r;
 105 }
 106
 107 void
 108 CreateBookmarkFolderForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 109 {
 110         AppLogDebug("CreateBookmarkFolderForm::OnSceneActivatedN");
 111
 112         result r = E_SUCCESS;
 113         __previousScene = previousSceneId;
 114         bool flag = false;
 115         ArrayList folderList;
 116         String parentID = "0";
 117         String title ;
 118         String folderTitle ;
 119         int count = 0;
 120         int foldercount = 0;
 121         int counter = 0;
 122         __ret = false;
 123
 124         String pStr = CommonUtil::GetString(L"IDS_BR_SK_EDIT");
 125
 126         String folder01 = CommonUtil::GetString(L"IDS_BR_HEADER_FOLDER");
 127         folder01.Append(L"_");
 128
 129         String* pEvent = null;
 130         if (pArgs != NULL)
 131         {
 132                 pEvent = dynamic_cast<String*>(pArgs->GetAt(1));
 133         }
 134
 135         if (pEvent != null)
 136         {
 137                 if (pEvent->CompareTo(pStr) == 0)
 138                 {
 139                         __ret = true;
 140                 }
 141                 delete pEvent;
 142         }
 143
 144         Header* pHeader = GetHeader();
 145
 146         if (pHeader != null)
 147         {
 148                 if (previousSceneId ==IDSCN_EDIT_BOOKMARK_LIST || __ret == true)
 149                 {
 150                         pHeader->SetTitleText(CommonUtil::GetString(L"IDS_BR_SK_EDIT"));
 151                 }
 152                 else
 153                 {
 154                         pHeader->SetTitleText(CommonUtil::GetString(L"IDS_BR_SK3_CREATE_FOLDER"));
 155                 }
 156         }
 157
 158         if (__pFolderTitle == NULL)
 159         {
 160                 return;
 161         }
 162
 163         if (previousSceneId == IDSCN_EDIT_BOOKMARK_LIST || __ret == true)
 164         {
 165                 if (__pBookmark != NULL )
 166                 {
 167                         delete __pBookmark;
 168                         __pBookmark = null;
 169                 }
 170
 171                 if ( pArgs != NULL )
 172                 {
 173                         __pBookmark = dynamic_cast<BookmarkData*>(pArgs->GetAt(0));
 174                 }
 175
 176                 if (__pBookmark != null)
 177                 {
 178                         __pFolderTitle->SetText(__pBookmark->GetBookmarkTitle());
 179                         __pFolderTitle->SetFocus();
 180                         __pFolderTitle->ShowKeypad();
 181                 }
 182         }
 183         else
 184         {
 185                 __pFolderTitle->SetText(folder01);
 186                 __pFolderTitle->SetFocus();
 187                 __pFolderTitle->ShowKeypad();
 188
 189                 r = BookmarkPresentationModel::GetInstance()->GetFolderCount(parentID, foldercount);   // to get count of existing folders
 190                 TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetInstance()->GetFolderCount failed  %s",GetErrorMessage(r));
 191
 192                 r = BookmarkPresentationModel::GetInstance()->GetFolder(parentID, 0, foldercount, folderList);   // to get list of existing folders
 193                 TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetInstance()->GetFolder failed  %s",GetErrorMessage(r));
 194
 195                 while (true)              // to provide user with unique folder title when he creates a new(std::nothrow) folder
 196                 {                         // to generate folder with default name of type Folder_##
 197                         flag = false ;
 198                         title = L"";
 199                         count = 0;
 200                         counter++;
 201                         title.Append(folder01);
 202
 203                         if (counter/10 == 0)
 204                         {
 205                                 title.Append(0);
 206                         }
 207
 208                         title.Append(counter);
 209
 210                         for (count = 0;count < foldercount ; count++)
 211                         {
 212                                 BookmarkData* pBookmark = dynamic_cast<BookmarkData*>(folderList.GetAt(count));
 213                                 folderTitle = L"";
 214                                 if ( pBookmark != NULL)
 215                                 {
 216                                         folderTitle = pBookmark->GetBookmarkTitle();
 217                                 }
 218
 219                                 if (title.Equals(folderTitle,false) == true)
 220                                 {
 221                                         flag = true;    // if flag is true folder title already exists
 222                                         break;          // break from for loop
 223                                 }
 224
 225                         }    // end of for loop
 226
 227                         if ( flag == false)
 228                         {
 229                                 __pFolderTitle->SetText(title);      // if flag is false folder title is unique
 230                                 break;                               // break from while loop
 231                         }
 232
 233                 }  // end of while loop
 234         }
 235
 236         CATCH:
 237
 238         folderList.RemoveAll(true);
 239         return;
 240 }
 241
 242 void
 243 CreateBookmarkFolderForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 244 {
 245
 246 }
 247
 248 void
 249 CreateBookmarkFolderForm::OnActionPerformed(const Control& source, int actionId)
 250 {
 251         int count = 0;
 252         SceneManager* pSceneManager = SceneManager::GetInstance();
 253
 254         if (pSceneManager == null)
 255         {
 256                 return;
 257         }
 258
 259         switch (actionId)
 260         {
 261         case IDA_BUTTON_CANCEL:
 262         {
 263                 result r;
 264                 if (__pFolderTitle != NULL)
 265                 {
 266                         __pFolderTitle->Clear();
 267                         __pFolderTitle->HideKeypad();
 268                 }
 269
 270                 r = pSceneManager->GoBackward(BackwardSceneTransition());
 271                 AppLogDebug("SCENE_ADD_BOOKMARK error = %s",GetErrorMessage(r));
 272                 TryCatch(!IsFailed(r),L"BookmarkPresentationModel::GetFolderCount failed %s",GetErrorMessage(r));
 273
 274         }
 275         break;
 276
 277         case IDA_BUTTON_DONE:
 278         {
 279                 result r = E_SUCCESS;
 280                 bool flag = false;
 281                 ArrayList folderList;
 282                 String parentID = "0";
 283                 int foldercount = 0;
 284                 String title;
 285                 String folderTitle;
 286                 folderTitle = __pFolderTitle->GetText();
 287                 folderTitle.Trim();
 288                 AppLog("IDA_BUTTON_DONE folderTitle %ls",folderTitle.GetPointer());
 289
 290                 r = BookmarkPresentationModel::GetInstance()->GetFolderCount(parentID, foldercount);
 291                 TryCatch( !IsFailed(r),,"BookmarkPresentationModel::GetInstance()->GetFolderCount failed %s",GetErrorMessage(r));
 292
 293                 r = BookmarkPresentationModel::GetInstance()->GetFolder(parentID, 0, foldercount, folderList);
 294                 TryCatch( !IsFailed(r),,"BookmarkPresentationModel::GetInstance()->GetFolder failed %s",GetErrorMessage(r));
 295
 296                 // To check if folder with same name exists
 297                 for (count = 0; count < foldercount; count++)
 298                 {
 299                         BookmarkData* pBookmark = dynamic_cast< BookmarkData* >(folderList.GetAt(count));
 300                         if ( pBookmark == NULL )
 301                         {
 302                                 return;
 303                         }
 304                         title = pBookmark->GetBookmarkTitle();
 305                         title.Trim();
 306
 307                         if (folderTitle.Equals(title, true) == true)
 308                         {
 309                                 flag = true;
 310                                 break;
 311                         }
 312                 }
 313
 314                 if (flag == true && ( __ret == true || __previousScene == IDSCN_EDIT_BOOKMARK_LIST) )
 315                 {
 316
 317                         if(__pBookmark && (__pBookmark->GetBookmarkTitle() == folderTitle ))
 318                         {
 319                                 SceneManager::GetInstance()->GoBackward(BackwardSceneTransition());
 320                                 folderList.RemoveAll(false);
 321                                 return;
 322                         }
 323                 }
 324
 325                 if (flag == true)
 326                 {
 327                         String message = " Folder already exists ";
 328                         CreateMessage(message);                   // Message alert saying Folder already exists
 329                 }
 330                 else
 331                 {
 332                         if (__previousScene == IDSCN_EDIT_BOOKMARK_LIST  || __ret == true )
 333                         {
 334                                 __pBookmark->SetBookmarkTitle(folderTitle);
 335                                 BookmarkPresentationModel::GetInstance()->SaveFolder(*__pBookmark);
 336
 337                                 r = SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_RIGHT));
 338                                 AppLogDebug("SCENE_ADD_BOOKMARK error = %s",GetErrorMessage(r));
 339
 340                         }
 341                         else
 342                         {
 343                                 ArrayList* pArgList = null;
 344                                 pArgList = new(std::nothrow) ArrayList();
 345                                 if (pArgList != null)
 346                                 {
 347                                         pArgList->Construct();
 348                                         pArgList->Add(*new(std::nothrow) String(L"2"));
 349                                 }
 350
 351                                 BookmarkData bookmark;
 352                                 bookmark.SetBookmarkTitle(folderTitle);
 353                                 BookmarkPresentationModel::GetInstance()->SaveFolder(bookmark);
 354                                 result r = pSceneManager->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_RIGHT),pArgList);
 355                                 AppLogDebug("SCENE_ADD_BOOKMARK error = %s",GetErrorMessage(r));
 356                                 if (pArgList != null)
 357                                 {
 358                                         pArgList->RemoveAll(false);
 359                                         delete pArgList;
 360                                 }
 361                                 TryCatch( !IsFailed(r),L"BookmarkPresentationModel::GetFolder failed %s",GetErrorMessage(r));
 362                         }
 363
 364                 }
 365
 366                 folderList.RemoveAll(false);
 367         }
 368         break;
 369
 370         default:
 371                 break;
 372         }
 373
 374         CATCH:  return;
 375 }
 376
 377 void
 378 CreateBookmarkFolderForm::OnFormBackRequested(Tizen::Ui::Controls::Form& source)
 379 {
 380         SceneManager* pSceneManager = SceneManager::GetInstance();
 381         if (pSceneManager == null)
 382         {
 383                 return;
 384         }
 385         result r;
 386         if (__pFolderTitle != NULL)
 387         {
 388                 __pFolderTitle->Clear();
 389                 __pFolderTitle->HideKeypad();
 390         }
 391
 392         r = pSceneManager->GoBackward(BackwardSceneTransition());
 393         AppLogDebug("SCENE_ADD_BOOKMARK error = %s",GetErrorMessage(r));
 394
 395
 396 }
 397
 398 void
 399 CreateBookmarkFolderForm::OnKeypadActionPerformed(Control& source, KeypadAction keypadAction)
 400 {
 401
 402 }
 403
 404 void
 405 CreateBookmarkFolderForm::OnKeypadClosed(Control& source)
 406 {
 407 //      __pFolderTitle->SetFocus();
 408 //      __pFolderTitle->HideKeypad();
 409 }
 410
 411 void
 412 CreateBookmarkFolderForm::OnKeypadOpened(Control& source)
 413 {
 414
 415 }
 416
 417 void
 418 CreateBookmarkFolderForm::OnKeypadWillOpen(Control& source)
 419 {
 420
 421 }
 422
 423 void
 424 CreateBookmarkFolderForm::OnTextValueChanged(const Control& source)
 425 {
 426         AppLog("CreateBookmarkFolderForm::OnTextValueChanged");
 427         String title = L"";
 428         Header* pHeader = GetHeader();
 429
 430         if (pHeader == NULL)
 431         {
 432                 return;
 433         }
 434
 435         if (__pFolderTitle == NULL)
 436         {
 437                 return;
 438         }
 439
 440         title = __pFolderTitle->GetText();
 441         title.Trim();
 442
 443         // To disable done button when folder title edit-field is empty
 444         if (__pFolderTitle && title.GetLength() == 0)
 445         {
 446                 pHeader->SetButtonEnabled(BUTTON_POSITION_RIGHT, false);
 447         }
 448         else
 449         {
 450                 pHeader->SetButtonEnabled(BUTTON_POSITION_RIGHT, true);
 451         }
 452         pHeader->Invalidate(true);
 453         return;
 454 }
 455
 456 void
 457 CreateBookmarkFolderForm::OnTextValueChangeCanceled(const Control& source)
 458 {
 459
 460 }
 461
 462 void
 463 CreateBookmarkFolderForm::CreateMessage(String& msg)
 464 {
 465
 466         if (__pMsgBox != null)
 467         {
 468                 delete __pMsgBox;
 469                 __pMsgBox = null;
 470                 __modalMsgBoxResult = 0;
 471         }
 472
 473         __pMsgBox = new(std::nothrow) MessageBox;
 474
 475         if (__pMsgBox != null)
 476         {
 477                 __pMsgBox->Construct(L"", msg, MSGBOX_STYLE_OK, 3000);
 478         }
 479
 480         if (__pMsgBox != null)
 481         {
 482                 __pMsgBox->ShowAndWait(__modalMsgBoxResult);
 483                 if(__pFolderTitle != null)
 484                         __pFolderTitle->SetFocus();
 485                 /*if (__modalMsgBoxResult == MSGBOX_RESULT_OK)
 486                 {
 487                         AppLog("CreateBookmarkFolderForm::CreateMessage MSGBOX_RESULT_OK");
 488                         if (__pMsgBox != null)
 489                         {
 490                                 delete __pMsgBox;
 491                                 __pMsgBox = null;
 492                         }
 493                 }*/
 494                 if (__pMsgBox != null)
 495                 {
 496                         delete __pMsgBox;
 497                         __pMsgBox = null;
 498                 }
 499                 __modalMsgBoxResult = 0;
 500         }
 501
 502         return;
 503 }