From: davis@en.ecn.purdue.edu (Robert E Davis)
Subject: Available for FTP:  a NeXTSTEP front-end for GNUPLOT 3.2
Organization: Purdue University Engineering Computer Network
Date: Sun, 22 Nov 92 20:17:28 GMT


	The pre-release version of a NeXTSTEP front-end for Gnuplot is
	now available via anonymous FTP from Oregon State
	(cs.orst.edu) and Purdue (sonata.cc.purdue.edu).


NeXTSTEP Gnuplot 0.47 is completely integrated with Gnuplot 3.2 and
requires no prior experience with or knowledge of the original
plotting program.  This app was written without any change to the
original source (except renaming main() to something less obtrusive
and adding a custom terminal type) and may be run either as a NeXTSTEP
app from the Workspace or as the original command line program from
Terminal or Stuart.


	NeXTSTEP features:

	+ Exports Encapsulated PostScript (EPS), Tag Image File Format
	  (TIFF), the document filename, and ASCII text selections to
	  Service-providers and exports EPS, PS fonts, and ASCII text
	  selections via Copy/Paste.

	+ Allows drag and drop of EPS plots into other NeXTSTEP
	  applications, such as the Workspace, Mail, Create, or Diagram.

	+ Accepts drag and drop of ASCII text files containing
	  columns of numerical data to be plotted.

	+ Font selection through the standard NeXTSTEP Font panel.
	  Print support through standard NeXTSTEP Page Setup and Print
	  panels.

	+ "Constant Update" feature that automatically updates the
	  plot when changes are made to its settings (e.g. If you want
	  the plot to have a border, put a check mark in the "Border"
	  box, and a border will appear in the plot).  May be disabled
	  with Preferences.

	+ Multi-purpose inspectors.  Unlimited number of open
	  documents.

	+ Written for NeXTSTEP 2.1 and should compile under 3.0.

	+ Fully compliant with NeXTSTEP 2.1 User Interface Guidelines.



	Other features:

	+ Entire Gnuplot 3.2 distribution included, with
	  documentation, demonstration documents, and Makefiles.

	+ Simple installation: the default Makefile produces a single
	  NeXTSTEP app-wrapper that includes "everything you need" and
	  may be placed in ~/Apps or /LocalApps -- no other
	  installation necessary.
	
	+ Compatible with standard Gnuplot files (i.e. it reads text
	  files meant for the original Gnuplot, and writes files that
	  can be read by the original Gnuplot).

	+ Support for most (soon-to-be all) relevant Gnuplot features.

	+ All source and nibs included.  (The NeXTSTEP additions to
	  Gnuplot are protected under the Free Software Foundations's
	  GNU copyleft, and the original source is protected under its
	  own copyright -- please see the copyright notice in the Info
	  menu).

	+ Demonstration documents for the NeXTSTEP front end included.
	  (The standard demo docs work as well, if you add a
	  ".gnuplot" to their filenames and limit the number of plots
	  to one per file -- that's one *plot*, with any number of
	  *functions* -- just as you would normally do to create an
	  EPS plot with Gnuplot.)

	+ "Dual-binary" ;-) which may be double-clicked for the
	  NeXTSTEP version or run with "Gnuplot -c ..." for the
	  old-fashioned command-line version, so you'll only need one
	  version of Gnuplot on your system.


	Caveats:

	+ Although this app accepts all standard Gnuplot files,
	  "pause," "set output," "set terminal," and any "plot"
	  commands after the first one are ignored, and references to
	  external files should use full pathnames.

	+ Comments and aesthetic formatting contained in Gnuplot files
	  that are opened, modified, and then saved with this app will
	  be overwritten.

	+ This app does not expand on Gnuplot's plotting features --
	  my goal of leaving the original source unchanged limits the
	  app to Gnuplot 3.2's capabilities -- although the creation
	  and manipulation of plots is greatly simplified.


	The Gnuplot front-end is provided with absolutely no warranty,
of course, and no promise that it is suitable for any purpose or that
its bugs will be fixed or that its features will be expanded or that
it will keep pace with the official Gnuplot releases.  And since it is
a kludge, I make no claim that it is a good example of object-oriented,
NeXTSTEP programming.


	And I make no promise that questions, comments, etc. mailed to
davis@ecn.purdue.edu or 71302.273@compuserve.com will be answered (I'm
busy being a student), although there is a distinct possibility.



Enjoy,
Robert Davis



---------------------------- The README ----------------------------

Gnuplot NeXTSTEP Front End 0.47
October 1992
For NeXTSTEP 2.0 or higher


Contents
--------
	The file package should have unpacked into a folder called
Gnuplot containing the following:

-- Gnuplot.app

	This contains the pre-compiled, ready-to-go app which may be
	copied to ~/Apps or wherever you like.

-- NeXTSTEP

	For those people who would rather compile the software
	themselves, this folder contains all the files necessary to
	build Gnuplot.app.

-- Samples

	This folder contains sample documents created specifically for
	the NeXTSTEP version.

-- gnuplot3.2

	Several files from the Gnuplot 3.2 distribution are not
	required to build Gnuplot.app but are included here, for
	completeness.  Documentation, demo files, and support
	documents pertaining only to original Gnuplot are here as
	well.



Building and Installing Gnuplot.app
-----------------------------------
	To install the pre-compiled app, simply drag Gnuplot.app to
the folder of your choice.  To build and install the NeXTSTEP version
of Gnuplot, launch Terminal or Stuart and cd to the NeXTSTEP
directory.  Then choose one of the these options:

	-- to build and install the app in your own Apps folder, type
	   "make install".  This will create a file package
	   "Gnuplot.app" in your Apps folder which contains all the
	   files necessary for running either the NeXTSTEP version or
	   the command line version of Gnuplot.  (When compiling under
	   NeXTSTEP 2.1, you will receive warnings on parse.c and
	   plot.c, which can be ignored.  Compiling under NeXTSTEP 3.0
	   has not been tested, but will probably compile with many
	   more warnings.)

	-- to build and install the app in a folder other than your
	   own Apps folder, type "make INSTALLDIR=/LocalApps install"
	   replacing /LocalApps with the desired folder.  You must
	   have write access to the install folder, of course.

	-- to build the app right here without installing it, type
	   "make".  It will create the executable (called "Gnuplot")
	   in the current directory.  Note that this app requires the
	   various TIFF and NIB files in the NeXTSTEP directory to be
	   present as it is running, so moving the executable from
	   this directory will cause the NeXTSTEP version to fail.


Launching the NeXTSTEP Version
------------------------------
	To launch the NeXTSTEP version, double click its icon in the
Workspace File Viewer.  The app will launch and an untitled plot will
be created.  To look at some of the sample documents, choose "Open..."
from the "Plot" menu and select the sample plot(s) in the
NeXTSTEP/SamplePlots directory.  (Alternatively, you may double click
the sample plot(s) in the Workspace File Viewer.)


Running the Command Line Version
--------------------------------
	To run the command line version, go to a Terminal or Stuart
window, cd to the directory containing the executable (probably
~/Apps/Gnuplot.app) and type "./Gnuplot -c".  The -c specifies that
you want the command line version.  The standard Gnuplot banner and
copyright information will be displayed, and you will get a "gnuplot>"
prompt.

	If you have files of Gnuplot commands, you may load them into
the command line version with "./Gnuplot -c filename".  You may also
load them into the NeXTSTEP version if you give each filename a
".gnuplot" extension.  (Note that irrelevant commands, such as set
terminal, set output, pause, and any commands after the first plot
command, will be ignored, and you should use full path names when
specifying external files.)


What the NeXTSTEP Version Can't Do
----------------------------------
	I wrote this app primarily for myself, and I admit that the
Gnuplot features that the app does not support are those that I rarely
use.  Nearly all of them would be easy to implement because they are
supported by the underlying code, I just haven't added them to the
interface yet.  Specifically, the following features are not included
but will (probably) make it into any subsequent releases:

	-- Ranges for parametric plots

	-- Re-ordering of functions within a pair/triple for
	   parametric plots

	-- Positioning of titles and axis labels

	-- Labels that can be placed at arbitrary locations and arrows
	   that can point to arbitrary locations (although I bet
	   anyone with an app like Diagram will never use these two
	   features)

	-- Support for 3-dimensional features, like surfaces,
	   contours, isolinear samples, and hidden graphics.
	   
	-- User-defined functions and variables
	
	-- Custom formats for custom tic marks
	

	Additionally, I'd like a few more NeXTSTEP additions:

	-- Better graphical depiction of pairs/triples of functions
	   for parametric plots in the Data Inspector

	-- Allow creation of raw data points within Gnuplot, with the
	   option of saving the data to a text file, which would allow
	   the app to...

	-- Provide a service that allows the user to select columns of
	   text in other apps and plot them with Gnuplot, or select a
	   text file in another app and plot its contents with Gnuplot.

	-- Ability to drag data files onto the plot window instead of
	   onto the Gnuplot app icon.  It would make more sense and
	   would cause less conflict with dock-extenders like Engage.
	   I was just being lazy.

	-- Support new 3.0 features, like interactive help, links,
	   etc.


Acknowledgements
----------------
	Although I worked on this alone, I examined and borrowed code
and ideas from many sources:

	-- NeXTSTEP Examples and Mini-Examples primarily
	   CellScrollView by R. Dunbar Poor and Mai Nguyen,
	   ScrollDoodScroll by Jayson Adams, and Draw by Paul Hegarty.
	   Any classes or methods that I used have their origins
	   documented in the code.

	-- Nick Strobel, whose Gnuplot terminal served as an example.
	   My custom terminal is similar to his first version -- it
	   creates a stream of PostScript which is used to create an
	   NXImage that is composited into the plot window.  His
	   second version is faster and less of a memory hog, but it
	   violates some "rules" about calling Objective-C code from a
	   .c file.  I'm trying to think of a clean, legal way around
	   this.  (By the way, Strobel's terminal is included with the
	   official Gnuplot 3.2 distribution and is, therefore,
	   included here if you want to use it.)

	-- Russell Lang, whose official Gnuplot PostScript terminal
	   driver is the basis for my custom terminal driver.  In fact,
	   mine is a very slight modification of his.

	-- Usenet's comp.sys.next.programmer.  The best source of cool
	   tips on the planet.


Rejected Names
--------------
	I almost named this app something else, like

		Plot!
		Gnuisance
		DataGraf
		Thicken
		Visual Gnuplot
		Denoument

but opted for the less artsy, less monumental "Gnuplot Front End,"
which has about as much charm, sophistication, and panache as does "The
IBM Personal Computer Company."


Enjoy,
Rob

davis@ecn.purdue.edu
71302.273@compuserve.com

-- 
| Robert Davis					      davis@ecn.purdue.edu
| "Look up, Hannah.  Look up."                          NeXT Mail accepted
--
Newsgroups: comp.sys.next.software