Continuation of patch proposed by Marcin Łapiński.
[Issue] https://bugs.tizen.org/jira/browse/TT-157
[Problem] There was no proper views management
[Cause] N/A
[Solution] New class ViewManager for controling switching
between views.
[Verify] Launch browser > switch between different
views (page view, more menu, settings, etc.),
check if switching is correct check if there
are no relevant warnings in logs.
Change-Id: I8827964b6539ecb7a4c02edd3d296b72a149a9e7
Signed-off-by: Maciej Skrzypkowski <m.skrzypkows@samsung.com>
m_bookmark_item_class->func.del = nullptr;
}
-void BookmarkManagerUI::show(Evas_Object* parent)
-{
- init(parent);
- b_mm_layout=createBookmarksLayout(m_parent);
- showUI();
-}
-
void BookmarkManagerUI::init(Evas_Object* parent)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
void BookmarkManagerUI::showUI()
{
evas_object_show(b_mm_layout);
- //regenerate gengrid and genlist
- createGenGrid();
- showTopContent();
}
void BookmarkManagerUI::hideUI()
{
- evas_object_hide(b_mm_layout);
- evas_object_del(m_gengrid);
- m_gengrid=nullptr;
- evas_object_del(m_genList);
- m_genList=nullptr;
+ evas_object_hide(b_mm_layout);
+ elm_gengrid_clear(m_gengrid);
+ m_map_bookmark.clear();
}
Evas_Object* BookmarkManagerUI::getContent()
evas_object_show(b_mm_layout);
createGenGrid();
+ showTopContent();
return b_mm_layout;
}
// (After fixing window managment)
void BookmarkManagerUI::createGenGrid()
{
- //TODO: After fixing window managment remove this.
- if(m_gengrid != nullptr)
- evas_object_del(m_gengrid);
-
m_gengrid = elm_gengrid_add(b_mm_layout);
elm_object_part_content_set(b_mm_layout, "elm.swallow.grid", m_gengrid);
elm_object_style_set(m_gengrid, "back_ground");
elm_gengrid_item_size_set(m_gengrid, 404 * efl_scale, 320 * efl_scale);
}
-//TODO: Remove externall calls and make it private method.
-// Make parend the argument and return created object
-// to make code more modular.(After fixing window managment)
void BookmarkManagerUI::showTopContent()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
return nullptr;
}
-void BookmarkManagerUI::item_clicked_cb(void*, Evas_Object*, void*)
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
-}
-
void BookmarkManagerUI::close_clicked_cb(void* data, Evas_Object*, void*)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data != nullptr)
{
ItemData * id = static_cast<ItemData *>(data);
- id->m_bookmarkManager->closeBookmarkManagerClicked(std::string());
- id->m_bookmarkManager->clearItems();
+ id->m_bookmarkManager->closeBookmarkManagerClicked();
}
}
return strdup("Bookmark");
}
-void BookmarkManagerUI::hide()
-{
- evas_object_hide(elm_layout_content_get(b_mm_layout, "elm.swallow.grid"));
- evas_object_hide(elm_layout_content_get(b_mm_layout, "elm.swallow.genlist"));
- evas_object_hide(b_mm_layout);
-}
-
Evas_Object * BookmarkManagerUI::getGenList()
{
return m_genList;
}
}
-void BookmarkManagerUI::clearItems()
-{
- hide();
- BROWSER_LOGD("Deleting all items from gengrid");
- elm_gengrid_clear(m_gengrid);
- elm_genlist_clear(m_genList);
- m_map_bookmark.clear();
- elm_theme_extension_del(nullptr, edjFilePath.c_str());
- elm_theme_full_flush();
- elm_cache_all_flush();
-}
-
-void BookmarkManagerUI::updateGengrid()
-{
- elm_genlist_clear(m_genList);
- //elm_gengrid_clear(m_gengrid);
- //remove 'createGenGrid' if the elm_gengrid_clear() will be valid again
- createGenGrid();
- m_map_bookmark.clear();
-}
}
}
void hideUI();
Evas_Object *getContent();
- // TODO: remove this (After fixing window managment)
- void show(Evas_Object *main_layout);
-
- //TODO: make it private;
- void showTopContent();
virtual std::string getName();
void addBookmarkItem(std::shared_ptr<tizen_browser::services::BookmarkItem>);
void addBookmarkItems(std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> >);
void hide();
void clearItems();
- void updateGengrid();
Evas_Object* createNoHistoryLabel();
void setEmptyGengrid(bool setEmpty);
- boost::signals2::signal<void (std::string)> closeBookmarkManagerClicked;
+ boost::signals2::signal<void ()> closeBookmarkManagerClicked;
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::BookmarkItem>)> bookmarkItemClicked;
private:
Evas_Object* createBookmarksLayout(Evas_Object* parent);
void createGenGrid();
+ void showTopContent();
void createGengridItemClasses();
Evas_Object *getGenList();
Evas_Object *getGenGrid();
static Evas_Object* listItemContentGet(void *data, Evas_Object *obj, const char *part);
static char* listItemTextGet(void *data, Evas_Object *, const char *part);
- static void item_clicked_cb(void *, Evas_Object *, void *);
static void close_clicked_cb(void *data, Evas_Object *, void *);
private:
min: 1920 795;
max: 1920 795;
align: 0.0 0.0;
- fixed: 0 0;
+ fixed: 1 1;
rel1 { relative: 0.0 0.0; to: "gengrid_bg"; offset: 63 0;}
rel2 { relative: 1.0 1.0; to: "gengrid_bg";}
}
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_history_layout);
- m_gengrid = createGengrid(m_history_layout);
- addItems();
evas_object_show(m_actionBar);
evas_object_show(m_history_layout);
+ elm_object_focus_custom_chain_append(m_history_layout, m_genListToday, nullptr);
elm_object_focus_set(elm_object_part_content_get(m_actionBar, "close_click"), EINA_TRUE);
}
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_history_layout);
- evas_object_del(m_genListToday);
- m_genListToday = nullptr;
- evas_object_del(m_gengrid);
- m_gengrid = nullptr;
evas_object_hide(m_actionBar);
evas_object_hide(m_history_layout);
elm_object_focus_custom_chain_unset(m_history_layout);
+ clearItems();
}
-// TODO: Remove this function when proper view handling will be introduced
-void HistoryUI::show(Evas_Object* parent)
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- init(parent);
- m_history_layout = createHistoryUILayout(m_parent);
- showUI();
-}
void HistoryUI::init(Evas_Object* parent)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_parent);
if (!m_history_layout)
- m_history_layout = createHistoryUILayout(m_parent);
+ createHistoryUILayout(m_parent);
return m_history_layout;
}
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
elm_theme_extension_add(nullptr, m_edjFilePath.c_str());
- Evas_Object* history_layout = elm_layout_add(parent);
- elm_layout_file_set(history_layout, m_edjFilePath.c_str(), "history-layout");
- evas_object_size_hint_weight_set(history_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- evas_object_size_hint_align_set(history_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
-
- m_actionBar = createActionBar(history_layout);
- m_gengrid = createGengrid(history_layout);
+ m_history_layout = elm_layout_add(parent);
+ elm_layout_file_set(m_history_layout, m_edjFilePath.c_str(), "history-layout");
+ evas_object_size_hint_weight_set(m_history_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(m_history_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
- return history_layout;
+ m_actionBar = createActionBar(m_history_layout);
+ m_gengrid = createGengrid(m_history_layout);
+ clearItems();
}
Evas_Object* HistoryUI::createGengrid(Evas_Object* history_layout)
double efl_scale = elm_config_scale_get() / elm_app_base_scale_get();
elm_gengrid_item_size_set(gengrid, 580 * efl_scale, 580 * efl_scale);
+
+ HistoryItemData *itemData = new HistoryItemData();
+ itemData->historyUI = std::shared_ptr<tizen_browser::base_ui::HistoryUI>(this);
+ Elm_Object_Item* historyView = elm_gengrid_item_append(gengrid, m_item_class, itemData, nullptr, this);
+ elm_gengrid_item_selected_set(historyView, EINA_FALSE);
+
+ // create genlist for today entries
+ m_genListToday = elm_genlist_add(m_history_layout);
+ elm_genlist_homogeneous_set(m_genListToday, EINA_FALSE);
+ elm_genlist_multi_select_set(m_genListToday, EINA_FALSE);
+ elm_genlist_select_mode_set(m_genListToday, ELM_OBJECT_SELECT_MODE_ALWAYS);
+ elm_genlist_mode_set(m_genListToday, ELM_LIST_LIMIT);
+ elm_genlist_decorate_mode_set(m_genListToday, EINA_TRUE);
+ evas_object_size_hint_weight_set(m_genListToday, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ m_itemClassToday = elm_genlist_item_class_new();
+ m_itemClassToday->item_style = "history_url_items";
+ m_itemClassToday->func.text_get = &_listTodayTextGet;
+ m_itemClassToday->func.content_get = nullptr;
+ m_itemClassToday->func.state_get = nullptr;
+ m_itemClassToday->func.del = nullptr;
+
return gengrid;
}
if (data) {
HistoryUI *historyUI = static_cast<HistoryUI*>(data);
historyUI->closeHistoryUIClicked();
- historyUI->clearItems();
}
}
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
HistoryUI *historyUI = static_cast<HistoryUI*>(data);
- historyUI->clearHistoryClicked(std::string());
+ historyUI->clearHistoryClicked();
historyUI->clearItems();
}
-void HistoryUI::addItems()
-{
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
- for (size_t i = 0; i < 1; i++) {
- HistoryItemData *itemData = new HistoryItemData();
- itemData->historyUI = std::shared_ptr<tizen_browser::base_ui::HistoryUI>(this);
- Elm_Object_Item* historyView = elm_gengrid_item_append(m_gengrid, m_item_class, itemData, nullptr, this);
- elm_gengrid_item_selected_set(historyView, EINA_FALSE);
- }
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
-}
-
void HistoryUI::addHistoryItem(std::shared_ptr<services::HistoryItem> hi)
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
itemData->item = hi;
itemData->historyUI = std::shared_ptr<tizen_browser::base_ui::HistoryUI>(this);
_history_item_data.push_back(itemData);
+ Elm_Object_Item* historyView = elm_genlist_item_append(itemData->historyUI->m_genListToday, itemData->historyUI->m_itemClassToday, itemData, nullptr, ELM_GENLIST_ITEM_NONE, _history_item_clicked_cb, itemData);
+ itemData->historyUI->m_map_history_views.insert(std::pair<std::string,Elm_Object_Item*>(hi->getUrl(), historyView));
}
void HistoryUI::addHistoryItems(std::shared_ptr<services::HistoryItemVector> items)
static const int part_name_len = strlen(part_name);
if(!strncmp(part_name, part, part_name_len)) {
- id->historyUI->m_genListToday = elm_genlist_add(id->historyUI->m_history_layout);
-
- elm_genlist_homogeneous_set(id->historyUI->m_genListToday, EINA_FALSE);
- elm_genlist_multi_select_set(id->historyUI->m_genListToday, EINA_FALSE);
- elm_genlist_select_mode_set(id->historyUI->m_genListToday, ELM_OBJECT_SELECT_MODE_ALWAYS);
- elm_genlist_mode_set(id->historyUI->m_genListToday, ELM_LIST_LIMIT);
- elm_genlist_decorate_mode_set(id->historyUI->m_genListToday, EINA_TRUE);
- evas_object_size_hint_weight_set(id->historyUI->m_genListToday, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
-
- id->historyUI->m_itemClassToday = elm_genlist_item_class_new();
- id->historyUI->m_itemClassToday->item_style = "history_url_items";
- id->historyUI->m_itemClassToday->func.text_get = &_listTodayTextGet;
- id->historyUI->m_itemClassToday->func.content_get = nullptr;
- id->historyUI->m_itemClassToday->func.state_get = nullptr;
- id->historyUI->m_itemClassToday->func.del = nullptr;
-
- for(auto it = _history_item_data.begin(); it != _history_item_data.end(); it++) {
- Elm_Object_Item* historyView = elm_genlist_item_append(id->historyUI->m_genListToday, id->historyUI->m_itemClassToday, *it, nullptr, ELM_GENLIST_ITEM_NONE, _history_item_clicked_cb, (*it));
- id->historyUI->m_map_history_views.insert(std::pair<std::string,Elm_Object_Item*>((*it)->item->getUrl(), historyView));
- }
- elm_object_focus_custom_chain_append(id->historyUI->m_history_layout, id->historyUI->m_genListToday, nullptr);
-
return id->historyUI->m_genListToday;
}
}
m_map_history_views.erase(uri);
}
-void HistoryUI::hide()
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- evas_object_hide(elm_layout_content_get(m_history_layout, "action_bar_history"));
- evas_object_hide(m_history_layout);
-}
-
void HistoryUI::clearItems()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- hide();
elm_genlist_clear(m_genListToday);
- elm_gengrid_clear(m_gengrid);
m_map_history_views.clear();
_history_item_data.clear();
}
void addHistoryItem(std::shared_ptr<services::HistoryItem>);
void addHistoryItems(std::shared_ptr<services::HistoryItemVector>);
void removeHistoryItem(const std::string& uri);
- void clearItems();
- void hide();
Evas_Object* createActionBar(Evas_Object* history_layout);
- void show(Evas_Object *main_layout);
void addItems();
boost::signals2::signal<void ()> closeHistoryUIClicked;
- boost::signals2::signal<void (const std::string&)> clearHistoryClicked;
+ boost::signals2::signal<void ()> clearHistoryClicked;
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::HistoryItem>)> historyItemClicked;
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::HistoryItem>)> historyDeleteClicked;
private:
+ void clearItems();
Evas_Object* createHistoryUILayout(Evas_Object* parent);
Elm_Gengrid_Item_Class* crateItemClass();
static char* _grid_text_get(void *data, Evas_Object *obj, const char *part);
m_mostVisitedView = createMostVisitedView(layout);
m_bookmarksView = createBookmarksView (layout);
- evas_object_show(m_mostVisitedView);
- //TODO: uncoment this after cleaning up the mess in whole app window.
- //evas_object_show(m_bookmarksView);
showHistory();
return layout;
evas_object_size_hint_weight_set(bookmarkViewLayout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(bookmarkViewLayout, EVAS_HINT_FILL, EVAS_HINT_FILL);
- Evas_Object *bookmarkGengrid = elm_gengrid_add(bookmarkViewLayout);
+ m_bookmarkGengrid = createBookmarkGengrid(bookmarkViewLayout);
+ elm_object_part_content_set(bookmarkViewLayout, "elm.swallow.grid", m_bookmarkGengrid);
+
+ Evas_Object* topButtons = createTopButtons(bookmarkViewLayout);
+ elm_object_part_content_set(bookmarkViewLayout, "elm.swallow.layoutTop", topButtons);
+
+ Evas_Object* bottomButton = createBottomButton(bookmarkViewLayout);
+ elm_object_part_content_set(bookmarkViewLayout, "elm.swallow.layoutBottom", bottomButton);
+
+ return bookmarkViewLayout;
+}
+
+Evas_Object* MainUI::createBookmarkGengrid(Evas_Object *parent)
+{
+ Evas_Object *bookmarkGengrid = elm_gengrid_add(parent);
elm_gengrid_align_set(bookmarkGengrid, 0, 0);
elm_gengrid_select_mode_set(bookmarkGengrid, ELM_OBJECT_SELECT_MODE_ALWAYS);
evas_object_size_hint_weight_set(bookmarkGengrid, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(bookmarkGengrid, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_gengrid_item_size_set(bookmarkGengrid, 364 * efl_scale, 320 * efl_scale);
- evas_object_show(bookmarkGengrid);
-
- elm_object_part_content_set(bookmarkViewLayout, "elm.swallow.grid", bookmarkGengrid);
- m_bookmarkGengrid = bookmarkGengrid;
-
- Evas_Object* topButtons = createTopButtons(bookmarkViewLayout);
- elm_object_part_content_set(bookmarkViewLayout, "elm.swallow.layoutTop", topButtons);
- Evas_Object* bottomButton = createBottomButton(bookmarkViewLayout);
- elm_object_part_content_set(bookmarkViewLayout, "elm.swallow.layoutBottom", bottomButton);
-
- return bookmarkViewLayout;
+ return bookmarkGengrid;
}
Evas_Object* MainUI::createTopButtons (Evas_Object *parent)
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
MainUI* mainUI = reinterpret_cast<MainUI *>(data);
- mainUI->mostVisitedClicked(std::string());
+ mainUI->mostVisitedClicked();
}
void MainUI::_bookmark_clicked(void * data, Evas_Object *, void *)
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
MainUI* mainUI = reinterpret_cast<MainUI *>(data);
- mainUI->bookmarkClicked(std::string());
+ mainUI->bookmarkClicked();
}
void MainUI::_bookmark_manager_clicked(void * data, Evas_Object *, void *)
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
MainUI* mainUI = static_cast<MainUI *>(data);
- mainUI->bookmarkManagerClicked(std::string());
+ mainUI->bookmarkManagerClicked();
}
void MainUI::addHistoryItem(std::shared_ptr<services::HistoryItem> hi)
void MainUI::addBookmarkItems(std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > items)
{
clearBookmarkGengrid();
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
- for (auto it = items.begin(); it != items.end(); ++it) {
- addBookmarkItem(*it);
- }
+ for (auto it = items.begin(); it != items.end(); ++it) {
+ addBookmarkItem(*it);
+ }
}
if (elm_layout_content_get(m_layout, "elm.swallow.content") == m_mostVisitedView)
return;
- //TODO: remove these "evas_object_hide" and "evas_object_show" after cleaning up the mess in whole app window.
elm_layout_content_unset(m_layout, "elm.swallow.content");
evas_object_hide(m_bookmarksView);
elm_layout_content_set(m_layout, "elm.swallow.content", m_mostVisitedView);
void MainUI::clearBookmarkGengrid()
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
-
elm_gengrid_clear(m_bookmarkGengrid);
m_map_bookmark_views.clear();
}
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
- if (elm_layout_content_get(m_layout, "elm.swallow.content") == m_bookmarksView)
+ if (elm_layout_content_get(m_layout, "elm.swallow.content") == m_bookmarksView && m_bookmarksView != nullptr)
return;
- //TODO: remove these "evas_object_hide" and "evas_object_show" after cleaning up the mess in whole app window.
elm_layout_content_unset(m_layout, "elm.swallow.content");
evas_object_hide(m_mostVisitedView);
elm_layout_content_set(m_layout, "elm.swallow.content", m_bookmarksView);
evas_object_show(m_layout);
}
-void MainUI::hide()
+void MainUI::showUI()
{
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
- evas_object_hide(m_layout);
- evas_object_hide(m_mostVisitedView);
- evas_object_hide(m_bookmarksView);
- clearItems();
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ evas_object_show(m_layout);
+ if (elm_layout_content_get(m_layout, "elm.swallow.content") == m_bookmarksView) {
+ evas_object_show(m_bookmarksView);
+ } else {
+ evas_object_show(m_mostVisitedView);
+ }
}
-void MainUI::clearItems()
+void MainUI::hideUI()
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
+ evas_object_hide(m_layout);
+ evas_object_hide(m_mostVisitedView);
+ evas_object_hide(m_bookmarksView);
clearHistoryGenlist();
clearBookmarkGengrid();
}
Evas_Object* getContent();
void showMostVisited(std::shared_ptr<services::HistoryItemVector> vec);
void showBookmarks(std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > vec);
- void hide();
+ void hideUI();
+ void showUI();
virtual std::string getName();
void openDetailPopup(std::shared_ptr<services::HistoryItem> currItem, std::shared_ptr<services::HistoryItemVector> prevItems);
bool isDesktopMode() const;
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::HistoryItem>, int)> mostVisitedTileClicked;
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::HistoryItem>, bool)> openURLInNewTab;
- boost::signals2::signal<void (const std::string & )> mostVisitedClicked;
- boost::signals2::signal<void (const std::string & )> bookmarkClicked;
- boost::signals2::signal<void (const std::string & )> bookmarkManagerClicked;
+ boost::signals2::signal<void ()> mostVisitedClicked;
+ boost::signals2::signal<void ()> bookmarkClicked;
+ boost::signals2::signal<void ()> bookmarkManagerClicked;
static const int MAX_THUMBNAIL_WIDTH;
static const int MAX_THUMBNAIL_HEIGHT;
void addBookmarkItems(std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> >);
void clearHistoryGenlist();
void clearBookmarkGengrid();
+ Evas_Object* createBookmarkGengrid(Evas_Object *parent);
void showHistory();
void showBookmarks();
- void clearItems();
Evas_Object* createQuickAccessLayout(Evas_Object *parent);
Evas_Object* createMostVisitedView(Evas_Object *parent);
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
} MoreMenuItemData;
MoreMenuUI::MoreMenuUI()
- : m_gengrid(nullptr)
+ : m_current_tab_bar(nullptr)
+ , m_mm_layout(nullptr)
+ , m_gengrid(nullptr)
, m_parent(nullptr)
+ , m_toastPopup(nullptr)
+ , m_icon(nullptr)
+ , m_bookmarkIcon(nullptr)
, m_item_class(nullptr)
- , m_mm_layout(nullptr)
, m_desktopMode(true)
, m_isBookmark(false)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (m_item_class)
elm_gengrid_item_class_free(m_item_class);
+ evas_object_del(m_gengrid);
}
Elm_Gengrid_Item_Class* MoreMenuUI::createItemClass()
m_parent = parent;
}
-void MoreMenuUI::show(Evas_Object* parent, bool desktopMode)
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- init(parent);
- //TODO: move this function call to SimpleUI::initUIServices after introducing new window managment.
- setDesktopMode(desktopMode);
- m_mm_layout=createMoreMenuLayout(parent);
- showUI();
-}
void MoreMenuUI::showUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- M_ASSERT(m_parent);
- evas_object_show(getContent());
- //regenerate gengrid
- m_gengrid=createGengrid(getContent());
+ M_ASSERT(m_mm_layout);
+ createGengrid(); // recreate gengrid because icons could have changed
addItems();
- elm_object_part_content_set(getContent(), "elm.swallow.grid", m_gengrid);
+ evas_object_show(m_mm_layout);
+ evas_object_show(elm_object_part_content_get(m_mm_layout,"current_tab_bar"));
+ evas_object_show(m_gengrid);
setFocus(EINA_TRUE);
}
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_mm_layout);
- evas_object_hide(getContent());
- //destroy gengrid
+ setFocus(EINA_FALSE);
+ evas_object_hide(m_mm_layout);
+ evas_object_hide(elm_object_part_content_get(m_mm_layout,"current_tab_bar"));
+ clearItems();
evas_object_del(m_gengrid);
}
Evas_Object* MoreMenuUI::getContent()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- M_ASSERT(m_parent);
if(!m_mm_layout)
- m_mm_layout = createMoreMenuLayout(m_parent);
+ createMoreMenuLayout();
return m_mm_layout;
}
-Evas_Object* MoreMenuUI::createMoreMenuLayout(Evas_Object* parent)
+void MoreMenuUI::createMoreMenuLayout()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ M_ASSERT(m_parent);
elm_theme_extension_add(NULL, m_edjFilePath.c_str());
- Evas_Object* mm_layout = elm_layout_add(parent);
- elm_layout_file_set(mm_layout, m_edjFilePath.c_str(), "moremenu-layout");
- evas_object_size_hint_weight_set(mm_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- evas_object_size_hint_align_set(mm_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
-
- evas_object_show(mm_layout);
- return mm_layout;
+ m_mm_layout = elm_layout_add(m_parent);
+ elm_layout_file_set(m_mm_layout, m_edjFilePath.c_str(), "moremenu-layout");
+ evas_object_size_hint_weight_set(m_mm_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(m_mm_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
}
-Evas_Object* MoreMenuUI::createGengrid(Evas_Object* parent)
+void MoreMenuUI::createGengrid()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- Evas_Object* gengrid = elm_gengrid_add(parent);
- elm_object_part_content_set(parent, "elm.swallow.grid", gengrid);
+ m_gengrid = elm_gengrid_add(m_mm_layout);
+ elm_object_part_content_set(m_mm_layout, "elm.swallow.grid", m_gengrid);
- elm_gengrid_align_set(gengrid, 0, 0);
- elm_gengrid_select_mode_set(gengrid, ELM_OBJECT_SELECT_MODE_ALWAYS);
- elm_gengrid_multi_select_set(gengrid, EINA_FALSE);
- elm_gengrid_horizontal_set(gengrid, EINA_FALSE);
- elm_scroller_policy_set(gengrid, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
- elm_scroller_page_size_set(gengrid, 0, 327);
- evas_object_size_hint_weight_set(gengrid, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- evas_object_size_hint_align_set(gengrid, EVAS_HINT_FILL, EVAS_HINT_FILL);
- elm_gengrid_item_size_set(gengrid, 364 * efl_scale, 320 * efl_scale);
- return gengrid;
+ elm_gengrid_align_set(m_gengrid, 0, 0);
+ elm_gengrid_select_mode_set(m_gengrid, ELM_OBJECT_SELECT_MODE_ALWAYS);
+ elm_gengrid_multi_select_set(m_gengrid, EINA_FALSE);
+ elm_gengrid_horizontal_set(m_gengrid, EINA_FALSE);
+ elm_scroller_policy_set(m_gengrid, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
+ elm_scroller_page_size_set(m_gengrid, 0, 327);
+ evas_object_size_hint_weight_set(m_gengrid, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(m_gengrid, EVAS_HINT_FILL, EVAS_HINT_FILL);
+ elm_gengrid_item_size_set(m_gengrid, 364 * efl_scale, 320 * efl_scale);
}
void MoreMenuUI::showCurrentTab()
void MoreMenuUI::setURL(const std::string& url)
{
BROWSER_LOGD("[%s:%d] %s", __PRETTY_FUNCTION__, __LINE__, url.c_str());
- char* part_name = "add_to_bookmark_text";
if(!url.empty()) {
elm_object_part_text_set(m_current_tab_bar, "webpage_url", url.c_str());
elm_popup_timeout_set(m_toastPopup, 3.0);
}
-void MoreMenuUI::_timeout(void *data, Evas_Object *obj, void *event_info)
+void MoreMenuUI::_timeout(void *data, Evas_Object*, void*)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
MoreMenuUI *moreMenuUI = static_cast<MoreMenuUI*>(data);
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
MoreMenuUI *moreMenuUI = static_cast<MoreMenuUI*>(data);
- moreMenuUI->closeMoreMenuClicked(std::string());
- moreMenuUI->clearItems();
+ moreMenuUI->closeMoreMenuClicked();
}
}
-void MoreMenuUI::hide()
-{
- evas_object_hide(elm_layout_content_get(m_mm_layout, "elm.swallow.grid"));
- evas_object_hide(elm_layout_content_get(m_mm_layout, "current_tab_bar"));
- evas_object_hide(m_mm_layout);
-}
void MoreMenuUI::addItems()
{
m_map_menu_views.insert(std::pair<ItemType, Elm_Object_Item*>(itemData->item, bookmarkView));
elm_gengrid_item_selected_set(bookmarkView, EINA_FALSE);
}
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
+}
+
+void MoreMenuUI::clearItems()
+{
+ BROWSER_LOGD("[%s:%d]", __PRETTY_FUNCTION__, __LINE__);
+ for (auto it = m_map_menu_views.begin(); it != m_map_menu_views.end(); ++it) {
+ Elm_Object_Item* bookmarkView = it->second;
+ Evas_Object *button = elm_object_item_part_content_get(it->second, "thumbbutton_item");
+ evas_object_event_callback_del(button, EVAS_CALLBACK_MOUSE_IN, __cb_mouse_in);
+ evas_object_event_callback_del(button, EVAS_CALLBACK_MOUSE_OUT, __cb_mouse_out);
+ }
+
+ elm_gengrid_clear(m_gengrid);
+ m_map_menu_views.clear();
}
char* MoreMenuUI::_grid_text_get(void* data, Evas_Object*, const char* part)
BROWSER_LOGD("type: %d", itemData->item);
switch (itemData->item) {
case HISTORY:
- itemData->moreMenuUI->setFocus(EINA_FALSE);
- itemData->moreMenuUI->historyUIClicked(std::string());
+ itemData->moreMenuUI->historyUIClicked();
break;
case SETTINGS:
- itemData->moreMenuUI->setFocus(EINA_FALSE);
- itemData->moreMenuUI->settingsClicked(std::string());
+ itemData->moreMenuUI->settingsClicked();
break;
case BOOKMARK_MANAGER:
- itemData->moreMenuUI->setFocus(EINA_FALSE);
- itemData->moreMenuUI->bookmarkManagerClicked(std::string());
+ itemData->moreMenuUI->bookmarkManagerClicked();
break;
#ifdef READER_MODE_ENABLED
case READER_MODE:
case VIEW_MOBILE_WEB:
itemData->moreMenuUI->switchToMobileMode();
itemData->moreMenuUI->m_desktopMode = false;
- itemData->moreMenuUI->closeMoreMenuClicked(std::string());
- itemData->moreMenuUI->clearItems();
+ itemData->moreMenuUI->closeMoreMenuClicked();
break;
case VIEW_DESKTOP_WEB:
itemData->moreMenuUI->switchToDesktopMode();
itemData->moreMenuUI->m_desktopMode = true;
- itemData->moreMenuUI->closeMoreMenuClicked(std::string());
- itemData->moreMenuUI->clearItems();
+ itemData->moreMenuUI->closeMoreMenuClicked();
break;
case SHARE:
break;
}
}
-void MoreMenuUI::clearItems()
-{
- hide();
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- elm_gengrid_clear(m_gengrid);
- elm_object_tree_focus_allow_set(getContent(), EINA_FALSE);
- m_map_menu_views.clear();
- evas_object_del(m_current_tab_bar);
- elm_theme_extension_del(NULL, m_edjFilePath.c_str());
- elm_theme_full_flush();
- elm_cache_all_flush();
-}
-
void MoreMenuUI::_exitClicked()
{
BROWSER_LOGD("[%s:%d]", __PRETTY_FUNCTION__, __LINE__);
void setDesktopMode(bool desktopMode) {m_desktopMode = desktopMode;}
- void show(Evas_Object *main_layout, bool desktopMode);
- //TODO: remove this function after new view managment introduction.
void showCurrentTab();
virtual std::string getName();
- void addItems();
- //TODO: remove this function after new view managment introduction.
- void hide();
- void clearItems();
void setFavIcon(std::shared_ptr<tizen_browser::tools::BrowserImage> favicon);
void setWebTitle(const std::string& title);
void setURL(const std::string& url);
void setFocus(Eina_Bool focusable);
boost::signals2::signal<void (int)> addToBookmarkClicked;
- //TODO: remove redundant argument from this signal.
- boost::signals2::signal<void (std::string)> bookmarkManagerClicked;
- boost::signals2::signal<void (std::string)> historyUIClicked;
- boost::signals2::signal<void (const std::string&)> settingsClicked;
- //TODO: remove redundant argument from this signal.
- boost::signals2::signal<void (std::string)> closeMoreMenuClicked;
+ boost::signals2::signal<void ()> bookmarkManagerClicked;
+ boost::signals2::signal<void ()> historyUIClicked;
+ boost::signals2::signal<void ()> settingsClicked;
+ boost::signals2::signal<void ()> closeMoreMenuClicked;
boost::signals2::signal<void ()> switchToMobileMode;
boost::signals2::signal<void ()> switchToDesktopMode;
boost::signals2::signal<bool ()> isBookmark;
boost::signals2::signal<void ()> deleteBookmark;
private:
Elm_Gengrid_Item_Class* createItemClass();
- Evas_Object* createMoreMenuLayout(Evas_Object* parent);
- Evas_Object* createGengrid(Evas_Object* parent);
+ void createMoreMenuLayout();
+ void createGengrid();
+ void addItems();
+ void clearItems();
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);
static void _thumbSelected(void * data, Evas_Object * obj, void * event_info);
return settings_layout;
}
-void SettingsUI::show(Evas_Object* parent)
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- init(parent);
- m_settings_layout = createSettingsUILayout(m_parent);
- showUI();
-}
-
Evas_Object* SettingsUI::createActionBar(Evas_Object* settings_layout)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
SettingsUI * s_ui = static_cast<SettingsUI*>(data);
- s_ui->closeSettingsUIClicked(std::string());
- s_ui->clearItems();
+ s_ui->closeSettingsUIClicked();
}
}
-void SettingsUI::hide()
-{
- evas_object_hide(elm_layout_content_get(m_settings_layout, "action_bar_swallow"));
- evas_object_hide(elm_layout_content_get(m_settings_layout, "settings_scroller_swallow"));
- evas_object_hide(m_settings_layout);
-}
-
void SettingsUI::_del_selected_data_clicked_cb(void *data, Evas_Object*, void*)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
ItemData* itemData = static_cast<ItemData*>(data);
- itemData->settingsUI->resetMostVisitedClicked(std::string());
+ itemData->settingsUI->resetMostVisitedClicked();
}
}
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
ItemData* itemData = static_cast<ItemData*>(data);
- itemData->settingsUI->resetBrowserClicked(std::string());
+ itemData->settingsUI->resetBrowserClicked();
}
}
-void SettingsUI::clearItems()
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- hide();
-}
-
}
}
virtual std::string getName();
Evas_Object* createActionBar(Evas_Object* settings_layout);
Evas_Object* createSettingsPage(Evas_Object* settings_layout);
- void clearItems();
- void hide();
- boost::signals2::signal<void (const std::string & )> resetBrowserClicked;
- boost::signals2::signal<void (const std::string & )> resetMostVisitedClicked;
- boost::signals2::signal<void (const std::string & )> deleteSelectedDataClicked;
- boost::signals2::signal<void (const std::string & )> closeSettingsUIClicked;
+ boost::signals2::signal<void ()> resetBrowserClicked;
+ boost::signals2::signal<void ()> resetMostVisitedClicked;
+ boost::signals2::signal<void (std::string&)> deleteSelectedDataClicked;
+ boost::signals2::signal<void ()> closeSettingsUIClicked;
private:
Evas_Object* createSettingsUILayout(Evas_Object* parent);
AuthenticationPopup.edc
BookmarksManager.edc
Tooltip.edc
+ ViewManager.edc
)
foreach(edec ${edcFiles})
BROWSER_LOGE("Failed to create main window");
setMainWindow(main_window);
+ m_viewManager = new ViewManager(main_window);
+ evas_object_size_hint_weight_set(main_window, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set (main_window, EVAS_HINT_FILL, EVAS_HINT_FILL);
+
+ elm_win_resize_object_add(main_window, m_viewManager->getContent());
+ evas_object_show(main_window);
}
SimpleUI::~SimpleUI() {
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_sessionService->getStorage()->deleteSession(m_currentSession);
- /// \todo Auto-generated destructor stub
evas_object_del(m_window.get());
ewk_context_delete(m_ewkContext);
}
m_tabLimit = boost::any_cast <int> (config.get("TAB_LIMIT"));
m_favoritesLimit = boost::any_cast <int> (config.get("FAVORITES_LIMIT"));
- // Set up main window
- //TODO: These functions seems redundant. Check if these functions are neccessary.
- int width = 0;
- int height = 0;
- ecore_wl_screen_size_get(&width, &height);
- evas_object_move(m_window.get(), 0, 0);
- evas_object_resize(m_window.get(), width, height);
-
- elm_win_focus_highlight_style_set(m_window.get(), "invisible");
-
- //set global show tooltip timeout
- elm_config_tooltip_delay_set( boost::any_cast <double> (config.get("TOOLTIP_DELAY")));
loadUIServices();
loadModelServices();
initUIServices();
initModelServices();
- // create view layouts
- elm_win_resize_object_add(m_window.get(), m_webPageUI->getContent());
connectModelSignals();
connectUISignals();
connectActions();
- // show main layout and window
- evas_object_show(m_webPageUI->getContent());
- evas_object_show(m_window.get());
+ //Push first view to stack.
+ m_viewManager->pushViewToStack(m_webPageUI.get());
}
m_initialised = true;
}
} else {
openNewTab(url);
}
- m_webPageUI->getURIEntry().setFocus();
BROWSER_LOGD("[%s]:%d url=%s", __func__, __LINE__, url.c_str());
return 0;
std::dynamic_pointer_cast
<tizen_browser::base_ui::MainUI,tizen_browser::core::AbstractService>
(tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.mainui"));
+
+ m_tabUI =
+ std::dynamic_pointer_cast
+ <tizen_browser::base_ui::TabUI,tizen_browser::core::AbstractService>
+ (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.tabui"));
+
+ m_historyUI =
+ std::dynamic_pointer_cast
+ <tizen_browser::base_ui::HistoryUI,tizen_browser::core::AbstractService>
+ (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.historyui"));
+
+ m_settingsUI =
+ std::dynamic_pointer_cast
+ <tizen_browser::base_ui::SettingsUI,tizen_browser::core::AbstractService>
+ (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.settingsui"));
+
+ m_moreMenuUI =
+ std::dynamic_pointer_cast
+ <tizen_browser::base_ui::MoreMenuUI,tizen_browser::core::AbstractService>
+ (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.moremenuui"));
+
+ m_bookmarkManagerUI =
+ std::dynamic_pointer_cast
+ <tizen_browser::base_ui::BookmarkManagerUI,tizen_browser::core::AbstractService>
+ (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.bookmarkmanagerui"));
}
void SimpleUI::connectUISignals()
M_ASSERT(m_webPageUI.get());
m_webPageUI->getURIEntry().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->reloadPage.connect(boost::bind(&SimpleUI::switchViewToWebPage, this));
+ m_webPageUI->showTabUI.connect(boost::bind(&SimpleUI::showTabUI, this));
+ m_webPageUI->showMoreMenu.connect(boost::bind(&SimpleUI::showMoreMenu, this));
+ m_webPageUI->forwardPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::forward, m_webEngine.get()));
+ m_webPageUI->stopLoadingPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::stopLoading, m_webEngine.get()));
+ m_webPageUI->reloadPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::reload, m_webEngine.get()));
+ m_webPageUI->showMainUI.connect(boost::bind(&SimpleUI::showMainUI, this));
+ m_webPageUI->hideMainUI.connect(boost::bind(&MainUI::hideUI, m_mainUI));
+
M_ASSERT(m_mainUI.get());
m_mainUI->getDetailPopup().openURLInNewTab.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, _2));
m_mainUI->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));
- m_mainUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::onBookmarkManagerButtonClicked, this,_1));
+ m_mainUI->mostVisitedClicked.connect(boost::bind(&SimpleUI::onMostVisitedClicked, this));
+ m_mainUI->bookmarkClicked.connect(boost::bind(&SimpleUI::onBookmarkButtonClicked, this));
+ m_mainUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::showBookmarkManagerUI, this));
+
+ M_ASSERT(m_tabUI.get());
+ m_tabUI->closeTabUIClicked.connect(boost::bind(&SimpleUI::closeTabUI, this));
+ m_tabUI->newTabClicked.connect(boost::bind(&SimpleUI::newTabClicked, this));
+ m_tabUI->tabClicked.connect(boost::bind(&SimpleUI::tabClicked, this,_1));
+ m_tabUI->closeTabsClicked.connect(boost::bind(&SimpleUI::closeTabsClicked, this,_1));
+ m_tabUI->newIncognitoTabClicked.connect(boost::bind(&SimpleUI::newTabClicked, this));
+ m_tabUI->tabsCount.connect(boost::bind(&SimpleUI::tabsCount, this));
+
+ M_ASSERT(m_historyUI.get());
+ m_historyUI->clearHistoryClicked.connect(boost::bind(&SimpleUI::onClearHistoryClicked, this));
+ m_historyUI->closeHistoryUIClicked.connect(boost::bind(&SimpleUI::closeHistoryUI, this));
+ // desktop mode as default
+ m_historyUI->historyItemClicked.connect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, true));
+
+ M_ASSERT(m_settingsUI.get());
+ m_settingsUI->closeSettingsUIClicked.connect(boost::bind(&SimpleUI::closeSettingsUI, this));
+ m_settingsUI->deleteSelectedDataClicked.connect(boost::bind(&SimpleUI::settingsDeleteSelectedData, this,_1));
+ m_settingsUI->resetMostVisitedClicked.connect(boost::bind(&SimpleUI::settingsResetMostVisited, this));
+ m_settingsUI->resetBrowserClicked.connect(boost::bind(&SimpleUI::settingsResetBrowser, this));
+
+ M_ASSERT(m_moreMenuUI.get());
+ m_moreMenuUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::showBookmarkManagerUI, this));
+ m_moreMenuUI->historyUIClicked.connect(boost::bind(&SimpleUI::showHistoryUI, this));
+ m_moreMenuUI->settingsClicked.connect(boost::bind(&SimpleUI::showSettingsUI, this));
+ m_moreMenuUI->closeMoreMenuClicked.connect(boost::bind(&SimpleUI::closeMoreMenu, 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::addToBookmarks, this, _1));
+ m_moreMenuUI->isBookmark.connect(boost::bind(&SimpleUI::checkBookmark, this));
+ m_moreMenuUI->deleteBookmark.connect(boost::bind(&SimpleUI::deleteBookmark, this));
+
+ M_ASSERT(m_bookmarkManagerUI.get());
+ m_bookmarkManagerUI->closeBookmarkManagerClicked.connect(boost::bind(&SimpleUI::closeBookmarkManagerUI, this));
+ m_bookmarkManagerUI->bookmarkItemClicked.connect(boost::bind(&SimpleUI::onBookmarkClicked, this, _1));
+
}
void SimpleUI::loadModelServices()
<tizen_browser::services::PlatformInputManager,tizen_browser::core::AbstractService>
(tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.platforminputmanager"));
- m_sessionService = std::dynamic_pointer_cast
+ m_sessionService =
+ std::dynamic_pointer_cast
<tizen_browser::services::SessionStorage,tizen_browser::core::AbstractService>
(tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.sessionStorageService"));
}
void SimpleUI::initUIServices()
{
- m_webPageUI->init(m_window.get());
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ M_ASSERT (m_viewManager);
+
+ M_ASSERT(m_webPageUI.get());
+ m_webPageUI->init(m_viewManager->getContent());
+
+ M_ASSERT(m_mainUI.get());
m_mainUI->init(m_webPageUI->getContent());
+
+ M_ASSERT(m_tabUI.get());
+ m_tabUI->init(m_viewManager->getContent());
+
+ M_ASSERT(m_historyUI.get());
+ m_historyUI->init(m_viewManager->getContent());
+
+ M_ASSERT(m_moreMenuUI.get());
+ m_moreMenuUI->init(m_viewManager->getContent());
+
+ M_ASSERT(m_settingsUI.get());
+ m_settingsUI->init(m_viewManager->getContent());
+
+ M_ASSERT(m_bookmarkManagerUI.get());
+ m_bookmarkManagerUI->init(m_viewManager->getContent());
}
void SimpleUI::initModelServices()
m_webEngine->uriChanged.connect(boost::bind(&URIEntry::changeUri, &m_webPageUI->getURIEntry(), _1));
m_webEngine->uriOnTabChanged.connect(boost::bind(&SimpleUI::checkTabId,this,_1));
m_webEngine->webViewClicked.connect(boost::bind(&URIEntry::clearFocus, &m_webPageUI->getURIEntry()));
- m_webEngine->backwardEnableChanged.connect(boost::bind(&SimpleUI::backEnable, this, _1));
- m_webEngine->forwardEnableChanged.connect(boost::bind(&SimpleUI::forwardEnable, this, _1));
+ m_webEngine->backwardEnableChanged.connect(boost::bind(&WebPageUI::setBackButtonEnabled, m_webPageUI.get(), _1));
+ m_webEngine->forwardEnableChanged.connect(boost::bind(&WebPageUI::setForwardButtonEnabled, m_webPageUI.get(), _1));
m_webEngine->loadStarted.connect(boost::bind(&SimpleUI::loadStarted, this));
m_webEngine->loadProgress.connect(boost::bind(&SimpleUI::progressChanged,this,_1));
m_webEngine->loadFinished.connect(boost::bind(&SimpleUI::loadFinished, this));
m_webEngine->tabCreated.connect(boost::bind(&SimpleUI::tabCreated, this));
m_webEngine->tabClosed.connect(boost::bind(&SimpleUI::tabClosed,this,_1));
m_webEngine->IMEStateChanged.connect(boost::bind(&SimpleUI::setwvIMEStatus, this, _1));
+ m_webEngine->favIconChanged.connect(boost::bind(&MoreMenuUI::setFavIcon, m_moreMenuUI.get(), _1));
+ m_webEngine->titleChanged.connect(boost::bind(&MoreMenuUI::setWebTitle, m_moreMenuUI.get(), _1));
+ m_webEngine->uriChanged.connect(boost::bind(&MoreMenuUI::setURL, m_moreMenuUI.get(), _1));
m_favoriteService->bookmarkAdded.connect(boost::bind(&SimpleUI::onBookmarkAdded, this,_1));
m_favoriteService->bookmarkDeleted.connect(boost::bind(&SimpleUI::onBookmarkRemoved, this, _1));
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_settingPrivateBrowsing->toggled.connect(boost::bind(&SimpleUI::settingsPrivateModeSwitch, this, _1));
-
- //left bar
- m_webPageUI->backPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::back, m_webEngine.get()));
- m_webPageUI->backPage.connect(boost::bind(&SimpleUI::switchViewToWebPage, this));
- m_webPageUI->forwardPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::forward, m_webEngine.get()));
- m_webPageUI->stopLoadingPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::stopLoading, m_webEngine.get()));
- m_webPageUI->reloadPage.connect(boost::bind(&tizen_browser::basic_webengine::AbstractWebEngine<Evas_Object>::reload, m_webEngine.get()));
- m_webPageUI->reloadPage.connect(boost::bind(&SimpleUI::switchViewToWebPage, this));
-
- //right bar
- m_webPageUI->showTabUI.connect(boost::bind(&SimpleUI::showTabUI, this));
- m_webPageUI->showMoreMenu.connect(boost::bind(&SimpleUI::showMoreMenu, this));
}
void SimpleUI::switchViewToWebPage()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- M_ASSERT(m_webPageUI);
- M_ASSERT(m_mainUI);
+ M_ASSERT(m_mainUI.get());
+ M_ASSERT(m_viewManager);
+
if(m_webPageUI->isHomePageActive())
- m_mainUI->hide();
+ m_mainUI->hideUI();
+
m_webPageUI->switchViewToWebPage(m_webEngine->getLayout(), m_webEngine->getURI());
}
return m_webPageUI->isErrorPageActive();
}
+void SimpleUI::showMainUI()
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ m_mainUI->showMostVisited(getMostVisitedItems());
+ m_mainUI->showUI();
+}
+
void SimpleUI::switchViewToQuickAccess()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if(m_webPageUI->isHomePageActive())
- return;
+ M_ASSERT(m_viewManager);
+ m_viewManager->popStackTo(m_webPageUI.get());
m_webPageUI->switchViewToQuickAccess(m_mainUI->getContent());
m_webEngine->disconnectCurrentWebViewSignals();
- m_mainUI->showMostVisited(getMostVisitedItems());
}
void SimpleUI::checkTabId(const tizen_browser::basic_webengine::TabId& id){
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if(m_webEngine->currentTabId() != id || isErrorPageActive()){
BROWSER_LOGD("URL changed on non-visible tab, updating browser view");
switchToTab(id);
void SimpleUI::openNewTab(const std::string &uri, bool desktopMode)
{
+ BROWSER_LOGD("[%s:%d] uri =%s", __PRETTY_FUNCTION__, __LINE__, uri.c_str());
switchToTab(m_webEngine->addTab(uri, nullptr, desktopMode));
}
-void SimpleUI::closeTab(){
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
+void SimpleUI::closeTab()
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
auto tabId = m_webEngine->currentTabId();
closeTab(tabId);
}
void SimpleUI::closeTab(const tizen_browser::basic_webengine::TabId& id)
{
- BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_currentSession.removeItem(id.toString());
m_webEngine->closeTab(id);
updateView();
bool SimpleUI::checkBookmark()
{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (m_webPageUI->isHomePageActive())
return false;
void SimpleUI::onOpenURLInNewTab(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem, bool desktopMode)
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
+ m_viewManager->popStackTo(m_webPageUI.get());
std::string historyAddress = historyItem->getUrl();
- if(m_historyUI) { // TODO: remove this section when naviframes will be available
- m_historyUI->clearItems();
- closeHistoryUI();
- }
-
- if(m_moreMenuUI) { // TODO: remove this section when naviframes will be available
- m_moreMenuUI->clearItems();
- closeMoreMenu(std::string());
- }
openNewTab(historyAddress, desktopMode);
}
m_mainUI->openDetailPopup(historyItem, m_historyService->getHistoryItemsByURL(historyItem->getUrl(), itemsNumber));
}
-void SimpleUI::onClearHistoryClicked(const std::string&)
+void SimpleUI::onClearHistoryClicked()
{
BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
m_historyService->clearAllHistory();
- m_historyUI.reset();
}
-void SimpleUI::onMostVisitedClicked(const std::string&)
+void SimpleUI::onMostVisitedClicked()
{
- BROWSER_LOGD("[%s]", __func__);
+ BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
m_mainUI->showMostVisited(getMostVisitedItems());
}
-void SimpleUI::onBookmarkButtonClicked(const std::string&)
+void SimpleUI::onBookmarkButtonClicked()
{
- BROWSER_LOGD("[%s]", __func__);
+ BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
m_mainUI->showBookmarks(getBookmarks());
}
-void SimpleUI::onBookmarkManagerButtonClicked(const std::string&)
-{
- BROWSER_LOGD("[%s]", __func__);
- m_mainUI->hide();
-
- if(m_moreMenuUI) { // TODO: remove this section when naviframes will be available
- m_moreMenuUI->clearItems();
- }
-
- showBookmarkManagerMenu();
-}
-
void SimpleUI::onBookmarkClicked(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem)
{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ M_ASSERT(m_viewManager);
+ m_viewManager->popStackTo(m_webPageUI.get());
std::string bookmarkAddress = bookmarkItem->getAddress();
- if(m_bookmarkManagerUI) { // TODO: remove this section when naviframes will be available
- m_bookmarkManagerUI->clearItems();
- closeBookmarkManagerMenu(std::string());
- }
-
- if(m_moreMenuUI) { // TODO: remove this section when naviframes will be available
- m_moreMenuUI->clearItems();
- closeMoreMenu(std::string());
- }
openNewTab(bookmarkAddress);
}
-// Consider removing these functions
void SimpleUI::onHistoryRemoved(const std::string& uri)
{
BROWSER_LOGD("[%s]", __func__);
m_platformInputManager->returnPressed.disconnect_all_slots();
m_platformInputManager->returnPressed.connect(boost::bind(&elm_exit));
- hidePopup.disconnect_all_slots();
m->hidePopup();
}
m_webEngine->backButtonClicked();
}
-void SimpleUI::backEnable(bool enable)
-{
- m_webPageUI->setBackButtonEnabled(enable);
-}
-
-void SimpleUI::forwardEnable(bool enable)
-{
- m_webPageUI->setForwardButtonEnabled(enable);
-}
-
void SimpleUI::reloadEnable(bool enable)
{
m_webPageUI->setReloadButtonEnabled(enable);
void SimpleUI::showTabUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_tabUI = std::dynamic_pointer_cast<tizen_browser::base_ui::TabUI,tizen_browser::core::AbstractService>
- (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.tabui"));
- M_ASSERT(m_tabUI);
- m_tabUI->closeTabUIClicked.connect(boost::bind(&SimpleUI::closeTabUI, this,_1));
- m_tabUI->newTabClicked.connect(boost::bind(&SimpleUI::newTabClicked, this,_1));
- m_tabUI->tabClicked.connect(boost::bind(&SimpleUI::tabClicked, this,_1));
- m_tabUI->closeTabsClicked.connect(boost::bind(&SimpleUI::closeTabsClicked, this,_1));
- m_tabUI->newIncognitoTabClicked.connect(boost::bind(&SimpleUI::newTabClicked, this,_1));
- m_tabUI->tabsCount.connect(boost::bind(&SimpleUI::tabsCount, this));
- m_tabUI->show(m_window.get());
+ M_ASSERT(m_viewManager);
+ m_viewManager->pushViewToStack(m_tabUI.get());
m_tabUI->addTabItems(m_webEngine->getTabContents());
}
-void SimpleUI::closeTabUI(const std::string& str)
+void SimpleUI::closeTabUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_tabUI = nullptr;
+ M_ASSERT(m_viewManager);
+ if (m_viewManager->topOfStack() == m_tabUI.get())
+ m_viewManager->popTheStack();
}
-void SimpleUI::newTabClicked(const std::string& str)
+void SimpleUI::newTabClicked()
{
- BROWSER_LOGD("%s", __func__);
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
switchViewToQuickAccess();
}
void SimpleUI::tabClicked(const tizen_browser::basic_webengine::TabId& tabId)
{
- BROWSER_LOGD("%s", __func__);
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ m_viewManager->popStackTo(m_webPageUI.get());
switchToTab(tabId);
}
void SimpleUI::closeTabsClicked(const tizen_browser::basic_webengine::TabId& tabId)
{
- BROWSER_LOGD("%s", __func__);
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_webEngine->closeTab(tabId);
}
std::string edjFilePath = EDJE_DIR;
edjFilePath.append("SimpleUI/AuthenticationPopup.edj");
Eina_Bool layoutSetResult = elm_layout_file_set(popup_content, edjFilePath.c_str(), "authentication_popup");
- if(!layoutSetResult)
+ if (!layoutSetResult)
throw std::runtime_error("Layout file not found: " + edjFilePath);
#if PLATFORM(TIZEN)
}
}
-void SimpleUI::showHistoryUI(const std::string& str)
+void SimpleUI::showHistoryUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if(!m_historyUI)
- {
- m_historyUI =
- std::dynamic_pointer_cast<tizen_browser::base_ui::HistoryUI,tizen_browser::core::AbstractService>
- (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.historyui"));
- M_ASSERT(m_historyUI);
- m_historyUI->clearHistoryClicked.connect(boost::bind(&SimpleUI::onClearHistoryClicked, this,_1));
- m_historyUI->closeHistoryUIClicked.connect(boost::bind(&SimpleUI::closeHistoryUI, this));
- 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());
- }
+ M_ASSERT(m_viewManager);
+ m_viewManager->pushViewToStack(m_historyUI.get());
+ m_historyUI->addHistoryItems(getHistory());
}
void SimpleUI::closeHistoryUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_historyUI->clearHistoryClicked.disconnect(boost::bind(&SimpleUI::onClearHistoryClicked, this,_1));
- m_historyUI->closeHistoryUIClicked.disconnect(boost::bind(&SimpleUI::closeHistoryUI, this));
- m_historyUI->historyItemClicked.disconnect(boost::bind(&SimpleUI::onOpenURLInNewTab, this, _1, true)); // desktop mode as default
- m_historyUI.reset();
- m_moreMenuUI->setFocus(EINA_TRUE);
+ M_ASSERT(m_viewManager);
+ if (m_viewManager->topOfStack() == m_historyUI.get())
+ m_viewManager->popTheStack();
}
-void SimpleUI::showSettingsUI(const std::string& str)
+void SimpleUI::showSettingsUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if(!m_settingsUI){
- m_settingsUI =
- std::dynamic_pointer_cast
- <tizen_browser::base_ui::SettingsUI,tizen_browser::core::AbstractService>
- (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.settingsui"));
- M_ASSERT(m_settingsUI);
- m_settingsUI->closeSettingsUIClicked.disconnect_all_slots();
- m_settingsUI->closeSettingsUIClicked.connect(boost::bind(&SimpleUI::closeSettingsUI, this,_1));
- m_settingsUI->deleteSelectedDataClicked.disconnect_all_slots();
- m_settingsUI->deleteSelectedDataClicked.connect(boost::bind(&SimpleUI::settingsDeleteSelectedData, this,_1));
- m_settingsUI->resetMostVisitedClicked.disconnect_all_slots();
- m_settingsUI->resetMostVisitedClicked.connect(boost::bind(&SimpleUI::settingsResetMostVisited, this,_1));
- m_settingsUI->resetBrowserClicked.disconnect_all_slots();
- m_settingsUI->resetBrowserClicked.connect(boost::bind(&SimpleUI::settingsResetBrowser, this,_1));
- m_settingsUI->show(m_window.get());
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- }
+ M_ASSERT(m_viewManager);
+ m_viewManager->pushViewToStack(m_settingsUI.get());
}
-void SimpleUI::closeSettingsUI(const std::string& str)
+void SimpleUI::closeSettingsUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_settingsUI.reset();
- m_moreMenuUI->setFocus(EINA_TRUE);
+ M_ASSERT(m_viewManager);
+ if (m_viewManager->topOfStack() == m_settingsUI.get())
+ m_viewManager->popTheStack();
}
void SimpleUI::showMoreMenu()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- bool desktopMode = m_webPageUI->isHomePageActive() ? m_mainUI->isDesktopMode() : m_webEngine->isDesktopMode();
- if(!m_moreMenuUI){
- m_moreMenuUI =
- std::dynamic_pointer_cast
- <tizen_browser::base_ui::MoreMenuUI,tizen_browser::core::AbstractService>
- (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.moremenuui"));
- M_ASSERT(m_moreMenuUI);
- m_webEngine->favIconChanged.connect(boost::bind(&MoreMenuUI::setFavIcon, m_moreMenuUI.get(), _1));
- m_webEngine->titleChanged.connect(boost::bind(&MoreMenuUI::setWebTitle, m_moreMenuUI.get(), _1));
- m_webEngine->uriChanged.connect(boost::bind(&MoreMenuUI::setURL, m_moreMenuUI.get(), _1));
- m_moreMenuUI->bookmarkManagerClicked.connect(boost::bind(&SimpleUI::onBookmarkManagerButtonClicked, this, _1));
- 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->switchToMobileMode.connect(boost::bind(&SimpleUI::switchToMobileMode, this));
- m_moreMenuUI->switchToDesktopMode.connect(boost::bind(&SimpleUI::switchToDesktopMode, this));
- m_moreMenuUI->addToBookmarkClicked.connect(boost::bind(&SimpleUI::addToBookmarks, this, _1));
- m_moreMenuUI->isBookmark.connect(boost::bind(&SimpleUI::checkBookmark, this));
- m_moreMenuUI->deleteBookmark.connect(boost::bind(&SimpleUI::deleteBookmark, this));
-
- m_moreMenuUI->show(m_window.get(), desktopMode);
- m_moreMenuUI->showCurrentTab();
-
- if(!m_webPageUI->isHomePageActive()) {
- m_moreMenuUI->setFavIcon(m_webEngine->getFavicon());
- m_moreMenuUI->setWebTitle(m_webEngine->getTitle());
- m_moreMenuUI->setURL(m_webEngine->getURI());
- }
- else {
- m_moreMenuUI->setHomePageInfo();
- }
+ M_ASSERT(m_viewManager);
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ bool desktopMode = m_webPageUI->isHomePageActive() ? m_mainUI->isDesktopMode() : m_webEngine->isDesktopMode();
+ m_moreMenuUI->setDesktopMode(desktopMode);
+ m_viewManager->pushViewToStack(m_moreMenuUI.get());
+ m_moreMenuUI->showCurrentTab();
+
+ if(!m_webPageUI->isHomePageActive()) {
+ m_moreMenuUI->setFavIcon(m_webEngine->getFavicon());
+ m_moreMenuUI->setWebTitle(m_webEngine->getTitle());
+ m_moreMenuUI->setURL(m_webEngine->getURI());
+ }
+ else {
+ m_moreMenuUI->setHomePageInfo();
}
}
-void SimpleUI::closeMoreMenu(const std::string& str)
+void SimpleUI::closeMoreMenu()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_webEngine->favIconChanged.disconnect(boost::bind(&MoreMenuUI::setFavIcon, m_moreMenuUI.get(), _1));
- m_webEngine->titleChanged.disconnect(boost::bind(&MoreMenuUI::setWebTitle, m_moreMenuUI.get(), _1));
- m_webEngine->uriChanged.disconnect(boost::bind(&MoreMenuUI::setURL, m_moreMenuUI.get(), _1));
- m_moreMenuUI->bookmarkManagerClicked.disconnect(boost::bind(&SimpleUI::onBookmarkManagerButtonClicked, this, _1));
- m_moreMenuUI->historyUIClicked.disconnect(boost::bind(&SimpleUI::showHistoryUI, this,_1));
- m_moreMenuUI->settingsClicked.disconnect(boost::bind(&SimpleUI::showSettingsUI, this,_1));
- m_moreMenuUI->closeMoreMenuClicked.disconnect(boost::bind(&SimpleUI::closeMoreMenu, this,_1));
- m_moreMenuUI->switchToMobileMode.disconnect(boost::bind(&SimpleUI::switchToMobileMode, this));
- m_moreMenuUI->switchToDesktopMode.disconnect(boost::bind(&SimpleUI::switchToDesktopMode, this));
- m_moreMenuUI->addToBookmarkClicked.disconnect(boost::bind(&SimpleUI::addToBookmarks, this, _1));
- m_moreMenuUI->isBookmark.disconnect(boost::bind(&SimpleUI::checkBookmark, this));
- m_moreMenuUI->deleteBookmark.disconnect(boost::bind(&SimpleUI::deleteBookmark, this));
- m_moreMenuUI.reset();
-
- // TODO: temporary showing proper view untin VieManger will be available
- if (m_webPageUI->isHomePageActive()) {
- m_webPageUI->switchViewToQuickAccess(m_mainUI->getContent());
- m_webEngine->disconnectCurrentWebViewSignals();
- m_mainUI->showMostVisited(getMostVisitedItems());
- }
- else {
- switchViewToWebPage();
- }
+ M_ASSERT(m_viewManager);
+ if (m_viewManager->topOfStack() == m_moreMenuUI.get())
+ m_viewManager->popTheStack();
+ else
+ BROWSER_LOGD("[%s:%d] WARNING!!! closeMoreMenu is not topOfStack", __PRETTY_FUNCTION__, __LINE__);
}
void SimpleUI::switchToMobileMode()
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (!m_webPageUI->isHomePageActive()) {
m_webEngine->switchToMobileMode();
+ m_viewManager->popStackTo(m_webPageUI.get());
m_webEngine->reload();
} else {
m_mainUI->setDesktopMode(false);
}
}
-void SimpleUI::showBookmarkManagerMenu()
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if(!m_bookmarkManagerUI){
- m_bookmarkManagerUI =
- std::dynamic_pointer_cast
- <tizen_browser::base_ui::BookmarkManagerUI,tizen_browser::core::AbstractService>
- (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.bookmarkmanagerui"));
- M_ASSERT(m_bookmarkManagerUI);
- m_bookmarkManagerUI->closeBookmarkManagerClicked.connect(boost::bind(&SimpleUI::closeBookmarkManagerMenu, this,_1));
- m_bookmarkManagerUI->bookmarkItemClicked.connect(boost::bind(&SimpleUI::onBookmarkClicked, this, _1));
- m_bookmarkManagerUI->show(m_window.get());
- m_bookmarkManagerUI->addBookmarkItems(getBookmarks(ROOT_FOLDER));
- m_bookmarkManagerUI->showTopContent();
- }
-}
-
-void SimpleUI::closeBookmarkManagerMenu(const std::string& str)
+void SimpleUI::showBookmarkManagerUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_bookmarkManagerUI->closeBookmarkManagerClicked.disconnect(boost::bind(&SimpleUI::closeBookmarkManagerMenu, this,_1));
- m_bookmarkManagerUI->bookmarkItemClicked.disconnect(boost::bind(&SimpleUI::onBookmarkClicked, this, _1));
- m_bookmarkManagerUI.reset();
-
- if(m_moreMenuUI) {
- closeMoreMenu(std::string());
- showMoreMenu();
- }
-
- if(m_mainUI) {
- m_mainUI->showBookmarks(getBookmarks());
- }
- m_moreMenuUI->setFocus(EINA_TRUE);
+ M_ASSERT(m_viewManager);
+ m_viewManager->pushViewToStack(m_bookmarkManagerUI.get());
+ m_bookmarkManagerUI->addBookmarkItems(getBookmarks(ROOT_FOLDER));
}
-void SimpleUI::hideHistory()
+void SimpleUI::closeBookmarkManagerUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- hidePopup();
+ M_ASSERT(m_viewManager);
+ if (m_viewManager->topOfStack() == m_bookmarkManagerUI.get())
+ m_viewManager->popTheStack();
}
void SimpleUI::settingsPointerModeSwitch(bool newState)
void SimpleUI::onDeleteSelectedDataButton(PopupButtons button, std::shared_ptr< PopupData > popupData)
{
- if(button == OK){
+ if (button == OK) {
BROWSER_LOGD("[%s]: OK", __func__);
std::string dataText = std::static_pointer_cast<EntryPopupData>(popupData)->text;
BROWSER_LOGD("[%s]: TYPE : %s", __func__, dataText.c_str());
}
}
-void SimpleUI::settingsResetMostVisited(const std::string& str)
+void SimpleUI::settingsResetMostVisited()
{
BROWSER_LOGD("[%s]: Deleting Hisory", __func__);
SimplePopup *popup = SimplePopup::createPopup();
void SimpleUI::onDeleteMostVisitedButton(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
{
- if(button == OK){
+ if (button == OK) {
BROWSER_LOGD("[%s]: OK", __func__);
BROWSER_LOGD("[%s]: Deleting most visited", __func__);
}
}
-void SimpleUI::settingsResetBrowser(const std::string& str)
+void SimpleUI::settingsResetBrowser()
{
BROWSER_LOGD("[%s]: Deleting Hisory", __func__);
SimplePopup *popup = SimplePopup::createPopup();
void SimpleUI::onResetBrowserButton(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
{
- if(button == OK){
+ if (button == OK) {
BROWSER_LOGD("[%s]: OK", __func__);
BROWSER_LOGD("[%s]: Resetting browser", __func__);
}
void SimpleUI::tabLimitPopupButtonClicked(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/)
{
- if(button == CLOSE_TAB){
+ if (button == CLOSE_TAB) {
BROWSER_LOGD("[%s]: CLOSE TAB", __func__);
closeTab();
}
{
int tabs = m_webEngine->tabsCount();
- if(tabs > m_tabLimit)
+ if (tabs > m_tabLimit)
{
SimplePopup *popup = SimplePopup::createPopup();
popup->setTitle("Too many tabs open");
void SimpleUI::onNetworkError()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if(!m_networkErrorPopup){
+ if (!m_networkErrorPopup) {
m_networkErrorPopup = SimplePopup::createPopup();
m_networkErrorPopup->setTitle("Network Error");
m_networkErrorPopup->addButton(CONNECT);
m_networkErrorPopup = 0;
}
-void SimpleUI::onNetworkConnected()
-{
- if(m_networkErrorPopup){
- delete m_networkErrorPopup;
- m_networkErrorPopup = 0;
- }
-}
-
void SimpleUI::searchWebPage(std::string &text, int flags)
{
m_webEngine->searchOnWebsite(text, flags);
BROWSER_LOGD("[%s,%d],", __func__, __LINE__);
if (m_favoriteService)
{
- if( m_webEngine && !m_webEngine->getURI().empty())
+ if (m_webEngine && !m_webEngine->getURI().empty())
{
m_favoriteService->addToBookmarks(m_webEngine->getURI(), m_webEngine->getTitle(), std::string(),
m_webEngine->getSnapshotData(373, 240),
#include "WebConfirmation.h"
#include "BookmarksManager.h"
#include "Config.h"
+#include "ViewManager.h"
namespace tizen_browser{
namespace base_ui{
Evas_Object* createErrorLayout(Evas_Object* parent);
- void backEnable(bool enable);
void forwardEnable(bool enable);
void stopEnable(bool enable);
void reloadEnable(bool enable);
void bookmarkAdded();
void bookmarkDeleted();
+ void showMainUI();
void switchViewToQuickAccess();
void switchViewToWebPage();
void updateView();
void openNewTab(const std::string &uri, bool desktopMode = true);
void switchToTab(const tizen_browser::basic_webengine::TabId& tabId);
- void newTabClicked(const std::string &);
+ void newTabClicked();
void tabClicked(const tizen_browser::basic_webengine::TabId& tabId);
void closeTabsClicked(const tizen_browser::basic_webengine::TabId& tabId);
void tabCreated();
void onHistoryRemoved(const std::string& uri);
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 onClearHistoryClicked();
- void onMostVisitedClicked(const std::string&);
- void onBookmarkButtonClicked(const std::string&);
- void onBookmarkManagerButtonClicked(const std::string&);
+ void onMostVisitedClicked();
+ void onBookmarkButtonClicked();
void handleConfirmationRequest(basic_webengine::WebConfirmationPtr webConfirmation);
void authPopupButtonClicked(PopupButtons button, std::shared_ptr<PopupData> popupData);
*/
void deleteBookmark(void);
- void showHistory();
- void hideHistory();
-
void showTabUI();
- void closeTabUI(const std::string& str);
+ void closeTabUI();
void showMoreMenu();
- void closeMoreMenu(const std::string& str);
+ void closeMoreMenu();
void switchToMobileMode();
void switchToDesktopMode();
- void showHistoryUI(const std::string& str);
+ void showHistoryUI();
void closeHistoryUI();
void showURIBar();
void hideURIBar();
void hideSettingsMenu();
- void showSettingsUI(const std::string&);
- void closeSettingsUI(const std::string&);
-
- void closeBookmarkManagerMenu(const std::string& str);
- void showBookmarkManagerMenu();
+ void showSettingsUI();
+ void closeSettingsUI();
+ void closeBookmarkManagerUI();
+ void showBookmarkManagerUI();
void showPopup(Evas_Object *content, char* btn1_text, char* btn2_text);
void settingsDeleteData();
void settingsDeleteFavorite();
void settingsDeleteSelectedData(const std::string& str);
- void settingsResetMostVisited(const std::string& str);
- void settingsResetBrowser(const std::string& str);
+ void settingsResetMostVisited();
+ void settingsResetBrowser();
void onDeleteSelectedDataButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
void onDeleteMostVisitedButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
void onResetBrowserButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
int tabsCount();
void onNetworkError();
- void onNetworkConnected();
void onNetErrorButtonPressed(PopupButtons, std::shared_ptr<PopupData>);
void onReturnPressed(MenuButton *m);
void onBackPressed();
- boost::signals2::signal<void ()> hidePopup;
-
std::string edjePath(const std::string &);
Evas_Object *m_popup;
int m_tabLimit;
int m_favoritesLimit;
bool m_wvIMEStatus;
+
+ //helper object used to view management
+ ViewManager* m_viewManager;
+
// This context object is used to implicitly init internal ewk data used by opengl to create the first and
// consecutive webviews in the application, otherwise we would encounter a crash after creating
// the first web view
*/
#include <Elementary.h>
+#include <Ecore.h>
+#include <Ecore_Wayland.h>
+#include <string>
#include "ViewManager.h"
#include "core/BrowserLogger.h"
namespace base_ui{
ViewManager::ViewManager(Evas_Object* parentWindow)
- :m_mainLayout(nullptr)
- ,m_previousTop(nullptr)
+ : m_mainLayout(nullptr)
+ , m_parentWindow(parentWindow)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(parentWindow);
m_mainLayout = elm_layout_add(parentWindow);
evas_object_size_hint_weight_set(m_mainLayout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set (m_mainLayout, EVAS_HINT_FILL, EVAS_HINT_FILL);
- if(!elm_object_style_set (m_mainLayout,"content-back"))
- BROWSER_LOGD("[%s:%d] elm_object_style_set falied.",__PRETTY_FUNCTION__, __LINE__);
+
+ Eina_Bool ret = elm_layout_file_set(m_mainLayout,
+ (std::string(EDJE_DIR)
+ + std::string("SimpleUI/ViewManager.edj")).c_str(),
+ "main_layout");
+ if (!ret)
+ BROWSER_LOGD("[%s:%d] elm_layout_file_set falied !!!",__PRETTY_FUNCTION__, __LINE__);
+
elm_win_resize_object_add(parentWindow, m_mainLayout);
evas_object_show(m_mainLayout);
}
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(view);
+ interfaces::AbstractUIComponent* previousView = m_viewStack.top();
- if(!m_viewStack.empty())
- m_previousTop = m_viewStack.top();
-
- while(!m_viewStack.empty())
+ while(!m_viewStack.empty() && m_viewStack.top() != view)
{
- if (m_viewStack.top() == view)
- break;
m_viewStack.pop();
}
- updateLayout();
+ updateLayout(previousView);
+ BROWSER_LOGD("[%s:%d] new top: %p", __PRETTY_FUNCTION__, __LINE__, topOfStack());
}
void ViewManager::popTheStack()
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if(!m_viewStack.empty())
{
- m_previousTop = m_viewStack.top();
+ interfaces::AbstractUIComponent* previousView = m_viewStack.top();
m_viewStack.pop();
- updateLayout();
+ updateLayout(previousView);
}
+ BROWSER_LOGD("[%s:%d] new top: %p", __PRETTY_FUNCTION__, __LINE__, topOfStack());
}
void ViewManager::pushViewToStack(interfaces::AbstractUIComponent* view)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+
M_ASSERT(view);
+ if (topOfStack() == view)
+ {
+ BROWSER_LOGD("[%s:%d] View %p is already on stack !!!",
+ __PRETTY_FUNCTION__, __LINE__, view);
+ return;
+ }
+ interfaces::AbstractUIComponent* previousView = topOfStack();
m_viewStack.push(view);
- updateLayout();
+ updateLayout(previousView);
+ BROWSER_LOGD("[%s:%d] new top: %p", __PRETTY_FUNCTION__, __LINE__, topOfStack());
}
-void ViewManager::updateLayout()
+void ViewManager::updateLayout(interfaces::AbstractUIComponent* previousView)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- Evas_Object* swallowed = elm_layout_content_get(m_mainLayout, "elm.swallow.content");
-
+ Evas_Object* swallowed = elm_layout_content_get(m_mainLayout, "content");
if (!m_viewStack.empty())
{
if (m_viewStack.top()->getContent() == swallowed)
__PRETTY_FUNCTION__, __LINE__);
return;
}
- if(m_previousTop)
- m_previousTop->hideUI();
- elm_layout_content_unset(m_mainLayout, "elm.swallow.content");
- elm_layout_content_set(m_mainLayout, "elm.swallow.content", m_viewStack.top()->getContent());
+ if(previousView)
+ previousView->hideUI();
+ elm_layout_content_unset(m_mainLayout, "content");
+ elm_layout_content_set(m_mainLayout, "content", m_viewStack.top()->getContent());
+
m_viewStack.top()->showUI();
}
else
{
BROWSER_LOGD("[%s:%d] Stack is empty!!!",__PRETTY_FUNCTION__, __LINE__);
- if(m_previousTop)
- m_previousTop->hideUI();
+ if(previousView)
+ previousView->hideUI();
- elm_layout_content_unset(m_mainLayout, "elm.swallow.content");
- elm_layout_content_set(m_mainLayout, "elm.swallow.content", nullptr);
+ elm_layout_content_unset(m_mainLayout, "content");
+ elm_layout_content_set(m_mainLayout, "content", nullptr);
}
}
return m_mainLayout;
}
+
+interfaces::AbstractUIComponent* ViewManager::topOfStack()
+{
+ if(!m_viewStack.empty())
+ return m_viewStack.top();
+ else
+ return nullptr;
+}
+
}//namespace base_ui
}//names1pace tizen_browser
*/
Evas_Object* getContent();
+/**
+ * @brief Returns actual top of stack which is dispalyed. It stack is empty
+ * returns null.
+ *
+ * @return actual dispalyed view
+ */
+ interfaces::AbstractUIComponent* topOfStack();
+
private:
- void updateLayout();
+ void updateLayout(interfaces::AbstractUIComponent* previousView);
private:
Evas_Object* m_mainLayout;
+ Evas_Object* m_parentWindow;
std::stack<interfaces::AbstractUIComponent*> m_viewStack;
- interfaces::AbstractUIComponent* m_previousTop;
};
}//namespace base_ui
--- /dev/null
+
+#########################################################################
+# Copyright (c) 2015 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.
+##########################################################################
+
+#
+# ViewManager.cpp
+#
+# Created on: Sep 22, 2015
+# Author: m.lapinski@samsung.com
+#
+
+collections {
+ group {
+ name: "main_layout";
+ parts {
+ part {
+ name: "content";
+ type: SWALLOW;
+ scale: 1;
+ description {
+ state: "default" 0.0;
+ visible: 1;
+ fixed: 1 1;
+ align: 0.0 0.0;
+ rel1 { relative: 0.0 0.0; }
+ rel2 { relative: 1.0 1.0; }
+ }
+ }
+ }
+ }
+}
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
elm_gengrid_item_class_free(m_item_class);
+ evas_object_del(m_gengrid);
}
void TabUI::createTabItemClass()
}
}
-void TabUI::show(Evas_Object* parent)
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- init(parent);
- m_tab_layout = createTabUILayout(m_parent);
- showUI();
-}
-
void TabUI::showUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_tab_layout);
evas_object_show(m_tab_layout);
- //regenerate gengrid
- m_gengrid = createGengrid(m_tab_layout);
- elm_object_part_content_set(m_tab_layout, "tab_gengrid", m_gengrid);
- evas_object_show(m_gengrid);
-
evas_object_show(elm_layout_content_get(m_tab_layout, "action_bar"));
evas_object_show(elm_layout_content_get(m_tab_layout, "top_bar"));
}
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_tab_layout);
- evas_object_hide(m_tab_layout);
-
- //delete gengrid
- evas_object_del(m_gengrid);
- m_gengrid = nullptr;
+ elm_gengrid_clear(m_gengrid);
+ m_map_tab_views.clear();
+ evas_object_hide(m_tab_layout);
evas_object_hide(elm_layout_content_get(m_tab_layout, "action_bar"));
evas_object_hide(elm_layout_content_get(m_tab_layout, "top_bar"));
}
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
M_ASSERT(m_parent);
if(!m_tab_layout)
- m_tab_layout = createTabUILayout(m_parent);
+ createTabUILayout();
return m_tab_layout;
}
-Evas_Object* TabUI::createTabUILayout(Evas_Object* parent)
+void TabUI::createTabUILayout()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ M_ASSERT(m_parent);
- Evas_Object* tab_layout = elm_layout_add(parent);
- elm_layout_file_set(tab_layout, m_edjFilePath.c_str(), "tab-layout");
- evas_object_size_hint_weight_set(tab_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- evas_object_size_hint_align_set(tab_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
+ m_tab_layout = elm_layout_add(m_parent);
+ elm_layout_file_set(m_tab_layout, m_edjFilePath.c_str(), "tab-layout");
+ evas_object_size_hint_weight_set(m_tab_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(m_tab_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
//Create button bars and put them to layout's swallows
- Evas_Object* buttonBar = createTopButtons(tab_layout);
- elm_object_part_content_set(tab_layout, "top_bar", buttonBar);
+ Evas_Object* buttonBar = createTopButtons(m_tab_layout);
+ elm_object_part_content_set(m_tab_layout, "top_bar", buttonBar);
- buttonBar = createActionBar(tab_layout);
- elm_object_part_content_set(tab_layout, "action_bar", buttonBar);
- return tab_layout;
+ buttonBar = createActionBar(m_tab_layout);
+ elm_object_part_content_set(m_tab_layout, "action_bar", buttonBar);
+
+ m_gengrid = createGengrid(m_tab_layout);
+ elm_object_part_content_set(m_tab_layout, "tab_gengrid", m_gengrid);
}
Evas_Object* TabUI::createGengrid(Evas_Object* parent)
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
TabUI * tabUI = static_cast<TabUI*>(data);
- tabUI->closeTabUIClicked(std::string());
- tabUI->clearItems();
+ tabUI->closeTabUIClicked();
tabUI->editMode = false;
tabUI->onOtherDevicesSwitch = false;
}
}
-void TabUI::hide()
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- evas_object_hide(elm_layout_content_get(m_tab_layout, "action_bar"));
- evas_object_hide(elm_layout_content_get(m_tab_layout, "top_bar"));
- evas_object_hide(elm_layout_content_get(m_tab_layout, "tab_gengrid"));
- evas_object_hide(m_tab_layout);
-}
-
Evas_Object* TabUI::createTopButtons(Evas_Object* parent)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
TabUI* tabUI = static_cast<TabUI*>(data);
- tabUI->clearItems();
- tabUI->newTabClicked(std::string());
+ tabUI->newTabClicked();
tabUI->editMode = false;
tabUI->onOtherDevicesSwitch = false;
}
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
TabUI* tabUI = static_cast<TabUI*>(data);
- tabUI->clearItems();
- tabUI->newIncognitoTabClicked(std::string());
+ tabUI->newIncognitoTabClicked();
tabUI->editMode = false;
tabUI->onOtherDevicesSwitch = false;
}
}
-void TabUI::_closetabs_clicked(void* data, Evas_Object* obj, void*)
+void TabUI::_closetabs_clicked(void* data, Evas_Object*, void*)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
TabItemData *itemData = static_cast<TabItemData*>(data);
const char *part_name1 = "tab_thumbnail";
static const int part_name1_len = strlen(part_name1);
- const char *part_name2 = "tab_thumbButton";
- static const int part_name2_len = strlen(part_name2);
if (!strncmp(part_name1, part, part_name1_len)) {
if (itemData->item->getThumbnail()) {
if (data) {
TabItemData *itemData = static_cast<TabItemData*>(data);
if (!itemData->tabUI->editMode) {
- itemData->tabUI->clearItems();
itemData->tabUI->tabClicked(itemData->item->getId());
} else {
itemData->tabUI->closeTabsClicked(itemData->item->getId());
elm_gengrid_realized_items_update(itemData->tabUI->m_gengrid);
int tabsNumber = *(itemData->tabUI->tabsCount());
BROWSER_LOGD("%s:%d %s, items: %d", __FILE__, __LINE__, __func__, tabsNumber);
- if (!tabsNumber)
- itemData->tabUI->hide();
}
}
}
-void TabUI::clearItems()
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- hide();
- elm_gengrid_clear(m_gengrid);
- m_map_tab_views.clear();
-}
-
Evas_Object* TabUI::createNoHistoryLabel()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
item->tabUI->closeTabsClicked(item->item->getId());
it = elm_gengrid_item_next_get(it);
}
- hide();
+ closeTabUIClicked();
}
+
void TabUI::setEmptyGengrid(bool setEmpty)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
}
}
-void TabUI::_focus_in(void * data, Evas*, Evas_Object * obj, void * event_info)
+void TabUI::_focus_in(void* data, Evas*, Evas_Object*, void* event_info)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
Evas_Event_Mouse_In* ee = (Evas_Event_Mouse_In*)event_info;
void init(Evas_Object *parent);
Evas_Object* getContent();
- void show(Evas_Object *parent);
virtual std::string getName();
- void clearItems();
- void hide();
- void addTabItem(std::shared_ptr<tizen_browser::basic_webengine::TabContent>);
void addTabItems(std::vector<std::shared_ptr<tizen_browser::basic_webengine::TabContent> > items);
boost::signals2::signal<void (const tizen_browser::basic_webengine::TabId&)> tabClicked;
- boost::signals2::signal<void (const std::string & )> newTabClicked;
- boost::signals2::signal<void (const std::string & )> newIncognitoTabClicked;
+ boost::signals2::signal<void ()> newTabClicked;
+ boost::signals2::signal<void ()> newIncognitoTabClicked;
boost::signals2::signal<void (const tizen_browser::basic_webengine::TabId&)> closeTabsClicked;
boost::signals2::signal<void (const std::string & )> openedTabsClicked;
boost::signals2::signal<void (const std::string & )> onOtherDevicesClicked;
- boost::signals2::signal<void (const std::string & )> closeTabUIClicked;
+ boost::signals2::signal<void ()> closeTabUIClicked;
boost::signals2::signal<int () > tabsCount;
private:
static void _onotherdevices_clicked(void * data, Evas_Object * obj, void * event_info);
static void _focus_in(void * data, Evas*, Evas_Object * obj, void * event_info);
- Evas_Object* createTabUILayout(Evas_Object* parent);
+ void createTabUILayout();
Evas_Object* createActionBar(Evas_Object* parent);
Evas_Object* createGengrid(Evas_Object* parent);
Evas_Object* createTopButtons(Evas_Object* parent);
Evas_Object* createNoHistoryLabel();
void createTabItemClass();
void closeAllTabs();
+ void addTabItem(std::shared_ptr<tizen_browser::basic_webengine::TabContent>);
Evas_Object *m_tab_layout;
Evas_Object *m_gengrid;
bool hasFocus() const;
void setDisabled(bool disabled);
+ void editingCanceled();
private:
static void activated(void* data, Evas_Object* obj, void* event_info);
static void _uriEntryBtnClicked(void* data, Evas_Object* obj, void* event_info);
void editingCompleted();
- void editingCanceled();
-
void selectWholeText();
/**
void WebPageUI::showUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ M_ASSERT(m_mainLayout);
+ evas_object_show(m_mainLayout);
+
+ evas_object_show(elm_object_part_content_get(m_mainLayout, "web_view"));
+ evas_object_show(m_URIEntry->getContent());
+ evas_object_show(elm_object_part_content_get(m_mainLayout, "uri_bar_buttons_left"));
+ evas_object_show(elm_object_part_content_get(m_mainLayout, "uri_bar_buttons_right"));
+
+ // set custom focus chain
+ elm_object_focus_custom_chain_unset(m_mainLayout);
+ elm_object_focus_custom_chain_append(m_mainLayout, m_rightButtonBar->getContent(), NULL);
+ if (!isHomePageActive())
+ elm_object_focus_custom_chain_append(m_mainLayout, m_leftButtonBar->getContent(), NULL);
+ elm_object_focus_custom_chain_append(m_mainLayout, m_URIEntry->getContent(), NULL);
+
+ if (m_homePageActive) {
+ m_URIEntry->setFocus();
+ showMainUI();
+ } else {
+ elm_object_focus_set(elm_object_part_content_get(m_mainLayout, "web_view"), EINA_TRUE);
+ }
}
+
void WebPageUI::hideUI()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ M_ASSERT(m_mainLayout);
elm_object_focus_custom_chain_unset(m_mainLayout);
+ evas_object_hide(m_mainLayout);
+
+ if (m_homePageActive)
+ hideMainUI();
+
+ evas_object_hide(elm_object_part_content_get(m_mainLayout, "web_view"));
+ m_URIEntry->editingCanceled();
+ evas_object_hide(m_URIEntry->getContent());
+ evas_object_hide(elm_object_part_content_get(m_mainLayout, "uri_bar_buttons_left"));
+ evas_object_hide(elm_object_part_content_get(m_mainLayout, "uri_bar_buttons_right"));
}
void WebPageUI::loadStarted()
hideWebView();
elm_object_part_content_set(m_mainLayout, "web_view", content);
evas_object_show(content);
-
- // set custom focus chain
- elm_object_focus_custom_chain_unset(m_mainLayout);
- elm_object_focus_custom_chain_append(m_mainLayout, m_rightButtonBar->getContent(), NULL);
- if (!isHomePageActive())
- elm_object_focus_custom_chain_append(m_mainLayout, m_leftButtonBar->getContent(), NULL);
- elm_object_focus_custom_chain_append(m_mainLayout, m_URIEntry->getContent(), NULL);
}
void WebPageUI::switchViewToErrorPage()
void WebPageUI::switchViewToWebPage(Evas_Object* content, const std::string uri)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- m_homePageActive = false;
+ if (m_homePageActive)
+ {
+ hideMainUI();
+ m_homePageActive = false;
+ }
setMainContent(content);
evas_object_show(m_leftButtonBar->getContent());
updateURIBar(uri);
void WebPageUI::switchViewToQuickAccess(Evas_Object* content)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+
+ if (m_homePageActive)
+ return;
+
m_homePageActive = true;
setMainContent(content);
+ showMainUI();
m_URIEntry->changeUri("");
m_leftButtonBar->setActionForButton("refresh_stop_button", m_reload);
elm_object_signal_emit(m_mainLayout, "shiftback_uri", "ui");
elm_object_signal_emit(m_URIEntry->getContent(), "shiftback_uribg", "ui");
hideProgressBar();
+ m_URIEntry->setFocus();
}
void WebPageUI::faviconClicked(void* data, Evas_Object*, const char*, const char*)
void WebPageUI::hideWebView()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+
evas_object_hide(elm_object_part_content_get(m_mainLayout, "web_view"));
elm_object_part_content_unset(m_mainLayout, "web_view");
}
}
} // namespace tizen_browser
-} // namespace base_ui
\ No newline at end of file
+} // namespace base_ui
boost::signals2::signal<void ()> reloadPage;
boost::signals2::signal<void ()> showTabUI;
boost::signals2::signal<void ()> showMoreMenu;
+ boost::signals2::signal<void ()> hideMainUI;
+ boost::signals2::signal<void ()> showMainUI;
static void faviconClicked(void* data, Evas_Object* obj, const char* emission, const char* source);
+
private:
void createLayout();
void createErrorLayout();
projects / profile / tv / apps / web / browser.git / commitdiff