haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BOARD_ITEM::Draw()

This commit is contained in:
dickelbeck 2008-04-01 05:21:50 +00:00
parent c439e0da05
commit aa93f54d97
56 changed files with 755 additions and 830 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
change_log.txt
View File

@ -10,6 +10,10 @@ email address.
+all
Tweaked class MsgPanel so that the screen drawing only happens from
its OnPaint() function.
+pcbnew
Added virtual BOARD_ITEM::Draw() and forced all BOARD_ITEM derived classes
to implement it so that all these functions are also virtual.
Made the offset argument default to the new wxPoint BOARD_ITEM::ZeroOffset
2008-Mar-30 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>

2
cvpcb/setvisu.cpp
View File

@ -94,7 +94,7 @@ void WinEDA_DisplayFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
if( Module )
{
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_COPY );
Module->Draw( DrawPanel, DC, GR_COPY );
Module->Display_Infos( this );
}

17
include/base_struct.h
View File

@ -574,6 +574,11 @@ public:
}
/**
* A value of wxPoint(0,0) which can be passed to the Draw() functions.
*/
static wxPoint ZeroOffset;
BOARD_ITEM* Next() const { return (BOARD_ITEM*) Pnext; }
BOARD_ITEM* Back() const { return (BOARD_ITEM*) Pback; }
BOARD_ITEM* GetParent() const { return (BOARD_ITEM*) m_Parent; }
@ -600,6 +605,18 @@ public:
void SetLayer( int aLayer ) { m_Layer = aLayer; }
/**
* Function Draw
* overrides Draw() from EDA_BaseStruct in order to make it virtual
* without the default color argument, which is more appropriate for
* BOARD_ITEMs which have their own color information.
*/
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int aDrawMode, const wxPoint& offset = ZeroOffset )
{
}
/**
* Function IsOnLayer
* tests to see if this object is on the given layer. Is virtual so

6
pcbnew/automove.cpp
View File

@ -287,7 +287,7 @@ void WinEDA_PcbFrame::AutoMoveModulesOnPcb( wxDC* DC, bool PlaceModulesHorsPcb )
PutOnGrid( &m_CurrentScreen->m_Curseur );
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( DrawPanel, DC, GR_XOR );
Place_Module( Module, DC ); /* positionne Module et recalcule cadre */
current.x += Module->m_RealBoundaryBox.GetWidth() + pas_grille;
@ -354,9 +354,9 @@ void WinEDA_PcbFrame::ReOrientModules( const wxString& ModuleMask,
if( WildCompareString( ModuleMask, Module->m_Reference->m_Text, FALSE ) )
{
m_CurrentScreen->SetModify();
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( DrawPanel, DC, GR_XOR );
Rotate_Module( NULL, Module, Orient, FALSE );
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
}
}
}

2
pcbnew/autoplac.cpp
View File

@ -182,7 +182,7 @@ void WinEDA_PcbFrame::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC
if( Module->m_ModuleStatus & MODULE_to_PLACE ) // Erase from screen
{
NbModules++;
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( DrawPanel, DC, GR_XOR );
}
else
{

120
pcbnew/block.cpp
View File

@ -463,11 +463,11 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
{
NextS = module->Next();
if( module->HitTest( GetScreen()->BlockLocate ) )
{
module->m_Flags = 0;
module->DeleteStructure();
m_Pcb->m_Status_Pcb = 0;
}
{
module->m_Flags = 0;
module->DeleteStructure();
m_Pcb->m_Status_Pcb = 0;
}
}
}
@ -520,14 +520,12 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* le texte est ici bon a etre efface */
( (TEXTE_PCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
PtStruct->Draw( DrawPanel, DC, GR_XOR );
/* Suppression du texte en Memoire*/
PtStruct->DeleteStructure();
break;
case TYPEMIRE:
#undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
@ -537,8 +535,6 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
break;
case TYPECOTATION:
#undef STRUCT
#define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break;
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
@ -566,24 +562,24 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
}
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
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
}
}
{
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();
}
else
{
m_Pcb->m_Status_Pcb = 0; /* we need (later) a full ratnest computation */
build_liste_pads();
}
}
@ -672,13 +668,13 @@ void WinEDA_BasePcbFrame::Block_Rotate( wxDC* DC )
}
track = track->Next();
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
if( m_Pcb->GetArea(ii)->HitTest( GetScreen()->BlockLocate ) )
{
m_Pcb->GetArea(ii)->Rotate(centre, 900);
}
}
{
m_Pcb->GetArea(ii)->Rotate(centre, 900);
}
}
}
masque_layer = EDGE_LAYER;
@ -848,14 +844,14 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
}
track = (TRACK*) track->Pnext;
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
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)->Mirror( wxPoint(0, centerY) );
m_Pcb->GetArea(ii)->SetLayer( ChangeSideNumLayer( m_Pcb->GetArea(ii)->GetLayer() ) );
}
}
}
}
}
masque_layer = EDGE_LAYER;
@ -925,7 +921,7 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
break;
/* l'element est ici bon a etre modifie */
STRUCT->Mirror( wxPoint(0, centerY) );
STRUCT->Mirror( wxPoint(0, centerY) );
STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
break;
@ -1018,13 +1014,13 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
}
track = (TRACK*) track->Pnext;
}
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
for ( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
if( m_Pcb->GetArea(ii)->HitTest( GetScreen()->BlockLocate ) )
{
m_Pcb->GetArea(ii)->Move( MoveVector );
}
}
{
m_Pcb->GetArea(ii)->Move( MoveVector );
}
}
}
masque_layer = EDGE_LAYER;
@ -1046,7 +1042,7 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
STRUCT->m_Start += MoveVector;
STRUCT->m_Start += MoveVector;
STRUCT->m_End += MoveVector;
break;
@ -1081,7 +1077,7 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
if( ! PtStruct->HitTest( GetScreen()->BlockLocate ) )
break;
/* l'element est ici bon a etre efface */
( (COTATION*) PtStruct )->Move( wxPoint(MoveVector) );
( (COTATION*) PtStruct )->Move( wxPoint(MoveVector) );
break;
default:
@ -1107,7 +1103,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
EDA_BaseStruct* PtStruct;
int masque_layer;
wxPoint oldpos;
wxPoint MoveVector = GetScreen()->BlockLocate.m_MoveVector;
wxPoint MoveVector = GetScreen()->BlockLocate.m_MoveVector;
oldpos = GetScreen()->m_Curseur;
DrawPanel->ManageCurseur = NULL;
@ -1124,7 +1120,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
if( Block_Include_Modules )
{
bool Show_Ratsnest_tmp = g_Show_Ratsnest;
g_Show_Ratsnest = false;
g_Show_Ratsnest = false;
module = m_Pcb->m_Modules;
oldpos = GetScreen()->m_Curseur;
@ -1143,7 +1139,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
new_module->Pback = m_Pcb;
m_Pcb->m_Modules->Pback = new_module;
m_Pcb->m_Modules = new_module;
GetScreen()->m_Curseur = module->m_Pos + MoveVector;
GetScreen()->m_Curseur = module->m_Pos + MoveVector;
Place_Module( new_module, DC );
}
@ -1191,19 +1187,19 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
segzone = segzone->Next();
}
unsigned imax = m_Pcb->GetAreaCount();
for ( unsigned ii = 0; ii < imax; ii++ )
{
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, wxPoint( 0, 0 ), GR_OR );
}
}
{
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;
@ -1257,7 +1253,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
m_Pcb->m_Drawings = new_pcbtext;
/* Redessin du Texte */
new_pcbtext->m_Pos += MoveVector;
new_pcbtext->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
new_pcbtext->Draw( DrawPanel, DC, GR_OR );
break;
}
@ -1277,7 +1273,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
m_Pcb->m_Drawings->Pback = new_mire;
m_Pcb->m_Drawings = new_mire;
new_mire->m_Pos += MoveVector;
new_mire->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
new_mire->Draw( DrawPanel, DC, GR_OR );
break;
}
@ -1296,8 +1292,8 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
new_cotation->Pback = m_Pcb;
m_Pcb->m_Drawings->Pback = new_cotation;
m_Pcb->m_Drawings = new_cotation;
new_cotation->Move( MoveVector );
new_cotation->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
new_cotation->Move( MoveVector );
new_cotation->Draw( DrawPanel, DC, GR_OR );
break;
}

16
pcbnew/block_module_editor.cpp
View File

@ -293,7 +293,7 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
{
DrawBlockStruct* PtBlock;
BASE_SCREEN* screen = panel->m_Parent->GetScreen();
EDA_BaseStruct* item;
BOARD_ITEM* item;
wxPoint move_offset;
MODULE* Currentmodule = g_EDA_Appl->m_ModuleEditFrame->m_Pcb->m_Modules;
@ -320,11 +320,8 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
switch( item->Type() )
{
case TYPETEXTEMODULE:
( (TEXTE_MODULE*) item )->Draw( panel, DC, move_offset, g_XorMode );
break;
case TYPEEDGEMODULE:
( (EDGE_MODULE*) item )->Draw( panel, DC, move_offset, g_XorMode );
item->Draw( panel, DC, g_XorMode, move_offset );
break;
default:
@ -337,7 +334,7 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
{
if( pad->m_Selected == 0 )
continue;
pad->Draw( panel, DC, move_offset, g_XorMode );
pad->Draw( panel, DC, g_XorMode, move_offset );
}
}
}
@ -365,11 +362,8 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
switch( item->Type() )
{
case TYPETEXTEMODULE:
( (TEXTE_MODULE*) item )->Draw( panel, DC, move_offset, g_XorMode );
break;
case TYPEEDGEMODULE:
( (EDGE_MODULE*) item )->Draw( panel, DC, move_offset, g_XorMode );
item->Draw( panel, DC, g_XorMode, move_offset );
break;
default:
@ -382,7 +376,7 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
{
if( pad->m_Selected == 0 )
continue;
pad->Draw( panel, DC, move_offset, g_XorMode );
pad->Draw( panel, DC, g_XorMode, move_offset );
}
}
}

8
pcbnew/class_board.cpp
View File

@ -7,6 +7,12 @@
#include "pcbnew.h"
/* This is an odd place for this, but cvpcb won't link if it is
in class_board_item.cpp like I first tried it.
*/
wxPoint BOARD_ITEM::ZeroOffset(0,0);
/*****************/
/* Class BOARD: */
/*****************/
@ -1037,7 +1043,7 @@ void BOARD::RedrawAreasOutlines(WinEDA_DrawPanel* panel, wxDC * aDC, int aDrawMo
{
ZONE_CONTAINER* edge_zone = GetArea(ii);
if( (aLayer < 0) || (aLayer == edge_zone->GetLayer()) )
edge_zone->Draw( panel, aDC, wxPoint( 0, 0 ), aDrawMode );
edge_zone->Draw( panel, aDC, aDrawMode );
}
}

1
pcbnew/class_board_item.cpp
View File

@ -16,6 +16,7 @@
#include "Add_Mires.xpm"
/********************************************************/
wxString BOARD_ITEM::MenuText( const BOARD* aPcb ) const
/********************************************************/

130
pcbnew/class_cotation.cpp
View File

@ -69,7 +69,7 @@ wxString COTATION:: GetText( void )
/* Reutun the dimension text
*/
{
return m_Text->m_Text;
return m_Text->m_Text;
}
@ -234,22 +234,22 @@ void COTATION::Move(const wxPoint& offset)
* @param offset : moving vector
*/
{
m_Pos += offset;
m_Text->m_Pos += offset;
Barre_ox += offset.x; Barre_oy += offset.y;
Barre_fx += offset.x; Barre_fy += offset.y;
TraitG_ox += offset.x; TraitG_oy += offset.y;
TraitG_fx += offset.x; TraitG_fy += offset.y;
TraitD_ox += offset.x; TraitD_oy += offset.y;
TraitD_fx += offset.x; TraitD_fy += offset.y;
FlecheG1_ox += offset.x; FlecheG1_oy += offset.y;
FlecheG1_fx += offset.x; FlecheG1_fy += offset.y;
FlecheG2_ox += offset.x; FlecheG2_oy += offset.y;
FlecheG2_fx += offset.x; FlecheG2_fy += offset.y;
FlecheD1_ox += offset.x; FlecheD1_oy += offset.y;
FlecheD1_fx += offset.x; FlecheD1_fy += offset.y;
FlecheD2_ox += offset.x; FlecheD2_oy += offset.y;
FlecheD2_fx += offset.x; FlecheD2_fy += offset.y;
m_Pos += offset;
m_Text->m_Pos += offset;
Barre_ox += offset.x; Barre_oy += offset.y;
Barre_fx += offset.x; Barre_fy += offset.y;
TraitG_ox += offset.x; TraitG_oy += offset.y;
TraitG_fx += offset.x; TraitG_fy += offset.y;
TraitD_ox += offset.x; TraitD_oy += offset.y;
TraitD_fx += offset.x; TraitD_fy += offset.y;
FlecheG1_ox += offset.x; FlecheG1_oy += offset.y;
FlecheG1_fx += offset.x; FlecheG1_fy += offset.y;
FlecheG2_ox += offset.x; FlecheG2_oy += offset.y;
FlecheG2_fx += offset.x; FlecheG2_fy += offset.y;
FlecheD1_ox += offset.x; FlecheD1_oy += offset.y;
FlecheD1_fx += offset.x; FlecheD1_fy += offset.y;
FlecheD2_ox += offset.x; FlecheD2_oy += offset.y;
FlecheD2_fx += offset.x; FlecheD2_fy += offset.y;
}
@ -262,30 +262,30 @@ void COTATION::Rotate(const wxPoint& centre, int angle)
* @param angle : Rotation angle in 0.1 degrees
*/
{
RotatePoint( &m_Pos, centre, 900 );
RotatePoint( &m_Pos, centre, 900 );
RotatePoint( &m_Text->m_Pos, centre, 900 );
m_Text->m_Orient += 900;
if( m_Text->m_Orient >= 3600 )
m_Text->m_Orient -= 3600;
if( (m_Text->m_Orient > 900)
&& (m_Text->m_Orient <2700) )
m_Text->m_Orient -= 1800;
RotatePoint( &m_Text->m_Pos, centre, 900 );
m_Text->m_Orient += 900;
if( m_Text->m_Orient >= 3600 )
m_Text->m_Orient -= 3600;
if( (m_Text->m_Orient > 900)
&& (m_Text->m_Orient <2700) )
m_Text->m_Orient -= 1800;
RotatePoint( &Barre_ox, &Barre_oy, centre.x, centre.y, 900 );
RotatePoint( &Barre_fx, &Barre_fy, centre.x, centre.y, 900 );
RotatePoint( &TraitG_ox, &TraitG_oy, centre.x, centre.y, 900 );
RotatePoint( &TraitG_fx, &TraitG_fy, centre.x, centre.y, 900 );
RotatePoint( &TraitD_ox, &TraitD_oy, centre.x, centre.y, 900 );
RotatePoint( &TraitD_fx, &TraitD_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG1_ox, &FlecheG1_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG1_fx, &FlecheG1_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG2_ox, &FlecheG2_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG2_fx, &FlecheG2_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD1_ox, &FlecheD1_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD1_fx, &FlecheD1_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD2_ox, &FlecheD2_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD2_fx, &FlecheD2_fy, centre.x, centre.y, 900 );
RotatePoint( &Barre_ox, &Barre_oy, centre.x, centre.y, 900 );
RotatePoint( &Barre_fx, &Barre_fy, centre.x, centre.y, 900 );
RotatePoint( &TraitG_ox, &TraitG_oy, centre.x, centre.y, 900 );
RotatePoint( &TraitG_fx, &TraitG_fy, centre.x, centre.y, 900 );
RotatePoint( &TraitD_ox, &TraitD_oy, centre.x, centre.y, 900 );
RotatePoint( &TraitD_fx, &TraitD_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG1_ox, &FlecheG1_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG1_fx, &FlecheG1_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG2_ox, &FlecheG2_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG2_fx, &FlecheG2_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD1_ox, &FlecheD1_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD1_fx, &FlecheD1_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD2_ox, &FlecheD2_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD2_fx, &FlecheD2_fy, centre.x, centre.y, 900 );
}
@ -302,28 +302,28 @@ void COTATION::Mirror(const wxPoint& axis_pos)
{
#define INVERT( pos ) (pos) = axis_pos.y - ( (pos) - axis_pos.y )
#define INVERT_ANGLE( phi ) (phi) = -(phi)
INVERT( m_Pos.y );
INVERT( m_Text->m_Pos.y );
INVERT_ANGLE( m_Text->m_Orient );
if( m_Text->m_Orient >= 3600 )
m_Text->m_Orient -= 3600;
if( (m_Text->m_Orient > 900) && (m_Text->m_Orient <2700) )
m_Text->m_Orient -= 1800;
INVERT( m_Pos.y );
INVERT( m_Text->m_Pos.y );
INVERT_ANGLE( m_Text->m_Orient );
if( m_Text->m_Orient >= 3600 )
m_Text->m_Orient -= 3600;
if( (m_Text->m_Orient > 900) && (m_Text->m_Orient <2700) )
m_Text->m_Orient -= 1800;
INVERT( Barre_oy );
INVERT( Barre_fy );
INVERT( TraitG_oy );
INVERT( TraitG_fy );
INVERT( TraitD_oy );
INVERT( TraitD_fy );
INVERT( FlecheG1_oy );
INVERT( FlecheG1_fy );
INVERT( FlecheG2_oy );
INVERT( FlecheG2_fy );
INVERT( FlecheD1_oy );
INVERT( FlecheD1_fy );
INVERT( FlecheD2_oy );
INVERT( FlecheD2_fy );
INVERT( Barre_oy );
INVERT( Barre_fy );
INVERT( TraitG_oy );
INVERT( TraitG_fy );
INVERT( TraitD_oy );
INVERT( TraitD_fy );
INVERT( FlecheG1_oy );
INVERT( FlecheG1_fy );
INVERT( FlecheG2_oy );
INVERT( FlecheG2_fy );
INVERT( FlecheD1_oy );
INVERT( FlecheD1_fy );
INVERT( FlecheD2_oy );
INVERT( FlecheD2_fy );
}
/****************************************/
@ -396,7 +396,7 @@ out:
/************************************************************************/
void COTATION::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int mode_color )
int mode_color, const wxPoint& offset )
/************************************************************************/
/* impression de 1 cotation : serie de n segments + 1 texte
@ -408,7 +408,7 @@ void COTATION::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
ox = offset.x;
oy = offset.y;
m_Text->Draw( panel, DC, offset, mode_color );
m_Text->Draw( panel, DC, mode_color, offset );
gcolor = g_DesignSettings.m_LayerColor[m_Layer];
if( (gcolor & ITEM_NOT_SHOW) != 0 )
@ -618,7 +618,7 @@ bool COTATION::HitTest( const wxPoint& ref_pos )
*/
bool COTATION::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Pos ) )
return true;
return false;
if( refArea.Inside( m_Pos ) )
return true;
return false;
}

43
pcbnew/class_cotation.h
View File

@ -53,29 +53,30 @@ public:
void Copy( COTATION* source );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int mode_color );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int aColorMode, const wxPoint& offset = ZeroOffset );
/**
* Function Move
* @param offset : moving vector
*/
void Move(const wxPoint& offset);
/**
* Function Move
* @param offset : moving vector
*/
void Move(const wxPoint& offset);
/**
* Function Rotate
* @param offset : Rotation point
* @param angle : Rotation angle in 0.1 degrees
*/
void Rotate(const wxPoint& centre, int angle);
/**
* Function Rotate
* @param offset : Rotation point
* @param angle : Rotation angle in 0.1 degrees
*/
void Rotate(const wxPoint& centre, int angle);
/**
* Function Mirror
* Mirror the Dimension , relative to a given horizontal axis
* the text is not mirrored. only its position (and angle) is mirrored
* the layer is not changed
* @param axis_pos : vertical axis position
*/
void Mirror(const wxPoint& axis_pos);
/**
* Function Mirror
* Mirror the Dimension , relative to a given horizontal axis
* the text is not mirrored. only its position (and angle) is mirrored
* the layer is not changed
* @param axis_pos : vertical axis position
*/
void Mirror(const wxPoint& axis_pos);
/**
* Function Display_Infos
@ -97,7 +98,7 @@ public:
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, the anchor must be inside this rect.
* For now, the anchor must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/

2
pcbnew/class_edge_mod.cpp
View File

@ -127,7 +127,7 @@ void EDGE_MODULE::SetDrawCoord()
/********************************************************************************/
void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode )
int draw_mode, const wxPoint& offset )
/********************************************************************************/
/* Affichage d'un segment contour de module :

6
pcbnew/class_edge_mod.h
View File

@ -60,10 +60,10 @@ public:
void SetDrawCoord();
/* drawing functions */
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode );
void Draw3D( Pcb3D_GLCanvas* glcanvas );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int aDrawMode, const wxPoint& offset = ZeroOffset );
void Draw3D( Pcb3D_GLCanvas* glcanvas );
/**
* Function Display_Infos

2
pcbnew/class_marker.cpp
View File

@ -182,7 +182,7 @@ bool MARKER::HitTest( const wxPoint& refPos )
/**********************************************************************/
void MARKER::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int DrawMode )
void MARKER::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int DrawMode, const wxPoint& offset )
/**********************************************************************/
/*

4
pcbnew/class_marker.h
View File

@ -48,10 +48,10 @@ public:
const wxString& aText, const wxPoint& aPos );
~MARKER();
~MARKER();
void UnLink();
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int DrawMode );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int DrawMode, const wxPoint& offset = ZeroOffset );
/**

8
pcbnew/class_mire.cpp
View File

@ -124,7 +124,7 @@ out:
/**********************************************************/
void MIREPCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int mode_color )
int mode_color, const wxPoint& offset )
/**********************************************************/
/* Affichage de 1 mire : 2 segments + 1 cercle
@ -226,8 +226,8 @@ bool MIREPCB::HitTest( const wxPoint& refPos )
*/
bool MIREPCB::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Pos ) )
return true;
return false;
if( refArea.Inside( m_Pos ) )
return true;
return false;
}

4
pcbnew/class_mire.h
View File

@ -40,7 +40,7 @@ public:
void Copy( MIREPCB* source );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int mode_color );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int aDrawMode, const wxPoint& offset = ZeroOffset );
/**
@ -54,7 +54,7 @@ public:
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, the anchor must be inside this rect.
* For now, the anchor must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/

48
pcbnew/class_module.cpp
View File

@ -262,7 +262,7 @@ void MODULE::UnLink()
/**********************************************************/
void MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode )
int draw_mode, const wxPoint& offset )
/**********************************************************/
/** Function Draw
@ -273,46 +273,38 @@ void MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
* @param draw_mode = GR_OR, GR_XOR, GR_AND
*/
{
D_PAD* pt_pad;
EDA_BaseStruct* PtStruct;
TEXTE_MODULE* PtTexte;
if( (m_Flags & DO_NOT_DRAW) )
return;
/* Draw pads */
pt_pad = m_Pads;
D_PAD* pt_pad = m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
if( pt_pad->m_Flags & IS_MOVED )
continue;
pt_pad->Draw( panel, DC, offset, draw_mode );
pt_pad->Draw( panel, DC, draw_mode, offset );
}
/* Draws foootprint anchor */
// Draws foootprint anchor
DrawAncre( panel, DC, offset, DIM_ANCRE_MODULE, draw_mode );
/* Draw graphic items */
if( !(m_Reference->m_Flags & IS_MOVED) )
m_Reference->Draw( panel, DC, offset, draw_mode );
if( !(m_Value->m_Flags & IS_MOVED) )
m_Value->Draw( panel, DC, offset, draw_mode );
m_Reference->Draw( panel, DC, draw_mode, offset );
PtStruct = m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
if( !(m_Value->m_Flags & IS_MOVED) )
m_Value->Draw( panel, DC, draw_mode, offset );
for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
{
if( PtStruct->m_Flags & IS_MOVED )
if( item->m_Flags & IS_MOVED )
continue;
switch( PtStruct->Type() )
switch( item->Type() )
{
case TYPETEXTEMODULE:
PtTexte = (TEXTE_MODULE*) PtStruct;
PtTexte->Draw( panel, DC, offset, draw_mode );
break;
case TYPEEDGEMODULE:
( (EDGE_MODULE*) PtStruct )->Draw( panel, DC, offset, draw_mode );
item->Draw( panel, DC, draw_mode, offset );
break;
default:
@ -335,16 +327,12 @@ void MODULE::DrawEdgesOnly( WinEDA_DrawPanel* panel, wxDC* DC,
* @param draw_mode = GR_OR, GR_XOR, GR_AND
*/
{
EDA_BaseStruct* PtStruct;
/* Draw graphic items */
PtStruct = m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
{
switch( PtStruct->Type() )
switch( item->Type() )
{
case TYPEEDGEMODULE:
( (EDGE_MODULE*) PtStruct )->Draw( panel, DC, offset, draw_mode );
item->Draw( panel, DC, draw_mode, offset );
break;
default:
@ -1082,9 +1070,9 @@ EDA_Rect MODULE::GetBoundingBox()
area.Merge( text_area );
}
// Add the Clearence shape size: (shape around the pads when the clearence is shown
// Not optimized, but the draw cost is small (perhaps smaller than optimization)
area.Inflate(g_DesignSettings.m_TrackClearence, g_DesignSettings.m_TrackClearence);
// Add the Clearence shape size: (shape around the pads when the clearence is shown
// Not optimized, but the draw cost is small (perhaps smaller than optimization)
area.Inflate(g_DesignSettings.m_TrackClearence, g_DesignSettings.m_TrackClearence);
return area;
}

6
pcbnew/class_module.h
View File

@ -165,10 +165,10 @@ public:
* @param panel = draw panel, Used to know the clip box
* @param DC = Current Device Context
* @param offset = draw offset (usually wxPoint(0,0)
* @param draw_mode = GR_OR, GR_XOR..
* @param aDrawMode = GR_OR, GR_XOR..
*/
void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int aDrawMode, const wxPoint& offset = ZeroOffset );
void Draw3D( Pcb3D_GLCanvas* glcanvas );
void DrawEdgesOnly( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode );

2
pcbnew/class_pad.cpp
View File

@ -218,7 +218,7 @@ void D_PAD::UnLink()
/*******************************************************************************************/
void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode )
void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoint& offset )
/*******************************************************************************************/
/** Draw a pad:

6
pcbnew/class_pad.h
View File

@ -66,7 +66,7 @@ public:
int m_physical_connexion; // variable used in rastnest computations
// handle block number in track connection
int m_zone_connexion; // variable used in rastnest computations
int m_zone_connexion; // variable used in rastnest computations
// handle block number in zone connection
public:
@ -111,7 +111,9 @@ public:
/* drawing functions */
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int aDrawMode, const wxPoint& offset = ZeroOffset );
void Draw3D( Pcb3D_GLCanvas* glcanvas );
// others

2
pcbnew/class_pcb_text.cpp
View File

@ -146,7 +146,7 @@ out:
/**********************************************************************/
void TEXTE_PCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode )
int DrawMode, const wxPoint& offset )
/**********************************************************************/
/*

33
pcbnew/class_pcb_text.h
View File

@ -9,9 +9,9 @@
class TEXTE_PCB : public BOARD_ITEM, public EDA_TextStruct
{
public:
TEXTE_PCB( BOARD_ITEM* parent );
TEXTE_PCB( TEXTE_PCB* textepcb );
~TEXTE_PCB();
TEXTE_PCB( BOARD_ITEM* parent );
TEXTE_PCB( TEXTE_PCB* textepcb );
~TEXTE_PCB();
/**
@ -26,17 +26,16 @@ public:
}
/* supprime du chainage la structure Struct */
void UnLink();
/* supprime du chainage la structure Struct */
void UnLink();
/* duplicate structure */
void Copy( TEXTE_PCB* source );
/* duplicate structure */
void Copy( TEXTE_PCB* source );
void Draw( WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset, int DrawMode );
void Draw( WinEDA_DrawPanel * panel, wxDC* DC, int aDrawMode, const wxPoint& offset = ZeroOffset );
// File Operations:
int ReadTextePcbDescr( FILE* File, int* LineNum );
// File Operations:
int ReadTextePcbDescr( FILE* File, int* LineNum );
/**
* Function Save
@ -68,12 +67,12 @@ public:
}
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* @param refArea the given EDA_Rect to test
* @return bool - true if a hit, else false
*/
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* @param refArea the given EDA_Rect to test
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea )
{
return EDA_TextStruct::HitTest( refArea );

54
pcbnew/class_text_mod.cpp
View File

@ -106,7 +106,7 @@ void TEXTE_MODULE::Copy( TEXTE_MODULE* source ) // copy structure
m_Type = source->m_Type; // 0: ref,1: val, others = 2..255
m_Orient = source->m_Orient; // orientation in 1/10 deg
m_Pos0 = source->m_Pos0; // text coordinates relatives to the footprint ancre, orient 0
// Text coordinate ref point is the text centre
// Text coordinate ref point is the text centre
m_Size = source->m_Size;
m_Width = source->m_Width;
@ -201,23 +201,23 @@ void TEXTE_MODULE:: SetLocalCoord()
*/
EDA_Rect TEXTE_MODULE::GetTextRect(void)
{
EDA_Rect area;
EDA_Rect area;
int dx, dy;
dx = ( m_Size.x * GetLength() ) / 2;
dx = (dx * 10) / 9 ; /* letter size = 10/9 */
dx += m_Width / 2;
dx += m_Width / 2;
dy = ( m_Size.y + m_Width ) / 2;
wxPoint Org = m_Pos; // This is the position of the centre of the area
Org.x -= dx;
Org.y -= dy;
area.SetOrigin( Org);
area.SetHeight(2 * dy);
area.SetWidth(2 * dx);
area.Normalize();
wxPoint Org = m_Pos; // This is the position of the centre of the area
Org.x -= dx;
Org.y -= dy;
area.SetOrigin( Org);
area.SetHeight(2 * dy);
area.SetWidth(2 * dx);
area.Normalize();
return area;
return area;
}
/**
@ -229,11 +229,11 @@ EDA_Rect TEXTE_MODULE::GetTextRect(void)
bool TEXTE_MODULE::HitTest( const wxPoint& refPos )
{
wxPoint rel_pos;
EDA_Rect area = GetTextRect();
EDA_Rect area = GetTextRect();
/* Rotate refPos to - angle
* to test if refPos is within area (which is relative to an horizontal text)
*/
*/
rel_pos = refPos;
RotatePoint( &rel_pos, m_Pos, - GetDrawRotation() );
@ -249,25 +249,25 @@ bool TEXTE_MODULE::HitTest( const wxPoint& refPos )
*/
EDA_Rect TEXTE_MODULE::GetBoundingBox()
{
// Calculate area without text fielsd:
EDA_Rect text_area;
int angle = GetDrawRotation();
wxPoint textstart, textend;
// Calculate area without text fielsd:
EDA_Rect text_area;
int angle = GetDrawRotation();
wxPoint textstart, textend;
text_area = GetTextRect();
textstart = text_area.GetOrigin();
textend = text_area.GetEnd();
RotatePoint( &textstart, m_Pos, angle);
RotatePoint( &textend, m_Pos, angle);
text_area = GetTextRect();
textstart = text_area.GetOrigin();
textend = text_area.GetEnd();
RotatePoint( &textstart, m_Pos, angle);
RotatePoint( &textend, m_Pos, angle);
text_area.SetOrigin(textstart);
text_area.SetEnd(textend);
text_area.Normalize();
return text_area;
text_area.SetOrigin(textstart);
text_area.SetEnd(textend);
text_area.Normalize();
return text_area;
}
/******************************************************************************************/
void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, wxPoint offset, int draw_mode )
void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoint& offset )
/******************************************************************************************/
/** Function Draw

14
pcbnew/class_text_mod.h
View File

@ -19,13 +19,13 @@ public:
wxPoint m_Pos; // Real (physical)coord
int m_Width;
wxPoint m_Pos0; // text coordinates relatives to the footprint ancre, orient 0
// Text coordinate ref point is the text centre
// Text coordinate ref point is the text centre
char m_Unused; // unused (reserved for future extensions)
char m_Miroir; // Show normal / mirror
char m_NoShow; // 0: visible 1: invisible (bool)
char m_Type; // 0: ref,1: val, others = 2..255
int m_Orient; // orientation in 1/10 deg relative to the footprint
// Physical orient is m_Orient + m_Parent->m_Orient
// Physical orient is m_Orient + m_Parent->m_Orient
wxSize m_Size; // text size
wxString m_Text;
@ -56,10 +56,10 @@ public:
int Pitch(); /* retourne le pas entre 2 caracteres */
int GetDrawRotation(); // Return text rotation for drawings and plotting
/** Function GetTextRect
* @return an EDA_Rect which gives the position and size of the text area (for the 0 orient text and footprint)
*/
EDA_Rect GetTextRect(void);
/** Function GetTextRect
* @return an EDA_Rect which gives the position and size of the text area (for the 0 orient text and footprint)
*/
EDA_Rect GetTextRect(void);
/**
* Function GetBoundingBox
@ -84,7 +84,7 @@ public:
int ReadDescr( FILE* File, int* LineNum = NULL );
/* drawing functions */
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, wxPoint offset, int draw_mode );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int aDrawMode, const wxPoint& offset = ZeroOffset );
/**

2
pcbnew/class_track.cpp
View File

@ -626,7 +626,7 @@ bool TRACK::Save( FILE* aFile ) const
/*********************************************************************/
void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode )
void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoint& notUsed )
/*********************************************************************/
/** Draws the segment.

2
pcbnew/class_track.h
View File

@ -146,7 +146,7 @@ public:
/* Display on screen: */
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int aDrawMode, const wxPoint& offset = ZeroOffset );
/* divers */
int Shape() const { return m_Shape & 0xFF; }

2
pcbnew/class_zone.cpp
View File

@ -235,7 +235,7 @@ int ZONE_CONTAINER::ReadDescr( FILE* aFile, int* aLineNum )
/****************************************************************************************************/
void ZONE_CONTAINER::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode )
void ZONE_CONTAINER::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoint& offset )
/****************************************************************************************************/
/** Function Draw

55
pcbnew/class_zone.h
View File

@ -68,17 +68,16 @@ public:
* @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 ..
* @param aDrawMode = GR_OR, GR_XOR, GR_COPY ..
*/
void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int aDrawMode, const wxPoint& offset = ZeroOffset );
/**
* Function DrawWhileCreateOutline
* Draws the zone outline when ir is created.
* The moving edges are in XOR graphic mode, old segment in draw_mode graphic mode (usually GR_OR)
* The closing edge has its owm shape
* The moving edges are in XOR graphic mode, old segment in draw_mode graphic mode (usually GR_OR)
* The closing edge has its owm shape
* @param panel = current Draw Panel
* @param DC = current Device Context
* @param draw_mode = draw mode: OR, XOR ..
@ -179,34 +178,34 @@ public:
return wxT( "ZONE_CONTAINER" );
}
/** Acces to m_Poly parameters
*/
/** Acces to m_Poly parameters
*/
int GetNumCorners(void)
{
return m_Poly->GetNumCorners();
}
int GetNumCorners(void)
{
return m_Poly->GetNumCorners();
}
void RemoveAllContours(void)
{
m_Poly->RemoveAllContours();
}
void RemoveAllContours(void)
{
m_Poly->RemoveAllContours();
}
wxPoint GetCornerPosition(int aCornerIndex)
{
return wxPoint(m_Poly->GetX(aCornerIndex), m_Poly->GetY(aCornerIndex));
}
wxPoint GetCornerPosition(int aCornerIndex)
{
return wxPoint(m_Poly->GetX(aCornerIndex), m_Poly->GetY(aCornerIndex));
}
void SetCornerPosition(int aCornerIndex, wxPoint new_pos)
{
m_Poly->SetX(aCornerIndex, new_pos.x);
m_Poly->SetY(aCornerIndex, new_pos.y);
}
void SetCornerPosition(int aCornerIndex, wxPoint new_pos)
{
m_Poly->SetX(aCornerIndex, new_pos.x);
m_Poly->SetY(aCornerIndex, new_pos.y);
}
void AppendCorner( wxPoint position )
{
m_Poly->AppendCorner( position.x, position.y );
}
void AppendCorner( wxPoint position )
{
m_Poly->AppendCorner( position.x, position.y );
}
};

18
pcbnew/cotation.cpp
View File

@ -162,7 +162,7 @@ void WinEDA_CotationPropertiesFrame::OnOkClick( wxCommandEvent& event )
{
if( m_DC ) // Effacement ancien texte
{
CurrentCotation->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_XOR );
CurrentCotation->Draw( m_Parent->DrawPanel, m_DC, GR_XOR );
}
if( m_Name->GetValue() != wxEmptyString )
@ -183,7 +183,7 @@ void WinEDA_CotationPropertiesFrame::OnOkClick( wxCommandEvent& event )
if( m_DC ) // Affichage nouveau texte
{
/* Redessin du Texte */
CurrentCotation->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_OR );
CurrentCotation->Draw( m_Parent->DrawPanel, m_DC, GR_OR );
}
m_Parent->m_CurrentScreen->SetModify();
@ -201,12 +201,12 @@ static void Exit_EditCotation( WinEDA_DrawPanel* Panel, wxDC* DC )
{
if( Cotation->m_Flags & IS_NEW )
{
Cotation->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
Cotation->Draw( Panel, DC, GR_XOR );
Cotation->DeleteStructure();
}
else
{
Cotation->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR );
Cotation->Draw( Panel, DC, GR_OR );
}
}
@ -262,7 +262,7 @@ COTATION* WinEDA_PcbFrame::Begin_Cotation( COTATION* Cotation, wxDC* DC )
Ajuste_Details_Cotation( Cotation );
Cotation->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Cotation->Draw( DrawPanel, DC, GR_XOR );
DrawPanel->ManageCurseur = Montre_Position_New_Cotation;
DrawPanel->ForceCloseManageCurseur = Exit_EditCotation;
@ -276,7 +276,7 @@ COTATION* WinEDA_PcbFrame::Begin_Cotation( COTATION* Cotation, wxDC* DC )
return Cotation;
}
Cotation->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Cotation->Draw( DrawPanel, DC, GR_OR );
Cotation->m_Flags = 0;
/* Insertion de la structure dans le Chainage .Drawings du PCB */
@ -309,7 +309,7 @@ static void Montre_Position_New_Cotation( WinEDA_DrawPanel* panel, wxDC* DC, boo
/* efface ancienne position */
if( erase )
{
Cotation->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
Cotation->Draw( panel, DC, GR_XOR );
}
Cotation->SetLayer( screen->m_Active_Layer );
@ -345,7 +345,7 @@ static void Montre_Position_New_Cotation( WinEDA_DrawPanel* panel, wxDC* DC, boo
Ajuste_Details_Cotation( Cotation );
}
Cotation->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
Cotation->Draw( panel, DC, GR_XOR );
}
@ -372,7 +372,7 @@ void WinEDA_PcbFrame::Delete_Cotation( COTATION* Cotation, wxDC* DC )
return;
if( DC )
Cotation->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Cotation->Draw( DrawPanel, DC, GR_XOR );
Cotation->DeleteStructure();
m_CurrentScreen->SetModify();
}

8
pcbnew/dialog_edit_mod_text.cpp
View File

@ -425,8 +425,8 @@ void WinEDA_TextModPropertiesFrame::TextModPropertiesAccept( wxCommandEvent& eve
m_Parent->SaveCopyInUndoList( m_Parent->m_Pcb->m_Modules );
if( m_DC ) // Effacement ancien texte
{
m_CurrentTextMod->Draw( m_Parent->DrawPanel, m_DC,
(m_CurrentTextMod->m_Flags & IS_MOVED) ? MoveVector : wxPoint( 0, 0 ), GR_XOR );
m_CurrentTextMod->Draw( m_Parent->DrawPanel, m_DC, GR_XOR,
(m_CurrentTextMod->m_Flags & IS_MOVED) ? MoveVector : wxPoint( 0, 0 ) );
}
m_CurrentTextMod->m_Text = m_Name->GetValue();
@ -465,8 +465,8 @@ void WinEDA_TextModPropertiesFrame::TextModPropertiesAccept( wxCommandEvent& eve
m_CurrentTextMod->SetDrawCoord();
if( m_DC ) // Display new text
{
m_CurrentTextMod->Draw( m_Parent->DrawPanel, m_DC,
(m_CurrentTextMod->m_Flags & IS_MOVED) ? MoveVector : wxPoint( 0, 0 ), GR_XOR );
m_CurrentTextMod->Draw( m_Parent->DrawPanel, m_DC, GR_XOR,
(m_CurrentTextMod->m_Flags & IS_MOVED) ? MoveVector : wxPoint( 0, 0 ) );
}
m_Parent->GetScreen()->SetModify();
( (MODULE*) m_CurrentTextMod->m_Parent )->m_LastEdit_Time = time( NULL );

2
pcbnew/dialog_edit_module.cpp
View File

@ -588,7 +588,7 @@ void WinEDA_ModulePropertiesFrame::OnOkClick( wxCommandEvent& event )
EndModal( 1 );
if( m_DC )
m_CurrentModule->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_OR );
m_CurrentModule->Draw( m_Parent->DrawPanel, m_DC, GR_OR );
if( m_DC )
m_Parent->DrawPanel->CursorOn( m_DC );
}

36
pcbnew/edgemod.cpp
View File

@ -39,7 +39,7 @@ void WinEDA_ModuleEditFrame::Start_Move_EdgeMod( EDGE_MODULE* Edge, wxDC* DC )
{
if( Edge == NULL )
return;
Edge->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Edge->Draw( DrawPanel, DC, GR_XOR );
Edge->m_Flags |= IS_MOVED;
MoveVector.x = MoveVector.y = 0;
CursorInitialPosition = GetScreen()->m_Curseur;
@ -70,7 +70,7 @@ void WinEDA_ModuleEditFrame::Place_EdgeMod( EDGE_MODULE* Edge, wxDC* DC )
Edge->m_End0.x -= MoveVector.x;
Edge->m_End0.y -= MoveVector.y;
Edge->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Edge->Draw( DrawPanel, DC, GR_OR );
Edge->m_Flags = 0;
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
@ -96,13 +96,13 @@ static void Move_Segment( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
if( erase )
{
Edge->Draw( panel, DC, MoveVector, GR_XOR );
Edge->Draw( panel, DC, GR_XOR, MoveVector );
}
MoveVector.x = -(screen->m_Curseur.x - CursorInitialPosition.x);
MoveVector.y = -(screen->m_Curseur.y - CursorInitialPosition.y);
Edge->Draw( panel, DC, MoveVector, GR_XOR );
Edge->Draw( panel, DC, GR_XOR, MoveVector );
Module->Set_Rectangle_Encadrement();
}
@ -125,7 +125,7 @@ static void ShowEdgeModule( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
// if( erase )
{
Edge->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
Edge->Draw( panel, DC, GR_XOR );
}
Edge->m_End = screen->m_Curseur;
@ -136,7 +136,7 @@ static void ShowEdgeModule( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
RotatePoint( (int*) &Edge->m_End0.x,
(int*) &Edge->m_End0.y, -Module->m_Orient );
Edge->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
Edge->Draw( panel, DC, GR_XOR );
Module->Set_Rectangle_Encadrement();
}
@ -193,17 +193,17 @@ void WinEDA_ModuleEditFrame::Edit_Edge_Layer( EDGE_MODULE* Edge, wxDC* DC )
new_layer = Edge->GetLayer();
/* Ask for the new layer */
/* Ask for the new layer */
new_layer = SelectLayer( new_layer, FIRST_COPPER_LAYER, LAST_NO_COPPER_LAYER );
if( new_layer < 0 )
return;
if ( new_layer >= FIRST_COPPER_LAYER && new_layer <= LAST_COPPER_LAYER )
/* an edge is put on a copper layer, and it is very dangerous. a confirmation is requested */
{
if ( ! IsOK(this, _("The graphic item will be on a copper layer.It is very dangerous. Are you sure") ) )
return;
}
if ( new_layer >= FIRST_COPPER_LAYER && new_layer <= LAST_COPPER_LAYER )
/* an edge is put on a copper layer, and it is very dangerous. a confirmation is requested */
{
if ( ! IsOK(this, _("The graphic item will be on a copper layer.It is very dangerous. Are you sure") ) )
return;
}
SaveCopyInUndoList( Module );
@ -283,7 +283,7 @@ void WinEDA_ModuleEditFrame::Delete_Edge_Module( EDGE_MODULE* Edge, wxDC* DC )
}
MODULE* Module = (MODULE*) Edge->m_Parent;
Edge->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Edge->Draw( DrawPanel, DC, GR_XOR );
/* suppression d'un segment */
Edge ->DeleteStructure();
@ -306,15 +306,15 @@ static void Exit_EditEdge_Module( WinEDA_DrawPanel* Panel, wxDC* DC )
if( Edge->m_Flags & IS_NEW ) /* effacement du nouveau contour */
{
MODULE* Module = (MODULE*) Edge->m_Parent;
Edge->Draw( Panel, DC, MoveVector, GR_XOR );
Edge->Draw( Panel, DC, GR_XOR, MoveVector );
Edge ->DeleteStructure();
Module->Set_Rectangle_Encadrement();
}
else
{
Edge->Draw( Panel, DC, MoveVector, GR_XOR );
Edge->Draw( Panel, DC, GR_XOR, MoveVector );
Edge->m_Flags = 0;
Edge->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR );
Edge->Draw( Panel, DC, GR_OR );
}
}
Panel->ManageCurseur = NULL;
@ -390,7 +390,7 @@ EDGE_MODULE* WinEDA_ModuleEditFrame::Begin_Edge_Module( EDGE_MODULE* Edge,
if( (Edge->m_Start0.x) != (Edge->m_End0.x)
|| (Edge->m_Start0.y) != (Edge->m_End0.y) )
{
Edge->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Edge->Draw( DrawPanel, DC, GR_OR );
EDGE_MODULE* newedge = new EDGE_MODULE( Module );
newedge->Copy( Edge );
newedge->AddToChain( Edge );

8
pcbnew/edit.cpp
View File

@ -380,8 +380,8 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
break;
case ID_POPUP_PCB_PLACE_MICROVIA:
if ( ! ((PCB_SCREEN*)GetScreen())->IsMicroViaAcceptable() )
break;
if ( ! ((PCB_SCREEN*)GetScreen())->IsMicroViaAcceptable() )
break;
case ID_POPUP_PCB_PLACE_VIA:
DrawPanel->MouseToCursorSchema();
@ -521,10 +521,10 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
* and zone_cont->m_CornerSelection+1
* and start move the new corner
*/
zone_cont->Draw( DrawPanel, &dc, wxPoint( 0, 0 ), GR_XOR );
zone_cont->Draw( DrawPanel, &dc, GR_XOR );
zone_cont->m_Poly->InsertCorner( zone_cont->m_CornerSelection, pos.x, pos.y );
zone_cont->m_CornerSelection++;
zone_cont->Draw( DrawPanel, &dc, wxPoint( 0, 0 ), GR_XOR );
zone_cont->Draw( DrawPanel, &dc, GR_XOR );
Start_Move_Zone_Corner( &dc, zone_cont, zone_cont->m_CornerSelection, true );
break;
}

36
pcbnew/editedge.cpp
View File

@ -155,11 +155,6 @@ void WinEDA_PcbFrame::Drawing_SetNewWidth( DRAWSEGMENT* DrawSegm, wxDC* DC )
void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC )
/******************************************************************************/
{
DRAWSEGMENT* pt_segm;
TEXTE_PCB* pt_txt;
BOARD_ITEM* PtStruct;
BOARD_ITEM* PtNext;
COTATION* Cotation;
int layer = Segment->GetLayer();
if( layer <= LAST_COPPER_LAYER )
@ -178,39 +173,28 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
if( !IsOK( this, msg ) )
return;
PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtNext )
BOARD_ITEM* PtNext;
for( BOARD_ITEM* item = m_Pcb->m_Drawings; item; item = PtNext )
{
GetScreen()->SetModify();
PtNext = PtStruct->Next();
PtNext = item->Next();
switch( PtStruct->Type() )
switch( item->Type() )
{
case TYPEDRAWSEGMENT:
pt_segm = (DRAWSEGMENT*) PtStruct;
if( pt_segm->GetLayer() == layer )
if( item->GetLayer() == layer )
{
Trace_DrawSegmentPcb( DrawPanel, DC, pt_segm, GR_XOR );
PtStruct ->DeleteStructure();
Trace_DrawSegmentPcb( DrawPanel, DC, (DRAWSEGMENT*) item, GR_XOR );
item->DeleteStructure();
}
break;
case TYPETEXTE:
pt_txt = (TEXTE_PCB*) PtStruct;
if( pt_txt->GetLayer() == layer )
{
pt_txt->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
PtStruct ->DeleteStructure();
}
break;
case TYPECOTATION:
Cotation = (COTATION*) PtStruct;
if( Cotation->GetLayer() == layer )
if( item->GetLayer() == layer )
{
Cotation->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
PtStruct ->DeleteStructure();
item->Draw( DrawPanel, DC, GR_XOR );
item->DeleteStructure();
}
break;

58
pcbnew/editpads.cpp
View File

@ -356,7 +356,7 @@ void WinEDA_PadPropertiesFrame::PadPropertiesAccept( wxCommandEvent& event )
{
long PadLayerMask;
bool error = FALSE;
bool RastnestIsChanged = false;
bool RastnestIsChanged = false;
if( m_DC )
m_Parent->DrawPanel->CursorOff( m_DC );
@ -443,14 +443,14 @@ void WinEDA_PadPropertiesFrame::PadPropertiesAccept( wxCommandEvent& event )
Module->m_LastEdit_Time = time( NULL );
if( m_DC )
CurrentPad->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_XOR );
CurrentPad->Draw( m_Parent->DrawPanel, m_DC, GR_XOR );
CurrentPad->m_PadShape = g_Pad_Master.m_PadShape;
CurrentPad->m_Attribut = g_Pad_Master.m_Attribut;
if (CurrentPad->m_Pos != g_Pad_Master.m_Pos )
{
CurrentPad->m_Pos = g_Pad_Master.m_Pos;
RastnestIsChanged = true;
}
if (CurrentPad->m_Pos != g_Pad_Master.m_Pos )
{
CurrentPad->m_Pos = g_Pad_Master.m_Pos;
RastnestIsChanged = true;
}
/* compute the pos 0 value, i.e. pad position for module orient = 0 i.e.
* refer to module origin (module position) */
@ -466,29 +466,29 @@ void WinEDA_PadPropertiesFrame::PadPropertiesAccept( wxCommandEvent& event )
CurrentPad->m_DrillShape = g_Pad_Master.m_DrillShape;
CurrentPad->m_Offset = g_Pad_Master.m_Offset;
if ( CurrentPad->m_Masque_Layer != g_Pad_Master.m_Masque_Layer )
{
RastnestIsChanged = true;
CurrentPad->m_Masque_Layer = g_Pad_Master.m_Masque_Layer;
}
{
RastnestIsChanged = true;
CurrentPad->m_Masque_Layer = g_Pad_Master.m_Masque_Layer;
}
CurrentPad->SetPadName( g_Current_PadName );
if ( CurrentPad->m_Netname != Current_PadNetName )
{
if( Current_PadNetName.IsEmpty() )
CurrentPad->SetNet( 0 );
else
{
const EQUIPOT* net = m_Parent->m_Pcb->FindNet( Current_PadNetName );
if ( net )
{
RastnestIsChanged = true;
CurrentPad->m_Netname = Current_PadNetName;
CurrentPad->SetNet(net->GetNet());
}
else
DisplayError(this, _("Unknown netname, no change"));
}
}
{
if( Current_PadNetName.IsEmpty() )
CurrentPad->SetNet( 0 );
else
{
const EQUIPOT* net = m_Parent->m_Pcb->FindNet( Current_PadNetName );
if ( net )
{
RastnestIsChanged = true;
CurrentPad->m_Netname = Current_PadNetName;
CurrentPad->SetNet(net->GetNet());
}
else
DisplayError(this, _("Unknown netname, no change"));
}
}
switch( CurrentPad->m_PadShape )
{
@ -530,7 +530,7 @@ void WinEDA_PadPropertiesFrame::PadPropertiesAccept( wxCommandEvent& event )
Module->Set_Rectangle_Encadrement();
CurrentPad->Display_Infos( m_Parent );
if( m_DC )
CurrentPad->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_OR );
CurrentPad->Draw( m_Parent->DrawPanel, m_DC, GR_OR );
m_Parent->GetScreen()->SetModify();
}
@ -538,7 +538,7 @@ void WinEDA_PadPropertiesFrame::PadPropertiesAccept( wxCommandEvent& event )
if( m_DC )
m_Parent->DrawPanel->CursorOn( m_DC );
if ( RastnestIsChanged ) // The net ratsnest must be recalculated
if ( RastnestIsChanged ) // The net ratsnest must be recalculated
m_Parent->m_Pcb->m_Status_Pcb = 0;

46
pcbnew/editrack-part2.cpp
View File

@ -224,29 +224,29 @@ bool WinEDA_PcbFrame::Other_Layer_Route( TRACK* track, wxDC* DC )
/* Adjust the via layer pair */
switch ( Via->Shape() )
{
case VIA_BLIND_BURIED:
Via->SetLayerPair( old_layer, ((PCB_SCREEN*)GetScreen())->m_Active_Layer );
break;
{
case VIA_BLIND_BURIED:
Via->SetLayerPair( old_layer, ((PCB_SCREEN*)GetScreen())->m_Active_Layer );
break;
case VIA_MICROVIA: // from external to the near neghbour inner layer
if ( old_layer == COPPER_LAYER_N )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = LAYER_N_2;
else if ( old_layer == LAYER_CMP_N )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = m_Pcb->m_BoardSettings->m_CopperLayerCount - 2;
else if ( old_layer == LAYER_N_2 )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = COPPER_LAYER_N;
else if ( old_layer == m_Pcb->m_BoardSettings->m_CopperLayerCount - 2 )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = LAYER_CMP_N;
// else error
Via->SetLayerPair( old_layer, ((PCB_SCREEN*)GetScreen())->m_Active_Layer );
Via->m_Width = g_DesignSettings.m_CurrentMicroViaSize;
break;
case VIA_MICROVIA: // from external to the near neghbour inner layer
if ( old_layer == COPPER_LAYER_N )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = LAYER_N_2;
else if ( old_layer == LAYER_CMP_N )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = m_Pcb->m_BoardSettings->m_CopperLayerCount - 2;
else if ( old_layer == LAYER_N_2 )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = COPPER_LAYER_N;
else if ( old_layer == m_Pcb->m_BoardSettings->m_CopperLayerCount - 2 )
((PCB_SCREEN*)GetScreen())->m_Active_Layer = LAYER_CMP_N;
// else error
Via->SetLayerPair( old_layer, ((PCB_SCREEN*)GetScreen())->m_Active_Layer );
Via->m_Width = g_DesignSettings.m_CurrentMicroViaSize;
break;
default:
// Usual via is from copper to component; layer pair is 0 and 0x0F.
Via->SetLayerPair( COPPER_LAYER_N, LAYER_CMP_N );
break;
default:
// Usual via is from copper to component; layer pair is 0 and 0x0F.
Via->SetLayerPair( COPPER_LAYER_N, LAYER_CMP_N );
break;
}
if( Drc_On && BAD_DRC==m_drc->Drc( Via, m_Pcb->m_Track ) )
@ -477,10 +477,10 @@ void WinEDA_PcbFrame::Affiche_PadsNoConnect( wxDC* DC )
pt_pad = pt_chevelu->pad_start;
if( pt_pad )
pt_pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR | GR_SURBRILL );
pt_pad->Draw( DrawPanel, DC, GR_OR | GR_SURBRILL );
pt_pad = pt_chevelu->pad_end;
if( pt_pad )
pt_pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR | GR_SURBRILL );
pt_pad->Draw( DrawPanel, DC, GR_OR | GR_SURBRILL );
}
}

18
pcbnew/edtxtmod.cpp
View File

@ -56,7 +56,7 @@ TEXTE_MODULE* WinEDA_BasePcbFrame::CreateTextModule( MODULE* Module, wxDC* DC )
InstallTextModOptionsFrame( Text, NULL, wxPoint( -1, -1 ) );
Text->m_Flags = 0;
Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Text->Draw( DrawPanel, DC, GR_OR );
Text->Display_Infos( this );
@ -74,14 +74,14 @@ void WinEDA_BasePcbFrame::RotateTextModule( TEXTE_MODULE* Text, wxDC* DC )
MODULE* module = (MODULE*) Text->m_Parent;
Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Text->Draw( DrawPanel, DC, GR_XOR );
Text->m_Orient += 900;
while( Text->m_Orient >= 1800 )
Text->m_Orient -= 1800;
/* Redessin du Texte */
Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Text->Draw( DrawPanel, DC, GR_XOR );
Text->Display_Infos( this );
@ -107,7 +107,7 @@ void WinEDA_BasePcbFrame::DeleteTextModule( TEXTE_MODULE* Text, wxDC* DC )
if( Text->m_Type == TEXT_is_DIVERS )
{
Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Text->Draw( DrawPanel, DC, GR_XOR );
/* liberation de la memoire : */
Text ->DeleteStructure();
@ -137,10 +137,10 @@ static void ExitTextModule( WinEDA_DrawPanel* Panel, wxDC* DC )
return;
Module = (MODULE*) Text->m_Parent;
Text->Draw( Panel, DC, MoveVector, GR_XOR );
Text->Draw( Panel, DC, GR_XOR, MoveVector );
/* Redessin du Texte */
Text->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR );
Text->Draw( Panel, DC, GR_OR );
Text->m_Flags = 0;
Module->m_Flags = 0;
@ -205,7 +205,7 @@ void WinEDA_BasePcbFrame::PlaceTexteModule( TEXTE_MODULE* Text, wxDC* DC )
GetScreen()->SetModify();
/* Redessin du Texte */
Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Text->Draw( DrawPanel, DC, GR_OR );
}
}
@ -229,11 +229,11 @@ static void Show_MoveTexte_Module( WinEDA_DrawPanel* panel, wxDC* DC, bool erase
/* effacement du texte : */
if( erase )
Text->Draw( panel, DC, MoveVector, GR_XOR );
Text->Draw( panel, DC, GR_XOR, MoveVector );
MoveVector.x = -(screen->m_Curseur.x - CursorInitialPosition.x);
MoveVector.y = -(screen->m_Curseur.y - CursorInitialPosition.y);
/* Redessin du Texte */
Text->Draw( panel, DC, MoveVector, GR_XOR );
Text->Draw( panel, DC, GR_XOR, MoveVector );
}

4
pcbnew/gen_self.h
View File

@ -285,7 +285,7 @@ MODULE* WinEDA_PcbFrame::Genere_Self( wxDC* DC )
Module->m_Attributs = MOD_VIRTUAL | MOD_CMS;
Module->m_Flags = 0;
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( DrawPanel, DC, GR_XOR );
/* Generation des elements speciaux: drawsegments */
LastSegm = (EDGE_MODULE*) Module->m_Drawings;
@ -472,7 +472,7 @@ MODULE* WinEDA_PcbFrame::Genere_Self( wxDC* DC )
Module->Set_Rectangle_Encadrement();
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
return Module;
}

4
pcbnew/globaleditpad.cpp
View File

@ -266,7 +266,7 @@ void WinEDA_BasePcbFrame::Global_Import_Pad_Settings( D_PAD* Pad, wxDC* DC )
Module->Display_Infos( this );
/* Effacement du module */
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( DrawPanel, DC, GR_XOR );
pt_pad = (D_PAD*) Module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
@ -345,7 +345,7 @@ void WinEDA_BasePcbFrame::Global_Import_Pad_Settings( D_PAD* Pad, wxDC* DC )
}
Module->Set_Rectangle_Encadrement();
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
}
GetScreen()->SetModify();

16
pcbnew/lay2plot.cpp
View File

@ -69,21 +69,21 @@ void WinEDA_DrawPanel::PrintPage( wxDC* DC, bool Print_Sheet_Ref, int printmaskl
case TYPECOTATION:
if( (g_TabOneLayerMask[ PtStruct->GetLayer()] & printmasklayer) == 0 )
break;
( (COTATION*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode );
( (COTATION*) PtStruct )->Draw( this, DC, drawmode );
break;
case TYPETEXTE:
{
if( (g_TabOneLayerMask[ PtStruct->GetLayer()] & printmasklayer) == 0 )
break;
( (TEXTE_PCB*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode );
( (TEXTE_PCB*) PtStruct )->Draw( this, DC, drawmode );
break;
}
case TYPEMIRE:
if( (g_TabOneLayerMask[ PtStruct->GetLayer()] & printmasklayer) == 0 )
break;
( (MIREPCB*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode );
( (MIREPCB*) PtStruct )->Draw( this, DC, drawmode );
break;
case TYPEMARKER: /* Trace des marqueurs */
@ -170,7 +170,7 @@ static void Plot_Module( WinEDA_DrawPanel* panel, wxDC* DC,
{
if( (pt_pad->m_Masque_Layer & masklayer ) == 0 )
continue;
pt_pad->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
pt_pad->Draw( panel, DC, draw_mode );
}
/* draw footprint graphic shapes */
@ -192,9 +192,9 @@ static void Plot_Module( WinEDA_DrawPanel* panel, wxDC* DC,
trace_val = FALSE;
if( trace_ref )
Module->m_Reference->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
Module->m_Reference->Draw( panel, DC, draw_mode );
if( trace_val )
Module->m_Value->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
Module->m_Value->Draw( panel, DC, draw_mode );
}
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
@ -206,7 +206,7 @@ static void Plot_Module( WinEDA_DrawPanel* panel, wxDC* DC,
break;
TextMod = (TEXTE_MODULE*) PtStruct;
TextMod->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
TextMod->Draw( panel, DC, draw_mode );
break;
case TYPEEDGEMODULE:
@ -214,7 +214,7 @@ static void Plot_Module( WinEDA_DrawPanel* panel, wxDC* DC,
EDGE_MODULE* edge = (EDGE_MODULE*) PtStruct;
if( (g_TabOneLayerMask[edge->GetLayer()] & masklayer ) == 0 )
break;
edge->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
edge->Draw( panel, DC, draw_mode );
break;
}

2
pcbnew/loadcmp.cpp
View File

@ -162,7 +162,7 @@ MODULE* WinEDA_BasePcbFrame::Load_Module_From_Library( const wxString& library,
module->SetPosition( curspos );
build_liste_pads();
module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
module->Draw( DrawPanel, DC, GR_OR );
}
return module;

20
pcbnew/mirepcb.cpp
View File

@ -143,13 +143,13 @@ void WinEDA_MirePropertiesFrame::OnOkClick( wxCommandEvent& event )
/* Met a jour les differents parametres pour le composant en cours d'édition
*/
{
m_MirePcb->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_XOR );
m_MirePcb->Draw( m_Parent->DrawPanel, m_DC, GR_XOR );
m_MirePcb->m_Width = m_MireWidthCtrl->GetValue();
MireDefaultSize = m_MirePcb->m_Size = m_MireSizeCtrl->GetValue();
m_MirePcb->m_Shape = m_MireShape->GetSelection() ? 1 : 0;
m_MirePcb->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_OR );
m_MirePcb->Draw( m_Parent->DrawPanel, m_DC, GR_OR );
m_Parent->GetScreen()->SetModify();
EndModal( 1 );
@ -163,8 +163,8 @@ void WinEDA_PcbFrame::Delete_Mire( MIREPCB* MirePcb, wxDC* DC )
if( MirePcb == NULL )
return;
MirePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
MirePcb ->DeleteStructure();
MirePcb->Draw( DrawPanel, DC, GR_XOR );
MirePcb->DeleteStructure();
}
@ -181,11 +181,11 @@ static void Exit_EditMire( WinEDA_DrawPanel* Panel, wxDC* DC )
if( MirePcb )
{
/* Effacement de la mire */
MirePcb->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
MirePcb->Draw( Panel, DC, GR_XOR );
if( MirePcb->m_Flags & IS_NEW )
{
MirePcb->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
MirePcb->Draw( Panel, DC, GR_XOR );
MirePcb ->DeleteStructure();
MirePcb = NULL;
}
@ -193,7 +193,7 @@ static void Exit_EditMire( WinEDA_DrawPanel* Panel, wxDC* DC )
{
MirePcb->m_Pos = OldPos;
MirePcb->m_Flags = 0;
MirePcb->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR );
MirePcb->Draw( Panel, DC, GR_OR );
}
}
}
@ -250,7 +250,7 @@ void WinEDA_PcbFrame::Place_Mire( MIREPCB* MirePcb, wxDC* DC )
if( MirePcb == NULL )
return;
MirePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
MirePcb->Draw( DrawPanel, DC, GR_OR );
MirePcb->m_Flags = 0;
DrawPanel->ManageCurseur = NULL;
@ -273,10 +273,10 @@ static void Montre_Position_Mire( WinEDA_DrawPanel* panel, wxDC* DC, bool erase
/* efface ancienne position */
if( erase )
MirePcb->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
MirePcb->Draw( panel, DC, GR_XOR );
MirePcb->m_Pos = screen->m_Curseur;
// Reaffichage
MirePcb->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
MirePcb->Draw( panel, DC, GR_XOR );
}

52
pcbnew/modules.cpp
View File

@ -47,7 +47,7 @@ void Show_Pads_On_Off( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* module )
pt_pad = module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
pt_pad->Draw( panel, DC, g_Offset_Module, GR_XOR );
pt_pad->Draw( panel, DC, GR_XOR, g_Offset_Module );
}
DisplayOpt.DisplayPadFill = pad_fill_tmp;
@ -127,12 +127,12 @@ void WinEDA_PcbFrame::StartMove_Module( MODULE* module, wxDC* DC )
// effacement module a l'ecran:
if ( DC )
{
int tmp = module->m_Flags;
module->m_Flags |= DO_NOT_DRAW;
DrawPanel->PostDirtyRect( module->GetBoundingBox() );
module->m_Flags = tmp;
}
{
int tmp = module->m_Flags;
module->m_Flags |= DO_NOT_DRAW;
DrawPanel->PostDirtyRect( module->GetBoundingBox() );
module->m_Flags = tmp;
}
// Reaffichage
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
@ -200,7 +200,7 @@ void Exit_Module( WinEDA_DrawPanel* Panel, wxDC* DC )
pcbframe->Rotate_Module( NULL, module, ModuleInitOrient, FALSE );
if( ModuleInitLayer != module->GetLayer() )
pcbframe->m_Pcb->Change_Side_Module( module, NULL );
module->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR );
module->Draw( Panel, DC, GR_OR );
}
g_Drag_Pistes_On = FALSE;
Panel->ManageCurseur = NULL;
@ -300,8 +300,8 @@ bool WinEDA_PcbFrame::Delete_Module( MODULE* module, wxDC* DC, bool aAskBeforeDe
m_CurrentScreen->SetModify();
/* Erase rastnest if needed
* Dirty rectangle is not used here because usually using a XOR draw mode gives good results (very few artefacts) for ratsnest
*/
* Dirty rectangle is not used here because usually using a XOR draw mode gives good results (very few artefacts) for ratsnest
*/
if( g_Show_Ratsnest )
DrawGeneralRatsnest( DC );
@ -327,7 +327,7 @@ bool WinEDA_PcbFrame::Delete_Module( MODULE* module, wxDC* DC, bool aAskBeforeDe
ReCompile_Ratsnest_After_Changes( DC );
// redraw the area where the module was
if ( DC )
DrawPanel->PostDirtyRect( module->GetBoundingBox() );
DrawPanel->PostDirtyRect( module->GetBoundingBox() );
return TRUE;
}
@ -362,12 +362,12 @@ void BOARD::Change_Side_Module( MODULE* Module, wxDC* DC )
{
m_Status_Pcb &= ~( LISTE_CHEVELU_OK | CONNEXION_OK);
if( DC && m_PcbFrame )
{
int tmp = Module->m_Flags;
Module->m_Flags |= DO_NOT_DRAW;
m_PcbFrame->DrawPanel->PostDirtyRect( Module->GetBoundingBox() );
Module->m_Flags = tmp;
}
{
int tmp = Module->m_Flags;
Module->m_Flags |= DO_NOT_DRAW;
m_PcbFrame->DrawPanel->PostDirtyRect( Module->GetBoundingBox() );
Module->m_Flags = tmp;
}
/* Effacement chevelu general si necessaire */
if( DC && g_Show_Ratsnest )
@ -514,13 +514,13 @@ void BOARD::Change_Side_Module( MODULE* Module, wxDC* DC )
Module->Set_Rectangle_Encadrement();
if ( m_PcbFrame )
Module->Display_Infos( m_PcbFrame );
Module->Display_Infos( m_PcbFrame );
if( !(Module->m_Flags & IS_MOVED) ) /* Inversion simple */
{
if( DC && m_PcbFrame )
{
Module->Draw( m_PcbFrame->DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( m_PcbFrame->DrawPanel, DC, GR_OR );
/* affichage chevelu general si necessaire */
m_PcbFrame->ReCompile_Ratsnest_After_Changes( DC );
@ -671,7 +671,7 @@ void WinEDA_BasePcbFrame::Place_Module( MODULE* module, wxDC* DC )
module->SetPosition( newpos );
if( DC )
module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
module->Draw( DrawPanel, DC, GR_OR );
/* Tracage des segments dragges et liberation memoire */
if( g_DragSegmentList )
@ -723,10 +723,10 @@ void WinEDA_BasePcbFrame::Rotate_Module( wxDC* DC, MODULE* module,
{
if( DC )
{
int tmp = module->m_Flags;
module->m_Flags |= DO_NOT_DRAW;
DrawPanel->PostDirtyRect( module->GetBoundingBox() );
module->m_Flags = tmp;
int tmp = module->m_Flags;
module->m_Flags |= DO_NOT_DRAW;
DrawPanel->PostDirtyRect( module->GetBoundingBox() );
module->m_Flags = tmp;
/* Reaffichage chevelu general si necessaire */
if( g_Show_Ratsnest )
@ -756,7 +756,7 @@ void WinEDA_BasePcbFrame::Rotate_Module( wxDC* DC, MODULE* module,
{
if( !(module->m_Flags & IS_MOVED) ) /* Rotation simple */
{
module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
module->Draw( DrawPanel, DC, GR_OR );
/* Reaffichage chevelu general si necessaire */
ReCompile_Ratsnest_After_Changes( DC );
@ -792,7 +792,7 @@ void DrawModuleOutlines( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* module )
pt_pad = module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
pt_pad->Draw( panel, DC, g_Offset_Module, GR_XOR );
pt_pad->Draw( panel, DC, GR_XOR, g_Offset_Module );
}
DisplayOpt.DisplayPadFill = pad_fill_tmp;

27
pcbnew/move-drag_pads.cpp
View File

@ -36,10 +36,10 @@ static void Exit_Move_Pad( WinEDA_DrawPanel* Panel, wxDC* DC )
if( pad == NULL )
return;
pad->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
pad->Draw( Panel, DC, GR_XOR );
pad->m_Flags = 0;
pad->m_Pos = Pad_OldPos;
pad->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
pad->Draw( Panel, DC, GR_XOR );
/* Pad Move en cours : remise a l'etat d'origine */
if( g_Drag_Pistes_On )
{
@ -72,9 +72,10 @@ static void Show_Pad_Move( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
D_PAD* pad = s_CurrentSelectedPad;
if( erase )
pad->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
pad->Draw( panel, DC, GR_XOR );
pad->m_Pos = screen->m_Curseur;
pad->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
pad->Draw( panel, DC, GR_XOR );
if( !g_Drag_Pistes_On )
return;
@ -141,7 +142,7 @@ void WinEDA_BasePcbFrame::Import_Pad_Settings( D_PAD* pt_pad, wxDC* DC )
*/
{
if( DC )
pt_pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
pt_pad->Draw( DrawPanel, DC, GR_XOR );
pt_pad->m_PadShape = g_Pad_Master.m_PadShape;
pt_pad->m_Masque_Layer = g_Pad_Master.m_Masque_Layer;
@ -178,7 +179,7 @@ void WinEDA_BasePcbFrame::Import_Pad_Settings( D_PAD* pt_pad, wxDC* DC )
pt_pad->ComputeRayon();
if( DC )
pt_pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
pt_pad->Draw( DrawPanel, DC, GR_XOR );
( (MODULE*) pt_pad->m_Parent )->m_LastEdit_Time = time( NULL );
}
@ -247,7 +248,7 @@ void WinEDA_BasePcbFrame::AddPad( MODULE* Module, wxDC* DC )
/* Redessin du module */
Module->Set_Rectangle_Encadrement();
Pad->Display_Infos( this );
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
}
@ -301,9 +302,9 @@ void WinEDA_BasePcbFrame::StartMovePad( D_PAD* Pad, wxDC* DC )
DrawPanel->ForceCloseManageCurseur = Exit_Move_Pad;
/* Draw the pad (SKETCH mode) */
Pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Pad->Draw( DrawPanel, DC, GR_XOR );
Pad->m_Flags |= IS_MOVED;
Pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Pad->Draw( DrawPanel, DC, GR_XOR );
/* Build the list of track segments to drag if the command is a drag pad*/
if( g_Drag_Pistes_On )
@ -329,7 +330,7 @@ void WinEDA_BasePcbFrame::PlacePad( D_PAD* Pad, wxDC* DC )
Module = (MODULE*) Pad->m_Parent;
/* Placement du pad */
Pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Pad->Draw( DrawPanel, DC, GR_XOR );
/* Save old module */
Pad->m_Pos = Pad_OldPos; SaveCopyInUndoList( m_Pcb->m_Modules );
@ -345,7 +346,7 @@ void WinEDA_BasePcbFrame::PlacePad( D_PAD* Pad, wxDC* DC )
Pad->m_Flags = 0;
Pad->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Pad->Draw( DrawPanel, DC, GR_OR );
Module->Set_Rectangle_Encadrement();
Module->m_LastEdit_Time = time( NULL );
@ -386,7 +387,7 @@ void WinEDA_BasePcbFrame::RotatePad( D_PAD* Pad, wxDC* DC )
GetScreen()->SetModify();
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( DrawPanel, DC, GR_XOR );
EXCHG( Pad->m_Size.x, Pad->m_Size.y );
EXCHG( Pad->m_Drill.x, Pad->m_Drill.y );
@ -400,5 +401,5 @@ void WinEDA_BasePcbFrame::RotatePad( D_PAD* Pad, wxDC* DC )
Module->Set_Rectangle_Encadrement();
Pad->Display_Infos( this );
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
}

14
pcbnew/muonde.cpp
View File

@ -86,7 +86,7 @@ MODULE* WinEDA_PcbFrame::Create_MuWaveBasicShape( wxDC* DC,
}
if( DC )
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
return Module;
}
@ -102,12 +102,12 @@ static void Exit_Muonde( WinEDA_DrawFrame* frame, wxDC* DC )
{
if( Module->m_Flags & IS_NEW )
{
Module->Draw( frame->DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( frame->DrawPanel, DC, GR_XOR );
Module ->DeleteStructure();
}
else
{
Module->Draw( frame->DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( frame->DrawPanel, DC, GR_XOR );
}
}
@ -273,7 +273,7 @@ MODULE* WinEDA_PcbFrame::Create_MuWaveComponent( wxDC* DC, int shape_type )
}
Module->Set_Rectangle_Encadrement();
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
DrawPanel->MouseToCursorSchema();
m_Pcb->m_Status_Pcb = 0;
m_CurrentScreen->SetModify();
@ -644,7 +644,7 @@ MODULE* WinEDA_PcbFrame::Create_MuWavePolygonShape( wxDC* DC )
PolyEdges = NULL;
Module->Set_Rectangle_Encadrement();
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
m_Pcb->m_Status_Pcb = 0;
m_CurrentScreen->SetModify();
return Module;
@ -685,7 +685,7 @@ void WinEDA_PcbFrame::Edit_Gap( wxDC* DC, MODULE* Module )
}
/* Effacement du module: */
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
Module->Draw( DrawPanel, DC, GR_XOR );
/* Calcul de la dimension actuelle */
gap_size = next_pad->m_Pos0.x - pad->m_Pos0.x - pad->m_Size.x;
@ -728,5 +728,5 @@ void WinEDA_PcbFrame::Edit_Gap( wxDC* DC, MODULE* Module )
RotatePoint( &(next_pad->m_Pos.x), &(next_pad->m_Pos.y),
Module->m_Pos.x, Module->m_Pos.y, Module->m_Orient );
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
}

22
pcbnew/pcbtexte.cpp
View File

@ -215,7 +215,7 @@ void WinEDA_TextPCBPropertiesFrame::OnOkClick( wxCommandEvent& event )
if( m_DC ) // Effacement ancien texte
{
CurrentTextPCB->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_XOR );
CurrentTextPCB->Draw( m_Parent->DrawPanel, m_DC, GR_XOR );
}
if( !m_Name->GetValue().IsEmpty() )
@ -238,7 +238,7 @@ void WinEDA_TextPCBPropertiesFrame::OnOkClick( wxCommandEvent& event )
if( m_DC ) // Affichage nouveau texte
{
/* Redessin du Texte */
CurrentTextPCB->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_OR );
CurrentTextPCB->Draw( m_Parent->DrawPanel, m_DC, GR_OR );
}
m_Parent->m_CurrentScreen->SetModify();
EndModal( 1 );
@ -260,9 +260,9 @@ void Exit_Texte_Pcb( WinEDA_DrawPanel* Panel, wxDC* DC )
if( TextePcb )
{
TextePcb->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
TextePcb->Draw( Panel, DC, GR_XOR );
TextePcb->m_Pos = old_pos;
TextePcb->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR );
TextePcb->Draw( Panel, DC, GR_OR );
TextePcb->m_Flags = 0;
}
@ -284,7 +284,7 @@ void WinEDA_PcbFrame::Place_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC )
return;
TextePcb->CreateDrawData();
TextePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
TextePcb->Draw( DrawPanel, DC, GR_OR );
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
SetCurItem( NULL );
@ -303,7 +303,7 @@ void WinEDA_PcbFrame::StartMoveTextePcb( TEXTE_PCB* TextePcb, wxDC* DC )
if( TextePcb == NULL )
return;
old_pos = TextePcb->m_Pos;
TextePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
TextePcb->Draw( DrawPanel, DC, GR_XOR );
TextePcb->m_Flags |= IS_MOVED;
TextePcb->Display_Infos( this );
DrawPanel->ManageCurseur = Move_Texte_Pcb;
@ -327,12 +327,12 @@ static void Move_Texte_Pcb( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
/* effacement du texte : */
if( erase )
TextePcb->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
TextePcb->Draw( panel, DC, GR_XOR );
TextePcb->m_Pos = panel->m_Parent->m_CurrentScreen->m_Curseur;
/* Redessin du Texte */
TextePcb->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
TextePcb->Draw( panel, DC, GR_XOR );
}
@ -343,7 +343,7 @@ void WinEDA_PcbFrame::Delete_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC )
if( TextePcb == NULL )
return;
TextePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
TextePcb->Draw( DrawPanel, DC, GR_XOR );
/* Suppression du texte en Memoire*/
TextePcb ->DeleteStructure();
@ -403,7 +403,7 @@ void WinEDA_PcbFrame::Rotate_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC )
return;
/* effacement du texte : */
TextePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
TextePcb->Draw( DrawPanel, DC, GR_XOR );
TextePcb->m_Orient += angle;
@ -415,7 +415,7 @@ void WinEDA_PcbFrame::Rotate_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC )
TextePcb->CreateDrawData();
/* Redessin du Texte */
TextePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), drawmode );
TextePcb->Draw( DrawPanel, DC, drawmode );
TextePcb->Display_Infos( this );
m_CurrentScreen->SetModify();

8
pcbnew/solve.cpp
View File

@ -254,8 +254,8 @@ int WinEDA_PcbFrame::Solve( wxDC* DC, int two_sides )
/* Affiche Liaison */
GRLine( &DrawPanel->m_ClipBox, DC, segm_oX, segm_oY, segm_fX, segm_fY, 0, WHITE | GR_XOR );
pt_cur_ch->pad_start->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR | GR_SURBRILL );
pt_cur_ch->pad_end->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR | GR_SURBRILL );
pt_cur_ch->pad_start->Draw( DrawPanel, DC, GR_OR | GR_SURBRILL );
pt_cur_ch->pad_end->Draw( DrawPanel, DC, GR_OR | GR_SURBRILL );
success = Route_1_Trace( this, DC, two_sides, row_source, col_source,
row_target, col_target, pt_cur_ch );
@ -288,8 +288,8 @@ int WinEDA_PcbFrame::Solve( wxDC* DC, int two_sides )
Affiche_1_Parametre( this, 72, wxT( "NoConn" ), msg, LIGHTCYAN );
/* Effacement des affichages de routage sur l'ecran */
pt_cur_ch->pad_start->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_AND );
pt_cur_ch->pad_end->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_AND );
pt_cur_ch->pad_start->Draw( DrawPanel, DC, GR_AND );
pt_cur_ch->pad_end->Draw( DrawPanel, DC, GR_AND );
if( stop )
break;

8
pcbnew/surbrill.cpp
View File

@ -184,15 +184,13 @@ void WinEDA_PcbFrame::DrawHightLight( wxDC* DC, int NetCode )
}
#endif
wxPoint zero(0,0); // construct outside loop for speed
// Redraw ZONE_CONTAINERS
BOARD::ZONE_CONTAINERS& zones = m_Pcb->m_ZoneDescriptorList;
for( BOARD::ZONE_CONTAINERS::iterator zc = zones.begin(); zc!=zones.end(); ++zc )
{
if( (*zc)->GetNet() == NetCode )
{
(*zc)->Draw( DrawPanel, DC, zero, draw_mode );
(*zc)->Draw( DrawPanel, DC, draw_mode );
}
}
@ -221,14 +219,12 @@ static void Pad_Surbrillance( WinEDA_DrawPanel* panel,
{
D_PAD* pt_pad;
wxPoint zero(0,0); // construct outside loop for speed
/* trace des pastilles */
for( pt_pad = Module->m_Pads; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
if( pt_pad->GetNet() == NetCode )
{
pt_pad->Draw( panel, DC, zero, draw_mode );
pt_pad->Draw( panel, DC, draw_mode );
}
}
}

2
pcbnew/tracemod.cpp
View File

@ -58,7 +58,7 @@ void Trace_Pads_Only( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* Module,
{
if( (pt_pad->m_Masque_Layer & MasqueLayer) == 0 )
continue;
pt_pad->Draw( panel, DC, wxPoint( ox, oy ), draw_mode );
pt_pad->Draw( panel, DC, draw_mode, wxPoint( ox, oy ) );
}
frame->m_DisplayPadFill = tmp;

95
pcbnew/tracepcb.cpp
View File

@ -32,7 +32,7 @@ void WinEDA_ModuleEditFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
{
MODULE* Module;
PCB_SCREEN* screen = (PCB_SCREEN*)GetScreen();
PCB_SCREEN* screen = (PCB_SCREEN*)GetScreen();
if( !m_Pcb || !screen )
return;
@ -46,11 +46,11 @@ void WinEDA_ModuleEditFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
DrawPanel->DrawBackGround( DC );
TraceWorkSheet( DC, screen, 0 );
/* Redraw the footprint */
/* Redraw the footprint */
Module = (MODULE*) m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
Module->Draw( DrawPanel, DC, GR_OR );
}
Affiche_Status_Box();
@ -72,7 +72,7 @@ void WinEDA_PcbFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
/* Draw the BOARD, and others elements : axis, grid ..
*/
{
PCB_SCREEN* Screen = (PCB_SCREEN*)GetScreen();
PCB_SCREEN* Screen = (PCB_SCREEN*)GetScreen();
if( !m_Pcb || !Screen )
return;
@ -87,105 +87,100 @@ void WinEDA_PcbFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
Trace_Pcb( DC, GR_OR );
TraceWorkSheet( DC, GetScreen(), 0 );
Affiche_Status_Box();
if( DrawPanel->ManageCurseur )
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
/* Redraw the cursor */
DrawPanel->Trace_Curseur( DC );
if( DrawPanel->ManageCurseur )
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
// Redraw the cursor
DrawPanel->Trace_Curseur( DC );
}
#define DRAW_CUR_LAYER_LAST 1
/****************************************************/
void WinEDA_PcbFrame::Trace_Pcb( wxDC* DC, int mode )
/****************************************************/
/* Redraw the BOARD items but not cursors, axis or grid */
{
MODULE* Module;
EDA_BaseStruct* PtStruct;
if( !m_Pcb )
return;
Module = (MODULE*) m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
for( MODULE* module = m_Pcb->m_Modules; module; module = module->Next() )
{
bool display = true;
int MaskLay = ALL_CU_LAYERS;
int layerMask = ALL_CU_LAYERS;
if( Module->m_Flags & IS_MOVED )
if( module->m_Flags & IS_MOVED )
continue;
if( !DisplayOpt.Show_Modules_Cmp )
{
if( Module->GetLayer() == CMP_N )
if( module->GetLayer() == CMP_N )
display = FALSE;
MaskLay &= ~CMP_LAYER;
layerMask &= ~CMP_LAYER;
}
if( !DisplayOpt.Show_Modules_Cu )
{
if( Module->GetLayer() == COPPER_LAYER_N )
if( module->GetLayer() == COPPER_LAYER_N )
display = FALSE;
MaskLay &= ~CUIVRE_LAYER;
layerMask &= ~CUIVRE_LAYER;
}
if( display )
Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), mode );
module->Draw( DrawPanel, DC, mode );
else
Trace_Pads_Only( DrawPanel, DC, Module, 0, 0, MaskLay, mode );
Trace_Pads_Only( DrawPanel, DC, module, 0, 0, layerMask, mode );
}
/* Draw the graphic items */
PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
// Draw the graphic items
for( BOARD_ITEM* item = m_Pcb->m_Drawings; item; item = item->Next() )
{
if( PtStruct->m_Flags & IS_MOVED )
if( item->m_Flags & IS_MOVED )
continue;
switch( PtStruct->Type() )
switch( item->Type() )
{
case TYPECOTATION:
( (COTATION*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), mode );
break;
case TYPETEXTE:
( (TEXTE_PCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), mode );
break;
case TYPEMIRE:
( (MIREPCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), mode );
item->Draw( DrawPanel, DC, mode );
break;
case TYPEDRAWSEGMENT:
Trace_DrawSegmentPcb( DrawPanel, DC, (DRAWSEGMENT*) PtStruct, mode );
break;
Trace_DrawSegmentPcb( DrawPanel, DC, (DRAWSEGMENT*) item, mode );
break;
default:
default:
break;
}
}
Trace_Pistes( DrawPanel, m_Pcb, DC, mode );
if( g_HightLigt_Status )
DrawHightLight( DC, g_HightLigth_NetCode );
for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
ZONE_CONTAINER* edge_zone = m_Pcb->GetArea(ii);
// Areas must be drawn here only if not moved or dragged,
// because these areas are drawn by ManageCursor() in a specific manner
if ( (edge_zone->m_Flags & (IN_EDIT | IS_DRAGGED | IS_MOVED)) == 0 )
edge_zone->Draw( DrawPanel, DC, mode );
}
// draw the BOARD's markers.
for( unsigned i=0; i<m_Pcb->m_markers.size(); ++i )
{
m_Pcb->m_markers[i]->Draw( DrawPanel, DC, mode );
}
Trace_Pistes( DrawPanel, m_Pcb, DC, mode );
if( g_HightLigt_Status )
DrawHightLight( DC, g_HightLigth_NetCode );
for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
ZONE_CONTAINER* edge_zone = m_Pcb->GetArea(ii);
// Areas must be drawn here only if not moved or dragged,
// because these areas are drawn by ManageCursor() in a specific manner
if ( (edge_zone->m_Flags & (IN_EDIT | IS_DRAGGED | IS_MOVED)) == 0 )
edge_zone->Draw( DrawPanel, DC, wxPoint(0,0), mode);
}
DrawGeneralRatsnest( DC );
m_CurrentScreen->ClrRefreshReq();

2
pcbnew/undelete.cpp
View File

@ -65,7 +65,7 @@ void WinEDA_PcbFrame::UnDeleteItem( wxDC* DC )
g_UnDeleteStack[g_UnDeleteStackPtr] = NULL;
((MODULE*) item)->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
((MODULE*) item)->Draw( DrawPanel, DC, GR_OR );
item->SetState( DELETED, OFF ); /* Creal DELETED flag */
item->m_Flags = 0;

8
pcbnew/xchgmod.cpp
View File

@ -492,12 +492,12 @@ MODULE* WinEDA_ExchangeModuleFrame::Change_1_Module( MODULE* PtModule,
m_WinMsg->WriteText( wxT( "Ok\n" ) );
/* Effacement a l'ecran de l'ancien module */
PtModule->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_XOR );
PtModule->Draw( m_Parent->DrawPanel, m_DC, GR_XOR );
m_Parent->Exchange_Module( this, PtModule, NewModule );
/* Affichage du nouveau module */
NewModule->Draw( m_Parent->DrawPanel, m_DC, wxPoint( 0, 0 ), GR_OR );
NewModule->Draw( m_Parent->DrawPanel, m_DC, GR_OR );
Maj_ListeCmp( NewModule->m_Reference->m_Text, oldnamecmp, namecmp, ShowError );
@ -550,7 +550,7 @@ MODULE* WinEDA_BasePcbFrame::Exchange_Module( wxWindow* winaff,
/* Mise a jour des autres parametres */
NewModule->m_TimeStamp = OldModule->m_TimeStamp;
NewModule->m_Path = OldModule->m_Path;
NewModule->m_Path = OldModule->m_Path;
/* mise a jour des netnames ( lorsque c'est possible) */
pt_pad = NewModule->m_Pads;
@ -646,7 +646,7 @@ bool WinEDA_PcbFrame::RecreateCmpFileFromBoard()
{
fprintf( FichCmp, "\nBeginCmp\n" );
fprintf( FichCmp, "TimeStamp = %8.8lX\n", Module->m_TimeStamp );
fprintf( FichCmp, "Path = %s\n", CONV_TO_UTF8(Module->m_Path) );
fprintf( FichCmp, "Path = %s\n", CONV_TO_UTF8(Module->m_Path) );
fprintf( FichCmp, "Reference = %s;\n",
!Module->m_Reference->m_Text.IsEmpty() ?
CONV_TO_UTF8( Module->m_Reference->m_Text ) : "[NoRef]" );

24
pcbnew/zones_by_polygon.cpp
View File

@ -260,7 +260,7 @@ void WinEDA_PcbFrame::Start_Move_Zone_Drag_Outline_Edge( wxDC* DC,
*/
{
zone_container->m_Flags = IS_DRAGGED;
zone_container->m_CornerSelection = corner_id;
zone_container->m_CornerSelection = corner_id;
DrawPanel->ManageCurseur = Show_Zone_Corner_Or_Outline_While_Move_Mouse;
DrawPanel->ForceCloseManageCurseur = Abort_Zone_Move_Corner_Or_Outlines;
s_CursorLastPosition = s_CornerInitialPosition = GetScreen()->m_Curseur;
@ -312,7 +312,7 @@ void WinEDA_PcbFrame::End_Move_Zone_Corner_Or_Outlines( wxDC* DC, ZONE_CONTAINER
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
if( DC )
zone_container->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
zone_container->Draw( DrawPanel, DC, GR_OR );
GetScreen()->SetModify();
s_AddCutoutToCurrentZone = false;
s_CurrentZone = NULL;
@ -353,7 +353,7 @@ void WinEDA_PcbFrame::Remove_Zone_Corner( wxDC* DC, ZONE_CONTAINER* zone_contain
if( zone_container->m_Poly->GetNumCorners() <= 3 )
{
zone_container->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
zone_container->Draw( DrawPanel, DC, GR_XOR );
Delete_Zone_Fill( DC, NULL, zone_container->m_TimeStamp );
m_Pcb->Delete( zone_container );
return;
@ -392,7 +392,7 @@ void Abort_Zone_Move_Corner_Or_Outlines( WinEDA_DrawPanel* Panel, wxDC* DC )
WinEDA_PcbFrame* pcbframe = (WinEDA_PcbFrame*) Panel->m_Parent;
ZONE_CONTAINER* zone_container = (ZONE_CONTAINER*) pcbframe->GetCurItem();
zone_container->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
zone_container->Draw( Panel, DC, GR_XOR );
if( zone_container->m_Flags == IS_MOVED )
{
@ -418,7 +418,7 @@ void Abort_Zone_Move_Corner_Or_Outlines( WinEDA_DrawPanel* Panel, wxDC* DC )
zone_container->m_Poly->MoveCorner( zone_container->m_CornerSelection, pos.x, pos.y );
}
}
zone_container->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
zone_container->Draw( Panel, DC, GR_XOR );
Panel->ManageCurseur = NULL;
Panel->ForceCloseManageCurseur = NULL;
@ -441,7 +441,7 @@ void Show_Zone_Corner_Or_Outline_While_Move_Mouse( WinEDA_DrawPanel* Panel, wxDC
if( erase ) /* Undraw edge in old position*/
{
zone->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
zone->Draw( Panel, DC, GR_XOR );
}
wxPoint pos = pcbframe->GetScreen()->m_Curseur;
@ -462,7 +462,7 @@ void Show_Zone_Corner_Or_Outline_While_Move_Mouse( WinEDA_DrawPanel* Panel, wxDC
else
zone->m_Poly->MoveCorner( zone->m_CornerSelection, pos.x, pos.y );
zone->Draw( Panel, DC, wxPoint( 0, 0 ), GR_XOR );
zone->Draw( Panel, DC, GR_XOR );
}
@ -511,11 +511,11 @@ int WinEDA_PcbFrame::Begin_Zone( wxDC* DC )
if( diag == ZONE_ABORT )
return 0;
((PCB_SCREEN*)GetScreen())->m_Active_Layer = s_Zone_Layer; // Set by the dialog frame
((PCB_SCREEN*)GetScreen())->m_Active_Layer = s_Zone_Layer; // Set by the dialog frame
}
else /* Start a new contour: init zone params (net and layer) from an existing zone */
{
((PCB_SCREEN*)GetScreen())->m_Active_Layer = s_Zone_Layer = s_CurrentZone->GetLayer();
((PCB_SCREEN*)GetScreen())->m_Active_Layer = s_Zone_Layer = s_CurrentZone->GetLayer();
s_Zone_Hatching = s_CurrentZone->m_Poly->GetHatchStyle();
}
@ -737,7 +737,7 @@ void WinEDA_PcbFrame::Edit_Zone_Params( wxDC* DC, ZONE_CONTAINER* zone_container
for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
ZONE_CONTAINER* edge_zone = m_Pcb->GetArea( ii );
edge_zone->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
edge_zone->Draw( DrawPanel, DC, GR_XOR );
}
zone_container->SetLayer( s_Zone_Layer );
@ -777,7 +777,7 @@ void WinEDA_PcbFrame::Delete_Zone_Contour( wxDC* DC, ZONE_CONTAINER* zone_contai
int ncont = zone_container->m_Poly->GetContour( zone_container->m_CornerSelection );
if( DC )
zone_container->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
zone_container->Draw( DrawPanel, DC, GR_XOR );
Delete_Zone_Fill( DC, NULL, zone_container->m_TimeStamp ); // Remove fill segments
@ -788,7 +788,7 @@ void WinEDA_PcbFrame::Delete_Zone_Contour( wxDC* DC, ZONE_CONTAINER* zone_contai
{
zone_container->m_Poly->RemoveContour( ncont );
if( DC )
zone_container->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
zone_container->Draw( DrawPanel, DC, GR_OR );
}
GetScreen()->SetModify();
}

67
share/drawpanel.cpp
View File

@ -550,7 +550,6 @@ void WinEDA_DrawPanel::EraseScreen( wxDC* DC )
/***************************************************/
void WinEDA_DrawPanel::OnPaint( wxPaintEvent& event )
/***************************************************/
#if 1 // new code without multiple calls to ReDraw()
{
wxPaintDC paintDC( this );
EDA_Rect tmp;
@ -622,72 +621,6 @@ void WinEDA_DrawPanel::OnPaint( wxPaintEvent& event )
}
#else // old code
{
wxPaintDC paintDC( this );
EDA_Rect tmp;
wxRect PaintClipBox;
wxPoint org;
static int counter;
++counter;
PrepareGraphicContext( &paintDC );
tmp = m_ClipBox;
org = m_ClipBox.GetOrigin();
wxRegionIterator upd( GetUpdateRegion() ); // get the update rect list
while( upd )
{
PaintClipBox = upd.GetRect();
upd++;
PaintClipBox.x += org.x;
PaintClipBox.y += org.y;
#if 0
printf( "PaintClipBox[%d]=(%d, %d, %d, %d)\n",
counter,
PaintClipBox.x,
PaintClipBox.y,
PaintClipBox.width,
PaintClipBox.height );
#endif
#ifdef WX_ZOOM
m_ClipBox.m_Pos.x = PaintClipBox.x * GetZoom();
m_ClipBox.m_Pos.y = PaintClipBox.y * GetZoom();
m_ClipBox.m_Size.x = PaintClipBox.m_Size.x * GetZoom();
m_ClipBox.m_Size.y = PaintClipBox.m_Size.y * GetZoom();
PaintClipBox = m_ClipBox;
#else
m_ClipBox.SetX( PaintClipBox.GetX() );
m_ClipBox.SetY( PaintClipBox.GetY() );
m_ClipBox.SetWidth( PaintClipBox.GetWidth() );
m_ClipBox.SetHeight( PaintClipBox.GetHeight() );
#endif
wxDCClipper* dcclip = new wxDCClipper( paintDC, PaintClipBox );
ReDraw( &paintDC, TRUE );
delete dcclip;
}
m_ClipBox = tmp;
event.Skip();
}
#endif
/****************************************************/
void WinEDA_DrawPanel::ReDraw( wxDC* DC, bool erasebg )
/****************************************************/

9
todo.txt
View File

@ -74,3 +74,12 @@ edges editable.
2) final solution: get rid of requirement for tracks buried within a zone.
Reivew the GEDA source code and other sources to gather ideas before doing 2).
2008-Mar-31 Assigned To:
asked by: Dick Hollenbeck
================================================================================
EESCHEMA:
Derive all eeschema classes from SCH_ITEM, not EDA_BaseStruct.
Move the virtual EDA_BaseStruct::Draw() function into SCH_ITEM, so that
there is no EDA_BaseStruct::Draw() function.
Make the KICAD_T spelling mimic the class names.