jAPIshapes.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
#ifndef jAPIshapesH
#define jAPIshapesH
//---------------------------------------------------------------------------

#include <vector.h>
#include <stdio.h>

#include "jAPIvectoriels.h"
#include "jAPIgeometry.h"

jSHPdrawGrid(TCanvas * _canvas, int _nbCellsX, int _nbCellsY, int _totalSizeX, int _totalSizeY, TColor _color);

class jShape
{
        public :
        vector<TPoint> points;

        jShape & operator=(jShape & s)                                          { jVCTcopy(&(s.points), &points); return (*this); }

        TRect __fastcall Zone()                                                 { return jVCTzone(&points); }

        TPoint __fastcall Origine()                                             { TRect rect = Zone(); return TPoint(rect.Left, rect.Top); }

        bool __fastcall Direction(jShape * src, TPoint debX, TPoint debY)       { if (!src)      return false; return jVCTdirection(&(src->points), &points, debX, debY); }
        bool __fastcall Direction(TPoint debX, TPoint debY)                     { return jVCTdirection(&points, debX, debY); }

        virtual bool __fastcall IsInside(const TPoint & p)                              { return jVCTinside(p, &points); }

        void __fastcall AddPoint(int X, int Y)                                  { points.push_back(TPoint(X, Y)); }
        void __fastcall AddPoint(TPoint p)                                      { points.push_back(p); }

        void __fastcall Clear()                                                 { points.clear(); }

        bool __fastcall Rotate(jShape * src, TPoint origine, double angle)      { if (!src)      return false; return jVCTrotate(&(src->points), &points, origine, angle); }
        bool __fastcall Rotate(TPoint origine, double angle)                    { return jVCTrotate(&points, origine, angle); }

        bool __fastcall Stretch(jShape * src, double coeffx, double coeffy)     { if (!src)      return false; return jVCTstretch(&(src->points), &points, Origine(), coeffx, coeffy); }
        bool __fastcall Stretch(double coeffx, double coeffy)                   { return jVCTstretch(&points, Origine(), coeffx, coeffy); }

        bool __fastcall Move(jShape * src, int offsetx, int offsety)            { if (!src)      return false; return jVCTmove(&(src->points), &points, offsetx, offsety); }
        bool __fastcall Move(int offsetx, int offsety)                          { return jVCTmove(&points, offsetx, offsety); }

        bool __fastcall Move(jShape * src, TPoint p)                            { if (!src)      return false; return jVCTmove(&(src->points), &points, p); }
        bool __fastcall Move(TPoint p)                                          { return jVCTmove(&points, p); }

        bool __fastcall Draw(TCanvas * cv)                                      { return jDRWshape(cv, &points); }

        bool __fastcall Fetch(jShape * src, TRect zone)                         { if (!src)      return false; return jVCTfetch(&(src->points), &points, zone); }
        bool __fastcall Fetch(TRect zone)                                       { return jVCTfetch(&points, zone); }

        bool __fastcall Fetch(jShape * src, TRect z_src, TRect z_dst)           { if (!src)      return false; return jVCTfetch(&(src->points), &points, z_src, z_dst); }
        bool __fastcall Fetch(TRect z_src, TRect z_dst)                         { return jVCTfetch(&points, z_src, z_dst); }

        bool __fastcall LoadFromStream(TStream * _str)                          { return jVCTloadFromStream(&points, _str); }
        bool __fastcall saveToStream(TStream * _str)                            { return jVCTsaveToStream(&points, _str); }
        bool __fastcall LoadFromFile(FILE * f)                                  { return jVCTloadFromFile(&points, f); }
        bool __fastcall SaveToFile(FILE * f)                                    { return jVCTsaveToFile(&points, f);   }

        bool __fastcall DrawFetched(TCanvas * cv, const TRect & dst, const TRect & src)
        {
                jShape l_shape = *this;
                l_shape.Fetch(src, dst);
                l_shape.Draw(cv);
                return true;
        }
};

enum jShpType {shpSimpleLineArrow, shpFineArrow, shpMediumArrow, shpLargeArrow,
               shpDoubleLineArrow, shpSegment, shpSquare};

class jStdShape : public jShape
{
        public :
        vector<TPoint> m_OriginalPoints;

        jPoint m_start;
        jPoint m_end;

        int m_type;

        jStdShape() {Clear();}

        jStdShape & operator=(const jStdShape & s)
        {
                jVCTcopy(&(((jStdShape)s).points), &points);
                jVCTcopy(&(((jStdShape)s).m_OriginalPoints), &m_OriginalPoints);
                m_start = s.m_start;
                m_end   = s.m_end;
                m_type  = s.m_type;
                return (*this);
        }

        void __fastcall Set(jShpType apparence);

        bool __fastcall DrawExtremities(TCanvas * cv)                          { return jDRWpoint(cv, m_start, 3) & jDRWpoint(cv, m_end, 3); }

        bool __fastcall Direction(TPoint deb, TPoint fin)                      { if (jVCTdirection(&m_OriginalPoints, &points, deb, fin) == false)     return false;     m_start = deb;  m_end   = fin; return true; }
        bool __fastcall DrawOriginal(TCanvas * cv)                             { return jDRWshape(cv, &m_OriginalPoints); }

        bool __fastcall LoadFromFile(FILE * f);
        bool __fastcall SaveToFile(FILE * f);

        bool __fastcall IsStartPoint(const TPoint & p)                         { return jPNTinside(p, TRect(m_start.x-3, m_start.y-3, m_start.x+3, m_start.y+3)); }
        bool __fastcall IsEndPoint(const TPoint & p)                           { return jPNTinside(p, TRect(m_end.x-3,   m_end.y-3,   m_end.x+3,   m_end.y+3)); }

        bool __fastcall Fetch(const TRect & z_old, const TRect & z_new)        { return m_start.Stretch(z_new, z_old) & m_end.Stretch(z_new, z_old) & Direction(m_start, m_end); }
        bool __fastcall UnFetch(const TRect & z_new, const TRect & z_old)      { return m_start.UnStretch(z_new, z_old) & m_end.UnStretch(z_new, z_old) & Direction(m_start, m_end); }

        bool __fastcall DrawFetched(TCanvas * cv, const TRect & dst, const TRect & src)
        {
                jStdShape l_shape = *this;
                l_shape.Fetch(src, dst);
                l_shape.Draw(cv);
                return true;
        }

        bool __fastcall IsInside(const TPoint & p);
};

class jStdShapes
{
        vector<jStdShape> m_shapes;
        vector<jStdShape>::iterator it;

        public:

        jStdShapes & operator=(const jStdShapes & s)
        {
                m_shapes.clear();
                for (int i=0; i<s.Count(); i++)
                        m_shapes.push_back(s.At(i));
                return (*this);
        }

        bool __fastcall Add(jStdShape shape)    { m_shapes.push_back(shape); return true;}
        int  __fastcall Count()                 { return m_shapes.size(); }
        jStdShape & __fastcall At(int pos)      { return m_shapes.at(pos); }

        bool __fastcall Draw(TCanvas * cv, bool points=false);
        bool __fastcall DrawFetched(TCanvas * cv, const TRect & z_dst, const TRect & z_src);
        bool __fastcall Remove(int pos);

        jStdShape * __fastcall UnderFocus(const TPoint & mouse, bool & startPoint);
        jStdShape * __fastcall Focused(const TPoint & mouse, TRect & view, TRect & Cadre, int & pos);

        bool __fastcall Fetch(const TRect & src, const TRect & dst);

        bool __fastcall LoadFromFile(FILE * f, int max);
        bool __fastcall SaveToFile(FILE * f);
};

#endif

---