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