mirror of
https://github.com/python/cpython.git
synced 2024-12-11 18:53:56 +08:00
282 lines
6.6 KiB
Python
Executable File
282 lines
6.6 KiB
Python
Executable File
# 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
|