*** NEdit Add-on Programs
*** originally by Doug Hellmann (hellmann@erdas.com)

These add-on programs were written to be used with NEdit, but they
should be useful for other editors as well.  They do require the
source from NEdit to compile.  They are provided as is.  The only
stipulation to distributing them is to let me know if you make any
changes and to list me as the creator, even if you want to add your
name as a modifier.  Of course, there is no warranty.  

*** Citations

The balloon help code (Aldora) was written by Rajesh Chandran.

The ComboBox came from the Net, and it looks like it was written by
Harald Albrecht.

The Tree widget came from the Net, originally from Douglas Young.  I
modified the routines which draw the lines between the children to
produce an effect I think looks better.  There's a resource to control
this.

The MegaButton came from the Net, originally by John L. Cwikla.  I
have a modified version of nedit which uses the MegaButton to show a
tags list, but that source is not ready for release.  I don't believe
that the MegaButton is used in any of the current programs.

*** Portability

Each program which depends on an external program can be modified to
use different parameter sets without changing the meat of the source
code.  The commandOptions module defines a data structure for this.
Each program should have a file set aside for defining an instance of
this data structure for each platform (some aren't done yet).  This
provides a simple way to control which options are available to
various programs on different platforms.  An example of this is the
-ls flag to find under AIX.  This produces a long listing in ls
format, instead of just the file name like the -print option gives.

The only platform on which any of this is truely tested is AIX, but
the others should be pretty easy to figure out.  I have compiled it
under Solaris, but I don't use Solaris so it hasn't been used there.

*** The programs included

mcflow - parses output from cflow and uses a modified Tree widget to
display the call tree.  The parsing process (by cflow) is pretty slow
for large programs, and cflow itself tends to have problems with Motif
programs.  There are commands in Makefile.common to build the
cflow.tree for the add-on programs (make cflow.tree).  I recommend
rebuilding the tree as infrequently as possible and storing it in a
file.  Parsing the file in mcflow takes significantly less time than
parsing all of the source code.

mmake - parses output from make (or gmake, etc.) and allows jumps to
errors when selected.  The build and editor command options along with
the error pattern matching options should make this useful even if you
don't use nedit as an editor.

findfile - runs a find and automatically opens files when selected.

mctags - parses ctags output file and jumps to the location of tag
definitions within the defined editor.  The editor does not have to
support tags itself.

mgrep - another window interface for jumping around in files using the
results of a grep search.  The file /dev/null is always appended to
the file list for the command so that the names are shown in the output.

mdepend - This is probably less than useful to the general public at
this stage.  It parses makedepend and dump output to build a
dependency graph between object files in a project.  It then outputs
the graph in a format which can be read by daVinci, a public domain
graph display tool.  The input file formats are based on data that we
were already generating here for our software.  I'm working on an
entirely new version of this program as a separate project.  It may or
may not be released when it is finished, because it has now officially
been claimed by my employer.

*** Building

Edit Makefile.common to set the root directory of the NEdit source
tree in NEDIT_SOURCE_ROOT.  NEdit must already be compiled because
several objects are used directly.

Then make sure that your Makefile.$arch is correct.  Most of these
came from NEdit 4.0 and were modified later.  

Then just type:

	make -f Makefile.$arch

and all of the targets will be built.  There are no messy resource
files to install, and the programs don't care where they are
installed.
