{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data) {
- BookmarkManagerUI* bookmarkManagerUI = static_cast<BookmarkManagerUI*>(data);
- bookmarkManagerUI->onBackPressed();
+ auto self = static_cast<BookmarkManagerUI*>(data);
+ self->onBackPressed();
} else
BROWSER_LOGW("[%s] data = nullptr", __PRETTY_FUNCTION__);
}
break;
case BookmarkManagerState::SelectFolder:
bookmarkManagerUI->folderSelected(bookmarkManagerUI->m_folder_path.back());
- break;
+ break;
+ case BookmarkManagerState::HistoryDeleteView:
+ bookmarkManagerUI->removeHistoryItems();
+ break;
default:
break;
}
BROWSER_LOGW("[%s] data = nullptr", __PRETTY_FUNCTION__);
}
+void BookmarkManagerUI::removeHistoryItems()
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+
+ auto historyListSize = elm_genlist_items_count(m_historyGenlist);
+
+ for (int i = historyListSize; i > 1; --i) {
+ auto it = elm_genlist_nth_item_get(m_historyGenlist, i);
+ auto check = elm_object_item_part_content_get(it, "elm.swallow.end");
+ if (!check)
+ continue;
+ auto state = elm_check_state_get(check);
+ if (state == EINA_TRUE) {
+ elm_object_item_del(it);
+ }
+ }
+ elm_genlist_realized_items_update(m_historyGenlist);
+ removeSelectedItemsFromHistory();
+ m_naviframe->setRightButtonEnabled(false);
+
+}
void BookmarkManagerUI::_prev_clicked(void* data, Evas_Object*, void*)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
void BookmarkManagerUI::addBookmarkItem(BookmarkData* item)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- Elm_Object_Item* bookmarkView = elm_genlist_item_append(m_genlist, m_bookmark_item_class,
- item, nullptr, ELM_GENLIST_ITEM_NONE, _bookmarkItemClicked, item);
- m_map_bookmark.insert(std::pair<unsigned int, Elm_Object_Item*>(item->bookmarkItem->getId(), bookmarkView));
+ Elm_Object_Item* bookmarkView = elm_genlist_item_append(
+ m_genlist,
+ m_bookmark_item_class,
+ item,
+ nullptr,
+ ELM_GENLIST_ITEM_NONE,
+ _bookmarkItemClicked,
+ item);
+ m_map_bookmark.insert(
+ std::pair<unsigned int, Elm_Object_Item*>(item->bookmarkItem->getId(), bookmarkView));
elm_genlist_item_selected_set(bookmarkView, EINA_FALSE);
}
//TODO: We should go to the previous navigatorToolbar element if it exists.
closeBookmarkManagerClicked();
break;
+ case BookmarkManagerState::HistoryDeleteView:
+ changeState(BookmarkManagerState::HistoryView);
+ prepareHistoryContent();
+ break;
case BookmarkManagerState::HistoryView:
elm_toolbar_item_selected_set(
elm_toolbar_first_item_get(m_modulesToolbar),
alignContextMenu(*window);
} else if (m_state == BookmarkManagerState::HistoryView) {
createContextMenu(*window);
- elm_ctxpopup_item_append(m_ctxpopup, _("IDS_BR_OPT_REMOVE"), nullptr, nullptr, nullptr);
+ elm_ctxpopup_item_append(m_ctxpopup, _("IDS_BR_OPT_REMOVE"), nullptr, _cm_history_remove_clicked, this);
alignContextMenu(*window);
}
} else
BROWSER_LOGE("[%s:%d] Signal not found", __PRETTY_FUNCTION__, __LINE__);
}
+void BookmarkManagerUI::_cm_history_remove_clicked(void* data, Evas_Object*, void*)
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ if (data) {
+ auto bookmarkManagerUI = static_cast<BookmarkManagerUI*>(data);
+ _cm_dismissed(nullptr, bookmarkManagerUI->m_ctxpopup, nullptr);
+ bookmarkManagerUI->changeState(BookmarkManagerState::HistoryDeleteView);
+ bookmarkManagerUI->prepareHistoryContent();
+ } else
+ BROWSER_LOGW("[%s] data = nullptr", __PRETTY_FUNCTION__);
+}
+
void BookmarkManagerUI::_cm_delete_clicked(void* data, Evas_Object*, void* )
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- auto historyGenlist = getHistoryGenlistContent(m_box);
+ bool removeMode = (m_state == BookmarkManagerState::HistoryDeleteView);
+ auto historyGenlist = getHistoryGenlistContent(m_box, m_naviframe, removeMode);
+
elm_box_unpack_all(m_box);
if (historyGenlist && *historyGenlist) {
elm_object_part_content_unset(m_content, "navigator_toolbar");
elm_object_signal_emit(m_content, "hide_navigator_toolbar", "ui");
evas_object_show(m_modulesToolbar);
- elm_genlist_reorder_mode_set(m_genlist, EINA_FALSE);
elm_box_unpack(m_box, m_select_all);
evas_object_hide(m_select_all);
break;
+ case BookmarkManagerState::HistoryDeleteView:
+ updateNoBookmarkText();
+ m_naviframe->setTitle(_("IDS_BR_MBODY_HISTORY"));
+ m_naviframe->setPrevButtonVisible(false);
+ m_naviframe->setLeftButtonVisible(true);
+ m_naviframe->setRightButtonVisible(true);
+ m_naviframe->setRightButtonText(_("IDS_BR_SK_DELETE"));
+ updateDeleteTopContent();
+ elm_object_signal_emit(m_content, "hide_toolbars", "ui");
+ evas_object_hide(m_modulesToolbar);
+ evas_object_hide(m_navigatorToolbar);
+ break;
case BookmarkManagerState::Default:
default:
updateNoBookmarkText();
void BookmarkManagerUI::updateNoBookmarkText()
{
- if (m_map_bookmark.size() || m_state == BookmarkManagerState::HistoryView) {
+ if (m_map_bookmark.size() ||
+ (m_state == BookmarkManagerState::HistoryView || m_state == BookmarkManagerState::HistoryDeleteView)) {
evas_object_hide(m_empty_layout);
elm_object_signal_emit(m_content, "hide_overlay", "ui");
} else {
{
m_delete_count -= m_map_delete[id] ? 1 : -1;
m_map_delete[id] = !m_map_delete[id];
- elm_check_state_set(elm_object_part_content_get(m_select_all, "elm.swallow.end"), m_delete_count
- == elm_genlist_items_count(m_genlist));
+ elm_check_state_set(
+ elm_object_part_content_get(m_select_all, "elm.swallow.end"),
+ m_delete_count == elm_genlist_items_count(m_genlist));
updateDeleteTopContent();
}
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::BookmarkItem>)> bookmarkItemOrderEdited;
boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::BookmarkItem>)> bookmarkItemDeleted;
boost::signals2::signal<void (int)> newFolderItemClicked;
- boost::signals2::signal<Evas_Object* (Evas_Object*)> getHistoryGenlistContent;
+ boost::signals2::signal<Evas_Object* (Evas_Object*, SharedNaviframeWrapper, bool)> getHistoryGenlistContent;
+ boost::signals2::signal<void (void)> removeSelectedItemsFromHistory;
private:
using FolderData = struct
void updateNoBookmarkText();
void updateDeleteClick(int id);
void updateDeleteTopContent();
+ void removeHistoryItems();
void prepareHistoryContent();
void prepareBookmarksContent();
static void _genlist_bookmark_realized(void *, Evas_Object *, void *event_info);
static void _select_all_down(void *data, Evas *, Evas_Object *, void *);
static void _select_all_state_changed(void *data, Evas_Object *obj, void *);
+ static void _cm_history_remove_clicked(void*, Evas_Object*, void*);
static void _cm_delete_clicked(void*, Evas_Object*, void*);
static void _cm_share_clicked(void*, Evas_Object*, void*);
static void _cm_reorder_clicked(void*, Evas_Object*, void*);
{
public:
virtual ~HistoryDaysListManager() {}
- virtual Evas_Object* createDaysList(Evas_Object* parentLayout) = 0;
+ virtual Evas_Object* createDaysList(Evas_Object* parentLayout, bool isRemoveMode) = 0;
virtual void addHistoryItems(const std::shared_ptr<services::HistoryItemVector>& items, HistoryPeriod period) = 0;
// clear everything including efl objects (result: empty list)
virtual void clear() = 0;
virtual void setFocusChain(Evas_Object* obj) = 0;
+ virtual void removeSelectedItems() = 0;
+ virtual bool isSelectAllChecked() const = 0;
boost::signals2::signal<void (std::string url, std::string title)> signalHistoryItemClicked;
- boost::signals2::signal<void (std::shared_ptr<const std::vector<int>> itemIds)> signalDeleteHistoryItems;
+ boost::signals2::signal<void (int)> signalDeleteHistoryItems;
+ boost::signals2::signal<void (bool)> setRightButtonEnabledForHistory;
+ boost::signals2::signal<void (int)> setSelectedItemsCount;
};
}
#include "app_i18n.h"
#include <services/HistoryUI/HistoryDeleteManager.h>
-
#include <GeneralTools.h>
#include <EflTools.h>
, m_history_day_item_class(elm_genlist_item_class_new())
, m_history_item_item_class(elm_genlist_item_class_new())
, m_history_download_item_class(elm_genlist_item_class_new())
+ , m_isRemoveMode(false)
+ , m_delete_count(0)
+ , m_history_count(0)
+ , m_isSelectAllChecked(EINA_FALSE)
+ , m_downloadManagerItem(nullptr)
+ , m_selectAllItem(nullptr)
{
createGenlistItemClasses();
connectSignals();
HistoryDaysListManagerMob::~HistoryDaysListManagerMob()
{
+ for (auto& data : m_itemDataVector)
+ delete data;
+
for (auto& dayItem : m_dayItems)
dayItem->setEflObjectsAsDeleted();
m_history_download_item_class->item_style = "type1";
m_history_download_item_class->func.text_get = _genlist_history_download_text_get;
- m_history_download_item_class->func.content_get = nullptr;
+ m_history_download_item_class->func.content_get = _genlist_history_download_content_get;
m_history_download_item_class->func.state_get = nullptr;
m_history_download_item_class->func.del = nullptr;
m_history_download_item_class->decorate_all_item_style = "edit_default";
char* HistoryDaysListManagerMob::_genlist_history_day_text_get(void* data, Evas_Object *, const char *part)
{
if (data && part) {
- auto item = static_cast<HistoryDayItemData*>(data);
+ auto item(static_cast<HistoryDayItemData*>(data));
if (!strcmp(part, "elm.text"))
return strdup(item->day.c_str());
}
return nullptr;
}
+Evas_Object* HistoryDaysListManagerMob::_genlist_history_download_content_get(void* data, Evas_Object* obj, const char *part)
+{
+ if (data && part && !strcmp(part, "elm.swallow.end")) {
+ auto id(static_cast<ItemData*>(data));
+ if (id->self->m_isRemoveMode) {
+ auto check(elm_check_add(obj));
+ evas_object_smart_callback_add(check, "changed", _check_state_changed, id);
+ return check;
+ }
+ }
+ return nullptr;
+}
+
+void HistoryDaysListManagerMob::countItemsToDelete()
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ m_delete_count = 0;
+ auto it(elm_genlist_first_item_get(m_genlist));
+ while ((it = elm_genlist_item_next_get(it))) {
+ auto check(elm_object_item_part_content_get(it, "elm.swallow.end"));
+ if (!check)
+ continue;
+ auto state(elm_check_state_get(check));
+ m_itemsToDelete[it] = state;
+ if (state == EINA_TRUE)
+ ++m_delete_count;
+ if (m_delete_count == m_history_count) {
+ auto first(elm_genlist_first_item_get(m_genlist));
+ auto firstCheck(elm_object_item_part_content_get(first, "elm.swallow.end"));
+ elm_check_state_set(firstCheck, EINA_TRUE);
+ }
+ if (it == elm_genlist_last_item_get(m_genlist) &&
+ m_delete_count == 0) {
+ auto first(elm_genlist_first_item_get(m_genlist));
+ auto firstCheck(elm_object_item_part_content_get(first, "elm.swallow.end"));
+ elm_check_state_set(firstCheck, EINA_FALSE);
+ }
+ }
+ setSelectedItemsCount(m_delete_count);
+ setRightButtonEnabledForHistory(m_delete_count);
+}
+
+void HistoryDaysListManagerMob::selectAllCheckboxes()
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ auto it(elm_genlist_first_item_get(m_genlist));
+ auto firstCheck(elm_object_item_part_content_get(it, "elm.swallow.end"));
+ m_isSelectAllChecked = elm_check_state_get(firstCheck);
+
+ while ((it = elm_genlist_item_next_get(it))) {
+ auto check(elm_object_item_part_content_get(it, "elm.swallow.end"));
+ if (!check)
+ continue;
+ elm_check_state_set(check, m_isSelectAllChecked);
+ }
+ if (m_isSelectAllChecked == EINA_TRUE && elm_genlist_items_count(m_genlist) > 1)
+ m_delete_count = m_history_count;
+ if (m_isSelectAllChecked == EINA_FALSE)
+ m_delete_count = 0;
+ setSelectedItemsCount(m_delete_count);
+ setRightButtonEnabledForHistory(m_delete_count);
+}
+
+void HistoryDaysListManagerMob::_check_state_changed(void* data, Evas_Object* obj, void*)
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ if (data) {
+ auto id(static_cast<ItemData*>(data));
+ auto first(elm_genlist_first_item_get(id->self->m_genlist));
+ auto check(elm_object_item_part_content_get(first, "elm.swallow.end"));
+
+ if (check == obj)
+ id->self->selectAllCheckboxes();
+ else
+ id->self->countItemsToDelete();
+ } else
+ BROWSER_LOGW("[%s] data = nullptr", __PRETTY_FUNCTION__);
+}
+
char* HistoryDaysListManagerMob::_genlist_history_download_text_get(void* data, Evas_Object*, const char *part)
{
if (data && part && !strcmp(part, "elm.text")) {
- auto str = static_cast<const char*>(data);
- return strdup(str);
+ auto id(static_cast<ItemData*>(data));
+ return strdup(id->str);
}
return nullptr;
}
char* HistoryDaysListManagerMob::_genlist_history_item_text_get(void* data, Evas_Object *, const char *part)
{
if (data && part) {
- auto item = static_cast<WebsiteHistoryItemData*>(data);
+ auto item(static_cast<ItemData*>(data));
if (!strcmp(part, "elm.text"))
return strdup(item->websiteVisitItem->historyItem->getTitle().c_str());
if (!strcmp(part, "elm.text.sub"))
Evas_Object* HistoryDaysListManagerMob::_genlist_history_day_content_get(void* data, Evas_Object* obj, const char *part)
{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (data && part && !strcmp(part, "elm.swallow.end")) {
- auto dayData = static_cast<HistoryDayItemData*>(data);
+ auto dayData(static_cast<HistoryDayItemData*>(data));
- auto arrow_layout = elm_layout_add(obj);
- auto edjeDir = EDJE_DIR + std::string("HistoryUI/HistoryDaysList.edj");
+ auto arrow_layout(elm_layout_add(obj));
+ auto edjeDir(EDJE_DIR + std::string("HistoryUI/HistoryDaysList.edj"));
elm_layout_file_set(arrow_layout, edjeDir.c_str(), "arrow-layout");
- auto edje = elm_layout_edje_get(arrow_layout);
+ auto edje(elm_layout_edje_get(arrow_layout));
edje_object_signal_emit(edje, "state,contracted,signal", "");
- if(dayData->expanded)
+ if (dayData->expanded)
edje_object_signal_emit(edje, "state,expanded,signal", "");
return arrow_layout;
Evas_Object* HistoryDaysListManagerMob::_genlist_history_item_content_get(void *data, Evas_Object* obj, const char *part)
{
if (data && !strcmp(part, "elm.swallow.icon")) {
- auto item = static_cast<WebsiteHistoryItemData*>(data);
- auto icon = item->favIcon->getEvasImage(obj);
+ auto item(static_cast<ItemData*>(data));
+ auto favicon(item->websiteHistoryItemData->favIcon);
+ if (!favicon) {
+ auto no_icon(elm_icon_add(obj));
+ elm_image_resizable_set(no_icon, EINA_TRUE, EINA_TRUE);
+ evas_object_size_hint_min_set(no_icon,
+ ELM_SCALE_SIZE(64),
+ ELM_SCALE_SIZE(64));
+ evas_object_size_hint_max_set(no_icon,
+ ELM_SCALE_SIZE(64),
+ ELM_SCALE_SIZE(64));
+ return no_icon;
+ }
+ auto icon(favicon->getEvasImage(obj));
elm_image_resizable_set(icon, EINA_TRUE, EINA_TRUE);
evas_object_size_hint_min_set(icon,
ELM_SCALE_SIZE(64),
ELM_SCALE_SIZE(64));
return icon;
} else if (!data && !strcmp(part, "elm.swallow.icon")) {
- auto icon = elm_icon_add(obj);
+ auto icon(elm_icon_add(obj));
elm_image_resizable_set(icon, EINA_TRUE, EINA_TRUE);
evas_object_size_hint_min_set(icon,
ELM_SCALE_SIZE(64),
ELM_SCALE_SIZE(64));
return icon;
}
+ if (data && !strcmp(part, "elm.swallow.end")) {
+ auto check(elm_check_add(obj));
+ auto item(static_cast<ItemData*>(data));
+ if (item->self->m_isRemoveMode){
+ elm_genlist_select_mode_set(obj, ELM_OBJECT_SELECT_MODE_NONE);
+ evas_object_smart_callback_add(check, "changed", _check_state_changed, data);
+ if (item->self->m_selectAllItem &&
+ item->self->m_isSelectAllChecked == EINA_TRUE) {
+ auto firstCheck(elm_object_item_part_content_get(item->self->m_selectAllItem, "elm.swallow.end"));
+ elm_check_state_set(firstCheck, item->self->m_isSelectAllChecked);
+ }
+ elm_check_state_set(check, item->self->m_isSelectAllChecked);
+ return check;
+ } else {
+ evas_object_smart_callback_del(check, "changed", _check_state_changed);
+ elm_genlist_select_mode_set(obj, ELM_OBJECT_SELECT_MODE_ALWAYS);
+ }
+ }
return nullptr;
}
Evas_Object* HistoryDaysListManagerMob::createDaysList(
- Evas_Object* parent)
+ Evas_Object* parent, bool isRemoveMode)
{
+ // TODO Download history is planed for the 2nd phase
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_parent = parent;
+
+ m_isRemoveMode = isRemoveMode;
+ if (m_genlist) {
+ elm_genlist_clear(m_genlist);
+ evas_object_del(m_genlist);
+ m_genlist = nullptr;
+ }
m_genlist = elm_genlist_add(m_parent);
tools::EflTools::setExpandHints(m_genlist);
elm_scroller_policy_set(m_genlist, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
evas_object_smart_callback_add(m_genlist, "expanded", _tree_item_expanded, this);
evas_object_smart_callback_add(m_genlist, "contracted", _tree_item_contracted, this);
evas_object_smart_callback_add(m_genlist, "pressed", _tree_item_pressed, this);
-
- // TODO Download history is planed for the 2nd phase
- auto el = elm_genlist_item_append(
- m_genlist, m_history_download_item_class,
- _("IDS_BR_BODY_DOWNLOAD_HISTORY"),
- nullptr, ELM_GENLIST_ITEM_NONE,
- nullptr, nullptr);
- elm_object_item_disabled_set(el, EINA_TRUE);
-
- evas_object_show(m_genlist);
-
+ m_history_count = 0;
+ auto id(new ItemData);
+ id->self = this;
+ id->websiteVisitItem = nullptr;
+ id->websiteHistoryItemData = nullptr;
+ id->str = nullptr;
+ if (!m_isRemoveMode) {
+ id->str = _("IDS_BR_BODY_DOWNLOAD_HISTORY");
+ m_downloadManagerItem = elm_genlist_item_append(
+ m_genlist, m_history_download_item_class,
+ id,
+ nullptr, ELM_GENLIST_ITEM_NONE,
+ nullptr, nullptr);
+ elm_object_item_disabled_set(m_downloadManagerItem, EINA_TRUE);
+ } else {
+ id->str = _("IDS_BR_OPT_SELECT_ALL");
+ m_selectAllItem = elm_genlist_item_append(
+ m_genlist, m_history_download_item_class,
+ id,
+ nullptr, ELM_GENLIST_ITEM_NONE,
+ nullptr, nullptr);
+ }
+ m_itemDataVector.push_back(id);
return m_genlist;
}
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
std::vector<WebsiteHistoryItemDataPtr> historyItems;
for (auto& item : *items) {
- auto pageViewItem = std::make_shared<WebsiteVisitItemData>(item);
- std::shared_ptr<tools::BrowserImage> websiteFavicon = item->getFavIcon();
+ auto pageViewItem(std::make_shared<WebsiteVisitItemData>(item));
+ auto websiteFavicon(item->getFavIcon());
if (!websiteFavicon || websiteFavicon->getSize() == 0)
websiteFavicon = nullptr;
historyItems.push_back(
item->getUrl(),
websiteFavicon,
pageViewItem));
+ ++m_history_count;
}
auto dayItem(std::make_shared<HistoryDayItemData>(toString(period), historyItems));
appendDayItem(dayItem);
void HistoryDaysListManagerMob::connectSignals()
{
- HistoryDayItemMob::signaButtonClicked.connect(
- boost::bind(&HistoryDaysListManagerMob::onHistoryDayItemButtonClicked,
- this, _1, _2));
- WebsiteHistoryItemTitleMob::signalButtonClicked.connect(
- boost::bind(&HistoryDaysListManagerMob::onWebsiteHistoryItemClicked,
- this, _1, _2));
WebsiteHistoryItemVisitItemsMob::signalButtonClicked.connect(
boost::bind(
&HistoryDaysListManagerMob::onWebsiteHistoryItemVisitItemClicked,
BROWSER_LOGD("[%s:%d] data is null", __PRETTY_FUNCTION__, __LINE__);
return;
}
- auto it = static_cast<Elm_Object_Item*>(event_info);
- auto self = static_cast<HistoryDaysListManagerMob*>(data);
-
+ auto it(static_cast<Elm_Object_Item*>(event_info));
+ auto self(static_cast<HistoryDaysListManagerMob*>(data));
for (auto& el : self->m_itemData[it]->websiteHistoryItems) {
- auto itData = new ItemData;
- itData->historyDaysListManager = self;
+ auto itData(new ItemData);
+ itData->self = self;
itData->websiteVisitItem = el->websiteVisitItem;
- elm_genlist_item_append(
- genlist,
- self->m_history_item_item_class,
- el.get(),
- it,
- ELM_GENLIST_ITEM_NONE,
- _item_selected,
- itData);
+ itData->websiteHistoryItemData = el;
+ itData->str = nullptr;
+ auto listItem(
+ elm_genlist_item_append(
+ genlist,
+ self->m_history_item_item_class,
+ itData,
+ it,
+ ELM_GENLIST_ITEM_NONE,
+ _item_selected,
+ itData));
+ self->m_itemsToDelete[listItem] = EINA_FALSE;
+ self->m_visitItemData[listItem] = el->websiteVisitItem;
+ self->m_itemDataVector.push_back(itData);
}
self->m_itemData[it]->expanded = true;
- auto arrow_layout = elm_object_item_part_content_get(it, "elm.swallow.end");
- auto edje = elm_layout_edje_get(arrow_layout);
+ auto arrow_layout(
+ elm_object_item_part_content_get(it, "elm.swallow.end"));
+ auto edje(elm_layout_edje_get(arrow_layout));
edje_object_signal_emit(edje, "state,expanded,signal", "");
elm_genlist_realized_items_update(genlist);
}
void HistoryDaysListManagerMob::_item_selected(void* data, Evas_Object *, void *)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- auto iD = static_cast<ItemData*>(data);
- BROWSER_LOGD("[%s:%d] %s", __PRETTY_FUNCTION__, __LINE__, iD->websiteVisitItem->historyItem->getUrl().c_str());
- iD->historyDaysListManager->signalHistoryItemClicked(
+ auto iD(static_cast<ItemData*>(data));
+ iD->self->signalHistoryItemClicked(
iD->websiteVisitItem->historyItem->getUrl().c_str(),
iD->websiteVisitItem->historyItem->getTitle().c_str());
delete iD;
void HistoryDaysListManagerMob::_tree_item_pressed(void* data, Evas_Object*, void* event_info)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- auto it = static_cast<Elm_Object_Item*>(event_info);
- auto self = static_cast<HistoryDaysListManagerMob*>(data);
+ auto it(static_cast<Elm_Object_Item*>(event_info));
+ auto self(static_cast<HistoryDaysListManagerMob*>(data));
- if (self->m_itemState[it] == EINA_FALSE) {
+ if (self->m_expandedState[it] == EINA_FALSE) {
elm_genlist_item_expanded_set(it, EINA_TRUE);
- self->m_itemState[it] = EINA_TRUE;
- } else if (self->m_itemState[it] == EINA_TRUE) {
+ self->m_expandedState[it] = EINA_TRUE;
+ } else if (self->m_expandedState[it] == EINA_TRUE) {
elm_genlist_item_expanded_set(it, EINA_FALSE);
- self->m_itemState[it] = EINA_FALSE;
+ self->m_expandedState[it] = EINA_FALSE;
}
return;
}
void HistoryDaysListManagerMob::_tree_item_contracted(void* data, Evas_Object*, void* event_info)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- auto it = static_cast<Elm_Object_Item*>(event_info);
- auto self = static_cast<HistoryDaysListManagerMob*>(data);
+ auto it(static_cast<Elm_Object_Item*>(event_info));
+ auto self(static_cast<HistoryDaysListManagerMob*>(data));
elm_genlist_item_subitems_clear(it);
self->m_itemData[it]->expanded = false;
- auto arrow_layout = elm_object_item_part_content_get(it, "elm.swallow.end");
- auto edje = elm_layout_edje_get(arrow_layout);
+ auto arrow_layout(elm_object_item_part_content_get(it, "elm.swallow.end"));
+ auto edje(elm_layout_edje_get(arrow_layout));
edje_object_signal_emit(edje, "state,contracted,signal", "");
}
void HistoryDaysListManagerMob::appendDayItem(HistoryDayItemDataPtr dayItemData)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- auto item = std::make_shared<HistoryDayItemMob>(dayItemData);
+ auto item(std::make_shared<HistoryDayItemMob>(dayItemData));
m_dayItems.push_back(item);
dayItemData->expanded = false;
- auto el = elm_genlist_item_append(
+ auto el(elm_genlist_item_append(
m_genlist, m_history_day_item_class,
dayItemData.get(),
nullptr, ELM_GENLIST_ITEM_TREE,
- nullptr, nullptr);
+ nullptr, nullptr));
m_itemData[el] = dayItemData;
- m_itemState[el] = EINA_FALSE;
+ m_expandedState[el] = EINA_FALSE;
}
void HistoryDaysListManagerMob::showNoHistoryMessage(bool show)
elm_object_signal_emit(m_layoutScrollerDays, "hide_empty_message", "ui");
}
-void HistoryDaysListManagerMob::onHistoryDayItemButtonClicked(
- const HistoryDayItemDataPtrConst clickedItem, bool remove)
-{
- if (remove)
- removeItem(clickedItem);
-}
-
-void HistoryDaysListManagerMob::onWebsiteHistoryItemClicked(
- const WebsiteHistoryItemDataPtrConst clickedItem, bool remove)
-{
- if (remove)
- removeItem(clickedItem);
- else
- signalHistoryItemClicked(
- tools::PROTOCOL_DEFAULT + clickedItem->websiteDomain,
- clickedItem->websiteTitle);
-}
-
void HistoryDaysListManagerMob::onWebsiteHistoryItemVisitItemClicked(
const WebsiteVisitItemDataPtrConst clickedItem, bool remove)
{
if (remove) {
removeItem(clickedItem);
- signalDeleteHistoryItems(
- std::make_shared<std::vector<int>>(std::initializer_list<int> {
- clickedItem->historyItem->getId() }));
+ signalDeleteHistoryItems(clickedItem->historyItem->getId());
} else
- signalHistoryItemClicked(clickedItem->historyItem->getUrl(),
+ signalHistoryItemClicked(
+ clickedItem->historyItem->getUrl(),
clickedItem->historyItem->getTitle());
}
+void HistoryDaysListManagerMob::removeSelectedItems()
+{
+ BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+ if (m_isSelectAllChecked == EINA_TRUE) {
+ m_visitItemData.clear();
+ m_expandedState.clear();
+ m_itemsToDelete.clear();
+ m_history_count = 0;
+ return;
+ }
+ for (auto& x : m_itemsToDelete) {
+ if (x.second == EINA_TRUE) {
+ onWebsiteHistoryItemVisitItemClicked(
+ m_visitItemData[x.first], true);
+ x.second = EINA_FALSE;
+ m_visitItemData.erase(x.first);
+ m_expandedState.erase(x.first);
+ m_itemsToDelete.erase(x.first);
+ --m_history_count;
+ }
+ }
+}
+
void HistoryDaysListManagerMob::removeItem(
HistoryDayItemDataPtrConst historyDayItemData)
{
BROWSER_LOGE("%s remove error", __PRETTY_FUNCTION__);
return;
}
- auto item = getItem(historyDayItemData);
+ auto item(getItem(historyDayItemData));
if (!item)
return;
// remove day item from vector, destructor will clear efl objects
return;
}
for (auto& dayItem : m_dayItems) {
- auto websiteHistoryItem = dayItem->getItem(websiteHistoryItemData);
+ auto websiteHistoryItem(dayItem->getItem(websiteHistoryItemData));
if (websiteHistoryItem) {
- signalDeleteHistoryItems(websiteHistoryItem->getVisitItemsIds());
+ signalDeleteHistoryItems(websiteHistoryItem->getVisitItemsId());
dayItem->removeItem(websiteHistoryItemData);
return;
}
#include <Elementary.h>
#include <string>
#include <vector>
+#include <set>
#include "HistoryDayItemDataTypedef.h"
#include "HistoryDaysListManager.h"
#include "HistoryDaysListManagerEdje.h"
static char* _genlist_history_day_text_get(void *data, Evas_Object *, const char *part);
static char* _genlist_history_download_text_get(void* data, Evas_Object*, const char *part);
static char* _genlist_history_item_text_get(void *data, Evas_Object *, const char *part);
+ static void _check_state_changed(void*, Evas_Object*, void *);
static void _tree_item_expanded(void*, Evas_Object*, void*);
static void _tree_item_contracted(void*, Evas_Object*, void*);
static void _tree_item_pressed(void*, Evas_Object*, void*);
static void _item_selected(void *data, Evas_Object *obj, void *event_info);
+ static Evas_Object* _genlist_history_download_content_get(void*, Evas_Object* obj, const char *part);
static Evas_Object* _genlist_history_item_content_get(void *data, Evas_Object *, const char *part);
static Evas_Object* _genlist_history_day_content_get(void *data, Evas_Object* obj, const char *part);
- Evas_Object* createDaysList(Evas_Object* parent) override;
+ Evas_Object* createDaysList(Evas_Object* parent, bool isRemoveMode = false) override;
void addHistoryItems(
const std::shared_ptr<services::HistoryItemVector>& items,
HistoryPeriod period) override;
void clear() override;
void setFocusChain(Evas_Object* /*obj*/) override {}
- void onHistoryDayItemButtonClicked(
- const HistoryDayItemDataPtrConst clickedItem, bool remove);
- void onWebsiteHistoryItemClicked(
- const WebsiteHistoryItemDataPtrConst websiteHistoryItemData,
- bool remove);
void onWebsiteHistoryItemVisitItemClicked(
const WebsiteVisitItemDataPtrConst websiteVisitItemData,
bool remove);
+ void countItemsToDelete();
+ void selectAllCheckboxes();
+ void removeSelectedItems();
+ bool isSelectAllChecked() const { return m_isSelectAllChecked == EINA_TRUE; }
struct ItemData {
- HistoryDaysListManagerMob* historyDaysListManager;
+ HistoryDaysListManagerMob* self;
WebsiteVisitItemDataPtr websiteVisitItem;
+ WebsiteHistoryItemDataPtr websiteHistoryItemData;
+ const char* str;
};
private:
Elm_Genlist_Item_Class* m_history_item_item_class;
Elm_Genlist_Item_Class* m_history_download_item_class;
Evas_Object* m_genlist;
- Evas_Object* m_box;
std::map<Elm_Object_Item*, HistoryDayItemDataPtr> m_itemData;
- std::map<Elm_Object_Item*, Eina_Bool> m_itemState;
+ std::map<Elm_Object_Item*, Eina_Bool> m_expandedState;
+ std::map<Elm_Object_Item*, Eina_Bool> m_itemsToDelete;
+ std::map<Elm_Object_Item*, WebsiteVisitItemDataPtr> m_visitItemData;
+ bool m_isRemoveMode;
+ std::vector<ItemData*> m_itemDataVector;
+ size_t m_delete_count;
+ size_t m_history_count;
+ Eina_Bool m_isSelectAllChecked;
+ Elm_Object_Item* m_downloadManagerItem;
+ Elm_Object_Item* m_selectAllItem;
};
} /* namespace base_ui */
return m_websiteHistoryItemVisitItems->contains(historyVisitItemData);
}
-std::shared_ptr<std::vector<int>> WebsiteHistoryItemMob::getVisitItemsIds()
+int WebsiteHistoryItemMob::getVisitItemsId()
{
- return m_websiteHistoryItemVisitItems->getVisitItemsIds();
+ return m_websiteHistoryItemVisitItems->getVisitItemsId();
}
int WebsiteHistoryItemMob::sizeHistoryVisitItems() {
void removeItem(WebsiteVisitItemDataPtrConst historyVisitItemData);
bool contains(WebsiteVisitItemDataPtrConst websiteVisitItemData);
- std::shared_ptr<std::vector<int>> getVisitItemsIds();
+ int getVisitItemsId();
/**
* @brief invoked when main layout is already removed.
}
}
-std::shared_ptr<std::vector<int>> WebsiteHistoryItemVisitItemsMob::getVisitItemsIds()
+int WebsiteHistoryItemVisitItemsMob::getVisitItemsId()
{
- auto vec = std::make_shared<std::vector<int>>();
- vec->push_back(m_websiteVisitItem.websiteVisitItemData->historyItem->getId());
- return vec;
+ return m_websiteVisitItem.websiteVisitItemData->historyItem->getId();
}
}
bool contains(WebsiteVisitItemDataPtrConst websiteVisitItemData);
void removeItem(WebsiteVisitItemDataPtrConst websiteVisitItemData);
- std::shared_ptr<std::vector<int>> getVisitItemsIds();
+ int getVisitItemsId();
int size() {return eina_list_count(elm_box_children_get(m_boxMainVertical));}
private:
#include <Elementary.h>
#include <boost/concept_check.hpp>
+#include <boost/format.hpp>
#include <vector>
#include <string>
#include <string.h>
namespace tizen_browser{
namespace base_ui{
+// TODO History needs solid refactoring. A lot of features are not used in any place.
+
using namespace services;
EXPORT_SERVICE(HistoryUI, "org.tizen.browser.historyui")
-using HistoryItemData = struct _HistoryItemData
-{
- std::shared_ptr<tizen_browser::services::HistoryItem> item;
- std::shared_ptr<tizen_browser::base_ui::HistoryUI> historyUI;
-};
-
-struct ItemData{
- tizen_browser::base_ui::HistoryUI* historyUI;
- Elm_Object_Item * e_item;
-};
-
HistoryUI::HistoryUI()
: m_parent(nullptr)
, m_main_layout(nullptr)
, m_buttonClose(nullptr)
, m_buttonClear(nullptr)
, m_daysList(nullptr)
- , m_historyDeleteManager(std::make_shared<HistoryDeleteManager>())
+ , m_historyDaysListManager(nullptr)
, m_naviframe(nullptr)
, m_modulesToolbar(nullptr)
{
m_edjFilePath = EDJE_DIR;
m_edjFilePath.append("HistoryUI/History.edj");
- m_historyDaysListManager = std::make_shared<HistoryDaysListManagerMob>();
+ if (!m_historyDaysListManager)
+ m_historyDaysListManager = std::make_shared<HistoryDaysListManagerMob>();
m_historyDaysListManager->signalHistoryItemClicked.connect(signalHistoryItemClicked);
m_historyDaysListManager->signalDeleteHistoryItems.connect(signalDeleteHistoryItems);
+ m_historyDaysListManager->setRightButtonEnabledForHistory.connect(
+ boost::bind(&HistoryUI::setRightButtonEnabled, this, _1));
+ m_historyDaysListManager->setSelectedItemsCount.connect([this](auto count){
+ m_naviframe->setTitle((boost::format(_("IDS_BR_HEADER_PD_SELECTED_ABB")) % count).str());
+ });
}
HistoryUI::~HistoryUI()
M_ASSERT(m_main_layout);
evas_object_hide(m_main_layout);
clearItems();
- m_historyDeleteManager->setDeleteMode(false);
m_naviframe->hide();
}
+void HistoryUI::setRightButtonEnabled(bool enable)
+{
+ BROWSER_LOGD("[%s:%d] %d", __PRETTY_FUNCTION__, __LINE__, enable);
+ m_naviframe->setRightButtonEnabled(enable);
+}
+
void HistoryUI::init(Evas_Object* parent)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
Evas_Object* HistoryUI::getContent()
{
M_ASSERT(m_parent);
- if (!m_naviframe)
- createHistoryUILayout();
+ createHistoryUILayout();
return m_naviframe->getLayout();
}
void HistoryUI::createHistoryUILayout()
{
elm_theme_extension_add(nullptr, m_edjFilePath.c_str());
- m_naviframe = std::make_shared<NaviframeWrapper>(m_parent);
+ if (!m_naviframe)
+ m_naviframe = std::make_shared<NaviframeWrapper>(m_parent);
m_main_layout = elm_layout_add(m_naviframe->getLayout());
m_naviframe->setContent(m_main_layout);
m_naviframe->setTitle(_("IDS_BR_TAB2_HISTORY"));
}
-void HistoryUI::createModulesToolbar()
-{
- m_modulesToolbar = elm_toolbar_add(m_naviframe->getLayout());
-
- elm_object_style_set(m_modulesToolbar, "tabbar/notitle");
- elm_toolbar_shrink_mode_set(m_modulesToolbar, ELM_TOOLBAR_SHRINK_EXPAND);
- elm_toolbar_select_mode_set(m_modulesToolbar, ELM_OBJECT_SELECT_MODE_ALWAYS);
- elm_toolbar_transverse_expanded_set(m_modulesToolbar, EINA_TRUE);
- elm_object_part_content_set(m_naviframe->getLayout(), "action_bar_history", m_modulesToolbar);
- evas_object_show(m_modulesToolbar);
-
- elm_toolbar_item_append(m_modulesToolbar, nullptr, _("IDS_BR_BODY_BOOKMARKS"), nullptr, this);
- elm_toolbar_item_append(m_modulesToolbar, nullptr, _("IDS_BR_MBODY_HISTORY"), nullptr, this);
-}
-
-HistoryItemVectorMap
-HistoryUI::groupItemsByDomain(const HistoryItemVector& historyItems)
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- HistoryItemVectorMap groupedMap;
- for(auto& item : historyItems) {
- auto domain = tools::extractDomain(item->getUrl());
- if(groupedMap.find(domain) == groupedMap.end()) {
- groupedMap.insert(std::pair<std::string, HistoryItemVector>(domain, {}));
- }
- groupedMap.find(domain)->second.push_back(item);
- }
- return groupedMap;
-}
-
-Evas_Object* HistoryUI::createDaysList(Evas_Object* parent)
+Evas_Object* HistoryUI::createDaysList(Evas_Object* parent, bool isRemoveMode)
{
M_ASSERT(history_layout);
- auto list = m_historyDaysListManager->createDaysList(parent);
+ auto list = m_historyDaysListManager->createDaysList(parent, isRemoveMode);
evas_object_size_hint_weight_set(list, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(list, EVAS_HINT_FILL, EVAS_HINT_FILL);
return list;
}
-void HistoryUI::_close_clicked_cb(void * data, Evas_Object*, void*)
+void HistoryUI::removeSelectedHistoryItems()
{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if (!data) {
- BROWSER_LOGW("[%s] data = nullptr", __PRETTY_FUNCTION__);
+ if (!m_historyDaysListManager) {
+ BROWSER_LOGD("[%s:%d] No selected elements to delete");
return;
}
- auto self = static_cast<HistoryUI*>(data);
- self->closeHistoryUIClicked();
+ if (m_historyDaysListManager->isSelectAllChecked())
+ clearHistoryClicked();
+ m_historyDaysListManager->removeSelectedItems();
}
-void HistoryUI::_clearHistory_clicked(void* data, Evas_Object*, void*)
+void HistoryUI::_close_clicked_cb(void * data, Evas_Object*, void*)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
if (!data) {
return;
}
auto self = static_cast<HistoryUI*>(data);
- self->clearItems();
- self->clearHistoryClicked();
+ self->closeHistoryUIClicked();
}
void HistoryUI::addHistoryItems(
m_historyDaysListManager->addHistoryItems(items, period);
}
-void HistoryUI::removeHistoryItem(const std::string& uri)
-{
- BROWSER_LOGD("[%s] uri=%s", __func__, uri.c_str());
-}
-
void HistoryUI::clearItems()
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
m_historyDaysListManager->clear();
}
-void HistoryUI::showContextMenu()
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
-
- auto window = getWindow();
- if (window) {
- createContextMenu(*window);
- elm_ctxpopup_item_append(m_ctxpopup, _("IDS_BR_OPT_REMOVE"), nullptr, _cm_delete_clicked, this);
- alignContextMenu(*window);
- } else
- BROWSER_LOGE("[%s:%d] Signal not found", __PRETTY_FUNCTION__, __LINE__);
-}
-
-void HistoryUI::_cm_delete_clicked(void* data, Evas_Object*, void* )
-{
- BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- if (!data) {
- BROWSER_LOGW("[%s] data = nullptr", __PRETTY_FUNCTION__);
- return;
- }
- auto self = static_cast<HistoryUI*>(data);
- _cm_dismissed(nullptr, self->m_ctxpopup, nullptr);
-}
-
}
}
Evas_Object* getContent();
void showUI();
void hideUI();
- Evas_Object* createDaysList(Evas_Object* history_layout);
+ Evas_Object* createDaysList(Evas_Object* history_layout, bool isRemoveMode = false);
+ void removeSelectedHistoryItems();
virtual std::string getName();
void addHistoryItems(std::shared_ptr<services::HistoryItemVector>,
HistoryPeriod period = HistoryPeriod::HISTORY_TODAY);
- void removeHistoryItem(const std::string& uri);
void addItems();
+ void setNaviframe(SharedNaviframeWrapper naviframe) { m_naviframe = naviframe;}
//AbstractContextMenu interface implementation
- virtual void showContextMenu() override;
+ virtual void showContextMenu() override {};
boost::signals2::signal<void ()> closeHistoryUIClicked;
boost::signals2::signal<void ()> clearHistoryClicked;
- boost::signals2::signal<void (std::shared_ptr<const std::vector<int>> itemIds)> signalDeleteHistoryItems;
+ boost::signals2::signal<void (int)> signalDeleteHistoryItems;
boost::signals2::signal<void (std::string url, std::string title)> signalHistoryItemClicked;
private:
void clearItems();
void createHistoryUILayout();
void createTopContent();
- void createModulesToolbar();
-
- HistoryDeleteManagerPtr getHistoryDeleteManager() {return m_historyDeleteManager;}
-
- /**
- * @brief Groups history items by domain
- *
- * @return key: domain, value: domain's history items
- */
- services::HistoryItemVectorMap
- groupItemsByDomain(const services::HistoryItemVector& historyItems);
+ void setRightButtonEnabled(bool);
static Evas_Object* _listActionBarContentGet(void *data, Evas_Object *obj, const char *part);
- static void _clearHistory_clicked(void *data, Evas_Object *obj, void *event_info);
static void _close_clicked_cb(void *data, Evas_Object *obj, void *event_info);
- static void _cm_delete_clicked(void*, Evas_Object*, void*);
std::string m_edjFilePath;
Evas_Object *m_parent;
m_bookmarkManagerUI->bookmarkItemDeleted.connect(boost::bind(&SimpleUI::onBookmarkDeleted, this, _1));
m_bookmarkManagerUI->newFolderItemClicked.connect(boost::bind(&SimpleUI::onNewFolderClicked, this, _1));
m_bookmarkManagerUI->isLandscape.connect(boost::bind(&SimpleUI::isLandscape, this));
- m_bookmarkManagerUI->getHistoryGenlistContent.connect(boost::bind(&SimpleUI::showHistoryUI, this, _1));
+ m_bookmarkManagerUI->getHistoryGenlistContent.connect(boost::bind(&SimpleUI::showHistoryUI, this, _1, _2, _3));
+ m_bookmarkManagerUI->removeSelectedItemsFromHistory.connect(boost::bind(&HistoryUI::removeSelectedHistoryItems, m_historyUI.get()));
#if PROFILE_MOBILE
m_quickAccess->addQuickAccessClicked.connect(boost::bind(&SimpleUI::onNewQuickAccessClicked, this));
#else
m_historyService->clearAllHistory();
}
-void SimpleUI::onDeleteHistoryItems(
- std::shared_ptr<const std::vector<int>> itemIds)
+void SimpleUI::onDeleteHistoryItems(int id)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- for (const int& id : *itemIds)
- m_historyService->deleteHistoryItem(id);
+ m_historyService->deleteHistoryItem(id);
}
void SimpleUI::onMostVisitedClicked()
}
}
-Evas_Object* SimpleUI::showHistoryUI(Evas_Object* parent)
+Evas_Object* SimpleUI::showHistoryUI(Evas_Object* parent, SharedNaviframeWrapper naviframe, bool removeMode)
{
BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
- auto ret = m_historyUI->createDaysList(parent);
+ m_historyUI->setNaviframe(naviframe);
+ auto ret = m_historyUI->createDaysList(parent, removeMode);
m_historyUI->addHistoryItems(
m_historyService->getHistoryToday(), HistoryPeriod::HISTORY_TODAY);
m_historyUI->addHistoryItems(
void onOpenURL(const std::string& url);
void onOpenURL(const std::string& url, const std::string& title, bool desktopMode);
void onClearHistoryAllClicked();
- void onDeleteHistoryItems(std::shared_ptr<const std::vector<int>> itemIds);
+ void onDeleteHistoryItems(int id);
void onMostVisitedClicked();
void onQuickAccessClicked();
void closeTabUI();
void switchToMobileMode();
void switchToDesktopMode();
- Evas_Object* showHistoryUI(Evas_Object* parent);
+ Evas_Object* showHistoryUI(Evas_Object* parent, SharedNaviframeWrapper naviframe, bool removeMode = false);
void closeHistoryUI();
void showSettings(unsigned);
void closeSettingsUI();
projects / profile / common / apps / web / browser.git / commitdiff