Save playlists separately for each target folder

diff --git a/notipod_gui.py b/notipod_gui.py
index 334f0057b58f98d09f8e5db0fef87395b779195c..52b4456faa633bb910a0a68b0f9b6835fd39857c 100644 (file)
--- a/notipod_gui.py
+++ b/notipod_gui.py
@@ -6,6 +6,7 @@ import logging
 import os
 import sys
 import traceback
+import uuid
 
 import objc
 from Foundation import *
@@ -22,6 +23,7 @@ class PlaylistModel(NSObject):
                self.root = []
                self.playlists = {}
                self.outlineView.setDataSource_(self)
+               self.outlineView.setEnabled_(False)
 
        def setPlaylists(self, playlists):
                self.root = []
@@ -78,8 +80,7 @@ class FolderModel(NSObject):
        window = objc.IBOutlet()
        folderPopup = objc.IBOutlet()
 
-       def awakeFromNib(self):
-               folders = NSApp.delegate().folders()
+       def loadFolders_(self, folders):
                self.folderPopup.addItemsWithTitles_(folders)
                if len(folders) > 0:
                        self.folderPopup.selectItemAtIndex_(2)
@@ -92,7 +93,7 @@ class FolderModel(NSObject):
                currentIndex = self.folderPopup.indexOfSelectedItem()
                if currentIndex >= 2:
                        self.lastIndex = currentIndex
-                       NSApp.delegate().addFolder_(self.folderPopup.titleOfSelectedItem())
+                       NSApp.delegate().setFolder_(self.folderPopup.titleOfSelectedItem())
                        return
                panel = NSOpenPanel.openPanel()
                panel.setCanChooseFiles_(False)
@@ -107,7 +108,7 @@ class FolderModel(NSObject):
                if ret == NSOKButton:
                        assert len(panel.filenames()) == 1
                        folder = panel.filenames()[0]
-                       NSApp.delegate().addFolder_(folder)
+                       NSApp.delegate().setFolder_(folder)
                        self.folderPopup.insertItemWithTitle_atIndex_(folder, 2)
                        self.folderPopup.selectItemAtIndex_(2)
                else:
@@ -136,6 +137,13 @@ class NotiPodController(NSObject):
                pass
 
        def applicationDidFinishLaunching_(self, _):
+               self._loadPrefs()
+
+               folders = []
+               for target in self.targets:
+                       folders.append(target["folder"])
+               self.folderModel.loadFolders_(folders)
+               
                self.library = libnotipod.ITunesLibrary.alloc().init()
                def finish():
                        self.playlistModel.setPlaylists(self.library.get_playlists())
@@ -188,11 +196,11 @@ class NotiPodController(NSObject):
                self.runningGenerator = False
 
        def getDestFolder(self):
-               folders = self.folders()
-               if not folders:
+               target = self.getCurrentTarget()
+               if not target:
                        NSRunAlertPanel("Error!", "You must choose a folder first!", "Ok", None, None)
                        return
-               folder = folders[0]
+               folder = target["folder"]
                if not os.path.isdir(folder.encode("utf-8")):
                        NSRunAlertPanel("Error!", "Destination " + folder + " does not exist, try mounting it first?", "Ok", None, None)
                        return
@@ -286,40 +294,109 @@ class NotiPodController(NSObject):
                )
 
 
-       # Public accessors
+       # Preferences
 
        def prefs(self):
                return NSUserDefaults.standardUserDefaults()
 
-       def _getArray(self, key):
-               res = self.prefs().stringArrayForKey_(key)
-               return list(res) if res else []
+       def _migratePrefs(self):
+               p = self.prefs()
+               
+               playlists = p.stringArrayForKey_("playlists")
+               if playlists is not None:
+                       p.removeObjectForKey_("playlists")
+               else:
+                       playlists = []
 
-       def _saveArray(self, key, array):
-               self.prefs().setObject_forKey_(array, key)
+               folders = p.stringArrayForKey_("folders")
+               if not folders:
+                       return
+               p.removeObjectForKey_("folders")
+
+               first = True
+               for f in folders:
+                       target = {}
+                       target["folder"] = f
+                       target["playlists"] = list(playlists)
+                       target["uuid"] = uuid.uuid1().get_hex()
+                       if first:
+                               first = False
+                               self.setCurrentTarget_(target["uuid"])
+                       self.targets.addObject_(target)
+
+               self._savePrefs()
+
+       def _loadPrefs(self):
+               p = self.prefs()
+
+               self.current_target = None
+               self.setCurrentTarget_(p.stringForKey_("current_target"))
+
+               self.targets = self.prefs().arrayForKey_("targets")
+               if self.targets is None:
+                       self.targets = NSMutableArray.array()
+               else:
+                       self.targets = NSMutableArray.arrayWithArray_(self.targets)
+
+               if self.getCurrentTarget() is None:
+                       self._migratePrefs()
+
+       def _savePrefs(self):
+               p = self.prefs()
+               p.setObject_forKey_(self.current_target, "current_target")
+               p.setObject_forKey_(self.targets, "targets")
+               p.synchronize()
+
+       def getCurrentTarget(self):
+               for target in self.targets:
+                       if target["uuid"] == self.current_target:
+                               return target
+               return None
+       
+       def setCurrentTarget_(self, target_uuid):
+               old_uuid = self.current_target
+               self.current_target = target_uuid
+               if old_uuid is None and target_uuid is not None:
+                       self.playlistModel.outlineView.setEnabled_(True)
+               if old_uuid != target_uuid:
+                       self.playlistModel.outlineView.reloadItem_reloadChildren_(None, True)
 
        def playlists(self):
-               return self._getArray("playlists")
+               target = self.getCurrentTarget()
+               if not target:
+                       return []
+               return list(target["playlists"])
+
+       def setFolder_(self, folder):
+               for i, target in enumerate(self.targets):
+                       if target["folder"] == folder:
+                               self.targets.removeObjectAtIndex_(i)
+                               self.targets.insertObject_atIndex_(target, 0)
+                               break
+               else:
+                       target = {}
+                       target["folder"] = folder
+                       target["playlists"] = self.playlists()
+                       target["uuid"] = uuid.uuid1().get_hex()
+                       self.targets.insertObject_atIndex_(target, 0)
 
-       def folders(self):
-               return self._getArray("folders")
+               self.setCurrentTarget_(target["uuid"])
 
-       def addFolder_(self, folder):
-               folders = self.folders()
-               while folder in folders:
-                       folders.remove(folder)
-               folders.insert(0, folder)
-               folders = folders[:10]
-               self._saveArray("folders", folders)
+               self._savePrefs()
 
        def setPlaylist_selected_(self, playlist, selected):
-               playlists = self.playlists()
+               target = self.getCurrentTarget()
+               if not target:
+                       raise AssertionError("No target selected when editing playlists")
+
+               playlists = target["playlists"]
                if selected:
                        playlists.append(playlist)
                else:
                        playlists.remove(playlist)
-               playlists = list(set(playlists))
-               self._saveArray("playlists", list(set(playlists)))
+               target["playlists"] = list(set(playlists))
+
+               self._savePrefs()
 
 
 def main():