chiark / gitweb /
More tests for mime.c
[disorder] / python / tkdisorder
1 #! /usr/bin/env python
2 #
3 # Copyright (C) 2004, 2005 Richard Kettlewell
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful, but
11 # WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 # General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
18 # USA
19 #
20
21 # THIS PROGRAM IS NO LONGER MAINTAINED.
22 #
23 # It worked last time I tried running it, but all client maintenance
24 # effort is now devoted to the web interface and the GTK+ client
25 # (Disobedience).
26
27 """Graphical user interface for DisOrder"""
28
29 from Tkinter import *
30 import tkFont
31 import Queue
32 import threading
33 import disorder
34 import time
35 import string
36 import re
37 import getopt
38 import sys
39
40 ########################################################################
41
42 # Architecture:
43 #
44 #  The main (initial) thread of the program runs all GUI code.  The GUI is only
45 #  directly modified from inside this thread.  We sometimes call this the
46 #  master thread.
47 #
48 #  We have a background thread, MonitorStateThread, which waits for changes to
49 #  the server's state which we care about.  Whenever such a change occurs it
50 #  notifies all the widgets which care about it (and possibly other widgets;
51 #  the current implementation is unsophisticated.)
52 #
53 #  Widget poll() methods usually, but NOT ALWAYS, called in the
54 #  MonitorStateThread.  Other widget methods are call in the master thread.
55 #
56 #  We have a separate disorder.client for each thread rather than locking a
57 #  single client.  MonitorStateThread also has a private disorder.client that
58 #  it uses to watch for server state changes.
59
60 ########################################################################
61
62 class Intercom:
63   # communication queue into thread containing Tk event loop
64   #
65   # Sets up a callback on the event loop (in this thread) which periodically
66   # checks the queue for elements; if any are found they are executed.
67   def __init__(self, master):
68     self.q = Queue.Queue();
69     self.master = master
70     self.poll()
71
72   def poll(self):
73     try:
74       item = self.q.get_nowait()
75       item()
76       self.master.after_idle(self.poll)
77     except Queue.Empty:
78       self.master.after(100, self.poll)
79
80   def put(self, item):
81     self.q.put(item)
82
83 ########################################################################
84
85 class ProgressBar(Canvas):
86   # progress bar widget
87   def __init__(self, master=None, **kw):
88     Canvas.__init__(self, master, highlightthickness=0, **kw)
89     self.outer = self.create_rectangle(0, 0, 0, 0,
90                                        outline="#000000",
91                                        width=1,
92                                        fill="#ffffff")
93     self.bar = self.create_rectangle(0, 0, 0, 0,
94                                      width=1,
95                                      fill="#ff0000",
96                                      outline='#ff0000')
97     self.current = None
98     self.total = None
99     self.bind("<Configure>", lambda e: self.redisplay())
100
101   def update(self, current, total):
102     self.current = current
103     if current > total:
104       current = total
105     elif current < 0:
106       current = 0
107     self.total = total
108     self.redisplay()
109
110   def clear(self):
111     self.current = None
112     self.total = None
113     self.redisplay()
114
115   def redisplay(self):
116     w, h = self.winfo_width(), self.winfo_height()
117     if w > 0 and h > 0:
118       self.coords(self.outer, 0, 0, w - 1, h - 1)
119       if self.total:
120         bw = int((w - 2) * self.current / self.total)
121         self.itemconfig(self.bar,
122                         fill="#ff0000",
123                         outline="#ff0000")
124         self.coords(self.bar, 1, 1, bw, h - 2)
125       else:
126         self.itemconfig(self.bar,
127                         fill="#909090",
128                         outline="#909090")
129         self.coords(self.bar, 1, 1, w - 2, h - 2)
130
131 # look up a track's name part, using client c.  Maintains a cache.
132 part_cache = {}
133 def part(c, track, context, part):
134   key = "%s-%s-%s" % (part, context, track)
135   now = time.time()
136   if not part_cache.has_key(key) or part_cache[key]['when'] < now - 3600:
137     part_cache[key] = {'when': now,
138                        'what': c.part(track, context, part)}
139   return part_cache[key]['what']
140
141 class PlayingWidget(Frame):
142   # widget that always displays information about what's
143   # playing
144   def __init__(self, master=None, **kw):
145     Frame.__init__(self, master, **kw)
146     # column 0 is descriptions, column 1 is the values
147     self.columnconfigure(0,weight=0)
148     self.columnconfigure(1,weight=1)
149     self.fields = {}
150     self.field(0, 0, "artist", "Artist")
151     self.field(1, 0, "album", "Album")
152     self.field(2, 0, "title", "Title")
153     # column 1 also has the progress bar in it
154     self.p = ProgressBar(self, height=20)
155     self.p.grid(row=3, column=1, sticky=E+W)
156     # column 2 has operation buttons
157     b = Button(self, text="Quit", command=self.quit)
158     b.grid(row=0, column=2, sticky=E+W)
159     b = Button(self, text="Scratch", command=self.scratch)
160     b.grid(row=1, column=2, sticky=E+W)
161     b = Button(self, text="Recent", command=self.recent)
162     b.grid(row=2, column=2, sticky=E+W)
163     self.length = 0
164     self.update_length()
165     self.last = None
166     self.recentw = None
167     
168   def field(self, row, column, name, label):
169     # create a field
170     Label(self, text=label).grid(row=row, column=column, sticky=E)
171     self.fields[name] = Text(self, height=1, state=DISABLED)
172     self.fields[name].grid(row=row, column=column + 1, sticky=W+E);
173
174   def set(self, name, value):
175     # set a field's value
176     f = self.fields[name]
177     f.config(state=NORMAL)
178     f.delete(1.0, END)
179     f.insert(END, value)
180     f.config(state=DISABLED)
181
182   def playing(self, p):
183     # called with new what's-playing information
184     values = {}
185     if p:
186       for tpart in ['artist', 'album', 'title']:
187         values[tpart] = part(client, p['track'], 'display', tpart)
188       try:
189         self.length = client.length(p['track'])
190       except disorder.operationError:
191         self.length = 0
192       self.started = int(p['played'])
193     else:
194       self.length = 0
195     for k in self.fields.keys():
196       if k in values:
197         self.set(k, values[k])
198       else:
199         self.set(k, "")
200     self.length_bar()
201
202   def length_bar(self):
203     if self.length and self.length > 0:
204       self.p.update(time.time() - self.started, self.length)
205     else:
206       self.p.clear()
207
208   def update_length(self):
209     self.length_bar()
210     self.after(1000, self.update_length)
211
212   def poll(self, c):
213     p = c.playing()
214     if p != self.last:
215       intercom.put(lambda: self.playing(p))
216       self.last = p
217
218   def quit(self):
219     sys.exit(0)
220
221   def scratch(self):
222     client.scratch()
223
224   def recent_close(self):
225     self.recentw.destroy()
226     self.recentw = None
227
228   def recent(self):
229     if self.recentw:
230       self.recentw.deiconify()
231       self.recentw.lift()
232     else:
233       w = 80*tracklistFont.measure('A')
234       h = 40*tracklistFont.metrics("linespace")
235       self.recentw = Toplevel()
236       self.recentw.protocol("WM_DELETE_WINDOW", self.recent_close)
237       self.recentw.title("Recently Played")
238       # XXX for some reason Toplevel(width=w,height=h) doesn't seem to work
239       self.recentw.geometry("%dx%d" % (w,h))
240       w = RecentWidget(self.recentw)
241       w.pack(fill=BOTH, expand=1)
242       mst.add(w);
243
244 class TrackListWidget(Frame):
245   def __init__(self, master=None, **kw):
246     Frame.__init__(self, master, **kw)
247     self.yscrollbar = Scrollbar(self)
248     self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
249     self.canvas = Canvas(self,
250                          xscrollcommand=self.xscrollbar.set,
251                          yscrollcommand=self.yscrollbar.set)
252     self.xscrollbar.config(command=self.canvas.xview)
253     self.yscrollbar.config(command=self.canvas.yview)
254     self.canvas.grid(row=0, column=0, sticky=N+S+E+W)
255     self.yscrollbar.grid(row=0, column=1, sticky=N+S)
256     self.xscrollbar.grid(row=1, column=0, sticky=E+W)
257     self.columnconfigure(0,weight=1)
258     self.rowconfigure(0,weight=1)
259     self.last = None
260     self.default_cursor = self['cursor']
261     self.configure(cursor="watch")
262
263   def queue(self, q, w_artists, w_albums, w_titles, artists, albums, titles):
264     # called with new queue state
265     # delete old contents
266     try:
267       for i in self.canvas.find_all():
268         self.canvas.delete(i)
269     except TclError:
270       # if the call was queued but not received before the window was deleted
271       # we might get an error from Tcl/Tk, which no longer knows the window,
272       # here
273       return
274     w = tracklistHFont.measure("Artist")
275     if w > w_artists:
276       w_artists = w
277     w = tracklistHFont.measure("Album")
278     if w > w_albums:
279       w_albums = w
280     w = tracklistHFont.measure("Title")
281     if w > w_titles:
282       w_titles = w
283     hheading = tracklistHFont.metrics("linespace")
284     h = tracklistFont.metrics('linespace')
285     x_artist = 8
286     x_album = x_artist + w_artists + 16
287     x_title = x_album + w_albums + 16
288     w = x_title + w_titles + 8
289     self.canvas['scrollregion'] = (0, 0, w, h * len(artists) + hheading)
290     self.canvas.create_text(x_artist, 0, text="Artist",
291                             font=tracklistHFont,
292                             anchor='nw')
293     self.canvas.create_text(x_album, 0, text="Album",
294                             font=tracklistHFont,
295                             anchor='nw')
296     self.canvas.create_text(x_title, 0, text="Title",
297                             font=tracklistHFont,
298                             anchor='nw')
299     y = hheading
300     for n in range(0,len(artists)):
301       artist = artists[n]
302       album = albums[n]
303       title = titles[n]
304       if artist != "":
305         self.canvas.create_text(x_artist, y, text=artist,
306                                 font=tracklistFont,
307                                 anchor='nw')
308       if album != "":
309         self.canvas.create_text(x_album, y, text=album,
310                                 font=tracklistFont,
311                                 anchor='nw')
312       if title != "":
313         self.canvas.create_text(x_title, y, text=title,
314                                 font=tracklistFont,
315                                 anchor='nw')
316       y += h
317     self.last = q
318     self.configure(cursor=self.default_cursor)
319
320   def poll(self, c):
321     q = self.getqueue(c)
322     if q != self.last:
323       # we do the track name calculation in the background thread so that
324       # the gui can still be responsive
325       artists = []
326       albums = []
327       titles = []
328       w_artists = w_albums = w_titles = 16
329       for t in q:
330         artist = part(c, t['track'], 'display', 'artist')
331         album = part(c, t['track'], 'display', 'album')
332         title = part(c, t['track'], 'display', 'title')
333         w = tracklistFont.measure(artist)
334         if w > w_artists:
335           w_artists = w
336         w = tracklistFont.measure(album)
337         if w > w_albums:
338           w_albums = w
339         w = tracklistFont.measure(title)
340         if w > w_titles:
341           w_titles = w
342         artists.append(artist)
343         albums.append(album)
344         titles.append(title)
345       intercom.put(lambda: self.queue(q, w_artists, w_albums, w_titles,
346                                       artists, albums, titles))
347       self.last = q
348
349 class QueueWidget(TrackListWidget):
350   def __init__(self, master=None, **kw):
351     TrackListWidget.__init__(self, master, **kw)
352
353   def getqueue(self, c):
354     return c.queue()
355
356 class RecentWidget(TrackListWidget):
357   def __init__(self, master=None, **kw):
358     TrackListWidget.__init__(self, master, **kw)
359
360   def getqueue(self, c):
361     l = c.recent()
362     l.reverse()
363     return l
364
365 class MonitorStateThread:
366   # thread to pick up current server state and publish it
367   #
368   # Creates a client and monitors it in a daemon thread for state changes.
369   # Whenever one occurs, call w.poll(c) for every member w of widgets with
370   # a client owned by the thread in which the call occurs.
371   def __init__(self, widgets, masterclient=None):
372     self.logclient = disorder.client()
373     self.client = disorder.client()
374     self.clientlock = threading.Lock()
375     if not masterclient:
376       masterclient = disorder.client()
377     self.masterclient = masterclient
378     self.widgets = widgets
379     self.lock = threading.Lock()
380     # the main thread
381     self.thread = threading.Thread(target=self.run)
382     self.thread.setDaemon(True)
383     self.thread.start()
384     # spare thread for processing additions
385     self.adderq = Queue.Queue()
386     self.adder = threading.Thread(target=self.runadder)
387     self.adder.setDaemon(True)
388     self.adder.start()
389
390   def notify(self, line):
391     self.lock.acquire()
392     widgets = self.widgets
393     self.lock.release()
394     for w in widgets:
395       self.clientlock.acquire()
396       w.poll(self.client)
397       self.clientlock.release()
398     return 1
399
400   def add(self, w):
401     self.lock.acquire()
402     self.widgets.append(w)
403     self.lock.release()
404     self.adderq.put(lambda client: w.poll(client))
405
406   def remove(self, what):
407     self.lock.acquire()
408     self.widgets.remove(what)    
409     self.lock.release()
410     
411   def run(self):
412     self.notify("")
413     self.logclient.log(lambda client, line: self.notify(line))
414
415   def runadder(self):
416     while True:
417       item = self.adderq.get()
418       self.clientlock.acquire()
419       item(self.client)
420       self.clientlock.release()
421
422 ########################################################################
423
424 def usage(s):
425   # display usage on S
426   s.write(
427     """Usage:
428
429   tkdisorder [OPTIONS]
430
431 Options:
432
433   -h, --help         Display this message
434   -V, --version      Display version number
435
436 tkdisorder is copyright (c) 2004, 2005 Richard Kettlewell.
437 """)
438
439 ########################################################################
440
441 try:
442   opts, rest = getopt.getopt(sys.argv[1:], "Vh", ["version", "help"])
443 except getopt.GetoptError, e:
444   sys.stderr.write("ERROR: %s, try --help for help\n" % e.msg)
445   sys.exit(1)
446 for o, v in opts:
447   if o in ('-V', '--version'):
448     print "%s" % disorder.version
449     sys.stdout.close()
450     sys.exit(0)
451   if o in ('h', '--help'):
452     usage(sys.stdout)
453     sys.stdout.close()
454     sys.exit(0)
455
456 client = disorder.client()              # master thread's client
457
458 root = Tk()
459 root.title("DisOrder")
460
461 tracklistFont = tkFont.Font(family='Helvetica', size=10)
462 tracklistHFont = tracklistFont.copy()
463 tracklistHFont.config(weight="bold")
464
465 p = PlayingWidget(root)
466 p.pack(fill=BOTH, expand=1)
467
468 q = QueueWidget(root)
469 q.pack(fill=BOTH, expand=1)
470
471 intercom = Intercom(root)               # only need a single intercom
472 mst = MonitorStateThread([p, q], client)
473
474 root.mainloop()
475
476 # Local Variables:
477 # py-indent-offset:2
478 # comment-column:40
479 # fill-column:79
480 # End: