Lib/plat-irix6/panel.py

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