#include "TabOrigin.h"
#include "WebConfirmation.h"
#include "WebEngineSettings.h"
+#include "State.h"
namespace tizen_browser {
namespace basic_webengine {
* It is designed for multiple tabs operations.
* It is designed to be only way for communication with WebEngine. It should NOT return WebEngine object.
*/
-template<typename T>
#ifndef NDEBUG
-class AbstractWebEngine : public tizen_browser::core::AbstractService, ShowLifeCycle<AbstractWebEngine<T>>
+class AbstractWebEngine: public tizen_browser::core::AbstractService, ShowLifeCycle<AbstractWebEngine>
#else
class AbstractWebEngine: public tizen_browser::core::AbstractService
#endif
* Remember that there must be at least 1 tab created to return layout
* @return pointer Evas_Object for current WebView.
*/
- virtual T * getLayout() = 0;
+ virtual Evas_Object* getLayout() = 0;
/**
* Initialize WebEngine.
- * @param guiParent GUI parent object (now should pass Evas_Object)
- * \todo make guiParent nonEFL object
+ * @param guiParent GUI parent object
*/
- virtual void init(void * guiParent) = 0;
+ virtual void init(Evas_Object* guiParent) = 0;
/**
* Preinitialize WebView parameters.
* @param tabId Tab id of the new tab. If boost::none, tab's id will be
* generated
* @param desktopMode true if desktop mode, false if mobile mode
- * @param incognitoMode true if incognito mode, false if not
* @return TabId of created tab
*/
virtual TabId addTab(
const std::string& uri = std::string(),
- const TabId* openerId = NULL,
const boost::optional<int> tabId = boost::none,
const std::string& title = std::string(),
bool desktopMode = true,
- bool incognitoMode = false,
TabOrigin origin = TabOrigin::UNKNOWN) = 0;
/**
* @param tab id
* @return returns underlaying UI component
*/
- virtual T* getTabView(TabId id) = 0;
+ virtual Evas_Object* getTabView(TabId id) = 0;
/**
* Switch current tab for tab with tabId
bool async, tizen_browser::tools::SnapshotType snapshot_type) = 0;
/**
- * Get the state of private mode for a specific tab
+ * Get the state of secret mode
*
* /param id of snapshot
* /return state of private mode
*/
- virtual bool isPrivateMode(const TabId&) = 0;
+ virtual bool isSecretMode() = 0;
virtual bool isLoadError() const = 0;
*/
virtual void onTabIdCreated(int tabId) = 0;
-#if PROFILE_MOBILE
/**
* @brief Searches for word in the current page.
*
* @brief Informs WebEngine that device orientation is changed.
*/
virtual void orientationChanged() = 0;
-#endif
+
+ /**
+ * @brief set next state
+ */
+ virtual void changeState() = 0;
+
+ /**
+ * @brief Get current state of the engine
+ */
+ virtual State getState() = 0;
/**
* Ask browser to minimize itself
--- /dev/null
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __STATE_H__
+#define __STATE_H__
+
+namespace tizen_browser {
+namespace basic_webengine {
+
+enum class State {
+ NORMAL,
+ SECRET
+};
+
+}
+}
+
+#endif // __STATE_H__
\ No newline at end of file
evas_object_smart_callback_add(button, "clicked", callback, data);
elm_box_pack_end(m_bottom_box, button);
- m_map_bottom_box.insert(std::pair<std::string, Evas_Object*>(text, button));
+ m_bottom_buttons.push_back(button);
evas_object_show(button);
}
-void NaviframeWrapper::setEnableButtonInBottomBar(std::string text, bool enabled)
+void NaviframeWrapper::setEnableButtonInBottomBar(int number, bool enabled)
{
if (enabled)
- elm_object_signal_emit(m_map_bottom_box[text], "elm,state,enabled", "elm");
+ elm_object_signal_emit(m_bottom_buttons[number], "elm,state,enabled", "elm");
else
- elm_object_signal_emit(m_map_bottom_box[text], "elm,state,disabled", "elm");
+ elm_object_signal_emit(m_bottom_buttons[number], "elm,state,disabled", "elm");
+}
+
+void NaviframeWrapper::setBottomButtonText(int number, const std::string& text)
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ elm_object_part_text_set(m_bottom_buttons[number], "elm.text", text.c_str());
}
void NaviframeWrapper::setVisibleBottomBar(bool visible)
void createBottomBar(Evas_Object* layout = nullptr,
std::string swallow_name = "elm.swallow.content");
void addButtonToBottomBar(std::string text, Evas_Smart_Cb callback, void* data);
- void setEnableButtonInBottomBar(std::string text, bool enabled);
+ void setEnableButtonInBottomBar(int number, bool enabled);
+ void setBottomButtonText(int number, const std::string& text);
void setVisibleBottomBar(bool visible);
protected:
Evas_Object *m_parent;
Evas_Object *m_layout;
Evas_Object *m_bottom_box;
- std::map<std::string, Evas_Object*> m_map_bottom_box;
+ std::vector<Evas_Object*> m_bottom_buttons;
};
using SharedNaviframeWrapper = std::shared_ptr<NaviframeWrapper>;
name: "AO035";
color: 255 255 255 230;
}
-
+ color_class {
+ name: "secret";
+ color: 97 97 97 255;
+ }
//Font colors
color_class {
name: "ATO015";
#include <Evas.h>
#include <Elementary.h>
#include <string>
-#include <list>
-#include <memory>
#include "AbstractPopup.h"
#include "PopupButtons.h"
// m_webPageUI->getUrlHistoryList()->openURL.connect(boost::bind(&SimpleUI::onOpenURL, this, _1));
// m_webPageUI->getUrlHistoryList()->uriChanged.connect(boost::bind(&SimpleUI::filterURL, this, _1));
m_webPageUI->backPage.connect(boost::bind(&SimpleUI::switchViewToWebPage, this));
- m_webPageUI->backPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::back, m_webEngine.get()));
+ m_webPageUI->backPage.connect(boost::bind(&basic_webengine::AbstractWebEngine::back, m_webEngine.get()));
m_webPageUI->showTabUI.connect(boost::bind(&SimpleUI::showTabUI, this));
m_webPageUI->showBookmarksUI.connect(boost::bind(&SimpleUI::showBookmarkManagerUI, this,
m_favoriteService->getRoot(), BookmarkManagerState::Default));
m_webPageUI->showHomePage.connect(boost::bind(&SimpleUI::showHomePage, this));
- m_webPageUI->forwardPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::forward, m_webEngine.get()));
+ m_webPageUI->forwardPage.connect(boost::bind(&basic_webengine::AbstractWebEngine::forward, m_webEngine.get()));
m_webPageUI->showQuickAccess.connect(boost::bind(&SimpleUI::showQuickAccess, this));
m_webPageUI->hideQuickAccess.connect(boost::bind(&QuickAccess::hideUI, m_quickAccess));
- m_webPageUI->focusWebView.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::setFocus, m_webEngine.get()));
- m_webPageUI->unfocusWebView.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::clearFocus, m_webEngine.get()));
+ m_webPageUI->focusWebView.connect(boost::bind(&basic_webengine::AbstractWebEngine::setFocus, m_webEngine.get()));
+ m_webPageUI->unfocusWebView.connect(boost::bind(&basic_webengine::AbstractWebEngine::clearFocus, m_webEngine.get()));
m_webPageUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::showBookmarkManagerUI, this,
m_favoriteService->getRoot(), BookmarkManagerState::Default));
m_webPageUI->getWindow.connect(boost::bind(&SimpleUI::getMainWindow, this));
m_webPageUI->getURIEntry().secureIconClicked.connect(boost::bind(&SimpleUI::showCertificatePopup, this));
m_webPageUI->getURIEntry().isValidCert.connect(boost::bind(&services::CertificateContents::isValidCertificate, m_certificateContents, _1));
m_webPageUI->getURIEntry().reloadPage.connect(
- boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::reload, m_webEngine.get()));
+ boost::bind(&basic_webengine::AbstractWebEngine::reload, m_webEngine.get()));
m_webPageUI->getURIEntry().stopLoadingPage.connect(
- boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::stopLoading, m_webEngine.get()));
+ boost::bind(&basic_webengine::AbstractWebEngine::stopLoading, m_webEngine.get()));
m_webPageUI->isLandscape.connect(boost::bind(&SimpleUI::isLandscape, this));
m_webPageUI->switchToMobileMode.connect(boost::bind(&SimpleUI::switchToMobileMode, this));
m_webPageUI->switchToDesktopMode.connect(boost::bind(&SimpleUI::switchToDesktopMode, this));
+ m_webPageUI->getEngineState.connect(boost::bind(&basic_webengine::AbstractWebEngine::getState, m_webEngine.get()));
// WPA
m_webPageUI->requestCurrentPageForWebPageUI.connect(boost::bind(&SimpleUI::requestSettingsCurrentPage, this));
m_tabUI->closeTabsClicked.connect(boost::bind(&SimpleUI::closeTabsClicked, this,_1));
m_tabUI->getWindow.connect(boost::bind(&SimpleUI::getMainWindow, this));
m_tabUI->isLandscape.connect(boost::bind(&SimpleUI::isLandscape, this));
+ m_tabUI->changeEngineState.connect(boost::bind(&basic_webengine::AbstractWebEngine::changeState, m_webEngine.get()));
+ m_tabUI->changeEngineState.connect(boost::bind(&SimpleUI::changeEngineState, this));
+ m_tabUI->refetchTabUIData.connect(boost::bind(&SimpleUI::refetchTabUIData, this));
M_ASSERT(m_historyUI.get());
m_historyUI->clearHistoryClicked.connect(boost::bind(&SimpleUI::onClearHistoryAllClicked, this));
m_webEngine =
std::dynamic_pointer_cast
- <basic_webengine::AbstractWebEngine<Evas_Object>,tizen_browser::core::AbstractService>
+ <basic_webengine::AbstractWebEngine,tizen_browser::core::AbstractService>
(tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.webengineservice"));
m_storageService =
boost::bind(&SimpleUI::showSettings, this,_1));
SPSC.getWebEngineSettingsParam.connect(
boost::bind(
- &basic_webengine::AbstractWebEngine<Evas_Object>::getSettingsParam,
+ &basic_webengine::AbstractWebEngine::getSettingsParam,
m_webEngine.get(),
_1));
SPSC. getWebEngineSettingsParamString.connect(
SPSC.setWebEngineSettingsParam.connect(
boost::bind(
- &basic_webengine::AbstractWebEngine<Evas_Object>::setSettingsParam,
+ &basic_webengine::AbstractWebEngine::setSettingsParam,
m_webEngine.get(),
_1,
_2));
m_webEngine->loadProgress.connect(boost::bind(&SimpleUI::progressChanged,this,_1));
m_webEngine->loadFinished.connect(boost::bind(&SimpleUI::loadFinished, this));
m_webEngine->loadStop.connect(boost::bind(&SimpleUI::loadFinished, this));
- m_webEngine->loadError.connect(boost::bind(&SimpleUI::loadError, this));
m_webEngine->tabCreated.connect(boost::bind(&SimpleUI::tabCreated, this));
m_webEngine->checkIfCreate.connect(boost::bind(&SimpleUI::checkIfCreate, this));
m_webEngine->tabClosed.connect(boost::bind(&SimpleUI::tabClosed,this,_1));
m_certificateContents->addOrUpdateCertificateEntry.connect(boost::bind(&storage::CertificateStorage::addOrUpdateCertificateEntry, &m_storageService->getCertificateStorage(), _1, _2, _3));
#if PROFILE_MOBILE
- m_storageService->getSettingsStorage().setWebEngineSettingsParam.connect(boost::bind(&basic_webengine::AbstractWebEngine<Evas_Object>::setSettingsParam, m_webEngine.get(), _1, _2));
+ m_storageService->getSettingsStorage().setWebEngineSettingsParam.connect(boost::bind(&basic_webengine::AbstractWebEngine::setSettingsParam, m_webEngine.get(), _1, _2));
m_platformInputManager->menuButtonPressed.connect(boost::bind(&SimpleUI::onMenuButtonPressed, this));
m_platformInputManager->XF86BackPressed.connect(boost::bind(&SimpleUI::onXF86BackPressed, this));
m_webEngine->registerHWKeyCallback.connect(boost::bind(&SimpleUI::registerHWKeyCallback, this));
m_webEngine->resume();
m_webEngine->connectCurrentWebViewSignals();
m_webPageUI->switchViewToWebPage(m_webEngine->getLayout(), m_webEngine->getURI(), m_webEngine->isLoading());
- m_webPageUI->toIncognito(m_webEngine->isPrivateMode(m_webEngine->currentTabId()));
}
void SimpleUI::switchToTab(const tizen_browser::basic_webengine::TabId& tabId)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if(m_webEngine->currentTabId() != tabId) {
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_webEngine->switchToTab(tabId);
}
- if(m_webEngine->isLoadError()){
- BROWSER_LOGD("[%s:%d] LOAD ERROR!", __PRETTY_FUNCTION__, __LINE__);
- loadError();
- return;
- }
- BROWSER_LOGD("[%s:%d] swiching to web_view ", __PRETTY_FUNCTION__, __LINE__);
switchViewToWebPage();
}
{
BROWSER_LOGD("[%s:%d] uri =%s", __PRETTY_FUNCTION__, __LINE__, uri.c_str());
tizen_browser::basic_webengine::TabId tab = m_webEngine->addTab(uri,
- nullptr, adaptorId, title, desktopMode, incognitoMode, origin);
+ adaptorId, title, desktopMode, origin);
if (tab == basic_webengine::TabId::NONE) {
BROWSER_LOGW("[%s:%d] New tab is not created!", __PRETTY_FUNCTION__, __LINE__);
return;
}
switchToTab(tab);
- m_webPageUI->toIncognito(incognitoMode);
if (incognitoMode)
switchViewToIncognitoPage();
}
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
switch (snapshot_type) {
case tools::SnapshotType::ASYNC_LOAD_FINISHED:
- m_historyService->updateHistoryItemSnapshot(m_webEngine->getURI(), snapshot);
- m_tabService->updateTabItemSnapshot(m_webEngine->currentTabId(), snapshot);
+ if (m_webEngine->isSecretMode()) {
+ m_tabService->saveThumbCache(m_webEngine->currentTabId(), snapshot);
+ } else {
+ m_historyService->updateHistoryItemSnapshot(m_webEngine->getURI(), snapshot);
+ m_tabService->updateTabItemSnapshot(m_webEngine->currentTabId(), snapshot);
+ }
break;
case tools::SnapshotType::ASYNC_TAB:
m_tabService->updateTabItemSnapshot(m_webEngine->currentTabId(), snapshot);
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_webPageUI->loadFinished();
#if PROFILE_MOBILE
- if (!m_webEngine->isPrivateMode(m_webEngine->currentTabId())) {
+ if (!m_webEngine->isSecretMode()) {
m_tabService->updateTabItem(m_webEngine->currentTabId(),
m_webEngine->getURI(),
m_webEngine->getTitle(),
#endif
}
-void SimpleUI::loadError()
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
-#if !PROFILE_MOBILE
- m_webPageUI->switchViewToErrorPage();
-#endif
-}
-
void SimpleUI::filterURL(const std::string& url)
{
BROWSER_LOGD("[%s:%d] url=%s", __PRETTY_FUNCTION__, __LINE__, url.c_str());
else
m_webEngine->setURI(url);
- if (m_webEngine->isPrivateMode(m_webEngine->currentTabId()) ||
+ if (m_webEngine->isSecretMode() ||
m_webPageUI->stateEquals(WPUState::MAIN_ERROR_PAGE))
switchViewToWebPage();
}
m_viewManager.popTheStack();
}
+void SimpleUI::refetchTabUIData() {
+ m_tabUI->setState(m_webEngine->getState());
+ std::vector<basic_webengine::TabContentPtr> tabsContents =
+ m_webEngine->getTabContents();
+ m_tabService->fillThumbs(tabsContents);
+ m_tabUI->addTabItems(tabsContents);
+}
+
void SimpleUI::newTabClicked()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
void SimpleUI::tabClicked(const tizen_browser::basic_webengine::TabId& tabId)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_viewManager.popStackTo(m_webPageUI.get());
- m_webPageUI->toIncognito(m_webEngine->isPrivateMode(tabId));
switchToTab(tabId);
+ m_viewManager.popStackTo(m_webPageUI.get());
}
void SimpleUI::closeTabsClicked(const tizen_browser::basic_webengine::TabId& tabId)
m_webPageUI->setTabsNumber(tabs);
}
+void SimpleUI::changeEngineState()
+{
+ m_webEngine->disconnectCurrentWebViewSignals();
+ m_webPageUI->switchViewToQuickAccess(m_quickAccess->getContent());
+ updateView();
+}
+
void SimpleUI::windowCreated()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
void loadFinished();
void progressChanged(double progress);
void loadStarted();
- void loadError();
void setErrorButtons();
void switchViewToIncognitoPage();
void switchViewToWebPage();
void updateView();
+ void changeEngineState();
void windowCreated();
void minimizeBrowser();
void showTabUI();
void closeTabUI();
+ void refetchTabUIData();
void switchToMobileMode();
void switchToDesktopMode();
Evas_Object* showHistoryUI(Evas_Object* parent, SharedNaviframeWrapper naviframe, bool removeMode = false);
std::vector<interfaces::AbstractPopup*> m_popupVector;
std::shared_ptr<WebPageUI> m_webPageUI;
- std::shared_ptr<basic_webengine::AbstractWebEngine<Evas_Object>> m_webEngine;
+ std::shared_ptr<basic_webengine::AbstractWebEngine> m_webEngine;
std::shared_ptr<interfaces::AbstractFavoriteService> m_favoriteService;
std::shared_ptr<services::HistoryService> m_historyService;
services::TabServicePtr m_tabService;
void updateTabItemSnapshot(const basic_webengine::TabId& tabId,
tools::BrowserImagePtr imagePtr);
-
+ /**
+ * Cache given thumb image with given tab id.
+ */
+ void saveThumbCache(const basic_webengine::TabId& tabId,
+ tools::BrowserImagePtr imagePtr);
private:
/**
* Help method printing last bp_tab_error_defs error.
*/
boost::optional<tools::BrowserImagePtr> getThumbCache(
const basic_webengine::TabId& tabId);
- /**
- * Cache given thumb image with given tab id.
- */
- void saveThumbCache(const basic_webengine::TabId& tabId,
- tools::BrowserImagePtr imagePtr);
/**
* Check if thumb for given id is in a map.
*/
m_naviframe->setVisibleBottomBar(true);
//TODO: Missing translation
m_naviframe->addButtonToBottomBar("Enable Secret", _enable_secret_clicked, this);
- m_naviframe->setEnableButtonInBottomBar("Enable Secret", true);
+ m_naviframe->setEnableButtonInBottomBar(0, true);
//TODO: _("IDS_BR_OPT_NEW_TAB") when it works
m_naviframe->addButtonToBottomBar("New tab", _new_tab_clicked, this);
- m_naviframe->setEnableButtonInBottomBar("New tab", true);
+ m_naviframe->setEnableButtonInBottomBar(1, true);
}
void TabUI::createEmptyLayout()
}
}
+void TabUI::setState(basic_webengine::State state)
+{
+ switch(state) {
+ case basic_webengine::State::NORMAL:
+ m_naviframe->setBottomButtonText(0, "Enable Secret");
+ break;
+ case basic_webengine::State::SECRET:
+ m_naviframe->setBottomButtonText(0, "Disable Secret");
+ break;
+ default:
+ BROWSER_LOGE("[%s:%d] Unknown state!", __PRETTY_FUNCTION__, __LINE__);
+ }
+}
+
void TabUI::_cm_sync_clicked(void* data, Evas_Object*, void* )
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
+ auto self = static_cast<TabUI*>(data);
+ self->changeEngineState();
+ self->refetchTabUIData();
} else {
BROWSER_LOGW("[%s] data = nullptr", __PRETTY_FUNCTION__);
}
void TabUI::addTabItems(std::vector<basic_webengine::TabContentPtr>& items)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ elm_gengrid_clear(m_gengrid);
for (auto it = items.begin(); it < items.end(); ++it)
addTabItem(*it);
updateNoTabsText();
#include "AbstractContextMenu.h"
#include "AbstractUIComponent.h"
#include "AbstractService.h"
+#include "AbstractWebEngine/State.h"
#include "ServiceFactory.h"
#include "service_macros.h"
#include "TabIdTypedef.h"
//AbstractContextMenu interface implementation
virtual void showContextMenu() override;
+ void setState(basic_webengine::State state);
+
boost::signals2::signal<void (const tizen_browser::basic_webengine::TabId&)> tabClicked;
boost::signals2::signal<void ()> newTabClicked;
boost::signals2::signal<void (const tizen_browser::basic_webengine::TabId&)> closeTabsClicked;
boost::signals2::signal<void ()> closeTabUIClicked;
+ boost::signals2::signal<void ()> changeEngineState;
+ boost::signals2::signal<void ()> refetchTabUIData;
private:
struct TabData
EXPORT_SERVICE(WebEngineService, "org.tizen.browser.webengineservice")
WebEngineService::WebEngineService()
- : m_initialised(false)
+ : m_state(State::NORMAL)
+ , m_initialised(false)
, m_guiParent(nullptr)
, m_stopped(false)
, m_webViewCacheInitialized(false)
, m_currentTabId(TabId::NONE)
, m_currentWebView(nullptr)
+ , m_stateStruct(&m_normalStateStruct)
, m_tabIdCreated(-1)
- #if PROFILE_MOBILE
+ , m_tabIdSecret(0)
, m_downloadControl(nullptr)
- #endif
{
- m_mostRecentTab.clear();
- m_tabs.clear();
+ m_stateStruct->mostRecentTab.clear();
+ m_stateStruct->tabs.clear();
#if PROFILE_MOBILE
// init settings
void WebEngineService::destroyTabs()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_tabs.clear();
+ m_stateStruct->tabs.clear();
if (m_currentWebView)
m_currentWebView.reset();
}
return m_currentWebView->getLayout();
}
-void WebEngineService::init(void * guiParent)
+void WebEngineService::init(Evas_Object* guiParent)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (!m_initialised) {
if (!m_webViewCacheInitialized) {
m_webViewCacheInitialized = true;
Ewk_Context* context = ewk_context_default_get();
- Evas_Object* ewk_view = ewk_view_add_with_context(evas_object_evas_get(
- reinterpret_cast<Evas_Object *>(m_guiParent)), context);
+ Evas_Object* ewk_view = ewk_view_add_with_context(evas_object_evas_get(m_guiParent), context);
ewk_context_cache_model_set(context, EWK_CACHE_MODEL_PRIMARY_WEBBROWSER);
ewk_view_orientation_send(ewk_view, 0);
evas_object_del(ewk_view);
void WebEngineService::disconnectSignals(std::shared_ptr<WebView> webView)
{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(webView);
webView->favIconChanged.disconnect(boost::bind(&WebEngineService::_favIconChanged, this));
webView->titleChanged.disconnect(boost::bind(&WebEngineService::_titleChanged, this, _1));
BROWSER_LOGD("[%s:%d:%s] ", __PRETTY_FUNCTION__, __LINE__,"m_currentWebView is null");
return;
}
- if (tabsCount()>0) {
- m_currentWebView->suspend();
+ m_currentWebView->suspend();
#if PROFILE_MOBILE
unregisterHWKeyCallback();
#endif
- }
}
void WebEngineService::resume()
BROWSER_LOGD("[%s:%d:%s] ", __PRETTY_FUNCTION__, __LINE__,"m_currentWebView is null");
return;
}
- if (tabsCount()>0) {
- M_ASSERT(m_currentWebView);
- m_currentWebView->resume();
+ m_currentWebView->resume();
#if PROFILE_MOBILE
registerHWKeyCallback();
#endif
- }
}
bool WebEngineService::isSuspended() const
int WebEngineService::tabsCount() const
{
- return m_tabs.size();
+ return m_stateStruct->tabs.size();
}
TabId WebEngineService::currentTabId() const
std::vector<TabContentPtr> WebEngineService::getTabContents() const {
std::vector<TabContentPtr> result;
- for (auto const& tab : m_tabs) {
+ for (auto const& tab : m_stateStruct->tabs) {
auto tabContent = std::make_shared<TabContent>(tab.first, tab.second->getURI(), tab.second->getTitle(), tab.second->getOrigin());
result.push_back(tabContent);
}
return result;
}
-TabId WebEngineService::addTab(const std::string & uri,
- const TabId * tabInitId, const boost::optional<int> tabId,
- const std::string& title, bool desktopMode, bool incognitoMode, TabOrigin origin)
+TabId WebEngineService::addTab(const std::string & uri, const boost::optional<int> tabId,
+ const std::string& title, bool desktopMode, TabOrigin origin)
{
if (!(*AbstractWebEngine::checkIfCreate()))
return currentTabId();
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- int newAdaptorId = -1;
- if (tabId) {
- newAdaptorId = *tabId;
+ TabId newTabId(0);
+ if (m_state == State::NORMAL) {
+ int newAdaptorId = -1;
+ if (tabId) {
+ newAdaptorId = *tabId;
+ } else {
+ // searching for next available tabId
+ newAdaptorId = createTabId();
+ if (newAdaptorId < 0)
+ return TabId(TabId::NONE);
+ }
+ newTabId = TabId(newAdaptorId);
} else {
- // searching for next available tabId
- newAdaptorId = createTabId();
- if (newAdaptorId < 0)
- return TabId(TabId::NONE);
+ ++m_tabIdSecret;
+ newTabId = TabId(m_tabIdSecret);
}
- TabId newTabId(newAdaptorId);
m_webViewCacheInitialized = true;
- WebViewPtr p = std::make_shared<WebView>(reinterpret_cast<Evas_Object *>(m_guiParent), newTabId, title, incognitoMode);
- if (tabInitId)
- p->init(desktopMode, origin, getTabView(*tabInitId));
- else
- p->init(desktopMode, origin);
+ WebViewPtr p = std::make_shared<WebView>(m_guiParent, newTabId, title, m_state == State::SECRET);
+ p->init(desktopMode, origin);
- m_tabs[newTabId] = p;
+ m_stateStruct->tabs[newTabId] = p;
#if PROFILE_MOBILE
setWebViewSettings(p);
}
Evas_Object* WebEngineService::getTabView(TabId id){
- if (m_tabs.find(id) == m_tabs.end()) {
+ if (m_stateStruct->tabs.find(id) == m_stateStruct->tabs.end()) {
BROWSER_LOGW("[%s:%d] there is no tab of id %d", __PRETTY_FUNCTION__, __LINE__, id.get());
return nullptr;
}
- return m_tabs[id]->getLayout();
+ return m_stateStruct->tabs[id]->getLayout();
}
bool WebEngineService::switchToTab(tizen_browser::basic_webengine::TabId newTabId)
suspend();
}
- if (m_tabs.find(newTabId) == m_tabs.end()) {
+ if (m_stateStruct->tabs.find(newTabId) == m_stateStruct->tabs.end()) {
BROWSER_LOGW("[%s:%d] there is no tab of id %d", __PRETTY_FUNCTION__, __LINE__, newTabId.get());
return false;
}
#if PROFILE_MOBILE
closeFindOnPage();
#endif
- m_currentWebView = m_tabs[newTabId];
+ m_currentWebView = m_stateStruct->tabs[newTabId];
m_currentTabId = newTabId;
- m_mostRecentTab.erase(std::remove(m_mostRecentTab.begin(), m_mostRecentTab.end(), newTabId), m_mostRecentTab.end());
- m_mostRecentTab.push_back(newTabId);
+ m_stateStruct->mostRecentTab.erase(
+ std::remove(m_stateStruct->mostRecentTab.begin(),
+ m_stateStruct->mostRecentTab.end(),
+ newTabId),
+ m_stateStruct->mostRecentTab.end());
+ m_stateStruct->mostRecentTab.push_back(newTabId);
connectSignals(m_currentWebView);
resume();
if (closingTabId == TabId::NONE){
return res;
}
- m_tabs.erase(closingTabId);
- m_mostRecentTab.erase(std::remove(m_mostRecentTab.begin(), m_mostRecentTab.end(), closingTabId), m_mostRecentTab.end());
+ m_stateStruct->tabs.erase(closingTabId);
+ m_stateStruct->mostRecentTab.erase(
+ std::remove(m_stateStruct->mostRecentTab.begin(),
+ m_stateStruct->mostRecentTab.end(),
+ closingTabId),
+ m_stateStruct->mostRecentTab.end());
if (closingTabId == m_currentTabId) {
if (m_currentWebView)
m_currentWebView.reset();
}
- if (m_tabs.size() == 0) {
+ if (m_stateStruct->tabs.size() == 0) {
m_currentTabId = TabId::NONE;
}
- else if (closingTabId == m_currentTabId && m_mostRecentTab.size()){
- res = switchToTab(m_mostRecentTab.back());
+ else if (closingTabId == m_currentTabId && m_stateStruct->mostRecentTab.size()){
+ res = switchToTab(m_stateStruct->mostRecentTab.back());
}
tabClosed(closingTabId);
M_ASSERT(c && c->getTabId() != TabId());
// check if still exists
- if (m_tabs.find(c->getTabId()) == m_tabs.end()) {
+ if (m_stateStruct->tabs.find(c->getTabId()) == m_stateStruct->tabs.end()) {
return;
}
- m_tabs[c->getTabId()]->confirmationResult(c);
+ m_stateStruct->tabs[c->getTabId()]->confirmationResult(c);
}
-bool WebEngineService::isPrivateMode(const TabId& id)
+bool WebEngineService::isSecretMode()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if (m_tabs.find(id) == m_tabs.end()) {
- BROWSER_LOGW("[%s:%d] there is no tab of id %d", __PRETTY_FUNCTION__, __LINE__, id.get());
- return false;
- }
- return m_tabs[id]->isPrivateMode();
+ return m_state == State::SECRET;
}
std::shared_ptr<tizen_browser::tools::BrowserImage> WebEngineService::getSnapshotData(int width, int height,
std::shared_ptr<tizen_browser::tools::BrowserImage> WebEngineService::getSnapshotData(TabId id, int width, int height, bool async,
tizen_browser::tools::SnapshotType snapshot_type){
- if (m_tabs.find(id) == m_tabs.end()) {
+ if (m_stateStruct->tabs.find(id) == m_stateStruct->tabs.end()) {
BROWSER_LOGW("[%s:%d] there is no tab of id %d", __PRETTY_FUNCTION__, __LINE__, id.get());
return std::shared_ptr<tizen_browser::tools::BrowserImage>();
}
- return m_tabs[id]->captureSnapshot(width, height, async, snapshot_type);
+ return m_stateStruct->tabs[id]->captureSnapshot(width, height, async, snapshot_type);
}
void WebEngineService::setFocus()
void WebEngineService::clearCache()
{
- for(std::map<TabId, WebViewPtr>::const_iterator it = m_tabs.begin(); it != m_tabs.end(); ++it){
- it->second->clearCache();
- }
+ for(const auto& it: m_stateStruct->tabs) {
+ it.second->clearCache();
+ }
}
void WebEngineService::clearCookies()
{
- for(std::map<TabId, WebViewPtr>::const_iterator it = m_tabs.begin(); it != m_tabs.end(); ++it){
- it->second->clearCookies();
- }
+ for(const auto& it: m_stateStruct->tabs) {
+ it.second->clearCookies();
+ }
}
void WebEngineService::clearPrivateData()
{
- for(std::map<TabId, WebViewPtr>::const_iterator it = m_tabs.begin(); it != m_tabs.end(); ++it){
- it->second->clearPrivateData();
- }
+ for(const auto& it: m_stateStruct->tabs) {
+ it.second->clearPrivateData();
+ }
}
void WebEngineService::clearPasswordData()
{
- for(std::map<TabId, WebViewPtr>::const_iterator it = m_tabs.begin(); it != m_tabs.end(); ++it){
- it->second->clearPasswordData();
- }
+ for(const auto& it: m_stateStruct->tabs) {
+ it.second->clearPasswordData();
+ }
}
void WebEngineService::clearFormData()
}
}
ewk_context_form_candidate_data_delete_all(ewk_context_default_get());
- for (std::map<TabId, WebViewPtr>::const_iterator it = m_tabs.begin(); it != m_tabs.end(); ++it)
- it->second->clearFormData();
+ for(const auto& it: m_stateStruct->tabs)
+ it.second->clearFormData();
}
void WebEngineService::searchOnWebsite(const std::string & searchString, int flags)
if (isBackEnabled()) {
m_currentWebView->back();
- } else if (m_currentWebView->isPrivateMode()) {
- closeTab();
- } else if (m_currentWebView->getOrigin().isFromWebView() && m_tabs.find(m_currentWebView->getOrigin().getValue()) != m_tabs.end()) {
+ } else if (m_currentWebView->getOrigin().isFromWebView() &&
+ m_stateStruct->tabs.find(m_currentWebView->getOrigin().getValue()) != m_stateStruct->tabs.end()) {
int switchTo = m_currentWebView->getOrigin().getValue();
closeTab();
switchToTab(switchTo);
m_currentWebView->scrollView(dx, dy);
}
-#if PROFILE_MOBILE
void WebEngineService::findWord(const char *word, Eina_Bool forward, Evas_Smart_Cb found_cb, void *data)
{
if (m_currentWebView)
void WebEngineService::setSettingsParam(WebEngineSettings param, bool value) {
m_settings[param] = value;
- for(auto it = m_tabs.cbegin(); it != m_tabs.cend(); ++it) {
+ for(auto it = m_stateStruct->tabs.cbegin(); it != m_stateStruct->tabs.cend(); ++it) {
switch (param) {
case WebEngineSettings::PAGE_OVERVIEW:
it->second->ewkSettingsAutoFittingSet(value);
setSettingsParam(WebEngineSettings::SCRIPTS_CAN_OPEN_PAGES, boost::any_cast<bool>(
tizen_browser::config::Config::getInstance().get(CONFIG_KEY::WEB_ENGINE_SCRIPTS_CAN_OPEN_PAGES)));
}
-#endif
+
+void WebEngineService::changeState()
+{
+ if (m_state == State::NORMAL) {
+ m_state = State::SECRET;
+ m_stateStruct = &m_secretStateStruct;
+ } else {
+ m_state = State::NORMAL;
+ m_stateStruct = &m_normalStateStruct;
+ }
+}
} /* end of webengine_service */
} /* end of basic_webengine */
#include "AbstractWebEngine/TabIdTypedef.h"
#include "AbstractWebEngine/WebConfirmation.h"
#include "AbstractWebEngine/TabOrigin.h"
+#include "AbstractWebEngine/State.h"
#include "SnapshotType.h"
#include "BrowserImage.h"
#include "DownloadControl/DownloadControl.h"
class WebView;
-typedef std::shared_ptr<WebView> WebViewPtr;
+using WebViewPtr = std::shared_ptr<WebView>;
+using TabsMapPtr = std::shared_ptr<std::map<TabId, WebViewPtr > >;
-class BROWSER_EXPORT WebEngineService : public AbstractWebEngine<Evas_Object>, boost::noncopyable
+class BROWSER_EXPORT WebEngineService : public AbstractWebEngine, boost::noncopyable
{
public:
WebEngineService();
virtual std::string getName();
Evas_Object * getLayout();
- void init(void * guiParent);
+ void init(Evas_Object* guiParent);
void preinitializeWebViewCache();
void setURI(const std::string &);
*/
TabId addTab(
const std::string & uri = std::string(),
- const TabId* tabInitId = NULL,
const boost::optional<int> tabId = boost::none,
const std::string& title = std::string(),
bool desktopMode = true,
- bool incognitoMode = false,
TabOrigin origin = TabOrigin::UNKNOWN);
Evas_Object* getTabView(TabId id);
bool switchToTab(TabId);
std::shared_ptr<tizen_browser::tools::BrowserImage> getSnapshotData(TabId id, int width, int height, bool async, tizen_browser::tools::SnapshotType snapshot_type);
/**
- * @brief Get the state of private mode for a specific tab
+ * @brief Get the state of secret mode
*
- * @param id of snapshot
- * @return state of private mode where:
- * -1 is "Not set"
- * 0 is "False"
- * 1 is "True"
*/
- bool isPrivateMode(const TabId& id);
+ bool isSecretMode();
/**
void onTabIdCreated(int tabId) override;
-#if PROFILE_MOBILE
/**
* @brief Searches for word in the current page.
*
* @brief Reset WebView settings
*/
virtual void resetSettingsParam() override;
-#endif
+
+ /**
+ * @brief set next state
+ */
+ void changeState() override;
+
+ /**
+ * @brief Get current state of the engine
+ */
+ State getState() override { return m_state; }
private:
// callbacks from WebView
void _favIconChanged(std::shared_ptr<tizen_browser::tools::BrowserImage> bi);
int createTabId();
private:
+ struct StateStruct {
+ std::map<TabId, WebViewPtr > tabs;
+ std::vector<TabId> mostRecentTab;
+ };
+
+ State m_state;
bool m_initialised;
- void* m_guiParent;
+ Evas_Object* m_guiParent;
bool m_stopped;
bool m_webViewCacheInitialized;
TabId m_currentTabId;
// current WebView
WebViewPtr m_currentWebView;
-
- // map of all tabs (WebViews)
- std::map<TabId, WebViewPtr > m_tabs;
- // Most recent tab list
- std::vector<TabId> m_mostRecentTab;
+ StateStruct m_normalStateStruct;
+ StateStruct m_secretStateStruct;
+ StateStruct* m_stateStruct;
int m_tabIdCreated;
-#if PROFILE_MOBILE
+ int m_tabIdSecret;
+
std::map<WebEngineSettings, bool> m_settings;
DownloadControl *m_downloadControl;
-#endif
};
} /* end of webengine_service */
#endif
}
-void WebView::init(bool desktopMode, TabOrigin origin, Evas_Object*)
+void WebView::init(bool desktopMode, TabOrigin origin)
{
m_ewkView = m_private ? ewk_view_add_in_incognito_mode(evas_object_evas_get(m_parent)) :
ewk_view_add_with_context(evas_object_evas_get(m_parent), ewk_context_default_get());
WebView * self = reinterpret_cast<WebView *>(data);
BROWSER_LOGD("[%s:%d] self=%p", __PRETTY_FUNCTION__, __LINE__, self);
BROWSER_LOGD("Window creating in tab: %s", self->getTabId().toString().c_str());
- std::shared_ptr<basic_webengine::AbstractWebEngine<Evas_Object>> m_webEngine;
+ std::shared_ptr<basic_webengine::AbstractWebEngine> m_webEngine;
m_webEngine = std::dynamic_pointer_cast
<
- basic_webengine::AbstractWebEngine<Evas_Object>,tizen_browser::core::AbstractService
+ basic_webengine::AbstractWebEngine,tizen_browser::core::AbstractService
>
(tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.webengineservice"));
M_ASSERT(m_webEngine);
TabId id(TabId::NONE);
TabId currentTabId = m_webEngine->currentTabId();
if (currentTabId != (id = m_webEngine->addTab(std::string(),
- &self->getTabId(),
boost::none,
std::string(),
self->isDesktopMode(),
- self->isPrivateMode(),
currentTabId.get()))) {
BROWSER_LOGD("Created tab: %s", id.toString().c_str());
Evas_Object* tab_ewk_view = m_webEngine->getTabView(id);
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
WebView * self = reinterpret_cast<WebView *>(data);
- std::shared_ptr<AbstractWebEngine<Evas_Object>> m_webEngine =
+ std::shared_ptr<AbstractWebEngine> m_webEngine =
std::dynamic_pointer_cast
- <basic_webengine::AbstractWebEngine<Evas_Object>,tizen_browser::core::AbstractService>
+ <basic_webengine::AbstractWebEngine,tizen_browser::core::AbstractService>
(tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.webengineservice"));
m_webEngine->closeTab(self->getTabId());
}
public:
WebView(Evas_Object *, TabId, const std::string& title, bool incognitoMode);
virtual ~WebView();
- void init(bool desktopMode, TabOrigin origin, Evas_Object * view = NULL);
+ void init(bool desktopMode, TabOrigin origin);
#if PROFILE_MOBILE
virtual void orientationChanged() override;
void confirmationResult(WebConfirmationPtr);
- /**
- * @brief Get the state of private mode
- *
- * @return state of private mode
- */
- bool isPrivateMode() {return m_private;}
-
std::shared_ptr<tizen_browser::tools::BrowserImage> captureSnapshot(int width, int height, bool async,
tizen_browser::tools::SnapshotType snapshot_type);
/**
actionButton.eAction = eAction;
Evas_Object* button = elm_button_add(m_layout);
- edje_color_class_set("elm/widget/button/default/bg-default", 240, 240, 240, 255,
- 255, 255, 255, 255,
- 255, 255, 255, 255);
-
- edje_color_class_set("elm/widget/button/default/bg-disabled", 240, 240, 240, 255,
- 255, 255, 255, 255,
- 255, 255, 255, 255);
-
- Evas_Object* m_box = elm_box_add(button);
- evas_object_size_hint_weight_set(m_box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- evas_object_size_hint_align_set(m_box, EVAS_HINT_FILL, EVAS_HINT_FILL);
- elm_box_homogeneous_set(m_box, EINA_FALSE);
+ Evas_Object* box = elm_box_add(button);
+ evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
+ elm_box_homogeneous_set(box, EINA_FALSE);
// Set a source file to fetch pixel data
- Evas_Object *img = elm_image_add(m_box);
- elm_image_file_set(img, m_edjFilePath.c_str(), action->getIcon().c_str());
+ Evas_Object *img = elm_layout_add(box);
+ elm_layout_file_set(img, m_edjFilePath.c_str(), action->getIcon().c_str());
evas_object_size_hint_min_set(img, 0, BUTTON_WITH_ICON_HEIGHT);
- elm_box_pack_end(m_box, img);
+ elm_box_pack_end(box, img);
evas_object_show(img);
+ m_imgMap[buttonName] = img;
- Evas_Object *label = elm_label_add(m_box);
+ Evas_Object *label = elm_label_add(box);
elm_object_text_set(label, action->getText().c_str());
- elm_box_pack_end(m_box, label);
+ elm_box_pack_end(box, label);
evas_object_show(label);
- evas_object_show(m_box);
- elm_object_part_content_set(button, "elm.swallow.content", m_box);
+ evas_object_show(box);
+ elm_object_part_content_set(button, "elm.swallow.content", box);
elm_object_disabled_set(button, action->isEnabled() ? EINA_FALSE : EINA_TRUE);
evas_object_smart_callback_add(button, "clicked", EAction::callbackFunction, eAction.get());
Evas_Object* button = m_buttonsMap[buttonName].button;
std::shared_ptr<EAction> eAction = std::make_shared<EAction>(newAction);
- elm_object_style_set(button, newAction->getIcon().c_str());
-
evas_object_smart_callback_del(button, "clicked", EAction::callbackFunction);
evas_object_smart_callback_add(button, "clicked", EAction::callbackFunction, eAction.get());
elm_object_disabled_set(getContent(), disabled ? EINA_TRUE : EINA_FALSE);
}
+void ButtonBar::setButtonsColor(bool secretMode)
+{
+ for (const auto& it : m_buttonsMap) {
+ if (secretMode) {
+ //TODO works, state is changed but get gray scale only, why?
+ //elm_object_signal_emit(m_imgMap[it.first], "set_secret_mode", "ui");
+ evas_object_color_set(it.second.button, 97, 97, 97, 255);
+ } else {
+ evas_object_color_set(it.second.button, 240, 240, 240, 255);
+ elm_object_signal_emit(m_imgMap[it.first], "set_normal_mode", "ui");
+ }
+ }
+
+}
+
}
}
Evas_Object* getButton(const std::string& buttonName);
void clearFocus();
void setDisabled(bool disabled);
+ void setButtonsColor(bool secretMode);
private:
std::string m_edjFilePath;
std::map<std::string, sharedAction> m_actionsMap;
//map button name to struct ActionButton which contains Evas_Object of button
std::map<std::string, ActionButton> m_buttonsMap;
+ std::map<std::string, Evas_Object*> m_imgMap;
Evas_Object* m_layout;
void refreshButton(const std::string& buttonName);
void onEnabledChanged(const std::string& buttonName, sharedAction action);
void WebPageUI::showUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+
+ auto state = getEngineState();
+ if (state) {
+ switch (*state) {
+ case basic_webengine::State::NORMAL:
+ elm_object_signal_emit(m_mainLayout, "set_normal_mode", "ui");
+ break;
+ case basic_webengine::State::SECRET:
+ elm_object_signal_emit(m_mainLayout, "set_secret_mode", "ui");
+ break;
+ default:
+ BROWSER_LOGE("[%s:%d] Unknown state!", __PRETTY_FUNCTION__, __LINE__);
+ }
+ m_bottomButtonBar->setButtonsColor(*state == basic_webengine::State::SECRET);
+ m_rightButtonBar->setButtonsColor(*state == basic_webengine::State::SECRET);
+ } else {
+ BROWSER_LOGE("[%s:%d] Wrong state value!", __PRETTY_FUNCTION__, __LINE__);
+ }
+
M_ASSERT(m_mainLayout);
evas_object_show(m_mainLayout);
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_parent);
+
+ // set white base background for button
+ edje_color_class_set("elm/widget/button/default/bg-default", 255, 255, 255, 255,
+ 255, 255, 255, 255,
+ 255, 255, 255, 255);
+ edje_color_class_set("elm/widget/button/default/bg-disabled", 255, 255, 255, 255,
+ 255, 255, 255, 255,
+ 255, 255, 255, 255);
+
// create web layout
m_mainLayout = elm_layout_add(m_parent);
evas_object_size_hint_weight_set(m_mainLayout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
#include "service_macros.h"
#include "ButtonBar.h"
#include "URIEntry.h"
+#include "AbstractWebEngine/State.h"
namespace tizen_browser {
namespace base_ui {
boost::signals2::signal<void ()> switchToDesktopMode;
boost::signals2::signal<std::string ()> requestCurrentPageForWebPageUI;
+ boost::signals2::signal<basic_webengine::State ()> getEngineState;
private:
static void faviconClicked(void* data, Evas_Object* obj, const char* emission, const char* source);
name: NAME; \
images.image: IMG COMP; \
parts { \
- part { \
+ image { \
name: "image"; \
- type: IMAGE; \
mouse_events: 1; \
repeat_events: 0; \
description { \
image.normal: IMG; \
color: 105 105 105 255; \
} \
+ description { \
+ state: "secret" 0.0; \
+ inherit: "default" 0.0; \
+ color: 250 250 250 255; \
+ } \
+ } \
+ } \
+ programs { \
+ program { \
+ name: "set_normal_mode"; \
+ signal: "set_normal_mode"; \
+ source: "ui"; \
+ action: STATE_SET "default" 0.0; \
+ target: "image"; \
+ } \
+ program { \
+ name: "set_secret_mode"; \
+ signal: "set_secret_mode"; \
+ source: "ui"; \
+ action: STATE_SET "secret" 0.0; \
+ target: "image"; \
} \
} \
}
#define FINDONPAGE_WIDTH 720
#define SPACER_SIZE 16
#include "../../../core/Tools/edc/Spacer.edc"
+#include "../../../core/Tools/edc/ColorClasses.edc"
#define PROGRESS_DESCRIPTIONS\
PROGRESS_DESCRIPTION(0.00)\
image: PROGRESS_BG_IMAGE COMP;
image: PROGRESS_BAR_IMAGE COMP;
}
+ color_classes{
+ color_class{
+ name: "defaultBg";
+ color: 240 240 240 255;
+ }
+ }
parts {
part {
name: "bg";
scale: 1;
description {
state: "default" 0.0;
- visible: 1;
+ visible: 0;
fixed: 0 1;
align: 0 0;
min: 0 URI_BG_HEIGHT;
max: -1 URI_BG_HEIGHT;
- color: 240 240 240 255;
rel1 {relative: 0.0 0.0; to:"bg";}
rel2 {relative: 1.0 1.0; to:"bg";}
}
rel1 {relative: 0.0 -URI_BG_HEIGHT/668; to:"bg";}
}
}
+
+ rect {
+ name: "uri_bar_bg_color";
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ visible: 1;
+ align: 0 0;
+ color_class: "defaultBg";
+ rel1 {relative: 0.0 0.0; to:"uri_bar_bg";}
+ rel2 {relative: 1.0 1.0; to:"uri_bar_bg";}
+ }
+ description {
+ state: "secret" 0.0;
+ inherit: "default" 0.0;
+ color_class: "secret";
+ }
+ }
ADD_SPACER_OVER("left_spacer", "uri_bar_bg", SPACER_SIZE, SPACER_SIZE)
part {
scale: 1;
description {
state: "default" 0.0;
- visible: 1;
+ visible: 0;
align: 0.0 1.0;
min: 0 0;
max: -1 BOTTOM_TOOLBAR_HEIGHT;
- color: 240 240 240 255;
+ color_class: "defaultBg";
rel1 { relative: 0.0 0.0; to: "bg"; }
rel2 { relative: 1.0 1.0; to: "bg"; }
}
rel1 {relative: 0.0 1.0; to:"bg";}
}
}
+ rect {
+ name: "bottom_toolbar_bg_color";
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ visible: 1;
+ align: 0.0 0.0;
+ color_class: "defaultBg";
+ rel1 { relative: 0.0 0.0; to: "bottom_toolbar"; }
+ rel2 { relative: 1.0 1.0; to: "bottom_toolbar"; }
+ }
+ description {
+ state: "secret" 0.0;
+ inherit: "default" 0.0;
+ color_class: "secret";
+ }
+ }
part {
name: "bottom_swallow";
type: SWALLOW;
action: STATE_SET "visible" 0.0;
target: "findonpage";
}
+ program {
+ name: "set_normal_mode";
+ signal: "set_normal_mode";
+ source: "ui";
+ action: STATE_SET "default" 0.0;
+ target: "uri_bar_bg_color";
+ target: "bottom_toolbar_bg_color";
+ }
+ program {
+ name: "set_secret_mode";
+ signal: "set_secret_mode";
+ source: "ui";
+ action: STATE_SET "secret" 0.0;
+ target: "uri_bar_bg_color";
+ target: "bottom_toolbar_bg_color";
+ }
}
}
}
tizen_browser::basic_webengine::TabId parentTabId = webEngineService->addTab("www.test.com");
- BOOST_CHECK(!(webEngineService->isPrivateMode()));
+ BOOST_CHECK(!(webEngineService->isSecretMode()));
webEngineService->setPrivateMode(true);
- BOOST_CHECK(webEngineService->isPrivateMode());
+ BOOST_CHECK(webEngineService->isSecretMode());
webEngineService->setPrivateMode(false);
- BOOST_CHECK(!(webEngineService->isPrivateMode()));
+ BOOST_CHECK(!(webEngineService->isSecretMode()));
BOOST_TEST_MESSAGE(TAG "Print closeTab():" << webEngineService->closeTab());
projects / profile / common / apps / web / browser.git / commitdiff