| # |
| # flp - Module to load fl forms from fd files |
| # |
| # Jack Jansen, December 1991 |
| # |
| import string |
| import os |
| import sys |
| import FL |
| |
| SPLITLINE = '--------------------' |
| FORMLINE = '=============== FORM ===============' |
| ENDLINE = '==============================' |
| |
| class error(Exception): |
| pass |
| |
| ################################################################## |
| # Part 1 - The parsing routines # |
| ################################################################## |
| |
| # |
| # Externally visible function. Load form. |
| # |
| def parse_form(filename, formname): |
| forms = checkcache(filename) |
| if forms is None: |
| forms = parse_forms(filename) |
| if forms.has_key(formname): |
| return forms[formname] |
| else: |
| raise error, 'No such form in fd file' |
| |
| # |
| # Externally visible function. Load all forms. |
| # |
| def parse_forms(filename): |
| forms = checkcache(filename) |
| if forms is not None: return forms |
| fp = _open_formfile(filename) |
| nforms = _parse_fd_header(fp) |
| forms = {} |
| for i in range(nforms): |
| form = _parse_fd_form(fp, None) |
| forms[form[0].Name] = form |
| writecache(filename, forms) |
| return forms |
| |
| # |
| # Internal: see if a cached version of the file exists |
| # |
| MAGIC = '.fdc' |
| _internal_cache = {} # Used by frozen scripts only |
| def checkcache(filename): |
| if _internal_cache.has_key(filename): |
| altforms = _internal_cache[filename] |
| return _unpack_cache(altforms) |
| import marshal |
| fp, filename = _open_formfile2(filename) |
| fp.close() |
| cachename = filename + 'c' |
| try: |
| fp = open(cachename, 'r') |
| except IOError: |
| #print 'flp: no cache file', cachename |
| return None |
| try: |
| if fp.read(4) != MAGIC: |
| print 'flp: bad magic word in cache file', cachename |
| return None |
| cache_mtime = rdlong(fp) |
| file_mtime = getmtime(filename) |
| if cache_mtime != file_mtime: |
| #print 'flp: outdated cache file', cachename |
| return None |
| #print 'flp: valid cache file', cachename |
| altforms = marshal.load(fp) |
| return _unpack_cache(altforms) |
| finally: |
| fp.close() |
| |
| def _unpack_cache(altforms): |
| forms = {} |
| for name in altforms.keys(): |
| altobj, altlist = altforms[name] |
| obj = _newobj() |
| obj.make(altobj) |
| list = [] |
| for altobj in altlist: |
| nobj = _newobj() |
| nobj.make(altobj) |
| list.append(nobj) |
| forms[name] = obj, list |
| return forms |
| |
| def rdlong(fp): |
| s = fp.read(4) |
| if len(s) != 4: return None |
| a, b, c, d = s[0], s[1], s[2], s[3] |
| return ord(a)<<24 | ord(b)<<16 | ord(c)<<8 | ord(d) |
| |
| def wrlong(fp, x): |
| a, b, c, d = (x>>24)&0xff, (x>>16)&0xff, (x>>8)&0xff, x&0xff |
| fp.write(chr(a) + chr(b) + chr(c) + chr(d)) |
| |
| def getmtime(filename): |
| import os |
| from stat import ST_MTIME |
| try: |
| return os.stat(filename)[ST_MTIME] |
| except os.error: |
| return None |
| |
| # |
| # Internal: write cached version of the form (parsing is too slow!) |
| # |
| def writecache(filename, forms): |
| import marshal |
| fp, filename = _open_formfile2(filename) |
| fp.close() |
| cachename = filename + 'c' |
| try: |
| fp = open(cachename, 'w') |
| except IOError: |
| print 'flp: can\'t create cache file', cachename |
| return # Never mind |
| fp.write('\0\0\0\0') # Seek back and write MAGIC when done |
| wrlong(fp, getmtime(filename)) |
| altforms = _pack_cache(forms) |
| marshal.dump(altforms, fp) |
| fp.seek(0) |
| fp.write(MAGIC) |
| fp.close() |
| #print 'flp: wrote cache file', cachename |
| |
| # |
| # External: print some statements that set up the internal cache. |
| # This is for use with the "freeze" script. You should call |
| # flp.freeze(filename) for all forms used by the script, and collect |
| # the output on a file in a module file named "frozenforms.py". Then |
| # in the main program of the script import frozenforms. |
| # (Don't forget to take this out when using the unfrozen version of |
| # the script!) |
| # |
| def freeze(filename): |
| forms = parse_forms(filename) |
| altforms = _pack_cache(forms) |
| print 'import flp' |
| print 'flp._internal_cache[', `filename`, '] =', altforms |
| |
| # |
| # Internal: create the data structure to be placed in the cache |
| # |
| def _pack_cache(forms): |
| altforms = {} |
| for name in forms.keys(): |
| obj, list = forms[name] |
| altobj = obj.__dict__ |
| altlist = [] |
| for obj in list: altlist.append(obj.__dict__) |
| altforms[name] = altobj, altlist |
| return altforms |
| |
| # |
| # Internal: Locate form file (using PYTHONPATH) and open file |
| # |
| def _open_formfile(filename): |
| return _open_formfile2(filename)[0] |
| |
| def _open_formfile2(filename): |
| if filename[-3:] != '.fd': |
| filename = filename + '.fd' |
| if filename[0] == '/': |
| try: |
| fp = open(filename,'r') |
| except IOError: |
| fp = None |
| else: |
| for pc in sys.path: |
| pn = os.path.join(pc, filename) |
| try: |
| fp = open(pn, 'r') |
| filename = pn |
| break |
| except IOError: |
| fp = None |
| if fp is None: |
| raise error, 'Cannot find forms file ' + filename |
| return fp, filename |
| |
| # |
| # Internal: parse the fd file header, return number of forms |
| # |
| def _parse_fd_header(file): |
| # First read the magic header line |
| datum = _parse_1_line(file) |
| if datum != ('Magic', 12321): |
| raise error, 'Not a forms definition file' |
| # Now skip until we know number of forms |
| while 1: |
| datum = _parse_1_line(file) |
| if type(datum) == type(()) and datum[0] == 'Numberofforms': |
| break |
| return datum[1] |
| # |
| # Internal: parse fd form, or skip if name doesn't match. |
| # the special value None means 'always parse it'. |
| # |
| def _parse_fd_form(file, name): |
| datum = _parse_1_line(file) |
| if datum != FORMLINE: |
| raise error, 'Missing === FORM === line' |
| form = _parse_object(file) |
| if form.Name == name or name is None: |
| objs = [] |
| for j in range(form.Numberofobjects): |
| obj = _parse_object(file) |
| objs.append(obj) |
| return (form, objs) |
| else: |
| for j in range(form.Numberofobjects): |
| _skip_object(file) |
| return None |
| |
| # |
| # Internal class: a convenient place to store object info fields |
| # |
| class _newobj: |
| def add(self, name, value): |
| self.__dict__[name] = value |
| def make(self, dict): |
| for name in dict.keys(): |
| self.add(name, dict[name]) |
| |
| # |
| # Internal parsing routines. |
| # |
| def _parse_string(str): |
| if '\\' in str: |
| s = '\'' + str + '\'' |
| try: |
| return eval(s) |
| except: |
| pass |
| return str |
| |
| def _parse_num(str): |
| return eval(str) |
| |
| def _parse_numlist(str): |
| slist = string.split(str) |
| nlist = [] |
| for i in slist: |
| nlist.append(_parse_num(i)) |
| return nlist |
| |
| # This dictionary maps item names to parsing routines. |
| # If no routine is given '_parse_num' is default. |
| _parse_func = { \ |
| 'Name': _parse_string, \ |
| 'Box': _parse_numlist, \ |
| 'Colors': _parse_numlist, \ |
| 'Label': _parse_string, \ |
| 'Name': _parse_string, \ |
| 'Callback': _parse_string, \ |
| 'Argument': _parse_string } |
| |
| # This function parses a line, and returns either |
| # a string or a tuple (name,value) |
| |
| import re |
| prog = re.compile('^([^:]*): *(.*)') |
| |
| def _parse_line(line): |
| match = prog.match(line) |
| if not match: |
| return line |
| name, value = match.group(1, 2) |
| if name[0] == 'N': |
| name = string.join(string.split(name),'') |
| name = string.lower(name) |
| name = string.capitalize(name) |
| try: |
| pf = _parse_func[name] |
| except KeyError: |
| pf = _parse_num |
| value = pf(value) |
| return (name, value) |
| |
| def _readline(file): |
| line = file.readline() |
| if not line: |
| raise EOFError |
| return line[:-1] |
| |
| def _parse_1_line(file): |
| line = _readline(file) |
| while line == '': |
| line = _readline(file) |
| return _parse_line(line) |
| |
| def _skip_object(file): |
| line = '' |
| while not line in (SPLITLINE, FORMLINE, ENDLINE): |
| pos = file.tell() |
| line = _readline(file) |
| if line == FORMLINE: |
| file.seek(pos) |
| |
| def _parse_object(file): |
| obj = _newobj() |
| while 1: |
| pos = file.tell() |
| datum = _parse_1_line(file) |
| if datum in (SPLITLINE, FORMLINE, ENDLINE): |
| if datum == FORMLINE: |
| file.seek(pos) |
| return obj |
| if type(datum) is not type(()) or len(datum) != 2: |
| raise error, 'Parse error, illegal line in object: '+datum |
| obj.add(datum[0], datum[1]) |
| |
| ################################################################# |
| # Part 2 - High-level object/form creation routines # |
| ################################################################# |
| |
| # |
| # External - Create a form an link to an instance variable. |
| # |
| def create_full_form(inst, (fdata, odatalist)): |
| form = create_form(fdata) |
| exec 'inst.'+fdata.Name+' = form\n' |
| for odata in odatalist: |
| create_object_instance(inst, form, odata) |
| |
| # |
| # External - Merge a form into an existing form in an instance |
| # variable. |
| # |
| def merge_full_form(inst, form, (fdata, odatalist)): |
| exec 'inst.'+fdata.Name+' = form\n' |
| if odatalist[0].Class != FL.BOX: |
| raise error, 'merge_full_form() expects FL.BOX as first obj' |
| for odata in odatalist[1:]: |
| create_object_instance(inst, form, odata) |
| |
| |
| ################################################################# |
| # Part 3 - Low-level object/form creation routines # |
| ################################################################# |
| |
| # |
| # External Create_form - Create form from parameters |
| # |
| def create_form(fdata): |
| import fl |
| return fl.make_form(FL.NO_BOX, fdata.Width, fdata.Height) |
| |
| # |
| # External create_object - Create an object. Make sure there are |
| # no callbacks. Returns the object created. |
| # |
| def create_object(form, odata): |
| obj = _create_object(form, odata) |
| if odata.Callback: |
| raise error, 'Creating free object with callback' |
| return obj |
| # |
| # External create_object_instance - Create object in an instance. |
| # |
| def create_object_instance(inst, form, odata): |
| obj = _create_object(form, odata) |
| if odata.Callback: |
| cbfunc = eval('inst.'+odata.Callback) |
| obj.set_call_back(cbfunc, odata.Argument) |
| if odata.Name: |
| exec 'inst.' + odata.Name + ' = obj\n' |
| # |
| # Internal _create_object: Create the object and fill options |
| # |
| def _create_object(form, odata): |
| crfunc = _select_crfunc(form, odata.Class) |
| obj = crfunc(odata.Type, odata.Box[0], odata.Box[1], odata.Box[2], \ |
| odata.Box[3], odata.Label) |
| if not odata.Class in (FL.BEGIN_GROUP, FL.END_GROUP): |
| obj.boxtype = odata.Boxtype |
| obj.col1 = odata.Colors[0] |
| obj.col2 = odata.Colors[1] |
| obj.align = odata.Alignment |
| obj.lstyle = odata.Style |
| obj.lsize = odata.Size |
| obj.lcol = odata.Lcol |
| return obj |
| # |
| # Internal crfunc: helper function that returns correct create function |
| # |
| def _select_crfunc(fm, cl): |
| if cl == FL.BEGIN_GROUP: return fm.bgn_group |
| elif cl == FL.END_GROUP: return fm.end_group |
| elif cl == FL.BITMAP: return fm.add_bitmap |
| elif cl == FL.BOX: return fm.add_box |
| elif cl == FL.BROWSER: return fm.add_browser |
| elif cl == FL.BUTTON: return fm.add_button |
| elif cl == FL.CHART: return fm.add_chart |
| elif cl == FL.CHOICE: return fm.add_choice |
| elif cl == FL.CLOCK: return fm.add_clock |
| elif cl == FL.COUNTER: return fm.add_counter |
| elif cl == FL.DIAL: return fm.add_dial |
| elif cl == FL.FREE: return fm.add_free |
| elif cl == FL.INPUT: return fm.add_input |
| elif cl == FL.LIGHTBUTTON: return fm.add_lightbutton |
| elif cl == FL.MENU: return fm.add_menu |
| elif cl == FL.POSITIONER: return fm.add_positioner |
| elif cl == FL.ROUNDBUTTON: return fm.add_roundbutton |
| elif cl == FL.SLIDER: return fm.add_slider |
| elif cl == FL.VALSLIDER: return fm.add_valslider |
| elif cl == FL.TEXT: return fm.add_text |
| elif cl == FL.TIMER: return fm.add_timer |
| else: |
| raise error, 'Unknown object type: ' + `cl` |
| |
| |
| def test(): |
| import time |
| t0 = time.time() |
| if len(sys.argv) == 2: |
| forms = parse_forms(sys.argv[1]) |
| t1 = time.time() |
| print 'parse time:', 0.001*(t1-t0), 'sec.' |
| keys = forms.keys() |
| keys.sort() |
| for i in keys: |
| _printform(forms[i]) |
| elif len(sys.argv) == 3: |
| form = parse_form(sys.argv[1], sys.argv[2]) |
| t1 = time.time() |
| print 'parse time:', round(t1-t0, 3), 'sec.' |
| _printform(form) |
| else: |
| print 'Usage: test fdfile [form]' |
| |
| def _printform(form): |
| f = form[0] |
| objs = form[1] |
| print 'Form ', f.Name, ', size: ', f.Width, f.Height, ' Nobj ', f.Numberofobjects |
| for i in objs: |
| print ' Obj ', i.Name, ' type ', i.Class, i.Type |
| print ' Box ', i.Box, ' btype ', i.Boxtype |
| print ' Label ', i.Label, ' size/style/col/align ', i.Size,i.Style, i.Lcol, i.Alignment |
| print ' cols ', i.Colors |
| print ' cback ', i.Callback, i.Argument |