| 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
|
|---|
