/*
 *  $Source: $
 *  $Name:  $
 *  $Revision: $
 *  $Date: $
 *  $Locker:  $
 */
/*
 *  CategorizedStackedBarChart -- A class to create a categorized stacked bar chart.
 *
 *  Written by Tom Gutwin - WebARTS Design.
 *  Copyright (C) 2007-2010 WebARTS Design, North Vancouver Canada
 *  http://www..webarts.bc.ca
 *
 *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package ca.bc.webarts.tools;

import java.awt.*;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.geom.Rectangle2D;
import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.BufferedOutputStream;
import java.io.OutputStreamWriter;
import java.awt.Rectangle;
import java.util.Vector;
import java.io.Writer;

import javax.swing.JPanel;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.LegendItem;
import org.jfree.chart.LegendItemCollection;
import org.jfree.chart.axis.SubCategoryAxis;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.Plot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.CategoryMarker;
import org.jfree.chart.plot.IntervalMarker;
import org.jfree.chart.labels.*;
import org.jfree.chart.renderer.category.GroupedStackedBarRenderer;
//import org.jfree.data.io.CSV;
import org.jfree.data.KeyToGroupMap;
import org.jfree.data.category.CategoryDataset;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.chart.renderer.category.BarRenderer;
import org.jfree.ui.ApplicationFrame;
import org.jfree.ui.GradientPaintTransformType;
import org.jfree.ui.RefineryUtilities;
import org.jfree.ui.StandardGradientPaintTransformer;
import org.jfree.ui.TextAnchor;

import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
//import com.itextpdf.text.Font;
import com.itextpdf.text.FontFactory;
import com.itextpdf.text.Header;
//import com.itextpdf.text.Rectangle;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.DefaultFontMapper;
import com.itextpdf.text.pdf.FontMapper;
import com.itextpdf.text.pdf.PdfContentByte;
import com.itextpdf.text.pdf.PdfTemplate;
import com.itextpdf.text.pdf.PdfWriter;


import au.com.bytecode.opencsv.CSVReader;
//import au.com.bytecode.opencsv.CSVWriter;
import jxl.*;


import ca.bc.webarts.widgets.Util;

/**
 *  A class that reads a csv file of data and creates a bar chart - Categoirzed, grouped Stacked Bars.
 * It also saves the rendered chart as a png and svg file so you can use it elsewhere.<br />
 * <a href="file:///C:/DOCUME~1/tgutwin/Desktop/BCHydroReliabilityAndGrowthSpend.svg">
 *   <img src="file:///C:/DOCUME~1/tgutwin/Desktop/BCHydroReliabilityAndGrowthSpend.png" width="240" height="160"/>
 * </a>
 * <br /><br />
 * The data in the csv has to be in the following format:<br />
 * <pre>
 * // Sample data for a Categorized Bar chart with sub-grouped stacked bars.
 * // the first real line is to define the group titles
 * Fiscal Year,Accounting Category,Project Driver Dollars
 * F2005,SI Sustain,Reliability,12.20
 * F2005,SI Sustain,Vegetation Management,25.5
 * F2005,SI Sustain,Asset Replacement,34
 * F2005,SI Sustain,Wires Maintenance,25.6
 * F2005,Growth,System,8.4
 * F2006,SI Sustain,Reliability,13.40
 * F2006,SI Sustain,Vegetation Management,23.40
 * F2006,SI Sustain,Asset Replacement,33.00
 * F2006,SI Sustain,Wires Maintenance,26.90
 * F2006,Growth,System,21.20
 * F2007,SI Sustain,Reliability,14.51
 * F2007,SI Sustain,Vegetation Management,22.20
 * F2007,SI Sustain,Asset Replacement,38.10
 * F2007,SI Sustain,Wires Maintenance,26.80
 * F2007,Growth,System,31.70
 * F2008,SI Sustain,Reliability,14.51
 * F2008,SI Sustain,Vegetation Management,23.00
 * F2008,SI Sustain,Asset Replacement,38.20
 * F2008,SI Sustain,Wires Maintenance,31.30
 * F2008,Growth,System,52.50
 * </pre>
 * Tom Gutwin
 */
public class CategorizedStackedBarChart extends ApplicationFrame
{
  public static final short FILETYPE_UNKNOWN=0;
  public static final short FILETYPE_XLS=1;
  public static final short FILETYPE_CSV=2;
  public static final short FILETYPE_SQL=3;

  private String categoryName = "Category";
  private Vector categories = new Vector();
  private String groupName = "Group";
  private Vector groups = new Vector();
  private String stackedDataName = "StackedData";
  private Vector stackedGroup = new Vector();
  private GroupedStackedBarRenderer groupedstackedbarrenderer
         = new GroupedStackedBarRenderer();
  private KeyToGroupMap keytogroupmap_ = new KeyToGroupMap();
  private  JFreeChart jfreechart_ = null;
  private int chartdX = 1200;
  private int chartdY = 800;
  /* The class value for the percent of category space to use for a margin around the category.
     It is a decimal  double value representing the percentage to use (for example, 0.05 is five percent).*/
  private double categoryMargin_ = 0.25;

  private String chartTitle = "Categorized Stacked Bar Chart";
  public Color[] chartColours = new Color[20];
  public GradientPaint[] gradientpaint =  new GradientPaint[chartColours.length];
  public Color chartBackgroundFromColor = new Color(200,205,255);
  public Color chartBackgroundToColor = new Color(160,240,255);
  public Font itemLabelFont = new Font("SansSerif",Font.PLAIN,7);
  private boolean showLabels = true;
  private boolean showToolTips = true;

  /**
   *  Constructor for the CategorizedStackedBarChart object. This constructor
   * does not do anything exept instantiate so some of the methods can be used.
   *
   */
  public CategorizedStackedBarChart()
  {
    super("");
  }


  /**
   *  Constructor for the CategorizedStackedBarChart object. This constructor
   * does not do anything exept instantiate so some of the methods can be used.
   *
   */
  public CategorizedStackedBarChart(String chartTitle)
  {
    super(chartTitle);
    this.chartTitle = chartTitle;
    //init colours
    initColours();
  }


  /**
   *  Constructor for the CategorizedStackedBarChart object
   *
   * @param  chartTitle  is the title to place at the top of the chart, it also uses this for the exported filenames
   * @param csvFilename is the name of the csv file to read the data from
   */
  public CategorizedStackedBarChart(String chartTitle, String filename)
  {
    super(chartTitle);
    this.chartTitle = chartTitle;
    //init colours
    initColours();

    JPanel jpanel = null;

    switch (getFileType(filename))
    {
      case FILETYPE_XLS:
        jpanel = createChartPanel(createDatasetFromXLS(filename));
        break;

      case FILETYPE_CSV:
        jpanel = createChartPanel(createDatasetFromCSVFile(filename));
        break;

      case FILETYPE_SQL:
        jpanel = createChartPanel(createDatasetFromSQL(filename));
        break;

      default:

    }

    if (jpanel!=null)
    {
      jpanel.setPreferredSize(new Dimension(chartdX, chartdY));
      setContentPane(jpanel);
    }
  }


  public static short getFileType(String filename)
  {
    short retVal = FILETYPE_UNKNOWN;
    if (filename.length() >=3)
    {
      String ext = filename.substring(filename.length()-3).toLowerCase();
      //System.out.println("Input file is type:"+ext);
      if (ext.equals("xls")) { retVal = FILETYPE_XLS;}
      else if (ext.equals("sql")) {retVal = FILETYPE_SQL;}
      else if (ext.equals("csv")) { retVal = FILETYPE_CSV;}
    }
    return retVal;
  }


  private void initColours()
  {
    chartColours[0] = new Color(34, 34, 255);
    chartColours[1] = new Color(34, 255, 34);
    chartColours[2] = new Color(255, 34, 34);
    chartColours[3] = new Color(255, 255, 34);
    chartColours[4] = new Color(255, 100, 34);
    chartColours[5] = new Color(0, 100, 150);
    chartColours[6] = new Color(235, 235, 235);
    chartColours[7] = new Color(255, 10, 255);
    chartColours[8] = new Color(100, 40, 100);
    chartColours[9] = new Color(70, 255, 255);
    chartColours[10] = new Color(155, 10, 255);
    chartColours[11] = new Color(25, 125, 0);
    chartColours[12] = new Color(255, 34, 134);
    chartColours[13] = new Color(180, 180, 255);
    chartColours[14] = new Color(180, 60, 0);
    chartColours[15] = new Color(134, 150, 150);
    chartColours[16] = new Color(225, 225, 225);
    chartColours[17] = new Color(0, 255, 255);
    chartColours[18] = new Color(140, 140, 140);
    chartColours[19] = new Color(50, 50, 50);
    for (int i=0; i<chartColours.length && chartColours[i] != null; i++)
      gradientpaint[i] = new GradientPaint(0.0F, 0.0F, chartColours[i],
                              0.0F, 0.0F, chartColours[i].darker().darker().darker());
  }


  /**
   *  The main program for the CategorizedStackedBarChart class
   *
   * @param  args  The command line arguments (1st is the csvFilename, the rest make up a Chart Title)
   */
  public static void main(String[] args)
  {
    if (args.length >0 && getFileType(args[0])!=FILETYPE_UNKNOWN)
    {
      CategorizedStackedBarChart chart = null;
      String titleParms = "Categorized Stacked Bar Chart";
      if (args.length >1 )
      {
        titleParms = "";
        for (int i=1; i < args.length; i++)
          titleParms += args[i] + " ";
        titleParms = titleParms.trim();
      }
      chart = new CategorizedStackedBarChart(titleParms, args[0]);
      chart.pack();
      RefineryUtilities.centerFrameOnScreen(chart);
      chart.setVisible(true);
      chart.saveChartToSvg(new File(Util.spacesToCapsInString(titleParms)+".svg"));
      chart.saveChartToPng(new File(Util.spacesToCapsInString(titleParms)+".png"));
      chart.saveChartToPdf(new File(Util.spacesToCapsInString(titleParms)+".pdf"));
    }
    else
    {
      System.out.println("Don't be a dufus... give me a csv, sqlFilename or xls filename to use.");
    }
  }


  public JFreeChart getChart() { return jfreechart_;}


  /**
   *  Description of the Method
   *
   * @return    Description of the Return Value
   */
  public JPanel createChartPanel(CategoryDataset ds)
  {
    jfreechart_ = createCategoryStackedBarChart(ds);
    return new ChartPanel(jfreechart_);
  }


  /**
   *  Queries a db and converts the results into a Dataset that can be used in
   *  a Grouped Stacked Bar Chart.
   *
   * @return    The SQL results as a CategoryDataset
   */
  private CategoryDataset createDatasetFromSQL(String sqlFilename)
  {
    DefaultCategoryDataset cd = new DefaultCategoryDataset();

    try
    {
    }
    catch( Exception ex)
    {
    }
    return cd;
  }


  /**
   *  takes an xls file in the proper format into a Dataset useable by the charter.
   *
   * @return    Description of the Return Value
   */
  public CategoryDataset createDatasetFromXLS(String xlsFilename)
  {
    DefaultCategoryDataset cd = new DefaultCategoryDataset();

    /*  These are to read data from an excel data file */
    Workbook workbook = null;
    Sheet configSheet = null;
    Sheet dataSheet = null;

    try
    {
      /* Get the Excel Config file init */
      System.out.println("Opening Excel Workbook:"+xlsFilename );
      File f = new File(xlsFilename);
      if (f.exists() && f.canRead())
      {
        workbook = Workbook.getWorkbook(f);
        dataSheet = workbook.getSheet(0);  // keep the data on the 1st sheet
        String categoryName = "";
        String groupName = "";
        String stackName = "";
        double value = 0.0;
        boolean done = false;
        boolean nextGroup = false;
        String cellStr = "";
        int valCol = 3;
        keytogroupmap_ = null;

        for (int row = 3; !done; row++)
        {
          nextGroup = false;
          System.out.print((row-2)+") ");
          try
          {
            // getCell is (Column, row)
            cellStr = dataSheet.getCell(0,row+1).getContents().trim();
            if (cellStr !=null && !cellStr.equals("")) nextGroup = true; //this is a total row so skip it
            cellStr = dataSheet.getCell(0,row).getContents().trim();
            if (cellStr !=null && !cellStr.equals("")) categoryName = cellStr;
            //System.out.print(" (cellStr="+cellStr+") ");
            System.out.print(categoryName+", ");
            cellStr = dataSheet.getCell(1,row+1).getContents().trim();
            if (cellStr !=null && !cellStr.equals("")) nextGroup = true; //this is a total row so skip it
            cellStr = dataSheet.getCell(1,row).getContents().trim();
            if (cellStr !=null && !cellStr.equals("")) groupName = cellStr;
            //System.out.print(" (cellStr="+cellStr+") ");
            System.out.print(groupName+", ");
            cellStr = dataSheet.getCell(2,row).getContents().trim();
            if (cellStr !=null && !cellStr.equals("")) stackName = cellStr;
            //System.out.print(" (cellStr="+cellStr+") ");
            System.out.print(stackName+", ");


            if (!nextGroup)
            {
              // Find the last value column
              valCol = 3;
              try
              {
                while (dataSheet.getCell(valCol+1,row)!=null &&
                        dataSheet.getCell(valCol+1,row).getContents()!=null &&
                        !dataSheet.getCell(valCol+1,row).getContents().trim().equals(""))
                  valCol++;
              }
              catch (java.lang.ArrayIndexOutOfBoundsException vEx)
              {

              }
              value = ((NumberCell)dataSheet.getCell(valCol,row)).getValue();
              System.out.print(value);

              if (keytogroupmap_ == null) keytogroupmap_ = new KeyToGroupMap(groupName);
              if (!categories.contains(categoryName)) categories.add(categoryName);
              if (!groups.contains(groupName)) groups.add(groupName);
              if (!stackedGroup.contains(stackName)) stackedGroup.add(stackName);
              cd.addValue(value, stackName + " ("+groupName+")", categoryName);
              keytogroupmap_.mapKeyToGroup(stackName + " ("+groupName+")", groupName);

              try
              {
              if (dataSheet.getCell(valCol,row+1) == null ||
                  dataSheet.getCell(valCol,row+1).getContents() == null ||
                  dataSheet.getCell(valCol,row+1).getContents().equals("NA") ||
                  dataSheet.getCell(valCol,row+1).getContents().equals("") )
                done = true;
              }
              catch (java.lang.ArrayIndexOutOfBoundsException vEx)
              {
                System.out.println("\nWe Seem to be done at Row:"+row+" Col:"+valCol);
                done = true;
              }
            }
            System.out.println();
          }
          catch (java.lang.ArrayIndexOutOfBoundsException vEx)
          {
            nextGroup = true; done = true;
          }

        }
        groupedstackedbarrenderer.setSeriesToGroupMap(keytogroupmap_);
      }
      else
        System.out.println("What The F%#@, Cannot Read File "+xlsFilename);
    }
    catch (FileNotFoundException fnfEx)
    {
      System.out.println("File Not Found "+xlsFilename);
      fnfEx.printStackTrace();
    }
    catch (IOException ioEx)
    {
     System.out.println("Could Not read input EXCEL File: "+xlsFilename);
     ioEx.printStackTrace();
    }
    catch (jxl.read.biff.BiffException biffEx)
    {
     System.out.println("Could Not read input EXCEL File: "+xlsFilename);
     biffEx.printStackTrace();
    }
    catch( Exception ex)
    {
     ex.printStackTrace();
    }
    return cd;
  }


  /**
   *  Description of the Method
   *
   * @return    Description of the Return Value
   */
  public CategoryDataset createDatasetFromCSVFile(String csvFilename)
  {
    DefaultCategoryDataset cd = new DefaultCategoryDataset();

    try
    {
      CSVReader reader = new CSVReader(new FileReader(csvFilename));
      String [] nextLine;
      int rows = 0;
      while ((nextLine = reader.readNext()) != null)
      {
        if (nextLine.length>1 && !nextLine[0].startsWith("//"))
        {
          if (rows==1) //this is to setup an initial group
          {
            keytogroupmap_ = new KeyToGroupMap(nextLine[1]);
          }
          if (rows==0)
          {
            categoryName = nextLine[0];
            groupName = nextLine[1];
            stackedDataName = nextLine[2];
          }
          else
          {
            // nextLine[] is an array of values from the line
            System.out.print(rows+") ");
            for (int i=0;i< nextLine.length; i++){System.out.print(nextLine[i]+", ");}
            System.out.println("");

            if (!categories.contains(nextLine[0])) categories.add(nextLine[0]);
            if (!groups.contains(nextLine[1])) groups.add(nextLine[1]);
            if (!stackedGroup.contains(nextLine[2])) stackedGroup.add(nextLine[2]);
            // add to dataset              Value       , Group      , Category
            cd.addValue(Double.parseDouble(nextLine[3]), nextLine[2] + " ("+nextLine[1]+")", nextLine[0]);
            //cd.addValue(Double.parseDouble(nextLine[3]), nextLine[2], nextLine[0]);
            // Assigns which data gets into which categorygroup.
            // One group represents One Stack on the barchart
            //stackedGroup.add(nextLine[2]);
            keytogroupmap_.mapKeyToGroup(nextLine[2] + " ("+nextLine[1]+")", nextLine[1]);
            //keytogroupmap_.mapKeyToGroup(nextLine[2], nextLine[1]);
          }
          rows++;
        }
      }
      groupedstackedbarrenderer.setSeriesToGroupMap(keytogroupmap_);
    }
    catch (FileNotFoundException fnfEx)
    {
      System.out.println("File Not Found "+csvFilename);
      fnfEx.printStackTrace();
    }
    catch (IOException ioEx)
    {
      System.out.println("Cannot read from CSV file "+csvFilename);
      ioEx.printStackTrace();
    }

    return cd;
  }


   /**
   *  Create the dataset from delimited String.
   *
   * @return    Description of the Return Value
   */
  public CategoryDataset createDatasetFromCSV(String csv)
  {
    DefaultCategoryDataset cd = new DefaultCategoryDataset();

    try
    {
      CSVReader reader = new CSVReader(new java.io.StringReader(csv));
      String [] nextLine;
      int rows = 0;
      while ((nextLine = reader.readNext()) != null)
      {
        if (nextLine.length>1 && !nextLine[0].startsWith("//"))
        {
          if (rows==1) //this is to setup an initial group
          {
            keytogroupmap_ = new KeyToGroupMap(nextLine[1]);
          }
          if (rows==0)
          {
            categoryName = nextLine[0];
            groupName = nextLine[1];
            stackedDataName = nextLine[2];
          }
          else
          {
            // nextLine[] is an array of values from the line
            System.out.print(rows+") ");
            for (int i=0;i< nextLine.length; i++){System.out.print(nextLine[i]+", ");}
            System.out.println("");

            if (!categories.contains(nextLine[0])) categories.add(nextLine[0]);
            if (!groups.contains(nextLine[1])) groups.add(nextLine[1]);
            if (!stackedGroup.contains(nextLine[2])) stackedGroup.add(nextLine[2]);
            // add to dataset              Value       , Group      , Category
            cd.addValue(Double.parseDouble(nextLine[3]), nextLine[2] + " ("+nextLine[1]+")", nextLine[0]);
            //cd.addValue(Double.parseDouble(nextLine[3]), nextLine[2], nextLine[0]);
            // Assigns which data gets into which categorygroup.
            // One group represents One Stack on the barchart
            //stackedGroup.add(nextLine[2]);
            keytogroupmap_.mapKeyToGroup(nextLine[2] + " ("+nextLine[1]+")", nextLine[1]);
            //keytogroupmap_.mapKeyToGroup(nextLine[2], nextLine[1]);
          }
          rows++;
        }
      }
      groupedstackedbarrenderer.setSeriesToGroupMap(keytogroupmap_);
    }
    catch (IOException ioEx)
    {
      System.out.println("Cannot read from CSV  "+csv);
      ioEx.printStackTrace();
    }

    return cd;
  }


  /**
   *  This method does all the work for getting the chart plot set up.
   * It sets the labels, axis, colours, margins and whatnot. It uses the class chartTtile.
   *
   * @param  categorydataset  the dataset to use in the chart
   * @return                  The category  grouped stacked bar chart.
   */
  public JFreeChart createCategoryStackedBarChart(CategoryDataset categorydataset)
  {
    return createCategoryStackedBarChart(this.chartTitle, categorydataset);
  }


  /**
   *  This method does all the work for getting the chart plot set up. It sets the labels, axis, colours, margins and whatnot.
   *
   * @param  chartTitle  a new title to put at the top of the chart
   * @param  categorydataset  the dataset to use in the chart
   * @return                  The category  grouped stacked bar chart.
   */
  public JFreeChart createCategoryStackedBarChart(String chartTitle,
                                                CategoryDataset categorydataset)
  {
    return createCategoryStackedBarChart(chartTitle, null, categorydataset);
  }


  /**
   *  This method does all the work for getting the chart plot set up. It sets the labels, axis, colours, margins and whatnot.
   *
   * @param  chartTitle  a new title to put at the top of the chart
   * @param  chartSubTitle  a new subtitle below the title
   * @param  categorydataset  the dataset to use in the chart
   * @return                  The category  grouped stacked bar chart.
   */
  public JFreeChart createCategoryStackedBarChart(String chartTitle, String subTitle,
                                                CategoryDataset categorydataset)
  {
    jfreechart_ = ChartFactory.createStackedBarChart(chartTitle,
                                              categoryName, stackedDataName,
                                              categorydataset,
                                              PlotOrientation.VERTICAL,
                                              true, true, false);

    if (subTitle !=null && !subTitle.equals(""))
    {
      org.jfree.chart.title.TextTitle textSubTitle = new org.jfree.chart.title.TextTitle(subTitle);
      jfreechart_.addSubtitle(textSubTitle);
    }

    CategoryPlot categoryplot = (CategoryPlot) jfreechart_.getPlot();

    // setup axis label
    SubCategoryAxis subcategoryaxis
         = new SubCategoryAxis(groupName+" / "+categoryName);

    // set the margin between the Categories (% of space )
    subcategoryaxis.setCategoryMargin(categoryMargin_);

    // sub categorize the groups
    for (int j=0; j<groups.size(); j++)
    {
      subcategoryaxis.addSubCategory((String)groups.get(j));
      subcategoryaxis.setTickLabelFont((String)groups.get(j), itemLabelFont);
    }

    subcategoryaxis.setMaximumCategoryLabelWidthRatio(1/groups.size());
    subcategoryaxis.setCategoryMargin(0.15);
    subcategoryaxis.setMaximumCategoryLabelLines(3);

    // Set the axis to the subcategorized axis already defined above
    categoryplot.setDomainAxis(subcategoryaxis);

    // Category series labels
    groupedstackedbarrenderer.setItemLabelGenerator(new StandardCategoryItemLabelGenerator());
    groupedstackedbarrenderer.setItemLabelsVisible(showLabels);
    groupedstackedbarrenderer.setItemLabelFont(itemLabelFont);
    //groupedstackedbarrenderer.setItemMargin(0.30);
    ItemLabelPosition p = new ItemLabelPosition(
        ItemLabelAnchor.CENTER, TextAnchor.CENTER, TextAnchor.CENTER, 0.0
    );
    groupedstackedbarrenderer.setPositiveItemLabelPosition(p);
    categoryplot.setRenderer(groupedstackedbarrenderer);

    // Assign the Floatover tooltips
    StandardCategoryToolTipGenerator toolTipGen = new StandardCategoryToolTipGenerator();
    groupedstackedbarrenderer.setToolTipGenerator(toolTipGen);
    //groupedstackedbarrenderer.setDisplayToolTips(showToolTips);

    // Group the entries in the Legend
    categoryplot.setFixedLegendItems(createLegendItems());

    // Assign gradient colours to the bars
    BarRenderer barrenderer = (BarRenderer) categoryplot.getRenderer();
    barrenderer.setDrawBarOutline(false);
    barrenderer.setMaximumBarWidth(0.2);
    // set the margin between the sub-groups with in each category (% of space )
    barrenderer.setItemMargin(0.02);

    // Set up the backFrame colour
    jfreechart_.setBackgroundPaint(new GradientPaint(
                                      0,
                                      0,
                                      chartBackgroundFromColor,
                                      chartdX,
                                      chartdY,
                                      chartBackgroundToColor));

    // Assign the colours to the stacked groups.
    // each stacked group gets its own colour
    for (int j = 0; j < groups.size(); j++)
      for (int i=0; i<stackedGroup.size() && chartColours[i] != null; i++)
        barrenderer.setSeriesPaint((j*stackedGroup.size()) + i, gradientpaint[i]);

    return jfreechart_;
  }


  /** Gets the current jfreechart plot (null if not already initialized). **/
  public CategoryPlot getPlot()
  {
    CategoryPlot categoryplot = null;
    if (jfreechart_ !=null)
    {
      categoryplot = (CategoryPlot) jfreechart_.getPlot();
    }
    return categoryplot;
  }


  /**
   * Adds a marker for the Domain category.
   *
   * @param catMarginPercent  The main category spacing in percent (where 0.10 is ten percent).
   */
  public void setDomainMarker(String categoryKey)
  {
    if (jfreechart_ !=null)
    {
      CategoryPlot categoryplot = this.getPlot();
      if (categoryplot !=null)
      {
        /*
        groupedstackedbarrenderer.getSeriesToGroupMap(keytogroupmap_);
        final CategoryMarker marker = new CategoryMarker(categoryKey);
        marker.setLabel("Projects Year");
        marker.setLabelFont(new Font("SansSerif", Font.ITALIC, 11));
        marker.setLabelAnchor(org.jfree.ui.RectangleAnchor.LEFT);
        marker.setLabelTextAnchor(TextAnchor.CENTER_LEFT);
        marker.setPaint(new Color(222, 222, 255, 128));
        */
      }
    }
  }


  /**
   * Changes the spacing between the categories.
   *
   * @param catMarginPercent  The main category spacing in percent (where 0.10 is ten percent).
   */
  public void setCategoryMargins(double catMarginPercent)
  {
    if (jfreechart_ !=null)
    {
      CategoryPlot categoryplot = this.getPlot();
      if (categoryplot !=null)
      {
        BarRenderer barrenderer = (BarRenderer) categoryplot.getRenderer();
        barrenderer.setItemMargin(catMarginPercent);

        //SubCategoryAxis subcategoryaxis = (SubCategoryAxis) barrenderer.getDomainAxis(categoryplot,0);
        //subcategoryaxis.setCategoryMargin(subCatMarginPercent);
      }
    }
  }


  /**
   * Changes the spacing between the sub categories.
   *
   * @param subCatMarginPercent  The sub-category spacing in percent (where 0.10 is ten percent).
   */
  public void setSubCategoryMargins(double subCatMarginPercent )
  {
    if (jfreechart_ !=null)
    {
      CategoryPlot categoryplot = (CategoryPlot) jfreechart_.getPlot();
      if (categoryplot !=null)
      {
        // setup axis label
        SubCategoryAxis subcategoryaxis
             = new SubCategoryAxis(groupName+" / "+categoryName);

        // set the margin between the Categories (% of space )
        subcategoryaxis.setCategoryMargin(categoryMargin_);

        // sub categorize the groups
        for (int j=0; j<groups.size(); j++)
        {
          subcategoryaxis.addSubCategory((String)groups.get(j));
          subcategoryaxis.setTickLabelFont((String)groups.get(j), itemLabelFont);
        }

        subcategoryaxis.setMaximumCategoryLabelWidthRatio(1/groups.size());
        subcategoryaxis.setCategoryMargin(subCatMarginPercent);
        subcategoryaxis.setMaximumCategoryLabelLines(3);

        // Set the axis to the subcategorized axis already defined above
        categoryplot.setDomainAxis(subcategoryaxis);

      }
    }
  }


  /**
   *  Adds/or changes the subtitle.
   *
   * @param subtitleParm -  The new subtitle
   */
  public void addSubtitle(String subtitleParm )
  {
    if (subtitleParm !=null && !subtitleParm.equals(""))
      {
        org.jfree.chart.title.TextTitle textSubTitle = new org.jfree.chart.title.TextTitle(subtitleParm);
        jfreechart_.addSubtitle(textSubTitle);
      }
  }


  /**
   *  Sets up the words in the grouped legend.
   *
   * @return    Description of the Return Value
   */
  private LegendItemCollection createLegendItems()
  {
    LegendItemCollection legenditemcollection = new LegendItemCollection();
    LegendItem legenditem = null;
    try
    {
      for (int j=0; j<stackedGroup.size(); j++)
      {
        legenditem = new LegendItem((String)stackedGroup.get(j), "-", null, null,
            Plot.DEFAULT_LEGEND_ITEM_BOX,
            chartColours[j]);
        legenditemcollection.add(legenditem);
      }
    }
    catch (Exception ex)
    {
       System.out.println(" Error Setting Legend Colours ");
    }
    return legenditemcollection;
  }


  /** saves the passed chart to a svg file in the current models yearly dir.**/
  public void saveChartToSvg(JFreeChart chart, File svgFile)
  {
    if (svgFile != null)
    try
    {
      // Get a DOMImplementation and create an XML document
      org.w3c.dom.DOMImplementation domImpl =
          org.apache.batik.dom.GenericDOMImplementation.getDOMImplementation();
      org.w3c.dom.Document document = domImpl.createDocument(null, "svg", null);

      // Create an instance of the SVG Generator
      org.apache.batik.svggen.SVGGraphics2D svgGenerator =
          new org.apache.batik.svggen.SVGGraphics2D(document);

      // draw the chart in the SVG generator
      chart.draw(svgGenerator, new java.awt.Rectangle(chartdX, chartdY));

      // Write svg file
      OutputStream outputStream = new FileOutputStream(svgFile);
      Writer out = new OutputStreamWriter(outputStream, "UTF-8");
      svgGenerator.stream(out, true /* use css */);
      outputStream.flush();
      outputStream.close();
    }
    catch (IOException ioEx)
    {
      System.out.println("Error Saving "+svgFile.toString());
    }

  }


  /** saves the passed chart to a svg file in the current models yearly dir.**/
  public void saveChartToSvg(File svgFile)
  {
    saveChartToSvg(jfreechart_, svgFile);
  }


  /**
   * Saves the passed chart to a png file in the specified file.
   * NOTE: This method spawns a seperate thread for this process.
   *
   * @param savedFile is the resulting file to save into
   **/
  public void saveChartToPng(File savedFile)
  {
    if (savedFile != null)
      saveChartToPng( jfreechart_, savedFile);
  }


  /**
   * Saves the passed chart to a png file in the specified file.
   * NOTE: This method spawns a seperate thread for this process.
   *
   * @param chart is the chart to render to a file
   * @param savedFile is the resulting file to save into
   **/
  public void saveChartToPng(JFreeChart chart, File savedFile)
  {
    if (savedFile != null)
    {
      /*
      // Run in separate thread.
      Thread fileSaveThread =
        new Thread()
        {
          public void run()
          {
      */
            try
            {
              ChartUtilities.saveChartAsPNG(savedFile, chart, chartdX, chartdY);
            }
            catch (IOException ioEx)
            {
              System.out.println("Error Saving "+savedFile.toString());
            }
      /*
          }
        };
      fileSaveThread.start();
      */
    }
  }

  /**
   *  Writes a chart to an output stream in PDF format.
   *
   * @param  out              the output stream.
   * @param  chart            the chart.
   * @param  width            the chart width.
   * @param  height           the chart height.
   * @param  title            duh
   * @exception  IOException  Description of the Exception
   */
  public static void exportChartAsPDF(OutputStream out,
                                        JFreeChart chart,
                                        int width,int height, String title)
  {
    exportChartAsPDF(out, chart, width, height, new DefaultFontMapper(),title);
  }


  /**
   *  Writes a chart to an output stream in PDF format.
   *
   * @param  out              the output stream.
   * @param  chart            the chart.
   * @param  width            the chart width.
   * @param  height           the chart height.
   * @exception  IOException  Description of the Exception
   */
  public static void exportChartAsPDF(OutputStream out,
                                        JFreeChart chart, int width,int height)
  {
    exportChartAsPDF(out, chart, width, height, new DefaultFontMapper(),"");
  }


  /**
   *  Writes a chart to an output stream in PDF format.
   *
   * @param  out              the output stream.
   * @param  chart            the chart.
   * @param  width            the chart width.
   * @param  height           the chart height.
   * @param  mapper           Description of the Parameter
   * @exception  IOException  Description of the Exception
   */
  public static void exportChartAsPDF(OutputStream out,
      JFreeChart chart, int width,
      int height,
      FontMapper mapper)
  {
    exportChartAsPDF(out, chart, width, height, mapper,"");
  }


  /**
   *  Writes a chart to an output stream in PDF format.
   *
   *

   * @param  out              the output stream.
   * @param  chart            the chart.
   * @param  width            the chart width.
   * @param  height           the chart height.
   * @param  mapper           Description of the Parameter
   * @param  title            is the title to assign to the pdf
   * @exception  IOException  Description of the Exception
   */
  public static void exportChartAsPDF(final OutputStream out,
      final JFreeChart chart, final int width, final int height,
      final FontMapper mapper,
      final String title)
  {
    if (out != null)
    {
      /*
      // Run in separate thread.
      Thread fileSaveThread =
        new Thread()
        {
          public void run()
          {
      */
            try
            {
              com.itextpdf.text.Rectangle pagesize = new com.itextpdf.text.Rectangle(width, height);
              Document document = new Document(pagesize, 50, 50, 50, 50);
              PdfWriter writer = PdfWriter.getInstance(document, out);
              document.open();

              PdfContentByte cb = writer.getDirectContent();
              PdfTemplate tp = cb.createTemplate(width, height);
              Graphics2D g2 = tp.createGraphics(width, height, mapper);
              Rectangle2D r2D = new Rectangle2D.Double(0, 0, width, height);
              chart.draw(g2, r2D);
              g2.dispose();
              cb.addTemplate(tp, 0, 0);
              document.close();
            }
            catch (DocumentException de)
            {
              System.out.println("Error Saving PDF Stream"+out.toString());
              System.err.println(de.getMessage());
            }
            catch (Exception ioEx)
            {
              System.out.println("Error Saving PDF Stream"+out.toString());
              System.err.println(ioEx.getMessage());
            }
      /*
          } // run
        }; // Thread
      fileSaveThread.start();
      */
    }
  }


  /** saves the passed chart to a pdf file in the current models yearly dir.
   * NOTE: This method spawns a seperate thread for this process.
   *
   **/
  public void saveChartToPdf(File pdfFile)
  {
    saveChartToPdf(jfreechart_, pdfFile);
  }


  /** saves the passed chart to a pdf file in the current models yearly dir.
   * NOTE: This method spawns a seperate thread for this process.
   *
   **/
  public void saveChartToPdf(String fileName)
  {
    File pdfFile = new File(fileName);
    saveChartToPdf(jfreechart_, pdfFile);
  }


  /** saves the passed chart to a pdf file in the current models yearly dir.
   * NOTE: This method spawns a seperate thread for this process.
   *
   **/
  public void saveChartToPdf(JFreeChart chart, String fileName)
  {
    File pdfFile = new File(fileName);
    saveChartToPdf(chart, pdfFile);
  }


  /** saves the passed chart to a pdf file in the current models yearly dir.
   * NOTE: This method spawns a seperate thread for this process.
   *
   **/
  public void saveChartToPdf(JFreeChart chart, File pdfFile)
  {
    //File pdfFile = new File(fileName);

    if (pdfFile != null)
    {
      try
      {
        OutputStream out = new BufferedOutputStream(new FileOutputStream(pdfFile));
        exportChartAsPDF(out, chart, chartdX, chartdY,  new DefaultFontMapper());
        out.close();
      }
      catch (FileNotFoundException fnfEx)
      {
        System.out.println("Error Saving PDF "+pdfFile.getName());
        System.err.println(fnfEx.getMessage());
      }
      catch (IOException ioEx)
      {
        System.out.println("Error Saving PDF "+pdfFile.getName());
        System.err.println(ioEx.getMessage());
      }
    }
  }
}