home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / Python 1.1 / Lib / irix5 / panel.py < prev    next >
Encoding:
Text File  |  1992-01-01  |  6.6 KB  |  282 lines  |  [TEXT/R*ch]
  1. # Module 'panel'
  2. #
  3. # Support for the Panel library.
  4. # Uses built-in module 'pnl'.
  5. # Applciations should use 'panel.function' instead of 'pnl.function';
  6. # most 'pnl' functions are transparently exported by 'panel',
  7. # but dopanel() is overridden and you have to use this version
  8. # if you want to use callbacks.
  9.  
  10.  
  11. import pnl
  12.  
  13.  
  14. debug = 0
  15.  
  16.  
  17. # Test if an object is a list.
  18. #
  19. def is_list(x):
  20.     return type(x) == type([])
  21.  
  22.  
  23. # Reverse a list.
  24. #
  25. def reverse(list):
  26.     res = []
  27.     for item in list:
  28.         res.insert(0, item)
  29.     return res
  30.  
  31.  
  32. # Get an attribute of a list, which may itself be another list.
  33. # Don't use 'prop' for name.
  34. #
  35. def getattrlist(list, name):
  36.     for item in list:
  37.         if item and is_list(item) and item[0] == name:
  38.             return item[1:]
  39.     return []
  40.  
  41.  
  42. # Get a property of a list, which may itself be another list.
  43. #
  44. def getproplist(list, name):
  45.     for item in list:
  46.         if item and is_list(item) and item[0] == 'prop':
  47.             if len(item) > 1 and item[1] == name:
  48.                 return item[2:]
  49.     return []
  50.  
  51.  
  52. # Test if an actuator description contains the property 'end-of-group'
  53. #
  54. def is_endgroup(list):
  55.     x = getproplist(list, 'end-of-group')
  56.     return (x and x[0] == '#t')
  57.  
  58.  
  59. # Neatly display an actuator definition given as S-expression
  60. # the prefix string is printed before each line.
  61. #
  62. def show_actuator(prefix, a):
  63.     for item in a:
  64.         if not is_list(item):
  65.             print prefix, item
  66.         elif item and item[0] == 'al':
  67.             print prefix, 'Subactuator list:'
  68.             for a in item[1:]:
  69.                 show_actuator(prefix + '    ', a)
  70.         elif len(item) == 2:
  71.             print prefix, item[0], '=>', item[1]
  72.         elif len(item) == 3 and item[0] == 'prop':
  73.             print prefix, 'Prop', item[1], '=>',
  74.             print item[2]
  75.         else:
  76.             print prefix, '?', item
  77.  
  78.  
  79. # Neatly display a panel.
  80. #
  81. def show_panel(prefix, p):
  82.     for item in p:
  83.         if not is_list(item):
  84.             print prefix, item
  85.         elif item and item[0] == 'al':
  86.             print prefix, 'Actuator list:'
  87.             for a in item[1:]:
  88.                 show_actuator(prefix + '    ', a)
  89.         elif len(item) == 2:
  90.             print prefix, item[0], '=>', item[1]
  91.         elif len(item) == 3 and item[0] == 'prop':
  92.             print prefix, 'Prop', item[1], '=>',
  93.             print item[2]
  94.         else:
  95.             print prefix, '?', item
  96.  
  97.  
  98. # Exception raised by build_actuator or build_panel.
  99. #
  100. panel_error = 'panel error'
  101.  
  102.  
  103. # Dummy callback used to initialize the callbacks.
  104. #
  105. def dummy_callback(arg):
  106.     pass
  107.  
  108.  
  109. # Assign attributes to members of the target.
  110. # Attribute names in exclist are ignored.
  111. # The member name is the attribute name prefixed with the prefix.
  112. #
  113. def assign_members(target, attrlist, exclist, prefix):
  114.     for item in attrlist:
  115.         if is_list(item) and len(item) == 2 and item[0] not in exclist:
  116.             name, value = item[0], item[1]
  117.             ok = 1
  118.             if value[0] in '-0123456789':
  119.                 value = eval(value)
  120.             elif value[0] == '"':
  121.                 value = value[1:-1]
  122.             elif value == 'move-then-resize':
  123.                 # Strange default set by Panel Editor...
  124.                 ok = 0
  125.             else:
  126.                 print 'unknown value', value, 'for', name
  127.                 ok = 0
  128.             if ok:
  129.                 lhs = 'target.' + prefix + name
  130.                 stmt = lhs + '=' + `value`
  131.                 if debug: print 'exec', stmt
  132.                 try:
  133.                     exec(stmt + '\n')
  134.                 except KeyboardInterrupt: # Don't catch this!
  135.                     raise KeyboardInterrupt
  136.                 except:
  137.                     print 'assign failed:', stmt
  138.  
  139.  
  140. # Build a real actuator from an actuator descriptior.
  141. # Return a pair (actuator, name).
  142. #
  143. def build_actuator(descr):
  144.     namelist = getattrlist(descr, 'name')
  145.     if namelist:
  146.         # Assume it is a string
  147.         actuatorname = namelist[0][1:-1]
  148.     else:
  149.         actuatorname = ''
  150.     type = descr[0]
  151.     if type[:4] == 'pnl_': type = type[4:]
  152.     act = pnl.mkact(type)
  153.     act.downfunc = act.activefunc = act.upfunc = dummy_callback
  154.     #
  155.     assign_members(act, descr[1:], ['al', 'data', 'name'], '')
  156.     #
  157.     # Treat actuator-specific data
  158.     #
  159.     datalist = getattrlist(descr, 'data')
  160.     prefix = ''
  161.     if type[-4:] == 'puck':
  162.         prefix = 'puck_'
  163.     elif type == 'mouse':
  164.         prefix = 'mouse_'
  165.     assign_members(act, datalist, [], prefix)
  166.     #
  167.     return act, actuatorname
  168.  
  169.  
  170. # Build all sub-actuators and add them to the super-actuator.
  171. # The super-actuator must already have been added to the panel.
  172. # Sub-actuators with defined names are added as members to the panel
  173. # so they can be referenced as p.name.
  174. #
  175. # Note: I have no idea how panel.endgroup() works when applied
  176. # to a sub-actuator.
  177. #
  178. def build_subactuators(panel, super_act, al):
  179.     #
  180.     # This is nearly the same loop as below in build_panel(),
  181.     # except a call is made to addsubact() instead of addact().
  182.     #
  183.     for a in al:
  184.         act, name = build_actuator(a)
  185.         act.addsubact(super_act)
  186.         if name:
  187.             stmt = 'panel.' + name + ' = act'
  188.             if debug: print 'exec', stmt
  189.             exec(stmt + '\n')
  190.         if is_endgroup(a):
  191.             panel.endgroup()
  192.         sub_al = getattrlist(a, 'al')
  193.         if sub_al:
  194.             build_subactuators(panel, act, sub_al)
  195.     #
  196.     # Fix the actuator to which whe just added subactuators.
  197.     # This can't hurt (I hope) and is needed for the scroll actuator.
  198.     #
  199.     super_act.fixact()
  200.  
  201.  
  202. # Build a real panel from a panel definition.
  203. # Return a panel object p, where for each named actuator a, p.name is a
  204. # reference to a.
  205. #
  206. def build_panel(descr):
  207.     #
  208.     # Sanity check
  209.     #
  210.     if (not descr) or descr[0] <> 'panel':
  211.         raise panel_error, 'panel description must start with "panel"'
  212.     #
  213.     if debug: show_panel('', descr)
  214.     #
  215.     # Create an empty panel
  216.     #
  217.     panel = pnl.mkpanel()
  218.     #
  219.     # Assign panel attributes
  220.     #
  221.     assign_members(panel, descr[1:], ['al'], '')
  222.     #
  223.     # Look for actuator list
  224.     #
  225.     al = getattrlist(descr, 'al')
  226.     #
  227.     # The order in which actuators are created is important
  228.     # because of the endgroup() operator.
  229.     # Unfortunately the Panel Editor outputs the actuator list
  230.     # in reverse order, so we reverse it here.
  231.     #
  232.     al = reverse(al)
  233.     #
  234.     for a in al:
  235.         act, name = build_actuator(a)
  236.         act.addact(panel)
  237.         if name:
  238.             stmt = 'panel.' + name + ' = act'
  239.             exec(stmt + '\n')
  240.         if is_endgroup(a):
  241.             panel.endgroup()
  242.         sub_al = getattrlist(a, 'al')
  243.         if sub_al:
  244.             build_subactuators(panel, act, sub_al)
  245.     #
  246.     return panel
  247.  
  248.  
  249. # Wrapper around pnl.dopanel() which calls call-back functions.
  250. #
  251. def my_dopanel():
  252.     # Extract only the first 4 elements to allow for future expansion
  253.     a, down, active, up = pnl.dopanel()[:4]
  254.     if down:
  255.         down.downfunc(down)
  256.     if active:
  257.         active.activefunc(active)
  258.     if up:
  259.         up.upfunc(up)
  260.     return a
  261.  
  262.  
  263. # Create one or more panels from a description file (S-expressions)
  264. # generated by the Panel Editor.
  265. # 
  266. def defpanellist(file):
  267.     import panelparser
  268.     descrlist = panelparser.parse_file(open(file, 'r'))
  269.     panellist = []
  270.     for descr in descrlist:
  271.         panellist.append(build_panel(descr))
  272.     return panellist
  273.  
  274.  
  275. # Import everything from built-in method pnl, so the user can always
  276. # use panel.foo() instead of pnl.foo().
  277. # This gives *no* performance penalty once this module is imported.
  278. #
  279. from pnl import *            # for export
  280.  
  281. dopanel = my_dopanel            # override pnl.dopanel
  282.