Tryag File Manager
Home
-
Turbo Force
Current Path :
/
usr
/
lib
/
python2.4
/
lib-old
/
Upload File :
New :
File
Dir
//usr/lib/python2.4/lib-old/fmt.py
# Text formatting abstractions # Note -- this module is obsolete, it's too slow anyway import string import Para # A formatter back-end object has one method that is called by the formatter: # addpara(p), where p is a paragraph object. For example: # Formatter back-end to do nothing at all with the paragraphs class NullBackEnd: # def __init__(self): pass # def addpara(self, p): pass # def bgn_anchor(self, id): pass # def end_anchor(self, id): pass # Formatter back-end to collect the paragraphs in a list class SavingBackEnd(NullBackEnd): # def __init__(self): self.paralist = [] # def addpara(self, p): self.paralist.append(p) # def hitcheck(self, h, v): hits = [] for p in self.paralist: if p.top <= v <= p.bottom: for id in p.hitcheck(h, v): if id not in hits: hits.append(id) return hits # def extract(self): text = '' for p in self.paralist: text = text + (p.extract()) return text # def extractpart(self, long1, long2): if long1 > long2: long1, long2 = long2, long1 para1, pos1 = long1 para2, pos2 = long2 text = '' while para1 < para2: ptext = self.paralist[para1].extract() text = text + ptext[pos1:] pos1 = 0 para1 = para1 + 1 ptext = self.paralist[para2].extract() return text + ptext[pos1:pos2] # def whereis(self, d, h, v): total = 0 for i in range(len(self.paralist)): p = self.paralist[i] result = p.whereis(d, h, v) if result is not None: return i, result return None # def roundtowords(self, long1, long2): i, offset = long1 text = self.paralist[i].extract() while offset > 0 and text[offset-1] != ' ': offset = offset-1 long1 = i, offset # i, offset = long2 text = self.paralist[i].extract() n = len(text) while offset < n-1 and text[offset] != ' ': offset = offset+1 long2 = i, offset # return long1, long2 # def roundtoparagraphs(self, long1, long2): long1 = long1[0], 0 long2 = long2[0], len(self.paralist[long2[0]].extract()) return long1, long2 # Formatter back-end to send the text directly to the drawing object class WritingBackEnd(NullBackEnd): # def __init__(self, d, width): self.d = d self.width = width self.lineno = 0 # def addpara(self, p): self.lineno = p.render(self.d, 0, self.lineno, self.width) # A formatter receives a stream of formatting instructions and assembles # these into a stream of paragraphs on to a back-end. The assembly is # parametrized by a text measurement object, which must match the output # operations of the back-end. The back-end is responsible for splitting # paragraphs up in lines of a given maximum width. (This is done because # in a windowing environment, when the window size changes, there is no # need to redo the assembly into paragraphs, but the splitting into lines # must be done taking the new window size into account.) # Formatter base class. Initialize it with a text measurement object, # which is used for text measurements, and a back-end object, # which receives the completed paragraphs. The formatting methods are: # setfont(font) # setleftindent(nspaces) # setjust(type) where type is 'l', 'c', 'r', or 'lr' # flush() # vspace(nlines) # needvspace(nlines) # addword(word, nspaces) class BaseFormatter: # def __init__(self, d, b): # Drawing object used for text measurements self.d = d # # BackEnd object receiving completed paragraphs self.b = b # # Parameters of the formatting model self.leftindent = 0 self.just = 'l' self.font = None self.blanklines = 0 # # Parameters derived from the current font self.space = d.textwidth(' ') self.line = d.lineheight() self.ascent = d.baseline() self.descent = self.line - self.ascent # # Parameter derived from the default font self.n_space = self.space # # Current paragraph being built self.para = None self.nospace = 1 # # Font to set on the next word self.nextfont = None # def newpara(self): return Para.Para() # def setfont(self, font): if font is None: return self.font = self.nextfont = font d = self.d d.setfont(font) self.space = d.textwidth(' ') self.line = d.lineheight() self.ascent = d.baseline() self.descent = self.line - self.ascent # def setleftindent(self, nspaces): self.leftindent = int(self.n_space * nspaces) if self.para: hang = self.leftindent - self.para.indent_left if hang > 0 and self.para.getlength() <= hang: self.para.makehangingtag(hang) self.nospace = 1 else: self.flush() # def setrightindent(self, nspaces): self.rightindent = int(self.n_space * nspaces) if self.para: self.para.indent_right = self.rightindent self.flush() # def setjust(self, just): self.just = just if self.para: self.para.just = self.just # def flush(self): if self.para: self.b.addpara(self.para) self.para = None if self.font is not None: self.d.setfont(self.font) self.nospace = 1 # def vspace(self, nlines): self.flush() if nlines > 0: self.para = self.newpara() tuple = None, '', 0, 0, 0, int(nlines*self.line), 0 self.para.words.append(tuple) self.flush() self.blanklines = self.blanklines + nlines # def needvspace(self, nlines): self.flush() # Just to be sure if nlines > self.blanklines: self.vspace(nlines - self.blanklines) # def addword(self, text, space): if self.nospace and not text: return self.nospace = 0 self.blanklines = 0 if not self.para: self.para = self.newpara() self.para.indent_left = self.leftindent self.para.just = self.just self.nextfont = self.font space = int(space * self.space) self.para.words.append((self.nextfont, text, self.d.textwidth(text), space, space, self.ascent, self.descent)) self.nextfont = None # def bgn_anchor(self, id): if not self.para: self.nospace = 0 self.addword('', 0) self.para.bgn_anchor(id) # def end_anchor(self, id): if not self.para: self.nospace = 0 self.addword('', 0) self.para.end_anchor(id) # Measuring object for measuring text as viewed on a tty class NullMeasurer: # def __init__(self): pass # def setfont(self, font): pass # def textwidth(self, text): return len(text) # def lineheight(self): return 1 # def baseline(self): return 0 # Drawing object for writing plain ASCII text to a file class FileWriter: # def __init__(self, fp): self.fp = fp self.lineno, self.colno = 0, 0 # def setfont(self, font): pass # def text(self, (h, v), str): if not str: return if '\n' in str: raise ValueError, 'can\'t write \\n' while self.lineno < v: self.fp.write('\n') self.colno, self.lineno = 0, self.lineno + 1 while self.lineno > v: # XXX This should never happen... self.fp.write('\033[A') # ANSI up arrow self.lineno = self.lineno - 1 if self.colno < h: self.fp.write(' ' * (h - self.colno)) elif self.colno > h: self.fp.write('\b' * (self.colno - h)) self.colno = h self.fp.write(str) self.colno = h + len(str) # Formatting class to do nothing at all with the data class NullFormatter(BaseFormatter): # def __init__(self): d = NullMeasurer() b = NullBackEnd() BaseFormatter.__init__(self, d, b) # Formatting class to write directly to a file class WritingFormatter(BaseFormatter): # def __init__(self, fp, width): dm = NullMeasurer() dw = FileWriter(fp) b = WritingBackEnd(dw, width) BaseFormatter.__init__(self, dm, b) self.blanklines = 1 # # Suppress multiple blank lines def needvspace(self, nlines): BaseFormatter.needvspace(self, min(1, nlines)) # A "FunnyFormatter" writes ASCII text with a twist: *bold words*, # _italic text_ and _underlined words_, and `quoted text'. # It assumes that the fonts are 'r', 'i', 'b', 'u', 'q': (roman, # italic, bold, underline, quote). # Moreover, if the font is in upper case, the text is converted to # UPPER CASE. class FunnyFormatter(WritingFormatter): # def flush(self): if self.para: finalize(self.para) WritingFormatter.flush(self) # Surrounds *bold words* and _italic text_ in a paragraph with # appropriate markers, fixing the size (assuming these characters' # width is 1). openchar = \ {'b':'*', 'i':'_', 'u':'_', 'q':'`', 'B':'*', 'I':'_', 'U':'_', 'Q':'`'} closechar = \ {'b':'*', 'i':'_', 'u':'_', 'q':'\'', 'B':'*', 'I':'_', 'U':'_', 'Q':'\''} def finalize(para): oldfont = curfont = 'r' para.words.append(('r', '', 0, 0, 0, 0)) # temporary, deleted at end for i in range(len(para.words)): fo, te, wi = para.words[i][:3] if fo is not None: curfont = fo if curfont != oldfont: if closechar.has_key(oldfont): c = closechar[oldfont] j = i-1 while j > 0 and para.words[j][1] == '': j = j-1 fo1, te1, wi1 = para.words[j][:3] te1 = te1 + c wi1 = wi1 + len(c) para.words[j] = (fo1, te1, wi1) + \ para.words[j][3:] if openchar.has_key(curfont) and te: c = openchar[curfont] te = c + te wi = len(c) + wi para.words[i] = (fo, te, wi) + \ para.words[i][3:] if te: oldfont = curfont else: oldfont = 'r' if curfont in string.uppercase: te = string.upper(te) para.words[i] = (fo, te, wi) + para.words[i][3:] del para.words[-1] # Formatter back-end to draw the text in a window. # This has an option to draw while the paragraphs are being added, # to minimize the delay before the user sees anything. # This manages the entire "document" of the window. class StdwinBackEnd(SavingBackEnd): # def __init__(self, window, drawnow): self.window = window self.drawnow = drawnow self.width = window.getwinsize()[0] self.selection = None self.height = 0 window.setorigin(0, 0) window.setdocsize(0, 0) self.d = window.begindrawing() SavingBackEnd.__init__(self) # def finish(self): self.d.close() self.d = None self.window.setdocsize(0, self.height) # def addpara(self, p): self.paralist.append(p) if self.drawnow: self.height = \ p.render(self.d, 0, self.height, self.width) else: p.layout(self.width) p.left = 0 p.top = self.height p.right = self.width p.bottom = self.height + p.height self.height = p.bottom # def resize(self): self.window.change((0, 0), (self.width, self.height)) self.width = self.window.getwinsize()[0] self.height = 0 for p in self.paralist: p.layout(self.width) p.left = 0 p.top = self.height p.right = self.width p.bottom = self.height + p.height self.height = p.bottom self.window.change((0, 0), (self.width, self.height)) self.window.setdocsize(0, self.height) # def redraw(self, area): d = self.window.begindrawing() (left, top), (right, bottom) = area d.erase(area) d.cliprect(area) for p in self.paralist: if top < p.bottom and p.top < bottom: v = p.render(d, p.left, p.top, p.right) if self.selection: self.invert(d, self.selection) d.close() # def setselection(self, new): if new: long1, long2 = new pos1 = long1[:3] pos2 = long2[:3] new = pos1, pos2 if new != self.selection: d = self.window.begindrawing() if self.selection: self.invert(d, self.selection) if new: self.invert(d, new) d.close() self.selection = new # def getselection(self): return self.selection # def extractselection(self): if self.selection: a, b = self.selection return self.extractpart(a, b) else: return None # def invert(self, d, region): long1, long2 = region if long1 > long2: long1, long2 = long2, long1 para1, pos1 = long1 para2, pos2 = long2 while para1 < para2: self.paralist[para1].invert(d, pos1, None) pos1 = None para1 = para1 + 1 self.paralist[para2].invert(d, pos1, pos2) # def search(self, prog): import re, string if type(prog) is type(''): prog = re.compile(string.lower(prog)) if self.selection: iold = self.selection[0][0] else: iold = -1 hit = None for i in range(len(self.paralist)): if i == iold or i < iold and hit: continue p = self.paralist[i] text = string.lower(p.extract()) match = prog.search(text) if match: a, b = match.group(0) long1 = i, a long2 = i, b hit = long1, long2 if i > iold: break if hit: self.setselection(hit) i = hit[0][0] p = self.paralist[i] self.window.show((p.left, p.top), (p.right, p.bottom)) return 1 else: return 0 # def showanchor(self, id): for i in range(len(self.paralist)): p = self.paralist[i] if p.hasanchor(id): long1 = i, 0 long2 = i, len(p.extract()) hit = long1, long2 self.setselection(hit) self.window.show( (p.left, p.top), (p.right, p.bottom)) break # GL extensions class GLFontCache: # def __init__(self): self.reset() self.setfont('') # def reset(self): self.fontkey = None self.fonthandle = None self.fontinfo = None self.fontcache = {} # def close(self): self.reset() # def setfont(self, fontkey): if fontkey == '': fontkey = 'Times-Roman 12' elif ' ' not in fontkey: fontkey = fontkey + ' 12' if fontkey == self.fontkey: return if self.fontcache.has_key(fontkey): handle = self.fontcache[fontkey] else: import string i = string.index(fontkey, ' ') name, sizestr = fontkey[:i], fontkey[i:] size = eval(sizestr) key1 = name + ' 1' key = name + ' ' + `size` # NB key may differ from fontkey! if self.fontcache.has_key(key): handle = self.fontcache[key] else: if self.fontcache.has_key(key1): handle = self.fontcache[key1] else: import fm handle = fm.findfont(name) self.fontcache[key1] = handle handle = handle.scalefont(size) self.fontcache[fontkey] = \ self.fontcache[key] = handle self.fontkey = fontkey if self.fonthandle != handle: self.fonthandle = handle self.fontinfo = handle.getfontinfo() handle.setfont() class GLMeasurer(GLFontCache): # def textwidth(self, text): return self.fonthandle.getstrwidth(text) # def baseline(self): return self.fontinfo[6] - self.fontinfo[3] # def lineheight(self): return self.fontinfo[6] class GLWriter(GLFontCache): # # NOTES: # (1) Use gl.ortho2 to use X pixel coordinates! # def text(self, (h, v), text): import gl, fm gl.cmov2i(h, v + self.fontinfo[6] - self.fontinfo[3]) fm.prstr(text) # def setfont(self, fontkey): oldhandle = self.fonthandle GLFontCache.setfont(fontkey) if self.fonthandle != oldhandle: handle.setfont() class GLMeasurerWriter(GLMeasurer, GLWriter): pass class GLBackEnd(SavingBackEnd): # def __init__(self, wid): import gl gl.winset(wid) self.wid = wid self.width = gl.getsize()[1] self.height = 0 self.d = GLMeasurerWriter() SavingBackEnd.__init__(self) # def finish(self): pass # def addpara(self, p): self.paralist.append(p) self.height = p.render(self.d, 0, self.height, self.width) # def redraw(self): import gl gl.winset(self.wid) width = gl.getsize()[1] if width != self.width: setdocsize = 1 self.width = width for p in self.paralist: p.top = p.bottom = None d = self.d v = 0 for p in self.paralist: v = p.render(d, 0, v, width)