pLogicalFunction.h

Go to the documentation of this file.

#ifndef __pLogicalFunction_h__
#define __pLogicalFunction_h__

// ----------------------------------------------------------------------------
// WX headers inclusion.
// For compilers that support precompilation, includes <wx/wx.h>.
// ----------------------------------------------------------------------------

#include <wx/wxprec.h>
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif


//----------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------------

#include "pFunctionPoint.h"
#include <iostream>
#include <fstream>
#include <string>



class pLogicalFunction;
//----------------------------------------------------------------------------
// Class definition
//----------------------------------------------------------------------------
#define MAX_POINTS 50

//if your are going to change se sensible region  you have to change MOVE in pPlotterLayer
#define SENSIBLE_REGION 5


class pLogicalFunction: public wxObject
{
public:

        //----------------------------------------------------------------------------
        // Constructors
        //----------------------------------------------------------------------------
        pLogicalFunction( );

        ~pLogicalFunction( );
        
        /*virtual void Rewind()
        {
                node = realPoints.GetFirst();
        }
        */
        
        /*virtual bool GetNextXY(double & x, double & y) 
        {
                if(node)
                {
                        pFunctionPoint* p=(pFunctionPoint*)node->GetData();
                        x=p->getRealX();
                        y=p->getRealY();
                        node=node->GetNext();
                        return true;
                }
                return false;
        }
        */

        /*virtual*/
        void GetPoints(wxList &points)
        {
                points = realPoints;
        }  
        /*
        * validate if the function has that point in a sensible area returning the index where the point was found or -1 if is in not part of the function: define the sensible area is  
        * x1-validPointRange<x<x1+validPointRange y1-validPointRange<y<y1+validPointRange
        */
        int validPointOnFunction(wxPoint realPoint);

        //returns the index in the list of the point  
        int getIndexOf(wxPoint realpoint);

        /*
        * This metohd returns the node of the point that is the movingPointIndex position in the list of points.
        * @param: int movingPointIndex, Is the index value of the searched node.
        * @return: Return a pointer to the node corresponding to the index value by parameter.
        */
        wxNode* GetPointAt( int movingPointIndex);

        /*
        * Includes a point between two existing points of the this function. The new point (x,y) was not defined when the function was created.
        *@ return Returns true is the point was succcesfully added to the funcion.
        */
        bool AddNewPoint(int x,int y);

        bool AddPoint(int aX, int aY,bool order=true);

        bool DeletePoint(int aX, int aY);

        bool changePoint(wxPoint newCoords, int movingIndexPoint);

        //bool hasPoint(wxPoint aAPoint);

        double * getX_RealValues();

        double* getY_RealValues();
        /*
        * This method orders the list of points taking into account that the last appended node in the list (realPoint) is the only one disordered.
        * @return Returns true if the last point included has a valid value for x and was ordered, according to the definition of function.
        */
        bool orderPoints();

        //wxNode * findPreviousNodeTo( int realX, int realY );

        /*
         * sets the start point of the function
         */
        void  setStartPoints();

        /*
         * sets the end point of the function
         */
        void setEndPoints();

        /*
         * set the max value in x and y between all the points of the function
         */
        void setMaxPoints();


        /*
         * set the min value in x and y between all the points of the function
         */
        void setMinPoints();
        /*
         * Set Up startPoint, endPoint, maxY,maxX points        
        */
        void setUp();


        //set if the function has to draw the points  
        //void SetShowPoints(bool showPoints);

        //get the paramater showPointsF
        //bool getShowPoints();

        //-----------------------
        // Persistence
        //-----------------------

        /*
         Save the points of the function
        */
        void save(wxString fileName);
        /*
         Load the points of a function 
        */
        void load(wxString fileName);

        //----------------------------
        //Getters and Setters
        //----------------------------

        void setStartX(double aStartX);

        double getStartX();

        void setStartY(double aStartY);

        double getStartY();

        void setEndX(double aEndX);

        double getEndX();

        void setEndY(double aEndY);

        double getEndY();

        void setScaleX(double aScaleX);

        double getScaleX();

        void setScaleY(double aScaleY);

        double getScaleY();

        void setMinX(double aMinX);

        double getMinX();

        void setMinY(double aMinY);

        double getMinY();

        void setMaxX(double aMaxX);

        double getMaxX();

        void setMaxY(double aMaxY);

        double getMaxY();

        void setOffsetX(double aOffsetX);

        double getOffsetX();

        void setOffsetY(double aOffsetY);

        double getOffsetY();

        void setType(int aType);

        int getType();

        int getValidPointRange();

        void setValidPointRange(int theRange);

        bool deletePointAt(int index);
        /*
        * Returns the number of points that the function
        * has
        */
        int getSizePoints();

        void getDirection(bool &dir);



private:

        double _startX;
        double _startY;
        double _endX;
        double _endY;
        double _scaleX;
        double _scaleY;
        double _minX;
        double _minY;
        double _maxX;

        double _maxY;

        double _offsetX;
        double _offsetY;
        int _type;
        wxList realPoints;

        double x_Values[MAX_POINTS];
        double y_Values[MAX_POINTS];
        //wxNode* node;
        
        int validPointRange;

        bool leftToRigthDef;

        //bool drawing;


        DECLARE_CLASS (pLogicalFunction)
};

#endif