PageRenderTime 611ms CodeModel.GetById 203ms app.highlight 204ms RepoModel.GetById 187ms app.codeStats 0ms

/Lib/plat-irix6/flp.py

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