mirror of https://github.com/python/cpython
Removing junk
This commit is contained in:
parent
81b4e41cd9
commit
6a1b1338de
|
@ -1,408 +0,0 @@
|
||||||
# Text formatting abstractions
|
|
||||||
|
|
||||||
|
|
||||||
# Oft-used type object
|
|
||||||
Int = type(0)
|
|
||||||
|
|
||||||
|
|
||||||
# Represent a paragraph. This is a list of words with associated
|
|
||||||
# font and size information, plus indents and justification for the
|
|
||||||
# entire paragraph.
|
|
||||||
# Once the words have been added to a paragraph, it can be laid out
|
|
||||||
# for different line widths. Once laid out, it can be rendered at
|
|
||||||
# different screen locations. Once rendered, it can be queried
|
|
||||||
# for mouse hits, and parts of the text can be highlighted
|
|
||||||
class Para:
|
|
||||||
#
|
|
||||||
def __init__(self):
|
|
||||||
self.words = [] # The words
|
|
||||||
self.just = 'l' # Justification: 'l', 'r', 'lr' or 'c'
|
|
||||||
self.indent_left = self.indent_right = self.indent_hang = 0
|
|
||||||
# Final lay-out parameters, may change
|
|
||||||
self.left = self.top = self.right = self.bottom = \
|
|
||||||
self.width = self.height = self.lines = None
|
|
||||||
#
|
|
||||||
# Add a word, computing size information for it.
|
|
||||||
# Words may also be added manually by appending to self.words
|
|
||||||
# Each word should be a 7-tuple:
|
|
||||||
# (font, text, width, space, stretch, ascent, descent)
|
|
||||||
def addword(self, d, font, text, space, stretch):
|
|
||||||
if font <> None:
|
|
||||||
d.setfont(font)
|
|
||||||
width = d.textwidth(text)
|
|
||||||
ascent = d.baseline()
|
|
||||||
descent = d.lineheight() - ascent
|
|
||||||
spw = d.textwidth(' ')
|
|
||||||
space = space * spw
|
|
||||||
stretch = stretch * spw
|
|
||||||
tuple = (font, text, width, space, stretch, ascent, descent)
|
|
||||||
self.words.append(tuple)
|
|
||||||
#
|
|
||||||
# Hooks to begin and end anchors -- insert numbers in the word list!
|
|
||||||
def bgn_anchor(self, id):
|
|
||||||
self.words.append(id)
|
|
||||||
#
|
|
||||||
def end_anchor(self, id):
|
|
||||||
self.words.append(0)
|
|
||||||
#
|
|
||||||
# Return the total length (width) of the text added so far, in pixels
|
|
||||||
def getlength(self):
|
|
||||||
total = 0
|
|
||||||
for word in self.words:
|
|
||||||
if type(word) <> Int:
|
|
||||||
total = total + word[2] + word[3]
|
|
||||||
return total
|
|
||||||
#
|
|
||||||
# Tab to a given position (relative to the current left indent):
|
|
||||||
# remove all stretch, add fixed space up to the new indent.
|
|
||||||
# If the current position is already beying the tab stop,
|
|
||||||
# don't add any new space (but still remove the stretch)
|
|
||||||
def tabto(self, tab):
|
|
||||||
total = 0
|
|
||||||
as, de = 1, 0
|
|
||||||
for i in range(len(self.words)):
|
|
||||||
word = self.words[i]
|
|
||||||
if type(word) == Int: continue
|
|
||||||
fo, te, wi, sp, st, as, de = word
|
|
||||||
self.words[i] = fo, te, wi, sp, 0, as, de
|
|
||||||
total = total + wi + sp
|
|
||||||
if total < tab:
|
|
||||||
self.words.append((None, '', 0, tab-total, 0, as, de))
|
|
||||||
#
|
|
||||||
# Make a hanging tag: tab to hang, increment indent_left by hang,
|
|
||||||
# and reset indent_hang to -hang
|
|
||||||
def makehangingtag(self, hang):
|
|
||||||
self.tabto(hang)
|
|
||||||
self.indent_left = self.indent_left + hang
|
|
||||||
self.indent_hang = -hang
|
|
||||||
#
|
|
||||||
# Decide where the line breaks will be given some screen width
|
|
||||||
def layout(self, linewidth):
|
|
||||||
self.width = linewidth
|
|
||||||
height = 0
|
|
||||||
self.lines = lines = []
|
|
||||||
avail1 = self.width - self.indent_left - self.indent_right
|
|
||||||
avail = avail1 - self.indent_hang
|
|
||||||
words = self.words
|
|
||||||
i = 0
|
|
||||||
n = len(words)
|
|
||||||
lastfont = None
|
|
||||||
while i < n:
|
|
||||||
firstfont = lastfont
|
|
||||||
charcount = 0
|
|
||||||
width = 0
|
|
||||||
stretch = 0
|
|
||||||
ascent = 0
|
|
||||||
descent = 0
|
|
||||||
lsp = 0
|
|
||||||
j = i
|
|
||||||
while i < n:
|
|
||||||
word = words[i]
|
|
||||||
if type(word) == Int:
|
|
||||||
if word > 0 and width >= avail:
|
|
||||||
break
|
|
||||||
i = i+1
|
|
||||||
continue
|
|
||||||
fo, te, wi, sp, st, as, de = word
|
|
||||||
if width + wi > avail and width > 0 and wi > 0:
|
|
||||||
break
|
|
||||||
if fo <> None:
|
|
||||||
lastfont = fo
|
|
||||||
if width == 0:
|
|
||||||
firstfont = fo
|
|
||||||
charcount = charcount + len(te) + (sp > 0)
|
|
||||||
width = width + wi + sp
|
|
||||||
lsp = sp
|
|
||||||
stretch = stretch + st
|
|
||||||
lst = st
|
|
||||||
ascent = max(ascent, as)
|
|
||||||
descent = max(descent, de)
|
|
||||||
i = i+1
|
|
||||||
while i > j and type(words[i-1]) == Int and \
|
|
||||||
words[i-1] > 0: i = i-1
|
|
||||||
width = width - lsp
|
|
||||||
if i < n:
|
|
||||||
stretch = stretch - lst
|
|
||||||
else:
|
|
||||||
stretch = 0
|
|
||||||
tuple = i-j, firstfont, charcount, width, stretch, \
|
|
||||||
ascent, descent
|
|
||||||
lines.append(tuple)
|
|
||||||
height = height + ascent + descent
|
|
||||||
avail = avail1
|
|
||||||
self.height = height
|
|
||||||
#
|
|
||||||
# Call a function for all words in a line
|
|
||||||
def visit(self, wordfunc, anchorfunc):
|
|
||||||
avail1 = self.width - self.indent_left - self.indent_right
|
|
||||||
avail = avail1 - self.indent_hang
|
|
||||||
v = self.top
|
|
||||||
i = 0
|
|
||||||
for tuple in self.lines:
|
|
||||||
wordcount, firstfont, charcount, width, stretch, \
|
|
||||||
ascent, descent = tuple
|
|
||||||
h = self.left + self.indent_left
|
|
||||||
if i == 0: h = h + self.indent_hang
|
|
||||||
extra = 0
|
|
||||||
if self.just == 'r': h = h + avail - width
|
|
||||||
elif self.just == 'c': h = h + (avail - width) / 2
|
|
||||||
elif self.just == 'lr' and stretch > 0:
|
|
||||||
extra = avail - width
|
|
||||||
v2 = v + ascent + descent
|
|
||||||
for j in range(i, i+wordcount):
|
|
||||||
word = self.words[j]
|
|
||||||
if type(word) == Int:
|
|
||||||
ok = anchorfunc(self, tuple, word, \
|
|
||||||
h, v)
|
|
||||||
if ok <> None: return ok
|
|
||||||
continue
|
|
||||||
fo, te, wi, sp, st, as, de = word
|
|
||||||
if extra > 0 and stretch > 0:
|
|
||||||
ex = extra * st / stretch
|
|
||||||
extra = extra - ex
|
|
||||||
stretch = stretch - st
|
|
||||||
else:
|
|
||||||
ex = 0
|
|
||||||
h2 = h + wi + sp + ex
|
|
||||||
ok = wordfunc(self, tuple, word, h, v, \
|
|
||||||
h2, v2, (j==i), (j==i+wordcount-1))
|
|
||||||
if ok <> None: return ok
|
|
||||||
h = h2
|
|
||||||
v = v2
|
|
||||||
i = i + wordcount
|
|
||||||
avail = avail1
|
|
||||||
#
|
|
||||||
# Render a paragraph in "drawing object" d, using the rectangle
|
|
||||||
# given by (left, top, right) with an unspecified bottom.
|
|
||||||
# Return the computed bottom of the text.
|
|
||||||
def render(self, d, left, top, right):
|
|
||||||
if self.width <> right-left:
|
|
||||||
self.layout(right-left)
|
|
||||||
self.left = left
|
|
||||||
self.top = top
|
|
||||||
self.right = right
|
|
||||||
self.bottom = self.top + self.height
|
|
||||||
self.anchorid = 0
|
|
||||||
try:
|
|
||||||
self.d = d
|
|
||||||
self.visit(self.__class__._renderword, \
|
|
||||||
self.__class__._renderanchor)
|
|
||||||
finally:
|
|
||||||
self.d = None
|
|
||||||
return self.bottom
|
|
||||||
#
|
|
||||||
def _renderword(self, tuple, word, h, v, h2, v2, isfirst, islast):
|
|
||||||
if word[0] <> None: self.d.setfont(word[0])
|
|
||||||
baseline = v + tuple[5]
|
|
||||||
self.d.text((h, baseline - word[5]), word[1])
|
|
||||||
if self.anchorid > 0:
|
|
||||||
self.d.line((h, baseline+2), (h2, baseline+2))
|
|
||||||
#
|
|
||||||
def _renderanchor(self, tuple, word, h, v):
|
|
||||||
self.anchorid = word
|
|
||||||
#
|
|
||||||
# Return which anchor(s) was hit by the mouse
|
|
||||||
def hitcheck(self, mouseh, mousev):
|
|
||||||
self.mouseh = mouseh
|
|
||||||
self.mousev = mousev
|
|
||||||
self.anchorid = 0
|
|
||||||
self.hits = []
|
|
||||||
self.visit(self.__class__._hitcheckword, \
|
|
||||||
self.__class__._hitcheckanchor)
|
|
||||||
return self.hits
|
|
||||||
#
|
|
||||||
def _hitcheckword(self, tuple, word, h, v, h2, v2, isfirst, islast):
|
|
||||||
if self.anchorid > 0 and h <= self.mouseh <= h2 and \
|
|
||||||
v <= self.mousev <= v2:
|
|
||||||
self.hits.append(self.anchorid)
|
|
||||||
#
|
|
||||||
def _hitcheckanchor(self, tuple, word, h, v):
|
|
||||||
self.anchorid = word
|
|
||||||
#
|
|
||||||
# Return whether the given anchor id is present
|
|
||||||
def hasanchor(self, id):
|
|
||||||
return id in self.words or -id in self.words
|
|
||||||
#
|
|
||||||
# Extract the raw text from the word list, substituting one space
|
|
||||||
# for non-empty inter-word space, and terminating with '\n'
|
|
||||||
def extract(self):
|
|
||||||
text = ''
|
|
||||||
for w in self.words:
|
|
||||||
if type(w) <> Int:
|
|
||||||
word = w[1]
|
|
||||||
if w[3]: word = word + ' '
|
|
||||||
text = text + word
|
|
||||||
return text + '\n'
|
|
||||||
#
|
|
||||||
# Return which character position was hit by the mouse, as
|
|
||||||
# an offset in the entire text as returned by extract().
|
|
||||||
# Return None if the mouse was not in this paragraph
|
|
||||||
def whereis(self, d, mouseh, mousev):
|
|
||||||
if mousev < self.top or mousev > self.bottom:
|
|
||||||
return None
|
|
||||||
self.mouseh = mouseh
|
|
||||||
self.mousev = mousev
|
|
||||||
self.lastfont = None
|
|
||||||
self.charcount = 0
|
|
||||||
try:
|
|
||||||
self.d = d
|
|
||||||
return self.visit(self.__class__._whereisword, \
|
|
||||||
self.__class__._whereisanchor)
|
|
||||||
finally:
|
|
||||||
self.d = None
|
|
||||||
#
|
|
||||||
def _whereisword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
|
|
||||||
fo, te, wi, sp, st, as, de = word
|
|
||||||
if fo <> None: self.lastfont = fo
|
|
||||||
h = h1
|
|
||||||
if isfirst: h1 = 0
|
|
||||||
if islast: h2 = 999999
|
|
||||||
if not (v1 <= self.mousev <= v2 and h1 <= self.mouseh <= h2):
|
|
||||||
self.charcount = self.charcount + len(te) + (sp > 0)
|
|
||||||
return
|
|
||||||
if self.lastfont <> None:
|
|
||||||
self.d.setfont(self.lastfont)
|
|
||||||
cc = 0
|
|
||||||
for c in te:
|
|
||||||
cw = self.d.textwidth(c)
|
|
||||||
if self.mouseh <= h + cw/2:
|
|
||||||
return self.charcount + cc
|
|
||||||
cc = cc+1
|
|
||||||
h = h+cw
|
|
||||||
self.charcount = self.charcount + cc
|
|
||||||
if self.mouseh <= (h+h2) / 2:
|
|
||||||
return self.charcount
|
|
||||||
else:
|
|
||||||
return self.charcount + 1
|
|
||||||
#
|
|
||||||
def _whereisanchor(self, tuple, word, h, v):
|
|
||||||
pass
|
|
||||||
#
|
|
||||||
# Return screen position corresponding to position in paragraph.
|
|
||||||
# Return tuple (h, vtop, vbaseline, vbottom).
|
|
||||||
# This is more or less the inverse of whereis()
|
|
||||||
def screenpos(self, d, pos):
|
|
||||||
if pos < 0:
|
|
||||||
ascent, descent = self.lines[0][5:7]
|
|
||||||
return self.left, self.top, self.top + ascent, \
|
|
||||||
self.top + ascent + descent
|
|
||||||
self.pos = pos
|
|
||||||
self.lastfont = None
|
|
||||||
try:
|
|
||||||
self.d = d
|
|
||||||
ok = self.visit(self.__class__._screenposword, \
|
|
||||||
self.__class__._screenposanchor)
|
|
||||||
finally:
|
|
||||||
self.d = None
|
|
||||||
if ok == None:
|
|
||||||
ascent, descent = self.lines[-1][5:7]
|
|
||||||
ok = self.right, self.bottom - ascent - descent, \
|
|
||||||
self.bottom - descent, self.bottom
|
|
||||||
return ok
|
|
||||||
#
|
|
||||||
def _screenposword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
|
|
||||||
fo, te, wi, sp, st, as, de = word
|
|
||||||
if fo <> None: self.lastfont = fo
|
|
||||||
cc = len(te) + (sp > 0)
|
|
||||||
if self.pos > cc:
|
|
||||||
self.pos = self.pos - cc
|
|
||||||
return
|
|
||||||
if self.pos < cc:
|
|
||||||
self.d.setfont(self.lastfont)
|
|
||||||
h = h1 + self.d.textwidth(te[:self.pos])
|
|
||||||
else:
|
|
||||||
h = h2
|
|
||||||
ascent, descent = tuple[5:7]
|
|
||||||
return h, v1, v1+ascent, v2
|
|
||||||
#
|
|
||||||
def _screenposanchor(self, tuple, word, h, v):
|
|
||||||
pass
|
|
||||||
#
|
|
||||||
# Invert the stretch of text between pos1 and pos2.
|
|
||||||
# If pos1 is None, the beginning is implied;
|
|
||||||
# if pos2 is None, the end is implied.
|
|
||||||
# Undoes its own effect when called again with the same arguments
|
|
||||||
def invert(self, d, pos1, pos2):
|
|
||||||
if pos1 == None:
|
|
||||||
pos1 = self.left, self.top, self.top, self.top
|
|
||||||
else:
|
|
||||||
pos1 = self.screenpos(d, pos1)
|
|
||||||
if pos2 == None:
|
|
||||||
pos2 = self.right, self.bottom,self.bottom,self.bottom
|
|
||||||
else:
|
|
||||||
pos2 = self.screenpos(d, pos2)
|
|
||||||
h1, top1, baseline1, bottom1 = pos1
|
|
||||||
h2, top2, baseline2, bottom2 = pos2
|
|
||||||
if bottom1 <= top2:
|
|
||||||
d.invert((h1, top1), (self.right, bottom1))
|
|
||||||
h1 = self.left
|
|
||||||
if bottom1 < top2:
|
|
||||||
d.invert((h1, bottom1), (self.right, top2))
|
|
||||||
top1, bottom1 = top2, bottom2
|
|
||||||
d.invert((h1, top1), (h2, bottom2))
|
|
||||||
|
|
||||||
|
|
||||||
# Test class Para
|
|
||||||
# XXX This was last used on the Mac, hence the weird fonts...
|
|
||||||
def test():
|
|
||||||
import stdwin
|
|
||||||
from stdwinevents import *
|
|
||||||
words = 'The', 'quick', 'brown', 'fox', 'jumps', 'over', \
|
|
||||||
'the', 'lazy', 'dog.'
|
|
||||||
paralist = []
|
|
||||||
for just in 'l', 'r', 'lr', 'c':
|
|
||||||
p = Para()
|
|
||||||
p.just = just
|
|
||||||
p.addword(stdwin, ('New York', 'p', 12), words[0], 1, 1)
|
|
||||||
for word in words[1:-1]:
|
|
||||||
p.addword(stdwin, None, word, 1, 1)
|
|
||||||
p.addword(stdwin, None, words[-1], 2, 4)
|
|
||||||
p.addword(stdwin, ('New York', 'b', 18), 'Bye!', 0, 0)
|
|
||||||
p.addword(stdwin, ('New York', 'p', 10), 'Bye!', 0, 0)
|
|
||||||
paralist.append(p)
|
|
||||||
window = stdwin.open('Para.test()')
|
|
||||||
start = stop = selpara = None
|
|
||||||
while 1:
|
|
||||||
etype, win, detail = stdwin.getevent()
|
|
||||||
if etype == WE_CLOSE:
|
|
||||||
break
|
|
||||||
if etype == WE_SIZE:
|
|
||||||
window.change((0, 0), (1000, 1000))
|
|
||||||
if etype == WE_DRAW:
|
|
||||||
width, height = window.getwinsize()
|
|
||||||
d = None
|
|
||||||
try:
|
|
||||||
d = window.begindrawing()
|
|
||||||
d.cliprect(detail)
|
|
||||||
d.erase(detail)
|
|
||||||
v = 0
|
|
||||||
for p in paralist:
|
|
||||||
v = p.render(d, 0, v, width)
|
|
||||||
if p == selpara and \
|
|
||||||
start <> None and stop <> None:
|
|
||||||
p.invert(d, start, stop)
|
|
||||||
finally:
|
|
||||||
if d: d.close()
|
|
||||||
if etype == WE_MOUSE_DOWN:
|
|
||||||
if selpara and start <> None and stop <> None:
|
|
||||||
d = window.begindrawing()
|
|
||||||
selpara.invert(d, start, stop)
|
|
||||||
d.close()
|
|
||||||
start = stop = selpara = None
|
|
||||||
mouseh, mousev = detail[0]
|
|
||||||
for p in paralist:
|
|
||||||
start = p.whereis(stdwin, mouseh, mousev)
|
|
||||||
if start <> None:
|
|
||||||
selpara = p
|
|
||||||
break
|
|
||||||
if etype == WE_MOUSE_UP and start <> None and selpara:
|
|
||||||
mouseh, mousev = detail[0]
|
|
||||||
stop = selpara.whereis(stdwin, mouseh, mousev)
|
|
||||||
if stop == None: start = selpara = None
|
|
||||||
else:
|
|
||||||
if start > stop:
|
|
||||||
start, stop = stop, start
|
|
||||||
d = window.begindrawing()
|
|
||||||
selpara.invert(d, start, stop)
|
|
||||||
d.close()
|
|
||||||
window.close()
|
|
|
@ -1,627 +0,0 @@
|
||||||
# Text formatting abstractions
|
|
||||||
|
|
||||||
|
|
||||||
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 <> 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 == 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 <> 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)
|
|
||||||
#
|
|
||||||
def hrule(self):
|
|
||||||
# Typically need to override this for bit-mapped displays
|
|
||||||
self.flush()
|
|
||||||
self.addword('-'*60, 0)
|
|
||||||
self.flush()
|
|
||||||
|
|
||||||
|
|
||||||
# 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 <> 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 regex, string
|
|
||||||
if type(prog) == type(''):
|
|
||||||
prog = regex.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())
|
|
||||||
if prog.search(text) >= 0:
|
|
||||||
a, b = prog.regs[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)
|
|
|
@ -1,639 +0,0 @@
|
||||||
# A parser for HTML documents
|
|
||||||
|
|
||||||
|
|
||||||
# HTML: HyperText Markup Language; an SGML-like syntax used by WWW to
|
|
||||||
# describe hypertext documents
|
|
||||||
#
|
|
||||||
# SGML: Standard Generalized Markup Language
|
|
||||||
#
|
|
||||||
# WWW: World-Wide Web; a distributed hypertext system develped at CERN
|
|
||||||
#
|
|
||||||
# CERN: European Particle Physics Laboratory in Geneva, Switzerland
|
|
||||||
|
|
||||||
|
|
||||||
# This file is only concerned with parsing and formatting HTML
|
|
||||||
# documents, not with the other (hypertext and networking) aspects of
|
|
||||||
# the WWW project. (It does support highlighting of anchors.)
|
|
||||||
|
|
||||||
|
|
||||||
import os
|
|
||||||
import sys
|
|
||||||
import regex
|
|
||||||
import string
|
|
||||||
import sgmllib
|
|
||||||
|
|
||||||
|
|
||||||
class HTMLParser(sgmllib.SGMLParser):
|
|
||||||
|
|
||||||
# Copy base class entities and add some
|
|
||||||
entitydefs = {}
|
|
||||||
for key in sgmllib.SGMLParser.entitydefs.keys():
|
|
||||||
entitydefs[key] = sgmllib.SGMLParser.entitydefs[key]
|
|
||||||
entitydefs['bullet'] = '*'
|
|
||||||
|
|
||||||
# Provided -- handlers for tags introducing literal text
|
|
||||||
|
|
||||||
def start_listing(self, attrs):
|
|
||||||
self.setliteral('listing')
|
|
||||||
self.literal_bgn('listing', attrs)
|
|
||||||
|
|
||||||
def end_listing(self):
|
|
||||||
self.literal_end('listing')
|
|
||||||
|
|
||||||
def start_xmp(self, attrs):
|
|
||||||
self.setliteral('xmp')
|
|
||||||
self.literal_bgn('xmp', attrs)
|
|
||||||
|
|
||||||
def end_xmp(self):
|
|
||||||
self.literal_end('xmp')
|
|
||||||
|
|
||||||
def do_plaintext(self, attrs):
|
|
||||||
self.setnomoretags()
|
|
||||||
self.literal_bgn('plaintext', attrs)
|
|
||||||
|
|
||||||
# To be overridden -- begin/end literal mode
|
|
||||||
def literal_bgn(self, tag, attrs): pass
|
|
||||||
def literal_end(self, tag): pass
|
|
||||||
|
|
||||||
|
|
||||||
# Next level of sophistication -- collect anchors, title, nextid and isindex
|
|
||||||
class CollectingParser(HTMLParser):
|
|
||||||
#
|
|
||||||
def __init__(self):
|
|
||||||
HTMLParser.__init__(self)
|
|
||||||
self.savetext = None
|
|
||||||
self.nextid = ''
|
|
||||||
self.isindex = 0
|
|
||||||
self.title = ''
|
|
||||||
self.inanchor = 0
|
|
||||||
self.anchors = []
|
|
||||||
self.anchornames = []
|
|
||||||
self.anchortypes = []
|
|
||||||
#
|
|
||||||
def start_a(self, attrs):
|
|
||||||
self.inanchor = 0
|
|
||||||
href = ''
|
|
||||||
name = ''
|
|
||||||
type = ''
|
|
||||||
for attrname, value in attrs:
|
|
||||||
if attrname == 'href':
|
|
||||||
href = value
|
|
||||||
if attrname == 'name=':
|
|
||||||
name = value
|
|
||||||
if attrname == 'type=':
|
|
||||||
type = string.lower(value)
|
|
||||||
if not (href or name):
|
|
||||||
return
|
|
||||||
self.anchors.append(href)
|
|
||||||
self.anchornames.append(name)
|
|
||||||
self.anchortypes.append(type)
|
|
||||||
self.inanchor = len(self.anchors)
|
|
||||||
if not href:
|
|
||||||
self.inanchor = -self.inanchor
|
|
||||||
#
|
|
||||||
def end_a(self):
|
|
||||||
if self.inanchor > 0:
|
|
||||||
# Don't show anchors pointing into the current document
|
|
||||||
if self.anchors[self.inanchor-1][:1] <> '#':
|
|
||||||
self.handle_data('[' + `self.inanchor` + ']')
|
|
||||||
self.inanchor = 0
|
|
||||||
#
|
|
||||||
def start_header(self, attrs): pass
|
|
||||||
def end_header(self): pass
|
|
||||||
#
|
|
||||||
# (head is the same as header)
|
|
||||||
def start_head(self, attrs): pass
|
|
||||||
def end_head(self): pass
|
|
||||||
#
|
|
||||||
def start_body(self, attrs): pass
|
|
||||||
def end_body(self): pass
|
|
||||||
#
|
|
||||||
def do_nextid(self, attrs):
|
|
||||||
self.nextid = attrs
|
|
||||||
#
|
|
||||||
def do_isindex(self, attrs):
|
|
||||||
self.isindex = 1
|
|
||||||
#
|
|
||||||
def start_title(self, attrs):
|
|
||||||
self.savetext = ''
|
|
||||||
#
|
|
||||||
def end_title(self):
|
|
||||||
if self.savetext <> None:
|
|
||||||
self.title = self.savetext
|
|
||||||
self.savetext = None
|
|
||||||
#
|
|
||||||
def handle_data(self, text):
|
|
||||||
if self.savetext is not None:
|
|
||||||
self.savetext = self.savetext + text
|
|
||||||
|
|
||||||
|
|
||||||
# Formatting parser -- takes a formatter and a style sheet as arguments
|
|
||||||
|
|
||||||
# XXX The use of style sheets should change: for each tag and end tag
|
|
||||||
# there should be a style definition, and a style definition should
|
|
||||||
# encompass many more parameters: font, justification, indentation,
|
|
||||||
# vspace before, vspace after, hanging tag...
|
|
||||||
|
|
||||||
wordprog = regex.compile('[^ \t\n]*')
|
|
||||||
spaceprog = regex.compile('[ \t\n]*')
|
|
||||||
|
|
||||||
class FormattingParser(CollectingParser):
|
|
||||||
|
|
||||||
def __init__(self, formatter, stylesheet):
|
|
||||||
CollectingParser.__init__(self)
|
|
||||||
self.fmt = formatter
|
|
||||||
self.stl = stylesheet
|
|
||||||
self.savetext = None
|
|
||||||
self.compact = 0
|
|
||||||
self.nofill = 0
|
|
||||||
self.resetfont()
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
def resetfont(self):
|
|
||||||
self.fontstack = []
|
|
||||||
self.stylestack = []
|
|
||||||
self.fontset = self.stl.stdfontset
|
|
||||||
self.style = ROMAN
|
|
||||||
self.passfont()
|
|
||||||
|
|
||||||
def passfont(self):
|
|
||||||
font = self.fontset[self.style]
|
|
||||||
self.fmt.setfont(font)
|
|
||||||
|
|
||||||
def pushstyle(self, style):
|
|
||||||
self.stylestack.append(self.style)
|
|
||||||
self.style = min(style, len(self.fontset)-1)
|
|
||||||
self.passfont()
|
|
||||||
|
|
||||||
def popstyle(self):
|
|
||||||
self.style = self.stylestack[-1]
|
|
||||||
del self.stylestack[-1]
|
|
||||||
self.passfont()
|
|
||||||
|
|
||||||
def pushfontset(self, fontset, style):
|
|
||||||
self.fontstack.append(self.fontset)
|
|
||||||
self.fontset = fontset
|
|
||||||
self.pushstyle(style)
|
|
||||||
|
|
||||||
def popfontset(self):
|
|
||||||
self.fontset = self.fontstack[-1]
|
|
||||||
del self.fontstack[-1]
|
|
||||||
self.popstyle()
|
|
||||||
|
|
||||||
def flush(self):
|
|
||||||
self.fmt.flush()
|
|
||||||
|
|
||||||
def setindent(self, n):
|
|
||||||
self.fmt.setleftindent(n)
|
|
||||||
|
|
||||||
def needvspace(self, n):
|
|
||||||
self.fmt.needvspace(n)
|
|
||||||
|
|
||||||
def close(self):
|
|
||||||
HTMLParser.close(self)
|
|
||||||
self.fmt.flush()
|
|
||||||
|
|
||||||
def handle_literal(self, text):
|
|
||||||
lines = string.splitfields(text, '\n')
|
|
||||||
for i in range(1, len(lines)):
|
|
||||||
lines[i] = string.expandtabs(lines[i], 8)
|
|
||||||
for line in lines[:-1]:
|
|
||||||
self.fmt.addword(line, 0)
|
|
||||||
self.fmt.flush()
|
|
||||||
self.fmt.nospace = 0
|
|
||||||
for line in lines[-1:]:
|
|
||||||
self.fmt.addword(line, 0)
|
|
||||||
|
|
||||||
def handle_data(self, text):
|
|
||||||
if self.savetext is not None:
|
|
||||||
self.savetext = self.savetext + text
|
|
||||||
return
|
|
||||||
if self.literal:
|
|
||||||
self.handle_literal(text)
|
|
||||||
return
|
|
||||||
i = 0
|
|
||||||
n = len(text)
|
|
||||||
while i < n:
|
|
||||||
j = i + wordprog.match(text, i)
|
|
||||||
word = text[i:j]
|
|
||||||
i = j + spaceprog.match(text, j)
|
|
||||||
self.fmt.addword(word, i-j)
|
|
||||||
if self.nofill and '\n' in text[j:i]:
|
|
||||||
self.fmt.flush()
|
|
||||||
self.fmt.nospace = 0
|
|
||||||
i = j+1
|
|
||||||
while text[i-1] <> '\n': i = i+1
|
|
||||||
|
|
||||||
def literal_bgn(self, tag, attrs):
|
|
||||||
if tag == 'plaintext':
|
|
||||||
self.flush()
|
|
||||||
else:
|
|
||||||
self.needvspace(1)
|
|
||||||
self.pushfontset(self.stl.stdfontset, FIXED)
|
|
||||||
self.setindent(self.stl.literalindent)
|
|
||||||
|
|
||||||
def literal_end(self, tag):
|
|
||||||
self.needvspace(1)
|
|
||||||
self.popfontset()
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
def start_title(self, attrs):
|
|
||||||
self.flush()
|
|
||||||
self.savetext = ''
|
|
||||||
# NB end_title is unchanged
|
|
||||||
|
|
||||||
def do_p(self, attrs):
|
|
||||||
if self.compact:
|
|
||||||
self.flush()
|
|
||||||
else:
|
|
||||||
self.needvspace(1)
|
|
||||||
|
|
||||||
def do_hr(self, attrs):
|
|
||||||
self.fmt.hrule()
|
|
||||||
|
|
||||||
def start_h1(self, attrs):
|
|
||||||
self.needvspace(2)
|
|
||||||
self.setindent(self.stl.h1indent)
|
|
||||||
self.pushfontset(self.stl.h1fontset, BOLD)
|
|
||||||
self.fmt.setjust('c')
|
|
||||||
|
|
||||||
def end_h1(self):
|
|
||||||
self.popfontset()
|
|
||||||
self.needvspace(2)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
self.fmt.setjust('l')
|
|
||||||
|
|
||||||
def start_h2(self, attrs):
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.h2indent)
|
|
||||||
self.pushfontset(self.stl.h2fontset, BOLD)
|
|
||||||
|
|
||||||
def end_h2(self):
|
|
||||||
self.popfontset()
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
def start_h3(self, attrs):
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
self.pushfontset(self.stl.h3fontset, BOLD)
|
|
||||||
|
|
||||||
def end_h3(self):
|
|
||||||
self.popfontset()
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
def start_h4(self, attrs):
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
self.pushfontset(self.stl.stdfontset, BOLD)
|
|
||||||
|
|
||||||
def end_h4(self):
|
|
||||||
self.popfontset()
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
start_h5 = start_h4
|
|
||||||
end_h5 = end_h4
|
|
||||||
|
|
||||||
start_h6 = start_h5
|
|
||||||
end_h6 = end_h5
|
|
||||||
|
|
||||||
start_h7 = start_h6
|
|
||||||
end_h7 = end_h6
|
|
||||||
|
|
||||||
def start_ul(self, attrs):
|
|
||||||
self.needvspace(1)
|
|
||||||
for attrname, value in attrs:
|
|
||||||
if attrname == 'compact':
|
|
||||||
self.compact = 1
|
|
||||||
self.setindent(0)
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
self.setindent(self.stl.ulindent)
|
|
||||||
|
|
||||||
start_dir = start_menu = start_ol = start_ul
|
|
||||||
|
|
||||||
do_li = do_p
|
|
||||||
|
|
||||||
def end_ul(self):
|
|
||||||
self.compact = 0
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
end_dir = end_menu = end_ol = end_ul
|
|
||||||
|
|
||||||
def start_dl(self, attrs):
|
|
||||||
for attrname, value in attrs:
|
|
||||||
if attrname == 'compact':
|
|
||||||
self.compact = 1
|
|
||||||
self.needvspace(1)
|
|
||||||
|
|
||||||
def end_dl(self):
|
|
||||||
self.compact = 0
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
def do_dt(self, attrs):
|
|
||||||
if self.compact:
|
|
||||||
self.flush()
|
|
||||||
else:
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
|
|
||||||
def do_dd(self, attrs):
|
|
||||||
self.fmt.addword('', 1)
|
|
||||||
self.setindent(self.stl.ddindent)
|
|
||||||
|
|
||||||
def start_address(self, attrs):
|
|
||||||
self.compact = 1
|
|
||||||
self.needvspace(1)
|
|
||||||
self.fmt.setjust('r')
|
|
||||||
|
|
||||||
def end_address(self):
|
|
||||||
self.compact = 0
|
|
||||||
self.needvspace(1)
|
|
||||||
self.setindent(self.stl.stdindent)
|
|
||||||
self.fmt.setjust('l')
|
|
||||||
|
|
||||||
def start_pre(self, attrs):
|
|
||||||
self.needvspace(1)
|
|
||||||
self.nofill = self.nofill + 1
|
|
||||||
self.pushstyle(FIXED)
|
|
||||||
|
|
||||||
def end_pre(self):
|
|
||||||
self.popstyle()
|
|
||||||
self.nofill = self.nofill - 1
|
|
||||||
self.needvspace(1)
|
|
||||||
|
|
||||||
start_typewriter = start_pre
|
|
||||||
end_typewriter = end_pre
|
|
||||||
|
|
||||||
def do_img(self, attrs):
|
|
||||||
self.fmt.addword('(image)', 0)
|
|
||||||
|
|
||||||
# Physical styles
|
|
||||||
|
|
||||||
def start_tt(self, attrs): self.pushstyle(FIXED)
|
|
||||||
def end_tt(self): self.popstyle()
|
|
||||||
|
|
||||||
def start_b(self, attrs): self.pushstyle(BOLD)
|
|
||||||
def end_b(self): self.popstyle()
|
|
||||||
|
|
||||||
def start_i(self, attrs): self.pushstyle(ITALIC)
|
|
||||||
def end_i(self): self.popstyle()
|
|
||||||
|
|
||||||
def start_u(self, attrs): self.pushstyle(ITALIC) # Underline???
|
|
||||||
def end_u(self): self.popstyle()
|
|
||||||
|
|
||||||
def start_r(self, attrs): self.pushstyle(ROMAN) # Not official
|
|
||||||
def end_r(self): self.popstyle()
|
|
||||||
|
|
||||||
# Logical styles
|
|
||||||
|
|
||||||
start_em = start_i
|
|
||||||
end_em = end_i
|
|
||||||
|
|
||||||
start_strong = start_b
|
|
||||||
end_strong = end_b
|
|
||||||
|
|
||||||
start_code = start_tt
|
|
||||||
end_code = end_tt
|
|
||||||
|
|
||||||
start_samp = start_tt
|
|
||||||
end_samp = end_tt
|
|
||||||
|
|
||||||
start_kbd = start_tt
|
|
||||||
end_kbd = end_tt
|
|
||||||
|
|
||||||
start_file = start_tt # unofficial
|
|
||||||
end_file = end_tt
|
|
||||||
|
|
||||||
start_var = start_i
|
|
||||||
end_var = end_i
|
|
||||||
|
|
||||||
start_dfn = start_i
|
|
||||||
end_dfn = end_i
|
|
||||||
|
|
||||||
start_cite = start_i
|
|
||||||
end_cite = end_i
|
|
||||||
|
|
||||||
start_hp1 = start_i
|
|
||||||
end_hp1 = start_i
|
|
||||||
|
|
||||||
start_hp2 = start_b
|
|
||||||
end_hp2 = end_b
|
|
||||||
|
|
||||||
def unknown_starttag(self, tag, attrs):
|
|
||||||
print '*** unknown <' + tag + '>'
|
|
||||||
|
|
||||||
def unknown_endtag(self, tag):
|
|
||||||
print '*** unknown </' + tag + '>'
|
|
||||||
|
|
||||||
|
|
||||||
# An extension of the formatting parser which formats anchors differently.
|
|
||||||
class AnchoringParser(FormattingParser):
|
|
||||||
|
|
||||||
def start_a(self, attrs):
|
|
||||||
FormattingParser.start_a(self, attrs)
|
|
||||||
if self.inanchor:
|
|
||||||
self.fmt.bgn_anchor(self.inanchor)
|
|
||||||
|
|
||||||
def end_a(self):
|
|
||||||
if self.inanchor:
|
|
||||||
self.fmt.end_anchor(self.inanchor)
|
|
||||||
self.inanchor = 0
|
|
||||||
|
|
||||||
|
|
||||||
# Style sheet -- this is never instantiated, but the attributes
|
|
||||||
# of the class object itself are used to specify fonts to be used
|
|
||||||
# for various paragraph styles.
|
|
||||||
# A font set is a non-empty list of fonts, in the order:
|
|
||||||
# [roman, italic, bold, fixed].
|
|
||||||
# When a style is not available the nearest lower style is used
|
|
||||||
|
|
||||||
ROMAN = 0
|
|
||||||
ITALIC = 1
|
|
||||||
BOLD = 2
|
|
||||||
FIXED = 3
|
|
||||||
|
|
||||||
class NullStylesheet:
|
|
||||||
# Fonts -- none
|
|
||||||
stdfontset = [None]
|
|
||||||
h1fontset = [None]
|
|
||||||
h2fontset = [None]
|
|
||||||
h3fontset = [None]
|
|
||||||
# Indents
|
|
||||||
stdindent = 2
|
|
||||||
ddindent = 25
|
|
||||||
ulindent = 4
|
|
||||||
h1indent = 0
|
|
||||||
h2indent = 0
|
|
||||||
literalindent = 0
|
|
||||||
|
|
||||||
|
|
||||||
class X11Stylesheet(NullStylesheet):
|
|
||||||
stdfontset = [ \
|
|
||||||
'-*-helvetica-medium-r-normal-*-*-100-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-medium-o-normal-*-*-100-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-bold-r-normal-*-*-100-100-*-*-*-*-*', \
|
|
||||||
'-*-courier-medium-r-normal-*-*-100-100-*-*-*-*-*', \
|
|
||||||
]
|
|
||||||
h1fontset = [ \
|
|
||||||
'-*-helvetica-medium-r-normal-*-*-180-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-medium-o-normal-*-*-180-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-bold-r-normal-*-*-180-100-*-*-*-*-*', \
|
|
||||||
]
|
|
||||||
h2fontset = [ \
|
|
||||||
'-*-helvetica-medium-r-normal-*-*-140-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-medium-o-normal-*-*-140-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-bold-r-normal-*-*-140-100-*-*-*-*-*', \
|
|
||||||
]
|
|
||||||
h3fontset = [ \
|
|
||||||
'-*-helvetica-medium-r-normal-*-*-120-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-medium-o-normal-*-*-120-100-*-*-*-*-*', \
|
|
||||||
'-*-helvetica-bold-r-normal-*-*-120-100-*-*-*-*-*', \
|
|
||||||
]
|
|
||||||
ddindent = 40
|
|
||||||
|
|
||||||
|
|
||||||
class MacStylesheet(NullStylesheet):
|
|
||||||
stdfontset = [ \
|
|
||||||
('Geneva', 'p', 10), \
|
|
||||||
('Geneva', 'i', 10), \
|
|
||||||
('Geneva', 'b', 10), \
|
|
||||||
('Monaco', 'p', 10), \
|
|
||||||
]
|
|
||||||
h1fontset = [ \
|
|
||||||
('Geneva', 'p', 18), \
|
|
||||||
('Geneva', 'i', 18), \
|
|
||||||
('Geneva', 'b', 18), \
|
|
||||||
('Monaco', 'p', 18), \
|
|
||||||
]
|
|
||||||
h3fontset = [ \
|
|
||||||
('Geneva', 'p', 14), \
|
|
||||||
('Geneva', 'i', 14), \
|
|
||||||
('Geneva', 'b', 14), \
|
|
||||||
('Monaco', 'p', 14), \
|
|
||||||
]
|
|
||||||
h3fontset = [ \
|
|
||||||
('Geneva', 'p', 12), \
|
|
||||||
('Geneva', 'i', 12), \
|
|
||||||
('Geneva', 'b', 12), \
|
|
||||||
('Monaco', 'p', 12), \
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
if os.name == 'mac':
|
|
||||||
StdwinStylesheet = MacStylesheet
|
|
||||||
else:
|
|
||||||
StdwinStylesheet = X11Stylesheet
|
|
||||||
|
|
||||||
|
|
||||||
class GLStylesheet(NullStylesheet):
|
|
||||||
stdfontset = [ \
|
|
||||||
'Helvetica 10', \
|
|
||||||
'Helvetica-Italic 10', \
|
|
||||||
'Helvetica-Bold 10', \
|
|
||||||
'Courier 10', \
|
|
||||||
]
|
|
||||||
h1fontset = [ \
|
|
||||||
'Helvetica 18', \
|
|
||||||
'Helvetica-Italic 18', \
|
|
||||||
'Helvetica-Bold 18', \
|
|
||||||
'Courier 18', \
|
|
||||||
]
|
|
||||||
h2fontset = [ \
|
|
||||||
'Helvetica 14', \
|
|
||||||
'Helvetica-Italic 14', \
|
|
||||||
'Helvetica-Bold 14', \
|
|
||||||
'Courier 14', \
|
|
||||||
]
|
|
||||||
h3fontset = [ \
|
|
||||||
'Helvetica 12', \
|
|
||||||
'Helvetica-Italic 12', \
|
|
||||||
'Helvetica-Bold 12', \
|
|
||||||
'Courier 12', \
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
# Test program -- produces no output but times how long it takes
|
|
||||||
# to send a document to a null formatter, exclusive of I/O
|
|
||||||
|
|
||||||
def test():
|
|
||||||
import fmt
|
|
||||||
import time
|
|
||||||
import urllib
|
|
||||||
if sys.argv[1:]: file = sys.argv[1]
|
|
||||||
else: file = 'test.html'
|
|
||||||
data = urllib.urlopen(file).read()
|
|
||||||
t0 = time.time()
|
|
||||||
fmtr = fmt.WritingFormatter(sys.stdout, 79)
|
|
||||||
p = FormattingParser(fmtr, NullStylesheet)
|
|
||||||
p.feed(data)
|
|
||||||
p.close()
|
|
||||||
t1 = time.time()
|
|
||||||
print
|
|
||||||
print '*** Formatting time:', round(t1-t0, 3), 'seconds.'
|
|
||||||
|
|
||||||
|
|
||||||
# Test program using stdwin
|
|
||||||
|
|
||||||
def testStdwin():
|
|
||||||
import stdwin, fmt
|
|
||||||
from stdwinevents import *
|
|
||||||
if sys.argv[1:]: file = sys.argv[1]
|
|
||||||
else: file = 'test.html'
|
|
||||||
data = open(file, 'r').read()
|
|
||||||
window = stdwin.open('testStdwin')
|
|
||||||
b = None
|
|
||||||
while 1:
|
|
||||||
etype, ewin, edetail = stdwin.getevent()
|
|
||||||
if etype == WE_CLOSE:
|
|
||||||
break
|
|
||||||
if etype == WE_SIZE:
|
|
||||||
window.setdocsize(0, 0)
|
|
||||||
window.setorigin(0, 0)
|
|
||||||
window.change((0, 0), (10000, 30000)) # XXX
|
|
||||||
if etype == WE_DRAW:
|
|
||||||
if not b:
|
|
||||||
b = fmt.StdwinBackEnd(window, 1)
|
|
||||||
f = fmt.BaseFormatter(b.d, b)
|
|
||||||
p = FormattingParser(f, \
|
|
||||||
MacStylesheet)
|
|
||||||
p.feed(data)
|
|
||||||
p.close()
|
|
||||||
b.finish()
|
|
||||||
else:
|
|
||||||
b.redraw(edetail)
|
|
||||||
window.close()
|
|
||||||
|
|
||||||
|
|
||||||
# Test program using GL
|
|
||||||
|
|
||||||
def testGL():
|
|
||||||
import gl, GL, fmt
|
|
||||||
if sys.argv[1:]: file = sys.argv[1]
|
|
||||||
else: file = 'test.html'
|
|
||||||
data = open(file, 'r').read()
|
|
||||||
W, H = 600, 600
|
|
||||||
gl.foreground()
|
|
||||||
gl.prefsize(W, H)
|
|
||||||
wid = gl.winopen('testGL')
|
|
||||||
gl.ortho2(0, W, H, 0)
|
|
||||||
gl.color(GL.WHITE)
|
|
||||||
gl.clear()
|
|
||||||
gl.color(GL.BLACK)
|
|
||||||
b = fmt.GLBackEnd(wid)
|
|
||||||
f = fmt.BaseFormatter(b.d, b)
|
|
||||||
p = FormattingParser(f, GLStylesheet)
|
|
||||||
p.feed(data)
|
|
||||||
p.close()
|
|
||||||
b.finish()
|
|
||||||
#
|
|
||||||
import time
|
|
||||||
time.sleep(5)
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == '__main__':
|
|
||||||
test()
|
|
|
@ -1,321 +0,0 @@
|
||||||
# A parser for SGML, using the derived class as static DTD.
|
|
||||||
|
|
||||||
# XXX This only supports those SGML features used by HTML.
|
|
||||||
|
|
||||||
# XXX There should be a way to distinguish between PCDATA (parsed
|
|
||||||
# character data -- the normal case), RCDATA (replaceable character
|
|
||||||
# data -- only char and entity references and end tags are special)
|
|
||||||
# and CDATA (character data -- only end tags are special).
|
|
||||||
|
|
||||||
|
|
||||||
import regex
|
|
||||||
import string
|
|
||||||
|
|
||||||
|
|
||||||
# Regular expressions used for parsing
|
|
||||||
|
|
||||||
incomplete = regex.compile( \
|
|
||||||
'<!-?\|</[a-zA-Z][a-zA-Z0-9]*[ \t\n]*\|</?\|' + \
|
|
||||||
'&#[a-zA-Z0-9]*\|&[a-zA-Z][a-zA-Z0-9]*\|&')
|
|
||||||
entityref = regex.compile('&[a-zA-Z][a-zA-Z0-9]*[;.]')
|
|
||||||
charref = regex.compile('&#[a-zA-Z0-9]+;')
|
|
||||||
starttagopen = regex.compile('<[a-zA-Z]')
|
|
||||||
endtag = regex.compile('</[a-zA-Z][a-zA-Z0-9]*[ \t\n]*>')
|
|
||||||
commentopen = regex.compile('<!--')
|
|
||||||
|
|
||||||
|
|
||||||
# SGML parser base class -- find tags and call handler functions.
|
|
||||||
# Usage: p = SGMLParser(); p.feed(data); ...; p.close().
|
|
||||||
# The dtd is defined by deriving a class which defines methods
|
|
||||||
# with special names to handle tags: start_foo and end_foo to handle
|
|
||||||
# <foo> and </foo>, respectively, or do_foo to handle <foo> by itself.
|
|
||||||
# (Tags are converted to lower case for this purpose.) The data
|
|
||||||
# between tags is passed to the parser by calling self.handle_data()
|
|
||||||
# with some data as argument (the data may be split up in arbutrary
|
|
||||||
# chunks). Entity references are passed by calling
|
|
||||||
# self.handle_entityref() with the entity reference as argument.
|
|
||||||
|
|
||||||
class SGMLParser:
|
|
||||||
|
|
||||||
# Interface -- initialize and reset this instance
|
|
||||||
def __init__(self):
|
|
||||||
self.reset()
|
|
||||||
|
|
||||||
# Interface -- reset this instance. Loses all unprocessed data
|
|
||||||
def reset(self):
|
|
||||||
self.rawdata = ''
|
|
||||||
self.stack = []
|
|
||||||
self.nomoretags = 0
|
|
||||||
self.literal = 0
|
|
||||||
|
|
||||||
# For derived classes only -- enter literal mode (CDATA) till EOF
|
|
||||||
def setnomoretags(self):
|
|
||||||
self.nomoretags = self.literal = 1
|
|
||||||
|
|
||||||
# For derived classes only -- enter literal mode (CDATA)
|
|
||||||
def setliteral(self, *args):
|
|
||||||
self.literal = 1
|
|
||||||
|
|
||||||
# Interface -- feed some data to the parser. Call this as
|
|
||||||
# often as you want, with as little or as much text as you
|
|
||||||
# want (may include '\n'). (This just saves the text, all the
|
|
||||||
# processing is done by process() or close().)
|
|
||||||
def feed(self, data):
|
|
||||||
self.rawdata = self.rawdata + data
|
|
||||||
self.goahead(0)
|
|
||||||
|
|
||||||
# Interface -- handle the remaining data
|
|
||||||
def close(self):
|
|
||||||
self.goahead(1)
|
|
||||||
|
|
||||||
# Internal -- handle data as far as reasonable. May leave state
|
|
||||||
# and data to be processed by a subsequent call. If 'end' is
|
|
||||||
# true, force handling all data as if followed by EOF marker.
|
|
||||||
def goahead(self, end):
|
|
||||||
rawdata = self.rawdata
|
|
||||||
i = 0
|
|
||||||
n = len(rawdata)
|
|
||||||
while i < n:
|
|
||||||
if self.nomoretags:
|
|
||||||
self.handle_data(rawdata[i:n])
|
|
||||||
i = n
|
|
||||||
break
|
|
||||||
j = incomplete.search(rawdata, i)
|
|
||||||
if j < 0: j = n
|
|
||||||
if i < j: self.handle_data(rawdata[i:j])
|
|
||||||
i = j
|
|
||||||
if i == n: break
|
|
||||||
if rawdata[i] == '<':
|
|
||||||
if starttagopen.match(rawdata, i) >= 0:
|
|
||||||
if self.literal:
|
|
||||||
self.handle_data(rawdata[i])
|
|
||||||
i = i+1
|
|
||||||
continue
|
|
||||||
k = self.parse_starttag(i)
|
|
||||||
if k < 0: break
|
|
||||||
i = i + k
|
|
||||||
continue
|
|
||||||
k = endtag.match(rawdata, i)
|
|
||||||
if k >= 0:
|
|
||||||
j = i+k
|
|
||||||
self.parse_endtag(rawdata[i:j])
|
|
||||||
i = j
|
|
||||||
self.literal = 0
|
|
||||||
continue
|
|
||||||
if commentopen.match(rawdata, i) >= 0:
|
|
||||||
if self.literal:
|
|
||||||
self.handle_data(rawdata[i])
|
|
||||||
i = i+1
|
|
||||||
continue
|
|
||||||
k = self.parse_comment(i)
|
|
||||||
if k < 0: break
|
|
||||||
i = i+k
|
|
||||||
continue
|
|
||||||
elif rawdata[i] == '&':
|
|
||||||
k = charref.match(rawdata, i)
|
|
||||||
if k >= 0:
|
|
||||||
j = i+k
|
|
||||||
self.handle_charref(rawdata[i+2:j-1])
|
|
||||||
i = j
|
|
||||||
continue
|
|
||||||
k = entityref.match(rawdata, i)
|
|
||||||
if k >= 0:
|
|
||||||
j = i+k
|
|
||||||
self.handle_entityref(rawdata[i+1:j-1])
|
|
||||||
i = j
|
|
||||||
continue
|
|
||||||
else:
|
|
||||||
raise RuntimeError, 'neither < nor & ??'
|
|
||||||
# We get here only if incomplete matches but
|
|
||||||
# nothing else
|
|
||||||
k = incomplete.match(rawdata, i)
|
|
||||||
if k < 0: raise RuntimeError, 'no incomplete match ??'
|
|
||||||
j = i+k
|
|
||||||
if j == n: break # Really incomplete
|
|
||||||
self.handle_data(rawdata[i:j])
|
|
||||||
i = j
|
|
||||||
# end while
|
|
||||||
if end and i < n:
|
|
||||||
self.handle_data(rawdata[i:n])
|
|
||||||
i = n
|
|
||||||
self.rawdata = rawdata[i:]
|
|
||||||
# XXX if end: check for empty stack
|
|
||||||
|
|
||||||
# Internal -- parse comment, return length or -1 if not ternimated
|
|
||||||
def parse_comment(self, i):
|
|
||||||
rawdata = self.rawdata
|
|
||||||
if rawdata[i:i+4] <> '<!--':
|
|
||||||
raise RuntimeError, 'unexpected call to handle_comment'
|
|
||||||
try:
|
|
||||||
j = string.index(rawdata, '--', i+4)
|
|
||||||
except string.index_error:
|
|
||||||
return -1
|
|
||||||
self.handle_comment(rawdata[i+4: j])
|
|
||||||
j = j+2
|
|
||||||
n = len(rawdata)
|
|
||||||
while j < n and rawdata[j] in ' \t\n': j = j+1
|
|
||||||
if j == n: return -1 # Wait for final '>'
|
|
||||||
if rawdata[j] == '>':
|
|
||||||
j = j+1
|
|
||||||
else:
|
|
||||||
print '*** comment not terminated with >'
|
|
||||||
print repr(rawdata[j-5:j]), '*!*', repr(rawdata[j:j+5])
|
|
||||||
return j-i
|
|
||||||
|
|
||||||
# Internal -- handle starttag, return length or -1 if not terminated
|
|
||||||
def parse_starttag(self, i):
|
|
||||||
rawdata = self.rawdata
|
|
||||||
try:
|
|
||||||
j = string.index(rawdata, '>', i)
|
|
||||||
except string.index_error:
|
|
||||||
return -1
|
|
||||||
# Now parse the data between i+1 and j into a tag and attrs
|
|
||||||
attrs = []
|
|
||||||
tagfind = regex.compile('[a-zA-Z][a-zA-Z0-9]*')
|
|
||||||
attrfind = regex.compile( \
|
|
||||||
'[ \t\n]+\([a-zA-Z][a-zA-Z0-9]*\)' + \
|
|
||||||
'\([ \t\n]*=[ \t\n]*' + \
|
|
||||||
'\(\'[^\']*\';\|"[^"]*"\|[-a-zA-Z0-9./:+*%?!()_#]+\)\)?')
|
|
||||||
k = tagfind.match(rawdata, i+1)
|
|
||||||
if k < 0:
|
|
||||||
raise RuntimeError, 'unexpected call to parse_starttag'
|
|
||||||
k = i+1+k
|
|
||||||
tag = string.lower(rawdata[i+1:k])
|
|
||||||
while k < j:
|
|
||||||
l = attrfind.match(rawdata, k)
|
|
||||||
if l < 0: break
|
|
||||||
regs = attrfind.regs
|
|
||||||
a1, b1 = regs[1]
|
|
||||||
a2, b2 = regs[2]
|
|
||||||
a3, b3 = regs[3]
|
|
||||||
attrname = rawdata[a1:b1]
|
|
||||||
if '=' in rawdata[k:k+l]:
|
|
||||||
attrvalue = rawdata[a3:b3]
|
|
||||||
if attrvalue[:1] == '\'' == attrvalue[-1:] or \
|
|
||||||
attrvalue[:1] == '"' == attrvalue[-1:]:
|
|
||||||
attrvalue = attrvalue[1:-1]
|
|
||||||
else:
|
|
||||||
attrvalue = ''
|
|
||||||
attrs.append(string.lower(attrname), attrvalue)
|
|
||||||
k = k + l
|
|
||||||
j = j+1
|
|
||||||
try:
|
|
||||||
method = getattr(self, 'start_' + tag)
|
|
||||||
except AttributeError:
|
|
||||||
try:
|
|
||||||
method = getattr(self, 'do_' + tag)
|
|
||||||
except AttributeError:
|
|
||||||
self.unknown_starttag(tag, attrs)
|
|
||||||
return j-i
|
|
||||||
method(attrs)
|
|
||||||
return j-i
|
|
||||||
self.stack.append(tag)
|
|
||||||
method(attrs)
|
|
||||||
return j-i
|
|
||||||
|
|
||||||
# Internal -- parse endtag
|
|
||||||
def parse_endtag(self, data):
|
|
||||||
if data[:2] <> '</' or data[-1:] <> '>':
|
|
||||||
raise RuntimeError, 'unexpected call to parse_endtag'
|
|
||||||
tag = string.lower(string.strip(data[2:-1]))
|
|
||||||
try:
|
|
||||||
method = getattr(self, 'end_' + tag)
|
|
||||||
except AttributeError:
|
|
||||||
self.unknown_endtag(tag)
|
|
||||||
return
|
|
||||||
if self.stack and self.stack[-1] == tag:
|
|
||||||
del self.stack[-1]
|
|
||||||
else:
|
|
||||||
print '*** Unbalanced </' + tag + '>'
|
|
||||||
print '*** Stack:', self.stack
|
|
||||||
found = None
|
|
||||||
for i in range(len(self.stack)):
|
|
||||||
if self.stack[i] == tag: found = i
|
|
||||||
if found <> None:
|
|
||||||
del self.stack[found:]
|
|
||||||
method()
|
|
||||||
|
|
||||||
# Example -- handle character reference, no need to override
|
|
||||||
def handle_charref(self, name):
|
|
||||||
try:
|
|
||||||
n = string.atoi(name)
|
|
||||||
except string.atoi_error:
|
|
||||||
self.unknown_charref(name)
|
|
||||||
return
|
|
||||||
if not 0 <= n <= 255:
|
|
||||||
self.unknown_charref(name)
|
|
||||||
return
|
|
||||||
self.handle_data(chr(n))
|
|
||||||
|
|
||||||
# Definition of entities -- derived classes may override
|
|
||||||
entitydefs = \
|
|
||||||
{'lt': '<', 'gt': '>', 'amp': '&', 'quot': '"', 'apos': '\''}
|
|
||||||
|
|
||||||
# Example -- handle entity reference, no need to override
|
|
||||||
def handle_entityref(self, name):
|
|
||||||
table = self.__class__.entitydefs
|
|
||||||
name = string.lower(name)
|
|
||||||
if table.has_key(name):
|
|
||||||
self.handle_data(table[name])
|
|
||||||
else:
|
|
||||||
self.unknown_entityref(name)
|
|
||||||
return
|
|
||||||
|
|
||||||
# Example -- handle data, should be overridden
|
|
||||||
def handle_data(self, data):
|
|
||||||
pass
|
|
||||||
|
|
||||||
# Example -- handle comment, could be overridden
|
|
||||||
def handle_comment(self, data):
|
|
||||||
pass
|
|
||||||
|
|
||||||
# To be overridden -- handlers for unknown objects
|
|
||||||
def unknown_starttag(self, tag, attrs): pass
|
|
||||||
def unknown_endtag(self, tag): pass
|
|
||||||
def unknown_charref(self, ref): pass
|
|
||||||
def unknown_entityref(self, ref): pass
|
|
||||||
|
|
||||||
|
|
||||||
class TestSGML(SGMLParser):
|
|
||||||
|
|
||||||
def handle_data(self, data):
|
|
||||||
r = repr(data)
|
|
||||||
if len(r) > 72:
|
|
||||||
r = r[:35] + '...' + r[-35:]
|
|
||||||
print 'data:', r
|
|
||||||
|
|
||||||
def handle_comment(self, data):
|
|
||||||
r = repr(data)
|
|
||||||
if len(r) > 68:
|
|
||||||
r = r[:32] + '...' + r[-32:]
|
|
||||||
print 'comment:', r
|
|
||||||
|
|
||||||
def unknown_starttag(self, tag, attrs):
|
|
||||||
print 'start tag: <' + tag,
|
|
||||||
for name, value in attrs:
|
|
||||||
print name + '=' + '"' + value + '"',
|
|
||||||
print '>'
|
|
||||||
|
|
||||||
def unknown_endtag(self, tag):
|
|
||||||
print 'end tag: </' + tag + '>'
|
|
||||||
|
|
||||||
def unknown_entityref(self, ref):
|
|
||||||
print '*** unknown entity ref: &' + ref + ';'
|
|
||||||
|
|
||||||
def unknown_charref(self, ref):
|
|
||||||
print '*** unknown char ref: &#' + ref + ';'
|
|
||||||
|
|
||||||
|
|
||||||
def test():
|
|
||||||
file = 'test.html'
|
|
||||||
f = open(file, 'r')
|
|
||||||
x = TestSGML()
|
|
||||||
while 1:
|
|
||||||
line = f.readline()
|
|
||||||
if not line:
|
|
||||||
x.close()
|
|
||||||
break
|
|
||||||
x.feed(line)
|
|
||||||
|
|
||||||
|
|
||||||
#test()
|
|
|
@ -1,63 +0,0 @@
|
||||||
# Tk backend -- unfinished
|
|
||||||
|
|
||||||
debug = 0
|
|
||||||
|
|
||||||
from fmt import *
|
|
||||||
|
|
||||||
class TkFormatter:
|
|
||||||
|
|
||||||
def __init__(self, text):
|
|
||||||
self.text = text # The text widget to draw in
|
|
||||||
self.nospace = 1
|
|
||||||
self.blanklines = 0
|
|
||||||
self.font = ''
|
|
||||||
|
|
||||||
# Methods called by htmllib.FormattingParser:
|
|
||||||
|
|
||||||
def setfont(self, font):
|
|
||||||
if 1 or debug: print "setfont(%s)" % `font`
|
|
||||||
self.font = font
|
|
||||||
|
|
||||||
def resetfont(self):
|
|
||||||
if debug: print "resetfont()"
|
|
||||||
self.font = ''
|
|
||||||
|
|
||||||
def flush(self):
|
|
||||||
if debug: print "flush()"
|
|
||||||
self.needvspace(1)
|
|
||||||
|
|
||||||
def setleftindent(self, n):
|
|
||||||
if debug: print "setleftindent(%d)" % n
|
|
||||||
|
|
||||||
def needvspace(self, n):
|
|
||||||
if debug: print "needvspace(%d)" % n
|
|
||||||
self.blanklines = max(n, self.blanklines)
|
|
||||||
self.nospace = 1
|
|
||||||
|
|
||||||
def addword(self, word, nspaces):
|
|
||||||
if debug: print "addword(%s, %d)" % (`word`, nspaces)
|
|
||||||
if self.nospace and not word:
|
|
||||||
return
|
|
||||||
if self.blanklines > 0:
|
|
||||||
word = '\n'*self.blanklines + word
|
|
||||||
self.blanklines = 0
|
|
||||||
self.nospace = 0
|
|
||||||
here = self.text.index('end')
|
|
||||||
self.text.insert('end', word + nspaces*' ')
|
|
||||||
if not self.font:
|
|
||||||
self.tag_remo
|
|
||||||
|
|
||||||
def setjust(self, c):
|
|
||||||
if debug: print "setjust(%s)" % `c`
|
|
||||||
|
|
||||||
def bgn_anchor(self):
|
|
||||||
if debug: print "bgn_anchor()"
|
|
||||||
|
|
||||||
def end_anchor(self):
|
|
||||||
if debug: print "end_anchor()"
|
|
||||||
|
|
||||||
def hrule(self):
|
|
||||||
if debug: print "hrule()"
|
|
||||||
self.flush()
|
|
||||||
self.addword('_'*60, 0)
|
|
||||||
self.flush()
|
|
|
@ -1,19 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www1.py -- print the contents of a URL on stdout
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
print line,
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,101 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www10.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
# - update display while reading
|
|
||||||
# - vertical scroll bar
|
|
||||||
# - rewritten as class
|
|
||||||
# - editable url entry and reload button
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
viewer = Viewer()
|
|
||||||
viewer.load(url)
|
|
||||||
viewer.go()
|
|
||||||
|
|
||||||
class Viewer:
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
# Create root window
|
|
||||||
self.root = Tk()
|
|
||||||
self.root.minsize(1, 1)
|
|
||||||
|
|
||||||
# Create topframe for the entry and button
|
|
||||||
self.topframe = Frame(self.root)
|
|
||||||
self.topframe.pack({'fill': 'x', 'side': 'top'})
|
|
||||||
|
|
||||||
# Create a label in front of the entry
|
|
||||||
self.urllabel = Label(self.topframe, {'text': 'URL:'})
|
|
||||||
self.urllabel.pack({'side': 'left'})
|
|
||||||
|
|
||||||
# Create the entry containing the URL
|
|
||||||
self.entry = Entry(self.topframe, {'relief': 'sunken'})
|
|
||||||
self.entry.pack({'side': 'left', 'fill': 'x', 'expand': 1})
|
|
||||||
self.entry.bind('<Return>', self.loadit)
|
|
||||||
|
|
||||||
# Create the button
|
|
||||||
self.reload = Button(self.topframe,
|
|
||||||
{'text': 'Reload',
|
|
||||||
'command': self.reload})
|
|
||||||
self.reload.pack({'side': 'right'})
|
|
||||||
|
|
||||||
# Create botframe for the text and scrollbar
|
|
||||||
self.botframe = Frame(self.root)
|
|
||||||
self.botframe.pack({'fill': 'both', 'expand': 1})
|
|
||||||
|
|
||||||
# The Scrollbar *must* be created first
|
|
||||||
self.vbar = Scrollbar(self.botframe)
|
|
||||||
self.vbar.pack({'fill': 'y', 'side': 'right'})
|
|
||||||
self.text = Text(self.botframe)
|
|
||||||
self.text.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
|
|
||||||
|
|
||||||
# Link Text widget and Scrollbar
|
|
||||||
self.text['yscrollcommand'] = (self.vbar, 'set')
|
|
||||||
self.vbar['command'] = (self.text, 'yview')
|
|
||||||
|
|
||||||
self.url = None
|
|
||||||
|
|
||||||
def load(self, url):
|
|
||||||
# Load a new URL into the window
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
|
|
||||||
self.url = url
|
|
||||||
|
|
||||||
self.root.title(url)
|
|
||||||
|
|
||||||
self.entry.delete('0', 'end')
|
|
||||||
self.entry.insert('end', url)
|
|
||||||
|
|
||||||
self.text.delete('1.0', 'end')
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
if line[-2:] == '\r\n': line = line[:-2] + '\n'
|
|
||||||
self.text.insert('end', line)
|
|
||||||
self.root.update_idletasks()
|
|
||||||
|
|
||||||
fp.close()
|
|
||||||
|
|
||||||
def go(self):
|
|
||||||
# Start Tk main loop
|
|
||||||
self.root.mainloop()
|
|
||||||
|
|
||||||
def reload(self, *args):
|
|
||||||
# Callback for Reload button
|
|
||||||
if self.url:
|
|
||||||
self.load(self.url)
|
|
||||||
|
|
||||||
def loadit(self, *args):
|
|
||||||
# Callback for <Return> event in entry
|
|
||||||
self.load(self.entry.get())
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,137 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www11.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
# - update display while reading
|
|
||||||
# - vertical scroll bar
|
|
||||||
# - rewritten as class
|
|
||||||
# - editable url entry and reload button
|
|
||||||
# - error dialog
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
import Dialog
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
viewer = Viewer()
|
|
||||||
viewer.load(url)
|
|
||||||
viewer.go()
|
|
||||||
|
|
||||||
class Viewer:
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
# Create root window
|
|
||||||
self.root = Tk()
|
|
||||||
self.root.minsize(1, 1)
|
|
||||||
|
|
||||||
# Create topframe for the entry and button
|
|
||||||
self.topframe = Frame(self.root)
|
|
||||||
self.topframe.pack({'fill': 'x'})
|
|
||||||
|
|
||||||
# Create a label in front of the entry
|
|
||||||
self.urllabel = Label(self.topframe, {'text': 'URL:'})
|
|
||||||
self.urllabel.pack({'side': 'left'})
|
|
||||||
|
|
||||||
# Create the entry containing the URL
|
|
||||||
self.entry = Entry(self.topframe,
|
|
||||||
{'relief': 'sunken', 'border': 2})
|
|
||||||
self.entry.pack({'side': 'left', 'fill': 'x', 'expand': 1})
|
|
||||||
self.entry.bind('<Return>', self.loadit)
|
|
||||||
|
|
||||||
# Create the button
|
|
||||||
self.reload = Button(self.topframe,
|
|
||||||
{'text': 'Reload',
|
|
||||||
'command': self.reload})
|
|
||||||
self.reload.pack({'side': 'right'})
|
|
||||||
|
|
||||||
# Create botframe for the text and scrollbar
|
|
||||||
self.botframe = Frame(self.root)
|
|
||||||
self.botframe.pack({'fill': 'both', 'expand': 1})
|
|
||||||
|
|
||||||
# The Scrollbar *must* be created first
|
|
||||||
self.vbar = Scrollbar(self.botframe)
|
|
||||||
self.vbar.pack({'fill': 'y', 'side': 'right'})
|
|
||||||
self.text = Text(self.botframe)
|
|
||||||
self.text.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
|
|
||||||
|
|
||||||
# Link Text widget and Scrollbar
|
|
||||||
self.text['yscrollcommand'] = (self.vbar, 'set')
|
|
||||||
self.vbar['command'] = (self.text, 'yview')
|
|
||||||
|
|
||||||
self.url = None
|
|
||||||
|
|
||||||
def load(self, url):
|
|
||||||
# Load a new URL into the window
|
|
||||||
fp, url = self.urlopen(url)
|
|
||||||
if not fp:
|
|
||||||
return
|
|
||||||
|
|
||||||
self.url = url
|
|
||||||
|
|
||||||
self.root.title(url)
|
|
||||||
|
|
||||||
self.entry.delete('0', 'end')
|
|
||||||
self.entry.insert('end', url)
|
|
||||||
|
|
||||||
self.text.delete('0.0', 'end')
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
if line[-2:] == '\r\n': line = line[:-2] + '\n'
|
|
||||||
self.text.insert('end', line)
|
|
||||||
self.root.update_idletasks()
|
|
||||||
|
|
||||||
fp.close()
|
|
||||||
|
|
||||||
def urlopen(self, url):
|
|
||||||
# Open a URL --
|
|
||||||
# return (fp, url) if successful
|
|
||||||
# display dialog and return (None, url) for errors
|
|
||||||
try:
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
except IOError, msg:
|
|
||||||
import types
|
|
||||||
if type(msg) == types.TupleType and len(msg) == 4:
|
|
||||||
if msg[1] == 302:
|
|
||||||
m = msg[3]
|
|
||||||
if m.has_key('location'):
|
|
||||||
url = m['location']
|
|
||||||
return self.urlopen(url)
|
|
||||||
elif m.has_key('uri'):
|
|
||||||
url = m['uri']
|
|
||||||
return self.urlopen(url)
|
|
||||||
self.errordialog(IOError, msg)
|
|
||||||
fp = None
|
|
||||||
return fp, url
|
|
||||||
|
|
||||||
def errordialog(self, exc, msg):
|
|
||||||
# Display an error dialog -- return when the user clicks OK
|
|
||||||
Dialog.Dialog(self.root, {
|
|
||||||
'text': str(msg),
|
|
||||||
'title': exc,
|
|
||||||
'bitmap': 'error',
|
|
||||||
'default': 0,
|
|
||||||
'strings': ('OK',),
|
|
||||||
})
|
|
||||||
|
|
||||||
def go(self):
|
|
||||||
# Start Tk main loop
|
|
||||||
self.root.mainloop()
|
|
||||||
|
|
||||||
def reload(self, *args):
|
|
||||||
# Callback for Reload button
|
|
||||||
if self.url:
|
|
||||||
self.load(self.url)
|
|
||||||
|
|
||||||
def loadit(self, *args):
|
|
||||||
# Callback for <Return> event in entry
|
|
||||||
self.load(self.entry.get())
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,210 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www12.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
# - update display while reading
|
|
||||||
# - vertical scroll bar
|
|
||||||
# - rewritten as class
|
|
||||||
# - editable url entry and reload button
|
|
||||||
# - error dialog
|
|
||||||
# - menu bar; added 'master' option to constructor
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
import Dialog
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
tk = Tk()
|
|
||||||
tk.withdraw()
|
|
||||||
viewer = Viewer(tk)
|
|
||||||
viewer.load(url)
|
|
||||||
viewer.go()
|
|
||||||
|
|
||||||
class Viewer:
|
|
||||||
|
|
||||||
def __init__(self, master = None):
|
|
||||||
# Create root window
|
|
||||||
if master is None:
|
|
||||||
self.root = self.master = Tk()
|
|
||||||
else:
|
|
||||||
self.master = master
|
|
||||||
self.root = Toplevel(self.master)
|
|
||||||
self.root.minsize(1, 1)
|
|
||||||
|
|
||||||
# Create menu bar
|
|
||||||
self.mbar = Frame(self.root,
|
|
||||||
{'relief': 'raised',
|
|
||||||
'border': 2})
|
|
||||||
self.mbar.pack({'fill': 'x'})
|
|
||||||
|
|
||||||
# Create File menu
|
|
||||||
self.filebutton = Menubutton(self.mbar, {'text': 'File'})
|
|
||||||
self.filebutton.pack({'side': 'left'})
|
|
||||||
|
|
||||||
self.filemenu = Menu(self.filebutton)
|
|
||||||
self.filebutton['menu'] = self.filemenu
|
|
||||||
|
|
||||||
# Create Edit menu
|
|
||||||
self.editbutton = Menubutton(self.mbar, {'text': 'Edit'})
|
|
||||||
self.editbutton.pack({'side': 'left'})
|
|
||||||
|
|
||||||
self.editmenu = Menu(self.editbutton)
|
|
||||||
self.editbutton['menu'] = self.editmenu
|
|
||||||
|
|
||||||
# Magic so you can swipe from one button to the next
|
|
||||||
self.mbar.tk_menuBar(self.filebutton, self.editbutton)
|
|
||||||
|
|
||||||
# Populate File menu
|
|
||||||
self.filemenu.add('command', {'label': 'New',
|
|
||||||
'command': self.new_command})
|
|
||||||
self.filemenu.add('command', {'label': 'Open...',
|
|
||||||
'command': self.open_command})
|
|
||||||
self.filemenu.add('command', {'label': 'Clone',
|
|
||||||
'command': self.clone_command})
|
|
||||||
self.filemenu.add('separator')
|
|
||||||
self.filemenu.add('command', {'label': 'Close',
|
|
||||||
'command': self.close_command})
|
|
||||||
self.filemenu.add('command', {'label': 'Quit',
|
|
||||||
'command': self.quit_command})
|
|
||||||
|
|
||||||
# Populate Edit menu
|
|
||||||
pass
|
|
||||||
|
|
||||||
# Create topframe for the entry and button
|
|
||||||
self.topframe = Frame(self.root)
|
|
||||||
self.topframe.pack({'fill': 'x'})
|
|
||||||
|
|
||||||
# Create a label in front of the entry
|
|
||||||
self.urllabel = Label(self.topframe, {'text': 'URL:'})
|
|
||||||
self.urllabel.pack({'side': 'left'})
|
|
||||||
|
|
||||||
# Create the entry containing the URL
|
|
||||||
self.entry = Entry(self.topframe,
|
|
||||||
{'relief': 'sunken', 'border': 2})
|
|
||||||
self.entry.pack({'side': 'left', 'fill': 'x', 'expand': 1})
|
|
||||||
self.entry.bind('<Return>', self.loadit)
|
|
||||||
|
|
||||||
# Create the button
|
|
||||||
self.reload = Button(self.topframe,
|
|
||||||
{'text': 'Reload',
|
|
||||||
'command': self.reload})
|
|
||||||
self.reload.pack({'side': 'right'})
|
|
||||||
|
|
||||||
# Create botframe for the text and scrollbar
|
|
||||||
self.botframe = Frame(self.root)
|
|
||||||
self.botframe.pack({'fill': 'both', 'expand': 1})
|
|
||||||
|
|
||||||
# The Scrollbar *must* be created first
|
|
||||||
self.vbar = Scrollbar(self.botframe)
|
|
||||||
self.vbar.pack({'fill': 'y', 'side': 'right'})
|
|
||||||
self.text = Text(self.botframe)
|
|
||||||
self.text.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
|
|
||||||
|
|
||||||
# Link Text widget and Scrollbar
|
|
||||||
self.text['yscrollcommand'] = (self.vbar, 'set')
|
|
||||||
self.vbar['command'] = (self.text, 'yview')
|
|
||||||
|
|
||||||
self.url = None
|
|
||||||
|
|
||||||
def load(self, url):
|
|
||||||
# Load a new URL into the window
|
|
||||||
fp, url = self.urlopen(url)
|
|
||||||
if not fp:
|
|
||||||
return
|
|
||||||
|
|
||||||
self.url = url
|
|
||||||
|
|
||||||
self.root.title(url)
|
|
||||||
|
|
||||||
self.entry.delete('0', 'end')
|
|
||||||
self.entry.insert('end', url)
|
|
||||||
|
|
||||||
self.text.delete('0.0', 'end')
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
if line[-2:] == '\r\n': line = line[:-2] + '\n'
|
|
||||||
self.text.insert('end', line)
|
|
||||||
self.root.update_idletasks()
|
|
||||||
|
|
||||||
fp.close()
|
|
||||||
|
|
||||||
def urlopen(self, url):
|
|
||||||
# Open a URL --
|
|
||||||
# return (fp, url) if successful
|
|
||||||
# display dialog and return (None, url) for errors
|
|
||||||
try:
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
except IOError, msg:
|
|
||||||
import types
|
|
||||||
if type(msg) == types.TupleType and len(msg) == 4:
|
|
||||||
if msg[1] == 302:
|
|
||||||
m = msg[3]
|
|
||||||
if m.has_key('location'):
|
|
||||||
url = m['location']
|
|
||||||
return self.urlopen(url)
|
|
||||||
elif m.has_key('uri'):
|
|
||||||
url = m['uri']
|
|
||||||
return self.urlopen(url)
|
|
||||||
self.errordialog(IOError, msg)
|
|
||||||
fp = None
|
|
||||||
return fp, url
|
|
||||||
|
|
||||||
def errordialog(self, exc, msg):
|
|
||||||
# Display an error dialog -- return when the user clicks OK
|
|
||||||
Dialog.Dialog(self.root, {
|
|
||||||
'text': str(msg),
|
|
||||||
'title': exc,
|
|
||||||
'bitmap': 'error',
|
|
||||||
'default': 0,
|
|
||||||
'strings': ('OK',),
|
|
||||||
})
|
|
||||||
|
|
||||||
def go(self):
|
|
||||||
# Start Tk main loop
|
|
||||||
self.root.mainloop()
|
|
||||||
|
|
||||||
def reload(self, *args):
|
|
||||||
# Callback for Reload button
|
|
||||||
if self.url:
|
|
||||||
self.load(self.url)
|
|
||||||
|
|
||||||
def loadit(self, *args):
|
|
||||||
# Callback for <Return> event in entry
|
|
||||||
self.load(self.entry.get())
|
|
||||||
|
|
||||||
def new_command(self):
|
|
||||||
# File/New...
|
|
||||||
Viewer(self.master)
|
|
||||||
|
|
||||||
def clone_command(self):
|
|
||||||
# File/Clone
|
|
||||||
v = Viewer(self.master)
|
|
||||||
v.load(self.url)
|
|
||||||
|
|
||||||
def open_command(self):
|
|
||||||
# File/Open...
|
|
||||||
print "File/Open...: Not implemented"
|
|
||||||
|
|
||||||
def close_command(self):
|
|
||||||
# File/Close
|
|
||||||
self.destroy()
|
|
||||||
|
|
||||||
def quit_command(self):
|
|
||||||
# File/Quit
|
|
||||||
self.root.quit()
|
|
||||||
|
|
||||||
def destroy(self):
|
|
||||||
# Destroy this window
|
|
||||||
self.root.destroy()
|
|
||||||
if self.master is not self.root and not self.master.children:
|
|
||||||
self.master.quit()
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,218 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www13.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
# - update display while reading
|
|
||||||
# - vertical scroll bar
|
|
||||||
# - rewritten as class
|
|
||||||
# - editable url entry and reload button
|
|
||||||
# - error dialog
|
|
||||||
# - menu bar; added 'master' option to constructor
|
|
||||||
# - Added HTML parser
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
import Dialog
|
|
||||||
import tkfmt
|
|
||||||
import htmllib
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
tk = Tk()
|
|
||||||
tk.withdraw()
|
|
||||||
viewer = Viewer(tk)
|
|
||||||
viewer.load(url)
|
|
||||||
viewer.go()
|
|
||||||
|
|
||||||
class Viewer:
|
|
||||||
|
|
||||||
def __init__(self, master = None):
|
|
||||||
# Create root window
|
|
||||||
if master is None:
|
|
||||||
self.root = self.master = Tk()
|
|
||||||
else:
|
|
||||||
self.master = master
|
|
||||||
self.root = Toplevel(self.master)
|
|
||||||
self.root.minsize(1, 1)
|
|
||||||
|
|
||||||
# Create menu bar
|
|
||||||
self.mbar = Frame(self.root,
|
|
||||||
{'relief': 'raised',
|
|
||||||
'border': 2})
|
|
||||||
self.mbar.pack({'fill': 'x'})
|
|
||||||
|
|
||||||
# Create File menu
|
|
||||||
self.filebutton = Menubutton(self.mbar, {'text': 'File'})
|
|
||||||
self.filebutton.pack({'side': 'left'})
|
|
||||||
|
|
||||||
self.filemenu = Menu(self.filebutton)
|
|
||||||
self.filebutton['menu'] = self.filemenu
|
|
||||||
|
|
||||||
# Create Edit menu
|
|
||||||
self.editbutton = Menubutton(self.mbar, {'text': 'Edit'})
|
|
||||||
self.editbutton.pack({'side': 'left'})
|
|
||||||
|
|
||||||
self.editmenu = Menu(self.editbutton)
|
|
||||||
self.editbutton['menu'] = self.editmenu
|
|
||||||
|
|
||||||
# Magic so you can swipe from one button to the next
|
|
||||||
self.mbar.tk_menuBar(self.filebutton, self.editbutton)
|
|
||||||
|
|
||||||
# Populate File menu
|
|
||||||
self.filemenu.add('command', {'label': 'New',
|
|
||||||
'command': self.new_command})
|
|
||||||
self.filemenu.add('command', {'label': 'Open...',
|
|
||||||
'command': self.open_command})
|
|
||||||
self.filemenu.add('command', {'label': 'Clone',
|
|
||||||
'command': self.clone_command})
|
|
||||||
self.filemenu.add('separator')
|
|
||||||
self.filemenu.add('command', {'label': 'Close',
|
|
||||||
'command': self.close_command})
|
|
||||||
self.filemenu.add('command', {'label': 'Quit',
|
|
||||||
'command': self.quit_command})
|
|
||||||
|
|
||||||
# Populate Edit menu
|
|
||||||
pass
|
|
||||||
|
|
||||||
# Create topframe for the entry and button
|
|
||||||
self.topframe = Frame(self.root)
|
|
||||||
self.topframe.pack({'fill': 'x'})
|
|
||||||
|
|
||||||
# Create a label in front of the entry
|
|
||||||
self.urllabel = Label(self.topframe, {'text': 'URL:'})
|
|
||||||
self.urllabel.pack({'side': 'left'})
|
|
||||||
|
|
||||||
# Create the entry containing the URL
|
|
||||||
self.entry = Entry(self.topframe,
|
|
||||||
{'relief': 'sunken', 'border': 2})
|
|
||||||
self.entry.pack({'side': 'left', 'fill': 'x', 'expand': 1})
|
|
||||||
self.entry.bind('<Return>', self.loadit)
|
|
||||||
|
|
||||||
# Create the button
|
|
||||||
self.reload = Button(self.topframe,
|
|
||||||
{'text': 'Reload',
|
|
||||||
'command': self.reload})
|
|
||||||
self.reload.pack({'side': 'right'})
|
|
||||||
|
|
||||||
# Create botframe for the text and scrollbar
|
|
||||||
self.botframe = Frame(self.root)
|
|
||||||
self.botframe.pack({'fill': 'both', 'expand': 1})
|
|
||||||
|
|
||||||
# The Scrollbar *must* be created first
|
|
||||||
self.vbar = Scrollbar(self.botframe)
|
|
||||||
self.vbar.pack({'fill': 'y', 'side': 'right'})
|
|
||||||
self.text = Text(self.botframe)
|
|
||||||
self.text.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
|
|
||||||
|
|
||||||
# Link Text widget and Scrollbar
|
|
||||||
self.text['yscrollcommand'] = (self.vbar, 'set')
|
|
||||||
self.vbar['command'] = (self.text, 'yview')
|
|
||||||
|
|
||||||
self.url = None
|
|
||||||
|
|
||||||
def load(self, url):
|
|
||||||
# Load a new URL into the window
|
|
||||||
fp, url = self.urlopen(url)
|
|
||||||
if not fp:
|
|
||||||
return
|
|
||||||
|
|
||||||
self.url = url
|
|
||||||
|
|
||||||
self.root.title(url)
|
|
||||||
|
|
||||||
self.entry.delete('0', 'end')
|
|
||||||
self.entry.insert('end', url)
|
|
||||||
|
|
||||||
self.text.delete('0.0', 'end')
|
|
||||||
|
|
||||||
f = tkfmt.TkFormatter(self.text)
|
|
||||||
p = htmllib.FormattingParser(f, htmllib.X11Stylesheet)
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
if line[-2:] == '\r\n': line = line[:-2] + '\n'
|
|
||||||
p.feed(line)
|
|
||||||
self.root.update_idletasks()
|
|
||||||
|
|
||||||
p.close()
|
|
||||||
|
|
||||||
fp.close()
|
|
||||||
|
|
||||||
def urlopen(self, url):
|
|
||||||
# Open a URL --
|
|
||||||
# return (fp, url) if successful
|
|
||||||
# display dialog and return (None, url) for errors
|
|
||||||
try:
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
except IOError, msg:
|
|
||||||
import types
|
|
||||||
if type(msg) == types.TupleType and len(msg) == 4:
|
|
||||||
if msg[1] == 302:
|
|
||||||
m = msg[3]
|
|
||||||
if m.has_key('location'):
|
|
||||||
url = m['location']
|
|
||||||
return self.urlopen(url)
|
|
||||||
elif m.has_key('uri'):
|
|
||||||
url = m['uri']
|
|
||||||
return self.urlopen(url)
|
|
||||||
self.errordialog(IOError, msg)
|
|
||||||
fp = None
|
|
||||||
return fp, url
|
|
||||||
|
|
||||||
def errordialog(self, exc, msg):
|
|
||||||
# Display an error dialog -- return when the user clicks OK
|
|
||||||
Dialog.Dialog(self.root, {
|
|
||||||
'text': str(msg),
|
|
||||||
'title': exc,
|
|
||||||
'bitmap': 'error',
|
|
||||||
'default': 0,
|
|
||||||
'strings': ('OK',),
|
|
||||||
})
|
|
||||||
|
|
||||||
def go(self):
|
|
||||||
# Start Tk main loop
|
|
||||||
self.root.mainloop()
|
|
||||||
|
|
||||||
def reload(self, *args):
|
|
||||||
# Callback for Reload button
|
|
||||||
if self.url:
|
|
||||||
self.load(self.url)
|
|
||||||
|
|
||||||
def loadit(self, *args):
|
|
||||||
# Callback for <Return> event in entry
|
|
||||||
self.load(self.entry.get())
|
|
||||||
|
|
||||||
def new_command(self):
|
|
||||||
# File/New...
|
|
||||||
Viewer(self.master)
|
|
||||||
|
|
||||||
def clone_command(self):
|
|
||||||
# File/Clone
|
|
||||||
v = Viewer(self.master)
|
|
||||||
v.load(self.url)
|
|
||||||
|
|
||||||
def open_command(self):
|
|
||||||
# File/Open...
|
|
||||||
print "File/Open...: Not implemented"
|
|
||||||
|
|
||||||
def close_command(self):
|
|
||||||
# File/Close
|
|
||||||
self.destroy()
|
|
||||||
|
|
||||||
def quit_command(self):
|
|
||||||
# File/Quit
|
|
||||||
self.root.quit()
|
|
||||||
|
|
||||||
def destroy(self):
|
|
||||||
# Destroy this window
|
|
||||||
self.root.destroy()
|
|
||||||
if self.master is not self.root and not self.master.children:
|
|
||||||
self.master.quit()
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,35 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www2.py -- print the contents of a URL on stdout
|
|
||||||
# - error checking
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
import types
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = my_urlopen(url)
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
sys.stdout.write(line)
|
|
||||||
|
|
||||||
def my_urlopen(url):
|
|
||||||
try:
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
return fp
|
|
||||||
except IOError, msg:
|
|
||||||
if type(msg) == types.TupleType and len(msg) == 4:
|
|
||||||
print msg[:3]
|
|
||||||
m = msg[3]
|
|
||||||
for line in m.headers:
|
|
||||||
sys.stdout.write(line)
|
|
||||||
else:
|
|
||||||
print msg
|
|
||||||
sys.exit(1)
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,46 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www3.py -- print the contents of a URL on stdout
|
|
||||||
# - error checking
|
|
||||||
# - Error 302 handling
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
import types
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = my_urlopen(url)
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
sys.stdout.write(line)
|
|
||||||
|
|
||||||
def my_urlopen(url):
|
|
||||||
try:
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
return fp
|
|
||||||
except IOError, msg:
|
|
||||||
if type(msg) == types.TupleType and len(msg) == 4:
|
|
||||||
m = msg[3]
|
|
||||||
if msg[1] == 302:
|
|
||||||
if m.has_key('location'):
|
|
||||||
url = m['location']
|
|
||||||
print 'Location:', url
|
|
||||||
return my_urlopen(url)
|
|
||||||
elif m.has_key('uri'):
|
|
||||||
url = m['uri']
|
|
||||||
print 'URI:', url
|
|
||||||
return my_urlopen(url)
|
|
||||||
print '(Error 302 w/o Location/URI header???)'
|
|
||||||
print msg[:3]
|
|
||||||
for line in m.headers:
|
|
||||||
sys.stdout.write(line)
|
|
||||||
else:
|
|
||||||
print msg
|
|
||||||
sys.exit(1)
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,26 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www4.py -- display the contents of a URL in a Text widget
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
|
|
||||||
text = Text() # Create text widget
|
|
||||||
text.pack() # Realize it
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
text.insert('end', line) # Append line to text widget
|
|
||||||
|
|
||||||
text.mainloop() # Start Tk main loop
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,29 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www5.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
|
|
||||||
root = Tk()
|
|
||||||
root.title(url) # Set window manager title
|
|
||||||
text = Text(root)
|
|
||||||
text.pack()
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
text.insert('end', line)
|
|
||||||
|
|
||||||
text.mainloop()
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,31 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www6.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
|
|
||||||
root = Tk()
|
|
||||||
root.title(url)
|
|
||||||
root.minsize(1, 1) # Set minimum size
|
|
||||||
text = Text(root)
|
|
||||||
text.pack({'expand': 1, 'fill': 'both'}) # Expand into available space
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
text.insert('end', line)
|
|
||||||
|
|
||||||
root.mainloop() # Start Tk main loop (for root!)
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,33 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www7.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
# - update display while reading
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
|
|
||||||
root = Tk()
|
|
||||||
root.title(url)
|
|
||||||
root.minsize(1, 1)
|
|
||||||
text = Text(root)
|
|
||||||
text.pack({'expand': 1, 'fill': 'both'})
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
text.insert('end', line)
|
|
||||||
root.update_idletasks() # Update display
|
|
||||||
|
|
||||||
root.mainloop()
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,43 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www8.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
# - update display while reading
|
|
||||||
# - vertical scroll bar
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
|
|
||||||
# Create root window
|
|
||||||
root = Tk()
|
|
||||||
root.title(url)
|
|
||||||
root.minsize(1, 1)
|
|
||||||
|
|
||||||
# The Scrollbar *must* be created first -- this is magic for me :-(
|
|
||||||
vbar = Scrollbar(root)
|
|
||||||
vbar.pack({'fill': 'y', 'side': 'right'})
|
|
||||||
text = Text(root, {'yscrollcommand': (vbar, 'set')})
|
|
||||||
text.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
|
|
||||||
|
|
||||||
# Link Text widget and Scrollbar -- this is magic for you :-)
|
|
||||||
##text['yscrollcommand'] = (vbar, 'set')
|
|
||||||
vbar['command'] = (text, 'yview')
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
text.insert('end', line)
|
|
||||||
root.update_idletasks()
|
|
||||||
|
|
||||||
root.mainloop()
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,60 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# www9.py -- display the contents of a URL in a Text widget
|
|
||||||
# - set window title
|
|
||||||
# - make window resizable
|
|
||||||
# - update display while reading
|
|
||||||
# - vertical scroll bar
|
|
||||||
# - rewritten as class
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import urllib
|
|
||||||
from Tkinter import *
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) != 2 or sys.argv[1][:1] == '-':
|
|
||||||
print "Usage:", sys.argv[0], "url"
|
|
||||||
sys.exit(2)
|
|
||||||
url = sys.argv[1]
|
|
||||||
viewer = Viewer()
|
|
||||||
viewer.load(url)
|
|
||||||
viewer.go()
|
|
||||||
|
|
||||||
class Viewer:
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
# Create root window
|
|
||||||
self.root = Tk()
|
|
||||||
self.root.minsize(1, 1)
|
|
||||||
|
|
||||||
# The Scrollbar *must* be created first
|
|
||||||
self.vbar = Scrollbar(self.root)
|
|
||||||
self.vbar.pack({'fill': 'y', 'side': 'right'})
|
|
||||||
self.text = Text(self.root)
|
|
||||||
self.text.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
|
|
||||||
|
|
||||||
# Link Text widget and Scrollbar
|
|
||||||
self.text['yscrollcommand'] = (self.vbar, 'set')
|
|
||||||
self.vbar['command'] = (self.text, 'yview')
|
|
||||||
|
|
||||||
def load(self, url):
|
|
||||||
# Load a new URL into the window
|
|
||||||
fp = urllib.urlopen(url)
|
|
||||||
|
|
||||||
self.root.title(url)
|
|
||||||
|
|
||||||
self.text.delete('0.0', 'end')
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line: break
|
|
||||||
self.text.insert('end', line)
|
|
||||||
self.root.update_idletasks()
|
|
||||||
|
|
||||||
fp.close()
|
|
||||||
|
|
||||||
def go(self):
|
|
||||||
# Start Tk main loop
|
|
||||||
self.root.mainloop()
|
|
||||||
|
|
||||||
main()
|
|
Loading…
Reference in New Issue