point_editor_behavior.h

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
#include <wx/debug.h>
 
#include <base_units.h>
#include <settings/app_settings.h>
#include <eda_shape.h>
#include <tool/edit_points.h>
#include <view/view_controls.h>
 
class COMMIT;
class REFERENCE_IMAGE;
class SHAPE_POLY_SET;

class POINT_EDIT_BEHAVIOR
{
public:
    virtual ~POINT_EDIT_BEHAVIOR() = default;

    virtual void MakePoints( EDIT_POINTS& aPoints ) = 0;

    virtual bool UpdatePoints( EDIT_POINTS& aPoints ) = 0;

    virtual void FinalizeItem( EDIT_POINTS& aPoints, COMMIT& aCommit ) {};

    virtual void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                             std::vector<EDA_ITEM*>& aUpdatedItems ) = 0;

    virtual OPT_VECTOR2I Get45DegreeConstrainer( const EDIT_POINT& aEditedPoint,
                                                 EDIT_POINTS&      aPoints ) const
    {
        // By default, no constrainer is defined and the caller must decide
        return std::nullopt;
    }
 
protected:
    static bool isModified( const EDIT_POINT& aEditedPoint, const EDIT_POINT& aPoint )
    {
        return &aEditedPoint == &aPoint;
    }
};
 
// Helper macros to check the number of points in the edit points object
// Still a bug, but at least it won't segfault if the number of points is wrong
#define CHECK_POINT_COUNT( aPoints, aExpected ) \
    wxCHECK( aPoints.PointsSize() == aExpected, /* void */ )
#define CHECK_POINT_COUNT_GE( aPoints, aExpected ) \
    wxCHECK( aPoints.PointsSize() >= aExpected, /* void */ )
 

class POLYGON_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    POLYGON_POINT_EDIT_BEHAVIOR( SHAPE_POLY_SET& aPolygon ) :
            m_polygon( aPolygon )
    {}

    static void BuildForPolyOutline( EDIT_POINTS& aPoints, const SHAPE_POLY_SET& aOutline );

    static void UpdatePointsFromOutline( const SHAPE_POLY_SET& aOutline, EDIT_POINTS& aPoints );

    static void UpdateOutlineFromPoints( SHAPE_POLY_SET& aOutline, const EDIT_POINT& aEditedPoint,
                                         EDIT_POINTS& aPoints );

    static void RemoveNullSegmentsIfPolygonSurvives( SHAPE_POLY_SET& aOutline );
 
    void MakePoints( EDIT_POINTS& aPoints ) override
    {
        BuildForPolyOutline( aPoints, m_polygon );
    }
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override
    {
        UpdatePointsFromOutline( m_polygon, aPoints );
        return true;
    }
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override
    {
        UpdateOutlineFromPoints( m_polygon, aEditedPoint, aPoints );
    }
 
    void FinalizeItem( EDIT_POINTS& aPoints, COMMIT& aCommit ) override;
 
private:
    SHAPE_POLY_SET& m_polygon;
};
 

class EDA_POLYGON_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    EDA_POLYGON_POINT_EDIT_BEHAVIOR( EDA_SHAPE& aPolygon ) :
            m_shape( aPolygon )
    {
        wxASSERT( aPolygon.GetShape() == SHAPE_T::POLY );
    }
 
    void MakePoints( EDIT_POINTS& aPoints ) override
    {
        POLYGON_POINT_EDIT_BEHAVIOR::BuildForPolyOutline( aPoints, m_shape.GetPolyShape() );
    }
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override
    {
        // Normalize can fold the polygon into a rectangle, which needs a different editor
        if( m_shape.GetShape() != SHAPE_T::POLY )
            return false;
 
        POLYGON_POINT_EDIT_BEHAVIOR::UpdatePointsFromOutline( m_shape.GetPolyShape(), aPoints );
        return true;
    }
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override
    {
        POLYGON_POINT_EDIT_BEHAVIOR::UpdateOutlineFromPoints(
                m_shape.GetPolyShape(), aEditedPoint, aPoints );
    }
 
    void FinalizeItem( EDIT_POINTS& aPoints, COMMIT& aCommit ) override
    {
        POLYGON_POINT_EDIT_BEHAVIOR::RemoveNullSegmentsIfPolygonSurvives( m_shape.GetPolyShape() );
    }
 
private:
    EDA_SHAPE& m_shape;
};
 

class EDA_SEGMENT_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    EDA_SEGMENT_POINT_EDIT_BEHAVIOR( EDA_SHAPE& aSegment ) :
            m_segment( aSegment )
    {
        wxASSERT( aSegment.GetShape() == SHAPE_T::SEGMENT );
    }
 
    void MakePoints( EDIT_POINTS& aPoints ) override;
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override;
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override;
 
    OPT_VECTOR2I Get45DegreeConstrainer( const EDIT_POINT& aEditedPoint,
                                         EDIT_POINTS&      aPoints ) const override;
 
protected:
    enum SEGMENT_POINTS
    {
        SEGMENT_START,
        SEGMENT_END,
 
        SEGMENT_MAX_POINTS,
    };
 
private:
    EDA_SHAPE& m_segment;
};
 

class EDA_CIRCLE_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    EDA_CIRCLE_POINT_EDIT_BEHAVIOR( EDA_SHAPE& aCircle ) :
            m_circle( aCircle )
    {
        wxASSERT( aCircle.GetShape() == SHAPE_T::CIRCLE );
    }
 
    void MakePoints( EDIT_POINTS& aPoints ) override;
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override;
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override;
 
    OPT_VECTOR2I Get45DegreeConstrainer( const EDIT_POINT& aEditedPoint,
                                         EDIT_POINTS&      aPoints ) const override;
 
protected:
    enum CIRCLE_POINTS
    {
        CIRC_CENTER,
        CIRC_END,
 
        CIRC_MAX_POINTS,
    };
 
private:
    EDA_SHAPE& m_circle;
};
 

class EDA_BEZIER_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    EDA_BEZIER_POINT_EDIT_BEHAVIOR( EDA_SHAPE& aBezier, int aMaxError ) :
            m_bezier( aBezier ),
            m_maxError( aMaxError )
    {
        wxASSERT( aBezier.GetShape() == SHAPE_T::BEZIER );
    }
 
    void MakePoints( EDIT_POINTS& aPoints ) override;
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override;
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override;
 
protected:
    enum BEZIER_POINTS
    {
        BEZIER_START,
        BEZIER_CTRL_PT1,
        BEZIER_CTRL_PT2,
        BEZIER_END,
 
        BEZIER_MAX_POINTS
    };
 
private:
    EDA_SHAPE& m_bezier;
    int        m_maxError;
};
 

class EDA_ELLIPSE_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    EDA_ELLIPSE_POINT_EDIT_BEHAVIOR( EDA_SHAPE& aEllipse ) :
            m_ellipse( aEllipse )
    {
        wxASSERT( aEllipse.GetShape() == SHAPE_T::ELLIPSE || aEllipse.GetShape() == SHAPE_T::ELLIPSE_ARC );
    }
 
    void MakePoints( EDIT_POINTS& aPoints ) override;
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override;
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override;
 
protected:
    enum ELLIPSE_POINTS
    {
        ELLIPSE_CENTER = 0,
        ELLIPSE_MAJOR_END,
        ELLIPSE_MINOR_END,
        ELLIPSE_ARC_START, // only for ELLIPSE_ARC
        ELLIPSE_ARC_END,   // only for ELLIPSE_ARC
 
        ELLIPSE_CLOSED_POINTS = 3,
        ELLIPSE_ARC_POINTS = 5,
    };
 
private:
    EDA_SHAPE& m_ellipse;

    VECTOR2I evaluateAt( const EDA_ANGLE& aTheta ) const;

    EDA_ANGLE parametricAngleOf( const VECTOR2I& aWorldPt ) const;
};
 

class REFERENCE_IMAGE_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
    enum REFIMG_POINTS
    {
        REFIMG_TOP_LEFT,
        REFIMG_TOP_RIGHT,
        REFIMG_BOT_RIGHT,
        REFIMG_BOT_LEFT,
        REFIMG_ORIGIN,
        REFIMG_ROTATION,
 
        REFIMG_MAX_POINTS,
    };
 
public:
    REFERENCE_IMAGE_POINT_EDIT_BEHAVIOR( REFERENCE_IMAGE& aImage, int aMinSize ) :
            m_image( aImage ),
            m_minSize( aMinSize )
    {
    }
 
    void MakePoints( EDIT_POINTS& aPoints ) override;
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override;
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override;
 
private:
    REFERENCE_IMAGE& m_image;
    int              m_minSize;
};
 

class EDA_TABLECELL_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    EDA_TABLECELL_POINT_EDIT_BEHAVIOR( EDA_SHAPE& aCell ) :
            m_cell( aCell )
    {
        // Point editor only supports cardinally-rotated table cells.
        wxASSERT( aCell.GetShape() == SHAPE_T::RECTANGLE );
    }
 
    void MakePoints( EDIT_POINTS& aPoints ) override;
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override;
 
protected:
    enum TABLECELL_POINTS
    {
        COL_WIDTH,
        ROW_HEIGHT,
 
        TABLECELL_MAX_POINTS,
    };
 
private:
    EDA_SHAPE& m_cell;
};
 

class EDA_ARC_POINT_EDIT_BEHAVIOR : public POINT_EDIT_BEHAVIOR
{
public:
    EDA_ARC_POINT_EDIT_BEHAVIOR( EDA_SHAPE& aArc, const ARC_EDIT_MODE& aArcEditMode,
                                 KIGFX::VIEW_CONTROLS& aViewContols,
                                 const EDA_IU_SCALE& aIuScale );
 
    void MakePoints( EDIT_POINTS& aPoints ) override;
 
    bool UpdatePoints( EDIT_POINTS& aPoints ) override;
 
    void UpdateItem( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints, COMMIT& aCommit,
                     std::vector<EDA_ITEM*>& aUpdatedItems ) override;
 
    OPT_VECTOR2I Get45DegreeConstrainer( const EDIT_POINT& aEditedPoint, EDIT_POINTS& aPoints ) const override;
 
private:
    enum ARC_POINTS
    {
        ARC_START,
        ARC_MID,
        ARC_END,
        ARC_CENTER,
    };
 
    EDA_SHAPE& m_arc;
    // The arc edit mode, which is injected from the editor
    const ARC_EDIT_MODE&  m_arcEditMode;
    KIGFX::VIEW_CONTROLS& m_viewControls;
    // IU scale of the owning editor, used to derive the minimum arc radius
    const EDA_IU_SCALE&   m_iuScale;
};
 
 
ARC_EDIT_MODE IncrementArcEditMode( ARC_EDIT_MODE aMode );
 
 
namespace KI_ARC_EDIT
{
void EditArcEndpointKeepCenter( EDA_SHAPE& aArc, const VECTOR2I& aCenter, const VECTOR2I& aStart,
                                const VECTOR2I& aMid, const VECTOR2I& aEnd, const VECTOR2I& aCursor,
                                const EDA_IU_SCALE& aIuScale );

void EditArcMidKeepCenter( EDA_SHAPE& aArc, const VECTOR2I& aCenter, const VECTOR2I& aStart,
                           const VECTOR2I& aMid, const VECTOR2I& aEnd, const VECTOR2I& aCursor,
                           const EDA_IU_SCALE& aIuScale );
} // namespace KI_ARC_EDIT