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 os

    11 import sys

    12 import FL

    13 

    14 SPLITLINE = '--------------------'

    15 FORMLINE = '=============== FORM ==============='

    16 ENDLINE = '=============================='

    17 

    18 class error(Exception):

    19     pass

    20 

    21 ##################################################################

    22 #    Part 1 - The parsing routines                               #

    23 ##################################################################

    24 

    25 #

    26 # Externally visible function. Load form.

    27 #

    28 def 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 #

    40 def 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 #

    55 MAGIC = '.fdc'

    56 _internal_cache = {}                    # Used by frozen scripts only

    57 def 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 

    85 def _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 

    99 def 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 

   105 def 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 

   109 def 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 #

   120 def 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 #

   148 def 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 #

   157 def _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 #

   170 def _open_formfile(filename):

   171     return _open_formfile2(filename)[0]

   172 

   173 def _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 #

   197 def _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 #

   212 def _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 #

   231 class _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 #

   241 def _parse_string(str):

   242     if '\\' in str:

   243         s = '\'' + str + '\''

   244         try:

   245             return eval(s)

   246         except:

   247             pass

   248     return str

   249 

   250 def _parse_num(str):

   251     return eval(str)

   252 

   253 def _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 

   274 import re

   275 prog = re.compile('^([^:]*): *(.*)')

   276 

   277 def _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 

   293 def _readline(file):

   294     line = file.readline()

   295     if not line:

   296         raise EOFError

   297     return line[:-1]

   298 

   299 def _parse_1_line(file):

   300     line = _readline(file)

   301     while line == '':

   302         line = _readline(file)

   303     return _parse_line(line)

   304 

   305 def _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 

   313 def _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 #

   333 def 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 #

   343 def 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 #

   358 def 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 #

   366 def 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 #

   374 def 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 #

   384 def _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 #

   400 def _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 

   426 def 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 

   445 def _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