setting for global Favorites/Lastplayed into a "favorites" collection

.gitignore

@@ -11,6 +11,5 @@ Configuration/Configuration/obj/**
 Artifacts/**
 BP Files/Page.cpp
 BP Files/RetroFE.cpp
-/.vs/RetroFE-MF-Dev/v17
 /.vs
 /RetroFE/Builds

RetroFE/Source/Collection/CollectionInfo.cpp

@@ -34,20 +34,23 @@
 #include <cstring>
 #endif
 
-CollectionInfo::CollectionInfo(std::string name,
-                               std::string listPath,
-                               std::string extensions,
-                               std::string metadataType,
-                               std::string metadataPath)
-    : name(name)
+CollectionInfo::CollectionInfo(
+    Configuration& c,
+    std::string name,
+    std::string listPath,
+    std::string extensions,
+    std::string metadataType,
+    std::string metadataPath)
+    : conf_(c)
+    , name(name)
     , listpath(listPath)
     , saveRequest(false)
     , metadataType(metadataType)
     , menusort(true)
     , subsSplit(false)
     , hasSubs(false)
     , metadataPath_(metadataPath)
-	, extensions_(extensions)
+    , extensions_(extensions)
 {
 }
 
@@ -79,8 +82,14 @@ bool CollectionInfo::Save()
     bool retval = true;
     if(saveRequest)
     {
-        std::string dir  = Utils::combinePath(Configuration::absolutePath, "collections", name, "playlists");
-        std::string file = Utils::combinePath(Configuration::absolutePath, "collections", name, "playlists/favorites.txt");
+        std::string playlistCollectionName = name;
+        bool globalFavLast = false;
+        (void)conf_.getProperty("globalFavLast", globalFavLast);
+        if (globalFavLast) {
+            playlistCollectionName = "Favorites";
+        }
+        std::string dir  = Utils::combinePath(Configuration::absolutePath, "collections", playlistCollectionName, "playlists");
+        std::string file = Utils::combinePath(Configuration::absolutePath, "collections", playlistCollectionName, "playlists", "favorites.txt");
         Logger::write(Logger::ZONE_INFO, "Collection", "Saving " + file);
 
         std::ofstream filestream;
@@ -121,7 +130,7 @@ bool CollectionInfo::Save()
             std::vector<Item *> *saveitems = playlists["favorites"];
             for(std::vector<Item *>::iterator it = saveitems->begin(); it != saveitems->end(); it++)
             {
-                if ((*it)->collectionInfo->name == name)
+                if ((*it)->collectionInfo->name == (*it)->name)
                 {
                     filestream << (*it)->name << std::endl;
                 }

RetroFE/Source/Collection/CollectionInfo.h

@@ -20,11 +20,12 @@
 #include <map>
 
 class Item;
+class Configuration;
 
 class CollectionInfo
 {
 public:
-    CollectionInfo(std::string name, std::string listPath, std::string extensions, std::string metadataType, std::string metadataPath);
+    CollectionInfo(Configuration& c, std::string name, std::string listPath, std::string extensions, std::string metadataType, std::string metadataPath);
     virtual ~CollectionInfo();
     std::string settingsPath() const;
     bool Save();
@@ -48,6 +49,7 @@ class CollectionInfo
     bool subsSplit;
     bool hasSubs;
 private:
+    Configuration& conf_;
     std::string metadataPath_;
     std::string extensions_;
     static bool itemIsLess(Item *lhs, Item *rhs);

RetroFE/Source/Collection/CollectionInfoBuilder.cpp

@@ -184,7 +184,7 @@ CollectionInfo *CollectionInfoBuilder::buildCollection(std::string name, std::st
         Logger::write(Logger::ZONE_NOTICE, "Collections", ss.str());
     }
 
-    CollectionInfo *collection = new CollectionInfo(name, listItemsPath, extensions, metadataType, metadataPath);
+    CollectionInfo *collection = new CollectionInfo(conf_, name, listItemsPath, extensions, metadataType, metadataPath);
 
     (void)conf_.getProperty("collections." + collection->name + ".launcher", collection->launcher);
 
@@ -414,6 +414,27 @@ void CollectionInfoBuilder::addPlaylists(CollectionInfo *info)
         info->playlists["all"] = &info->items;
     }
 
+    std::map<std::string, Item*> playlistItems;
+    std::string path = Utils::combinePath(Configuration::absolutePath, "collections", info->name, "playlists");
+    loadPlaylistItems(info, playlistItems, path);
+
+    bool globalFavLast = false;
+    (void)conf_.getProperty("globalFavLast", globalFavLast);
+    if (globalFavLast) {
+        // don't use collection's playlist
+        if (!info->playlists["favorites"]) {
+            info->playlists["favorites"] = new std::vector<Item*>();
+        } else {
+            info->playlists["favorites"]->clear();
+        }
+        std::string path = Utils::combinePath(Configuration::absolutePath, "collections", "Favorites", "playlists");
+        loadPlaylistItems(info, playlistItems, path);
+    }
+
+    if (!playlistItems.size()) {
+        return;
+    }
+    // if cyclePlaylist then order playlist menu items by that
     // get playlist cycle
     std::string settingPrefix = "collections." + info->name + ".";
     std::string cycleString;
@@ -427,31 +448,77 @@ void CollectionInfoBuilder::addPlaylists(CollectionInfo *info)
     std::vector<std::string> cycleVector;
     Utils::listToVector(cycleString, cycleVector, ',');
 
-    DIR *dp;
-    struct dirent *dirp;
-    std::string path = Utils::combinePath(Configuration::absolutePath, "collections", info->name, "playlists");
-    dp = opendir(path.c_str());
+    if (cycleVector.size())
+    {
+        // add in order according to cycle list
+        for (std::vector<std::string>::iterator itP = cycleVector.begin(); itP != cycleVector.end(); itP++)
+        {
+            if (playlistItems[*itP]) {
+                info->playlistItems.push_back(playlistItems[*itP]);
+            }
+        }
+    }
+    else {
+        // convert lookup playlist map to vector
+        for (std::map<std::string, Item*>::iterator itP = playlistItems.begin(); itP != playlistItems.end(); itP++)
+        {
+            info->playlistItems.push_back(itP->second);
+        }
+    }
 
-    if(dp == NULL)
+    if(info->playlists["favorites"] == NULL)
     {
         info->playlists["favorites"] = new std::vector<Item *>();
+    }
+
+    if(info->playlists["lastplayed"] == NULL)
+    {
+        info->playlists["lastplayed"] = new std::vector<Item *>();
+    }
+
+    return;
+}
+
+void CollectionInfoBuilder::loadPlaylistItems(CollectionInfo* info, std::map<std::string, Item*> playlistItems, std::string path)
+{
+    // get playlist cycle
+    std::string settingPrefix = "collections." + info->name + ".";
+    std::string cycleString;
+    // check if collection has different setting
+    if (conf_.propertyExists(settingPrefix + "cyclePlaylist")) {
+        conf_.getProperty(settingPrefix + "cyclePlaylist", cycleString);
+    }
+    else {
+        conf_.getProperty("cyclePlaylist", cycleString);
+    }
+    std::vector<std::string> cycleVector;
+    Utils::listToVector(cycleString, cycleVector, ',');
+
+    DIR* dp;
+    struct dirent* dirp;
+    dp = opendir(path.c_str());
+
+    if (dp == NULL)
+    {
+        info->playlists["favorites"] = new std::vector<Item*>();
         return;
     }
-    std::map<std::string, Item*> playlistItems;
 
-    while((dirp = readdir(dp)) != NULL)
+    while ((dirp = readdir(dp)) != NULL)
     {
         std::string file = dirp->d_name;
-
+        if (file == "." || file == "..") {
+            continue;
+        }
         size_t position = file.find_last_of(".");
-        std::string basename = (std::string::npos == position)? file : file.substr(0, position);
+        std::string basename = (std::string::npos == position) ? file : file.substr(0, position);
 
         std::string comparator = ".txt";
         int start = file.length() - comparator.length();
 
-        if(start >= 0)
+        if (start >= 0)
         {
-            if(file.compare(start, comparator.length(), comparator) == 0)
+            if (file.compare(start, comparator.length(), comparator) == 0)
             {
                 // don't include if not in cyclePlaylist
                 if (cycleVector.size() && std::find(cycleVector.begin(), cycleVector.end(), basename) == cycleVector.end()) {
@@ -462,11 +529,11 @@ void CollectionInfoBuilder::addPlaylists(CollectionInfo *info)
 
                 Logger::write(Logger::ZONE_INFO, "RetroFE", "Loading playlist: " + basename);
 
-                std::map<std::string, Item *> playlistFilter;
-                std::string playlistFile = Utils::combinePath(Configuration::absolutePath, "collections", info->name, "playlists", file);
+                std::map<std::string, Item*> playlistFilter;
+                std::string playlistFile = Utils::combinePath(path, file);
                 ImportBasicList(info, playlistFile, playlistFilter);
 
-                info->playlists[basename] = new std::vector<Item *>();
+                info->playlists[basename] = new std::vector<Item*>();
 
                 Item* playlistItem = new Item();
                 playlistItem->name = basename;
@@ -477,82 +544,58 @@ void CollectionInfoBuilder::addPlaylists(CollectionInfo *info)
                 playlistItems[basename] = playlistItem;
 
                 // add the playlist list 
-                for(std::map<std::string, Item *>::iterator it = playlistFilter.begin(); it != playlistFilter.end(); it++)
+                for (std::map<std::string, Item*>::iterator it = playlistFilter.begin(); it != playlistFilter.end(); it++)
                 {
                     std::string collectionName = info->name;
-                    std::string itemName       = it->first;
+                    std::string itemName = it->first;
                     if (itemName.at(0) == '_') // name consists of _<collectionName>:<itemName>
                     {
-                         itemName.erase(0, 1); // Remove _
-                         size_t position = itemName.find(":");
-                         if (position != std::string::npos )
-                         {
-                             collectionName = itemName.substr(0, position);
-                             itemName       = itemName.erase(0, position+1);
-                         }
+                        itemName.erase(0, 1); // Remove _
+                        size_t position = itemName.find(":");
+                        if (position != std::string::npos)
+                        {
+                            collectionName = itemName.substr(0, position);
+                            itemName = itemName.erase(0, position + 1);
+                        }
                     }
 
-                    for(std::vector<Item *>::iterator it = info->items.begin(); it != info->items.end(); it++)
+                    for (std::vector<Item*>::iterator it = info->items.begin(); it != info->items.end(); it++)
                     {
-                        if ( ((*it)->name == itemName || itemName == "*") && (*it)->collectionInfo->name == collectionName )
+                        if (((*it)->name == itemName || itemName == "*") && (*it)->collectionInfo->name == collectionName)
                         {
                             info->playlists[basename]->push_back((*it));
-                            if ( basename == "favorites" )
+                            if (basename == "favorites")
                                 (*it)->isFavorite = true;
                         }
                     }
                 }
-                while ( playlistFilter.size( ) > 0 )
+                while (playlistFilter.size() > 0)
                 {
-                    std::map<std::string, Item *>::iterator it = playlistFilter.begin();
+                    std::map<std::string, Item*>::iterator it = playlistFilter.begin();
                     delete it->second;
-                    playlistFilter.erase( it->first );
+                    playlistFilter.erase(it->first);
                 }
             }
         }
     }
-    // if cyclePlaylist then order playlist menu items by that
-    if (cycleVector.size())
-    {
-        // add in order according to cycle list
-        for (std::vector<std::string>::iterator itP = cycleVector.begin(); itP != cycleVector.end(); itP++)
-        {
-            if (playlistItems[*itP]) {
-                info->playlistItems.push_back(playlistItems[*itP]);
-            }
-        }
-    }
-    else {
-        // convert lookup playlist map to vector
-        for (std::map<std::string, Item*>::iterator itP = playlistItems.begin(); itP != playlistItems.end(); itP++)
-        {
-            info->playlistItems.push_back(itP->second);
-        }
-    }
-
-    if (dp) closedir(dp);
 
-    if(info->playlists["favorites"] == NULL)
-    {
-        info->playlists["favorites"] = new std::vector<Item *>();
-    }
-
-    if(info->playlists["lastplayed"] == NULL)
-    {
-        info->playlists["lastplayed"] = new std::vector<Item *>();
-    }
-
-    return;
+    closedir(dp);
 }
 
 
 void CollectionInfoBuilder::updateLastPlayedPlaylist(CollectionInfo *info, Item *item, int size)
 {
-    std::string path = Utils::combinePath(Configuration::absolutePath, "collections", info->name, "playlists");
+    std::string playlistCollectionName = info->name;
+    bool globalFavLast = false;
+    (void)conf_.getProperty("globalFavLast", globalFavLast);
+    if (globalFavLast) {
+        playlistCollectionName = "Favorites";
+    }
+    std::string path = Utils::combinePath(Configuration::absolutePath, "collections", playlistCollectionName, "playlists");
     Logger::write(Logger::ZONE_INFO, "RetroFE", "Updating lastplayed playlist");
 
     std::vector<Item *> lastplayedList;
-    std::string playlistFile = Utils::combinePath(Configuration::absolutePath, "collections", info->name, "playlists", "lastplayed.txt");
+    std::string playlistFile = Utils::combinePath(Configuration::absolutePath, "collections", playlistCollectionName, "playlists", "lastplayed.txt");
     ImportBasicList(info, playlistFile, lastplayedList);
 
     if (info->playlists["lastplayed"] == NULL)
@@ -595,8 +638,8 @@ void CollectionInfoBuilder::updateLastPlayedPlaylist(CollectionInfo *info, Item
     }
 
     // Write new lastplayed playlist
-    std::string dir  = Utils::combinePath(Configuration::absolutePath, "collections", info->name, "playlists");
-    std::string file = Utils::combinePath(Configuration::absolutePath, "collections", info->name, "playlists/lastplayed.txt");
+    std::string dir  = Utils::combinePath(Configuration::absolutePath, "collections", playlistCollectionName, "playlists");
+    std::string file = Utils::combinePath(Configuration::absolutePath, "collections", playlistCollectionName, "playlists", "lastplayed.txt");
     Logger::write(Logger::ZONE_INFO, "Collection", "Saving " + file);
 
     std::ofstream filestream;
@@ -637,7 +680,7 @@ void CollectionInfoBuilder::updateLastPlayedPlaylist(CollectionInfo *info, Item
         std::vector<Item *> *saveitems = info->playlists["lastplayed"];
         for(std::vector<Item *>::iterator it = saveitems->begin(); it != saveitems->end(); it++)
         {
-            if ((*it)->collectionInfo->name == info->name)
+            if ((*it)->collectionInfo->name == playlistCollectionName)
             {
                 filestream << (*it)->name << std::endl;
             }

RetroFE/Source/Collection/CollectionInfoBuilder.h

@@ -32,6 +32,7 @@ class CollectionInfoBuilder
     CollectionInfo *buildCollection(std::string collectionName);
     CollectionInfo *buildCollection(std::string collectionName, std::string mergedCollectionName);
     void addPlaylists(CollectionInfo *info);
+    void loadPlaylistItems(CollectionInfo* info, std::map<std::string, Item*> playlistItems, std::string path);
     void updateLastPlayedPlaylist(CollectionInfo *info, Item *item, int size);
     void injectMetadata(CollectionInfo *info);
     static bool createCollectionDirectory(std::string collectionName);

RetroFE/Source/RetroFE.cpp

@@ -2092,7 +2092,7 @@ CollectionInfo *RetroFE::getMenuCollection( std::string collectionName )
     std::string menuFile = Utils::combinePath( menuPath, collectionName + ".txt" );
     std::vector<Item *> menuVector;
     CollectionInfoBuilder cib( config_, *metadb_ );
-    CollectionInfo *collection = new CollectionInfo( collectionName, menuPath, "", "", "" );
+    CollectionInfo *collection = new CollectionInfo(config_, collectionName, menuPath, "", "", "" );
     cib.ImportBasicList( collection, menuFile, menuVector );
     for ( std::vector<Item *>::iterator it = menuVector.begin( ); it != menuVector.end( ); ++it)
     {