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