Lib/lib-old/fmt.py

   1 # Text formatting abstractions
   2 # Note -- this module is obsolete, it's too slow anyway
   3
   4
   5 import string
   6 import Para
   7
   8
   9 # A formatter back-end object has one method that is called by the formatter:
  10 # addpara(p), where p is a paragraph object.  For example:
  11
  12
  13 # Formatter back-end to do nothing at all with the paragraphs
  14 class NullBackEnd:
  15     #
  16     def __init__(self):
  17         pass
  18     #
  19     def addpara(self, p):
  20         pass
  21     #
  22     def bgn_anchor(self, id):
  23         pass
  24     #
  25     def end_anchor(self, id):
  26         pass
  27
  28
  29 # Formatter back-end to collect the paragraphs in a list
  30 class SavingBackEnd(NullBackEnd):
  31     #
  32     def __init__(self):
  33         self.paralist = []
  34     #
  35     def addpara(self, p):
  36         self.paralist.append(p)
  37     #
  38     def hitcheck(self, h, v):
  39         hits = []
  40         for p in self.paralist:
  41             if p.top <= v <= p.bottom:
  42                 for id in p.hitcheck(h, v):
  43                     if id not in hits:
  44                         hits.append(id)
  45         return hits
  46     #
  47     def extract(self):
  48         text = ''
  49         for p in self.paralist:
  50             text = text + (p.extract())
  51         return text
  52     #
  53     def extractpart(self, long1, long2):
  54         if long1 > long2: long1, long2 = long2, long1
  55         para1, pos1 = long1
  56         para2, pos2 = long2
  57         text = ''
  58         while para1 < para2:
  59             ptext = self.paralist[para1].extract()
  60             text = text + ptext[pos1:]
  61             pos1 = 0
  62             para1 = para1 + 1
  63         ptext = self.paralist[para2].extract()
  64         return text + ptext[pos1:pos2]
  65     #
  66     def whereis(self, d, h, v):
  67         total = 0
  68         for i in range(len(self.paralist)):
  69             p = self.paralist[i]
  70             result = p.whereis(d, h, v)
  71             if result is not None:
  72                 return i, result
  73         return None
  74     #
  75     def roundtowords(self, long1, long2):
  76         i, offset = long1
  77         text = self.paralist[i].extract()
  78         while offset > 0 and text[offset-1] != ' ': offset = offset-1
  79         long1 = i, offset
  80         #
  81         i, offset = long2
  82         text = self.paralist[i].extract()
  83         n = len(text)
  84         while offset < n-1 and text[offset] != ' ': offset = offset+1
  85         long2 = i, offset
  86         #
  87         return long1, long2
  88     #
  89     def roundtoparagraphs(self, long1, long2):
  90         long1 = long1[0], 0
  91         long2 = long2[0], len(self.paralist[long2[0]].extract())
  92         return long1, long2
  93
  94
  95 # Formatter back-end to send the text directly to the drawing object
  96 class WritingBackEnd(NullBackEnd):
  97     #
  98     def __init__(self, d, width):
  99         self.d = d
 100         self.width = width
 101         self.lineno = 0
 102     #
 103     def addpara(self, p):
 104         self.lineno = p.render(self.d, 0, self.lineno, self.width)
 105
 106
 107 # A formatter receives a stream of formatting instructions and assembles
 108 # these into a stream of paragraphs on to a back-end.  The assembly is
 109 # parametrized by a text measurement object, which must match the output
 110 # operations of the back-end.  The back-end is responsible for splitting
 111 # paragraphs up in lines of a given maximum width.  (This is done because
 112 # in a windowing environment, when the window size changes, there is no
 113 # need to redo the assembly into paragraphs, but the splitting into lines
 114 # must be done taking the new window size into account.)
 115
 116
 117 # Formatter base class.  Initialize it with a text measurement object,
 118 # which is used for text measurements, and a back-end object,
 119 # which receives the completed paragraphs.  The formatting methods are:
 120 # setfont(font)
 121 # setleftindent(nspaces)
 122 # setjust(type) where type is 'l', 'c', 'r', or 'lr'
 123 # flush()
 124 # vspace(nlines)
 125 # needvspace(nlines)
 126 # addword(word, nspaces)
 127 class BaseFormatter:
 128     #
 129     def __init__(self, d, b):
 130         # Drawing object used for text measurements
 131         self.d = d
 132         #
 133         # BackEnd object receiving completed paragraphs
 134         self.b = b
 135         #
 136         # Parameters of the formatting model
 137         self.leftindent = 0
 138         self.just = 'l'
 139         self.font = None
 140         self.blanklines = 0
 141         #
 142         # Parameters derived from the current font
 143         self.space = d.textwidth(' ')
 144         self.line = d.lineheight()
 145         self.ascent = d.baseline()
 146         self.descent = self.line - self.ascent
 147         #
 148         # Parameter derived from the default font
 149         self.n_space = self.space
 150         #
 151         # Current paragraph being built
 152         self.para = None
 153         self.nospace = 1
 154         #
 155         # Font to set on the next word
 156         self.nextfont = None
 157     #
 158     def newpara(self):
 159         return Para.Para()
 160     #
 161     def setfont(self, font):
 162         if font is None: return
 163         self.font = self.nextfont = font
 164         d = self.d
 165         d.setfont(font)
 166         self.space = d.textwidth(' ')
 167         self.line = d.lineheight()
 168         self.ascent = d.baseline()
 169         self.descent = self.line - self.ascent
 170     #
 171     def setleftindent(self, nspaces):
 172         self.leftindent = int(self.n_space * nspaces)
 173         if self.para:
 174             hang = self.leftindent - self.para.indent_left
 175             if hang > 0 and self.para.getlength() <= hang:
 176                 self.para.makehangingtag(hang)
 177                 self.nospace = 1
 178             else:
 179                 self.flush()
 180     #
 181     def setrightindent(self, nspaces):
 182         self.rightindent = int(self.n_space * nspaces)
 183         if self.para:
 184             self.para.indent_right = self.rightindent
 185             self.flush()
 186     #
 187     def setjust(self, just):
 188         self.just = just
 189         if self.para:
 190             self.para.just = self.just
 191     #
 192     def flush(self):
 193         if self.para:
 194             self.b.addpara(self.para)
 195             self.para = None
 196             if self.font is not None:
 197                 self.d.setfont(self.font)
 198         self.nospace = 1
 199     #
 200     def vspace(self, nlines):
 201         self.flush()
 202         if nlines > 0:
 203             self.para = self.newpara()
 204             tuple = None, '', 0, 0, 0, int(nlines*self.line), 0
 205             self.para.words.append(tuple)
 206             self.flush()
 207             self.blanklines = self.blanklines + nlines
 208     #
 209     def needvspace(self, nlines):
 210         self.flush() # Just to be sure
 211         if nlines > self.blanklines:
 212             self.vspace(nlines - self.blanklines)
 213     #
 214     def addword(self, text, space):
 215         if self.nospace and not text:
 216             return
 217         self.nospace = 0
 218         self.blanklines = 0
 219         if not self.para:
 220             self.para = self.newpara()
 221             self.para.indent_left = self.leftindent
 222             self.para.just = self.just
 223             self.nextfont = self.font
 224         space = int(space * self.space)
 225         self.para.words.append((self.nextfont, text,
 226                 self.d.textwidth(text), space, space,
 227                 self.ascent, self.descent))
 228         self.nextfont = None
 229     #
 230     def bgn_anchor(self, id):
 231         if not self.para:
 232             self.nospace = 0
 233             self.addword('', 0)
 234         self.para.bgn_anchor(id)
 235     #
 236     def end_anchor(self, id):
 237         if not self.para:
 238             self.nospace = 0
 239             self.addword('', 0)
 240         self.para.end_anchor(id)
 241
 242
 243 # Measuring object for measuring text as viewed on a tty
 244 class NullMeasurer:
 245     #
 246     def __init__(self):
 247         pass
 248     #
 249     def setfont(self, font):
 250         pass
 251     #
 252     def textwidth(self, text):
 253         return len(text)
 254     #
 255     def lineheight(self):
 256         return 1
 257     #
 258     def baseline(self):
 259         return 0
 260
 261
 262 # Drawing object for writing plain ASCII text to a file
 263 class FileWriter:
 264     #
 265     def __init__(self, fp):
 266         self.fp = fp
 267         self.lineno, self.colno = 0, 0
 268     #
 269     def setfont(self, font):
 270         pass
 271     #
 272     def text(self, (h, v), str):
 273         if not str: return
 274         if '\n' in str:
 275             raise ValueError, 'can\'t write \\n'
 276         while self.lineno < v:
 277             self.fp.write('\n')
 278             self.colno, self.lineno = 0, self.lineno + 1
 279         while self.lineno > v:
 280             # XXX This should never happen...
 281             self.fp.write('\033[A') # ANSI up arrow
 282             self.lineno = self.lineno - 1
 283         if self.colno < h:
 284             self.fp.write(' ' * (h - self.colno))
 285         elif self.colno > h:
 286             self.fp.write('\b' * (self.colno - h))
 287         self.colno = h
 288         self.fp.write(str)
 289         self.colno = h + len(str)
 290
 291
 292 # Formatting class to do nothing at all with the data
 293 class NullFormatter(BaseFormatter):
 294     #
 295     def __init__(self):
 296         d = NullMeasurer()
 297         b = NullBackEnd()
 298         BaseFormatter.__init__(self, d, b)
 299
 300
 301 # Formatting class to write directly to a file
 302 class WritingFormatter(BaseFormatter):
 303     #
 304     def __init__(self, fp, width):
 305         dm = NullMeasurer()
 306         dw = FileWriter(fp)
 307         b = WritingBackEnd(dw, width)
 308         BaseFormatter.__init__(self, dm, b)
 309         self.blanklines = 1
 310     #
 311     # Suppress multiple blank lines
 312     def needvspace(self, nlines):
 313         BaseFormatter.needvspace(self, min(1, nlines))
 314
 315
 316 # A "FunnyFormatter" writes ASCII text with a twist: *bold words*,
 317 # _italic text_ and _underlined words_, and `quoted text'.
 318 # It assumes that the fonts are 'r', 'i', 'b', 'u', 'q': (roman,
 319 # italic, bold, underline, quote).
 320 # Moreover, if the font is in upper case, the text is converted to
 321 # UPPER CASE.
 322 class FunnyFormatter(WritingFormatter):
 323     #
 324     def flush(self):
 325         if self.para: finalize(self.para)
 326         WritingFormatter.flush(self)
 327
 328
 329 # Surrounds *bold words* and _italic text_ in a paragraph with
 330 # appropriate markers, fixing the size (assuming these characters'
 331 # width is 1).
 332 openchar = \
 333     {'b':'*', 'i':'_', 'u':'_', 'q':'`', 'B':'*', 'I':'_', 'U':'_', 'Q':'`'}
 334 closechar = \
 335     {'b':'*', 'i':'_', 'u':'_', 'q':'\'', 'B':'*', 'I':'_', 'U':'_', 'Q':'\''}
 336 def finalize(para):
 337     oldfont = curfont = 'r'
 338     para.words.append(('r', '', 0, 0, 0, 0)) # temporary, deleted at end
 339     for i in range(len(para.words)):
 340         fo, te, wi = para.words[i][:3]
 341         if fo is not None: curfont = fo
 342         if curfont != oldfont:
 343             if closechar.has_key(oldfont):
 344                 c = closechar[oldfont]
 345                 j = i-1
 346                 while j > 0 and para.words[j][1] == '': j = j-1
 347                 fo1, te1, wi1 = para.words[j][:3]
 348                 te1 = te1 + c
 349                 wi1 = wi1 + len(c)
 350                 para.words[j] = (fo1, te1, wi1) + \
 351                         para.words[j][3:]
 352             if openchar.has_key(curfont) and te:
 353                 c = openchar[curfont]
 354                 te = c + te
 355                 wi = len(c) + wi
 356                 para.words[i] = (fo, te, wi) + \
 357                         para.words[i][3:]
 358             if te: oldfont = curfont
 359             else: oldfont = 'r'
 360         if curfont in string.uppercase:
 361             te = string.upper(te)
 362             para.words[i] = (fo, te, wi) + para.words[i][3:]
 363     del para.words[-1]
 364
 365
 366 # Formatter back-end to draw the text in a window.
 367 # This has an option to draw while the paragraphs are being added,
 368 # to minimize the delay before the user sees anything.
 369 # This manages the entire "document" of the window.
 370 class StdwinBackEnd(SavingBackEnd):
 371     #
 372     def __init__(self, window, drawnow):
 373         self.window = window
 374         self.drawnow = drawnow
 375         self.width = window.getwinsize()[0]
 376         self.selection = None
 377         self.height = 0
 378         window.setorigin(0, 0)
 379         window.setdocsize(0, 0)
 380         self.d = window.begindrawing()
 381         SavingBackEnd.__init__(self)
 382     #
 383     def finish(self):
 384         self.d.close()
 385         self.d = None
 386         self.window.setdocsize(0, self.height)
 387     #
 388     def addpara(self, p):
 389         self.paralist.append(p)
 390         if self.drawnow:
 391             self.height = \
 392                     p.render(self.d, 0, self.height, self.width)
 393         else:
 394             p.layout(self.width)
 395             p.left = 0
 396             p.top = self.height
 397             p.right = self.width
 398             p.bottom = self.height + p.height
 399             self.height = p.bottom
 400     #
 401     def resize(self):
 402         self.window.change((0, 0), (self.width, self.height))
 403         self.width = self.window.getwinsize()[0]
 404         self.height = 0
 405         for p in self.paralist:
 406             p.layout(self.width)
 407             p.left = 0
 408             p.top = self.height
 409             p.right = self.width
 410             p.bottom = self.height + p.height
 411             self.height = p.bottom
 412         self.window.change((0, 0), (self.width, self.height))
 413         self.window.setdocsize(0, self.height)
 414     #
 415     def redraw(self, area):
 416         d = self.window.begindrawing()
 417         (left, top), (right, bottom) = area
 418         d.erase(area)
 419         d.cliprect(area)
 420         for p in self.paralist:
 421             if top < p.bottom and p.top < bottom:
 422                 v = p.render(d, p.left, p.top, p.right)
 423         if self.selection:
 424             self.invert(d, self.selection)
 425         d.close()
 426     #
 427     def setselection(self, new):
 428         if new:
 429             long1, long2 = new
 430             pos1 = long1[:3]
 431             pos2 = long2[:3]
 432             new = pos1, pos2
 433         if new != self.selection:
 434             d = self.window.begindrawing()
 435             if self.selection:
 436                 self.invert(d, self.selection)
 437             if new:
 438                 self.invert(d, new)
 439             d.close()
 440             self.selection = new
 441     #
 442     def getselection(self):
 443         return self.selection
 444     #
 445     def extractselection(self):
 446         if self.selection:
 447             a, b = self.selection
 448             return self.extractpart(a, b)
 449         else:
 450             return None
 451     #
 452     def invert(self, d, region):
 453         long1, long2 = region
 454         if long1 > long2: long1, long2 = long2, long1
 455         para1, pos1 = long1
 456         para2, pos2 = long2
 457         while para1 < para2:
 458             self.paralist[para1].invert(d, pos1, None)
 459             pos1 = None
 460             para1 = para1 + 1
 461         self.paralist[para2].invert(d, pos1, pos2)
 462     #
 463     def search(self, prog):
 464         import re, string
 465         if type(prog) is type(''):
 466             prog = re.compile(string.lower(prog))
 467         if self.selection:
 468             iold = self.selection[0][0]
 469         else:
 470             iold = -1
 471         hit = None
 472         for i in range(len(self.paralist)):
 473             if i == iold or i < iold and hit:
 474                 continue
 475             p = self.paralist[i]
 476             text = string.lower(p.extract())
 477             match = prog.search(text)
 478             if match:
 479                 a, b = match.group(0)
 480                 long1 = i, a
 481                 long2 = i, b
 482                 hit = long1, long2
 483                 if i > iold:
 484                     break
 485         if hit:
 486             self.setselection(hit)
 487             i = hit[0][0]
 488             p = self.paralist[i]
 489             self.window.show((p.left, p.top), (p.right, p.bottom))
 490             return 1
 491         else:
 492             return 0
 493     #
 494     def showanchor(self, id):
 495         for i in range(len(self.paralist)):
 496             p = self.paralist[i]
 497             if p.hasanchor(id):
 498                 long1 = i, 0
 499                 long2 = i, len(p.extract())
 500                 hit = long1, long2
 501                 self.setselection(hit)
 502                 self.window.show(
 503                         (p.left, p.top), (p.right, p.bottom))
 504                 break
 505
 506
 507 # GL extensions
 508
 509 class GLFontCache:
 510     #
 511     def __init__(self):
 512         self.reset()
 513         self.setfont('')
 514     #
 515     def reset(self):
 516         self.fontkey = None
 517         self.fonthandle = None
 518         self.fontinfo = None
 519         self.fontcache = {}
 520     #
 521     def close(self):
 522         self.reset()
 523     #
 524     def setfont(self, fontkey):
 525         if fontkey == '':
 526             fontkey = 'Times-Roman 12'
 527         elif ' ' not in fontkey:
 528             fontkey = fontkey + ' 12'
 529         if fontkey == self.fontkey:
 530             return
 531         if self.fontcache.has_key(fontkey):
 532             handle = self.fontcache[fontkey]
 533         else:
 534             import string
 535             i = string.index(fontkey, ' ')
 536             name, sizestr = fontkey[:i], fontkey[i:]
 537             size = eval(sizestr)
 538             key1 = name + ' 1'
 539             key = name + ' ' + `size`
 540             # NB key may differ from fontkey!
 541             if self.fontcache.has_key(key):
 542                 handle = self.fontcache[key]
 543             else:
 544                 if self.fontcache.has_key(key1):
 545                     handle = self.fontcache[key1]
 546                 else:
 547                     import fm
 548                     handle = fm.findfont(name)
 549                     self.fontcache[key1] = handle
 550                 handle = handle.scalefont(size)
 551                 self.fontcache[fontkey] = \
 552                         self.fontcache[key] = handle
 553         self.fontkey = fontkey
 554         if self.fonthandle != handle:
 555             self.fonthandle = handle
 556             self.fontinfo = handle.getfontinfo()
 557             handle.setfont()
 558
 559
 560 class GLMeasurer(GLFontCache):
 561     #
 562     def textwidth(self, text):
 563         return self.fonthandle.getstrwidth(text)
 564     #
 565     def baseline(self):
 566         return self.fontinfo[6] - self.fontinfo[3]
 567     #
 568     def lineheight(self):
 569         return self.fontinfo[6]
 570
 571
 572 class GLWriter(GLFontCache):
 573     #
 574     # NOTES:
 575     # (1) Use gl.ortho2 to use X pixel coordinates!
 576     #
 577     def text(self, (h, v), text):
 578         import gl, fm
 579         gl.cmov2i(h, v + self.fontinfo[6] - self.fontinfo[3])
 580         fm.prstr(text)
 581     #
 582     def setfont(self, fontkey):
 583         oldhandle = self.fonthandle
 584         GLFontCache.setfont(fontkey)
 585         if self.fonthandle != oldhandle:
 586             handle.setfont()
 587
 588
 589 class GLMeasurerWriter(GLMeasurer, GLWriter):
 590     pass
 591
 592
 593 class GLBackEnd(SavingBackEnd):
 594     #
 595     def __init__(self, wid):
 596         import gl
 597         gl.winset(wid)
 598         self.wid = wid
 599         self.width = gl.getsize()[1]
 600         self.height = 0
 601         self.d = GLMeasurerWriter()
 602         SavingBackEnd.__init__(self)
 603     #
 604     def finish(self):
 605         pass
 606     #
 607     def addpara(self, p):
 608         self.paralist.append(p)
 609         self.height = p.render(self.d, 0, self.height, self.width)
 610     #
 611     def redraw(self):
 612         import gl
 613         gl.winset(self.wid)
 614         width = gl.getsize()[1]
 615         if width != self.width:
 616             setdocsize = 1
 617             self.width = width
 618             for p in self.paralist:
 619                 p.top = p.bottom = None
 620         d = self.d
 621         v = 0
 622         for p in self.paralist:
 623             v = p.render(d, 0, v, width)