Source code: jplot/GraphPars.java

   /*
    * JPLOT  -- Java Plotting Interface for any programme or
    *           as an independent GUI
    * 
    * Copyright (C) 1999 Jan van der Lee
    *
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU General Public License
    * as published by the Free Software Foundation; either version 2
   * of the License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  
   * 02111-1307, USA.
   *
   * Send bugs, suggestions or queries to <jplot@cig.ensmp.fr>
   * The latest releases are found at 
   * http://www.cig.ensmp.fr/~vanderlee/jplot.html
   *
   * Initally developed for use by the Centre d'Informatique Geologique 
   * Ecole des Mines de Paris, Fontainebleau, France.
   */
  
  package jplot;
  
  import java.awt.*;
  import java.util.*;
  import javax.swing.*;
  
  /**
   * <code>GraphPars</code> contains the parameters which are used to
   * draw the graph such as number of tics, scaling values, offset
   * parameters, axis lengths etc. All these parameters are settable
   * by the GUI, and written to this class. Class <code>Graph</code>
   * reads this class and draws the graph based on these parameters.
   */
  public class GraphPars extends DataChangeListener {
  
    // some handy variables, if we need more than an boolean:
    static final int DISABLE=0;
    static final int ENABLE=1;
    static final int AUTO=2;
  
    static final Color[] color = {
      new Color(0,0,102),   // very dark blue
      new Color(255,0,0),   // red
          //new Color(0,102,102), // very dark green
      new Color(0,114,0),   // very dark green
      new Color(132,0,132), // dark-purple
      
      new Color(102,0,255), // dark blue
      new Color(255,0,102), // red-violet
          //new Color(0,102,0),   // dark green
      new Color(0,145,0),   // dark green
      new Color(255,0,255), // light-purple
      
      new Color(0,153,255), // medium-light blue
      new Color(255,153,0), // orange
          //new Color(0,205,153), // medium (sea) green
      new Color(0,195,100), // medium green
      new Color(255,188,255),  // light-violet
      
      new Color(0,255,255), // light blue
      new Color(255,255,0), // yellow
      new Color(102,255,0), // light green
      new Color(255,220,226), // saumong
      
      new Color(10,10,10), // black
      new Color(100,100,100), // gray
      new Color(160,160,160), // gray
      new Color(220,220,220)}; // gray
    
    
    public static final float[] dashLengths = {0.0f,2.0f,3.0f,4.0f,5.0f,6.0f,7.0f,-1.0f};
    // Very large number, used to initialize stuff:
    static final double INF = 1e300;  
  
    // number of axis and symbolic constants to facilitate 
    // endless lists of axis-specific parameters:
    static final int NAXES  = 2;
    static final int X_AXIS = 0;
    static final int Y_AXIS = 1;
    static final int Z_AXIS = 2;
  
    // currently available graphstyles. Public, available from outside
    // the current package (so you can use the function 'switchGraphType())
    static public final int GRAPHTYPE_2D=0;
    static public final int GRAPHTYPE_PIPER=1;
    static public final int GRAPHTYPE_MULTI=2;
  
    // symbolic constant used for no symbols (points) on the lines:
    static final int NO_SYMBOL = 13;
  
   // symbolic constant used for no lines:
   static final int NO_LINE = 7;
 
   // index pointing to the actual color and point indices, 
   // used by  the plotpanels. Must be declared here in case 
   // there are different datasets:
   //-------------------------------------------------------
   public int colorIndex=0;
   public int pointIndex=0;
 
 
   // actual color. This color is used for previewing the color if
   // different from one of the default colors:
   // ------------------------------------------------------------
   public Color actualColor;
 
   // size of the graph panel:
   private Dimension panelSize;
 
   // offsets:
   private double leftMargin;
   private double rightMargin;
   private double bottomMargin;
   private double topMargin;
 
   // tics:
   private double[] ticLength = new double [NAXES];
   private int maxNumberOfTics;
   private int[] numberTics = new int [NAXES];
   private boolean[] useNumberOfTics = new boolean [NAXES];
   private boolean[] plotTics = new boolean [NAXES];
   private boolean[] rotateTics = new boolean [NAXES];
   private boolean[] mirrorTics = new boolean [NAXES];
   private boolean[] plotTicLabels = new boolean [NAXES];
 
   // labels:
   private Vector labels = new Vector();
   //private Vector dataLabels = new Vector();
 
   // axes:
   private double axesRatio;
   private boolean[] plotAxis = new boolean [NAXES];
   private boolean[] plotMirrorAxis = new boolean [NAXES];
   private boolean[] rotTics = new boolean [NAXES];
   private double[] inv = new double [NAXES];
 
   // colors:
   private Color backgroundColor;
   private Color axesColor;
   private Color[] labelColor = new Color [NAXES];
   private Color titleColor;
 
   // legend:
   private Font legendFont;
   private boolean useLegend;
   private boolean useLegendPosition;
   //private FontMetrics legendFontMetrics;
   private double[] legendPos = new double [NAXES];  
   private double legendSpacing;
 
   // scaling:
   private boolean[] isLogarithmic = new boolean [NAXES];
   private boolean[] autoRange = new boolean [NAXES];
   private double[] minValue = new double[NAXES];
   private double[] maxValue = new double[NAXES];
   private float[] multiplier = new float[NAXES];
   private float[] additioner = new float[NAXES];
   private float[] globalDivider = new float[NAXES];
   private float[] globalOffset = new float[NAXES];
 
   // fonts, colors used by the tic-labels
   private Font[] ticFont = new Font [NAXES];
   private Color[] ticColor = new Color [NAXES];
   //private FontMetrics[] ticFontMetrics = new FontMetrics [NAXES];
 
   // grid:
   private boolean[] grid = new boolean [NAXES];
   private Color gridColor;
   private boolean toFront;
 
   // gadgets:
   private boolean shadow;
   private boolean useRatio;
   
   // piper diagram stuff:
   private Color triangleFillColor;
   private boolean plotInner;
 
   // bounding box:
   private boolean plotBox;
   private float boxOffset;
   private Color graphBgColor;
   private Color boxFillColor;
   private Color boxColor;
   
   // flags, used to avoid usless calculatations or updates:
   private boolean updatePlot;
   private boolean fontChanged;
 
   // use points:
   private int pointMode;
   private int colorMode;
 
   // graph types and linestyles:
   private int graphType;
   private int graphStyle;
 
   private float tdsFac;
   private boolean useTds;
 
   private final String lf = System.getProperty("line.separator");
 
   // accessibility methods:
   //-----------------------
   /** 
    * @return the panel dimension of the graph
    */
   Dimension getDimension() {
     return panelSize;
   }
 
   /** 
    * Sets the dimension of the panel of the graph.
    * @param d dimension of the graph panel
    */
   void setDimension(Dimension d) {
     panelSize = d;
   }
 
   /** 
    * @return the panel width
    */
   int getPanelWidth() {
     return panelSize.width;
   }
 
   /** 
    * @return the panel height
    */
   int getPanelHeight() {
     return panelSize.height;
   }
 
   /** 
    * Returns the distance between the left panel border and the left Y-axis.
    * @return the left margin.
    */
   double getLeftMargin() {
     return leftMargin;
   }
 
   /** 
    * Sets the distance between the left panel border and the left Y-axis.
    * @param lm the left margin in points.
    */
   void setLeftMargin(double lm) {
     leftMargin = lm;
   }
 
   /** 
    * Returns the distance between the right panel border and the right Y-axis.
    * @return the right margin.
    */
   double getRightMargin() {
     return rightMargin;
   }
 
   /** 
    * Sets the distance between the right panel border and the right Y-axis.
    * @param rm the right margin in points.
    */
   void setRightMargin(double rm) {
     rightMargin = rm;
   }
 
   /** 
    * Returns the distance between the lower panel border and the bottom X-axis.
    * @return the bottom margin.
    */
   double getBottomMargin() {
     return bottomMargin;
   }
 
   /** 
    * Sets the distance between the lower panel border and the bottom X-axis.
    * @param bm the bottom margin in points.
    */
   void setBottomMargin(double bm) {
     bottomMargin = bm;
   }
 
   /** 
    * Returns the distance between the upper panel border and the top X-axis.
    * @return the top margin.
    */
   double getTopMargin() {
     return topMargin;
   }
 
   /** 
    * Sets the distance between the upper panel border and the top X-axis.
    * @param tm the top margin in points.
    */
   void setTopMargin(double tm) {
     topMargin = tm;
   }
 
   /**
    * @returns the length of the tics. 
    * @param axis defines to which axis this function applies.
    */
   double getTicLength(int axis) {
     return ticLength[axis];
   }
 
   /**
    * Sets the length of the tics. In fact, the actual tic length is
    * the value you set here multiplied by the axis length. By default,
    * the tic-length is about 0.01 times the axis length.
    * @param axis defines to which axis this function applies.
    * @param tl tic length in points */
   void setTicLength(int axis, double tl) {
     ticLength[axis] = tl;
   }
 
   /**
    * @returns the length of one of the axes.
    * @param axis defines to which axis this function applies.
    */
   /*
   double getAxisLength(int axis) {
     return axisLength[axis];
   }
   */
 
   /**
    * Sets the length of one of the axes.
    * @param axis defines to which axis this function applies.
    * @param l length of the axis, in points */
   /*
   void setAxisLength(int axis, double l) {
     axisLength[axis] = l;
   }
   */
 
   /**
    * Sets whether or not to use a fixed ratio between 
    * X- and Y-axes lengths.
    * @param boolean, true if the ratio should be used.
    */
   void setUseAxesRatio(boolean b) {
     useRatio = b;
   }
 
   /**
    * Returns the whether or not to use a fixed ratio between 
    * X- and Y-axes lengths.
    * @return true if the ratio should be used.
    */
   boolean useAxesRatio() {
     return useRatio;
   }
 
   /**
    * Returns the ratio between X- and Y-axes lengths.
    * @return the ratio Y-axisLength/X-axisLength
    */
   double getAxesRatio() {
     return axesRatio;
   }
 
   /**
    * Sets the ratio between X- and Y-axes lengths. This ratio
    * must be greater than 0.0, a value of 0.0 means that the
    * ratio will be calculated automatically as a function of
    * the size of the panel, used to plot the graph.
    * @param r the ratio Y-axisLength/X-axisLength
    */
   void setAxesRatio(double r) {
     axesRatio = (r > 0.0)? r:0.0;
   }
 
   /**
    * Sets wether the user defines the number of tics.
    * X- and Y-axes lengths.
    * @param axis defines to which axis this function applies.
    * @param boolean, true if the ratio should be used.
    */
   void setUseNumberOfTics(int axis, boolean b) {
     useNumberOfTics[axis] = b;
   }
 
   /**
    * Returns whether or not to use a user-defined number of tics.
    * @param axis defines to which axis this function applies.
    * @return true if the ratio should be used.
    */
   boolean useNumberOfTics(int axis) {
     return useNumberOfTics[axis];
   }
 
   /**
    * Returns the number of tics for the specfied axis.
    * @param axis defines to which axis this function applies.
    * @return the number of tics for the specfied axis.
    */
   int getNumberOfTics(int axis) {
     return numberTics[axis];
   }
 
   /**
    * Sets the number of tics for the specified axis.
    * @param axis defines to which axis this function applies.
    * @param n the number of tics
    */
   void setNumberOfTics(int axis, int n) {
     numberTics[axis] = (n > 0)? n:0;
   }
 
   /**
    * @return the maximum number of tics allowed.
    */
   int getMaxNumberOfTics() {
     return maxNumberOfTics;
   }
 
   /**
    * Sets the maximum number of tics allowed. Setting this parameter
    * may change the number of tics, but the exact number of tics is
    * a function of the start- and end values of the data.
    * @param n an indicative number of tics
    */
   void setMaxNumberOfTics(int n) {
     maxNumberOfTics = n;
   }
 
   /**
    * sets the multiplier used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    * @param val value of the multiplier
    */  
   void setMultiplier(int axis, float val) {
     multiplier[axis] = val;
   }
 
   /**
    * @return the multiplier used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    */  
   float getMultiplier(int axis) {
     return multiplier[axis];
   }
 
   /**
    * Sets a global divider used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    * @param val value of the divider
    */  
   void setGlobalDivider(int axis, float val) {
     globalDivider[axis] = val;
   }
 
   /**
    * @return the divider used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    */  
   float getGlobalDivider(int axis) {
     return globalDivider[axis];
   }
 
   /**
    * Sets a global offset used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    * @param val value of the offset
    */  
   void setGlobalOffset(int axis, float val) {
     globalOffset[axis] = val;
   }
 
   /**
    * @return the offset used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    */  
   float getGlobalOffset(int axis) {
     return globalOffset[axis];
   }
 
   /**
    * sets the additioner used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    * @param val value of the additioner
    */  
   void setAdditioner(int axis, float val) {
     additioner[axis] = val;
   }
 
   /**
    * @return the additioner used to rescale all the data arrays.
    * @param axis defines to which axis this function applies.
    */  
   float getAdditioner(int axis) {
     return additioner[axis];
   }
 
   /**
    * @return the start-value of the X, Y or Z range.
    * @param axis defines to which axis this function applies.
    */  
   double getMinValue(int axis) {
     return minValue[axis];
   }
 
   /**
    * Sets the start-value of the value range.
    * @param axis defines to which axis this function applies.
    * @param x minimum value of the X-range.
    */
   void setMinValue(int axis, double x) {
     minValue[axis] = x;
   }
 
   /**
    * @return the maximum value of the X,Y or Z range.
    * @param axis defines to which axis this function applies.
    */  
   double getMaxValue(int axis) {
     return maxValue[axis];
   }
 
   /**
    * Sets the maximum value of the X,Y or Z range.
    * @param axis defines to which axis this function applies.
    * @param x maximum value of the range.
    */
   void setMaxValue(int axis, double x) {
     maxValue[axis] = x;
   }
 
   /**
    * Returns whether an axis will be drawn or not.
    * @param axis defines to which axis this function applies.
    * @return true if the axis will be drawn.
    */
   boolean drawAxis(int axis) {
     return plotAxis[axis];
   }
 
   /**
    * Sets whether an axis will be drawn or not.
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the axis should be drawn.
    */
   void setDrawAxis(int axis, boolean b) {
     plotAxis[axis] = b;
   }
 
   /**
    * Returns whether the mirror of an axis will be drawn or not.
    * @param axis defines to which axis this function applies.
    * @return true if the mirror axis will be drawn.
    */
   boolean drawMirrorAxis(int axis) {
     return plotMirrorAxis[axis];
   }
 
   /**
    * Sets whether the mirror of an axis will be drawn or not.
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the mirror axis should be drawn.
    */
   void setDrawMirrorAxis(int axis, boolean b) {
     plotMirrorAxis[axis] = b;
   }
 
   /**
    * Returns whether or not to draw tic labels.
    * @param axis defines to which axis this function applies.
    * @return true if tic labels should be drawn.
    */
   boolean drawTicLabels(int axis) {
     return plotTicLabels[axis];
   }
 
   /**
    * Sets whether all ticlabels will be written or not.
    * @param b toggle, true if the axis should be drawn.
    */
   void setDrawTicLabels(boolean b) {
     plotTicLabels[X_AXIS] = plotTicLabels[Y_AXIS] = b;
   }
 
   /**
    * Sets whether X, Y or Z ticlabels will be written or not.
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the axis should be drawn.
    */
   void setDrawTicLabels(int axis, boolean b) {
     plotTicLabels[axis] = b;
   }
 
   /**
    * Returns whether or not to draw tics.
    * @param axis defines to which axis this function applies.
    * @return true if tics should be drawn.
    */
   boolean drawTics(int axis) {
     return plotTics[axis];
   }
 
   /**
    * Sets whether ticlabels will be written or not. You know, these
    * little lines indicating the dimensions of your plot.
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the tics should be drawn.
    */
   void setDrawTics(int axis, boolean b) {
     plotTics[axis] = b;
   }
 
   /**
    * Returns the actual background color of the graph.
    * @return actual background color.
    */
   Color getBackgroundColor() {
     return backgroundColor;
   }
 
   /**
    * Sets the actual background color of the graph.
    * @param color new background color.
    */
   void setBackgroundColor(Color color) {
     backgroundColor = color;
   }
 
   /**
    * Returns the actual color of the axes of the graph.
    * @return actual color used to draw the axes.
    */
   Color getAxesColor() {
     return axesColor;
   }
 
   /**
    * Sets the actual color of the axes of the graph.
    * @param color new color to draw the axes.
    */
   void setAxesColor(Color color) {
     axesColor = color;
   }
 
   /**
    * @return the list of labels currently defined
    */
   public Vector getLabels() {
     return labels;
   }
 
   /*
    * Returns a vector of labels which are defined by the dataset.
    * @return the list of labels currently defined.
    */
   /*
   public Vector getDataLabels() {
     return dataLabels;
     }*/
 
   /**
    * Add a label or, if already in the list, replaces a label
    * with the current one.
    * @param newgl new label
    */
   public void addLabel(GraphLabel newgl) {
     labels.add(newgl);
   }
 
   /**
    * Add a label or, if already in the list, replaces a label
    * with the current one.
    * @param gl new label
    */
   public void setLabel(GraphLabel gl) {
     boolean labelFound=false;
     for (Enumeration e=labels.elements(); e.hasMoreElements();) {
       GraphLabel g = (GraphLabel) e.nextElement();
       if (gl.equals(g.getText())) {
   g.copy(gl);
   labelFound = true;
   break;
       }
     }
     if (!labelFound) labels.add(gl);
   }
 
   /**
    * Returns the font used by the labels drawn at each tic
    * @param axis defines to which axis this function applies.
    * @return actual font used by the tic labels.
    */
   public Font getTicFont(int axis) {
     return ticFont[axis];
   }
 
   /**
    * Sets the font used by the labels drawn at each tic
    * @param axis defines to which axis this function applies.
    * @param font the new font
    */
   public void setTicFont(int axis, Font font) {
     ticFont[axis] = font;
     fontChanged = true;
   }
 
   /**
    * Returns the color used by the labels drawn at each tic
    * @param axis defines to which axis this function applies.
    * @return actual color used by the tic labels.
    */
   public Color getTicColor(int axis) {
     return ticColor[axis];
   }
 
   /**
    * Sets the color used by the labels drawn at each tic
    * @param axis defines to which axis this function applies.
    * @param color the new color
    */
   public void setTicColor(int axis, Color color) {
     ticColor[axis] = color;
   }
 
   /**
    * Returns the font metrics used by the labels drawn at each tic
    * @param axis defines to which axis this function applies.
    * @return actual font metrics used by the tic labels.
    */
   /*
   public Font getTicFontMetrics(int axis) {
     return ticFontMetrics[axis];
   }
   */
 
   /**
    * Returns the font used by the legend
    * @return actual font used by the legend.
    */
   Font getLegendFont() {
     return legendFont;
   }
 
   /**
    * Sets the actual font of the legend.
    * @param axis defines to which axis this function applies.
    * @param font new font to draw the legend.
    */
   void setLegendFont(Font font) {
     legendFont = font;
     fontChanged = true;
   }
 
   /**
    * @return the font metrics used by the legend
    */
   /*
   public FontMetrics getLegendFontMetrics() {
     return legendFontMetrics;
   }
   */
 
   /**
    * @return true if you want to show the legend
    */
   boolean drawLegend() {
     return useLegend;
   }
 
   /**
    * Sets whether or not to draw the legend.
    * @param b true if you want to show the legend
    */
   void setDrawLegend(boolean b) {
     useLegend = b;
   }
 
   /**
    * Returns the x or y coordinates (defined in pixels, relative 
    * to the size of the panel showing the graph) of the legend.
    * @param axis defines to which axis this function applies.
    * @return the x- or y coordinates of the legend.
    */
   double getLegendPos(int axis) {
     return legendPos[axis];
   }
 
   /*
   private double xPixel2Data(double x) {
     double d = inv[X]*diff[X]*(x-leftMargin)/axisLength[X];
     if (useLogScale(X)) return getMinValue(X)*Math.pow(10.0,d);
     else return getMinValue(X) + d;
   }
 
   private double yPixel2Data(double y) {
     double d = inv[Y]*diff[Y]*(1.0-(y-topMargin)/axisLength[Y]);
     if (useLogScale(Y)) return getMinValue(Y)*Math.pow(10.0,d);
     else return getMinValue(Y) + d;
   }
   */
 
   /**
    * Sets the x or y coordinates (defined relative 
    * to the actual axes values) of the legend.
    * @param axis defines to which axis this function applies.
    * @param c the x/y coordinate of the legend.
    */
   void setLegendPos(int axis, double c) {
     legendPos[axis] = c;
   }
 
   /**
    * Sets the x and y coordinates (defined relative 
    * to the actual axes values) of the legend.
    * @param x the x coordinate of the legend.
    * @param y the y coordinate of the legend.
    */
   void setLegendPos(double x, double y) {
     legendPos[X_AXIS] = x;
     legendPos[Y_AXIS] = y;
   }
 
   /**
    * @return true if you want to set the legend coordinates
    */
   boolean useLegendPos() {
     return useLegendPosition;
   }
 
   /**
    * Sets whether or not to set the legend position in X,Y 
    * coordinates as defined by the graph.
    * @param b true if you want to set the position
    */
   void setUseLegendPos(boolean b) {
     useLegendPosition = b;
   }
 
   /**
    * Returns the vertical spacing, between each line of the legend.
    * @return vertical spacing for the legend.
    */
   public double getLegendSpacing() {
     return legendSpacing;
   }
 
   /**
    * Sets the vertical spacing, between each line of the legend.
    * @param dy vertical spacing for the legend.
    */
   public void setLegendSpacing(double dy) {
     legendSpacing = dy;
   }
 
   /**
    * Reset the positions of all the labels.
    */
   void resetLabels() {
     for (Enumeration e=labels.elements(); e.hasMoreElements();) {
       ((GraphLabel)e.nextElement()).setUsePosition(false);
     }
   }
 
   /**
    * Returns whether or not to plot using a logarithmic scale.
    * @param axis defines to which axis this function applies.
    * @return true if the scale is logarithmic.
    */
   boolean useLogScale(int axis) {
     return isLogarithmic[axis];
   }
 
   /**
    * Sets true or false to plot on a log scale.
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the scaling is logarithmic
    */
   void setLogScale(int axis, boolean b) {
     isLogarithmic[axis] = b;
   }
 
   /**
    * Returns whether or not we should use automatic scaling.
    * @param axis defines to which axis this function applies.
    * @return true if the scale is logarithmic.
    */
   boolean useAutoRange(int axis) {
     return autoRange[axis];
   }
 
   /**
    * Sets true or false to use automatic scaling.
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the the automatic scaling feature is enabled.
    */
   void setAutoRange(int axis, boolean b) {
     autoRange[axis] = b;
   }
 
   /**
    * Returns whether or not we should draw tics on the mirror axis.
    * @param axis defines to which axis this function applies.
    * @return true if the mirror tics should be drawn
    */
   boolean drawMirrorTics(int axis) {
     return mirrorTics[axis];
   }
 
   /**
    * Sets true or false to draw mirror tics
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the we should draw mirror tics
    */
   void setDrawMirrorTics(int axis, boolean b) {
     mirrorTics[axis] = b;
   }
 
   /**
    * Sets true or false to rotate tics
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the we should rotate the tics
    */
   void setRotateTics(int axis, boolean b) {
     rotTics[axis] = b;
   }
 
   /**
    * Returns whether or not we should rotate the tics.
    * Rotated tics are drawn at the outer-side of the axes.
    * @param axis defines to which axis this function applies.
    * @return true if the tics will be rotated.
    */
   boolean rotateTics(int axis) {
     return rotTics[axis];
   }
 
   /**
    * Returns whether or not we should update the graph.
    * @return true if the graph should be updated
    */
   boolean updateGraph() {
     return updatePlot;
   }
 
   /**
    * Sets true or false to update the graph.
    * @param b toggle, true if the we should update.
    */
   void setUpdateGraph(boolean b) {
     updatePlot = b;
   }
 
   /**
    * Returns whether or not a shadow will be drawn at the panel border.
    * @return true if the shadow should be drawn.
    */
   boolean drawShadow() {
     return shadow;
   }
 
   /**
    * Defines whether or not a shadow will be drawn at the panel border.
    * @param b toggle, true if the shadow should be drawn.
    */
   void setShadow(boolean b) {
     shadow = b;
   }
 
   /**
    * Sets whether or not using grid lines.
    * @param axis defines to which axis this function applies.
    * @param b toggle, true if the the grid should be rotated.
    */
   void setDrawGrid(int axis, boolean b) {
     grid[axis] = b;
   }
 
   /**
    * Returns true if the grid should be drawn.
    * @param axis defines to which axis this function applies.
    * @return true if the grid lines should be used
    */
   boolean drawGrid(int axis) {
     return grid[axis];
   }
 
   /**
    * Sets whether or not plotting points
    * @param b flag, indicates if the the points should be drawn.
    * Note that the flag can take symbolic values such as ENABLE, AUTO etc.
    */
   void setPointMode(int b) {
     pointMode = b;
  }

  /**
   * Returns true if the points should be drawn.
   * @return true if the grid lines should be used
   */
  int getPointMode() {
    return pointMode;
  }

  /**
   * Sets the way of defining the colors of the curves.
   * By default, the program takes, for each data-array, the colors
   * from the pre-defined color swatches. If there are more lines
   * than colors, than the first colors are re-used. This is the
   * auto-mode (flag = AUTO), which is the default. By seting the flag
   * to HIDE, no lines are drawn.
   * @param b flag, indicates how the program should color the curves
   * Note that the flag can take symbolic values such as DISABLE, AUTO etc.
   */
  void setColorMode(int b) {
    colorMode = b;
  }

  /**
   * Returns the mode used to assign colors to the curves.
   * @return AUTO for the auto-selection mode (default), DISABLE
   * if the lines should be hidden.
   */
  int getColorMode() {
    return colorMode;
  }

  /** 
   * Sets the color used by the grid. As is common use, the same 
   * color applies to horizontal and vertical, for the moment.
   * @param c color of the grid lines.
   */
  void setGridColor(Color c) {
    gridColor = c;
  }

  /**
   * @return the grid color
   */
  Color getGridColor() {
    return gridColor;
  }
  
  /**
   * @return whether or not to draw the grid at the front, i.e.,
   * in front of all the plotted stuff.
   */
  boolean gridToFront() {
     return toFront;
  }
  
  /**
   * sets whether or not to draw the grid at the front.
   * @param b true if the grid will be moved to the front
   */
  void setGridToFront(boolean b) {
    toFront = b;
  }
  
  /** 
   * Sets the graph type. The integer is an symbolic constant,
   * must be one of the constants defined in class Data
   * (GRAPHTYPE_2D, GRAPHTYPE_PIPER, etc.).
   * @param s graph style (symbolic constant)
   */
  void setGraphType(int s) {
    graphType = s;
    if (s == GRAPHTYPE_PIPER) {
      gridColor = new Color(200,200,200);
      ticFont[X_AXIS] = Utils.getDefaultFont().deriveFont(9f);
      ticFont[Y_AXIS] = Utils.getDefaultFont().deriveFont(9f);
    }
  }

  /** 
   * Returns the current graph type.
   * @return the current graph type.
   */
  int getGraphType() {
    return graphType;
  }

  /** 
   * Sets the line drawing style for 2D graphs. The integer is an 
   * symbolic constant, must be one of the constants defined in 
   * class LinePars (LinePars.LINES, LinePars.HISTO, etc.).
   * @param s line style (symbolic constant)
   */
  void setGraphStyle(int s) {
    graphStyle = s;
  }

  /** 
   * Returns the current line style.
   * @return the current line style.
   */
  int getGraphStyle() {
    return graphStyle;
  }

  /**
   * Returns the color used to fill the shaded triangles.
   * @return the color used to fill the shaded triangles.
   */
  public Color getInnerColor() {
    return triangleFillColor;
  }

  /**
   * Sets the color used to fill the inner triangles.
   * @param c the color used to fill the shaded triangles.
   */
  public void setInnerColor(Color c) {
    triangleFillColor = c;
  }

  /**
   * Sets whether or not to draw the filled triangles.
   * @param b true if the filled triangles should be drawn.
   */
  public void setShowInner(boolean b) {
    plotInner = b;
  }

  /**
   * @return true if the filled triangles should be drawn.
   */
  public boolean showInner() {
    return plotInner;
  }

  /**
   * Sets whether or not to draw the bounding box.
   * @param b true if the filled triangles should be drawn.
   */
  public void setShowBox(boolean b) {
    plotBox = b;
  }

  /**
   * @return true if the bounding box should be drawn.
   */
  public boolean showBox() {
    return plotBox;
  }

  /**
   * Sets the offset of the bounding box drawn around a graph.
   * @param f offset in pixels.
   */
  public void setBoxOffset(float f) {
    boxOffset = f;
  }

  /**
   * @return the offset of the bounding box.
   */
  public float getBoxOffset() {
    return boxOffset;
  }  

  /**
   * Sets the fill color of the bounding box drawn around a graph.
   * @param c color.
   */
  public void setBoxFillColor(Color c) {
    boxFillColor = c;
  }

  /**
   * @return the fill color of the bounding box.
   */
  public Color getBoxFillColor() {
    return boxFillColor;
  }  

  /**
   * Sets the color of the bounding box drawn around a graph.
   * @param c color.
   */
  public void setBoxColor(Color c) {
    boxColor = c;
  }

  /**
   * @return the color of the bounding box.
   */
  public Color getBoxColor() {
    return boxColor;
  }  

  /**
   * Sets the background color of the graph.
   * @param c color.
   */
  public void setGraphBackgroundColor(Color c) {
    graphBgColor = c;
  }

  /**
   * @return the color of the background of the graph.
   */
  public Color getGraphBackgroundColor() {
    return graphBgColor;
  }  

  /**
   * Sets the factor used to plot a TDS circle.
   * The size of the circle is proportional to the TDS but scaled
   * by some factor 100 or so. This factor is set by the user with
   * this method.
   * @param f scaling factor for the TDS circle.
   */
  public void setTdsFactor(float f) {
    tdsFac = f;
  }

  /**
   * @return the factor used to plot a TDS circle.
   */
  public float getTdsFactor() {
    return tdsFac;
  }

  /**
   * Sets whether the tds should be drawn or not.
   * @param b true if the TDS circle should be drawn on a piper diagram
   */
  public void setDrawTds(boolean b) {
    useTds = b;
  }

  /**
   * @return true if the tds circle should be drawn.
   */
  public boolean drawTds() {
    return useTds;
  }

  /**
   * Resets the class to all the default values.
   */
  public void reset() {
    for (int k=0; k<NAXES; k++) {
      minValue[k] = INF;          // INF is 1e300
      maxValue[k] = -INF;
      autoRange[k] = true;
      isLogarithmic[k] = false;
      plotTicLabels[k] = true;
      plotTics[k] = true;
      plotAxis[k] = true;
      plotMirrorAxis[k] = true;
      rotateTics[k] = false;
      mirrorTics[k] = true;
      numberTics[k] = 0;
      useNumberOfTics[k] = false;
      ticColor[k] = Color.black;
      ticFont[k] = Utils.getDefaultFont();
      grid[k] = true;
      multiplier[k] = 1.0f;
      additioner[k] = 0.0f;
      globalDivider[k] = 1.0f;
      globalOffset[k] = 0.0f;
      legendPos[k]  = 5.0f;
      ticLength[k] = 0.01;
      rotTics[k] = false;
    }
    setDataChanged(false);
    axesRatio = 0.0;
    panelSize = new Dimension(440,300);
    shadow = true;
    maxNumberOfTics = 20;
    //backgroundColor = new Color(255,255,220);
    axesColor = Color.black;
    leftMargin = 20;
    rightMargin = 27;
    bottomMargin = 15;
    topMargin = 15;
    useRatio = false;
    legendFont = Utils.getDefaultFont();
    legendSpacing = 1.0f;
    useLegendPosition = false;
    useLegend = true;
    gridColor = new Color(227,230,230);
    toFront = false;
    fontChanged = true;
    updatePlot = false;
    pointMode = DISABLE;
    colorMode = AUTO;
    graphStyle = LinePars.LINES;
    graphType = GRAPHTYPE_2D;
    triangleFillColor = new Color(224,223,221);
    plotInner = true;
    plotBox = false;
    boxFillColor = new Color(247,247,247);
    boxColor = Color.black;
    //backgroundColor = new Color(0,0,85);
    backgroundColor = new Color(247,247,247);
    graphBgColor = Color.white;
    boxOffset = 3.0f;
    tdsFac = 1000.0f;
    useTds = true;
    labels.clear();
    if (JPlot.debug) System.out.println("settings reset in GraphPars...");
  }

  /**
   * Return the current parameter settings in a string.
   * This string is generally used to save the graph settings.
   * All settings are returned in some kind of keyword-based
   * format, i.e. keyword1 = value1 (separated by a newline).
   * @return graph settings in a string.
   */
  public String getSettings() {
    StringBuffer sb = new StringBuffer(1000);
    sb.append("  graph-parameters {");
    for (int k=0; k<NAXES; k++) {
      String sk = Integer.toString(k);
      sb.append(lf);
      sb.append("    min-axes ").append(sk).append(" = ").append(minValue[k]);
      sb.append(lf);
      sb.append("    max-axes ").append(sk).append(" = ").append(maxValue[k]);
      sb.append(lf);
      sb.append("    autorange ").append(sk).append(" = ").append(autoRange[k]);
      sb.append(lf);
      sb.append("    uselog ").append(sk).append(" = ").append(isLogarithmic[k]);
      sb.append(lf);
      sb.append("    showticlabels ").append(sk).append(" = ").append(plotTicLabels[k]);
      sb.append(lf);
      sb.append("    showtics ").append(sk).append(" = ").append(plotTics[k]);
      sb.append(lf);
      sb.append("    showaxis ").append(sk).append(" = ").append(plotAxis[k]);
      sb.append(lf);
      sb.append("    showmirroraxis ").append(sk).append(" = ").append(plotMirrorAxis[k]);
      sb.append(lf);
      sb.append("    rotatetics ").append(sk).append(" = ").append(rotateTics[k]);
      sb.append(lf);
      sb.append("    mirrortics ").append(sk).append(" = ").append(mirrorTics[k]);
      sb.append(lf);
      sb.append("    rotatetics ").append(sk).append(" = ").append(rotTics[k]);
      sb.append(lf);
      sb.append("    numoftics ").append(sk).append(" = ").append(numberTics[k]);
      sb.append(lf);
      sb.append("    fixnumoftics ").append(sk).append(" = ").append(useNumberOfTics[k]);
      sb.append(lf);
      sb.append("    ticcolor ").append(sk).append(" = ");
      sb.append(ticColor[k].getRed()).append(",");
      sb.append(ticColor[k].getGreen()).append(",");
      sb.append(ticColor[k].getBlue());
      sb.append(lf);
      sb.append("    ticfont ").append(sk).append(" = \"");
      sb.append(ticFont[k].getName()).append("\",");
      sb.append(ticFont[k].getStyle()).append(",");
      sb.append(ticFont[k].getSize());
      sb.append(lf);
      sb.append("    showgrid ").append(sk).append(" = ").append(grid[k]);
      sb.append(lf);
      sb.append("    legendpos ").append(sk).append(" = ").append(legendPos[k]);
      sb.append(lf);
      sb.append("    multiply ").append(sk).append(" = ").append(multiplier[k]);
      sb.append(lf);
      sb.append("    additioner ").append(sk).append(" = ").append(additioner[k]);
      sb.append(lf);
      sb.append("    datadivide ").append(sk).append(" = ").append(globalDivider[k]);
      sb.append(lf);
      sb.append("    dataoffset ").append(sk).append(" = ").append(globalOffset[k]);
      sb.append(lf);
      sb.append("    ticlength ").append(sk).append(" = ").append(ticLength[k]);
      sb.append(lf);
    }
    sb.append(lf);
    sb.append("    panelsize = ").append(getPanelWidth()).append(",");
    sb.append(getPanelHeight());
    sb.append(lf);
    sb.append("    bgcolor = ").append(backgroundColor.getRed()).append(",");
    sb.append(backgroundColor.getGreen()).append(",").append(backgroundColor.getBlue());
    sb.append(lf);
    sb.append("    axescolor = ").append(axesColor.getRed()).append(",");
    sb.append(axesColor.getGreen()).append(",").append(axesColor.getBlue());
    sb.append(lf);
    sb.append("    uselegendpos = ").append(useLegendPosition);
    sb.append(lf);
    sb.append("    legendspacing = ").append(legendSpacing);
    sb.append(lf);
    sb.append("    showlegend = ").append(useLegend);
    sb.append(lf);
    sb.append("    legendfont ").append(" = \"");
    sb.append(legendFont.getName()).append("\",");
    sb.append(legendFont.getStyle()).append(",");
    sb.append(legendFont.getSize());
    sb.append(lf);
    sb.append("    axesratio = ").append(axesRatio);
    sb.append(lf);
    sb.append("    useratio = ").append(useRatio);
    sb.append(lf);
    sb.append("    gridcolor = ").append(gridColor.getRed()).append(",");
    sb.append(gridColor.getGreen()).append(",").append(gridColor.getBlue());
    sb.append(lf);
    sb.append("    gridtofront = ").append(toFront);
    sb.append(lf);
    sb.append("    graphtype = ").append(graphType);
    sb.append(lf);
    sb.append("    plotboundingbox = ").append(plotBox);
    sb.append(lf);
    sb.append("    offset = ").append(boxOffset);
    sb.append(lf);
    sb.append("    boundingboxbgcolor = ");
    sb.append(boxFillColor.getRed()).append(",");
    sb.append(boxFillColor.getGreen()).append(",");
    sb.append(boxFillColor.getBlue());
    sb.append(lf);
    sb.append("    boundingboxcolor = ");
    sb.append(boxColor.getRed()).append(",");
    sb.append(boxColor.getGreen()).append(",");
    sb.append(boxColor.getBlue());
    sb.append(lf);
    sb.append("    graphbgcolor = ");
    sb.append(graphBgColor.getRed()).append(",");
    sb.append(graphBgColor.getGreen()).append(",");
    sb.append(graphBgColor.getBlue());
    if (graphType == GRAPHTYPE_PIPER) {
      sb.append(lf);
      sb.append("    innertriangle = ");
      sb.append(triangleFillColor.getRed()).append(",");
      sb.append(triangleFillColor.getGreen()).append(",");
      sb.append(triangleFillColor.getBlue()).append(plotInner);
      sb.append(lf).append("    tdsfactor = ").append(tdsFac);
      sb.append(lf).append("    drawtds = ").append(useTds);
    }
    for (Enumeration e=labels.elements(); e.hasMoreElements();) {
      GraphLabel gl = (GraphLabel) e.nextElement();
      if (!gl.equals(GraphLabel.DATA)) sb.append(gl.getSettings());
    }
    sb.append(lf).append("  }");
    return sb.toString();
  }

  /*
   * Parses stuff like 'max-value 1 = <double-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private void parseDouble(StringTokenizer st, double[] a) {
    int axis = Integer.parseInt(st.nextToken());
    if (axis >= NAXES) return;
    st.nextToken();    // eat '='
    a[axis] = Double.parseDouble(st.nextToken());
  }

  /*
   * Parses stuff like 'max-value 1 = <float-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private void parseFloat(StringTokenizer st, float[] a) {
    int axis = Integer.parseInt(st.nextToken());
    if (axis >= NAXES) return;
    st.nextToken();    // eat '='
    a[axis] = Float.parseFloat(st.nextToken());
  }

  /*
   * Parses stuff like 'isLog 1 = <boolean-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private void parseBoolean(StringTokenizer st, boolean[] a) {
    int axis = Integer.parseInt(st.nextToken());
    if (axis >= NAXES) return;
    st.nextToken();    // eat '='
    a[axis] = Boolean.valueOf(st.nextToken()).booleanValue();
  }

  /*
   * Parses stuff like 'numoftics 0 = <integer-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private void parseInteger(StringTokenizer st, int[] a) {
    int axis = Integer.parseInt(st.nextToken());
    if (axis >= NAXES) return;
    st.nextToken();    // eat '='
    a[axis] = Integer.parseInt(st.nextToken());
  }

  /*
   * Parses a string for an axis
   * @param st stringtokenizer instance with the tokens
   */
  private void parseString(StringTokenizer st, String[] a) {
    int axis = Integer.parseInt(st.nextToken());
    if (axis >= NAXES) return;
    st.nextToken();    // eat '='
    String n = st.nextToken();
    if (n.startsWith("\"")) {  // is name between " and "
      while (!n.endsWith("\"")) n += " " + st.nextToken();
      n = n.substring(1,n.length()-1);
    }
    a[axis] = n;
  }

  /*
   * Parses a color for an axis
   * @param st stringtokenizer instance with the tokens
   */
  private void parseColor(StringTokenizer st, Color[] a) {
    int axis = Integer.parseInt(st.nextToken());
    if (axis >= NAXES) return;
    st.nextToken();    // eat '='
    a[axis] = new Color(Integer.parseInt(st.nextToken()),
      Integer.parseInt(st.nextToken()),
      Integer.parseInt(st.nextToken()));
  }

  /*
   * Parses a font for an axis
   * @param st stringtokenizer instance with the tokens
   */
  private void parseFont(StringTokenizer st, Font[] a) {
    int axis = Integer.parseInt(st.nextToken());
    if (axis >= NAXES) return;
    st.nextToken();    // eat '='
    String n = st.nextToken();
    if (n.startsWith("\"")) {  // is name between " and "
      while (!n.endsWith("\"")) n += " " + st.nextToken();
      n = n.substring(1,n.length()-1);
    }
    a[axis] = new Font(n,Integer.parseInt(st.nextToken()),
           Integer.parseInt(st.nextToken()));
  }

  /*
   * Parses stuff like 'showTitle = <boolean-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private boolean getBoolean(StringTokenizer st) {
    st.nextToken();    // eat '='
    return Boolean.valueOf(st.nextToken()).booleanValue();
  }
  
  /*
   * Parses stuff like 'title = <string>'
   * @param st stringtokenizer instance with the tokens
   */
  private String getString(StringTokenizer st) {
    st.nextToken();    // eat '='
    String n = st.nextToken();
    if (n.startsWith("\"")) {  // is name between " and "
      while (!n.endsWith("\"")) n += " " + st.nextToken();
      n = n.substring(1,n.length()-1);
    }
    return n;
  }
  
  /*
   * Parses stuff like 'axesratio = <double-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private double getDouble(StringTokenizer st) {
    st.nextToken();    // eat '='
    return Double.parseDouble(st.nextToken());
  }

  /*
   * Parses stuff like 'keyword = <float-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private float getFloat(StringTokenizer st) {
    st.nextToken();    // eat '='
    return Float.parseFloat(st.nextToken());
  }

  /*
   * Parses stuff like 'keyword = <int-value>'
   * @param st stringtokenizer instance with the tokens
   */
  private int getInteger(StringTokenizer st) {
    st.nextToken();    // eat '='
    return Integer.parseInt(st.nextToken());
  }

  /*
   * Parses stuff like 'panelSize = <width>,<height>'
   * @param st stringtokenizer instance with the tokens
   */
  private Dimension getDimension(StringTokenizer st) {
    st.nextToken();    // eat '='
    return new Dimension(Integer.parseInt(st.nextToken()),
       Integer.parseInt(st.nextToken()));
  }

  /*
   * Parses a font for an axis
   * @param st stringtokenizer instance with the tokens
   */
  private Font getFont(StringTokenizer st) {
    st.nextToken();    // eat '='
    String n = st.nextToken();
    if (n.startsWith("\"")) {  // is name between " and "
      while (!n.endsWith("\"")) n += " " + st.nextToken();
      n = n.substring(1,n.length()-1);
    }
    return new Font(n,Integer.parseInt(st.nextToken()),
        Integer.parseInt(st.nextToken()));
  }

  /*
   * Parses a color for an axis
   * @param st stringtokenizer instance with the tokens
   */
  private Color getColor(StringTokenizer st) {
    st.nextToken();    // eat '='
    return new Color(Integer.parseInt(st.nextToken()),
         Integer.parseInt(st.nextToken()),
         Integer.parseInt(st.nextToken()));
  }

  /*
   * Parses stuff which contains all label parameters.
   * @param st stringtokenizer inst