FXCurve.h

/*******************************************************************************
* Copyright (C) 2003-2005 by Rafael de Pelegrini Soares.   All Rights Reserved.
********************************************************************************
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
********************************************************************************
* $Id: FXCurve.h,v 1.4 2006/01/17 22:06:18 rpseng Exp $
********************************************************************************/


#ifndef __FXCURVE_H
#define __FXCURVE_H


#include <vector>

// forward declaration of plot
class FXPlot2D;
class FXAxis;

class FXCurveData {
protected:
        double *data;

        FXbool del;

        FXint len;

        FXdouble max;
        FXdouble min;
        
public:
        enum DataType{
                SharedData = 0, 
                SharedDelete, 
                CopyData, 
        };

        FXCurveData(double *data, FXint len, DataType type = CopyData){
                this->data = NULL;
                this->len = 0;
                this->del = false;
                setData(data, len, type);
        }

        void clear(){
                if(del)
                        delete []data;
                data = NULL;
                len = 0;
                del = false;
        }

        void setData(double *data, FXint len, DataType type){
                clear();
                del = false;
                this->len = len;
                switch(type){
                        case SharedDelete:
                                del = true;
                        case SharedData:
                                this->data = data;
                                break;
                        case CopyData:
                        default:
                                del = true;
                                this->data = new double[len];
                                memcpy(this->data, data, sizeof(double)*len);
                }

                min = HUGE_VAL;
                max = -min;
                FXint i; double *di;
                for(i=0, di = data; i<len; ++i, ++di){
                        if(*di < min) min = *di;
                        if(*di > max) max = *di;
                }
        };
        virtual ~FXCurveData(){
                clear();
        }

        const double& at(FXint i) const {
                return data[i];
        }
        double& at(FXint i) {
                return data[i];
        }

        FXint length() const {
                return len;
        };

        double getMax() const {
                return max;
        }

        double getMin() const {
                return min;
        }
};


class FXCurve
{
public:
        enum CurveStyle {
                Lines = 0,
                Steps,
                //Sticks,
                //Spline,
                NoCurve,
        };

        enum MarkStyle{
                Square = 0,
                Circle,
                Triangle,
                TriangleInv,
                X,
                NoMark,
        };
protected:
        FXString label;

        FXPlot2D *plot;

        FXAxis *axisx;
        FXAxis *axisy;

        FXCurveData *datax;
        FXCurveData *datay;
        std::vector<FXPoint> points;

        MarkStyle mark;
        FXint marksize;
        FXColor markcolor;
        FXPlotPen pen;
        CurveStyle style;

        FXbool calculated;

public:
        void loadDefault(FXuint width, FXuint counter);

        void setAxis(FXAxis *x, FXAxis *y);

        void drawSample(FXDC *p, FXint x, FXint y, FXbool line = false) const;
        
        void setLabel(FXString curveName);
        
        virtual void drawSelf(FXDC *dc, FXint rootx, FXint rooty);

        const FXCurveData* getDataX(void){
                return datax;
        }
        const FXCurveData* getDataY(void){
                return datay;
        }
        void setView(FXPlot2D *view);
        const FXPlotPen& getPen(void) const {
                return pen;
        }

        CurveStyle getStyle() const {
                return style;
        }
        void setStyle(CurveStyle style) {
                this->style = style;
        }

        enum MarkStyle getMarkStyle(void) const{
                return mark;
        }
        FXint getMarkSize(void) const{
                return marksize;
        }
        FXColor getMarkColor(void) const {
                return markcolor;
        }

        void setPen(const FXPlotPen &pen){
                this->pen = pen;
        }
        void setMarkSize(FXint size){
                marksize = size;
        }
        void setMarkStyle(MarkStyle m){
                mark = m;
        }

        void setMarkColor(FXColor color){
                markcolor = color;
        }

        void update(){
                calculated = false;
        }

        FXCurve(const FXString &label, FXCurveData *x, FXCurveData *y,
                CurveStyle style = Lines, FXPlot2D *view = NULL);

        virtual ~FXCurve();

        void calcule(FXint rootx, FXint rooty);

        FXString getLabel() const {
                return label;
        }

protected:

        virtual void drawSteps(FXDC *dc) const;

        virtual void drawMarks(FXDC *dc) const;

        virtual void drawMark(FXDC *dc, FXPoint p, MarkStyle style, FXint size,
                        FXColor color) const ;
};

#endif // __FXCURVE_H

---