624 lines
19 KiB
Python
624 lines
19 KiB
Python
# 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)
|