--- /dev/null
+#! /usr/local/python
+
+testlabels = 'Name', 'Address', 'City', 'Country', 'Comments'
+
+def main():
+ import stdwin
+ from WindowParent import WindowParent, MainLoop
+ from FormSplit import FormSplit
+ from Buttons import Label
+ from TextEdit import TextEdit
+ #
+ stdwin.setdefscrollbars(0, 0)
+ #
+ w = WindowParent().create('FormTest', (0, 0))
+ f = FormSplit().create(w)
+ #
+ h, v = 0, 0
+ for label in testlabels:
+ f.placenext(h, v)
+ lbl = Label().definetext(f, label)
+ f.placenext(h + 100, v)
+ txt = TextEdit().createboxed(f, (40, 2), (2, 2))
+ #txt = TextEdit().create(f, (40, 2))
+ v = v + 2*stdwin.lineheight() + 10
+ #
+ w.realize()
+ #
+ MainLoop()
+
+main()
--- /dev/null
+Contents of this directory:
+
+FormTest.py Show how a form can be built to enter multiple fields
+RadioGroups.py Show how to use multiple groups of radio buttons
+TestCSplit.py Test CSplit widget (a clock-like split)
+TestDirList.py Test DirList widget (lists directory contents)
+TestFormSplit.py Test FormSplit widget (arbitrary grouping)
+TestSched.py Test WindowSched widget (event scheduling)
+TestTextEdit.py Test TextEdit widget (probably doen't work any more)
+ibrowse/ An Emacs info file browser
+clock.py A simple clock, with alarm
+lpwin.py Watch line printer queues
+microedit.py The smallest window editor
+miniedit.py A small multi-window editor
+python.py A window interface to the Python interpreter
+wdiff.py A window-based directory diff
--- /dev/null
+#! /usr/local/python
+
+# radiogroups.py
+#
+# Demonstrate multiple groups of radio buttons
+
+import stdwin
+from Buttons import *
+from WindowParent import WindowParent, MainLoop
+from HVSplit import HSplit, VSplit
+
+def main():
+ #
+ # Create the widget hierarchy, top-down
+ #
+ # 1. Create the window
+ #
+ window = WindowParent().create('Radio Groups', (0, 0))
+ #
+ # 2. Create a horizontal split to contain the groups
+ #
+ topsplit = HSplit().create(window)
+ #
+ # 3. Create vertical splits, one for each group
+ #
+ group1 = VSplit().create(topsplit)
+ group2 = VSplit().create(topsplit)
+ group3 = VSplit().create(topsplit)
+ #
+ # 4. Create individual radio buttons, each in their own split
+ #
+ b11 = RadioButton().definetext(group1, 'Group 1 button 1')
+ b12 = RadioButton().definetext(group1, 'Group 1 button 2')
+ b13 = RadioButton().definetext(group1, 'Group 1 button 3')
+ #
+ b21 = RadioButton().definetext(group2, 'Group 2 button 1')
+ b22 = RadioButton().definetext(group2, 'Group 2 button 2')
+ b23 = RadioButton().definetext(group2, 'Group 2 button 3')
+ #
+ b31 = RadioButton().definetext(group3, 'Group 3 button 1')
+ b32 = RadioButton().definetext(group3, 'Group 3 button 2')
+ b33 = RadioButton().definetext(group3, 'Group 3 button 3')
+ #
+ # 5. Define the grouping for the radio buttons.
+ # Note: this doesn't have to be the same as the
+ # grouping is splits (although it usually is).
+ # Also set the 'hook' procedure for each button
+ #
+ list1 = [b11, b12, b13]
+ list2 = [b21, b22, b23]
+ list3 = [b31, b32, b33]
+ #
+ for b in list1:
+ b.group = list1
+ b.on_hook = myhook
+ for b in list2:
+ b.group = list2
+ b.on_hook = myhook
+ for b in list3:
+ b.group = list3
+ b.on_hook = myhook
+ #
+ # 6. Select a default button in each group
+ #
+ b11.select(1)
+ b22.select(1)
+ b33.select(1)
+ #
+ # 6. Realize the window
+ #
+ window.realize()
+ #
+ # 7. Dispatch events until the window is closed
+ #
+ MainLoop()
+ #
+ # 8. Report final selections
+ #
+ print 'You selected the following choices:'
+ if b11.selected: print '1.1'
+ if b12.selected: print '1.2'
+ if b13.selected: print '1.3'
+ if b21.selected: print '2.1'
+ if b22.selected: print '2.2'
+ if b23.selected: print '2.3'
+ if b31.selected: print '3.1'
+ if b32.selected: print '3.2'
+ if b33.selected: print '3.3'
+
+
+# My 'hook' procedure
+# This is placed as 'hook' attribute on each button.
+# The example just prints the title of the selected button.
+#
+def myhook(self):
+ print 'Selected:', self.text
+
+main()
--- /dev/null
+#! /usr/local/python
+
+# TestCSplit
+
+import stdwin
+from WindowParent import WindowParent, MainLoop
+from Buttons import PushButton
+
+def main(n):
+ from CSplit import CSplit
+ #
+ stdwin.setdefscrollbars(0, 0)
+ #
+ the_window = WindowParent().create('TestCSplit', (0, 0))
+ the_csplit = CSplit().create(the_window)
+ #
+ for i in range(n):
+ the_child = PushButton().define(the_csplit)
+ the_child.settext(`(i+n-1)%n+1`)
+ #
+ the_window.realize()
+ #
+ MainLoop()
+
+main(12)
--- /dev/null
+#! /usr/local/python
+
+# TestDirList
+
+from DirList import DirListWindow
+from WindowParent import MainLoop
+
+def main():
+ import sys
+ args = sys.argv[1:]
+ if not args:
+ args = ['.']
+ # Mac: args = [':']
+ for arg in args:
+ w = DirListWindow().create(arg)
+ MainLoop()
+
+main()
--- /dev/null
+#! /usr/local/python
+
+# TestFormSplit
+
+import stdwin
+from WindowParent import WindowParent, MainLoop
+from Buttons import PushButton
+
+def main(n):
+ from FormSplit import FormSplit
+ #
+ stdwin.setdefscrollbars(1, 1)
+ #
+ the_window = WindowParent().create('TestFormSplit', (0, 0))
+ the_form = FormSplit().create(the_window)
+ #
+ for i in range(n):
+ if i % 3 == 0:
+ the_form.placenext(i*40, 0)
+ the_child = PushButton().define(the_form)
+ the_child.settext('XXX-' + `i` + '-YYY')
+ #
+ the_window.realize()
+ #
+ MainLoop()
+
+main(6)
--- /dev/null
+#! /usr/local/python
+
+# TestSched
+
+import stdwin
+from WindowParent import WindowParent, MainLoop
+import WindowSched
+from Buttons import PushButton
+
+def my_ringer(child):
+ child.id = None
+ stdwin.fleep()
+
+def my_hook(child):
+ # schedule for the bell to ring in N seconds; cancel previous
+ if child.my_id:
+ WindowSched.cancel(child.my_id)
+ child.my_id = \
+ WindowSched.enter(child.my_number*1000, 0, my_ringer, child)
+
+def main(n):
+ from CSplit import CSplit
+
+ window = WindowParent().create('TestSched', (0, 0))
+ csplit = CSplit().create(window)
+
+ for i in range(n):
+ child = PushButton().define(csplit)
+ child.my_number = i
+ child.my_id = None
+ child.settext(`(i+n-1)%n+1`)
+ child.hook = my_hook
+
+ window.realize()
+
+ WindowSched.run()
+
+main(12)
--- /dev/null
+#! /usr/local/python
+
+# Test TextEdit widgets
+
+def main():
+ from TextEdit import TextEdit
+ from WindowParent import WindowParent, MainLoop
+ w = WindowParent().create('Test TextEdit', (0, 0))
+ t = TextEdit().create(w, (40, 4))
+ w.realize()
+ MainLoop()
+
+main()
--- /dev/null
+#! /usr/local/python
+
+# 'clock' -- A simple alarm clock
+
+# The alarm can be set at 5 minute intervals on a 12 hour basis.
+# It is controlled with the mouse:
+# - Click and drag around the circle to set the alarm.
+# - Click far outside the circle to clear the alarm.
+# - Click near the center to set the alarm at the last time set.
+# The alarm time is indicated by a small triangle just outside the circle,
+# and also by a digital time at the bottom.
+# The indicators disappear when the alarm is not set.
+# When the alarm goes off, it beeps every minute for five minutes,
+# and the clock turns into inverse video.
+# Click or activate the window to turn the ringing off.
+
+import stdwin
+from stdwinevents import WE_MOUSE_DOWN, WE_MOUSE_MOVE, WE_MOUSE_UP, \
+ WE_TIMER, WE_DRAW, WE_SIZE, WE_CLOSE, WE_ACTIVATE
+import mainloop
+import time
+from math import sin, cos, atan2, pi, sqrt
+
+DEFWIDTH, DEFHEIGHT = 200, 200
+
+MOUSE_EVENTS = (WE_MOUSE_DOWN, WE_MOUSE_MOVE, WE_MOUSE_UP)
+ORIGIN = 0, 0
+FARAWAY = 2000, 2000
+EVERYWHERE = ORIGIN, FARAWAY
+
+# TZDIFF = 5*3600 # THINK C 3.0 returns UCT if local time is EST
+TZDIFF = 0 # THINK C 4.0 always returns local time
+
+
+def main():
+ win = makewindow()
+ del win
+ mainloop.mainloop()
+
+def makewindow():
+ stdwin.setdefwinsize(DEFWIDTH, DEFHEIGHT + stdwin.lineheight())
+ win = stdwin.open('clock')
+ setdimensions(win)
+ win.set = 1 # True when alarm is set
+ win.time = 11*60 + 40 # Time when alarm must go off
+ win.ring = 0 # True when alarm is ringing
+ win.dispatch = cdispatch
+ mainloop.register(win)
+ settimer(win)
+ return win
+
+def cdispatch(event):
+ type, win, detail = event
+ if type == WE_DRAW:
+ drawproc(win, detail)
+ elif type == WE_TIMER:
+ settimer(win)
+ drawproc(win, EVERYWHERE)
+ elif type in MOUSE_EVENTS:
+ mouseclick(win, type, detail)
+ elif type == WE_ACTIVATE:
+ if win.ring:
+ # Turn the ringing off
+ win.ring = 0
+ win.begindrawing().invert(win.mainarea)
+ elif type == WE_SIZE:
+ win.change(EVERYWHERE)
+ setdimensions(win)
+ elif type == WE_CLOSE:
+ mainloop.unregister(win)
+
+def setdimensions(win):
+ width, height = win.getwinsize()
+ height = height - stdwin.lineheight()
+ if width < height: size = width
+ else: size = height
+ halfwidth = width/2
+ halfheight = height/2
+ win.center = halfwidth, halfheight
+ win.radius = size*45/100
+ win.width = width
+ win.height = height
+ win.corner = width, height
+ win.mainarea = ORIGIN, win.corner
+ win.lineheight = stdwin.lineheight()
+ win.farcorner = width, height + win.lineheight
+ win.statusarea = (0, height), win.farcorner
+ win.fullarea = ORIGIN, win.farcorner
+
+def settimer(win):
+ now = getlocaltime()
+ win.times = calctime(now)
+ delay = 61 - now % 60
+ win.settimer(10 * delay)
+ minutes = (now/60) % 720
+ if win.ring:
+ # Is it time to stop the alarm ringing?
+ since = (minutes - win.time + 720) % 720
+ if since >= 5:
+ # Stop it now
+ win.ring = 0
+ else:
+ # Ring again, once every minute
+ stdwin.fleep()
+ elif win.set and minutes == win.time:
+ # Start the alarm ringing
+ win.ring = 1
+ stdwin.fleep()
+
+def drawproc(win, area):
+ hours, minutes, seconds = win.times
+ d = win.begindrawing()
+ d.cliprect(area)
+ d.erase(EVERYWHERE)
+ d.circle(win.center, win.radius)
+ d.line(win.center, calcpoint(win, hours*30 + minutes/2, 0.6))
+ d.line(win.center, calcpoint(win, minutes*6, 1.0))
+ str = dd(hours) + ':' + dd(minutes)
+ p = (win.width - d.textwidth(str))/2, win.height * 3 / 4
+ d.text(p, str)
+ if win.set:
+ drawalarm(win, d)
+ drawalarmtime(win, d)
+ if win.ring:
+ d.invert(win.mainarea)
+
+def mouseclick(win, type, detail):
+ d = win.begindrawing()
+ if win.ring:
+ # First turn the ringing off
+ win.ring = 0
+ d.invert(win.mainarea)
+ h, v = detail[0]
+ ch, cv = win.center
+ x, y = h-ch, cv-v
+ dist = sqrt(x*x + y*y) / float(win.radius)
+ if dist > 1.2:
+ if win.set:
+ drawalarm(win, d)
+ erasealarmtime(win, d)
+ win.set = 0
+ elif dist < 0.8:
+ if not win.set:
+ win.set = 1
+ drawalarm(win, d)
+ drawalarmtime(win, d)
+ else:
+ # Convert to half-degrees (range 0..720)
+ alpha = atan2(y, x)
+ hdeg = alpha*360.0/pi
+ hdeg = 180.0 - hdeg
+ hdeg = (hdeg + 720.0) % 720.0
+ atime = 5*int(hdeg/5.0 + 0.5)
+ if atime <> win.time or not win.set:
+ if win.set:
+ drawalarm(win, d)
+ erasealarmtime(win, d)
+ win.set = 1
+ win.time = atime
+ drawalarm(win, d)
+ drawalarmtime(win, d)
+
+def drawalarm(win, d):
+ p1 = calcpoint(win, float(win.time)/2.0, 1.02)
+ p2 = calcpoint(win, float(win.time)/2.0 - 4.0, 1.1)
+ p3 = calcpoint(win, float(win.time)/2.0 + 4.0, 1.1)
+ d.xorline(p1, p2)
+ d.xorline(p2, p3)
+ d.xorline(p3, p1)
+
+def erasealarmtime(win, d):
+ d.erase(win.statusarea)
+
+def drawalarmtime(win, d):
+ # win.time is in the range 0..720 with origin at 12 o'clock
+ # Convert to hours (0..12) and minutes (12*(0..60))
+ hh = win.time/60
+ mm = win.time%60
+ str = 'Alarm@' + dd(hh) + ':' + dd(mm)
+ p1 = (win.width - d.textwidth(str))/2, win.height
+ d.text(p1, str)
+
+def calcpoint(win, degrees, size):
+ alpha = pi/2.0 - float(degrees) * pi/180.0
+ x, y = cos(alpha), sin(alpha)
+ h, v = win.center
+ r = float(win.radius)
+ return h + int(x*size*r), v - int(y*size*r)
+
+def calctime(now):
+ seconds = now % 60
+ minutes = (now/60) % 60
+ hours = (now/3600) % 12
+ return hours, minutes, seconds
+
+def dd(n):
+ s = `n`
+ return '0'*(2-len(s)) + s
+
+def getlocaltime():
+ return time.time() - TZDIFF
+
+main()
--- /dev/null
+This directory contains a browser written in Python for "Info files"
+as used by the Emacs documentation system. The browser requires that
+Python is built with the "stdwin" option and runs under X11 or the
+Mac window system.
+
+Now you can read Info files even if you can't spare the memory, time or
+disk space to run Emacs. (I have used this extensively on a Macintosh
+with 1 Megabyte main memory and a 20 Meg harddisk.)
+
+You can give this to someone with great fear of complex computer
+systems, as long as they can use a mouse.
+
+Another reason to use this is to encourage the use of Info for on-line
+documentation of software that is not related to Emacs or GNU.
+(In particular, I plan to redo the Python and STDWIN documentation
+in texinfo.)
+
+The main program is in file "ib.py"; this accepts a file name and a
+node name as optional command line arguments, i.e., its usage is
+
+ python ib.py [file [node]]
+
+
+Configuration:
+
+- The pathname of the directory (or directories) containing
+the standard Info files should be set by editing the
+value assigned to INFOPATH in module ifile.py.
+
+- The default font should be set by editing the value of FONT
+in this module (ibrowse.py).
+
+- For fastest I/O, you may look at BLOCKSIZE and a few other
+constants in ifile.py.
--- /dev/null
+-*- Text -*-
+This is the file .../ibrowse/dir, which contains the topmost node of the
+Info hierarchy. The first time you invoke Ibrowse you start off
+looking at that node, which is (dir)Top. (This is a copy of the Info
+dir node, except that the reference to Info is replaced by one to Ibrowse.)
+\1f
+File: dir Node: Top This is the top of the INFO tree
+ This (the Directory node) gives a menu of major topics.
+ Typing "d" returns here, "q" exits, "?" lists all INFO commands, "h"
+ gives a primer for first-timers, "mTexinfo<Return>" visits Texinfo topic,
+ etc.
+ --- PLEASE ADD DOCUMENTATION TO THIS TREE. (See INFO topic first.) ---
+
+* Menu: The list of major topics begins on the next line.
+
+* Ibrowse: (ibrowse). Documentation browsing system.
+
+* Emacs: (emacs). The extensible self-documenting text editor.
+
+* VIP: (vip). A VI-emulation for Emacs.
+
+* Texinfo: (texinfo).
+ With one source file, make either a printed manual
+ (through TeX) or an Info file (through texinfo).
+ Full documentation in this menu item.
+
+* Termcap: (termcap).
+ The termcap library, which enables application programs
+ to handle all types of character-display terminals.
+
+* Regex: (regex).
+ The GNU regular expression library.
+
+* Bison: (bison.info).
+ The GNU yacc-compatible parser generator.
+
+* GCC: (gcc.info).
+ The GNU C compiler.
+
+* G++: (g-whiz).
+ The GNU C++ compiler.
+
+* LibG++: (libg++).
+ The GNU C++ library.
+
+* GDB: (gdb.info).
+ The GNU debugger.
+
+* CPP: (cpp.info).
+ The GNU C preprocessor.
+
+* Lispref: (lispref).
+ The GNU Emacs Lisp reference manual.
+
+* Make: (make-info).
+ The GNU make program.
+
+* M4: (m4).
+ The GNU m4 program.
+
+* Gawk: (gawk-info).
+ GNU awk.
--- /dev/null
+: ${ARCH}=`arch`
+exec /ufs/guido/bin/$ARCH/python ib.py ${1+"$@"}
--- /dev/null
+#! /usr/local/python
+
+# Call ibrowse (the info file browser) under UNIX.
+
+import sys
+import ibrowse
+
+if len(sys.argv) > 1:
+ file = sys.argv[1]
+ if len(sys.argv) > 2:
+ if len(sys.argv) > 3:
+ sys.stdout = sys.stderr
+ print 'usage:', sys.argv[0], '[file [node]]'
+ sys.exit(2)
+ else:
+ node = sys.argv[2]
+ else:
+ node = ''
+ ibrowse.start('(' + file + ')' + node)
+else:
+ ibrowse.main()
--- /dev/null
+This file documents the ibrowse program. -*-Text-*-
+The H command of ibrowse goes to the node Help in this file.
+\1f
+File: ibrowse Node: Top Up: (DIR) Next: Expert
+
+Ibrowse is a program for reading documentation, which you are using now.
+** Ibrowse uses the file format of the Emacs Info program, and its
+** commands are similar, but not identical.
+
+To learn how to use Ibrowse, type the command "h". It will bring you
+to a programmed instruction sequence.
+
+* Menu:
+
+* Expert:: Advanced Ibrowse commands: c, k, g, s, 1 - 9, arrows.
+* Add:: Describes how to add new nodes to the hierarchy.
+ Also tells what nodes look like.
+* Menus:: How to add to or create menus in Info nodes.
+* Cross-refs:: How to add cross-references to Info nodes.
+* Tags:: How to make tag tables for Info files.
+* Checking:: How to check the consistency of an Info file.
+* Texinfo: (texinfo).
+ How to generate an Info file and a printed manual
+ from the same source file.
+\1f\f
+File: ibrowse Node: Summary Next: Help
+
+Ibrowse is a Python program for browsing through the Emacs Info
+documentation tree. Documentation in Info is divided into "nodes",
+each of which discusses one topic and contains references to other
+nodes which discuss related topics. Ibrowse has commands to follow the
+references and show you other nodes.
+
+h Invoke the Ibrowse tutorial.
+? Display this Summary node.
+q Quit Ibrowse.
+w Close current window.
+
+Selecting other nodes:
+n Move to the "next" node of this node.
+p Move to the "previous" node of this node.
+m Pick menu item specified by name (or abbreviation).
+1-9 Pick first..ninth in node's menu.
+ Menu items select nodes that are "subsections" of this node.
+u Move "up" from this node (i.e., from a subsection to a section).
+f Follow a cross reference by name (or abbrev). Type `l' to get back.
+l Move back to the last node you were in.
+
+Moving within a node:
+Space Scroll forward a full screen. DEL, BS Scroll backward.
+b Go to beginning of node.
+
+Advanced commands:
+k Clone current window (create an independent duplicate).
+c Copy text selection to clipboard (for paste in another application).
+g Move to node specified by name.
+ You may include a filename as well, as (FILENAME)NODENAME.
+d Go to the main directory of Info files.
+t Go to Top node of this file.
+s Search through this Info file for node with specified regexp.
+\1f\f
+File: ibrowse Node: Help-Small-Screen Next: Help
+
+Since your terminal has an unusually small number of lines on its
+screen, it is necessary to give you special advice at the beginning.
+
+If you see the text "--All----" at near the bottom right corner of
+the screen, it means the entire text you are looking at fits on the
+screen. If you see "--Top----" instead, it means that there is more
+text below that does not fit. To move forward through the text and
+see another screen full, press the Space bar. To move back up, press
+the key labeled Rubout or Delete or DEL.
+
+Here are 40 lines of junk, so you can try Spaces and Rubout and
+see what they do. At the end are instructions of what you should do
+next.
+
+This is line 17
+This is line 18
+This is line 19
+This is line 20
+This is line 21
+This is line 22
+This is line 23
+This is line 24
+This is line 25
+This is line 26
+This is line 27
+This is line 28
+This is line 29
+This is line 30
+This is line 31
+This is line 32
+This is line 33
+This is line 34
+This is line 35
+This is line 36
+This is line 37
+This is line 38
+This is line 39
+This is line 40
+This is line 41
+This is line 42
+This is line 43
+This is line 44
+This is line 45
+This is line 46
+This is line 47
+This is line 48
+This is line 49
+This is line 50
+This is line 51
+This is line 52
+This is line 53
+This is line 54
+This is line 55
+This is line 56
+
+If you have managed to get here, go back to the beginning with
+Rubout, and come back here again, then you understand Space and
+Rubout. So now type an "n"--just one character; don't type the
+quotes and don't type a Return afterward-- to get to the normal start
+of the course.
+\1f\f
+File: ibrowse Node: Help Next: Help-P Previous: Help-Small-Screen
+
+You are talking to the program Ibrowse, for reading documentation.
+
+ Right now you are looking at one "Node" of Information.
+A node contains text describing a specific topic at a specific
+level of detail. This node's topic is "how to use Ibrowse".
+
+ The top line of a node is its "header". This node's header (look at
+it now) says that it is the node named "Help" in the file "ibrowse".
+It says that the Next node after this one is the node called "Help-P".
+An advanced Ibrowse command lets you go to any node whose name you know.
+
+ Besides a "Next", a node can have a "Previous" or an "Up".
+This node has a "Previous" but no "Up", as you can see.
+
+ Now it's time to move on to the Next node, named "Help-P".
+
+>> Type "n" to move there. Type just one character;
+ don't type the quotes and don't type a Return afterward.
+
+">>" in the margin means it is really time to try a command.
+\1f
+File: ibrowse Node: Help-P Next: Help-Page Previous: Help
+
+This node is called "Help-P". The "Previous" node, as you see, is
+"Help", which is the one you just came from using the "N" command.
+Another "N" command now would take you to the Next node, "Help-Page".
+
+>> But don't do that yet. First, try the "p" command, which takes
+you to the Previous node. When you get there, you can do an "n"
+again to return here.
+
+ This all probably seems insultingly simple so far, but DON'T be
+led into skimming. Things will get more complicated soon. Also,
+don't try a new command until you are told it's time to. Otherwise,
+you may make Ibrowse skip past an important warning that was coming up.
+
+>> Now do an "n" to get to the node "Help-Page" and learn more.
+\1f\f
+File: ibrowse Node: Help-Page Next: Help-M Previous: Help-P
+
+Space, Backspace, and B commands.
+
+ This node's header tells you that you are now at node "Help-Page", and
+that "P" would get you back to "Help-P". The line starting "Space,"
+is a "Title", saying what the node is about (most nodes have titles).
+
+ This is a big node and it doesn't all fit on your display screen.
+You can tell that there is more that isn't visible because you
+the scroll bar on the side of the window has become active (gray).
+
+ The Space, Backspace and B commands exist to allow you to "move
+around" in a node that doesn't all fit on the screen at once.
+Space moves forward, to show what was below the bottom of the screen.
+Backspace moves backward, to show what was above the top of the screen
+(there isn't anything above the top until you have typed some spaces).
+
+>> Now try typing a Space (afterward, type a Backspace to return here).
+
+ When you type the space, the two lines that were at the bottom of the
+screen appear at the top, followed by more lines. Backspace takes the
+two lines from the top and moves them to the bottom, USUALLY, but if
+there are not a full screen's worth of lines above them they may not
+make it all the way to the bottom.
+
+ If you type a Space when there is no more to see, it will ring the
+bell and otherwise do nothing. The same goes for a Backspace when
+the header of the node is visible.
+
+ Of course you can use the mouse and directly move the scroll bar
+as well, but Ibrowse has keyboard commands for almost everything,
+including scrolling. These keyboard commands are called "shortcuts",
+because it generally takes less effort to press a key on the
+keyboard than to move the mouse. On the other hand, if you are
+an infrequent user of Ibrowse, you can do everything with the
+mouse that you can do with the keyboard. Just look in the menus
+(I'm sure you must know how to use the menus on this system, or
+else you couldn't have gotten this far...). In fact you'll see that
+the commands and shortcuts listed in the menus are the same as those
+described in this course. You can use the shortcuts either with or
+without the "Command" or "Meta" key.
+
+ Two menus are always available: the "Ibrowse" menu contains commands
+pertaining to the Ibrowse program at large, while the "Navigation" menu
+contains commands that move around between nodes. There may be other
+menus; these will be explained later.
+
+ To move back to the beginning of the node you are on, you can type
+a lot of Backspaces. You can also type simply "b" for beginning.
+>> Try that now. (I have put in enough verbiage to make sure you are
+ not on the first screenful now). Then come back, with Spaces.
+
+ You have just learned a considerable number of commands. If you
+want to use one but have trouble remembering which, just pull down
+the menus to get a summary of commands and shortcuts. Some additional
+shortcuts (not listed in the menus) are listed by the "Short help"
+command. This brings up a dialog box which you can acknowledge
+by clicking the OK button or pressing the Return key.
+
+ From now on, you will encounter large nodes without warning, and
+will be expected to know how to use Space and Backspace to move
+around in them without being told. Since you could change the
+size of the window used, it would be impossible to warn you anyway.
+
+>> Now type "n" to see the description of the "m" command.
+\1f\f
+File: ibrowse Node: Help-M Next: Help-Adv Previous: Help-Page
+
+Menus and the "m" command
+
+ With only the "n" and "p" commands for moving between nodes, nodes
+are restricted to a linear sequence. Menus allow a branching
+structure. A menu is a list of other nodes you can move to. It is
+actually just part of the text of the node formatted specially so that
+Ibrowse can interpret it. The beginning of a menu is always identified
+by a line which starts with "* Menu:". A node contains a menu if and
+only if it has a line in it which starts that way. The only menu you
+can use at any moment is the one in the node you are in. To use a
+menu in any other node, you must move to that node first.
+
+ (There is an unfortunate confusion of terms here. "Menu" may refer
+to one of the Ibrowse menus at the top, such as as the "Ibrowse" and
+"Navigation" menus explained in the previous node, or to the menu in
+a node. Where confusion is possible, these will be disambiguated by
+calling them "Ibrowse menus" or "node menu".)
+
+ After the start of the menu, each line that starts with a "*"
+identifies one subtopic. The line will usually contain a brief name
+for the subtopic (followed by a ":"), the name of the node that talks
+about that subtopic, and optionally some further description of the
+subtopic. Lines in the menu that don't start with a "*" have no
+special meaning - they are only for the human reader's benefit and do
+not define additional subtopics. Here is an example:
+* Foo: FOO's Node This tells about FOO
+The subtopic name is Foo, and the node describing it is "FOO's Node".
+The rest of the line is just for the reader's Information.
+[[ But this line is not a real menu item, simply because there is
+no line above it which starts with "* Menu:".]]
+
+ When you use a menu to go to another node (in a way that will be
+described soon), what you specify is the subtopic name, the first
+thing in the menu line. Ibrowse uses it to find the menu line, extracts
+the node name from it, and goes to that node. The reason that there
+is both a subtopic name and a node name is that the node name must be
+meaningful to the computer and may therefore have to be ugly looking.
+The subtopic name can be chosen just to be convenient for the user to
+specify. Often the node name is convenient for the user to specify
+and so both it and the subtopic name are the same. There is an
+abbreviation for this:
+* Foo:: This tells about FOO
+This means that the subtopic name and node name are the same; they are
+both "Foo".
+
+>> Now use Spaces to find the menu in this node, then come back to
+the front with a "b". As you see, a menu is actually visible
+in its node. If you can't find a menu in a node by looking at it,
+then the node doesn't have a menu and the "m" command is not available.
+
+ (Actually, a quicker way to see if there is a node menu, is to look
+for an Ibrowse menu at the top named "Menu".)
+
+ The command to go to one of the subnodes is "m" - but DON'T DO IT
+YET! Before you use "m", you must understand the difference between
+commands and arguments. So far, you have learned several commands
+that do not need arguments. When you type one, Ibrowse processes it and
+is instantly ready for another command. The "m" command is different:
+it is incomplete without the NAME OF THE SUBTOPIC. Once you have
+typed "m", Ibrowse wants to read the subtopic name.
+
+ Thanks to modern user interface technology, this will be obvious:
+you are prompted for the subtopic name in a dialog box. When you are
+finished typing the name, press Return or click the OK button. You can
+cancel the dialog box by clicking the Cancel button. The first subtopic
+is provided as a default choice, so if you want to go there, you can
+just press Return.
+
+ You can abbreviate the subtopic name. If the abbreviation is not
+unique, the first matching subtopic is chosen. Some menus will put
+the shortest possible abbreviation for each subtopic name in capital
+letters, so you can see how much you need to type. It does not
+matter whether you use upper case or lower case when you type the
+subtopic. You should not put any spaces at the end, or inside of the
+item name, except for one space where a space appears in the item in
+the menu.
+
+ Here is a menu to give you a chance to practice.
+
+* Menu: The menu starts here.
+
+This menu gives you three ways of going to one place, Help-FOO.
+
+* Foo: Help-FOO A node you can visit for fun
+* Bar: Help-FOO Strange! two ways to get to the same place.
+* Help-FOO:: And yet another!
+
+>> Now type just an "m" and see what happens. (Read ahead before
+>> trying this out, as the dialog box will probably cover these
+>> instructions!)
+
+ Now you are "inside" an "m" command. Commands can't be used now;
+the next thing you will type must be the name of a subtopic.
+
+ You can change your mind about doing the "m" by clicking the Cancel
+button.
+>> Try that now; notice the dialog box disappear.
+>> Then type another "m".
+
+>> Now type "BAR", the item name. Don't type Return yet.
+
+ While you are typing the item name, you can use the Backspace
+key to cancel one character at a time if you make a mistake.
+>> Type one to cancel the "R". You could type another "R" to
+replace it. You don't have to, since "BA" is a valid abbreviation.
+>> Now you are ready to go. Type a Return.
+
+ After visiting Help-FOO, you should return here (it will tell how).
+
+>> Type "n" to see more commands.
+\1f
+File: ibrowse Node: Help-FOO Up: Help-M
+
+The "u" command
+
+ Congratulations! This is the node Help-FOO. Unlike the other
+nodes you have seen, this one has an "Up": "Help-M", the node you
+just came from via the "m" command. This is the usual convention--
+the nodes you reach from a menu have Ups that lead back to the menu.
+Menus move Down in the tree, and Up moves Up. Previous, on the other
+hand, is usually used to "stay on the same level but go backwards".
+
+ You can go back to the node Help-M by typing the command
+"u" for "Up". That will put you at the FRONT of the node - to get
+back to where you were reading you will have to type some Spaces.
+
+>> Now type "u" to move back up to Help-M.
+\1f\f
+File: ibrowse Node: Help-Adv Next: Help-Q Previous: Help-M
+
+Some advanced Ibrowse commands
+
+ The course is almost over, so please stick with it to the end.
+
+ If you have been moving around to different nodes and wish to
+retrace your steps, the "l" command ("l" for "last") will do that, one
+node at a time. If you have been following directions, an "l" command
+now will get you back to Help-M. Another "l" command would undo the "u"
+and get you back to Help-FOO. Another "l" would undo the M and get you
+back to Help-M.
+
+>> Try typing three "l"'s, pausing in between to see what each "l" does.
+Then follow directions again and you will end up back here.
+
+ Note the difference between "l" and "p": "l" moves to where YOU
+last were, whereas "p" always moves to the node which the header says
+is the "Previous" node (from this node, to Help-M).
+
+ The "d" command gets you instantly to the Directory node.
+This node, which is the first one you saw when you entered Ibrowse,
+has a menu which leads (directly, or indirectly through other menus),
+to all the nodes that exist.
+
+>> Try doing a "d", then do an "l" to return here (yes, DO return).
+
+ Sometimes, in Ibrowse documentation, you will see a cross reference.
+Cross references look like this: *Note Cross: Help-Cross. That is a
+real, live cross reference which is named "Cross" and points at the
+node named "Help-Cross".
+
+ If you wish to follow a cross reference, you must use the "f"
+command. The "f" prompts for the cross reference name (in this case,
+"Cross") with a dialog box.
+
+>> Type "f", followed by "Cross", and a Return.
+
+ The "f" command allows abbreviations just like "m".
+
+ To get a list of all the cross references in the current node,
+look in the Ibrowse menu at the top labeled "Footnotes". This menu is
+only present if there are cross references in the current node, and
+can be used to directly follow a cross reference, just like the "Menu"
+menu is another way to choose an item of the node's menu.
+
+>> Now type "n" to see the last node of the course.
+\1f
+File: ibrowse Node: Help-Cross
+
+ This is the node reached by the cross reference named "Cross".
+
+ While this node is specifically intended to be reached by a cross
+reference, most cross references lead to nodes that "belong" someplace
+else far away in the structure of Ibrowse. So you can't expect the
+footnote to have a Next, Previous or Up pointing back to where you
+came from. In general, the "l" (el) command is the only way to get
+back there.
+
+>> Type "l" to return to the node where the cross reference was.
+\1f
+File: ibrowse Node: Help-Q Previous: Help-Adv Up: Top
+
+ To get out of Ibrowse, type "q" for "Quit". All Ibrowse windows
+will be closed (on UNIX, only those managed by the same process).
+To close just one window, use the standard method of closing windows
+on your system; you can also use "w".
+
+ This is the end of the course on using Ibrowse. There are some other
+commands that are not essential or meant for experienced users; they
+are useful, and you can find them by looking in the directory for
+documentation on Ibrowse. Finding them will be a good exercise in using
+Ibrowse in the usual manner.
+
+>> Close this window and find back the window where you typed "h"
+ to enter this tutorial.
+ Then type "d" to go to the Ibrowse directory node if necessary,
+ and choose the "Ibrowse" menu item, to get to the node about
+ Ibrowse and see what other help is available.
+\1f\f
+File: ibrowse, Node: Expert, Up: Top, Previous: Top, Next: Add
+
+Some Advanced Ibrowse Commands ("c", "k", "g", "s", "1" - "9", arrows).
+
+The "c" command lets you copy text from the window to the clipboard.
+You must first select the text to be copied with the mouse.
+
+The "k" command means "klone" (we are running out of letters now...).
+It creates a new Ibrowse window, showing the same node as the current.
+You can then make an excursion in the new window to different nodes or
+files, while the old window keeps showing the original node. Each
+window has its own history for use by the "l" command.
+
+If you know a node's name, you can go there with the "g" command.
+This prompts for a node name with a dialog box. Entering, "Top"
+would go to the node called Top in this file (its directory node).
+Pressing "g" again and entering "Expert" would come back here.
+
+Unlike "m", "g" does not allow the use of abbreviations.
+
+To go to a node in another file, you can include the filename in the
+node name by putting it at the front, in parentheses. Thus,
+"(dir)Top" would go to the Ibrowse Directory node, which is
+node Top in the file dir.
+
+The node name "*" specifies the whole file. So you can look at all
+of the current file by typing "*" or all of any other file
+with "(FILENAME)*".
+
+File names are converted to lower case before they are tried; this
+is necessary to be compatible with Emacs Info. (File names are
+generally relative to the Info directory, but needn't be.)
+
+The "s" command allows you to search a whole file for a regular
+expression. Unlike the corresponding Emacs Info command, it will
+not search beyond the end of the current node.
+
+Regular expressions are like in UNIX egrep; if you don't know what
+regular expressions are, limit your search strings to letters, digits
+and spaces. Searches in Ibrowse are case-sensitive; searching for
+"foo" will not find "Foo" or "FOO"!
+
+A description of regular expressions as they occur in Emacs is
+available. (*Note Emacs Regular Expressions: (regex)syntax.)
+Ibrowse regular expressions are slightly different: the meaning
+of \( \| \) is swapped with that of ( | ), and there are no
+escapes to handle "words" specially.
+
+Searching starts after the current focus position. The "B" command
+resets the focus to the beginning of the file, but space and backspace
+leave it unchanged (so they may render the focus invisible).
+
+If you grudge the system each character of type-in it requires,
+you might like to use the commands "1", "2", "3", through "9".
+They are short for the first nine entries of the node menu.
+
+The left, right and up arrow keys are duplicates of "p", "n" and "u".
+
+The down arrow key, as well as the Return key, goes to the first item
+of the node's menu if there is one, else it executes "n". This is a
+quick way to visit all nodes in a tree in pre-order: use Return to go
+down and right as far as possible, then use "u" and "n" to go right
+at the next higher level.
+\1f\f
+File: ibrowse, Node: Add, Up: Top, Previous: Expert, Next: Menus
+
+To add a new topic to the list in the directory, you must
+ 1) enter the Emacs text editor. *Note Emacs: (emacs).
+ 2) create a node, in some file, to document that topic.
+ 3) put that topic in the menu in the directory. *Note Menu: Menus.
+
+ The new node can live in an existing documentation file, or in a new
+one. It must have a ^_ character before it (invisible to the user;
+this node has one but you can't see it), and it ends with either a ^_,
+or the end of file. A nice way to make a node boundary be a
+page boundary as well is to put a ^L RIGHT AFTER the ^_.
+
+ The ^_ starting a node must be followed by a newline or a ^L newline,
+after which comes the node's header line. The header line must give
+the node's name (by which Ibrowse will find it), and state the names of
+the Next, Previous, and Up nodes (if there are any). As you can see,
+this node's Up node is the node Top, which points at all the
+documentation for Ibrowse. The Next node is "Menus".
+
+ The keywords "Node", "Previous", "Up" and "Next", may appear in
+any order, anywhere in the header line, but the recommended order is
+the one in this sentence. Each keyword must be followed by a colon,
+spaces and tabs, and then the appropriate name. The name may be
+terminated with a tab, a comma, or a newline. A space does not end
+it; node names may contain spaces. The case of letters in the names
+is insignificant. "Previous" can be abbreviated to "Prev".
+
+ A node name has two forms. A node in the current file is named by
+what appears after the "Node: " in that node's first line. For
+example, this node's name is "Add". A node in another file is named
+by "(FILENAME)NODE-WITHIN-FILE", as in "(ibrowse)Add" for this node.
+If the file name is relative, it is taken starting from the standard
+Info file directory of your site. The name "(FILENAME)Top" can be
+abbreviated to just "(FILENAME)". By convention, the name "Top" is
+used for the "highest" node in any single file - the node whose "Up"
+points out of the file. The Directory node is "(dir)". The Top node
+of a document file listed in the Directory should have an "Up: (dir)"
+in it.
+
+ The node name "*" is special: it refers to the entire file. Thus,
+g* will show you the whole current file. The use of the node * is to
+make it possible to make old-fashioned, unstructured files into nodes
+of the tree. Footnotes and node menus appearing in a file are disabled
+when it is viewed in this way.
+
+ The "Node:" name, in which a node states its own name, must not
+contain a filename, since Ibrowse when searching for a node does not
+expect one to be there. The Next, Previous and Up names may contain
+them. In this node, since the Up node is in the same file, it was not
+necessary to use one.
+
+ Note that the nodes in this file have a File name in the header
+line. The File names are ignored by Ibrowse, but they serve as
+comments to help identify the node for the user.
+\1f\f
+File: ibrowse, Node: Menus, Previous: Add, Up: Top, Next: Cross-refs
+
+How to Create Menus:
+
+ Any node in the Ibrowse hierarchy may have a MENU--a list of subnodes.
+The "m" command searches the current node's menu for the topic which it
+reads from the terminal.
+
+ A menu begins with a line starting with "* Menu:". The rest of the
+line is a comment. After the starting line, every line that begins
+with a "* " lists a single topic. The name of the topic--the arg
+that the user must give to the "m" command to select this topic--
+comes right after the star and space, and is followed by
+a colon, spaces and tabs, and the name of the node which discusses
+that topic. The node name, like node names following Next,
+Previous and Up, may be terminated with a tab, comma, or newline;
+it may also be terminated with a period.
+
+ If the node name and topic name are the same, than rather than
+giving the name twice, the abbreviation "* NAME::" may be used
+(and should be used, whenever possible, as it reduces the visual
+clutter in the menu).
+
+ It is considerate to choose the topic names so that they differ
+from each other very near the beginning--this allows the user to type
+short abbreviations. In a long menu, it is a good idea to capitalize
+the beginning of each item name which is the minimum acceptable
+abbreviation for it (a long menu is more than 5 or so entries).
+
+ The node's listed in a node's menu are called its "subnodes", and
+it is their "superior". They should each have an "Up:" pointing at
+the superior. It is often useful to arrange all or most of the
+subnodes in a sequence of Next's/Previous's so that someone who
+wants to see them all need not keep revisiting the Menu.
+
+ The Info Directory is simply the menu of the node "(dir)Top"--that
+is, node Top in file .../info/dir. You can put new entries in that
+menu just like any other menu. The Info Directory is NOT the same as
+the file directory called "info". It happens that many of Ibrowse's
+files live on that file directory, but they don't have to; and files
+on that directory are not automatically listed in the Info Directory
+node.
+
+ The Ibrowse program uses a second directory called .../ibrowse,
+which contains versions of the "dir" and "info" files adapted to
+Ibrowse (the latter renamed to "ibrowse", obviously). It searches
+any file first in the "ibrowse", then in the "info" directory.
+(Actually, the search path is configurable.)
+
+ Also, although the Info node graph is claimed to be a "hierarchy",
+in fact it can be ANY directed graph. Shared structures and pointer
+cycles are perfectly possible, and can be used if they are
+appropriate to the meaning to be expressed. There is no need for all
+the nodes in a file to form a connected structure. In fact, this
+file has two connected components. You are in one of them, which is
+under the node Top; the other contains the node Help which the "h"
+command goes to. In fact, since there is no garbage collector,
+nothing terrible happens if a substructure is not pointed to, but
+such a substructure will be rather useless since nobody will ever
+find out that it exists.
+\1f
+File: ibrowse, Node: Cross-refs, Previous: Menus, Up: Top, Next: Tags
+
+Creating Cross References:
+
+ A cross reference can be placed anywhere in the text, unlike a menu
+item which must go at the front of a line. A cross reference looks
+like a menu item except that it has "*note" instead of "*". It CANNOT
+be terminated by a ")", because ")"'s are so often part of node names.
+If you wish to enclose a cross reference in parentheses, terminate it
+with a period first. Here are two examples of cross references pointers:
+
+ *Note details: commands. (See *note 3: Full Proof.)
+
+They are just examples. The places they "lead to" don't really exist!
+\1f
+File: ibrowse, Node: Tags, Previous: Cross-refs, Up: Top, Next: Checking
+
+Tag Tables for Info Files:
+
+ You can speed up the access to nodes of a large Info file by giving
+it a tag table. Unlike the tag table for a program, the tag table for
+an Info file lives inside the file itself and will automatically be
+used whenever Ibrowse reads in the file.
+
+ To make a tag table, go to a node in the file using Emacs Info and type
+M-x Info-tagify. Then you must use C-x C-s to save the file.
+
+ Once the Info file has a tag table, you must make certain it is up
+to date. If, as a result of deletion of text, any node moves back
+more than a thousand characters in the file from the position
+recorded in the tag table, Ibrowse will no longer be able to find that
+node. To update the tag table, use the Info-tagify command again.
+
+ An Info file tag table appears at the end of the file and looks like
+this:
+
+^_^L
+Tag Table:
+File: ibrowse, Node: Cross-refs\7f21419
+File: ibrowse, Node: Tags\7f22145
+^_
+End Tag Table
+
+Note that it contains one line per node, and this line contains
+the beginning of the node's header (ending just after the node name),
+a rubout (DEL) character, and the character position in the file of the
+beginning of the node. The words "Tag Table" may occur in lower case
+as well.
+
+It is also possible for an extra level of indirection to be present.
+In this case, the first line of the Tag table contains the string
+"(Indirect)", and preceding the tag table is another "pseudo node"
+whose header reads "Indirect:". Each following line has the form
+"filename: offset", meaning that nodes at that offset or larger (but
+less than the offset in the next line) really occur in the file named
+here, and that the file's offset should be subtracted from the node's
+offset. (Indirect tables are created by texinfo for large files.
+*Note Texinfo: (texinfo). *Note Splitting files: (texinfo)Splitting.)
+\1f
+File: ibrowse, Node: Checking, Previous: Tags, Up: Top
+
+Checking an Info File:
+
+ When creating an Info file, it is easy to forget the name of a node
+when you are making a pointer to it from another node. If you put in
+the wrong name for a node, this will not be detected until someone
+tries to go through the pointer using Ibrowse. Verification of the Info
+file is an automatic process which checks all pointers to nodes and
+reports any pointers which are invalid. Every Next, Previous, and Up
+is checked, as is every menu item and every cross reference. In addition,
+any Next which doesn't have a Previous pointing back is reported.
+Only pointers within the file are checked, because checking pointers
+to other files would be terribly slow. But those are usually few.
+
+ To check an Info file, do M-x Info-validate while looking at any
+node of the file with Emacs Info.
+\1f\f
+Tag table:
+Node: Top\7f117
+Node: Summary\7f952
+Node: Help-Small-Screen\7f997
+Node: Help\7f2628
+Node: Help-P\7f3588
+Node: Help-Page\7f4348
+Node: Help-M\7f7763
+Node: Help-FOO\7f13183
+Node: Help-Adv\7f13887
+Node: Help-Cross\7f15923
+Node: Help-Q\7f16443
+Node: Expert\7f17326
+Node: Add\7f20280
+Node: Menus\7f23273
+Node: Cross-refs\7f26394
+Node: Tags\7f27050
+Node: Checking\7f28966
+\1f
+End tag table
--- /dev/null
+# Browser for "Info files" as used by the Emacs documentation system.
+#
+# Now you can read Info files even if you can't spare the memory, time or
+# disk space to run Emacs. (I have used this extensively on a Macintosh
+# with 1 Megabyte main memory and a 20 Meg harddisk.)
+#
+# You can give this to someone with great fear of complex computer
+# systems, as long as they can use a mouse.
+#
+# Another reason to use this is to encourage the use of Info for on-line
+# documentation of software that is not related to Emacs or GNU.
+# (In particular, I plan to redo the Python and STDWIN documentation
+# in texinfo.)
+
+
+# NB: this is not a self-executing script. You must startup Python,
+# import ibrowse, and call ibrowse.main(). On UNIX, the script 'ib'
+# runs the browser.
+
+
+# Configuration:
+#
+# - The pathname of the directory (or directories) containing
+# the standard Info files should be set by editing the
+# value assigned to INFOPATH in module ifile.py.
+#
+# - The default font should be set by editing the value of FONT
+# in this module (ibrowse.py).
+#
+# - For fastest I/O, you may look at BLOCKSIZE and a few other
+# constants in ifile.py.
+
+
+# This is a fairly large Python program, split in the following modules:
+#
+# ibrowse.py Main program and user interface.
+# This is the only module that imports stdwin.
+#
+# ifile.py This module knows about the format of Info files.
+# It is imported by all of the others.
+#
+# itags.py This module knows how to read prebuilt tag tables,
+# including indirect ones used by large texinfo files.
+#
+# icache.py Caches tag tables and visited nodes.
+
+
+# XXX There should really be a different tutorial, as the user interface
+# XXX differs considerably from Emacs...
+
+
+import sys
+import regexp
+import stdwin
+from stdwinevents import *
+import string
+from ifile import NoSuchFile, NoSuchNode
+import icache
+
+
+# Default font.
+# This should be an acceptable argument for stdwin.setfont();
+# on the Mac, this can be a pair (fontname, pointsize), while
+# under X11 it should be a standard X11 font name.
+# For best results, use a constant width font like Courier;
+# many Info files contain tabs that don't align with other text
+# unless all characters have the same width.
+#
+#FONT = ('Monaco', 9) # Mac
+FONT = '-schumacher-clean-medium-r-normal--14-140-75-75-c-70-iso8859-1' # X11
+
+
+# Try not to destroy the list of windows when reload() is used.
+# This is useful during debugging, and harmless in production...
+#
+try:
+ dummy = windows
+ del dummy
+except NameError:
+ windows = []
+
+
+# Default main function -- start at the '(dir)' node.
+#
+def main():
+ start('(dir)')
+
+
+# Start at an arbitrary node.
+# The default file is 'ibrowse'.
+#
+def start(ref):
+ stdwin.setdefscrollbars(0, 1)
+ stdwin.setfont(FONT)
+ stdwin.setdefwinsize(76*stdwin.textwidth('x'), 22*stdwin.lineheight())
+ makewindow('ibrowse', ref)
+ mainloop()
+
+
+# Open a new browser window.
+# Arguments specify the default file and a node reference
+# (if the node reference specifies a file, the default file is ignored).
+#
+def makewindow(file, ref):
+ win = stdwin.open('Info file Browser, by Guido van Rossum')
+ win.mainmenu = makemainmenu(win)
+ win.navimenu = makenavimenu(win)
+ win.textobj = win.textcreate((0, 0), win.getwinsize())
+ win.file = file
+ win.node = ''
+ win.last = []
+ win.pat = ''
+ win.dispatch = idispatch
+ windows.append(win)
+ imove(win, ref)
+
+# Create the 'Ibrowse' menu for a new browser window.
+#
+def makemainmenu(win):
+ mp = win.menucreate('Ibrowse')
+ mp.callback = []
+ additem(mp, 'New window (clone)', 'K', iclone)
+ additem(mp, 'Help (tutorial)', 'H', itutor)
+ additem(mp, 'Command summary', '?', isummary)
+ additem(mp, 'Close this window', 'W', iclose)
+ additem(mp, '', '', None)
+ additem(mp, 'Copy to clipboard', 'C', icopy)
+ additem(mp, '', '', None)
+ additem(mp, 'Search regexp...', 'S', isearch)
+ additem(mp, '', '', None)
+ additem(mp, 'Reset node cache', '', iresetnodecache)
+ additem(mp, 'Reset entire cache', '', iresetcache)
+ additem(mp, '', '', None)
+ additem(mp, 'Quit', 'Q', iquit)
+ return mp
+
+# Create the 'Navigation' menu for a new browser window.
+#
+def makenavimenu(win):
+ mp = win.menucreate('Navigation')
+ mp.callback = []
+ additem(mp, 'Menu item...', 'M', imenu)
+ additem(mp, 'Follow reference...', 'F', ifollow)
+ additem(mp, 'Go to node...', 'G', igoto)
+ additem(mp, '', '', None)
+ additem(mp, 'Next node in tree', 'N', inext)
+ additem(mp, 'Previous node in tree', 'P', iprev)
+ additem(mp, 'Up in tree', 'U', iup)
+ additem(mp, 'Last visited node', 'L', ilast)
+ additem(mp, 'Top of tree', 'T', itop)
+ additem(mp, 'Directory node', 'D', idir)
+ return mp
+
+# Add an item to a menu, and a function to its list of callbacks.
+# (Specifying all in one call is the only way to keep the menu
+# and the list of callbacks in synchrony.)
+#
+def additem(mp, text, shortcut, function):
+ if shortcut:
+ mp.additem(text, shortcut)
+ else:
+ mp.additem(text)
+ mp.callback.append(function)
+
+
+# Stdwin event processing main loop.
+# Return when there are no windows left.
+# Note that windows not in the windows list don't get their events.
+#
+def mainloop():
+ while windows:
+ event = stdwin.getevent()
+ if event[1] in windows:
+ try:
+ event[1].dispatch(event)
+ except KeyboardInterrupt:
+ # The user can type Control-C (or whatever)
+ # to leave the browser without closing
+ # the window. Mainly useful for
+ # debugging.
+ break
+ except:
+ # During debugging, it was annoying if
+ # every mistake in a callback caused the
+ # whole browser to crash, hence this
+ # handler. In a production version
+ # it may be better to disable this.
+ #
+ msg = sys.exc_type
+ if sys.exc_value:
+ val = sys.exc_value
+ if type(val) <> type(''):
+ val = `val`
+ msg = msg + ': ' + val
+ msg = 'Oops, an exception occurred: ' + msg
+ event = None
+ stdwin.message(msg)
+ event = None
+
+
+# Handle one event. The window is taken from the event's window item.
+# This function is placed as a method (named 'dispatch') on the window,
+# so the main loop will be able to handle windows of a different kind
+# as well, as long as they are all placed in the list of windows.
+#
+def idispatch(event):
+ type, win, detail = event
+ if type == WE_CHAR:
+ if not keybindings.has_key(detail):
+ detail = string.lower(detail)
+ if keybindings.has_key(detail):
+ keybindings[detail](win)
+ return
+ if detail in '0123456789':
+ i = eval(detail) - 1
+ if 0 <= i < len(win.menu):
+ topic, ref = win.menu[i]
+ imove(win, ref)
+ return
+ stdwin.fleep()
+ return
+ if type == WE_COMMAND:
+ if detail == WC_LEFT:
+ iprev(win)
+ elif detail == WC_RIGHT:
+ inext(win)
+ elif detail == WC_UP:
+ iup(win)
+ elif detail == WC_DOWN:
+ idown(win)
+ elif detail == WC_BACKSPACE:
+ ibackward(win)
+ elif detail == WC_RETURN:
+ idown(win)
+ else:
+ stdwin.fleep()
+ return
+ if type == WE_MENU:
+ mp, item = detail
+ if mp == None:
+ pass # A THINK C console menu was selected
+ elif mp in (win.mainmenu, win.navimenu):
+ mp.callback[item](win)
+ elif mp == win.nodemenu:
+ topic, ref = win.menu[item]
+ imove(win, ref)
+ elif mp == win.footmenu:
+ topic, ref = win.footnotes[item]
+ imove(win, ref)
+ return
+ if type == WE_SIZE:
+ win.textobj.move((0, 0), win.getwinsize())
+ (left, top), (right, bottom) = win.textobj.getrect()
+ win.setdocsize(0, bottom)
+ return
+ if type == WE_CLOSE:
+ iclose(win)
+ return
+ if not win.textobj.event(event):
+ pass
+
+
+# Paging callbacks
+
+def ibeginning(win):
+ win.setorigin(0, 0)
+ win.textobj.setfocus(0, 0) # To restart searches
+
+def iforward(win):
+ lh = stdwin.lineheight() # XXX Should really use the window's...
+ h, v = win.getorigin()
+ docwidth, docheight = win.getdocsize()
+ width, height = win.getwinsize()
+ if v + height >= docheight:
+ stdwin.fleep()
+ return
+ increment = max(lh, ((height - 2*lh) / lh) * lh)
+ v = v + increment
+ win.setorigin(h, v)
+
+def ibackward(win):
+ lh = stdwin.lineheight() # XXX Should really use the window's...
+ h, v = win.getorigin()
+ if v <= 0:
+ stdwin.fleep()
+ return
+ width, height = win.getwinsize()
+ increment = max(lh, ((height - 2*lh) / lh) * lh)
+ v = max(0, v - increment)
+ win.setorigin(h, v)
+
+
+# Ibrowse menu callbacks
+
+def iclone(win):
+ stdwin.setdefwinsize(win.getwinsize())
+ makewindow(win.file, win.node)
+
+def itutor(win):
+ # The course looks best at 76x22...
+ stdwin.setdefwinsize(76*stdwin.textwidth('x'), 22*stdwin.lineheight())
+ makewindow('ibrowse', 'Help')
+
+def isummary(win):
+ stdwin.setdefwinsize(76*stdwin.textwidth('x'), 22*stdwin.lineheight())
+ makewindow('ibrowse', 'Summary')
+
+def iclose(win):
+ #
+ # Remove the window from the windows list so the mainloop
+ # will notice if all windows are gone.
+ # Delete the textobj since it constitutes a circular reference
+ # to the window which would prevent it from being closed.
+ # (Deletion is done by assigning None to avoid crashes
+ # when closing a half-initialized window.)
+ #
+ if win in windows:
+ windows.remove(win)
+ win.textobj = None
+
+def icopy(win):
+ focustext = win.textobj.getfocustext()
+ if not focustext:
+ stdwin.fleep()
+ else:
+ stdwin.rotatecutbuffers(1)
+ stdwin.setcutbuffer(0, focustext)
+ # XXX Should also set the primary selection...
+
+def isearch(win):
+ try:
+ pat = stdwin.askstr('Search pattern:', win.pat)
+ except KeyboardInterrupt:
+ return
+ if not pat:
+ pat = win.pat
+ if not pat:
+ stdwin.message('No previous pattern')
+ return
+ try:
+ cpat = regexp.compile(pat)
+ except regexp.error, msg:
+ stdwin.message('Bad pattern: ' + msg)
+ return
+ win.pat = pat
+ f1, f2 = win.textobj.getfocus()
+ text = win.text
+ match = cpat.match(text, f2)
+ if not match:
+ stdwin.fleep()
+ return
+ a, b = match[0]
+ win.textobj.setfocus(a, b)
+
+
+def iresetnodecache(win):
+ icache.resetnodecache()
+
+def iresetcache(win):
+ icache.resetcache()
+
+def iquit(win):
+ for win in windows[:]:
+ iclose(win)
+
+
+# Navigation menu callbacks
+
+def imenu(win):
+ ichoice(win, 'Menu item (abbreviated):', win.menu, whichmenuitem(win))
+
+def ifollow(win):
+ ichoice(win, 'Follow reference named (abbreviated):', \
+ win.footnotes, whichfootnote(win))
+
+def igoto(win):
+ try:
+ choice = stdwin.askstr('Go to node (full name):', '')
+ except KeyboardInterrupt:
+ return
+ if not choice:
+ stdwin.message('Sorry, Go to has no default')
+ return
+ imove(win, choice)
+
+def inext(win):
+ prev, next, up = win.header
+ if next:
+ imove(win, next)
+ else:
+ stdwin.fleep()
+
+def iprev(win):
+ prev, next, up = win.header
+ if prev:
+ imove(win, prev)
+ else:
+ stdwin.fleep()
+
+def iup(win):
+ prev, next, up = win.header
+ if up:
+ imove(win, up)
+ else:
+ stdwin.fleep()
+
+def ilast(win):
+ if not win.last:
+ stdwin.fleep()
+ else:
+ i = len(win.last)-1
+ lastnode, lastfocus = win.last[i]
+ imove(win, lastnode)
+ if len(win.last) > i+1:
+ # The move succeeded -- restore the focus
+ win.textobj.setfocus(lastfocus)
+ # Delete the stack top even if the move failed,
+ # else the whole stack would remain unreachable
+ del win.last[i:] # Delete the entry pushed by imove as well!
+
+def itop(win):
+ imove(win, '')
+
+def idir(win):
+ imove(win, '(dir)')
+
+
+# Special and generic callbacks
+
+def idown(win):
+ if win.menu:
+ default = whichmenuitem(win)
+ for topic, ref in win.menu:
+ if default == topic:
+ break
+ else:
+ topic, ref = win.menu[0]
+ imove(win, ref)
+ else:
+ inext(win)
+
+def ichoice(win, prompt, list, default):
+ if not list:
+ stdwin.fleep()
+ return
+ if not default:
+ topic, ref = list[0]
+ default = topic
+ try:
+ choice = stdwin.askstr(prompt, default)
+ except KeyboardInterrupt:
+ return
+ if not choice:
+ return
+ choice = string.lower(choice)
+ n = len(choice)
+ for topic, ref in list:
+ topic = string.lower(topic)
+ if topic[:n] == choice:
+ imove(win, ref)
+ return
+ stdwin.message('Sorry, no topic matches ' + `choice`)
+
+
+# Follow a reference, in the same window.
+#
+def imove(win, ref):
+ savetitle = win.gettitle()
+ win.settitle('Looking for ' + ref + '...')
+ #
+ try:
+ file, node, header, menu, footnotes, text = \
+ icache.get_node(win.file, ref)
+ except NoSuchFile, file:
+ win.settitle(savetitle)
+ stdwin.message(\
+ 'Sorry, I can\'t find a file named ' + `file` + '.')
+ return
+ except NoSuchNode, node:
+ win.settitle(savetitle)
+ stdwin.message(\
+ 'Sorry, I can\'t find a node named ' + `node` + '.')
+ return
+ #
+ win.settitle('Found (' + file + ')' + node + '...')
+ #
+ if win.file and win.node:
+ lastnode = '(' + win.file + ')' + win.node
+ win.last.append(lastnode, win.textobj.getfocus())
+ win.file = file
+ win.node = node
+ win.header = header
+ win.menu = menu
+ win.footnotes = footnotes
+ win.text = text
+ #
+ win.setorigin(0, 0) # Scroll to the beginnning
+ win.textobj.settext(text)
+ win.textobj.setfocus(0, 0)
+ (left, top), (right, bottom) = win.textobj.getrect()
+ win.setdocsize(0, bottom)
+ #
+ win.footmenu = None
+ win.nodemenu = None
+ #
+ win.menu = menu
+ if menu:
+ win.nodemenu = win.menucreate('Menu')
+ digit = 1
+ for topic, ref in menu:
+ if digit < 10:
+ win.nodemenu.additem(topic, `digit`)
+ else:
+ win.nodemenu.additem(topic)
+ digit = digit + 1
+ #
+ win.footnotes = footnotes
+ if footnotes:
+ win.footmenu = win.menucreate('Footnotes')
+ for topic, ref in footnotes:
+ win.footmenu.additem(topic)
+ #
+ win.settitle('(' + win.file + ')' + win.node)
+
+
+# Find menu item at focus
+#
+findmenu = regexp.compile('^\* [mM]enu:').match
+findmenuitem = regexp.compile( \
+ '^\* ([^:]+):[ \t]*(:|\([^\t]*\)[^\t,\n.]*|[^:(][^\t,\n.]*)').match
+#
+def whichmenuitem(win):
+ if not win.menu:
+ return ''
+ match = findmenu(win.text)
+ if not match:
+ return ''
+ a, b = match[0]
+ i = b
+ f1, f2 = win.textobj.getfocus()
+ lastmatch = ''
+ while i < len(win.text):
+ match = findmenuitem(win.text, i)
+ if not match:
+ break
+ (a, b), (a1, b1), (a2, b2) = match
+ if a > f1:
+ break
+ lastmatch = win.text[a1:b1]
+ i = b
+ return lastmatch
+
+
+# Find footnote at focus
+#
+findfootnote = \
+ regexp.compile('\*[nN]ote ([^:]+):[ \t]*(:|[^:][^\t,\n.]*)').match
+#
+def whichfootnote(win):
+ if not win.footnotes:
+ return ''
+ i = 0
+ f1, f2 = win.textobj.getfocus()
+ lastmatch = ''
+ while i < len(win.text):
+ match = findfootnote(win.text, i)
+ if not match:
+ break
+ (a, b), (a1, b1), (a2, b2) = match
+ if a > f1:
+ break
+ lastmatch = win.text[a1:b1]
+ i = b
+ return lastmatch
+
+
+# Now all the "methods" are defined, we can initialize the table
+# of key bindings.
+#
+keybindings = {}
+
+# Window commands
+
+keybindings['k'] = iclone
+keybindings['h'] = itutor
+keybindings['?'] = isummary
+keybindings['w'] = iclose
+
+keybindings['c'] = icopy
+
+keybindings['s'] = isearch
+
+keybindings['q'] = iquit
+
+# Navigation commands
+
+keybindings['m'] = imenu
+keybindings['f'] = ifollow
+keybindings['g'] = igoto
+
+keybindings['n'] = inext
+keybindings['p'] = iprev
+keybindings['u'] = iup
+keybindings['l'] = ilast
+keybindings['d'] = idir
+keybindings['t'] = itop
+
+# Paging commands
+
+keybindings['b'] = ibeginning
+keybindings['.'] = ibeginning
+keybindings[' '] = iforward
--- /dev/null
+# Cache management for info file processing.
+# The function get_node() is the standard interface;
+# its signature is the same as ifile.get_node() but it uses
+# the cache and supports indirect tag tables.
+
+
+import string
+import ifile
+from ifile import NoSuchNode, NoSuchFile
+import itags
+
+
+# Special hack to save the cache when using reload().
+# This can just be "cache = {}" in a production version.
+#
+try:
+ dummy = cache
+ del dummy
+except NameError:
+ cache = {}
+
+
+# Clear the entire cache.
+#
+def resetcache():
+ for key in cache.keys():
+ del cache[key]
+
+
+# Clear the node info from the cache (the most voluminous data).
+#
+def resetnodecache():
+ for key in cache.keys():
+ tags, nodes = cache[key]
+ cache[key] = tags, {}
+
+
+# Get a node.
+#
+def get_node(curfile, ref):
+ file, node = ifile.parse_ref(curfile, ref)
+ file = string.lower(file)
+ node = string.lower(node)
+ if node == '*':
+ # Don't cache whole file references;
+ # reading the data is faster than displaying it anyway.
+ return ifile.get_whole_file(file) # May raise NoSuchFile
+ if not cache.has_key(file):
+ cache[file] = get_tags(file), {} # May raise NoSuchFile
+ tags, nodes = cache[file]
+ if not nodes.has_key(node):
+ if not tags.has_key(node):
+ raise NoSuchNode, ref
+ file1, offset, line = tags[node]
+ if not file1:
+ file1 = file
+ file1, node1, header, menu, footnotes, text = \
+ ifile.get_file_node(file1, offset, node)
+ nodes[node] = file, node1, header, menu, footnotes, text
+ return nodes[node]
+
+
+# Get the tag table for a file.
+# Either construct one or get the one found in the file.
+# Raise NoSuchFile if the file isn't found.
+#
+def get_tags(file):
+ f = ifile.try_open(file) # May raise NoSuchFile
+ tags = itags.get_tags(f)
+ if not tags:
+ ###print 'Scanning file...'
+ f.seek(0)
+ tags = ifile.make_tags(f)
+ return tags
--- /dev/null
+# Tools for info file processing.
+
+# XXX Need to be more careful with reading ahead searching for nodes.
+
+
+import regexp
+import string
+
+
+# Exported exceptions.
+#
+NoSuchFile = 'no such file'
+NoSuchNode = 'no such node'
+
+
+# The search path for info files; this is site-specific.
+# Directory names should end in a partname delimiter,
+# so they can simply be concatenated to a relative pathname.
+#
+#INFOPATH = ['', ':Info.Ibrowse:', ':Info:'] # Mac
+INFOPATH = ['', '/usr/local/emacs/info/'] # X11 on UNIX
+
+
+# Tunable constants.
+#
+BLOCKSIZE = 512 # Qty to align reads to, if possible
+FUZZ = 2*BLOCKSIZE # Qty to back-up before searching for a node
+CHUNKSIZE = 4*BLOCKSIZE # Qty to read at once when reading lots of data
+
+
+# Regular expressions used.
+# Note that it is essential that Python leaves unrecognized backslash
+# escapes in a string so they can be seen by regexp.compile!
+#
+findheader = regexp.compile('\037\014?\n(.*\n)').match
+findescape = regexp.compile('\037').match
+parseheader = regexp.compile('[nN]ode:[ \t]*([^\t,\n]*)').match
+findfirstline = regexp.compile('^.*\n').match
+findnode = regexp.compile('[nN]ode:[ \t]*([^\t,\n]*)').match
+findprev = regexp.compile('[pP]rev[ious]*:[ \t]*([^\t,\n]*)').match
+findnext = regexp.compile('[nN]ext:[ \t]*([^\t,\n]*)').match
+findup = regexp.compile('[uU]p:[ \t]*([^\t,\n]*)').match
+findmenu = regexp.compile('^\* [mM]enu:').match
+findmenuitem = regexp.compile( \
+ '^\* ([^:]+):[ \t]*(:|\([^\t]*\)[^\t,\n.]*|[^:(][^\t,\n.]*)').match
+findfootnote = regexp.compile( \
+ '\*[nN]ote ([^:]+):[ \t]*(:|[^:][^\t,\n.]*)').match
+parsenoderef = regexp.compile('^\((.*)\)(.*)$').match
+
+
+# Get a node and all information pertaining to it.
+# This doesn't work if there is an indirect tag table,
+# and in general you are better off using icache.get_node() instead.
+# Functions get_whole_file() and get_file_node() provide part
+# functionality used by icache.
+# Raise NoSuchFile or NoSuchNode as appropriate.
+#
+def get_node(curfile, ref):
+ file, node = parse_ref(curfile, ref)
+ if node == '*':
+ return get_whole_file(file)
+ else:
+ return get_file_node(file, 0, node)
+#
+def get_whole_file(file):
+ f = try_open(file) # May raise NoSuchFile
+ text = f.read()
+ header, menu, footnotes = ('', '', ''), [], []
+ return file, '*', header, menu, footnotes, text
+#
+def get_file_node(file, offset, node):
+ f = try_open(file) # May raise NoSuchFile
+ text = find_node(f, offset, node) # May raise NoSuchNode
+ node, header, menu, footnotes = analyze_node(text)
+ return file, node, header, menu, footnotes, text
+
+
+# Parse a node reference into a file (possibly default) and node name.
+# Possible reference formats are: "NODE", "(FILE)", "(FILE)NODE".
+# Default file is the curfile argument; default node is Top.
+# A node value of '*' is a special case: the whole file should
+# be interpreted (by the caller!) as a single node.
+#
+def parse_ref(curfile, ref):
+ match = parsenoderef(ref)
+ if not match:
+ file, node = curfile, ref
+ else:
+ (a, b), (a1, b1), (a2, b2) = match
+ file, node = ref[a1:b1], ref[a2:b2]
+ if not file:
+ file = curfile # (Is this necessary?)
+ if not node:
+ node = 'Top'
+ return file, node
+
+
+# Extract node name, links, menu and footnotes from the node text.
+#
+def analyze_node(text):
+ #
+ # Get node name and links from the header line
+ #
+ match = findfirstline(text)
+ if match:
+ (a, b) = match[0]
+ line = text[a:b]
+ else:
+ line = ''
+ node = get_it(text, findnode)
+ prev = get_it(text, findprev)
+ next = get_it(text, findnext)
+ up = get_it(text, findup)
+ #
+ # Get the menu items, if there is a menu
+ #
+ menu = []
+ match = findmenu(text)
+ if match:
+ (a, b) = match[0]
+ while 1:
+ match = findmenuitem(text, b)
+ if not match:
+ break
+ (a, b), (a1, b1), (a2, b2) = match
+ topic, ref = text[a1:b1], text[a2:b2]
+ if ref == ':':
+ ref = topic
+ menu.append(topic, ref)
+ #
+ # Get the footnotes
+ #
+ footnotes = []
+ b = 0
+ while 1:
+ match = findfootnote(text, b)
+ if not match:
+ break
+ (a, b), (a1, b1), (a2, b2) = match
+ topic, ref = text[a1:b1], text[a2:b2]
+ if ref == ':':
+ ref = topic
+ footnotes.append(topic, ref)
+ #
+ return node, (prev, next, up), menu, footnotes
+#
+def get_it(line, matcher):
+ match = matcher(line)
+ if not match:
+ return ''
+ else:
+ (a, b), (a1, b1) = match
+ return line[a1:b1]
+
+
+# Find a node in an open file.
+# The offset (from the tags table) is a hint about the node's position.
+# Pass zero if there is no tags table.
+# Raise NoSuchNode if the node isn't found.
+# NB: This seeks around in the file.
+#
+def find_node(f, offset, node):
+ node = string.lower(node) # Just to be sure
+ #
+ # Position a little before the given offset,
+ # so we may find the node even if it has moved around
+ # in the file a little.
+ #
+ offset = max(0, ((offset-FUZZ) / BLOCKSIZE) * BLOCKSIZE)
+ f.seek(offset)
+ #
+ # Loop, hunting for a matching node header.
+ #
+ while 1:
+ buf = f.read(CHUNKSIZE)
+ if not buf:
+ break
+ i = 0
+ while 1:
+ match = findheader(buf, i)
+ if match:
+ (a,b), (a1,b1) = match
+ start = a1
+ line = buf[a1:b1]
+ i = b
+ match = parseheader(line)
+ if match:
+ (a,b), (a1,b1) = match
+ key = string.lower(line[a1:b1])
+ if key == node:
+ # Got it! Now read the rest.
+ return read_node(f, buf[start:])
+ elif findescape(buf, i):
+ next = f.read(CHUNKSIZE)
+ if not next:
+ break
+ buf = buf + next
+ else:
+ break
+ #
+ # If we get here, we didn't find it. Too bad.
+ #
+ raise NoSuchNode, node
+
+
+# Finish off getting a node (subroutine for find_node()).
+# The node begins at the start of buf and may end in buf;
+# if it doesn't end there, read additional data from f.
+#
+def read_node(f, buf):
+ i = 0
+ match = findescape(buf, i)
+ while not match:
+ next = f.read(CHUNKSIZE)
+ if not next:
+ end = len(buf)
+ break
+ i = len(buf)
+ buf = buf + next
+ match = findescape(buf, i)
+ else:
+ # Got a match
+ (a, b) = match[0]
+ end = a
+ # Strip trailing newlines
+ while end > 0 and buf[end-1] == '\n':
+ end = end-1
+ buf = buf[:end]
+ return buf
+
+
+# Read reverse starting at offset until the beginning of a node is found.
+# Then return a buffer containing the beginning of the node,
+# with f positioned just after the buffer.
+# The buffer will contain at least the full header line of the node;
+# the caller should finish off with read_node() if it is the right node.
+# (It is also possible that the buffer extends beyond the node!)
+# Return an empty string if there is no node before the given offset.
+#
+def backup_node(f, offset):
+ start = max(0, ((offset-CHUNKSIZE) / BLOCKSIZE) * BLOCKSIZE)
+ end = offset
+ while start < end:
+ f.seek(start)
+ buf = f.read(end-start)
+ i = 0
+ hit = -1
+ while 1:
+ match = findheader(buf, i)
+ if match:
+ (a,b), (a1,b1) = match
+ hit = a1
+ i = b
+ elif end < offset and findescape(buf, i):
+ next = f.read(min(offset-end, BLOCKSIZE))
+ if not next:
+ break
+ buf = buf + next
+ end = end + len(next)
+ else:
+ break
+ if hit >= 0:
+ return buf[hit:]
+ end = start
+ start = max(0, end - CHUNKSIZE)
+ return ''
+
+
+# Make a tag table for the given file by scanning the file.
+# The file must be open for reading, and positioned at the beginning
+# (or wherever the hunt for tags must begin; it is read till the end).
+#
+def make_tags(f):
+ tags = {}
+ while 1:
+ offset = f.tell()
+ buf = f.read(CHUNKSIZE)
+ if not buf:
+ break
+ i = 0
+ while 1:
+ match = findheader(buf, i)
+ if match:
+ (a,b), (a1,b1) = match
+ start = offset+a1
+ line = buf[a1:b1]
+ i = b
+ match = parseheader(line)
+ if match:
+ (a,b), (a1,b1) = match
+ key = string.lower(line[a1:b1])
+ if tags.has_key(key):
+ print 'Duplicate node:',
+ print key
+ tags[key] = '', start, line
+ elif findescape(buf, i):
+ next = f.read(CHUNKSIZE)
+ if not next:
+ break
+ buf = buf + next
+ else:
+ break
+ return tags
+
+
+# Try to open a file, return a file object if succeeds.
+# Raise NoSuchFile if the file can't be opened.
+# Should treat absolute pathnames special.
+#
+def try_open(file):
+ for dir in INFOPATH:
+ try:
+ return open(dir + file, 'r')
+ except RuntimeError:
+ pass
+ raise NoSuchFile, file
+
+
+# A little test for the speed of make_tags().
+#
+TESTFILE = 'texinfo-1'
+def test_make_tags():
+ import time
+ f = try_open(TESTFILE)
+ t1 = time.millitimer()
+ tags = make_tags(f)
+ t2 = time.millitimer()
+ print 'Making tag table for', `TESTFILE`, 'took', t2-t1, 'msec.'
--- /dev/null
+# Utility module for 'icache.py': interpret tag tables and indirect nodes.
+
+# (This module is a bit chatty when confronted with the unexpected.)
+
+
+import regexp
+import string
+import ifile
+
+
+# Get the tag table of an open file, as a dictionary.
+# Seeks around in the file; after reading, the position is undefined.
+# Return an empty tag table if none is found.
+#
+def get_tags(f):
+ #
+ # First see if the last "node" is the end of tag table marker.
+ #
+ f.seek(0, 2) # Seek to EOF
+ end = f.tell()
+ buf = ifile.backup_node(f, end)
+ if not labelmatch(buf, 0, 'end tag table\n'):
+ return {} # No succes
+ #
+ # Next backup to the previous "node" -- the tag table itself.
+ #
+ ###print 'Getting prebuilt tag table...'
+ end = f.tell() - len(buf)
+ buf = ifile.backup_node(f, end)
+ label = 'tag table:\n'
+ if not labelmatch(buf, 0, label):
+ print 'Weird: end tag table marker but no tag table?'
+ print 'Node begins:', `buf[:50]`
+ return {}
+ #
+ # Now read the whole tag table.
+ #
+ end = f.tell() - len(buf) # Do this first!
+ buf = ifile.read_node(f, buf)
+ #
+ # First check for an indirection table.
+ #
+ indirlist = []
+ if labelmatch(buf, len(label), '(indirect)\n'):
+ indirbuf = ifile.backup_node(f, end)
+ if not labelmatch(indirbuf, 0, 'indirect:\n'):
+ print 'Weird: promised indirection table not found'
+ print 'Node begins:', `indirbuf[:50]`
+ # Carry on. Things probably won't work though.
+ else:
+ indirbuf = ifile.read_node(f, indirbuf)
+ indirlist = parse_indirlist(indirbuf)
+ #
+ # Now parse the tag table.
+ #
+ findtag = regexp.compile('^(.*[nN]ode:[ \t]*(.*))\177([0-9]+)$').match
+ i = 0
+ tags = {}
+ while 1:
+ match = findtag(buf, i)
+ if not match:
+ break
+ (a,b), (a1,b1), (a2,b2), (a3,b3) = match
+ i = b
+ line = buf[a1:b1]
+ node = string.lower(buf[a2:b2])
+ offset = eval(buf[a3:b3]) # XXX What if it overflows?
+ if tags.has_key(node):
+ print 'Duplicate key in tag table:', `node`
+ file, offset = map_offset(offset, indirlist)
+ tags[node] = file, offset, line
+ #
+ return tags
+
+
+# Return true if buf[i:] begins with a label, after lower case conversion.
+# The label argument must be in lower case.
+#
+def labelmatch(buf, i, label):
+ return string.lower(buf[i:i+len(label)]) == label
+
+
+# Parse the indirection list.
+# Return a list of (filename, offset) pairs ready for use.
+#
+def parse_indirlist(buf):
+ list = []
+ findindir = regexp.compile('^(.+):[ \t]*([0-9]+)$').match
+ i = 0
+ while 1:
+ match = findindir(buf, i)
+ if not match:
+ break
+ (a,b), (a1,b1), (a2,b2) = match
+ file = buf[a1:b1]
+ offset = eval(buf[a2:b2]) # XXX What if this gets overflow?
+ list.append(file, offset)
+ i = b
+ return list
+
+
+# Map an offset through the indirection list.
+# Return (filename, new_offset).
+# If the list is empty, return the given offset and an empty file name.
+#
+def map_offset(offset, indirlist):
+ if not indirlist:
+ return '', offset
+ #
+ # XXX This could be done more elegant.
+ #
+ filex, offx = indirlist[0]
+ for i in range(len(indirlist)):
+ file1, off1 = indirlist[i]
+ if i+1 >= len(indirlist):
+ file2, off2 = '', 0x7fffffff
+ else:
+ file2, off2 = indirlist[i+1]
+ if off1 <= offset < off2:
+ # Add offx+2 to compensate for extra header.
+ # No idea whether this is always correct.
+ return file1, offset-off1 + offx+2
+ #
+ # XXX Shouldn't get here.
+ #
+ print 'Oops, map_offset fell through'
+ return '', offset # Not likely to get good results
--- /dev/null
+#! /usr/local/python
+
+# Watch line printer queues (only works with BSD 4.3 lpq).
+#
+# This brings up a window containing one line per printer argument.
+#
+# Each line gives a small summary of the printer's status and queue.
+# The status tries to give as much relevant information as possible,
+# and gives extra info if you have jobs in the queue.
+#
+# The line's background color gives a hint at the status: navajo white
+# for idle, green if your job is now printing, yellow/orange for
+# small/large queue, red for errors.
+#
+# To reduce the duration of the unresponsive time while it is waiting
+# for an lpq subprocess to finish, it polls one printer every
+# delay/len(printers) seconds. A tiny dot indicates the last printer
+# updated. Hit the mouse button in the window to update the next one.
+#
+# To do:
+# - add an argument to override the default delay
+# - add arguments to override the default colors
+# - better heuristic for small/large queue (and more colors!)
+# - mouse clicks should update the printer clicked in
+# - better visual appearance, e.g., boxes around the lines?
+
+import posix
+import sys
+import time
+import string
+
+import stdwin
+from stdwinevents import *
+import mainloop
+
+# Default parameters
+DEF_PRINTER = 'oce' # This is CWI specific!
+DEF_DELAY = 10
+
+# Color assignments
+c_unknown = stdwin.fetchcolor('white')
+c_idle = stdwin.fetchcolor('navajo white')
+c_ontop = stdwin.fetchcolor('green')
+c_smallqueue = stdwin.fetchcolor('yellow')
+c_bigqueue = stdwin.fetchcolor('orange')
+c_error = stdwin.fetchcolor('red')
+
+def main():
+ delay = DEF_DELAY
+ #
+ try:
+ thisuser = posix.environ['LOGNAME']
+ except:
+ thisuser = posix.environ['USER']
+ #
+ printers = sys.argv[1:]
+ if printers:
+ # Strip '-P' from printer names just in case
+ # the user specified it...
+ for i in range(len(printers)):
+ if printers[i][:2] == '-P':
+ printers[i] = printers[i][2:]
+ else:
+ if posix.environ.has_key('PRINTER'):
+ printers = [posix.environ['PRINTER']]
+ else:
+ printers = [DEF_PRINTER]
+ #
+ width = stdwin.textwidth('in')*20
+ height = len(printers) * stdwin.lineheight() + 5
+ stdwin.setdefwinsize(width, height)
+ stdwin.setdefscrollbars(0, 0)
+ #
+ win = stdwin.open('lpwin')
+ #
+ win.printers = printers
+ win.colors = [c_unknown] * len(printers)
+ win.texts = printers[:]
+ win.next = 0
+ win.delay = DEF_DELAY
+ win.thisuser = thisuser
+ win.dispatch = lpdispatch
+ #
+ win.settimer(1)
+ #
+ mainloop.register(win)
+ mainloop.mainloop()
+
+def lpdispatch(type, win, detail):
+ if type == WE_CLOSE or type == WE_CHAR and detail in ('q', 'Q'):
+ mainloop.unregister(win)
+ elif type == WE_DRAW:
+ drawproc(win)
+ elif type == WE_TIMER:
+ update(win)
+ win.change((0,0), (10000, 10000))
+ elif type == WE_MOUSE_UP:
+ win.settimer(1)
+
+def drawproc(win):
+ d = win.begindrawing()
+ offset = d.textwidth('.')
+ h, v = 0, 0
+ for i in range(len(win.printers)):
+ text = win.texts[i]
+ color = win.colors[i]
+ d.setbgcolor(color)
+ d.erase((h, v), (h+10000, v+d.lineheight()))
+ if (i+1) % len(win.printers) == win.next and color <> c_unknown:
+ d.text((h, v), '.')
+ d.text((h+offset, v), text)
+ v = v + d.lineheight()
+
+def update(win):
+ i = win.next
+ win.next = (i+1) % len(win.printers)
+ win.texts[i], win.colors[i] = makestatus(win.printers[i], win.thisuser)
+ win.settimer(int(win.delay * 10.0 / len(win.printers)))
+
+def makestatus(name, thisuser):
+ pipe = posix.popen('lpq -P' + name + ' 2>&1', 'r')
+ lines = []
+ users = {}
+ aheadbytes = 0
+ aheadjobs = 0
+ userseen = 0
+ totalbytes = 0
+ totaljobs = 0
+ color = c_unknown
+ while 1:
+ line = pipe.readline()
+ if not line: break
+ fields = string.split(line)
+ n = len(fields)
+ if len(fields) >= 6 and fields[n-1] == 'bytes':
+ rank = fields[0]
+ user = fields[1]
+ job = fields[2]
+ files = fields[3:-2]
+ bytes = eval(fields[n-2])
+ if user == thisuser:
+ userseen = 1
+ if aheadjobs == 0:
+ color = c_ontop
+ elif not userseen:
+ aheadbytes = aheadbytes + bytes
+ aheadjobs = aheadjobs + 1
+ totalbytes = totalbytes + bytes
+ totaljobs = totaljobs + 1
+ if color == c_unknown:
+ color = c_smallqueue
+ elif color == c_smallqueue:
+ color = c_bigqueue
+ if users.has_key(user):
+ ujobs, ubytes = users[user]
+ else:
+ ujobs, ubytes = 0, 0
+ ujobs = ujobs + 1
+ ubytes = ubytes + bytes
+ users[user] = ujobs, ubytes
+ else:
+ if fields and fields[0] <> 'Rank':
+ line = string.strip(line)
+ if line == 'no entries':
+ line = name + ': idle'
+ if color == c_unknown:
+ color = c_idle
+ elif line[-22:] == ' is ready and printing':
+ line = line[:-22]
+ else:
+ line = name + ': ' + line
+ color = c_error
+ lines.append(line)
+ #
+ if totaljobs:
+ line = `(totalbytes+1023)/1024` + ' K'
+ if totaljobs <> len(users):
+ line = line + ' (' + `totaljobs` + ' jobs)'
+ if len(users) == 1:
+ line = line + ' for ' + users.keys()[0]
+ else:
+ line = line + ' for ' + `len(users)` + ' users'
+ if userseen:
+ if aheadjobs == 0:
+ line = line + ' (' + thisuser + ' first)'
+ else:
+ line = line + ' (' + `(aheadbytes+1023)/1024`
+ line = line + ' K before ' + thisuser + ')'
+ lines.append(line)
+ #
+ sts = pipe.close()
+ if sts:
+ lines.append('lpq exit status ' + `sts`)
+ color = c_error
+ return string.joinfields(lines, ': '), color
+
+main()
--- /dev/null
+#! /usr/local/python
+
+# A minimal single-window text editor using STDWIN's text objects.
+#
+# Usage: microedit file
+#
+# This is not intended as a real application but as an introduction
+# to STDWIN programming in Python, especially text objects.
+# Once you understand microedit.py, study miniedit.py to learn
+# about multiple windows and menus, cut and paste, etc.
+
+
+import sys
+import stdwin
+from stdwinevents import *
+
+
+# Main program
+#
+def main():
+ #
+ # Get the filename argument and read its contents as one very
+ # large string.
+ # An exception will terminate the program if there is no argument
+ # or if the file could not be read...
+ #
+ filename = sys.argv[1]
+ fp = open(filename, 'r')
+ contents = fp.read()
+ del fp # Close the file
+ #
+ # Create the window, using the filename as window title
+ #
+ window = stdwin.open(filename)
+ #
+ # Add a simple File menu to the window with two items
+ #
+ filemenu = window.menucreate('File')
+ filemenu.additem('Save', 'S') # Item 0 (shortcut Meta-S)
+ filemenu.additem('Save As...') # Item 1
+ #
+ # Create a text object occupying the entire window
+ # and fill it with the file's contents
+ #
+ corner = window.getwinsize() # (width, height)
+ area = (0, 0), corner # Rectangle as large as the window
+ text = window.textcreate(area)
+ text.settext(contents)
+ del contents # Get rid of contents object
+ fix_textsize(window, text) # Set document size accordingly
+ #
+ # Main event loop -- stop if a close request comes in.
+ #
+ # STDWIN applications should regularly call stdwin.getevent()
+ # otherwise the windows won't function as expected.
+ #
+ while 1:
+ #
+ # Get the next event
+ #
+ type, w, detail = e = stdwin.getevent()
+ #
+ # Event decoding switch
+ #
+ if type == WE_CLOSE:
+ break # Stop (no check for saved file!)
+ elif type == WE_SIZE:
+ #
+ # The window was resized --
+ # let the text object recompute the line breaks
+ # and change the document size accordingly,
+ # so scroll bars will work
+ #
+ fix_textsize(window, text)
+ elif type == WE_MENU:
+ #
+ # Execute a file menu request (our only menu)
+ #
+ menu, item = detail
+ if item == 0:
+ #
+ # "Save": save to the current filename
+ #
+ dummy = save_file(window, text, filename)
+ elif item == 1:
+ #
+ # "Save As": ask a new filename, save to it,
+ # and make it the current filename
+ #
+ # NB: askfile raises KeyboardInterrupt
+ # if the user cancels the dialog, hence
+ # the try statement
+ #
+ try:
+ newfile = stdwin.askfile( \
+ 'Save as:', filename, 1)
+ except KeyboardInterrupt:
+ newfile = ''
+ if newfile:
+ if save_file(window, text, newfile):
+ filename = newfile
+ window.settitle(filename)
+ elif text.event(e):
+ #
+ # The text object has handled the event.
+ # Fix the document size if necessary.
+ # Note: this sometimes fixes the size
+ # unnecessarily, e.g., for arrow keys.
+ #
+ if type in (WE_CHAR, WE_COMMAND):
+ fix_docsize(window, text)
+
+
+# Save the window's contents to the filename.
+# If the open() fails, put up a warning message and return 0;
+# if the save succeeds, return 1.
+#
+def save_file(window, text, filename):
+ #
+ # Open the file for writing, handling exceptions
+ #
+ try:
+ fp = open(filename, 'w')
+ except RuntimeError:
+ stdwin.message('Cannot create ' + filename)
+ return 0
+ #
+ # Get the contents of the text object as one very long string
+ #
+ contents = text.gettext()
+ #
+ # Write the contents to the file
+ #
+ fp.write(contents)
+ #
+ # The file is automatically closed when this routine returns
+ #
+ return 1
+
+
+# Change the size of the text object to fit in the window,
+# and then fix the window's document size to fit around the text object.
+#
+def fix_textsize(window, text):
+ #
+ # Compute a rectangle as large as the window
+ #
+ corner = window.getwinsize() # (width, height)
+ area = (0, 0), (corner)
+ #
+ # Move the text object to this rectangle.
+ # Note: text.move() ignores the bottom coordinate!
+ #
+ text.move(area)
+ #
+ # Now fix the document size accordingly
+ #
+ fix_docsize(window, text)
+
+
+# Fix the document size, after the text has changed
+#
+def fix_docsize(window, text):
+ #
+ # Get the actual rectangle occupied by the text object.
+ # This has the same left, top and right, but a different bottom.
+ #
+ area = text.getrect()
+ #
+ # Compute the true height of the text object
+ #
+ origin, corner = area
+ width, height = corner
+ #
+ # Set the document height to the text object's height.
+ # The width is zero since we don't want a horizontal scroll bar.
+ #
+ window.setdocsize(0, height)
+
+
+# Once all functions are defined, call main()
+#
+main()
--- /dev/null
+#! /usr/local/python
+
+# A miniature multi-window editor using STDWIN's text objects.
+#
+# Usage: miniedit [file] ...
+#
+# The user interface is similar to that of the miniedit demo application
+# in C that comes with STDWIN.
+#
+# XXX need to comment the functions
+# XXX Not yet implemented:
+# disabling menu entries for inapplicable actions
+# Find operations
+
+
+import sys
+import stdwin
+from stdwinevents import *
+
+
+# Constant: list of WE_COMMAND events that (may) change the text buffer
+# so we can decide whether to set the 'changed' flag.
+# Note that it is possible for such a command to fail (a backspace
+# at the beginning of the buffer) but we'll set the changed flag anyway
+# -- it's too complicated to check this condition right now.
+#
+changing = [WC_RETURN, WC_TAB, WC_BACKSPACE]
+
+
+# The list of currently open windows;
+# this is maintained so we can stop when there are no windows left
+#
+windows = []
+
+
+# A note on window data attributes (set by open_window):
+#
+# w.textobject the window's text object
+# w.changed true when the window's text is changed
+# w.filename filename connected to the window; '' if none
+
+
+# Main program
+#
+def main():
+ #
+ # Set a reasonable default window size.
+ # If we are using a fixed-width font this will open a 80x24 window;
+ # for variable-width fonts we approximate this based on an average
+ #
+ stdwin.setdefwinsize(40*stdwin.textwidth('in'), 24*stdwin.lineheight())
+ #
+ # Create global menus (as local variables)
+ #
+ filemenu = make_file_menu(stdwin)
+ editmenu = make_edit_menu(stdwin)
+ findmenu = make_find_menu(stdwin)
+ #
+ # Get the list of files from the command line (maybe none)
+ #
+ files = sys.argv[1:]
+ #
+ # Open any files -- errors will be reported but do won't stop us
+ #
+ for filename in files:
+ open_file(filename)
+ #
+ # If there were no files, or none of them could be opened,
+ # put up a dialog asking for a filename
+ #
+ if not windows:
+ try:
+ open_dialog(None)
+ except KeyboardInterrupt:
+ pass # User cancelled
+ #
+ # If the dialog was cancelled, create an empty new window
+ #
+ if not windows:
+ new_window(None)
+ #
+ # Main event loop -- stop when we have no open windows left
+ #
+ while windows:
+ #
+ # Get the next event -- ignore interrupts
+ #
+ try:
+ type, window, detail = event = stdwin.getevent()
+ except KeyboardInterrupt:
+ type, window, detail = event = WE_NONE, None, None
+ #
+ # Event decoding switch
+ #
+ if not window:
+ pass # Ignore such events
+ elif type == WE_MENU:
+ #
+ # Execute menu operation
+ #
+ menu, item = detail
+ try:
+ menu.actions[item](window)
+ except KeyboardInterrupt:
+ pass # User cancelled
+ elif type == WE_CLOSE:
+ #
+ # Close a window
+ #
+ try:
+ close_dialog(window)
+ except KeyboardInterrupt:
+ pass # User cancelled
+ elif type == WE_SIZE:
+ #
+ # A window was resized --
+ # let the text object recompute the line breaks
+ # and change the document size accordingly,
+ # so scroll bars will work
+ #
+ fix_textsize(window)
+ elif window.textobject.event(event):
+ #
+ # The event was eaten by the text object --
+ # set the changed flag if not already set
+ #
+ if type == WE_CHAR or \
+ type == WE_COMMAND and detail in changing:
+ window.changed = 1
+ fix_docsize(window)
+ #
+ # Delete all objects that may still reference the window
+ # in the event -- this is needed otherwise the window
+ # won't actually be closed and may receive further
+ # events, which will confuse the event decoder
+ #
+ del type, window, detail, event
+
+
+def make_file_menu(object):
+ menu = object.menucreate('File')
+ menu.actions = []
+ additem(menu, 'New', 'N', new_window)
+ additem(menu, 'Open..', 'O', open_dialog)
+ additem(menu, '', '', None)
+ additem(menu, 'Save', 'S', save_dialog)
+ additem(menu, 'Save As..', '', save_as_dialog)
+ additem(menu, 'Save a Copy..', '', save_copy_dialog)
+ additem(menu, 'Revert', 'R', revert_dialog)
+ additem(menu, 'Quit', 'Q', quit_dialog)
+ return menu
+
+
+def make_edit_menu(object):
+ menu = object.menucreate('Edit')
+ menu.actions = []
+ additem(menu, 'Cut', 'X', do_cut)
+ additem(menu, 'Copy', 'C', do_copy)
+ additem(menu, 'Paste', 'V', do_paste)
+ additem(menu, 'Clear', 'B', do_clear)
+ additem(menu, 'Select All', 'A', do_select_all)
+ return menu
+
+
+def make_find_menu(object):
+ menu = object.menucreate('Find')
+ menu.actions = []
+ # XXX
+ return menu
+
+
+def additem(menu, text, shortcut, function):
+ if shortcut:
+ menu.additem(text, shortcut)
+ else:
+ menu.additem(text)
+ menu.actions.append(function)
+
+
+def open_dialog(current_ignored):
+ filename = stdwin.askfile('Open file:', '', 0)
+ open_file(filename)
+
+
+def open_file(filename):
+ try:
+ fp = open(filename, 'r')
+ except RuntimeError:
+ stdwin.message(filename + ': cannot open')
+ return # Error, forget it
+ try:
+ contents = fp.read()
+ except RuntimeError:
+ stdwin.message(filename + ': read error')
+ return # Error, forget it
+ del fp # Close the file
+ open_window(filename, filename, contents)
+
+
+def new_window(current_ignored):
+ open_window('', 'Untitled', '')
+
+
+def open_window(filename, title, contents):
+ try:
+ window = stdwin.open(title)
+ except RuntimeError:
+ stdwin.message('cannot open new window')
+ return # Error, forget it
+ window.textobject = window.textcreate((0, 0), window.getwinsize())
+ window.textobject.settext(contents)
+ window.changed = 0
+ window.filename = filename
+ fix_textsize(window)
+ windows.append(window)
+
+
+def quit_dialog(window):
+ for window in windows[:]:
+ close_dialog(window)
+
+
+def close_dialog(window):
+ if window.changed:
+ prompt = 'Save changes to ' + window.gettitle() + ' ?'
+ if stdwin.askync(prompt, 1):
+ save_dialog(window)
+ if window.changed:
+ return # Save failed (not) cancelled
+ windows.remove(window)
+ del window.textobject
+
+
+def save_dialog(window):
+ if not window.filename:
+ save_as_dialog(window)
+ return
+ if save_file(window, window.filename):
+ window.changed = 0
+
+
+def save_as_dialog(window):
+ prompt = 'Save ' + window.gettitle() + ' as:'
+ filename = stdwin.askfile(prompt, window.filename, 1)
+ if save_file(window, filename):
+ window.filename = filename
+ window.settitle(filename)
+ window.changed = 0
+
+
+def save_copy_dialog(window):
+ prompt = 'Save a copy of ' + window.gettitle() + ' as:'
+ filename = stdwin.askfile(prompt, window.filename, 1)
+ void = save_file(window, filename)
+
+
+def save_file(window, filename):
+ try:
+ fp = open(filename, 'w')
+ except RuntimeError:
+ stdwin.message(filename + ': cannot create')
+ return 0
+ contents = window.textobject.gettext()
+ try:
+ fp.write(contents)
+ except RuntimeError:
+ stdwin.message(filename + ': write error')
+ return 0
+ return 1
+
+
+def revert_dialog(window):
+ if not window.filename:
+ stdwin.message('This window has no file to revert from')
+ return
+ if window.changed:
+ prompt = 'Really read ' + window.filename + ' back from file?'
+ if not stdwin.askync(prompt, 1):
+ return
+ try:
+ fp = open(window.filename, 'r')
+ except RuntimeError:
+ stdwin.message(filename + ': cannot open')
+ return
+ contents = fp.read()
+ del fp # Close the file
+ window.textobject.settext(contents)
+ window.changed = 0
+ fix_docsize(window)
+
+
+def fix_textsize(window):
+ corner = window.getwinsize()
+ area = (0, 0), (corner)
+ window.textobject.move(area)
+ fix_docsize(window)
+
+
+def fix_docsize(window):
+ area = window.textobject.getrect()
+ origin, corner = area
+ width, height = corner
+ window.setdocsize(0, height)
+
+
+def do_cut(window):
+ selection = window.textobject.getfocustext()
+ if not selection:
+ stdwin.fleep() # Nothing to cut
+ elif not window.setselection(WS_PRIMARY, selection):
+ stdwin.fleep() # Window manager glitch...
+ else:
+ stdwin.rotatecutbuffers(1)
+ stdwin.setcutbuffer(0, selection)
+ window.textobject.replace('')
+ window.changed = 1
+ fix_docsize(window)
+
+
+def do_copy(window):
+ selection = window.textobject.getfocustext()
+ if not selection:
+ stdwin.fleep() # Nothing to cut
+ elif not window.setselection(WS_PRIMARY, selection):
+ stdwin.fleep() # Window manager glitch...
+ else:
+ stdwin.rotatecutbuffers(1)
+ stdwin.setcutbuffer(0, selection)
+
+
+def do_paste(window):
+ selection = stdwin.getselection(WS_PRIMARY)
+ if not selection:
+ selection = stdwin.getcutbuffer(0)
+ if not selection:
+ stdwin.fleep() # Nothing to paste
+ else:
+ window.textobject.replace(selection)
+ window.changed = 1
+ fix_docsize(window)
+
+def do_clear(window):
+ first, last = window.textobject.getfocus()
+ if first == last:
+ stdwin.fleep() # Nothing to clear
+ else:
+ window.textobject.replace('')
+ window.changed = 1
+ fix_docsize(window)
+
+
+def do_select_all(window):
+ window.textobject.setfocus(0, 0x7fffffff) # XXX Smaller on the Mac!
+
+
+main()
--- /dev/null
+#! /usr/local/python
+
+XXX This file needs some work for Python 0.9.6!!!
+
+# A STDWIN-based front end for the Python interpreter.
+#
+# This is useful if you want to avoid console I/O and instead
+# use text windows to issue commands to the interpreter.
+#
+# It supports multiple interpreter windows, each with its own context.
+#
+# BUGS AND CAVEATS:
+#
+# Although this supports multiple windows, the whole application
+# is deaf and dumb when a command is running in one window.
+#
+# Everything written to stdout or stderr is saved on a file which
+# is inserted in the window at the next input request.
+#
+# On UNIX (using X11), interrupts typed in the window will not be
+# seen until the next input request. (On the Mac, interrupts work.)
+#
+# Direct input from stdin should not be attempted.
+
+
+import sys
+import builtin
+import stdwin
+from stdwinevents import *
+import rand
+import mainloop
+
+from util import readfile # 0.9.1
+
+try:
+ import mac
+ os = mac
+except NameError:
+ import posix
+ os = posix
+
+
+# Filename used to capture output from commands; change to suit your taste
+#
+OUTFILE = '@python.stdout.tmp'
+
+
+# Stack of windows waiting for [raw_]input().
+# Element [0] is the top.
+# If there are multiple windows waiting for input, only the
+# one on top of the stack can accept input, because the way
+# raw_input() is implemented (using recursive mainloop() calls).
+#
+inputwindows = []
+
+
+# Exception raised when input is available.
+#
+InputAvailable = 'input available for raw_input (not an error)'
+
+
+# Main program. Create the window and call the mainloop.
+#
+def main():
+ # Hack so 'import python' won't load another copy
+ # of this if we were loaded though 'python python.py'.
+ # (Should really look at sys.argv[0]...)
+ if 'inputwindows' in dir(sys.modules['__main__']) and \
+ sys.modules['__main__'].inputwindows is inputwindows:
+ sys.modules['python'] = sys.modules['__main__']
+ #
+ win = makewindow()
+ mainloop.mainloop()
+
+
+# Create a new window.
+#
+def makewindow():
+ # stdwin.setdefscrollbars(0, 1) # Not in Python 0.9.1
+ # stdwin.setfont('monaco') # Not on UNIX! and not Python 0.9.1
+ # stdwin.setdefwinsize(stdwin.textwidth('in')*40, stdwin.lineheight() * 24)
+ win = stdwin.open('Python interpreter ready')
+ win.editor = win.textcreate((0,0), win.getwinsize())
+ win.outfile = OUTFILE + `rand.rand()`
+ win.globals = {} # Dictionary for user's global variables
+ win.command = '' # Partially read command
+ win.busy = 0 # Ready to accept a command
+ win.auto = 1 # [CR] executes command
+ win.insertOutput = 1 # Insert output at focus.
+ win.insertError = 1 # Insert error output at focus.
+ win.setwincursor('ibeam')
+ win.filename = '' # Empty if no file associated with this window
+ makefilemenu(win)
+ makeeditmenu(win)
+ win.dispatch = pdispatch # Event dispatch function
+ mainloop.register(win)
+ return win
+
+
+# Make a 'File' menu
+#
+def makefilemenu(win):
+ win.filemenu = mp = win.menucreate('File')
+ mp.callback = []
+ additem(mp, 'New', 'N', do_new)
+ additem(mp, 'Open...', 'O', do_open)
+ additem(mp, '', '', None)
+ additem(mp, 'Close', 'W', do_close)
+ additem(mp, 'Save', 'S', do_save)
+ additem(mp, 'Save as...', '', do_saveas)
+ additem(mp, '', '', None)
+ additem(mp, 'Quit', 'Q', do_quit)
+
+
+# Make an 'Edit' menu
+#
+def makeeditmenu(win):
+ win.editmenu = mp = win.menucreate('Edit')
+ mp.callback = []
+ additem(mp, 'Cut', 'X', do_cut)
+ additem(mp, 'Copy', 'C', do_copy)
+ additem(mp, 'Paste', 'V', do_paste)
+ additem(mp, 'Clear', '', do_clear)
+ additem(mp, '', '', None)
+ win.iauto = len(mp.callback)
+ additem(mp, 'Autoexecute', '', do_auto)
+ mp.check(win.iauto, win.auto)
+ win.insertOutputNum = len(mp.callback)
+ additem(mp, 'Insert Output', '', do_insertOutputOption)
+ win.insertErrorNum = len(mp.callback)
+ additem(mp, 'Insert Error', '', do_insertErrorOption)
+ additem(mp, 'Exec', '\r', do_exec)
+
+
+# Helper to add a menu item and callback function
+#
+def additem(mp, text, shortcut, handler):
+ if shortcut:
+ mp.additem(text, shortcut)
+ else:
+ mp.additem(text)
+ mp.callback.append(handler)
+
+
+# Dispatch a single event to the interpreter.
+# Resize events cause a resize of the editor.
+# Other events are directly sent to the editor.
+#
+# Exception: WE_COMMAND/WC_RETURN causes the current selection
+# (if not empty) or current line (if empty) to be sent to the
+# interpreter. (In the future, there should be a way to insert
+# newlines in the text; or perhaps Enter or Meta-RETURN should be
+# used to trigger execution, like in MPW, though personally I prefer
+# using a plain Return to trigger execution, as this is what I want
+# in the majority of cases.)
+#
+# Also, WE_COMMAND/WC_CANCEL cancels any command in progress.
+#
+def pdispatch(event):
+ type, win, detail = event
+ if type == WE_CLOSE:
+ do_close(win)
+ elif type == WE_SIZE:
+ win.editor.move((0, 0), win.getwinsize())
+ elif type == WE_COMMAND and detail == WC_RETURN:
+ if win.auto:
+ do_exec(win)
+ else:
+ void = win.editor.event(event)
+ elif type == WE_COMMAND and detail == WC_CANCEL:
+ if win.busy:
+ raise InputAvailable, (EOFError, None)
+ else:
+ win.command = ''
+ settitle(win)
+ elif type == WE_MENU:
+ mp, item = detail
+ mp.callback[item](win)
+ else:
+ void = win.editor.event(event)
+ if win.editor:
+ # May have been deleted by close...
+ win.setdocsize(0, win.editor.getrect()[1][1])
+ if type in (WE_CHAR, WE_COMMAND):
+ win.editor.setfocus(win.editor.getfocus())
+
+
+# Helper to set the title of the window.
+#
+def settitle(win):
+ if win.filename == '':
+ win.settitle('Python interpreter ready')
+ else:
+ win.settitle(win.filename)
+
+
+# Helper to replace the text of the focus.
+#
+def replace(win, text):
+ win.editor.replace(text)
+ # Resize the window to display the text
+ win.setdocsize(0, win.editor.getrect()[1][1]) # update the size before..
+ win.editor.setfocus(win.editor.getfocus()) # move focus to the change - dml
+
+
+# File menu handlers
+#
+def do_new(win):
+ win = makewindow()
+#
+def do_open(win):
+ try:
+ filename = stdwin.askfile('Open file', '', 0)
+ win = makewindow()
+ win.filename = filename
+ win.editor.replace(readfile(filename)) # 0.9.1
+ # win.editor.replace(open(filename, 'r').read()) # 0.9.2
+ win.editor.setfocus(0, 0)
+ win.settitle(win.filename)
+ #
+ except KeyboardInterrupt:
+ pass # Don't give an error on cancel.
+#
+def do_save(win):
+ try:
+ if win.filename == '':
+ win.filename = stdwin.askfile('Open file', '', 1)
+ f = open(win.filename, 'w')
+ f.write(win.editor.gettext())
+ #
+ except KeyboardInterrupt:
+ pass # Don't give an error on cancel.
+
+def do_saveas(win):
+ currentFilename = win.filename
+ win.filename = ''
+ do_save(win) # Use do_save with empty filename
+ if win.filename == '': # Restore the name if do_save did not set it.
+ win.filename = currentFilename
+#
+def do_close(win):
+ if win.busy:
+ stdwin.message('Can\'t close busy window')
+ return # need to fail if quitting??
+ win.editor = None # Break circular reference
+ #del win.editmenu # What about the filemenu??
+ try:
+ os.unlink(win.outfile)
+ except os.error:
+ pass
+ mainloop.unregister(win)
+#
+def do_quit(win):
+ # Call win.dispatch instead of do_close because there
+ # may be 'alien' windows in the list.
+ for win in mainloop.windows:
+ mainloop.dispatch(WE_CLOSE, win, None) # need to catch failed close
+
+
+# Edit menu handlers
+#
+def do_cut(win):
+ text = win.editor.getfocustext()
+ if not text:
+ stdwin.fleep()
+ return
+ stdwin.setcutbuffer(0, text)
+ replace(win, '')
+#
+def do_copy(win):
+ text = win.editor.getfocustext()
+ if not text:
+ stdwin.fleep()
+ return
+ stdwin.setcutbuffer(0, text)
+#
+def do_paste(win):
+ text = stdwin.getcutbuffer(0)
+ if not text:
+ stdwin.fleep()
+ return
+ replace(win, text)
+#
+def do_clear(win):
+ replace(win, '')
+
+#
+# These would be better in a preferences dialog:
+def do_auto(win):
+ win.auto = (not win.auto)
+ win.editmenu.check(win.iauto, win.auto)
+#
+def do_insertOutputOption(win):
+ win.insertOutput = (not win.insertOutput)
+ title = ['Append Output', 'Insert Output'][win.insertOutput]
+ win.editmenu.setitem(win.insertOutputNum, title)
+#
+def do_insertErrorOption(win):
+ win.insertError = (not win.insertError)
+ title = ['Error Dialog', 'Insert Error'][win.insertError]
+ win.editmenu.setitem(win.insertErrorNum, title)
+
+
+# Extract a command from the editor and execute it, or pass input to
+# an interpreter waiting for it.
+# Incomplete commands are merely placed in the window's command buffer.
+# All exceptions occurring during the execution are caught and reported.
+# (Tracebacks are currently not possible, as the interpreter does not
+# save the traceback pointer until it reaches its outermost level.)
+#
+def do_exec(win):
+ if win.busy:
+ if win not in inputwindows:
+ stdwin.message('Can\'t run recursive commands')
+ return
+ if win <> inputwindows[0]:
+ stdwin.message( \
+ 'Please complete recursive input first')
+ return
+ #
+ # Set text to the string to execute.
+ a, b = win.editor.getfocus()
+ alltext = win.editor.gettext()
+ n = len(alltext)
+ if a == b:
+ # There is no selected text, just an insert point;
+ # so execute the current line.
+ while 0 < a and alltext[a-1] <> '\n': a = a-1 # Find beginning of line.
+ while b < n and alltext[b] <> '\n': # Find end of line after b.
+ b = b+1
+ text = alltext[a:b] + '\n'
+ else:
+ # Execute exactly the selected text.
+ text = win.editor.getfocustext()
+ if text[-1:] <> '\n': # Make sure text ends with newline.
+ text = text + '\n'
+ while b < n and alltext[b] <> '\n': # Find end of line after b.
+ b = b+1
+ #
+ # Set the focus to expect the output, since there is always something.
+ # Output will be inserted at end of line after current focus,
+ # or appended to the end of the text.
+ b = [n, b][win.insertOutput]
+ win.editor.setfocus(b, b)
+ #
+ # Make sure there is a preceeding newline.
+ if alltext[b-1:b] <> '\n':
+ win.editor.replace('\n')
+ #
+ #
+ if win.busy:
+ # Send it to raw_input() below
+ raise InputAvailable, (None, text)
+ #
+ # Like the real Python interpreter, we want to execute
+ # single-line commands immediately, but save multi-line
+ # commands until they are terminated by a blank line.
+ # Unlike the real Python interpreter, we don't do any syntax
+ # checking while saving up parts of a multi-line command.
+ #
+ # The current heuristic to determine whether a command is
+ # the first line of a multi-line command simply checks whether
+ # the command ends in a colon (followed by a newline).
+ # This is not very robust (comments and continuations will
+ # confuse it), but it is usable, and simple to implement.
+ # (It even has the advantage that single-line loops etc.
+ # don't need te be terminated by a blank line.)
+ #
+ if win.command:
+ # Already continuing
+ win.command = win.command + text
+ if win.command[-2:] <> '\n\n':
+ win.settitle('Unfinished command...')
+ return # Need more...
+ else:
+ # New command
+ win.command = text
+ if text[-2:] == ':\n':
+ win.settitle('Unfinished command...')
+ return
+ command = win.command
+ win.command = ''
+ win.settitle('Executing command...')
+ #
+ # Some hacks: sys.stdout is temporarily redirected to a file,
+ # so we can intercept the command's output and insert it
+ # in the editor window; the built-in function raw_input
+ # and input() are replaced by out versions;
+ # and a second, undocumented argument
+ # to exec() is used to specify the directory holding the
+ # user's global variables. (If this wasn't done, the
+ # exec would be executed in the current local environment,
+ # and the user's assignments to globals would be lost...)
+ #
+ save_input = builtin.input
+ save_raw_input = builtin.raw_input
+ save_stdout = sys.stdout
+ save_stderr = sys.stderr
+ iwin = Input().init(win)
+ try:
+ builtin.input = iwin.input
+ builtin.raw_input = iwin.raw_input
+ sys.stdout = sys.stderr = open(win.outfile, 'w')
+ win.busy = 1
+ try:
+ exec(command, win.globals)
+ except KeyboardInterrupt:
+ pass # Don't give an error.
+ except:
+ msg = sys.exc_type
+ if sys.exc_value <> None:
+ msg = msg + ': ' + `sys.exc_value`
+ if win.insertError:
+ stdwin.fleep()
+ replace(win, msg + '\n')
+ else:
+ win.settitle('Unhandled exception')
+ stdwin.message(msg)
+ finally:
+ # Restore redirected I/O in *all* cases
+ win.busy = 0
+ sys.stderr = save_stderr
+ sys.stdout = save_stdout
+ builtin.raw_input = save_raw_input
+ builtin.input = save_input
+ settitle(win)
+ getoutput(win)
+
+
+# Read any output the command may have produced back from the file
+# and show it. Optionally insert it after the focus, like MPW does,
+# or always append at the end.
+#
+def getoutput(win):
+ filename = win.outfile
+ try:
+ fp = open(filename, 'r')
+ except:
+ stdwin.message('Can\'t read output from ' + filename)
+ return
+ #out = fp.read() # Not in Python 0.9.1
+ out = fp.read(10000) # For Python 0.9.1
+ del fp # Close it
+ if out or win.insertOutput:
+ replace(win, out)
+
+
+# Implementation of input() and raw_input().
+# This uses a class only because we must support calls
+# with and without arguments; this can't be done normally in Python,
+# but the extra, implicit argument for instance methods does the trick.
+#
+class Input:
+ #
+ def init(self, win):
+ self.win = win
+ return self
+ #
+ def input(args):
+ # Hack around call with or without argument:
+ if type(args) == type(()):
+ self, prompt = args
+ else:
+ self, prompt = args, ''
+ #
+ return eval(self.raw_input(prompt), self.win.globals)
+ #
+ def raw_input(args):
+ # Hack around call with or without argument:
+ if type(args) == type(()):
+ self, prompt = args
+ else:
+ self, prompt = args, ''
+ #
+ print prompt # Need to terminate with newline.
+ sys.stdout.close()
+ sys.stdout = sys.stderr = None
+ getoutput(self.win)
+ sys.stdout = sys.stderr = open(self.win.outfile, 'w')
+ save_title = self.win.gettitle()
+ n = len(inputwindows)
+ title = n*'(' + 'Requesting input...' + ')'*n
+ self.win.settitle(title)
+ inputwindows.insert(0, self.win)
+ try:
+ mainloop.mainloop()
+ except InputAvailable, (exc, val): # See do_exec above.
+ if exc:
+ raise exc, val
+ if val[-1:] == '\n':
+ val = val[:-1]
+ return val
+ finally:
+ del inputwindows[0]
+ self.win.settitle(save_title)
+ # If we don't catch InputAvailable, something's wrong...
+ raise EOFError
+ #
+
+
+# Currently unused function to test a command's syntax without executing it
+#
+def testsyntax(s):
+ import string
+ lines = string.splitfields(s, '\n')
+ for i in range(len(lines)): lines[i] = '\t' + lines[i]
+ lines.insert(0, 'if 0:')
+ lines.append('')
+ exec(string.joinfields(lines, '\n'))
+
+
+# Call the main program.
+#
+main()
--- /dev/null
+#! /usr/local/python
+
+# A window-oriented recursive diff utility.
+# NB: This uses undocumented window classing modules.
+
+# TO DO:
+# - faster update after moving/copying one file
+# - diff flags (-b, etc.) should be global or maintained per window
+# - use a few fixed windows instead of creating new ones all the time
+# - ways to specify patterns to skip
+# (best by pointing at a file and clicking a special menu entry!)
+# - add rcsdiff menu commands
+# - add a way to view status of selected files without opening them
+# - add a way to diff two files with different names
+# - add a way to rename files
+# - keep backups of overwritten/deleted files
+# - a way to mark specified files as uninteresting for dircmp
+
+import sys
+import os
+import rand
+import commands
+import dircache
+import statcache
+import cmp
+import cmpcache
+import stdwin
+import gwin
+import textwin
+import filewin
+import tablewin
+import anywin
+
+mkarg = commands.mkarg
+mk2arg = commands.mk2arg
+
+# List of names to ignore in dircmp()
+#
+skiplist = ['RCS', '.Amake', 'tags', '.', '..']
+
+# Function to determine whether a name should be ignored in dircmp().
+#
+def skipthis(file):
+ return file[-1:] == '~' or file in skiplist
+
+
+def anydiff(a, b, flags): # Display differences between any two objects
+ print 'diff', flags, a, b
+ if os.path.isdir(a) and os.path.isdir(b):
+ w = dirdiff(a, b, flags)
+ else:
+ w = filediff(a, b, flags)
+ addstatmenu(w, [a, b])
+ w.original_close = w.close
+ w.close = close_dirwin
+ return w
+
+def close_dirwin(w):
+ close_subwindows(w, (), 0)
+ w.original_close(w)
+
+def filediff(a, b, flags): # Display differences between two text files
+ diffcmd = 'diff'
+ if flags: diffcmd = diffcmd + mkarg(flags)
+ diffcmd = diffcmd + mkarg(a) + mkarg(b)
+ difftext = commands.getoutput(diffcmd)
+ return textwin.open_readonly(mktitle(a, b), difftext)
+
+def dirdiff(a, b, flags): # Display differences between two directories
+ data = diffdata(a, b, flags)
+ w = tablewin.open(mktitle(a, b), data)
+ w.flags = flags
+ w.a = a
+ w.b = b
+ addviewmenu(w)
+ addactionmenu(w)
+ return w
+
+def diffdata(a, b, flags): # Compute directory differences.
+ #
+ a_only = [('A only:', header_action), ('', header_action)]
+ b_only = [('B only:', header_action), ('', header_action)]
+ ab_diff = [('A <> B:', header_action), ('', header_action)]
+ ab_same = [('A == B:', header_action), ('', header_action)]
+ data = [a_only, b_only, ab_diff, ab_same]
+ #
+ a_list = dircache.listdir(a)[:]
+ b_list = dircache.listdir(b)[:]
+ dircache.annotate(a, a_list)
+ dircache.annotate(b, b_list)
+ a_list.sort()
+ b_list.sort()
+ #
+ for x in a_list:
+ if x in ['./', '../']:
+ pass
+ elif x not in b_list:
+ a_only.append(x, a_only_action)
+ else:
+ ax = os.path.join(a, x)
+ bx = os.path.join(b, x)
+ if os.path.isdir(ax) and os.path.isdir(bx):
+ if flags == '-r':
+ same = dircmp(ax, bx)
+ else:
+ same = 0
+ else:
+ try:
+ same = cmp.cmp(ax, bx)
+ except (RuntimeError, os.error):
+ same = 0
+ if same:
+ ab_same.append(x, ab_same_action)
+ else:
+ ab_diff.append(x, ab_diff_action)
+ #
+ for x in b_list:
+ if x in ['./', '../']:
+ pass
+ elif x not in a_list:
+ b_only.append(x, b_only_action)
+ #
+ return data
+
+# Re-read the directory.
+# Attempt to find the selected item back.
+
+def update(w):
+ setbusy(w)
+ icol, irow = w.selection
+ if 0 <= icol < len(w.data) and 2 <= irow < len(w.data[icol]):
+ selname = w.data[icol][irow][0]
+ else:
+ selname = ''
+ statcache.forget_dir(w.a)
+ statcache.forget_dir(w.b)
+ tablewin.select(w, (-1, -1))
+ tablewin.update(w, diffdata(w.a, w.b, w.flags))
+ if selname:
+ for icol in range(len(w.data)):
+ for irow in range(2, len(w.data[icol])):
+ if w.data[icol][irow][0] == selname:
+ tablewin.select(w, (icol, irow))
+ break
+
+# Action functions for table items in directory diff windows
+
+def header_action(w, string, (icol, irow), (pos, clicks, button, mask)):
+ tablewin.select(w, (-1, -1))
+
+def a_only_action(w, string, (icol, irow), (pos, clicks, button, mask)):
+ tablewin.select(w, (icol, irow))
+ if clicks == 2:
+ w2 = anyopen(os.path.join(w.a, string))
+ if w2:
+ w2.parent = w
+
+def b_only_action(w, string, (icol, irow), (pos, clicks, button, mask)):
+ tablewin.select(w, (icol, irow))
+ if clicks == 2:
+ w2 = anyopen(os.path.join(w.b, string))
+ if w2:
+ w2.parent = w
+
+def ab_diff_action(w, string, (icol, irow), (pos, clicks, button, mask)):
+ tablewin.select(w, (icol, irow))
+ if clicks == 2:
+ w2 = anydiff(os.path.join(w.a, string), os.path.join(w.b, string),'')
+ w2.parent = w
+
+def ab_same_action(w, string, sel, detail):
+ ax = os.path.join(w.a, string)
+ if os.path.isdir(ax):
+ ab_diff_action(w, string, sel, detail)
+ else:
+ a_only_action(w, string, sel, detail)
+
+def anyopen(name): # Open any kind of document, ignore errors
+ try:
+ w = anywin.open(name)
+ except (RuntimeError, os.error):
+ stdwin.message('Can\'t open ' + name)
+ return 0
+ addstatmenu(w, [name])
+ return w
+
+def dircmp(a, b): # Compare whether two directories are the same
+ # To make this as fast as possible, it uses the statcache
+ print ' dircmp', a, b
+ a_list = dircache.listdir(a)
+ b_list = dircache.listdir(b)
+ for x in a_list:
+ if skipthis(x):
+ pass
+ elif x not in b_list:
+ return 0
+ else:
+ ax = os.path.join(a, x)
+ bx = os.path.join(b, x)
+ if statcache.isdir(ax) and statcache.isdir(bx):
+ if not dircmp(ax, bx): return 0
+ else:
+ try:
+ if not cmpcache.cmp(ax, bx): return 0
+ except (RuntimeError, os.error):
+ return 0
+ for x in b_list:
+ if skipthis(x):
+ pass
+ elif x not in a_list:
+ return 0
+ return 1
+
+
+# View menu (for dir diff windows only)
+
+def addviewmenu(w):
+ w.viewmenu = m = w.menucreate('View')
+ m.action = []
+ add(m, 'diff -r A B', diffr_ab)
+ add(m, 'diff A B', diff_ab)
+ add(m, 'diff -b A B', diffb_ab)
+ add(m, 'diff -c A B', diffc_ab)
+ add(m, 'gdiff A B', gdiff_ab)
+ add(m, ('Open A ', 'A'), open_a)
+ add(m, ('Open B ', 'B'), open_b)
+ add(m, 'Rescan', rescan)
+ add(m, 'Rescan -r', rescan_r)
+
+# Action menu (for dir diff windows only)
+
+def addactionmenu(w):
+ w.actionmenu = m = w.menucreate('Action')
+ m.action = []
+ add(m, 'cp A B', cp_ab)
+ add(m, 'rm B', rm_b)
+ add(m, '', nop)
+ add(m, 'cp B A', cp_ba)
+ add(m, 'rm A', rm_a)
+
+# Main menu (global):
+
+def mainmenu():
+ m = stdwin.menucreate('Wdiff')
+ m.action = []
+ add(m, ('Quit wdiff', 'Q'), quit_wdiff)
+ add(m, 'Close subwindows', close_subwindows)
+ return m
+
+def add(m, text, action):
+ m.additem(text)
+ m.action.append(action)
+
+def quit_wdiff(w, m, item):
+ if askyesno('Really quit wdiff altogether?', 1):
+ sys.exit(0)
+
+def close_subwindows(w, m, item):
+ while 1:
+ for w2 in gwin.windows:
+ if w2.parent == w:
+ close_subwindows(w2, m, item)
+ w2.close(w2)
+ break # inner loop, continue outer loop
+ else:
+ break # outer loop
+
+def diffr_ab(w, m, item):
+ dodiff(w, '-r')
+
+def diff_ab(w, m, item):
+ dodiff(w, '')
+
+def diffb_ab(w, m, item):
+ dodiff(w, '-b')
+
+def diffc_ab(w, m, item):
+ dodiff(w, '-c')
+
+def gdiff_ab(w, m, item): # Call SGI's gdiff utility
+ x = getselection(w)
+ if x:
+ a, b = os.path.join(w.a, x), os.path.join(w.b, x)
+ if os.path.isdir(a) or os.path.isdir(b):
+ stdwin.fleep() # This is for files only
+ else:
+ diffcmd = 'gdiff'
+ diffcmd = diffcmd + mkarg(a) + mkarg(b) + ' &'
+ print diffcmd
+ sts = os.system(diffcmd)
+ if sts: print 'Exit status', sts
+
+def dodiff(w, flags):
+ x = getselection(w)
+ if x:
+ w2 = anydiff(os.path.join(w.a, x), os.path.join(w.b, x), flags)
+ w2.parent = w
+
+def open_a(w, m, item):
+ x = getselection(w)
+ if x:
+ w2 = anyopen(os.path.join(w.a, x))
+ if w2:
+ w2.parent = w
+
+def open_b(w, m, item):
+ x = getselection(w)
+ if x:
+ w2 = anyopen(os.path.join(w.b, x))
+ if w2:
+ w2.parent = w
+
+def rescan(w, m, item):
+ w.flags = ''
+ update(w)
+
+def rescan_r(w, m, item):
+ w.flags = '-r'
+ update(w)
+
+def rm_a(w, m, item):
+ x = getselection(w)
+ if x:
+ if x[-1:] == '/': x = x[:-1]
+ x = os.path.join(w.a, x)
+ if os.path.isdir(x):
+ if askyesno('Recursively remove A directory ' + x, 1):
+ runcmd('rm -rf' + mkarg(x))
+ else:
+ runcmd('rm -f' + mkarg(x))
+ update(w)
+
+def rm_b(w, m, item):
+ x = getselection(w)
+ if x:
+ if x[-1:] == '/': x = x[:-1]
+ x = os.path.join(w.b, x)
+ if os.path.isdir(x):
+ if askyesno('Recursively remove B directory ' + x, 1):
+ runcmd('rm -rf' + mkarg(x))
+ else:
+ runcmd('rm -f' + mkarg(x))
+ update(w)
+
+def cp_ab(w, m, item):
+ x = getselection(w)
+ if x:
+ if x[-1:] == '/': x = x[:-1]
+ ax = os.path.join(w.a, x)
+ bx = os.path.join(w.b, x)
+ if os.path.isdir(ax):
+ if os.path.exists(bx):
+ m = 'Can\'t copy directory to existing target'
+ stdwin.message(m)
+ return
+ runcmd('cp -r' + mkarg(ax) + mkarg(w.b))
+ else:
+ runcmd('cp' + mkarg(ax) + mk2arg(w.b, x))
+ update(w)
+
+def cp_ba(w, m, item):
+ x = getselection(w)
+ if x:
+ if x[-1:] == '/': x = x[:-1]
+ ax = os.path.join(w.a, x)
+ bx = os.path.join(w.b, x)
+ if os.path.isdir(bx):
+ if os.path.exists(ax):
+ m = 'Can\'t copy directory to existing target'
+ stdwin.message(m)
+ return
+ runcmd('cp -r' + mkarg(bx) + mkarg(w.a))
+ else:
+ runcmd('cp' + mk2arg(w.b, x) + mkarg(ax))
+ update(w)
+
+def nop(args):
+ pass
+
+def getselection(w):
+ icol, irow = w.selection
+ if 0 <= icol < len(w.data):
+ if 0 <= irow < len(w.data[icol]):
+ return w.data[icol][irow][0]
+ stdwin.message('no selection')
+ return ''
+
+def runcmd(cmd):
+ print cmd
+ sts, output = commands.getstatusoutput(cmd)
+ if sts or output:
+ if not output:
+ output = 'Exit status ' + `sts`
+ stdwin.message(output)
+
+
+# Status menu (for all kinds of windows)
+
+def addstatmenu(w, files):
+ w.statmenu = m = w.menucreate('Stat')
+ m.files = files
+ m.action = []
+ for file in files:
+ m.additem(commands.getstatus(file))
+ m.action.append(stataction)
+
+def stataction(w, m, item): # Menu item action for stat menu
+ file = m.files[item]
+ try:
+ m.setitem(item, commands.getstatus(file))
+ except os.error:
+ stdwin.message('Can\'t get status for ' + file)
+
+
+# Compute a suitable window title from two paths
+
+def mktitle(a, b):
+ if a == b: return a
+ i = 1
+ while a[-i:] == b[-i:]: i = i+1
+ i = i-1
+ if not i:
+ return a + ' ' + b
+ else:
+ return '{' + a[:-i] + ',' + b[:-i] + '}' + a[-i:]
+
+
+# Ask a confirmation question
+
+def askyesno(prompt, default):
+ try:
+ return stdwin.askync(prompt, default)
+ except KeyboardInterrupt:
+ return 0
+
+
+# Display a message "busy" in a window, and mark it for updating
+
+def setbusy(w):
+ left, top = w.getorigin()
+ width, height = w.getwinsize()
+ right, bottom = left + width, top + height
+ d = w.begindrawing()
+ d.erase((0, 0), (10000, 10000))
+ text = 'Busy...'
+ textwidth = d.textwidth(text)
+ textheight = d.lineheight()
+ h, v = left + (width-textwidth)/2, top + (height-textheight)/2
+ d.text((h, v), text)
+ del d
+ w.change((0, 0), (10000, 10000))
+
+
+# Main function
+
+def main():
+ print 'wdiff: warning: this program does NOT make backups'
+ argv = sys.argv
+ flags = ''
+ if len(argv) >= 2 and argv[1][:1] == '-':
+ flags = argv[1]
+ del argv[1]
+ m = mainmenu() # Create menu earlier than windows
+ if len(argv) == 2: # 1 argument
+ w = anyopen(argv[1])
+ if not w: return
+ elif len(argv) == 3: # 2 arguments
+ w = anydiff(argv[1], argv[2], flags)
+ w.parent = ()
+ else:
+ sys.stdout = sys.stderr
+ print 'usage:', argv[0], '[diff-flags] dir-1 [dir-2]'
+ sys.exit(2)
+ del w # It's preserved in gwin.windows
+ while 1:
+ try:
+ gwin.mainloop()
+ break
+ except KeyboardInterrupt:
+ pass # Just continue...
+
+# Start the main function (this is a script)
+main()
projects / thirdparty / Python / cpython.git / commitdiff
