598 lines
15 KiB
C++
598 lines
15 KiB
C++
/**********************************/
|
||
/* classes to handle copper zones */
|
||
/**********************************/
|
||
|
||
#include "fctsys.h"
|
||
#include "wxstruct.h"
|
||
|
||
#include "gr_basic.h"
|
||
|
||
#include "common.h"
|
||
#include "PolyLine.h"
|
||
#include "pcbnew.h"
|
||
#include "trigo.h"
|
||
|
||
/**********************/
|
||
/* Class EDGE_ZONE */
|
||
/**********************/
|
||
/* now used only to create a zone outline
|
||
* TODO: remove this class and use only the ZONE_CONTAINER::m_Poly
|
||
* to create outlines
|
||
*/
|
||
|
||
/* Constructor */
|
||
EDGE_ZONE::EDGE_ZONE( BOARD* parent ) :
|
||
DRAWSEGMENT( parent, TYPEEDGEZONE )
|
||
{
|
||
m_Width = 2; // a minimum for visibility, while dragging
|
||
SetNet(0);
|
||
}
|
||
|
||
|
||
/* Destructor */
|
||
EDGE_ZONE:: ~EDGE_ZONE()
|
||
{
|
||
}
|
||
|
||
/****************************************/
|
||
bool EDGE_ZONE::Save( FILE* aFile ) const
|
||
/****************************************/
|
||
/* edge_zone is a temporary item only used when creating a zone area.
|
||
* it will not saved in file
|
||
*/
|
||
{
|
||
return true;
|
||
}
|
||
|
||
// see pcbstruct.h
|
||
void EDGE_ZONE::Display_Infos( WinEDA_DrawFrame* frame )
|
||
{
|
||
int itype;
|
||
wxString msg;
|
||
|
||
frame->MsgPanel->EraseMsgBox();
|
||
|
||
itype = m_Type & 0x0F;
|
||
|
||
msg = wxT( "Edge Zone" );
|
||
|
||
Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
|
||
|
||
Affiche_1_Parametre( frame, 16, _( "Layer" ),
|
||
ReturnPcbLayerName( GetLayer() ), BROWN );
|
||
|
||
msg.Empty(); msg << GetNet();
|
||
Affiche_1_Parametre( frame, 25, _( "Netcode" ), msg, RED );
|
||
|
||
msg = wxT("???");
|
||
if ( m_Parent )
|
||
{
|
||
EQUIPOT* net = ((BOARD*) m_Parent)->FindNet( GetNet() );
|
||
if( net )
|
||
msg = net->m_Netname;
|
||
}
|
||
Affiche_1_Parametre( frame, 34, _( "Netname" ), msg, RED );
|
||
}
|
||
|
||
/************************/
|
||
/* class ZONE_CONTAINER */
|
||
/************************/
|
||
|
||
ZONE_CONTAINER::ZONE_CONTAINER( BOARD* parent ) :
|
||
BOARD_ITEM( parent, TYPEZONE_CONTAINER )
|
||
|
||
{
|
||
m_NetCode = -1; // Net number for fast comparisons
|
||
m_CornerSelection = -1;
|
||
m_ZoneClearance = 200; // a reasonnable clerance value
|
||
m_GridFillValue = 50; // a reasonnable grid used for filling
|
||
m_PadOption = THERMAL_PAD;
|
||
utility = 0; // flags used in polygon calculations
|
||
utility2 = 0; // flags used in polygon calculations
|
||
m_Poly = new CPolyLine(); // Outlines
|
||
|
||
}
|
||
|
||
|
||
ZONE_CONTAINER::~ZONE_CONTAINER()
|
||
{
|
||
delete m_Poly;
|
||
m_Poly = NULL;
|
||
}
|
||
|
||
|
||
/*******************************************/
|
||
void ZONE_CONTAINER::SetNet( int anet_code )
|
||
/*******************************************/
|
||
/**
|
||
* Set the netcode and the netname
|
||
* if netcode >= 0, set the netname
|
||
* if netcode < 0: keep old netname (used to set an necode error flag)
|
||
*/
|
||
{
|
||
m_NetCode = anet_code;
|
||
|
||
if ( anet_code < 0 ) return;
|
||
|
||
if ( m_Parent )
|
||
{
|
||
EQUIPOT* net = ((BOARD*) m_Parent)->FindNet( anet_code );
|
||
if( net )
|
||
m_Netname = net->m_Netname;
|
||
else m_Netname.Empty();
|
||
}
|
||
else m_Netname.Empty();
|
||
}
|
||
|
||
|
||
|
||
/********************************************/
|
||
bool ZONE_CONTAINER::Save( FILE* aFile ) const
|
||
/********************************************/
|
||
{
|
||
if( GetState( DELETED ) )
|
||
return true;
|
||
|
||
unsigned item_pos;
|
||
int ret;
|
||
unsigned corners_count = m_Poly->corner.size();
|
||
int outline_hatch;
|
||
|
||
fprintf( aFile, "$CZONE_OUTLINE\n");
|
||
// Save the outline main info
|
||
ret = fprintf( aFile, "ZInfo %8.8lX %d \"%s\"\n",
|
||
m_TimeStamp, m_NetCode,
|
||
CONV_TO_UTF8(m_Netname) );
|
||
if ( ret < 3 ) return false;
|
||
// Save the ouline layer info
|
||
ret = fprintf( aFile, "ZLayer %d\n", m_Layer );
|
||
if ( ret < 1 ) return false;
|
||
// Save the ouline aux info
|
||
switch ( m_Poly->GetHatchStyle() )
|
||
{
|
||
default:
|
||
case CPolyLine::NO_HATCH:
|
||
outline_hatch = 'N';
|
||
break;
|
||
case CPolyLine::DIAGONAL_EDGE:
|
||
outline_hatch = 'E';
|
||
break;
|
||
case CPolyLine::DIAGONAL_FULL:
|
||
outline_hatch = 'F';
|
||
break;
|
||
}
|
||
|
||
ret = fprintf( aFile, "ZAux %d %c\n", corners_count, outline_hatch );
|
||
if ( ret < 2 ) return false;
|
||
// Save the corner list
|
||
for ( item_pos = 0; item_pos < corners_count; item_pos++ )
|
||
{
|
||
ret = fprintf( aFile, "ZCorner %d %d %d \n",
|
||
m_Poly->corner[item_pos].x, m_Poly->corner[item_pos].y,
|
||
m_Poly->corner[item_pos].end_contour );
|
||
if ( ret < 3 ) return false;
|
||
}
|
||
fprintf( aFile, "$endCZONE_OUTLINE\n");
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
/**********************************************************/
|
||
int ZONE_CONTAINER::ReadDescr( FILE* aFile, int* aLineNum )
|
||
/**********************************************************/
|
||
/** Function ReadDescr
|
||
* @param aFile = opened file
|
||
* @param aLineNum = pointer on a line number counter (can be NULL or missing)
|
||
* @return 0 if ok or NULL
|
||
*/
|
||
{
|
||
char Line[1024], * text;
|
||
char netname_buffer[1024];
|
||
int ret;
|
||
int n_corner_item = 0;
|
||
int outline_hatch = CPolyLine::NO_HATCH;
|
||
bool error = false, has_corner = false;
|
||
|
||
netname_buffer[0] = 0;
|
||
while( GetLine( aFile, Line, aLineNum, sizeof(Line) - 1 ) != NULL )
|
||
{
|
||
if( strnicmp(Line, "ZCorner", 7 ) == 0 ) // new corner found
|
||
{
|
||
int x = 0, y = 0, flag = 0;
|
||
text = Line + 7;
|
||
ret = sscanf( text, "%d %d %d", &x, &y, &flag);
|
||
if (ret < 3 ) error = true;
|
||
else
|
||
{
|
||
if ( ! has_corner )
|
||
m_Poly->Start( m_Layer, 0, 0,
|
||
x, y,
|
||
outline_hatch );
|
||
else
|
||
m_Poly->AppendCorner( x, y );
|
||
has_corner = true;
|
||
if ( flag ) m_Poly->Close();
|
||
}
|
||
}
|
||
if( strnicmp(Line, "ZInfo", 5 ) == 0 ) // general info found
|
||
{
|
||
int ts = 0, netcode = 0;
|
||
text = Line + 5;
|
||
ret = sscanf( text, "%X %d %s", &ts, &netcode, netname_buffer);
|
||
if (ret < 3 ) error = true;
|
||
else
|
||
{
|
||
m_TimeStamp = ts;
|
||
m_NetCode = netcode;
|
||
ReadDelimitedText( netname_buffer, netname_buffer, 1024 );
|
||
m_Netname = CONV_FROM_UTF8(netname_buffer);
|
||
}
|
||
}
|
||
if( strnicmp(Line, "ZLayer", 6 ) == 0 ) // layer found
|
||
{
|
||
int x = 0;
|
||
text = Line + 6;
|
||
ret = sscanf( text, "%d", &x);
|
||
if (ret < 1 ) error = true;
|
||
else m_Layer = x;
|
||
}
|
||
if( strnicmp(Line, "ZAux", 4 ) == 0 ) // aux info found
|
||
{
|
||
int x = 0;
|
||
char hopt[10];
|
||
text = Line + 4;
|
||
ret = sscanf( text, "%d %c", &x, hopt );
|
||
if (ret < 2 ) error = true;
|
||
else
|
||
{
|
||
n_corner_item = x;
|
||
switch ( hopt[0] )
|
||
{
|
||
case 'n':
|
||
case 'N':
|
||
outline_hatch = CPolyLine::NO_HATCH;
|
||
break;
|
||
case 'e':
|
||
case 'E':
|
||
outline_hatch = CPolyLine::DIAGONAL_EDGE;
|
||
break;
|
||
case 'f':
|
||
case 'F':
|
||
outline_hatch = CPolyLine::DIAGONAL_FULL;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if( strnicmp(Line, "$end", 4 ) == 0 ) // end of description
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
return error ? 0 : 1;
|
||
}
|
||
|
||
|
||
/****************************************************************************************************/
|
||
void ZONE_CONTAINER::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode )
|
||
/****************************************************************************************************/
|
||
|
||
/** Function Draw
|
||
* @param panel = current Draw Panel
|
||
* @param DC = current Device Context
|
||
* @param offset = Draw offset (usually wxPoint(0,0))
|
||
* @param draw_mode = draw mode: OR, XOR ..
|
||
*/
|
||
{
|
||
int curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
|
||
int color = g_DesignSettings.m_LayerColor[m_Layer];
|
||
|
||
if( ( color & (ITEM_NOT_SHOW | HIGHT_LIGHT_FLAG) ) == ITEM_NOT_SHOW )
|
||
return;
|
||
|
||
GRSetDrawMode( DC, draw_mode );
|
||
|
||
if( DisplayOpt.ContrastModeDisplay )
|
||
{
|
||
if( !IsOnLayer( curr_layer ) )
|
||
{
|
||
color &= ~MASKCOLOR;
|
||
color |= DARKDARKGRAY;
|
||
}
|
||
}
|
||
|
||
if( draw_mode & GR_SURBRILL )
|
||
{
|
||
if( draw_mode & GR_AND )
|
||
color &= ~HIGHT_LIGHT_FLAG;
|
||
else
|
||
color |= HIGHT_LIGHT_FLAG;
|
||
}
|
||
if( color & HIGHT_LIGHT_FLAG )
|
||
color = ColorRefs[color & MASKCOLOR].m_LightColor;
|
||
|
||
// draw the lines
|
||
int i_start_contour = 0;
|
||
for( unsigned ic = 0; ic < m_Poly->corner.size(); ic++ )
|
||
{
|
||
int xi = m_Poly->corner[ic].x + offset.x;
|
||
int yi = m_Poly->corner[ic].y + offset.y;
|
||
int xf, yf;
|
||
if( m_Poly->corner[ic].end_contour == FALSE && ic < m_Poly->corner.size() - 1 )
|
||
{
|
||
xf = m_Poly->corner[ic + 1].x + offset.x;
|
||
yf = m_Poly->corner[ic + 1].y + offset.y;
|
||
}
|
||
else
|
||
{
|
||
xf = m_Poly->corner[i_start_contour].x + offset.x;
|
||
yf = m_Poly->corner[i_start_contour].y + offset.y;
|
||
i_start_contour = ic + 1;
|
||
}
|
||
GRLine( &panel->m_ClipBox, DC, xi, yi, xf, yf, 0, color );
|
||
}
|
||
|
||
// draw hatches
|
||
for( unsigned ic = 0; ic < m_Poly->m_HatchLines.size(); ic++ )
|
||
{
|
||
int xi = m_Poly->m_HatchLines[ic].xi + offset.x;
|
||
int yi = m_Poly->m_HatchLines[ic].yi + offset.y;
|
||
int xf = m_Poly->m_HatchLines[ic].xf + offset.x;
|
||
int yf =m_Poly->m_HatchLines[ic].yf + offset.y;
|
||
GRLine( &panel->m_ClipBox, DC, xi, yi, xf, yf, 0, color );
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/**
|
||
* Function HitTest
|
||
* tests if the given wxPoint is within the bounds of this object.
|
||
* @param refPos A wxPoint to test
|
||
* @return bool - true if a hit, else false
|
||
* return true if refPos is near a corner or an edge
|
||
*/
|
||
bool ZONE_CONTAINER::HitTest( const wxPoint& refPos )
|
||
{
|
||
if( HitTestForCorner( refPos ) >= 0 )
|
||
return true;
|
||
if( HitTestForEdge( refPos ) >= 0 )
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
/**
|
||
* Function HitTestForCorner
|
||
* tests if the given wxPoint near a corner, or near the segment define by 2 corners.
|
||
* "near" means CORNER_MIN_DIST_IN_PIXELS pixels
|
||
* @return -1 if none, corner index in .corner <vector>
|
||
* @param refPos : A wxPoint to test
|
||
*/
|
||
int ZONE_CONTAINER::HitTestForCorner( const wxPoint& refPos )
|
||
{
|
||
#define CORNER_MIN_DIST 500 // distance (in internal units) to detect a corner in a zone outline
|
||
int dist;
|
||
unsigned item_pos, lim;
|
||
lim = m_Poly->corner.size();
|
||
m_CornerSelection = -1;
|
||
|
||
for ( item_pos = 0; item_pos < lim; item_pos++ )
|
||
{
|
||
dist = abs( m_Poly->corner[item_pos].x - refPos.x ) + abs( m_Poly->corner[item_pos].y - refPos.y );
|
||
if( dist <= CORNER_MIN_DIST )
|
||
{
|
||
m_CornerSelection = item_pos;
|
||
return item_pos;
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
/**
|
||
* Function HitTestForEdge
|
||
* tests if the given wxPoint near a corner, or near the segment define by 2 corners.
|
||
* "near" means EDGE_MIN_DIST_IN_PIXELS pixels
|
||
* @return -1 if none, or index of the starting corner in .corner <vector>
|
||
* @param refPos : A wxPoint to test
|
||
*/
|
||
int ZONE_CONTAINER::HitTestForEdge( const wxPoint& refPos )
|
||
{
|
||
#define EDGE_MIN_DIST 200 // distance (in internal units) to detect a zone outline
|
||
int dist;
|
||
unsigned item_pos, lim;
|
||
lim = m_Poly->corner.size();
|
||
|
||
/* Test for an entire segment */
|
||
unsigned first_corner_pos = 0, end_segm;
|
||
m_CornerSelection = -1;
|
||
|
||
for ( item_pos = 0; item_pos < lim; item_pos++ )
|
||
{
|
||
end_segm = item_pos+1;
|
||
/* the last corner of the current outline is tested
|
||
* the last segment of the current outline starts at current corner, and ends
|
||
* at the first corner of the outline
|
||
*/
|
||
if( m_Poly->corner[item_pos].end_contour || end_segm >= lim)
|
||
{
|
||
unsigned tmp = first_corner_pos;
|
||
first_corner_pos = end_segm; // first_corner_pos is now the beginning of the next outline
|
||
end_segm = tmp; // end_segm is the beginning of the current outline
|
||
}
|
||
|
||
/* test the dist between segment and ref point */
|
||
dist = (int) GetPointToLineSegmentDistance( refPos.x,
|
||
refPos.y,
|
||
m_Poly->corner[item_pos].x,
|
||
m_Poly->corner[item_pos].y,
|
||
m_Poly->corner[end_segm].x,
|
||
m_Poly->corner[end_segm].y );
|
||
if( dist <= EDGE_MIN_DIST )
|
||
{
|
||
m_CornerSelection = item_pos;
|
||
return item_pos;
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
/**
|
||
* Function HitTest (overlayed)
|
||
* tests if the given EDA_Rect contains the bounds of this object.
|
||
* @param refArea : the given EDA_Rect
|
||
* @return bool - true if a hit, else false
|
||
*/
|
||
bool ZONE_CONTAINER::HitTest( EDA_Rect& refArea )
|
||
{
|
||
bool is_out_of_box = false;
|
||
|
||
CRect rect = m_Poly->GetCornerBounds();
|
||
|
||
if( rect.left < refArea.GetX() )
|
||
is_out_of_box = true;
|
||
if( rect.top < refArea.GetY() )
|
||
is_out_of_box = true;
|
||
if( rect.right > refArea.GetRight() )
|
||
is_out_of_box = true;
|
||
if( rect.bottom > refArea.GetBottom() )
|
||
is_out_of_box = true;
|
||
|
||
return is_out_of_box ? false : true;
|
||
}
|
||
|
||
/************************************************************/
|
||
void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame )
|
||
/************************************************************/
|
||
{
|
||
wxString msg;
|
||
int text_pos;
|
||
|
||
frame->MsgPanel->EraseMsgBox();
|
||
|
||
msg = _( "Zone Outline" );
|
||
|
||
int ncont = m_Poly->GetContour(m_CornerSelection);
|
||
if ( ncont ) msg << wxT(" ") << _("(Cutout)");
|
||
|
||
text_pos = 1;
|
||
Affiche_1_Parametre( frame, text_pos, _( "Type" ), msg, DARKCYAN );
|
||
|
||
text_pos += 15;
|
||
|
||
if ( GetNet() >= 0 )
|
||
{
|
||
EQUIPOT* equipot = ( (WinEDA_PcbFrame*) frame )->m_Pcb->FindNet( GetNet() );
|
||
|
||
if( equipot )
|
||
msg = equipot->m_Netname;
|
||
else
|
||
msg = wxT( "<noname>" );
|
||
}
|
||
else // a netcode <<3C> is an error
|
||
{
|
||
msg = wxT( " [" );
|
||
msg << m_Netname + wxT( "]" );
|
||
msg << wxT(" <") << _("Not Found") << wxT(">");
|
||
}
|
||
|
||
Affiche_1_Parametre( frame, text_pos, _( "NetName" ), msg, RED );
|
||
|
||
/* Display net code : (usefull in test or debug) */
|
||
text_pos += 18;
|
||
msg.Printf( wxT( "%d" ), GetNet());
|
||
Affiche_1_Parametre( frame, text_pos, _( "NetCode" ), msg, RED );
|
||
|
||
text_pos += 8;
|
||
msg = ReturnPcbLayerName( m_Layer );
|
||
Affiche_1_Parametre( frame, text_pos, _( "Layer" ), msg, BROWN );
|
||
|
||
text_pos += 8;
|
||
msg.Printf( wxT( "%d" ), m_Poly->corner.size() );
|
||
Affiche_1_Parametre( frame, text_pos, _( "Corners" ), msg, BLUE );
|
||
|
||
text_pos += 8;
|
||
msg.Printf( wxT( "%d" ), m_Poly->m_HatchLines.size() );
|
||
Affiche_1_Parametre( frame, text_pos, _( "Hatch lines" ), msg, BLUE );
|
||
}
|
||
|
||
|
||
/* Geometric transformations: */
|
||
/**
|
||
* Function Move
|
||
* Move the outlines
|
||
* @param offset = moving vector
|
||
*/
|
||
void ZONE_CONTAINER::Move(const wxPoint& offset )
|
||
{
|
||
for ( unsigned ii = 0; ii < m_Poly->corner.size(); ii++ )
|
||
{
|
||
m_Poly->corner[ii].x += offset.x;
|
||
m_Poly->corner[ii].y += offset.y;
|
||
}
|
||
m_Poly->Hatch();
|
||
}
|
||
|
||
/**
|
||
* Function Move
|
||
* Move the outlines
|
||
* @param centre = rot centre
|
||
* @param angle = in 0.1 degree
|
||
*/
|
||
void ZONE_CONTAINER::Rotate( const wxPoint& centre, int angle)
|
||
{
|
||
for ( unsigned ii = 0; ii < m_Poly->corner.size(); ii++ )
|
||
{
|
||
wxPoint pos;
|
||
pos.x = m_Poly->corner[ii].x;
|
||
pos.y = m_Poly->corner[ii].y;
|
||
RotatePoint(&pos, centre, angle );
|
||
m_Poly->corner[ii].x = pos.x;
|
||
m_Poly->corner[ii].y = pos.y;
|
||
}
|
||
|
||
m_Poly->Hatch();
|
||
}
|
||
|
||
|
||
/**
|
||
* Function Mirror
|
||
* flip the outlines , relative to a given horizontal axis
|
||
* @param mirror_ref = vertical axis position
|
||
*/
|
||
void ZONE_CONTAINER::Mirror( const wxPoint& mirror_ref)
|
||
{
|
||
for ( unsigned ii = 0; ii < m_Poly->corner.size(); ii++ )
|
||
{
|
||
m_Poly->corner[ii].y -= mirror_ref.y;
|
||
m_Poly->corner[ii].y = - m_Poly->corner[ii].y;
|
||
m_Poly->corner[ii].y += mirror_ref.y;
|
||
}
|
||
m_Poly->Hatch();
|
||
}
|
||
|
||
|
||
/** Function copy
|
||
* copy usefull data from the source.
|
||
* flags and linked list pointers are NOT copied
|
||
*/
|
||
void ZONE_CONTAINER::Copy( ZONE_CONTAINER * src )
|
||
{
|
||
m_Parent = src->m_Parent;
|
||
m_Layer = src->m_Layer;
|
||
SetNet(src->GetNet());
|
||
m_TimeStamp = src->m_TimeStamp;
|
||
m_Poly->Copy(src->m_Poly); // copy outlines
|
||
m_CornerSelection = -1; // For corner moving, corner index to drag, or -1 if no selection
|
||
m_ZoneClearance = src->m_ZoneClearance; // clearance value
|
||
m_GridFillValue = src->m_GridFillValue; // Grid used for filling
|
||
m_PadOption = src->m_PadOption;
|
||
m_Poly->SetHatch(src->m_Poly->GetHatchStyle());
|
||
}
|
||
|
||
|