* A general plotting class that uses data from a {@link CategoryDataset} and

* renders each data item using a {@link CategoryItemRenderer}.

*/

    RendererChangeListener, Cloneable, PublicCloneable, Serializable {

  /** For serialization. */

  private static final long serialVersionUID = -3537691700434728188L;

  public static String COLOR_GRIDLINE_PAINT = "CategoryPlot.defaultGridLineColor";

  public static String FONT_VALUE_LABEL = "CategoryPlot.defaultValueLabelFont";

  /** A stroke style used to draw range gridlines. */

  public static final String STROKE_RANGE_GRIDLINE = "CategoryPlot.rangeGridlineStroke"; //$NON-NLS-1$

  /**

   * The default visibility of the grid lines plotted against the domain axis.

   */

  public static final boolean DEFAULT_DOMAIN_GRIDLINES_VISIBLE = false;

  /**

   * The default visibility of the grid lines plotted against the range axis.

   */

  public static final boolean DEFAULT_RANGE_GRIDLINES_VISIBLE = true;

  /** The default grid line stroke. */

  public static final Stroke DEFAULT_GRIDLINE_STROKE = new Stroke(1,

      SWT.CAP_FLAT, SWT.JOIN_BEVEL);

  /** The default grid line paint. */

  // public static final Color DEFAULT_GRIDLINE_PAINT = Color.lightGray;

  /** The plot orientation. */

  private PlotOrientation orientation;

  /** The offset between the data area and the axes. */

  private RectangleInsets axisOffset;

  /** Storage for the domain axes. */

  private final ObjectList domainAxes;

  /** Storage for the domain axis locations. */

  private final ObjectList domainAxisLocations;

  /**

   * A flag that controls whether or not the shared domain axis is drawn (only

   * relevant when the plot is being used as a subplot).

   */

  private boolean drawSharedDomainAxis;

  /** Storage for the range axes. */

  private final ObjectList rangeAxes;

  /** Storage for the range axis locations. */

  private final ObjectList rangeAxisLocations;

  /** Storage for the datasets. */

  private final ObjectList datasets;

  /** Storage for keys that map datasets to domain axes. */

  private final ObjectList datasetToDomainAxisMap;

  /** Storage for keys that map datasets to range axes. */

  private final ObjectList datasetToRangeAxisMap;

  /** Storage for the renderers. */

  private final ObjectList renderers;

  /** The dataset rendering order. */

  private DatasetRenderingOrder renderingOrder = DatasetRenderingOrder.REVERSE;

  /**

   * Controls the order in which the columns are traversed when rendering the

   * data items.

   */

  private SortOrder columnRenderingOrder = SortOrder.ASCENDING;

  /**

   * Controls the order in which the rows are traversed when rendering the

   * data items.

   */

  private SortOrder rowRenderingOrder = SortOrder.ASCENDING;

  /**

   * A flag that controls whether the grid-lines for the domain axis are

   * visible.

   */

  private boolean domainGridlinesVisible;

  /** The position of the domain gridlines relative to the category. */

  private CategoryAnchor domainGridlinePosition;

  /** The stroke used to draw the domain grid-lines. */

  private transient Stroke domainGridlineStroke;

  /** The paint used to draw the domain grid-lines. */

  private transient Color domainGridlinePaint;

  /**

   * A flag that controls whether the grid-lines for the range axis are

   * visible.

   */

  private boolean rangeGridlinesVisible;

  /** The stroke used to draw the range axis grid-lines. */

  private transient Stroke rangeGridlineStroke;

  /** The paint used to draw the range axis grid-lines. */

  private transient Color rangeGridlinePaint;

  /** The anchor value. */

  private double anchorValue;

  /** A flag that controls whether or not a range crosshair is drawn.. */

  private boolean rangeCrosshairVisible;

  /** The range crosshair value. */

  private double rangeCrosshairValue;

  /** The pen/brush used to draw the crosshair (if any). */

  private transient Stroke rangeCrosshairStroke;

  /** The color used to draw the crosshair (if any). */

  private transient Color rangeCrosshairPaint;

  /**

   * A flag that controls whether or not the crosshair locks onto actual data

   * points.

   */

  private boolean rangeCrosshairLockedOnData = true;

  /** A map containing lists of markers for the domain axes. */

  private final Map foregroundDomainMarkers;

  /** A map containing lists of markers for the domain axes. */

  private final Map backgroundDomainMarkers;

  /** A map containing lists of markers for the range axes. */

  private final Map foregroundRangeMarkers;

  /** A map containing lists of markers for the range axes. */

  private final Map backgroundRangeMarkers;

  /**

   * A (possibly empty) list of annotations for the plot. The list should be

   * initialised in the constructor and never allowed to be <code>null</code>.

   */

  private final List annotations;

  /**

   * The weight for the plot (only relevant when the plot is used as a subplot

   * within a combined plot).

   */

  private int weight;

  /** The fixed space for the domain axis. */

  private AxisSpace fixedDomainAxisSpace;

  /** The fixed space for the range axis. */

  private AxisSpace fixedRangeAxisSpace;

  /**

   * An optional collection of legend items that can be returned by the

   * getLegendItems() method.

   */

  private LegendItemCollection fixedLegendItems;

  /**

   * Default constructor.

   */

  public CategoryPlot() {

    this(null, null, null, null);

  }

  /**

   * Creates a new plot.

   *

   * @param dataset

   *            the dataset (<code>null</code> permitted).

   * @param domainAxis

   *            the domain axis (<code>null</code> permitted).

   * @param rangeAxis

   *            the range axis (<code>null</code> permitted).

   * @param renderer

   *            the item renderer (<code>null</code> permitted).

   *

   */

  public CategoryPlot(final CategoryDataset dataset,

      final CategoryAxis domainAxis, final ValueAxis rangeAxis,

      final CategoryItemRenderer renderer) {

    super();

    this.orientation = PlotOrientation.VERTICAL;

    // allocate storage for dataset, axes and renderers

    this.domainAxes = new ObjectList();

    this.domainAxisLocations = new ObjectList();

    this.rangeAxes = new ObjectList();

    this.rangeAxisLocations = new ObjectList();

    this.datasetToDomainAxisMap = new ObjectList();

    this.datasetToRangeAxisMap = new ObjectList();

    this.renderers = new ObjectList();

    this.datasets = new ObjectList();

    this.datasets.set(0, dataset);

    if (dataset != null) {

      dataset.addChangeListener(this);

    }

    this.axisOffset = RectangleInsets.ZERO_INSETS;

    this.setDomainAxisLocation(AxisLocation.BOTTOM_OR_LEFT, false);

    this.setRangeAxisLocation(AxisLocation.TOP_OR_LEFT, false);

    this.renderers.set(0, renderer);

    if (renderer != null) {

      renderer.setPlot(this);

      renderer.addChangeListener(this);

    }

    this.domainAxes.set(0, domainAxis);

    this.mapDatasetToDomainAxis(0, 0);

    if (domainAxis != null) {

      domainAxis.setPlot(this);

      domainAxis.addChangeListener(this);

    }

    this.drawSharedDomainAxis = false;

    this.rangeAxes.set(0, rangeAxis);

    this.mapDatasetToRangeAxis(0, 0);

    if (rangeAxis != null) {

      rangeAxis.setPlot(this);

      rangeAxis.addChangeListener(this);

    }

    this.configureDomainAxes();

    this.configureRangeAxes();

    this.domainGridlinesVisible = DEFAULT_DOMAIN_GRIDLINES_VISIBLE;

    this.domainGridlinePosition = CategoryAnchor.MIDDLE;

    this.domainGridlineStroke = DEFAULT_GRIDLINE_STROKE;

    this.rangeGridlinesVisible = DEFAULT_RANGE_GRIDLINES_VISIBLE;

    this.rangeGridlineStroke = DEFAULT_GRIDLINE_STROKE;

    this.foregroundDomainMarkers = new HashMap();

    this.backgroundDomainMarkers = new HashMap();

    this.foregroundRangeMarkers = new HashMap();

    this.backgroundRangeMarkers = new HashMap();

    // TODO : SIMPLIFICATION was done.

    // Marker baseline = new ValueMarker(0.0, new Color(0.8f, 0.8f, 0.8f,

    // 0.5f), new BasicStroke(1.0f), new Color(0.85f, 0.85f, 0.95f,

    // 0.5f), new BasicStroke(1.0f), 0.6f);

    // Marker baseline = new ValueMarker();

    // addRangeMarker(baseline, Layer.BACKGROUND);

    this.anchorValue = 0.0;

    this.annotations = new java.util.ArrayList();

  }

  /**

   * Adds an annotation to the plot and sends a {@link PlotChangeEvent} to all

   * registered listeners.

   *

   * @param annotation

   *            the annotation (<code>null</code> not permitted).

   */

  public void addAnnotation(final CategoryAnnotation annotation) {

    if (annotation == null) {

      throw new IllegalArgumentException("Null 'annotation' argument.");

    }

    this.annotations.add(annotation);

    this.notifyListeners(new PlotChangeEvent(this));

  }

  /**

   * Adds a marker for display (in the foreground) against the domain axis and

   * sends a {@link PlotChangeEvent} to all registered listeners. Typically a

   * marker will be drawn by the renderer as a line perpendicular to the

   * domain axis, however this is entirely up to the renderer.

   *

   * @param marker

   *            the marker (<code>null</code> not permitted).

   */

  public void addDomainMarker(final CategoryMarker marker) {

    this.addDomainMarker(marker, Layer.FOREGROUND);

  }

  /**

   * Adds a marker for display against the domain axis and sends a

   * {@link PlotChangeEvent} to all registered listeners. Typically a marker

   * will be drawn by the renderer as a line perpendicular to the domain axis,

   * however this is entirely up to the renderer.

   *

   * @param marker

   *            the marker (<code>null</code> not permitted).

   * @param layer

   *            the layer (foreground or background) (<code>null</code> not

   *            permitted).

   */

  public void addDomainMarker(final CategoryMarker marker, final Layer layer) {

    this.addDomainMarker(0, marker, layer);

  }

  /**

   * Adds a marker for display by a particular renderer.

   * <P>

   * Typically a marker will be drawn by the renderer as a line perpendicular

   * to a domain axis, however this is entirely up to the renderer.

   *

   * @param index

   *            the renderer index.

   * @param marker

   *            the marker (<code>null</code> not permitted).

   * @param layer

   *            the layer (<code>null</code> not permitted).

   */

  public void addDomainMarker(final int index, final CategoryMarker marker,

      final Layer layer) {

    if (marker == null) {

      throw new IllegalArgumentException("Null 'marker' not permitted.");

    }

    if (layer == null) {

      throw new IllegalArgumentException("Null 'layer' not permitted.");

    }

    Collection markers;

    if (layer == Layer.FOREGROUND) {

      markers = (Collection) this.foregroundDomainMarkers

          .get(new Integer(index));

      if (markers == null) {

        markers = new java.util.ArrayList();

        this.foregroundDomainMarkers.put(new Integer(index), markers);

      }

      markers.add(marker);

    } else if (layer == Layer.BACKGROUND) {

      markers = (Collection) this.backgroundDomainMarkers

          .get(new Integer(index));

      if (markers == null) {

        markers = new java.util.ArrayList();

        this.backgroundDomainMarkers.put(new Integer(index), markers);

      }

      markers.add(marker);

    }

    marker.addChangeListener(this);

    this.notifyListeners(new PlotChangeEvent(this));

  }

  /**

   * Adds a marker for display by a particular renderer.

   * <P>

   * Typically a marker will be drawn by the renderer as a line perpendicular

   * to a range axis, however this is entirely up to the renderer.

   *

   * @param index

   *            the renderer index.

   * @param marker

   *            the marker.

   * @param layer

   *            the layer.

   */

  public void addRangeMarker(final int index, final Marker marker,

      final Layer layer) {

    Collection markers;

    if (layer == Layer.FOREGROUND) {

      markers = (Collection) this.foregroundRangeMarkers.get(new Integer(

          index));

      if (markers == null) {

        markers = new java.util.ArrayList();

        this.foregroundRangeMarkers.put(new Integer(index), markers);

      }

      markers.add(marker);

    } else if (layer == Layer.BACKGROUND) {

      markers = (Collection) this.backgroundRangeMarkers.get(new Integer(

          index));

      if (markers == null) {

        markers = new java.util.ArrayList();

        this.backgroundRangeMarkers.put(new Integer(index), markers);