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