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/format.hpp>
  24 #include <boost/any.hpp>
  25 #include <memory>
  26 #include <algorithm>
  27 #include <Elementary.h>
  28 #include <Ecore.h>
  29 #include <Ecore_Wayland.h>
  30 #include <Edje.h>
  31 #include <Evas.h>
  32 #include "Config.h"
  33
  34 #include "BrowserLogger.h"
  35 #include "ServiceManager.h"
  36 #include "AbstractWebEngine.h"
  37 #include "TabId.h"
  38 #include "Tools/EflTools.h"
  39 #include "BrowserImage.h"
  40 #include "SimpleURI.h"
  41 #include "SimpleUI.h"
  42 #include "BookmarkItem.h"
  43 #include "Tools/EflTools.h"
  44 #include "BrowserImage.h"
  45 #include "HistoryItem.h"
  46 #include "BookmarkItem.h"
  47 #include "boost/date_time/gregorian/gregorian.hpp"
  48 #include "boost/date_time/posix_time/posix_time.hpp"
  49 #include "NetworkErrorHandler.h"
  50 #include "SqlStorage.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
  60 SimpleUI::SimpleUI()
  61     : AbstractMainWindow()
  62     , m_mainLayout(nullptr)
  63     , m_progressBar(nullptr)
  64     , m_popup(nullptr)
  65 #if MERGE_ME
  66     , m_settings()
  67     , m_moreMenuUI()
  68     , m_tabUI()
  69     , m_bookmarkManagerUI()
  70 #endif
  71     , m_mainUI()
  72     , m_initialised(false)
  73     , m_isHomePageActive(false)
  74     , m_currentZoom(ZOOM_TYPE_100)
  75     , items_vector()
  76     , m_networkErrorPopup(0)
  77     , m_wvIMEStatus(false)
  78 {
  79     elm_init(0, nullptr);
  80     ewk_context_default_get();
  81     Evas_Object *main_window = elm_win_util_standard_add("browserApp", "browserApp");
  82     if (main_window == nullptr)
  83         BROWSER_LOGE("Failed to create main window");
  84
  85     setMainWindow(main_window);
  86 }
  87
  88 SimpleUI::~SimpleUI() {
  89     BROWSER_LOGD("%s", __func__);
  90     m_sessionService->getStorage()->deleteSession(m_currentSession);
  91     /// \todo Auto-generated destructor stub
  92     evas_object_del(m_window.get());
  93 }
  94
  95 void SimpleUI::destroyUI()
  96 {
  97     BROWSER_LOGD("%s", __func__);
  98     evas_object_del(m_window.get());
  99 }
 100
 101 std::string SimpleUI::edjePath(const std::string &file)
 102 {
 103     return std::string(EDJE_DIR) + file;
 104 }
 105
 106 std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > SimpleUI::getBookmarks(int folder_id)
 107 {
 108     return m_favoriteService->getBookmarks(folder_id);
 109 }
 110
 111 std::vector<std::shared_ptr<tizen_browser::services::HistoryItem> > SimpleUI::getHistory()
 112 {
 113     return m_historyService->getMostVisitedHistoryItems();
 114 }
 115
 116
 117 std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > SimpleUI::getBookmarkFolders()
 118 {
 119     return m_favoriteService->getBookmarkFolders();
 120 }
 121
 122
 123
 124 int SimpleUI::exec(const std::string& _url)
 125 {
 126     BROWSER_LOGD("[%s] _url=%s, initialised=%d", __func__, _url.c_str(), m_initialised);
 127     std::string url = _url;
 128     Session::Session lastSession;
 129
 130     if(!m_initialised){
 131         if (m_window.get()) {
 132             config::DefaultConfig config;
 133             config.load("");
 134             m_tabLimit = boost::any_cast <int> (config.get("TAB_LIMIT"));
 135             m_favoritesLimit = boost::any_cast <int> (config.get("FAVORITES_LIMIT"));
 136             elm_win_alpha_set(m_window.get(), EINA_FALSE);
 137
 138             // creating main window
 139             int width = 0;
 140             int height = 0;
 141             ecore_wl_screen_size_get(&width, &height);
 142             evas_object_move(m_window.get(), 0, 0);
 143             evas_object_resize(m_window.get(), width, height);
 144
 145             // create main layout
 146             m_mainLayout = elm_layout_add(m_window.get());
 147             evas_object_size_hint_weight_set(m_mainLayout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 148             elm_win_resize_object_add(m_window.get(), m_mainLayout);
 149
 150             ///\todo Integrate with pointer / tab mode switch
 151             elm_win_focus_highlight_style_set(m_window.get(), "invisible");
 152             //elm_config_focus_highlight_animate_set(EINA_TRUE);
 153
 154             m_errorLayout = elm_layout_add(m_window.get());
 155             evas_object_size_hint_weight_set(m_errorLayout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 156             //elm_win_resize_object_add(m_window.get(), m_errorLayout);
 157
 158             //set global show tooltip timeout
 159             elm_config_tooltip_delay_set( boost::any_cast <double> (config.get("TOOLTIP_DELAY")));
 160
 161             loadThemes();
 162
 163             if(!elm_layout_file_set(m_mainLayout, edjePath("SimpleUI/MainLayout.edj").c_str(), "main_layout"))
 164                 throw std::runtime_error("Layout file not found: " + edjePath("SimpleUI/MainLayout.edj"));
 165
 166             //elm_object_style_set(m_errorLayout, "error_message");
 167             if(!elm_layout_file_set(m_errorLayout, edjePath("SimpleUI/ErrorMessage.edj").c_str(), "error_message"))
 168                 throw std::runtime_error("Layout file not found: " + edjePath("SimpleUI/ErrorMessage.edj"));
 169
 170             // load && initialize components
 171             // simpleURI
 172             BROWSER_LOGD("[%s:%d] service: simpleURI ", __PRETTY_FUNCTION__, __LINE__);
 173             m_simpleURI =
 174                 std::dynamic_pointer_cast
 175                 <tizen_browser::base_ui::SimpleURI,tizen_browser::core::AbstractService>
 176                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.simpleuri"));
 177             M_ASSERT(m_simpleURI);
 178
 179             // webengine
 180             BROWSER_LOGD("[%s:%d] service: webkitengineservice ", __PRETTY_FUNCTION__, __LINE__);
 181             m_webEngine =
 182                 std::dynamic_pointer_cast
 183                 <basic_webengine::AbstractWebEngine<Evas_Object>,tizen_browser::core::AbstractService>
 184                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.webkitengineservice"));
 185             M_ASSERT(m_webEngine);
 186             m_webEngine->init(m_mainLayout);
 187
 188             // bookmarks UI
 189             BROWSER_LOGD("[%s:%d] service: bookmarksui ", __PRETTY_FUNCTION__, __LINE__);
 190
 191             // favorites service
 192             BROWSER_LOGD("[%s:%d] service: favoriteservice ", __PRETTY_FUNCTION__, __LINE__);
 193             std::string favoriteService(boost::any_cast < std::string > (config.get("favorite_service_name")));
 194             BROWSER_LOGD("favorite config");
 195             m_favoriteService =
 196                 std::dynamic_pointer_cast
 197                 <tizen_browser::interfaces::AbstractFavoriteService,tizen_browser::core::AbstractService>
 198                 (tizen_browser::core::ServiceManager::getInstance().getService(favoriteService));
 199             BROWSER_LOGD("favorite create");
 200             M_ASSERT(m_favoriteService);
 201             m_favoriteService->synchronizeBookmarks();
 202             BROWSER_LOGD("favorite before getBookmarks");
 203             m_favoriteService->getBookmarks();
 204             BROWSER_LOGD("favorite after getBookmarks");
 205
 206             // history service
 207             BROWSER_LOGD("[%s:%d] service: historyservice ", __PRETTY_FUNCTION__, __LINE__);
 208             m_historyService =
 209                 std::dynamic_pointer_cast
 210                 <tizen_browser::services::HistoryService,tizen_browser::core::AbstractService>
 211                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.historyservice"));
 212             M_ASSERT(m_historyService);
 213
 214
 215             // Platforminputmanager
 216             BROWSER_LOGD("[%s:%d] service: platforminputmanager ", __PRETTY_FUNCTION__, __LINE__);
 217             m_platformInputManager =
 218                 std::dynamic_pointer_cast
 219                 <tizen_browser::services::PlatformInputManager,tizen_browser::core::AbstractService>
 220                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.platforminputmanager"));
 221             M_ASSERT(m_platformInputManager);
 222             m_platformInputManager->init(m_window.get());
 223             m_platformInputManager->returnPressed.connect(boost::bind(&elm_exit));
 224             m_platformInputManager->backPressed.connect(boost::bind(&SimpleUI::onBackPressed, this));
 225
 226             createActions();
 227
 228             // left buttons
 229             leftButtonBar = std::make_shared<ButtonBar>(m_mainLayout, "SimpleUI/LeftButtonBar.edj", "left_button_bar");
 230             leftButtonBar->addAction(m_back, "prev_button");
 231             leftButtonBar->addAction(m_forward, "next_button");
 232             leftButtonBar->addAction(m_reload, "refresh_stop_button");
 233             //register action that will be used later by buttons
 234             leftButtonBar->registerEnabledChangedCallback(m_stopLoading, "refresh_stop_button");
 235
 236             // right buttons
 237             rightButtonBar = std::make_shared<ButtonBar>(m_mainLayout, "SimpleUI/RightButtonBar.edj", "right_button_bar");
 238             rightButtonBar->addAction(m_tab, "tab_button");
 239             rightButtonBar->addAction(m_showMoreMenu, "setting_button");
 240
 241             m_progressBar = elm_progressbar_add(m_mainLayout);
 242             elm_object_style_set(m_progressBar,"play_buffer");
 243
 244             webTitleBar = std::make_shared<WebTitleBar>(m_mainLayout, "SimpleUI/WebTitleBar.edj", "web_title_bar");
 245             elm_object_part_content_set(m_mainLayout, "web_title_bar", webTitleBar->getContent());
 246
 247             elm_object_part_content_set(m_mainLayout, "uri_entry", m_simpleURI->getContent(m_mainLayout));
 248             elm_object_part_content_set(m_mainLayout, "uri_bar_buttons_left", leftButtonBar->getContent());
 249             elm_object_part_content_set(m_mainLayout, "uri_bar_buttons_right", rightButtonBar->getContent());
 250
 251             // connecting all together
 252             m_simpleURI->uriChanged.connect(boost::bind(&SimpleUI::filterURL, this, _1));
 253             m_webEngine->uriChanged.connect(boost::bind(&SimpleUI::webEngineURLChanged, this, _1));
 254             m_webEngine->uriOnTabChanged.connect(boost::bind(&SimpleUI::checkTabId,this,_1));
 255             m_webEngine->webViewClicked.connect(boost::bind(&SimpleURI::clearFocus, m_simpleURI.get()));
 256             m_webEngine->backwardEnableChanged.connect(boost::bind(&SimpleUI::backEnable, this, _1));
 257             m_webEngine->forwardEnableChanged.connect(boost::bind(&SimpleUI::forwardEnable, this, _1));
 258             m_webEngine->loadStarted.connect(boost::bind(&SimpleUI::loadStarted, this));
 259             m_webEngine->loadProgress.connect(boost::bind(&SimpleUI::progressChanged,this,_1));
 260             m_webEngine->loadFinished.connect(boost::bind(&SimpleUI::loadFinished, this));
 261             m_webEngine->loadStop.connect(boost::bind(&SimpleUI::loadFinished, this));
 262             m_webEngine->loadError.connect(boost::bind(&SimpleUI::loadError, this));
 263             m_webEngine->confirmationRequest.connect(boost::bind(&SimpleUI::handleConfirmationRequest, this, _1));
 264             m_webEngine->tabCreated.connect(boost::bind(&SimpleUI::tabCreated, this));
 265             m_webEngine->tabClosed.connect(boost::bind(&SimpleUI::tabClosed,this,_1));
 266             m_webEngine->favIconChanged.connect(boost::bind(&SimpleURI::setFavIcon, m_simpleURI.get(), _1));
 267             m_webEngine->favIconChanged.connect(boost::bind(&WebTitleBar::setFavIcon, webTitleBar.get(), _1));
 268             m_webEngine->titleChanged.connect(boost::bind(&WebTitleBar::show, webTitleBar.get(), _1));
 269             m_webEngine->IMEStateChanged.connect(boost::bind(&SimpleUI::setwvIMEStatus, this, _1));
 270
 271             m_favoriteService->bookmarkAdded.connect(boost::bind(&SimpleUI::onBookmarkAdded, this,_1));
 272             m_favoriteService->bookmarkDeleted.connect(boost::bind(&SimpleUI::onBookmarkRemoved, this, _1));
 273
 274             //m_historyService->historyEmpty.connect(boost::bind(&SimpleUI::disableHistoryButton, this, _1));
 275             m_historyService->historyAdded.connect(boost::bind(&SimpleUI::onHistoryAdded, this,_1));
 276             m_historyService->historyDeleted.connect(boost::bind(&SimpleUI::onHistoryRemoved, this,_1));
 277
 278             connectActions();
 279
 280             elm_layout_signal_callback_add(m_simpleURI->getContent(), "slide_websearch", "elm", SimpleUI::favicon_clicked, this);
 281
 282             // show main layout and window
 283             evas_object_show(m_mainLayout);
 284             evas_object_show(m_window.get());
 285
 286             m_netErrorHandler = std::unique_ptr<tizen_browser::basic_ui::NetworkErrorHandler>(new tizen_browser::basic_ui::NetworkErrorHandler);
 287             m_netErrorHandler->networkError.connect(boost::bind(&SimpleUI::onNetworkError, this));
 288             m_netErrorHandler->networkConnected.connect(boost::bind(&SimpleUI::onNetworkConnected, this));
 289
 290             m_sessionService = std::dynamic_pointer_cast
 291             <
 292                 tizen_browser::services::SessionStorage,
 293                 tizen_browser::core::AbstractService
 294             >(tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.sessionStorageService"));
 295             if(m_sessionService){
 296                 lastSession = std::move(m_sessionService->getStorage()->getLastSession());
 297                 m_currentSession = std::move(m_sessionService->getStorage()->createSession());
 298             }
 299
 300         }
 301         m_initialised = true;
 302
 303         // only when first run
 304         if (url.empty()) {
 305             BROWSER_LOGD("[%s]: changing to homeUrl", __func__);
 306             switchViewToHomePage();
 307 #if MERGE_ME // Not sure if this should be enabled
 308             filterURL(HomePageURL);
 309 #endif
 310             if(lastSession.items().size() >= 1){
 311                 for(auto iter=lastSession.items().begin(),
 312                           end=lastSession.items().end();
 313                     iter != end;
 314                     iter++
 315                 ){
 316                     openNewTab(iter->second);
 317                 }
 318                 m_sessionService->getStorage()->deleteSession(lastSession);
 319             }
 320         }
 321         else
 322             openNewTab(url);
 323     }
 324
 325     BROWSER_LOGD("[%s]:%d url=%s", __func__, __LINE__, url.c_str());
 326
 327     saveFolder("Bookmark Bar",0,1);
 328
 329     m_simpleURI->setFocus();
 330
 331     return 0;
 332 }
 333
 334 void SimpleUI::loadThemes()
 335 {
 336     elm_theme_extension_add(nullptr, edjePath("SimpleUI/ZoomItem.edj").c_str());
 337     elm_theme_extension_add(nullptr, edjePath("SimpleUI/TabItem.edj").c_str());
 338     elm_theme_extension_add(nullptr, edjePath("SimpleUI/ErrorMessage.edj").c_str());
 339
 340     elm_theme_overlay_add(0, edjePath("SimpleUI/ScrollerDefault.edj").c_str());
 341     elm_theme_overlay_add(0, edjePath("SimpleUI/Tooltip.edj").c_str());
 342 }
 343
 344 void SimpleUI::createActions()
 345 {
 346     ///\todo Add MulitStateAction. and convert m_stopLoading and m_reload actons to it?
 347
 348     m_back = sharedAction(new Action("Back"));
 349     m_back->setToolTip("Previous");
 350     m_back->setIcon("browser/toolbar_prev");
 351
 352     m_forward = sharedAction(new Action("Next"));
 353     m_forward->setToolTip("Next");
 354     m_forward->setIcon("browser/toolbar_next");
 355
 356     m_stopLoading = sharedAction(new Action("Stop"));
 357     m_stopLoading->setToolTip("Stop");
 358     m_stopLoading->setIcon("browser/toolbar_stop");
 359
 360     m_reload = sharedAction(new Action("Reload"));
 361     m_reload->setToolTip("Reload");
 362     m_reload->setIcon("browser/toolbar_reload");
 363     m_tab = sharedAction(new Action("Tabs"));
 364     m_tab->setToolTip("Tab page");
 365     m_tab->setIcon("browser/toolbar_tab");
 366     //m_tab->setCheckable(true);
 367
 368     m_showMoreMenu = sharedAction(new Action("Settings"));
 369     m_showMoreMenu->setToolTip("Settings");
 370     m_showMoreMenu->setIcon("browser/toolbar_setting");
 371 /*
 372     m_settingPointerMode = sharedAction(new Action("Pointer mode"));
 373     m_settingPointerMode->setToolTip("Switch to Pointer Mode");
 374     m_settingPointerMode->setCheckable(true);
 375     m_settingPointerMode->setChecked(m_platformInputManager->getPointerModeEnabled());
 376     m_settingPointerMode->setEnabled(true);
 377 */
 378
 379     m_settingPrivateBrowsing = sharedAction(new Action("Private browsing"));
 380     m_settingPrivateBrowsing->setToolTip("On exit from private mode all cookies, history, and stored data will be deleted");
 381     m_settingPrivateBrowsing->setCheckable(true);
 382     m_settingPrivateBrowsing->setChecked(m_webEngine->isPrivateMode());
 383     m_settingPrivateBrowsing->setEnabled(true);
 384
 385     m_settingDeleteHistory = sharedAction(new Action("Delete history"));
 386     m_settingDeleteHistory->setToolTip("Delete History");
 387
 388     m_settingDeleteData = sharedAction(new Action("Delete data"));
 389     m_settingDeleteData->setToolTip("Delete Data");
 390
 391     m_settingDeleteFavorite = sharedAction(new Action("Delete favorite site"));
 392     m_settingDeleteFavorite->setToolTip("Delete favorite site");
 393
 394     m_bookmarks_manager_Add_NewFolder = sharedAction(new Action("+ New Folder"));
 395     m_bookmarks_manager_Add_NewFolder->setToolTip("Add a new Folder");
 396
 397     m_bookmarks_manager_BookmarkBar = sharedAction(new Action("Bookmark Bar"));
 398     m_bookmarks_manager_BookmarkBar->setToolTip("show Bookmark bar");
 399
 400     m_bookmarks_manager_Folder3 = sharedAction(new Action("Folder 3"));
 401     m_bookmarks_manager_Folder3->setToolTip("open Folder 3");
 402
 403     m_bookmarks_manager_Folder2 = sharedAction(new Action("Folder 2"));
 404     m_bookmarks_manager_Folder2->setToolTip("open Folder 2");
 405
 406     m_bookmarks_manager_Folder1 = sharedAction(new Action("Folder 1"));
 407     m_bookmarks_manager_Folder1->setToolTip("open Folder 1");
 408 }
 409
 410 void SimpleUI::connectActions()
 411 {
 412     //left bar
 413     m_back->triggered.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::back, m_webEngine.get()));
 414     m_back->triggered.connect(boost::bind(&SimpleUI::updateBrowserView, this));
 415     m_forward->triggered.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::forward, m_webEngine.get()));
 416     m_stopLoading->triggered.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::stopLoading, m_webEngine.get()));
 417     m_reload->triggered.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::reload, m_webEngine.get()));
 418     m_reload->triggered.connect(boost::bind(&SimpleUI::updateBrowserView, this));
 419
 420     //right bar
 421     m_tab->triggered.connect(boost::bind(&SimpleUI::showTabUI, this));
 422     m_showMoreMenu->triggered.connect(boost::bind(&SimpleUI::showMoreMenu, this));
 423
 424 //  m_settingPointerMode->toggled.connect(boost::bind(&tizen_browser::services::PlatformInputManager::setPointerModeEnabled, m_platformInputManager.get(), _1));
 425 #if MERGE_ME
 426     m_settingPrivateBrowsing->toggled.connect(boost::bind(&SimpleUI::settingsPrivateModeSwitch, this, _1));
 427 #endif
 428     //m_settingDeleteHistory->triggered.connect(boost::bind(&SimpleUI::settingsDeleteHistory, this));
 429     //m_settingDeleteData->triggered.connect(boost::bind(&SimpleUI::settingsDeleteData, this));;
 430     //m_settingDeleteFavorite->triggered.connect(boost::bind(&SimpleUI::settingsDeleteFavorite, this));;
 431 #if MERGE_ME
 432 //    m_settingPrivateBrowsing->toggled.connect(boost::bind(&SimpleUI::settingsPrivateModeSwitch, this, _1));
 433     m_settingDeleteHistory->triggered.connect(boost::bind(&SimpleUI::settingsDeleteHistory, this));
 434     m_settingDeleteData->triggered.connect(boost::bind(&SimpleUI::settingsDeleteData, this));;
 435     m_settingDeleteFavorite->triggered.connect(boost::bind(&SimpleUI::settingsDeleteFavorite, this));;
 436 #endif
 437 }
 438
 439 void SimpleUI::updateURIBarView()
 440 {
 441         m_simpleURI->changeUri(m_webEngine->getURI());
 442         leftButtonBar->setActionForButton("refresh_stop_button", m_reload);
 443         stopEnable(true);
 444         reloadEnable(true);
 445         hideProgressBar();
 446 }
 447
 448 void SimpleUI::updateWebView()
 449 {
 450     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 451     evas_object_hide(elm_object_part_content_get(m_mainLayout, "web_view"));
 452     elm_object_part_content_unset(m_mainLayout, "web_view");
 453     elm_object_part_content_set(m_mainLayout, "web_view", m_webEngine->getLayout());
 454     evas_object_show(m_webEngine->getLayout());
 455 }
 456
 457 void SimpleUI::updateBrowserView()
 458 {
 459     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 460         if(isHomePageActive())
 461         hideMainUI();
 462
 463         updateWebView();
 464
 465         updateURIBarView();
 466 }
 467
 468 void SimpleUI::switchToTab(const tizen_browser::basic_webengine::TabId& tabId)
 469 {
 470     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 471     if(m_webEngine->currentTabId() != tabId) {
 472         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 473         m_webEngine->switchToTab(tabId);
 474     }
 475     if(m_webEngine->isLoadError()){
 476         BROWSER_LOGD("[%s:%d] LOAD ERROR!", __PRETTY_FUNCTION__, __LINE__);
 477         loadError();
 478         return;
 479     }
 480     BROWSER_LOGD("[%s:%d] swiching to web_view ", __PRETTY_FUNCTION__, __LINE__);
 481     updateBrowserView();
 482 }
 483
 484 bool SimpleUI::isHomePageActive()
 485 {
 486     BROWSER_LOGD("[%s:%d] isHomePageActive : %d", __PRETTY_FUNCTION__, __LINE__, m_isHomePageActive);
 487     return m_isHomePageActive;
 488 }
 489
 490 bool SimpleUI::isErrorPageActive()
 491 {
 492     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 493     return elm_object_part_content_get(m_mainLayout, "web_view") == m_errorLayout;
 494 }
 495
 496 void SimpleUI::switchViewToHomePage()
 497 {
 498 #if MERGE_ME // remove
 499     if(!isHomePageActive()){
 500         evas_object_hide(elm_object_part_content_get(m_mainLayout,"web_view"));
 501         elm_object_part_content_unset(m_mainLayout, "web_view");
 502         elm_object_part_content_set(m_mainLayout, "web_view", m_bookmarksUI->getContent());
 503         evas_object_show(m_bookmarksUI->getContent());
 504         //m_simpleURI->changeUri(HomePageURL);
 505         filterURL(HomePageURL);
 506         }
 507 #endif
 508     BROWSER_LOGD("[%s:%d] isHomePageActive : %d", __PRETTY_FUNCTION__, __LINE__, m_isHomePageActive);
 509     if(isHomePageActive())
 510         return;
 511
 512     showMainUI();
 513     filterURL(HomePageURL);
 514
 515     m_webEngine->disconnectCurrentWebViewSignals();
 516
 517     leftButtonBar->setActionForButton("refresh_stop_button", m_reload);
 518
 519     stopEnable(false);
 520     reloadEnable(false);
 521     forwardEnable(false);
 522     backEnable(false);
 523     evas_object_hide(leftButtonBar->getContent());
 524     elm_object_signal_emit(m_mainLayout, "shiftback_uri", "ui");
 525     elm_object_signal_emit(m_simpleURI->getContent(), "shiftback_uribg", "ui");
 526
 527     webTitleBar->hide();
 528
 529     hideProgressBar();
 530 }
 531
 532 void SimpleUI::checkTabId(const tizen_browser::basic_webengine::TabId& id){
 533     BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 534     if(m_webEngine->currentTabId() != id || isErrorPageActive()){
 535         BROWSER_LOGD("URL changed on non-visible tab, updating browser view");
 536         switchToTab(id);
 537     }
 538 }
 539
 540 void SimpleUI::openNewTab(const std::string &uri)
 541 {
 542     switchToTab(m_webEngine->addTab(uri));
 543 }
 544
 545 void SimpleUI::closeTab(){
 546     BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 547     auto tabId = m_webEngine->currentTabId();
 548     closeTab(tabId);
 549 }
 550
 551 void SimpleUI::closeTab(const tizen_browser::basic_webengine::TabId& id)
 552 {
 553     BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
 554     m_currentSession.removeItem(id.toString());
 555     m_webEngine->closeTab(id);
 556     updateView();
 557 }
 558
 559 void SimpleUI::bookmarkCheck()
 560 {
 561     if (isHomePageActive())
 562         return;
 563
 564     if(m_favoriteService->bookmarkExists(m_webEngine->getURI())){
 565         BROWSER_LOGD("[%s] There is bookmark for this site [%s], set indicator on!", __func__, m_webEngine->getURI().c_str());
 566         // MERGE_ME
 567         //leftButtonBar->setActionForButton("bookmark_button", m_unbookmark);
 568     }
 569     else{
 570         BROWSER_LOGD("[%s] There is no bookmark for this site [%s], set indicator off", __func__, m_webEngine->getURI().c_str());
 571         // MERGE_ME
 572         //leftButtonBar->setActionForButton("bookmark_button", m_bookmark);
 573         //addBookmarkEnable(m_favoriteService->countBookmarksAndSubFolders() < m_favoritesLimit);
 574     }
 575 }
 576
 577 void SimpleUI::onBookmarkAdded(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem)
 578 {
 579 #if 0
 580     BROWSER_LOGI("Bookmark added with address %s",bookmarkItem->getAddress().c_str());
 581     bookmarkCheck();
 582     webTitleBar->removeFavIcon();
 583     webTitleBar->show("Added to favorites");
 584 #endif
 585 }
 586
 587 void SimpleUI::onHistoryAdded(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem)
 588 {
 589 #if 0
 590     m_mainUI->addHistoryItem(historyItem);
 591     BROWSER_LOGI("Bookmark added with address %s",historyItem->getUrl().c_str());
 592 #endif
 593 }
 594
 595 void SimpleUI::onHistoryClicked(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem)
 596 {
 597     std::string historyAddress = historyItem->getUrl();
 598     openNewTab(historyAddress);
 599 }
 600
 601 void SimpleUI::onMostVisitedClicked(const std::string&)
 602 {
 603    BROWSER_LOGD("[%s]", __func__);
 604    m_mainUI->clearHistoryGenlist();
 605    m_mainUI->clearBookmarkGengrid();
 606    m_mainUI->addHistoryItems(getHistory());
 607    m_mainUI->showHistoryGenlist();
 608 }
 609
 610 void SimpleUI::onBookmarkButtonClicked(const std::string&)
 611 {
 612    BROWSER_LOGD("[%s]", __func__);
 613    m_mainUI->clearBookmarkGengrid();
 614    m_mainUI->clearHistoryGenlist();
 615    m_mainUI->addBookmarkItems(getBookmarks());
 616    m_mainUI->showBookmarkGengrid();
 617 }
 618
 619 void SimpleUI::onBookmarkManagerButtonClicked(const std::string&)
 620 {
 621     BROWSER_LOGD("[%s]", __func__);
 622     showBookmarkManagerMenu();
 623 }
 624
 625 void SimpleUI::onBookmarkClicked(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem)
 626 {
 627     std::string bookmarkAddress = bookmarkItem->getAddress();
 628     openNewTab(bookmarkAddress);
 629 }
 630
 631 void SimpleUI::onBookmarkDeleteClicked(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem)
 632 {
 633     BROWSER_LOGD("[%s] delete %s", __func__, bookmarkItem->getAddress().c_str());
 634     m_favoriteService->deleteBookmark(bookmarkItem->getAddress());
 635 }
 636
 637 void SimpleUI::onBookmarkRemoved(const std::string& uri)
 638 {
 639 #if 0
 640     BROWSER_LOGD("[%s] deleted %s", __func__, uri.c_str());
 641     bookmarkCheck();
 642     webTitleBar->removeFavIcon();
 643     webTitleBar->show("Removed from favorites");
 644 #endif
 645 }
 646
 647 void SimpleUI::onHistoryRemoved(const std::string& uri)
 648 {
 649     BROWSER_LOGD("[%s] deleted %s", __func__, uri.c_str());
 650     //m_mainUI->removeHistoryItem(uri.c_str());
 651 }
 652
 653 void SimpleUI::onReturnPressed(MenuButton *m)
 654 {
 655     BROWSER_LOGD("[%s]", __func__);
 656     m_platformInputManager->returnPressed.disconnect_all_slots();
 657     m_platformInputManager->returnPressed.connect(boost::bind(&elm_exit));
 658     hidePopup.disconnect_all_slots();
 659     m->hidePopup();
 660 }
 661
 662 void SimpleUI::setwvIMEStatus(bool status)
 663 {
 664     BROWSER_LOGD("[%s]", __func__);
 665     m_wvIMEStatus = status;
 666 }
 667
 668 void SimpleUI::onBackPressed()
 669 {
 670     BROWSER_LOGD("[%s]", __func__);
 671     if (!m_simpleURI->hasFocus() && !m_wvIMEStatus && !isHomePageActive() && m_back->isEnabled())
 672         m_webEngine->backButtonClicked();
 673 }
 674
 675 void SimpleUI::backEnable(bool enable)
 676 {
 677     m_back->setEnabled(enable);
 678 }
 679
 680 void SimpleUI::forwardEnable(bool enable)
 681 {
 682     m_forward->setEnabled(enable);
 683 }
 684
 685 void SimpleUI::reloadEnable(bool enable)
 686 {
 687     m_reload->setEnabled(enable);
 688 }
 689
 690 void SimpleUI::stopEnable(bool enable)
 691 {
 692     m_stopLoading->setEnabled(enable);
 693 }
 694
 695 void SimpleUI::addBookmarkEnable(bool enable)
 696 {
 697     //MERGE_ME
 698     //m_bookmark->setEnabled(enable);
 699 }
 700
 701 void SimpleUI::removeBookmarkEnable(bool enable)
 702 {
 703     //MERGE_ME
 704     //m_unbookmark->setEnabled(enable);
 705 }
 706 void SimpleUI::zoomEnable(bool enable)
 707 {
 708     m_zoom_in->setEnabled(enable);
 709 }
 710
 711 void SimpleUI::settingsButtonEnable(bool enable)
 712 {
 713     m_showMoreMenu->setEnabled(enable);
 714 }
 715
 716 void SimpleUI::loadStarted()
 717 {
 718     BROWSER_LOGD("Switching \"reload\" to \"stopLoading\".");
 719     showProgressBar();
 720     elm_object_signal_emit(m_simpleURI->getContent(), "shiftright_uribg", "ui");
 721     elm_object_signal_emit(m_mainLayout, "shiftright_uri", "ui");
 722     evas_object_show(leftButtonBar->getContent());
 723     leftButtonBar->setActionForButton("refresh_stop_button", m_stopLoading);
 724     addBookmarkEnable(false);
 725     if(!m_webEngine->isPrivateMode()){
 726         m_currentSession.updateItem(m_webEngine->currentTabId().toString(), m_webEngine->getURI());
 727     }
 728
 729 #if 0
 730     if(!m_platformInputManager->getPointerModeEnabled())
 731         elm_object_focus_set(leftButtonBar->getButton("refresh_stop_button"), EINA_TRUE);
 732 #endif
 733 }
 734
 735 void SimpleUI::progressChanged(double progress)
 736 {
 737     if(progress == 1.0){
 738         hideProgressBar();
 739     } else {
 740         elm_progressbar_value_set(m_progressBar,progress);
 741     }
 742 }
 743
 744 void SimpleUI::loadFinished()
 745 {
 746     elm_object_signal_emit(m_mainLayout, "hide_progressbar_bg", "ui");
 747     BROWSER_LOGD("Switching \"stopLoading\" to \"reload\".");
 748
 749     leftButtonBar->setActionForButton("refresh_stop_button", m_reload);
 750
 751     addBookmarkEnable(m_favoriteService->countBookmarksAndSubFolders() < m_favoritesLimit);
 752
 753     if(m_simpleURI->getCurrentIconTyep() != SimpleURI::IconTypeFav){
 754         m_simpleURI->setFavIcon(m_webEngine->getFavicon());
 755         webTitleBar->setFavIcon(m_webEngine->getFavicon());
 756     }
 757     if(m_webEngine->isLoadError()){
 758         loadError();
 759     }
 760
 761     if(!m_webEngine->isPrivateMode()){
 762         m_historyService->addHistoryItem(std::make_shared<tizen_browser::services::HistoryItem> (m_webEngine->getURI(),
 763                                                                                                 m_webEngine->getTitle(),
 764                                                                                                 m_webEngine->getFavicon()));
 765     }
 766 #if 0
 767     if(!m_platformInputManager->getPointerModeEnabled())
 768         elm_object_focus_set(leftButtonBar->getButton("refresh_stop_button"), EINA_TRUE);
 769 #endif
 770 }
 771
 772 void SimpleUI::loadError()
 773 {
 774     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 775     hideWebView();
 776     elm_object_part_content_set(m_mainLayout, "web_view",m_errorLayout);
 777     //evas_object_show(m_errorLayout);
 778 }
 779
 780 void SimpleUI::setErrorButtons()
 781 {
 782 //  leftButtonBar->setActionForButton("bookmark_button", m_bookmark);
 783     leftButtonBar->setActionForButton("refresh_stop_button", m_reload);
 784 //  addBookmarkEnable(false);
 785     stopEnable(false);
 786     reloadEnable(true);
 787     forwardEnable(false);
 788     evas_object_hide(m_progressBar);
 789 }
 790
 791 void SimpleUI::filterURL(const std::string& url)
 792 {
 793     BROWSER_LOGD("[%s] url=%s", __func__, url.c_str());
 794
 795     //check for special urls (like:  'about:home')
 796     //if there will be more addresses may be we should
 797     //create some kind of std::man<std::string url, bool *(doSomethingWithUrl)()>
 798     //and then just map[url]() ? m_webEngine->setURI(url) : /*do nothing*/;;
 799     if(/*url.empty() ||*/ url == HomePageURL){
 800         m_simpleURI->changeUri("");
 801     } else if (!url.empty()){
 802
 803     //check if url is in favorites
 804
 805     //check if url is in blocked
 806
 807     //no filtering
 808         if (isHomePageActive())
 809             openNewTab(url);
 810         else
 811             m_webEngine->setURI(url);
 812     }
 813     m_simpleURI->clearFocus();
 814     //addBookmarkEnable(false);
 815 }
 816
 817 void SimpleUI::webEngineURLChanged(const std::string& url)
 818 {
 819     BROWSER_LOGD("webEngineURLChanged:%s", url.c_str());
 820
 821     m_simpleURI->changeUri(url);
 822     m_simpleURI->clearFocus();
 823     bookmarkCheck();
 824 }
 825
 826 void SimpleUI::showZoomMenu()
 827 {
 828     if(!m_zoomList){
 829         BROWSER_LOGD("[%s:%d] - create ", __PRETTY_FUNCTION__, __LINE__);
 830         m_zoomList = std::make_shared<ZoomList>(m_window,
 831                                                 rightButtonBar->getButton("zoom_in_button"));
 832         m_zoomList->addItem("300%", ZOOM_TYPE_300);
 833         m_zoomList->addItem("200%", ZOOM_TYPE_200);
 834         m_zoomList->addItem("150%", ZOOM_TYPE_150);
 835         m_zoomList->addItem("100%", ZOOM_TYPE_100);
 836         m_zoomList->addItem("75%", ZOOM_TYPE_75);
 837         m_zoomList->addItem("50%", ZOOM_TYPE_50);
 838
 839         m_zoomList->zoomChanged.connect(boost::bind(&SimpleUI::zoomLevelChanged, this, _1));
 840     }
 841
 842     zoom_type currentZoomType;
 843
 844     currentZoomType = static_cast<zoom_type> (m_webEngine->getZoomFactor());
 845
 846     //Handling Initial case
 847     if(m_webEngine->getZoomFactor() == 0){
 848         m_webEngine->setZoomFactor(100);
 849         m_currentZoom = static_cast<zoom_type> (100);
 850         currentZoomType = ZOOM_TYPE_100;
 851     }
 852     //each tab may have another zoom, but there is only one instance of zoomlist
 853     //so we should refresh value of zoom every time
 854     m_zoomList->setZoom(currentZoomType);
 855     BROWSER_LOGD("Current zoom factor from webkit %d%%", m_webEngine->getZoomFactor());
 856
 857     m_platformInputManager->returnPressed.disconnect_all_slots();
 858     m_platformInputManager->returnPressed.connect(boost::bind(&SimpleUI::onReturnPressed, this, m_zoomList.get()));
 859     hidePopup.connect(boost::bind(&SimpleUI::onReturnPressed, this, m_zoomList.get()));
 860     m_zoomList->showPopup();
 861 }
 862
 863 void SimpleUI::zoomLevelChanged(int zoom_level)
 864 {
 865     m_webEngine->setZoomFactor(zoom_level);
 866     m_currentZoom = static_cast<zoom_type> (zoom_level);
 867 }
 868
 869 void SimpleUI::AddBookmarkPopup(std::string& str)
 870 {
 871    BROWSER_LOGD("[%s]", __func__);
 872    if(!m_bookmarks_manager){
 873         m_bookmarks_manager = std::make_shared<BookmarksManager>(m_window,
 874                                                 rightButtonBar->getButton("bookmark_button"));
 875         m_bookmarks_manager->addAction( m_bookmarks_manager_Add_NewFolder);
 876         m_bookmarks_manager->addAction( m_bookmarks_manager_BookmarkBar);
 877         m_bookmarks_manager->addAction( m_bookmarks_manager_Folder1);
 878         m_bookmarks_manager->addAction( m_bookmarks_manager_Folder2);
 879         m_bookmarks_manager->addAction( m_bookmarks_manager_Folder3);
 880     }
 881     m_platformInputManager->returnPressed.disconnect_all_slots();
 882     m_platformInputManager->returnPressed.connect(boost::bind(&SimpleUI::onReturnPressed, this, m_bookmarks_manager.get()));
 883     hidePopup.connect(boost::bind(&SimpleUI::onReturnPressed, this, m_bookmarks_manager.get()));
 884     m_bookmarks_manager->showPopup();
 885 }
 886
 887 void SimpleUI::AddNewFolderPopup(std::string& str)
 888 {
 889    BROWSER_LOGD("[%s]", __func__);
 890 }
 891
 892 void SimpleUI::showTabUI()
 893 {
 894 #if MERGE_ME
 895     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 896         m_tabUI =
 897                 std::dynamic_pointer_cast
 898                 <tizen_browser::base_ui::TabUI,tizen_browser::core::AbstractService>
 899                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.tabui"));
 900         M_ASSERT(m_tabUI);
 901         m_tabUI->closeTabUIClicked.connect(boost::bind(&SimpleUI::closeTabUI, this,_1));
 902         m_tabUI->newTabClicked.connect(boost::bind(&SimpleUI::newTabClicked, this,_1));
 903         m_tabUI->tabClicked.connect(boost::bind(&SimpleUI::tabClicked, this,_1));
 904         m_tabUI->newIncognitoTabClicked.connect(boost::bind(&SimpleUI::newTabClicked, this,_1));
 905         m_tabUI->show(m_window.get());
 906         m_tabUI->addTabItems(m_webEngine->getTabContents());
 907 #endif
 908 }
 909
 910 void SimpleUI::closeTabUI(const std::string& str)
 911 {
 912 #if MERGE_ME
 913         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 914         m_tabUI = nullptr;
 915 #endif
 916 }
 917
 918 void SimpleUI::newTabClicked(const std::string& str)
 919 {
 920     BROWSER_LOGD("%s", __func__);
 921     switchViewToHomePage();
 922 }
 923
 924 void SimpleUI::tabClicked(const tizen_browser::basic_webengine::TabId& tabId)
 925 {
 926     BROWSER_LOGD("%s", __func__);
 927     switchToTab(tabId);
 928 }
 929
 930 void SimpleUI::handleConfirmationRequest(basic_webengine::WebConfirmationPtr webConfirmation)
 931 {
 932     std::cerr<<"Web confirmation signal received"<<std::endl;
 933     switch(webConfirmation->getConfirmationType()) {
 934         case basic_webengine::WebConfirmation::ConfirmationType::Authentication:
 935         {
 936         basic_webengine::AuthenticationConfirmationPtr auth = std::dynamic_pointer_cast<basic_webengine::AuthenticationConfirmation, basic_webengine::WebConfirmation>(webConfirmation);
 937
 938         Evas_Object *popup_content = elm_layout_add(m_mainLayout);
 939         std::string edjFilePath = EDJE_DIR;
 940         edjFilePath.append("SimpleUI/AuthenticationPopup.edj");
 941         Eina_Bool layoutSetResult = elm_layout_file_set(popup_content, edjFilePath.c_str(), "authentication_popup");
 942         if(!layoutSetResult)
 943             throw std::runtime_error("Layout file not found: " + edjFilePath);
 944
 945     #if PLATFORM(TIZEN)
 946         elm_object_translatable_part_text_set(popup_content, "login_label", "Login");
 947         elm_object_translatable_part_text_set(popup_content, "password_label", "Password");
 948     #else
 949         elm_object_part_text_set(popup_content, "login_label", "Login");
 950         elm_object_part_text_set(popup_content, "password_label", "Password");
 951     #endif
 952
 953         Evas_Object *loginEntry = elm_entry_add(popup_content);
 954         elm_object_part_content_set(popup_content, "login", loginEntry);
 955
 956         Evas_Object *passwordEntry = elm_entry_add(popup_content);
 957         elm_object_part_content_set(popup_content, "password", passwordEntry);
 958
 959         SimplePopup *popup = SimplePopup::createPopup();
 960         popup->setTitle("Authentication request");
 961         popup->addButton(OK);
 962         popup->addButton(CANCEL);
 963         popup->setContent(popup_content);
 964         std::shared_ptr<AuthenticationPopupData> popupData = std::make_shared<AuthenticationPopupData>();
 965         popupData->loginEntry = loginEntry;
 966         popupData->passwordEntry = passwordEntry;
 967         popupData->auth = auth;
 968         popup->setData(popupData);
 969         popup->buttonClicked.connect(boost::bind(&SimpleUI::authPopupButtonClicked, this, _1, _2));
 970         popup->show();
 971         }
 972         break;
 973         case basic_webengine::WebConfirmation::ConfirmationType::CertificateConfirmation:
 974         {
 975         webConfirmation->setResult(tizen_browser::basic_webengine::WebConfirmation::ConfirmationResult::Confirmed);
 976         m_webEngine->confirmationResult(webConfirmation);
 977         break;
 978         }
 979     default:
 980         break;
 981     }
 982 }
 983
 984 void SimpleUI::authPopupButtonClicked(PopupButtons button, std::shared_ptr<PopupData> popupData)
 985 {
 986     std::shared_ptr<AuthenticationPopupData> authPopupData = std::dynamic_pointer_cast<AuthenticationPopupData, PopupData>(popupData);
 987     switch(button){
 988         case OK:
 989             authPopupData->auth->setLogin(elm_entry_entry_get(authPopupData->loginEntry) ? elm_entry_entry_get(authPopupData->loginEntry) : "");
 990             authPopupData->auth->setPassword(elm_entry_entry_get(authPopupData->passwordEntry) ? elm_entry_entry_get(authPopupData->passwordEntry) : "");
 991             authPopupData->auth->setResult(basic_webengine::WebConfirmation::ConfirmationResult::Confirmed);
 992             m_webEngine->confirmationResult(authPopupData->auth);
 993             break;
 994         case CANCEL:
 995             authPopupData->auth->setResult(basic_webengine::WebConfirmation::ConfirmationResult::Rejected);
 996             m_webEngine->confirmationResult(authPopupData->auth);
 997             break;
 998     case YES:
 999     case NO:
1000     case CLOSE:
1001     case CONNECT:
1002         break;
1003     default:
1004         break;
1005     }
1006 }
1007
1008 #if 0
1009 void SimpleUI::hideURIBar()
1010 {
1011     evas_object_hide(m_simpleURI->getContent(m_mainLayout));
1012         evas_object_hide(rightButtonBar->getContent());
1013         evas_object_hide(leftButtonBar->getContent());
1014     elm_object_part_content_unset(m_mainLayout, "uri_entry");
1015         elm_object_part_content_unset(m_mainLayout, "uri_bar_buttons_left");
1016         elm_object_part_content_unset(m_mainLayout, "uri_bar_buttons_right");
1017 }
1018
1019 void SimpleUI::showURIBar()
1020 {
1021     elm_object_part_content_unset(m_mainLayout, "uri_entry");
1022         elm_object_part_content_unset(m_mainLayout, "uri_bar_buttons_left");
1023         elm_object_part_content_unset(m_mainLayout, "uri_bar_buttons_right");
1024     elm_object_part_content_set(m_mainLayout, "uri_entry", m_simpleURI->getContent(m_mainLayout));
1025         elm_object_part_content_set(m_mainLayout, "uri_bar_buttons_left", leftButtonBar->getContent());
1026         elm_object_part_content_set(m_mainLayout, "uri_bar_buttons_right", rightButtonBar->getContent());
1027     evas_object_show(m_simpleURI->getContent(m_mainLayout));
1028     evas_object_show(leftButtonBar->getContent());
1029     evas_object_show(rightButtonBar->getContent());
1030     m_simpleURI->setFocus();
1031 }
1032 #endif
1033
1034 void SimpleUI::hideWebView()
1035 {
1036         evas_object_hide(elm_object_part_content_get(m_mainLayout,"web_view"));
1037         elm_object_part_content_unset(m_mainLayout, "web_view");
1038 }
1039
1040 void SimpleUI::hideMainUI()
1041 {
1042         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1043     if(m_mainUI)
1044         m_mainUI->hide();
1045         m_mainUI = nullptr;
1046         m_isHomePageActive = false;
1047 }
1048
1049 void SimpleUI::showMainUI()
1050 {
1051     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1052         m_mainUI =
1053                 std::dynamic_pointer_cast
1054                 <tizen_browser::base_ui::MainUI,tizen_browser::core::AbstractService>
1055                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.mainui"));
1056         M_ASSERT(m_mainUI);
1057         hideWebView();
1058         m_mainUI->show(m_window.get());
1059         m_mainUI->addHistoryItems(getHistory());
1060
1061         m_historyService->historyAllDeleted.connect(boost::bind(&tizen_browser::base_ui::MainUI::clearHistoryGenlist, m_mainUI.get()));
1062         m_mainUI->historyClicked.connect(boost::bind(&SimpleUI::onHistoryClicked, this,_1));
1063         m_mainUI->mostVisitedClicked.connect(boost::bind(&SimpleUI::onMostVisitedClicked, this,_1));
1064         m_mainUI->bookmarkClicked.connect(boost::bind(&SimpleUI::onBookmarkButtonClicked, this,_1));
1065         m_mainUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::onBookmarkManagerButtonClicked, this,_1));
1066         m_isHomePageActive = true;
1067 }
1068
1069 void SimpleUI::showHistoryUI(const std::string& str)
1070 {
1071 #if MERGE_ME
1072     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1073         m_historyUI =
1074                 std::dynamic_pointer_cast
1075                 <tizen_browser::base_ui::HistoryUI,tizen_browser::core::AbstractService>
1076                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.historyui"));
1077         M_ASSERT(m_historyUI);
1078         m_historyUI->closeHistoryUIClicked.connect(boost::bind(&SimpleUI::closeHistoryUI, this,_1));
1079         m_historyUI->historyItemClicked.connect(boost::bind(&SimpleUI::onHistoryClicked, this,_1));
1080         m_historyUI->addHistoryItems(getHistory());
1081         m_historyUI->show(m_window.get());
1082 #endif
1083 }
1084
1085 void SimpleUI::closeHistoryUI(const std::string& str)
1086 {
1087 #if MERGE_ME
1088         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1089         m_historyUI = nullptr;
1090 #endif
1091 }
1092
1093 void SimpleUI::showSettingsUI(const std::string& str)
1094 {
1095 #if MERGE_ME
1096     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1097     if(!m_settingsUI){
1098         m_settingsUI =
1099                 std::dynamic_pointer_cast
1100                 <tizen_browser::base_ui::SettingsUI,tizen_browser::core::AbstractService>
1101                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.settingsui"));
1102         M_ASSERT(m_settingsUI);
1103         m_settingsUI->closeSettingsUIClicked.disconnect_all_slots();
1104         m_settingsUI->closeSettingsUIClicked.connect(boost::bind(&SimpleUI::closeSettingsUI, this,_1));
1105         m_settingsUI->deleteSelectedDataClicked.disconnect_all_slots();
1106         m_settingsUI->deleteSelectedDataClicked.connect(boost::bind(&SimpleUI::settingsDeleteSelectedData, this,_1));
1107         m_settingsUI->resetMostVisitedClicked.disconnect_all_slots();
1108         m_settingsUI->resetMostVisitedClicked.connect(boost::bind(&SimpleUI::settingsResetMostVisited, this,_1));
1109         m_settingsUI->resetBrowserClicked.disconnect_all_slots();
1110         m_settingsUI->resetBrowserClicked.connect(boost::bind(&SimpleUI::settingsResetBrowser, this,_1));
1111         m_settingsUI->show(m_window.get());
1112         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1113     }
1114 #endif
1115 }
1116
1117 void SimpleUI::closeSettingsUI(const std::string& str)
1118 {
1119 #if MERGE_ME
1120         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1121         m_settingsUI.reset();
1122 #endif
1123 }
1124
1125 void SimpleUI::showMoreMenu()
1126 {
1127 #if MERGE_ME
1128     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1129     bool current_tab_as_new_tab = isHomePageActive() || (m_historyService->getHistoryItemsCount() == 0);
1130     if(!m_moreMenuUI){
1131            m_moreMenuUI =
1132                 std::dynamic_pointer_cast
1133                 <tizen_browser::base_ui::MoreMenuUI,tizen_browser::core::AbstractService>
1134                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.moremenuui"));
1135         M_ASSERT(m_moreMenuUI);
1136         m_moreMenuUI->historyUIClicked.connect(boost::bind(&SimpleUI::showHistoryUI, this,_1));
1137         m_moreMenuUI->settingsClicked.connect(boost::bind(&SimpleUI::showSettingsUI, this,_1));
1138         m_moreMenuUI->closeMoreMenuClicked.disconnect_all_slots();
1139         m_moreMenuUI->closeMoreMenuClicked.connect(boost::bind(&SimpleUI::closeMoreMenu, this,_1));
1140         m_moreMenuUI->AddBookmarkInput.disconnect_all_slots();
1141         m_moreMenuUI->AddBookmarkInput.connect(boost::bind(&SimpleUI::addToBookmarks, this,_1));
1142         m_moreMenuUI->BookmarkFolderCreated.disconnect_all_slots();
1143         m_moreMenuUI->BookmarkFolderCreated.connect(boost::bind(&SimpleUI::NewFolder, this,_1,_2,_3));
1144         m_moreMenuUI->show(m_window.get());
1145         m_moreMenuUI->getBookmarkFolderList(getBookmarkFolders());
1146         m_moreMenuUI->showCurrentTab(current_tab_as_new_tab ? nullptr : m_historyService->getHistoryItems().front());
1147         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1148     }
1149 #endif
1150 }
1151
1152 void SimpleUI::closeMoreMenu(const std::string& str)
1153 {
1154 #if MERGE_ME
1155         BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1156         m_moreMenuUI.reset() ;
1157 #endif
1158 }
1159
1160 void SimpleUI::showBookmarkManagerMenu()
1161 {
1162 #if MERGE_ME
1163     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1164     if(!m_bookmarkManagerUI){
1165         m_bookmarkManagerUI =
1166                 std::dynamic_pointer_cast
1167                 <tizen_browser::base_ui::BookmarkManagerUI,tizen_browser::core::AbstractService>
1168                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.bookmarkmanagerui"));
1169         M_ASSERT(m_bookmarkManagerUI);
1170         m_bookmarkManagerUI->closeBookmarkManagerClicked.disconnect_all_slots();
1171         m_bookmarkManagerUI->closeBookmarkManagerClicked.connect(boost::bind(&SimpleUI::closeBookmarkManagerMenu, this,_1));
1172         m_bookmarkManagerUI->saveFolderClicked.disconnect_all_slots();
1173         m_bookmarkManagerUI->saveFolderClicked.connect(boost::bind(&SimpleUI::saveFolder, this,_1,_2,_3));
1174         m_bookmarkManagerUI->bookmarkFolderClicked.disconnect_all_slots();
1175         m_bookmarkManagerUI->bookmarkFolderClicked.connect(boost::bind(&SimpleUI::updateBookmakMangaerGenGrid, this,_1));
1176         m_bookmarkManagerUI->show(m_window.get());
1177         m_bookmarkManagerUI->addBookmarkFolderItems(getBookmarkFolders());
1178         m_bookmarkManagerUI->showTopContent();
1179     }
1180 #endif
1181 }
1182
1183 void SimpleUI::updateBookmakMangaerGenGrid(int folder_id)
1184 {
1185 #if MERGE_ME
1186     m_bookmarkManagerUI->updateGengrid();
1187     m_bookmarkManagerUI->addBookmarkItems(getBookmarks(folder_id));
1188     m_bookmarkManagerUI->showTopContent();
1189 #endif
1190 }
1191
1192 void SimpleUI::closeBookmarkManagerMenu(std::string& str)
1193 {
1194 #if MERGE_ME
1195     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1196     m_bookmarkManagerUI.reset();
1197 #endif
1198 }
1199
1200 void SimpleUI::openLinkFromPopup(const std::string &uri)
1201 {
1202     filterURL(uri);
1203     hidePopup();
1204 }
1205
1206 void SimpleUI::hideHistory()
1207 {
1208     hidePopup();
1209 }
1210
1211 void SimpleUI::settingsPointerModeSwitch(bool newState)
1212 {
1213     BROWSER_LOGD("%s: Setting Pointer mode to:%s", __func__, (newState ? "true" : "false"));
1214 }
1215
1216 void SimpleUI::settingsPrivateModeSwitch(bool newState)
1217 {
1218     BROWSER_LOGD("%s: Setting Private mode to: %s", __func__, (newState ? "true" : "false"));
1219     m_webEngine->setPrivateMode(newState);
1220     BROWSER_LOGD("[%s:%d] webEngine private mode: %s", __PRETTY_FUNCTION__, __LINE__, (m_webEngine->isPrivateMode() ? "true" : "false"));
1221 }
1222
1223 void SimpleUI::settingsDeleteSelectedData(const std::string& str)
1224 {
1225     BROWSER_LOGD("[%s]: Deleting Hisory", __func__);
1226     SimplePopup *popup = SimplePopup::createPopup();
1227     popup->setTitle("Delete selected data");
1228     popup->addButton(OK);
1229     popup->addButton(CANCEL);
1230     popup->setMessage("Are you sure you want to delete all selected data?");
1231     std::shared_ptr<EntryPopupData> popupData = std::make_shared<EntryPopupData>();
1232     popupData->text = str;
1233     popup->setData(popupData);
1234     popup->buttonClicked.connect(boost::bind(&SimpleUI::onDeleteSelectedDataButton, this, _1, _2));
1235     popup->show();
1236 }
1237
1238 void SimpleUI::onDeleteSelectedDataButton(PopupButtons button, std::shared_ptr< PopupData > popupData)
1239 {
1240     if(button == OK){
1241         BROWSER_LOGD("[%s]: OK", __func__);
1242         std::string dataText = std::static_pointer_cast<EntryPopupData>(popupData)->text;
1243         BROWSER_LOGD("[%s]: TYPE : %s", __func__, dataText.c_str());
1244         if (dataText.find("CACHE") != std::string::npos)
1245                 m_webEngine->clearPrivateData();
1246         if (dataText.find("COOKIES") != std::string::npos)
1247                 m_webEngine->clearPrivateData();
1248         if (dataText.find("HISTORY") != std::string::npos)
1249                 m_historyService->clearAllHistory();
1250         //webTitleBar->removeFavIcon();
1251         //webTitleBar->show("History deleted");
1252     }
1253 }
1254
1255 void SimpleUI::settingsResetMostVisited(const std::string& str)
1256 {
1257     BROWSER_LOGD("[%s]: Deleting Hisory", __func__);
1258     SimplePopup *popup = SimplePopup::createPopup();
1259     popup->setTitle("Delete most visited");
1260     popup->addButton(OK);
1261     popup->addButton(CANCEL);
1262     popup->setMessage("Are you sure you want to delete most visited sites?");
1263     popup->buttonClicked.connect(boost::bind(&SimpleUI::onDeleteMostVisitedButton, this, _1, _2));
1264     popup->show();
1265 }
1266
1267 void SimpleUI::onDeleteMostVisitedButton(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
1268 {
1269     if(button == OK){
1270         BROWSER_LOGD("[%s]: OK", __func__);
1271         BROWSER_LOGD("[%s]: Deleting most visited", __func__);
1272         /*m_historyService->clearAllHistory();
1273         webTitleBar->removeFavIcon();
1274         webTitleBar->show("History deleted");*/
1275     }
1276 }
1277
1278 void SimpleUI::settingsResetBrowser(const std::string& str)
1279 {
1280     BROWSER_LOGD("[%s]: Deleting Hisory", __func__);
1281     SimplePopup *popup = SimplePopup::createPopup();
1282     popup->setTitle("Reset browser");
1283     popup->addButton(OK);
1284     popup->addButton(CANCEL);
1285     popup->setMessage("Are you sure you want to reset browser?");
1286     popup->buttonClicked.connect(boost::bind(&SimpleUI::onResetBrowserButton, this, _1, _2));
1287     popup->show();
1288 }
1289
1290 void SimpleUI::onResetBrowserButton(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
1291 {
1292     if(button == OK){
1293         BROWSER_LOGD("[%s]: OK", __func__);
1294         BROWSER_LOGD("[%s]: Resetting browser", __func__);
1295         /*webTitleBar->removeFavIcon();
1296         webTitleBar->show("History deleted");*/
1297     }
1298 }
1299
1300 void SimpleUI::tabLimitPopupButtonClicked(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
1301 {
1302     if(button == CLOSE_TAB){
1303         BROWSER_LOGD("[%s]: CLOSE TAB", __func__);
1304         closeTab();
1305     }
1306 }
1307
1308 void SimpleUI::tabCreated()
1309 {
1310     int tabs = m_webEngine->tabsCount();
1311
1312     if(tabs > m_tabLimit)
1313     {
1314         SimplePopup *popup = SimplePopup::createPopup();
1315         popup->setTitle("Too many tabs open");
1316         popup->addButton(CONTINUE);
1317         popup->addButton(CLOSE_TAB);
1318         popup->setMessage("Browser might slow down. Are you sure you want to continue?");
1319         popup->buttonClicked.connect(boost::bind(&SimpleUI::tabLimitPopupButtonClicked, this, _1, _2));
1320         popup->show();
1321     }
1322     elm_object_part_text_set(rightButtonBar->getContent(), "tabs_number", (boost::format("%1%") % tabs).str().c_str());
1323 }
1324
1325 void SimpleUI::updateView() {
1326     int tabs = m_webEngine->tabsCount();
1327     BROWSER_LOGD("[%s] Opened tabs: %d", __func__, tabs);
1328     if (tabs == 0) {
1329         switchViewToHomePage();
1330         elm_object_part_text_set(rightButtonBar->getContent(), "tabs_number", "");
1331     } else {
1332         if (!isHomePageActive()) {
1333             updateBrowserView();
1334         }
1335         elm_object_part_text_set(rightButtonBar->getContent(), "tabs_number", (boost::format("%1%") % tabs).str().c_str());
1336     }
1337 }
1338
1339 void SimpleUI::tabClosed(const tizen_browser::basic_webengine::TabId& id) {
1340     updateView();
1341 }
1342
1343 void SimpleUI::onNetworkError()
1344 {
1345     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
1346     if(!m_networkErrorPopup){
1347         m_networkErrorPopup = SimplePopup::createPopup();
1348         m_networkErrorPopup->setTitle("Network Error");
1349         m_networkErrorPopup->addButton(CONNECT);
1350         m_networkErrorPopup->addButton(CANCEL);
1351         m_networkErrorPopup->setMessage("Network is disconnected. Please check the connection.");
1352         m_networkErrorPopup->buttonClicked.connect(boost::bind(&SimpleUI::onNetErrorButtonPressed, this, _1, _2));
1353         m_networkErrorPopup->show();
1354     }
1355 }
1356
1357 void SimpleUI::onNetErrorButtonPressed(PopupButtons, std::shared_ptr< PopupData >)
1358 {
1359     m_networkErrorPopup = 0;
1360 }
1361
1362 void SimpleUI::onNetworkConnected()
1363 {
1364     if(m_networkErrorPopup){
1365         delete m_networkErrorPopup;
1366         m_networkErrorPopup = 0;
1367     }
1368 }
1369
1370
1371 void SimpleUI::showProgressBar()
1372 {
1373     elm_object_signal_emit(m_mainLayout, "show_progressbar_bg", "ui");
1374     elm_object_part_content_set(m_mainLayout,"progress_bar",m_progressBar);
1375 }
1376
1377 void SimpleUI::hideProgressBar()
1378 {
1379     elm_object_signal_emit(m_mainLayout, "hide_progressbar_bg", "ui");
1380     elm_progressbar_value_set(m_progressBar,0.0);
1381     elm_object_part_content_unset(m_mainLayout,"progress_bar");
1382     evas_object_hide(m_progressBar);
1383 }
1384
1385 void SimpleUI::searchWebPage(std::string &text, int flags)
1386 {
1387     m_webEngine->searchOnWebsite(text, flags);
1388 }
1389
1390 void SimpleUI::favicon_clicked(void *data, Evas_Object */*obj*/, const char */*emission*/, const char */*source*/)
1391 {
1392     BROWSER_LOGD("[%s],", __func__);
1393     SimpleUI *self = reinterpret_cast<SimpleUI*>(data);
1394     if (!self->isHomePageActive() && !self->isErrorPageActive())
1395     {
1396         self->m_simpleURI->clearFocus();
1397     }
1398 }
1399
1400 void SimpleUI::addToBookmarks(int folder_id)
1401 {   BROWSER_LOGD("[%s,%d],", __func__, __LINE__);
1402         if (m_favoriteService)
1403             {   if( m_webEngine && !m_webEngine->getURI().empty())
1404                   {  m_favoriteService->addToBookmarks(m_webEngine->getURI(), m_webEngine->getTitle(), std::string(),
1405                                                                                   m_webEngine->getSnapshotData(373, 240),
1406                                                                                   m_webEngine->getFavicon(),(unsigned int)folder_id);
1407                  }
1408         }
1409 }
1410
1411 void SimpleUI::saveFolder(const char* title,int folder_id, int by_operator)
1412 {   BROWSER_LOGD("[%s,%d],", __func__, __LINE__);
1413      int id = -1;
1414         if (m_favoriteService)
1415                 m_favoriteService->save_folder(title, &id, folder_id, by_operator);
1416     if (id >= 0 )
1417      {     BROWSER_LOGD("[%s], Added New Folder", __func__);
1418      }
1419 #if MERGE_ME
1420     if(m_bookmarkManagerUI)
1421     {   m_bookmarkManagerUI->updateGengrid();
1422         m_bookmarkManagerUI->addBookmarkFolderItems(getBookmarkFolders());
1423     }
1424 #endif
1425 }
1426
1427
1428
1429 void SimpleUI::NewFolder(const char* title,int folder_id, int by_operator)
1430 {   BROWSER_LOGD("[%s,%d],", __func__, __LINE__);
1431     int id = -1;
1432         if (m_favoriteService)
1433                 m_favoriteService->save_folder(title, &id, folder_id, by_operator);
1434     if (id >= 0 )
1435      {     BROWSER_LOGD("[%s], Added New Folder", __func__);
1436      }
1437         if (m_favoriteService)
1438             {   if( m_webEngine && !m_webEngine->getURI().empty())
1439                   {  m_favoriteService->addToBookmarks(m_webEngine->getURI(), m_webEngine->getTitle(), std::string(),
1440                                                                                   m_webEngine->getSnapshotData(373, 240),
1441                                                                                   m_webEngine->getFavicon(),(unsigned int)id);
1442                  }
1443         }
1444 }
1445
1446 void SimpleUI::deleteBookmark(void)
1447 {
1448         if (m_favoriteService)
1449                 m_favoriteService->deleteBookmark(m_webEngine->getURI());
1450 }
1451
1452 }
1453 }