text: # Module 'panel'
  #
  # Support for the Panel library.
  # Uses built-in module 'pnl'.
  # Applciations should use 'panel.function' instead of 'pnl.function';
  # most 'pnl' functions are transparently exported by 'panel',
  # but dopanel() is overridden and you have to use this version
  # if you want to use callbacks.
  
  
  import pnl
  
  
  debug = 0
  
  
  # Test if an object is a list.
  #
  def is_list(x):
  	return type(x) == type([])
  
  
  # Reverse a list.
  #
  def reverse(list):
  	res = []
  	for item in list:
  		res.insert(0, item)
  	return res
  
  
  # Get an attribute of a list, which may itself be another list.
  # Don't use 'prop' for name.
  #
  def getattrlist(list, name):
  	for item in list:
  		if item and is_list(item) and item[0] == name:
  			return item[1:]
  	return []
  
  
  # Get a property of a list, which may itself be another list.
  #
  def getproplist(list, name):
  	for item in list:
  		if item and is_list(item) and item[0] == 'prop':
  			if len(item) > 1 and item[1] == name:
  				return item[2:]
  	return []
  
  
  # Test if an actuator description contains the property 'end-of-group'
  #
  def is_endgroup(list):
  	x = getproplist(list, 'end-of-group')
  	return (x and x[0] == '#t')
  
  
  # Neatly display an actuator definition given as S-expression
  # the prefix string is printed before each line.
  #
  def show_actuator(prefix, a):
  	for item in a:
  		if not is_list(item):
  			print prefix, item
  		elif item and item[0] == 'al':
  			print prefix, 'Subactuator list:'
  			for a in item[1:]:
  				show_actuator(prefix + '    ', a)
  		elif len(item) == 2:
  			print prefix, item[0], '=>', item[1]
  		elif len(item) == 3 and item[0] == 'prop':
  			print prefix, 'Prop', item[1], '=>',
  			print item[2]
  		else:
  			print prefix, '?', item
  
  
  # Neatly display a panel.
  #
  def show_panel(prefix, p):
  	for item in p:
  		if not is_list(item):
  			print prefix, item
  		elif item and item[0] == 'al':
  			print prefix, 'Actuator list:'
  			for a in item[1:]:
  				show_actuator(prefix + '    ', a)
  		elif len(item) == 2:
  			print prefix, item[0], '=>', item[1]
  		elif len(item) == 3 and item[0] == 'prop':
  			print prefix, 'Prop', item[1], '=>',
  			print item[2]
  		else:
  			print prefix, '?', item
  
  
  # Exception raised by build_actuator or build_panel.
  #
  panel_error = 'panel error'
  
  
  # Dummy callback used to initialize the callbacks.
  #
  def dummy_callback(arg):
  	pass
  
  
  # Assign attributes to members of the target.
  # Attribute names in exclist are ignored.
  # The member name is the attribute name prefixed with the prefix.
  #
  def assign_members(target, attrlist, exclist, prefix):
  	for item in attrlist:
  		if is_list(item) and len(item) == 2 and item[0] not in exclist:
  			name, value = item[0], item[1]
  			ok = 1
  			if value[0] in '-0123456789':
  				value = eval(value)
  			elif value[0] == '"':
  				value = value[1:-1]
  			elif value == 'move-then-resize':
  				# Strange default set by Panel Editor...
  				ok = 0
  			else:
  				print 'unknown value', value, 'for', name
  				ok = 0
  			if ok:
  				lhs = 'target.' + prefix + name
  				stmt = lhs + '=' + `value`
  				if debug: print 'exec', stmt
  				try:
  					exec stmt + '\n'
  				except KeyboardInterrupt: # Don't catch this!
  					raise KeyboardInterrupt
  				except:
  					print 'assign failed:', stmt
  
  
  # Build a real actuator from an actuator descriptior.
  # Return a pair (actuator, name).
  #
  def build_actuator(descr):
  	namelist = getattrlist(descr, 'name')
  	if namelist:
  		# Assume it is a string
  		actuatorname = namelist[0][1:-1]
  	else:
  		actuatorname = ''
  	type = descr[0]
  	if type[:4] == 'pnl_': type = type[4:]
  	act = pnl.mkact(type)
  	act.downfunc = act.activefunc = act.upfunc = dummy_callback
  	#
  	assign_members(act, descr[1:], ['al', 'data', 'name'], '')
  	#
  	# Treat actuator-specific data
  	#
  	datalist = getattrlist(descr, 'data')
  	prefix = ''
  	if type[-4:] == 'puck':
  		prefix = 'puck_'
  	elif type == 'mouse':
  		prefix = 'mouse_'
  	assign_members(act, datalist, [], prefix)
  	#
  	return act, actuatorname
  
  
  # Build all sub-actuators and add them to the super-actuator.
  # The super-actuator must already have been added to the panel.
  # Sub-actuators with defined names are added as members to the panel
  # so they can be referenced as p.name.
  #
  # Note: I have no idea how panel.endgroup() works when applied
  # to a sub-actuator.
  #
  def build_subactuators(panel, super_act, al):
  	#
  	# This is nearly the same loop as below in build_panel(),
  	# except a call is made to addsubact() instead of addact().
  	#
  	for a in al:
  		act, name = build_actuator(a)
  		act.addsubact(super_act)
  		if name:
  			stmt = 'panel.' + name + ' = act'
  			if debug: print 'exec', stmt
  			exec stmt + '\n'
  		if is_endgroup(a):
  			panel.endgroup()
  		sub_al = getattrlist(a, 'al')
  		if sub_al:
  			build_subactuators(panel, act, sub_al)
  	#
  	# Fix the actuator to which whe just added subactuators.
  	# This can't hurt (I hope) and is needed for the scroll actuator.
  	#
  	super_act.fixact()
  
  
  # Build a real panel from a panel definition.
  # Return a panel object p, where for each named actuator a, p.name is a
  # reference to a.
  #
  def build_panel(descr):
  	#
  	# Sanity check
  	#
  	if (not descr) or descr[0] <> 'panel':
  		raise panel_error, 'panel description must start with "panel"'
  	#
  	if debug: show_panel('', descr)
  	#
  	# Create an empty panel
  	#
  	panel = pnl.mkpanel()
  	#
  	# Assign panel attributes
  	#
  	assign_members(panel, descr[1:], ['al'], '')
  	#
  	# Look for actuator list
  	#
  	al = getattrlist(descr, 'al')
  	#
  	# The order in which actuators are created is important
  	# because of the endgroup() operator.
  	# Unfortunately the Panel Editor outputs the actuator list
  	# in reverse order, so we reverse it here.
  	#
  	al = reverse(al)
  	#
  	for a in al:
  		act, name = build_actuator(a)
  		act.addact(panel)
  		if name:
  			stmt = 'panel.' + name + ' = act'
  			exec stmt + '\n'
  		if is_endgroup(a):
  			panel.endgroup()
  		sub_al = getattrlist(a, 'al')
  		if sub_al:
  			build_subactuators(panel, act, sub_al)
  	#
  	return panel
  
  
  # Wrapper around pnl.dopanel() which calls call-back functions.
  #
  def my_dopanel():
  	# Extract only the first 4 elements to allow for future expansion
  	a, down, active, up = pnl.dopanel()[:4]
  	if down:
  		down.downfunc(down)
  	if active:
  		active.activefunc(active)
  	if up:
  		up.upfunc(up)
  	return a
  
  
  # Create one or more panels from a description file (S-expressions)
  # generated by the Panel Editor.
  # 
  def defpanellist(file):
  	import panelparser
  	descrlist = panelparser.parse_file(open(file, 'r'))
  	panellist = []
  	for descr in descrlist:
  		panellist.append(build_panel(descr))
  	return panellist
  
  
  # Import everything from built-in method pnl, so the user can always
  # use panel.foo() instead of pnl.foo().
  # This gives *no* performance penalty once this module is imported.
  #
  from pnl import *			# for export
  
  dopanel = my_dopanel			# override pnl.dopanel
  