| Current File : //proc/thread-self/root/lib64/python2.7/Demo/tkinter/guido/ManPage.py |
# Widget to display a man page
import re
from Tkinter import *
from Tkinter import _tkinter
from ScrolledText import ScrolledText
# XXX These fonts may have to be changed to match your system
BOLDFONT = '*-Courier-Bold-R-Normal-*-120-*'
ITALICFONT = '*-Courier-Medium-O-Normal-*-120-*'
# XXX Recognizing footers is system dependent
# (This one works for IRIX 5.2 and Solaris 2.2)
footerprog = re.compile(
'^ Page [1-9][0-9]*[ \t]+\|^.*Last change:.*[1-9][0-9]*\n')
emptyprog = re.compile('^[ \t]*\n')
ulprog = re.compile('^[ \t]*[Xv!_][Xv!_ \t]*\n')
# Basic Man Page class -- does not disable editing
class EditableManPage(ScrolledText):
# Initialize instance
def __init__(self, master=None, **cnf):
# Initialize base class
apply(ScrolledText.__init__, (self, master), cnf)
# Define tags for formatting styles
self.tag_config('X', underline=1)
self.tag_config('!', font=BOLDFONT)
self.tag_config('_', font=ITALICFONT)
# Set state to idle
self.fp = None
self.lineno = 0
# Test whether we are busy parsing a file
def busy(self):
return self.fp != None
# Ensure we're not busy
def kill(self):
if self.busy():
self._endparser()
# Parse a file, in the background
def asyncparsefile(self, fp):
self._startparser(fp)
self.tk.createfilehandler(fp, _tkinter.READABLE,
self._filehandler)
parsefile = asyncparsefile # Alias
# I/O handler used by background parsing
def _filehandler(self, fp, mask):
nextline = self.fp.readline()
if not nextline:
self._endparser()
return
self._parseline(nextline)
# Parse a file, now (cannot be aborted)
def syncparsefile(self, fp):
from select import select
def avail(fp=fp, tout=0.0, select=select):
return select([fp], [], [], tout)[0]
height = self.getint(self['height'])
self._startparser(fp)
while 1:
nextline = fp.readline()
if not nextline:
break
self._parseline(nextline)
self._endparser()
# Initialize parsing from a particular file -- must not be busy
def _startparser(self, fp):
if self.busy():
raise RuntimeError, 'startparser: still busy'
fp.fileno() # Test for file-ness
self.fp = fp
self.lineno = 0
self.ok = 0
self.empty = 0
self.buffer = None
savestate = self['state']
self['state'] = NORMAL
self.delete('1.0', END)
self['state'] = savestate
# End parsing -- must be busy, need not be at EOF
def _endparser(self):
if not self.busy():
raise RuntimeError, 'endparser: not busy'
if self.buffer:
self._parseline('')
try:
self.tk.deletefilehandler(self.fp)
except TclError, msg:
pass
self.fp.close()
self.fp = None
del self.ok, self.empty, self.buffer
# Parse a single line
def _parseline(self, nextline):
if not self.buffer:
# Save this line -- we need one line read-ahead
self.buffer = nextline
return
if emptyprog.match(self.buffer) >= 0:
# Buffered line was empty -- set a flag
self.empty = 1
self.buffer = nextline
return
textline = self.buffer
if ulprog.match(nextline) >= 0:
# Next line is properties for buffered line
propline = nextline
self.buffer = None
else:
# Next line is read-ahead
propline = None
self.buffer = nextline
if not self.ok:
# First non blank line after footer must be header
# -- skip that too
self.ok = 1
self.empty = 0
return
if footerprog.match(textline) >= 0:
# Footer -- start skipping until next non-blank line
self.ok = 0
self.empty = 0
return
savestate = self['state']
self['state'] = NORMAL
if TkVersion >= 4.0:
self.mark_set('insert', 'end-1c')
else:
self.mark_set('insert', END)
if self.empty:
# One or more previous lines were empty
# -- insert one blank line in the text
self._insert_prop('\n')
self.lineno = self.lineno + 1
self.empty = 0
if not propline:
# No properties
self._insert_prop(textline)
else:
# Search for properties
p = ''
j = 0
for i in range(min(len(propline), len(textline))):
if propline[i] != p:
if j < i:
self._insert_prop(textline[j:i], p)
j = i
p = propline[i]
self._insert_prop(textline[j:])
self.lineno = self.lineno + 1
self['state'] = savestate
# Insert a string at the end, with at most one property (tag)
def _insert_prop(self, str, prop = ' '):
here = self.index(AtInsert())
self.insert(AtInsert(), str)
if TkVersion <= 4.0:
tags = self.tag_names(here)
for tag in tags:
self.tag_remove(tag, here, AtInsert())
if prop != ' ':
self.tag_add(prop, here, AtInsert())
# Readonly Man Page class -- disables editing, otherwise the same
class ReadonlyManPage(EditableManPage):
# Initialize instance
def __init__(self, master=None, **cnf):
cnf['state'] = DISABLED
apply(EditableManPage.__init__, (self, master), cnf)
# Alias
ManPage = ReadonlyManPage
# Test program.
# usage: ManPage [manpage]; or ManPage [-f] file
# -f means that the file is nroff -man output run through ul -i
def test():
import os
import sys
# XXX This directory may be different on your system
MANDIR = '/usr/local/man/mann'
DEFAULTPAGE = 'Tcl'
formatted = 0
if sys.argv[1:] and sys.argv[1] == '-f':
formatted = 1
del sys.argv[1]
if sys.argv[1:]:
name = sys.argv[1]
else:
name = DEFAULTPAGE
if not formatted:
if name[-2:-1] != '.':
name = name + '.n'
name = os.path.join(MANDIR, name)
root = Tk()
root.minsize(1, 1)
manpage = ManPage(root, relief=SUNKEN, borderwidth=2)
manpage.pack(expand=1, fill=BOTH)
if formatted:
fp = open(name, 'r')
else:
fp = os.popen('nroff -man %s | ul -i' % name, 'r')
manpage.parsefile(fp)
root.mainloop()
# Run the test program when called as a script
if __name__ == '__main__':
test()