edit_points.h

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright (C) 2014-2017 CERN
 * Copyright (C) 2020-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Maciej Suminski <[email protected]>
 *
 * 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef EDIT_POINTS_H_
#define EDIT_POINTS_H_

#include <eda_item.h>
#include <layer_ids.h>

#include <list>
#include <deque>
#include <memory>

#include "edit_constraints.h"
#include <view/view.h>


class EDIT_POINT
{
public:
 EDIT_POINT( const VECTOR2I& aPoint, std::pair<EDA_ITEM*, int> aConnected = { nullptr, 0 } ) :
 m_position( aPoint ),
 m_isActive( false ),
 m_isHover( false ),
 m_gridConstraint( SNAP_TO_GRID ),
 m_connected( aConnected )
 {
 }

 virtual ~EDIT_POINT() {}

 virtual VECTOR2I GetPosition() const
 {
 return m_position;
 }

 virtual std::pair<EDA_ITEM*, int> GetConnected() const
 {
 return m_connected;
 }

 inline int GetX() const
 {
 return GetPosition().x;
 }

 inline int GetY() const
 {
 return GetPosition().y;
 }

 virtual void SetPosition( const VECTOR2I& aPosition )
 {
 m_position = aPosition;
 }

 virtual void SetPosition( int x, int y )
 {
 m_position.x = x;
 m_position.y = y;
 }

 bool WithinPoint( const VECTOR2I& aPoint, unsigned int aSize ) const;

 void SetConstraint( EDIT_CONSTRAINT<EDIT_POINT>* aConstraint )
 {
 m_constraint.reset( aConstraint );
 }

 EDIT_CONSTRAINT<EDIT_POINT>* GetConstraint() const
 {
 return m_constraint.get();
 }

 inline void ClearConstraint()
 {
 m_constraint.reset();
 }

 inline bool IsConstrained() const
 {
 return m_constraint != nullptr;
 }

 virtual void ApplyConstraint()
 {
 if( m_constraint )
 m_constraint->Apply();
 }

 bool IsActive() const { return m_isActive; }
 void SetActive( bool aActive = true ) { m_isActive = aActive; }

 bool IsHover() const { return m_isHover; }
 void SetHover( bool aHover = true ) { m_isHover = aHover; }

 GRID_CONSTRAINT_TYPE GetGridConstraint() const { return m_gridConstraint; }
 void SetGridConstraint( GRID_CONSTRAINT_TYPE aConstraint ) { m_gridConstraint = aConstraint; }

 bool operator==( const EDIT_POINT& aOther ) const
 {
 return m_position == aOther.m_position;
 }

 static const int POINT_SIZE = 8;

 static const int BORDER_SIZE = 2;

 static const int HOVER_SIZE = 5;

private:
 VECTOR2I m_position; 
 bool m_isActive; 
 bool m_isHover; 
 GRID_CONSTRAINT_TYPE m_gridConstraint; 

 std::pair<EDA_ITEM*, int> m_connected;

 std::shared_ptr<EDIT_CONSTRAINT<EDIT_POINT> > m_constraint;
};


class EDIT_LINE : public EDIT_POINT
{
public:
 EDIT_LINE( EDIT_POINT& aOrigin, EDIT_POINT& aEnd ) :
 EDIT_POINT( aOrigin.GetPosition()
 + ( aEnd.GetPosition() / 2 - aOrigin.GetPosition() / 2 ) ),
 m_origin( aOrigin ), m_end( aEnd )
 {
 SetGridConstraint( SNAP_BY_GRID );
 }

 virtual VECTOR2I GetPosition() const override
 {
 return m_origin.GetPosition() / 2 + m_end.GetPosition() / 2;
 }

 virtual void SetPosition( const VECTOR2I& aPosition ) override
 {
 VECTOR2I difference = aPosition - GetPosition();

 m_origin.SetPosition( m_origin.GetPosition() + difference );
 m_end.SetPosition( m_end.GetPosition() + difference );
 }

 virtual void ApplyConstraint() override
 {
 if( m_constraint )
 m_constraint->Apply();

 m_origin.ApplyConstraint();
 m_end.ApplyConstraint();
 }

 void SetConstraint( EDIT_CONSTRAINT<EDIT_LINE>* aConstraint )
 {
 m_constraint.reset( aConstraint );
 }

 EDIT_CONSTRAINT<EDIT_LINE>* GetConstraint() const
 {
 return m_constraint.get();
 }

 EDIT_POINT& GetOrigin()
 {
 return m_origin;
 }

 const EDIT_POINT& GetOrigin() const
 {
 return m_origin;
 }

 EDIT_POINT& GetEnd()
 {
 return m_end;
 }

 const EDIT_POINT& GetEnd() const
 {
 return m_end;
 }

 bool operator==( const EDIT_POINT& aOther ) const
 {
 return GetPosition() == aOther.GetPosition();
 }

 bool operator==( const EDIT_LINE& aOther ) const
 {
 return m_origin == aOther.m_origin && m_end == aOther.m_end;
 }

private:
 EDIT_POINT& m_origin; 
 EDIT_POINT& m_end; 

 std::shared_ptr<EDIT_CONSTRAINT<EDIT_LINE> > m_constraint;
};


class EDIT_POINTS : public EDA_ITEM
{
public:
 EDIT_POINTS( EDA_ITEM* aParent );

 EDIT_POINT* FindPoint( const VECTOR2I& aLocation, KIGFX::VIEW *aView );

 EDA_ITEM* GetParent() const
 {
 return m_parent;
 }

 void AddPoint( const EDIT_POINT& aPoint )
 {
 m_points.push_back( aPoint );
 }

 void AddPoint( const VECTOR2I& aPoint, std::pair<EDA_ITEM*, int> aConnected = { nullptr, 0 } )
 {
 AddPoint( EDIT_POINT( aPoint, aConnected ) );
 }

 void AddLine( const EDIT_LINE& aLine )
 {
 m_lines.push_back( aLine );
 }

 void AddLine( EDIT_POINT& aOrigin, EDIT_POINT& aEnd )
 {
 m_lines.emplace_back( aOrigin, aEnd );
 }

 void AddBreak()
 {
 assert( m_points.size() > 0 );
 m_contours.push_back( m_points.size() - 1 );
 }

 int GetContourStartIdx( int aPointIdx ) const;

 int GetContourEndIdx( int aPointIdx ) const;

 bool IsContourStart( int aPointIdx ) const;

 bool IsContourEnd( int aPointIdx ) const;

 EDIT_POINT* Previous( const EDIT_POINT& aPoint, bool aTraverseContours = true );

 EDIT_LINE* Previous( const EDIT_LINE& aLine );

 EDIT_POINT* Next( const EDIT_POINT& aPoint, bool aTraverseContours = true );

 EDIT_LINE* Next( const EDIT_LINE& aLine );

 EDIT_POINT& Point( unsigned int aIndex )
 {
 return m_points[aIndex];
 }

 const EDIT_POINT& Point( unsigned int aIndex ) const
 {
 return m_points[aIndex];
 }

 EDIT_LINE& Line( unsigned int aIndex )
 {
 return m_lines[aIndex];
 }

 const EDIT_LINE& Line( unsigned int aIndex ) const
 {
 return m_lines[aIndex];
 }

 unsigned int PointsSize() const
 {
 return m_points.size();
 }

 unsigned int LinesSize() const
 {
 return m_lines.size();
 }

 virtual const BOX2I ViewBBox() const override;

 virtual void ViewDraw( int aLayer, KIGFX::VIEW* aView ) const override;

 virtual void ViewGetLayers( int aLayers[], int& aCount ) const override
 {
 aCount = 1;
 aLayers[0] = LAYER_GP_OVERLAY ;
 }

#if defined(DEBUG)
 void Show( int x, std::ostream& st ) const override
 {
 }
#endif

 virtual wxString GetClass() const override
 {
 return wxT( "EDIT_POINTS" );
 }

private:
 EDA_ITEM* m_parent; 
 std::deque<EDIT_POINT> m_points; 
 std::deque<EDIT_LINE> m_lines; 
 std::list<int> m_contours; 
 bool m_allowPoints; 
};

#endif /* EDIT_POINTS_H_ */