def setUp(self):
self.q = PlaylistModel()
self.pl = PlaylistModel()
self.p = NullPlayer()
self.mux = PlaylistMux(self.p, self.q, self.pl)
self.p.setup(self.mux, None, 0)
self.failUnless(self.pl.current is None)
def setUp(self):
config.init()
config.set("player", "gst_pipeline", "fakesink")
config.set("settings", "xine_driver", "none")
module = player.init_backend(self.NAME)
lib = library.init()
self.player = module.init(lib.librarian)
source = PlaylistModel()
source.set(FILES)
self.events = []
def start_end_handler(player, song, *args):
self.events.append((args[-1], song))
self.player.connect("song-started", start_end_handler, "started")
self.player.connect("song-ended", start_end_handler, "ended")
self.player.setup(source, None, 0)
self.signals = []
def handler(type_, *args):
self.signals.append(type_)
connect_obj(self.player, "unpaused", handler, "unpaused")
connect_obj(self.player, "paused", handler, "paused")
def test_remaining(self):
order = OrderShuffle()
pl = PlaylistModel()
pl.set([r3, r1, r2, r0])
cur = pl.current_iter
for i in range(4, -1, -1):
cur = order.next_explicit(pl, cur)
self.failUnlessEqual(len(order.remaining(pl)), i)
def setUp(self):
config.init()
config.set("player", "gst_pipeline", "fakesink")
module = player.init(self.NAME)
lib = library.init()
self.player = module.init(lib.librarian)
source = PlaylistModel()
source.set(FILES)
self.player.setup(source, None, 0)
def test_remaining(self):
order = OrderShuffle()
pl = PlaylistModel()
songs = [r3, r1, r2, r0]
pl.set(songs)
cur = pl.current_iter
for i in range(4, 0, -1):
cur = order.next_explicit(pl, cur)
self.failUnlessEqual(len(order.remaining(pl)), i)
# The playlist should reset after the last song
cur = order.next_explicit(pl, cur)
self.failUnlessEqual(len(order.remaining(pl)), len(songs))
def test_weighted(self):
pl = PlaylistModel()
pl.set([r3, r1, r2, r0])
order = OrderWeighted()
scores = defaultdict(int)
for i in range(500):
order.reset(pl)
cur = pl.current_iter
for j in range(3, -1, -1):
cur = order.next_explicit(pl, cur)
scores[pl[cur][0]] += j
self.failUnless(scores[r1] > scores[r0])
self.failUnless(scores[r2] > scores[r1])
self.failUnless(scores[r3] > scores[r2])
def __init__(self, library, player=None, update=False):
super(SongList, self).__init__()
self._register_instance(SongList)
self.set_model(PlaylistModel())
self.info = SongInfoSelection(self)
self.set_size_request(200, 150)
self.set_rules_hint(True)
self.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
self.set_fixed_height_mode(True)
self.__csig = self.connect('columns-changed', self.__columns_changed)
self._first_column = None
# A priority list of how to apply the sort keys.
# might contain column header names not present...
self._sort_sequence = []
self.set_column_headers(self.headers)
librarian = library.librarian or library
sigs = []
# The player needs to be called first so it can ge the next song
# in case the current one gets deleted and the order gets reset.
if player:
s = librarian.connect_object('removed', map, player.remove)
sigs.append(s)
sigs.extend([
librarian.connect('changed', self.__song_updated),
librarian.connect('removed', self.__song_removed)
])
if update:
sigs.append(librarian.connect('added', self.__song_added))
for sig in sigs:
self.connect_object('destroy', librarian.disconnect, sig)
if player:
sigs = [
player.connect('paused', lambda *x: self.__redraw_current()),
player.connect('unpaused', lambda *x: self.__redraw_current()),
player.connect('error', lambda *x: self.__redraw_current()),
]
for sig in sigs:
self.connect_object('destroy', player.disconnect, sig)
self.connect('button-press-event', self.__button_press, librarian)
self.connect('key-press-event', self.__key_press, librarian)
self.setup_drop(library)
self.disable_drop()
self.set_search_equal_func(self.__search_func, None)
self.connect('destroy', self.__destroy)
def _render_column(self, column, **kwargs):
view = Gtk.TreeView()
model = PlaylistModel()
view.set_model(model)
song = AudioFile({"~filename": devnull, "~#rating": 0.6666})
song.update(kwargs)
model.append(row=[song])
view.append_column(column)
if column.get_resizable():
column.set_expand(True)
with visible(view):
view.columns_autosize()
text = column.get_cells()[0].get_property("text")
self.assertIsNot(text, None)
return text
def test_remaining(self):
order = OneSong(OrderInOrder())
pl = PlaylistModel(OrderInOrder)
pl.set([r0, r1])
for i in range(2):
self.failUnlessEqual(order.next(pl, pl.current_iter), None)
def setUp(self):
self.pl = PlaylistModel()
self.pl.set(range(10))
do_events()
self.failUnless(self.pl.current is None)
