2012-01-14 19:50:32 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2017-11-16 11:09:24 +00:00
|
|
|
* Copyright (C) 2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
2012-06-08 09:56:42 +00:00
|
|
|
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
2012-01-14 19:50:32 +00:00
|
|
|
* Copyright (C) 2011 Wayne Stambaugh <stambaughw@verizon.net>
|
2017-11-16 11:09:24 +00:00
|
|
|
* Copyright (C) 1992-2017 KiCad Developers, see AUTHORS.txt for contributors.
|
2012-01-14 19:50:32 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2011-09-23 13:57:12 +00:00
|
|
|
/**
|
|
|
|
* @file class_drawsegment.cpp
|
|
|
|
* @brief Class and functions to handle a graphic segments.
|
|
|
|
*/
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <fctsys.h>
|
|
|
|
#include <macros.h>
|
|
|
|
#include <wxstruct.h>
|
|
|
|
#include <gr_basic.h>
|
|
|
|
#include <bezier_curves.h>
|
|
|
|
#include <class_drawpanel.h>
|
2012-02-28 20:14:17 +00:00
|
|
|
#include <class_pcb_screen.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <trigo.h>
|
2013-01-12 17:32:24 +00:00
|
|
|
#include <msgpanel.h>
|
2017-02-20 12:20:39 +00:00
|
|
|
#include <bitmaps.h>
|
2009-02-04 15:25:03 +00:00
|
|
|
|
2017-08-04 12:43:02 +00:00
|
|
|
#include <wxPcbStruct.h>
|
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <pcbnew.h>
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_board.h>
|
|
|
|
#include <class_module.h>
|
|
|
|
#include <class_drawsegment.h>
|
2012-04-27 14:15:11 +00:00
|
|
|
#include <base_units.h>
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2008-12-04 04:28:11 +00:00
|
|
|
DRAWSEGMENT::DRAWSEGMENT( BOARD_ITEM* aParent, KICAD_T idtype ) :
|
|
|
|
BOARD_ITEM( aParent, idtype )
|
2008-01-16 18:48:04 +00:00
|
|
|
{
|
2013-07-29 07:33:56 +00:00
|
|
|
m_Type = 0;
|
|
|
|
m_Angle = 0;
|
2013-03-31 13:27:46 +00:00
|
|
|
m_Flags = 0;
|
2011-08-08 23:50:55 +00:00
|
|
|
m_Shape = S_SEGMENT;
|
2017-11-16 08:38:26 +00:00
|
|
|
// Gives a decent pen size to draw shape:
|
|
|
|
m_Width = m_Shape == S_POLYGON ? 0 : Millimeter2iu( 0.15 );
|
2008-01-16 18:48:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-12-14 04:29:25 +00:00
|
|
|
DRAWSEGMENT::~DRAWSEGMENT()
|
2008-01-16 18:48:04 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-12-18 17:24:25 +00:00
|
|
|
void DRAWSEGMENT::SetPosition( const wxPoint& aPos )
|
|
|
|
{
|
|
|
|
m_Start = aPos;
|
|
|
|
}
|
|
|
|
|
|
|
|
const wxPoint DRAWSEGMENT::GetPosition() const
|
|
|
|
{
|
|
|
|
if( m_Shape == S_POLYGON )
|
|
|
|
return (wxPoint) m_Poly.CVertex( 0 );
|
|
|
|
else
|
|
|
|
return m_Start;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DRAWSEGMENT::Move( const wxPoint& aMoveVector )
|
|
|
|
{
|
|
|
|
m_Start += aMoveVector;
|
|
|
|
m_End += aMoveVector;
|
|
|
|
|
|
|
|
switch ( m_Shape )
|
|
|
|
{
|
|
|
|
case S_POLYGON:
|
|
|
|
for( auto iter = m_Poly.Iterate(); iter; iter++ )
|
|
|
|
{
|
|
|
|
(*iter) += VECTOR2I( aMoveVector );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2011-12-14 04:29:25 +00:00
|
|
|
void DRAWSEGMENT::Rotate( const wxPoint& aRotCentre, double aAngle )
|
2009-08-01 19:26:05 +00:00
|
|
|
{
|
2015-02-12 03:22:24 +00:00
|
|
|
switch( m_Shape )
|
|
|
|
{
|
|
|
|
case S_ARC:
|
|
|
|
case S_SEGMENT:
|
|
|
|
case S_CIRCLE:
|
|
|
|
// these can all be done by just rotating the start and end points
|
|
|
|
RotatePoint( &m_Start, aRotCentre, aAngle);
|
|
|
|
RotatePoint( &m_End, aRotCentre, aAngle);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case S_POLYGON:
|
2017-10-19 21:16:06 +00:00
|
|
|
for( auto iter = m_Poly.Iterate(); iter; iter++ )
|
2015-02-12 03:22:24 +00:00
|
|
|
{
|
2017-10-19 21:16:06 +00:00
|
|
|
RotatePoint( *iter, VECTOR2I(aRotCentre), aAngle);
|
2015-02-12 03:22:24 +00:00
|
|
|
}
|
|
|
|
break;
|
2009-08-01 19:26:05 +00:00
|
|
|
|
2015-02-12 03:22:24 +00:00
|
|
|
case S_CURVE:
|
|
|
|
RotatePoint( &m_Start, aRotCentre, aAngle);
|
|
|
|
RotatePoint( &m_End, aRotCentre, aAngle);
|
|
|
|
|
|
|
|
for( unsigned int ii = 0; ii < m_BezierPoints.size(); ii++ )
|
|
|
|
{
|
|
|
|
RotatePoint( &m_BezierPoints[ii], aRotCentre, aAngle);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case S_RECT:
|
|
|
|
default:
|
|
|
|
// un-handled edge transform
|
|
|
|
wxASSERT_MSG( false, wxT( "DRAWSEGMENT::Rotate not implemented for "
|
|
|
|
+ ShowShape( m_Shape ) ) );
|
|
|
|
break;
|
|
|
|
}
|
2017-11-02 20:41:29 +00:00
|
|
|
}
|
2011-08-08 23:50:55 +00:00
|
|
|
|
|
|
|
void DRAWSEGMENT::Flip( const wxPoint& aCentre )
|
2009-08-01 19:26:05 +00:00
|
|
|
{
|
|
|
|
m_Start.y = aCentre.y - (m_Start.y - aCentre.y);
|
|
|
|
m_End.y = aCentre.y - (m_End.y - aCentre.y);
|
2012-01-14 19:50:32 +00:00
|
|
|
|
2017-12-18 17:24:25 +00:00
|
|
|
switch ( m_Shape )
|
|
|
|
{
|
|
|
|
case S_ARC:
|
2015-06-26 13:41:56 +00:00
|
|
|
m_Angle = -m_Angle;
|
2017-12-18 17:24:25 +00:00
|
|
|
break;
|
|
|
|
case S_POLYGON:
|
|
|
|
for( auto iter = m_Poly.Iterate(); iter; iter++ )
|
|
|
|
{
|
|
|
|
iter->y = aCentre.y - (iter->y - aCentre.y);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2012-01-14 19:50:32 +00:00
|
|
|
|
2015-12-27 15:51:13 +00:00
|
|
|
// DRAWSEGMENT items are not allowed on copper layers, so
|
|
|
|
// copper layers count is not taken in accoun in Flip transform
|
2013-04-05 19:04:58 +00:00
|
|
|
SetLayer( FlipLayer( GetLayer() ) );
|
2009-08-01 19:26:05 +00:00
|
|
|
}
|
|
|
|
|
2015-02-12 03:22:24 +00:00
|
|
|
const wxPoint DRAWSEGMENT::GetCenter() const
|
|
|
|
{
|
|
|
|
wxPoint c;
|
|
|
|
|
|
|
|
switch( m_Shape )
|
|
|
|
{
|
|
|
|
case S_ARC:
|
|
|
|
case S_CIRCLE:
|
|
|
|
c = m_Start;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case S_SEGMENT:
|
|
|
|
// Midpoint of the line
|
|
|
|
c = ( GetStart() + GetEnd() ) / 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case S_POLYGON:
|
|
|
|
case S_RECT:
|
|
|
|
case S_CURVE:
|
|
|
|
c = GetBoundingBox().Centre();
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
wxASSERT_MSG( false, "DRAWSEGMENT::GetCentre not implemented for shape"
|
|
|
|
+ ShowShape( GetShape() ) );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2011-12-14 04:29:25 +00:00
|
|
|
const wxPoint DRAWSEGMENT::GetArcEnd() const
|
|
|
|
{
|
|
|
|
wxPoint endPoint; // start of arc
|
|
|
|
|
|
|
|
switch( m_Shape )
|
|
|
|
{
|
|
|
|
case S_ARC:
|
|
|
|
// rotate the starting point of the arc, given by m_End, through the
|
|
|
|
// angle m_Angle to get the ending point of the arc.
|
|
|
|
// m_Start is the arc centre
|
|
|
|
endPoint = m_End; // m_End = start point of arc
|
|
|
|
RotatePoint( &endPoint, m_Start, -m_Angle );
|
2012-05-22 17:51:18 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2017-12-18 17:24:25 +00:00
|
|
|
break;
|
2011-12-14 04:29:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return endPoint; // after rotation, the end of the arc.
|
|
|
|
}
|
|
|
|
|
2014-02-07 18:55:40 +00:00
|
|
|
double DRAWSEGMENT::GetArcAngleStart() const
|
2008-05-05 19:46:54 +00:00
|
|
|
{
|
2012-07-05 09:29:42 +00:00
|
|
|
// due to the Y axis orient atan2 needs - y value
|
2013-05-01 17:32:36 +00:00
|
|
|
double angleStart = ArcTangente( GetArcStart().y - GetCenter().y,
|
|
|
|
GetArcStart().x - GetCenter().x );
|
2012-07-05 09:29:42 +00:00
|
|
|
|
|
|
|
// Normalize it to 0 ... 360 deg, to avoid discontinuity for angles near 180 deg
|
|
|
|
// because 180 deg and -180 are very near angles when ampping betewwen -180 ... 180 deg.
|
|
|
|
// and this is not easy to handle in calculations
|
2013-05-01 17:32:36 +00:00
|
|
|
NORMALIZE_ANGLE_POS( angleStart );
|
2012-07-05 09:29:42 +00:00
|
|
|
|
|
|
|
return angleStart;
|
2008-05-05 19:46:54 +00:00
|
|
|
}
|
|
|
|
|
2014-02-07 18:55:40 +00:00
|
|
|
|
2011-12-02 21:56:47 +00:00
|
|
|
void DRAWSEGMENT::SetAngle( double aAngle )
|
|
|
|
{
|
2017-10-23 13:35:03 +00:00
|
|
|
// m_Angle must be >= -360 and <= +360 degrees
|
|
|
|
m_Angle = NormalizeAngle360Max( aAngle );
|
2011-12-02 21:56:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-08-08 23:50:55 +00:00
|
|
|
MODULE* DRAWSEGMENT::GetParentModule() const
|
|
|
|
{
|
2017-09-08 18:18:52 +00:00
|
|
|
if( !m_Parent || m_Parent->Type() != PCB_MODULE_T )
|
2011-08-08 23:50:55 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return (MODULE*) m_Parent;
|
|
|
|
}
|
|
|
|
|
2008-05-05 19:46:54 +00:00
|
|
|
|
2012-09-01 13:38:27 +00:00
|
|
|
void DRAWSEGMENT::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE draw_mode,
|
|
|
|
const wxPoint& aOffset )
|
2008-04-01 06:07:00 +00:00
|
|
|
{
|
|
|
|
int ux0, uy0, dx, dy;
|
2011-09-07 19:41:04 +00:00
|
|
|
int l_trace;
|
|
|
|
int radius;
|
2014-06-29 13:05:51 +00:00
|
|
|
|
2017-03-13 03:19:33 +00:00
|
|
|
PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
|
2008-04-01 06:07:00 +00:00
|
|
|
|
2010-01-31 20:01:46 +00:00
|
|
|
BOARD * brd = GetBoard( );
|
2011-08-08 23:50:55 +00:00
|
|
|
|
2010-01-31 20:01:46 +00:00
|
|
|
if( brd->IsLayerVisible( GetLayer() ) == false )
|
2008-04-01 06:07:00 +00:00
|
|
|
return;
|
|
|
|
|
2017-08-04 12:43:02 +00:00
|
|
|
auto frame = static_cast<PCB_EDIT_FRAME*> ( panel->GetParent() );
|
|
|
|
auto color = frame->Settings().Colors().GetLayerColor( GetLayer() );
|
2009-10-10 01:25:53 +00:00
|
|
|
|
2017-10-30 17:21:07 +00:00
|
|
|
auto displ_opts = (PCB_DISPLAY_OPTIONS*) panel->GetDisplayOptions();
|
2015-01-10 10:27:49 +00:00
|
|
|
|
|
|
|
if( ( draw_mode & GR_ALLOW_HIGHCONTRAST ) && displ_opts && displ_opts->m_ContrastModeDisplay )
|
2012-02-28 20:14:17 +00:00
|
|
|
{
|
2014-06-24 16:17:18 +00:00
|
|
|
if( !IsOnLayer( curr_layer ) && !IsOnLayer( Edge_Cuts ) )
|
2017-02-20 16:57:41 +00:00
|
|
|
color = COLOR4D( DARKDARKGRAY );
|
2012-02-28 20:14:17 +00:00
|
|
|
}
|
|
|
|
|
2008-04-01 06:07:00 +00:00
|
|
|
GRSetDrawMode( DC, draw_mode );
|
2014-06-29 13:05:51 +00:00
|
|
|
l_trace = m_Width >> 1; // half trace width
|
2008-04-01 06:07:00 +00:00
|
|
|
|
2010-10-25 07:43:50 +00:00
|
|
|
// Line start point or Circle and Arc center
|
2010-11-11 21:46:55 +00:00
|
|
|
ux0 = m_Start.x + aOffset.x;
|
|
|
|
uy0 = m_Start.y + aOffset.y;
|
2008-04-01 06:07:00 +00:00
|
|
|
|
2010-10-25 07:43:50 +00:00
|
|
|
// Line end point or circle and arc start point
|
2010-11-11 21:46:55 +00:00
|
|
|
dx = m_End.x + aOffset.x;
|
|
|
|
dy = m_End.y + aOffset.y;
|
2008-04-01 06:07:00 +00:00
|
|
|
|
2015-02-02 08:06:39 +00:00
|
|
|
bool filled = displ_opts ? displ_opts->m_DisplayDrawItemsFill : FILLED;
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2008-04-01 06:07:00 +00:00
|
|
|
if( m_Flags & FORCE_SKETCH )
|
2015-02-02 08:06:39 +00:00
|
|
|
filled = SKETCH;
|
2008-04-01 06:07:00 +00:00
|
|
|
|
|
|
|
switch( m_Shape )
|
|
|
|
{
|
|
|
|
case S_CIRCLE:
|
2013-05-01 17:32:36 +00:00
|
|
|
radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2015-02-02 08:06:39 +00:00
|
|
|
if( filled )
|
2008-04-01 06:07:00 +00:00
|
|
|
{
|
2015-02-02 08:06:39 +00:00
|
|
|
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius, m_Width, color );
|
2008-04-01 06:07:00 +00:00
|
|
|
}
|
2015-02-02 08:06:39 +00:00
|
|
|
else
|
2008-04-01 06:07:00 +00:00
|
|
|
{
|
2011-12-29 20:11:42 +00:00
|
|
|
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius - l_trace, color );
|
|
|
|
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius + l_trace, color );
|
2008-04-01 06:07:00 +00:00
|
|
|
}
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2008-04-01 06:07:00 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case S_ARC:
|
2013-05-05 07:17:48 +00:00
|
|
|
double StAngle, EndAngle;
|
2013-05-01 17:32:36 +00:00
|
|
|
radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
|
|
|
|
StAngle = ArcTangente( dy - uy0, dx - ux0 );
|
2009-01-29 14:26:20 +00:00
|
|
|
EndAngle = StAngle + m_Angle;
|
2008-04-01 06:07:00 +00:00
|
|
|
|
2011-12-29 20:11:42 +00:00
|
|
|
if( !panel->GetPrintMirrored() )
|
2009-01-29 14:26:20 +00:00
|
|
|
{
|
|
|
|
if( StAngle > EndAngle )
|
2015-06-26 13:41:56 +00:00
|
|
|
std::swap( StAngle, EndAngle );
|
2009-01-29 14:26:20 +00:00
|
|
|
}
|
2009-11-12 15:43:38 +00:00
|
|
|
else // Mirrored mode: arc orientation is reversed
|
2009-01-29 14:26:20 +00:00
|
|
|
{
|
|
|
|
if( StAngle < EndAngle )
|
2015-06-26 13:41:56 +00:00
|
|
|
std::swap( StAngle, EndAngle );
|
2009-01-29 14:26:20 +00:00
|
|
|
}
|
2008-11-02 19:52:57 +00:00
|
|
|
|
2015-02-02 08:06:39 +00:00
|
|
|
if( filled )
|
2014-11-15 19:06:05 +00:00
|
|
|
{
|
2015-02-02 08:06:39 +00:00
|
|
|
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
|
|
|
|
radius, m_Width, color );
|
2014-11-15 19:06:05 +00:00
|
|
|
}
|
2015-02-02 08:06:39 +00:00
|
|
|
else
|
2009-01-29 14:26:20 +00:00
|
|
|
{
|
2011-12-29 20:11:42 +00:00
|
|
|
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
|
2011-09-07 19:41:04 +00:00
|
|
|
radius - l_trace, color );
|
2011-12-29 20:11:42 +00:00
|
|
|
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
|
2011-09-07 19:41:04 +00:00
|
|
|
radius + l_trace, color );
|
2009-01-29 14:26:20 +00:00
|
|
|
}
|
2015-02-02 08:06:39 +00:00
|
|
|
|
2008-04-01 06:07:00 +00:00
|
|
|
break;
|
2012-12-28 20:52:12 +00:00
|
|
|
|
2009-06-25 20:45:27 +00:00
|
|
|
case S_CURVE:
|
2017-05-16 15:38:19 +00:00
|
|
|
{
|
|
|
|
std::vector<wxPoint> ctrlPoints = { m_Start, m_BezierC1, m_BezierC2, m_End };
|
|
|
|
BEZIER_POLY converter( ctrlPoints );
|
|
|
|
converter.GetPoly( m_BezierPoints );
|
|
|
|
}
|
2012-12-28 20:52:12 +00:00
|
|
|
|
2014-11-15 19:06:05 +00:00
|
|
|
for( unsigned int i=1; i < m_BezierPoints.size(); i++ )
|
|
|
|
{
|
2015-02-02 08:06:39 +00:00
|
|
|
if( filled )
|
2014-11-15 19:06:05 +00:00
|
|
|
{
|
2015-02-02 08:06:39 +00:00
|
|
|
GRFillCSegm( panel->GetClipBox(), DC,
|
|
|
|
m_BezierPoints[i].x, m_BezierPoints[i].y,
|
|
|
|
m_BezierPoints[i-1].x, m_BezierPoints[i-1].y,
|
|
|
|
m_Width, color );
|
2014-11-15 19:06:05 +00:00
|
|
|
}
|
2015-02-02 08:06:39 +00:00
|
|
|
else
|
2012-12-28 20:52:12 +00:00
|
|
|
{
|
|
|
|
GRCSegm( panel->GetClipBox(), DC,
|
|
|
|
m_BezierPoints[i].x, m_BezierPoints[i].y,
|
|
|
|
m_BezierPoints[i-1].x, m_BezierPoints[i-1].y,
|
|
|
|
m_Width, color );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2017-11-16 08:38:26 +00:00
|
|
|
case S_POLYGON:
|
|
|
|
{
|
|
|
|
SHAPE_POLY_SET& outline = GetPolyShape();
|
|
|
|
// Draw the polygon: only one polygon is expected
|
|
|
|
// However we provide a multi polygon shape drawing
|
|
|
|
// ( for the future or to show a non expected shape )
|
|
|
|
for( int jj = 0; jj < outline.OutlineCount(); ++jj )
|
|
|
|
{
|
|
|
|
SHAPE_LINE_CHAIN& poly = outline.Outline( jj );
|
|
|
|
|
|
|
|
GRClosedPoly( panel->GetClipBox(), DC, poly.PointCount(),
|
|
|
|
(wxPoint*)&poly.Point( 0 ), FILLED, GetWidth(),
|
|
|
|
color, color );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2008-04-01 06:07:00 +00:00
|
|
|
default:
|
2015-02-02 08:06:39 +00:00
|
|
|
if( filled )
|
2008-04-01 06:07:00 +00:00
|
|
|
{
|
2015-02-02 08:06:39 +00:00
|
|
|
GRFillCSegm( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
|
2008-04-01 06:07:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-02 08:06:39 +00:00
|
|
|
GRCSegm( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
|
2008-04-01 06:07:00 +00:00
|
|
|
}
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2008-04-01 06:07:00 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
void DRAWSEGMENT::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
|
2008-01-16 18:48:04 +00:00
|
|
|
{
|
|
|
|
wxString msg;
|
2013-04-18 17:03:47 +00:00
|
|
|
wxASSERT( m_Parent );
|
2008-03-04 04:22:27 +00:00
|
|
|
|
2014-11-15 13:09:59 +00:00
|
|
|
msg = _( "Drawing" );
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
aList.push_back( MSG_PANEL_ITEM( _( "Type" ), msg, DARKCYAN ) );
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2008-05-05 19:46:54 +00:00
|
|
|
wxString shape = _( "Shape" );
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
switch( m_Shape )
|
|
|
|
{
|
|
|
|
case S_CIRCLE:
|
|
|
|
aList.push_back( MSG_PANEL_ITEM( shape, _( "Circle" ), RED ) );
|
|
|
|
break;
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
case S_ARC:
|
|
|
|
aList.push_back( MSG_PANEL_ITEM( shape, _( "Arc" ), RED ) );
|
2013-05-01 17:32:36 +00:00
|
|
|
msg.Printf( wxT( "%.1f" ), m_Angle / 10.0 );
|
2014-11-15 19:06:05 +00:00
|
|
|
aList.push_back( MSG_PANEL_ITEM( _( "Angle" ), msg, RED ) );
|
2013-01-12 17:32:24 +00:00
|
|
|
break;
|
2008-05-05 19:46:54 +00:00
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
case S_CURVE:
|
|
|
|
aList.push_back( MSG_PANEL_ITEM( shape, _( "Curve" ), RED ) );
|
|
|
|
break;
|
2008-05-05 19:46:54 +00:00
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
default:
|
2014-11-15 13:09:59 +00:00
|
|
|
{
|
2013-01-12 17:32:24 +00:00
|
|
|
aList.push_back( MSG_PANEL_ITEM( shape, _( "Segment" ), RED ) );
|
2014-11-15 13:09:59 +00:00
|
|
|
|
|
|
|
msg = ::CoordinateToString( GetLineLength( m_Start, m_End ) );
|
|
|
|
aList.push_back( MSG_PANEL_ITEM( _( "Length" ), msg, DARKGREEN ) );
|
|
|
|
|
|
|
|
// angle counter-clockwise from 3'o-clock
|
2016-01-17 15:59:24 +00:00
|
|
|
const double deg = RAD2DEG( atan2( (double)( m_Start.y - m_End.y ),
|
|
|
|
(double)( m_End.x - m_Start.x ) ) );
|
2014-11-15 13:09:59 +00:00
|
|
|
msg.Printf( wxT( "%.1f" ), deg );
|
|
|
|
aList.push_back( MSG_PANEL_ITEM( _( "Angle" ), msg, DARKGREEN ) );
|
|
|
|
}
|
2009-06-25 20:45:27 +00:00
|
|
|
}
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2008-05-05 19:46:54 +00:00
|
|
|
wxString start;
|
|
|
|
start << GetStart();
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2008-05-05 19:46:54 +00:00
|
|
|
wxString end;
|
|
|
|
end << GetEnd();
|
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
aList.push_back( MSG_PANEL_ITEM( start, end, DARKGREEN ) );
|
2013-04-07 11:55:18 +00:00
|
|
|
aList.push_back( MSG_PANEL_ITEM( _( "Layer" ), GetLayerName(), DARKBROWN ) );
|
2013-01-12 17:32:24 +00:00
|
|
|
msg = ::CoordinateToString( m_Width );
|
|
|
|
aList.push_back( MSG_PANEL_ITEM( _( "Width" ), msg, DARKCYAN ) );
|
2008-01-16 18:48:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-24 17:48:14 +00:00
|
|
|
const EDA_RECT DRAWSEGMENT::GetBoundingBox() const
|
2008-01-16 18:48:04 +00:00
|
|
|
{
|
2011-08-08 23:50:55 +00:00
|
|
|
EDA_RECT bbox;
|
|
|
|
|
|
|
|
bbox.SetOrigin( m_Start );
|
2008-01-16 18:48:04 +00:00
|
|
|
|
2011-08-08 23:50:55 +00:00
|
|
|
switch( m_Shape )
|
2011-02-27 19:54:01 +00:00
|
|
|
{
|
2012-05-22 17:51:18 +00:00
|
|
|
case S_SEGMENT:
|
|
|
|
bbox.SetEnd( m_End );
|
|
|
|
break;
|
2009-06-25 20:45:27 +00:00
|
|
|
|
2012-05-22 17:51:18 +00:00
|
|
|
case S_CIRCLE:
|
|
|
|
bbox.Inflate( GetRadius() );
|
|
|
|
break;
|
2009-06-25 20:45:27 +00:00
|
|
|
|
2012-05-22 17:51:18 +00:00
|
|
|
case S_ARC:
|
2015-09-03 21:05:01 +00:00
|
|
|
computeArcBBox( bbox );
|
|
|
|
break;
|
2009-06-25 20:45:27 +00:00
|
|
|
|
2012-05-22 17:51:18 +00:00
|
|
|
case S_POLYGON:
|
2017-10-25 07:39:26 +00:00
|
|
|
if( m_Poly.IsEmpty() )
|
|
|
|
break;
|
2014-11-15 19:06:05 +00:00
|
|
|
{
|
|
|
|
wxPoint p_end;
|
|
|
|
MODULE* module = GetParentModule();
|
2017-10-19 21:16:06 +00:00
|
|
|
bool first = true;
|
2014-11-15 19:06:05 +00:00
|
|
|
|
2017-10-19 21:16:06 +00:00
|
|
|
for( auto iter = m_Poly.CIterate(); iter; iter++ )
|
2011-08-08 23:50:55 +00:00
|
|
|
{
|
2017-10-19 21:16:06 +00:00
|
|
|
wxPoint pt ( iter->x, iter->y );
|
|
|
|
|
2014-11-15 19:06:05 +00:00
|
|
|
if( module ) // Transform, if we belong to a module
|
2011-08-08 23:50:55 +00:00
|
|
|
{
|
2014-11-15 19:06:05 +00:00
|
|
|
RotatePoint( &pt, module->GetOrientation() );
|
|
|
|
pt += module->GetPosition();
|
2012-04-16 12:56:01 +00:00
|
|
|
}
|
|
|
|
|
2017-10-19 21:16:06 +00:00
|
|
|
|
|
|
|
if( first )
|
|
|
|
{
|
2014-11-15 19:06:05 +00:00
|
|
|
p_end = pt;
|
2017-10-19 21:16:06 +00:00
|
|
|
bbox.SetX( pt.x );
|
|
|
|
bbox.SetY( pt.y );
|
|
|
|
first = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-11-15 19:06:05 +00:00
|
|
|
|
2017-10-19 21:16:06 +00:00
|
|
|
bbox.SetX( std::min( bbox.GetX(), pt.x ) );
|
|
|
|
bbox.SetY( std::min( bbox.GetY(), pt.y ) );
|
2014-11-15 19:06:05 +00:00
|
|
|
|
2017-10-19 21:16:06 +00:00
|
|
|
p_end.x = std::max( p_end.x, pt.x );
|
|
|
|
p_end.y = std::max( p_end.y, pt.y );
|
|
|
|
}
|
|
|
|
}
|
2017-10-25 07:39:26 +00:00
|
|
|
|
2014-11-15 19:06:05 +00:00
|
|
|
bbox.SetEnd( p_end );
|
2012-05-22 17:51:18 +00:00
|
|
|
break;
|
2017-10-19 21:16:06 +00:00
|
|
|
}
|
2012-05-22 17:51:18 +00:00
|
|
|
default:
|
2017-05-09 07:28:01 +00:00
|
|
|
break;
|
2011-08-08 23:50:55 +00:00
|
|
|
}
|
|
|
|
|
2012-04-16 12:56:01 +00:00
|
|
|
bbox.Inflate( ((m_Width+1) / 2) + 1 );
|
|
|
|
bbox.Normalize();
|
|
|
|
|
2011-08-08 23:50:55 +00:00
|
|
|
return bbox;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-05-04 17:08:36 +00:00
|
|
|
bool DRAWSEGMENT::HitTest( const wxPoint& aPosition ) const
|
2011-08-08 23:50:55 +00:00
|
|
|
{
|
|
|
|
switch( m_Shape )
|
|
|
|
{
|
|
|
|
case S_CIRCLE:
|
|
|
|
case S_ARC:
|
2014-11-15 19:06:05 +00:00
|
|
|
{
|
|
|
|
wxPoint relPos = aPosition - GetCenter();
|
|
|
|
int radius = GetRadius();
|
|
|
|
int dist = KiROUND( EuclideanNorm( relPos ) );
|
|
|
|
|
|
|
|
if( abs( radius - dist ) <= ( m_Width / 2 ) )
|
2011-08-08 23:50:55 +00:00
|
|
|
{
|
2014-11-15 19:06:05 +00:00
|
|
|
if( m_Shape == S_CIRCLE )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// For arcs, the test point angle must be >= arc angle start
|
|
|
|
// and <= arc angle end
|
|
|
|
// However angle values > 360 deg are not easy to handle
|
|
|
|
// so we calculate the relative angle between arc start point and teast point
|
|
|
|
// this relative arc should be < arc angle if arc angle > 0 (CW arc)
|
|
|
|
// and > arc angle if arc angle < 0 (CCW arc)
|
|
|
|
double arc_angle_start = GetArcAngleStart(); // Always 0.0 ... 360 deg, in 0.1 deg
|
2011-08-08 23:50:55 +00:00
|
|
|
|
2014-11-15 19:06:05 +00:00
|
|
|
double arc_hittest = ArcTangente( relPos.y, relPos.x );
|
|
|
|
|
|
|
|
// Calculate relative angle between the starting point of the arc, and the test point
|
|
|
|
arc_hittest -= arc_angle_start;
|
|
|
|
|
|
|
|
// Normalise arc_hittest between 0 ... 360 deg
|
|
|
|
NORMALIZE_ANGLE_POS( arc_hittest );
|
|
|
|
|
|
|
|
// Check angle: inside the arc angle when it is > 0
|
|
|
|
// and outside the not drawn arc when it is < 0
|
|
|
|
if( GetAngle() >= 0.0 )
|
2012-05-22 17:51:18 +00:00
|
|
|
{
|
2014-11-15 19:06:05 +00:00
|
|
|
if( arc_hittest <= GetAngle() )
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( arc_hittest >= (3600.0 + GetAngle()) )
|
2012-05-22 17:51:18 +00:00
|
|
|
return true;
|
|
|
|
}
|
2011-08-08 23:50:55 +00:00
|
|
|
}
|
2014-11-15 19:06:05 +00:00
|
|
|
}
|
2012-05-22 17:51:18 +00:00
|
|
|
break;
|
2011-08-08 23:50:55 +00:00
|
|
|
|
|
|
|
case S_CURVE:
|
|
|
|
for( unsigned int i= 1; i < m_BezierPoints.size(); i++)
|
|
|
|
{
|
2012-03-15 14:31:16 +00:00
|
|
|
if( TestSegmentHit( aPosition, m_BezierPoints[i-1], m_BezierPoints[i-1], m_Width / 2 ) )
|
2008-01-16 18:48:04 +00:00
|
|
|
return true;
|
2011-08-08 23:50:55 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case S_SEGMENT:
|
2012-03-15 14:31:16 +00:00
|
|
|
if( TestSegmentHit( aPosition, m_Start, m_End, m_Width / 2 ) )
|
2011-08-08 23:50:55 +00:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
|
2015-02-17 16:32:47 +00:00
|
|
|
case S_POLYGON: // not yet handled
|
2017-10-19 21:16:06 +00:00
|
|
|
{
|
|
|
|
#define MAX_DIST_IN_MM 0.25
|
|
|
|
int distmax = Millimeter2iu( 0.25 );
|
|
|
|
SHAPE_POLY_SET::VERTEX_INDEX dummy;
|
|
|
|
auto poly = m_Poly;
|
|
|
|
|
|
|
|
if( poly.CollideVertex( VECTOR2I( aPosition ), dummy, distmax ) )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if( poly.CollideEdge( VECTOR2I( aPosition ), dummy, distmax ) )
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-17 16:32:47 +00:00
|
|
|
break;
|
|
|
|
|
2011-08-08 23:50:55 +00:00
|
|
|
default:
|
2015-02-17 16:32:47 +00:00
|
|
|
wxASSERT_MSG( 0, wxString::Format( "unknown DRAWSEGMENT shape: %d", m_Shape ) );
|
2011-08-08 23:50:55 +00:00
|
|
|
break;
|
2008-01-16 18:48:04 +00:00
|
|
|
}
|
2014-11-15 19:06:05 +00:00
|
|
|
|
2008-01-16 18:48:04 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-21 18:09:41 +00:00
|
|
|
bool DRAWSEGMENT::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
|
2008-01-16 18:48:04 +00:00
|
|
|
{
|
2013-09-21 18:09:41 +00:00
|
|
|
EDA_RECT arect = aRect;
|
2017-04-22 06:49:15 +00:00
|
|
|
arect.Normalize();
|
2013-09-21 18:09:41 +00:00
|
|
|
arect.Inflate( aAccuracy );
|
|
|
|
|
2017-04-20 14:53:57 +00:00
|
|
|
EDA_RECT arcRect;
|
2017-05-09 07:28:01 +00:00
|
|
|
EDA_RECT bb = GetBoundingBox();
|
2017-04-20 14:53:57 +00:00
|
|
|
|
2011-08-08 23:50:55 +00:00
|
|
|
switch( m_Shape )
|
2011-02-27 19:54:01 +00:00
|
|
|
{
|
2012-05-22 17:51:18 +00:00
|
|
|
case S_CIRCLE:
|
2013-09-21 18:09:41 +00:00
|
|
|
// Test if area intersects or contains the circle:
|
|
|
|
if( aContained )
|
2017-05-09 07:28:01 +00:00
|
|
|
return arect.Contains( bb );
|
2013-09-21 18:09:41 +00:00
|
|
|
else
|
2017-04-20 14:53:57 +00:00
|
|
|
{
|
|
|
|
// If the rectangle does not intersect the bounding box, this is a much quicker test
|
2017-05-09 07:28:01 +00:00
|
|
|
if( !aRect.Intersects( bb ) )
|
2017-04-20 14:53:57 +00:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return arect.IntersectsCircleEdge( GetCenter(), GetRadius(), GetWidth() );
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2013-09-21 18:09:41 +00:00
|
|
|
break;
|
2012-03-15 14:31:16 +00:00
|
|
|
|
2013-09-21 18:09:41 +00:00
|
|
|
case S_ARC:
|
|
|
|
|
2017-04-22 05:03:06 +00:00
|
|
|
// Test for full containment of this arc in the rect
|
2013-09-21 18:09:41 +00:00
|
|
|
if( aContained )
|
2017-04-22 05:03:06 +00:00
|
|
|
{
|
2017-05-09 07:28:01 +00:00
|
|
|
return arect.Contains( bb );
|
2017-04-22 05:03:06 +00:00
|
|
|
}
|
|
|
|
// Test if the rect crosses the arc
|
2013-09-21 18:09:41 +00:00
|
|
|
else
|
2017-04-22 05:03:06 +00:00
|
|
|
{
|
2017-05-09 07:28:01 +00:00
|
|
|
arcRect = bb.Common( arect );
|
2017-04-22 05:03:06 +00:00
|
|
|
|
|
|
|
/* All following tests must pass:
|
|
|
|
* 1. Rectangle must intersect arc BoundingBox
|
|
|
|
* 2. Rectangle must cross the outside of the arc
|
|
|
|
*/
|
|
|
|
return arcRect.Intersects( arect ) &&
|
|
|
|
arcRect.IntersectsCircleEdge( GetCenter(), GetRadius(), GetWidth() );
|
|
|
|
}
|
2011-08-08 23:50:55 +00:00
|
|
|
break;
|
2012-05-22 17:51:18 +00:00
|
|
|
case S_SEGMENT:
|
2013-09-21 18:09:41 +00:00
|
|
|
if( aContained )
|
2017-04-23 00:06:56 +00:00
|
|
|
{
|
2013-09-21 18:09:41 +00:00
|
|
|
return arect.Contains( GetStart() ) && aRect.Contains( GetEnd() );
|
2017-04-23 00:06:56 +00:00
|
|
|
}
|
2013-09-21 18:09:41 +00:00
|
|
|
else
|
2017-04-23 00:06:56 +00:00
|
|
|
{
|
|
|
|
// Account for the width of the line
|
|
|
|
arect.Inflate( GetWidth() / 2 );
|
2013-09-21 18:09:41 +00:00
|
|
|
return arect.Intersects( GetStart(), GetEnd() );
|
2017-04-23 00:06:56 +00:00
|
|
|
}
|
2012-03-15 14:31:16 +00:00
|
|
|
|
2012-05-22 17:51:18 +00:00
|
|
|
break;
|
|
|
|
|
2015-02-17 16:32:47 +00:00
|
|
|
case S_CURVE:
|
|
|
|
case S_POLYGON: // not yet handled
|
|
|
|
break;
|
|
|
|
|
2012-05-22 17:51:18 +00:00
|
|
|
default:
|
2015-02-17 16:32:47 +00:00
|
|
|
wxASSERT_MSG( 0, wxString::Format( "unknown DRAWSEGMENT shape: %d", m_Shape ) );
|
|
|
|
break;
|
2011-02-27 19:54:01 +00:00
|
|
|
}
|
2015-02-17 16:32:47 +00:00
|
|
|
|
2008-01-16 18:48:04 +00:00
|
|
|
return false;
|
|
|
|
}
|
2008-01-22 20:36:46 +00:00
|
|
|
|
|
|
|
|
2011-07-14 15:42:44 +00:00
|
|
|
wxString DRAWSEGMENT::GetSelectMenuText() const
|
|
|
|
{
|
|
|
|
wxString text;
|
2012-04-27 14:15:11 +00:00
|
|
|
wxString temp = ::LengthDoubleToString( GetLength() );
|
2011-07-14 15:42:44 +00:00
|
|
|
|
2013-04-07 11:55:18 +00:00
|
|
|
text.Printf( _( "Pcb Graphic: %s, length %s on %s" ),
|
2015-11-04 08:48:34 +00:00
|
|
|
GetChars( ShowShape( m_Shape ) ),
|
2012-04-27 14:15:11 +00:00
|
|
|
GetChars( temp ), GetChars( GetLayerName() ) );
|
2011-07-14 15:42:44 +00:00
|
|
|
|
|
|
|
return text;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-02-20 12:20:39 +00:00
|
|
|
BITMAP_DEF DRAWSEGMENT::GetMenuImage() const
|
|
|
|
{
|
|
|
|
return add_dashed_line_xpm;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-17 14:39:27 +00:00
|
|
|
EDA_ITEM* DRAWSEGMENT::Clone() const
|
2012-01-14 19:50:32 +00:00
|
|
|
{
|
|
|
|
return new DRAWSEGMENT( *this );
|
|
|
|
}
|
2015-09-03 21:05:01 +00:00
|
|
|
|
|
|
|
|
|
|
|
const BOX2I DRAWSEGMENT::ViewBBox() const
|
|
|
|
{
|
|
|
|
// For arcs - do not include the center point in the bounding box,
|
|
|
|
// it is redundant for displaying an arc
|
|
|
|
if( m_Shape == S_ARC )
|
|
|
|
{
|
|
|
|
EDA_RECT bbox;
|
|
|
|
bbox.SetOrigin( m_End );
|
|
|
|
computeArcBBox( bbox );
|
|
|
|
return BOX2I( bbox.GetOrigin(), bbox.GetSize() );
|
|
|
|
}
|
|
|
|
|
|
|
|
return EDA_ITEM::ViewBBox();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void DRAWSEGMENT::computeArcBBox( EDA_RECT& aBBox ) const
|
|
|
|
{
|
2017-02-04 01:42:37 +00:00
|
|
|
// Do not include the center, which is not necessarily
|
|
|
|
// inside the BB of a arc with a small angle
|
|
|
|
aBBox.SetOrigin( m_End );
|
|
|
|
|
2015-09-03 21:05:01 +00:00
|
|
|
wxPoint end = m_End;
|
|
|
|
RotatePoint( &end, m_Start, -m_Angle );
|
|
|
|
aBBox.Merge( end );
|
|
|
|
|
|
|
|
// Determine the starting quarter
|
|
|
|
// 0 right-bottom
|
|
|
|
// 1 left-bottom
|
|
|
|
// 2 left-top
|
|
|
|
// 3 right-top
|
|
|
|
unsigned int quarter = 0; // assume right-bottom
|
|
|
|
|
|
|
|
if( m_End.x < m_Start.x )
|
|
|
|
{
|
|
|
|
if( m_End.y <= m_Start.y )
|
|
|
|
quarter = 2;
|
|
|
|
else // ( m_End.y > m_Start.y )
|
|
|
|
quarter = 1;
|
|
|
|
}
|
|
|
|
else if( m_End.x >= m_Start.x )
|
|
|
|
{
|
|
|
|
if( m_End.y < m_Start.y )
|
|
|
|
quarter = 3;
|
|
|
|
else if( m_End.x == m_Start.x )
|
|
|
|
quarter = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int radius = GetRadius();
|
|
|
|
int angle = (int) GetArcAngleStart() % 900 + m_Angle;
|
|
|
|
bool directionCW = ( m_Angle > 0 ); // Is the direction of arc clockwise?
|
|
|
|
|
|
|
|
// Make the angle positive, so we go clockwise and merge points belonging to the arc
|
|
|
|
if( !directionCW )
|
|
|
|
{
|
|
|
|
angle = 900 - angle;
|
|
|
|
quarter = ( quarter + 3 ) % 4; // -1 modulo arithmetic
|
|
|
|
}
|
|
|
|
|
|
|
|
while( angle > 900 )
|
|
|
|
{
|
|
|
|
switch( quarter )
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
aBBox.Merge( wxPoint( m_Start.x, m_Start.y + radius ) ); // down
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
aBBox.Merge( wxPoint( m_Start.x - radius, m_Start.y ) ); // left
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
aBBox.Merge( wxPoint( m_Start.x, m_Start.y - radius ) ); // up
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
aBBox.Merge( wxPoint( m_Start.x + radius, m_Start.y ) ); // right
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( directionCW )
|
|
|
|
++quarter;
|
|
|
|
else
|
|
|
|
quarter += 3; // -1 modulo arithmetic
|
|
|
|
|
|
|
|
quarter %= 4;
|
|
|
|
angle -= 900;
|
|
|
|
}
|
|
|
|
}
|
2017-10-19 21:16:06 +00:00
|
|
|
|
|
|
|
void DRAWSEGMENT::SetPolyPoints( const std::vector<wxPoint>& aPoints )
|
|
|
|
{
|
|
|
|
m_Poly.RemoveAllContours();
|
|
|
|
m_Poly.NewOutline();
|
2017-10-21 10:46:59 +00:00
|
|
|
|
2017-10-19 21:16:06 +00:00
|
|
|
for ( auto p : aPoints )
|
|
|
|
{
|
|
|
|
m_Poly.Append( p.x, p.y );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::vector<wxPoint> DRAWSEGMENT::GetPolyPoints() const
|
|
|
|
{
|
|
|
|
std::vector<wxPoint> rv;
|
|
|
|
|
2018-01-12 20:25:45 +00:00
|
|
|
if( m_Poly.OutlineCount() )
|
2017-10-19 21:16:06 +00:00
|
|
|
{
|
2018-01-12 20:25:45 +00:00
|
|
|
if( m_Poly.COutline( 0 ).PointCount() )
|
2017-10-21 10:46:59 +00:00
|
|
|
{
|
2018-01-12 20:25:45 +00:00
|
|
|
for ( auto iter = m_Poly.CIterate(); iter; iter++ )
|
|
|
|
{
|
|
|
|
rv.push_back( wxPoint( iter->x, iter->y ) );
|
|
|
|
}
|
2017-10-21 10:46:59 +00:00
|
|
|
}
|
2017-10-19 21:16:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
2017-10-31 13:59:03 +00:00
|
|
|
|
|
|
|
void DRAWSEGMENT::SwapData( BOARD_ITEM* aImage )
|
|
|
|
{
|
|
|
|
assert( aImage->Type() == PCB_LINE_T );
|
|
|
|
|
|
|
|
std::swap( *((DRAWSEGMENT*) this), *((DRAWSEGMENT*) aImage) );
|
|
|
|
}
|