kicad/pcbnew/class_module_transform_func...

379 lines
10 KiB
C++
Raw Normal View History

2009-08-01 19:26:05 +00:00
/****************************************************
* class_module_transform_functions.cpp :
* functions of class MODULE to handle some geometric changes:
* move, rot ...
****************************************************/
#include "fctsys.h"
#include "wxstruct.h"
#include "common.h"
#include "trigo.h"
#include "pcbcommon.h"
#include "pcbnew.h"
#include "protos.h"
/* Calculate the layer number for changing cu / cmp layers for Cu / CMP
* (Copper, Mask, Paste, solder)
2009-08-01 19:26:05 +00:00
*/
int ChangeSideNumLayer( int oldlayer )
2009-08-01 19:26:05 +00:00
{
int newlayer;
switch( oldlayer )
{
case LAYER_N_BACK:
newlayer = LAYER_N_FRONT;
break;
2009-08-01 19:26:05 +00:00
case LAYER_N_FRONT:
newlayer = LAYER_N_BACK;
break;
2009-08-01 19:26:05 +00:00
case SILKSCREEN_N_BACK:
newlayer = SILKSCREEN_N_FRONT;
break;
2009-08-01 19:26:05 +00:00
case SILKSCREEN_N_FRONT:
newlayer = SILKSCREEN_N_BACK;
break;
2009-08-01 19:26:05 +00:00
case ADHESIVE_N_BACK:
newlayer = ADHESIVE_N_FRONT;
break;
2009-08-01 19:26:05 +00:00
case ADHESIVE_N_FRONT:
newlayer = ADHESIVE_N_BACK;
break;
2009-08-01 19:26:05 +00:00
case SOLDERMASK_N_BACK:
newlayer = SOLDERMASK_N_FRONT;
break;
2009-08-01 19:26:05 +00:00
case SOLDERMASK_N_FRONT:
newlayer = SOLDERMASK_N_BACK;
break;
2009-08-01 19:26:05 +00:00
case SOLDERPASTE_N_BACK:
newlayer = SOLDERPASTE_N_FRONT;
break;
2009-08-01 19:26:05 +00:00
case SOLDERPASTE_N_FRONT:
newlayer = SOLDERPASTE_N_BACK;
break;
2009-08-01 19:26:05 +00:00
default:
newlayer = oldlayer;
}
return newlayer;
}
/* Calculate the mask layer when flipping a footprint
* BACK and FRONT copper layers , mask, paste, solder layers are swapped
2009-08-01 19:26:05 +00:00
*/
int ChangeSideMaskLayer( int masque )
2009-08-01 19:26:05 +00:00
{
int newmasque;
newmasque = masque & ~(LAYER_BACK | LAYER_FRONT |
SILKSCREEN_LAYER_BACK | SILKSCREEN_LAYER_FRONT |
ADHESIVE_LAYER_BACK | ADHESIVE_LAYER_FRONT |
SOLDERMASK_LAYER_BACK | SOLDERMASK_LAYER_FRONT |
SOLDERPASTE_LAYER_BACK | SOLDERPASTE_LAYER_FRONT |
ADHESIVE_LAYER_BACK | ADHESIVE_LAYER_FRONT);
2009-08-01 19:26:05 +00:00
if( masque & LAYER_BACK )
newmasque |= LAYER_FRONT;
if( masque & LAYER_FRONT )
newmasque |= LAYER_BACK;
2009-08-01 19:26:05 +00:00
if( masque & SILKSCREEN_LAYER_BACK )
newmasque |= SILKSCREEN_LAYER_FRONT;
if( masque & SILKSCREEN_LAYER_FRONT )
newmasque |= SILKSCREEN_LAYER_BACK;
if( masque & ADHESIVE_LAYER_BACK )
newmasque |= ADHESIVE_LAYER_FRONT;
if( masque & ADHESIVE_LAYER_FRONT )
newmasque |= ADHESIVE_LAYER_BACK;
if( masque & SOLDERMASK_LAYER_BACK )
newmasque |= SOLDERMASK_LAYER_FRONT;
if( masque & SOLDERMASK_LAYER_FRONT )
newmasque |= SOLDERMASK_LAYER_BACK;
if( masque & SOLDERPASTE_LAYER_BACK )
newmasque |= SOLDERPASTE_LAYER_FRONT;
if( masque & SOLDERPASTE_LAYER_FRONT )
newmasque |= SOLDERPASTE_LAYER_BACK;
if( masque & ADHESIVE_LAYER_BACK )
newmasque |= ADHESIVE_LAYER_FRONT;
if( masque & ADHESIVE_LAYER_FRONT )
newmasque |= ADHESIVE_LAYER_BACK;
2009-08-01 19:26:05 +00:00
return newmasque;
}
/**
* Function Move (virtual)
* move this object.
2010-12-29 17:47:32 +00:00
* @param aMoveVector - the move vector for this object.
2009-08-01 19:26:05 +00:00
*/
void MODULE::Move(const wxPoint& aMoveVector)
{
wxPoint newpos = m_Pos + aMoveVector;
SetPosition( newpos );
}
2009-08-01 19:26:05 +00:00
/**
* Function Rotate
* Rotate this object.
2010-12-29 17:47:32 +00:00
* @param aRotCentre - the rotation point.
2009-08-01 19:26:05 +00:00
* @param aAngle - the rotation angle in 0.1 degree.
*/
void MODULE::Rotate(const wxPoint& aRotCentre, int aAngle)
{
wxPoint newpos = m_Pos;
RotatePoint( &newpos, aRotCentre, aAngle );
SetPosition( newpos );
SetOrientation( m_Orient + aAngle );
}
2009-08-01 19:26:05 +00:00
/**
* Function Flip
* Flip this object, i.e. change the board side for this object
2010-12-29 17:47:32 +00:00
* @param aCentre - the rotation point.
2009-08-01 19:26:05 +00:00
*/
void MODULE::Flip(const wxPoint& aCentre )
{
D_PAD* pt_pad;
TEXTE_MODULE* pt_texte;
EDGE_MODULE* pt_edgmod;
EDA_ITEM* PtStruct;
2009-08-01 19:26:05 +00:00
// Move module to its final position:
wxPoint finalPos = m_Pos;
finalPos.y = aCentre.y - ( finalPos.y - aCentre.y ); /// Mirror the Y position
2009-08-01 19:26:05 +00:00
SetPosition(finalPos);
/* Flip layer */
SetLayer( ChangeSideNumLayer( GetLayer() ) );
/* Reverse mirror orientation. */
2009-08-01 19:26:05 +00:00
NEGATE( m_Orient );
NORMALIZE_ANGLE_POS( m_Orient );
/* Mirror inversion layers pads. */
2009-08-01 19:26:05 +00:00
pt_pad = m_Pads;
for( ; pt_pad != NULL; pt_pad = pt_pad->Next() )
{
pt_pad->m_Pos.y -= m_Pos.y;
pt_pad->m_Pos.y = -pt_pad->m_Pos.y;
pt_pad->m_Pos.y += m_Pos.y;
NEGATE( pt_pad->m_Pos0.y );
NEGATE( pt_pad->m_Offset.y );
NEGATE( pt_pad->m_DeltaSize.y );
2009-08-01 19:26:05 +00:00
NEGATE_AND_NORMALIZE_ANGLE_POS( pt_pad->m_Orient );
/* flip pads layers*/
pt_pad->m_Masque_Layer = ChangeSideMaskLayer( pt_pad->m_Masque_Layer );
}
/* Mirror reference. */
2009-08-01 19:26:05 +00:00
pt_texte = m_Reference;
pt_texte->m_Pos.y -= m_Pos.y;
pt_texte->m_Pos.y = -pt_texte->m_Pos.y;
pt_texte->m_Pos.y += m_Pos.y;
NEGATE(pt_texte->m_Pos0.y);
pt_texte->m_Mirror = false;
NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient );
pt_texte->SetLayer( GetLayer() );
pt_texte->SetLayer( ChangeSideNumLayer( pt_texte->GetLayer() ) );
if( GetLayer() == LAYER_N_BACK )
pt_texte->SetLayer( SILKSCREEN_N_BACK );
2009-08-01 19:26:05 +00:00
if( GetLayer() == LAYER_N_FRONT )
pt_texte->SetLayer( SILKSCREEN_N_FRONT );
2009-08-01 19:26:05 +00:00
if( (GetLayer() == SILKSCREEN_N_BACK)
|| (GetLayer() == ADHESIVE_N_BACK) || (GetLayer() == LAYER_N_BACK) )
2009-08-01 19:26:05 +00:00
pt_texte->m_Mirror = true;
/* Mirror value. */
2009-08-01 19:26:05 +00:00
pt_texte = m_Value;
pt_texte->m_Pos.y -= m_Pos.y;
NEGATE( pt_texte->m_Pos.y );
2009-08-01 19:26:05 +00:00
pt_texte->m_Pos.y += m_Pos.y;
NEGATE( pt_texte->m_Pos0.y );
2009-08-01 19:26:05 +00:00
pt_texte->m_Mirror = false;
NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient );
pt_texte->SetLayer( GetLayer() );
pt_texte->SetLayer( ChangeSideNumLayer( pt_texte->GetLayer() ) );
if( GetLayer() == LAYER_N_BACK )
pt_texte->SetLayer( SILKSCREEN_N_BACK );
2009-08-01 19:26:05 +00:00
if( GetLayer() == LAYER_N_FRONT )
pt_texte->SetLayer( SILKSCREEN_N_FRONT );
2009-08-01 19:26:05 +00:00
if( (GetLayer() == SILKSCREEN_N_BACK)
|| (GetLayer() == ADHESIVE_N_BACK) || (GetLayer() == LAYER_N_BACK) )
2009-08-01 19:26:05 +00:00
pt_texte->m_Mirror = true;
/* Reverse mirror footprints. */
2009-08-01 19:26:05 +00:00
PtStruct = m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
switch( PtStruct->Type() )
{
case TYPE_EDGE_MODULE:
pt_edgmod = (EDGE_MODULE*) PtStruct;
pt_edgmod->m_Start.y -= m_Pos.y;
pt_edgmod->m_Start.y = -pt_edgmod->m_Start.y;
pt_edgmod->m_Start.y += m_Pos.y;
pt_edgmod->m_End.y -= m_Pos.y;
pt_edgmod->m_End.y = -pt_edgmod->m_End.y;
pt_edgmod->m_End.y += m_Pos.y;
NEGATE( pt_edgmod->m_Start0.y );
NEGATE( pt_edgmod->m_End0.y );
2009-08-01 19:26:05 +00:00
if( pt_edgmod->m_Shape == S_ARC )
{
NEGATE(pt_edgmod->m_Angle);
}
pt_edgmod->SetLayer( ChangeSideNumLayer( pt_edgmod->GetLayer() ) );
break;
case TYPE_TEXTE_MODULE:
/* Reverse mirror position and mirror. */
2009-08-01 19:26:05 +00:00
pt_texte = (TEXTE_MODULE*) PtStruct;
pt_texte->m_Pos.y -= m_Pos.y;
pt_texte->m_Pos.y = -pt_texte->m_Pos.y;
pt_texte->m_Pos.y += m_Pos.y;
NEGATE( pt_texte->m_Pos0.y );
2009-08-01 19:26:05 +00:00
pt_texte->m_Mirror = false;
NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient );
pt_texte->SetLayer( GetLayer() );
pt_texte->SetLayer( ChangeSideNumLayer( pt_texte->GetLayer() ) );
if( GetLayer() == LAYER_N_BACK )
pt_texte->SetLayer( SILKSCREEN_N_BACK );
2009-08-01 19:26:05 +00:00
if( GetLayer() == LAYER_N_FRONT )
pt_texte->SetLayer( SILKSCREEN_N_FRONT );
2009-08-01 19:26:05 +00:00
if( GetLayer() == SILKSCREEN_N_BACK
|| GetLayer() == ADHESIVE_N_BACK
|| GetLayer() == LAYER_N_BACK )
2009-08-01 19:26:05 +00:00
{
pt_texte->m_Mirror = true;
}
break;
default:
wxMessageBox( wxT( "MODULE::Flip() error: Unknown Draw Type" ) );
break;
}
}
Set_Rectangle_Encadrement();
}
void MODULE::SetPosition( const wxPoint& newpos )
{
wxPoint delta = newpos - m_Pos;
2009-08-01 19:26:05 +00:00
m_Pos += delta;
m_Reference->m_Pos += delta;
m_Value->m_Pos += delta;
2009-08-01 19:26:05 +00:00
for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
{
pad->m_Pos += delta;
2009-08-01 19:26:05 +00:00
}
EDA_ITEM* PtStruct = m_Drawings;
2009-08-01 19:26:05 +00:00
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
switch( PtStruct->Type() )
{
case TYPE_EDGE_MODULE:
{
EDGE_MODULE* pt_edgmod = (EDGE_MODULE*) PtStruct;
pt_edgmod->SetDrawCoord();
break;
}
case TYPE_TEXTE_MODULE:
{
TEXTE_MODULE* pt_texte = (TEXTE_MODULE*) PtStruct;
pt_texte->m_Pos += delta;
2009-08-01 19:26:05 +00:00
break;
}
default:
wxMessageBox( wxT( "Draw type undefined." ) );
break;
2009-08-01 19:26:05 +00:00
}
}
Set_Rectangle_Encadrement();
}
void MODULE::SetOrientation( int newangle )
{
int px, py;
newangle -= m_Orient; // = Change in rotation
2009-08-01 19:26:05 +00:00
m_Orient += newangle;
NORMALIZE_ANGLE_POS( m_Orient );
for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
{
px = pad->m_Pos0.x;
py = pad->m_Pos0.y;
pad->m_Orient += newangle; /* change m_Orientation */
NORMALIZE_ANGLE_POS( pad->m_Orient );
RotatePoint( &px, &py, m_Orient );
2009-08-01 19:26:05 +00:00
pad->m_Pos.x = m_Pos.x + px;
pad->m_Pos.y = m_Pos.y + py;
}
/* Update of the reference and value. */
2009-08-01 19:26:05 +00:00
m_Reference->SetDrawCoord();
m_Value->SetDrawCoord();
/* Displace contours and text of the footprint. */
2009-08-01 19:26:05 +00:00
for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
{
if( item->Type() == TYPE_EDGE_MODULE )
{
EDGE_MODULE* pt_edgmod = (EDGE_MODULE*) item;
pt_edgmod->SetDrawCoord();
}
if( item->Type() == TYPE_TEXTE_MODULE )
{
TEXTE_MODULE* pt_texte = (TEXTE_MODULE*) item;
pt_texte->SetDrawCoord();
}
}
Set_Rectangle_Encadrement();
}