haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/pcbnew/block.cpp

1289 lines
40 KiB
C++
Raw Blame History

/*****************************************************************/
/* Operations sur Blocks : deplacement, rotation, effacement ... */
/*****************************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "class_drawpanel.h"
#include "confirm.h"
#include "block_commande.h"
#include "pcbnew.h"
#include "autorout.h"
#include "pcbplot.h"
#include "trigo.h"
#include "protos.h"
#define BLOCK_COLOR BROWN
/* Routines Locales */
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
/* Variables locales :*/
static bool Block_Include_Modules = TRUE;
static bool Block_Include_Tracks = TRUE;
static bool Block_Include_Zones = TRUE;
static bool Block_Include_Draw_Items = TRUE;
static bool Block_Include_Edges_Items = TRUE;
static bool Block_Include_PcbTextes = TRUE;
/************************************/
/* class WinEDA_ExecBlockCmdFrame */
/************************************/
class WinEDA_ExecBlockCmdFrame : public wxDialog
{
private:
WinEDA_BasePcbFrame* m_Parent;
wxCheckBox* m_Include_Modules;
wxCheckBox* m_Include_Tracks;
wxCheckBox* m_Include_Zones;
wxCheckBox* m_Include_Draw_Items;
wxCheckBox* m_Include_Edges_Items;
wxCheckBox* m_Include_PcbTextes;
public:
// Constructor and destructor
WinEDA_ExecBlockCmdFrame( WinEDA_BasePcbFrame* parent,
const wxString& title );
~WinEDA_ExecBlockCmdFrame()
{
}
private:
void ExecuteCommand( wxCommandEvent& event );
void Cancel( wxCommandEvent& event );
DECLARE_EVENT_TABLE()
};
BEGIN_EVENT_TABLE( WinEDA_ExecBlockCmdFrame, wxDialog )
EVT_BUTTON( wxID_OK, WinEDA_ExecBlockCmdFrame::ExecuteCommand )
EVT_BUTTON( wxID_CANCEL, WinEDA_ExecBlockCmdFrame::Cancel )
END_EVENT_TABLE()
/**************************************************************/
static bool InstallBlockCmdFrame( WinEDA_BasePcbFrame* parent,
const wxString& title )
/**************************************************************/
{
int nocmd;
wxPoint oldpos = parent->GetScreen()->m_Curseur;
parent->DrawPanel->m_IgnoreMouseEvents = TRUE;
WinEDA_ExecBlockCmdFrame* frame = new WinEDA_ExecBlockCmdFrame( parent, title );
nocmd = frame->ShowModal();
frame->Destroy();
parent->GetScreen()->m_Curseur = oldpos;
parent->DrawPanel->MouseToCursorSchema();
parent->DrawPanel->m_IgnoreMouseEvents = FALSE;
parent->DrawPanel->SetCursor(
parent->DrawPanel->m_PanelCursor = parent->DrawPanel->m_PanelDefaultCursor );
return nocmd ? FALSE : TRUE;
}
/******************************************************************************/
WinEDA_ExecBlockCmdFrame::WinEDA_ExecBlockCmdFrame( WinEDA_BasePcbFrame* parent,
const wxString& title ) :
wxDialog( parent, -1, title, wxPoint( -1, -1 ), wxDefaultSize,
DIALOG_STYLE )
/******************************************************************************/
{
wxPoint pos;
wxButton* m_button1;
wxButton* m_button2;
m_Parent = parent;
SetFont( *g_DialogFont );
Centre();
this->SetSizeHints( wxDefaultSize, wxDefaultSize );
this->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxEmptyString ) );
/* Sizer 1 creation */
wxFlexGridSizer* fgSizer1;
fgSizer1 = new wxFlexGridSizer( 1, 1, 0, 0 );
fgSizer1->SetFlexibleDirection( wxBOTH );
fgSizer1->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
// Selection des options :
m_Include_Modules = new wxCheckBox( this, -1, _( "Include Modules" ), wxDefaultPosition, wxDefaultSize, 0 );
m_Include_Modules->SetValue( Block_Include_Modules );
fgSizer1->Add( m_Include_Modules, 0, wxALL, 5 );
m_Include_Tracks = new wxCheckBox( this, -1, _( "Include tracks" ), wxDefaultPosition, wxDefaultSize, 0 );
m_Include_Tracks->SetValue( Block_Include_Tracks );
fgSizer1->Add( m_Include_Tracks, 0, wxALL, 5 );
m_Include_Zones = new wxCheckBox( this, -1, _( "Include zones" ), wxDefaultPosition, wxDefaultSize, 0 );
m_Include_Zones->SetValue( Block_Include_Zones );
fgSizer1->Add( m_Include_Zones, 0, wxALL, 5 );
m_Include_PcbTextes = new wxCheckBox( this, -1,
_( "Include Text on copper layers" ), wxDefaultPosition, wxDefaultSize, 0 );
m_Include_PcbTextes->SetValue( Block_Include_PcbTextes );
fgSizer1->Add( m_Include_PcbTextes, 0, wxALL, 5 );
m_Include_Draw_Items = new wxCheckBox( this, -1, _( "Include drawings" ), wxDefaultPosition, wxDefaultSize, 0 );
m_Include_Draw_Items->SetValue( Block_Include_Draw_Items );
fgSizer1->Add( m_Include_Draw_Items, 0, wxALL, 5 );
m_Include_Edges_Items = new wxCheckBox( this, -1, _( "Include board outline layer" ), wxDefaultPosition, wxDefaultSize, 0 );
m_Include_Edges_Items->SetValue( Block_Include_Edges_Items );
fgSizer1->Add( m_Include_Edges_Items, 0, wxALL, 5 );
/* Sizer 2 creation */
wxFlexGridSizer* fgSizer2;
fgSizer2 = new wxFlexGridSizer( 1, 2, 0, 0 );
fgSizer2->SetFlexibleDirection( wxBOTH );
fgSizer2->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
/* Creation des boutons de commande */
m_button2 = new wxButton( this, wxID_CANCEL, _( "Cancel" ), wxDefaultPosition, wxDefaultSize, 0 );
m_button2->SetForegroundColour( *wxBLUE );
fgSizer2->Add( m_button2, 0, wxALL, 5 );
m_button1 = new wxButton( this, wxID_OK, _( "OK" ), wxDefaultPosition, wxDefaultSize, 0 );
m_button1->SetForegroundColour( *wxRED );
m_button1->SetDefault();
fgSizer2->Add( m_button1, 0, wxALL, 5 );
fgSizer1->Add( fgSizer2, 1, wxALIGN_RIGHT, 5 );
this->SetSizer( fgSizer1 );
this->Layout();
fgSizer1->Fit( this );
}
/**********************************************************************/
void WinEDA_ExecBlockCmdFrame::Cancel( wxCommandEvent& WXUNUSED (event) )
/**********************************************************************/
{
EndModal( -1 );
}
/*******************************************************************/
void WinEDA_ExecBlockCmdFrame::ExecuteCommand( wxCommandEvent& event )
/*******************************************************************/
{
Block_Include_Modules = m_Include_Modules->GetValue();
Block_Include_Tracks = m_Include_Tracks->GetValue();
Block_Include_Zones = m_Include_Zones->GetValue();
Block_Include_Draw_Items = m_Include_Draw_Items->GetValue();
Block_Include_Edges_Items = m_Include_Edges_Items->GetValue();
Block_Include_PcbTextes = m_Include_PcbTextes->GetValue();
EndModal( 0 );
}
/*************************************************/
int WinEDA_PcbFrame::ReturnBlockCommand( int key )
/*************************************************/
/* Return the block command (BLOCK_MOVE, BLOCK_COPY...) corresponding to
* the key (ALT, SHIFT ALT ..)
*/
{
int cmd = 0;
switch( key )
{
default:
cmd = key & 0x255;
break;
case 0:
cmd = BLOCK_MOVE;
break;
case GR_KB_SHIFT:
cmd = BLOCK_COPY;
break;
case GR_KB_CTRL:
cmd = BLOCK_ROTATE;
break;
case GR_KB_SHIFTCTRL:
cmd = BLOCK_DELETE;
break;
case GR_KB_ALT:
cmd = BLOCK_INVERT;
break;
case MOUSE_MIDDLE:
cmd = BLOCK_ZOOM;
break;
}
return cmd;
}
/*****************************************************/
void WinEDA_PcbFrame::HandleBlockPlace( wxDC* DC )
/*****************************************************/
/* Routine to handle the BLOCK PLACE commande */
{
bool err = FALSE;
if( DrawPanel->ManageCurseur == NULL )
{
err = TRUE;
DisplayError( this, wxT( "Error in HandleBlockPLace : ManageCurseur = NULL" ) );
}
GetScreen()->BlockLocate.m_State = STATE_BLOCK_STOP;
switch( GetScreen()->BlockLocate.m_Command )
{
case BLOCK_IDLE:
err = TRUE;
break;
case BLOCK_DRAG: /* Drag */
case BLOCK_MOVE: /* Move */
case BLOCK_PRESELECT_MOVE: /* Move with preselection list*/
if( DrawPanel->ManageCurseur )
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
Block_Move( DC );
GetScreen()->BlockLocate.m_BlockDrawStruct = NULL;
break;
case BLOCK_COPY: /* Copy */
if( DrawPanel->ManageCurseur )
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
Block_Duplicate( DC );
GetScreen()->BlockLocate.m_BlockDrawStruct = NULL;
break;
case BLOCK_PASTE:
break;
case BLOCK_ZOOM: // Handled by HandleBlockEnd()
default:
break;
}
GetScreen()->SetModify();
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
GetScreen()->BlockLocate.m_Flags = 0;
GetScreen()->BlockLocate.m_State = STATE_NO_BLOCK;
GetScreen()->BlockLocate.m_Command = BLOCK_IDLE;
if( GetScreen()->BlockLocate.m_BlockDrawStruct )
{
DisplayError( this, wxT( "Error in HandleBlockPLace DrawStruct != NULL" ) );
GetScreen()->BlockLocate.m_BlockDrawStruct = NULL;
}
DisplayToolMsg( wxEmptyString );
}
/**********************************************/
int WinEDA_PcbFrame::HandleBlockEnd( wxDC* DC )
/**********************************************/
/* Routine de gestion de la commande BLOCK END
* returne :
* 0 si aucun compos ant selectionne
* 1 sinon
* -1 si commande termin<69>e et composants trouv<75>s (block delete, block save)
*/
{
int endcommande = TRUE;
if( DrawPanel->ManageCurseur )
switch( GetScreen()->BlockLocate.m_Command )
{
case BLOCK_IDLE:
DisplayError( this, wxT( "Error in HandleBlockPLace" ) );
break;
case BLOCK_DRAG: /* Drag (not used, for future enhancements)*/
case BLOCK_MOVE: /* Move */
case BLOCK_COPY: /* Copy */
case BLOCK_PRESELECT_MOVE: /* Move with preselection list*/
GetScreen()->BlockLocate.m_State = STATE_BLOCK_MOVE;
endcommande = FALSE;
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
DrawPanel->ManageCurseur = DrawMovingBlockOutlines;
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
break;
case BLOCK_DELETE: /* Delete */
// Turn off the block rectangle now so it is not redisplayed
DrawPanel->ManageCurseur = NULL;
GetScreen()->BlockLocate.m_State = STATE_BLOCK_STOP;
DrawAndSizingBlockOutlines( DrawPanel, DC, FALSE );
Block_Delete( DC );
break;
case BLOCK_ROTATE: /* Rotation */
// Turn off the block rectangle now so it is not redisplayed
DrawPanel->ManageCurseur = NULL;
GetScreen()->BlockLocate.m_State = STATE_BLOCK_STOP;
DrawAndSizingBlockOutlines( DrawPanel, DC, FALSE );
Block_Rotate( DC );
break;
case BLOCK_INVERT: /* Flip */
// Turn off the block rectangle now so it is not redisplayed
DrawPanel->ManageCurseur = NULL;
GetScreen()->BlockLocate.m_State = STATE_BLOCK_STOP;
DrawAndSizingBlockOutlines( DrawPanel, DC, FALSE );
Block_Invert( DC );
break;
case BLOCK_SAVE: /* Save (not used, for future enhancements)*/
GetScreen()->BlockLocate.m_State = STATE_BLOCK_STOP;
if( GetScreen()->BlockLocate.m_BlockDrawStruct != NULL )
{
DrawAndSizingBlockOutlines( DrawPanel, DC, FALSE );
// SaveStruct(GetScreen()->BlockLocate.m_BlockDrawStruct);
}
break;
case BLOCK_PASTE:
break;
case BLOCK_ZOOM: /* Window Zoom */
//Turn off the redraw block routine now so it is not displayed
// with one corner at the new center of the screen
DrawPanel->ManageCurseur = NULL;
Window_Zoom( GetScreen()->BlockLocate );
break;
default:
break;
}
if( endcommande == TRUE )
{
GetScreen()->BlockLocate.m_Flags = 0;
GetScreen()->BlockLocate.m_State = STATE_NO_BLOCK;
GetScreen()->BlockLocate.m_Command = BLOCK_IDLE;
GetScreen()->BlockLocate.m_BlockDrawStruct = NULL;
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
DisplayToolMsg( wxEmptyString );
}
return endcommande;
}
/**************************************************************************/
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
/**************************************************************************/
/* Retrace le contour du block de repositionnement des structures a d<>placer
*/
{
int Color;
BASE_SCREEN* screen = panel->GetScreen();
Color = YELLOW;
GRSetDrawMode( DC, g_XorMode );
/* Effacement ancien cadre */
if( erase )
{
screen->BlockLocate.Draw( panel, DC );
if( screen->BlockLocate.m_MoveVector.x || screen->BlockLocate.m_MoveVector.y )
{
screen->BlockLocate.Offset( screen->BlockLocate.m_MoveVector );
screen->BlockLocate.Draw( panel, DC );
screen->BlockLocate.Offset( -screen->BlockLocate.m_MoveVector.x,
-screen->BlockLocate.m_MoveVector.y );
}
}
if( screen->BlockLocate.m_State != STATE_BLOCK_STOP )
{
screen->BlockLocate.m_MoveVector.x = screen->m_Curseur.x - screen->BlockLocate.GetRight();
screen->BlockLocate.m_MoveVector.y = screen->m_Curseur.y - screen->BlockLocate.GetBottom();
}
screen->BlockLocate.Draw( panel, DC );
if( screen->BlockLocate.m_MoveVector.x || screen->BlockLocate.m_MoveVector.y )
{
screen->BlockLocate.Offset( screen->BlockLocate.m_MoveVector );
screen->BlockLocate.Draw( panel, DC );
screen->BlockLocate.Offset( -screen->BlockLocate.m_MoveVector.x,
-screen->BlockLocate.m_MoveVector.y );
}
}
/************************************************/
void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
/************************************************/
/*
* routine d'effacement du block deja selectionne
*/
{
BOARD_ITEM* PtStruct, * NextS;
int masque_layer;
if( !InstallBlockCmdFrame( this, _( "Delete Block" ) ) )
return;
GetScreen()->SetModify();
GetScreen()->BlockLocate.Normalize();
SetCurItem( NULL );
/* Effacement des modules */
if( Block_Include_Modules )
{
MODULE* module;
module = m_Pcb->m_Modules;
for( ; module != NULL; module = (MODULE*) NextS )
{
NextS = module->Next();
if( module->HitTest( GetScreen()->BlockLocate ) )
{
module->m_Flags = 0;
module->DeleteStructure();
m_Pcb->m_Status_Pcb = 0;
}
}
}
/* Effacement des Pistes */
if( Block_Include_Tracks )
{
TRACK* pt_segm;
for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) NextS )
{
NextS = pt_segm->Next();
if( pt_segm->HitTest( GetScreen()->BlockLocate ) )
{
/* la piste est ici bonne a etre efface */
pt_segm->DeleteStructure();
}
}
}
/* Effacement des Elements De Dessin */
masque_layer = EDGE_LAYER;
if( Block_Include_Draw_Items )
masque_layer = ALL_LAYERS;
if( !Block_Include_Edges_Items )
masque_layer &= ~EDGE_LAYER;
PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = NextS )
{
NextS = PtStruct->Next();
switch( PtStruct->Type() )
{
case TYPE_DRAWSEGMENT:
if( (g_TabOneLayerMask[PtStruct->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
PtStruct->Draw( DrawPanel, DC, GR_XOR );
PtStruct->DeleteStructure();
break;
case TYPE_TEXTE:
if( !Block_Include_PcbTextes )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* le texte est ici bon a etre efface */
PtStruct->Draw( DrawPanel, DC, GR_XOR );
/* Suppression du texte en Memoire*/
PtStruct->DeleteStructure();
break;
case TYPE_MIRE:
if( (g_TabOneLayerMask[PtStruct->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
PtStruct->DeleteStructure();
break;
case TYPE_COTATION:
if( (g_TabOneLayerMask[PtStruct->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
PtStruct->DeleteStructure();
break;
default:
break;
}
}
/* Effacement des Zones */
if( Block_Include_Zones )
{
SEGZONE* pt_segm, *NextSegZ;
Affiche_Message( _( "Delete zones" ) );
for( pt_segm = m_Pcb->m_Zone; pt_segm != NULL; pt_segm = NextSegZ )
{
NextSegZ = pt_segm->Next();
if( pt_segm->HitTest( GetScreen()->BlockLocate ) )
{
pt_segm->DeleteStructure();
}
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
if( m_Pcb->GetArea(ii)->HitTest( GetScreen()->BlockLocate ) )
{
m_Pcb->Delete(m_Pcb->GetArea(ii));
ii--; // because the current data was removed, ii points actually the next data
}
}
}
DrawPanel->Refresh( TRUE );
if( g_Show_Ratsnest )
Compile_Ratsnest( DC, TRUE );
else
{
m_Pcb->m_Status_Pcb = 0; /* we need (later) a full ratnest computation */
build_liste_pads();
}
}
/****************************************************/
void WinEDA_BasePcbFrame::Block_Rotate( wxDC* DC )
/****************************************************/
/**
* Function Block_Rotate
* Rotate 90 deg the selected block
* The rotation centre is the centre of the block
*/
{
MODULE* module;
EDA_BaseStruct* PtStruct;
int masque_layer;
wxPoint oldpos;
wxPoint centre; /* rotation centre for the rotation transform */
if( !InstallBlockCmdFrame( this, _( "Rotate Block" ) ) )
return;
oldpos = GetScreen()->m_Curseur;
GetScreen()->BlockLocate.Normalize();
centre = GetScreen()->BlockLocate.Centre(); // This is the rotation centre
GetScreen()->SetModify();
/* Rotation des modules */
if( Block_Include_Modules )
{
bool Show_Ratsnest_tmp = g_Show_Ratsnest; g_Show_Ratsnest = false;
int Angle_Rot_Module = 900;
module = m_Pcb->m_Modules;
for( ; module != NULL; module = module->Next() )
{
if( ! module->HitTest( GetScreen()->BlockLocate ) )
continue;
m_Pcb->m_Status_Pcb = 0;
module->m_Flags = 0;
/* Move the footprint before rotate it */
RotatePoint( &module->m_Pos, centre, 900 );
GetScreen()->m_Curseur = module->m_Pos;
Place_Module( module, NULL );
/* Rotate the footprint */
Rotate_Module( DC, module, Angle_Rot_Module, TRUE );
}
/* regeneration des valeurs originelles */
GetScreen()->m_Curseur = oldpos;
g_Show_Ratsnest = Show_Ratsnest_tmp;
}
/* Move and rotate the track segments */
if( Block_Include_Tracks )
{
TRACK* track;
track = m_Pcb->m_Track;
while( track )
{
if( track->HitTest( GetScreen()->BlockLocate ) )
{ /* la piste est ici bonne a etre deplacee */
m_Pcb->m_Status_Pcb = 0;
RotatePoint( &track->m_Start, centre, 900 );
RotatePoint( &track->m_End, centre, 900 );
}
track = track->Next();
}
}
/* Move and rotate the zone fill segments, and outlines */
if( Block_Include_Zones )
{
TRACK* track;
Affiche_Message( _( "Zone rotation" ) );
track = (TRACK*) m_Pcb->m_Zone;
while( track )
{
if( track->HitTest( GetScreen()->BlockLocate ) )
{
RotatePoint( &track->m_Start, centre, 900 );
RotatePoint( &track->m_End, centre, 900 );
}
track = track->Next();
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
if( m_Pcb->GetArea(ii)->HitTest( GetScreen()->BlockLocate ) )
{
m_Pcb->GetArea(ii)->Rotate(centre, 900);
}
}
}
masque_layer = EDGE_LAYER;
if( Block_Include_Draw_Items )
masque_layer = ALL_LAYERS;
if( !Block_Include_Edges_Items )
masque_layer &= ~EDGE_LAYER;
/* Move and rotate the graphic items */
PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
switch( PtStruct->Type() )
{
case TYPE_DRAWSEGMENT:
#undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
RotatePoint( &STRUCT->m_Start, centre, 900 );
RotatePoint( &STRUCT->m_End, centre, 900 );
break;
case TYPE_TEXTE:
#undef STRUCT
#define STRUCT ( (TEXTE_PCB*) PtStruct )
if( !Block_Include_PcbTextes )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
RotatePoint( &STRUCT->m_Pos, centre, 900 );
STRUCT->m_Orient += 900;
if( STRUCT->m_Orient >= 3600 )
STRUCT->m_Orient -= 3600;
break;
case TYPE_MIRE:
#undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre modifie */
RotatePoint( &STRUCT->m_Pos, centre, 900 );
break;
case TYPE_COTATION:
#undef STRUCT
#define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
STRUCT->Rotate(centre, 900);
break;
default:
break;
}
}
DrawPanel->Refresh( TRUE );
if( g_Show_Ratsnest )
Compile_Ratsnest( DC, TRUE );
}
/*****************************************************/
void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
/*****************************************************/
/*
* routine d'inversion miroir deg du block deja selectionne
* les elements sont inverse / axe horizontal,
* l'axe d'inversion est la mediane horizontale du block
*/
{
#define INVERT( pos ) (pos) = centerY - ( (pos) - centerY )
#define INVERT_ANGLE( phi ) (phi) = -(phi)
MODULE* module;
EDA_BaseStruct* PtStruct;
int masque_layer;
wxPoint memo;
int Ny, centerY;/* position de l'axe d'inversion de l'ensemble des elements */
if( !InstallBlockCmdFrame( this, _( "Block mirroring" ) ) )
return;
memo = GetScreen()->m_Curseur;
GetScreen()->BlockLocate.Normalize();
/* calcul du centre d'inversion */
centerY = GetScreen()->BlockLocate.Centre().y;
GetScreen()->SetModify();
/* Inversion des modules */
if( Block_Include_Modules )
{
bool Show_Ratsnest_tmp = g_Show_Ratsnest; g_Show_Ratsnest = false;
module = m_Pcb->m_Modules;
for( ; module != NULL; module = module->Next() )
{
if( ! module->HitTest( GetScreen()->BlockLocate ) )
continue;
/* le module est ici bon a etre efface */
m_Pcb->m_Status_Pcb = 0;
module->m_Flags = 0;
/* calcul de la nouvelle position du Module */
Ny = module->m_Pos.y;
INVERT( Ny );
GetScreen()->m_Curseur.x = module->m_Pos.x;
GetScreen()->m_Curseur.y = Ny;
Place_Module( module, NULL );
/* inversion du module */
m_Pcb->Change_Side_Module( module, DC );
/* regeneration des valeurs originelles */
GetScreen()->m_Curseur = memo;
}
g_Show_Ratsnest = Show_Ratsnest_tmp;
}
/* Deplacement des Segments de piste */
if( Block_Include_Tracks )
{
TRACK* track;
track = m_Pcb->m_Track;
while( track )
{
if( track->HitTest( GetScreen()->BlockLocate ) )
{ /* la piste est ici bonne a etre deplacee */
m_Pcb->m_Status_Pcb = 0;
INVERT( track->m_Start.y );
INVERT( track->m_End.y );
if( track->Type() != TYPE_VIA )
{
track->SetLayer( ChangeSideNumLayer( track->GetLayer() ) );
}
}
track = track->Next();
}
}
/* Deplacement des Segments de Zone */
if( Block_Include_Zones )
{
TRACK* track;
track = (TRACK*) m_Pcb->m_Zone;
while( track )
{
if( track->HitTest( GetScreen()->BlockLocate ) )
{ /* la piste est ici bonne a etre deplacee */
INVERT( track->m_Start.y );
INVERT( track->m_End.y );
track->SetLayer( ChangeSideNumLayer( track->GetLayer() ) );
}
track = track->Next();
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
if( m_Pcb->GetArea(ii)->HitTest( GetScreen()->BlockLocate ) )
{
m_Pcb->GetArea(ii)->Mirror( wxPoint(0, centerY) );
m_Pcb->GetArea(ii)->SetLayer( ChangeSideNumLayer( m_Pcb->GetArea(ii)->GetLayer() ) );
}
}
}
masque_layer = EDGE_LAYER;
if( Block_Include_Draw_Items )
masque_layer = ALL_LAYERS;
if( !Block_Include_Edges_Items )
masque_layer &= ~EDGE_LAYER;
PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
switch( PtStruct->Type() )
{
case TYPE_DRAWSEGMENT:
#undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre selectionne */
if( STRUCT->m_Shape == S_ARC )
{
INVERT_ANGLE( STRUCT->m_Angle );
}
INVERT( STRUCT->m_Start.y );
INVERT( STRUCT->m_End.y );
STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
break;
case TYPE_TEXTE:
#undef STRUCT
#define STRUCT ( (TEXTE_PCB*) PtStruct )
if( !Block_Include_PcbTextes )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* le texte est ici bon a etre selectionne*/
INVERT( STRUCT->m_Pos.y );
INVERT_ANGLE( STRUCT->m_Orient );
if( (STRUCT->GetLayer() == COPPER_LAYER_N) || (STRUCT->GetLayer() == CMP_N) )
{
STRUCT->m_Mirror = not STRUCT->m_Mirror; /* inverse miroir */
}
STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
break;
case TYPE_MIRE:
#undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre modifie */
INVERT( STRUCT->m_Pos.y );
STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
break;
case TYPE_COTATION:
#undef STRUCT
#define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre modifie */
STRUCT->Mirror( wxPoint(0, centerY) );
STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
break;
default:
break;
}
}
DrawPanel->Refresh( TRUE );
if( g_Show_Ratsnest )
Compile_Ratsnest( DC, TRUE );
}
/************************************************/
void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
/************************************************/
/*
* Function to move items withing the selected block
*/
{
int masque_layer;
wxPoint oldpos;
wxPoint MoveVector = GetScreen()->BlockLocate.m_MoveVector;
oldpos = GetScreen()->m_Curseur;
DrawPanel->ManageCurseur = NULL;
if( !InstallBlockCmdFrame( this, _( "Move Block" ) ) )
return;
GetScreen()->m_Curseur = oldpos;
DrawPanel->MouseToCursorSchema();
GetScreen()->SetModify();
GetScreen()->BlockLocate.Normalize();
/* Deplacement des modules */
if( Block_Include_Modules )
{
bool Show_Ratsnest_tmp = g_Show_Ratsnest; g_Show_Ratsnest = false;
oldpos = GetScreen()->m_Curseur;
for( MODULE* module = m_Pcb->m_Modules; module; module = module->Next() )
{
if( ! module->HitTest( GetScreen()->BlockLocate ) )
continue;
/* le module est ici bon a etre deplace */
m_Pcb->m_Status_Pcb = 0;
module->m_Flags = 0;
GetScreen()->m_Curseur = module->m_Pos + MoveVector;
Place_Module( module, NULL );
}
GetScreen()->m_Curseur = oldpos;
g_Show_Ratsnest = Show_Ratsnest_tmp;
}
/* Deplacement des Segments de piste */
if( Block_Include_Tracks )
{
for( TRACK* track = m_Pcb->m_Track; track; track = track->Next() )
{
if( track->HitTest( GetScreen()->BlockLocate ) )
{ /* la piste est ici bonne a etre deplacee */
m_Pcb->m_Status_Pcb = 0;
track->m_Start += MoveVector;
track->m_End += MoveVector;
}
}
}
/* Deplacement des Segments de Zone */
if( Block_Include_Zones )
{
for( TRACK* track = m_Pcb->m_Zone; track; track = track->Next() )
{
if( track->HitTest( GetScreen()->BlockLocate ) )
{ /* la piste est ici bonne a etre deplacee */
track->m_Start += MoveVector;
track->m_End += MoveVector;
}
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
if( m_Pcb->GetArea(ii)->HitTest( GetScreen()->BlockLocate ) )
{
m_Pcb->GetArea(ii)->Move( MoveVector );
}
}
}
masque_layer = EDGE_LAYER;
if( Block_Include_Draw_Items )
masque_layer = ALL_LAYERS;
if( !Block_Include_Edges_Items )
masque_layer &= ~EDGE_LAYER;
for( BOARD_ITEM* item = m_Pcb->m_Drawings; item; item = item->Next() )
{
switch( item->Type() )
{
case TYPE_DRAWSEGMENT:
#undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) item )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
STRUCT->m_Start += MoveVector;
STRUCT->m_End += MoveVector;
break;
case TYPE_TEXTE:
#undef STRUCT
#define STRUCT ( (TEXTE_PCB*) item )
if( !Block_Include_PcbTextes )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* le texte est ici bon a etre deplace */
/* Redessin du Texte */
STRUCT->m_Pos += MoveVector;
break;
case TYPE_MIRE:
#undef STRUCT
#define STRUCT ( (MIREPCB*) item )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
STRUCT->m_Pos += MoveVector;
break;
case TYPE_COTATION:
#undef STRUCT
#define STRUCT ( (COTATION*) item )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
( (COTATION*) item )->Move( wxPoint(MoveVector) );
break;
default:
break;
}
}
DrawPanel->Refresh( TRUE );
if( g_Show_Ratsnest )
Compile_Ratsnest( DC, TRUE );
}
/**************************************************/
void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
/**************************************************/
/*
* routine de duplication des elements du block deja selectionne
*/
{
int masque_layer;
wxPoint oldpos;
wxPoint MoveVector = GetScreen()->BlockLocate.m_MoveVector;
oldpos = GetScreen()->m_Curseur;
DrawPanel->ManageCurseur = NULL;
if( !InstallBlockCmdFrame( this, _( "Copy Block" ) ) )
return;
GetScreen()->m_Curseur = oldpos;
DrawPanel->MouseToCursorSchema();
GetScreen()->SetModify();
GetScreen()->BlockLocate.Normalize();
/* Module copy */
if( Block_Include_Modules )
{
bool Show_Ratsnest_tmp = g_Show_Ratsnest;
g_Show_Ratsnest = false;
oldpos = GetScreen()->m_Curseur;
for( MODULE* module= m_Pcb->m_Modules; module; module = module->Next() )
{
MODULE* new_module;
if( ! module->HitTest( GetScreen()->BlockLocate ) )
continue;
/* le module est ici bon a etre deplace */
m_Pcb->m_Status_Pcb = 0;
module->m_Flags = 0;
new_module = new MODULE( m_Pcb );
new_module->Copy( module );
new_module->m_TimeStamp = GetTimeStamp();
m_Pcb->m_Modules.PushFront( new_module );
GetScreen()->m_Curseur = module->m_Pos + MoveVector;
Place_Module( new_module, DC );
}
GetScreen()->m_Curseur = oldpos;
g_Show_Ratsnest = Show_Ratsnest_tmp;
}
/* Deplacement des Segments de piste */
if( Block_Include_Tracks )
{
TRACK* track, * next_track, * new_track;
track = m_Pcb->m_Track;
while( track )
{
next_track = track->Next();
if( track->HitTest( GetScreen()->BlockLocate ) )
{
/* la piste est ici bonne a etre deplacee */
m_Pcb->m_Status_Pcb = 0;
new_track = track->Copy();
m_Pcb->m_Track.PushFront( new_track );
new_track->m_Start += MoveVector;
new_track->m_End += MoveVector;
new_track->Draw( DrawPanel, DC, GR_OR ); // reaffichage
}
track = next_track;
}
}
/* Duplicate Zones */
if( Block_Include_Zones )
{
for( SEGZONE* segzone = m_Pcb->m_Zone; segzone; segzone = segzone->Next() )
{
if( segzone->HitTest( GetScreen()->BlockLocate ) )
{
SEGZONE* new_segzone = (SEGZONE*) segzone->Copy();
m_Pcb->m_Zone.PushFront( new_segzone );
new_segzone->m_Start += MoveVector;
new_segzone->m_End += MoveVector;
new_segzone->Draw( DrawPanel, DC, GR_OR );
}
}
unsigned imax = m_Pcb->GetAreaCount();
for ( unsigned ii = 0; ii < imax; ii++ )
{
if( m_Pcb->GetArea(ii)->HitTest( GetScreen()->BlockLocate ) )
{
ZONE_CONTAINER * new_zone = new ZONE_CONTAINER(m_Pcb);
new_zone->Copy( m_Pcb->GetArea(ii) );
new_zone->m_TimeStamp = GetTimeStamp();
new_zone->Move( MoveVector );
m_Pcb->Add(new_zone);
new_zone->Draw( DrawPanel, DC, GR_OR );
}
}
}
masque_layer = EDGE_LAYER;
if( Block_Include_Draw_Items )
masque_layer = ALL_LAYERS;
if( !Block_Include_Edges_Items )
masque_layer &= ~EDGE_LAYER;
for( BOARD_ITEM* item = m_Pcb->m_Drawings; item; item = item->Next() )
{
switch( item->Type() )
{
case TYPE_DRAWSEGMENT:
{
#undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) item )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre copie */
DRAWSEGMENT* new_drawsegment = new DRAWSEGMENT( m_Pcb );
new_drawsegment->Copy( STRUCT );
m_Pcb->Add( new_drawsegment );
new_drawsegment->m_Start += MoveVector;
new_drawsegment->m_End += MoveVector;
new_drawsegment->Draw( DrawPanel, DC, GR_OR );
}
break;
case TYPE_TEXTE:
{
#undef STRUCT
#define STRUCT ( (TEXTE_PCB*) item )
if( !Block_Include_PcbTextes )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* le texte est ici bon a etre deplace */
TEXTE_PCB* new_pcbtext = new TEXTE_PCB( m_Pcb );
new_pcbtext->Copy( STRUCT );
m_Pcb->Add( new_pcbtext );
/* Redessin du Texte */
new_pcbtext->m_Pos += MoveVector;
new_pcbtext->Draw( DrawPanel, DC, GR_OR );
}
break;
case TYPE_MIRE:
{
#undef STRUCT
#define STRUCT ( (MIREPCB*) item )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
MIREPCB* new_mire = new MIREPCB( m_Pcb );
new_mire->Copy( STRUCT );
m_Pcb->Add( new_mire );
new_mire->m_Pos += MoveVector;
new_mire->Draw( DrawPanel, DC, GR_OR );
}
break;
case TYPE_COTATION:
{
#undef STRUCT
#define STRUCT ( (COTATION*) item )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! item->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre copie */
COTATION* new_cotation = new COTATION( m_Pcb );
new_cotation->Copy( STRUCT );
m_Pcb->Add( new_cotation );
new_cotation->Move( MoveVector );
new_cotation->Draw( DrawPanel, DC, GR_OR );
}
break;
default:
break;
}
}
}
Reference in New Issue View Git Blame Copy Permalink