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 and 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 455
