Skip to content

K
kicad-source-mirror
Commit f353c77c authored by dickelbeck's avatar dickelbeck
Browse files
Options

more zone preps

parent 64e9e168
Hide whitespace changes
Inline Side-by-side
Showing with 1131 additions and 893 deletions
change_log.txt
View file @ f353c77c
...@@ -19,6 +19,8 @@ email address. ...@@ -19,6 +19,8 @@ email address.
design and was crashing. Also, export_to_pcbnew.cpp now uses the simple design and was crashing. Also, export_to_pcbnew.cpp now uses the simple
BOARD::Save() function. It was another place to maintain the PCB file format, BOARD::Save() function. It was another place to maintain the PCB file format,
rather than simply putting that knowledge into one place like BOARD::Save(). rather than simply putting that knowledge into one place like BOARD::Save().
+ all
beautified gr_basic.cpp and made CLIP_LINE macro a static inline function.
2007-Oct-30 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr> 2007-Oct-30 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
......
common/base_struct.cpp
View file @ f353c77c
...@@ -57,23 +57,6 @@ void EDA_BaseStruct::InitVars() ...@@ -57,23 +57,6 @@ void EDA_BaseStruct::InitVars()
} }
/* Gestion de l'etat (status) de la structure (active, deleted..) */
int EDA_BaseStruct::GetState( int type ) const
{
return m_Status & type;
}
void EDA_BaseStruct::SetState( int type, int state )
{
if( state )
m_Status |= type;/* state = ON ou OFF */
else
m_Status &= ~type;
}
/***********************************************************/ /***********************************************************/
void EDA_BaseStruct::DeleteStructList() void EDA_BaseStruct::DeleteStructList()
/***********************************************************/ /***********************************************************/
......
common/gr_basic.cpp
View file @ f353c77c
/********************************/ /********************************/
/* Low level graphics routines */ /* Low level graphics routines */
/********************************/ /********************************/
#include "fctsys.h" #include "fctsys.h"
...@@ -15,41 +15,42 @@ ...@@ -15,41 +15,42 @@
/* global variables */ /* global variables */
extern BASE_SCREEN * ActiveScreen; extern BASE_SCREEN* ActiveScreen;
/* Variables locales */ /* Variables locales */
static int GRLastMoveToX , GRLastMoveToY; static int GRLastMoveToX, GRLastMoveToY;
static int Text_Color = LIGHTGRAY; static int Text_Color = LIGHTGRAY;
static int PenMinWidth = 1; /* largeur minimum de la plume (DOIT etre > 0) static int PenMinWidth = 1;/* largeur minimum de la plume (DOIT etre > 0)
(utile pour trace sur imprimante) */ * (utile pour trace sur imprimante) */
static int ForceBlackPen; /* si != 0 : traces en noir (utilise pour trace static int ForceBlackPen;/* si != 0 : traces en noir (utilise pour trace
sur imprimante */ * sur imprimante */
static int xcliplo = 0, static int xcliplo = 0,
ycliplo = 0, ycliplo = 0,
xcliphi = 2000, xcliphi = 2000,
ycliphi = 2000; /* coord de la surface de trace */ ycliphi = 2000;/* coord de la surface de trace */
static int lastcolor = -1; static int lastcolor = -1;
static int lastwidth = -1; static int lastwidth = -1;
static int s_Last_Pen_Style = -1; static int s_Last_Pen_Style = -1;
static wxDC * lastDC = NULL; static wxDC* lastDC = NULL;
/* /*
Macro de clipping du trace d'une ligne: * Macro de clipping du trace d'une ligne:
la ligne (x1,y1 x2,y2) est clippee pour rester dans le cadre * la ligne (x1,y1 x2,y2) est clippee pour rester dans le cadre
(xcliplo,ycliplo xcliphi,ycliphi) (variables globales,locales a ce fichier) * (xcliplo,ycliplo xcliphi,ycliphi) (variables globales,locales a ce fichier)
Ceci est necessaire sous WIN95 car les coord de trace * Ceci est necessaire sous WIN95 car les coord de trace
(bien que en int 32bits) sont tronquees en 16 bits (stupide BG) * (bien que en int 32bits) sont tronquees en 16 bits (stupide BG)
*/ */
#ifndef us #ifndef us
#define us unsigned int #define us unsigned int
#endif #endif
static inline int USCALE(us arg, us num, us den) static inline int USCALE( us arg, us num, us den )
{ {
int ii; int ii;
ii = (int)( ((float) arg * num) / den); ii = (int) ( ( (float) arg * num ) / den );
return( ii ); return ii;
} }
...@@ -59,213 +60,254 @@ static inline int USCALE(us arg, us num, us den) ...@@ -59,213 +60,254 @@ static inline int USCALE(us arg, us num, us den)
#define GET_ZOOM ActiveScreen->GetZoom() #define GET_ZOOM ActiveScreen->GetZoom()
#endif #endif
static int inline ZoomValue(int value_to_zoom) static int inline ZoomValue( int value_to_zoom ) {
{ int zoom = GET_ZOOM;
int zoom = GET_ZOOM;
if ( value_to_zoom >= 0 ) if( value_to_zoom >= 0 )
return( (value_to_zoom + (zoom >> 1 ) ) /zoom ); return ( value_to_zoom + (zoom >> 1 ) ) / zoom;
else else
return( (value_to_zoom - (zoom >> 1 ) ) /zoom ); return ( value_to_zoom - (zoom >> 1 ) ) / zoom;
} }
/****************************************/ /****************************************/
/* External reference for the mappings. */ /* External reference for the mappings. */
/****************************************/ /****************************************/
int GRMapX(int x) int GRMapX( int x )
{ {
int coord = x - ActiveScreen->m_DrawOrg.x; int coord = x - ActiveScreen->m_DrawOrg.x;
#ifndef WX_ZOOM #ifndef WX_ZOOM
coord = ZoomValue(coord); coord = ZoomValue( coord );
coord -= ActiveScreen->m_StartVisu.x; coord -= ActiveScreen->m_StartVisu.x;
#endif #endif
return coord; return coord;
} }
int GRMapY(int y)
int GRMapY( int y )
{ {
int coord = y - ActiveScreen->m_DrawOrg.y; int coord = y - ActiveScreen->m_DrawOrg.y;
#ifndef WX_ZOOM #ifndef WX_ZOOM
coord = ZoomValue(coord); coord = ZoomValue( coord );
coord -= ActiveScreen->m_StartVisu.y; coord -= ActiveScreen->m_StartVisu.y;
#endif #endif
return coord; return coord;
} }
#define WHEN_OUTSIDE return #define WHEN_OUTSIDE return
#define WHEN_INSIDE #define WHEN_INSIDE
#define CLIP_LINE(x1,y1,x2,y2) \
{\ static inline void clip_line( int& x1, int& y1, int& x2, int& y2 )
int temp;\ {
do {\ int temp;
if(x1 > x2) { EXCHG(x1,x2); EXCHG(y1,y2); }\
if((x2 < xcliplo) || (x1 > xcliphi)) { WHEN_OUTSIDE; }\ if( x1 > x2 )
if(y1 < y2)\ {
{\ EXCHG( x1, x2 );
if((y2 < ycliplo) || (y1 > ycliphi)) { WHEN_OUTSIDE;}\ EXCHG( y1, y2 );
if(y1 < ycliplo)\ }
{\ if( (x2 < xcliplo) || (x1 > xcliphi) )
temp = USCALE((x2 - x1),(ycliplo - y1),(y2 - y1));\ {
if((x1 += temp) > xcliphi) { WHEN_OUTSIDE; }\ WHEN_OUTSIDE;
y1 = ycliplo;\ }
WHEN_INSIDE;\ if( y1 < y2 )
}\ {
if(y2 > ycliphi)\ if( (y2 < ycliplo) || (y1 > ycliphi) )
{\ {
temp = USCALE((x2 - x1),(y2 - ycliphi),(y2 - y1));\ WHEN_OUTSIDE;
if((x2 -= temp) < xcliplo) { WHEN_OUTSIDE; }\ }
y2 = ycliphi;\ if( y1 < ycliplo )
WHEN_INSIDE;\ {
}\ temp = USCALE( (x2 - x1), (ycliplo - y1), (y2 - y1) );
if(x1 < xcliplo)\ if( (x1 += temp) > xcliphi )
{\ {
temp = USCALE((y2 - y1),(xcliplo - x1),(x2 - x1));\ WHEN_OUTSIDE;
y1 += temp; x1 = xcliplo;\ }
WHEN_INSIDE;\ y1 = ycliplo;
}\ WHEN_INSIDE;
if(x2 > xcliphi)\ }
{\ if( y2 > ycliphi )
temp = USCALE((y2 - y1),(x2 - xcliphi),(x2 - x1));\ {
y2 -= temp; x2 = xcliphi;\ temp = USCALE( (x2 - x1), (y2 - ycliphi), (y2 - y1) );
WHEN_INSIDE;\ if( (x2 -= temp) < xcliplo )
}\ {
}\ WHEN_OUTSIDE;
else\ }
{\ y2 = ycliphi;
if((y1 < ycliplo) || (y2 > ycliphi)) { WHEN_OUTSIDE; }\ WHEN_INSIDE;
if(y1 > ycliphi)\ }
{\ if( x1 < xcliplo )
temp = USCALE((x2 - x1),(y1 - ycliphi),(y1 - y2));\ {
if((x1 += temp) > xcliphi) { WHEN_OUTSIDE; }\ temp = USCALE( (y2 - y1), (xcliplo - x1), (x2 - x1) );
y1 = ycliphi;\ y1 += temp;
WHEN_INSIDE;\ x1 = xcliplo;
}\ WHEN_INSIDE;
if(y2 < ycliplo)\ }
{\ if( x2 > xcliphi )
temp = USCALE((x2 - x1),(ycliplo - y2),(y1 - y2));\ {
if((x2 -= temp) < xcliplo) { WHEN_OUTSIDE; }\ temp = USCALE( (y2 - y1), (x2 - xcliphi), (x2 - x1) );
y2 = ycliplo;\ y2 -= temp;
WHEN_INSIDE;\ x2 = xcliphi;
}\ WHEN_INSIDE;
if(x1 < xcliplo)\ }
{\ }
temp = USCALE((y1 - y2),(xcliplo - x1),(x2 - x1));\ else
y1 -= temp; x1 = xcliplo;\ {
WHEN_INSIDE;\ if( (y1 < ycliplo) || (y2 > ycliphi) )
}\ {
if(x2 > xcliphi)\ WHEN_OUTSIDE;
{\ }
temp = USCALE((y1 - y2),(x2 - xcliphi),(x2 - x1));\ if( y1 > ycliphi )
y2 += temp; x2 = xcliphi;\ {
WHEN_INSIDE;\ temp = USCALE( (x2 - x1), (y1 - ycliphi), (y1 - y2) );
}\ if( (x1 += temp) > xcliphi )
}\ {
} while(0);\ WHEN_OUTSIDE;
} }
y1 = ycliphi;
static void WinClipAndDrawLine(EDA_Rect * ClipBox, wxDC * DC, WHEN_INSIDE;
int x1, int y1, int x2, int y2, }
int Color, int width = 1 ) if( y2 < ycliplo )
{ {
GRLastMoveToX = x2; temp = USCALE( (x2 - x1), (ycliplo - y2), (y1 - y2) );
GRLastMoveToY = y2; if( (x2 -= temp) < xcliplo )
{
if ( ClipBox ) WHEN_OUTSIDE;
{ }
xcliplo = ClipBox->GetX(); y2 = ycliplo;
ycliplo = ClipBox->GetY(); WHEN_INSIDE;
xcliphi = ClipBox->GetRight(); }
ycliphi = ClipBox->GetBottom(); if( x1 < xcliplo )
{
xcliplo -= width; temp = USCALE( (y1 - y2), (xcliplo - x1), (x2 - x1) );
ycliplo -= width; y1 -= temp;
x1 = xcliplo;
xcliphi += width; WHEN_INSIDE;
ycliphi += width; }
if( x2 > xcliphi )
CLIP_LINE(x1, y1, x2, y2); {
} temp = USCALE( (y1 - y2), (x2 - xcliphi), (x2 - x1) );
y2 += temp;
GRSetColorPen(DC, Color, width); x2 = xcliphi;
DC->DrawLine(x1, y1, x2, y2); WHEN_INSIDE;
}
}
}
static void WinClipAndDrawLine( EDA_Rect* ClipBox, wxDC* DC,
int x1, int y1, int x2, int y2,
int Color, int width = 1 )
{
GRLastMoveToX = x2;
GRLastMoveToY = y2;
if( ClipBox )
{
xcliplo = ClipBox->GetX();
ycliplo = ClipBox->GetY();
xcliphi = ClipBox->GetRight();
ycliphi = ClipBox->GetBottom();
xcliplo -= width;
ycliplo -= width;
xcliphi += width;
ycliphi += width;
clip_line( x1, y1, x2, y2 );
}
GRSetColorPen( DC, Color, width );
DC->DrawLine( x1, y1, x2, y2 );
} }
/* Routine de forcage de la reinit de la plume courante. /* Routine de forcage de la reinit de la plume courante.
Doit etre appelee par securite apres changement de contexte graphique * Doit etre appelee par securite apres changement de contexte graphique
avant tout trace * avant tout trace
*/ */
void GRResetPenAndBrush(wxDC * DC) void GRResetPenAndBrush( wxDC* DC )
{ {
lastcolor = -1; lastcolor = -1;
GRSetBrush(DC, BLACK); // Force no fill GRSetBrush( DC, BLACK ); // Force no fill
lastDC = NULL; lastDC = NULL;
} }
/* routine d'ajustage de la largeur mini de plume */ /* routine d'ajustage de la largeur mini de plume */
void SetPenMinWidth(int minwidth) void SetPenMinWidth( int minwidth )
{ {
PenMinWidth = minwidth; PenMinWidth = minwidth;
if( PenMinWidth < 1 ) PenMinWidth = 1; if( PenMinWidth < 1 )
PenMinWidth = 1;
} }
/* Routine de changement de couleurs et epaisseur de la plume courante */ /* Routine de changement de couleurs et epaisseur de la plume courante */
void GRSetColorPen(wxDC * DC, int Color , int width, int style) void GRSetColorPen( wxDC* DC, int Color, int width, int style )
{ {
Color &= MASKCOLOR; // Pour 32 couleurs Max Color &= MASKCOLOR; // Pour 32 couleurs Max
if( width < PenMinWidth )
width = PenMinWidth;
if(width < PenMinWidth) width = PenMinWidth; if( ForceBlackPen && Color != WHITE )
Color = BLACK;
if( ForceBlackPen && Color != WHITE ) Color = BLACK; if( (lastcolor != Color) || (lastwidth != width) || (s_Last_Pen_Style != style)
|| (lastDC != DC ) )
{
wxPen DrawPen;
DrawPen.SetColour(
ColorRefs[Color].m_Red,
ColorRefs[Color].m_Green,
ColorRefs[Color].m_Blue
);
if( (lastcolor != Color) || (lastwidth != width) || (s_Last_Pen_Style != style) || (lastDC != DC ) ) DrawPen.SetWidth( width );
{ DrawPen.SetStyle( style );
wxPen DrawPen;
DrawPen.SetColour(
ColorRefs[Color].m_Red,
ColorRefs[Color].m_Green,
ColorRefs[Color].m_Blue
);
DrawPen.SetWidth(width);
DrawPen.SetStyle(style);
// if ( &DC->GetPen() != DrawPen ) // if ( &DC->GetPen() != DrawPen )
DC->SetPen(DrawPen); DC->SetPen( DrawPen );
lastcolor = Color; lastwidth = width; lastDC = DC; lastcolor = Color; lastwidth = width; lastDC = DC;
s_Last_Pen_Style = style; s_Last_Pen_Style = style;
} }
} }
/***********************************************/ /***********************************************/
void GRSetBrush(wxDC * DC, int Color , int fill) void GRSetBrush( wxDC* DC, int Color, int fill )
/***********************************************/ /***********************************************/
{ {
Color &= MASKCOLOR; // Pour 32 couleurs Max Color &= MASKCOLOR; // Pour 32 couleurs Max
if( ForceBlackPen && Color != WHITE ) Color = BLACK; if( ForceBlackPen && Color != WHITE )
wxBrush DrawBrush; Color = BLACK;
DrawBrush.SetColour( wxBrush DrawBrush;
ColorRefs[Color].m_Red, DrawBrush.SetColour(
ColorRefs[Color].m_Green, ColorRefs[Color].m_Red,
ColorRefs[Color].m_Blue ColorRefs[Color].m_Green,
); ColorRefs[Color].m_Blue
);
if ( fill ) DrawBrush.SetStyle(wxSOLID); if( fill )
else DrawBrush.SetStyle(wxTRANSPARENT); DrawBrush.SetStyle( wxSOLID );
DC->SetBrush(DrawBrush); else
DrawBrush.SetStyle( wxTRANSPARENT );
DC->SetBrush( DrawBrush );
} }
/*************************************/ /*************************************/
void GRForceBlackPen(bool flagforce ) void GRForceBlackPen( bool flagforce )
/*************************************/ /*************************************/
{ {
ForceBlackPen = flagforce; ForceBlackPen = flagforce;
} }
...@@ -273,267 +315,332 @@ void GRForceBlackPen(bool flagforce ) ...@@ -273,267 +315,332 @@ void GRForceBlackPen(bool flagforce )
/* routines de controle et positionnement du curseur souris */ /* routines de controle et positionnement du curseur souris */
/************************************************************/ /************************************************************/
/* positionne la souris au point de coord pos */ /* positionne la souris au point de coord pos */
void GRMouseWarp(WinEDA_DrawPanel * panel, const wxPoint& pos) void GRMouseWarp( WinEDA_DrawPanel* panel, const wxPoint& pos )
{ {
if( panel == NULL ) return; if( panel == NULL )
panel->WarpPointer(pos.x, pos.y); return;
panel->WarpPointer( pos.x, pos.y );
} }
/**********************************************/ /**********************************************/
/* Routine pour selectionner le mode de trace */ /* Routine pour selectionner le mode de trace */
/**********************************************/ /**********************************************/
void GRSetDrawMode(wxDC * DC, int draw_mode) void GRSetDrawMode( wxDC* DC, int draw_mode )
{ {
if( draw_mode & GR_OR ) DC->SetLogicalFunction(wxOR); if( draw_mode & GR_OR )
else if( draw_mode & GR_XOR ) DC->SetLogicalFunction(wxXOR); DC->SetLogicalFunction( wxOR );
else if( draw_mode & GR_NXOR ) DC->SetLogicalFunction(wxEQUIV); else if( draw_mode & GR_XOR )
else DC->SetLogicalFunction(wxCOPY); DC->SetLogicalFunction( wxXOR );
else if( draw_mode & GR_NXOR )
DC->SetLogicalFunction( wxEQUIV );
else
DC->SetLogicalFunction( wxCOPY );
} }
/*********************************************************************/ /*********************************************************************/
void GRPutPixel(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int Color) void GRPutPixel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int Color )
/*********************************************************************/ /*********************************************************************/
{ {
GRSPutPixel(ClipBox, DC, GRMapX(x), GRMapY(y), Color); GRSPutPixel( ClipBox, DC, GRMapX( x ), GRMapY( y ), Color );
} }
/********************************************************************/ /********************************************************************/
void GRSPutPixel(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int Color) void GRSPutPixel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int Color )
/********************************************************************/ /********************************************************************/
{ {
if( ClipBox ) /* suppression des pixels hors ecran */
if ( ClipBox ) /* suppression des pixels hors ecran */ {
{ if( x < ClipBox->GetX() )
if ( x < ClipBox->GetX() ) return; return;
if ( y < ClipBox->GetY() ) return; if( y < ClipBox->GetY() )
if ( x > (ClipBox->GetRight()) ) return; return;
if ( y > (ClipBox->GetBottom()) ) return; if( x > ( ClipBox->GetRight() ) )
} return;
GRSetColorPen(DC, Color ); if( y > ( ClipBox->GetBottom() ) )
DC->DrawPoint( x, y); return;
}
GRSetColorPen( DC, Color );
DC->DrawPoint( x, y );
} }
/*******************************************/
/* int GRGetPixel(wxDC * DC, int x, int y) */
/*******************************************/
int GRGetPixel(wxDC * DC, int x, int y) /*******************************************/
/* int GRGetPixel(wxDC * DC, int x, int y) */
/*******************************************/
int GRGetPixel( wxDC* DC, int x, int y )
{ {
wxColour colour; wxColour colour;
unsigned char r, g, b; unsigned char r, g, b;
int ii; int ii;
DC->GetPixel( (long)x, (long)y, &colour); DC->GetPixel( (long) x, (long) y, &colour );
r = colour.Red(); r = colour.Red();
b = colour.Blue(); b = colour.Blue();
g = colour.Green(); g = colour.Green();
for ( ii = 0; ii < NBCOLOR; ii++ ) for( ii = 0; ii < NBCOLOR; ii++ )
{ {
if( ( r == ColorRefs[ii].m_Red ) && if( ( r == ColorRefs[ii].m_Red )
( g == ColorRefs[ii].m_Green ) && && ( g == ColorRefs[ii].m_Green )
( b == ColorRefs[ii].m_Blue ) ) && ( b == ColorRefs[ii].m_Blue ) )
break; break;
} }
return ii; return ii;
} }
/**************************************************************************** /****************************************************************************
* Routine to draw a line, in Object spaces. * * Routine to draw a line, in Object spaces. *
****************************************************************************/ ****************************************************************************/
void GRLine(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color) void GRLine( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{ {
GRSLine(ClipBox, DC, GRMapX(x1), GRMapY(y1), GRMapX(x2), GRMapY(y2), ZoomValue(width), Color); GRSLine( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ), ZoomValue(
width ), Color );
} }
/***************************************************/ /***************************************************/
/* Routine to draw a Dashed line, in Screen space. */ /* Routine to draw a Dashed line, in Screen space. */
/***************************************************/ /***************************************************/
void GRSDashedLine(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color) void GRSDashedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{ {
GRLastMoveToX = x2; GRLastMoveToX = x2;
GRLastMoveToY = y2; GRLastMoveToY = y2;
lastcolor = -1; lastcolor = -1;
GRSetColorPen(DC, Color, width, wxSHORT_DASH); GRSetColorPen( DC, Color, width, wxSHORT_DASH );
GRSLine(ClipBox, DC, x1, y1, x2, y2, width, Color); GRSLine( ClipBox, DC, x1, y1, x2, y2, width, Color );
lastcolor = -1; lastcolor = -1;
GRSetColorPen(DC, Color, width); GRSetColorPen( DC, Color, width );
} }
void GRSDashedLineTo(EDA_Rect * ClipBox,wxDC * DC, int x2, int y2, int width, int Color)
void GRSDashedLineTo( EDA_Rect* ClipBox, wxDC* DC, int x2, int y2, int width, int Color )
{ {
lastcolor = -1; lastcolor = -1;
GRSetColorPen(DC, Color, width, wxSHORT_DASH); GRSetColorPen( DC, Color, width, wxSHORT_DASH );
GRSLine(ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x2, y2, width, Color); GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x2, y2, width, Color );
lastcolor = -1; lastcolor = -1;
GRSetColorPen(DC, Color, width); GRSetColorPen( DC, Color, width );
GRLastMoveToX = x2; GRLastMoveToX = x2;
GRLastMoveToY = y2; GRLastMoveToY = y2;
} }
/**************************************************************************** /****************************************************************************
* Routine to draw a Dashed line, in Object spaces. * * Routine to draw a Dashed line, in Object spaces. *
****************************************************************************/ ****************************************************************************/
void GRDashedLineTo(EDA_Rect * ClipBox,wxDC * DC,int x2, int y2, int width, int Color) void GRDashedLineTo( EDA_Rect* ClipBox, wxDC* DC, int x2, int y2, int width, int Color )
{ {
GRSDashedLineTo(ClipBox, DC, GRMapX(x2), GRMapY(y2), ZoomValue(width), Color); GRSDashedLineTo( ClipBox, DC, GRMapX( x2 ), GRMapY( y2 ), ZoomValue( width ), Color );
} }
void GRDashedLine(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color)
void GRDashedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{ {
GRSDashedLine(ClipBox, DC, GRMapX(x1), GRMapY(y1), GRMapX(x2), GRMapY(y2), ZoomValue(width), Color); GRSDashedLine( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue( width ), Color );
} }
/**************************************************************************** /****************************************************************************
* Routine to move to a new position, in Object space. * * Routine to move to a new position, in Object space. *
****************************************************************************/ ****************************************************************************/
void GRMoveTo(int x, int y) void GRMoveTo( int x, int y )
{ {
GRLastMoveToX = GRMapX(x); GRLastMoveToX = GRMapX( x );
GRLastMoveToY = GRMapY(y); GRLastMoveToY = GRMapY( y );
} }
/*******************************************************/ /*******************************************************/
/* Routine to draw to a new position, in Object space. */ /* Routine to draw to a new position, in Object space. */
/*******************************************************/ /*******************************************************/
void GRLineTo(EDA_Rect * ClipBox,wxDC * DC, int x, int y, int width, int Color) void GRLineTo( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{ {
int GRLineToX, GRLineToY; int GRLineToX, GRLineToY;
GRLineToX = GRMapX(x); GRLineToY = GRMapY(y); GRLineToX = GRMapX( x ); GRLineToY = GRMapY( y );
GRSLine(ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, ZoomValue(width), Color); GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, ZoomValue(
width ), Color );
} }
/*************************************************/ /*************************************************/
/* Routine to draw a Mixed line, in Object space */ /* Routine to draw a Mixed line, in Object space */
/*************************************************/ /*************************************************/
void GRMixedLine(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color) void GRMixedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{ {
GRSMixedLine(ClipBox, DC, GRMapX(x1), GRMapY(y1), GRMapX(x2), GRMapY(y2), ZoomValue(width), Color); GRSMixedLine( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue( width ), Color );
} }
/***********************************************************/ /***********************************************************/
/* Routine to draw a Mixed line, in Screen (Pixels) space */ /* Routine to draw a Mixed line, in Screen (Pixels) space */
/***********************************************************/ /***********************************************************/
void GRSMixedLine(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color) void GRSMixedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{ {
GRSetColorPen(DC, Color, width, wxDOT_DASH); GRSetColorPen( DC, Color, width, wxDOT_DASH );
GRSLine(ClipBox, DC, x1, y1, x2, y2, width, Color); GRSLine( ClipBox, DC, x1, y1, x2, y2, width, Color );
GRSetColorPen(DC, Color, width); GRSetColorPen( DC, Color, width );
} }
/**************************************************************************** /****************************************************************************
* Routine to move to a new position, in Screen (pixels) space. * * Routine to move to a new position, in Screen (pixels) space. *
****************************************************************************/ ****************************************************************************/
void GRSMoveTo(int x, int y) void GRSMoveTo( int x, int y )
{ {
GRLastMoveToX = x; GRLastMoveToX = x;
GRLastMoveToY = y; GRLastMoveToY = y;
} }
/**************************************************************************** /****************************************************************************
* Routine to draw to a new position, in Screen (pixels) space. * * Routine to draw to a new position, in Screen (pixels) space. *
****************************************************************************/ ****************************************************************************/
void GRSLineTo(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int width, int Color) void GRSLineTo( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{ {
GRSLine(ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x, y, width, Color); GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x, y, width, Color );
GRLastMoveToX = x; GRLastMoveToY = y; GRLastMoveToX = x; GRLastMoveToY = y;
} }
/**************************************************************************** /****************************************************************************
* Routine to draw to a new position, in Screen (pixels) space. * * Routine to draw to a new position, in Screen (pixels) space. *
****************************************************************************/ ****************************************************************************/
void GRSLine(EDA_Rect * ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, int Color) void GRSLine( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{ {
WinClipAndDrawLine(ClipBox, DC, x1, y1, x2, y2, Color, width ); WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, Color, width );
GRLastMoveToX = x2; GRLastMoveToY = y2; GRLastMoveToX = x2; GRLastMoveToY = y2;
} }
/****************************************************************************/ /****************************************************************************/
/* Routine to move to a new position relative to current one, as in Object */ /* Routine to move to a new position relative to current one, as in Object */
/* space. */ /* space. */
/****************************************************************************/ /****************************************************************************/
void GRMoveRel(int x, int y) void GRMoveRel( int x, int y )
{ {
GRLastMoveToX += ZoomValue(x); GRLastMoveToX += ZoomValue( x );
GRLastMoveToY += ZoomValue(y); GRLastMoveToY += ZoomValue( y );
} }
/**************************************************************************** /****************************************************************************
* Routine to line to a new position relative to current one, as in Object * * Routine to line to a new position relative to current one, as in Object *
* space. * * space. *
****************************************************************************/ ****************************************************************************/
void GRLineRel(EDA_Rect * ClipBox,wxDC * DC, int x, int y, int width, int Color) void GRLineRel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{ {
int GRLineToX = GRLastMoveToX, int GRLineToX = GRLastMoveToX,
GRLineToY = GRLastMoveToY; GRLineToY = GRLastMoveToY;
GRLineToX += ZoomValue(x); GRLineToX += ZoomValue( x );
GRLineToY += ZoomValue(y); GRLineToY += ZoomValue( y );
GRSLine(ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, ZoomValue(width), Color); GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, ZoomValue(
width ), Color );
} }
/**************************************************************************** /****************************************************************************
* Routine to move to a new position relative to current one, as in Screen * * Routine to move to a new position relative to current one, as in Screen *
* space (pixel coords.). * * space (pixel coords.). *
****************************************************************************/ ****************************************************************************/
void GRSMoveRel(int x, int y) void GRSMoveRel( int x, int y )
{ {
GRLastMoveToX += x; GRLastMoveToX += x;
GRLastMoveToY += y; GRLastMoveToY += y;
} }
/**************************************************************************** /****************************************************************************
* Routine to line to a new position relative to current one, as in Screen * * Routine to line to a new position relative to current one, as in Screen *
* space (pixel coords.). * * space (pixel coords.). *
****************************************************************************/ ****************************************************************************/
void GRSLineRel(EDA_Rect * ClipBox,wxDC * DC, int x, int y, int width, int Color) void GRSLineRel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{ {
long GRLineToX = GRLastMoveToX + x, long GRLineToX = GRLastMoveToX + x,
GRLineToY = GRLastMoveToY + y; GRLineToY = GRLastMoveToY + y;
GRSLine(ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, width, Color); GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, width, Color );
GRLastMoveToX = GRLineToX; GRLastMoveToX = GRLineToX;
GRLastMoveToY = GRLineToY; GRLastMoveToY = GRLineToY;
} }
/**************************************************/ /**************************************************/
/* Routine de trace d'un segment a bouts arrondis */ /* Routine de trace d'un segment a bouts arrondis */
/* Object space = real coords.). */ /* Object space = real coords.). */
/**************************************************/ /**************************************************/
void GRCSegm(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRCSegm( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color) int width, int Color )
{ {
GRSCSegm(ClipBox, DC, GRMapX(x1), GRMapY(y1), GRMapX(x2), GRMapY(y2), GRSCSegm( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue(width), Color); ZoomValue( width ), Color );
} }
/******************************************************************* /*******************************************************************
* Routine de trace d'un segment (plein) a bouts arrondis in Object * * Routine de trace d'un segment (plein) a bouts arrondis in Object *
* space (real coords.). * * space (real coords.). *
********************************************************************/ ********************************************************************/
void GRFillCSegm(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRFillCSegm( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color) int width, int Color )
{ {
GRSFillCSegm(ClipBox, DC, GRMapX(x1), GRMapY(y1), GRMapX(x2), GRMapY(y2), GRSFillCSegm( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue(width), Color); ZoomValue( width ), Color );
} }
/**********************************************************/ /**********************************************************/
/* Routine de trace d'un segment (plein) a bouts arrondis */ /* Routine de trace d'un segment (plein) a bouts arrondis */
/* ( Screen space = pixel coords.). */ /* ( Screen space = pixel coords.). */
/**********************************************************/ /**********************************************************/
void GRSFillCSegm(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color) void GRSFillCSegm( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{ {
WinClipAndDrawLine(ClipBox, DC, x1,y1,x2,y2, Color, width); WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, Color, width );
} }
...@@ -541,371 +648,392 @@ void GRSFillCSegm(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, ...@@ -541,371 +648,392 @@ void GRSFillCSegm(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
/* Routine de trace d'un segment a bouts arrondis (Mode SKETCH) */ /* Routine de trace d'un segment a bouts arrondis (Mode SKETCH) */
/* Screen space (pixel coords.). */ /* Screen space (pixel coords.). */
/****************************************************************/ /****************************************************************/
void GRSCSegm(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color) void GRSCSegm( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{ {
long rayon, dwx, dwy; long rayon, dwx, dwy;
long dx, dy, dwx2, dwy2; long dx, dy, dwx2, dwy2;
long sx1, sy1, ex1, ey1; /* coord du 1er bord */ long sx1, sy1, ex1, ey1; /* coord du 1er bord */
long sx2, sy2, ex2, ey2; /* coord du 1eme bord */ long sx2, sy2, ex2, ey2; /* coord du 1eme bord */
bool swap_ends = FALSE; bool swap_ends = FALSE;
GRLastMoveToX = x2; GRLastMoveToX = x2;
GRLastMoveToY = y2; GRLastMoveToY = y2;
if ( ClipBox ) if( ClipBox )
{ {
xcliplo = ClipBox->GetX(); xcliplo = ClipBox->GetX();
ycliplo = ClipBox->GetY(); ycliplo = ClipBox->GetY();
xcliphi = ClipBox->GetRight(); xcliphi = ClipBox->GetRight();
ycliphi = ClipBox->GetHeight(); ycliphi = ClipBox->GetHeight();
xcliplo -= width; xcliplo -= width;
ycliplo -= width; ycliplo -= width;
xcliphi += width; xcliphi += width;
ycliphi += width; ycliphi += width;
CLIP_LINE(x1, y1, x2, y2); clip_line( x1, y1, x2, y2 );
} }
if ( width <= 2 ) /* ligne simple ou epaisse de 2 pixels*/ if( width <= 2 ) /* ligne simple ou epaisse de 2 pixels*/
{ {
GRSetColorPen(DC, Color, width ); GRSetColorPen( DC, Color, width );
DC->DrawLine(x1, y1, x2, y2); DC->DrawLine( x1, y1, x2, y2 );
return; return;
} }
GRSetColorPen(DC, Color ); GRSetColorPen( DC, Color );
GRSetBrush(DC,Color,FALSE); GRSetBrush( DC, Color, FALSE );
rayon = (width+1) >> 1; rayon = (width + 1) >> 1;
dx = x2 - x1; dy = y2 - y1; dx = x2 - x1; dy = y2 - y1;
if ( dx == 0 ) /* segment vertical */ if( dx == 0 ) /* segment vertical */
{ {
dwx = rayon; dwx = rayon;
if ( dy >= 0 ) dwx = -dwx; if( dy >= 0 )
sx1 = x1 - dwx; sy1 = y1; dwx = -dwx;
ex1 = x2 - dwx; ey1 = y2; sx1 = x1 - dwx; sy1 = y1;
DC->DrawLine(sx1 , sy1, ex1, ey1); ex1 = x2 - dwx; ey1 = y2;
DC->DrawLine( sx1, sy1, ex1, ey1 );
sx2 = x1 + dwx; sy2 = y1;
ex2 = x2 + dwx; ey2 = y2; sx2 = x1 + dwx; sy2 = y1;
DC->DrawLine(sx2, sy2, ex2, ey2); ex2 = x2 + dwx; ey2 = y2;
} DC->DrawLine( sx2, sy2, ex2, ey2 );
}
else if ( dy == 0 ) /* segment horizontal */ else if( dy == 0 ) /* segment horizontal */
{ {
dwy = rayon; dwy = rayon;
if ( dx < 0 ) dwy = -dwy; if( dx < 0 )
sx1 = x1, sy1 = y1 - dwy; dwy = -dwy;
ex1 = x2; ey1 = y2 - dwy; sx1 = x1, sy1 = y1 - dwy;
DC->DrawLine(sx1, sy1, ex1 , ey1); ex1 = x2; ey1 = y2 - dwy;
DC->DrawLine( sx1, sy1, ex1, ey1 );
sx2 = x1; sy2 = y1 + dwy;
ex2 = x2; ey2 = y2 + dwy; sx2 = x1; sy2 = y1 + dwy;
DC->DrawLine(sx2, sy2, ex2 , ey2); ex2 = x2; ey2 = y2 + dwy;
} DC->DrawLine( sx2, sy2, ex2, ey2 );
}
else else
{ {
if ( ABS(dx) == ABS(dy) ) /* segment a 45 degre */ if( ABS( dx ) == ABS( dy ) ) /* segment a 45 degre */
{ {
dwx = dwy = ((width * 5)+ 4) / 7; // = width/2 * 0.707 dwx = dwy = ( (width * 5) + 4 ) / 7; // = width/2 * 0.707
if ( dy < 0 ) if( dy < 0 )
{ {
if ( dx <= 0 ) if( dx <= 0 )
{ {
dwx = -dwx; swap_ends = TRUE; dwx = -dwx; swap_ends = TRUE;
} }
} }
else else
{ {
if( dx > 0 ) if( dx > 0 )
{ {
dwy = -dwy; swap_ends = TRUE; dwy = -dwy; swap_ends = TRUE;
} }
} }
} }
else
else {
{ int delta_angle = ArcTangente( dy, dx );
int delta_angle = ArcTangente(dy, dx); dwx = 0; dwy = width;
dwx = 0; dwy = width; RotatePoint( (int*) &dwx, (int*) &dwy, -delta_angle );
RotatePoint( (int*)&dwx, (int*)&dwy, -delta_angle); }
} dwx2 = dwx >> 1; dwy2 = dwy >> 1;
dwx2 = dwx >> 1; dwy2 = dwy >> 1; sx1 = x1 - dwx2; sy1 = y1 - dwy2;
sx1 = x1 - dwx2; sy1 = y1 - dwy2; ex1 = x2 - dwx2; ey1 = y2 - dwy2;
ex1 = x2 - dwx2; ey1 = y2 - dwy2; DC->DrawLine( sx1, sy1, ex1, ey1 );
DC->DrawLine(sx1, sy1, ex1, ey1);
sx2 = x1 + dwx2; sy2 = y1 + dwy2;
sx2 = x1 + dwx2; sy2 = y1 + dwy2; ex2 = x2 + dwx2; ey2 = y2 + dwy2;
ex2 = x2 + dwx2; ey2 = y2 + dwy2; DC->DrawLine( sx2, sy2, ex2, ey2 );
DC->DrawLine(sx2, sy2, ex2, ey2); }
}
if( swap_ends )
if ( swap_ends ) {
{ DC->DrawArc( sx2, sy2, sx1, sy1, x1, y1 );
DC->DrawArc(sx2, sy2, sx1 , sy1, x1, y1); DC->DrawArc( ex1, ey1, ex2, ey2, x2, y2 );
DC->DrawArc(ex1, ey1, ex2, ey2, x2, y2); }
} else
else {
{ DC->DrawArc( sx1, sy1, sx2, sy2, x1, y1 );
DC->DrawArc(sx1, sy1, sx2 , sy2, x1, y1); DC->DrawArc( ex2, ey2, ex1, ey1, x2, y2 );
DC->DrawArc(ex2, ey2, ex1, ey1, x2, y2); }
} }
}
static bool IsGRSPolyDrawable( EDA_Rect* ClipBox, int n, int* Points )
{
static bool IsGRSPolyDrawable( EDA_Rect * ClipBox,int n, int *Points) int ii;
{ int Xmin, Xmax, Ymin, Ymax;
int ii;
int Xmin, Xmax, Ymin, Ymax; Xmin = Xmax = Points[0];
Ymin = Ymax = Points[1];
Xmin = Xmax = Points[0];
Ymin = Ymax = Points[1]; for( ii = 1; ii < n; ii++ ) // calcul du rectangle d'encadrement
{
for ( ii = 1; ii < n; ii++) // calcul du rectangle d'encadrement int jj = ii * 2;
{ Xmin = MIN( Xmin, Points[jj] );
int jj = ii * 2; Xmax = MAX( Xmax, Points[jj] );
Xmin = MIN(Xmin,Points[jj]); Ymin = MIN( Ymin, Points[jj + 1] );
Xmax = MAX(Xmax,Points[jj]); Ymax = MAX( Ymax, Points[jj + 1] );
Ymin = MIN(Ymin,Points[jj+1]); }
Ymax = MAX(Ymax,Points[jj+1]);
} xcliplo = ClipBox->GetX();
ycliplo = ClipBox->GetY();
xcliplo = ClipBox->GetX(); xcliphi = ClipBox->GetRight();
ycliplo = ClipBox->GetY(); ycliphi = ClipBox->GetHeight();
xcliphi = ClipBox->GetRight();
ycliphi = ClipBox->GetHeight(); if( Xmax < xcliplo )
return FALSE;
if ( Xmax < xcliplo ) return FALSE; if( Xmin > xcliphi )
if ( Xmin > xcliphi ) return FALSE; return FALSE;
if ( Ymax < ycliplo ) return FALSE; if( Ymax < ycliplo )
if ( Ymin > ycliphi ) return FALSE; return FALSE;
if( Ymin > ycliphi )
return TRUE; return FALSE;
return TRUE;
} }
/************************************************************************/ /************************************************************************/
/* Routine to draw a new polyline and fill it if Fill, in screen space. */ /* Routine to draw a new polyline and fill it if Fill, in screen space. */
/************************************************************************/ /************************************************************************/
void GRSPoly(EDA_Rect * ClipBox,wxDC * DC, int n, int *Points, int Fill, void GRSPoly( EDA_Rect* ClipBox, wxDC* DC, int n, int* Points, int Fill,
int width, int Color, int BgColor) int width, int Color, int BgColor )
{ {
int startx, starty; int startx, starty;
if ( ! IsGRSPolyDrawable(ClipBox, n, Points) ) return; if( !IsGRSPolyDrawable( ClipBox, n, Points ) )
return;
GRSetColorPen(DC, Color, width ); GRSetColorPen( DC, Color, width );
if( Fill && ( n > 2 ) ) if( Fill && ( n > 2 ) )
{ {
GRSetBrush(DC, BgColor, FILLED); GRSetBrush( DC, BgColor, FILLED );
DC->DrawPolygon(n, (wxPoint*)Points); DC->DrawPolygon( n, (wxPoint*) Points );
} }
else else
{ {
startx = Points[n * 2 - 2]; starty = Points[n * 2 - 1]; startx = Points[n * 2 - 2]; starty = Points[n * 2 - 1];
GRSetBrush(DC, Color); GRSetBrush( DC, Color );
DC->DrawLines(n, (wxPoint*)Points); DC->DrawLines( n, (wxPoint*) Points );
} }
} }
/******************************************************************************/ /******************************************************************************/
/* Routine to draw a new closed polyline and fill it if Fill, in screen space */ /* Routine to draw a new closed polyline and fill it if Fill, in screen space */
/******************************************************************************/ /******************************************************************************/
void GRSClosedPoly(EDA_Rect * ClipBox,wxDC * DC, int n, int *Points, void GRSClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int n, int* Points,
int Fill, int Color, int BgColor) int Fill, int Color, int BgColor )
{ {
GRSClosedPoly( ClipBox, DC, n, Points, Fill, 0, Color, BgColor); GRSClosedPoly( ClipBox, DC, n, Points, Fill, 0, Color, BgColor );
} }
void GRSClosedPoly(EDA_Rect * ClipBox,wxDC * DC, int n, int *Points,
int Fill, int width, int Color, int BgColor) void GRSClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int n, int* Points,
int Fill, int width, int Color, int BgColor )
{ {
int startx, starty; int startx, starty;
if ( ! IsGRSPolyDrawable(ClipBox, n, Points) ) return; if( !IsGRSPolyDrawable( ClipBox, n, Points ) )
return;
GRSetColorPen(DC, Color, width ); GRSetColorPen( DC, Color, width );
if( Fill && ( n > 2 ) ) if( Fill && ( n > 2 ) )
{ {
GRSMoveTo(Points[n * 2 - 2], Points[n * 2 - 1]); GRSMoveTo( Points[n * 2 - 2], Points[n * 2 - 1] );
GRSetBrush(DC, BgColor, FILLED); GRSetBrush( DC, BgColor, FILLED );
DC->DrawPolygon(n, (wxPoint*) Points, 0, 0,wxODDEVEN_RULE ); DC->DrawPolygon( n, (wxPoint*) Points, 0, 0, wxODDEVEN_RULE );
} }
else else
{ {
startx = Points[n * 2 - 2]; starty = Points[n * 2 - 1]; startx = Points[n * 2 - 2]; starty = Points[n * 2 - 1];
GRSetBrush(DC, BgColor); GRSetBrush( DC, BgColor );
DC->DrawLines(n, (wxPoint*)Points); DC->DrawLines( n, (wxPoint*) Points );
/* Fermeture du polygone */ /* Fermeture du polygone */
if( (startx != Points[0]) || (starty != Points[1]) ) if( (startx != Points[0]) || (starty != Points[1]) )
{ {
GRSLine(ClipBox, DC, Points[0], Points[1], startx, starty, width, Color); GRSLine( ClipBox, DC, Points[0], Points[1], startx, starty, width, Color );
} }
} }
} }
/************************************************************************/ /************************************************************************/
/* Routine to draw a new polyline and fill it if Fill, in drawing space. */ /* Routine to draw a new polyline and fill it if Fill, in drawing space. */
/************************************************************************/ /************************************************************************/
void GRPoly(EDA_Rect * ClipBox, wxDC * DC, int n, int *Points, void GRPoly( EDA_Rect* ClipBox, wxDC* DC, int n, int* Points,
int Fill, int width, int Color, int BgColor) int Fill, int width, int Color, int BgColor )
{ {
int ii, jj; int ii, jj;
width = ZoomValue( width );
for( ii = 0; ii < n; ii++ )
{
jj = ii << 1;
Points[jj] = GRMapX( Points[jj] );
jj++;
Points[jj] = GRMapY( Points[jj] );
}
width = ZoomValue(width); GRSPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
for (ii = 0; ii < n; ii++)
{
jj = ii << 1;
Points[jj] = GRMapX(Points[jj]);
jj++;
Points[jj] = GRMapY(Points[jj]);
}
GRSPoly(ClipBox, DC, n, Points, Fill, width, Color, BgColor);
} }
/**************************************************************************/ /**************************************************************************/
/* Routine to draw a closed polyline and fill it if Fill, in object space */ /* Routine to draw a closed polyline and fill it if Fill, in object space */
/**************************************************************************/ /**************************************************************************/
void GRClosedPoly(EDA_Rect * ClipBox,wxDC * DC, int n, int *Points, void GRClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int n, int* Points,
int Fill, int Color, int BgColor) int Fill, int Color, int BgColor )
{ {
GRClosedPoly(ClipBox, DC, n, Points, Fill, 0, Color, BgColor); GRClosedPoly( ClipBox, DC, n, Points, Fill, 0, Color, BgColor );
} }
void GRClosedPoly(EDA_Rect * ClipBox,wxDC * DC, int n, int *Points,
int Fill, int width, int Color, int BgColor) void GRClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int n, int* Points,
int Fill, int width, int Color, int BgColor )
{ {
int ii, jj; int ii, jj;
width = ZoomValue( width );
for( ii = 0; ii < n; ii++ )
{
jj = ii << 1;
Points[jj] = GRMapX( Points[jj] );
jj++;
Points[jj] = GRMapY( Points[jj] );
}
width = ZoomValue(width); GRSClosedPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
for (ii = 0; ii < n; ii++)
{
jj = ii << 1;
Points[jj] = GRMapX(Points[jj]);
jj++;
Points[jj] = GRMapY(Points[jj]);
}
GRSClosedPoly(ClipBox, DC, n, Points, Fill, width, Color, BgColor);
} }
/***********************************************/ /***********************************************/
/* Routine to draw a circle, in object space. */ /* Routine to draw a circle, in object space. */
/***********************************************/ /***********************************************/
void GRCircle(EDA_Rect * ClipBox,wxDC * DC, int x, int y, int r, int Color) void GRCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r, int Color )
{ {
int cx = GRMapX(x); int cx = GRMapX( x );
int cy = GRMapY(y); int cy = GRMapY( y );
int rayon = ZoomValue(r); int rayon = ZoomValue( r );
GRSCircle(ClipBox, DC, cx, cy, rayon, 0, Color ); GRSCircle( ClipBox, DC, cx, cy, rayon, 0, Color );
} }
/*****************************************************/ /*****************************************************/
/* Routine to draw a Filled circle, in object space. */ /* Routine to draw a Filled circle, in object space. */
/*****************************************************/ /*****************************************************/
void GRFilledCircle(EDA_Rect * ClipBox,wxDC * DC, int x, int y, int r, void GRFilledCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r,
int width, int Color, int BgColor) int width, int Color, int BgColor )
{ {
r = ZoomValue(r); r = ZoomValue( r );
width = ZoomValue(width); width = ZoomValue( width );
GRSFilledCircle(ClipBox, DC, GRMapX(x), GRMapY(y), r, width, Color, BgColor ); GRSFilledCircle( ClipBox, DC, GRMapX( x ), GRMapY( y ), r, width, Color, BgColor );
} }
/******************************************************/ /******************************************************/
/* Routine to draw a FILLED circle, in drawing space. */ /* Routine to draw a FILLED circle, in drawing space. */
/******************************************************/ /******************************************************/
void GRSFilledCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r, void GRSFilledCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r,
int width, int Color, int BgColor) int width, int Color, int BgColor )
{ {
/* suppression des cercles hors ecran */ /* suppression des cercles hors ecran */
if ( ClipBox ) if( ClipBox )
{ {
int x0, y0, xm, ym; int x0, y0, xm, ym;
x0 = ClipBox->GetX(); x0 = ClipBox->GetX();
y0 = ClipBox->GetY(); y0 = ClipBox->GetY();
xm = ClipBox->GetRight(); xm = ClipBox->GetRight();
ym = ClipBox->GetBottom(); ym = ClipBox->GetBottom();
if ( x < (x0-r) ) return; if( x < (x0 - r) )
if ( y < (y0-r) ) return; return;
if ( x > (r+xm) ) return; if( y < (y0 - r) )
if ( y > (r+ym) ) return; return;
} if( x > (r + xm) )
return;
GRSetColorPen(DC, Color, width ); if( y > (r + ym) )
GRSetBrush(DC, BgColor, FILLED); return;
DC->DrawEllipse(x-r, y-r, r+r, r+r); }
GRSetColorPen( DC, Color, width );
GRSetBrush( DC, BgColor, FILLED );
DC->DrawEllipse( x - r, y - r, r + r, r + r );
} }
/***********************************************************/ /***********************************************************/
/* Routine to draw a circle, in object space. */ /* Routine to draw a circle, in object space. */
/***********************************************************/ /***********************************************************/
void GRCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r, int width, int Color) void GRCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r, int width, int Color )
{ {
r = ZoomValue(r); r = ZoomValue( r );
width = ZoomValue(width); width = ZoomValue( width );
GRSCircle(ClipBox, DC, GRMapX(x), GRMapY(y), r, width, Color); GRSCircle( ClipBox, DC, GRMapX( x ), GRMapY( y ), r, width, Color );
} }
/***********************************************/ /***********************************************/
/* Routine to draw a circle, in drawing space. */ /* Routine to draw a circle, in drawing space. */
/***********************************************/ /***********************************************/
void GRSCircle(EDA_Rect * ClipBox,wxDC * DC, int xc, int yc, int r, int width, int Color) void GRSCircle( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc, int r, int width, int Color )
{ {
/* suppression des cercles hors ecran */ /* suppression des cercles hors ecran */
if ( ClipBox ) if( ClipBox )
{ {
int x0, y0, xm, ym; int x0, y0, xm, ym;
x0 = ClipBox->GetX(); x0 = ClipBox->GetX();
y0 = ClipBox->GetY(); y0 = ClipBox->GetY();
xm = ClipBox->GetRight(); xm = ClipBox->GetRight();
ym = ClipBox->GetBottom(); ym = ClipBox->GetBottom();
if ( xc < (x0-r - width) ) return; if( xc < (x0 - r - width) )
if ( yc < (y0-r - width) ) return; return;
if ( xc > (r+xm + width) ) return; if( yc < (y0 - r - width) )
if ( yc > (r+ym + width) ) return; return;
} if( xc > (r + xm + width) )
return;
GRSetColorPen(DC, Color, width); if( yc > (r + ym + width) )
GRSetBrush(DC, Color, FALSE); return;
DC->DrawEllipse(xc-r, yc-r, r+r, r+r); }
GRSetColorPen( DC, Color, width );
GRSetBrush( DC, Color, FALSE );
DC->DrawEllipse( xc - r, yc - r, r + r, r + r );
} }
/************************************************/ /************************************************/
/* Routine to draw an arc, in USER space. */ /* Routine to draw an arc, in USER space. */
/* Debut et fin de l'arc donnes par leur coord. */ /* Debut et fin de l'arc donnes par leur coord. */
/************************************************/ /************************************************/
void GRArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRArc1( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int xc, int yc, int Color) int xc, int yc, int Color )
{ {
GRSArc1(ClipBox, DC, GRSArc1( ClipBox, DC,
GRMapX(x1), GRMapY(y1), GRMapX(x2), GRMapY(y2), GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
GRMapX(xc), GRMapY(yc), 0, Color); GRMapX( xc ), GRMapY( yc ), 0, Color );
} }
/************************************************/ /************************************************/
/* Routine to draw an arc, width = width in USER space. */ /* Routine to draw an arc, width = width in USER space. */
/* Debut et fin de l'arc donnes par leur coord. */ /* Debut et fin de l'arc donnes par leur coord. */
/************************************************/ /************************************************/
void GRArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRArc1( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int xc, int yc, int width, int Color) int xc, int yc, int width, int Color )
{ {
GRSArc1(ClipBox, DC, GRSArc1( ClipBox, DC,
GRMapX(x1), GRMapY(y1), GRMapX(x2), GRMapY(y2), GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
GRMapX(xc), GRMapY(yc), ZoomValue(width), Color); GRMapX( xc ), GRMapY( yc ), ZoomValue( width ), Color );
} }
...@@ -913,378 +1041,433 @@ void GRArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, ...@@ -913,378 +1041,433 @@ void GRArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
/* Routine to draw an arc, width = width, in screen space. */ /* Routine to draw an arc, width = width, in screen space. */
/* Debut et fin de l'arc donnes par leur coord. */ /* Debut et fin de l'arc donnes par leur coord. */
/************************************************/ /************************************************/
void GRSArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRSArc1( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int xc, int yc, int width, int Color) int xc, int yc, int width, int Color )
{ {
/* suppression des cercles hors ecran */ /* suppression des cercles hors ecran */
if ( ClipBox ) if( ClipBox )
{ {
int x0, y0, xm, ym, r; int x0, y0, xm, ym, r;
x0 = ClipBox->GetX(); x0 = ClipBox->GetX();
y0 = ClipBox->GetY(); y0 = ClipBox->GetY();
xm = ClipBox->GetRight(); xm = ClipBox->GetRight();
ym = ClipBox->GetBottom(); ym = ClipBox->GetBottom();
r = (int)hypot(x1-xc, y1-yc); r = (int) hypot( x1 - xc, y1 - yc );
if ( xc < (x0-r) ) return; if( xc < (x0 - r) )
if ( yc < (y0-r) ) return; return;
if ( xc > (r+xm) ) return; if( yc < (y0 - r) )
if ( yc > (r+ym) ) return; return;
} if( xc > (r + xm) )
return;
GRSetColorPen(DC, Color , width); if( yc > (r + ym) )
GRSetBrush(DC, Color); return;
DC->DrawArc(x1, y1, x2, y2, xc, yc); }
GRSetColorPen( DC, Color, width );
GRSetBrush( DC, Color );
DC->DrawArc( x1, y1, x2, y2, xc, yc );
} }
/********************************************************************/ /********************************************************************/
/* Routine to draw an arc, in screen space. */ /* Routine to draw an arc, in screen space. */
/* As the Y axe is inverted the Angles should be inverted as well. */ /* As the Y axe is inverted the Angles should be inverted as well. */
/********************************************************************/ /********************************************************************/
void GRSArc(EDA_Rect * ClipBox,wxDC * DC, int xc, int yc, int StAngle, int EndAngle, void GRSArc( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc, int StAngle, int EndAngle,
int r, int width, int Color) int r, int width, int Color )
{ {
int x1, y1, x2, y2; int x1, y1, x2, y2;
/* suppression des cercles hors ecran */ /* suppression des cercles hors ecran */
if ( ClipBox ) if( ClipBox )
{ {
int x0, y0, xm, ym; int x0, y0, xm, ym;
x0 = ClipBox->GetX(); x0 = ClipBox->GetX();
y0 = ClipBox->GetY(); y0 = ClipBox->GetY();
xm = ClipBox->GetRight(); xm = ClipBox->GetRight();
ym = ClipBox->GetBottom(); ym = ClipBox->GetBottom();
if ( xc < (x0-r - width) ) return; if( xc < (x0 - r - width) )
if ( yc < (y0-r - width) ) return; return;
if ( xc > (r+xm + width) ) return; if( yc < (y0 - r - width) )
if ( yc > (r+ym + width) ) return; return;
} if( xc > (r + xm + width) )
return;
if( yc > (r + ym + width) )
return;
}
x1 = r; y1 = 0; x1 = r; y1 = 0;
RotatePoint( &x1, & y1, EndAngle); RotatePoint( &x1, &y1, EndAngle );
x2 = r; y2 = 0; x2 = r; y2 = 0;
RotatePoint( &x2, & y2, StAngle); RotatePoint( &x2, &y2, StAngle );
GRSetColorPen(DC, Color , width); GRSetColorPen( DC, Color, width );
GRSetBrush(DC, Color); GRSetBrush( DC, Color );
DC->DrawArc(xc + x1, yc - y1, xc + x2, yc - y2, xc, yc); DC->DrawArc( xc + x1, yc - y1, xc + x2, yc - y2, xc, yc );
} }
/********************************************************************/ /********************************************************************/
/* Routine to draw an Filled arc, in screen space. */ /* Routine to draw an Filled arc, in screen space. */
/* As the Y axes is inverted the Angles should be inverted as well. */ /* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/ /********************************************************************/
void GRSFilledArc(EDA_Rect * ClipBox,wxDC * DC, int xc, int yc, void GRSFilledArc( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc,
int StAngle, int EndAngle, int r, int width, int Color, int BgColor) int StAngle, int EndAngle, int r, int width, int Color, int BgColor )
{ {
int x1, y1, x2, y2; int x1, y1, x2, y2;
/* suppression des cercles hors ecran */ /* suppression des cercles hors ecran */
if ( ClipBox ) if( ClipBox )
{ {
int x0, y0, xm, ym; int x0, y0, xm, ym;
x0 = ClipBox->GetX(); x0 = ClipBox->GetX();
y0 = ClipBox->GetY(); y0 = ClipBox->GetY();
xm = ClipBox->GetRight(); xm = ClipBox->GetRight();
ym = ClipBox->GetBottom(); ym = ClipBox->GetBottom();
if ( xc < (x0-r - 1) ) return; if( xc < (x0 - r - 1) )
if ( yc < (y0-r - 1) ) return; return;
if ( xc > (r+xm + 1) ) return; if( yc < (y0 - r - 1) )
if ( yc > (r+ym + 1) ) return; return;
} if( xc > (r + xm + 1) )
return;
if( yc > (r + ym + 1) )
return;
}
x1 = r; y1 = 0; x1 = r; y1 = 0;
RotatePoint( &x1, & y1, EndAngle); RotatePoint( &x1, &y1, EndAngle );
x2 = r; y2 = 0; x2 = r; y2 = 0;
RotatePoint( &x2, & y2, StAngle); RotatePoint( &x2, &y2, StAngle );
GRSetBrush(DC, BgColor, FILLED); GRSetBrush( DC, BgColor, FILLED );
GRSetColorPen(DC, Color, width); GRSetColorPen( DC, Color, width );
DC->DrawArc(xc + x1, yc - y1, xc + x2, yc - y2, xc, yc); DC->DrawArc( xc + x1, yc - y1, xc + x2, yc - y2, xc, yc );
} }
/********************************************************************/ /********************************************************************/
/* Routine to draw a Filled arc, in drawing space. */ /* Routine to draw a Filled arc, in drawing space. */
/* As the Y axes is inverted the Angles should be inverted as well. */ /* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/ /********************************************************************/
void GRFilledArc(EDA_Rect * ClipBox,wxDC * DC, int x, int y, void GRFilledArc( EDA_Rect* ClipBox, wxDC* DC, int x, int y,
int StAngle, int EndAngle, int r, int width, int Color, int BgColor) int StAngle, int EndAngle, int r, int width, int Color, int BgColor )
{ {
width = ZoomValue(width); width = ZoomValue( width );
GRSFilledArc(ClipBox, DC, GRMapX(x), GRMapY(y), GRSFilledArc( ClipBox, DC, GRMapX( x ), GRMapY( y ),
StAngle, EndAngle, StAngle, EndAngle,
ZoomValue(r), width, Color, BgColor); ZoomValue( r ), width, Color, BgColor );
} }
void GRFilledArc(EDA_Rect * ClipBox,wxDC * DC, int x, int y,
int StAngle, int EndAngle, int r, int Color, int BgColor) void GRFilledArc( EDA_Rect* ClipBox, wxDC* DC, int x, int y,
int StAngle, int EndAngle, int r, int Color, int BgColor )
{ {
GRSFilledArc(ClipBox, DC, GRMapX(x), GRMapY(y), GRSFilledArc( ClipBox, DC, GRMapX( x ), GRMapY( y ),
StAngle, EndAngle, StAngle, EndAngle,
ZoomValue(r), 0, Color, BgColor); ZoomValue( r ), 0, Color, BgColor );
} }
/********************************************************************/ /********************************************************************/
/* Routine to draw an arc, in drawing space. */ /* Routine to draw an arc, in drawing space. */
/* As the Y axes is inverted the Angles should be inverted as well. */ /* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/ /********************************************************************/
void GRArc(EDA_Rect * ClipBox,wxDC * DC, int xc, int yc, int StAngle, void GRArc( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc, int StAngle,
int EndAngle, int r, int Color) int EndAngle, int r, int Color )
{ {
int x1, y1, x2, y2; int x1, y1, x2, y2;
/* suppression des cercles hors ecran */ /* suppression des cercles hors ecran */
if ( ClipBox ) if( ClipBox )
{ {
int rayon = ZoomValue(r) + 1; int rayon = ZoomValue( r ) + 1;
int x0, y0, xm, ym, x, y; int x0, y0, xm, ym, x, y;
x0 = ClipBox->GetX(); x0 = ClipBox->GetX();
y0 = ClipBox->GetY(); y0 = ClipBox->GetY();
xm = ClipBox->GetRight(); xm = ClipBox->GetRight();
ym = ClipBox->GetBottom(); ym = ClipBox->GetBottom();
x = GRMapX(xc); y = GRMapY(yc); x = GRMapX( xc ); y = GRMapY( yc );
if ( x < (x0 - rayon) ) return; if( x < (x0 - rayon) )
if ( y < (y0 - rayon) ) return; return;
if ( x > (xm + rayon) ) return; if( y < (y0 - rayon) )
if ( y > (ym + rayon) ) return; return;
} if( x > (xm + rayon) )
return;
x1 = r; y1 = 0; if( y > (ym + rayon) )
RotatePoint( &x1, & y1, EndAngle); return;
}
x2 = r; y2 = 0;
RotatePoint( &x2, & y2, StAngle); x1 = r; y1 = 0;
RotatePoint( &x1, &y1, EndAngle );
GRSetColorPen(DC, Color);
GRSetBrush(DC,Color,FALSE); x2 = r; y2 = 0;
DC->DrawArc(GRMapX(xc + x1), GRMapY(yc - y1), RotatePoint( &x2, &y2, StAngle );
GRMapX(xc + x2), GRMapY(yc - y2),
GRMapX(xc), GRMapY(yc) ); GRSetColorPen( DC, Color );
GRSetBrush( DC, Color, FALSE );
DC->DrawArc( GRMapX( xc + x1 ), GRMapY( yc - y1 ),
GRMapX( xc + x2 ), GRMapY( yc - y2 ),
GRMapX( xc ), GRMapY( yc ) );
} }
/********************************************************************/ /********************************************************************/
/* Routine to draw an arc, width = width, in drawing space. */ /* Routine to draw an arc, width = width, in drawing space. */
/* As the Y axes is inverted the Angles should be inverted as well. */ /* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/ /********************************************************************/
void GRArc(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int StAngle, int EndAngle, void GRArc( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int StAngle, int EndAngle,
int r, int width, int Color) int r, int width, int Color )
{ {
GRSArc(ClipBox, DC, GRMapX(x), GRMapY(y), GRSArc( ClipBox, DC, GRMapX( x ), GRMapY( y ),
StAngle, EndAngle, StAngle, EndAngle,
ZoomValue(r), ZoomValue( r ),
ZoomValue(width), ZoomValue( width ),
Color); Color );
} }
/**************************************************/ /**************************************************/
/* Routine to draw a Rectangle, in drawing space. */ /* Routine to draw a Rectangle, in drawing space. */
/**************************************************/ /**************************************************/
void GRRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int Color) void GRRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int Color )
{ {
x1 = GRMapX(x1); y1 = GRMapY(y1); x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX(x2); y2 = GRMapY(y2); x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
GRSRect(ClipBox, DC, x1, y1, x2, y2, Color ); GRSRect( ClipBox, DC, x1, y1, x2, y2, Color );
} }
/**************************************************/ /**************************************************/
/* Routine to draw a Rectangle, in drawing space. */ /* Routine to draw a Rectangle, in drawing space. */
/**************************************************/ /**************************************************/
void GRRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color) void GRRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{ {
x1 = GRMapX(x1); y1 = GRMapY(y1); x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX(x2); y2 = GRMapY(y2); x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
width = ZoomValue(width); width = ZoomValue( width );
GRSRect(ClipBox, DC, x1, y1, x2, y2, width, Color ); GRSRect( ClipBox, DC, x1, y1, x2, y2, width, Color );
} }
/************************************************************************************/ /************************************************************************************/
void GRFilledRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int Color, int BgColor) int Color, int BgColor )
/************************************************************************************/ /************************************************************************************/
/* Routine to draw a Rectangle (filled with AreaColor), in drawing space. */ /* Routine to draw a Rectangle (filled with AreaColor), in drawing space. */
{ {
x1 = GRMapX(x1); y1 = GRMapY(y1); x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX(x2); y2 = GRMapY(y2); x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
GRSFilledRect(ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor ); GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor );
} }
/************************************************************************************/ /************************************************************************************/
void GRFilledRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color, int BgColor) int width, int Color, int BgColor )
/************************************************************************************/ /************************************************************************************/
/* Routine to draw a Rectangle (filled with AreaColor), in drawing space. */ /* Routine to draw a Rectangle (filled with AreaColor), in drawing space. */
{ {
x1 = GRMapX(x1); y1 = GRMapY(y1); x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX(x2); y2 = GRMapY(y2); x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
width = ZoomValue(width); width = ZoomValue( width );
GRSFilledRect(ClipBox, DC, x1, y1, x2, y2, width, Color, BgColor ); GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, width, Color, BgColor );
} }
/*************************************************/ /*************************************************/
/* Routine to draw a Rectangle, in screen space. */ /* Routine to draw a Rectangle, in screen space. */
/*************************************************/ /*************************************************/
void GRSRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, int Color) void GRSRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int Color )
{ {
GRSRect(ClipBox, DC, x1, y1, x2, y2, 0, Color); GRSRect( ClipBox, DC, x1, y1, x2, y2, 0, Color );
} }
void GRSRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
int width, int Color) void GRSRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color )
{ {
if(x1 > x2) EXCHG(x1,x2); if( x1 > x2 )
if(y1 > y2) EXCHG(y1,y2); EXCHG( x1, x2 );
if( y1 > y2 )
EXCHG( y1, y2 );
/* Clipping des coordonnees */ /* Clipping des coordonnees */
if ( ClipBox ) if( ClipBox )
{ {
int xmin = ClipBox->GetX(); int xmin = ClipBox->GetX();
int ymin = ClipBox->GetY(); int ymin = ClipBox->GetY();
int xmax = ClipBox->GetRight(); int xmax = ClipBox->GetRight();
int ymax = ClipBox->GetBottom(); int ymax = ClipBox->GetBottom();
if ( x1 > xmax ) return; if( x1 > xmax )
if ( x2 < xmin ) return; return;
if ( y1 > ymax ) return; if( x2 < xmin )
if ( y2 < ymin ) return; return;
} if( y1 > ymax )
return;
if( y2 < ymin )
return;
}
GRSetColorPen(DC, Color, width ); GRSetColorPen( DC, Color, width );
if ( (x1 == x2) || (y1 == y2) ) DC->DrawLine(x1, y1, x2, y2); if( (x1 == x2) || (y1 == y2) )
else DC->DrawLine( x1, y1, x2, y2 );
{ else
GRSetBrush(DC, BLACK ); {
DC->DrawRectangle(x1, y1, x2 - x1, y2 - y1); GRSetBrush( DC, BLACK );
} DC->DrawRectangle( x1, y1, x2 - x1, y2 - y1 );
}
} }
/* Routine to draw a Filled Rectangle, in screen space. */ /* Routine to draw a Filled Rectangle, in screen space. */
/***************************************************************************************/ /***************************************************************************************/
void GRSFilledRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRSFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int Color, int BgColor) int Color, int BgColor )
/***************************************************************************************/ /***************************************************************************************/
{ {
GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor); GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor );
} }
/***************************************************************************************/ /***************************************************************************************/
void GRSFilledRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2, void GRSFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color, int BgColor) int width, int Color, int BgColor )
/***************************************************************************************/ /***************************************************************************************/
{ {
if(x1 > x2) EXCHG(x1,x2); if( x1 > x2 )
if(y1 > y2) EXCHG(y1,y2); EXCHG( x1, x2 );
if ( ClipBox ) if( y1 > y2 )
{ EXCHG( y1, y2 );
int xmin = ClipBox->GetX(); if( ClipBox )
int ymin = ClipBox->GetY(); {
int xmax = ClipBox->GetRight(); int xmin = ClipBox->GetX();
int ymax = ClipBox->GetBottom(); int ymin = ClipBox->GetY();
int xmax = ClipBox->GetRight();
if ( x1 > xmax ) return; int ymax = ClipBox->GetBottom();
if ( x2 < xmin ) return;
if ( y1 > ymax ) return; if( x1 > xmax )
if ( y2 < ymin ) return; return;
if( x2 < xmin )
// Clipping coordinates return;
if ( x1 < xmin )x1 = xmin -1; if( y1 > ymax )
if ( y1 < ymin )y1 = ymin -1; return;
if ( x2 > xmax ) x2 = xmax +1; if( y2 < ymin )
if ( y2 > ymax ) y2 = ymax +1; return;
}
// Clipping coordinates
GRSetColorPen(DC, Color, width ); if( x1 < xmin )
if ( (x1 == x2) || (y1 == y2) ) DC->DrawLine(x1, y1, x2, y2); x1 = xmin - 1;
else if( y1 < ymin )
{ y1 = ymin - 1;
GRSetBrush(DC, BgColor, FILLED); if( x2 > xmax )
DC->DrawRectangle(x1, y1, x2 - x1, y2 - y1); x2 = xmax + 1;
} if( y2 > ymax )
} y2 = ymax + 1;
}
/*******************************/ GRSetColorPen( DC, Color, width );
/* Routines used to draw texts */ if( (x1 == x2) || (y1 == y2) )
/*******************************/ DC->DrawLine( x1, y1, x2, y2 );
else
{
GRSetBrush( DC, BgColor, FILLED );
DC->DrawRectangle( x1, y1, x2 - x1, y2 - y1 );
}
}
/*******************************/
/* Routines used to draw texts */
/*******************************/
/*********************************************/ /*********************************************/
void GRSetFont(wxDC * DC, wxFont * Font) void GRSetFont( wxDC* DC, wxFont* Font )
/*********************************************/ /*********************************************/
/* Routine to set the current font */ /* Routine to set the current font */
{ {
DC->SetFont(*Font); DC->SetFont( *Font );
} }
/*********************************************************/ /*********************************************************/
void GRSetTextFgColor(wxDC * DC, int Color) void GRSetTextFgColor( wxDC* DC, int Color )
/*********************************************************/ /*********************************************************/
/* Set the foreground color used to draw texts */ /* Set the foreground color used to draw texts */
{ {
DC->SetTextForeground(wxColour( DC->SetTextForeground( wxColour(
ColorRefs[Color].m_Red, ColorRefs[Color].m_Red,
ColorRefs[Color].m_Green, ColorRefs[Color].m_Green,
ColorRefs[Color].m_Blue) ColorRefs[Color].m_Blue )
); );
} }
void GRSetTextFgColor(wxDC * DC, wxFont *, int Color)
void GRSetTextFgColor( wxDC* DC, wxFont*, int Color )
{ {
DC->SetTextForeground(wxColour( DC->SetTextForeground( wxColour(
ColorRefs[Color].m_Red, ColorRefs[Color].m_Red,
ColorRefs[Color].m_Green, ColorRefs[Color].m_Green,
ColorRefs[Color].m_Blue) ColorRefs[Color].m_Blue )
); );
} }
/*****************************************************************************/ /*****************************************************************************/
void GRGetTextExtent(wxDC * DC, const wxChar * Text, long * width, long * height) void GRGetTextExtent( wxDC* DC, const wxChar* Text, long* width, long* height )
/*****************************************************************************/ /*****************************************************************************/
/* Return the size of the text /* Return the size of the text
*/ */
{ {
long w = 0, h = 0; long w = 0, h = 0;
if ( Text ) if( Text )
{ {
DC->GetTextExtent(Text, &w, &h ); DC->GetTextExtent( Text, &w, &h );
} }
if ( width ) *width = w; if( width )
if ( height ) * height = h; *width = w;
if( height )
*height = h;
} }
/********************************/ /********************************/
void GRResetTextFgColor(wxDC * DC) void GRResetTextFgColor( wxDC* DC )
/********************************/ /********************************/
/* Set the foreground color used to draw texts to the default value */ /* Set the foreground color used to draw texts to the default value */
{ {
GRSetTextFgColor(DC, Text_Color); GRSetTextFgColor( DC, Text_Color );
} }
/*********************************************************/ /*********************************************************/
void GRSetTextBgColor(wxDC * DC, int Color) void GRSetTextBgColor( wxDC* DC, int Color )
/*********************************************************/ /*********************************************************/
/* Set the background color used to draw texts */ /* Set the background color used to draw texts */
{ {
Color &= MASKCOLOR; // keep only the bits used to select the color Color &= MASKCOLOR; // keep only the bits used to select the color
DC->SetTextBackground(wxColour( DC->SetTextBackground( wxColour(
ColorRefs[Color].m_Red, ColorRefs[Color].m_Red,
ColorRefs[Color].m_Green, ColorRefs[Color].m_Green,
ColorRefs[Color].m_Blue) ColorRefs[Color].m_Blue )
); );
} }
void GRSetTextBgColor(wxDC * DC, wxFont *, int Color)
void GRSetTextBgColor( wxDC* DC, wxFont*, int Color )
{ {
Color &= MASKCOLOR; // keep only the bits used to select the color Color &= MASKCOLOR; // keep only the bits used to select the color
DC->SetTextBackground(wxColour( DC->SetTextBackground( wxColour(
ColorRefs[Color].m_Red, ColorRefs[Color].m_Red,
ColorRefs[Color].m_Green, ColorRefs[Color].m_Green,
ColorRefs[Color].m_Blue) ColorRefs[Color].m_Blue )
); );
} }
include/base_struct.h
View file @ f353c77c
...@@ -191,8 +191,19 @@ public: ...@@ -191,8 +191,19 @@ public:
/* Gestion de l'etat (status) de la structure (active, deleted..) */ /* Gestion de l'etat (status) de la structure (active, deleted..) */
int GetState( int type ) const;
void SetState( int type, int state ); int GetState( int type ) const
{
return m_Status & type;
}
void SetState( int type, int state )
{
if( state )
m_Status |= type; // state = ON or OFF
else
m_Status &= ~type;
}
int ReturnStatus() const { return m_Status; } int ReturnStatus() const { return m_Status; }
......
include/pcbstruct.h
View file @ f353c77c
...@@ -442,6 +442,17 @@ public: ...@@ -442,6 +442,17 @@ public:
EDGE_ZONE( BOARD_ITEM* StructFather ); EDGE_ZONE( BOARD_ITEM* StructFather );
EDGE_ZONE( const EDGE_ZONE& edgezone ); EDGE_ZONE( const EDGE_ZONE& edgezone );
~EDGE_ZONE(); ~EDGE_ZONE();
EDGE_ZONE* Next() { return (EDGE_ZONE*) Pnext; }
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.pcb" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
}; };
......
include/wxstruct.h
View file @ f353c77c
...@@ -535,7 +535,13 @@ public: ...@@ -535,7 +535,13 @@ public:
void Block_Move( wxDC* DC ); void Block_Move( wxDC* DC );
void Block_Duplicate( wxDC* DC ); void Block_Duplicate( wxDC* DC );
// zone handling:
/**
* Function DelLimitesZone
* deletes the limits of a zone.
* @param DC A wxDC to draw onto.
* @param Redraw If true, means redraw the pcb without the zone limits
*/
void DelLimitesZone( wxDC* DC, bool Redraw ); void DelLimitesZone( wxDC* DC, bool Redraw );
// layerhandling: // layerhandling:
......
pcbnew/class_board.cpp
View file @ f353c77c
...@@ -610,7 +610,7 @@ bool BOARD::Save( FILE* aFile ) const ...@@ -610,7 +610,7 @@ bool BOARD::Save( FILE* aFile ) const
default: default:
// future: throw exception here // future: throw exception here
#if defined(DEBUG) #if defined(DEBUG)
printf( "BOARD::Save() ignoring draw type %d\n", item->Type() ); printf( "BOARD::Save() ignoring m_Drawings type %d\n", item->Type() );
#endif #endif
break; break;
} }
...@@ -623,14 +623,22 @@ bool BOARD::Save( FILE* aFile ) const ...@@ -623,14 +623,22 @@ bool BOARD::Save( FILE* aFile ) const
goto out; goto out;
fprintf( aFile, "$EndTRACK\n" ); fprintf( aFile, "$EndTRACK\n" );
// save the zones // save the zones
fprintf( aFile, "$ZONE\n" ); fprintf( aFile, "$ZONE\n" );
for( item = m_Zone; item; item=item->Next() ) for( item = m_Zone; item; item=item->Next() )
if( !item->Save( aFile ) ) if( !item->Save( aFile ) )
goto out; goto out;
fprintf( aFile, "$EndZONE\n" ); fprintf( aFile, "$EndZONE\n" );
// save the zone edges
if( m_CurrentLimitZone )
{
fprintf( aFile, "$ZONE_EDGE\n" );
for( item = m_CurrentLimitZone; item; item=item->Next() )
if( !item->Save( aFile ) )
goto out;
fprintf( aFile, "$EndZONE_EDGE\n" );
}
if( fprintf( aFile, "$EndBOARD\n" ) != sizeof("$EndBOARD\n")-1 ) if( fprintf( aFile, "$EndBOARD\n" ) != sizeof("$EndBOARD\n")-1 )
goto out; goto out;
...@@ -690,11 +698,11 @@ void BOARD::Show( int nestLevel, std::ostream& os ) ...@@ -690,11 +698,11 @@ void BOARD::Show( int nestLevel, std::ostream& os )
p->Show( nestLevel+2, os ); p->Show( nestLevel+2, os );
NestedSpace( nestLevel+1, os ) << "</zones>\n"; NestedSpace( nestLevel+1, os ) << "</zones>\n";
NestedSpace( nestLevel+1, os ) << "<edgezones>\n"; NestedSpace( nestLevel+1, os ) << "<zoneedges>\n";
p = m_CurrentLimitZone; p = m_CurrentLimitZone;
for( ; p; p = p->Pnext ) for( ; p; p = p->Pnext )
p->Show( nestLevel+2, os ); p->Show( nestLevel+2, os );
NestedSpace( nestLevel+1, os ) << "</edgezones>\n"; NestedSpace( nestLevel+1, os ) << "</zoneedges>\n";
p = m_Son; p = m_Son;
for( ; p; p = p->Pnext ) for( ; p; p = p->Pnext )
......
pcbnew/class_edge_mod.cpp
View file @ f353c77c
...@@ -404,7 +404,9 @@ bool EDGE_MODULE::Save( FILE* aFile ) const ...@@ -404,7 +404,9 @@ bool EDGE_MODULE::Save( FILE* aFile ) const
default: default:
// future: throw an exception here // future: throw an exception here
printf( "%s unexpected EDGE_MODULE::m_Shape: %d\n", __func__, m_Shape ); #if defined(DEBUG)
printf( "EDGE_MODULE::Save(): unexpected m_Shape: %d\n", m_Shape );
#endif
break; break;
} }
......
pcbnew/class_track.h
View file @ f353c77c
...@@ -80,10 +80,12 @@ public: ...@@ -80,10 +80,12 @@ public:
*/ */
void Insert( BOARD* Pcb, BOARD_ITEM* InsertPoint ); void Insert( BOARD* Pcb, BOARD_ITEM* InsertPoint );
/*Search the "best" insertion point within the track linked list /**
* the best point is the of the corresponding net code section * Function GetBestInsertPoint
* @return the item found in the linked list (or NULL if no track) * searches the "best" insertion point within the track linked list.
*/ * The best point is the of the corresponding net code section.
* @return TRACK* - the item found in the linked list (or NULL if no track)
*/
TRACK* GetBestInsertPoint( BOARD* Pcb ); TRACK* GetBestInsertPoint( BOARD* Pcb );
/* Search (within the track linked list) the first segment matching the netcode /* Search (within the track linked list) the first segment matching the netcode
......
pcbnew/classpcb.cpp
View file @ f353c77c
...@@ -38,6 +38,7 @@ void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC ) ...@@ -38,6 +38,7 @@ void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
EDGE_ZONE::EDGE_ZONE( BOARD_ITEM* parent ) : EDGE_ZONE::EDGE_ZONE( BOARD_ITEM* parent ) :
DRAWSEGMENT( parent, TYPEEDGEZONE ) DRAWSEGMENT( parent, TYPEEDGEZONE )
{ {
m_Width = 2; // a minimum for visibility, while dragging
} }
...@@ -47,6 +48,23 @@ EDGE_ZONE:: ~EDGE_ZONE() ...@@ -47,6 +48,23 @@ EDGE_ZONE:: ~EDGE_ZONE()
} }
bool EDGE_ZONE::Save( FILE* aFile ) const
{
if( GetState( DELETED ) )
return true;
int ret = fprintf( aFile, "ZE %d %d %d %d %d %lX %X\n",
m_Start.x, m_Start.y,
m_End.x, m_End.y,
m_Angle,
m_TimeStamp,
ReturnStatus()
);
return (ret > 14 );
}
/**********************/ /**********************/
/* Classe DRAWSEGMENT */ /* Classe DRAWSEGMENT */
/**********************/ /**********************/
...@@ -131,7 +149,7 @@ bool DRAWSEGMENT::Save( FILE* aFile ) const ...@@ -131,7 +149,7 @@ bool DRAWSEGMENT::Save( FILE* aFile ) const
bool rc = false; bool rc = false;
if( fprintf( aFile, "$DRAWSEGMENT\n" ) != sizeof("%DRAWSEGMENT\n")-1 ) if( fprintf( aFile, "$DRAWSEGMENT\n" ) != sizeof("$DRAWSEGMENT\n")-1 )
goto out; goto out;
fprintf( aFile, "Po %d %d %d %d %d %d\n", fprintf( aFile, "Po %d %d %d %d %d %d\n",
......
pcbnew/files.cpp
View file @ f353c77c
...@@ -235,9 +235,13 @@ int WinEDA_PcbFrame::LoadOnePcbFile( const wxString& FullFileName, wxDC * DC, bo ...@@ -235,9 +235,13 @@ int WinEDA_PcbFrame::LoadOnePcbFile( const wxString& FullFileName, wxDC * DC, bo
#if 1 && defined(DEBUG) #if 1 && defined(DEBUG)
// note this seems to freeze up pcbnew when run under the kicad project // note this freezes up pcbnew when run under the kicad project
// manager. runs fine from command prompt. // manager. runs fine from command prompt. This is because the kicad
// output the board object tree to stdout: // project manager redirects stdout of the child pcbnew process to itself,
// but never reads from that pipe, and that in turn eventually blocks
// the pcbnew program when the pipe it is writing to gets full.
// Output the board object tree to stdout, but please run from command prompt:
m_Pcb->Show( 0, std::cout ); m_Pcb->Show( 0, std::cout );
#endif #endif
......
pcbnew/tracepcb.cpp
View file @ f353c77c
...@@ -177,10 +177,11 @@ void WinEDA_PcbFrame::Trace_Pcb( wxDC* DC, int mode ) ...@@ -177,10 +177,11 @@ void WinEDA_PcbFrame::Trace_Pcb( wxDC* DC, int mode )
DrawHightLight( DC, g_HightLigth_NetCode ); DrawHightLight( DC, g_HightLigth_NetCode );
EDGE_ZONE* segment = m_Pcb->m_CurrentLimitZone; EDGE_ZONE* segment = m_Pcb->m_CurrentLimitZone;
for( ; segment != NULL; segment = (EDGE_ZONE*) segment->Pback ) for( ; segment != NULL; segment = (EDGE_ZONE*) segment->Pback )
{ {
if( segment->m_Flags & IS_MOVED ) if( segment->m_Flags & IS_MOVED )
continue; continue;
Trace_DrawSegmentPcb( DrawPanel, DC, segment, mode ); Trace_DrawSegmentPcb( DrawPanel, DC, segment, mode );
} }
......
pcbnew/trpiste.cpp
View file @ f353c77c
...@@ -92,11 +92,11 @@ void Trace_DrawSegmentPcb( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -92,11 +92,11 @@ void Trace_DrawSegmentPcb( WinEDA_DrawPanel* panel, wxDC* DC,
/* coord de depart */ /* coord de depart */
ux0 = PtDrawSegment->m_Start.x; ux0 = PtDrawSegment->m_Start.x;
uy0 = PtDrawSegment->m_Start.y; uy0 = PtDrawSegment->m_Start.y;
/* coord d'arrivee */ /* coord d'arrivee */
dx = PtDrawSegment->m_End.x; dx = PtDrawSegment->m_End.x;
dy = PtDrawSegment->m_End.y; dy = PtDrawSegment->m_End.y;
mode = DisplayOpt.DisplayDrawItems; mode = DisplayOpt.DisplayDrawItems;
if( PtDrawSegment->m_Flags & FORCE_SKETCH ) if( PtDrawSegment->m_Flags & FORCE_SKETCH )
mode = SKETCH; mode = SKETCH;
......
pcbnew/zones.cpp
View file @ f353c77c
...@@ -412,8 +412,7 @@ void WinEDA_PcbFrame::Edit_Zone_Width( wxDC* DC, SEGZONE* aZone ) ...@@ -412,8 +412,7 @@ void WinEDA_PcbFrame::Edit_Zone_Width( wxDC* DC, SEGZONE* aZone )
Line.ToDouble( &f_new_width ); Line.ToDouble( &f_new_width );
g_DesignSettings.m_CurrentTrackWidth = From_User_Unit( g_UnitMetric, g_DesignSettings.m_CurrentTrackWidth = From_User_Unit( g_UnitMetric,
f_new_width, GetScreen( f_new_width, GetScreen()->GetInternalUnits() );
)->GetInternalUnits() );
for( SEGZONE* zone = m_Pcb->m_Zone; zone; zone = zone->Next() ) for( SEGZONE* zone = m_Pcb->m_Zone; zone; zone = zone->Next() )
{ {
...@@ -604,16 +603,16 @@ static void Display_Zone_Netname( WinEDA_PcbFrame* frame ) ...@@ -604,16 +603,16 @@ static void Display_Zone_Netname( WinEDA_PcbFrame* frame )
static void Exit_Zones( WinEDA_DrawPanel* Panel, wxDC* DC ) static void Exit_Zones( WinEDA_DrawPanel* Panel, wxDC* DC )
/********************************************************/ /********************************************************/
/* routine d'annulation de la Commande Begin_Zone si une piste est en cours /**
* de tracage, ou de sortie de l'application SEGZONES. * Function Exit_Zones
* Appel par la touche ESC * cancels the Begin_Zone state if at least one EDGE_ZONE has been created.
*/ */
{ {
WinEDA_PcbFrame* pcbframe = (WinEDA_PcbFrame*) Panel->m_Parent; WinEDA_PcbFrame* pcbframe = (WinEDA_PcbFrame*) Panel->m_Parent;
if( pcbframe->m_Pcb->m_CurrentLimitZone ) if( pcbframe->m_Pcb->m_CurrentLimitZone )
{ {
if( Panel->ManageCurseur ) /* trace en cours */ if( Panel->ManageCurseur ) // trace in progress
{ {
Panel->ManageCurseur( Panel, DC, 0 ); Panel->ManageCurseur( Panel, DC, 0 );
} }
...@@ -629,12 +628,9 @@ static void Exit_Zones( WinEDA_DrawPanel* Panel, wxDC* DC ) ...@@ -629,12 +628,9 @@ static void Exit_Zones( WinEDA_DrawPanel* Panel, wxDC* DC )
/**************************************************************/ /**************************************************************/
void WinEDA_BasePcbFrame::DelLimitesZone( wxDC* DC, bool Redraw ) void WinEDA_BasePcbFrame::DelLimitesZone( wxDC* DC, bool Redraw )
/**************************************************************/ /**************************************************************/
/* Supprime la liste des segments constituant la frontiere courante
* Libere la memoire correspondante
*/
{ {
EDGE_ZONE* segment, * Next; EDGE_ZONE* segment;
EDGE_ZONE* next;
if( m_Pcb->m_CurrentLimitZone == NULL ) if( m_Pcb->m_CurrentLimitZone == NULL )
return; return;
...@@ -642,14 +638,17 @@ void WinEDA_BasePcbFrame::DelLimitesZone( wxDC* DC, bool Redraw ) ...@@ -642,14 +638,17 @@ void WinEDA_BasePcbFrame::DelLimitesZone( wxDC* DC, bool Redraw )
if( !IsOK( this, _( "Delete Current Zone Edges" ) ) ) if( !IsOK( this, _( "Delete Current Zone Edges" ) ) )
return; return;
/* efface ancienne limite de zone */ // erase the old zone border, one segment at a time
segment = m_Pcb->m_CurrentLimitZone; segment = m_Pcb->m_CurrentLimitZone;
for( ; segment != NULL; segment = Next ) for( ; segment != NULL; segment = next )
{ {
Next = (EDGE_ZONE*) segment->Pback; next = (EDGE_ZONE*) segment->Pback;
if( Redraw ) if( Redraw )
Trace_DrawSegmentPcb( DrawPanel, DC, segment, GR_XOR ); Trace_DrawSegmentPcb( DrawPanel, DC, segment, GR_XOR );
segment->Pnext = NULL; delete segment;
segment->Pnext = NULL;
delete segment;
} }
SetCurItem( NULL ); SetCurItem( NULL );
...@@ -657,47 +656,53 @@ void WinEDA_BasePcbFrame::DelLimitesZone( wxDC* DC, bool Redraw ) ...@@ -657,47 +656,53 @@ void WinEDA_BasePcbFrame::DelLimitesZone( wxDC* DC, bool Redraw )
} }
/********************************************/ /**
EDGE_ZONE* WinEDA_PcbFrame::Begin_Zone() * Function Begin_Zone
/********************************************/ * either initializes the first segment of a new zone, or adds an
* intermediate segment.
/*
* Routine d'initialisation d'un trace de Limite de Zone ou
* de placement d'un point intermediaire
*/ */
EDGE_ZONE* WinEDA_PcbFrame::Begin_Zone()
{ {
EDGE_ZONE* oldedge, * newedge = NULL; EDGE_ZONE* oldedge;
EDGE_ZONE* newedge = NULL;
oldedge = m_Pcb->m_CurrentLimitZone; oldedge = m_Pcb->m_CurrentLimitZone;
// if first segment
if( (m_Pcb->m_CurrentLimitZone == NULL ) /* debut reel du trace */ if( (m_Pcb->m_CurrentLimitZone == NULL ) /* debut reel du trace */
|| (DrawPanel->ManageCurseur == NULL) ) /* reprise d'un trace complementaire */ || (DrawPanel->ManageCurseur == NULL) ) /* reprise d'un trace complementaire */
{ {
m_Pcb->m_CurrentLimitZone = newedge = new EDGE_ZONE( m_Pcb ); newedge = new EDGE_ZONE( m_Pcb );
newedge->m_Flags = IS_NEW | STARTPOINT | IS_MOVED; newedge->m_Flags = IS_NEW | STARTPOINT | IS_MOVED;
newedge->m_Start = newedge->m_End = GetScreen()->m_Curseur;
newedge->SetLayer( GetScreen()->m_Active_Layer );
// link into list:
newedge->Pback = oldedge; newedge->Pback = oldedge;
if( oldedge ) if( oldedge )
oldedge->Pnext = newedge; oldedge->Pnext = newedge;
newedge->SetLayer( GetScreen()->m_Active_Layer );
newedge->m_Width = 2; /* Largeur minimum tracable */
newedge->m_Start = newedge->m_End = GetScreen()->m_Curseur;
m_Pcb->m_CurrentLimitZone = newedge; m_Pcb->m_CurrentLimitZone = newedge;
DrawPanel->ManageCurseur = Show_Zone_Edge_While_MoveMouse; DrawPanel->ManageCurseur = Show_Zone_Edge_While_MoveMouse;
DrawPanel->ForceCloseManageCurseur = Exit_Zones; DrawPanel->ForceCloseManageCurseur = Exit_Zones;
} }
// edge in progress:
else /* piste en cours : les coord du point d'arrivee ont ete mises else /* piste en cours : les coord du point d'arrivee ont ete mises
* a jour par la routine Show_Zone_Edge_While_MoveMouse*/ * a jour par la routine Show_Zone_Edge_While_MoveMouse*/
{ {
if( oldedge->m_Start != oldedge->m_End ) if( oldedge->m_Start != oldedge->m_End )
{ {
newedge = new EDGE_ZONE( oldedge ); newedge = new EDGE_ZONE( oldedge );
newedge->Pback = oldedge;
oldedge->Pnext = newedge;
newedge->m_Flags = IS_NEW | IS_MOVED; newedge->m_Flags = IS_NEW | IS_MOVED;
newedge->m_Start = newedge->m_End = oldedge->m_End; newedge->m_Start = newedge->m_End = oldedge->m_End;
newedge->SetLayer( GetScreen()->m_Active_Layer ); newedge->SetLayer( GetScreen()->m_Active_Layer );
// link into list:
newedge->Pback = oldedge;
oldedge->Pnext = newedge;
m_Pcb->m_CurrentLimitZone = newedge; m_Pcb->m_CurrentLimitZone = newedge;
} }
} }
...@@ -724,11 +729,13 @@ void WinEDA_PcbFrame::End_Zone( wxDC* DC ) ...@@ -724,11 +729,13 @@ void WinEDA_PcbFrame::End_Zone( wxDC* DC )
/* il sera raccorde au point de depart */ /* il sera raccorde au point de depart */
PtLim = m_Pcb->m_CurrentLimitZone; PtLim = m_Pcb->m_CurrentLimitZone;
PtLim->m_Flags &= ~(IS_NEW | IS_MOVED); PtLim->m_Flags &= ~(IS_NEW | IS_MOVED);
while( PtLim && PtLim->Pback ) while( PtLim && PtLim->Pback )
{ {
PtLim = (EDGE_ZONE*) PtLim->Pback; PtLim = (EDGE_ZONE*) PtLim->Pback;
if( PtLim->m_Flags & STARTPOINT ) if( PtLim->m_Flags & STARTPOINT )
break; break;
PtLim->m_Flags &= ~(IS_NEW | IS_MOVED); PtLim->m_Flags &= ~(IS_NEW | IS_MOVED);
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment