path: root/Demo/stdwin/jukebox.py

#! /ufs/guido/bin/sgi/python

# XXX This file is being hacked -- some functionality has been taken out!

# JUKEBOX: browse directories full of sampled sound files.
#
# One or more "list windows" display the files and subdirectories of
# the arguments.  Double-clicking on a subdirectory opens a new window
# displaying its contents (and so on recursively).  Double clicking
# on a file plays it as a sound file (assuming it is one).
#
# Playing is asynchronous: the application keeps listening to events
# while the sample is playing, so you can change the volume (gain)
# during playing, cancel playing or start a new sample right away.
#
# The control window displays the current output gain and a primitive
# "stop button" to cancel the current play request.
#
# Sound files must currently be in Dik Winter's compressed Mac format.
# Since decompression is costly, decompressed samples are saved in
# /usr/tmp/@j* until the application is left.  The files are read
# afresh each time, though.

import commands
import getopt
import os
import rand
import stdwin
from stdwinevents import *
import string
import sys
import tempfile

from WindowParent import WindowParent
from HVSplit import VSplit
from Buttons import PushButton
from Sliders import ComplexSlider

# Pathnames

DEF_DB = '/usr/local/sounds/aiff'	# Default directory of sounds
SOX = '/usr/local/sox'			# Sound format conversion program
SFPLAY = '/usr/sbin/sfplay'		# Sound playing program


# Global variables

class struct(): pass		# Class to define featureless structures

G = struct()			# Holds writable global variables


# Main program

def main():
	G.synchronous = 0	# If set, use synchronous audio.write()
	G.debug = 0		# If set, print debug messages
	G.busy = 0		# Set while asynchronous playing is active
	G.windows = []		# List of open windows, except control
	G.mode = ''		# File type (default any that sfplay knows)
	G.rate = 0		# Sampling rate (default " " " ")
	G.tempprefix = tempfile.mktemp()
	#
	try:
		optlist, args = getopt.getopt(sys.argv[1:], 'dr:st:')
	except getopt.error, msg:
		sys.stdout = sys.stderr
		print msg
		print 'usage: jukebox [-d] [-s] [-t type] [-r rate]'
		print '  -d        debugging'
		print '  -s        synchronous playing'
		print '  -t type   file type'
		print '  -r rate   sampling rate'
		sys.exit(2)
	#
	for optname, optarg in optlist:
		if   optname == '-d':
			G.debug = 1
		elif optname == '-r':
			G.rate = int(eval(optarg))
		elif optname == '-s':
			G.synchronous = 1
		elif optname == '-t':
			G.mode = optarg
	#
	if not args:
		args = [DEF_DB]
	#
	G.cw = opencontrolwindow()
	for dirname in args:
		G.windows.append(openlistwindow(dirname))
	#
	#
	try:
		maineventloop()
	finally:
		clearcache()
		killchild()

def maineventloop():
	mouse_events = WE_MOUSE_DOWN, WE_MOUSE_MOVE, WE_MOUSE_UP
	while G.windows:
		type, w, detail = event = stdwin.getevent()
		if w == G.cw.win:
			if type == WE_CLOSE:
				return
			if type == WE_TIMER:
				checkchild()
				if G.busy:
					G.cw.win.settimer(1)
			else:
				G.cw.dispatch(event)
		else:
			if type == WE_DRAW:
				w.drawproc(w, detail)
			elif type in mouse_events:
				w.mouse(w, type, detail)
			elif type == WE_CLOSE:
				w.close(w)
				del w, event
			else:
				if G.debug: print type, w, detail

def checkchild():
	if G.busy:
		waitchild(1)

def killchild():
	if G.busy:
		os.kill(G.busy, 9)
		waitchild(0)

def waitchild(options):
	pid, sts = os.wait(G.busy, options)
	if pid == G.busy:
		G.busy = 0
		G.stop.enable(0)


# Control window -- to set gain and cancel play operations in progress

def opencontrolwindow():
	stdwin.setdefscrollbars(0, 0)
	cw = WindowParent().create('Jukebox', (0, 0))
	v = VSplit().create(cw)
	#
	stop = PushButton().definetext(v, 'Stop')
	stop.hook = stop_hook
	stop.enable(0)
	G.stop = stop
	#
	cw.realize()
	return cw

def stop_hook(self):
	killchild()


# List windows -- to display list of files and subdirectories

def openlistwindow(dirname):
	list = os.listdir(dirname)
	list.sort()
	i = 0
	while i < len(list):
		if list[i] == '.' or list[i] == '..':
			del list[i]
		else:
			i = i+1
	for i in range(len(list)):
		name = list[i]
		if os.path.isdir(os.path.join(dirname, name)):
			list[i] = list[i] + '/'
	width = maxwidth(list)
	# width = width + stdwin.textwidth(' ')	# XXX X11 stdwin bug workaround
	height = len(list) * stdwin.lineheight()
	stdwin.setdefwinsize(width, min(height, 500))
	stdwin.setdefscrollbars(0, 1)
	w = stdwin.open(dirname)
	stdwin.setdefwinsize(0, 0)
	w.setdocsize(width, height)
	w.drawproc = drawlistwindow
	w.mouse = mouselistwindow
	w.close = closelistwindow
	w.dirname = dirname
	w.list = list
	w.selected = -1
	return w

def maxwidth(list):
	width = 1
	for name in list:
		w = stdwin.textwidth(name)
		if w > width: width = w
	return width

def drawlistwindow(w, area):
##	(left, top), (right, bottom) = area
	d = w.begindrawing()
	d.erase((0, 0), (1000, 10000))
	lh = d.lineheight()
	h, v = 0, 0
	for name in w.list:
		d.text((h, v), name)
		v = v + lh
	showselection(w, d)
	d.close()

def hideselection(w, d):
	if w.selected >= 0:
		invertselection(w, d)

def showselection(w, d):
	if w.selected >= 0:
		invertselection(w, d)

def invertselection(w, d):
	lh = d.lineheight()
	h1, v1 = p1 = 0, w.selected*lh
	h2, v2 = p2 = 1000, v1 + lh
	d.invert(p1, p2)

def mouselistwindow(w, type, detail):
	(h, v), clicks, button = detail[:3]
	d = w.begindrawing()
	lh = d.lineheight()
	if 0 <= v < lh*len(w.list):
		i = v / lh
	else:
		i = -1
	if w.selected <> i:
		hideselection(w, d)
		w.selected = i
		showselection(w, d)
	d.close()
	if type == WE_MOUSE_DOWN and clicks >= 2 and i >= 0:
		setcursors('watch')
		name = os.path.join(w.dirname, w.list[i])
		if name[-1:] == '/':
			if clicks == 2:
				G.windows.append(openlistwindow(name[:-1]))
		else:
			playfile(name)
		setcursors('cross')

def closelistwindow(w):
	remove(G.windows, w)

def remove(list, item):
	for i in range(len(list)):
		if list[i] == item:
			del list[i]
			break

def setcursors(cursor):
	for w in G.windows:
		w.setwincursor(cursor)
	G.cw.win.setwincursor(cursor)


# Playing tools

cache = {}

def clearcache():
	for x in cache.keys():
		try:
			sts = os.system('rm -f ' + cache[x])
			if sts:
				print cmd
				print 'Exit status', sts
		except:
			print cmd
			print 'Exception?!'
		del cache[x]

def playfile(name):
	killchild()
	if G.mode in ('', 'au', 'aiff'):
		tempname = name
	elif cache.has_key(name):
		tempname = cache[name]
	else:
		tempname = G.tempprefix + `rand.rand()` + '.aiff'
		cmd = SOX
		if G.mode <> '' and G.mode <> 'sox':
			cmd = cmd + ' -t ' + G.mode
		cmd = cmd + ' ' + commands.mkarg(name)
		cmd = cmd + ' -t aiff'
		if G.rate:
			cmd = cmd + ' -r ' + `G.rate`
		cmd = cmd + ' ' + tempname
		if G.debug: print cmd
		sts = os.system(cmd)
		if sts:
			print cmd
			print 'Exit status', sts
			stdwin.fleep()
			return
		cache[name] = tempname
	pid = os.fork()
	if pid == 0:
		# Child
		os.exec(SFPLAY, [SFPLAY, '-r', tempname])
		# NOTREACHED
	# Parent
	if G.synchronous:
		sts = os.wait(pid, 0)
	else:
		G.busy = pid
		G.stop.enable(1)
		G.cw.win.settimer(1)

main()