pFigure.cxx

Go to the documentation of this file.

//----------------------------------------------------------------------------------------------------------------
// Class definition include
//----------------------------------------------------------------------------------------------------------------
#include "pFigure.h"

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

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

//----------------------------------------------------------------------------------------------------------------
// Class implementation
//----------------------------------------------------------------------------------------------------------------
IMPLEMENT_CLASS(pFigure, wxObject)

        //------------------------------------------------------------------------------------------------------------
        // Constructors & Destructors
        //------------------------------------------------------------------------------------------------------------
        pFigure :: pFigure(int edges_n, int _w, int _h, int _orientation, bool bar_orientation)
        {
                edges = edges_n;
                orientation = _orientation;
                width = _w;
                heigth = _h;
                setBarOrientation( bar_orientation );
        }

        pFigure :: ~pFigure()
        {

        }

        //------------------------------------------------------------------------------------------------------------
        // Methods
        //------------------------------------------------------------------------------------------------------------

        int pFigure :: getNumberEdges()
        {
                return edges;
        }

        void pFigure :: setNumberEdges(int n_edges)
        {
                edges = n_edges;
        }

        void pFigure :: getVertexPoints(wxPoint thePoints[])
        {
                if (edges == TRIANGLE)
                {
                        int halfWidth = 0;
                        int halfHeigth = 0;
                        if ( barOrientation ) // HORIZONTAL
                        {
                                halfWidth = (int)(width/2);
                                halfHeigth = (int)(heigth/2);
                                switch ( orientation ) 
                                {
                                  case UP : 
                                        thePoints[0].x = halfWidth;
                                        thePoints[0].y = 0;
                                        thePoints[1].x = width;
                                        thePoints[1].y = heigth;
                                        thePoints[2].x = -halfWidth;
                                        thePoints[2].y = heigth;
                                        break;
                                        
                                  case DOWN : 
                                        thePoints[0].x = halfWidth;
                                        thePoints[0].y = heigth;
                                        thePoints[1].x = width;
                                        thePoints[1].y = 0;
                                        thePoints[2].x = -halfWidth;
                                        thePoints[2].y = 0;
                                        break;

                                  case LEFT : 
                                        thePoints[0].x = 0;
                                        thePoints[0].y = halfHeigth;
                                        thePoints[1].x = width;
                                        thePoints[1].y = 0;
                                        thePoints[2].x = width;
                                        thePoints[2].y = heigth;
                                        break;

                                  case RIGHT :          
                                        thePoints[0].x = width;
                                        thePoints[0].y = halfHeigth;            
                                        thePoints[1].x = 0;
                                        thePoints[1].y = 0;
                                        thePoints[2].x = 0;
                                        thePoints[2].y = heigth;
                                        break;
                                }                       
                        }
                        else // VERTICAL
                        {
                                halfWidth = (int)(heigth/2);
                                halfHeigth = (int)(width/2);
                                switch ( orientation ) 
                                {
                                  case UP : 
                                        thePoints[0].x = halfWidth;
                                        thePoints[0].y = 0;
                                        thePoints[1].x = heigth;
                                        thePoints[1].y = width;
                                        thePoints[2].x = -halfWidth;
                                        thePoints[2].y = width;
                                        break;
                                        
                                  case DOWN : 
                                        thePoints[0].x = halfWidth;
                                        thePoints[0].y = width;
                                        thePoints[1].x = heigth;
                                        thePoints[1].y = 0;
                                        thePoints[2].x = -halfWidth;
                                        thePoints[2].y = 0;
                                        break;

                                  case LEFT : 
                                        thePoints[0].x = 0;
                                        thePoints[0].y = halfHeigth;
                                        thePoints[1].x = heigth;
                                        thePoints[1].y = -halfHeigth;
                                        thePoints[2].x = heigth;
                                        thePoints[2].y = width;
                                        break;

                                  case RIGHT :          
                                        thePoints[0].x = heigth;
                                        thePoints[0].y = halfHeigth;            
                                        thePoints[1].x = 0;
                                        thePoints[1].y = -halfHeigth;
                                        thePoints[2].x = 0;
                                        thePoints[2].y = width;
                                        break;
                                }       
                        }                               
                }
                else if (edges == RECTANGLE)
                {
                        if ( barOrientation ) // HORIZONTAL
                        {
                                thePoints[0].x = 0;
                                thePoints[0].y = 0;             
                                thePoints[1].x = width;
                                thePoints[1].y = 0;
                                thePoints[2].x = width;
                                thePoints[2].y = heigth;
                                thePoints[3].x = 0;
                                thePoints[3].y = heigth;
                        }
                        else // VERTICAL
                        {
                                thePoints[0].x = 0;
                                thePoints[0].y = 0;             
                                thePoints[1].x = heigth;
                                thePoints[1].y = 0;
                                thePoints[2].x = heigth;
                                thePoints[2].y = width;
                                thePoints[3].x = 0;
                                thePoints[3].y = width;
                        }
                }
        }

        void pFigure :: setVertexPoints(wxPoint * n_points)
        {
                v_points = n_points;
        }

        /*
        * Sets the heigth of the figure
        * @param _h The heigth to set
        */
        void pFigure :: setHeigth(int _h)
        {
                heigth = _h;
        }

        /*
        * Gets the heigth of the figure
        * @retval heigth The heigth of the figure
        */
        int pFigure :: getHeigth()
        {
                return heigth;
        }

        /*
        * Sets the width of the figure
        * @param _w The width to set
        */
        void pFigure :: setWidth(int _w)
        {
                width = _w;
        }

        /*
        * Gets the width of the figure
        * @retval width The width of the figure
        */
        int pFigure :: getWidth()
        {
                return width;
        }

        /*
        * Indicates if a pixel point is inside the figure
        * @param xFig_PixelPoint The known reference point inside the figure
        * @param xPixel The x-pixel coord asking for
        * @retval Returns true if the point is inside
        */
        bool pFigure :: isPointInside(int xFig_PixelPoint, int xPixel)
        {
                bool isInside = false;

                if (edges == TRIANGLE)
                {
                        int halfWidth = (int)(width/2)+1;
                        int halfHeigth = (int)(heigth/2)+1;
                        if ( orientation == UP || orientation == DOWN )
                        {
                                isInside = (xPixel>=xFig_PixelPoint-halfWidth) && (xPixel<=xFig_PixelPoint+halfWidth);
                        }
                        else if( orientation == LEFT || orientation == RIGHT )
                        {
                                isInside = (xPixel>=xFig_PixelPoint-halfHeigth) && (xPixel<=xFig_PixelPoint+halfHeigth);
                        }                                               
                }
                else if (edges == RECTANGLE)
                {
                        isInside = (xPixel >= xFig_PixelPoint) && (xPixel<=xFig_PixelPoint+width);
                }
                return isInside;
        }

        /*
        * Sets the bar orientation 
        * @ bar_orientation The orientation to set (true for horizontal, false for vertical)
        */
        void pFigure :: setBarOrientation(bool bar_orientation)
        {
                barOrientation = bar_orientation;
        }

        /*
        * Sets the bar orientation used for triangles
        * @ bar_orientation The orientation to set (LEFT = -4, RIGHT = -6, UP = -8, DOWN = -2)
        */
        void pFigure :: setFigureOrientation(int fig_orientation)
        {
                orientation = fig_orientation;
        }