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-2022 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_snapConstraint( OBJECT_LAYERS ),
 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( const GRID_HELPER& aGrid )
 {
 if( m_constraint )
 m_constraint->Apply( aGrid );
 }
 
 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; }
 
 SNAP_CONSTRAINT_TYPE GetSnapConstraint() const { return m_snapConstraint; }
 void SetSnapConstraint( SNAP_CONSTRAINT_TYPE aConstraint ) { m_snapConstraint = aConstraint; }
 
 bool operator==( const EDIT_POINT& aOther ) const
 {
 return m_position == aOther.m_position;
 }
 
 static const int POINT_SIZE = 8;
 
#ifdef __WXMAC__
 static const int BORDER_SIZE = 3; 
 static const int HOVER_SIZE = 6; 
#else
 static const int BORDER_SIZE = 2; 
 static const int HOVER_SIZE = 5; 
#endif
 
private:
 VECTOR2I m_position; 
 bool m_isActive; 
 bool m_isHover; 
 GRID_CONSTRAINT_TYPE m_gridConstraint; 
 SNAP_CONSTRAINT_TYPE m_snapConstraint; 
 
 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( const GRID_HELPER& aGrid ) override
 {
 if( m_constraint )
 m_constraint->Apply( aGrid );
 
 m_origin.ApplyConstraint( aGrid );
 m_end.ApplyConstraint( aGrid );
 }
 
 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 HasCenterPoint() const { return m_hasCenterPoint; }
 
 void SetHasCenterPoint( bool aHasCenterPoint ) { m_hasCenterPoint = aHasCenterPoint; }
 
 bool DrawLine() const { return m_showLine; }
 
 void SetDrawLine( bool aShowLine ) { m_showLine = aShowLine; }
 
 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; 
 
 bool m_hasCenterPoint = true; 
 bool m_showLine = false; 
 
 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 AddIndicatorLine( EDIT_POINT& aOrigin, EDIT_POINT& aEnd )
 {
 EDIT_LINE& line = m_lines.emplace_back( aOrigin, aEnd );
 line.SetHasCenterPoint( false );
 line.SetDrawLine( true );
 }
 
 
 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" );
 }
 
 bool SwapX() const { return m_swapX; }
 void SetSwapX( bool aSwap ) { m_swapX = aSwap; }
 
 bool SwapY() const { return m_swapY; }
 void SetSwapY( bool aSwap ) { m_swapY = aSwap; }
 
private:
 EDA_ITEM* m_parent; 
 bool m_swapX; 
 bool m_swapY; 
 std::deque<EDIT_POINT> m_points; 
 std::deque<EDIT_LINE> m_lines; 
 std::list<int> m_contours; 
 bool m_allowPoints; 
};
 
#endif /* EDIT_POINTS_H_ */