code.delx.au - notipod/blob - notipod_gui.py

   1 #!/usr/bin/env python
   2 # Copyright 2009 James Bunton <jamesbunton@fastmail.fm>
   3 # Licensed for distribution under the GPL version 2, check COPYING for details
   4
   5 import logging
   6 import os
   7 import sys
   8 import traceback
   9 import uuid
  10
  11 import objc
  12 from Foundation import *
  13 from AppKit import *
  14 from PyObjCTools import AppHelper
  15
  16 import libnotipod
  17
  18
  19 class PlaylistModel(NSObject):
  20         outlineView = objc.IBOutlet()
  21
  22         def awakeFromNib(self):
  23                 self.root = []
  24                 self.playlists = {}
  25                 self.outlineView.setDataSource_(self)
  26                 self.outlineView.setEnabled_(False)
  27
  28         def setPlaylists(self, playlists):
  29                 self.root = []
  30                 self.playlists = playlists
  31                 for playlist in self.playlists:
  32                         if playlist.parent is None:
  33                                 self.root.append(playlist)
  34                 self.outlineView.reloadData()
  35                 self.outlineView.expandItem_expandChildren_(None, True)
  36
  37         def outlineView_child_ofItem_(self, _, childIndex, playlist):
  38                 if playlist == None:
  39                         return self.root[childIndex]
  40                 else:
  41                         return playlist.children[childIndex]
  42
  43         def outlineView_isItemExpandable_(self, _, playlist):
  44                 if playlist == None:
  45                         return True
  46                 else:
  47                         return len(playlist.children) > 0
  48
  49         def outlineView_numberOfChildrenOfItem_(self, _, playlist):
  50                 if playlist == None:
  51                         return len(self.root)
  52                 else:
  53                         return len(playlist.children)
  54
  55         def outlineView_objectValueForTableColumn_byItem_(self, _, col, playlist):
  56                 if not col:
  57                         return
  58                 col = col.identifier()
  59
  60                 if col == "selected":
  61                         selected = NSApp.delegate().playlists()
  62                         return playlist.pid in selected
  63                 if col == "icon":
  64                         return NSImage.imageNamed_("playlist-" + playlist.ptype)
  65                 if col == "playlist":
  66                         return playlist.name
  67
  68         def outlineView_setObjectValue_forTableColumn_byItem_(self, _, v, col, playlist):
  69                 if not col:
  70                         return
  71                 col = col.identifier()
  72
  73
  74                 if col != "selected":
  75                         return
  76                 NSApp.delegate().setPlaylist_selected_(playlist.pid, v)
  77
  78
  79 class FolderModel(NSObject):
  80         window = objc.IBOutlet()
  81         folderPopup = objc.IBOutlet()
  82
  83         def loadFolders_(self, folders):
  84                 self.folderPopup.addItemsWithTitles_(folders)
  85                 if len(folders) > 0:
  86                         self.folderPopup.selectItemAtIndex_(2)
  87                         self.lastIndex = 2
  88                 else:
  89                         self.lastIndex = 0
  90
  91         @objc.IBAction
  92         def doSelectFolder_(self, sender):
  93                 currentIndex = self.folderPopup.indexOfSelectedItem()
  94                 if currentIndex >= 2:
  95                         self.lastIndex = currentIndex
  96                         NSApp.delegate().setFolder_(self.folderPopup.titleOfSelectedItem())
  97                         return
  98                 panel = NSOpenPanel.openPanel()
  99                 panel.setCanChooseFiles_(False)
 100                 panel.setCanChooseDirectories_(True)
 101                 panel.setCanCreateDirectories_(True)
 102                 panel.setAllowsMultipleSelection_(False)
 103                 panel.beginSheetForDirectory_file_types_modalForWindow_modalDelegate_didEndSelector_contextInfo_(
 104                         None, None, [], self.window, self, self.selectFolderEnd_returnCode_contextInfo_, None)
 105
 106         @objc.signature("v@:@ii")
 107         def selectFolderEnd_returnCode_contextInfo_(self, panel, ret, _):
 108                 if ret == NSOKButton:
 109                         assert len(panel.filenames()) == 1
 110                         folder = panel.filenames()[0]
 111                         NSApp.delegate().setFolder_(folder)
 112                         self.folderPopup.insertItemWithTitle_atIndex_(folder, 2)
 113                         self.folderPopup.selectItemAtIndex_(2)
 114                 else:
 115                         self.folderPopup.selectItemAtIndex_(self.lastIndex)
 116
 117
 118 class NotiPodController(NSObject):
 119         window = objc.IBOutlet()
 120
 121         loadingSheet = objc.IBOutlet()
 122         loadingLabel = objc.IBOutlet()
 123         loadingIndicator = objc.IBOutlet()
 124
 125         previewWindow = objc.IBOutlet()
 126         previewText = objc.IBOutlet()
 127
 128         playlistModel = objc.IBOutlet()
 129         folderModel = objc.IBOutlet()
 130
 131
 132         def awakeFromNib(self):
 133                 self.runningGenerator = False
 134
 135         # Delegate methods
 136         def applicationWillFinishLaunching_(self, _):
 137                 pass
 138
 139         def applicationDidFinishLaunching_(self, _):
 140                 self._loadPrefs()
 141
 142                 folders = []
 143                 for target in self.targets:
 144                         folders.append(target["folder"])
 145                 self.folderModel.loadFolders_(folders)
 146
 147                 self.library = libnotipod.ITunesLibrary.alloc().init()
 148                 def finish():
 149                         self.playlistModel.setPlaylists(self.library.get_playlists())
 150                 def fail():
 151                         sys.exit(0)
 152                 self.runGenerator(lambda: self.library.load_(None), finish, fail)
 153
 154         def applicationWillTerminate_(self, _):
 155                 self.prefs().synchronize()
 156
 157         def applicationShouldTerminateAfterLastWindowClosed_(self, _):
 158                 return True
 159
 160
 161         # Utility methods
 162         def runGenerator(self, func, finish, fail):
 163                 assert not self.runningGenerator
 164                 self.runningGenerator = True
 165                 self.loadingIndicator.startAnimation_(self)
 166                 NSApp.beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_(self.loadingSheet, self.window, None, None, None)
 167                 arg = (func(), finish, fail)
 168                 self.performSelectorInBackground_withObject_(self.runGeneratorThread, arg)
 169
 170         def runGeneratorThread(self, (gen, finish, fail)):
 171                 pool = NSAutoreleasePool.alloc().init()
 172                 try:
 173                         for msg in gen:
 174                                 if not self.runningGenerator:
 175                                         break
 176                                 self.loadingLabel.performSelectorOnMainThread_withObject_waitUntilDone_(
 177                                         self.loadingLabel.setStringValue_, msg, True)
 178                 except Exception, e:
 179                         NSRunAlertPanel("Error!", str(e), "Ok", None, None)
 180                         traceback.print_exc()
 181                         finish = fail
 182                 self.performSelectorOnMainThread_withObject_waitUntilDone_(
 183                         self.stopGenerator, finish, True)
 184                 self.runningGenerator = False
 185
 186         def stopGenerator(self, finish):
 187                 self.runningGenerator = False
 188                 NSApp.endSheet_(self.loadingSheet)
 189                 self.loadingSheet.orderOut_(self)
 190                 self.loadingIndicator.stopAnimation_(self)
 191                 if finish:
 192                         finish()
 193
 194         @objc.IBAction
 195         def doCancel_(self, sender):
 196                 self.runningGenerator = False
 197
 198         def getDestFolder(self):
 199                 target = self.getCurrentTarget()
 200                 if not target:
 201                         NSRunAlertPanel("Error!", "You must choose a folder first!", "Ok", None, None)
 202                         return
 203                 folder = target["folder"]
 204                 if not os.path.isdir(folder.encode("utf-8")):
 205                         NSRunAlertPanel("Error!", "Destination " + folder + " does not exist, try mounting it first?", "Ok", None, None)
 206                         return
 207                 return folder
 208
 209         def doPreviewThread(self):
 210                 yield "Calculating changes..."
 211
 212                 folder = self.getDestFolder()
 213                 if not folder:
 214                         return
 215
 216                 all_tracks = set()
 217                 for playlist_id in self.playlists():
 218                         playlist = self.library.get_playlist_pid(playlist_id)
 219                         if playlist is not None:
 220                                 all_tracks.update(set(playlist.tracks))
 221
 222                 all_filenames = []
 223                 for trackID in all_tracks:
 224                         all_filenames.append(self.library.get_track_filename(trackID))
 225
 226                 gen = libnotipod.sync(
 227                         dry_run=True,
 228                         source=self.library.folder,
 229                         dest=folder,
 230                         files_to_copy=all_filenames,
 231                 )
 232                 self.previewResult = "\n".join(gen)
 233
 234         @objc.IBAction
 235         def doPreview_(self, sender):
 236                 self.previewResult = ""
 237                 self.previewWindow.orderOut_(self)
 238
 239                 def finish():
 240                         self.previewText.textStorage().mutableString().setString_(self.previewResult)
 241                         self.previewWindow.center()
 242                         self.previewWindow.makeKeyAndOrderFront_(self)
 243
 244                 self.runGenerator(self.doPreviewThread, finish, None)
 245
 246         @objc.IBAction
 247         def doSync_(self, sender):
 248                 folder = self.getDestFolder()
 249                 if not folder:
 250                         return
 251
 252                 all_tracks = set()
 253                 orig_playlists = set(self.playlists())
 254                 all_playlists = orig_playlists.copy()
 255                 for playlist_id in all_playlists:
 256                         playlist = self.library.get_playlist_pid(playlist_id)
 257                         if playlist is None:
 258                                 print "Forgetting unknown playlist:", playlist_id
 259                                 self.setPlaylist_selected_(playlist_id, False)
 260                                 continue
 261                         all_tracks.update(set(playlist.tracks))
 262
 263                 all_filenames = []
 264                 for trackID in all_tracks:
 265                         all_filenames.append(self.library.get_track_filename(trackID))
 266                         all_playlists.update(self.library.get_track_playlists(trackID))
 267
 268                 for playlist_id in all_playlists:
 269                         playlist = self.library.get_playlist_pid(playlist_id)
 270                         if playlist is None:
 271                                 continue
 272                         tracks = []
 273                         for trackID in playlist.tracks:
 274                                 if trackID in all_tracks:
 275                                         tracks.append(self.library.get_track_filename(trackID))
 276                         if playlist_id not in orig_playlists and len(tracks) < 10:
 277                                 continue
 278                         libnotipod.export_m3u(dry_run=False, dest=folder, path_prefix="",
 279                                         playlist_name=playlist.name, files=tracks)
 280
 281                 def finish():
 282                         NSRunAlertPanel("Complete!", "Synchronisation is complete", "Ok", None, None)
 283                 self.runGenerator(
 284                         lambda:
 285                                 libnotipod.sync(
 286                                         dry_run=False,
 287                                         source=self.library.folder,
 288                                         dest=folder,
 289                                         files_to_copy=all_filenames,
 290                                 )
 291                         ,
 292                         finish,
 293                         None
 294                 )
 295
 296
 297         # Preferences
 298
 299         def prefs(self):
 300                 return NSUserDefaults.standardUserDefaults()
 301
 302         def _migratePrefs(self):
 303                 p = self.prefs()
 304
 305                 playlists = p.stringArrayForKey_("playlists")
 306                 if playlists is not None:
 307                         p.removeObjectForKey_("playlists")
 308                 else:
 309                         playlists = []
 310
 311                 folders = p.stringArrayForKey_("folders")
 312                 if not folders:
 313                         return
 314                 p.removeObjectForKey_("folders")
 315
 316                 first = True
 317                 for f in folders:
 318                         target = {}
 319                         target["folder"] = f
 320                         target["playlists"] = list(playlists)
 321                         target["uuid"] = uuid.uuid1().get_hex()
 322                         if first:
 323                                 first = False
 324                                 self.setCurrentTarget_(target["uuid"])
 325                         self.targets.addObject_(target)
 326
 327                 self._savePrefs()
 328
 329         def _loadPrefs(self):
 330                 p = self.prefs()
 331
 332                 self.current_target = None
 333                 self.setCurrentTarget_(p.stringForKey_("current_target"))
 334
 335                 self.targets = self.prefs().arrayForKey_("targets")
 336                 if self.targets is None:
 337                         self.targets = NSMutableArray.array()
 338                 else:
 339                         self.targets = NSMutableArray.arrayWithArray_(self.targets)
 340
 341                 if self.getCurrentTarget() is None:
 342                         self._migratePrefs()
 343
 344         def _savePrefs(self):
 345                 p = self.prefs()
 346                 p.setObject_forKey_(self.current_target, "current_target")
 347                 p.setObject_forKey_(self.targets, "targets")
 348                 p.synchronize()
 349
 350         def getCurrentTarget(self):
 351                 for target in self.targets:
 352                         if target["uuid"] == self.current_target:
 353                                 return target
 354                 return None
 355
 356         def setCurrentTarget_(self, target_uuid):
 357                 old_uuid = self.current_target
 358                 self.current_target = target_uuid
 359                 if old_uuid is None and target_uuid is not None:
 360                         self.playlistModel.outlineView.setEnabled_(True)
 361                 if old_uuid != target_uuid:
 362                         self.playlistModel.outlineView.reloadItem_reloadChildren_(None, True)
 363
 364         def playlists(self):
 365                 target = self.getCurrentTarget()
 366                 if not target:
 367                         return []
 368                 return list(target["playlists"])
 369
 370         def setFolder_(self, folder):
 371                 for i, target in enumerate(self.targets):
 372                         if target["folder"] == folder:
 373                                 self.targets.removeObjectAtIndex_(i)
 374                                 self.targets.insertObject_atIndex_(target, 0)
 375                                 break
 376                 else:
 377                         target = {}
 378                         target["folder"] = folder
 379                         target["playlists"] = self.playlists()
 380                         target["uuid"] = uuid.uuid1().get_hex()
 381                         self.targets.insertObject_atIndex_(target, 0)
 382
 383                 self.setCurrentTarget_(target["uuid"])
 384
 385                 self._savePrefs()
 386
 387         def setPlaylist_selected_(self, playlist, selected):
 388                 target = self.getCurrentTarget()
 389                 if not target:
 390                         raise AssertionError("No target selected when editing playlists")
 391
 392                 playlists = target["playlists"]
 393                 if selected:
 394                         playlists.append(playlist)
 395                 else:
 396                         playlists.remove(playlist)
 397                 target["playlists"] = list(set(playlists))
 398
 399                 self._savePrefs()
 400
 401
 402 def main():
 403 ###     logging.basicConfig(format="%(levelname)s: %(message)s")
 404 ###     logging.getLogger().setLevel(logging.DEBUG)
 405         AppHelper.runEventLoop()
 406
 407 if __name__ == "__main__":
 408         main()
 409