1 # Widget to display a man page

     2 

     3 import re

     4 from Tkinter import *

     5 from Tkinter import _tkinter

     6 from ScrolledText import ScrolledText

     7 

     8 # XXX These fonts may have to be changed to match your system

     9 BOLDFONT = '*-Courier-Bold-R-Normal-*-120-*'

    10 ITALICFONT = '*-Courier-Medium-O-Normal-*-120-*'

    11 

    12 # XXX Recognizing footers is system dependent

    13 # (This one works for IRIX 5.2 and Solaris 2.2)

    14 footerprog = re.compile(

    15         '^     Page [1-9][0-9]*[ \t]+\|^.*Last change:.*[1-9][0-9]*\n')

    16 emptyprog = re.compile('^[ \t]*\n')

    17 ulprog = re.compile('^[ \t]*[Xv!_][Xv!_ \t]*\n')

    18 

    19 # Basic Man Page class -- does not disable editing

    20 class EditableManPage(ScrolledText):

    21 

    22     # Initialize instance

    23     def __init__(self, master=None, **cnf):

    24         # Initialize base class

    25         apply(ScrolledText.__init__, (self, master), cnf)

    26 

    27         # Define tags for formatting styles

    28         self.tag_config('X', underline=1)

    29         self.tag_config('!', font=BOLDFONT)

    30         self.tag_config('_', font=ITALICFONT)

    31 

    32         # Set state to idle

    33         self.fp = None

    34         self.lineno = 0

    35 

    36     # Test whether we are busy parsing a file

    37     def busy(self):

    38         return self.fp != None

    39 

    40     # Ensure we're not busy

    41     def kill(self):

    42         if self.busy():

    43             self._endparser()

    44 

    45     # Parse a file, in the background

    46     def asyncparsefile(self, fp):

    47         self._startparser(fp)

    48         self.tk.createfilehandler(fp, _tkinter.READABLE,

    49                                   self._filehandler)

    50 

    51     parsefile = asyncparsefile      # Alias

    52 

    53     # I/O handler used by background parsing

    54     def _filehandler(self, fp, mask):

    55         nextline = self.fp.readline()

    56         if not nextline:

    57             self._endparser()

    58             return

    59         self._parseline(nextline)

    60 

    61     # Parse a file, now (cannot be aborted)

    62     def syncparsefile(self, fp):

    63         from select import select

    64         def avail(fp=fp, tout=0.0, select=select):

    65             return select([fp], [], [], tout)[0]

    66         height = self.getint(self['height'])

    67         self._startparser(fp)

    68         while 1:

    69             nextline = fp.readline()

    70             if not nextline:

    71                 break

    72             self._parseline(nextline)

    73         self._endparser()

    74 

    75     # Initialize parsing from a particular file -- must not be busy

    76     def _startparser(self, fp):

    77         if self.busy():

    78             raise RuntimeError, 'startparser: still busy'

    79         fp.fileno()             # Test for file-ness

    80         self.fp = fp

    81         self.lineno = 0

    82         self.ok = 0

    83         self.empty = 0

    84         self.buffer = None

    85         savestate = self['state']

    86         self['state'] = NORMAL

    87         self.delete('1.0', END)

    88         self['state'] = savestate

    89 

    90     # End parsing -- must be busy, need not be at EOF

    91     def _endparser(self):

    92         if not self.busy():

    93             raise RuntimeError, 'endparser: not busy'

    94         if self.buffer:

    95             self._parseline('')

    96         try:

    97             self.tk.deletefilehandler(self.fp)

    98         except TclError, msg:

    99             pass

   100         self.fp.close()

   101         self.fp = None

   102         del self.ok, self.empty, self.buffer

   103 

   104     # Parse a single line

   105     def _parseline(self, nextline):

   106         if not self.buffer:

   107             # Save this line -- we need one line read-ahead

   108             self.buffer = nextline

   109             return

   110         if emptyprog.match(self.buffer) >= 0:

   111             # Buffered line was empty -- set a flag

   112             self.empty = 1

   113             self.buffer = nextline

   114             return

   115         textline = self.buffer

   116         if ulprog.match(nextline) >= 0:

   117             # Next line is properties for buffered line

   118             propline = nextline

   119             self.buffer = None

   120         else:

   121             # Next line is read-ahead

   122             propline = None

   123             self.buffer = nextline

   124         if not self.ok:

   125             # First non blank line after footer must be header

   126             # -- skip that too

   127             self.ok = 1

   128             self.empty = 0

   129             return

   130         if footerprog.match(textline) >= 0:

   131             # Footer -- start skipping until next non-blank line

   132             self.ok = 0

   133             self.empty = 0

   134             return

   135         savestate = self['state']

   136         self['state'] = NORMAL

   137         if TkVersion >= 4.0:

   138             self.mark_set('insert', 'end-1c')

   139         else:

   140             self.mark_set('insert', END)

   141         if self.empty:

   142             # One or more previous lines were empty

   143             # -- insert one blank line in the text

   144             self._insert_prop('\n')

   145             self.lineno = self.lineno + 1

   146             self.empty = 0

   147         if not propline:

   148             # No properties

   149             self._insert_prop(textline)

   150         else:

   151             # Search for properties

   152             p = ''

   153             j = 0

   154             for i in range(min(len(propline), len(textline))):

   155                 if propline[i] != p:

   156                     if j < i:

   157                         self._insert_prop(textline[j:i], p)

   158                         j = i

   159                     p = propline[i]

   160             self._insert_prop(textline[j:])

   161         self.lineno = self.lineno + 1

   162         self['state'] = savestate

   163 

   164     # Insert a string at the end, with at most one property (tag)

   165     def _insert_prop(self, str, prop = ' '):

   166         here = self.index(AtInsert())

   167         self.insert(AtInsert(), str)

   168         if TkVersion <= 4.0:

   169             tags = self.tag_names(here)

   170             for tag in tags:

   171                 self.tag_remove(tag, here, AtInsert())

   172         if prop != ' ':

   173             self.tag_add(prop, here, AtInsert())

   174 

   175 # Readonly Man Page class -- disables editing, otherwise the same

   176 class ReadonlyManPage(EditableManPage):

   177 

   178     # Initialize instance

   179     def __init__(self, master=None, **cnf):

   180         cnf['state'] = DISABLED

   181         apply(EditableManPage.__init__, (self, master), cnf)

   182 

   183 # Alias

   184 ManPage = ReadonlyManPage

   185 

   186 # Test program.

   187 # usage: ManPage [manpage]; or ManPage [-f] file

   188 # -f means that the file is nroff -man output run through ul -i

   189 def test():

   190     import os

   191     import sys

   192     # XXX This directory may be different on your system

   193     MANDIR = '/usr/local/man/mann'

   194     DEFAULTPAGE = 'Tcl'

   195     formatted = 0

   196     if sys.argv[1:] and sys.argv[1] == '-f':

   197         formatted = 1

   198         del sys.argv[1]

   199     if sys.argv[1:]:

   200         name = sys.argv[1]

   201     else:

   202         name = DEFAULTPAGE

   203     if not formatted:

   204         if name[-2:-1] != '.':

   205             name = name + '.n'

   206         name = os.path.join(MANDIR, name)

   207     root = Tk()

   208     root.minsize(1, 1)

   209     manpage = ManPage(root, relief=SUNKEN, borderwidth=2)

   210     manpage.pack(expand=1, fill=BOTH)

   211     if formatted:

   212         fp = open(name, 'r')

   213     else:

   214         fp = os.popen('nroff -man %s | ul -i' % name, 'r')

   215     manpage.parsefile(fp)

   216     root.mainloop()

   217 

   218 # Run the test program when called as a script

   219 if __name__ == '__main__':

   220     test()