diff --git a/main.qml b/main.qml
index 775ec06..94ae4c3 100644
--- a/main.qml
+++ b/main.qml
@@ -1,1057 +1,1057 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.3
 import QtQuick.Layouts 1.3
 import QtGraphicalEffects 1.0
 import QtQuick.Controls.Material 2.1
 
 import "utils"
 
 import "widgets"
 import "widgets/PlaylistsView"
 import "widgets/MainPlaylist"
 import "widgets/SettingsView"
 import "widgets/SearchView"
 //import "widgets/CloudView"
 
 import "view_models"
 import "view_models/BabeTable"
 
 import "services/local"
 import "services/web"
 //import "services/web/Spotify"
 
 import "view_models/BabeGrid"
 
 import "widgets/InfoView"
 
 import "db/Queries.js" as Q
 import "utils/Help.js" as H
 import "utils/Player.js" as Player
 
 import org.kde.kirigami 2.7 as Kirigami
 import org.kde.mauikit 1.0 as Maui
 import Player 1.0
 import AlbumsList 1.0
 import TracksList 1.0
 
 import BaseModel 1.0
 import TracksList 1.0
 
 Maui.ApplicationWindow
 {
 
     id: root
     title: qsTr("vvave")
     /***************************************************/
     /******************** ALIASES ********************/
     /*************************************************/
     property alias mainPlaylist: mainPlaylist
     property alias selectionBar: _selectionBar
     property alias progressBar: progressBar
 
     about.appIcon: "qrc:/assets/vvave.svg"
     about.appDescription: qsTr("VVAVE will handle your whole music collection by retreaving semantic information from the web. Just relax, enjoy and discover your new music ")
     showAccounts: false
     /***************************************************/
     /******************** PLAYBACK ********************/
     /*************************************************/
     property bool isShuffle: Maui.FM.loadSettings("SHUFFLE","PLAYBACK", false)
     property var currentTrack: ({
                                     fav: "0",
                                     stars: "0"
                                 })
 
     property int currentTrackIndex: -1
     property int prevTrackIndex: 0
 
     property string currentArtwork: !mainlistEmpty ? mainPlaylist.list.get(0).artwork : ""
     property bool currentBabe: currentTrack.fav == "0" ? false : true
 
     property alias durationTimeLabel: player.duration
     property string progressTimeLabel: player.transformTime(player.position/1000)
 
     property alias isPlaying: player.playing
     property int onQueue: 0
 
     property bool mainlistEmpty: !mainPlaylist.table.count > 0
 
     /***************************************************/
     /******************** HANDLERS ********************/
     /*************************************************/
 
     property int currentView: viewsIndex.tracks
 
     readonly property var viewsIndex: ({
                                            tracks: 0,
                                            albums: 1,
                                            artists: 2,
                                            playlists: 3,
                                            search: 4,
                                            folders: 5,
                                            //                                           cloud: 6,
                                            //                                           vvave: 7,
                                            //                                           linking: 8,
                                            youtube: 6,
                                            //                                           spotify: 10
 
                                        })
 
     property string syncPlaylist: ""
     property bool sync: false
 
     property string infoMsg: ""
     property bool infoLabels: Maui.FM.loadSettings("LABELS", "PLAYBACK", false) == "true" ? true : false
 
     //    property bool isLinked: false
     //    property bool isServing: false
 
     //    property bool focusMode : false
     property bool selectionMode : false
 
     /***************************************************/
     /******************** UI COLORS *******************/
     /*************************************************/
     readonly property color babeColor: "#f84172"
 
     /*SIGNALS*/
     signal missingAlert(var track)
 
 
     /*HANDLE EVENTS*/
     onClosing: Player.savePlaylist()
     onMissingAlert:
     {
         var message = track.title + " by " + track.artist + " is missing"
         var messageBody = "Do you want to remove it from your collection?"
         notify("alert", message, messageBody, function ()
         {
             //            bae.removeTrack(currentTrack.url) //todo
             mainPlaylist.table.model.remove(mainPlaylist.table.currentIndex)
         })
     }
 
     /*COMPONENTS*/
 
     Player
     {
         id: player
         volume: 100
         onFinishedChanged: if (!mainlistEmpty)
                            {
                                if (currentTrack.url)
                                    mainPlaylist.list.countUp(currentTrackIndex)
 
                                Player.nextTrack()
                            }
     }
 
     //    BabeNotify
     //    {
     //        id: babeNotify //todo
     //    }
 
 
     /* UI */
 //    accentColor: babeColor
     //    headBarFGColor: altColorText
     //    headBarBGColor: "#212121"
     //    altColorText: darkTextColor
 
 //    headBar.spacing: space.big
     headBar.middleContent : Kirigami.ActionToolBar
     {
         display: isWide ? ToolButton.TextBesideIcon : ToolButton.IconOnly
         position: ToolBar.Header
         Layout.fillWidth: true
         hiddenActions: [
 
             Kirigami.Action
             {
                 text: qsTr("Folders")
                 icon.name: "folder"
                 checked: currentView === viewsIndex.folders
                 checkable: false
                 onTriggered: currentView = viewsIndex.folders
             },
 
             Kirigami.Action
             {
                 text: qsTr("YouTube")
                 checkable: false
                 icon.name: "internet-services"
                 checked: currentView === viewsIndex.youtube
                 onTriggered: currentView = viewsIndex.youtube
 
             }
 
         ]
         actions: [
             Kirigami.Action
             {
                 icon.name: "view-media-track"
                 checked: currentView === viewsIndex.tracks
                 //            showIndicator: true
                 //            icon.color: active ? babeColor : altColorText
                 onTriggered: currentView = viewsIndex.tracks
                 text: qsTr("Tracks")
                 checkable: false
                 //            colorScheme.highlightColor: babeColor
                 //            spacing: 0
 
             },
 
             Kirigami.Action
             {
                 text: qsTr("Albums")
                 checkable: false
                 checked: currentView === viewsIndex.albums
                 icon.name: /*"album"*/ "view-media-album-cover"
                 //            icon.color: currentView === viewsIndex.albums ? babeColor : altColorText
                 onTriggered: currentView = viewsIndex.albums
                 //            colorScheme.highlightColor: babeColor
                 //            showIndicator: true
 
             },
 
             Kirigami.Action
             {
                 text: qsTr("Artists")
                 checkable: false
                 checked: currentView === viewsIndex.artists
                 icon.name: "view-media-artist"
                 Kirigami.Theme.textColor:  currentView === viewsIndex.artists ? babeColor : altColorText
                 onTriggered: currentView = viewsIndex.artists
                 //            colorScheme.highlightColor: babeColor
                 //            showIndicator: true
             },
 
             Kirigami.Action
             {
                 text: qsTr("Playlists")
                 checkable: false
                 checked: currentView === viewsIndex.playlists
                 icon.name: "view-media-playlist"
                 //            icon.color: currentView === viewsIndex.playlists ? babeColor : altColorText
                 onTriggered: currentView = viewsIndex.playlists
                 //            colorScheme.highlightColor: babeColor
                 //            showIndicator: true
 
             }
 
         ]
     }
 
     footBar.visible: !mainlistEmpty
     footBar.implicitHeight: footBar.visible ? toolBarHeight * 1.2 : 0
     footer: ColumnLayout
     {
         id: _footerLayout
 
         height: footBar.height
         width: root.width
         spacing: 0
 
         Slider
         {
             id: progressBar
             Layout.preferredHeight: unit * (isMobile ?  6 : 8)
             Layout.fillWidth: true
 
             padding: 0
             from: 0
             to: 1000
             value: player.pos
             spacing: 0
             focus: true
             onMoved:
             {
                 player.pos = value
             }
 
             background: Rectangle
             {
                 implicitWidth: progressBar.width
                 implicitHeight: progressBar.height
                 width: progressBar.availableWidth
                 height: implicitHeight
                 color: "transparent"
 
                 Rectangle
                 {
                     width: progressBar.visualPosition * parent.width
                     height: progressBar.height
                     color: babeColor
                 }
             }
 
             handle: Rectangle
             {
                 x: progressBar.leftPadding + progressBar.visualPosition
                    * (progressBar.availableWidth - width)
                 y: -(progressBar.height * 0.8)
                 implicitWidth: progressBar.pressed ? iconSizes.medium : 0
                 implicitHeight: progressBar.pressed ? iconSizes.medium : 0
                 radius: progressBar.pressed ? iconSizes.medium : 0
                 color: babeColor
             }
         }
 
 //        Kirigami.Separator
 //        {
 //            Layout.fillWidth: true
 ////            color: borderColor
 //        }
 
         Maui.ToolBar
         {
             Layout.fillHeight: true
             Layout.fillWidth: true
 
             position: ToolBar.Footer
             leftContent:  ToolButton
             {
                 icon.name: "headphones"
                 visible: _drawer.modal
                 checked: _drawer.visible
                 icon.color: _drawer.visible ? babeColor : textColor
                 onClicked: _drawer.visible = !_drawer.visible
                 Kirigami.Theme.highlightColor: babeColor
                 //                text: qsTr("Now")
             }
 
             middleContent: [
                 ToolButton
                 {
                     id: babeBtnIcon
                     icon.name: "love"
                     enabled: currentTrackIndex >= 0
                     icon.color: currentBabe ? babeColor : textColor
                     onClicked: if (!mainlistEmpty)
                     {
                         mainPlaylist.list.fav(currentTrackIndex, !(mainPlaylist.list.get(currentTrackIndex).fav == "1"))
                         currentBabe = mainPlaylist.list.get(currentTrackIndex).fav == "1"
                     }
                 },
 
                 ToolButton
                 {
                     icon.name: "media-skip-backward"
                     icon.color: textColor
                     onClicked: Player.previousTrack()
                     onPressAndHold: Player.playAt(prevTrackIndex)
                 },
 
                 ToolButton
                 {
                     id: playIcon
                     enabled: currentTrackIndex >= 0
                     icon.color: textColor
                     icon.name: isPlaying ? "media-playback-pause" : "media-playback-start"
                     onClicked: player.playing = !player.playing
                 },
 
                 ToolButton
                 {
                     id: nextBtn
                     icon.color: textColor
                     icon.name: "media-skip-forward"
                     onClicked: Player.nextTrack()
                     onPressAndHold: Player.playAt(Player.shuffle())
                 },
 
                 ToolButton
                 {
                     id: shuffleBtn
                     icon.color: babeColor
                     icon.name: isShuffle ? "media-playlist-shuffle" : "media-playlist-normal"
                     onClicked:
                     {
                         isShuffle = !isShuffle
                         Maui.FM.saveSettings("SHUFFLE", isShuffle, "PLAYBACK")
                     }
                 }
             ]
         }
     }
 
 
     //    leftIcon.icon.color: currentView === viewsIndex.search ? babeColor : altColorText
     onSearchButtonClicked:
     {
         currentView = viewsIndex.search
         searchView.searchInput.forceActiveFocus()
     }
 
     InfoView
     {
         id: infoView
         maxWidth: parent.width * 0.8
         maxHeight: parent.height * 0.9
     }
 
     Maui.ShareDialog
     {
         id: shareDialog
     }
 
     Maui.FileDialog
     {
         id: fmDialog
     }
 
     SourcesDialog
     {
         id: sourcesDialog
     }
 
     mainMenu: [
 
         //        Maui.MenuItem
         //        {
         //            text: "Vvave Stream"
         //            icon.name: "headphones"
         //            onTriggered:
         //            {
         //                pageStack.currentIndex = 1
         //                currentView = viewsIndex.vvave
         //            }
         //        },
 
 
         //        Maui.MenuItem
         //        {
         //            text: qsTr("Linking")
         //            icon.name: "view-links"
         //            onTriggered:
         //            {
         //                pageStack.currentIndex = 1
         //                currentView = viewsIndex.linking
         //                if(!isLinked) linkingView.linkingConf.open()
         //            }
         //        },
 
 
 
         //        Maui.MenuItem
         //        {
         //            text: qsTr("Cloud")
         //            icon.name: "folder-cloud"
         //            onTriggered:
         //            {
         //                pageStack.currentIndex = 1
         //                currentView = viewsIndex.cloud
         //            }
         //        },
 
 
         //        Maui.MenuItem
         //        {
         //            text: qsTr("Spotify")
         //            icon.name: "internet-services"
         //            onTriggered:
         //            {
         //                pageStack.currentIndex = 1
         //                currentView = viewsIndex.spotify
         //            }
         //        },
 
         MenuSeparator{},
 
         MenuItem
         {
             text: qsTr("Sources...")
             icon.name: "folder-add"
             onTriggered: sourcesDialog.open()
         },
 
         MenuItem
         {
             text: qsTr("Open...")
             icon.name: "folder-add"
             onTriggered:
             {
                 fmDialog.onlyDirs = false
                 fmDialog.filterType = Maui.FMList.AUDIO
                 fmDialog.show(function(paths)
                 {
                     vvave.openUrls(paths)
                 })
             }
         }/*,
 
                 Menu
                 {
                     title: qsTr("Collection")
                     //            icon.name: "settings-configure"
 
                     MenuItem
                     {
                         text: qsTr("Re-Scan")
                         onTriggered: bae.refreshCollection();
                     }
 
                     MenuItem
                     {
                         text: qsTr("Refresh...")
                         onTriggered: H.refreshCollection();
                     }
 
                     MenuItem
                     {
                         text: qsTr("Clean")
                         onTriggered: bae.removeMissingTracks();
                     }
                 }*/
 
         //        Maui.Menu
         //        {
         //            title: qsTr("Settings...")
         //            //            Kirigami.Action
         //            //            {
         //            //                text: "Brainz"
 
         //            //                Kirigami.Action
         //            //                {
         //            //                    id: brainzToggle
         //            //                    text: checked ? "Turn OFF" : "Turn ON"
         //            //                    checked: bae.brainzState()
         //            //                    checkable: true
         //            //                    onToggled:
         //            //                    {
         //            //                        checked = !checked
         //            //                        bae.saveSetting("AUTO", checked, "BRAINZ")
         //            ////                        bae.brainz(checked)
         //            //                    }
         //            //                }
         //            //            }
 
 
 
         //            Maui.MenuItem
         //            {
         //                text: "Info label" + checked ? "ON" : "OFF"
         //                checked: infoLabels
         //                checkable: true
         //                onToggled:
         //                {
         //                    infoLabels = checked
         //                    bae.saveSetting("LABELS", infoLabels ? true : false, "PLAYBACK")
 
         //                }
         //            }
 
         //            Maui.MenuItem
         //            {
         //                text: "Autoplay"
         //                checked: autoplay
         //                checkable: true
         //                onToggled:
         //                {
         //                    autoplay = checked
         //                    bae.saveSetting("AUTOPLAY", autoplay ? true : false, "BABE")
         //                }
         //            }
         //        }
     ]
 
     Item
     {
         id: message
         visible: infoMsg.length && sync
         anchors.bottom: parent.bottom
         width: parent.width
         height: iconSize
         z: 999
 
         Rectangle
         {
             id: infoBg
 
             anchors.fill: parent
             z: -999
             color: altColor
             opacity: 0.8
 
             SequentialAnimation
             {
                 id: animBg
                 PropertyAnimation
                 {
                     target: infoBg
                     property: "color"
                     easing.type: Easing.InOutQuad
                     to: babeColor
                     duration: 250
                 }
 
                 PropertyAnimation
                 {
                     target: infoBg
                     property: "color"
                     easing.type: Easing.InOutQuad
                     to: altColor
                     duration: 500
                 }
             }
         }
 
         Label
         {
             id: infoTxt
             anchors.centerIn: parent
             anchors.fill: parent
             height: parent.height
             width: parent.width
             font.pointSize: fontSizes.medium
             text: infoMsg
             horizontalAlignment: Qt.AlignHCenter
             verticalAlignment: Qt.AlignVCenter
             color: textColor
 
             SequentialAnimation
             {
                 id: animTxt
                 PropertyAnimation
                 {
                     target: infoTxt
                     property: "color"
                     easing.type: Easing.InOutQuad
                     to: "white"
                     duration: 250
                 }
 
                 PropertyAnimation
                 {
                     target: infoTxt
                     property: "color"
                     easing.type: Easing.InOutQuad
                     to: textColor
                     duration: 500
                 }
             }
         }
     }
 
     PlaylistDialog
     {
         id: playlistDialog
     }
 
     globalDrawer: Maui.GlobalDrawer
     {
         id: _drawer
         width: Math.min(Kirigami.Units.gridUnit * 18, root.width)
         height: root.height - root.headBar.implicitHeight - root.footBar.implicitHeight
         modal: !isWide
-        handleVisible: modal
+        handleVisible: false
         closePolicy: Popup.NoAutoClose
         contentItem: MainPlaylist
         {
             id: mainPlaylist
             Connections
             {
                 target: mainPlaylist
                 onCoverPressed: Player.appendAll(tracks)
                 onCoverDoubleClicked: Player.playAll(tracks)
             }
         }
     }
 
     ColumnLayout
     {
         anchors.fill: parent
 
         SwipeView
         {
             id: swipeView
             Layout.fillHeight: true
             Layout.fillWidth: true
             interactive: isMobile
             currentIndex: currentView
 
             onCurrentItemChanged: currentItem.forceActiveFocus()
 
             onCurrentIndexChanged:
             {
                 currentView = currentIndex
                 //                if (!babeitView.isConnected && currentIndex === viewsIndex.vvave)
                 //                    babeitView.logginDialog.open()
             }
 
 
             TracksView
             {
                 id: tracksView
                 Connections
                 {
                     target: tracksView
                     onRowClicked: Player.addTrack(tracksView.list.get(index))
                     onQuickPlayTrack: Player.quickPlay(tracksView.list.get(index))
                     onPlayAll:
                     {
                         var query = Q.GET.allTracks
 
                         mainPlaylist.list.clear()
                         mainPlaylist.list.query = query
                         Player.playAll()
                     }
                     onAppendAll:
                     {
                         mainPlaylist.list.appendQuery(Q.GET.allTracks)
                         mainPlaylist.listView.positionViewAtEnd()
                     }
 
                     onQueueTrack: Player.queueTracks([tracksView.list.get(index)], index)
                 }
             }
 
             AlbumsView
             {
                 id: albumsView
 
                 holder.emoji: "qrc:/assets/MusicBox.png"
                 holder.isMask: false
                 holder.title : "No Albums!"
                 holder.body: "Add new music sources"
                 holder.emojiSize: iconSizes.huge
                 title: count + qsTr(" albums")
                 list.query: Albums.ALBUMS
                 list.sortBy: Albums.ALBUM
 
                 Connections
                 {
                     target: albumsView
                     onRowClicked: Player.addTrack(track)
                     onPlayTrack: Player.quickPlay(track)
 
                     onAlbumCoverClicked: albumsView.populateTable(album, artist)
 
                     onAlbumCoverPressedAndHold:
                     {
                         var query = Q.GET.albumTracks_.arg(album)
                         query = query.arg(artist)
 
                         mainPlaylist.list.clear()
                         mainPlaylist.list.sortBy = Tracks.NONE
                         mainPlaylist.list.query = query
                         Player.playAll()
                     }
 
                     onPlayAll:
                     {
                         var query = Q.GET.albumTracks_.arg(album)
                         query = query.arg(artist)
                         query = query.arg(data.artist)
 
                         mainPlaylist.list.clear()
                         mainPlaylist.list.query = query
                         Player.playAll()
                     }
 
                     onAppendAll:
                     {
                         var query = Q.GET.albumTracks_.arg(album)
                         query = query.arg(artist)
 
                         mainPlaylist.list.appendQuery(query)
                         mainPlaylist.listView.positionViewAtEnd()
                     }
                 }
             }
 
             AlbumsView
             {
                 id: artistsView
 
                 holder.emoji: "qrc:/assets/MusicBox.png"
                 holder.isMask: false
                 holder.title : qsTr("No Artists!")
                 holder.body: qsTr("Add new music sources")
                 holder.emojiSize: iconSizes.huge
                 title: count + qsTr(" artists")
                 list.query: Albums.ARTISTS
                 list.sortBy: Albums.ARTIST
                 table.list.sortBy:  Tracks.NONE
 
                 Connections
                 {
                     target: artistsView
                     onRowClicked: Player.addTrack(track)
                     onPlayTrack: Player.quickPlay(track)
                     onAlbumCoverClicked: artistsView.populateTable(undefined, artist)
 
                     onAlbumCoverPressedAndHold:
                     {
                         var query = Q.GET.artistTracks_.arg(artist)
                         mainPlaylist.list.clear()
                         mainPlaylist.list.sortBy = Tracks.NONE
                         mainPlaylist.list.query = query
                         Player.playAll()
                     }
 
                     onPlayAll:
                     {
                         var query = Q.GET.artistTracks_.arg(artist)
                         query = query.arg(data.artist)
 
                         mainPlaylist.list.clear()
                         mainPlaylist.list.sortBy = Tracks.NONE
                         mainPlaylist.list.query = query
                         Player.playAll()
                     }
 
                     onAppendAll:
                     {
                         var query = Q.GET.artistTracks_.arg(artist)
 
                         mainPlaylist.list.appendQuery(query)
                         mainPlaylist.listView.positionViewAtEnd()
                     }
                 }
             }
 
             PlaylistsView
             {
                 id: playlistsView
 
                 Connections
                 {
                     target: playlistsView
                     onRowClicked: Player.addTrack(track)
                     onQuickPlayTrack: Player.quickPlay(track)
 
                     onPlayAll:
                     {
                         var query = playlistsView.playlistQuery
                         mainPlaylist.list.clear()
                         mainPlaylist.list.sortBy = Tracks.NONE
                         mainPlaylist.list.query = query
                         Player.playAll()
                     }
 
                     onAppendAll:
                     {
                         var query = playlistsView.playlistQuery
 
                         mainPlaylist.list.appendQuery(query)
                         mainPlaylist.listView.positionViewAtEnd()
                     }
 
                     onPlaySync:
                     {
                         var query = playlistsView.playlistQuery
                         mainPlaylist.list.appendQuery(query)
                         Player.playAll()
 
                         root.sync = true
                         root.syncPlaylist = playlist
                         root.infoMsg = qsTr("Syncing to ") + playlist
                     }
                 }
             }
 
 
             SearchTable
             {
                 id: searchView
 
                 Connections
                 {
                     target: searchView
                     onRowClicked: Player.addTrack(searchView.list.get(index))
                     onQuickPlayTrack: Player.quickPlay(searchView.list.get(index))
                     onPlayAll:
                     {
                         mainPlaylist.list.clear()
                         var tracks = searchView.list.getAll()
                         for(var i in tracks)
                             Player.appendTrack(tracks[i])
 
                         Player.playAll()
                     }
 
                     onAppendAll: Player.appendAll(searchView.list.getAll())
                     onArtworkDoubleClicked:
                     {
                         var query = Q.GET.albumTracks_.arg(
                                     searchView.searchTable.model.get(
                                         index).album)
                         query = query.arg(searchView.searchTable.model.get(
                                               index).artist)
 
                         mainPlaylist.list.clear()
                         mainPlaylist.list.sortBy = Tracks.NONE
                         mainPlaylist.list.query = query
                         Player.playAll()
                     }
                 }
             }
 
             FoldersView
             {
                 id: foldersView
 
                 Connections
                 {
                     target: foldersView.list
 
                     onRowClicked: Player.addTrack(foldersView.list.model.get(index))
                     onQuickPlayTrack: Player.quickPlay(foldersView.list.model.get(index))
                     onPlayAll:
                     {
                         mainPlaylist.list.clear()
                         //                        mainPlaylist.list.sortBy = Tracks.NONE
                         mainPlaylist.list.query = foldersView.list.list.query
                         Player.playAll()
                     }
 
                     onAppendAll:
                     {
                         var query = foldersView.list.list.query
                         mainPlaylist.list.appendQuery(query)
                         mainPlaylist.listView.positionViewAtEnd()
                     }
 
                     onQueueTrack: Player.queueTracks([foldersView.list.model.get(index)], index)
                 }
             }
 
             //            CloudView
             //            {
             //                id: cloudView
             //                onQuickPlayTrack: Player.quickPlay(cloudView.list.get(index))
             //            }
 
             //            BabeitView
             //            {
             //                id: babeitView
             //            }
 
             //            LinkingView
             //            {
             //                id: linkingView
             //            }
 
             YouTube
             {
                 id: youtubeView
             }
 
             //            Spotify
             //            {
             //                id: spotifyView
             //            }
         }
 
         Maui.SelectionBar
         {
             id: _selectionBar
             property alias listView: _selectionBar.selectionList
             Layout.fillWidth: true
             Layout.margins: space.big
             Layout.topMargin: space.small
             Layout.bottomMargin: space.big
             onIconClicked: _contextMenu.popup()
             onExitClicked: clear()
 //            Kirigami.Theme.backgroundColor: "#212121"
 
 //            model: BaseModel
 //            {
 //                list: _selectionBarModelList
 //            }
 
 //            Tracks
 //            {
 //                id: _selectionBarModelList
 //            }
 
             SelectionBarMenu
             {
                 id: _contextMenu
             }
 
 //            function append(item)
 //            {
 //                _selectionBar.append(item)
 
 ////                if(selectedPaths.indexOf(item.path) < 0)
 ////                {
 ////                    selectedItems.push(item)
 ////                    selectedPaths.push(item.path)
 
 ////                    //             for(var i = 0; i < selectionList.count ; i++ )
 ////                    //                 if(selectionList.model.get(i).path === item.path)
 ////                    //                 {
 ////                    //                     selectionList.model.remove(i)
 ////                    //                     return
 ////                    //                 }
 
 ////                    selectionList.model.list.append(item)
 ////                    selectionList.positionViewAtEnd()
 
 ////                }
 //            }
         }
     }
 
 
     /*animations*/
 
 
     /*FUNCTIONS*/
     function infoMsgAnim()
     {
         animBg.running = true
         animTxt.running = true
     }
 
 
     function toggleMaximized()
     {
         if (root.visibility === Window.Maximized) {
             root.showNormal();
         } else {
             root.showMaximized();
         }
     }
 
 
     /*CONNECTIONS*/
 
     Connections
     {
         target: vvave
 
 //        onRefreshTables: H.refreshCollection(size)
 //        onRefreshTracks: H.refreshTracks()
 //        onRefreshAlbums: H.refreshAlbums()
 //        onRefreshArtists: H.refreshArtists()
 
         //        onCoverReady:
         //        {
         //            root.currentArtwork = path
         //            currentTrack.artwork = currentArtwork
         //            mainPlaylist.list.update(currentTrack, currentTrackIndex);
         //        }
 
         //        onTrackLyricsReady:
         //        {
         //            console.log(lyrics)
         //            if (url === currentTrack.url)
         //                Player.setLyrics(lyrics)
         //        }
 
         //        onSkipTrack: Player.nextTrack()
         //        onBabeIt: if (!mainlistEmpty)
         //                  {
         //                      mainPlaylist.list.fav(currentTrackIndex, !(mainPlaylist.list.get(currentTrackIndex).fav == "1"))
         //                      currentBabe = mainPlaylist.list.get(currentTrackIndex).fav == "1"
         //                  }
 
         onOpenFiles:
         {
             Player.appendTracksAt(tracks, 0)
             Player.playAt(0)
         }
     }
 }
diff --git a/models/cloud/cloud.cpp b/models/cloud/cloud.cpp
index 116f128..772377a 100644
--- a/models/cloud/cloud.cpp
+++ b/models/cloud/cloud.cpp
@@ -1,197 +1,197 @@
 #include "cloud.h"
 #include "services/local/taginfo.h"
 
 Cloud::Cloud(QObject *parent) : BaseList (parent)
 {
     this->fm = new FM(this);
     this->setList();
 
-    connect(this->fm, &FM::cloudServerContentReady, [this](const FMH::MODEL_LIST &list, const QString &url)
-    {
-        Q_UNUSED(url);
-        emit this->preListChanged();
-        this->list = list;
-        this->formatList();
-        emit this->postListChanged();
-    });
+//    connect(this->fm, &FM::cloudServerContentReady, [this](const FMH::MODEL_LIST &list, const QString &url)
+//    {
+//        Q_UNUSED(url);
+//        emit this->preListChanged();
+//        this->list = list;
+//        this->formatList();
+//        emit this->postListChanged();
+//    });
 
     connect(this->fm, &FM::warningMessage, [this](const QString &message)
     {
         emit this->warning(message);
     });
 
     connect(this->fm, &FM::newItem, [this](const FMH::MODEL &item, const QString &path)
     {
         auto newItem = item;
         auto url = item[FMH::MODEL_KEY::URL];
         auto thumbnail = item[FMH::MODEL_KEY::THUMBNAIL];
 
         newItem[FMH::MODEL_KEY::FAV] = QString("0");
         newItem[FMH::MODEL_KEY::RATE] = QString("0");
         newItem[FMH::MODEL_KEY::URL] = FMH::fileExists(thumbnail)? thumbnail : item[FMH::MODEL_KEY::URL];
         newItem[FMH::MODEL_KEY::SOURCE] = FMH::fileExists(thumbnail)? thumbnail : item[FMH::MODEL_KEY::PATH];
 
         if(FMH::fileExists(thumbnail))
         {
             qDebug()<< "file exists:" << thumbnail;
             TagInfo info;
             info.feed(thumbnail);
 
             newItem[FMH::MODEL_KEY::ARTIST] = info.getArtist();
             newItem[FMH::MODEL_KEY::ALBUM] = info.getAlbum();
             newItem[FMH::MODEL_KEY::TITLE] = info.getTitle();
             newItem[FMH::MODEL_KEY::RELEASEDATE] = QString::number(info.getYear());
             newItem[FMH::MODEL_KEY::TRACK] = QString::number(info.getTrack());
         }else
             newItem[FMH::MODEL_KEY::TITLE] = item[FMH::MODEL_KEY::LABEL];
 
         emit this->preItemAppended();
         this->list << newItem;
         emit this->postItemAppended();
 
     });
 
     connect(this->fm, &FM::cloudItemReady, [this](const FMH::MODEL &item, const QString &path)
     {
         qDebug()<< "REQUESTED CLOUD IMAGE READY << " << item;
         Q_UNUSED(path);
         auto newItem = item;
         auto url = item[FMH::MODEL_KEY::URL];
         auto thumbnail = item[FMH::MODEL_KEY::THUMBNAIL];
 
         newItem[FMH::MODEL_KEY::FAV] = QString("0");
         newItem[FMH::MODEL_KEY::RATE] = QString("0");
         newItem[FMH::MODEL_KEY::URL] = FMH::fileExists(thumbnail)? thumbnail : item[FMH::MODEL_KEY::URL];
         newItem[FMH::MODEL_KEY::SOURCE] = FMH::fileExists(thumbnail)? thumbnail : item[FMH::MODEL_KEY::PATH];
 
         if(FMH::fileExists(thumbnail))
         {
             qDebug()<< "file exists:" << thumbnail;
             TagInfo info;
             info.feed(thumbnail);
 
             newItem[FMH::MODEL_KEY::ARTIST] = info.getArtist();
             newItem[FMH::MODEL_KEY::ALBUM] = info.getAlbum();
             newItem[FMH::MODEL_KEY::TITLE] = info.getTitle();
             newItem[FMH::MODEL_KEY::RELEASEDATE] = QString::number(info.getYear());
             newItem[FMH::MODEL_KEY::TRACK] = QString::number(info.getTrack());
         }else
             newItem[FMH::MODEL_KEY::TITLE] = item[FMH::MODEL_KEY::LABEL];
 
 
-        this->update(FM::toMap(newItem), this->pending.take(QString(item[FMH::MODEL_KEY::PATH]).replace(FMH::CloudCachePath+"opendesktop", FMH::PATHTYPE_NAME[FMH::PATHTYPE_KEY::CLOUD_PATH])));
+        this->update(FM::toMap(newItem), this->pending.take(QString(item[FMH::MODEL_KEY::PATH]).replace(FMH::CloudCachePath+"opendesktop", FMH::PATHTYPE_URI[FMH::PATHTYPE_KEY::CLOUD_PATH])));
         emit this->cloudItemReady(FM::toMap(newItem));
     });
 }
 
 FMH::MODEL_LIST Cloud::items() const
 {
     return this->list;
 }
 
 void Cloud::setAccount(const QString value)
 {
     if(this->account == value)
         return;
 
     this->account = value;
     emit this->accountChanged();
 
     this->setList();
 }
 
 QString Cloud::getAccount() const
 {
     return this->account;
 }
 
 void Cloud::setList()
 {
     emit this->preListChanged();
     this->list.clear();
-    this->fm->getCloudServerContent(FMH::PATHTYPE_NAME[FMH::PATHTYPE_KEY::CLOUD_PATH]+"/"+this->account, FMH::FILTER_LIST[FMH::FILTER_TYPE::AUDIO], 3);
+    this->fm->getCloudServerContent(FMH::PATHTYPE_URI[FMH::PATHTYPE_KEY::CLOUD_PATH]+"/"+this->account, FMH::FILTER_LIST[FMH::FILTER_TYPE::AUDIO], 3);
     emit this->postListChanged();
 }
 
 void Cloud::formatList()
 {
     for(auto &item : this->list)
     {
         auto url = item[FMH::MODEL_KEY::URL];
         auto thumbnail = item[FMH::MODEL_KEY::THUMBNAIL];
 
         item[FMH::MODEL_KEY::FAV] = QString("0");
         item[FMH::MODEL_KEY::RATE] = QString("0");
         item[FMH::MODEL_KEY::URL] = FMH::fileExists(thumbnail)? thumbnail : item[FMH::MODEL_KEY::URL];
         item[FMH::MODEL_KEY::SOURCE] = FMH::fileExists(thumbnail)? thumbnail : item[FMH::MODEL_KEY::PATH];
 
         qDebug()<< "CLOUD FILE" << thumbnail;
 
         if(FMH::fileExists(thumbnail))
         {
             qDebug()<< "file exists:" << thumbnail;
             TagInfo info;
             info.feed(thumbnail);
 
             item[FMH::MODEL_KEY::ARTIST] = info.getArtist();
             item[FMH::MODEL_KEY::ALBUM] = info.getAlbum();
             item[FMH::MODEL_KEY::TITLE] = info.getTitle();
             item[FMH::MODEL_KEY::RELEASEDATE] = QString::number(info.getYear());
             item[FMH::MODEL_KEY::TRACK] = QString::number(info.getTrack());
         }else
         {
             item[FMH::MODEL_KEY::TITLE] = item[FMH::MODEL_KEY::LABEL];
         }
     }
 }
 
 QVariantMap Cloud::get(const int &index) const
 {
     if(index >= this->list.size() || index < 0)
         return QVariantMap();
 
     QVariantMap res;
     const auto item = this->list.at(index);
 
     for(auto key : item.keys())
         res.insert(FMH::MODEL_NAME[key], item[key]);
 
     return res;
 }
 
 void Cloud::requestFile(const int &index)
 {
     if(index < 0 || index >= this->list.size())
         return;
 
     this->pending.insert(this->list[index][FMH::MODEL_KEY::PATH], index);
     qDebug()<< "1-PEDNIGN CLOUD"<< this->pending;
 
     this->fm->getCloudItem(FM::toMap(this->list[index]));
 }
 
 bool Cloud::update(const QVariantMap &data, const int &index)
 {
     if(index < 0 || index >= this->list.size())
         return false;
 
     auto newData = this->list[index];
     QVector<int> roles;
 
     for(auto key : data.keys())
         if(newData[FMH::MODEL_NAME_KEY[key]] != data[key].toString())
         {
             newData.insert(FMH::MODEL_NAME_KEY[key], data[key].toString());
             roles << FMH::MODEL_NAME_KEY[key];
         }
 
     this->list[index] = newData;
 
     emit this->updateModel(index, roles);
     return true;
 }
 
 void Cloud::upload(const QString &url)
 {
-    this->fm->copy({FMH::getFileInfo(url)}, FMH::PATHTYPE_NAME[FMH::PATHTYPE_KEY::CLOUD_PATH]+"/"+this->account);
+    this->fm->copy({FMH::getFileInfo(url)}, FMH::PATHTYPE_URI[FMH::PATHTYPE_KEY::CLOUD_PATH]+"/"+this->account);
 }
diff --git a/widgets/MainPlaylist/MainPlaylist.qml b/widgets/MainPlaylist/MainPlaylist.qml
index 6588b1d..9f3f034 100644
--- a/widgets/MainPlaylist/MainPlaylist.qml
+++ b/widgets/MainPlaylist/MainPlaylist.qml
@@ -1,207 +1,206 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
 import QtQuick.Layouts 1.3
 import QtGraphicalEffects 1.0
 import org.kde.kirigami 2.2 as Kirigami
 import org.kde.mauikit 1.0 as Maui
 
 
 import "../../utils/Player.js" as Player
 import "../../db/Queries.js" as Q
 import "../../utils"
 import "../../widgets"
 import "../../view_models"
 import "../../view_models/BabeTable"
 
 Maui.Page
 {
     id: mainPlaylistRoot
 
     property alias albumsRoll : albumsRoll
     property alias list : table.list
     property alias listModel: table.listModel
     property alias listView : table.listView
     property alias table: table
     property alias menu : playlistMenu
 
     property alias contextMenu: table.contextMenu
 
     signal coverDoubleClicked(var tracks)
     signal coverPressed(var tracks)
     focus: true
     headBar.visible: false
 
     PlaylistMenu
     {
         id: playlistMenu
         onClearOut: Player.clearOutPlaylist()
         //        onHideCover: cover.visible = !cover.visible
         onClean: Player.cleanPlaylist()
         onSaveToClicked: table.saveList()
     }
 
     footBar.visible: !mainlistEmpty
     footBar.implicitHeight: toolBarHeight * 1.3
     footBar.width: parent.width
     footBar.middleContent: AlbumsRoll
     {
 //        height: toolBarHeight * 1.3
         Layout.fillWidth: true
         Layout.fillHeight: true
 //        width: footBar.width
 //        height: footBar.height
         id: albumsRoll
     }
 
     footBar.background: Item
     {
         id: footerBg
         clip : true
         height: footBar.implicitHeight
 
         Image
         {
             id: artworkBg
             height: parent.height
             width: parent.width
 
             sourceSize.width: parent.width
             sourceSize.height: parent.height
 
             fillMode: Image.PreserveAspectCrop
-            cache: true
             antialiasing: true
             smooth: true
             asynchronous: true
 
             source: "file://"+encodeURIComponent(currentArtwork)
         }
 
         FastBlur
         {
             id: fastBlur
             anchors.fill: parent
             y:1
             source: artworkBg
             radius: 100
             transparentBorder: false
             cached: true
             z:1
             clip: true
 
             Rectangle
             {
                 anchors.fill: parent
                 color: Kirigami.Theme.viewBackgroundColor
                 opacity: 0.85
             }
         }
     }
 
 
     ColumnLayout
     {
         id: playlistLayout
         anchors.fill: parent
         width: parent.width
         spacing: 0
 
         //            anchors.bottom: mainPlaylistRoot.searchBox
         BabeTable
         {
             id: table
             Layout.fillWidth: true
             Layout.fillHeight: true
             Layout.alignment: Qt.AlignBottom | Qt.AlignTop
             focus: true
             headBar.visible: false
             footBar.visible: false
             quickPlayVisible: false
             coverArtVisible: true
             trackRating: true
             showIndicator : true
             menuItemVisible: false
             holder.emoji: "qrc:/assets/Radio.png"
             holder.isMask: false
             holder.title : "Meh!"
             holder.body: "Start putting together your playlist!"
             holder.emojiSize: iconSizes.huge
             onRowClicked: play(index)
 
             onArtworkDoubleClicked: contextMenu.babeIt(index)
 
             Component.onCompleted:
             {
                 var lastplaylist = Maui.FM.loadSettings("LASTPLAYLIST", "PLAYLIST", [])
                 var n = lastplaylist.length
 
                 if(n>0)
                 {
                     for(var i = 0; i < n; i++)
                     {
                         var where = "url = \""+lastplaylist[i]+"\""
                         var query = Q.GET.tracksWhere_.arg(where)
                         table.list.appendQuery(query);
                     }
                 }else
                 {
                     where = "fav = 1"
                     query = Q.GET.tracksWhere_.arg(where)
                     table.list.appendQuery(query);
                 }
 
 //                if(autoplay)
 //                    Player.playAt(0)
             }
         }       
     }
 
     //    function goFocusMode()
     //    {
 
     //        if(focusMode)
     //        {
     //            if(isMobile)
     //            {
     //                root.width = screenWidth
     //                root.height= screenHeight
     //            }else
     //            {
     //                cover.y = 0
     //                root.maximumWidth = screenWidth
     //                root.minimumWidth = columnWidth
     //                root.maximumHeight = screenHeight
     //                root.minimumHeight = columnWidth
 
     //                root.width = columnWidth
     //                root.height = 700
     //            }
 
     //        }else
     //        {
     //            if(isMobile)
     //            {
 
     //            }else
     //            {
     //                root.maximumWidth = columnWidth
     //                root.minimumWidth = columnWidth
     //                root.maximumHeight = columnWidth
     //                root.minimumHeight = columnWidth
     //                //                root.footer.visible = false
     //                //                mainlistContext.visible = false
 
 
     //            }
     //        }
 
     //        focusMode = !focusMode
     //    }
 
     function play(index)
     {
         prevTrackIndex = currentTrackIndex
         Player.playAt(index)
 
     }
 }