diff options
Diffstat (limited to 'iup/srcpplot/iup_pplot.cpp')
| -rwxr-xr-x | iup/srcpplot/iup_pplot.cpp | 2959 |
1 files changed, 2959 insertions, 0 deletions
diff --git a/iup/srcpplot/iup_pplot.cpp b/iup/srcpplot/iup_pplot.cpp new file mode 100755 index 0000000..6f5c93a --- /dev/null +++ b/iup/srcpplot/iup_pplot.cpp @@ -0,0 +1,2959 @@ +/* + * 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"); + } +} |