| # 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() |