\section{Hints and Suggestions for Using the Interfaces}
 
\subsection{Tips for Using Geomview}\index{Geomview}
 
   In order to use DsTool Tk's three dimensional viewing capabilities, 
you need to have access to Geomview.  For information on using Geomview,
see the documentation accompanying it.  This section gives 
some tips which are specific to Geomview's interaction with DsTool.
 
In order to use Geomview effectively with DsTool, you need to know how
DsTool interacts with Geomview.  Geomview is used for two purposes in 
DsTool: plotting and viewing three dimensional data, and doing animations.  
For three dimensional viewing, data previously computed by DsTool 
is sent to Geomview, where the user can view and manipulate the data.  
For animations, the data is sent to Geomview as it is computed, so 
that the animation can take place in real time.  
 
Here are some other helpful tips:
 
\begin{enumerate}
%\item Geomview originally consists of three panels: the main command 
%   window, the Tools window, and the Camera window.   The main command
%   window gives a list of Targets (objects which are viewed with the 
%   camera), External modules which can be brought up, as well as the
%   menus for options controlling aspects of viewing.  The Tools window
%   contains a set of commands which can be used to manipulate objects
%   or change the view of objects in the Camera window.  The commands 
%   in the Tool window manipulate the target that is highlighted in 
%   the main window's target list, and listed in the Target entry field
%   in the Tools window.  The Camera window
%   is the view of the images in the target list.
 
\item You can scale the individual axes of a target sent to Geomview
   from DsTool using the external module ``Transformer''\index{Geomview, Transformer module}.  
   This module allows you to scale axes individually, or in groups.  This 
   feature comes in handy when you have data that has widely varying
   scales.  While DsTool automatically compensates for these cases,
   Geomview does not. 
% The Transformer module is part of Geomview \mbox{1.5.0},
%   but only for SGI platforms.  An X windows version does not exist.
 
%\item  When rotating things, the faster you move the cursor, the faster
%   Geomview will rotate the object.   So be careful to move slowly if 
%   you want to be able to see what's going on.   Also, on slower machines,
%   this becomes more important, since the animation becomes choppy as it 
%   gets faster.  
 
\item  There are two basic types of animations\index{animation, types} that are done with Geomview.
   The first type involves sending transformation matrices from DsTool to 
   Geomview at each time step of an integration to change the position of 
   the objects. The second type involves replacing the objects in Geomview with
   new ones at each time step.  Due to the large amounts
   of data being passed from DsTool to Geomview, animations can be very slow, 
   even for the first type.  Therefore, when doing animations, you might want to
   lower the number of time steps taken or choose a faster integrator.
 
\item You can delete trajectories or other data objects by using the 
   ``Delete'' function (on the edit menu), but this option will delete
   only the target which is highlighted in the target menu.  This target 
   is also listed in the Target field of the Tools window.  Selecting 
   Delete when the target is ``World'' will delete everything.
   Deleting selected targets can be useful when 
   for example you want to view the (un)stable manifold of a single 
   fixed point.  Since DsTool sends the 
   computed stable and unstable manifolds of the fixed points 
   individually, you can delete the ones you aren't interested in seeing.
   Alternately, you can delete the manifolds in DsTool before sending 
   them to Geomview.
 
%\item The ``L'' (for look) feature is very helpful in returning the object
%   back to the center of the Camera.   However, the look feature only 
%   refers to the target which is highlighted.  That is, if you choose
%   a given trajectory, you can pick it out with the look feature.   
 
\item You can overlay plots of variables\index{overlaying plots} by using the 3-D View window
   and Geomview.  For example, if you want to overlay plots of  x vs.~t, 
   y vs.~t and z vs.~t, you can do this by the following procedure:
   First, send to Geomview (via the 3-D View window) the plot x vs.~t vs.~0.
   Then copy the resulting Geomview target by selecting the Copy 
   option from the Edit menu button.  Next, send to Geomview
   the plot y vs.~t vs.~0.  Again, copy this resulting target.
   Finally, send to Geomview the plot z vs.~t vs.~0.  
   The resulting plot in Geomview will be the overlay of the three plots.
   If you fail to copy any of the targets, they will be erased.  This is 
   because DsTool sends trajectory objects to Geomview using the 
   name ``Traj.n.m'', where $n$ is the flow number, and $m$ is the 
   trajectory number.  Since we're only using one trajectory to generate
   all three plots, DsTool sends the data to the same target name each 
   time, writing over the previous data in that target.  
%   If you fail to copy any of the targets, they 
%   will be erased, since DsTool sends trajectories to Geomview using the 
%   same target name each time.  Since we are using one data set,
%   previous plots will be overwritten when we send the next plot. 
%  You won't be able to rescale things (or
%   will you?) individually, but at least you can see what's going
%   on.
 
%\item By default, you use the rotate function, but you can zoom in, and 
%   translate the object, and all sorts of stuff.  It's pretty darn 
%   self-explanatory.  
 
\end{enumerate} 
 
 
\subsection{Tips for the Tcl/Tk Interface in DsTool}\index{Tcl/Tk, interface}

DsTool's interface is written in Tcl/Tk.  In addition to providing 
an easy-to-use graphics interface framework, Tcl/Tk
is a scripting language, and you can run DsTool entirely by entering
commands at the prompt \unix{\%DsTool}.  Some other useful tips follow:
 
\begin{enumerate}
\item  Enter the command \unix{end\_wait} if DsTool grabs the input and 
   does not relinquish it.  Typically, during computations, DsTool 
   disables mouse input and returns control to the mouse when
   the computation is finished.  If an unexpected error occurs 
   in the computation,
   control might not be properly restored.  The command \unix{end\_wait}
   typed at the DsTool command prompt should return control to 
   the mouse.\index{restoring mouse input}\index{mouse, restoring input from}
 
%\item  You can change the background color of a 2-D or 1-D View window by 
%   the command:   .twoD{\em n}.c configure -bg {\em color}
%   where {\em n} is the number of the window in question (this number 
%   appears in the title of the window), and {\em color} is the desired 
%   color.  You can use any color name recognized by Tcl/Tk.  A complete
%   list appears in the file \unix{\$DSTOOL/doc/misc/rgb.txt}.   You can 
%   also input colors 
%   by hexidecimal rgb values, using \eg {\em color} == \#ff0000 (red)
 
\item You can modify the default window colors and fonts
   in DsTool by following the instructions for 
   adding custom Tcl/Tk code to your own version of DsTool.  See the 
   accompanying documentation in \unix{\$DSTOOL/my\_dstool/README}\index{customization}
   for more information.  The procedure essentially
   involves adding one line of code, and compiling your own 
   version of DsTool.
 
\item While you can run DsTool entirely from the keyboard, it is not 
   recommended that you do so.  Typically, a button press will call 
   ``tcl\_to\_pm'' to update the Postmaster, then ``pm EXEC'' to 
   perform the computation by calling a C routine, and finally ``pm\_to\_tcl'' 
   to update the interface.  However, it may perform 
   other tasks as well.  For example, the ``Forwards'' button on the 
   Continuation window checks to see if the number of active parameters
   selected is the correct number before proceeding.  If you insist on 
   running DsTool by typing from the prompt, you should use the procedures 
   that Tcl/Tk calls when a button is pressed, instead of calling the 
   Postmaster routines directly.  
   For example, to replicate a press of the ``Forwards'' button on the Orbits
   window, instead of typing \unix{pm EXEC Flow.Forwards}, type 
   \unix{orbits(forwards)}.
   In addition, if you change an entry in a field, you should follow it with
   a call of ``tcl\_to\_pm'' to update the Postmaster.  Similarly, if you 
   change a Postmaster entry,
   you should follow it with a call of ``pm\_to\_tcl'', to update the interface.
 
\item One efficient way to automate long calculations is by writing Tcl 
   scripts\index{Tcl/Tk, scripts}.  You can run scripts by entering the command 
   ``source {\em filename}'' at the prompt.  As with the previous note, 
   you should be careful when writing scripts to make sure that you are 
   computing the quantities that you wish to compute.  
\end{enumerate}
 
