Lib/plat-irix5/flp.py

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