TT-134 Implemented tree structure of bookmark folders

[Issue#] https://bugs.tizen.org/jira/browse/TT-134
[Problem] New folders were always added to the root folder
[Cause] N/A
[Solution] Used properly a current folder variable,
           changed displaying/updating folder content and
           did minor style improvements
[Verify] Check if new folder addition inside a folder
         actually adds a folder to the selected one.

Please keep in mind that there are some problems with diplaying
content inside folders, which will be handled in separate issue.

Change-Id: Ic5f71c57d78e95bb9878bf17d84db57eb57b8f9d

diff --git a/core/AbstractInterfaces/AbstractFavoriteService.h b/core/AbstractInterfaces/AbstractFavoriteService.h
index 4d3292051620e74d595c523d19765a752a645d20..d7a9d75592cc6e9750af05e8c069fddbe4570317 100644 (file)
--- a/core/AbstractInterfaces/AbstractFavoriteService.h
+++ b/core/AbstractInterfaces/AbstractFavoriteService.h
@@ -59,10 +59,10 @@ public:
                                                  std::shared_ptr<tizen_browser::tools::BrowserImage> favicon = std::shared_ptr<tizen_browser::tools::BrowserImage>(),
                                                  unsigned int dirId = 0) = 0;
    /**
-     * @brief Creates a new folder with name "title" in a folder with id, parent_id
+     * @brief Creates a new folder with name "title" in a folder with id and order
      * @return folder_id of created folder
      */
-    virtual int save_folder(const char *title, int *saved_bookmark_id, int parent_id=0, int by_operator=0)=0;
+    virtual int save_folder(const char *title, int *saved_bookmark_id, int by_operator = 0) = 0;
 
    /**
      * @brief get folder id of a folder with name "title" in folder with id, parent_id
@@ -96,7 +96,7 @@ public:
      *
      * @return list of bookmark folders
      */
-    virtual std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > getBookmarkFolders()= 0;
+    virtual std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > getBookmarkFolders(int folder_id) = 0;
 
     /**
      * @brief Delete all bookmarks

diff --git a/services/BookmarkManagerUI/BookmarkManagerUI.cpp b/services/BookmarkManagerUI/BookmarkManagerUI.cpp
index 2ae161751e3c11d97ce4bde3bec62b5cdbad7321..cd504712dc9ccd6a882972dcfa378c3b897e840a 100644 (file)
--- a/services/BookmarkManagerUI/BookmarkManagerUI.cpp
+++ b/services/BookmarkManagerUI/BookmarkManagerUI.cpp
@@ -51,8 +51,8 @@ BookmarkManagerUI::BookmarkManagerUI()
     , m_itemClass(nullptr)
     , m_gengrid(nullptr)
     , m_parent(nullptr)
-    , m_item_class(nullptr)
-    , m_detail_item_class(nullptr)
+    , m_folder_item_class(nullptr)
+    , m_bookmark_item_class(nullptr)
     , m_gengridSetup(false)
 {
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
@@ -76,29 +76,35 @@ void BookmarkManagerUI::show(Evas_Object* parent)
     evas_object_size_hint_align_set(b_mm_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
     evas_object_show(b_mm_layout);
 
-    m_gengrid = elm_gengrid_add(b_mm_layout);
-    elm_object_part_content_set(b_mm_layout, "elm.swallow.grid", m_gengrid);
+    createGenGrid();
 
-    elm_object_style_set(m_gengrid, "back_ground");
+    if (!m_folder_item_class) {
+        m_folder_item_class = elm_gengrid_item_class_new();
+        m_folder_item_class->item_style = "grid_bm_item";
+        m_folder_item_class->func.text_get = _grid_folder_text_get;
+        m_folder_item_class->func.content_get =  _grid_folder_content_get;
+        m_folder_item_class->func.state_get = nullptr;
+        m_folder_item_class->func.del = nullptr;
+    }
 
-      if (!m_item_class) {
-            m_item_class = elm_gengrid_item_class_new();
-            m_item_class->item_style = "grid_bm_item";
-            m_item_class->func.text_get = _grid_folder_text_get;
-            m_item_class->func.content_get =  _grid_folder_content_get;
-            m_item_class->func.state_get = nullptr;
-            m_item_class->func.del = nullptr;
-        }
+    if (!m_bookmark_item_class) {
+        m_bookmark_item_class = elm_gengrid_item_class_new();
+        m_bookmark_item_class->item_style = "grid_ds_item";
+        m_bookmark_item_class->func.text_get = _grid_bookmark_text_get;
+        m_bookmark_item_class->func.content_get =  _grid_bookmark_content_get;
+        m_bookmark_item_class->func.state_get = nullptr;
+        m_bookmark_item_class->func.del = nullptr;
+    }
+}
 
-      if (!m_detail_item_class) {
-            m_detail_item_class = elm_gengrid_item_class_new();
-            m_detail_item_class->item_style = "grid_ds_item";
-            m_detail_item_class->func.text_get = _grid_bookmark_text_get;
-            m_detail_item_class->func.content_get =  _grid_bookmark_content_get;
-            m_detail_item_class->func.state_get = nullptr;
-            m_detail_item_class->func.del = nullptr;
-        }
+void BookmarkManagerUI::createGenGrid()
+{
+    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_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);
@@ -141,6 +147,7 @@ void BookmarkManagerUI::showTopContent()
                                                       nullptr,
                                                       nullptr                //data passed to above function
                                                      );
+
     id->e_item = elmItem;
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
 }
@@ -204,19 +211,19 @@ void BookmarkManagerUI::newFolderPopup()
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
     m_popup.reset(new AddNewFolderPopup(m_parent, nullptr,"Add New Folder?","New Folder","Ok","Cancel"));
     m_popup->on_ok.disconnect_all_slots();
-    m_popup->on_ok.connect(boost::bind(&BookmarkManagerUI::NewFolderCreate, this, _1));
+    m_popup->on_ok.connect(boost::bind(&BookmarkManagerUI::newFolderCreate, this, _1));
     m_popup->on_cancel.disconnect_all_slots();
     m_popup->on_cancel.connect(boost::bind(&BookmarkManagerUI::CancelClicked, this, _1));
     m_popup->show();
 }
 
-void BookmarkManagerUI::NewFolderCreate(Evas_Object * popup_content)
+void BookmarkManagerUI::newFolderCreate(Evas_Object * popup_content)
 {
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
     if (popup_content != nullptr)
     {
         m_folderName = elm_entry_entry_get(popup_content);
-        saveFolderClicked(m_folderName.c_str(), 0,0);
+        saveFolderClicked(m_folderName.c_str(), 0);
         m_popup->hide();
     }
 }
@@ -295,7 +302,7 @@ void BookmarkManagerUI::addBookmarkFolderItem(std::shared_ptr<tizen_browser::ser
     BookmarkFolderItemData *itemData = new BookmarkFolderItemData();
     itemData->item = hi;
     itemData->bookmarkManagerUI.reset(this);
-    Elm_Object_Item* BookmarkFolderView = elm_gengrid_item_append(m_gengrid, m_item_class, itemData, _folderItemClicked, itemData);
+    Elm_Object_Item* BookmarkFolderView = elm_gengrid_item_append(m_gengrid, m_folder_item_class, itemData, _folderItemClicked, itemData);
     m_map_bookmark_folder_views.insert(std::pair<std::string,Elm_Object_Item*>(hi->getAddress(),BookmarkFolderView));
     elm_gengrid_item_selected_set(BookmarkFolderView, EINA_FALSE);
     setEmptyGengrid(false);
@@ -319,7 +326,7 @@ void BookmarkManagerUI::addBookmarkItem(std::shared_ptr<tizen_browser::services:
     BookmarkItemData *itemData = new BookmarkItemData();
     itemData->item = hi;
     itemData->bookmarkManagerUI.reset(this);
-    Elm_Object_Item* BookmarkView = elm_gengrid_item_append(m_gengrid, m_detail_item_class, itemData, _bookmarkItemClicked, itemData);
+    Elm_Object_Item* BookmarkView = elm_gengrid_item_append(m_gengrid, m_bookmark_item_class, itemData, _bookmarkItemClicked, itemData);
     m_map_bookmark_folder_views.insert(std::pair<std::string,Elm_Object_Item*>(hi->getAddress(),BookmarkView));
     elm_gengrid_item_selected_set(BookmarkView, EINA_FALSE);
     setEmptyGengrid(false);
@@ -346,7 +353,6 @@ char* BookmarkManagerUI::_grid_folder_text_get(void *data, Evas_Object *, const
         const char *part_name2 = "page_url";
         static const int part_name1_len = strlen(part_name1);
         static const int part_name2_len = strlen(part_name2);
-
         if (!strncmp(part_name1, part, part_name1_len) && !itemData->item->getTittle().empty())
         {
             return strdup(itemData->item->getTittle().c_str());
@@ -452,20 +458,12 @@ Evas_Object * BookmarkManagerUI::_grid_bookmark_content_get(void *data, Evas_Obj
 void BookmarkManagerUI::_bookmarkItemClicked(void * data, Evas_Object *, void * event_info)
 {
     BROWSER_LOGD("%s:%d %s", __FILE__, __LINE__, __func__);
-    (void)data;
-    (void)event_info;
-/*
-    if ((data != nullptr) && (event_info != nullptr))
+    if (data != nullptr)
     {
-        Elm_Object_Item * selected = static_cast<Elm_Object_Item *>(event_info);
-        BookmarkManagerUI * self = static_cast<BookmarkManagerUI *>(data);
-        HistoryItemData * itemData = static_cast<HistoryItemData *>(elm_object_item_data_get(selected));
-        if (itemData != nullptr)
-        {
-            self->bookmarkClicked(itemData->item);
-        }
+        BookmarkFolderItemData * itemData = static_cast<BookmarkFolderItemData*>(data);
+        BROWSER_LOGD("Bookmark URL: %s" , itemData->item->getAddress().c_str());
+        itemData->bookmarkManagerUI->bookmarkItemClicked(itemData->item);
     }
-*/
 }
 
 void BookmarkManagerUI::_folderItemClicked(void * data, Evas_Object *, void *)
@@ -476,7 +474,7 @@ void BookmarkManagerUI::_folderItemClicked(void * data, Evas_Object *, void *)
         BookmarkFolderItemData * itemData = static_cast<BookmarkFolderItemData *>(data);
         BROWSER_LOGD("Folder ID: %d" , itemData->item->getId());
         itemData->bookmarkManagerUI->set_folder(itemData->item->getTittle().c_str());
-        itemData->bookmarkManagerUI->bookmarkFolderClicked(itemData->item->getId());
+        itemData->bookmarkManagerUI->folderItemClicked(itemData->item->getId());
     }
 }
 
@@ -507,9 +505,10 @@ void BookmarkManagerUI::clearItems()
 void BookmarkManagerUI::updateGengrid()
 {
     elm_genlist_clear(m_genList);
-    elm_gengrid_clear(m_gengrid);
+    //elm_gengrid_clear(m_gengrid);
+    //remove 'createGenGrid' if the elm_gengrid_clear() will be valid again
+    createGenGrid();
     m_map_bookmark_folder_views.clear();
 }
-
 }
 }

diff --git a/services/BookmarkManagerUI/BookmarkManagerUI.h b/services/BookmarkManagerUI/BookmarkManagerUI.h
index eeb2a57bc23e16732b23403f3132e51fe9598f41..e37dbbb7666799146271440908672bd6c48a6751 100644 (file)
--- a/services/BookmarkManagerUI/BookmarkManagerUI.h
+++ b/services/BookmarkManagerUI/BookmarkManagerUI.h
@@ -57,10 +57,12 @@ public:
 
     boost::signals2::signal<void (std::string)> closeBookmarkManagerClicked;
     boost::signals2::signal<void (std::string)> addNewFolderClicked;
-    boost::signals2::signal<void (const char*, int, int)> saveFolderClicked;
-    boost::signals2::signal<void (int)> bookmarkFolderClicked;
+    boost::signals2::signal<void (const char*, int)> saveFolderClicked;
+    boost::signals2::signal<void (std::shared_ptr<tizen_browser::services::BookmarkItem>)> bookmarkItemClicked;
+    boost::signals2::signal<void (int)> folderItemClicked;
 
 private:
+    void createGenGrid();
     static char* _grid_folder_text_get(void *data, Evas_Object *obj, const char *part);
     static Evas_Object * _grid_folder_content_get(void *data, Evas_Object *obj, const char *part);
     static char* _grid_bookmark_text_get(void *data, Evas_Object *obj, const char *part);
@@ -70,7 +72,7 @@ private:
     static void _folderItemClicked(void * data, Evas_Object * obj, void * event_info);
     static void _bookmark_thumbSelected(void * data, Evas_Object *, void *);
 
-    void NewFolderCreate(Evas_Object * popup_content);
+    void newFolderCreate(Evas_Object * popup_content);
     void CancelClicked(Evas_Object * popup_content);
 
     static Evas_Object* listItemContentGet(void *data, Evas_Object *obj, const char *part);
@@ -89,8 +91,8 @@ private:
     Elm_Genlist_Item_Class *m_itemClass;
     Evas_Object *m_gengrid;
     Evas_Object *m_parent;
-    Elm_Gengrid_Item_Class * m_item_class;
-    Elm_Gengrid_Item_Class * m_detail_item_class;
+    Elm_Gengrid_Item_Class * m_bookmark_item_class;
+    Elm_Gengrid_Item_Class * m_folder_item_class;
     std::map<std::string,Elm_Object_Item*> m_map_bookmark_folder_views;
     std::string edjFilePath;
     std::string m_folder;

diff --git a/services/BookmarkService/BookmarkService.cpp b/services/BookmarkService/BookmarkService.cpp
index ac5cce3dd1c241cc2a3759c236f853c157425658..322e8267c31c8566f52e3b81df4a039ade348d08 100644 (file)
--- a/services/BookmarkService/BookmarkService.cpp
+++ b/services/BookmarkService/BookmarkService.cpp
@@ -191,9 +191,10 @@ int BookmarkService::getBookmarkId(const std::string & url)
 std::vector<std::shared_ptr<BookmarkItem> > BookmarkService::getBookmarks(int folder_id)
 {
     BROWSER_LOGD("[%s:%d] folder_id = %d", __func__, __LINE__, folder_id);
+    set_current_folder_id(folder_id);
     int *ids = nullptr;
     int ids_count = 0;
-    int ret = bp_bookmark_adaptor_get_ids_p(&ids, &ids_count, -1, 0, folder_id, 0, -1, -1, BP_BOOKMARK_O_SEQUENCE, 0);
+    int ret = bp_bookmark_adaptor_get_ids_p(&ids, &ids_count, -1, 0, folder_id, BOOKMARK_TYPE, -1, -1, BP_BOOKMARK_O_SEQUENCE, 0);
     if (ret<0){
         BROWSER_LOGE("Error! Could not get ids!");
         return std::vector<std::shared_ptr<BookmarkItem>>();
@@ -229,25 +230,26 @@ std::vector<std::shared_ptr<BookmarkItem> > BookmarkService::getBookmarks(int fo
         memcpy(fav->imageData, (void*)image_bytes, bookmark_info.favicon_length);
         bookmark->setFavicon(fav);
         m_bookmarks.push_back(bookmark);
+
     }
     free(ids);
     return m_bookmarks;
 }
 
-std::vector<std::shared_ptr<BookmarkItem> > BookmarkService::getBookmarkFolders()
+std::vector<std::shared_ptr<BookmarkItem> > BookmarkService::getBookmarkFolders(int folder_id)
 {
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+    set_current_folder_id(folder_id);
     int *ids = nullptr;
     int ids_count = 0;
-    int ret = bp_bookmark_adaptor_get_ids_p(&ids, &ids_count, -1, 0, -1, 1, -1, -1, BP_BOOKMARK_O_SEQUENCE, 0);
+    int ret = bp_bookmark_adaptor_get_ids_p(&ids, &ids_count, -1, 0, folder_id, FOLDER_TYPE, -1, -1, BP_BOOKMARK_O_SEQUENCE, 0);
     if (ret<0){
         BROWSER_LOGE("Error! Could not get ids!");
         return std::vector<std::shared_ptr<BookmarkItem>>();
     }
 
     m_bookmarks.clear();
-
-    BROWSER_LOGD("Bookmark items: %d", ids_count);
+    BROWSER_LOGD("Bookmark folders: %d", ids_count);
 
     for(int i = 0; i<ids_count; i++)
     {
@@ -299,12 +301,11 @@ int BookmarkService::get_root_folder_id(void)
     return root_id;
 }
 
-int BookmarkService::save_folder(const char *title, int *saved_folder_id, int parent_id, int by_operator)
+int BookmarkService::save_folder(const char *title, int *saved_folder_id, int by_operator)
 {
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
-
     bp_bookmark_property_cond_fmt properties;
-    properties.parent = parent_id;
+    properties.parent = get_current_folder_id();
     properties.type = 1;
     properties.is_operator = -1;
     properties.is_editable = -1;
@@ -333,7 +334,7 @@ int BookmarkService::save_folder(const char *title, int *saved_folder_id, int pa
     std::memset(&info, 0, sizeof(bp_bookmark_info_fmt));
 
     info.type = 1;
-    info.parent = parent_id;
+    info.parent = get_current_folder_id();
     info.sequence = -1;
     info.is_operator = by_operator;
     info.access_count = -1;
@@ -1340,7 +1341,7 @@ void BookmarkService::path_into_sub_folder(int folder_id, const char *folder_nam
     free(path_string);
     BROWSER_LOGD("m_path_string: %s", m_path_string.c_str());
 
-    m_curr_folder = folder_id;
+    set_current_folder_id(folder_id);
 }
 
 bool BookmarkService::path_to_upper_folder(int *curr_folder)
@@ -1392,7 +1393,7 @@ bool BookmarkService::path_to_upper_folder(int *curr_folder)
     }
     BROWSER_LOGD("m_path_string: %s", m_path_string.c_str());
 
-    m_curr_folder = *curr_folder;
+    set_current_folder_id(*curr_folder);
     return true;
 }
 

diff --git a/services/BookmarkService/BookmarkService.h b/services/BookmarkService/BookmarkService.h
index 8ce4790262bc25b165b67842d05526134d83611f..3560a46a31918479dc77ea1f197f15804264dab8 100644 (file)
--- a/services/BookmarkService/BookmarkService.h
+++ b/services/BookmarkService/BookmarkService.h
@@ -84,7 +84,7 @@ public:
      * @return list of bookmark items, bookmark items in a folder & bookmark folders
      */
     std::vector<std::shared_ptr<BookmarkItem> > getBookmarks(int folder_id = -1);
-    std::vector<std::shared_ptr<BookmarkItem> > getBookmarkFolders();
+    std::vector<std::shared_ptr<BookmarkItem> > getBookmarkFolders(int folder_id);
 
    /**
      * @brief Delete all bookmarks
@@ -110,7 +110,7 @@ public:
     } folder_info;
 
     int get_root_folder_id(void);
-    int save_folder(const char *title, int *saved_bookmark_id, int parent_id=0,int by_operator = 0);
+    int save_folder(const char *title, int *saved_bookmark_id, int by_operator = 0);
     bool delete_by_id(int id);
     bool delete_by_id_notify(int id);
     bool delete_by_uri(const char *uri);
@@ -159,10 +159,15 @@ public:
 
     bool get_memory_full(void) { return m_memory_full; }
     int get_current_folder_id(void) { return m_curr_folder; }
+    void set_current_folder_id(int folder_id) { m_curr_folder = folder_id; }
 
 private:
+    enum ItemType{
+          BOOKMARK_TYPE = 0
+        , FOLDER_TYPE = 1
+        , ALL_TYPE = -1
+    };
     bool _get_depth_count_recursive(int folder_id, int cur_depth, int *depth_count);
-
     std::vector<BookmarkItem *> m_bookmark_list;
     std::vector<folder_info *> m_path_history;
     std::string m_path_string;
@@ -171,7 +176,6 @@ private:
     int m_curr_folder;
     std::shared_ptr<tizen_browser::services::StorageService> m_storageManager;
     std::vector<std::shared_ptr<BookmarkItem> > m_bookmarks;
-
 ///    \todo Need to change getBookmarkId function for finding stored bookmark - check getBookmarkExists function
     int getBookmarkId(const std::string & url);
     std::shared_ptr<tizen_browser::services::StorageService> getStorageManager();

diff --git a/services/MoreMenuUI/MoreMenuUI.cpp b/services/MoreMenuUI/MoreMenuUI.cpp
index 3edef9ddcd585bf3620cce99e62c7fa8c7cba5ca..d28c73c328728fbfaabf8b8f68f13be9ca8f2c64 100644 (file)
--- a/services/MoreMenuUI/MoreMenuUI.cpp
+++ b/services/MoreMenuUI/MoreMenuUI.cpp
@@ -180,12 +180,14 @@ void MoreMenuUI::star_clicked_cb(void* data, Evas_Object*, void*)
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
     if (data) {
         ItemData * id = static_cast<ItemData *>(data);
+        id->m_moreMenu->addToBookmarkClicked();
         id->m_moreMenu->AddBookmarkPopupCalled();
     }
 }
 
 void MoreMenuUI::AddBookmarkPopupCalled()
 {
+
     m_add_bookmark_popup = std::make_shared<tizen_browser::base_ui::AddBookmarkPopup>(m_mm_layout);
     m_add_bookmark_popup->show();
     m_add_bookmark_popup->addBookmarkFolderItems(m_map_bookmark_folder_list);
@@ -218,7 +220,7 @@ void MoreMenuUI::NewFolderCreate(Evas_Object* popup_content)
    BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
    if (popup_content) {
        m_folderName = elm_entry_entry_get(popup_content);
-       BookmarkFolderCreated(m_folderName.c_str(), 0,0);
+       BookmarkFolderCreated(m_folderName.c_str(), 0);
        m_new_folder_popup->hide();
    }
 }

diff --git a/services/MoreMenuUI/MoreMenuUI.h b/services/MoreMenuUI/MoreMenuUI.h
index 0bb5b1eadf1bbc6daf4a31f9b0be0a557041551e..103b8c73175dab1f0575d0a31307ce1ed4011f3a 100644 (file)
--- a/services/MoreMenuUI/MoreMenuUI.h
+++ b/services/MoreMenuUI/MoreMenuUI.h
@@ -70,13 +70,14 @@ public:
     void clearItems();
     void getBookmarkFolderList(std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > );
 
+    boost::signals2::signal<void ()> addToBookmarkClicked;
+    boost::signals2::signal<void (int)> AddBookmarkInput;
+    boost::signals2::signal<void (const char*, int)> BookmarkFolderCreated;
     boost::signals2::signal<void (std::string)> bookmarkManagerClicked;
-    boost::signals2::signal<void (std::string)> historyUIClicked;
-    boost::signals2::signal<void (const char*, int, int)> BookmarkFolderCreated;
-    boost::signals2::signal<void (std::string)> closeMoreMenuClicked;
     boost::signals2::signal<void (std::string)> BookmarkFoldersListImport;
+    boost::signals2::signal<void (std::string)> historyUIClicked;
     boost::signals2::signal<void (const std::string&)> settingsClicked;
-    boost::signals2::signal<void (int)> AddBookmarkInput;
+    boost::signals2::signal<void (std::string)> closeMoreMenuClicked;
 private:
     static char* _grid_text_get(void *data, Evas_Object *obj, const char *part);
     static Evas_Object * _grid_content_get(void *data, Evas_Object *obj, const char *part);

diff --git a/services/SimpleUI/SimpleUI.cpp b/services/SimpleUI/SimpleUI.cpp
index 10e3bab0109a38fac068e5bf32f23edde347f549..c5e2385939dc05771be9b8b40005f57dca912e3f 100644 (file)
--- a/services/SimpleUI/SimpleUI.cpp
+++ b/services/SimpleUI/SimpleUI.cpp
@@ -56,6 +56,7 @@ namespace base_ui{
 EXPORT_SERVICE(SimpleUI, "org.tizen.browser.simpleui")
 
 const std::string HomePageURL = "about:home";
+const int ROOT_FOLDER = 0;
 
 SimpleUI::SimpleUI()
     : AbstractMainWindow()
@@ -113,9 +114,9 @@ std::vector<std::shared_ptr<tizen_browser::services::HistoryItem> > SimpleUI::ge
 }
 
 
-std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > SimpleUI::getBookmarkFolders()
+std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > SimpleUI::getBookmarkFolders(int folder_id)
 {
-    return m_favoriteService->getBookmarkFolders();
+    return m_favoriteService->getBookmarkFolders(folder_id);
 }
 
 
@@ -333,8 +334,6 @@ int SimpleUI::exec(const std::string& _url)
 
     BROWSER_LOGD("[%s]:%d url=%s", __func__, __LINE__, url.c_str());
 
-    saveFolder("Bookmark Bar",0,1);
-
     m_simpleURI->setFocus();
 
     return 0;
@@ -643,6 +642,15 @@ void SimpleUI::onBookmarkManagerButtonClicked(const std::string&)
 void SimpleUI::onBookmarkClicked(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem)
 {
     std::string bookmarkAddress = bookmarkItem->getAddress();
+    if(m_bookmarkManagerUI) {                // TODO: remove this section when naviframes will be available
+        m_bookmarkManagerUI->clearItems();
+        m_bookmarkManagerUI = nullptr;
+    }
+
+    if(m_moreMenuUI) {               // TODO: remove this section when naviframes will be available
+        m_moreMenuUI->clearItems();
+        m_moreMenuUI = nullptr;
+    }
     openNewTab(bookmarkAddress);
 }
 
@@ -1138,19 +1146,20 @@ void SimpleUI::showMoreMenu()
                 <tizen_browser::base_ui::MoreMenuUI,tizen_browser::core::AbstractService>
                 (tizen_browser::core::ServiceManager::getInstance().getService("org.tizen.browser.moremenuui"));
         M_ASSERT(m_moreMenuUI);
-    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.disconnect_all_slots();
-       m_moreMenuUI->closeMoreMenuClicked.connect(boost::bind(&SimpleUI::closeMoreMenu, this,_1));
-       m_moreMenuUI->AddBookmarkInput.disconnect_all_slots();
-       m_moreMenuUI->AddBookmarkInput.connect(boost::bind(&SimpleUI::addToBookmarks, this,_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.disconnect_all_slots();
+        m_moreMenuUI->closeMoreMenuClicked.connect(boost::bind(&SimpleUI::closeMoreMenu, this,_1));
+        m_moreMenuUI->addToBookmarkClicked.disconnect_all_slots();
+        m_moreMenuUI->addToBookmarkClicked.connect(boost::bind(&SimpleUI::addBookmarkFolders, this));
+        m_moreMenuUI->AddBookmarkInput.disconnect_all_slots();
+        m_moreMenuUI->AddBookmarkInput.connect(boost::bind(&SimpleUI::addToBookmarks, this,_1));
         m_moreMenuUI->BookmarkFolderCreated.disconnect_all_slots();
-        m_moreMenuUI->BookmarkFolderCreated.connect(boost::bind(&SimpleUI::NewFolder, this,_1,_2,_3));
+        m_moreMenuUI->BookmarkFolderCreated.connect(boost::bind(&SimpleUI::newFolderMoreMenu, this,_1,_2));
         m_moreMenuUI->show(m_window.get());
-        m_moreMenuUI->getBookmarkFolderList(getBookmarkFolders());
         m_moreMenuUI->showCurrentTab(current_tab_as_new_tab ? nullptr : m_historyService->getHistoryItems().front());
-       BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+        BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
     }
 }
 
@@ -1172,20 +1181,25 @@ void SimpleUI::showBookmarkManagerMenu()
         m_bookmarkManagerUI->closeBookmarkManagerClicked.disconnect_all_slots();
         m_bookmarkManagerUI->closeBookmarkManagerClicked.connect(boost::bind(&SimpleUI::closeBookmarkManagerMenu, this,_1));
         m_bookmarkManagerUI->saveFolderClicked.disconnect_all_slots();
-        m_bookmarkManagerUI->saveFolderClicked.connect(boost::bind(&SimpleUI::saveFolder, this,_1,_2,_3));
-        m_bookmarkManagerUI->bookmarkFolderClicked.disconnect_all_slots();
-        m_bookmarkManagerUI->bookmarkFolderClicked.connect(boost::bind(&SimpleUI::updateBookmakMangaerGenGrid, this,_1));
+        m_bookmarkManagerUI->saveFolderClicked.connect(boost::bind(&SimpleUI::newFolderBookmarkManager, this,_1,_2));
+        m_bookmarkManagerUI->bookmarkItemClicked.disconnect_all_slots();
+        m_bookmarkManagerUI->bookmarkItemClicked.connect(boost::bind(&SimpleUI::onBookmarkClicked, this, _1));
+        m_bookmarkManagerUI->folderItemClicked.disconnect_all_slots();
+        m_bookmarkManagerUI->folderItemClicked.connect(boost::bind(&SimpleUI::updateBookmarkManagerGenGrid, this,_1));
         m_bookmarkManagerUI->show(m_window.get());
-        m_bookmarkManagerUI->addBookmarkFolderItems(getBookmarkFolders());
+        m_bookmarkManagerUI->addBookmarkFolderItems(getBookmarkFolders(ROOT_FOLDER));
         m_bookmarkManagerUI->showTopContent();
+        m_curr_folder_id = ROOT_FOLDER;
     }
 }
 
-void SimpleUI::updateBookmakMangaerGenGrid(int folder_id)
+void SimpleUI::updateBookmarkManagerGenGrid(int folder_id)
 {
     m_bookmarkManagerUI->updateGengrid();
+    m_bookmarkManagerUI->addBookmarkFolderItems(getBookmarkFolders(folder_id));
     m_bookmarkManagerUI->addBookmarkItems(getBookmarks(folder_id));
     m_bookmarkManagerUI->showTopContent();
+    m_curr_folder_id = folder_id;
 }
 
 void SimpleUI::closeBookmarkManagerMenu(std::string& str)
@@ -1406,33 +1420,38 @@ void SimpleUI::addToBookmarks(int folder_id)
         }
 }
 
-void SimpleUI::saveFolder(const char* title,int folder_id, int by_operator)
+void SimpleUI::addBookmarkFolders(void)
+{
+    if(m_moreMenuUI)
+        m_moreMenuUI->getBookmarkFolderList(getBookmarkFolders(ROOT_FOLDER));
+}
+
+
+void SimpleUI::newFolderBookmarkManager(const char* title, int by_operator)
 {
     BROWSER_LOGD("[%s,%d],", __func__, __LINE__);
     int id = -1;
        if (m_favoriteService)
-               m_favoriteService->save_folder(title, &id, folder_id, by_operator);
+               m_favoriteService->save_folder(title, &id, by_operator);
     if (id >= 0 )
-     {     BROWSER_LOGD("[%s], Added New Folder", __func__);
-     }
-    if(m_bookmarkManagerUI)
-    {   m_bookmarkManagerUI->updateGengrid();
-        m_bookmarkManagerUI->addBookmarkFolderItems(getBookmarkFolders());
+    {
+        BROWSER_LOGD("[%s], Added New Folder", __func__);
+        if(m_bookmarkManagerUI)
+        {
+            updateBookmarkManagerGenGrid(m_curr_folder_id);   // TODO: correct folder displaying behaviour needs to be implemented
+        }
     }
 }
 
-
-
-void SimpleUI::NewFolder(const char* title,int folder_id, int by_operator)
+void SimpleUI::newFolderMoreMenu(const char* title, int by_operator)
 {
     int id = -1;
        if (m_favoriteService)
-               m_favoriteService->save_folder(title, &id, folder_id, by_operator);
+        m_favoriteService->save_folder(title, &id, by_operator);
     if (id >= 0)
     {
         BROWSER_LOGD("[%s], Added New Folder", __func__);
         addToBookmarks(id);
-        m_moreMenuUI->getBookmarkFolderList(getBookmarkFolders());
     }
 }
 
@@ -1441,6 +1460,5 @@ void SimpleUI::deleteBookmark(void)
        if (m_favoriteService)
                m_favoriteService->deleteBookmark(m_webEngine->getURI());
 }
-
 }
 }

diff --git a/services/SimpleUI/SimpleUI.h b/services/SimpleUI/SimpleUI.h
index 96a07cf0d3f87f2ac1ebdd9bb570b1f833331fc3..06bbe474609f1272d33f9c8a0d97b706eba8428e 100644 (file)
--- a/services/SimpleUI/SimpleUI.h
+++ b/services/SimpleUI/SimpleUI.h
@@ -121,7 +121,7 @@ private:
 
     void bookmarkCheck();
     std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > getBookmarks(int folder_id = -1);
-    std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > getBookmarkFolders();
+    std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > getBookmarkFolders(int folder_id);
     std::vector<std::shared_ptr<tizen_browser::services::HistoryItem> > getHistory();
     void onBookmarkAdded(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem);
 
@@ -219,9 +219,10 @@ private:
     void hideHistory();
     void AddBookmarkPopup(std::string& str);
     void AddNewFolderPopup(std::string& str);
+    void addBookmarkFolders();
 
-    void saveFolder(const char* title, int folder_id, int by_user);
-    void NewFolder(const char* title, int folder_id, int by_user);
+    void newFolderBookmarkManager(const char* title, int by_user);
+    void newFolderMoreMenu(const char* title, int by_user);
     void showTabUI();
     void closeTabUI(const std::string& str);
     void showMoreMenu();
@@ -241,7 +242,7 @@ private:
     void hideProgressBar();
 
     void closeBookmarkManagerMenu(std::string& str);
-    void updateBookmakMangaerGenGrid(int folder_id);
+    void updateBookmarkManagerGenGrid(int folder_id);
     void showBookmarkManagerMenu();
 
     void showPopup(Evas_Object *content, char* btn1_text, char* btn2_text);
@@ -313,6 +314,7 @@ private:
     int m_tabLimit;
     int m_favoritesLimit;
     bool m_wvIMEStatus;
+    int m_curr_folder_id;
     // 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