Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / 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)