Version 0
	Initial release at Agent2003 Conference

Version 1
	mason and mason3d directories collapsed.
	mousetraps application included.
	Various small bugs squashed.
	Documentation updated.
	Known bug: 3D Heat information not provided (bug in inspector)

Version 2
	sim.app.networktest.CustomNode now specifies its font
	sim.portrayal.FieldPortrayal's CustomInspector properly sets its
		SimState instance variable.  This enables 3D HeatBugs, among
		other things, to properly update their inspectors.
	Various static variables converted to instance variables to
		facilitate simultaneous parallel models in one
		process.
	Improved class docs
	Moved the color mapping functionality out of FastValueGrid2DPortrayal
		and ValueGrid2DPortrayal.  Now they use sim.guil.ColorMap.
		This is slightly slower; however we've compensated with an
		improved code in ColorMap so it's about the same speed still.
		This change will require applications which use these 
		portrayals to change themselves slightly: no longer is there
		a setLevels() or setColors() function -- it's gone -- and 
		instead, there's a setMap() function which does the same
		thing.  See HeatBugsWithUI.java for an example of how to
		convert over (it's a one-line change).
	The info HTML page may now be loaded in the Console via a file
		rather than specified by a string.  See GUIState.getInfo()
	Fixes to 3D inspectors to avoid flashing
	Cleanups and fixes to 3D applications
	2D displays update when their options are modified (in the wrench 
		window)
	Bug fix so 2D display backgrounds are striped rather than white
		in MacOS X Panther (10.3)
	Reformatting
	MacOS X Panther 1.3.1 has a bug which causes a number of drawing
		events to reset the clip afterwards (messing up later
		drawing events).  I don't know HOW they messed this up.
		We've only worked around this where it wouldn't impact
		redrawing significantly: clips are set before stretched
		image drawing, before drawing sparse grids (because
		they're often circles, which trigger the bug for some
		reason).  Expect a slight slow-down in sparse grid
		graphics until Apple fixes this stupidity and we can
		remove our fix hack.
	New nifty Makefile
	Released at the 2003 Workshop on the Mathematics and Algorithms
                of Social Insects

Version 3
	Scale can no longer be 0
	Display2Ds may be offset (see the options pane -- useful
		for Tutorial 5 and Lsystem).  Lsystem's offset facility
		has been eliminated as a result.
	If the inspector pane has been removed, switching to it will no
		longer generate an error -- it just won't do anything
	LabelledPortrayal2D added.  This is a "wrapper Portrayal" which
		is meant to use an underlying portrayal to draw the
		main object -- then LabelledPortrayal2D will add a label.
	Added some Triangular grid code to the Grid2D objects.  No
		FieldPortrayal yet tho.
	CircledPortrayal2D added.  Another "wrapper Portrayal" which
		draws a circle around the underlying portrayal.  Will
		be useful for showing selection.
	Added sim.util.DoubleDimension2D, which is a concrete subclass
		of Dimension2D that stores dimension information as
		doubles.  For some reason Java doesn't have such
		a class (nor a "FloatDimension2D") -- it only has
		Dimension (for ints).  Yet it has equivalents for
		Point2D (Point2D.Double, Point2D.Float, Point),
		Rectangle2D (Rectangle2D.Double, Rectangle2D.Float,
		Rectangle), etc.  Totally inexplicable.  Anyway, this
		class should make the new movement and selection APIs
		easy to implement.
	Partially implemented the movement and selection APIs in
		FieldPortrayal2D and SimplePortrayal2D.  More yet to
		do however.
	Modified sim.util.Indexed so that it has consistent naming
		(setValue and getValue).  Neither approach is good,
		but this is better.  Updated Bag, DoubleBag, IntBag
		with the new function name.
	Made DoubleBag Indexed.  Dunno why it wasn't.
	Slight bugfix which properly brings up the dialog box when
		jmf.jar is missing but the user asks to make a movie.
	Modified PropertyField to be able to switch among property
		display styles.
	Replaced deprecated getClipRect() with getClipBounds.  Dunno
		why we didn't see that earlier.  No biggie.
	Bug fix to Bag.resize(), IntBag.resize(), and 
		DoubleBag.resize().  If requested size to resize to
		is the same size as the bag, now nothing happens.
		Previously the bag doubled in size.
	Bug fix to [Double|Int|]Bag.addAll(...).  numObjs was not
		being correctly changed.
	Addition of [Double|int|]Bag.doubleCapacityPlusOne() private
		function in order to bring add(...) and push(...)
		back under 35 bytes for inlining.  Couldn't use
		normal resize() function because it wasted a few
		bytes (ARG!!!)
	Added a little efficiency to SparseField.getObjectsAtLocations,
		SparseGrid[2|3]D.getObjectsAtLocations, and
		Continuous[2|3]D.getObjectsWithinDistance: if the
		discovered object bags are null or empty, they're
		not added to the result; if they're 1 they're added
		using Bag.add, and if the're > 1 in size they're
		added using Bag.addAll.  With any luck this should
		be a bit faster.	
	Added some further discussion in the hashCode() code for
		Int2D, Int3D, Double2D, and Double3D.  We may want
		to simplify the code to make it faster, though it
		is of very high quality, particularly for Java
		1.4.1.  Any comments would be welcome.
	Bag Iterators now allow remove(), and next() now throws
		an exception if we're at the end, rather than
		returning null.
	Major revisions to Display3D and various portrayal3D objects,
		including complete revisions of updating and creating
		scene graphs, updating and creating models,
		transformations, facility for resetting rotations 
		etc. on option panel, etc.  This will NOT be very
		backward-compatible, sorry.  But now we have a 
		more orthogonal approach to 3D, and the start() and 
		init() methods in the example applications are much 
		cleaner and simpler.
	Added Oriented2D and OrientedPortrayal2D to make it easier
		to describe oriented objects.  OrientedPortrayal2D
		is yet another "wrapper portrayal".
	Display3D no longer puts a black band at the bottom of
		pictures and movies (oops).
	getPolygonAttributes is now polygonAttributes in order to
		prevent it from showing up as a property in the
		inspector.
	Addition of CircledPortrayal3D, LabeledPortrayal3D, and 
		TransformedPortrayal3D "wrapper portrayals", the equivalent
		of their counterparts in 2D more or less.
	Addition of ConePortrayal3D, CylinderPortrayal3D,
		(untested)Shape3DPortrayal.
	Removed FixPortrayal3D.  Added SharedGroupPortrayal3D in its place.
	Removed DirectionalLightPortrayal3D and replaced it with
		the general LightPortrayal3D.
	Added Scale to the Display3D.  This is different from zoom.  Scale 
		magnifies.  Zoom moves the eye closer to center (and thus 
		possibly past some objects which are now behind you).
		We may remove this if it proves too confusing.
	Modified ImagePortrayal2D so that it no longer requires square images 
		(or tries to squish them into a square).
	Added ImagePortrayal3D
	fastgridcell package renamed to quad package
	GridQuadCellPortrayal renamed to QuadPortrayal.
	MeshCellPortrayal renamed to MeshPortrayal.
	TileGridCellPortrayal renamed to TilePortrayal.
	NoZGridCellPortrayal deleted (it's the same as TileGridCellPortrayal 
		at 0 z scale)
	Color map and scaling moved into QuadPortrayal.
	setData() method on QuadPortrayals now has a width and a height.  
		Accordingly all QuadPortrayals have had changes in their 
		constructors.
	QuadPortrayals now have their getName() methods called.  Previously 
		that was interrupted by the ValueGrid2D3DPortrayal which used 
		its own getName method.
	GridCellInfo renamed to ValueGridCellInfo
	Display2D now creates BufferedImages using getGraphicsConfiguration
		rather than the older way of just using Component.createImage
		and casting it to a BufferedImage and hoping for the best. :-)
	Moved Axes to 3D Options.  Added the ability to have a backdrop.
	Can now turn on/off left/right vs. up/down rotation and translation
	Can now autospin negative values.  Still don't know what to think about
		bugs in Java3D's handling of autospinning.  :-(
	Added Tutorial6 and Tutorial7
	Display3D used to hang until you moved the mouse if there's *no* 
		change to the underlying model in-between steps.  This is due 
		to a stupidity in Java3D.  Now we get around that by adding a
		single (supposedly invisible) point and reset its location
		each timestep.
	Fixed little bug in GUIState which generated a null pointer exception
		when trying to load the index.html and discovering that one
		doesn't exist.  Oops!
	If the user doesn't set the location of the Console in the GUIState's
		init() method, then the Console will attempt to place itself
		to the far right of the rightmost attached window; if there
		is no room, it'll go to the default location.
	Bug fix to Bag.iterator.next() and Bag.iterator.remove(); they had
		a comparator wrong and thus were always throwing exceptions.
		Thanks to Matthew Nelson (mnelson()mailsnare.net).
	SimpleInspector has slightly more space between labels and widgets
	Added the (temporary) convert and convert_h scripts and UPGRADING
		file to help upgrade
	SwarmGame added
	null inspectors not added to the list.
	GREAT RENAMING.  We've renamed all the 2D and 3D field portrayals 
		to be consistent with the rest of the system.  Well, more 
		consistent.  Anyway, it's better than it used to be.  Now 
		the system is as follows: if a 2D field portrayal can handle 
		(or will in the future be able to handle :-) both 2D and 3D 
		fields, it's called FooPortrayal2D.  Similarly, a 3D field 
		portrayal would be FooPortrayal3D.  If the field portrayal 
		is designed specifically for 2D fields only, it's 
		Foo2DPortrayal2D or Foo2DPortrayal3D.  Similarly for 3D fields 
		only...  At present none of the 2D field portrayals can display 
		3D fields; but they will in the future so they're named
		appropriately.  Renamed portrayals:

		ValueGridPortrayal2D
		FastValueGridPortrayal2D
		HexaValueGridPortrayal2D
		ObjectGridPortrayal2D
		HexaObjectGridPortrayal2D
		SparseGridPortrayal2D
		HexaSparseGridPortrayal2D
		ContinuousPortrayal2D
		NetworkPortrayal2D
		ValueGrid2DPortrayal3D
		SparseGrid2DPortrayal3D
		SparseGridPortrayal3D
		ContinuousPortrayal3D

	Changed some demos to use loaded index.html files rather than embedded
		HTML.  No particularly good reason other than demonstration.
	MAVs in the MAV demo no longer can have their size changed.  This is
		because we're using OrientedPortrayal2Ds and OvalPortrayal2Ds
		to portray the MAVs rather than having them portray themselves,
		also primarily for demonstration purposes.  To see a portrayal
		which changes its size, Tutorial5 is useful.
	Set Oriented2D's sole method to be "orientation2D" rather than
		our original "get2DOrientation".  The reason is that we don't
		necessarily want it showing up as a property of the underlying
		object.  It's in radians rather than degrees (the Java3D stuff
		we've done is in degrees) because the vast majority of time
		you'll already have it in radians:  Math.atan2(dy,dx).  So
		yeah, an inconsistency there...

Version 4
	Added a main() to sim.display.Console so that if you run
		java sim.app.Console
		... you're presented with the ComboBox of available simulations
		and can choose one immediately.
	Fixed some bugs in the Makefile indent feature
	Slightly modified the stx and tx functions and documentation so that
		they'd run a little faster in some cases.
	Fixed a bug where if a Display2D was playing, then pressing the movie 
		button would hang the bug.  Now the behavior is that pressing
		the movie button temporarily pauses the Display2D (if it's 
		playing), and cancelling will unpause again if necessary.
	Similar fix in Display3D.  This required making Console.getPlayState() 
		public, which shouldn't be much of a problem (probably would be
		useful anyway).  Similarly, when the user does Open... in the 
		Console, the current simulation is paused (if it's playing).  
		The new model is still opened in a paused state.  But if the 
		user cancels, we automatically unpause again if necessary.
	Fixed a documentation bug in MersenneTwisterFast that suggested that
		nextDouble() returned a number in [0,1].  It does not.  
		It's [0,1), just like java.util.Random.
	MovieMaker now displays its default frame rate as the frame rate
		of the simulation currently.
	SimulatorLayout.graffle and SimulatorLayout.pdf updated.
	Added hardware acceleration for old Powerbook G4s and iBooks
	Switched to using TYPE_INT_ARGB_PRE for buffers in 
		FastValueGridPortrayal2D as it's supported natively by MacOS X
	convert and convert_h removed
	removed UPGRADING
	new [Int|Double|]Bag(bag) can accept a null bag now
	[Int|Double|]Bag all have new fill(), sort(), reverse(), and shuffle()
		methods.  The shuffle method will make [Int|Double|]Bag reliant
		on ec.util.MersenneTwister; but you can snip that out if you
		don't need it.  Suggestion by Russ Abbott rabbott()calstatela.edu
	Added numObjectsAtLocation per suggestion by Norman Makoto Su 
		(normsu()uci.edu).  Also modified Continuous[2|3]D documentation
		to warn against using numObjectsAtLocation or 
		getObjectsAtLocation, both of which look up discretized regions
		and that'd give unexpected results.
	Console's JEditorPane is now public.  Suggestion by Russ Abbott
		rabbott()calstatela.edu
	Well, it appears that changing to TYPE_INT_RGB_PRE in fact is SLOWER
		on MacOS X 1.3.1. By 1/3!  So we're undoing that change.
	Released at the 2004 SwarmFest conference

Version 5
	Fixed bug in 2D offset -- they weren't being considered for hit testing
	Continuous[2|3]D's toroidal neighborhood had a bug where objects on the
		0 x or y or z border weren't grabbing values wrapped around, due
		to truncation of negatives rather than flooring them.
	Bags, IntBags, and DoubleBags can be initialized with a given capacity
	Added toroidal distance functions to Continuous2D and Continuous3D.
	Console's JEditorPane now has a back button and properly handles 
		hyperlinks.  Of course, now that the JEditorPane is public,
		people can mess this up if they please -- we trust you to
		be gentle.
	Made the DEFAULT_... stuff in [Oriented|Circled|Labelled]Portrayal2D 
		final.
	Added two more shapes to OrientedPortrayal2D options
	Added new Flockers demo

Version 6
	Fixed minor bug in ObjectGridPortrayal2D which displayed null object
		slots as "null" in the inspectors.
	Fixed bugs in tx/ty/tz: if the width/height/length is >= half the
		maximal size of an integer, the toroidal computation doesn't
		work properly.  In the process of fixing it we got rid of a 
		modulo, so they probably run faster now as well.
	Slight improvements in the speed of 
		Continuous[2|3]D.getObjectsWithinDistance(...).  I believe
		that it should still run correctly for all possible values
		of width, height, and length (see tx/ty/tz fixes above),
		but uses slightly less code and a few minor speedups.
	Slight fix to [Int|Double|]Bag.resize method so it doubles in size
		more often (correctly)
	Fix to our recent Continuous[2|3]D fixes: non-point objects
		now properly increase the size of the lookup.  Maybe we
		should revisit the non-point object issue in the future and
		consider a different approach (perhaps increasing the range
		of the lookup by exactly the maximum dimension of the
		object?)
	Added toPoint() to Int2D
	Bug fixes in CollectionProperties' handling of Bags etc.  I think
		we should move to a table mechanism anyway.
	In order to implement ObjectGridPortrayal3D, it's necessary to
		modify the completedWrapper(...) function to include
		a PickResult object as well.  We could deprecate the
		older function and create a new one which default calls
		the older one; but I highly doubt anyone is creating 3D
		fields at this time, so we'll just go ahead and modify it.
	Added ObjectGridPortrayal3D
	ObjectGrid3D's field moved from Bags (why was this here?) to Objects
	Deleted extraneous HeatBugPortrayal3D code
	Fixed bug in SparseFieldPortrayal3D and SparseGrid2DPortrayal3D which
		wouldn't properly handle new models created during getModel()
	Heavy bug fixes to ObjectGridPortrayal3D
	ValueGrid2DPortrayal3D allows cells to be displayed EITHER as squares
		or as two triangles.  This is because squares trigger a Java3D
		bug (well, Sun insists its a "misfeature" that's part of the
		spec, but IT'S A BUG) where squares bent at strong angles
		won't pick right, so selecting them goes all haywire -- the
		wrong squares get selected by far.  Why not just do it always
		as two triangles?  Why bother with the option?  Because if
		you just show the mesh's lines, the diagonal line of the
		triangles shows up.  That's the only reason.
	Gouraud Shading added to ValueGrid2DPortrayal3D's cells.
	Previously if you loaded a simulation from checkpoint in the Console
		while STOPPED, what happened was that pause() was pressed
		first.  This resulted in a fresh model getting spuriously 
		start()ed and then immediately wiped out by the newly-loaded 
		model.  This confused people who saw a start() happening
		even though it was generally harmless.  But we've modified
		Console.doOpen() now so that this doesn't happen.  To do 
		this we've modified Console.pressPause() so that it now 
		calls an underlying pressPause(bool) which optionally does
		startSimulation() only if in stopped mode and bool == true.
		Thus we can control whether or not pausing the model in
		stopped mode starts the simulation proper.
		All this is no big deal, I think (hope!).
	Modification to HeatBugs.setRandomMovementProbability() so it doesn't
		change all the bugs' probabilities mid-stream.  This helps
		us in an upcoming parameter-loading tutorial.
	Hard-code-inlined Int2D and Int3D's hash codes into Double2D and
		Double3D, eliminating the hashCodeFor() function which
		couldn't get inlined.  This saves us a few percent on
		Flockers etc.
	Added FastHexaValueGridPortrayal2D
	Moved the Buffering property up to FieldPortrayal2D.
	Modified hexabugs's model inspector to show how you can change
		the two kinds of hex grids
	All FieldPortrayals now store three new instance variables:
		an Object called field, an immutableField boolean, and a 
		dirtyField boolean.  This promoted the field and immutableField
		variables up from FieldPortrayal3D.  In the process we have also
		eliminated all references to instance variables called field
		in various FieldPortrayal2Ds; they all now use the central field
		variable (which is an Object) and so must ensure its validity
		in the setField(...) method (which they already do).  Added some
		lines at the beginning of relevant methods which say basically
			final MyFieldType field = (MyFieldType) this.field;
		for compatability with existing code.  The dirtyField flag
		is supposed to be set during all setField() operations and
		cleared (if the field cares about immutableFields at all).
	Tutorial 4 had referenced SparseGridPortrayal2D's field variable;
		now that it's an Object and not a SparseGrid2D (and it's not
		public any more also), we replaced it with getField().
	Console now kills all existing inspectors and rebuilds the model 
		inspector (if there is one) when the user loads from a 
		checkpoint.  Oops, we should have done that before!
	Replaced SelectionBehavior.SetInspectorsRunnable with a smaller,
		simpler anonymous class.
	Random number seed now shown when the model is first displayed.
	When a model is loaded from a checkpoint, who knows what the random
		number seed is; so we display "Unknown" instead.
	When the user enters an invalid random number seed, it's replaced with
		the original seed (previously we had been randomizing it).
	We were not performing the specified check for valid classes when
		loading simulations in the Console (validSimState()).
		Now we do.
	Additional minor functions added to Schedule
	Fixed a bug in Schedule.scheduleRepeating(event,interval) which
		scheduled for time() and not time()+1.
	Reduced the division count in spheres used for Woims3D from 15 to 6.
		This makes it usable at 200-300 Woims (by default it's 40).
		With 15 divisions, for 200 woims you have about 15*200*4=12,000
		polygons which for Java3D is horribly unusable, at least on 
		a Mac powerbook (our test). Here's hoping Java3D speeds up now
		that it's open source.
	Added some clearCapabilityIsFrequent(...) statements to possibly improve
		Java3D optimization
	Makefile revisions
	Tiny speed tweaks to SimpleColorMap
	Made MutableDouble a subclass of Number
	NetworkField.getEdgesOut(...) and NetworkField.getEdgesIn(...) no longer
		return null if there are no edges.  Instead they return an empty
		Bag.  In fact, they all return the *same* empty Bag.  This is 
		okay because your contract is to never modify the Bag returned 
		by these methods.  Modified NetworkPortrayal2D and NetworkField
		in a few places to obviate the need to do a null check as
		a result.
	Added NetworkField.getEdges(...)
	Added Edge.getWeight(...)
	Added methods to [Int|Double][2|3]D which bring them to approximate
		parity with Point2D.
	Added NetworkField.getAdjacencyMatrix(...) and
		NetworkField.getMultigraphAdjacencyMatrix(...)

Version 7
	Added Edge.getOtherNode(node), which simplifies algorithms which operate
		both on directed and undirected graphs.
	Bug fix to ImagePortrayal3D to set oriented polygon attributes without
		triggering a null pointer exception
	FieldPortrayal3D.defaultPortrayal now protected
	Added ColorMap.getAlpha(value), which simplifies some Java3D stuff.
	Fixed a bug in ParallelSequence which generated an error if the
		model thread was interrupted while waiting for the
		ParallelSequence to finish up.
	Worked around a MacOS X bug where if a Canvas3D is in a window which is
		hidden and then reshown, the Canvas3D doesn't redisplay itself.
	Worked around a Linux bug where if a Canvas3D is in a window which is
		hidden, the whole Java3D system hangs until the window is
		reshown.
	Added MutableInt2D and MutableInt3D, and modified SparseGrid2D,
		SparseGrid3D, Continuous2D, and Continuous3D to take advantage
		of the mutable versions.  MutableInt[2|3]D is hash-equivalent 
		with Int[2|3]D, and can be used to look up objects in hash
		tables keyed internally by Int[2|3]D.  This is helpful because
		normally in these SparseFields, lots of Int[2|3]Ds are created
		over and over again to look up neighbors.  Reusing a single 
		MutableInt[2|3]D thus saves a LOT of unneeded GCing.
	Replaced DecimalFormat with NumberFormat universally, including in
		Tutorial5
	Added SimpleEdgePortrayal2D.getLabel(), which is a hook you can
		override to customize the label without rewriting the drawing.
        Early version of the NetworkPortrayal3D and ValueGridPortrayal3D 
                provided; they may have bugs.
        OrientedPortrayal2D now fits in smallest dimension rather than largest.
	Added the balls3d and particles3d examples
	Numerical properties can now include domains (either min and max, or a 
		list of strings representing integer values' "names") in order
		to make possible pop-up lists and sliders in the various
		inspectors.  To do so, you create a function called domFoo()
		where Foo is your property name (along with setFoo and
		getFoo).  This function returns either an array of objects
		(representing the "names" to display for the values 0 ...
		array.length - 1) on a pop-up list, or a sim.util.Interval, 
		which represents either a double-valued or long-values min 
		and max range for a slider.
	Removed unneccessary checks for index < 0 and other == null, plus
		in Bag, IntBag, and DoubleBag, and allAll(...) now throws
		an exception of other == null or if index > numObjs or
		index < 0 rather than returning false (incorrectly).
	Added ThreadedDiffuser and made HeatBugs multithreadable.  Results
		in almost twice the speed in the underlying model when
		using two processors.  When multithreaded, the heatbugs console
		says so. Nifty!  I've noticed that Linux is bizarre in how
		well it does multithreading (or *doesn't*) in java.  Linux's
		threading is an unbelievable mess.  MacOS X is much more
		straightforward: 2x speedup give or take.
	Added a few sliders to HeatBugs and HexaBugs, and made a few more
		HexaBugs properties writable.
	Changed HexaBugs' Hexagonal/Rectangular popup to use the new
		Domain Property code (mostly to test it that's all).
	Made some methods in Schedule non-final (in case you want to override
		'em.  Also, Console now uses schedule.getTimestamp to get
		the timestamp to display -- you can thus override Schedule
		to provide a more interesting timestamp of your own if you
		like.
	Fixed typo in the license.  Thanks to Rob Alexander (rda()cs.york.ac.uk)

Version 8
	Tweaks to Makefile to make compiling with jikes more straightforward
	Removed colons from some labels in Console
	Cleaned up code in Display2D and Console so applets can tell they're
		running on Macs (and draw faster as a result).
	Added make jar to Makefile.  It makes a file called mason.jar :-)
	Wrapped all cases of thread.interrupt() in a try to catch for
		SecurityExceptions -- IE sometimes incorrectly claims a given
		thread of ours is not interruptable.
	Slight mods to SimulatorLayout.graffle
	SimApplet can now launch Console
	Added sim/app/mousetraps to Makefile.  Dunno why it wasn't there.
	Added sim/util/Valuable for some future usage.
	Displays now don't allow snapshots or movies when in applet mode.
	Console now doesn't allow open/save/saveAs when in applet mode.
	Console's quit menu works properly now in applet mode.
	Modified sim/display/SimApplet.html to work with the new mason.jar
	Fixed a bug in ParallelSequence which didn't serialize properly --
		generated a null pointer exception.
	Added Console to the layers menu.  Dunno if we like this or not...
	Added memory warnings to Particle3D
	Added even more speed improvements to heatbugs' diffuser, plus a
		long discussion and examples showing the progression of
		better and better diffusers.
	Modified mason.1.3.1.command so it doesn't try to specify the
		dock name -- looks like a bug in 1.3.1 will cause java
		to fail if the dock name is specified.  Oh, well.
	Slight bug fix to parallelized HeatBugs
	Added GUIState.scheduleAtEnd and GUIState.scheduleAtStart
	mason.1.3.1.command bombs if -Xdock is used.  It's a bug in OS X.
	Slight bug in MersenneTwister: seeds were only allowed to be 28 bits.
		The mask was supposed to allow 32 bits.
	Modifications to Inspector.  Inspector now states whether or not it is
		volatile (you can set this), and also provides a convenience
		"Update Button" for non-volatile inspectors.  Accordingly,
		isInspectorVolatile() is now deprecated.  This required a
		modification of Tutorial 4 I think to reflect the new
		approach.  This only really effects people who have made
		non-volatile model inspectors.
	Added [Int|Double|]Bag.shrink(...), now used in SparseField
	Bag.addAll was requesting bag resizes twice what they should have been.
	If SparseField.replaceLargeBags is true, and we need to replace a Bag,
		now we just shrink it rather than deleting it and generating
		a new Bag.  This saves a hash in setObjectLocation.
	SparseField.LocationAndIndex now holds onto the Bag containing all
		objects at the given location so we don't have to hash for it.
		This saves a hash in setObjectLocation.  The new field means
		previous serialized models won't work with the new version.
	Added SparseField.getObjectsAtLocationOfObject and
		SparseField.numObjectsAtLocationOfObject
	Upgraded MersenneTwisterFast to version 9.  Bug fix in seeder was
		only bothering to look at the first 28 bits of the seed.
		Now it's 32 bits.
	Slight fix to SparseGrid[2|3]D.getObjectLocationAsDouble[2|3]D(),
		which now returns null if the object doesn't exist
		(instead of bombing!  :-)
	SparseField.numObjectsAtLocation bypasses getRawObjectLocation().
	SparseField.getObjectsAtLocation now ALWAYS returns null if the
		bag is empty.  This should prevent some bugs people were
		having when turning off removeEmptyBags.  But it'll be
		a tiny bit slower methinks.
	Accordingly, slight modification to SparseField.getObjectsAtLocations
		since the bag size can now never be 0
	SparseField.removeObjectsAtLocation is now public and there's no
		need to override it with a public submethod.
	In SparseGrid[2|3]D.getNeighborsMaxDistance(),
		SparseGrid[2|3]D.getNeighborsHamiltonianDistance() and
		SparseGrid2D.getNeighborsHexagonalDistance():
		- the upper bounds in the for loops are now precomputed
		- "int x_0 = x0;" were removed
	Console.main() now checks to see if we're an applet, and doesn't call
		System.exit(0) if so.
	Console.doNew(...) now checks to see if there's a default constructor
		and signals an appropriate error if there isn't.
	Bug fix in NetworkPortrayal2D: it was drawing edges incorrectly with
		SparseGrid2D.
	Slight fix to AntsForageWithUI to draw the home pheromone faster
	simulation.classes can now contain comments and blank lines.  And if
		you add the word 'ONLY' to a line all by itself, the Console
		will only permit the user to select from the classes in the
		simulation.classes file: he won't be able to type in his own
		class.
	Maximum number of properties in the inspecrtor increased to 100
	Added MutableDouble2D in order to support some basic functionality
		in the upcoming physics model.
	Added FooDistance() changes to AbstractGrid[2|3]D just like they were
		changed for SparseGrid[2|3]D above.
	start\mason.bat was changed to work around pushd and popd, which are not
		available in win2k.
	Edge weights can now be sim.util.Valuable
	NetworkField now constructed to be either directed or undirected.
	Added pressed versions of all icons
	Modified the Update button and heavily modified / fixed the paging
		facility for inspectors with too many properties.  They now
		both optionally appear in a "header" above the properties.
	Schedule has new facility called cleanup, in preparation for more
		multithreading.
	Added asynchronous steppables to the system, which run in their own
		thread for some period of time.  This code may be very
		buggy for all we know, so use it at your peril.  :-)
	Revised notes.html to include multithreading info
	GUIState.scheduleAtExtreme now deprecated.  use scheduleAtEnd or
		scheduleAtStart
	Fixed bug in Schedule.scheduleRepeating(time,ordering,event) which
		tried to create a repeat interval of 0 in length
	If ScheduleRepeating(time,ordering,event,interval) has a negative
		or zero interval, the method fails and returns null now.
	Non-volatile inspectors are no longer updated (oops)
	MutableDouble2D
		-fixed a bug in subtractIn
		-added a bunch of set methods, plus reverse() and 
			addIn(double, double)
		-added a distanceSq method for Double2D
	GUIState.scheduleAtStart() and scheduleAtEnd() have been redefined.
		scheduleAtStart() now schedules things which will be called
		when start() is called, OR when load() is called.  Likewise
		scheduleAtEnd() schedules things which will be called when
		finish() is called, including just before loading a new
		simulation (see next item below).
	Upon loading a new simulation, GUIState.finish() is called on 
		the old one.
	GUIState.finish() now resets the queues (scheduleImmediate...
		scheduleAtStart/End).  If you had something there you'll
		have to add it again at start() time.
	FastValueGridPortrayal2D now writes directly to buffers.  This
		results in a drawing speed improvement of approximately 30%.
	FastHexaValueGridPortrayal2D also similarly writes to buffers
		(somewhat less efficiently), with a speed improvement of
		well over 35%.
	MacOS X 1.4.x has a stupid minimum window size (128x37 -- the docs
		say 128x32 but they're wrong).  That'd be fine except that
		if you pack() the windows to something smaller, they'll TELL
		you that their size is now smaller even though it isn't.
		It's a bug.  This bites small inspectors.  So we have a bug
		fix to keep OS X inspector windows from dropping below
		this size on pack().
	Bug fix in DoubleGrid[2|3]D.truncate(), which didn't round properly
		for very large (over long sized) double integers.
	Various Grid...getNeighbors...Distance(...) methods have been modified
		to return the neighbor Bag and to allow null neighbor Bags
		too be passed in (though it's not efficient to do so).
	Documentation improvements in sim.field.grid
	We are transitioning the *name* NetworkField to simply Network.  In
		order to give you some transition time, we have made
		NetworkField a subclass of Network and have deprecated it.
		In a following version we will delete NetworkField entirely.
		However if in the unlikely event your code relies on 
		knowing about the class NetworkField.IndexOutIn, you'll 
		have to make the transition immediately -- all it is is a 
		name change -- just use Network instead of NetworkField 
		and Network.IndexOutIn instead of NetworkField.IndexOutIn.
		And we'd like to know about you.
	Network.getEdges(...) un-deprecated
	Made HexaBugs's custom model inspector non-volatile
	Added some Java3D documentation
	Added a hack to MovieEncoder to eliminate the jmf.log file.  It
		appears to be working, at least on the Mac.
	"Spurious Sun JMF Error?" messages result in hanging the
		simulator.  Added some notifyAll()s in MovieEncoder in
		the hopes that we'd create a failure rather than a hang.
		Don't know if it works yet or not.  JMF is buggy.  :-(
        Identified the race condition which caused movies to lock up and
                bomb the simulator -- under certain conditions MovieMaker.add
                can be called while MovieMaker.stop or MovieMaker.start is
                called (from a different thread), while the MovieMaker is
                being destroyed.  Fixed in both Display2D and Display3D.
		The fix involves locking on the schedule whenever the
		MovieMaker variable is being modified or when stop() or
		add() or start() are being called on it.  Locking on the
		schedule will also pause the simulation while the movie maker
		is being set up or brought down, a good thing (JOptionPane in 
		would hang the program if the movie button was pressed while
		the system was running and not paused).  Display3D already
		had some pause/unpause code which did largely the same
		thing to fix the JOptionPane business, but with the race
		condition fixed this code has been commented out as redundant.
		Plus, it required Display3D to know that the underlying
		Controller was a Console (bad).  Note: at present the 
		pausing above doesn't deal with asynchronous
		steppables, which could conceivably fire off some swing
		event and gum stuff up.  We'll have to keep an eye on that.
	Identified the race condition which causes JMF movies to fail if
		you press stop during a JMF production and then try to make
		another movie -- stop calls interrupt() on the thread and
		JMF no like that while writing.  So what Console does now
		is synchronize on the schedule before calling interrupt().
		I think that's fine because the function of the interrupt()
		is to force Display2D out of invokeAndWait, and at that point
		Display2D's not locked on the schedule.
	Deleted some unused / unnecessary Display3D internal variables.	
        Bug fix in Hexabugs when number of bugs are changed in Console
        FieldPortrayal2D contains concrete default versions of the abstract
                methods getDefaultPortrayal(...) and setField(...) so it can
                easily be used simply to draw stuff on-screen and not wrap
                a field per se.
        Added how-tos
        Added FastObjectGridPortrayal2D and FastHexaObjectGridPortrayal2D
                These objects use Valuable or Number as their default tests.
        Modified speed slider to be more forgiving on the low-end
        Made SimpleEdgePortrayal2D and LabelledPortrayal2D capable of scaling
                their text
        Bug fix to mason.1.3.1.command, mason.command, and mason.sh, which had
                been failing if multiple jar files are found in the mason
                directory
        Documentation fixes in Schedule.  Thanks to Rob Alexander
                rda()cs.york.ac.uk
        Bug fixes to [Double|Int|]Bag.shuffle: it was doing a somewhat non-
                uniform shuffle.  Also minor bug fix to RandomSequence,
                which was including the final item in the shuffle (unnecessary)
        Bug fix to Properties.getProperties with four parameters: the recursive
                call has been replaced with a call to the getProperties method
                with an additional parameter.
        [March 24 Revision] Fixed bad jpeg files -- oops!


Version 9
        Version 9 has a real-valued schedule.  This necessitated a number of
                changes internally, including moving the Heap to accept
                doubles rather than Longs, plus lots of other little
                changes.  It shouldn't have much of a negative effect on    
                your code actually: most changes were internal.
		The biggest things that will affect your schedule:
			- The epoch is no longer 1.  It is now 0.0
			  This will affect you if you had scheduled
			  some items with the default mechanisms and others
			  where you explicitly said '1' rather than
			  'Schedule.EPOCH'.  Or maybe if some items
			  were scheduled to start at '2' or something.
			- You can now schedule items to occur at the
			  present time.  At present the meaning of this
			  is that they will be scheduled to occur at
			  the present time + epsilon, where epsilon is
			  the smallest possible non-zero interval.  In
			  the future, we may further modify this to allow
			  you to schedule events into orderings of the
			  current time which have not been fired yet;
			  but not now.
			- If you used an 'L' (like '12432L') or other
			  long to pass in express times, you should change
			  it to a double.
			- The semantics of Schedule.scheduleRepeating(event,
			  interval) have changed -- see below.
			- sim.util.Heap now uses doubles and not longs
        Console's look has changed: now only one number (time/steps/rate/none)
                is shown at a time, rather than showing steps and rate
                together (and only them).
        Schedule.scheduleRepeating(event,interval) has changed its meaning.   
                It used to be every [interval] ticks starting at time() + 1.0.
                now it's every [interval] ticks starting at time() + interval.
        SimState now has a convenience function called doLoop(...) which steps
                through the simulation for you, plus two functions
                extractArgument(...) and extractLocationAfterArgument(...)
                which provide some convenience mechanisms for dealing with the
                args[] list.
        All the applications and tutorials have been updated to use the much
                simpler doLoop(...) in their main(...) body code.
        Performed De-tickification.  Now that we have separate steps and time
                formally defined in the user's mind with a real-valued
                schedule, to which one does "ticks" refer to?  This was always
                a poorly-worded term.  We've changed all tick references to
                either time or steps.
        Merged in the next-queue stuff into the Schedule again.  This should 
                make the Schedule a bit faster for those simulations which   
                really deal in integral schedules; but we may have introduced
                bugs.  I hope not.
        Updated Tutorial2 to discuss the new doLoop(...) method
	Modified Schedule's documentation to reflect new scheduling info.
	Updated Schedule's and Schedule.Repeat's serialversionUIDs.  This
		should guarantee incompatability with the old schedule for
		purposes of serialization (a good thing).
	Made scheduleRepeating(final Steppable event) synchronized (eliminating
                a race condition).
	UN-merged the next-queue stuff.  Commented it out from Schedule but left
		it in in case you want to put it back in (see 5 comments ago).
		It appears that the overhead for doing next-queue in the real-
		valued Schedule outweighs the overhead for not having it now.
		We could also improve the Schedule perhaps by using a single
		heap and pre-sorting by ordering; I wonder if that buys us much.
		At any rate, right now we have about 4% decrease in efficiency
		in rapid-step items such as Tutorial 5 when compared to the
		integral Schedule despite my best efforts at optimization.  :-(
	[March 24 Revision] Fixed bad jpeg files -- oops!

Version 10
	Fixed Display2D.takeSnapshot() which should have taken a snapshot
		WHEN the button is pressed, but on Windows/XWindows it
		was allowing the buffer to be shared with the current graphics
		context and the image stored would be something much later,
		when the image was being saved, oops.
	Fixed Display3D.takeSnapshot() to take a snapshot WHEN the button 
		is pressed, not when the image was being saved (i.e. file was
		selected).
	Fixed Console so that the pop-up time/rate/etc. menu isn't stretched
		in Windows.
	MouseTrapsWithUI takes advantage of the double-time scheduler; 
		MouseTraps3DWithUI is still on discrete time-steps.
	Added Display2D.attach(..., visible) and Display3D.attach(..., visible)
		added so you can attach portrayals hidden.  We may add more
		programmatic capabilities in the future.  We also made 
		certain PortrayalHolder variables consistent.  Thanks to 
		Rob Alexander <rda()CS.YORK.AC.UK>
	Bugfix in Balls3DWithUI: we had been changing the labels every time
		to test that feature and forgot to remove it for versions 8
		and 9, resulting in very slow redrawing.
	NetworkField.java deleted.  We said it'd happen!  Use Network.java.
	Fixed a bug in FastHexaValueGridPortrayal2D which, for non-Mac users,
		was skipping every other line to draw.  Oops!  Sorry about that!
        Updated MersenneTwister to latest version (11)
                Thanks to Seth Sticco sethn()snsware.net
	Small HTML fixes, spelling fixes, etc. to howto.html
	Added exception throwing to Schedule and GUIState to make errors in
		one's models' scheduling behavior more obvious.  See the
		documentation for these classes to understand how to change
		back to the previous behavior if you so desire.
	If you double-click on a hidden field portrayal, it won't give you
		inspectors any more.
	Fixed a bug in HexaObjectGridPortrayal2D.hitOrDraw: the HexaDrawInfo2D
		object for the simple portrayal had width and height swapped.
	Added -version option to MASON to print out versioning.  Thanks to
		R. Paul Wiegand <paul()tesseract.org>
	Added about box.  Also thanks to Paul.
	Further speedups to HeatBugs' diffuser
	Added TentativeStep
	In doLoop, no need to check for (until <= POSITIVE_INFINITY)!...
	Fixed bugs related to hexagonal neighborhoods in non-toroidal spaces
	Optimized the diffuser for hexabugs, which is now three times faster.
	Optimized the diffuser for antsforage, which is now rather faster.
	Bag Docs fix. Thanks to John McManus <jmcmanus()rsmas.miami.edu>
	Added ObjectGrid[2|3]D.clear()
	Added discussion of deleting things to the howto.
	If you press TAB or SHIFT-TAB in a PropertyField, it will be submitted
		just like if you pressed RETURN.
	Bug fix in sliders for integer property fields.  Thanks to Chad George
		<chad()mgproductscnc.com>
	Property fields for integers now accept double values that are integral
		(like "1.0")
	Added MutableDouble3D.java
	Made all Mutable... classes Cloneable.
	Added some methods to MutableInt3D, MutableDouble2D.
	Added WordWrap.split()
	Added a new constructor for Console to allow specifying the random seed.
	Fixed a bug in FastValueGridPortrayal2D that made it crash when zooming
		too much into the field.
	Fixed a bug in Schedule.Repeat and GUIState.Repeat: if time has expired
		in the Schedule, further repeated objects would have exceptions
		thrown when they tried to reschedule.  No catch was made for
		that so it'd just get printed to the screen (oops).
	Fixed AbstractGrid2D to complain about toroidal hexagonal fields that
		have an odd width.  It was before complaining about odd heights.
	Added some minor efficiencies and documentation statements which should
		improve speed if/when we allow opaque FastValueGrid2DPortrayals
		in Windows and X11.
	Added TransformedPortrayal2D and ShapePortrayal2D.
		TransformedPortrayal2D still needs to have its hitObjects code
		working properly.
	Fixed bugs in various Mutable/NonMutable Int/Double 2D/3D .equals(...)
	Reformatting

Version 11
	ValueGridPortrayal3D wasn't passing the polygonAttributes() method to
		its underlying child portrayal.  That's been fixed.
	ValuePortrayal3D now can draw either a cube or a square.
	Display3D's cull-setting and polygon mode-setting now catches
		javax.media.j3d.CapabilityNotSetException
	Upgraded MersenneTwister to version 12
	Switching to getDeviceConfiguration().createCompatableImage(...), as
		suggested by Sun, produces bizarre bugs in Java 1.3.1 on
		the Mac.  We've gone back to making BufferedImages the
		old fashioned way: with new BufferedImage(...)
	Added [Double|Int]Grid2D to ValueGridPortrayal3D.
	Changed the check field's listener from a ChangeListener to
		an ActionListener to fix it in PropertyField.
	LabelledList now can do 5 columns (2 main ones and 3 interspersed)
	Small tweaks to SimpleInspector
	Tweaks to tutorials
	View Button on PropertyField moved to left
	Added some tweaks to be more compatible with Quaqua
	Added tool tips to Display2D
	SimState's asynchronousLock is now a boolean[1] rather than a string
		because arrays are both serializable *and* unique.  Strings
		are not unique, so in theory someone else could have locked
		on the String.
	AsynchronousSteppable's documentation has been enhanced and fixed.
		We now include an example for full pause and resume, and we
		have changed the locks from strings to boolean[1] for the
		same reason as described immediately above.
	Slight efficiency improvements to Bag.addAll(...) when a Bag
		is passed in as a Collection.
	ValuePortrayal3D's geometry array is shared
	Added Properties.getObject()
	Added Inspector.createFrame() and SimpleInspector.createFrame()
	Added TabbedInspector
	Fixed (mostly removed) "un-read variable" warnings in 
		PngEncoder, MiniHistogram, Heap, Axes, QuadPortrayal (fixed), 
		ObjectGridPortrayal3D, LabelledPortrayal2D (fixed),
		HexaValueGridPortrayal2D, FieldPortrayal, DoubleGrid2D (fixed),
		DoubleGrid3D (fixed), SimState, Display3D, ToolTipBehavior,
		BandPortrayal2D, CooperativeObservation, Woims3D, Woim
	Fixed bug in DoubleGrid3D.setTo()
	Fixed bug in various popup menus: their Y location was incorrectly
		specified
	Added SinglePropertyInspector
	Added singlepropertyinspector.classes file
	Added StreamingSinglePropertyInspector
	Updated MersenneTwisterFast
	Added Utilities, merged some common static methods into this class
	Bugfix to MovieEncoder: if images are added fast enough, the very
		last one may not get included in the file.  Thanks to
		Anja Colgan (a.colgan()iggf.geo.uni-muenchen.de)
	Added Property Inspector facility, creating new package 
		sim.portrayal.inspector. The new facility permits dynamically
		loadable per-property inspectors designed for certain types
		of data.  This is in preparation for the Chart inspector.
		We've moved TabbedInspector into sim/portrayal/inspector,
		and have added the classes:
			sim/portrayal/inspector/PropertyInspector.java
			sim/portrayal/inspector/StreamingPropertyInspector.java
			sim/portrayal/inspector/propertyinspector.classes
			sim/portrayal/Inspect.png
			sim/portrayal/InspectPressed.png
	Added Charting facility.  While we've done our best to make it
		possible to delete this facility if you don't want it, but
		otherwise this facility will require iText and JFreeChart.
		The facility includes:
			sim/util/media/ChartGenerator.java
			sim/portrayal/inspector/ChartingPropertyInspector.java
	Fixes to Balls3D: deleted lots of static junk, and generally cleaned
		up the portrayals; fixed a bug causing the balls to not bounce
		in a certain direction; and renamed NodePortrayal to
		BallPortrayal.
	Slight mods to MiniHistogram
	Changes to Schedule, Heap, and SimState:
		Heap now uses Comparables as its keys, not doubles.  We may
			change this to a Leftist Heap if the constant is not
			too high.
		Schedule now allows any number of orderings without specifying
			them at construction time, and uses just a single
			heap.  This is much simpler and more flexible code, 
			but it is likely to be slower, as we're now allocating
			Comparables instead of using doubles as keys.  We're
			trying to reuse Comparables where we can though.
		SimState now has a method called kill() which is a way that
			Steppables scheduled on the Schedule can kill the
			entire simulation.  Untested though.
		One result of all of this is that the sorting order of objects
			within an ordering will be different than they were
			before.  Still properly randomized, but the
			randomization won't be the same.  This is because
			we're pulling out of a single heap rather than multiple
			ones and the single heap shuffles objects internally
			as it pulls them out in a different fashion than
			the multiple heaps do.
        Added tool tips to Display3D
	Fixed a race condition in Display3D.reset() which would cause the
		skip field to lock up
	Fixed bugs in LocationWrapper -- some field portrayal 3Ds were
		triggering null pointer exceptions in getLocationName()
		when the object had left the field.
	Updated mason.bat to include the jars in the mason directory to 
		classpath.  Added ignoreme.bat.
	Bug fix to Network.removeEdge(...): undirected graphs were
		resulting in bombing when removing edges due to incorrect
		shifting of new edges' indices.  Thanks to Peter Vrancx
		(pvrancx()vub.ac.be) and Mike Little 
		(little()research.telcorida.com) for the bug reports.
	Bug fix to Network.removeNode(...): graphs were not removing the
		node's indexInOutHash from the hash table, so if you
		removed the node twice, it'd corrupt the nodes in the
		allNodes bag. 
	Formally added schelling to the apps
	Schedule.reset() now stops everything immediately instead of waiting
		until the next timestep.
	Updates and cleanups to MutableDouble[2|3]D
	GUIState.getName() and GUIState.getInfo() have been deprecated and
		made final -- this will necessitate a minor change.  If you
		were implementing getName() and getInfo, just change your
		implementations to be under 
			public static String getName()
		and
		        public static Object getInfo()
		If you were *calling* these methods, then you should instead
		call
			public static String getName(Class theClass)
		and
			public static Object getInfo(Class theClass)
		The point of these changes is to make it possible to extract
		the name and information about the simulation GUIState without
		having to instantiate it.  We may yet change the names of
		these suckers, but will try to do so in at least a partially
		backward-compatible way.
	Fixed a bug in Schedule which threw an null-pointer exception when the
		schedule ended because there was nothing left in the Schedule.
		This was due to our revised single-heap Schedule design.
	SimState now can be constructed with just a MersenneTwisterFast (the
		Schedule is made for you) or with just a random number seed
		(the Schedule and MersenneTwisterFast are made for you).  This
		is possible because the Schedule no longer requires orderings to
		be prespecified.
	All apps and tutorials updated to reflect the new SimState constructors,
		getName(), getInfo(), and other little items.
	Broke out the HTML browser into a separate class, sim.util.HTMLBrowser,
		to enable a new simulation-selection mechanism.
	Updated the doNew() method to show a new window with a list and HTML
		views of the various classes
	Updated Console.informOfError() method so it doesn't need to have a
		frame to do its job
	Fixed checkpoint error in Schedule.Key
	Updates to Tutorial 4.  Thanks to Mitch Potter mpotter()cs.gmu.edu
	Removed printlns in Network.java
	Added a few more scheduleOnce and scheduleRepeating methods to make
		certain things a little easier; but we made a mistake early
		on in the order of our parameters for scheduleRepeating
		and as a result it's nontrivial to make a method which
		lets you just schedule something repeating for a given
		ordering with a default interval and starting at time+1
		(the default).  At best we can now let you do 
			scheduleRepeating(steppable, ordering, 1)
		To do better we'd need to come up with a new name for
		the method rather than continuing to overload the name.  :-(
	Tweaked to satisfy Java 5 -Xlint warnings except for serialization and
		unchecked warnings.
	Added an attach method to Display2D which allows easy translation of
		the world coordinates (to move 0,0 to the center of the screen,
		say).
	simstate.kill() now sets the schedule to AFTER_SIMULATION
	Reindented
	Bug fixes in PropertyInspector and ChartingPropertyInspector
	Made AsynchronousSteppable.run(...) and halt(...) protected, and
		fixed documentation example errors which did not properly
		reset the flags afterwards.  If you were using
		AsynchronousSteppable, you should reread the documentation.
	Added some more howtos
	Replaced '@' with '()' in all email addresses in CHANGES
	Added method Console.stopAllInspectors().  pressStop() calls this
		to stop all the inspectors though not close them.
	Deleted spurious ExperimentalToolTipBehavior.java
	Added new Console method stopAllInspectors which stops inspectors
		but does not delete them.  This method is now called when
		the simulation stops.  It's also called by
		removeAllInspectors when the simulation is started; thus
		Stoppables may get called multiple times.
	Added new Inspector method reviseStopper(...), which gives the
		user a hook to "wrap" the stopper the system is going
		to use.  Various Inspector subclasses updated.  This
		fixes a bug in MASON where inspectors' stoppables weren't
		being reliably called if they were doing wrapping in the
		createFrame method (as was the case for
		StreamingPropertyInspector for example).  This was a
		significant revision of a number of classes in little
		places.  Let's hope all went well.
	Updated StreamingPropertyInspector to be able to stream to
		files, append to files, write to stdout, and write
		to a window.
	Heavily updated the Inspector and PropertyInspector documentation
		to explain the various ins and outs of these classes.
	Removed System.out.println in most cases from the code.
	Framerate now updates once every half second (and doesn't redraw
		unless it's changed)
	Moved DialogToolTip to sim/util/gui
	Significant revamping of documentation
	SimplePortrayal2D.hitObject(...) now returns FALSE by default.
		This is proper given that it's supposed to be an
		invisible, non-selectable object.
	SimplePortrayal2D.setSelected(...) now returns true by default.
	Console strips out failed classes (perhaps Java3D classes) from
		the simulation list.
	Added legend checkbox to ChartGenerator.
	Added rudimentary setSelected(...) functionality to Continuous2D
		and SparseGrid2D.  For an example, see MavDemo
	Relicensed under Academic Free License Version 3.0
	Added MutableDouble3D.setLength and MutableDouble2D.setLength
	Slight tweak to MutableDouble2D.normalize and
		MutableDouble3D.normalize: multiplication by 1/x rather
		than division by x, should be a tiny bit faster.
	Removed Vector2D.java from Keepaway.  Replaced with
		MutableDouble2D.
	Fixed some bugs in Keepaway.
	Bug fixes in Light Cycles.
	Class renaming in LSystem.
	Bug fixes in LSystem.
	In all simple 3d portrayals, the top-level transform group now
		can have its children read.
	ValuePortrayal3D.getModel(obj,...) officially states that obj
		should be a ValueWrapper and not some other object.
		ValueGridPortrayal3D now assumes this and doesn't try
		to set the userdata anyway.
	Fixed bugs, added features to Shape3DPortrayal3D
	Removed sim.app.crowd3d.GullPortrayal3D.  Replaced with standard
		Shape3DPortrayal3D.
	When balls' masses are changed in 3D Balls and Bands, the spheres
		change size appropriately.
	Updated simulation documentation text.
	Modified ValueGridPortrayal3D to look up the user data in the
		child of the transformgroup, not the transformgroup itself.
	Squashed a nasty bug in Java 1.4.2/1.5 on OS X when making 2D movies.
		The buffer was being shared by accident, and this resulted
		in excruciatingly long drawing times to the buffered image.
		Now if we can just figure out why 3D movies and PNGs sometimes
		generate black blanks.  :-)
	ShapePortrayal2D should now hit-test (hopefully).
	Upgraded MersenneTwisterFast to version 14
	Slight bug fix for Bag.shuffle, IntBag.shuffle, DoubleBag.shuffle,
		and RandomSequence.step.  In all cases shuffling was done
		even for the very last element (which would be staying
		put anyway).  No big deal.
	Bug fix in OrientedPortrayal2D, which hadn't done any hit testing
		as it relied on the underlying SimplePortrayal2D to do so;
		now that SimplePortrayal2D doesn't hit-test, flockers weren't
		hitting.

Version 12
	Minor refactoring: removed unused variables, import declarations, and
		a few method calls.
	Some of the Grid3D subclasses were using fieldx[y][z] when
		fieldxy[z] was available -- we updated them to use fieldxy[z]
	Added option for hit-testing on OrientedPortrayal2D at the user's
		choice.
	Fixed bug null pointer exception in ChartingPropertyInspector
	Refactoring ChartGenerator to allow for Histograms and other kinds of
		charts which share common code.  This required moving to a new
		package and renaming the old ChartGenerator to
		TimeSeriesChartGenerator.  You'll need to update your code.
	Added HistogramChartingPropertyInspector, moved 
		ChartingPropertyInspector to 
		TimeSeriesChartingPropertyInspector, and made an abstract
		superclass ChartingPropertyInspector
	Updated howto.html to reflect the revision
	Minor bug fix to Schedule: if the time was AFTER_SIMULATION, and
		someone scheduled an event at that time, then it'd get
		bumped to AFTER_SIMULATION's bits + 1, which equals NaN.
		So we keep it at AFTER_SIMULATION (which will properly
		fail).
	Added portrayalForNonNull as an option to FieldPortrayal.  It's
		checked for after checking to see if the object is
		a Portrayal itself, but before searching the hash table
		for a registered portrayal.  The code is rearranged
		a bit to be easier to read and cleaner.  The purpose for
		portrayalForNonNull is to make typical 
		ObjectGridPortrayal2Ds quite a bit faster because you
		can just provide a portrayal for null objects and
		a portrayal for non-null objects.  It shouldn't slow
		down other graphics stuff except by a tiny amount, as
		it's just another quick check.
	Added MiniHistogram.makeBucketPositions, though it's presently
		unused.
	Added some gizmos in HeatBugs as example for Histogram
	Indexed.getValue() explicitly throws IndexOutOfBoundsException
	Minor null pointer exception in LightCycles fixed
	Small efficiency improvements in AbstractGrid2D/3D and
		SparseGrid2D/3D
	Added scheme example
	Added PSO3D, made small tweaks to PSO
	An incorrect bug report motivated a change in Console's loading
		of classes.  Now we have a method called buildClassList
		which is called lazily on doNew() or on the construction
		of a Console, rather than doing the class list building
		in static { } which is where we had it originally
		(and which probably wasn't a good idea).
	Tweaks to doLoop, keeping around the job number and random seed
		across checkpoints so they continue on recovery from the
		command line.  The GUI largely ignores this; it's mostly
		for people who want to have better control of the small
		loop facility in MASON.  Also, SimState.job() is introduced,
		giving the user some knowledge about which job number is
		being used.
	Minor patching to CapturingCanvas3D to avoid getting blank 
		snapshots of Display3D.  There might be a race condition 
		in GraphicsContext3D.readRaster(). Right now we call 
		readRaster twice and this seems to fix the problem.
	Bug fix Bag.java's iterator remove() method.  Performing a remove
		wouldn't back up to let next() consider the new item
		which just got put into the removed item's slot.  Thanks
		to Bruna VanDenBossche (Bruno.VanDenBossche@intec.ugent.be)
	Properties._setValue now protected
	PropertyInspector.setStopper now public
	ObjectGridPortrayal2D now has a SimplePortrayal2D as its default
		null portrayal, to be a bit more consistent with
		SparseGridPortrayal2D.	
	Slight speed tweak to Schedule.Key.compareTo() which considers the more
		common possibilities first.  Hope that didn't break anything.
	Added PDFEncoder.java.  Ultimately we'll use this to make nice PDF
		output of 2D displays.
	Fixed bug in ChartGenerator.setDomainAxisLabel (wasn't setting the
		value right).
	Fixed slight bug in ChartingPropertyInspector which was preventing us
		from adding data immediately on popping up a window.
	Charts now saved with ".pdf" extension, not ".PDF"
	PDFEncoder.java has been rigged up to allow the user to save 2D
		screenshots in either PDF or in PNG
	Adjustments to dialog boxes to make them look better in OS X; don't know
		if we uglified them in Windows yet.
	Merged Antialias and Antialias Text together in Display2D's options
	Charts now draw in color.  We had previously set them to only draw
		with black lines for printing purposes -- now they're in 
		color because of people's requests.
	SimpleEdgePortrayal2D can now draw edges either as lines or as
		triangles.  May add arrows in a bit.
	Added the ability to turn off random shuffling in the Schedule, per
		request from Michael Lees (mhl@cs.nott.ac.uk)
	Fixed background errors in buttons in Windows
	Charts now update NOW if they're not already waiting to update.  A
		minor improvement, but which necessitates a change in method
		name in ChartingPropertyInspector 
		(updateAfterTime -> updateBefore)
	Updated various buttons to have transparent backgrounds so they look
		proper in Windows.
	Bag.clear() now sets its values to null, allowing them to GC.  This
		is slower but doesn't leak memory.
	Slight tweaks to Tutorial3 docs to clarify issues in seralization.
	Bug fixes in MAV and Woims, which were using the old hitObjects(...)
		method instead of the new(er) hitObject(...) method, and so
		couldn't be hit any more.
	Updates to FieldPortrayal to make object lookup slightly faster.
		Specifically, the portrayals and classPortrayals
		WeakHashMaps aren't allocated by default now.  So we check
		to see if they're non-null before querying them; thus if
		they were never used, they're skipped entirely and no
		hash is performed on them.
	Tweak to Console: pause and step buttons now cause all displays
		to repaint themselves even if skip is high.
	Added to Display3D a spotlight behind the camera and an ambient
		light.  Deleted the custom spotlights in Balls3D and in
		Woims3D, but retained the three spotlights in Crowd3D
		as an example.
	The Backdrop is by default turned *off* now in Display3D, but
		is auto-turned-on when you set it.
	Slight modifications to tx(), ty(), and tz() for efficiency.
		We check to see if the value needs to be wrapped around at all,
		and if not we can return it rather than doing a %, which
		is of course expensive, particularly in floating point.  With
		a little rearranging, we can still do this inside 35 bytes
		so it gets inlined.  Here's hoping we didn't introduce bugs.
	Added check to ParallelSequence which looks to see if the sequence
		is being run nested or in parallel, both no-nos.
	Revised Tutorial3 to explain anonymous classes to those inexperienced
		with them.
	Changed the constructors of SimpleEdgePortrayal3D to match the ones
		from SimpleEdgePortrayal2D; and just as in 
		SimpleEdgePortrayal2D, one can have the line painted with 
		2 colors.
	Changed the insides of Arrow: the hight of the arrow head cone used to 
		be independent of the arrow length; now we test for the case 
		when the arrow head gets to be larger than the whole thing and 
		make the head a fraction of the total length. Also, the 
		components (the cyclinder tail and cone head) are now 
		accessible.	
	Created GenericEdgePortrayal3D, that takes any java3D Node and
		streches it between every pair of vertices where there's an 
		edge.
	Created subclasses of GenericEdgePortrayal3D:
		ArrowEdgePortrayal3D, ConeEdgePortrayal3D, 
		CylinderEdgePortrayal3D, and Shape3DEdgePortrayal3D.
	When the simulation was stopped, charts would disappear.  (Fixed).
	Slight speed tweaks to Bag, IntBag, and DoubleBag remove(...).
        javac has grown up and jikes has fallen into disrepair.  We move
                ECJ's default compiler to javac -target 1.3 -source 1.3
	Updates to MersenneTwisterFast
	Added indent to make dist
	Tweaks to make jar so we add a manifest which fires up a default form
		of MASON if double-clicked on.
	Modified Display2D's checking for iText so it doesn't bomb if iText 
		isn't there!
	Bug fix so the options button on Display3D appears properly

Version 13
	Updates to MersenneTwisterFast
	ChartGenerator: Added log-axis check-boxes
	Fixed import statements in Display3D to eliminate an ambiguity error:
		[Console: sim.display / java.io]
	HistogramSeriesAttributes: replaced the call to getSeriesPaint() with
		getItemPaint(), in order to make it work with version 1.0.6 of 
		jfreechart, while keeping it backward compatible 
		(tested with version 1.0.1 of jfreechart).
	SeriesAttributes: isolated getPlot().getRenderer() in a function
		(XYItemRenderer getRenderer()) to allow extensions to handle 
		multiple renderers.  The change affects 
		HistogramSeriesAttributes and TimeSeriesAttributes.
	HistogramGenerator: fixed a bug in removeSeries to preserve the
		attributes of the remaining series.	
	HistogramSeriesAttributes: fixed a bug with the series name being null
		in the remove series confirmation dialog
	TimeSeriesAttributes: same underlying problem as before: null returned
		by getSeriesPaint()  (which caused a missmatch between a 
		series' color and the initial color in the color well in the 
		attribute inspector for that series).
	HistogramGenerator: added function addSeriesToDataSet to isolate
		dataset.addSeries behavior, so it can be changed later (instead
		of overriding the entire update() function.
	ChartGenerator: legend is now built based on the XYPlot, not just its
		main renderer; series using different renderers will all be 
		included in the legend now.
	ChartingPropertyInspector: the ChartGenerator object is available 
		through getGenerator() method
	ChartingPropertyInspector: new constructor allows one to supply the 
		chart generator.  Matching constructors available in subclasses 
		(HistogramChartingPropertyInspector, 
		TimeSeriesChartingPropertyInspector)
	New Schedule, with improved functionality in multithreaded environments.
		This hasn't been tested particularly well and may introduce 
		bugs; please let us know.
	Removed vestigial 'parent' instance variable in PropertyInspector, 
		which wasn't really being used.	
	ChartGenerator: swing makeover to prevent series attributes from spreading
		to cover any vertical space.  Also, added 'up' and 'down' buttons
		in icon form, plus a close box in icon form, to the series
		attributes to enable them to move relative to one another.  Right
		now they're in a suboptimal location: next to the 'show' button.
		Maybe we can move them later.
	Added MethodStep and explained its functionality, and MASON's general
		use of Steppable, in the HowTos
	Slight speed improvements to internal uses of stx/sty/stz where the
		width/height/length is passed in
	Changed Schedule's lock variable to a boolean[1], which is Serializable,
		unlike Object.  Bug fix.  Thanks to Bruno Vandenbossche
		(bruno.vandenbossche@intec.ugent.be) for noting the bug.
	Eliminated Asynchronous interface
	Added CausedRuntimeException for MethodStep
	Schedule.getTimestamp now defines before-simulation times as being
		being less than EPOCH.
	Slight bug fixes to MiniHistogram
	Added new HowTo for hiding the Console, made slight modifications to
		Display2D and Display3D to accommodate this.
	Bug in MutableDouble3D and Double3D's hash value wasn't considering
		x values as part of the hash.
	Added some more distance methods to MutableDouble2D and MutableDouble3D
	Changed all JTextFields in the charting facility to PropertyFields.  This
		is much cleaner and shorter, and works better too.
	Set Display2D.innerDisplay to be opaque.  As a result, many 2D
		simulations run at up to twice their previous visualization speed.
		This necessitated setting the background for the Display2D scroll
		pane as well.  For good measure, also set the MiniHistogram to be
		an opaque JComponent instead of a non-opaque JPanel.
	Added a Display3D.destroySceneGraph() method and modified all 3D apps to
		call this new method prior to creating any portrayals (basically
		to call it at the beginning of setupPortrayals).  This unhooks
		the scene graph so any shared Java3D geometry isn't live any more
		and we don't get any Java3D complaints when we're just making new
		portrayals.  Updated the tutorials as well to reflect the new
		arrangement.
	Made the geometry of SpherePortrayal3D, ConePortrayal3D, and 
		CylinderPortrayal3D shared.  Previously we were worried this would
		also share the picked objects or the colors among the nodes, but
		it doesn't appear to be the case.  Will only work if destroySceneGraph()
		is properly called first.
	Fixed bugs in EdgePortrayal3D subclasses: model updating wasn't implemented
		so if you added or deleted an edge, it wasn't reflected in the
		scene.  Also we moved the pickability-setting capabilities into the
		constructors for the Java3D objects because it tickled capability bit
		problems elsewhere somewhere deep inside Java3D.  
	Added propertyinspector.classes to the Makefile's jar builder

Version 14
	Fixed bugs in MutableDouble[2|3]D.subtractIn.  Modified Keepaway to work with
		the bug fixes.
	Added a few MutableDouble[2|3]D.addIn methods.
	Added DrawInfo2D.equals(...)
	Tweaks to SpatialNetwork2D and NetworkPortrayal2D allow TWO fields to be
		embedded in a SpatialNetwork2D, to facilitate lines drawing FROM
		elements in one field TO elements in another field.  This required
		changing the instance variables, which may break applications which
		have customized on these classes, but it makes things simpler too.
	Similar tweaks to SpatialNetwork3D and NetworkPortrayal3D.
	Removed getPoint() from Int2D.java, which eliminates some inspectability
		issues.  It was deprecated last year.
	Tweaks to MutableDouble[2|3]D.setLength() methods with more error checks.
	Heap.java has been modified to check for heaps of size 1 or 0 and be a
		little bit faster in those (very common) cases.  Hope we didn't
		break anything!
	Modified Display2D so that zooming in maintains the location of what you
		were looking at.
	Wrapped the Schedule.step() method in a try { } so it doesn't bomb if the
		underlying agent throws an exception.
	Added Double2D.getNearestNeighbors() method.  No guarantees that it works!
	Added getFrom() and getTo() methods to the Edge object so they can be
		more easily inspected.
	Modified FieldPortrayal to make Locations inspectable as well as objects.
		Because the locations can get large, we included a disclosure
		triangle which keeps the location small until the user clicks
		on the triangle to inspect the location.
	Added DisclosurePanel to enable this.
	Removed the "View" buttons in various inspected properties.  Now the
		user does "views" of composite objects by clicking on the magnifying
		glass.  It looks cleaner and makes more sense to the user, even if
		the "view" is technicall not popping up a property inspector.
	Inconsequential changes to SimpleEdgePortrayal2D's constructors.
	Modified NetworkPortrayal3D and SimpleEdgePortrayal3D to remove some
		old, uneccessary parameters to constructors.
	Changed "Appending" option in StreamingPropertyInspector to be more user-readable.
	Modified SimpleColorMap to more often show the "largest" color -- a more
		uniform distribution.
	Modified ChartGenerator to have a white background.  This makes it more
		ready by default to be exported to PDF for inclusion in publications.
	Made SimpleEdgePortrayal3D the same as SimpleEdgePortrayal in how it shows
		the inspectableness of edge locations.
	Modified ContinuousPortrayal2D and SparseGridPortrayal2D to use new
		"StaticLocation" objects.  This allows locations to be inspected and
		charted continuously even though the locations of objects are constantly
		changing.  Added various StaticLocation objects.
	Modified Properties and SimpleProperties to allow a new "hideFoo" property
		element, indicating that the developer doesn't wish the property
		to be displayed.  SimpleInspector now respects this wish.
	Added selection code to SparseGridPortrayal2D and HexaSparseGridPortrayal2D,
		copied mostly from ContinuousPortrayal2D.
	Removed old setClip code from SparseGrid2D
	Added getLocation() to ContinuousPortrayal2D, SparseGridPortrayal2D, and
		HexaSparseGridPortrayal2D.  This code is intended to assist in
		future object tracking.
	Added selectability to ObjectGridPortrayal2D
	Added toIntegerArray, toLongArray, toDoubleArray to IntBag
	Revised some documentation in NumberTextField
	Revised HistogramSeriesAttributes to provide more flexibility in programmatic
		setting, and likewise in TimeSeriesAttributes
	Modified Display[2|3]D.java, Console.java to force the Quartz renderer on Macs.
		The Sun renderer is awful.
	Added "-server" to all scripts in the 'start' directory.  Hotspot Server is
		quite a bit faster for MASON than Hotspot client.
	Added some code to change the unit increment in scroll bars when Display2D is
		resized.  This makes the scrolling non-ridiculously slow, particularly
		for the Macs' two-finger gestures.
	Bug fixes to Display2D: (1) the Movie Maker now writes out step "0" of the
		simulation (prior to any steps happening) (2) the Movie Maker properly
		handles starting a new movie when the simulation is stopped -- in this
		case it starts up a new simulation paused (3) the Movie Maker also
		pauses the simulation when starting up a simulation fresh (4) now in
		windows and X Windows, MASON does a repaint() each step rather than
		doing a direct draw to the screen, because of race conditions discovered
		by Pelle Evensen (pelle@evensen.org), thanks (5) paintToMovie now takes
		a Graphics argument (6) paint(...) now always takes three arguments, the
		two-argument version has been deleted.  All this is likely to be slower
		for Windows and X Windows but should be thread-tight.
	Fixed bug in SpatialNetwork2D constructor (field was set to itself, and thus left null)
	Using TYPE_INT_ARGB now for FastValueGridPortrayal2D to be more compatable with
		Windows.
	Added sim.util.Propertied, and the ability for SimpleProperties to be attached
		to Propertied objects.  This is largely in preparation for providing
		dynamic properties via scheme.
	Commented out a chunk of code in MovieEncoder which prevented JMF from creating
		little jmf.log files.  This code appears to be causing JMF to fail under
		Java 1.6 on OS X (at least).  :-(  JMF is a pain.  If the little JMF poops
		show up again, we may need to test for 1.6 and not do this code only in
		that case.  Thanks to Amelia Ritahani (ritahani@cs.york.ac.uk).
	Tweak to MovieEncoder to remove a Java 1.6 deprecated method
	Updated OvalPortrayal2D to have border paint options just like RectanglePortrayal2D
	Likewise for ShapePortrayal2D.  Also added some stroke functionality.
	getLocation(Object,DrawInfo2D) changed to getPositionInFieldPortrayal(...) in
		Continuous2D, SparseGrid2D, HexaSparseGrid2D, and ObjectGrid2D.  Sorry,
		it was a bad name and needed to be renamed.  This method returns the
		location on-screen of an object given the field portrayal's drawinfo2d.
	Added getLocation(DrawInfo2D) to Continuous2D, SparseGrid2D, and HexaSparseGrid2D.
		This method returns the location in the field of the point defined by
		the clip origin in the given DrawInfo2D.
	Added three methods called getDrawInfo2D to Display2D.  These methods
		construct a DrawInfo2D given a portrayal and a clip region or
		hit point.  These methods are suitable for passing into getLocation(...)
	Changed Display2D.performSelection(Rectangle2D.Double, GUIState) to just
		Display2D.performSelection(Rectangle2D.Double) -- the GUIState was vestigial --
		and also added two new performSelection(...) methods as well to make it easier
		for the common man to select an object.
	Added Stable[Int|Double] classes in addition to StableLocation and Stable[Int|Double]2D.
		The latter classes originally enabled us to modify the location of continuous
		and sparse grid objects in 2D space from their inspectors.  The 3D classes
		now do the same thing for the 3D inspectors.
	Added selectable LabeledPortryal2D to MAVDemo as an example.
	Added selectable CircledPortrayal2D to NetworkTest as an example.
	Added dragging objects to NetworkTest and to HeatBugs as examples.
	Added HowTos on selecting and on dragging.
	Cleanups to NetworkTest
	Removed FieldPortrayal2D.getSelectedObjects, was vestigial
	SimplePortrayal3D by default now has setSelected return true
	Modifications to SelectionBehavior -- it's now a subclass of MouseBehavior rather than
		PickMouseBehavior.  This allows us to respond to MouseClicked rather than
		MousePressed (ugh).  And it's a little simpler to grok.  Anyway, now we
		can properly distinguish selection from dragging (for rotating the image).
	Added code to Display3D to handle selection.
	Bug fix in Display3D: we weren't deleting our SelectionBehaviors -- they were staying
		attached to the Canvas3D and piling up.  Minor leak.
	Changes to LabelledPortrayal3D and CircledPortrayal3D, which weren't handling
		display-on-selection properly (because selection wasn't working in 3D until
		now).  Now they both maintain internal HashMaps of selected objects because
		they can't query the Display3D to determine selection.  Furthermore, 
		in 3D, setSelected isn't called immediately prior to drawing the object in
		question because "drawing" isn't really a concept.  Instead you have to
		maintain a belief about whether or not you've been selected.
	setSelected(...) methods have been promoted from FieldPortrayal2D to FieldPortrayal
	Updates to Properties and Inspector objects to enable dynamic properties for 
		scheme code
	Bugfix in ShapePortrayal2D: sometimes drawing gray rather than the desired color.
	Added Continuous[2|3]D.getObjectsExactlyWithinDistance(...) which does the dirty
		work of extracting precisely the objects within a given distance from
		the continuous field.  The radial distance option has been bugfixed and
		is known to work well.  The square distance option hasn't been tested
		much.
	Modified Flockers to use the new getObjectsExactlyWithinDistance to simplfy
		things a little.  The result will be different because the order of the
		neighbors processed will be different, and this effects the numerical
		rounding in the doubles.  I've verified that if the order were the same,
		the results are identical.  Also fixed a few minor bugs in Flockers.
	Bug fixes in Tutorial 5 documentation.  Thanks to Mark Coletti <mcoletti@gmail.com>
	Updated Tutorial5 to use the new distance function
	Added precise drawing capabilities to OvalPortrayal2D and RectanglePortrayal2D
		and their subclasses.  If the 'precise' flag is turned on in the DrawInfo2D,
		these classes will draw using real-valued arithmetic rather than java.awt's
		integer methods.  Basically this looks better when doing screenshots to
		PDF.
	Tweaks to LabelledPortrayal2D.  Instead of "or" and "dr" we now have the better
		named "scale" and "offset".  We've also added some new constructors.
		"offset" is now a double, though it presently really makes little
		difference because we use drawString which requires ints anyway.  But
		if we make LabelledPortrayal able to handle precise drawing, it'll be
		easier to do it that way.
	Significant change to CircledPortrayal2D: "or" and "dr" have changed to "scale"
		and "offset", and "scale" is now twice what it used to be.  This will
		require you to double your values that you pass in for that.  This change
		makes the class consistent with CircledPortrayal3D and enables us to easily
		arrange it to be a subclass of OvalPortrayal2D; thus it inherits the new
		precise drawing features of that superclass.
	Modifications to ShapePortrayal2D.  It now handles precise drawing just like
		OvalPortrayal2D etc.  It also allows you to provide double-valued polygons
		in the form of arrays of x/y coordinates, as well as Shapes.
	Changes to HexagonalPortrayal2D.  This class is now a subclass of
		ShapePortrayal2D and so inherits its precise drawing.  We've also changed
		the constructor features of this class -- no longer can you "also" draw
		the frame in addition to the shape.  It's either stroke the frame or
		fill the object, you pick, just like OvalPortrayal2D and RectanglePortrayal2D
		etc.
	Added precise drawing to ImagePortrayal2D
	Bugfix in GenericEdgePortrayal3D when the edge should end up parallel to O_y.
		Thanks to Nicolas Payette (nicolaspayette@gmail.com).
	Bugfix to shuffling algorithm used in MASON. We stopped one element too early,
        so for small arrays the shuffling is non-uniform (and for size-two arrays
        there was no shuffling at all).  For shuffling large numbers of items,
        the effect was minimal.  This affects Bag.shuffle(), IntBag.shuffle(),
        DoubleBag.shuffle(), Schedule, and RandomSequence.
	Bugfix in constructor SpatialNetwork3D(final SparseGrid3D grid, final Network network)
	Added data cullig functionality to time series charts, both programmatically and
		from the GUI. Affected classes:
			TimeSeriesChartingPropertyInspector
			TimeSeriesChartingGenerator, and
			ChartGenerator (minor reordering of properties).
	The data culling code resides in sim.util.media.chart; 	the original location 
		(sim.util.datacull) was deleted.			
	ChartGenerator offers getters/setters for using log scale on either axis.
	Modified TimeSeriesChartGenerator.addSeries to return the series attributes rather than
		the index.  This makes it consistent with HistogramGenerator and more useful
		as well.
	Bumped seriesAttributes up to ChartingPropertyInspector, added getSeriesAttributes().
	Slight tweaks to [Mutable]Double[2|3]D to do slightly faster hashcode generation
	Tweak to Network documentation.  Thanks to Paul Wiegand (wiegand@ist.ucf.edu)
	ChartingPropertyInspector offers "public getSeriesAttributes()"
		to return the SeriesAttributes used in the ChartGenerator for the series 
		defined by that inspector; now you can programmatically set the number of 
		bins in a HistogramChartingPropertyInspector (after you cast it to 
		HistogramSeriesAttributes, of course).
	Bugfix in TimeSeriesAttributes.setStrokeColor(Color): the ColorWell would not update
		its color, just the series itself
	Documentation updates to AbstractGrid2D
	Cleanups to Edge and Network
	Modifications to how DisclosurePanel works with regard to locations in inspectors.
		Ideally we'd like inspectors to always track objects rather than fixate on
		locations.  The problem is that the locations of ObjectGrid2D objects 
		can't be looked up -- you have to scan through the entire grid to find them.
		So if an inspected object in an ObjectGrid2D wanders off, it's quite
		expensive to update the location of the object.  We've changed it as
		follows: we still track the object rather than fixate on a location.  When
		an object wanders, we first try to see if it's somewhere nearby (right now
		within a 7x7 toroidal square of where it used to be).  If it's there, we
		update the location.  Otherwise we set the location to "Location Unknown".
		To handle this, we've updated FieldPortrayal2D to properly update the 
		DisclosurePanel's internal labelled list, and have also changed some
		workings of the getWrapper() function in ObjectGridPortrayal2D.  Also
		updated ObjectGridPortrayal3D similarly, but haven't tested it.  Should
		automagically handle Fast... and Hexa... as well.
	Cleanups to ContinuousPortrayal2D
	Simplification of DrawPolicy's sole method.  This will change how people handle
		draw policies, so watch out for this one.
	HexaObjectGrid and HexaSparseGrid both updated to eliminate certain array manipulation
		code which wasn't used later.
	Cleanups to ObjectGridPortrayal2D
	Added precise drawing to SimpleEdgePortrayal2D
	Made HexagonalPortrayal2D consistent in constructors with other similar portrayals
	Minor hash improvements to [Mutable]Double[2|3]D
	Bug fix in StableDouble3D: it wasn't copying z properly.
	Edge now indicates its info in its toString() method.
	New method called getTitle() added to Inspector, intended to be overridden by inspectors
		which are in free-floating windows.  makeFrame() is reduced to just Inspector.
		This is all intended to make most inspectors properly display their titles
		when free-floating.
	Cleared Vector3d out of Agent.java in crowd3d; using Mutable3D instead
	Major modifications to Shape3D/Sphere/Cone/CylinderPortrayal3D.  We've moved them
		all under a new superclass called PrimitivePortrayal3D and have completely
		cleaned them out and made them consistent.  A new facility has been created
		with a lot of helpful methods to make it easy to transform (rotate, scale)
		them and change their appearance dynamically.  Thanks to Joerg Hoehne
		(hoehne@gmail.com) for the nudging.  Further modification of other classes
		will follow (like CubePortrayal3D and the various edge classes).
	Added a brand new BoxPortrayal3D (based on java3d's Box), extending PrimitivePortrayal3D.
	Balls3D's BallPortrayal class has been radically simplified and can do cool things
		now to show off the modifications in the various shapes above.
	Updated Tutorial5 and balls3d to both force collision checks when the balls are
		being created so the initial screenshot is prettier (has proper colors in it).
	Changed calls to cloneNode() into calls to cloneTree() in certain 3D portrayals;
		cloneNode() is supposedly pseudoprivate.
	Slightly revised setSelected() procedure for 3D objects.  Still suboptimal though.
		See documentation on the method in SimplePortrayal3D.
	Added a HowTo
	Bug fix to ShapePortrayal3D: added an appearance now
	Bug fix to CubePortrayal3D on pickability. 
		(although we might soon replace the class with BoxPortrayal3D).
	GenericEdgePortrayal3D lets you change the appearace and turn picking on/off. 
		-(i.e. some of the functionality of PrimitivePortrayal3D is offered here, too).
		-fixed previous bug in picking edge-portrayals extending GenericEdgePortrayal3D.
		-The classes extended GenericEdgePortrayal3D were refactored.
		-For using non-Primitive edge portrayal constructs, see ArrowEdgePortrayal3D.
	Updated MASON to compile with java 1.4
	Moved ValuePortrayal3D under ShapePortrayal3D
	Removed vestigial 'orient' variable from TransformedPortrayal2D
	added new Constructor and a missing copy of 'precise' variable in DrawInfo2D
	Bug fix in FieldPortrayal2D: getLocation -> getPositionInFieldPortrayal
	2D tooltips now only list objects whose status (name) is non-null
	Made changes to Arrow and ArrowEdgePortrayal3D: the default appearance in Arrow is 
		now lit grey.
	Increased the size of the default font in SimpleEdgePortrayal3D: from 24 to 60.
		-this change was motivated by the labels in Balls3DWithUI being way to small
		-this change was tested on mac-os and windows (/w java3D v 1.5)
		-this change affects GenericEdgePortrayal3D and its subclasses!
	GenericEdgePortrayal3D: minor housekeeping item, unused object commented out.
	Reindented	
	Moved ValueGridCellInfo into the quad package
	Added READMEs
	Made various edgePortrayal3Ds thinner by default: Cone, Cylinder and Arrow.
	Arrow: arrow head is wider, and, for short arrows it's also shorter.

Version 15
	Added some more READMES
	Added precision option (finally) to writing PDFs out.  Will probably break things!
	Made FastValuePortrayal2D precise when writing PDFs
	Heavily revised foraging ants example (antsforage).  The new version jettisons
		our old experimental version and replaces it with a version similar to the
		ones in our papers.  It's much simpler, smaller, far more elegant, and
		works better too.  Also elimiantes the stupid toroidal bug.
	Added a filtering function to SimpleColorMap.  This makes it a little slower but
		we think it's worth it.  See the new AntsForageWithUI.java file for an
		example of how to use it.
	Bug fix in SimpleEdgePortrayal2D: setScaling and getScaling were setting the wrong
		values.
	EdgeDrawInfo2D now has a few more constructors
	FieldPortrayal2D.getLocation() has been renamed to FieldPortrayal2D.getClipLocation()
		to avoid confusion.
	We've added and renamed a lot of methods in FieldPortrayal2D, resulting in the methods
		getObjectLocation, getLocationPosition, getObjectPosition, and a new method
		called getRelativeObjectPosition.  This makes the 2D portrayal nonsense a
		little more consistent and adds some functionality to make it easier to 
	Bug fix in Console: if you automatically pause after a certain time, then the Console
		wants to continue pausing, which can be irritating.
	Added size() method to SparseField
	Made sure that when a ChartingPropertyInspector's window is closed the underlying
		inspector is stop()ped.
	Stomped a bug in Console.java in which inspectors that had been detatched would
		stop updating themselves when you called forth a new list of inspectors.
		This was because we weren't deleting the inspectorStoppables code properly.
	Stoppables are no longer stored as weak references in the WeakHashMap in Console.
	Bug Fixes in heatbugs documentation
	Added Display2D.removeListeners()
	Bug fix in documentation: howto.html's description of how to hide the console
	Removed Schedule.setShuffling and Schedule.isShuffling.  These methods were intended
		to allow you to turn off the automatic shuffling procedure of the Schedule,
		notionally to allow Steppables to be stepped in the order in which they
		were submitted to the Schedule.  But that doesn't happen because a binary
		heap isn't stable and Schedule is based on binary heaps.  To make sure people
		don't produce results accidentally with that expectation, we've entirely
		removed the methods rather than deprecate them or create warnings.
	Changed GUIState.addImmediately to GUIState.addImmediatelyBefore and 
		GUIState.addImmediatelyAfter, deprecating the original.
	Added GUIState.createController(), which encapsulates the process of making a
		controller (typically a console) and making it visible and ready for the
		user.  This simplifies the code used in main() of GUIState subclasses
		and also allows non-Console applications (perhaps SimpleController ones)
		to be set up via the Console's New Simulation menu.  Generally speaking this
		change is backward-compatible -- if you want to use the old way it should
		work without any issues.
	Modified all standard demo applications and tutorials to use createController(), and
		modified Console and SimApplet to call createController() instead.
	Added Utilities.iFloor, iCeil, and iRound.  Faster than Math.floor, ceil, and round,
		but I don't trust them yet so we don't use them in any core code.  Cave Emptor.
	All generated threads set names for themselves now so you can see them in jvisualvm
	Added SimpleController, which for some reason I cannot fathom was not in the previous
		distro.
	Added FacetedPortrayal
	Console.doQuit is now static, and Controllers of all types are allowed in the
		allConsoles object, now public, and now renamed allControllers
	SimpleController properly registers itself with Console in the allControllers list
		and quits when doClose is called
	Schedule now checks for incorrect intervals in scheduleRepeating
	Added Schedule.clear()
	Addition to DrawInfo2D which now includes the location of the object, in case
		SimplePortrayal2Ds need this information in order to draw the object in
		context properly.  The particular class used to describe the location differs
		from FieldPortrayal to FieldPortrayal: in NetworkPortrayal2D it's the Edge,
		in ContinuousPortrayal2D it's a Double2D, in SparsePortrayal2D and
		HexaSparsePortrayal2D it's an Int2D, and all other relevant Field Portrayals
		use a MutableInt2D.
	Added warning in the movie maker about JMF's writing bad format string info out.
	Added manhattan distance to [Mutable]Double[2|3]D
	setToMinus, negate, and zero in MutableDouble[2|3]D now all return this
	Added various methods to Double2D, some borrowed from MutableDouble2D, others
		borrowed from physics.util.Double2D
	Added the ability for Display3D to select only one element or to select ALL of them,
		and similarly for inspection.
	Added Network.nodeExists(...)
	Added new demo, Celegans
	Modified SparseFieldPortrayal3D's method for culling portrayals for objects no longer
		in the field.  The existing method had bugs which were hard to pin down; we
		were trying to be clever in computational complexity, but looking at the
		Java3D source code shows that no matter how clever we'd be, and how absolutely
		obvious the Right Way to do things was, Sun's code monkeys managed not to do
		it.  They've made removing children from Groups O(n) regardless, even if you do
		removeAllChildren (which they coded -- and I kid you not -- as repeated
		removeChild() operations, totalling O(n^2)).  It's now quite clear why Sun
		wound up getting sold to Oracle.  Anyway, due to raw incompetence on part of
		these cretins, we have to do O(n) removals and so we might as well remove by
		object rather than by index, which was our Slow and Non-Clever but Safe way
		in the first place.  Gah.
	Added SparseField2D
	Modified SpatialNetwork2D to use SparseField2D
	Updated Schedule documentation regarding intervals in repeated schedules.  Thanks to
		Paul Wiegand <wiegand@ist.ucf.edu>
	Tweaks to the Console delay slider to make it more sensitive
	Added PacMan
	Documentation fixes to CircledPortrayal2D
	Added an option to Console.java to allow confirmation for stopping
	Fixed minor bug in pressStop(): if you pressed stop while stopped, and repeat
		when stopped was turned on, we'd start playing immediately.
	Added a check that button 1 was the one being clicked for selecting and inspecting
		in Display2D.  Makes it easier to use other buttons.
	Modified when Display.sceneGraphCreated() is called: it's now called prior to
		the root being added to the universe.  This is necessary because Java3D
		won't allow additions to the scene graph after it's been hooked to the
		universe even if the renderer hasn't started up yet.
	Major modification to ContinuousPortrayal2D, SparsePortrayal2D, HexaSparsePortrayal2D,
		and NetworkPortrayal2D -- all portrayals which can portray elements at negative
		locations.  In many places we were pulling real values down to integers for 
		purposes of discretization.  When we discretized to negative values, this 
		would fail.  So for those Field Portrayals which can deal with negative 
		field locations, we've changed discretization by (int)(... to 
		(int)Math.floor(... to guarantee that the movement is always downwards.
		This enables (among other things) objects to be selected and inspected when
		they're located in certain negative regions.  Irritating that this bug 
		wasn't caught earlier...
	Fix to PacMan: ghosts who were frightened precisely when the game changed to a new
		screen stayed frightened (and in their box) indefinitely.  A rare occurrance
		but a weird one.
	Added toroidal displaying to Continuous2D.  It could in theory be added to
		SparsePortrayal2D as well but is significantly more complex due to (1) the
		fact that SparsePortrayal2D draws its objects by looking up filled locations
		rather than looking up each object in turn and (2) the fact that
		SparsePortrayal2D allows for expicit drawing orders.  Maybe we'll add it later.
	Added setIncrementSeedOnPlay() and getIncrementSeedOnPlay() to Console and to
		SimpleController.  SimpleController in particular now has this value by
		default set to TRUE (Console always had it TRUE by default).
	Updated copyright information
	Added sim.display.RateAdjuster
	Removed sim.app.pacman.RateAdjuster (and changed how it works)
	Added Asteroids
	Added Asteroids to Makefile (oops)
	Tweaks to SimpleController so it doesn't go into infinite recursive loops on quitting
	Fix to ParallelSequence.  When we added thread naming, we accidentally included the
		current thread as an instance variable, as a bit of efficiency.  But threads
		aren't serializable, so it broke checkpointing.
	Fix to Display3D's new ability to select one or many elements with its picker: by default
		we were selecting only ONE, which is wrong.
	Fixes to Asteroids's and PacMan's handling of window focus events
	Scaling when the simulation isn't running no longer throws an exception.		
	Added ImageIcon loading to ImagePortrayal2D
	Added ImageIcon and Resource loading to ImagePortrayal3D
	Updated LabelledPortrayal3D to use 1/16 scaling since we're now using Text3D
	Added more options for stepping the Display2D and Display3D drawing.  One odd bug in
		the Display3D drawing: if a component has focus and causes the I-bar to blink,
		this will cause the Display3D to redraw whenever the blink occurs regardless
		of how often the user requested the redraw to happen. It's just a stupidity
		in Display3D but is fairly harmless.
	Updated howto.html with better instructions for creating a background image.  Thanks to
		Matthew Hendrey <mhendrey@gmu.edu>
	Major change to how setSelected works in 2D.  To tell a SimplePortrayal to draw itself
		in selected form, FieldPortrayals no longer call setSelected(true), then draw,
		then call setSelected(false).  Instead, they set a flag in DrawInfo2D called
		'selected' and draw with that DrawInfo2D.  Various SimplePortrayals which use
		the setSelected mechanism have been changed accordingly.  Note that when an
		object is first selected (added to the selected elements list) or when it is
		deselected (removed from the selected elements list) setSelected(...) is stil
		called.  This makes much more sense anyway.
	Deleted the vestigial "move" method in FieldPortrayal2D and SimplePortrayal2D.
	Fixed an off-by-2 bug in getClipLocation for hex grids
	Added a new optional method to SimplePortryal2D for handling arbitrary mouse events,
		called handleMouseEvent.  Most mouse events (except scroll wheel events due
		to a misfeature in Java) can be handled.  Display2D will first send mouse
		events to selected objects, then attempt to send them to objects hit by the
		event coordinate.  If an object returns 'true' from handleMouseEvent the
		event will not be propagated to any other objects, so basically it's
		first come first serve.
	Added two new wrapper portrayal classes which use the handleMouseEvent procedure:
		MovablePortrayal2D and AdjustingPortrayal2D.  The two new wrapper portrayal 
		classes can move objects in the field and can adjust their orientation and "scale".
		Also added three new interfaces to allow these portrayals to communicate with
		the underlying objects.  First, Orientable2D extends Oriented2D to allow an
		object to have its orientation changed.  Second, Scalable2D allows an object
		to have its "scale" changed.  Third, Fixed2D allows an object to determine if
		it can, at this time, be moved or if it wishes to remain fixed in space (or
		move itself).
	Fixed race condition triggered by the new mouse event functions.  When you launch
		MASON using java sim.display.Console for the very first time, the doNew()
		method to set up the first simulation is actually done from the main thread
		rather than the Swing event thread.  But at the same time that field portrayals
		are being set up by methods called by doNew(), mouse events can be
		coming into the Display, triggering calls to objectsHitBy(...), which looks
		up and scans through the current field portrayals.   Thus the race condition.
		This is fixed by having doNew() check to see if it's running in the Swing event
		thread, and if so, it just does its normal thing, but if not, it calls its
		methods inside an invokeAndWait. 
	Added rotation to Flockers
	mason.bat no longer includes the -server directive, which breaks Windows 7
	Deprecated getClipLocation
	Made ParallelSequence and AsynchronousSteppable's threads daemon
	Added the cleanup() method to ParallelSequence and added documentation explaining why
		and how you should use this method. 
	Added the destroysThreads flags to ParallelSequence and added documentation explaining
		why and how you should use this method.
	Tweaked HeatBugs and HexaBugs so that they call cleanup() on their ParallelSequences
	Added the Manipulating2D interface to avoid passing Display2D directly to
		SimplePortrayal2D subclasses.
	Added preferences to SimplePortrayal2D
	Console and SimpleController possibly call init(...) inside an invokeAndWait to 
		guarantee it happens on the Swing Event Thread.
	Additions to ChartGenerator.  Thanks to Paul Smaldino <paul.smaldino@gmail.com> and
		Joey Harrison <jharri@gmu.edu>
	Set up make dist to automatically remove sim/util/datacul
	Added the sim/util/distribution package
	Added Prefs class -- oops
	Added a 'seed' variable to SimState -- basically retaining the seed used to construct
		the random number generator.  This is only used for the GUI to know what the
		seed was so it can display it in the Console.  Also modified the Console so
		that startSimulation() doesn't replace the generator.  The generator is only
		replaced if the user changes the number if the field or if the stop() button
		is pressed thus incrementing the field.  This allows easy visualization of
		a simulation with a specific predefined random number generator seed.  All you
		have to do is change the constructor of your GUIState subclass so that it
		creates the model with a fixed seed and the visualization will see it also.
		For example, public FlockersWithUI() { super(new Flockers(15)); }
	Modified the seed field in the Console to accept a long, but warn the user that
		a long seed was provided.
	Bug fixes to Bag.toArray(Object[]), which was returning null incorrectly.  Thanks to
		Matt Miller <matt.miller@gmail.com>
	Made all distribution classes serializable and removed their clone methods, which
		were not safe.  Who made these clonable in the first place?  
	Added sim/util/datacull/README
	Set the binary flag on certain binary files in the CVS repository, oops
	exceptions thrown in init() now have their stack traces printed out
	Fixed bug in FacetedPortrayal, wasn't handling hitObjects and setSelected right
	Added no-backdrop option to saving to PDF
	Added initial ParallelSequence revision which allows arbitrary numbers of threads
		divvying up all the steppables
	Migrated to SVN on Google Code
	Deleted datacull directory
	Fixed bug in copy constructor for Bag, IntBag, and DoubleBag.  Thanks to
		Chris Hollander <chris.hollander@gmail.com>
	When minimizing a window in OS X, Display2D still will write to movies.  Note that
		due to bugs in Java3D we're having difficulty making the same guarantee
		of Display3D at this time.
	Added Schedule.Key.hashCode()
	Minor tweaks to RateAdjuster

Version 16
	Fixed a minor bug in PropertyList: when you update the text field that accompanies
		a slider, the slider doesn't update.  This is because of an exception
		thrown which is lost, and is in turn due to an unusual bug in Java's
		anonymous class instance variable declaration (see SimpleInspector code).
	Documentation bug in Grid2D.java which had the X and Y coordinates of triangular
		grids mixed up.
	Fixed a bug in IntGrid3D, which didn't accept null IntBags for its neighborhood
		lookup.
	Efficiency improvements to all array-style grid classes' neighborhood distance
		lookups: the returned bags are guaranteed are resized first before being
		returned.  Not the case for SparseGrid[2|3]D, which can have arbitrary
		numbers of neighbors.
	Added toArray() to all array-style grid classes, and elements() to ObjectArray[2|3]D.
	Modified SparseField.iterator() and SparseField.locationBagIterator() to fail
		on remove().
	[Int|Double|]Bag.add() and .push() code simplified, still under 35 bytes
	Added constructors to SparseGrid[2|3]D and Continuous[2|3]D, and an abstract
		constructor to SparseField.
	Tweaks to SparseGridPortrayal2D, HexaSparseGridPortrayal2D, and ContinuousPortrayal2D
		to double-check that the Oriented2D and Scalable2D interfaces are being
		used.
	Update to documentation on Fixed2D.
	getClipLocation deleted from all FieldPortrayals.  This eliminates certain
		deprecation warnings.
	Added addAll(...array...) to Bag, IntBag, and DoubleBag, as well as a constructor
		of the same form.
	Added Bag.sort().  Thanks to Mike Makowsky <mmakowsky@towson.edu>
	Deprecated Network.cloneGraph().  Eventually it will be removed.
	Deprected SimState constructors
	Major modifications to Continuous2D, Continuous3D, and SparseField to get all the
		SparseField methods properly set up for continuous values.  Probably broke
		something!  Though initial tests look good.
	Added fieldPortrayal to DrawInfo2D
	Modification to how selection is done in preparation for a fix for TrailedPortrayal2D.
		When an object is selected, we deselect all the existing selected wrappers,
		then call setSelected(true) on the object[s].  ContinuousPortrayal2D,
		SparseGridPortrayal2D, and ObjectGridPortrayal2D then have been modified so
		that they always pass through setSelected(...) and only then determine if
		the objects should be put in the "selected wrappers", so its DrawInfo2D
		has the selected flag set.  setSelected(false) is also called.
	Fix to TrailedPortrayal2D in conjunction with MovablePortrayal2D.  TrailedPortrayal2D
		has to know it's been selected, but it's wrapped around a DIFFERENT field
		portrayal than the object it's trailing.  This is a problem because if it's
		not selected, it won't hilight the trail.  When would this happen?  If
		MovablePortrayal2D has moved an object, it just calls select on that object
		and not on the underlying trail.  The fix is a hack: we make sure that
		TrailedPortrayal2D wraps both the object in the trail and the object in
		the main field portrayal (see Flockers for an example), so its setSelected
		method is called for sure.  Then TrailedPortrayal maintains an internal
		boolean variable which checks against this, and also double-checks that the
		underlying field portrayal is the one it's supposed to draw in.
	Double2D, Double3D, MutableDouble2D, and MutableDouble3D modified so that, for 
		purposes of equals() and hashCode(), 0.0 == -0.0, so elements get hashed to
		the same cell.
	Deleted private function SimState.indexAfterArgumentForKey
	SimState.nameThread() no longer static.
	Added SimState.setSeed() and SimState.setJob()
	SimState.setRandom() deprecated.  Use setSeed() instead.
	Deprecated schedule.time().  Use getTime() instead.
	Made Schedule.scheduleOnce(Key, Steppable) protected
	RandomSequence now synchronizes on the *Schedule*, not the random number generator.
	WeakStep no longer weakly holds its optional Stoppable
	AsynchronousSteppable.stopper() deprecated
	Documentation template examples in AsynchronousSteppable were wrong and have been
		revised (and a new one has been added).
	AsynchronousSteppable is now officially Stoppable
	ParallelSequence.cleaner() added
	DoubleDimension2D eliminated
	Modification to Heap's constructor: numElem no longer used.
	Removed Heap.extractMin(Comparable, Bag), which is confusing and no longer being used.
	Bugfix to FastValueGridPortrayal2D, which was not handling zommed-out grids properly
		when writing to high-quality (like PDF).
	Bugfix to FastHexaValueGridPortrayal2D, which was not setting the color propertly when
		writing to high-quality (like PDF).
	iFloor, iRound, iCeil made private in Utilities.java: they're probably not wise to use.
	Moved Utilities and WordWrap to sim.util.gui
	Added [Mutable]Int2D.manhattanDistance(java.awt.Point)
	Made MutableDouble2D cloneable
	Added Double2D.angle()
	Added a new Bag constructor
	Added a new Properties default factory method.  SimpleInspector now uses it.
	SimpleProperties default constructor modified so that getClass() is not included, to
		be consistent with the default Properties factory method.
	CausedRuntimeException officially deprecated
	Made GUIState(SimState) constructor public, though it matters little.
	Made GUIState.reset(...) private and deprecated.
	Removed ThreadPriority slider in Console.
	AsynchronousSteppable and ParallelSequence modified so that joins will work regardless
		of interrupts. Previously they threw errors, which is not consistent.
	Console methods no longer call doChangeCode, which is deprecated.  Methods such as 
		Console.get/SetPlaySleep(...) now lock on the playThreadLock
	Random number seeding in the Console is no longer immediately effective, but now
		always occurs immediately before playing.
	Loading from the Console no longer sets the random field to "UNKNOWN", but to the
		actual seed
	Made related random number seeding changes in SimpleController
	In Console and Controller, incrementSeedOnPlay renamed to incrementSeedOnStop
	Tweaked the HowTos.  
	Made Console.doAbout() protected
	Added Console.getRequiresConfirmationToStop()
	Fixed minor bug where a spurious exception is thrown if you cancel creating a chart.
		Thanks to Joey Harrison <jharri1@gmu.edu>
	Bug fix to ParallelSequence constructor
	Added disclosure triangles to ChartGenerator to reduce the clutter
	Added movie generation to ChartGenerator
	Fixed bug in handleMouseEvent calls in AdjustablePortrayal2D and MovablePortrayal2D:
		wasn't locking on model (creating race conditions).
	ValueGrid2DPortrayal3D should now be able to handle ObjectGrid2D as well (using
		the Valuable interface).
	New look for Display2D and Display3D: step field compressed into a single icon, which
		makes the window work better with small sizes.
	Updates to ChartGenerator to allow compatibility with newer versions of JFreeChart
		(which will be distributed with MASON from here on out).  Also added the ability
		to turn on/off grid lines in ChartGenerator.
	Fixed the 'ONLY' mechanism in simulation.classes
	Added methods to Console to enable turning on or off the New Simulation... menu.
	Major modifications to the Charting facility to clean it up and make it easier to add
		new charts.  This will modify the API a bit -- we've also modified the howto.html
		file to reflect the (small) changes that need to be made if you create a chart
		programmatically.
	Added Scatter Plots
	Modified Flockers to include two model elements which show off Scatter Plots
	Added the ability to draw a thin frame around Continuous2D.
	Bag, DoubleBag, and IntBag can be initialized with null passed in.
	Added DenseGrid2D, DenseGrid2DPortrayal, and HexaDenseGrid2DPortrayal
	Reindented
	BugFix to [Int|Double|]Bag.addAll method -- inserting in the middle of the Bag wasn't
		shifting elements over properly.  Thanks to Guoqiang Zhang <zgqoop_cn@hotmail.com>
	Made Edge Comparable
	Changed the slider so that it prints only a few decimal places when modifying a 
		double. The number of decimal places is chosen to be the minimum necessary 
		to show a change of size epsilon, which is the smallest increment the user 
		can make by dragging the slider. Epsilon is determined by the range of the 
		slider and its width, in pixels.
	Modified EdgePortrayal2D to allow the width of the triangle or line to change depending
		on the value of the Edge.
	Documentation fixes to sim.util.Distribution [CERN's not very careful].  Thanks to 
		Ben Stabile <bennett.stabile@GMAIL.COM>
	Added sealing to the Schedule, deprecated pushToAfterSimulation, and made SimState.kill()
		seal the schedule rather than push it.  This allows remaining non-cleared events
		after kill() to run in the current timestep rather than in AFTER_SIMULATION.
	Modified the scheduling functions so that they return FALSE when the schedule cannot
		accept any more events -- it's at AFTER_SIMULATION or is sealed.  Other invalid
		situations (invalid times, invalid Steppables) still throw an exception.
	Modified Console so that it updates inspectors one last time prior to stopping them.
	Modified ChartGenerator so that the DataSetChangeEvent is fired prior to writing to
		the movie (so any additional modifications to the chart are reflected in that
		movie frame).
	Modifications to ChartGenerator to make it easier to create charts as displays which can
		be used to generate movies.  Update the howto.html documentation to reflect this.
	Revised the SimState constructors -- making deprecated and private constructors protected.
		This makes it easier to use MASON with other toolkits (such as ECJ) which are
		in control of the random number generator.
	Deleted the GUIState.guiObjects variable, created a new variable called 'storage', which
		stores global elements by key.
	Charting inspectors now set their chart titles and axis labels to more useful things
	It's a known bug in JFreeChart: if you have multiple series on a chart, and they're named
		the same name, then only the first one controls the auto range.  :-(
	Further tweaked Console's update of inspectors when stopping them
	Modified SimpleController to update inspectors when stopping them just like Console
	Modified howto.html to show how to propery close and write out movies when finishing
		or quitting if your movie is from a display.
	Made network.directed non-final and private.  Created a new method called isDirected()
		to return direction.   Added network.reset(...) to reset direction. 
	Bug fix to NetworkPortrayal2D, which was drawing and inspecting edges twice if undirected.
		The error shouldn't occur in NetworkPortrayal3D which already does edge hashing
		and so shouldn't have duplicates.
	Edges are explicitly stated in documentation to hash by reference.
	Edges now print to strings differently based on whether they're owned, or directed,
		or undirected
	Added Edge.isDirected()
	Fixed bug in NetworkPortrayal2D() when using undirected edges -- not all edges would
		be displayed (was using edge.getTo() rather than edge.getOtherNode(...))
	Bug fixes to GUI description of updates in Display2D and Display3D
	Fixed deprecated warnings
	Deprecated Display2D's and Display3D's standard constructor -- you should use the new
		constructor now if you can.
	Modified all tutorials, documentation, and examples to use the new Display2D and Display3D
		constructors.
	Deprecated paintComponent(Graphics, buffer).  Eventually we'll delete this method and
		merge it in with paintComponent(Graphics).
	Deleted Display2D.getMaximumsize(), which (besides being misspelled) apparently isn't
		necessary.
	Moved createToolTipText from the InnerDisplay2D to the Display2D
	Deprecated InnerDisplay2D.removeListeners() and created an identical version in Display2D
	Fixed bug in preferences which wasn't setting the 'should repeat on stop' button.  Thanks
		to Kyle Feuz <kyle.feuz@aggiemail.usu.edu>
	Simplifications to Makefile
	Made ObjectGridPortrayal2D.searchForObject private
	Deleted the "beep" in ValueGridPortrayal2D
	Made the ColorMap in ValueGridPortrayal2D private
	Added getters and setters for DrawPolicy in Sparse and DenseGridPortrayal2D
	Deprecated certain constructors in Sparse and Dense 2D portrayals
	Made HEXAGONAL_RATIO private in hexagonal grid portrayals
	DenseGridPortrayal2D now has exactly the same LocationWrapper mechanism as
		ObjectGridPortrayal2D
	Added ContinuousPortrayal2D.getFrame()
	Added ValueGridPortrayal2D.setValueName(...)
	In Windows, FastValueGridPortrayal2D and FastHexaValueGridPortrayal2D now only buffer
		if the field is immutable.  For some reason they were considering whether it 
		was dirty as part of their calculus.
	Revised FieldPortrayal, FieldPortrayal[2|3]D, and various subclasses to deprecate the
		reset() method and create new setters and getters for the 'dirty flag'
		variable which are synchronized.  Made 'dirtyField' private to guarantee
		synchronization.  THIS WILL BREAK SOME PEOPLE'S CODE.
	Eliminated ValueGrid2DPortrayal3D's private Grid2D field variable.
	Deleted getWidth() and getHeight() from SpatialNetwork2D.  They've been long deprecated.
	Added setAuxiliaryField to SpatialNetwork2D and deprecated setAuxillaryField, due to
		misspelling.
	Wired up auxiliary fields for NetworkPortrayal2D, which for some reason weren't being
		used.
	Deprecated SpatialNetwork2D.getObjectLocation(...)
	Bug fix in EdgeDrawInfo2D(EdgeDrawInfo2D other), which wasn't copying the other second
		point properly.
	Updated StableLocation to no longer require update()
	Bug fix to StableInt3D and StableDouble3D, which were not updating the 'exists' flag.
	ShapePortrayal2D uses a BasicStroke if the stroke has not been set.
	ValuePortrayal2D no longer has a 'parent' -- various constructors and methods deprecated.
	Set the default setting of baseWidth in SimpleEdgePortrayal2D to 0.0. If you're drawing
		triangles, you need to explicitly set the width.  THIS WILL CONFUSE PEOPLE.
		But it's important.
	Added to SimpleProperties the ability to interpret String.toString(), 
		StringBuffer.toString(), Boolean.booleanValue(), Byte.longValue(), 
		Short.longValue(), Integer.longValue(), Long.longValue(), Double.doubleValue(),
		Float.doubleValue(), and any other Number.doubleValue() as read-only properties
		of the name "Value".  This is because these read-only classes (well, except for
		StringBuffer) don't have appropriate "get" methods.
	Eliminated "get()" and "is()" and "set()" as valid property names.
	Added missing setOnlyLabelWhenSelected() and getOnlyLabelWhenSelected() methods to
		LabelledPortrayal2D
	OR and DR in OrientedPortrayal2D renamed to SCALE and OFFSET, to be consistent with
		LabelledPortrayal2D and CircledPortrayal2D
	Added fill switch to OrientedPortrayal2D.  If filled, then the kite and compass are
		drawn UNDER the basic object.
	OrientedPortrayal2D.isLineShowing() and setLineShowing() deprecated and replaced with
		isOrientationShowing() and setOrientationShowing()
	OrientedPortrayal2D now can optionally turn off orientation depending on selection
	FacetedPortrayal2D can now have its child-selecting mechanism overridden
	Deprecated and renamed TrailedPortrayal2D.setGrowTrailOnlyWhenSelected() and
		TrailedPortrayal2D.getGrowTrailOnlyWhenSelected()
	Modifications to TrailedPortrayal2D to more properly draw trails under different
		circumstances.  Documentation is still wrong.
	Bug fix to NetworkPortrayal3D which was preventing the field from being displayed.
		This was due to refactoring of the 'field' variable.
	Major change to DrawInfo2D, EdgeDrawInfo2D, and TrailDrawInfo2D.  We add a new
		variable, 'gui', which points to the GUIState.  We also add new constructors
		which require passing in 'gui' and also the field portrayal.  Finally,
		old constructors which did not require this have been *deleted* because they
		are dangerous -- you have to be forced to upgrade to the new system.
	All FieldPortrayals implement the methods getScale, getPositionLocation, getObjectLocation,
		getLocationPosition, getObjectPosition, and setObjectLocation (as appropriate) 
		by synchronizing on the underlying field before querying or modifying the field.
	FieldPortrayal2D.getObjectLocation now requires a GUIState as an argument (so it can
		synchronize on it).
	FieldPortrayal.CustomInspector is no longer public
	Made Inspector.updateButtonPressed() final -- do not use it.  Just expect to have
		updateInspector() called instead.	
	Made TabbedInspector.updateDisplayedInspector private.
	Made ChartingPropertyInspector's various aggregation method and redraw constants
		protected (they were package-level).
	Made ChartingPropertyInspector.globalAttributes private and added getGlobalAttributes()
	Console now indicates where the first problematic class is on loading
	OrientedPortrayal2D now has precise drawing as an option
	Bug fixes to ChartingPropertyInspector and subclasses: no longer will *all* charts
		appear in the charts popup, but rather only those compatible with the 
		chart being generated.  Also if the user cancels, an error is no longer issued
		on the command line.
	OvalPortrayal2D and RectanglePortrayal2D are serializable, making some demos work
		properly serialized.
	Display3D.header is now formally a Box
	Display3D.skipFrame is now public
	Display3D.OptionPane3D's constructors and methods made private to be consistent with
		Display2D.OptionPane
	CapturingCanvas3D.setWritingParams(...) changed to startCapturing(...), and reduced by
		one parameter.  CapturingCanvas3D.stopMovie() renamed to stopCapturing().  And
		CapturingCanvas3D.getFrameAsImage() renamed to getLastImage()
	Display3D.movieMaker is now private
	Exposed a new Display3D instance variable called viewRoot, which allows the user to
		add scene material which stays constant in the scene despite the viewpoint
		changing.
	Display3D.createConsoleMenu is now private
	Display3D.rebuildSkipFrame is now private
	Display3D.rebuildRefreshPopup is now private
	Display3D.clearSelections added
	Fixed documentation errors in Display3D.getTransform and Display3D.setTransform
	Display3D.localWindowListener -> Display3D.LocalWindowListener
	Display3D.getFrame() made public
	Added Display3D.takeSnapshot(File file)
	Added Display3D.getSelectionBehavior(), and modified Balls3D to use it
	Deleted optional movement code in HeatBugs -- you should use MovablePortrayal2D
	Display3D examples had a vestigial element in setupPortrayals: a call to
		destroySceneGraph() which was unnecessary since createSceneGraph() would
		call it anyway (if needed).  We've deleted this call in all the examples
		and in the tutorials.
	Console.pressHide, pressHideAll, pressShow, and pressShowAll changed to
		hideSelectedFrames, hideAllFrames, showSelectedFrames, and
		showAllFrames.  Additionally, showAllFrames and hideAllFrames made
		public.  An additional new method, getAllFrames(), also made public.
		This last method also added to the Controller interface and is implemented
		by SimpleController as well.
	Tweaks to Inspector.createFrame() to make weak keys more likely to get GCed
	Added Controller.getAllInspectors() and implementations in Console and SimpleController
	ChartingPropertyInspectors now dispose their frames at the end of a simulation like
		other Inspectors.  If this proves irritating, just delete the
		ChartingPropertyInspector.disposeFrame() method and let us know and we may
		consider reversion.
	Removed nonsensical type check in SpatialNetwork2D.setAuxiliaryField(...)
	Added SparseField3D
	Added SparseGrid3D.getDimensions() and made SparseGrid3D a SparseField3D
	Added Continuous3D.getDimensions() and Continuous3D.getObjectLocationAsDouble3D(),
		and made Continuous3D a SparseField3D
	Major modifications to SpatialNetwork3D to work properly with SparseField3D instead
		of just with Continuous3D and SparseGrid3D.  SpatialNetwork3D also now
		works with SparseField2D as well.
	SpatialNetwork and SpatialNetwork3D instance variables now private
	FieldPortrayal3D.getDefaultTransform() made protected
	FieldPortrayal3D.defaultPortrayal is now private.  Subclasses wishing to modify this
		variable should instead override FieldPortrayal3D.getDefaultPortrayal()
	ValuePortrayal3D.Filter now has a toString() method which works just like
		ValuePortrayal2D.Portrayal
	Made QuadPortrayal.zScale and QuadPortrayal.colorDispenser private and created
		getters and setters for them.  Likewise for ValuePortrayal3D.map.
	Added ValueGrid2DPortrayal3D.[get|set]ValueName(...).  Made
		ValueGrid2DPortrayal3D.valueName private.  This required a small modification
		to HeatBugs.
	Added ValueGridPortrayal3D.[get|set]Map(...). Made ValueGridPortrayal3D.map private.
	Made both ValueGridPortrayal2D.valueName and ValueGridPortrayal3D.valueName private.
	Fixed bug in SparseGridPortrayal2D: selection information was not being passed on to
		simple portrayals.  Thanks to Martin Erdelen <martin.erdelen@kolombus.fi>
	Appropriate wrapper Simple Portrayals now pass mouse event information on to their
		children.
	ValueGridPortrayal3D.newValue revised to work in the same way as ValueGridPortrayal2D
		and ValueGrid2DPortrayal3D.
	Removed a spurious beep in ValueGridPortrayal3D
	Revisions to ValueGridPortrayal3D to refuse to allow changes in dimension to the
		field (because it doesn't use BranchGroups, argh, Java3D is irritating)
		and to allow scale changes to the individual blocks.
	Added ValueGrid2DPortrayal3D.getTransparency() and getImage().  Made the image and
		transparency variables private.  setTransparency() now checks for a valid
		transparency value.
	Restructuring of code to move polygon attributes in the ValueGrid2DPortrayal3D, 
		eliminating a confusing piece of code which was a possible facilitator of bugs.
	Modified ValueGrid2DPortrayal3D.newValue(...) to handle ObjectGrid2D
	Modified ValueGridCellInfo, removing the z option and removing doubleValue()
	Created new directory, sim/portrayal3d/simple/shapes/ for some OBJ files
	SimplePortrayal3D.setSelected() now frees its HashMap if it's empty
	Made PrimitivePortrayal3D.group protected
	PrimitivePortrayal3D.getAppearance returns a brand-new Appearance if the number of
		shapes is zero.
	Renamed Axes to AxesPortrayal3D
	BoxPortrayal3D is officially deleted
	Added an additional SpherePortrayal3D constructor
	Slight efficiency added to PrimitivePortrayal3D: if the scale is set to 1.0, no
		Transform3D is created.
	PrimitivePortrayal3D.setTransform(...) and setScale(...) now public
	Made various variables in CubePortrayal3D private
	Deleted two construcors in CubePortrayal3D
	LightPortrayal3D.light is private
	Major modifications to the ill-used SharedGroupPortrayal3D. It's now a wrapper
		portrayal for other SimplePortrayals which displays them repeatedly using
		a SharedGroup and Links.  This saves some memory but is not pickable.
	WireFrameBoxPortrayal3D.appearance is private
	TilePortrayal.tmpCoords and TilePortrayal.tmpColor are private	
	MeshPortrayal.tmpCoords and MeshPortrayal.tmpColor are private
	QuadPortrayals of various kinds have floats changed to doubles
	Various variables in Arrow made private and renamed
	Added Arrow.getArrowTail() and Arrow.getArrowHead()
	Changed a wide range of float arguments and variables to doubles in 3D to make it
		a little simpler for people to use with fewer errors (remembering to add
		'f' at the end).  This is a big change but it should be essentially
		upward-compatible.
	Arrow.createArrow(...) deleted
	Axes are defined in radius, not diameter
	Removed ValuePortrayal3D.ValueWrapper.  Instead, ValueGridPortrayal3D now has a
		method called getColorFor(wrapper).
	Made various variables in SimpleEdgePortrayal3D private
	Deleted SimpleEdgePortrayal3D.transformForOffset(double[])
	In SimpleEdgePortrayal3D, setting the label color to null turns off labels, and
		setting the label color to non-null turns on labels.
	LabelledPortrayal3D's malformed attempt to do ordered labels is officially removed.
	SimpleEdgePortrayal3D.setShowLabels() and getShowLabels() deprecated
	new CylinderEdgePortrayal3D(labelColor) now sets cylinders with the same size as
		new CylinderEdgePortrayal3D()
	For all SimpleEdgePortrayal3D and subclasses: if you pass in a null font, the
		default font (Sans Serif, Plain, 60pt) is assumed.
	All new set of constructors for all SimpleEdgePortrayal subclasses.  Multiple
		constructors deprecated.
	balls3d.Band is no longer a subclass of MutableDouble
	Modifications to tutorial5 and balls3d to make the Edges in the inspectors list
		more useful.  Also removed a vestigial decimalFormat from balls3d.Band
	Entirely eliminated SimpleEdgePortrayal3D.EdgeWrapper
	Made GenericEdgePortrayal3D.getTransform(...) private	
	GenericEdgePortrayal3D and PrimitiveEdgePortrayal3D folded into
		PrimitiveEdgePortrayal3D.  GenericEdgePortrayal3D is deleted.
	SharedGroupPortrayal3D renamed to SharedPortrayal3D to be consistent with the
		wrapper portrayal naming convention.
	LabelledPortrayal3D now uses Text2D again.
	Woims3D visualization look improved.
	Added GUIState.guirandom, a new random number generator just for the GUI and
		visualization.  Flockers modified to demonstrate how it works.
	Removed SimplePortrayal3D.setParentPortrayal() and SimplePortrayal3D.parentPortrayal.
		Added Portrayal3D.setCurrentDisplay(), Portrayal3D.getCurrentDisplay(),
		Portrayal3D.getCurrentGUIState(), SimplePortrayal3D.setCurrentFieldPortrayal(),
		and SimplePortrayal3D().getCurrentFieldPortrayal().  Modified the wrapper
		classes so that they call the appropriate methods on their children.
		Displays and Field Portrayals all call these methods as appropriate.  This
		approach solidifies the assumption that model objects oughtn't be their
		own Portrayal3Ds, though it's not forbidden (but serialization won't work).
		Modified Woims3D demo documentation to explain that it's an example of
		objects serving as their own Portrayal3Ds, but that it's not a good idea.
	All wrapper simple portrayals in 3D have their 'child' variable made private.
	LabelledPortrayal3D.updateSwitch() and CircledPortrayal3D.updateSwitch() made private.
	Bugs in LabelledPortrayal3D which were making the label too tiny
	LabelledPortayal3D now makes labels exactly the same size as SimpleEdgePortrayal3D.
	Modifications to LabelledPortrayal3D's constructors: scale no longer exists	
	GullCG made public
	Added missing copyright declarations
	Fixed bug in Rectangle2D where color wasn't set if precise was used.  Thanks to 
		Joerg Hoehne <hoehne@gmail.com>
	Moved reloading of precise rectangles and ovals to within the precise if-statement;
		a very minor efficiency improvement.
	PngEncoder renamed to PNGEncoder
	All variables in SimpleColorMap made private
	Changes changeColor(...) calls to setColor(...) in the various SeriesAttributes
	LabelledList.setBackground(...) removed.
	Added DisclosurePanel.setDisclosed(...) and isDisclosed()
	Multiple variables in NumberTextField made private.  This may break some people's code.
	NumberTextField.currentValue made protected  This may break some people's code.
	Added NumberTextField.setInitialValue(...), getInitialValue(), and getField()
	NumberTextField.listener and focusAdapter made private
	NumberTextField.iconFor(...) made private
	NumberTextField.setValues(...) deleted
	Numerous PropertyField public variables made private
	Added PropertyField.setEnabled(...) to be consistent with NumberTextField
	PropertyField.setValues(...) made private
	Deleted MiniHistogram.makeBucketPositions(...)
	Made MiniHistogram.minimum(...) and maximum(...) private	
	Added MiniHistogram.makeBuckets(...) variant
	DialogToolip is deleted and folded back into ToolTipBehavior
	WordWrap examples trimmed
	AbstractScrollable.getPreferredScrollableViewportSize() now doesn't call super
	Various PNGEncoder protected variables and methods made private
	PNGEncoder.ENCODE_ALPHA, NO_ALPHA, and FILTER_LAST constants deleted
	PNGEncoder.encodeBytes(alpha) method deleted
	Added double-checking for invalid Intervals as domains in Properties
	Font size reduced in LabelledPortrayal3D and EdgePortrayal3D in order to save memory.
	Added setScale() and getScale() methods to LabelledPortrayal3D and EdgePortrayal3D
	Added wcss tutorials
	Added tutorial 14 to wcss (3D)
	Made various ChartGenerator variables private
	Made various TimeSeriesChartGenerator variables private
	Made ChartGenerator.createFrame(...) deprecated and added ChartGenerator.createFrame()
	Deprecated ChartGenerator.getGlobalAttributeCount(), renamed to getNumGlobalAttributes()
	Deprecated ChartGenerator.[get|set][Range|Domain]AxisLabel() in favor of X/Y versions.
	Deprecated ChartGenerator.set[Range|Domain}AxisRange(...) in favor of X/Y versions.
	X and Y axis labels changed in ScatterPlotChartGenerator to more rational labels.
	JFreeChart.generatePDF rolled into PDFEncoder. 
	Made ChartGenerator.rebuildAttributeIndices() private
	ScatterPlotGenerator.updateSeries(...) has its arguments trimmed
	SeriesAttributes.manipulators made private
	SeriesAttributes.seriesIndex, stoppable, and generator now private
	Certain SeriesAttributes protected methods now public
	SeriesAttributes.iconFor(...) made private
	SeriesAttributes.setManipulatorsVisible(...) deleted
	SeriesAttributes.buildManipulators() made private
	Made TimeSeriesAttributes.series private
	TimeSeriesAttributes.[get|set][Thickness|Stretch]() now uses doubles, not floats
	TimeSeriesAttributes.getDashPattern() now properly returns an int, not a float
	ScatterPlotSeriesAttributes no longer has 'fill' methods and objects.
	ScatterPlotSeriesAttributes and HistogramSeriesAttributes.[get|set]Values() 
		made package-level private
	HistogramSeriesAttributes.[get|set]LineOpacity() renamed to [get|set]StrokeOpacity()
	HistogramSeriesAttributes.[get|set]Thickness() now uses doubles
	TimeSeriesChartingPropertyInspector.addToMainSeries(...) made private
	Moved data culling tasks from TimeSeriesChartingPropertyInspector to 
		TimeSeriesAttributes
	Removed two methods from DataCuller
	Methods in DataCuller made public
	Various MinGapDataCuller methods made private
	Reindented
	SimpleInspector revised.  MAX_PROPERTIES deleted and replaced with
		a private maximum properties variable and DEFAULT_MAX_PROPERTIES.
		The constructors were revamped, and new ones added.  Children
		SimpleInspectors now use the same max properties as their parents.
	GUIState.getMaximumPropertiesForInspector() added
	Updated wcss tutorial organization
	Deleted mason.1.3.1.command
