Lib/plat-irix6/flp.py

   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