| 1 | #
|
|---|
| 2 | # flp - Module to load fl forms from fd files
|
|---|
| 3 | #
|
|---|
| 4 | # Jack Jansen, December 1991
|
|---|
| 5 | #
|
|---|
| 6 | import os
|
|---|
| 7 | import sys
|
|---|
| 8 | import FL
|
|---|
| 9 |
|
|---|
| 10 | SPLITLINE = '--------------------'
|
|---|
| 11 | FORMLINE = '=============== FORM ==============='
|
|---|
| 12 | ENDLINE = '=============================='
|
|---|
| 13 |
|
|---|
| 14 | class error(Exception):
|
|---|
| 15 | pass
|
|---|
| 16 |
|
|---|
| 17 | ##################################################################
|
|---|
| 18 | # Part 1 - The parsing routines #
|
|---|
| 19 | ##################################################################
|
|---|
| 20 |
|
|---|
| 21 | #
|
|---|
| 22 | # Externally visible function. Load form.
|
|---|
| 23 | #
|
|---|
| 24 | def parse_form(filename, formname):
|
|---|
| 25 | forms = checkcache(filename)
|
|---|
| 26 | if forms is None:
|
|---|
| 27 | forms = parse_forms(filename)
|
|---|
| 28 | if forms.has_key(formname):
|
|---|
| 29 | return forms[formname]
|
|---|
| 30 | else:
|
|---|
| 31 | raise error, 'No such form in fd file'
|
|---|
| 32 |
|
|---|
| 33 | #
|
|---|
| 34 | # Externally visible function. Load all forms.
|
|---|
| 35 | #
|
|---|
| 36 | def parse_forms(filename):
|
|---|
| 37 | forms = checkcache(filename)
|
|---|
| 38 | if forms is not None: return forms
|
|---|
| 39 | fp = _open_formfile(filename)
|
|---|
| 40 | nforms = _parse_fd_header(fp)
|
|---|
| 41 | forms = {}
|
|---|
| 42 | for i in range(nforms):
|
|---|
| 43 | form = _parse_fd_form(fp, None)
|
|---|
| 44 | forms[form[0].Name] = form
|
|---|
| 45 | writecache(filename, forms)
|
|---|
| 46 | return forms
|
|---|
| 47 |
|
|---|
| 48 | #
|
|---|
| 49 | # Internal: see if a cached version of the file exists
|
|---|
| 50 | #
|
|---|
| 51 | MAGIC = '.fdc'
|
|---|
| 52 | _internal_cache = {} # Used by frozen scripts only
|
|---|
| 53 | def checkcache(filename):
|
|---|
| 54 | if _internal_cache.has_key(filename):
|
|---|
| 55 | altforms = _internal_cache[filename]
|
|---|
| 56 | return _unpack_cache(altforms)
|
|---|
| 57 | import marshal
|
|---|
| 58 | fp, filename = _open_formfile2(filename)
|
|---|
| 59 | fp.close()
|
|---|
| 60 | cachename = filename + 'c'
|
|---|
| 61 | try:
|
|---|
| 62 | fp = open(cachename, 'r')
|
|---|
| 63 | except IOError:
|
|---|
| 64 | #print 'flp: no cache file', cachename
|
|---|
| 65 | return None
|
|---|
| 66 | try:
|
|---|
| 67 | if fp.read(4) != MAGIC:
|
|---|
| 68 | print 'flp: bad magic word in cache file', cachename
|
|---|
| 69 | return None
|
|---|
| 70 | cache_mtime = rdlong(fp)
|
|---|
| 71 | file_mtime = getmtime(filename)
|
|---|
| 72 | if cache_mtime != file_mtime:
|
|---|
| 73 | #print 'flp: outdated cache file', cachename
|
|---|
| 74 | return None
|
|---|
| 75 | #print 'flp: valid cache file', cachename
|
|---|
| 76 | altforms = marshal.load(fp)
|
|---|
| 77 | return _unpack_cache(altforms)
|
|---|
| 78 | finally:
|
|---|
| 79 | fp.close()
|
|---|
| 80 |
|
|---|
| 81 | def _unpack_cache(altforms):
|
|---|
| 82 | forms = {}
|
|---|
| 83 | for name in altforms.keys():
|
|---|
| 84 | altobj, altlist = altforms[name]
|
|---|
| 85 | obj = _newobj()
|
|---|
| 86 | obj.make(altobj)
|
|---|
| 87 | list = []
|
|---|
| 88 | for altobj in altlist:
|
|---|
| 89 | nobj = _newobj()
|
|---|
| 90 | nobj.make(altobj)
|
|---|
| 91 | list.append(nobj)
|
|---|
| 92 | forms[name] = obj, list
|
|---|
| 93 | return forms
|
|---|
| 94 |
|
|---|
| 95 | def rdlong(fp):
|
|---|
| 96 | s = fp.read(4)
|
|---|
| 97 | if len(s) != 4: return None
|
|---|
| 98 | a, b, c, d = s[0], s[1], s[2], s[3]
|
|---|
| 99 | return ord(a)<<24 | ord(b)<<16 | ord(c)<<8 | ord(d)
|
|---|
| 100 |
|
|---|
| 101 | def wrlong(fp, x):
|
|---|
| 102 | a, b, c, d = (x>>24)&0xff, (x>>16)&0xff, (x>>8)&0xff, x&0xff
|
|---|
| 103 | fp.write(chr(a) + chr(b) + chr(c) + chr(d))
|
|---|
| 104 |
|
|---|
| 105 | def getmtime(filename):
|
|---|
| 106 | import os
|
|---|
| 107 | from stat import ST_MTIME
|
|---|
| 108 | try:
|
|---|
| 109 | return os.stat(filename)[ST_MTIME]
|
|---|
| 110 | except os.error:
|
|---|
| 111 | return None
|
|---|
| 112 |
|
|---|
| 113 | #
|
|---|
| 114 | # Internal: write cached version of the form (parsing is too slow!)
|
|---|
| 115 | #
|
|---|
| 116 | def writecache(filename, forms):
|
|---|
| 117 | import marshal
|
|---|
| 118 | fp, filename = _open_formfile2(filename)
|
|---|
| 119 | fp.close()
|
|---|
| 120 | cachename = filename + 'c'
|
|---|
| 121 | try:
|
|---|
| 122 | fp = open(cachename, 'w')
|
|---|
| 123 | except IOError:
|
|---|
| 124 | print 'flp: can\'t create cache file', cachename
|
|---|
| 125 | return # Never mind
|
|---|
| 126 | fp.write('\0\0\0\0') # Seek back and write MAGIC when done
|
|---|
| 127 | wrlong(fp, getmtime(filename))
|
|---|
| 128 | altforms = _pack_cache(forms)
|
|---|
| 129 | marshal.dump(altforms, fp)
|
|---|
| 130 | fp.seek(0)
|
|---|
| 131 | fp.write(MAGIC)
|
|---|
| 132 | fp.close()
|
|---|
| 133 | #print 'flp: wrote cache file', cachename
|
|---|
| 134 |
|
|---|
| 135 | #
|
|---|
| 136 | # External: print some statements that set up the internal cache.
|
|---|
| 137 | # This is for use with the "freeze" script. You should call
|
|---|
| 138 | # flp.freeze(filename) for all forms used by the script, and collect
|
|---|
| 139 | # the output on a file in a module file named "frozenforms.py". Then
|
|---|
| 140 | # in the main program of the script import frozenforms.
|
|---|
| 141 | # (Don't forget to take this out when using the unfrozen version of
|
|---|
| 142 | # the script!)
|
|---|
| 143 | #
|
|---|
| 144 | def freeze(filename):
|
|---|
| 145 | forms = parse_forms(filename)
|
|---|
| 146 | altforms = _pack_cache(forms)
|
|---|
| 147 | print 'import flp'
|
|---|
| 148 | print 'flp._internal_cache[', repr(filename), '] =', altforms
|
|---|
| 149 |
|
|---|
| 150 | #
|
|---|
| 151 | # Internal: create the data structure to be placed in the cache
|
|---|
| 152 | #
|
|---|
| 153 | def _pack_cache(forms):
|
|---|
| 154 | altforms = {}
|
|---|
| 155 | for name in forms.keys():
|
|---|
| 156 | obj, list = forms[name]
|
|---|
| 157 | altobj = obj.__dict__
|
|---|
| 158 | altlist = []
|
|---|
| 159 | for obj in list: altlist.append(obj.__dict__)
|
|---|
| 160 | altforms[name] = altobj, altlist
|
|---|
| 161 | return altforms
|
|---|
| 162 |
|
|---|
| 163 | #
|
|---|
| 164 | # Internal: Locate form file (using PYTHONPATH) and open file
|
|---|
| 165 | #
|
|---|
| 166 | def _open_formfile(filename):
|
|---|
| 167 | return _open_formfile2(filename)[0]
|
|---|
| 168 |
|
|---|
| 169 | def _open_formfile2(filename):
|
|---|
| 170 | if filename[-3:] != '.fd':
|
|---|
| 171 | filename = filename + '.fd'
|
|---|
| 172 | if filename[0] == '/':
|
|---|
| 173 | try:
|
|---|
| 174 | fp = open(filename,'r')
|
|---|
| 175 | except IOError:
|
|---|
| 176 | fp = None
|
|---|
| 177 | else:
|
|---|
| 178 | for pc in sys.path:
|
|---|
| 179 | pn = os.path.join(pc, filename)
|
|---|
| 180 | try:
|
|---|
| 181 | fp = open(pn, 'r')
|
|---|
| 182 | filename = pn
|
|---|
| 183 | break
|
|---|
| 184 | except IOError:
|
|---|
| 185 | fp = None
|
|---|
| 186 | if fp is None:
|
|---|
| 187 | raise error, 'Cannot find forms file ' + filename
|
|---|
| 188 | return fp, filename
|
|---|
| 189 |
|
|---|
| 190 | #
|
|---|
| 191 | # Internal: parse the fd file header, return number of forms
|
|---|
| 192 | #
|
|---|
| 193 | def _parse_fd_header(file):
|
|---|
| 194 | # First read the magic header line
|
|---|
| 195 | datum = _parse_1_line(file)
|
|---|
| 196 | if datum != ('Magic', 12321):
|
|---|
| 197 | raise error, 'Not a forms definition file'
|
|---|
| 198 | # Now skip until we know number of forms
|
|---|
| 199 | while 1:
|
|---|
| 200 | datum = _parse_1_line(file)
|
|---|
| 201 | if type(datum) == type(()) and datum[0] == 'Numberofforms':
|
|---|
| 202 | break
|
|---|
| 203 | return datum[1]
|
|---|
| 204 | #
|
|---|
| 205 | # Internal: parse fd form, or skip if name doesn't match.
|
|---|
| 206 | # the special value None means 'always parse it'.
|
|---|
| 207 | #
|
|---|
| 208 | def _parse_fd_form(file, name):
|
|---|
| 209 | datum = _parse_1_line(file)
|
|---|
| 210 | if datum != FORMLINE:
|
|---|
| 211 | raise error, 'Missing === FORM === line'
|
|---|
| 212 | form = _parse_object(file)
|
|---|
| 213 | if form.Name == name or name is None:
|
|---|
| 214 | objs = []
|
|---|
| 215 | for j in range(form.Numberofobjects):
|
|---|
| 216 | obj = _parse_object(file)
|
|---|
| 217 | objs.append(obj)
|
|---|
| 218 | return (form, objs)
|
|---|
| 219 | else:
|
|---|
| 220 | for j in range(form.Numberofobjects):
|
|---|
| 221 | _skip_object(file)
|
|---|
| 222 | return None
|
|---|
| 223 |
|
|---|
| 224 | #
|
|---|
| 225 | # Internal class: a convenient place to store object info fields
|
|---|
| 226 | #
|
|---|
| 227 | class _newobj:
|
|---|
| 228 | def add(self, name, value):
|
|---|
| 229 | self.__dict__[name] = value
|
|---|
| 230 | def make(self, dict):
|
|---|
| 231 | for name in dict.keys():
|
|---|
| 232 | self.add(name, dict[name])
|
|---|
| 233 |
|
|---|
| 234 | #
|
|---|
| 235 | # Internal parsing routines.
|
|---|
| 236 | #
|
|---|
| 237 | def _parse_string(str):
|
|---|
| 238 | if '\\' in str:
|
|---|
| 239 | s = '\'' + str + '\''
|
|---|
| 240 | try:
|
|---|
| 241 | return eval(s)
|
|---|
| 242 | except:
|
|---|
| 243 | pass
|
|---|
| 244 | return str
|
|---|
| 245 |
|
|---|
| 246 | def _parse_num(str):
|
|---|
| 247 | return eval(str)
|
|---|
| 248 |
|
|---|
| 249 | def _parse_numlist(str):
|
|---|
| 250 | slist = str.split()
|
|---|
| 251 | nlist = []
|
|---|
| 252 | for i in slist:
|
|---|
| 253 | nlist.append(_parse_num(i))
|
|---|
| 254 | return nlist
|
|---|
| 255 |
|
|---|
| 256 | # This dictionary maps item names to parsing routines.
|
|---|
| 257 | # If no routine is given '_parse_num' is default.
|
|---|
| 258 | _parse_func = { \
|
|---|
| 259 | 'Name': _parse_string, \
|
|---|
| 260 | 'Box': _parse_numlist, \
|
|---|
| 261 | 'Colors': _parse_numlist, \
|
|---|
| 262 | 'Label': _parse_string, \
|
|---|
| 263 | 'Name': _parse_string, \
|
|---|
| 264 | 'Callback': _parse_string, \
|
|---|
| 265 | 'Argument': _parse_string }
|
|---|
| 266 |
|
|---|
| 267 | # This function parses a line, and returns either
|
|---|
| 268 | # a string or a tuple (name,value)
|
|---|
| 269 |
|
|---|
| 270 | import re
|
|---|
| 271 | prog = re.compile('^([^:]*): *(.*)')
|
|---|
| 272 |
|
|---|
| 273 | def _parse_line(line):
|
|---|
| 274 | match = prog.match(line)
|
|---|
| 275 | if not match:
|
|---|
| 276 | return line
|
|---|
| 277 | name, value = match.group(1, 2)
|
|---|
| 278 | if name[0] == 'N':
|
|---|
| 279 | name = ''.join(name.split())
|
|---|
| 280 | name = name.lower()
|
|---|
| 281 | name = name.capitalize()
|
|---|
| 282 | try:
|
|---|
| 283 | pf = _parse_func[name]
|
|---|
| 284 | except KeyError:
|
|---|
| 285 | pf = _parse_num
|
|---|
| 286 | value = pf(value)
|
|---|
| 287 | return (name, value)
|
|---|
| 288 |
|
|---|
| 289 | def _readline(file):
|
|---|
| 290 | line = file.readline()
|
|---|
| 291 | if not line:
|
|---|
| 292 | raise EOFError
|
|---|
| 293 | return line[:-1]
|
|---|
| 294 |
|
|---|
| 295 | def _parse_1_line(file):
|
|---|
| 296 | line = _readline(file)
|
|---|
| 297 | while line == '':
|
|---|
| 298 | line = _readline(file)
|
|---|
| 299 | return _parse_line(line)
|
|---|
| 300 |
|
|---|
| 301 | def _skip_object(file):
|
|---|
| 302 | line = ''
|
|---|
| 303 | while not line in (SPLITLINE, FORMLINE, ENDLINE):
|
|---|
| 304 | pos = file.tell()
|
|---|
| 305 | line = _readline(file)
|
|---|
| 306 | if line == FORMLINE:
|
|---|
| 307 | file.seek(pos)
|
|---|
| 308 |
|
|---|
| 309 | def _parse_object(file):
|
|---|
| 310 | obj = _newobj()
|
|---|
| 311 | while 1:
|
|---|
| 312 | pos = file.tell()
|
|---|
| 313 | datum = _parse_1_line(file)
|
|---|
| 314 | if datum in (SPLITLINE, FORMLINE, ENDLINE):
|
|---|
| 315 | if datum == FORMLINE:
|
|---|
| 316 | file.seek(pos)
|
|---|
| 317 | return obj
|
|---|
| 318 | if type(datum) is not type(()) or len(datum) != 2:
|
|---|
| 319 | raise error, 'Parse error, illegal line in object: '+datum
|
|---|
| 320 | obj.add(datum[0], datum[1])
|
|---|
| 321 |
|
|---|
| 322 | #################################################################
|
|---|
| 323 | # Part 2 - High-level object/form creation routines #
|
|---|
| 324 | #################################################################
|
|---|
| 325 |
|
|---|
| 326 | #
|
|---|
| 327 | # External - Create a form an link to an instance variable.
|
|---|
| 328 | #
|
|---|
| 329 | def create_full_form(inst, (fdata, odatalist)):
|
|---|
| 330 | form = create_form(fdata)
|
|---|
| 331 | exec 'inst.'+fdata.Name+' = form\n'
|
|---|
| 332 | for odata in odatalist:
|
|---|
| 333 | create_object_instance(inst, form, odata)
|
|---|
| 334 |
|
|---|
| 335 | #
|
|---|
| 336 | # External - Merge a form into an existing form in an instance
|
|---|
| 337 | # variable.
|
|---|
| 338 | #
|
|---|
| 339 | def merge_full_form(inst, form, (fdata, odatalist)):
|
|---|
| 340 | exec 'inst.'+fdata.Name+' = form\n'
|
|---|
| 341 | if odatalist[0].Class != FL.BOX:
|
|---|
| 342 | raise error, 'merge_full_form() expects FL.BOX as first obj'
|
|---|
| 343 | for odata in odatalist[1:]:
|
|---|
| 344 | create_object_instance(inst, form, odata)
|
|---|
| 345 |
|
|---|
| 346 |
|
|---|
| 347 | #################################################################
|
|---|
| 348 | # Part 3 - Low-level object/form creation routines #
|
|---|
| 349 | #################################################################
|
|---|
| 350 |
|
|---|
| 351 | #
|
|---|
| 352 | # External Create_form - Create form from parameters
|
|---|
| 353 | #
|
|---|
| 354 | def create_form(fdata):
|
|---|
| 355 | import fl
|
|---|
| 356 | return fl.make_form(FL.NO_BOX, fdata.Width, fdata.Height)
|
|---|
| 357 |
|
|---|
| 358 | #
|
|---|
| 359 | # External create_object - Create an object. Make sure there are
|
|---|
| 360 | # no callbacks. Returns the object created.
|
|---|
| 361 | #
|
|---|
| 362 | def create_object(form, odata):
|
|---|
| 363 | obj = _create_object(form, odata)
|
|---|
| 364 | if odata.Callback:
|
|---|
| 365 | raise error, 'Creating free object with callback'
|
|---|
| 366 | return obj
|
|---|
| 367 | #
|
|---|
| 368 | # External create_object_instance - Create object in an instance.
|
|---|
| 369 | #
|
|---|
| 370 | def create_object_instance(inst, form, odata):
|
|---|
| 371 | obj = _create_object(form, odata)
|
|---|
| 372 | if odata.Callback:
|
|---|
| 373 | cbfunc = eval('inst.'+odata.Callback)
|
|---|
| 374 | obj.set_call_back(cbfunc, odata.Argument)
|
|---|
| 375 | if odata.Name:
|
|---|
| 376 | exec 'inst.' + odata.Name + ' = obj\n'
|
|---|
| 377 | #
|
|---|
| 378 | # Internal _create_object: Create the object and fill options
|
|---|
| 379 | #
|
|---|
| 380 | def _create_object(form, odata):
|
|---|
| 381 | crfunc = _select_crfunc(form, odata.Class)
|
|---|
| 382 | obj = crfunc(odata.Type, odata.Box[0], odata.Box[1], odata.Box[2], \
|
|---|
| 383 | odata.Box[3], odata.Label)
|
|---|
| 384 | if not odata.Class in (FL.BEGIN_GROUP, FL.END_GROUP):
|
|---|
| 385 | obj.boxtype = odata.Boxtype
|
|---|
| 386 | obj.col1 = odata.Colors[0]
|
|---|
| 387 | obj.col2 = odata.Colors[1]
|
|---|
| 388 | obj.align = odata.Alignment
|
|---|
| 389 | obj.lstyle = odata.Style
|
|---|
| 390 | obj.lsize = odata.Size
|
|---|
| 391 | obj.lcol = odata.Lcol
|
|---|
| 392 | return obj
|
|---|
| 393 | #
|
|---|
| 394 | # Internal crfunc: helper function that returns correct create function
|
|---|
| 395 | #
|
|---|
| 396 | def _select_crfunc(fm, cl):
|
|---|
| 397 | if cl == FL.BEGIN_GROUP: return fm.bgn_group
|
|---|
| 398 | elif cl == FL.END_GROUP: return fm.end_group
|
|---|
| 399 | elif cl == FL.BITMAP: return fm.add_bitmap
|
|---|
| 400 | elif cl == FL.BOX: return fm.add_box
|
|---|
| 401 | elif cl == FL.BROWSER: return fm.add_browser
|
|---|
| 402 | elif cl == FL.BUTTON: return fm.add_button
|
|---|
| 403 | elif cl == FL.CHART: return fm.add_chart
|
|---|
| 404 | elif cl == FL.CHOICE: return fm.add_choice
|
|---|
| 405 | elif cl == FL.CLOCK: return fm.add_clock
|
|---|
| 406 | elif cl == FL.COUNTER: return fm.add_counter
|
|---|
| 407 | elif cl == FL.DIAL: return fm.add_dial
|
|---|
| 408 | elif cl == FL.FREE: return fm.add_free
|
|---|
| 409 | elif cl == FL.INPUT: return fm.add_input
|
|---|
| 410 | elif cl == FL.LIGHTBUTTON: return fm.add_lightbutton
|
|---|
| 411 | elif cl == FL.MENU: return fm.add_menu
|
|---|
| 412 | elif cl == FL.POSITIONER: return fm.add_positioner
|
|---|
| 413 | elif cl == FL.ROUNDBUTTON: return fm.add_roundbutton
|
|---|
| 414 | elif cl == FL.SLIDER: return fm.add_slider
|
|---|
| 415 | elif cl == FL.VALSLIDER: return fm.add_valslider
|
|---|
| 416 | elif cl == FL.TEXT: return fm.add_text
|
|---|
| 417 | elif cl == FL.TIMER: return fm.add_timer
|
|---|
| 418 | else:
|
|---|
| 419 | raise error, 'Unknown object type: %r' % (cl,)
|
|---|
| 420 |
|
|---|
| 421 |
|
|---|
| 422 | def test():
|
|---|
| 423 | import time
|
|---|
| 424 | t0 = time.time()
|
|---|
| 425 | if len(sys.argv) == 2:
|
|---|
| 426 | forms = parse_forms(sys.argv[1])
|
|---|
| 427 | t1 = time.time()
|
|---|
| 428 | print 'parse time:', 0.001*(t1-t0), 'sec.'
|
|---|
| 429 | keys = forms.keys()
|
|---|
| 430 | keys.sort()
|
|---|
| 431 | for i in keys:
|
|---|
| 432 | _printform(forms[i])
|
|---|
| 433 | elif len(sys.argv) == 3:
|
|---|
| 434 | form = parse_form(sys.argv[1], sys.argv[2])
|
|---|
| 435 | t1 = time.time()
|
|---|
| 436 | print 'parse time:', round(t1-t0, 3), 'sec.'
|
|---|
| 437 | _printform(form)
|
|---|
| 438 | else:
|
|---|
| 439 | print 'Usage: test fdfile [form]'
|
|---|
| 440 |
|
|---|
| 441 | def _printform(form):
|
|---|
| 442 | f = form[0]
|
|---|
| 443 | objs = form[1]
|
|---|
| 444 | print 'Form ', f.Name, ', size: ', f.Width, f.Height, ' Nobj ', f.Numberofobjects
|
|---|
| 445 | for i in objs:
|
|---|
| 446 | print ' Obj ', i.Name, ' type ', i.Class, i.Type
|
|---|
| 447 | print ' Box ', i.Box, ' btype ', i.Boxtype
|
|---|
| 448 | print ' Label ', i.Label, ' size/style/col/align ', i.Size,i.Style, i.Lcol, i.Alignment
|
|---|
| 449 | print ' cols ', i.Colors
|
|---|
| 450 | print ' cback ', i.Callback, i.Argument
|
|---|
