4.1.3
===============

Fixes to several problems that quickly arose with 4.1.2
---------------------------------------------------

- Dependencies of source files on built sources caused build to stop.
It would continue correctly after restarting, but by making the objects
dependent instead we made it work in one pass.

- References in _regstream.c.  Missing references/deletes in _regstream.c 
and steamline.c caused objects to be really deleted before their time.
Problem appeared in ThunderStreamlines example.  Did this ever work?

- Not enough memory allocated for buffer in parse.c.

- Needed to pass in class_srcdir value to invokation of class script
in libdx/local.mk

- Include net2c in distribution

- Correctly free search_for in Browser.C.  Proper behavior dependent on
compile-time definitions.

- Not enoucgh memory allocated for type-in string in GARApplication.C.  
Caused segfaults in prompter.

4.1.2
===============

Distributed-memory extension to OpenDX
---------------------------------------------------
dxmpi checked in as a new part within OpenDX. No significant documentation
has been written. 

dxmpi works by starting an instance of the DX executive on each MPI
host, with one (rank 0) designated the master.  The master communicates
with the UI or directly in script language (though rather than by typing
directly in, a separate program is used to connect the keyboard to dxexec).
Absent any use of OpenDX-MPI extensions, the master performs as a
completely normal OpenDX exec.

The MPI extensions to OpenDX fit two forms: modules that appear to run on
the master but which use MPI internally to run in parallel, and macros that
are run in parallel on the slaves at the behest of a "RunOnSlaves" module
that runs on the master.  I've put in an API allowing modules to register
and call remote procedures and to pass DX objects around to support the
first type.  For the second, there's a set of new modules that provide
tools for data distribution from the master to the slaves, leaving the
distributed data as named objects in the slaves' cache, where they can be
retrieved by name by macros run on the slaves by RunOnSlaves.

As an example of the first type, a parallel regular-grid importer 
(DRegularImporter) that works like this.  As inputs, it receives
the name of an ad-hoc data description file that describes the layout of
data found in a separate file.  It registers a remote procedure with the
slaves, and then invokes that procedure on the slaves, passing them the
data description and a destination object name.   Each slave, knowing how
many slaves there are and its own rank among them, is able to determine
what portion of the data its responsible for (essentially, partitioning the
data as a part of importing it, and including a "ghost zone" of overlap
with neighboring partitions).   Each imports its part, saves it in the
cache under the destination object name (the same on all slaves), and
returns the bounding box and min max of its partition to the master.  The
master (still in the guts of the DReguarImport module) gathers this info
together into an output Group object where member i is the box and minmax
of partition i residing on slave i.

Now suppose you want to isosurface and render that data.  You create a
macro on the slaves that accesses the data by the name under which
DRegularImporter left it and an isovalue (again by name, from the cache).
The macro then sends the data through Isosurface and Color and whatever,
then passes that result to the SlaveDone module, which indicates to the
master that the execution of the macro is complete and returns the object.
On the master, a scalar interactor feeds the input of  Broadcast(value,
name) that broadcasts the interactor's value to the slaves under the
associated name.  The dummy output of Broadcast and the output of
DRegularImporter are passed to "control" inputs to RunOnSlaves(macro name,
control ...) that just serve to ensure correct module sequencing.
RunOnSlaves causes the slaves to run the named macro, waits for their
results, and gathers it all together in a group where member i contains the
result of slave i.  This could then be passed directly into Image for
rendering.

There are a couple other cool pieces to this, most notably a distributed
parallel renderer and a new streamline module that runs on distributed
vector fields.  There are a lot of holes to fix; for example, errors in
slave macros very often cause system hangs.  There is no integration of the
notion of slave macros into the UI. Lots of things.

Added command-line arg to configure for compatibility with ddx.  Either
way the resulting code works exactly as before, but if --enable-ddx is set
the libraries will work with ddx.

Implement compatibility with ddx, which requires code in the main loop
to check for input from MPI.  ddx.c is a stub file, so whether or not
--enable-ddx, the dxexec built in the source tree works as before.  
---------------------------------------------------

Added mechanisms to directly connect OpenDX to other processes.
Includes a new module, SocketConnection, that supports sending objects 
from an external process to OpenDX across a socket (and back, as a 
future enhancement). The idea is that the process makes a call to
see if an OpenDX instance has opened a port.  If it has, it can send data
to OpenDX by creating an object using the data model calls in the DXlite
library,  buffer it, and write it to the socket.  On the OpenDX side,
SocketConnection creates a port and an associated fd, then adds an input
handler to watch for input on the fd.  When input arrives, its read off the
socket and converted to a DX object via _dxfImportBin_Buffer, and
DXReadyToRun is called to indicate that new data is available.  When the
module runs, the received object is the module result.  This allows the
external process to send arbitrary objects to OpenDX across a socket.

Added a new subclass of Array to further assist with direct connection.
A SharedArray is very similar to a generic Array, but allows the array
contents to be shared with the external process directly.    When a
SharedArray is created, DXNewSharedArray is given a shared memory segment
ID and the address of the data, which must lie in that segment.  Unlike
generic Arrays, which copy data using the DXAddArrayData call, SharedArrays
use it directly.   DX keeps track of how many SharedArrays reference each
segment, and maintains an attachment to that segment as long as there are
references to it.   When the external process creates an object containing
a SharedArray, the buffering process transmits the segment id and offset
within the segment to OpenDX.  When its unbuffered, a new OpenDX-side
SharedArray is created, the segment is attached (if necessary - it may have
been seen before), and the SharedArray stores the address of the data in
OpenDX' memory space.  Thus the external-side SharedArray (which itself
shares data with the external process) and the OpenDX side SharedArray
actually share memory.

Support for SMP linux boxes:
Since this is not well tested it is an optional make- --with-smp-linux
on the configure command line.  The memory available to OpenDX in SMP mode 
is limited to the max size of a shared-memory segment.  This may be set 
low and must be changed in /proc/sys/kernel/shmmax. Created inter-process 
locking from IPC semaphores, and its not confidence-inspiring.

Fixed a bug in the handling of the deletion of task groups in task.c.

RSH enhancements: 
  - configure now picks up system rsh and bsh or is setable by the user.
  
  - The default command "rsh" has been left in place, but
    a user-specified remote shell command can be specified via the
    $DXRSH environment variable. Example: setenv DXRSH /usr/bin/ssh

  - FQDNs (full host paths) are used under the hood when available
    when creating the remote "invoke dxexec" script and connecting
    back to the master exec,

  - Users can now enter host names of the form "user@machine" in
    the Execute Group Assignment... dialog, and

  - setting the $DXRSH_NOENV in the local environment prevents the
    remote "invoke dxexec" script from being written with a full
    carbon copy of the local environment (only $DISPLAY is set).

  - dumped pcreateve on SGI in favor of vfork/fork and exec for
    kicking off rsh.

Correctly avoiding a memory leak with hardware rendering due to a mysterious
reference.

Add the capability to change the logo and splash screen by adding a
hook into the Xpm libraries. Now users can customize if they so desire.

New Regrid option of Radius 0 that basically performs a snap to grid
functionality. This option will make regrid apply data to the nearest
grid position and average it if there are multiple (not weighted).

Initial support for MacOS X. It appears that there are quite a few bugs
in 10.0.2 still so it may have to wait a little longer. Also, somebody
needs to work on the memory routines for OS X.

Further corrections for the Windows code versions. Updated several 
places where the DOS path may get munged. Updated JavaDX to be able to
pass in DOS pathnames to start the server.

An addition made to edfparse to allow the creation of a local reference
to an external file within the native file format. This local reference
can then be used repeatedly within the other objects without having to
reread the external file.
(Example:
  object "localobj" file "externalfile.dx",1

  object "f1" field
    component "positions" "localobj"

  object "f2" field
    component "positions" "localobj"
)

A correction to the edfparse to accept data description in the native
file format with object names as references instead of numbers.

A correction to isosurface to pass attributes through not remove them.

Fix to make CDBs open at correct opening width when scrollbar is needed.

Modifications to avoid glx functions not implemented by wiregl.

Some memory leak patches to general import, task, and redce.

Now installing the built dx.mdf file so that the BSpline
module is now visible in the VPE.

Add functionality to SuperviseWindow to use a camera to set the
window size.

If DXMDF env variable is set to NULL then an error occured. Check
it first before trying to open it.

Fixed SMP OpenDX to use parent process and fork in a better 
order. Didn't change the default behavior.

A fix in the List module that could go past array bounds.

A fix for DXcallm that allows Rubbersheet to be used again.

A small memory leak fixed from not closing a message file.

Fix in the Tube module that could cause a possible core dump.

Provided a fix in dxworker so the exec could launch on Solaris 2.8.

Cleaned up the warnings in src/exec/libdx, src/exec/dpexec, 
and src/exec/dxmods -- this included adding header files and
removing many of the extern prototypes making APIs more
usable.

Added the functionality to build C++ modules from the module
builder.

Fixed a possible memory leak in the Post module.

Added Randall Hopper's lock fixes to decrease execution
time on single processor machines by 20%.

Added Randall Hopper's module path fix that can decrease
execution time on cached networks significantly.

Dropped support for ImageMagick 5.1.1 and added support for ImageMagick > 5.2.
ImageMagick < 5.0 support still exists.

Added support for compiling with Microsoft compilers. Updated much
of the Windows environment setups.

Added more support for the AIX xl series of compilers.

Correction for 2D Map when point is on edge it is detected.

More cleanup to JavaDX. DX_JAVA_CLASSPATH is now the variable that
stores all classpath info. Removed the multiple ones of Netscape and
WRL.

Added support in configure to work with ImageMagick's Magick-config,
thus reducing the amount of checks that are required when configuring.

4.1.0 
===============

With this revision, a lot of the Gnu AutoConf stuff was cleaned up to
help improve building the package from the source code.

Many updates to the AutoConf build routines for JavaDX. JavaDX should
now build readily on all systems.

Added new configuration options to disable building some libraries and
JavaDX. Added options to direct where java files reside if they can't be
found: --disable-buildlibdx --disable-installhtml --without-javadx
(remove compilation alltogether)
--with-jni-path=/PathToDirectoryContaining-jni.h:/PathToDirectoryContaining-jni_md.h
--with-cosmojar-path=/PathToCosmoJarFile/cosmoFileName.jar
--with-java40jar-path=/PathToJava40JarFile/java40.jar

The internal copyright mechanisms all get updated from the configure
scripts this makes tracking versions from the user interface easier.

Some general source code clean-up was done, there will be much more to
come in the next set of revisions.

OpenDX-generated makefiles are now largely platform independent as
created. To the extent that they have platform dependencies, these are
(or should be) determined by dx configure and written into arch.mak.
This allows the module builder to generate makefiles compatible with
OpenDX, such that runtime loadables work on a number of platforms and
dxui now writes compatible makefiles for building and installing JX
applets.

Problems with Interactors not working properly on some systems is fixed.

Linux binaries can now use loadable modules.

dx script is now stored in two locations during installation in case the
installation is moved and /usr/bin/dx is forgotten to be collected.

name change of dx.workerscript to dxworker

defaulting of the environment variable of DXMACROS, DXDATA, and DXROOT
if they are not set.

added -whereami option to dx to detect location of dx install

LD_LIBRARY_PATH is not overwritten on Solaris but just added to now.

mdf2c is now constructed with appropriate open source paths.

Help files links and install should now be correct after installation.

Added support for 15 bit and 32 bit color displays.

Added outboard.c to source tree to be included with outboard modules.

Added support for including libraries from ImageMagick build into
libDX.a. If the libraries are shared, then they are not added and must
be linked at a later time.

Forced Linux versions to run as single processor only not SMP until
shared memory is correctly addressed.

Fixed a memory leak where if DXMACROS was set, it would tromp on memory.
This is now fixed and relieves many core dumps in the exec.

Removal of some hard coded geometries on dialog boxes to make dialogs
work better with Lesstif. So far no reports of any problems with Motif.

Added support for using ImageMagick. If ImageMagick is available during
compilation, then many more image export formats will be available by
choosing the ImageMagick formats.

Correction to AutoRegrid module. "infinity" used as the radius caused a
core dump. This did not show up with all compilers.

Fix in Colorbar to make positions "dep positions". Fixes compliance with
some other tools.

Fix in the Enumerate module for properly creating counts.

A few minor fixes with the import routines for HDF and netCDF.

Corrected typos in module SimplifySurface.

Correction in Stack module for series data.

libDX is now being built correctly so modules can be linked to it with
proper functionality.

Added functionality for dx to use its default memory rules on linux. Fix
for possible negative memory request.

Correction to quads for possible loop when point coincides with vertex.

Correction when a point is on the line containing an edge. Need to check
sign.

Fixes to allow FreeBSD to compile correctly.

A correction the Grid Dialog box. Some testing may still be in order.

A error with postscript printing the networks was corrected.

Correction in the Browser for a pointer to an array.

Clean up a lot of the Motif function calls prototype mismatches.


4.0.6 
============= 

First initial stable release.


4.0.3 
============= 

Added code to makefiles and c files to create libDX, libDXlite, libcallm

Fixed missing splat in WorkspaceW.c

Removed apparently unnecessary code referring to
_XmDestroyParentCallback

Changed configure to look for old versions of Lesstif and set
OLD_LESSTIF, rather than any version of Lesstif and set USING_LESSTIF

HP_UX -> HP-UX

More general test for cygwin

install change - mkdir dx/bin rather than use INSTALL

configure test for sys/select and use in PacketIF.C