/*
 * IupPPlot component
 *
 * Description : A component, derived from PPlot and IUP canvas
 *      Remark : Depend on libs IUP, CD, IUPCD
 */


#ifdef _MSC_VER
#pragma warning(disable: 4100)
#pragma warning(disable: 4512)
#endif

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "iup.h"
#include "iupcbs.h"
#include "iup_pplot.h"
#include "iupkey.h"

#include <cd.h>
#include <cdiup.h>
#include <cddbuf.h>
#include <cdirgb.h>
#include <cdgdiplus.h>

#include "iup_class.h"
#include "iup_register.h"
#include "iup_object.h"
#include "iup_attrib.h"
#include "iup_str.h"
#include "iup_drv.h"
#include "iup_stdcontrols.h"
#include "iup_assert.h"

#include "iupPPlot.h"
#include "iupPPlotInteraction.h"
#include "iuppplot.hpp"


#ifndef M_E
#define M_E 2.71828182846
#endif

struct _IcontrolData
{
  iupCanvas canvas;  /* from IupCanvas (must reserve it) */
  PPainterIup* plt;
};


static int iPPlotGetCDFontStyle(const char* value);


/* PPlot function pointer typedefs. */
typedef int (*IFnC)(Ihandle*, cdCanvas*); /* postdraw_cb, predraw_cb */
typedef int (*IFniiff)(Ihandle*, int, int, float, float); /* delete_cb */
typedef int (*IFniiffi)(Ihandle*, int, int, float, float, int); /* select_cb */
typedef int (*IFniiffff)(Ihandle*, int, int, float, float, float*, float*); /* edit_cb */


/* callback: forward redraw request to PPlot object */
static int iPPlotRedraw_CB(Ihandle* ih)
{
  ih->data->plt->Draw(0);  /* full redraw only if nothing changed */
  return IUP_DEFAULT;
}

/* callback: forward resize request to PPlot object */
static int iPPlotResize_CB(Ihandle* ih)
{
  ih->data->plt->Resize();
  return IUP_DEFAULT;
}

/* callback: forward mouse button events to PPlot object */
static int iPPlotMouseButton_CB(Ihandle* ih, int btn, int stat, int x, int y, char* r)
{
  ih->data->plt->MouseButton(btn, stat, x, y, r);
  return IUP_DEFAULT;
}

/* callback: forward mouse button events to PPlot object */
static int iPPlotMouseMove_CB(Ihandle* ih, int x, int y)
{
  ih->data->plt->MouseMove(x, y);
  return IUP_DEFAULT;
}

/* callback: forward keyboard events to PPlot object */
static int iPPlotKeyPress_CB(Ihandle* ih, int c, int press)
{
  ih->data->plt->KeyPress(c, press);
  return IUP_DEFAULT;
} 

/* user level call: add dataset to plot */
void IupPPlotBegin(Ihandle* ih, int strXdata)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return;

  PlotDataBase* inXData = (PlotDataBase*)iupAttribGet(ih, "_IUP_PPLOT_XDATA");
  PlotDataBase* inYData = (PlotDataBase*)iupAttribGet(ih, "_IUP_PPLOT_YDATA");

  if (inXData) delete inXData;
  if (inYData) delete inYData;

  if (strXdata)
    inXData = (PlotDataBase*)(new StringPlotData());
  else
    inXData = (PlotDataBase*)(new PlotData());

  inYData = (PlotDataBase*)new PlotData();

  iupAttribSetStr(ih, "_IUP_PPLOT_XDATA",    (char*)inXData);
  iupAttribSetStr(ih, "_IUP_PPLOT_YDATA",    (char*)inYData);
  iupAttribSetStr(ih, "_IUP_PPLOT_STRXDATA", (char*)(strXdata? "1": "0"));
}

void IupPPlotAdd(Ihandle* ih, float x, float y)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return;

  PlotData* inXData = (PlotData*)iupAttribGet(ih, "_IUP_PPLOT_XDATA");
  PlotData* inYData = (PlotData*)iupAttribGet(ih, "_IUP_PPLOT_YDATA");
  int strXdata = iupAttribGetInt(ih, "_IUP_PPLOT_STRXDATA");

  if (!inYData || !inXData || strXdata)
    return;

  inXData->push_back(x);
  inYData->push_back(y);
}

void IupPPlotAddStr(Ihandle* ih, const char* x, float y)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return;

  StringPlotData *inXData = (StringPlotData*)iupAttribGet(ih, "_IUP_PPLOT_XDATA");
  PlotData   *inYData = (PlotData*)iupAttribGet(ih, "_IUP_PPLOT_YDATA");
  int strXdata = iupAttribGetInt(ih, "_IUP_PPLOT_STRXDATA");

  if (!inYData || !inXData || !strXdata)
    return;

  inXData->AddItem(x);
  inYData->push_back(y);
}

void IupPPlotInsertStr(Ihandle* ih, int inIndex, int inSampleIndex, const char* inX, float inY)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return;

  PlotDataBase* theXDataBase = ih->data->plt->_plot.mPlotDataContainer.GetXData(inIndex);
  PlotDataBase* theYDataBase = ih->data->plt->_plot.mPlotDataContainer.GetYData(inIndex);
  StringPlotData *theXData = (StringPlotData*)theXDataBase;
  PlotData   *theYData = (PlotData*)theYDataBase;
  if (!theYData || !theXData)
    return;

  theXData->InsertItem(inSampleIndex, inX);
  theYData->insert(theYData->begin()+inSampleIndex, inY);
}

void IupPPlotInsert(Ihandle* ih, int inIndex, int inSampleIndex, float inX, float inY)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return;

  PlotDataBase* theXDataBase = ih->data->plt->_plot.mPlotDataContainer.GetXData(inIndex);
  PlotDataBase* theYDataBase = ih->data->plt->_plot.mPlotDataContainer.GetYData(inIndex);
  PlotData* theXData = (PlotData*)theXDataBase;
  PlotData* theYData = (PlotData*)theYDataBase;
  if (!theYData || !theXData)
    return;

  theXData->insert(theXData->begin()+inSampleIndex, inX);
  theYData->insert(theYData->begin()+inSampleIndex, inY);
}

int IupPPlotEnd(Ihandle* ih)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return -1;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return -1;

  PlotDataBase* inXData = (PlotDataBase*)iupAttribGet(ih, "_IUP_PPLOT_XDATA");
  PlotDataBase* inYData = (PlotDataBase*)iupAttribGet(ih, "_IUP_PPLOT_YDATA");
  if (!inYData || !inXData)
    return -1;

  /* add to plot */
  ih->data->plt->_currentDataSetIndex = ih->data->plt->_plot.mPlotDataContainer.AddXYPlot(inXData, inYData);

  LegendData* legend = ih->data->plt->_plot.mPlotDataContainer.GetLegendData(ih->data->plt->_currentDataSetIndex);
  legend->mStyle.mFontStyle = iPPlotGetCDFontStyle(IupGetAttribute(ih, "LEGENDFONTSTYLE"));
  legend->mStyle.mFontSize  = IupGetInt(ih, "LEGENDFONTSIZE");

  iupAttribSetStr(ih, "_IUP_PPLOT_XDATA", NULL);
  iupAttribSetStr(ih, "_IUP_PPLOT_YDATA", NULL);

  ih->data->plt->_redraw = 1;
  return ih->data->plt->_currentDataSetIndex;
}

void IupPPlotTransform(Ihandle* ih, float x, float y, int *ix, int *iy)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return;

  if (ix) *ix = ih->data->plt->_plot.Round(ih->data->plt->_plot.mXTrafo->Transform(x));
  if (iy) *iy = ih->data->plt->_plot.Round(ih->data->plt->_plot.mYTrafo->Transform(y));
}

/* user level call: plot on the given device */
void IupPPlotPaintTo(Ihandle* ih, void* _cnv)
{
  iupASSERT(iupObjectCheck(ih));
  if (!iupObjectCheck(ih))
    return;

  if (ih->iclass->nativetype != IUP_TYPECANVAS || 
      !iupStrEqual(ih->iclass->name, "pplot"))
    return;

  ih->data->plt->DrawTo((cdCanvas *)_cnv);
}

/* --------------------------------------------------------------------
                      class implementation
   -------------------------------------------------------------------- */

PostPainterCallbackIup::PostPainterCallbackIup (PPlot &inPPlot, Ihandle* inHandle):
  _ih(inHandle)
{
  inPPlot.mPostDrawerList.push_back (this);
}

bool PostPainterCallbackIup::Draw(Painter &inPainter)
{
  IFnC cb = (IFnC)IupGetCallback(_ih, "POSTDRAW_CB");

  if (cb)
  {
    PPainterIup* iupPainter = (PPainterIup*)(&inPainter);
    cb(_ih, iupPainter->_cddbuffer);
  }

  return true;
}

PrePainterCallbackIup::PrePainterCallbackIup (PPlot &inPPlot, Ihandle* inHandle):
  _ih(inHandle)
{
  inPPlot.mPreDrawerList.push_back (this);
}

bool PrePainterCallbackIup::Draw(Painter &inPainter)
{
  IFnC cb = (IFnC)IupGetCallback(_ih, "PREDRAW_CB");
  if (cb)
  {
    PPainterIup* iupPainter = (PPainterIup*)(&inPainter);
    cb(_ih, iupPainter->_cddbuffer);
  }

  return true;
}

bool PDeleteInteractionIup::DeleteNotify(int inIndex, int inSampleIndex, PlotDataBase* inXData, PlotDataBase* inYData)
{
  IFniiff cb = (IFniiff)IupGetCallback(_ih, "DELETE_CB");
  if (cb)
  {
    if (inIndex == -1)
    {
      Icallback cbb = IupGetCallback(_ih, "DELETEBEGIN_CB");
      if (cbb && cbb(_ih) == IUP_IGNORE)
        return false;
    }
    else if (inIndex == -2)
    {
      Icallback cbb = IupGetCallback(_ih, "DELETEEND_CB");
      if (cbb)
        cbb(_ih);
    }
    else
    {
      float theX = inXData->GetValue(inSampleIndex);
      float theY = inYData->GetValue(inSampleIndex);
      int ret = cb(_ih, inIndex, inSampleIndex, theX, theY);
      if (ret == IUP_IGNORE)
        return false;
    }
  }

  return true;
}

bool PSelectionInteractionIup::SelectNotify(int inIndex, int inSampleIndex, PlotDataBase* inXData, PlotDataBase* inYData, bool inSelect)
{
  IFniiffi cb = (IFniiffi)IupGetCallback(_ih, "SELECT_CB");
  if (cb)
  {
    if (inIndex == -1)
    {
      Icallback cbb = IupGetCallback(_ih, "SELECTBEGIN_CB");
      if (cbb && cbb(_ih) == IUP_IGNORE)
        return false;
    }
    else if (inIndex == -2)
    {
      Icallback cbb = IupGetCallback(_ih, "SELECTEND_CB");
      if (cbb)
        cbb(_ih);
    }
    else
    {
      float theX = inXData->GetValue(inSampleIndex);
      float theY = inYData->GetValue(inSampleIndex);
      int ret = cb(_ih, inIndex, inSampleIndex, theX, theY, (int)inSelect);
      if (ret == IUP_IGNORE)
        return false;
    }
  }

  return true;
}

bool PEditInteractionIup::Impl_HandleKeyEvent (const PKeyEvent &inEvent)
{
  if (inEvent.IsArrowDown () || inEvent.IsArrowUp () ||
      inEvent.IsArrowLeft () || inEvent.IsArrowRight ())
    return true;

  return false;
};

bool PEditInteractionIup::Impl_Calculate (Painter &inPainter, PPlot& inPPlot)
{
  PlotDataContainer &theContainer = inPPlot.mPlotDataContainer;
  long thePlotCount = theContainer.GetPlotCount();

  if (!EditNotify(-1, 0, 0, 0, NULL, NULL))
    return false;

  for (long theI=0;theI<thePlotCount;theI++)
  {
    PlotDataBase* theXData = theContainer.GetXData (theI);
    PlotDataBase* theYData = theContainer.GetYData (theI);
    PlotDataSelection *thePlotDataSelection = theContainer.GetPlotDataSelection (theI);

    if (mKeyEvent.IsArrowDown () || mKeyEvent.IsArrowUp () ||
        mKeyEvent.IsArrowLeft () || mKeyEvent.IsArrowRight ())
      HandleCursorKey (thePlotDataSelection, theXData, theYData, theI);
  }

  EditNotify(-2, 0, 0, 0, NULL, NULL);

  return true;
}

void PEditInteractionIup::HandleCursorKey (const PlotDataSelection *inPlotDataSelection, PlotDataBase* inXData, PlotDataBase* inYData, int inIndex)
{
  float theXDelta = 0; // pixels
  if (mKeyEvent.IsArrowLeft () || mKeyEvent.IsArrowRight ())
  {
    theXDelta = 1;

    if (mKeyEvent.IsArrowLeft ())
      theXDelta *= -1;

    if (mKeyEvent.IsOnlyControlKeyDown ())
      theXDelta *= 10;
  }

  float theYDelta = 0; // pixels
  if (mKeyEvent.IsArrowDown () || mKeyEvent.IsArrowUp ())
  {
    theYDelta = 1;

    if (mKeyEvent.IsArrowDown ())
      theYDelta *= -1;

    if (mKeyEvent.IsOnlyControlKeyDown ())
      theYDelta *= 10;
  }

  for (int theI=0;theI<inYData->GetSize ();theI++)
  {
    if (inPlotDataSelection->IsSelected (theI))
    {
      float theX = inXData->GetValue(theI);
      float newX = theX;

      if (theXDelta)
      {
        float theXPixels = mPPlot.mXTrafo->Transform(theX);
        theXPixels += theXDelta;
        newX = mPPlot.mXTrafo->TransformBack(theXPixels);
      }

      float theY = inYData->GetValue(theI);
      float newY = theY;
      if (theYDelta)
      {
        float theYPixels = mPPlot.mYTrafo->Transform(theY);
        theYPixels -= theYDelta;  // in pixels Y is descending
        newY = mPPlot.mYTrafo->TransformBack(theYPixels);
      }

      if (!EditNotify(inIndex, theI, theX, theY, &newX, &newY))
        return;

      if (inXData->IsString())
      {
        StringPlotData *theXData = (StringPlotData*)(inXData);
        PlotData* theYData = (PlotData*)(inYData);
        theXData->mRealPlotData[theI] = newX;
        (*theYData)[theI] = newY;
      }
      else
      {
        PlotData* theXData = (PlotData*)(inXData);
        PlotData* theYData = (PlotData*)(inYData);
        (*theXData)[theI] = newX;
        (*theYData)[theI] = newY;
      }
    }
  }
}

bool PEditInteractionIup::EditNotify(int inIndex, int inSampleIndex, float inX, float inY, float *inNewX, float *inNewY)
{
  IFniiffff cb = (IFniiffff)IupGetCallback(_ih, "EDIT_CB");
  if (cb)
  {
    if (inIndex == -1)
    {
      Icallback cbb = IupGetCallback(_ih, "EDITBEGIN_CB");
      if (cbb && cbb(_ih) == IUP_IGNORE)
        return false;
    }
    else if (inIndex == -2)
    {
      Icallback cbb = IupGetCallback(_ih, "EDITEND_CB");
      if (cbb)
        cbb(_ih);
    }
    else
    {
      int ret = cb(_ih, inIndex, inSampleIndex, inX, inY, inNewX, inNewY);
      if (ret == IUP_IGNORE)
        return false;
    }
  }

  return true;
}

InteractionContainerIup::InteractionContainerIup(PPlot &inPPlot, Ihandle* inHandle):
  mZoomInteraction (inPPlot),
  mSelectionInteraction (inPPlot, inHandle),
  mEditInteraction (inPPlot, inHandle),
  mDeleteInteraction (inPPlot, inHandle),
  mCrosshairInteraction (inPPlot),
  mPostPainterCallback(inPPlot, inHandle),
  mPrePainterCallback(inPPlot, inHandle)
{
  AddInteraction (mZoomInteraction);
  AddInteraction (mSelectionInteraction);
  AddInteraction (mEditInteraction);
  AddInteraction (mDeleteInteraction);
  AddInteraction (mCrosshairInteraction);
}

PPainterIup::PPainterIup(Ihandle *ih) : 
  Painter(),
  _ih(ih),
  _cdcanvas(NULL),
  _cddbuffer(NULL),
  _mouseDown(0),
  _currentDataSetIndex(-1),
  _redraw(1)
{
  _plot.mShowLegend = false; // change default to hidden
  _plot.mPlotBackground.mTransparent = false;  // always draw the background
  _plot.mMargins.mLeft = 15;
  _plot.mMargins.mBottom = 15;
  _plot.mMargins.mTop = 30;
  _plot.mMargins.mRight = 15;
  _plot.mXAxisSetup.mTickInfo.mTickDivision = 5;
  _plot.mYAxisSetup.mTickInfo.mTickDivision = 5;
  _plot.mXAxisSetup.mTickInfo.mMinorTickScreenSize = 5;
  _plot.mYAxisSetup.mTickInfo.mMinorTickScreenSize = 5;
  _plot.mXAxisSetup.mTickInfo.mMajorTickScreenSize = 8;
  _plot.mYAxisSetup.mTickInfo.mMajorTickScreenSize = 8;

  _InteractionContainer = new InteractionContainerIup(_plot, _ih);

} /* c-tor */


PPainterIup::~PPainterIup()
{
  if (_cddbuffer != NULL)
    cdKillCanvas(_cddbuffer);

  delete _InteractionContainer;
} /* d-tor */

class MarkDataDrawer: public LineDataDrawer
{
 public:
   MarkDataDrawer (bool inDrawLine)
   {
     mDrawLine = inDrawLine;
     mDrawPoint = true;
     mMode = inDrawLine ? "MARKLINE" : "MARK";
   };
   virtual bool DrawPoint (int inScreenX, int inScreenY, const PRect &inRect, Painter &inPainter) const;
};

bool MarkDataDrawer::DrawPoint (int inScreenX, int inScreenY, const PRect &inRect, Painter &inPainter) const
{
  PPainterIup* painter = (PPainterIup*)&inPainter;
  cdCanvasMark(painter->_cddbuffer, inScreenX, cdCanvasInvertYAxis(painter->_cddbuffer, inScreenY));

  return true;
}

static void RemoveSample(PPlot& inPPlot, int inIndex, int inSampleIndex)
{
  PlotDataBase* theXDataBase = inPPlot.mPlotDataContainer.GetXData(inIndex);
  PlotDataBase* theYDataBase = inPPlot.mPlotDataContainer.GetYData(inIndex);

  if (theXDataBase->IsString())
  {
    StringPlotData *theXData = (StringPlotData *)theXDataBase;
    PlotData* theYData = (PlotData*)theYDataBase;
    theXData->mRealPlotData.erase(theXData->mRealPlotData.begin()+inSampleIndex);
    theXData->mStringPlotData.erase(theXData->mStringPlotData.begin()+inSampleIndex);
    theYData->erase(theYData->begin()+inSampleIndex);
  }
  else
  {
    PlotData* theXData = (PlotData*)theXDataBase;
    PlotData* theYData = (PlotData*)theYDataBase;
    theXData->erase(theXData->begin()+inSampleIndex);
    theYData->erase(theYData->begin()+inSampleIndex);
  }
}

/* --------------------------------------------------------------------
                      CD Gets - size and style
   -------------------------------------------------------------------- */

static int iPPlotGetCDFontStyle(const char* value)
{
  if (!value)
    return -1;
  if (iupStrEqualNoCase(value, "PLAIN"))
    return CD_PLAIN;
  if (iupStrEqualNoCase(value, "BOLD"))
    return CD_BOLD;
  if (iupStrEqualNoCase(value, "ITALIC"))
    return CD_ITALIC;
  if (iupStrEqualNoCase(value, "BOLDITALIC"))
    return CD_BOLD_ITALIC;
  return -1;
}

static char* iPPlotGetPlotFontSize(int size)
{
  if (size)
  {
    char* buffer = iupStrGetMemory(50);
    sprintf(buffer, "%d", size);
    return buffer;
  }
  else
    return NULL;
}

static char* iPPlotGetPlotFontStyle(int style)
{
  if (style >= CD_PLAIN && style <= CD_BOLD_ITALIC)
  {
    char* style_str[4] = {"PLAIN", "BOLD", "ITALIC", "BOLDITALIC"};
    return style_str[style];
  }
  else
    return NULL;
}

static char* iPPlotGetPlotPenStyle(int style)
{
  if (style >= CD_CONTINUOUS && style <= CD_DASH_DOT_DOT)
  {
    char* style_str[5] = {"CONTINUOUS", "DASHED", "DOTTED", "DASH_DOT", "DASH_DOT_DOT"};
    return style_str[style];
  }
  else
    return NULL;
}

static int iPPlotGetCDPenStyle(const char* value)
{
  if (!value || iupStrEqualNoCase(value, "CONTINUOUS"))
    return CD_CONTINUOUS;
  else if (iupStrEqualNoCase(value, "DASHED"))
    return CD_DASHED;
  else if (iupStrEqualNoCase(value, "DOTTED"))
    return CD_DOTTED;
  else if (iupStrEqualNoCase(value, "DASH_DOT"))
    return CD_DASH_DOT;
  else if (iupStrEqualNoCase(value, "DASH_DOT_DOT"))
    return CD_DASH_DOT_DOT;
  else
    return CD_CONTINUOUS;
}
 
static char* iPPlotGetPlotMarkStyle(int style)
{
  if (style >= CD_PLUS && style <= CD_HOLLOW_DIAMOND)
  {
    char* style_str[9] = {"PLUS", "STAR", "CIRCLE", "X", "BOX", "DIAMOND", "HOLLOW_CIRCLE", "HOLLOW_BOX", "HOLLOW_DIAMOND"};
    return style_str[style];
  }
  else
    return NULL;
}

static int iPPlotGetCDMarkStyle(const char* value)
{
  if (!value || iupStrEqualNoCase(value, "PLUS"))
    return CD_PLUS;
  else if (iupStrEqualNoCase(value, "STAR"))
    return CD_STAR;
  else if (iupStrEqualNoCase(value, "CIRCLE"))
    return CD_CIRCLE;
  else if (iupStrEqualNoCase(value, "X"))
    return CD_X;
  else if (iupStrEqualNoCase(value, "BOX"))
    return CD_BOX;
  else if (iupStrEqualNoCase(value, "DIAMOND"))
    return CD_DIAMOND;
  else if (iupStrEqualNoCase(value, "HOLLOW_CIRCLE"))
    return CD_HOLLOW_CIRCLE;
  else if (iupStrEqualNoCase(value, "HOLLOW_BOX"))
    return CD_HOLLOW_BOX;
  else if (iupStrEqualNoCase(value, "HOLLOW_DIAMOND"))
    return CD_HOLLOW_DIAMOND;
  else
    return CD_PLUS;
}

/*****************************************************************************/
/***** SET AND GET ATTRIBUTES ************************************************/
/*****************************************************************************/

/* refresh plot window (write only) */
static int iPPlotSetRedrawAttrib(Ihandle* ih, const char* value)
{
  (void)value;  /* not used */
  ih->data->plt->Draw(1);   /* force a full redraw here */
  return 0;
}

/* total number of datasets (read only) */
static char* iPPlotGetCountAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", ih->data->plt->_plot.mPlotDataContainer.GetPlotCount());
  return att_buffer;
}

/* legend box visibility */
static int iPPlotSetLegendShowAttrib(Ihandle* ih, const char* value)
{
  if (iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    ih->data->plt->_plot.mShowLegend = true;
  else 
    ih->data->plt->_plot.mShowLegend = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetLegendShowAttrib(Ihandle* ih)
{
  if (ih->data->plt->_plot.mShowLegend)
    return "YES";
  else
    return "NO";
}

/* legend box visibility */
static int iPPlotSetLegendPosAttrib(Ihandle* ih, const char* value)
{
  if (iupStrEqualNoCase(value, "TOPLEFT"))
    ih->data->plt->_plot.mLegendPos = PPLOT_TOPLEFT;
  if (iupStrEqualNoCase(value, "BOTTOMLEFT"))
    ih->data->plt->_plot.mLegendPos = PPLOT_BOTTOMLEFT;
  if (iupStrEqualNoCase(value, "BOTTOMRIGHT"))
    ih->data->plt->_plot.mLegendPos = PPLOT_BOTTOMRIGHT;
  else
    ih->data->plt->_plot.mLegendPos = PPLOT_TOPRIGHT;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetLegendPosAttrib(Ihandle* ih)
{
  char* legendpos_str[4] = {"TOPLEFT", "TOPRIGHT", "BOTTOMLEFT", "BOTTOMRIGHT"};

  return legendpos_str[ih->data->plt->_plot.mLegendPos];
}

/* background color */
static int iPPlotSetBGColorAttrib(Ihandle* ih, const char* value)
{
  unsigned char rr, gg, bb;
  if (iupStrToRGB(value, &rr, &gg, &bb))
  {
    ih->data->plt->_plot.mPlotBackground.mPlotRegionBackColor = PColor(rr, gg, bb);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetBGColorAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d %d %d",
          ih->data->plt->_plot.mPlotBackground.mPlotRegionBackColor.mR,
          ih->data->plt->_plot.mPlotBackground.mPlotRegionBackColor.mG,
          ih->data->plt->_plot.mPlotBackground.mPlotRegionBackColor.mB);
  return att_buffer;
}


/* title color */
static int iPPlotSetFGColorAttrib(Ihandle* ih, const char* value)
{
  unsigned char rr, gg, bb;
  if (iupStrToRGB(value, &rr, &gg, &bb))
  {
    ih->data->plt->_plot.mPlotBackground.mTitleColor = PColor(rr, gg, bb);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetFGColorAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d %d %d",
          ih->data->plt->_plot.mPlotBackground.mTitleColor.mR,
          ih->data->plt->_plot.mPlotBackground.mTitleColor.mG,
          ih->data->plt->_plot.mPlotBackground.mTitleColor.mB);
  return att_buffer;
}


/* plot title */
static int iPPlotSetTitleAttrib(Ihandle* ih, const char* value)
{
  if (value && value[0] != 0)
    ih->data->plt->_plot.mPlotBackground.mTitle = value;
  else
    ih->data->plt->_plot.mPlotBackground.mTitle.resize(0);

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetTitleAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(256);
  strncpy(att_buffer, ih->data->plt->_plot.mPlotBackground.mTitle.c_str(), 256);
  att_buffer[255]='\0';
  return att_buffer;
}


/* plot title font size */
static int iPPlotSetTitleFontSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    ih->data->plt->_plot.mPlotBackground.mStyle.mFontSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetTitleFontSizeAttrib(Ihandle* ih)
{
  return iPPlotGetPlotFontSize(ih->data->plt->_plot.mPlotBackground.mStyle.mFontSize);
}


/* plot title font style */
static int iPPlotSetTitleFontStyleAttrib(Ihandle* ih, const char* value)
{
  int style = iPPlotGetCDFontStyle(value);
  if (style != -1)
  {
    ih->data->plt->_plot.mPlotBackground.mStyle.mFontStyle = style;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

/* legend font size */
static int iPPlotSetLegendFontSizeAttrib(Ihandle* ih, const char* value)
{
  int ii, xx;
  if (!iupStrToInt(value, &xx))
    return 0;

  for (ii = 0; ii < ih->data->plt->_plot.mPlotDataContainer.GetPlotCount(); ii++)
  {
    LegendData* legend = ih->data->plt->_plot.mPlotDataContainer.GetLegendData(ii);
    legend->mStyle.mFontSize = xx;
  }

  ih->data->plt->_redraw = 1;
  return 1;
}

/* legend font style */
static int iPPlotSetLegendFontStyleAttrib(Ihandle* ih, const char* value)
{
  int ii;
  int style = iPPlotGetCDFontStyle(value);
  if (style == -1)
    return 0;

  for (ii = 0; ii < ih->data->plt->_plot.mPlotDataContainer.GetPlotCount(); ii++)
  {
    LegendData* legend = ih->data->plt->_plot.mPlotDataContainer.GetLegendData(ii);
    legend->mStyle.mFontStyle = style;
  }

  ih->data->plt->_redraw = 1;
  return 1;
}

/* plot margins */
static int iPPlotSetMarginLeftAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    ih->data->plt->_plot.mMargins.mLeft = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetMarginRightAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    ih->data->plt->_plot.mMargins.mRight = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetMarginTopAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    ih->data->plt->_plot.mMargins.mTop = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetMarginBottomAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    ih->data->plt->_plot.mMargins.mBottom = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetMarginLeftAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", ih->data->plt->_plot.mMargins.mLeft);
  return att_buffer;
}

static char* iPPlotGetMarginRightAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", ih->data->plt->_plot.mMargins.mRight);
  return att_buffer;
}

static char* iPPlotGetMarginTopAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", ih->data->plt->_plot.mMargins.mTop);
  return att_buffer;
}

static char* iPPlotGetMarginBottomAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", ih->data->plt->_plot.mMargins.mBottom);
  return att_buffer;
}

/* plot grid color */
static int iPPlotSetGridColorAttrib(Ihandle* ih, const char* value)
{
  unsigned char rr, gg, bb;
  if (iupStrToRGB(value, &rr, &gg, &bb))
  {
    ih->data->plt->_plot.mGridInfo.mGridColor = PColor(rr, gg, bb);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetGridColorAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d %d %d",
          ih->data->plt->_plot.mGridInfo.mGridColor.mR,
          ih->data->plt->_plot.mGridInfo.mGridColor.mG,
          ih->data->plt->_plot.mGridInfo.mGridColor.mB);
  return att_buffer;
}

/* plot grid line style */
static int iPPlotSetGridLineStyleAttrib(Ihandle* ih, const char* value)
{
  ih->data->plt->_plot.mGridInfo.mStyle.mPenStyle = iPPlotGetCDPenStyle(value);
  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetGridLineStyleAttrib(Ihandle* ih)
{
  return iPPlotGetPlotPenStyle(ih->data->plt->_plot.mGridInfo.mStyle.mPenStyle);
}

/* grid */
static int iPPlotSetGridAttrib(Ihandle* ih, const char* value)
{
  if (iupStrEqualNoCase(value, "VERTICAL"))  /* vertical grid - X axis  */
  {
    ih->data->plt->_plot.mGridInfo.mXGridOn = true;
    ih->data->plt->_plot.mGridInfo.mYGridOn = false;
  }
  else if (iupStrEqualNoCase(value, "HORIZONTAL")) /* horizontal grid - Y axis */
  {
    ih->data->plt->_plot.mGridInfo.mYGridOn = true;
    ih->data->plt->_plot.mGridInfo.mXGridOn = false;
  }
  else if (iupStrEqualNoCase(value, "YES"))
  {
    ih->data->plt->_plot.mGridInfo.mXGridOn = true;
    ih->data->plt->_plot.mGridInfo.mYGridOn = true;
  }
  else
  {
    ih->data->plt->_plot.mGridInfo.mYGridOn = false;
    ih->data->plt->_plot.mGridInfo.mXGridOn = false;
  }

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetGridAttrib(Ihandle* ih)
{
  if (ih->data->plt->_plot.mGridInfo.mXGridOn && ih->data->plt->_plot.mGridInfo.mYGridOn)
    return "YES";
  else if (ih->data->plt->_plot.mGridInfo.mYGridOn)
    return "HORIZONTAL";
  else if (ih->data->plt->_plot.mGridInfo.mXGridOn)
    return "VERTICAL";
  else
    return "NO";
}

/* current dataset index */
static int iPPlotSetCurrentAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    int imax = ih->data->plt->_plot.mPlotDataContainer.GetPlotCount();
    ih->data->plt->_currentDataSetIndex = ( (ii>=0) && (ii<imax) ? ii : -1);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetCurrentAttrib(Ihandle* ih)
{
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", ih->data->plt->_currentDataSetIndex);
  return att_buffer;
}

/* remove a dataset */
static int iPPlotSetRemoveAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    ih->data->plt->_plot.mPlotDataContainer.RemoveElement(ii);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

/* clear all datasets */
static int iPPlotSetClearAttrib(Ihandle* ih, const char* value)
{
  ih->data->plt->_plot.mPlotDataContainer.ClearData();
  ih->data->plt->_redraw = 1;
  return 0;
}

/* =============================== */
/* current plot dataset attributes */
/* =============================== */

/* current plot line style */
static int iPPlotSetDSLineStyleAttrib(Ihandle* ih, const char* value)
{
  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
  
  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
  drawer->mStyle.mPenStyle = iPPlotGetCDPenStyle(value);

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetDSLineStyleAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);

  return iPPlotGetPlotPenStyle(drawer->mStyle.mPenStyle);
}

/* current plot line width */
static int iPPlotSetDSLineWidthAttrib(Ihandle* ih, const char* value)
{
  int ii;

  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;

  if (iupStrToInt(value, &ii))
  {
    DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
    drawer->mStyle.mPenWidth = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetDSLineWidthAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", drawer->mStyle.mPenWidth);
  return att_buffer;
}

/* current plot mark style */
static int iPPlotSetDSMarkStyleAttrib(Ihandle* ih, const char* value)
{
  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
  
  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
  drawer->mStyle.mMarkStyle = iPPlotGetCDMarkStyle(value);
  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetDSMarkStyleAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);

  return iPPlotGetPlotMarkStyle(drawer->mStyle.mMarkStyle);
}

/* current plot mark size */
static int iPPlotSetDSMarkSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;

  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
  
  if (iupStrToInt(value, &ii))
  {
    DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
    drawer->mStyle.mMarkSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetDSMarkSizeAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", drawer->mStyle.mMarkSize);
  return att_buffer;
}

/* current dataset legend */
static int iPPlotSetDSLegendAttrib(Ihandle* ih, const char* value)
{
  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
  
  LegendData* legend = ih->data->plt->_plot.mPlotDataContainer.GetLegendData(ih->data->plt->_currentDataSetIndex);
    
  if (value)
    legend->mName = value;
  else
    legend->mName.resize(0);

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetDSLegendAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  LegendData* legend = ih->data->plt->_plot.mPlotDataContainer.GetLegendData(ih->data->plt->_currentDataSetIndex);
  char* att_buffer = iupStrGetMemory(256);
  strncpy(att_buffer, legend->mName.c_str(), 255);
  att_buffer[255]='\0';
  return att_buffer;
}

/* current dataset line and legend color */
static int iPPlotSetDSColorAttrib(Ihandle* ih, const char* value)
{
  unsigned char rr, gg, bb;

  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;

  if (iupStrToRGB(value, &rr, &gg, &bb))
  {
    LegendData* legend = ih->data->plt->_plot.mPlotDataContainer.GetLegendData(ih->data->plt->_currentDataSetIndex);
    legend->mColor = PColor(rr, gg, bb);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetDSColorAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  LegendData* legend = ih->data->plt->_plot.mPlotDataContainer.GetLegendData(ih->data->plt->_currentDataSetIndex);
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d %d %d", legend->mColor.mR, legend->mColor.mG, legend->mColor.mB);
  return att_buffer;
}

/* show values */
static int iPPlotSetDSShowValuesAttrib(Ihandle* ih, const char* value)
{
  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
 
  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
    
  if (iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    drawer->mShowValues = true;
  else 
    drawer->mShowValues = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetDSShowValuesAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);
  if (drawer->mShowValues)
    return "YES";
  else
    return "NO";
}

/* current dataset drawing mode */
static int iPPlotSetDSModeAttrib(Ihandle* ih, const char* value)
{
  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
  
  DataDrawerBase *theDataDrawer = NULL;
  ih->data->plt->_plot.mXAxisSetup.mDiscrete = false;
    
  if(iupStrEqualNoCase(value, "BAR"))
  {
    theDataDrawer = new BarDataDrawer();
    ih->data->plt->_plot.mXAxisSetup.mDiscrete = true;
  }
  else if(iupStrEqualNoCase(value, "MARK"))
    theDataDrawer = new MarkDataDrawer(0);
  else if(iupStrEqualNoCase(value, "MARKLINE"))
    theDataDrawer = new MarkDataDrawer(1);
  else  /* LINE */
    theDataDrawer = new LineDataDrawer();

  ih->data->plt->_plot.mPlotDataContainer.SetDataDrawer(ih->data->plt->_currentDataSetIndex, theDataDrawer);

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetDSModeAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  DataDrawerBase* drawer = ih->data->plt->_plot.mPlotDataContainer.GetDataDrawer(ih->data->plt->_currentDataSetIndex);

  return (char*)drawer->mMode;
}

/* allows selection and editing */
static int iPPlotSetDSEditAttrib(Ihandle* ih, const char* value)
{
  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
  
  PlotDataSelection* dataselect = ih->data->plt->_plot.mPlotDataContainer.GetPlotDataSelection(ih->data->plt->_currentDataSetIndex);
    
  if (iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    dataselect->resize(ih->data->plt->_plot.mPlotDataContainer.GetConstYData(ih->data->plt->_currentDataSetIndex)->GetSize());
  else
    dataselect->clear();

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetDSEditAttrib(Ihandle* ih)
{
  if (ih->data->plt->_currentDataSetIndex < 0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return NULL;

  PlotDataSelection* dataselect = ih->data->plt->_plot.mPlotDataContainer.GetPlotDataSelection(ih->data->plt->_currentDataSetIndex);
  if (dataselect->empty())
    return "NO";
  else
    return "YES";
}

/* remove a sample */
static int iPPlotSetDSRemoveAttrib(Ihandle* ih, const char* value)
{
  int ii;

  if (ih->data->plt->_currentDataSetIndex <  0 ||
      ih->data->plt->_currentDataSetIndex >= ih->data->plt->_plot.mPlotDataContainer.GetPlotCount())
    return 0;
  
  if (iupStrToInt(value, &ii))
  {
    RemoveSample(ih->data->plt->_plot, ih->data->plt->_currentDataSetIndex, ii);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

/* ========== */
/* axis props */
/* ========== */

/* ========== */
/* axis props */
/* ========== */

/* axis title */
static int iPPlotSetAXSXLabelAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (value)
    axis->mLabel = value;
  else
    axis->mLabel = "";

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYLabelAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (value)
    axis->mLabel = value;
  else
    axis->mLabel = "";

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXLabelAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(256);
  strncpy(att_buffer, axis->mLabel.c_str(), 255);
  att_buffer[255]='\0';
  return att_buffer;
}

static char* iPPlotGetAXSYLabelAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(256);
  strncpy(att_buffer, axis->mLabel.c_str(), 255);
  att_buffer[255]='\0';
  return att_buffer;
}

/* axis title position */
static int iPPlotSetAXSXLabelCenteredAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mLabelCentered = true;
  else 
   axis->mLabelCentered = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYLabelCenteredAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mLabelCentered = true;
  else 
   axis->mLabelCentered = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXLabelCenteredAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mLabelCentered)
    return "YES";
  else
    return "NO";
}

static char* iPPlotGetAXSYLabelCenteredAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mLabelCentered)
    return "YES";
  else
    return "NO";
}

/* axis, ticks and label color */
static int iPPlotSetAXSXColorAttrib(Ihandle* ih, const char* value)
{
  unsigned char rr, gg, bb;
  if (iupStrToRGB(value, &rr, &gg, &bb))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mColor = PColor(rr, gg, bb);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYColorAttrib(Ihandle* ih, const char* value)
{
  unsigned char rr, gg, bb;
  if (iupStrToRGB(value, &rr, &gg, &bb))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mColor = PColor(rr, gg, bb);
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXColorAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d %d %d",
          axis->mColor.mR,
          axis->mColor.mG,
          axis->mColor.mB);
  return att_buffer;
}

static char* iPPlotGetAXSYColorAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d %d %d",
          axis->mColor.mR,
          axis->mColor.mG,
          axis->mColor.mB);
  return att_buffer;
}

/* autoscaling */
static int iPPlotSetAXSXAutoMinAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mAutoScaleMin = true;
  else 
    axis->mAutoScaleMin = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYAutoMinAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mAutoScaleMin = true;
  else 
    axis->mAutoScaleMin = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXAutoMinAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mAutoScaleMin)
    return "YES";
  else
    return "NO";
}

static char* iPPlotGetAXSYAutoMinAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mAutoScaleMin)
    return "YES";
  else
    return "NO";
}

/* autoscaling */
static int iPPlotSetAXSXAutoMaxAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mAutoScaleMax = true;
  else 
    axis->mAutoScaleMax = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYAutoMaxAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mAutoScaleMax = true;
  else 
    axis->mAutoScaleMax = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXAutoMaxAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mAutoScaleMax)
    return "YES";
  else
    return "NO";
}

static char* iPPlotGetAXSYAutoMaxAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mAutoScaleMax)
    return "YES";
  else
    return "NO";
}

/* min visible val */
static int iPPlotSetAXSXMinAttrib(Ihandle* ih, const char* value)
{
  float xx;
  if (iupStrToFloat(value, &xx))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mMin = xx;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYMinAttrib(Ihandle* ih, const char* value)
{
  float xx;
  if (iupStrToFloat(value, &xx))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mMin = xx;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXMinAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%g", axis->mMin);
  return att_buffer;
}

static char* iPPlotGetAXSYMinAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%g", axis->mMin);
  return att_buffer;
}

/* max visible val */
static int iPPlotSetAXSXMaxAttrib(Ihandle* ih, const char* value)
{
  float xx;
  if (iupStrToFloat(value, &xx))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mMax = xx;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYMaxAttrib(Ihandle* ih, const char* value)
{
  float xx;
  if (iupStrToFloat(value, &xx))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mMax = xx;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXMaxAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%g", axis->mMax);
  return att_buffer;
}

static char* iPPlotGetAXSYMaxAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%g", axis->mMax);
  return att_buffer;
}

/* values from left/top to right/bottom */
static int iPPlotSetAXSXReverseAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mAscending = false; // inverted
  else 
    axis->mAscending = true;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYReverseAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mAscending = false; // inverted
  else 
    axis->mAscending = true;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXReverseAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mAscending)
    return "NO";    /* inverted */
  else
    return "YES";
}

static char* iPPlotGetAXSYReverseAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mAscending)
    return "NO";    /* inverted */
  else
    return "YES";
}

/* axis mode */
static int iPPlotSetAXSXCrossOriginAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mCrossOrigin = true;
  else 
    axis->mCrossOrigin = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYCrossOriginAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mCrossOrigin = true;
  else 
    axis->mCrossOrigin = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXCrossOriginAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mCrossOrigin)
    return "YES";
  else
    return "NO";
}

static char* iPPlotGetAXSYCrossOriginAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mCrossOrigin)
    return "YES";
  else
    return "NO";
}

/* log/lin scale */
static int iPPlotSetAXSXScaleAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "LIN"))
  {
    axis->mLogScale = false;
  }
  else if(iupStrEqualNoCase(value, "LOG10"))
  {
    axis->mLogScale = true;
    axis->mLogBase  = 10.0;
  }
  else if(iupStrEqualNoCase(value, "LOG2"))
  {
    axis->mLogScale = true;
    axis->mLogBase  = 2.0;
  }
  else
  {
    axis->mLogScale = true;
    axis->mLogBase  = (float)M_E;
  }

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYScaleAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "LIN"))
  {
    axis->mLogScale = false;
  }
  else if(iupStrEqualNoCase(value, "LOG10"))
  {
    axis->mLogScale = true;
    axis->mLogBase  = 10.0;
  }
  else if(iupStrEqualNoCase(value, "LOG2"))
  {
    axis->mLogScale = true;
    axis->mLogBase  = 2.0;
  }
  else
  {
    axis->mLogScale = true;
    axis->mLogBase  = (float)M_E;
  }

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXScaleAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);

  if (axis->mLogScale)
  {
    if (axis->mLogBase == 10.0)
      strcpy(att_buffer, "LOG10");
    else if (axis->mLogBase == 2.0)
      strcpy(att_buffer, "LOG2");
    else
      strcpy(att_buffer, "LOGN");
  }
  else
    strcpy(att_buffer, "LIN");

  return att_buffer;
}

static char* iPPlotGetAXSYScaleAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);

  if (axis->mLogScale)
  {
    if (axis->mLogBase == 10.0)
      strcpy(att_buffer, "LOG10");
    else if (axis->mLogBase == 2.0)
      strcpy(att_buffer, "LOG2");
    else
      strcpy(att_buffer, "LOGN");
  }
  else
    strcpy(att_buffer, "LIN");

  return att_buffer;
}

/* axis label font size */
static int iPPlotSetAXSXFontSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mStyle.mFontSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYFontSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mStyle.mFontSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXFontSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  return iPPlotGetPlotFontSize(axis->mStyle.mFontSize);
}

static char* iPPlotGetAXSYFontSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  return iPPlotGetPlotFontSize(axis->mStyle.mFontSize);
}

/* axis label font style */
static int iPPlotSetAXSXFontStyleAttrib(Ihandle* ih, const char* value)
{
  int style = iPPlotGetCDFontStyle(value);
  if (style != -1)
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mStyle.mFontStyle = style;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYFontStyleAttrib(Ihandle* ih, const char* value)
{
  int style = iPPlotGetCDFontStyle(value);
  if (style != -1)
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mStyle.mFontStyle = style;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXFontStyleAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  return iPPlotGetPlotFontStyle(axis->mStyle.mFontStyle);
}

static char* iPPlotGetAXSYFontStyleAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  return iPPlotGetPlotFontStyle(axis->mStyle.mFontStyle);
}

/* automatic tick size */
static int iPPlotSetAXSXAutoTickSizeAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mTickInfo.mAutoTickSize = true;
  else 
    axis->mTickInfo.mAutoTickSize = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYAutoTickSizeAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mTickInfo.mAutoTickSize = true;
  else 
    axis->mTickInfo.mAutoTickSize = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXAutoTickSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mTickInfo.mAutoTickSize)
    return "YES";
  else
    return "NO";
}

static char* iPPlotGetAXSYAutoTickSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mTickInfo.mAutoTickSize)
    return "YES";
  else
    return "NO";
}

/* size of ticks (in pixels) */
static int iPPlotSetAXSXTickSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mTickInfo.mMinorTickScreenSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYTickSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mTickInfo.mMinorTickScreenSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXTickSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", axis->mTickInfo.mMinorTickScreenSize);
  return att_buffer;
}

static char* iPPlotGetAXSYTickSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", axis->mTickInfo.mMinorTickScreenSize);
  return att_buffer;
}

/* size of major ticks (in pixels) */
static int iPPlotSetAXSXTickMajorSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mTickInfo.mMajorTickScreenSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYTickMajorSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mTickInfo.mMajorTickScreenSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXTickMajorSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", axis->mTickInfo.mMajorTickScreenSize);
  return att_buffer;
}

static char* iPPlotGetAXSYTickMajorSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", axis->mTickInfo.mMajorTickScreenSize);
  return att_buffer;
}

/* axis ticks font size */
static int iPPlotSetAXSXTickFontSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mTickInfo.mStyle.mFontSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYTickFontSizeAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mTickInfo.mStyle.mFontSize = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXTickFontSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  return iPPlotGetPlotFontSize(axis->mTickInfo.mStyle.mFontSize);
}

static char* iPPlotGetAXSYTickFontSizeAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  return iPPlotGetPlotFontSize(axis->mTickInfo.mStyle.mFontSize);
}

/* axis ticks number font style */
static int iPPlotSetAXSXTickFontStyleAttrib(Ihandle* ih, const char* value)
{
  int style = iPPlotGetCDFontStyle(value);
  if (style != -1)
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mTickInfo.mStyle.mFontStyle = style;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYTickFontStyleAttrib(Ihandle* ih, const char* value)
{
  int style = iPPlotGetCDFontStyle(value);
  if (style != -1)
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mTickInfo.mStyle.mFontStyle = style;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXTickFontStyleAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  return iPPlotGetPlotFontSize(axis->mTickInfo.mStyle.mFontStyle);
}

static char* iPPlotGetAXSYTickFontStyleAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  return iPPlotGetPlotFontSize(axis->mTickInfo.mStyle.mFontStyle);
}

/* axis ticks number format */
static int iPPlotSetAXSXTickFormatAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (value && value[0]!=0)
    axis->mTickInfo.mFormatString = value;
  else
    axis->mTickInfo.mFormatString = "%.0f";

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYTickFormatAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (value && value[0]!=0)
    axis->mTickInfo.mFormatString = value;
  else
    axis->mTickInfo.mFormatString = "%.0f";

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXTickFormatAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(256);
  strncpy(att_buffer, axis->mTickInfo.mFormatString.c_str(), 255);
  att_buffer[255]='\0';
  return att_buffer;
}

static char* iPPlotGetAXSYTickFormatAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(256);
  strncpy(att_buffer, axis->mTickInfo.mFormatString.c_str(), 255);
  att_buffer[255]='\0';
  return att_buffer;
}

/* axis ticks */
static int iPPlotSetAXSXTickAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mTickInfo.mTicksOn = true;
  else 
    axis->mTickInfo.mTicksOn = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYTickAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mTickInfo.mTicksOn = true;
  else 
    axis->mTickInfo.mTicksOn = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXTickAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mTickInfo.mTicksOn)
    return "YES";
  else
    return "NO";
}

static char* iPPlotGetAXSYTickAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mTickInfo.mTicksOn)
    return "YES";
  else
    return "NO";
}

/* major tick spacing */
static int iPPlotSetAXSXTickMajorSpanAttrib(Ihandle* ih, const char* value)
{
  float xx;
  if (iupStrToFloat(value, &xx))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mTickInfo.mMajorTickSpan = xx;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYTickMajorSpanAttrib(Ihandle* ih, const char* value)
{
  float xx;
  if (iupStrToFloat(value, &xx))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mTickInfo.mMajorTickSpan = xx;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXTickMajorSpanAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%g", axis->mTickInfo.mMajorTickSpan);
  return att_buffer;
}

static char* iPPlotGetAXSYTickMajorSpanAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%g", axis->mTickInfo.mMajorTickSpan);
  return att_buffer;
}

/* number of ticks between major ticks */
static int iPPlotSetAXSXTickDivisionAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
    axis->mTickInfo.mTickDivision = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static int iPPlotSetAXSYTickDivisionAttrib(Ihandle* ih, const char* value)
{
  int ii;
  if (iupStrToInt(value, &ii))
  {
    AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
    axis->mTickInfo.mTickDivision = ii;
    ih->data->plt->_redraw = 1;
  }
  return 0;
}

static char* iPPlotGetAXSXTickDivisionAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", axis->mTickInfo.mTickDivision);
  return att_buffer;
}

static char* iPPlotGetAXSYTickDivisionAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;
  char* att_buffer = iupStrGetMemory(30);
  sprintf(att_buffer, "%d", axis->mTickInfo.mTickDivision);
  return att_buffer;
}

/* auto tick spacing */
static int iPPlotSetAXSXAutoTickAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mTickInfo.mAutoTick = true;
  else 
    axis->mTickInfo.mAutoTick = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static int iPPlotSetAXSYAutoTickAttrib(Ihandle* ih, const char* value)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if(iupStrEqualNoCase(value, "YES") || iupStrEqualNoCase(value, "ON"))
    axis->mTickInfo.mAutoTick = true;
  else 
    axis->mTickInfo.mAutoTick = false;

  ih->data->plt->_redraw = 1;
  return 0;
}

static char* iPPlotGetAXSXAutoTickAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mXAxisSetup;

  if (axis->mTickInfo.mAutoTick)
    return "YES";
  else
    return "NO";
}

static char* iPPlotGetAXSYAutoTickAttrib(Ihandle* ih)
{
  AxisSetup* axis = &ih->data->plt->_plot.mYAxisSetup;

  if (axis->mTickInfo.mAutoTick)
    return "YES";
  else
    return "NO";
}

/* MouseButton */
void PPainterIup::MouseButton(int btn, int stat, int x, int y, char *r)
{
  PMouseEvent theEvent;
  int theModifierKeys = 0;

  theEvent.mX = x;
  theEvent.mY = y;
  
  if(btn == IUP_BUTTON1)
  {
    theEvent.mType = ( stat!=0 ? (PMouseEvent::kDown) : (PMouseEvent::kUp) );
    _mouseDown = ( stat!=0 ? 1 : 0 );
  }
  else return;

  _mouse_ALT = 0;
  _mouse_SHIFT = 0;
  _mouse_CTRL = 0;

  if (iup_isalt(r))  /* signal Alt */
  {
    theModifierKeys = (theModifierKeys | PMouseEvent::kAlt);
    _mouse_ALT = 1;
  }
  if (iup_iscontrol(r))  /* signal Ctrl */
  {
    theModifierKeys = (theModifierKeys | PMouseEvent::kControl);
    _mouse_SHIFT = 1;
  }
  if (iup_isshift(r))  /* signal Shift */
  {
    theModifierKeys = (theModifierKeys | PMouseEvent::kShift);
    _mouse_CTRL = 1;
  }
  theEvent.SetModifierKeys (theModifierKeys);

  if( _InteractionContainer->HandleMouseEvent(theEvent))
  {
    this->Draw(1);
  } 
  else
  {
    /* ignore the event */
  }
}

/* MouseMove */
void PPainterIup::MouseMove(int x, int y)
{
  PMouseEvent theEvent;
  int theModifierKeys = 0;

  if(!_mouseDown ) return;

  theEvent.mX = x;
  theEvent.mY = y;

  theEvent.mType = PMouseEvent::kMove;
  if(_mouse_ALT)  /* signal Alt */
  {
    theModifierKeys = (theModifierKeys | PMouseEvent::kAlt);
  }
  if(_mouse_SHIFT)  /* signal Shift */
  {
    theModifierKeys = (theModifierKeys | PMouseEvent::kControl);
  }
  if(_mouse_CTRL)  /* signal Ctrl */
  {
    theModifierKeys = (theModifierKeys | PMouseEvent::kShift);
  }
  theEvent.SetModifierKeys (theModifierKeys);

  if(_InteractionContainer->HandleMouseEvent(theEvent))
  {
    this->Draw(1);
  } 
  else
  {
    /* ignore the event */
  }
}

/* KeyPress */
void PPainterIup::KeyPress(int c, int press)
{
  int theModifierKeys = 0;
  int theRepeatCount = 0;
  PKeyEvent::EKey theKeyCode = PKeyEvent::kNone;
  char theChar = 0;

  if(!press) return;

  switch(c)
  {
    case K_cX:  /* CTRL + X */
      theModifierKeys = PMouseEvent::kControl;
      theKeyCode = PKeyEvent::kChar;
      theChar = 'x';
    break;
    case K_cY:  /* CTRL + Y */
      theModifierKeys = PMouseEvent::kControl;
      theKeyCode = PKeyEvent::kChar;
      theChar = 'y';
    break;
    case K_cR:  /* CTRL + R */
      theModifierKeys = PMouseEvent::kControl;
      theKeyCode = PKeyEvent::kChar;
      theChar = 'r';
    break;
    case K_cUP:  /* CTRL + Arrow */
      theModifierKeys = PMouseEvent::kControl;
    case K_UP:   /* Arrow */
      theKeyCode = PKeyEvent::kArrowUp;
    break;
    case K_cDOWN:  /* CTRL + Arrow */
      theModifierKeys = PMouseEvent::kControl;
    case K_DOWN:   /* Arrow */
      theKeyCode = PKeyEvent::kArrowDown;
    break;
    case K_cLEFT:  /* CTRL + Arrow */
      theModifierKeys = PMouseEvent::kControl;
    case K_LEFT:   /* Arrow */
      theKeyCode = PKeyEvent::kArrowLeft;
    break;
    case K_cRIGHT:  /* CTRL + Arrow */
      theModifierKeys = PMouseEvent::kControl;
    case K_RIGHT:   /* Arrow */
      theKeyCode = PKeyEvent::kArrowRight;
    break;
    case K_cDEL:  /* CTRL + Arrow */
      theModifierKeys = PMouseEvent::kControl;
    case K_DEL:   /* Arrow */
      theKeyCode = PKeyEvent::kDelete;
    break;
  }

  PKeyEvent theEvent (theKeyCode, theRepeatCount, theModifierKeys, theChar);

  if(_InteractionContainer->HandleKeyEvent(theEvent))
  {
    this->Draw(1);
  } 
  else
  {
    /* ignore the event */
  }
}

/* Draw */
void PPainterIup::Draw(int force)
{
  if (!_cddbuffer)
    return;

  cdCanvasActivate(_cddbuffer);

  if (force || _redraw)
  {
    cdCanvasClear(_cddbuffer);
    _plot.Draw(*this);
    _redraw = 0;
  }

  cdCanvasFlush(_cddbuffer);
}

/* Resize */
void PPainterIup::Resize()
{
  if (!_cddbuffer)
  {
    /* update canvas size */
    cdCanvasActivate(_cdcanvas);

    /* this can fail if canvas size is zero */
    if (IupGetInt(_ih, "USE_IMAGERGB"))
      _cddbuffer = cdCreateCanvas(CD_DBUFFERRGB, _cdcanvas);
    else
      _cddbuffer = cdCreateCanvas(CD_DBUFFER, _cdcanvas);
  }

  if (!_cddbuffer)
    return;

  /* update canvas size */
  cdCanvasActivate(_cddbuffer);

  _redraw = 1;

  return;
}

/* send plot to some other device */ 
void PPainterIup::DrawTo(cdCanvas *usrCnv)
{
  cdCanvas *old_cddbuffer  = _cddbuffer;
  cdCanvas *old_cdcanvas   = _cdcanvas;
  
  _cdcanvas = _cddbuffer = usrCnv;

  if(!_cddbuffer)
    return;

  Draw(1);

  _cddbuffer = old_cddbuffer;
  _cdcanvas  = old_cdcanvas;
}

void PPainterIup::FillArrow(int inX1, int inY1, int inX2, int inY2, int inX3, int inY3)
{
  if (!_cddbuffer)
    return;

  cdCanvasBegin(_cddbuffer, CD_FILL);
  cdCanvasVertex(_cddbuffer, inX1, cdCanvasInvertYAxis(_cddbuffer, inY1));
  cdCanvasVertex(_cddbuffer, inX2, cdCanvasInvertYAxis(_cddbuffer, inY2));
  cdCanvasVertex(_cddbuffer, inX3, cdCanvasInvertYAxis(_cddbuffer, inY3));
  cdCanvasEnd(_cddbuffer);
}

/* DrawLine */
void PPainterIup::DrawLine(float inX1, float inY1, float inX2, float inY2)
{
  if (!_cddbuffer)
    return;

  cdfCanvasLine(_cddbuffer, inX1, cdfCanvasInvertYAxis(_cddbuffer, inY1),
                                           inX2, cdfCanvasInvertYAxis(_cddbuffer, inY2));
}

/* FillRect */
void PPainterIup::FillRect(int inX, int inY, int inW, int inH)
{
  if (!_cddbuffer)
    return;

  cdCanvasBox(_cddbuffer, inX, inX+inW, 
              cdCanvasInvertYAxis(_cddbuffer, inY),
              cdCanvasInvertYAxis(_cddbuffer, inY + inH - 1));
}

/* InvertRect */
void PPainterIup::InvertRect(int inX, int inY, int inW, int inH)
{
  long cprev;

  if (!_cddbuffer)
    return;

  cdCanvasWriteMode(_cddbuffer, CD_XOR);
  cprev = cdCanvasForeground(_cddbuffer, CD_WHITE);
  cdCanvasRect(_cddbuffer, inX, inX + inW - 1,
               cdCanvasInvertYAxis(_cddbuffer, inY),
               cdCanvasInvertYAxis(_cddbuffer, inY + inH - 1));
  cdCanvasWriteMode(_cddbuffer, CD_REPLACE);
  cdCanvasForeground(_cddbuffer, cprev);
}

/* SetClipRect */
void PPainterIup::SetClipRect(int inX, int inY, int inW, int inH)
{
  if (!_cddbuffer)
    return;

  cdCanvasClipArea(_cddbuffer, inX, inX + inW - 1,
                   cdCanvasInvertYAxis(_cddbuffer, inY),
                   cdCanvasInvertYAxis(_cddbuffer, inY + inH - 1));
  cdCanvasClip(_cddbuffer, CD_CLIPAREA);
}

/* GetWidth */
long PPainterIup::GetWidth() const
{
  int iret;

  if (!_cddbuffer)
    return IUP_DEFAULT;

  cdCanvasGetSize(_cddbuffer, &iret, NULL, NULL, NULL);

  return (long)iret;
}

/* GetHeight */
long PPainterIup::GetHeight() const
{
  int iret;

  if (!_cddbuffer)
    return IUP_NOERROR;

  cdCanvasGetSize(_cddbuffer, NULL, &iret, NULL, NULL);

  return (long)iret;
}

/* SetLineColor */
void PPainterIup::SetLineColor(int inR, int inG, int inB)
{
  if (!_cddbuffer)
    return;

  cdCanvasForeground(_cddbuffer, cdEncodeColor((unsigned char)inR,
                                               (unsigned char)inG,
                                               (unsigned char)inB));
}

/* SetFillColor */
void PPainterIup::SetFillColor(int inR, int inG, int inB)
{
  if (!_cddbuffer)
    return;

  cdCanvasForeground(_cddbuffer, cdEncodeColor((unsigned char)inR,
                                               (unsigned char)inG,
                                               (unsigned char)inB));
}

/* CalculateTextDrawSize */
long PPainterIup::CalculateTextDrawSize(const char *inString)
{
  int iw;

  if (!_cddbuffer)
    return IUP_NOERROR;

  cdCanvasGetTextSize(_cddbuffer, const_cast<char *>(inString), &iw, NULL);

  return iw;
}

/* GetFontHeight */
long PPainterIup::GetFontHeight() const
{
  int ih;

  if (!_cddbuffer)
    return IUP_NOERROR;

  cdCanvasGetFontDim(_cddbuffer, NULL, &ih, NULL, NULL);

  return ih;
}

/* DrawText */
/* this call leave all the hard job of alignment on painter side */
void PPainterIup::DrawText(int inX, int inY, short align, const char *inString)
{
  if (!_cddbuffer)
    return;

  cdCanvasTextAlignment(_cddbuffer, align);
  cdCanvasText(_cddbuffer, inX, cdCanvasInvertYAxis(_cddbuffer, inY), const_cast<char *>(inString));
}

/* DrawRotatedText */
void PPainterIup::DrawRotatedText(int inX, int inY, float inDegrees, short align, const char *inString)
{
  double aprev;

  if (!_cddbuffer)
    return;

  cdCanvasTextAlignment(_cddbuffer, align);
  aprev = cdCanvasTextOrientation(_cddbuffer, -inDegrees);
  cdCanvasText(_cddbuffer, inX, cdCanvasInvertYAxis(_cddbuffer, inY), const_cast<char *>(inString));
  cdCanvasTextOrientation(_cddbuffer, aprev);
}

void PPainterIup::SetStyle(const PStyle &inStyle)
{
  if (!_cddbuffer)
    return;

  cdCanvasLineWidth(_cddbuffer, inStyle.mPenWidth);
  cdCanvasLineStyle(_cddbuffer, inStyle.mPenStyle);

  cdCanvasNativeFont(_cddbuffer, IupGetAttribute(_ih, "FONT"));

  if (inStyle.mFontStyle != -1 || inStyle.mFontSize != 0)
    cdCanvasFont(_cddbuffer, NULL, inStyle.mFontStyle, inStyle.mFontSize);

  cdCanvasMarkType(_cddbuffer, inStyle.mMarkStyle);
  cdCanvasMarkSize(_cddbuffer, inStyle.mMarkSize);
}

int iPPlotMapMethod(Ihandle* ih)
{
  int old_gdi = 0;

  if (IupGetInt(ih, "USE_GDI+"))
    old_gdi = cdUseContextPlus(1);

  ih->data->plt->_cdcanvas = cdCreateCanvas(CD_IUP, ih);
  if (!ih->data->plt->_cdcanvas)
    return IUP_ERROR;

  /* this can fail if canvas size is zero */
  if (IupGetInt(ih, "USE_IMAGERGB"))
    ih->data->plt->_cddbuffer = cdCreateCanvas(CD_DBUFFERRGB, ih->data->plt->_cdcanvas);
  else
    ih->data->plt->_cddbuffer = cdCreateCanvas(CD_DBUFFER, ih->data->plt->_cdcanvas);

  if (IupGetInt(ih, "USE_GDI+"))
    cdUseContextPlus(old_gdi);

  ih->data->plt->_redraw = 1;

  return IUP_NOERROR;
}

void iPPlotDestroyMethod(Ihandle* ih)
{
  delete ih->data->plt;
}

int iPPlotCreateMethod(Ihandle* ih, void **params)
{
  (void)params;

  /* free the data alocated by IupCanvas */
  if (ih->data) free(ih->data);
  ih->data = iupALLOCCTRLDATA();

  /* Initializing object with no cd canvases */
  ih->data->plt = new PPainterIup(ih);

  /* IupCanvas callbacks */
  IupSetCallback(ih, "ACTION",      (Icallback)iPPlotRedraw_CB);
  IupSetCallback(ih, "RESIZE_CB",   (Icallback)iPPlotResize_CB);
  IupSetCallback(ih, "BUTTON_CB",   (Icallback)iPPlotMouseButton_CB);
  IupSetCallback(ih, "MOTION_CB",   (Icallback)iPPlotMouseMove_CB);
  IupSetCallback(ih, "KEYPRESS_CB", (Icallback)iPPlotKeyPress_CB);

  return IUP_NOERROR;
}

static Iclass* iupPPlotGetClass(void)
{
  Iclass* ic = iupClassNew(iupCanvasGetClass());

  ic->name = "pplot";
  ic->format = NULL;  /* none */
  ic->nativetype = IUP_TYPECANVAS;
  ic->childtype = IUP_CHILDNONE;
  ic->is_interactive = 1;
  ic->has_attrib_id = 1;  /* has attributes with IDs that must be parsed */

  /* Class functions */
  ic->Create  = iPPlotCreateMethod;
  ic->Destroy = iPPlotDestroyMethod;
  ic->Map     = iPPlotMapMethod;

  /* IupPPlot Callbacks */
  iupClassRegisterCallback(ic, "POSTDRAW_CB", "v");
  iupClassRegisterCallback(ic, "PREDRAW_CB", "v");
  iupClassRegisterCallback(ic, "DELETE_CB", "iiff");
  iupClassRegisterCallback(ic, "DELETEBEGIN_CB", "");
  iupClassRegisterCallback(ic, "DELETEEND_CB", "");
  iupClassRegisterCallback(ic, "SELECT_CB", "iiffi");
  iupClassRegisterCallback(ic, "SELECTBEGIN_CB", "");
  iupClassRegisterCallback(ic, "SELECTEND_CB", "");
  iupClassRegisterCallback(ic, "EDIT_CB", "iiffvv");
  iupClassRegisterCallback(ic, "EDITBEGIN_CB", "");
  iupClassRegisterCallback(ic, "EDITEND_CB", "");

  /* Visual */
  iupClassRegisterAttribute(ic, "BGCOLOR", iPPlotGetBGColorAttrib, iPPlotSetBGColorAttrib, IUPAF_SAMEASSYSTEM, "255 255 255", IUPAF_NOT_MAPPED);
  iupClassRegisterAttribute(ic, "FGCOLOR", iPPlotGetFGColorAttrib, iPPlotSetFGColorAttrib, IUPAF_SAMEASSYSTEM, "0 0 0", IUPAF_NOT_MAPPED);

  /* IupPPlot only */

  iupClassRegisterAttribute(ic, "REDRAW", NULL, iPPlotSetRedrawAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "TITLE", iPPlotGetTitleAttrib, iPPlotSetTitleAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "TITLEFONTSIZE", iPPlotGetTitleFontSizeAttrib, iPPlotSetTitleFontSizeAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "TITLEFONTSTYLE", NULL, iPPlotSetTitleFontStyleAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "LEGENDSHOW", iPPlotGetLegendShowAttrib, iPPlotSetLegendShowAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "LEGENDPOS", iPPlotGetLegendPosAttrib, iPPlotSetLegendPosAttrib, IUPAF_SAMEASSYSTEM, "TOPRIGHT", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "LEGENDFONTSIZE", NULL, iPPlotSetLegendFontSizeAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "LEGENDFONTSTYLE", NULL, iPPlotSetLegendFontStyleAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "MARGINLEFT", iPPlotGetMarginLeftAttrib, iPPlotSetMarginLeftAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "MARGINRIGHT", iPPlotGetMarginRightAttrib, iPPlotSetMarginRightAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "MARGINTOP", iPPlotGetMarginTopAttrib, iPPlotSetMarginTopAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "MARGINBOTTOM", iPPlotGetMarginBottomAttrib, iPPlotSetMarginBottomAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "GRIDLINESTYLE", iPPlotGetGridLineStyleAttrib, iPPlotSetGridLineStyleAttrib, IUPAF_SAMEASSYSTEM, "CONTINUOUS", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "GRIDCOLOR", iPPlotGetGridColorAttrib, iPPlotSetGridColorAttrib, IUPAF_SAMEASSYSTEM, "200 200 200", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "GRID", iPPlotGetGridAttrib, iPPlotSetGridAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);

  iupClassRegisterAttribute(ic, "DS_LINESTYLE", iPPlotGetDSLineStyleAttrib, iPPlotSetDSLineStyleAttrib, IUPAF_SAMEASSYSTEM, "CONTINUOUS", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_LINEWIDTH", iPPlotGetDSLineWidthAttrib, iPPlotSetDSLineWidthAttrib, IUPAF_SAMEASSYSTEM, "1", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_MARKSTYLE", iPPlotGetDSMarkStyleAttrib, iPPlotSetDSMarkStyleAttrib, IUPAF_SAMEASSYSTEM, "X", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_MARKSIZE", iPPlotGetDSMarkSizeAttrib, iPPlotSetDSMarkSizeAttrib, IUPAF_SAMEASSYSTEM, "7", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_LEGEND", iPPlotGetDSLegendAttrib, iPPlotSetDSLegendAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_COLOR", iPPlotGetDSColorAttrib, iPPlotSetDSColorAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_SHOWVALUES", iPPlotGetDSShowValuesAttrib, iPPlotSetDSShowValuesAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_MODE", iPPlotGetDSModeAttrib, iPPlotSetDSModeAttrib, IUPAF_SAMEASSYSTEM, "LINE", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_EDIT", iPPlotGetDSEditAttrib, iPPlotSetDSEditAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "DS_REMOVE", NULL, iPPlotSetDSRemoveAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);

  iupClassRegisterAttribute(ic, "AXS_XLABEL", iPPlotGetAXSXLabelAttrib, iPPlotSetAXSXLabelAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YLABEL", iPPlotGetAXSYLabelAttrib, iPPlotSetAXSYLabelAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XLABELCENTERED", iPPlotGetAXSXLabelCenteredAttrib, iPPlotSetAXSXLabelCenteredAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YLABELCENTERED", iPPlotGetAXSYLabelCenteredAttrib, iPPlotSetAXSYLabelCenteredAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XCOLOR", iPPlotGetAXSXColorAttrib, iPPlotSetAXSXColorAttrib, IUPAF_SAMEASSYSTEM, "0 0 0", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YCOLOR", iPPlotGetAXSYColorAttrib, iPPlotSetAXSYColorAttrib, IUPAF_SAMEASSYSTEM, "0 0 0", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XAUTOMIN", iPPlotGetAXSXAutoMinAttrib, iPPlotSetAXSXAutoMinAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YAUTOMIN", iPPlotGetAXSYAutoMinAttrib, iPPlotSetAXSYAutoMinAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XAUTOMAX", iPPlotGetAXSXAutoMaxAttrib, iPPlotSetAXSXAutoMaxAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YAUTOMAX", iPPlotGetAXSYAutoMaxAttrib, iPPlotSetAXSYAutoMaxAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XMIN", iPPlotGetAXSXMinAttrib, iPPlotSetAXSXMinAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YMIN", iPPlotGetAXSYMinAttrib, iPPlotSetAXSYMinAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XMAX", iPPlotGetAXSXMaxAttrib, iPPlotSetAXSXMaxAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YMAX", iPPlotGetAXSYMaxAttrib, iPPlotSetAXSYMaxAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XREVERSE", iPPlotGetAXSXReverseAttrib, iPPlotSetAXSXReverseAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YREVERSE", iPPlotGetAXSYReverseAttrib, iPPlotSetAXSYReverseAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XCROSSORIGIN", iPPlotGetAXSXCrossOriginAttrib, iPPlotSetAXSXCrossOriginAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YCROSSORIGIN", iPPlotGetAXSYCrossOriginAttrib, iPPlotSetAXSYCrossOriginAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XSCALE", iPPlotGetAXSXScaleAttrib, iPPlotSetAXSXScaleAttrib, IUPAF_SAMEASSYSTEM, "LIN", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YSCALE", iPPlotGetAXSYScaleAttrib, iPPlotSetAXSYScaleAttrib, IUPAF_SAMEASSYSTEM, "LIN", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XFONTSIZE", iPPlotGetAXSXFontSizeAttrib, iPPlotSetAXSXFontSizeAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YFONTSIZE", iPPlotGetAXSYFontSizeAttrib, iPPlotSetAXSYFontSizeAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XFONTSTYLE", iPPlotGetAXSXFontStyleAttrib, iPPlotSetAXSXFontStyleAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YFONTSTYLE", iPPlotGetAXSYFontStyleAttrib, iPPlotSetAXSYFontStyleAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICK", iPPlotGetAXSXTickAttrib, iPPlotSetAXSXTickAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICK", iPPlotGetAXSYTickAttrib, iPPlotSetAXSYTickAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICKSIZE", iPPlotGetAXSXTickSizeAttrib, iPPlotSetAXSXTickSizeAttrib, IUPAF_SAMEASSYSTEM, "5", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICKSIZE", iPPlotGetAXSYTickSizeAttrib, iPPlotSetAXSYTickSizeAttrib, IUPAF_SAMEASSYSTEM, "5", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICKFORMAT", iPPlotGetAXSXTickFormatAttrib, iPPlotSetAXSXTickFormatAttrib, IUPAF_SAMEASSYSTEM, "%.0f", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICKFORMAT", iPPlotGetAXSYTickFormatAttrib, iPPlotSetAXSYTickFormatAttrib, IUPAF_SAMEASSYSTEM, "%.0f", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICKFONTSIZE", iPPlotGetAXSXTickFontSizeAttrib, iPPlotSetAXSXTickFontSizeAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICKFONTSIZE", iPPlotGetAXSYTickFontSizeAttrib, iPPlotSetAXSYTickFontSizeAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICKFONTSTYLE", iPPlotGetAXSXTickFontStyleAttrib, iPPlotSetAXSXTickFontStyleAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICKFONTSTYLE", iPPlotGetAXSYTickFontStyleAttrib, iPPlotSetAXSYTickFontStyleAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XAUTOTICK", iPPlotGetAXSXAutoTickAttrib, iPPlotSetAXSXAutoTickAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YAUTOTICK", iPPlotGetAXSYAutoTickAttrib, iPPlotSetAXSYAutoTickAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XAUTOTICKSIZE", iPPlotGetAXSXAutoTickSizeAttrib, iPPlotSetAXSXAutoTickSizeAttrib, IUPAF_SAMEASSYSTEM, "5", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YAUTOTICKSIZE", iPPlotGetAXSYAutoTickSizeAttrib, iPPlotSetAXSYAutoTickSizeAttrib, IUPAF_SAMEASSYSTEM, "5", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICKMAJORSPAN", iPPlotGetAXSXTickMajorSpanAttrib, iPPlotSetAXSXTickMajorSpanAttrib, IUPAF_SAMEASSYSTEM, "1", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICKMAJORSPAN", iPPlotGetAXSYTickMajorSpanAttrib, iPPlotSetAXSYTickMajorSpanAttrib, IUPAF_SAMEASSYSTEM, "1", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICKDIVISION", iPPlotGetAXSXTickDivisionAttrib, iPPlotSetAXSXTickDivisionAttrib, IUPAF_SAMEASSYSTEM, "5", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICKDIVISION", iPPlotGetAXSYTickDivisionAttrib, iPPlotSetAXSYTickDivisionAttrib, IUPAF_SAMEASSYSTEM, "5", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XAUTOTICKSIZE", iPPlotGetAXSXAutoTickSizeAttrib, iPPlotSetAXSXAutoTickSizeAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YAUTOTICKSIZE", iPPlotGetAXSYAutoTickSizeAttrib, iPPlotSetAXSYAutoTickSizeAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_XTICKMAJORSIZE", iPPlotGetAXSXTickMajorSizeAttrib, iPPlotSetAXSXTickMajorSizeAttrib, IUPAF_SAMEASSYSTEM, "8", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "AXS_YTICKMAJORSIZE", iPPlotGetAXSYTickMajorSizeAttrib, iPPlotSetAXSYTickMajorSizeAttrib, IUPAF_SAMEASSYSTEM, "8", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);

  iupClassRegisterAttribute(ic, "REMOVE", NULL, iPPlotSetRemoveAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "CLEAR", NULL, iPPlotSetClearAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "COUNT", iPPlotGetCountAttrib, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "CURRENT", iPPlotGetCurrentAttrib, iPPlotSetCurrentAttrib, IUPAF_SAMEASSYSTEM, "-1", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);

  return ic;
}

/* user level call: create control */
Ihandle* IupPPlot(void)
{
  return IupCreate("pplot");
}

void IupPPlotOpen(void)
{
  if (!IupGetGlobal("_IUP_PPLOT_OPEN"))
  {
    iupRegisterClass(iupPPlotGetClass());
    IupSetGlobal("_IUP_PPLOT_OPEN", "1");
  }
}