/**
* Adds new tab
* @param uri if not empty opens specified uri
+ * @param desktopMode true if desktop mode, false if mobile mode
* @return TabId of created tab
*/
- virtual TabId addTab(const std::string & uri = std::string(), const TabId * openerId = NULL) = 0;
+ virtual TabId addTab(const std::string & uri = std::string(), const TabId * openerId = NULL, bool desktopMode = true) = 0;
/**
* @param tab id
virtual void backButtonClicked() const = 0;
/**
- * @brief Switch view to mobile
+ * @brief Switch current view to mobile mode
*/
- virtual void switchToMobileView() = 0;
+ virtual void switchToMobileMode() = 0;
/**
- * @brief Switch view to desktop
+ * @brief Switch current view to desktop mode
*/
- virtual void switchToDesktopView() = 0;
+ virtual void switchToDesktopMode() = 0;
+
+ /**
+ * @brief Check if desktop mode is enabled for current view
+ *
+ * @return true if desktop mode is enabled
+ */
+ virtual bool isDesktopMode() const = 0;
/**
* FavIcon of current page changed
evas_object_show(m_layout);
}
-
void DetailPopup::show(Evas_Object *parent, std::shared_ptr<services::HistoryItem> currItem, std::shared_ptr<services::HistoryItemVector> prevItems)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
void DetailPopup::hide()
{
+ edje_object_signal_callback_del(elm_layout_edje_get(m_layout), "mouse,clicked,1", "bg", _bg_click);
+ edje_object_signal_callback_del(elm_layout_edje_get(m_layout), "mouse,clicked,1", "url_over", _url_click);
+ edje_object_signal_callback_del(elm_layout_edje_get(m_layout), "mouse,clicked,1", "thumbnail", _url_click);
+ elm_genlist_clear(m_historyList);
evas_object_hide(m_layout);
}
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
DetailPopup *dp = reinterpret_cast<DetailPopup*>(data);
dp->hide();
- dp->m_mainUI->openURLInNewTab(dp->m_item);
+ dp->openURLInNewTab(dp->m_item, dp->m_mainUI->isDesktopMode());
}
char* DetailPopup::_get_history_link_text(void* data, Evas_Object* obj, const char* part)
*/
void show(Evas_Object *parent, std::shared_ptr<services::HistoryItem> currItem, std::shared_ptr<services::HistoryItemVector> prevItems);
- boost::signals2::signal<void (std::shared_ptr<services::HistoryItem>)> openURLInNewTab;
+ boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::HistoryItem>, bool)> openURLInNewTab;
static const int HISTORY_ITEMS_NO;
private:
Evas_Object* MainUI::createQuickAccessLayout(Evas_Object* parent)
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
+ m_desktopMode = true;
Evas_Object* layout = elm_layout_add(parent);
evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
return nullptr;
}
-
-void MainUI::_itemSelected(void * data, Evas_Object * /* obj */, void * event_info)
-{
- Elm_Object_Item * selected = reinterpret_cast<Elm_Object_Item *>(event_info);
- HistoryItemData * itemData = reinterpret_cast<HistoryItemData *>(elm_object_item_data_get(selected));
- MainUI * self = reinterpret_cast<MainUI *>(data);
-
- self->openURLInNewTab(itemData->item);
-}
-
void MainUI::_thumbSelected(void * data, Evas_Object * /* obj */, void * /* event_info */)
{
HistoryItemData * itemData = reinterpret_cast<HistoryItemData *>(data);
}
}
+bool MainUI::isDesktopMode() const
+{
+ return m_desktopMode;
+}
+
+void MainUI::setDesktopMode(bool mode)
+{
+ m_desktopMode = mode;
+}
+
+DetailPopup& MainUI::getDetailPopup()
+{
+ return m_detailPopup;
+}
+
}
}
void showBookmarks();
void clearItems();
void openDetailPopup(std::shared_ptr<services::HistoryItem> currItem, std::shared_ptr<services::HistoryItemVector> prevItems);
+ bool isDesktopMode() const;
+ void setDesktopMode(bool mode);
+ DetailPopup & getDetailPopup();
void addHistoryItem(std::shared_ptr<services::HistoryItem>);
void addHistoryItems(std::shared_ptr<services::HistoryItemVector>);
void addBookmarkItem(std::shared_ptr<tizen_browser::services::BookmarkItem>);
void addBookmarkItems(std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> >);
- boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::HistoryItem>)> openURLInNewTab;
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::HistoryItem>, int)> mostVisitedTileClicked;
boost::signals2::signal<void (const std::string & )> mostVisitedClicked;
boost::signals2::signal<void (const std::string & )> bookmarkClicked;
static const int MAX_TILE_WIDTH;
static const int MAX_TILE_HEIGHT;
-private:
+private:
void createItemClasses();
Evas_Object* createQuickAccessLayout(Evas_Object *parent);
static void _thumbSelected(void * data, Evas_Object * obj, void * event_info);
static void _deleteBookmark(void *data, Evas_Object *obj, void *event_info);
void setEmptyView(bool empty);
+ void showNoHistoryLabel();
static void _mostVisited_clicked(void * data, Evas_Object * obj, void * event_info);
static void _bookmark_clicked(void * data, Evas_Object * obj, void * event_info);
static void _bookmark_manager_clicked(void * data, Evas_Object * obj, void * event_info);
-private:
+
Evas_Object *m_parent;
Evas_Object *m_layout;
Evas_Object *m_bookmarksView;
std::map<std::string,Elm_Object_Item*> m_map_bookmark_views;
bool m_gengridSetup;
std::string edjFilePath;
- void showNoHistoryLabel();
+ bool m_desktopMode;
};
}
: m_gengrid(NULL)
, m_parent(NULL)
, m_item_class(NULL)
- , m_desktopView(true)
+ , m_desktopMode(true)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_edjFilePath = EDJE_DIR;
{
}
-void MoreMenuUI::show(Evas_Object* parent)
+void MoreMenuUI::show(Evas_Object* parent, bool desktopMode)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_parent = parent;
+ m_desktopMode = desktopMode;
elm_theme_extension_add(NULL, m_edjFilePath.c_str());
m_mm_layout = elm_layout_add(parent);
elm_layout_file_set(m_mm_layout, m_edjFilePath.c_str(), "moremenu-layout");
for (int i = 0; i <= EXIT_BROWSER; i++) {
ItemType type = static_cast<ItemType>(i);
// take proper image for desktop/mobile view
- if (type == ItemType::VIEW_DESKTOP_WEB && m_desktopView)
+ if (type == ItemType::VIEW_DESKTOP_WEB && m_desktopMode)
continue;
- if (type == ItemType::VIEW_MOBILE_WEB && !m_desktopView)
+ if (type == ItemType::VIEW_MOBILE_WEB && !m_desktopMode)
continue;
MoreMenuItemData *itemData = new MoreMenuItemData();
case FOCUS_MODE:
break;
case VIEW_MOBILE_WEB:
- itemData->moreMenuUI->switchToMobileView();
- itemData->moreMenuUI->m_desktopView = false;
- itemData->moreMenuUI->refreshGengrid();
+ itemData->moreMenuUI->switchToMobileMode();
+ itemData->moreMenuUI->m_desktopMode = false;
+ itemData->moreMenuUI->closeMoreMenuClicked(std::string());
+ itemData->moreMenuUI->clearItems();
break;
case VIEW_DESKTOP_WEB:
- itemData->moreMenuUI->switchToDesktopView();
- itemData->moreMenuUI->m_desktopView = true;
- itemData->moreMenuUI->refreshGengrid();
+ itemData->moreMenuUI->switchToDesktopMode();
+ itemData->moreMenuUI->m_desktopMode = true;
+ itemData->moreMenuUI->closeMoreMenuClicked(std::string());
+ itemData->moreMenuUI->clearItems();
break;
case SHARE:
break;
elm_cache_all_flush();
}
-void MoreMenuUI::refreshGengrid()
-{
- elm_gengrid_clear(m_gengrid);
- m_map_menu_views.clear();
- addItems();
-}
-
void MoreMenuUI::_exitClicked()
{
BROWSER_LOGD("[%s:%d]", __PRETTY_FUNCTION__, __LINE__);
public:
MoreMenuUI();
~MoreMenuUI();
- void show(Evas_Object *main_layout);
+ void show(Evas_Object *main_layout, bool desktopMode);
void showCurrentTab();
virtual std::string getName();
void addItems();
boost::signals2::signal<void (std::string)> historyUIClicked;
boost::signals2::signal<void (const std::string&)> settingsClicked;
boost::signals2::signal<void (std::string)> closeMoreMenuClicked;
- boost::signals2::signal<void ()> switchToMobileView;
- boost::signals2::signal<void ()> switchToDesktopView;
+ boost::signals2::signal<void ()> switchToMobileMode;
+ boost::signals2::signal<void ()> switchToDesktopMode;
private:
static char* _grid_text_get(void *data, Evas_Object *obj, const char *part);
static Evas_Object * _grid_content_get(void *data, Evas_Object *obj, const char *part);
void AddBookmarkPopupCalled();
void addToBookmarks(int folder_id);
- void refreshGengrid();
-
static void _star_clicked(void *data, Evas_Object *obj, void *event_info);
static void _close_clicked(void *data, Evas_Object *obj, void *event_info);
std::string m_folderName;
bool m_gengridSetup;
Evas_Object *m_icon;
- bool m_desktopView;
+ bool m_desktopMode;
};
}
#include "boost/date_time/posix_time/posix_time.hpp"
#include "NetworkErrorHandler.h"
#include "SqlStorage.h"
+#include "DetailPopup.h"
namespace tizen_browser{
M_ASSERT(m_mainUI.get());
m_historyService->historyAllDeleted.connect(boost::bind(&tizen_browser::base_ui::MainUI::clearHistoryGenlist, m_mainUI.get()));
- m_mainUI->openURLInNewTab.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this,_1));
+ m_mainUI->getDetailPopup().openURLInNewTab.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, _2));
m_mainUI->mostVisitedTileClicked.connect(boost::bind(&SimpleUI::onMostVisitedTileClicked, this, _1, _2));
m_mainUI->mostVisitedClicked.connect(boost::bind(&SimpleUI::onMostVisitedClicked, this,_1));
m_mainUI->bookmarkClicked.connect(boost::bind(&SimpleUI::onBookmarkButtonClicked, this,_1));
bool SimpleUI::isHomePageActive()
{
- BROWSER_LOGD("[%s:%d] isHomePageActive : %d", __PRETTY_FUNCTION__, __LINE__, m_isHomePageActive);
return m_isHomePageActive;
}
}
}
-void SimpleUI::openNewTab(const std::string &uri)
+void SimpleUI::openNewTab(const std::string &uri, bool desktopMode)
{
- switchToTab(m_webEngine->addTab(uri));
+ switchToTab(m_webEngine->addTab(uri, nullptr, desktopMode));
}
void SimpleUI::closeTab(){
#endif
}
-void SimpleUI::onOpenURLInNewTab(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem)
+void SimpleUI::onOpenURLInNewTab(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem, bool desktopMode)
{
+ BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
std::string historyAddress = historyItem->getUrl();
if(m_historyUI) { // TODO: remove this section when naviframes will be available
m_historyUI->clearItems();
m_moreMenuUI->clearItems();
m_moreMenuUI = nullptr;
}
- openNewTab(historyAddress);
+ openNewTab(historyAddress, desktopMode);
}
void SimpleUI::onMostVisitedTileClicked(std::shared_ptr< services::HistoryItem > historyItem, int itemsNumber)
M_ASSERT(m_historyUI);
m_historyUI->clearHistoryClicked.connect(boost::bind(&SimpleUI::onClearHistoryClicked, this,_1));
m_historyUI->closeHistoryUIClicked.connect(boost::bind(&SimpleUI::closeHistoryUI, this,_1));
- m_historyUI->historyItemClicked.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this,_1));
+ m_historyUI->historyItemClicked.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, true)); // desktop mode as default
m_historyUI->addHistoryItems(getHistory());
m_historyUI->show(m_window.get());
}
void SimpleUI::showMoreMenu()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- bool current_tab_as_new_tab = isHomePageActive() || (m_historyService->getHistoryItemsCount() == 0);
+ bool desktopMode = isHomePageActive() ? m_mainUI->isDesktopMode() : m_webEngine->isDesktopMode();
if(!m_moreMenuUI){
m_moreMenuUI =
std::dynamic_pointer_cast
m_moreMenuUI->historyUIClicked.connect(boost::bind(&SimpleUI::showHistoryUI, this,_1));
m_moreMenuUI->settingsClicked.connect(boost::bind(&SimpleUI::showSettingsUI, this,_1));
m_moreMenuUI->closeMoreMenuClicked.connect(boost::bind(&SimpleUI::closeMoreMenu, this,_1));
- m_moreMenuUI->switchToMobileView.connect(boost::bind(&SimpleUI::switchToMobileView, this));
- m_moreMenuUI->switchToDesktopView.connect(boost::bind(&SimpleUI::switchToDesktopView, this));
+ m_moreMenuUI->switchToMobileMode.connect(boost::bind(&SimpleUI::switchToMobileMode, this));
+ m_moreMenuUI->switchToDesktopMode.connect(boost::bind(&SimpleUI::switchToDesktopMode, this));
m_moreMenuUI->addToBookmarkClicked.connect(boost::bind(&SimpleUI::addBookmarkFolders, this));
m_moreMenuUI->AddBookmarkInput.connect(boost::bind(&SimpleUI::addToBookmarks, this,_1));
m_moreMenuUI->BookmarkFolderCreated.connect(boost::bind(&SimpleUI::newFolderMoreMenu, this,_1,_2));
- m_moreMenuUI->show(m_window.get());
+ m_moreMenuUI->show(m_window.get(), desktopMode);
m_moreMenuUI->showCurrentTab();
m_moreMenuUI->setFavIcon(m_webEngine->getFavicon());
m_moreMenuUI->setWebTitle(m_webEngine->getTitle());
m_moreMenuUI.reset();
}
-void SimpleUI::switchToMobileView()
+void SimpleUI::switchToMobileMode()
{
- m_webEngine->switchToMobileView();
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ if (!isHomePageActive()) {
+ m_webEngine->switchToMobileMode();
+ m_webEngine->reload();
+ } else {
+ m_mainUI->setDesktopMode(false);
+ }
}
-void SimpleUI::switchToDesktopView() {
- m_webEngine->switchToDesktopView();
+void SimpleUI::switchToDesktopMode()
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ if (!isHomePageActive()) {
+ m_webEngine->switchToDesktopMode();
+ m_webEngine->reload();
+ } else {
+ m_mainUI->setDesktopMode(true);
+ }
}
void SimpleUI::showBookmarkManagerMenu()
void updateURIBarView();
void updateView();
- void openNewTab(const std::string &uri);
+ void openNewTab(const std::string &uri, bool desktopMode = true);
void switchToTab(const tizen_browser::basic_webengine::TabId& tabId);
void newTabClicked(const std::string &);
void tabClicked(const tizen_browser::basic_webengine::TabId& tabId);
void onHistoryAdded(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem);
void onHistoryRemoved(const std::string& uri);
- void onOpenURLInNewTab(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem);
+ void onOpenURLInNewTab(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem, bool desktopMode);
void onMostVisitedTileClicked(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem, int itemsNumber);
void onClearHistoryClicked(const std::string&);
void closeTabUI(const std::string& str);
void showMoreMenu();
void closeMoreMenu(const std::string& str);
- void switchToMobileView();
- void switchToDesktopView();
+ void switchToMobileMode();
+ void switchToDesktopMode();
void showHistoryUI(const std::string& str);
void closeHistoryUI(const std::string&);
void showMainUI();
, m_privateMode(false)
, m_guiParent(nullptr)
, m_currentTabId(TabId::NONE)
- , m_desktopView(true)
{
m_mostRecentTab.clear();
m_tabs.clear();
return result;
}
-TabId WebKitEngineService::addTab(const std::string & uri, const TabId * openerId)
+TabId WebKitEngineService::addTab(const std::string & uri, const TabId * openerId, bool desktopMode)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
TabId newTabId;
WebViewPtr p = std::make_shared<WebView>(reinterpret_cast<Evas_Object *>(m_guiParent), newTabId);
if (openerId)
- p->init(m_desktopView, getTabView(*openerId));
+ p->init(desktopMode, getTabView(*openerId));
else
- p->init(m_desktopView);
+ p->init(desktopMode);
m_tabs[newTabId] = p;
}
}
-void WebKitEngineService::switchToDesktopView()
+void WebKitEngineService::switchToDesktopMode()
{
- m_desktopView = true;
- for (auto it = m_tabs.begin(); it != m_tabs.end(); ++it) {
- it->second->switchToDesktopView();
- }
+ M_ASSERT(m_currentWebView);
+ m_currentWebView->switchToDesktopMode();
}
-void WebKitEngineService::switchToMobileView()
+void WebKitEngineService::switchToMobileMode()
{
- m_desktopView = false;
- for (auto it = m_tabs.begin(); it != m_tabs.end(); ++it) {
- it->second->switchToMobileView();
- }
+ M_ASSERT(m_currentWebView);
+ m_currentWebView->switchToMobileMode();
+}
+
+bool WebKitEngineService::isDesktopMode() const
+{
+ M_ASSERT(m_currentWebView);
+ return m_currentWebView->isDesktopMode();
}
} /* end of webkitengine_service */
* @param uri
* @return TabId of created tab
*/
- TabId addTab(const std::string & uri = std::string(), const TabId * openerId = NULL);
+ TabId addTab(const std::string & uri = std::string(), const TabId * openerId = NULL, bool desktopMode = true);
Evas_Object* getTabView(TabId id);
bool switchToTab(TabId);
bool closeTab();
*/
void backButtonClicked() const;
- void switchToMobileView();
- void switchToDesktopView();
+ void switchToMobileMode();
+ void switchToDesktopMode();
+ bool isDesktopMode() const;
private:
// callbacks from WebView
std::list<TabId> m_mostRecentTab;
// recently added tabs first
std::list<TabId> m_chronoTabs;
- // true if desktop view is enabled, false if mobile
- bool m_desktopView;
};
} /* end of webkitengine_service */
ewk_context_delete(m_ewkContext);
}
-void WebView::init(bool desktopView, Evas_Object * opener)
+void WebView::init(bool desktopMode, Evas_Object * opener)
{
#if defined(USE_EWEBKIT)
m_ewkView = ewk_view_add_with_context(evas_object_evas_get(m_parent), m_ewkContext);
evas_object_color_set(m_ewkView, 255, 255, 255, 255);
evas_object_size_hint_weight_set(m_ewkView, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(m_ewkView, EVAS_HINT_FILL, EVAS_HINT_FILL);
- if (desktopView)
- switchToDesktopView();
- else
- switchToMobileView();
+ if (desktopMode) {
+ switchToDesktopMode();
+ } else {
+ switchToMobileMode();
+ }
//\todo: when value is other than 1.0, scroller is located improperly
// ewk_view_device_pixel_ratio_set(m_ewkView, 1.0f);
BROWSER_LOGD("Ewk search; word: %s, result: %d", searchString.c_str(), result);
}
-void WebView::switchToDesktopView() {
+void WebView::switchToDesktopMode() {
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
int res = ewk_view_user_agent_set(m_ewkView, APPLICATION_NAME_FOR_USER_AGENT);
+ m_desktopMode = true;
}
-void WebView::switchToMobileView() {
+void WebView::switchToMobileMode() {
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
int res = ewk_view_user_agent_set(m_ewkView, APPLICATION_NAME_FOR_USER_AGENT_MOBILE);
+ m_desktopMode = false;
+}
+
+bool WebView::isDesktopMode() const {
+ return m_desktopMode;
}
} /* namespace webkitengine_service */
public:
WebView(Evas_Object *, TabId);
virtual ~WebView();
- void init(bool desktopView = true, Evas_Object * opener = NULL);
+ void init(bool desktopMode, Evas_Object * opener = NULL);
void setURI(const std::string &);
/**
* @brief Change user agent to desktop type
*/
- void switchToDesktopView();
+ void switchToDesktopMode();
/**
* @brief Change user agent to mobile type
*/
- void switchToMobileView();
+ void switchToMobileMode();
+
+ /**
+ * @brief Check if desktop mode is enabled
+ *
+ * @return true if desktop mode is enabled
+ */
+ bool isDesktopMode() const;
/**
* @brief Get favicon of URL
bool m_isLoading;
double m_loadProgress;
bool m_loadError;
-
-
+ // true if desktop view is enabled, false if mobile
+ bool m_desktopMode;
config::DefaultConfig config;