services/SimpleUI/SimpleUI.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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 #include "browser_config.h"
  18
  19 #if defined(USE_EWEBKIT)
  20 #include <ewk_chromium.h>
  21 #endif
  22
  23 #include <boost/any.hpp>
  24 #include <memory>
  25 #include <algorithm>
  26 #include <Elementary.h>
  27 #include <Ecore.h>
  28 #include <Ecore_Wayland.h>
  29 #include <Edje.h>
  30 #include <Evas.h>
  31 #include "Config.h"
  32
  33 #include "BrowserLogger.h"
  34 #include "ServiceManager.h"
  35 #include "AbstractWebEngine.h"
  36 #include "TabId.h"
  37 #include "Tools/EflTools.h"
  38 #include "BrowserImage.h"
  39 #include "SimpleUI.h"
  40 #include "BookmarkItem.h"
  41 #include "Tools/EflTools.h"
  42 #include "BrowserImage.h"
  43 #include "HistoryItem.h"
  44 #include "BookmarkItem.h"
  45 #include "boost/date_time/gregorian/gregorian.hpp"
  46 #include "boost/date_time/posix_time/posix_time.hpp"
  47 #include "SqlStorage.h"
  48 #include "DetailPopup.h"
  49 #include "UrlHistoryList/UrlHistoryList.h"
  50 #include "NotificationPopup.h"
  51
  52
  53 namespace tizen_browser{
  54 namespace base_ui{
  55
  56 EXPORT_SERVICE(SimpleUI, "org.tizen.browser.simpleui")
  57
  58 const std::string HomePageURL = "about:home";
  59 const int ROOT_FOLDER = 0;
  60
  61
  62 SimpleUI::SimpleUI()
  63     : AbstractMainWindow()
  64     , m_popup(nullptr)
  65     , m_webPageUI()
  66     , m_moreMenuUI()
  67     , m_bookmarkManagerUI()
  68     , m_quickAccess()
  69     , m_historyUI()
  70     , m_settingsUI()
  71     , m_tabUI()
  72     , m_initialised(false)
  73     , m_wvIMEStatus(false)
  74     , m_ewkContext(ewk_context_new())
  75     , m_incognito(false)
  76 {
  77     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
  78     elm_init(0, nullptr);
  79     Evas_Object *main_window = elm_win_util_standard_add("browserApp", "browserApp");
  80     if (main_window == nullptr)
  81         BROWSER_LOGE("Failed to create main window");
  82
  83     setMainWindow(main_window);
  84     m_viewManager = new ViewManager(main_window);
  85     evas_object_size_hint_weight_set(main_window, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  86     evas_object_size_hint_align_set (main_window, EVAS_HINT_FILL, EVAS_HINT_FILL);
  87
  88     elm_win_resize_object_add(main_window, m_viewManager->getContent());
  89     evas_object_show(main_window);
  90 }
  91
  92 SimpleUI::~SimpleUI() {
  93     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
  94     m_sessionService->getStorage()->deleteSession(m_currentSession);
  95     evas_object_del(m_window.get());
  96     ewk_context_delete(m_ewkContext);
  97 }
  98
  99 void SimpleUI::destroyUI()
 100 {
 101     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 102     evas_object_del(m_window.get());
 103 }
 104
 105 std::string SimpleUI::edjePath(const std::string &file)
 106 {
 107     return std::string(EDJE_DIR) + file;
 108 }
 109
 110 std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > SimpleUI::getBookmarks(int folder_id)
 111 {
 112     return m_favoriteService->getBookmarks(folder_id);
 113 }
 114
 115 std::shared_ptr<services::HistoryItemVector> SimpleUI::getMostVisitedItems()
 116 {
 117     return m_historyService->getMostVisitedHistoryItems();
 118 }
 119
 120 std::shared_ptr<services::HistoryItemVector> SimpleUI::getHistory()
 121 {
 122     return m_historyService->getHistoryToday();
 123 }
 124
 125 int SimpleUI::exec(const std::string& _url)
 126 {
 127     BROWSER_LOGD("[%s] _url=%s, initialised=%d", __func__, _url.c_str(), m_initialised);
 128     std::string url = _url;
 129
 130     if(!m_initialised){
 131         if (m_window.get()) {
 132             config::DefaultConfig config;
 133             config.load("");
 134             m_tabLimit = boost::any_cast <int> (config.get("TAB_LIMIT"));
 135             m_favoritesLimit = boost::any_cast <int> (config.get("FAVORITES_LIMIT"));
 136
 137
 138             loadUIServices();
 139             loadModelServices();
 140             createActions();
 141
 142             // initModelServices() needs to be called after initUIServices()
 143             initUIServices();
 144             initModelServices();
 145
 146
 147             connectModelSignals();
 148             connectUISignals();
 149             connectActions();
 150
 151             //Push first view to stack.
 152             m_viewManager->pushViewToStack(m_webPageUI.get());
 153         }
 154         m_initialised = true;
 155     }
 156
 157     m_currentSession = std::move(m_sessionService->getStorage()->createSession());
 158
 159     if (url.empty())
 160     {
 161         BROWSER_LOGD("[%s]: changing to homeUrl", __func__);
 162         switchViewToQuickAccess();
 163         restoreLastSession();
 164     } else {
 165         openNewTab(url);
 166     }
 167
 168     BROWSER_LOGD("[%s]:%d url=%s", __func__, __LINE__, url.c_str());
 169     return 0;
 170 }
 171
 172 void SimpleUI::restoreLastSession()
 173 {
 174     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 175     M_ASSERT(m_sessionService);
 176     Session::Session lastSession = std::move(m_sessionService->getStorage()->getLastSession());
 177     if(lastSession.items().size() >= 1)
 178     {
 179         for(auto iter=lastSession.items().begin(), end=lastSession.items().end(); iter != end; ++iter)
 180         {
 181             openNewTab(iter->second);
 182         }
 183         m_sessionService->getStorage()->deleteSession(lastSession);
 184     }
 185 }
 186
 187
 188 //TODO: Move all service creation here:
 189 void SimpleUI::loadUIServices()
 190 {
 191     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 192
 193     m_webPageUI =
 194         std::dynamic_pointer_cast
 195         <tizen_browser::base_ui::WebPageUI,tizen_browser::core::AbstractService>
 196         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.webpageui"));
 197
 198     m_quickAccess =
 199         std::dynamic_pointer_cast
 200         <tizen_browser::base_ui::QuickAccess,tizen_browser::core::AbstractService>
 201         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.quickaccess"));
 202
 203     m_tabUI =
 204         std::dynamic_pointer_cast
 205         <tizen_browser::base_ui::TabUI,tizen_browser::core::AbstractService>
 206         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.tabui"));
 207
 208     m_historyUI =
 209         std::dynamic_pointer_cast
 210         <tizen_browser::base_ui::HistoryUI,tizen_browser::core::AbstractService>
 211         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.historyui"));
 212
 213     m_settingsUI =
 214         std::dynamic_pointer_cast
 215         <tizen_browser::base_ui::SettingsUI,tizen_browser::core::AbstractService>
 216         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.settingsui"));
 217
 218     m_moreMenuUI =
 219         std::dynamic_pointer_cast
 220         <tizen_browser::base_ui::MoreMenuUI,tizen_browser::core::AbstractService>
 221         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.moremenuui"));
 222
 223     m_bookmarkManagerUI =
 224         std::dynamic_pointer_cast
 225         <tizen_browser::base_ui::BookmarkManagerUI,tizen_browser::core::AbstractService>
 226         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.bookmarkmanagerui"));
 227
 228     m_zoomUI =
 229         std::dynamic_pointer_cast
 230         <tizen_browser::base_ui::ZoomUI, tizen_browser::core::AbstractService>
 231         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.zoomui"));
 232 }
 233
 234 void SimpleUI::connectUISignals()
 235 {
 236     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 237
 238     M_ASSERT(m_webPageUI.get());
 239     m_webPageUI->getURIEntry().uriChanged.connect(boost::bind(&SimpleUI::filterURL, this, _1));
 240     m_webPageUI->getURIEntry().uriEntryEditingChangedByUser.connect(boost::bind(&SimpleUI::onURLEntryEditedByUser, this, _1));
 241     m_webPageUI->getURIEntry().uriEntryEditingChanged.connect(boost::bind(&SimpleUI::onURLEntryEdited, this));
 242     m_webPageUI->backPage.connect(boost::bind(&SimpleUI::switchViewToWebPage, this));
 243     m_webPageUI->backPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::back, m_webEngine.get()));
 244     m_webPageUI->reloadPage.connect(boost::bind(&SimpleUI::switchViewToWebPage, this));
 245     m_webPageUI->showTabUI.connect(boost::bind(&SimpleUI::showTabUI, this));
 246     m_webPageUI->showMoreMenu.connect(boost::bind(&SimpleUI::showMoreMenu, this));
 247     m_webPageUI->forwardPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::forward, m_webEngine.get()));
 248     m_webPageUI->stopLoadingPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::stopLoading, m_webEngine.get()));
 249     m_webPageUI->reloadPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::reload, m_webEngine.get()));
 250     m_webPageUI->showQuickAccess.connect(boost::bind(&SimpleUI::showQuickAccess, this));
 251     m_webPageUI->hideQuickAccess.connect(boost::bind(&QuickAccess::hideUI, m_quickAccess));
 252     m_webPageUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::showBookmarkManagerUI, this));
 253
 254
 255     M_ASSERT(m_quickAccess.get());
 256     m_quickAccess->getDetailPopup().openURLInNewTab.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, _2));
 257     m_quickAccess->getUrlHistoryList()->openURLInNewTab.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, _2));
 258     m_quickAccess->openURLInNewTab.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, _2));
 259     m_quickAccess->mostVisitedTileClicked.connect(boost::bind(&SimpleUI::onMostVisitedTileClicked, this, _1, _2));
 260     m_quickAccess->mostVisitedClicked.connect(boost::bind(&SimpleUI::onMostVisitedClicked, this));
 261     m_quickAccess->bookmarkClicked.connect(boost::bind(&SimpleUI::onBookmarkButtonClicked, this));
 262     m_quickAccess->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::showBookmarkManagerUI, this));
 263
 264     M_ASSERT(m_tabUI.get());
 265     m_tabUI->closeTabUIClicked.connect(boost::bind(&SimpleUI::closeTabUI, this));
 266     m_tabUI->newTabClicked.connect(boost::bind(&SimpleUI::newTabClicked, this));
 267     m_tabUI->newTabClicked.connect(boost::bind(&SimpleUI::settingsPrivateModeSwitch, this, false));
 268     m_tabUI->tabClicked.connect(boost::bind(&SimpleUI::tabClicked, this,_1));
 269     m_tabUI->closeTabsClicked.connect(boost::bind(&SimpleUI::closeTabsClicked, this,_1));
 270     m_tabUI->newIncognitoTabClicked.connect(boost::bind(&SimpleUI::settingsPrivateModeSwitch, this, true));
 271     m_tabUI->newIncognitoTabClicked.connect(boost::bind(&SimpleUI::switchViewToIncognitoPage, this));
 272     m_tabUI->tabsCount.connect(boost::bind(&SimpleUI::tabsCount, this));
 273
 274     M_ASSERT(m_historyUI.get());
 275     m_historyUI->clearHistoryClicked.connect(boost::bind(&SimpleUI::onClearHistoryClicked, this));
 276     m_historyUI->closeHistoryUIClicked.connect(boost::bind(&SimpleUI::closeHistoryUI, this));
 277     // desktop mode as default
 278     m_historyUI->historyItemClicked.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, true));
 279
 280     M_ASSERT(m_settingsUI.get());
 281     m_settingsUI->closeSettingsUIClicked.connect(boost::bind(&SimpleUI::closeSettingsUI, this));
 282     m_settingsUI->deleteSelectedDataClicked.connect(boost::bind(&SimpleUI::settingsDeleteSelectedData, this,_1));
 283     m_settingsUI->resetMostVisitedClicked.connect(boost::bind(&SimpleUI::settingsResetMostVisited, this));
 284     m_settingsUI->resetBrowserClicked.connect(boost::bind(&SimpleUI::settingsResetBrowser, this));
 285
 286     M_ASSERT(m_moreMenuUI.get());
 287     m_moreMenuUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::showBookmarkManagerUI, this));
 288     m_moreMenuUI->historyUIClicked.connect(boost::bind(&SimpleUI::showHistoryUI, this));
 289     m_moreMenuUI->settingsClicked.connect(boost::bind(&SimpleUI::showSettingsUI, this));
 290     m_moreMenuUI->closeMoreMenuClicked.connect(boost::bind(&SimpleUI::closeMoreMenu, this));
 291     m_moreMenuUI->switchToMobileMode.connect(boost::bind(&SimpleUI::switchToMobileMode, this));
 292     m_moreMenuUI->switchToDesktopMode.connect(boost::bind(&SimpleUI::switchToDesktopMode, this));
 293     m_moreMenuUI->addToBookmarkClicked.connect(boost::bind(&SimpleUI::addToBookmarks, this, _1));
 294     m_moreMenuUI->isBookmark.connect(boost::bind(&SimpleUI::checkBookmark, this));
 295     m_moreMenuUI->deleteBookmark.connect(boost::bind(&SimpleUI::deleteBookmark, this));
 296     m_moreMenuUI->zoomUIClicked.connect(boost::bind(&SimpleUI::showZoomUI, this));
 297
 298     M_ASSERT(m_bookmarkManagerUI.get());
 299     m_bookmarkManagerUI->closeBookmarkManagerClicked.connect(boost::bind(&SimpleUI::closeBookmarkManagerUI, this));
 300     m_bookmarkManagerUI->bookmarkItemClicked.connect(boost::bind(&SimpleUI::onBookmarkClicked, this, _1));
 301
 302     M_ASSERT(m_zoomUI.get());
 303     m_zoomUI->setZoom.connect(boost::bind(&SimpleUI::setZoomFactor, this, _1));
 304     m_zoomUI->scrollView.connect(boost::bind(&SimpleUI::scrollView, this, _1, _2));
 305 }
 306
 307 void SimpleUI::loadModelServices()
 308 {
 309     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 310
 311     m_webEngine =
 312         std::dynamic_pointer_cast
 313         <basic_webengine::AbstractWebEngine<Evas_Object>,tizen_browser::core::AbstractService>
 314         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.webkitengineservice"));
 315
 316     m_favoriteService =
 317         std::dynamic_pointer_cast
 318         <tizen_browser::interfaces::AbstractFavoriteService,tizen_browser::core::AbstractService>
 319         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.favoriteservice"));
 320
 321     m_historyService =
 322         std::dynamic_pointer_cast
 323         <tizen_browser::services::HistoryService,tizen_browser::core::AbstractService>
 324         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.historyservice"));
 325
 326     m_platformInputManager =
 327         std::dynamic_pointer_cast
 328         <tizen_browser::services::PlatformInputManager,tizen_browser::core::AbstractService>
 329         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.platforminputmanager"));
 330
 331     m_sessionService =
 332         std::dynamic_pointer_cast
 333         <tizen_browser::services::SessionStorage,tizen_browser::core::AbstractService>
 334         (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.sessionStorageService"));
 335 }
 336
 337 void SimpleUI::initUIServices()
 338 {
 339     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 340     M_ASSERT (m_viewManager);
 341
 342     M_ASSERT(m_webPageUI.get());
 343     m_webPageUI->init(m_viewManager->getContent());
 344
 345     M_ASSERT(m_quickAccess.get());
 346     m_quickAccess->init(m_webPageUI->getContent());
 347
 348     M_ASSERT(m_tabUI.get());
 349     m_tabUI->init(m_viewManager->getContent());
 350
 351     M_ASSERT(m_historyUI.get());
 352     m_historyUI->init(m_viewManager->getContent());
 353
 354     M_ASSERT(m_moreMenuUI.get());
 355     m_moreMenuUI->init(m_viewManager->getContent());
 356
 357     M_ASSERT(m_settingsUI.get());
 358     m_settingsUI->init(m_viewManager->getContent());
 359
 360     M_ASSERT(m_bookmarkManagerUI.get());
 361     m_bookmarkManagerUI->init(m_viewManager->getContent());
 362
 363     M_ASSERT(m_zoomUI.get());
 364     m_zoomUI->init(m_viewManager->getContent());
 365 }
 366
 367 void SimpleUI::initModelServices()
 368 {
 369     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 370
 371     M_ASSERT(m_webEngine);
 372     M_ASSERT(m_webPageUI->getContent());
 373     m_webEngine->init(m_webPageUI->getContent());
 374
 375     M_ASSERT(m_favoriteService);
 376     m_favoriteService->synchronizeBookmarks();
 377     m_favoriteService->getBookmarks();
 378
 379     M_ASSERT(m_platformInputManager);
 380     m_platformInputManager->init(m_window.get());
 381 }
 382
 383 void SimpleUI::connectModelSignals()
 384 {
 385     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 386
 387     m_webEngine->uriChanged.connect(boost::bind(&SimpleUI::webEngineURLChanged, this, _1));
 388     m_webEngine->uriChanged.connect(boost::bind(&URIEntry::changeUri, &m_webPageUI->getURIEntry(), _1));
 389     m_webEngine->uriChanged.connect(boost::bind(&MoreMenuUI::setURL, m_moreMenuUI.get(), _1));
 390     m_webEngine->uriOnTabChanged.connect(boost::bind(&SimpleUI::checkTabId,this,_1));
 391     m_webEngine->uriOnTabChanged.connect(boost::bind(&SimpleUI::closeZoomUI, this));
 392     m_webEngine->webViewClicked.connect(boost::bind(&URIEntry::clearFocus, &m_webPageUI->getURIEntry()));
 393     m_webEngine->backwardEnableChanged.connect(boost::bind(&WebPageUI::setBackButtonEnabled, m_webPageUI.get(), _1));
 394     m_webEngine->forwardEnableChanged.connect(boost::bind(&WebPageUI::setForwardButtonEnabled, m_webPageUI.get(), _1));
 395     m_webEngine->loadStarted.connect(boost::bind(&SimpleUI::loadStarted, this));
 396     m_webEngine->loadProgress.connect(boost::bind(&SimpleUI::progressChanged,this,_1));
 397     m_webEngine->loadFinished.connect(boost::bind(&SimpleUI::loadFinished, this));
 398     m_webEngine->loadStop.connect(boost::bind(&SimpleUI::loadFinished, this));
 399     m_webEngine->loadError.connect(boost::bind(&SimpleUI::loadError, this));
 400     m_webEngine->confirmationRequest.connect(boost::bind(&SimpleUI::handleConfirmationRequest, this, _1));
 401     m_webEngine->tabCreated.connect(boost::bind(&SimpleUI::tabCreated, this));
 402     m_webEngine->checkIfCreate.connect(boost::bind(&SimpleUI::checkIfCreate, this));
 403     m_webEngine->tabClosed.connect(boost::bind(&SimpleUI::tabClosed,this,_1));
 404     m_webEngine->IMEStateChanged.connect(boost::bind(&SimpleUI::setwvIMEStatus, this, _1));
 405     m_webEngine->favIconChanged.connect(boost::bind(&MoreMenuUI::setFavIcon, m_moreMenuUI.get(), _1));
 406     m_webEngine->titleChanged.connect(boost::bind(&MoreMenuUI::setWebTitle, m_moreMenuUI.get(), _1));
 407     m_webEngine->titleChanged.connect(boost::bind(&WebPageUI::setPageTitle, m_webPageUI.get(), _1));
 408
 409     m_favoriteService->bookmarkAdded.connect(boost::bind(&SimpleUI::onBookmarkAdded, this,_1));
 410     m_favoriteService->bookmarkDeleted.connect(boost::bind(&SimpleUI::onBookmarkRemoved, this, _1));
 411
 412     m_historyService->historyDeleted.connect(boost::bind(&SimpleUI::onHistoryRemoved, this,_1));
 413
 414     m_platformInputManager->returnPressed.connect(boost::bind(&elm_exit));
 415     m_platformInputManager->backPressed.connect(boost::bind(&SimpleUI::onBackPressed, this));
 416     m_platformInputManager->mouseClicked.connect(
 417             boost::bind(&SimpleUI::onMouseClick, this));
 418
 419 }
 420
 421 void SimpleUI::createActions()
 422 {
 423     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 424     ///\todo Add MulitStateAction. and convert m_stopLoading and m_reload actons to it?
 425
 426     m_settingPrivateBrowsing = sharedAction(new Action("Private browsing"));
 427     m_settingPrivateBrowsing->setToolTip("On exit from private mode all cookies, history, and stored data will be deleted");
 428     m_settingPrivateBrowsing->setCheckable(true);
 429     m_settingPrivateBrowsing->setChecked(m_webEngine->isPrivateMode());
 430     m_settingPrivateBrowsing->setEnabled(true);
 431 }
 432
 433 void SimpleUI::connectActions()
 434 {
 435     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 436     m_settingPrivateBrowsing->toggled.connect(boost::bind(&SimpleUI::settingsPrivateModeSwitch, this, _1));
 437 }
 438
 439 void SimpleUI::switchViewToWebPage()
 440 {
 441     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 442     M_ASSERT(m_viewManager);
 443     m_webPageUI->switchViewToWebPage(m_webEngine->getLayout(), m_webEngine->getURI(), m_webEngine->getTitle());
 444 }
 445
 446 void SimpleUI::switchToTab(const tizen_browser::basic_webengine::TabId& tabId)
 447 {
 448     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 449     if(m_webEngine->currentTabId() != tabId) {
 450         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 451         m_webEngine->switchToTab(tabId);
 452     }
 453     if(m_webEngine->isLoadError()){
 454         BROWSER_LOGD("[%s:%d] LOAD ERROR!", __PRETTY_FUNCTION__, __LINE__);
 455         loadError();
 456         return;
 457     }
 458     BROWSER_LOGD("[%s:%d] swiching to web_view ", __PRETTY_FUNCTION__, __LINE__);
 459     switchViewToWebPage();
 460 }
 461
 462 bool SimpleUI::isErrorPageActive()
 463 {
 464     return m_webPageUI->isErrorPageActive();
 465 }
 466
 467 void SimpleUI::showQuickAccess()
 468 {
 469     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 470     m_quickAccess->showMostVisited(getMostVisitedItems());
 471     m_quickAccess->showUI();
 472 }
 473
 474 void SimpleUI::switchViewToQuickAccess()
 475 {
 476     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 477     M_ASSERT(m_viewManager);
 478
 479     m_webPageUI->switchViewToQuickAccess(m_quickAccess->getContent());
 480     m_webEngine->disconnectCurrentWebViewSignals();
 481     m_viewManager->popStackTo(m_webPageUI.get());
 482 }
 483
 484 void SimpleUI::switchViewToIncognitoPage()
 485 {
 486     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 487     M_ASSERT(m_viewManager);
 488     m_webPageUI->toIncognito(m_incognito);
 489     m_webPageUI->switchViewToIncognitoPage();
 490     m_webEngine->disconnectCurrentWebViewSignals();
 491     m_viewManager->popStackTo(m_webPageUI.get());
 492 }
 493
 494 void SimpleUI::checkTabId(const tizen_browser::basic_webengine::TabId& id){
 495     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 496     if(m_webEngine->currentTabId() != id || isErrorPageActive()){
 497         BROWSER_LOGD("URL changed on non-visible tab, updating browser view");
 498         switchToTab(id);
 499     }
 500 }
 501
 502 void SimpleUI::openNewTab(const std::string &uri, bool desktopMode)
 503 {
 504     BROWSER_LOGD("[%s:%d] uri =%s", __PRETTY_FUNCTION__, __LINE__, uri.c_str());
 505     tizen_browser::basic_webengine::TabId tab = m_webEngine->addTab(uri, nullptr, desktopMode);
 506     applyPrivateModeToTab(tab);
 507     switchToTab(tab);
 508 }
 509
 510 void SimpleUI::closeTab()
 511 {
 512     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 513     auto tabId = m_webEngine->currentTabId();
 514     closeTab(tabId);
 515 }
 516
 517 void SimpleUI::closeTab(const tizen_browser::basic_webengine::TabId& id)
 518 {
 519     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 520     m_currentSession.removeItem(id.toString());
 521     m_webEngine->closeTab(id);
 522     updateView();
 523 }
 524
 525 bool SimpleUI::checkBookmark()
 526 {
 527     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 528     if (m_webPageUI->isHomePageActive())
 529         return false;
 530
 531     if(m_favoriteService->bookmarkExists(m_webEngine->getURI())) {
 532         BROWSER_LOGD("[%s] There is bookmark for this site [%s], set indicator on!", __func__, m_webEngine->getURI().c_str());
 533         return true;
 534     }
 535     else {
 536         BROWSER_LOGD("[%s] There is no bookmark for this site [%s], set indicator off", __func__, m_webEngine->getURI().c_str());
 537         return false;
 538     }
 539 }
 540 // Consider removing these functions
 541 void SimpleUI::onBookmarkAdded(std::shared_ptr<tizen_browser::services::BookmarkItem>)
 542 {
 543     if (m_moreMenuUI) {
 544         m_moreMenuUI->changeBookmarkStatus(true);
 545         m_moreMenuUI->createToastPopup( (std::string(m_webEngine->getTitle()) + std::string(" added to bookmark")).c_str() );
 546     }
 547 }
 548
 549 void SimpleUI::onBookmarkRemoved(const std::string& uri)
 550 {
 551     BROWSER_LOGD("[%s] deleted %s", __func__, uri.c_str());
 552     if (m_moreMenuUI) {
 553         m_moreMenuUI->changeBookmarkStatus(false);
 554         m_moreMenuUI->createToastPopup( (std::string(m_webEngine->getTitle()) + std::string(" removed from bookmark")).c_str() );
 555     }
 556 }
 557
 558 void SimpleUI::onOpenURLInNewTab(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem, bool desktopMode)
 559 {
 560     BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 561     m_viewManager->popStackTo(m_webPageUI.get());
 562     std::string historyAddress = historyItem->getUrl();
 563     openNewTab(historyAddress, desktopMode);
 564 }
 565
 566 void SimpleUI::onMostVisitedTileClicked(std::shared_ptr< services::HistoryItem > historyItem, int itemsNumber)
 567 {
 568     BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 569     m_quickAccess->openDetailPopup(historyItem, m_historyService->getHistoryItemsByURL(historyItem->getUrl(), itemsNumber));
 570 }
 571
 572 void SimpleUI::onClearHistoryClicked()
 573 {
 574     BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 575     m_historyService->clearAllHistory();
 576 }
 577
 578 void SimpleUI::onMostVisitedClicked()
 579 {
 580    BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 581    m_quickAccess->showMostVisited(getMostVisitedItems());
 582 }
 583
 584 void SimpleUI::onBookmarkButtonClicked()
 585 {
 586    BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 587    m_quickAccess->showBookmarks(getBookmarks());
 588 }
 589
 590 void SimpleUI::onBookmarkClicked(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem)
 591 {
 592     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 593     M_ASSERT(m_viewManager);
 594     m_viewManager->popStackTo(m_webPageUI.get());
 595     std::string bookmarkAddress = bookmarkItem->getAddress();
 596     openNewTab(bookmarkAddress);
 597 }
 598
 599
 600 void SimpleUI::onHistoryRemoved(const std::string& uri)
 601 {
 602     BROWSER_LOGD("[%s] deleted %s", __func__, uri.c_str());
 603 }
 604
 605 void SimpleUI::onReturnPressed(MenuButton *m)
 606 {
 607     BROWSER_LOGD("[%s]", __func__);
 608     m_platformInputManager->returnPressed.disconnect_all_slots();
 609     m_platformInputManager->returnPressed.connect(boost::bind(&elm_exit));
 610     m->hidePopup();
 611 }
 612
 613 void SimpleUI::setwvIMEStatus(bool status)
 614 {
 615     BROWSER_LOGD("[%s]", __func__);
 616     m_wvIMEStatus = status;
 617 }
 618
 619 void SimpleUI::onBackPressed()
 620 {
 621     BROWSER_LOGD("[%s]", __func__);
 622     if (m_webPageUI->isHomePageActive()) {
 623         m_quickAccess->backButtonClicked();
 624     } else {
 625         if (!m_webPageUI->getURIEntry().hasFocus() && !m_wvIMEStatus)
 626             m_webEngine->backButtonClicked();
 627     }
 628 }
 629
 630 void SimpleUI::reloadEnable(bool enable)
 631 {
 632     m_webPageUI->setReloadButtonEnabled(enable);
 633 }
 634
 635 void SimpleUI::stopEnable(bool enable)
 636 {
 637     m_webPageUI->setStopButtonEnabled(enable);
 638 }
 639
 640 void SimpleUI::loadStarted()
 641 {
 642     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 643     if(!m_webEngine->isPrivateMode()){
 644         m_currentSession.updateItem(m_webEngine->currentTabId().toString(), m_webEngine->getURI());
 645     }
 646     m_webPageUI->loadStarted();
 647 }
 648
 649 void SimpleUI::progressChanged(double progress)
 650 {
 651     m_webPageUI->progressChanged(progress);
 652 }
 653
 654 void SimpleUI::loadFinished()
 655 {
 656     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 657
 658     if(!m_webEngine->isPrivateMode()){
 659         m_historyService->addHistoryItem(std::make_shared<tizen_browser::services::HistoryItem> (m_webEngine->getURI(),
 660                                                                                                 m_webEngine->getTitle(),
 661                                                                                                 m_webEngine->getFavicon()), m_webEngine->getSnapshotData(QuickAccess::MAX_THUMBNAIL_WIDTH, QuickAccess::MAX_THUMBNAIL_HEIGHT));
 662     }
 663     m_webPageUI->loadFinished();
 664 }
 665
 666 void SimpleUI::loadError()
 667 {
 668     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 669     m_webPageUI->switchViewToErrorPage();
 670 }
 671
 672 void SimpleUI::filterURL(const std::string& url)
 673 {
 674     BROWSER_LOGD("[%s:%d] url=%s", __PRETTY_FUNCTION__, __LINE__, url.c_str());
 675     //check for special urls (like:  'about:home')
 676     //if there will be more addresses may be we should
 677     //create some kind of std::man<std::string url, bool *(doSomethingWithUrl)()>
 678     //and then just map[url]() ? m_webEngine->setURI(url) : /*do nothing*/;;
 679     if(/*url.empty() ||*/ url == HomePageURL){
 680         m_webPageUI->getURIEntry().changeUri("");
 681     } else if (!url.empty()){
 682
 683     //check if url is in favorites
 684
 685     //check if url is in blocked
 686
 687     //no filtering
 688
 689         if (m_webPageUI->isHomePageActive())
 690             openNewTab(url);
 691         else
 692             m_webEngine->setURI(url);
 693     }
 694     m_webPageUI->getURIEntry().clearFocus();
 695 }
 696
 697 void SimpleUI::onURLEntryEditedByUser(const std::shared_ptr<std::string> editedUrlPtr)
 698 {
 699     string editedUrl(*editedUrlPtr);
 700     int historyItemsVisibleMax =
 701             m_quickAccess->getUrlHistoryList()->getVisibleItemsMax();
 702     int minKeywordLength =
 703             m_quickAccess->getUrlHistoryList()->getMinKeywordLength();
 704     std::shared_ptr<services::HistoryItemVector> result =
 705             m_historyService->getHistoryItemsByKeywordsString(editedUrl,
 706                     historyItemsVisibleMax, minKeywordLength);
 707     m_quickAccess->getUrlHistoryList()->onURLEntryEditedByUser(editedUrl, result);
 708 }
 709
 710 void SimpleUI::onURLEntryEdited()
 711 {
 712     m_quickAccess->getUrlHistoryList()->onURLEntryEdited();
 713 }
 714
 715 void SimpleUI::onMouseClick()
 716 {
 717     m_quickAccess->getUrlHistoryList()->onMouseClick();
 718 }
 719
 720 void SimpleUI::webEngineURLChanged(const std::string url)
 721 {
 722     BROWSER_LOGD("webEngineURLChanged:%s", url.c_str());
 723     m_webPageUI->getURIEntry().clearFocus();
 724 }
 725
 726 void SimpleUI::showZoomUI()
 727 {
 728     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 729     if(! m_webPageUI->isHomePageActive()) {
 730         M_ASSERT(m_viewManager);
 731         m_viewManager->popStackTo(m_webPageUI.get());
 732         m_webPageUI->showTabUI.connect(boost::bind(&SimpleUI::closeZoomUI, this));
 733         m_webPageUI->showMoreMenu.connect(boost::bind(&SimpleUI::closeZoomUI, this));
 734         m_zoomUI->show(m_window.get());
 735     }
 736 }
 737
 738 void SimpleUI::closeZoomUI()
 739 {
 740     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 741     M_ASSERT(m_zoomUI);
 742     m_webPageUI->showTabUI.disconnect(boost::bind(&SimpleUI::closeZoomUI, this));
 743     m_webPageUI->showMoreMenu.disconnect(boost::bind(&SimpleUI::closeZoomUI, this));
 744     m_zoomUI->hideUI();
 745 }
 746
 747 void SimpleUI::setZoomFactor(int level)
 748 {
 749     m_webEngine->setZoomFactor(level);
 750 }
 751
 752 void SimpleUI::scrollView(const int& dx, const int& dy)
 753 {
 754     m_webEngine->scrollView(dx, dy);
 755 }
 756
 757 void SimpleUI::showTabUI()
 758 {
 759     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 760     M_ASSERT(m_viewManager);
 761     m_viewManager->pushViewToStack(m_tabUI.get());
 762     m_tabUI->addTabItems(m_webEngine->getTabContents());
 763 }
 764
 765 void SimpleUI::closeTabUI()
 766 {
 767     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 768     M_ASSERT(m_viewManager);
 769     if (m_viewManager->topOfStack() == m_tabUI.get())
 770         m_viewManager->popTheStack();
 771 }
 772
 773 void SimpleUI::newTabClicked()
 774 {
 775     if (!checkIfCreate())
 776         return;
 777
 778     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 779     switchViewToQuickAccess();
 780 }
 781
 782 void SimpleUI::tabClicked(const tizen_browser::basic_webengine::TabId& tabId)
 783 {
 784     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 785     m_viewManager->popStackTo(m_webPageUI.get());
 786     applyPrivateModeToTab(tabId);
 787     switchToTab(tabId);
 788 }
 789
 790 void SimpleUI::closeTabsClicked(const tizen_browser::basic_webengine::TabId& tabId)
 791 {
 792     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 793     m_webEngine->closeTab(tabId);
 794 }
 795
 796 int SimpleUI::tabsCount()
 797 {
 798     return m_webEngine->tabsCount();
 799 }
 800
 801 void SimpleUI::handleConfirmationRequest(basic_webengine::WebConfirmationPtr webConfirmation)
 802 {
 803     BROWSER_LOGD("%s", __func__);
 804     switch(webConfirmation->getConfirmationType())
 805     {
 806         case basic_webengine::WebConfirmation::ConfirmationType::Authentication:
 807         {
 808         basic_webengine::AuthenticationConfirmationPtr auth = std::dynamic_pointer_cast<basic_webengine::AuthenticationConfirmation, basic_webengine::WebConfirmation>(webConfirmation);
 809
 810         Evas_Object *popup_content = elm_layout_add(m_webPageUI->getContent());
 811         std::string edjFilePath = EDJE_DIR;
 812         edjFilePath.append("SimpleUI/AuthenticationPopup.edj");
 813         Eina_Bool layoutSetResult = elm_layout_file_set(popup_content, edjFilePath.c_str(), "authentication_popup");
 814         if (!layoutSetResult)
 815             throw std::runtime_error("Layout file not found: " + edjFilePath);
 816
 817     #if PLATFORM(TIZEN)
 818         elm_object_translatable_part_text_set(popup_content, "login_label", "Login");
 819         elm_object_translatable_part_text_set(popup_content, "password_label", "Password");
 820     #else
 821         elm_object_part_text_set(popup_content, "login_label", "Login");
 822         elm_object_part_text_set(popup_content, "password_label", "Password");
 823     #endif
 824
 825         Evas_Object *loginEntry = elm_entry_add(popup_content);
 826         elm_object_part_content_set(popup_content, "login", loginEntry);
 827
 828         Evas_Object *passwordEntry = elm_entry_add(popup_content);
 829         elm_object_part_content_set(popup_content, "password", passwordEntry);
 830
 831         SimplePopup *popup = SimplePopup::createPopup();
 832         popup->setTitle("Authentication request");
 833         popup->addButton(OK);
 834         popup->addButton(CANCEL);
 835         popup->setContent(popup_content);
 836         std::shared_ptr<AuthenticationPopupData> popupData = std::make_shared<AuthenticationPopupData>();
 837         popupData->loginEntry = loginEntry;
 838         popupData->passwordEntry = passwordEntry;
 839         popupData->auth = auth;
 840         popup->setData(popupData);
 841         popup->buttonClicked.connect(boost::bind(&SimpleUI::authPopupButtonClicked, this, _1, _2));
 842         popup->show();
 843         break;
 844         }
 845         case basic_webengine::WebConfirmation::ConfirmationType::CertificateConfirmation:
 846         case basic_webengine::WebConfirmation::ConfirmationType::Geolocation:
 847         case basic_webengine::WebConfirmation::ConfirmationType::UserMedia:
 848         case basic_webengine::WebConfirmation::ConfirmationType::Notification:
 849         {
 850         // Implicitly accepted
 851         BROWSER_LOGE("NOT IMPLEMENTED: popups to confirm Ceritificate, Geolocation, UserMedia, Notification");
 852         webConfirmation->setResult(tizen_browser::basic_webengine::WebConfirmation::ConfirmationResult::Confirmed);
 853         m_webEngine->confirmationResult(webConfirmation);
 854         break;
 855         }
 856
 857     default:
 858         break;
 859     }
 860 }
 861
 862 void SimpleUI::authPopupButtonClicked(PopupButtons button, std::shared_ptr<PopupData> popupData)
 863 {
 864     std::shared_ptr<AuthenticationPopupData> authPopupData = std::dynamic_pointer_cast<AuthenticationPopupData, PopupData>(popupData);
 865     switch(button){
 866         case OK:
 867             authPopupData->auth->setLogin(elm_entry_entry_get(authPopupData->loginEntry) ? elm_entry_entry_get(authPopupData->loginEntry) : "");
 868             authPopupData->auth->setPassword(elm_entry_entry_get(authPopupData->passwordEntry) ? elm_entry_entry_get(authPopupData->passwordEntry) : "");
 869             authPopupData->auth->setResult(basic_webengine::WebConfirmation::ConfirmationResult::Confirmed);
 870             m_webEngine->confirmationResult(authPopupData->auth);
 871             break;
 872         case CANCEL:
 873             authPopupData->auth->setResult(basic_webengine::WebConfirmation::ConfirmationResult::Rejected);
 874             m_webEngine->confirmationResult(authPopupData->auth);
 875             break;
 876     case YES:
 877     case NO:
 878     case CLOSE:
 879     case CONNECT:
 880         break;
 881     default:
 882         break;
 883     }
 884 }
 885
 886 void SimpleUI::showHistoryUI()
 887 {
 888     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 889     M_ASSERT(m_viewManager);
 890     m_viewManager->pushViewToStack(m_historyUI.get());
 891     m_historyUI->addHistoryItems(getHistory());
 892 }
 893
 894 void SimpleUI::closeHistoryUI()
 895 {
 896     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 897     M_ASSERT(m_viewManager);
 898     if (m_viewManager->topOfStack() == m_historyUI.get())
 899         m_viewManager->popTheStack();
 900 }
 901
 902 void SimpleUI::showSettingsUI()
 903 {
 904     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 905     M_ASSERT(m_viewManager);
 906     m_viewManager->pushViewToStack(m_settingsUI.get());
 907 }
 908
 909 void SimpleUI::closeSettingsUI()
 910 {
 911     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 912     M_ASSERT(m_viewManager);
 913     if (m_viewManager->topOfStack() == m_settingsUI.get())
 914         m_viewManager->popTheStack();
 915 }
 916
 917 void SimpleUI::showMoreMenu()
 918 {
 919     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 920     M_ASSERT(m_viewManager);
 921
 922     bool desktopMode = m_webPageUI->isHomePageActive() ? m_quickAccess->isDesktopMode() : m_webEngine->isDesktopMode();
 923     m_moreMenuUI->setDesktopMode(desktopMode);
 924     m_viewManager->pushViewToStack(m_moreMenuUI.get());
 925     m_moreMenuUI->showCurrentTab();
 926
 927     if(!m_webPageUI->isHomePageActive()) {
 928         m_moreMenuUI->setFavIcon(m_webEngine->getFavicon());
 929         m_moreMenuUI->setWebTitle(m_webEngine->getTitle());
 930         m_moreMenuUI->setURL(m_webEngine->getURI());
 931     }
 932     else {
 933         m_moreMenuUI->setHomePageInfo();
 934     }
 935 }
 936
 937 void SimpleUI::closeMoreMenu()
 938 {
 939     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 940     M_ASSERT(m_viewManager);
 941     if (m_viewManager->topOfStack() == m_moreMenuUI.get())
 942         m_viewManager->popTheStack();
 943     else
 944         BROWSER_LOGD("[%s:%d] WARNING!!! closeMoreMenu is not topOfStack", __PRETTY_FUNCTION__, __LINE__);
 945 }
 946
 947 void SimpleUI::switchToMobileMode()
 948 {
 949     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 950     if (!m_webPageUI->isHomePageActive()) {
 951         m_webEngine->switchToMobileMode();
 952     m_viewManager->popStackTo(m_webPageUI.get());
 953         m_webEngine->reload();
 954     } else {
 955         m_quickAccess->setDesktopMode(false);
 956     }
 957 }
 958
 959 void SimpleUI::switchToDesktopMode()
 960 {
 961     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 962     if (!m_webPageUI->isHomePageActive()) {
 963         m_webEngine->switchToDesktopMode();
 964         m_webEngine->reload();
 965     } else {
 966         m_quickAccess->setDesktopMode(true);
 967     }
 968 }
 969
 970 void SimpleUI::showBookmarkManagerUI()
 971 {
 972     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 973     M_ASSERT(m_viewManager);
 974     m_viewManager->pushViewToStack(m_bookmarkManagerUI.get());
 975     m_bookmarkManagerUI->addBookmarkItems(getBookmarks(ROOT_FOLDER));
 976 }
 977
 978 void SimpleUI::closeBookmarkManagerUI()
 979 {
 980     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 981     M_ASSERT(m_viewManager);
 982     if (m_viewManager->topOfStack() == m_bookmarkManagerUI.get())
 983     m_viewManager->popTheStack();
 984 }
 985
 986 void SimpleUI::settingsPrivateModeSwitch(bool newState)
 987 {
 988     BROWSER_LOGD("%s: Setting Private mode to: %s", __func__, (newState ? "true" : "false"));
 989     m_incognito = newState;
 990 }
 991
 992 void SimpleUI::applyPrivateModeToTab(const tizen_browser::basic_webengine::TabId& tabId)
 993 {
 994     if (m_webEngine->isPrivateMode(tabId) < 0) {
 995         m_webEngine->setPrivateMode(tabId, m_incognito);
 996         m_webPageUI->toIncognito(m_incognito);
 997     } else {
 998         m_webEngine->setPrivateMode(tabId, m_webEngine->isPrivateMode(tabId));
 999         m_webPageUI->toIncognito(m_webEngine->isPrivateMode(tabId));
1000     }
1001 }
1002
1003 void SimpleUI::settingsDeleteSelectedData(const std::string& str)
1004 {
1005     BROWSER_LOGD("[%s]: Deleting selected data", __func__);
1006     M_ASSERT(m_viewManager);
1007     NotificationPopup *popup = NotificationPopup::createNotificationPopup(m_viewManager->getContent());
1008     popup->show("Delete Web Browsing Data");
1009     onDeleteSelectedDataButton(str);
1010     popup->dismiss();
1011 }
1012
1013 void SimpleUI::onDeleteSelectedDataButton(const std::string& dataText)
1014 {
1015         BROWSER_LOGD("[%s]: TYPE : %s", __func__, dataText.c_str());
1016         if (dataText.find("CACHE") != std::string::npos)
1017                 m_webEngine->clearPrivateData();
1018         if (dataText.find("COOKIES") != std::string::npos)
1019                 m_webEngine->clearPrivateData();
1020         if (dataText.find("HISTORY") != std::string::npos)
1021                 m_historyService->clearAllHistory();
1022 }
1023
1024 void SimpleUI::settingsResetMostVisited()
1025 {
1026     BROWSER_LOGD("[%s]: Deleting most visited sites", __func__);
1027     M_ASSERT(m_viewManager);
1028     NotificationPopup *popup = NotificationPopup::createNotificationPopup(m_viewManager->getContent());
1029     popup->show("Reset Most Visited Sites");
1030     onDeleteMostVisitedButton(nullptr);
1031     popup->dismiss();
1032 }
1033
1034 void SimpleUI::onDeleteMostVisitedButton(std::shared_ptr< PopupData > /*popupData*/)
1035 {
1036     BROWSER_LOGD("[%s]: Deleting most visited", __func__);
1037     m_historyService->cleanMostVisitedHistoryItems();
1038 }
1039
1040 void SimpleUI::settingsResetBrowser()
1041 {
1042     BROWSER_LOGD("[%s]: Resetting browser", __func__);
1043     SimplePopup *popup = SimplePopup::createPopup();
1044     popup->setTitle("Reset browser");
1045     popup->addButton(OK);
1046     popup->addButton(CANCEL);
1047     popup->setMessage("Are you sure you want to reset browser?");
1048     popup->buttonClicked.connect(boost::bind(&SimpleUI::onResetBrowserButton, this, _1, _2));
1049     popup->show();
1050 }
1051
1052 void SimpleUI::onResetBrowserButton(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
1053 {
1054     if (button == OK) {
1055         BROWSER_LOGD("[%s]: OK", __func__);
1056         BROWSER_LOGD("[%s]: Resetting browser", __func__);
1057         M_ASSERT(m_viewManager);
1058
1059         NotificationPopup *popup = NotificationPopup::createNotificationPopup(m_viewManager->getContent());
1060         popup->show("Reset Browser");
1061
1062         m_webEngine->clearPrivateData();
1063         m_historyService->clearAllHistory();
1064         m_favoriteService->deleteAllBookmarks();
1065
1066         // Close all openend tabs
1067         std::vector<std::shared_ptr<tizen_browser::basic_webengine::TabContent>> openedTabs = m_webEngine->getTabContents();
1068         for (auto it = openedTabs.begin(); it < openedTabs.end(); ++it) {
1069             tizen_browser::basic_webengine::TabId id = it->get()->getId();
1070             m_currentSession.removeItem(id.toString());
1071             m_webEngine->closeTab(id);
1072         }
1073         //TODO: add here any missing functionality that should be cleaned.
1074
1075         popup->dismiss();
1076     }
1077 }
1078
1079 void SimpleUI::tabLimitPopupButtonClicked(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
1080 {
1081     if (button == CLOSE_TAB) {
1082         BROWSER_LOGD("[%s]: CLOSE TAB", __func__);
1083         closeTab();
1084     }
1085 }
1086
1087 void SimpleUI::tabCreated()
1088 {
1089     int tabs = m_webEngine->tabsCount();
1090     m_webPageUI->setTabsNumber(tabs);
1091 }
1092
1093 bool SimpleUI::checkIfCreate()
1094 {
1095     int tabs = m_webEngine->tabsCount();
1096
1097     if (tabs >= m_tabLimit) {
1098         SimplePopup *popup = SimplePopup::createPopup();
1099         popup->setTitle("Maximum tab count reached.");
1100         popup->addButton(OK);
1101         popup->setMessage("Close other tabs to open another new tab");
1102         popup->buttonClicked.connect(boost::bind(&SimpleUI::tabLimitPopupButtonClicked, this, _1, _2));
1103         popup->show();
1104         return false;
1105     }
1106     else
1107         return true;
1108 }
1109
1110 void SimpleUI::updateView() {
1111     int tabs = m_webEngine->tabsCount();
1112     BROWSER_LOGD("[%s] Opened tabs: %d", __func__, tabs);
1113     if (tabs == 0) {
1114         switchViewToQuickAccess();
1115     } else if (!m_webPageUI->isHomePageActive()) {
1116         switchViewToWebPage();
1117     }
1118     m_webPageUI->setTabsNumber(tabs);
1119 }
1120
1121 void SimpleUI::tabClosed(const tizen_browser::basic_webengine::TabId& id) {
1122     m_currentSession.removeItem(id.toString());
1123     updateView();
1124 }
1125
1126 void SimpleUI::searchWebPage(std::string &text, int flags)
1127 {
1128     m_webEngine->searchOnWebsite(text, flags);
1129 }
1130
1131 void SimpleUI::addToBookmarks(int folder_id)
1132 {
1133     BROWSER_LOGD("[%s,%d],", __func__, __LINE__);
1134     if (m_favoriteService)
1135     {
1136         if (m_webEngine && !m_webEngine->getURI().empty())
1137          {
1138                m_favoriteService->addToBookmarks(m_webEngine->getURI(), m_webEngine->getTitle(), std::string(),
1139                                                  m_webEngine->getSnapshotData(373, 240),
1140                                                  m_webEngine->getFavicon(),(unsigned int)folder_id);
1141          }
1142     }
1143 }
1144
1145 //TODO: Replace by direct call.
1146 void SimpleUI::deleteBookmark()
1147 {
1148         if (m_favoriteService)
1149                 m_favoriteService->deleteBookmark(m_webEngine->getURI());
1150 }
1151 }
1152 }